464 lines
13 KiB
C++
464 lines
13 KiB
C++
/*
|
|
* Copyright (c) by BlackMark 2015-2018
|
|
* Date 24/04/2018
|
|
* Version 2.8
|
|
*/
|
|
|
|
#ifndef INOUT_H
|
|
#define INOUT_H
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
#include <stdint.h>
|
|
|
|
#include <avr/io.h>
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
#define AVR_DIP40 defined (__AVR_ATmega32A__) || defined (__AVR_ATmega644P__) || defined (__AVR_ATmega1284P__)
|
|
#define AVR_DIP28 defined (__AVR_ATmega8__) || defined (__AVR_ATmega8A__) || defined (__AVR_ATmega168A__) || defined (__AVR_ATmega328P__)
|
|
#define AVR_DIP8 defined (__AVR_ATtiny13A__) || defined (__AVR_ATtiny85__)
|
|
|
|
#if AVR_DIP40
|
|
static constexpr volatile uint8_t *IO_PINA = &PINA;
|
|
static constexpr volatile uint8_t *IO_DDRA = &DDRA;
|
|
static constexpr volatile uint8_t *IO_PORTA = &PORTA;
|
|
#else
|
|
static constexpr volatile uint8_t *IO_PINA = nullptr;
|
|
static constexpr volatile uint8_t *IO_DDRA = nullptr;
|
|
static constexpr volatile uint8_t *IO_PORTA = nullptr;
|
|
#endif
|
|
|
|
#if AVR_DIP40 || AVR_DIP28 || AVR_DIP8
|
|
static constexpr volatile uint8_t *IO_PINB = &PINB;
|
|
static constexpr volatile uint8_t *IO_DDRB = &DDRB;
|
|
static constexpr volatile uint8_t *IO_PORTB = &PORTB;
|
|
#else
|
|
static constexpr volatile uint8_t *IO_PINB = nullptr;
|
|
static constexpr volatile uint8_t *IO_DDRB = nullptr;
|
|
static constexpr volatile uint8_t *IO_PORTB = nullptr;
|
|
#endif
|
|
|
|
#if AVR_DIP40 || AVR_DIP28
|
|
static constexpr volatile uint8_t *IO_PINC = &PINC;
|
|
static constexpr volatile uint8_t *IO_DDRC = &DDRC;
|
|
static constexpr volatile uint8_t *IO_PORTC = &PORTC;
|
|
#else
|
|
static constexpr volatile uint8_t *IO_PINC = nullptr;
|
|
static constexpr volatile uint8_t *IO_DDRC = nullptr;
|
|
static constexpr volatile uint8_t *IO_PORTC = nullptr;
|
|
#endif
|
|
|
|
#if AVR_DIP40 || AVR_DIP28
|
|
static constexpr volatile uint8_t *IO_PIND = &PIND;
|
|
static constexpr volatile uint8_t *IO_DDRD = &DDRD;
|
|
static constexpr volatile uint8_t *IO_PORTD = &PORTD;
|
|
#else
|
|
static constexpr volatile uint8_t *IO_PIND = nullptr;
|
|
static constexpr volatile uint8_t *IO_DDRD = nullptr;
|
|
static constexpr volatile uint8_t *IO_PORTD = nullptr;
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
struct InOut
|
|
{
|
|
enum class Pin
|
|
{
|
|
#if AVR_DIP40
|
|
A0 = 0x00,
|
|
A1 = 0x01,
|
|
A2 = 0x02,
|
|
A3 = 0x03,
|
|
A4 = 0x04,
|
|
A5 = 0x05,
|
|
A6 = 0x06,
|
|
A7 = 0x07,
|
|
#endif
|
|
#if AVR_DIP40 || AVR_DIP28 || AVR_DIP8
|
|
B0 = 0x10,
|
|
B1 = 0x11,
|
|
B2 = 0x12,
|
|
B3 = 0x13,
|
|
B4 = 0x14,
|
|
B5 = 0x15,
|
|
#endif
|
|
#if AVR_DIP40 || AVR_DIP28
|
|
B6 = 0x16,
|
|
B7 = 0x17,
|
|
C0 = 0x20,
|
|
C1 = 0x21,
|
|
C2 = 0x22,
|
|
C3 = 0x23,
|
|
C4 = 0x24,
|
|
C5 = 0x25,
|
|
C6 = 0x26,
|
|
#endif
|
|
#if AVR_DIP40
|
|
C7 = 0x27,
|
|
#endif
|
|
#if AVR_DIP40 || AVR_DIP28
|
|
D0 = 0x30,
|
|
D1 = 0x31,
|
|
D2 = 0x32,
|
|
D3 = 0x33,
|
|
D4 = 0x34,
|
|
D5 = 0x35,
|
|
D6 = 0x36,
|
|
D7 = 0x37,
|
|
#endif
|
|
};
|
|
|
|
enum class Port
|
|
{
|
|
#if AVR_DIP40
|
|
A = Pin::A0,
|
|
#endif
|
|
#if AVR_DIP40 || AVR_DIP28 || AVR_DIP8
|
|
B = Pin::B0,
|
|
#endif
|
|
#if AVR_DIP40 || AVR_DIP28
|
|
C = Pin::C0,
|
|
D = Pin::D0,
|
|
#endif
|
|
};
|
|
|
|
enum class Dir
|
|
{
|
|
IN,
|
|
OUT
|
|
};
|
|
|
|
enum class Type
|
|
{
|
|
PIN,
|
|
DDR,
|
|
PORT
|
|
};
|
|
|
|
static constexpr volatile uint8_t* getPort( Pin enmPin, Type enmType );
|
|
static constexpr uint8_t getPin( Pin enmPin );
|
|
|
|
static inline void setPinDirection( volatile uint8_t *vpui8Port, uint8_t ui8Pin, Dir enmDir );
|
|
static inline bool readPin( volatile uint8_t *vpui8Port, uint8_t ui8Pin );
|
|
static inline void writePin( volatile uint8_t *vpui8Port, uint8_t ui8Pin, bool bValue );
|
|
|
|
static inline void setPortDirection( volatile uint8_t *vpui8Port, Dir enmDir );
|
|
static inline uint8_t readPort( volatile uint8_t *vpui8Port );
|
|
static inline void writePort( volatile uint8_t *vpui8Port, uint8_t ui8Value );
|
|
|
|
static inline void setPinDirection( Pin enmPin, Dir enmDir );
|
|
static inline void setPinPullup( Pin enmPin, bool bPullup );
|
|
static inline bool readPin( Pin enmPin );
|
|
static inline void writePin( Pin enmPin, bool bValue );
|
|
|
|
static inline void setPortDirection( Port enmPort, Dir enmDir );
|
|
static inline void setPortPullup( Port enmPort, bool bPullup );
|
|
static inline uint8_t readPort( Port enmPort );
|
|
static inline void writePort( Port enmPort, uint8_t ui8Value );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
constexpr volatile uint8_t* InOut::getPort( Pin enmPin, Type enmType )
|
|
{
|
|
volatile uint8_t *vpui8Port = nullptr;
|
|
uint8_t ui8Port = static_cast<uint16_t>( enmPin ) >> 4 & 0x0F;
|
|
|
|
switch( ui8Port )
|
|
{
|
|
case 0:
|
|
{
|
|
if( enmType == Type::PIN )
|
|
vpui8Port = IO_PINA;
|
|
else if( enmType == Type::DDR )
|
|
vpui8Port = IO_DDRA;
|
|
else if( enmType == Type::PORT )
|
|
vpui8Port = IO_PORTA;
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
if( enmType == Type::PIN )
|
|
vpui8Port = IO_PINB;
|
|
else if( enmType == Type::DDR )
|
|
vpui8Port = IO_DDRB;
|
|
else if( enmType == Type::PORT )
|
|
vpui8Port = IO_PORTB;
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
if( enmType == Type::PIN )
|
|
vpui8Port = IO_PINC;
|
|
else if( enmType == Type::DDR )
|
|
vpui8Port = IO_DDRC;
|
|
else if( enmType == Type::PORT )
|
|
vpui8Port = IO_PORTC;
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
if( enmType == Type::PIN )
|
|
vpui8Port = IO_PIND;
|
|
else if( enmType == Type::DDR )
|
|
vpui8Port = IO_DDRD;
|
|
else if( enmType == Type::PORT )
|
|
vpui8Port = IO_PORTD;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return vpui8Port;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
constexpr uint8_t InOut::getPin( Pin enmPin )
|
|
{
|
|
return static_cast<uint16_t>( enmPin ) & 0x0F;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPinDirection( volatile uint8_t *vpui8Port, uint8_t ui8Pin, Dir enmDir )
|
|
{
|
|
if( enmDir == Dir::OUT )
|
|
*vpui8Port |= ( 1 << ui8Pin );
|
|
else
|
|
*vpui8Port &= ~( 1 << ui8Pin );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline bool InOut::readPin( volatile uint8_t *vpui8Port, uint8_t ui8Pin )
|
|
{
|
|
if( *vpui8Port >> ui8Pin & 1 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::writePin( volatile uint8_t *vpui8Port, uint8_t ui8Pin, bool bValue )
|
|
{
|
|
if( bValue )
|
|
*vpui8Port |= ( 1 << ui8Pin );
|
|
else
|
|
*vpui8Port &= ~( 1 << ui8Pin );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPortDirection( volatile uint8_t *vpui8Port, Dir enmDir )
|
|
{
|
|
*vpui8Port = ( enmDir == Dir::OUT ) ? 0xFF : 0x00;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline uint8_t InOut::readPort( volatile uint8_t *vpui8Port )
|
|
{
|
|
return *vpui8Port;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::writePort( volatile uint8_t *vpui8Port, uint8_t ui8Value )
|
|
{
|
|
*vpui8Port = ui8Value;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPinDirection( Pin enmPin, Dir enmDir )
|
|
{
|
|
volatile uint8_t *vpui8PortDir = getPort( enmPin, Type::DDR );
|
|
uint8_t ui8Pin = getPin( enmPin );
|
|
setPinDirection( vpui8PortDir, ui8Pin, enmDir );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPinPullup( Pin enmPin, bool bPullup )
|
|
{
|
|
volatile uint8_t *vpui8PortOut = getPort( enmPin, Type::PORT );
|
|
uint8_t ui8Pin = getPin( enmPin );
|
|
writePin( vpui8PortOut, ui8Pin, bPullup );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline bool InOut::readPin( Pin enmPin )
|
|
{
|
|
volatile uint8_t *vpui8Port = getPort( enmPin, Type::PIN );
|
|
uint8_t ui8Pin = getPin( enmPin );
|
|
return readPin( vpui8Port, ui8Pin );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::writePin( Pin enmPin, bool bValue )
|
|
{
|
|
volatile uint8_t *vpui8Port = getPort( enmPin, Type::PORT );
|
|
uint8_t ui8Pin = getPin( enmPin );
|
|
writePin( vpui8Port, ui8Pin, bValue );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPortDirection( Port enmPort, Dir enmDir )
|
|
{
|
|
volatile uint8_t *vpui8PortDir = getPort( static_cast<Pin>( enmPort ), Type::DDR );
|
|
setPortDirection( vpui8PortDir, enmDir );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::setPortPullup( Port enmPort, bool bPullup )
|
|
{
|
|
volatile uint8_t *vpui8PortOut = getPort( static_cast<Pin>( enmPort ), Type::PORT );
|
|
writePort( vpui8PortOut, bPullup ? 0xFF : 0x00 );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline uint8_t InOut::readPort( Port enmPort )
|
|
{
|
|
volatile uint8_t *vpui8Port = getPort( static_cast<Pin>( enmPort ), Type::PIN );
|
|
return readPort( vpui8Port );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOut::writePort( Port enmPort, uint8_t ui8Value )
|
|
{
|
|
volatile uint8_t *vpui8Port = getPort( static_cast<Pin>( enmPort ), Type::PORT );
|
|
writePort( vpui8Port, ui8Value );
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
class InOutPin
|
|
{
|
|
private:
|
|
volatile uint8_t *m_pvui8PIN;
|
|
volatile uint8_t *m_pvui8DDR;
|
|
volatile uint8_t *m_pvui8PORT;
|
|
uint8_t m_ui8Pin;
|
|
|
|
public:
|
|
inline InOutPin();
|
|
inline InOutPin( InOut::Pin enmPin );
|
|
|
|
inline void setPin( InOut::Pin enmPin );
|
|
|
|
inline void setDirection( InOut::Dir enmDir );
|
|
inline void setPullup( bool bPullup );
|
|
|
|
inline bool read();
|
|
inline void write( bool bValue );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline InOutPin::InOutPin() :
|
|
m_pvui8PIN( nullptr ), m_pvui8DDR( nullptr ), m_pvui8PORT( nullptr ), m_ui8Pin( 0xFF )
|
|
{}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline InOutPin::InOutPin( InOut::Pin enmPin ) :
|
|
m_pvui8PIN( InOut::getPort( enmPin, InOut::Type::PIN ) ),
|
|
m_pvui8DDR( InOut::getPort( enmPin, InOut::Type::DDR ) ),
|
|
m_pvui8PORT( InOut::getPort( enmPin, InOut::Type::PORT ) ),
|
|
m_ui8Pin( InOut::getPin( enmPin ) )
|
|
{}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPin::setPin( InOut::Pin enmPin )
|
|
{
|
|
m_pvui8PIN = InOut::getPort( enmPin, InOut::Type::PIN );
|
|
m_pvui8DDR = InOut::getPort( enmPin, InOut::Type::DDR );
|
|
m_pvui8PORT = InOut::getPort( enmPin, InOut::Type::PORT );
|
|
m_ui8Pin = InOut::getPin( enmPin );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPin::setDirection( InOut::Dir enmDir )
|
|
{
|
|
InOut::setPinDirection( m_pvui8DDR, m_ui8Pin, enmDir );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPin::setPullup( bool bPullup )
|
|
{
|
|
InOut::writePin( m_pvui8PORT, m_ui8Pin, bPullup );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline bool InOutPin::read()
|
|
{
|
|
return InOut::readPin( m_pvui8PIN, m_ui8Pin );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPin::write( bool bValue )
|
|
{
|
|
InOut::writePin( m_pvui8PORT, m_ui8Pin, bValue );
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
class InOutPort
|
|
{
|
|
private:
|
|
volatile uint8_t *m_pvui8PIN;
|
|
volatile uint8_t *m_pvui8DDR;
|
|
volatile uint8_t *m_pvui8PORT;
|
|
|
|
public:
|
|
inline InOutPort();
|
|
inline InOutPort( InOut::Port enmPort );
|
|
|
|
inline void setPort( InOut::Port enmPort );
|
|
|
|
inline void setDirection( InOut::Dir enmDir );
|
|
inline void setPullup( bool bPullup );
|
|
|
|
inline uint8_t read();
|
|
inline void write( uint8_t ui8Value );
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline InOutPort::InOutPort() :
|
|
m_pvui8PIN( nullptr ), m_pvui8DDR( nullptr ), m_pvui8PORT( nullptr )
|
|
{}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline InOutPort::InOutPort( InOut::Port enmPort ) :
|
|
m_pvui8PIN( InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::PIN ) ),
|
|
m_pvui8DDR( InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::DDR ) ),
|
|
m_pvui8PORT( InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::PORT ) )
|
|
{}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPort::setPort( InOut::Port enmPort )
|
|
{
|
|
m_pvui8PIN = InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::PIN );
|
|
m_pvui8DDR = InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::DDR );
|
|
m_pvui8PORT = InOut::getPort( static_cast<InOut::Pin>( enmPort ), InOut::Type::PORT );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPort::setDirection( InOut::Dir enmDir )
|
|
{
|
|
InOut::setPortDirection( m_pvui8DDR, enmDir );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPort::setPullup( bool bPullup )
|
|
{
|
|
InOut::writePort( m_pvui8PORT, bPullup ? 0xFF : 0x00 );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline uint8_t InOutPort::read()
|
|
{
|
|
return InOut::readPort( m_pvui8PIN );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
inline void InOutPort::write( uint8_t ui8Value )
|
|
{
|
|
InOut::writePort( m_pvui8PORT, ui8Value );
|
|
}
|
|
|
|
#endif |