Rewrote inout library to allow compile time port lookup and inline optimization
This commit is contained in:
parent
b4fca1e7ce
commit
093c0a6a02
225
inout.cpp
225
inout.cpp
@ -1,225 +0,0 @@
|
||||
#include "inout.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
volatile uint8_t* InOut::getPort( Pin enmPin, Type enmType )
|
||||
{
|
||||
volatile uint8_t *vpui8Port = nullptr;
|
||||
|
||||
if( enmPin == Pin::P_NONE )
|
||||
{
|
||||
return vpui8Port;
|
||||
}
|
||||
|
||||
uint8_t ui8Port = ( static_cast<uint16_t>( enmPin ) >> 4 ) & 0x0F;
|
||||
|
||||
switch( ui8Port )
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
if( enmType == Type::T_PIN )
|
||||
{
|
||||
vpui8Port = PORT_PINA;
|
||||
}
|
||||
else if( enmType == Type::T_DDR )
|
||||
{
|
||||
vpui8Port = PORT_DDRA;
|
||||
}
|
||||
else if( enmType == Type::T_PORT )
|
||||
{
|
||||
vpui8Port = PORT_PORTA;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 1:
|
||||
{
|
||||
if( enmType == Type::T_PIN )
|
||||
{
|
||||
vpui8Port = PORT_PINB;
|
||||
}
|
||||
else if( enmType == Type::T_DDR )
|
||||
{
|
||||
vpui8Port = PORT_DDRB;
|
||||
}
|
||||
else if( enmType == Type::T_PORT )
|
||||
{
|
||||
vpui8Port = PORT_PORTB;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 2:
|
||||
{
|
||||
if( enmType == Type::T_PIN )
|
||||
{
|
||||
vpui8Port = PORT_PINC;
|
||||
}
|
||||
else if( enmType == Type::T_DDR )
|
||||
{
|
||||
vpui8Port = PORT_DDRC;
|
||||
}
|
||||
else if( enmType == Type::T_PORT )
|
||||
{
|
||||
vpui8Port = PORT_PORTC;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case 3:
|
||||
{
|
||||
if( enmType == Type::T_PIN )
|
||||
{
|
||||
vpui8Port = PORT_PIND;
|
||||
}
|
||||
else if( enmType == Type::T_DDR )
|
||||
{
|
||||
vpui8Port = PORT_DDRD;
|
||||
}
|
||||
else if( enmType == Type::T_PORT )
|
||||
{
|
||||
vpui8Port = PORT_PORTD;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return vpui8Port;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
uint8_t InOut::getPin( Pin enmPin )
|
||||
{
|
||||
return static_cast<uint16_t>( enmPin ) & 0x0F;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void InOut::setPinDirection( Pin enmPin, Dir enmDir, bool bPullup )
|
||||
{
|
||||
if( enmPin == Pin::P_NONE )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
volatile uint8_t *vpui8PortDir = getPort( enmPin, Type::T_DDR );
|
||||
volatile uint8_t *vpui8PortOut = getPort( enmPin, Type::T_PORT );
|
||||
uint8_t ui8Pin = getPin( enmPin );
|
||||
|
||||
setPinDirection( vpui8PortDir, ui8Pin, enmDir );
|
||||
|
||||
if( enmDir == Dir::D_IN )
|
||||
{
|
||||
writePin( vpui8PortOut, ui8Pin, bPullup );
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
bool InOut::readPin( Pin enmPin )
|
||||
{
|
||||
if( enmPin == Pin::P_NONE )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
volatile uint8_t *vpui8Port = getPort( enmPin, Type::T_PIN );
|
||||
uint8_t ui8Pin = getPin( enmPin );
|
||||
|
||||
return readPin( vpui8Port, ui8Pin );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void InOut::writePin( Pin enmPin, bool bValue )
|
||||
{
|
||||
if( enmPin == Pin::P_NONE )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
volatile uint8_t *vpui8Port = getPort( enmPin, Type::T_PORT );
|
||||
uint8_t ui8Pin = getPin( enmPin );
|
||||
|
||||
writePin( vpui8Port, ui8Pin, bValue );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
uint8_t InOut::readPort( Pin enmPortPin )
|
||||
{
|
||||
if( enmPortPin == Pin::P_NONE )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
volatile uint8_t *vpui8Port = getPort( enmPortPin, Type::T_PIN );
|
||||
|
||||
return readPort( vpui8Port );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void InOut::writePort( Pin enmPortPin, uint8_t ui8Value )
|
||||
{
|
||||
if( enmPortPin == Pin::P_NONE )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
volatile uint8_t *vpui8Port = getPort( enmPortPin, Type::T_PORT );
|
||||
|
||||
writePort( vpui8Port, ui8Value );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPin::InOutPin()
|
||||
{
|
||||
setPin( InOut::Pin::P_NONE );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPin::InOutPin( InOut::Pin enmPin )
|
||||
{
|
||||
setPin( enmPin );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPin::~InOutPin()
|
||||
{
|
||||
setDirection( InOut::Dir::D_IN, false );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void InOutPin::setPin( InOut::Pin enmPin )
|
||||
{
|
||||
m_vpui8Input = InOut::getPort( enmPin, InOut::Type::T_PIN );
|
||||
m_vpui8Dir = InOut::getPort( enmPin, InOut::Type::T_DDR );
|
||||
m_vpui8Output = InOut::getPort( enmPin, InOut::Type::T_PORT );
|
||||
|
||||
m_ui8Pin = InOut::getPin( enmPin );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPort::InOutPort()
|
||||
{
|
||||
setPort( InOut::Pin::P_NONE );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPort::InOutPort( InOut::Pin enmPin )
|
||||
{
|
||||
setPort( enmPin );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
InOutPort::~InOutPort()
|
||||
{
|
||||
setDirection( InOut::Dir::D_IN, false );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
void InOutPort::setPort( InOut::Pin enmPortPin )
|
||||
{
|
||||
m_vpui8Input = InOut::getPort( enmPortPin, InOut::Type::T_PIN );
|
||||
m_vpui8Dir = InOut::getPort( enmPortPin, InOut::Type::T_DDR );
|
||||
m_vpui8Output = InOut::getPort( enmPortPin, InOut::Type::T_PORT );
|
||||
}
|
||||
594
inout.h
594
inout.h
@ -1,298 +1,464 @@
|
||||
/*
|
||||
* Copyright (c) by BlackMark 2015-2017
|
||||
* Date 17/04/2017
|
||||
* Version 2.7
|
||||
* 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
|
||||
#define PORT_PINA &PINA
|
||||
#define PORT_DDRA &DDRA
|
||||
#define PORT_PORTA &PORTA
|
||||
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
|
||||
#define PORT_PINA nullptr
|
||||
#define PORT_DDRA nullptr
|
||||
#define PORT_PORTA nullptr
|
||||
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
|
||||
#define PORT_PINB &PINB
|
||||
#define PORT_DDRB &DDRB
|
||||
#define PORT_PORTB &PORTB
|
||||
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
|
||||
#define PORT_PINB nullptr
|
||||
#define PORT_DDRB nullptr
|
||||
#define PORT_PORTB nullptr
|
||||
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
|
||||
#define PORT_PINC &PINC
|
||||
#define PORT_DDRC &DDRC
|
||||
#define PORT_PORTC &PORTC
|
||||
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
|
||||
#define PORT_PINC nullptr
|
||||
#define PORT_DDRC nullptr
|
||||
#define PORT_PORTC nullptr
|
||||
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
|
||||
#define PORT_PIND &PIND
|
||||
#define PORT_DDRD &DDRD
|
||||
#define PORT_PORTD &PORTD
|
||||
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
|
||||
#define PORT_PIND nullptr
|
||||
#define PORT_DDRD nullptr
|
||||
#define PORT_PORTD nullptr
|
||||
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
|
||||
|
||||
class InOut
|
||||
/************************************************************************/
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
struct InOut
|
||||
{
|
||||
public:
|
||||
enum class Pin
|
||||
{
|
||||
P_NONE = -1,
|
||||
#if AVR_DIP40
|
||||
P_A0 = 0x00,
|
||||
P_A1 = 0x01,
|
||||
P_A2 = 0x02,
|
||||
P_A3 = 0x03,
|
||||
P_A4 = 0x04,
|
||||
P_A5 = 0x05,
|
||||
P_A6 = 0x06,
|
||||
P_A7 = 0x07,
|
||||
A0 = 0x00,
|
||||
A1 = 0x01,
|
||||
A2 = 0x02,
|
||||
A3 = 0x03,
|
||||
A4 = 0x04,
|
||||
A5 = 0x05,
|
||||
A6 = 0x06,
|
||||
A7 = 0x07,
|
||||
#endif
|
||||
#if AVR_DIP40 || AVR_DIP28 || AVR_DIP8
|
||||
P_B0 = 0x10,
|
||||
P_B1 = 0x11,
|
||||
P_B2 = 0x12,
|
||||
P_B3 = 0x13,
|
||||
P_B4 = 0x14,
|
||||
P_B5 = 0x15,
|
||||
B0 = 0x10,
|
||||
B1 = 0x11,
|
||||
B2 = 0x12,
|
||||
B3 = 0x13,
|
||||
B4 = 0x14,
|
||||
B5 = 0x15,
|
||||
#endif
|
||||
#if AVR_DIP40 || AVR_DIP28
|
||||
P_B6 = 0x16,
|
||||
P_B7 = 0x17,
|
||||
P_C0 = 0x20,
|
||||
P_C1 = 0x21,
|
||||
P_C2 = 0x22,
|
||||
P_C3 = 0x23,
|
||||
P_C4 = 0x24,
|
||||
P_C5 = 0x25,
|
||||
P_C6 = 0x26,
|
||||
B6 = 0x16,
|
||||
B7 = 0x17,
|
||||
C0 = 0x20,
|
||||
C1 = 0x21,
|
||||
C2 = 0x22,
|
||||
C3 = 0x23,
|
||||
C4 = 0x24,
|
||||
C5 = 0x25,
|
||||
C6 = 0x26,
|
||||
#endif
|
||||
#if AVR_DIP40
|
||||
P_C7 = 0x27,
|
||||
C7 = 0x27,
|
||||
#endif
|
||||
#if AVR_DIP40 || AVR_DIP28
|
||||
P_D0 = 0x30,
|
||||
P_D1 = 0x31,
|
||||
P_D2 = 0x32,
|
||||
P_D3 = 0x33,
|
||||
P_D4 = 0x34,
|
||||
P_D5 = 0x35,
|
||||
P_D6 = 0x36,
|
||||
P_D7 = 0x37,
|
||||
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
|
||||
{
|
||||
D_IN = 0,
|
||||
D_OUT = 1
|
||||
IN,
|
||||
OUT
|
||||
};
|
||||
|
||||
enum class Type
|
||||
{
|
||||
T_PIN = 0,
|
||||
T_DDR = 1,
|
||||
T_PORT = 2
|
||||
PIN,
|
||||
DDR,
|
||||
PORT
|
||||
};
|
||||
|
||||
static volatile uint8_t* getPort( Pin enmPin, Type enmType );
|
||||
static uint8_t getPin( Pin enmPin );
|
||||
static constexpr volatile uint8_t* getPort( Pin enmPin, Type enmType );
|
||||
static constexpr uint8_t getPin( Pin enmPin );
|
||||
|
||||
static void setPinDirection( Pin enmPin, Dir enmDir, bool bPullup );
|
||||
static bool readPin( Pin enmPin );
|
||||
static void writePin( Pin enmPin, bool bValue );
|
||||
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 uint8_t readPort( Pin enmPortPin );
|
||||
static void writePort( Pin enmPortPin, uint8_t ui8Value );
|
||||
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( volatile uint8_t *vpui8Port, uint8_t ui8Pin, Dir enmDir )
|
||||
{
|
||||
if( enmDir == Dir::D_OUT )
|
||||
{
|
||||
*vpui8Port |= ( 1 << ui8Pin );
|
||||
}
|
||||
else
|
||||
{
|
||||
*vpui8Port &= ~( 1 << ui8Pin );
|
||||
}
|
||||
}
|
||||
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 bool readPin( volatile uint8_t *vpui8Port, uint8_t ui8Pin )
|
||||
{
|
||||
if( ( ( *vpui8Port ) >> ui8Pin ) & 1 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
static inline void writePin( volatile uint8_t *vpui8Port, uint8_t ui8Pin, bool bValue )
|
||||
{
|
||||
if( bValue )
|
||||
{
|
||||
*vpui8Port |= ( 1 << ui8Pin );
|
||||
}
|
||||
else
|
||||
{
|
||||
*vpui8Port &= ~( 1 << ui8Pin );
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
static inline void setPortDirection( volatile uint8_t *vpui8Port, Dir enmDir )
|
||||
{
|
||||
*vpui8Port = ( ( enmDir == InOut::Dir::D_OUT ) ? ( 0xFF ) : ( 0x00 ) );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
static inline uint8_t readPort( volatile uint8_t *vpui8Port )
|
||||
{
|
||||
return *vpui8Port;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
static inline void writePort( volatile uint8_t *vpui8Port, uint8_t ui8Value )
|
||||
{
|
||||
*vpui8Port = ui8Value;
|
||||
}
|
||||
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_vpui8Input;
|
||||
volatile uint8_t *m_vpui8Dir;
|
||||
volatile uint8_t *m_vpui8Output;
|
||||
|
||||
volatile uint8_t *m_pvui8PIN;
|
||||
volatile uint8_t *m_pvui8DDR;
|
||||
volatile uint8_t *m_pvui8PORT;
|
||||
uint8_t m_ui8Pin;
|
||||
|
||||
public:
|
||||
InOutPin();
|
||||
InOutPin( InOut::Pin enmPin );
|
||||
~InOutPin();
|
||||
inline InOutPin();
|
||||
inline InOutPin( InOut::Pin enmPin );
|
||||
|
||||
void setPin( InOut::Pin enmPin );
|
||||
inline void setPin( InOut::Pin enmPin );
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline void setDirection( InOut::Dir enmDir, bool bPullup )
|
||||
{
|
||||
if( !m_vpui8Dir || !m_vpui8Output )
|
||||
{
|
||||
return;
|
||||
}
|
||||
inline void setDirection( InOut::Dir enmDir );
|
||||
inline void setPullup( bool bPullup );
|
||||
|
||||
InOut::setPinDirection( m_vpui8Dir, m_ui8Pin, enmDir );
|
||||
|
||||
if( enmDir == InOut::Dir::D_IN )
|
||||
{
|
||||
InOut::writePin( m_vpui8Output, m_ui8Pin, bPullup );
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline bool read()
|
||||
{
|
||||
if( !m_vpui8Input )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return InOut::readPin( m_vpui8Input, m_ui8Pin );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline void write( bool bValue )
|
||||
{
|
||||
if( !m_vpui8Output )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
InOut::writePin( m_vpui8Output, m_ui8Pin, bValue );
|
||||
}
|
||||
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_vpui8Input;
|
||||
volatile uint8_t *m_vpui8Dir;
|
||||
volatile uint8_t *m_vpui8Output;
|
||||
volatile uint8_t *m_pvui8PIN;
|
||||
volatile uint8_t *m_pvui8DDR;
|
||||
volatile uint8_t *m_pvui8PORT;
|
||||
|
||||
public:
|
||||
InOutPort();
|
||||
InOutPort( InOut::Pin enmPortPin );
|
||||
~InOutPort();
|
||||
inline InOutPort();
|
||||
inline InOutPort( InOut::Port enmPort );
|
||||
|
||||
void setPort( InOut::Pin enmPortPin );
|
||||
inline void setPort( InOut::Port enmPort );
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline void setDirection( InOut::Dir enmDir, bool bPullup )
|
||||
{
|
||||
if( !m_vpui8Dir || !m_vpui8Output )
|
||||
{
|
||||
return;
|
||||
}
|
||||
inline void setDirection( InOut::Dir enmDir );
|
||||
inline void setPullup( bool bPullup );
|
||||
|
||||
InOut::setPortDirection( m_vpui8Dir, enmDir );
|
||||
|
||||
if( enmDir == InOut::Dir::D_IN )
|
||||
{
|
||||
InOut::writePort( m_vpui8Output, ( ( bPullup ) ? ( 0xFF ) : ( 0x00 ) ) );
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline uint8_t read()
|
||||
{
|
||||
if( !m_vpui8Input )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
return InOut::readPort( m_vpui8Input );
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
inline void write( uint8_t ui8Value )
|
||||
{
|
||||
if( !m_vpui8Output )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
InOut::writePort( m_vpui8Output, ui8Value );
|
||||
}
|
||||
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
|
||||
Loading…
Reference in New Issue
Block a user