554 lines
13 KiB
C++
554 lines
13 KiB
C++
#pragma once
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <avr/io.h>
|
|
#include <avr/sfr_defs.h>
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Preprocessor defines
|
|
|
|
#if defined(__AVR_ATmega32__) || defined(__AVR_ATmega32A__) || defined(__AVR_ATmega644P__) || \
|
|
defined(__AVR_ATmega1284P__)
|
|
#define GPIO_32
|
|
#endif
|
|
|
|
#if defined(__AVR_ATmega8__) || defined(__AVR_ATmega8A__) || defined(__AVR_ATmega168A__) || defined(__AVR_ATmega328P__)
|
|
#define GPIO_23
|
|
#endif
|
|
|
|
#if defined(__AVR_ATtiny13A__) || defined(__AVR_ATtiny85__)
|
|
#define GPIO_6
|
|
#endif
|
|
|
|
#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega168A__) || \
|
|
defined(__AVR_ATmega328P__) || defined(__AVR_ATtiny13A__) || defined(__AVR_ATtiny85__)
|
|
#define HARDWARE_TOGGLE
|
|
#endif
|
|
|
|
#ifdef GPIO_32
|
|
#define PORT_A_AVAILABLE
|
|
#endif
|
|
|
|
#if defined(GPIO_32) || defined(GPIO_23) || defined(GPIO_6)
|
|
#define PORT_B_AVAILABLE
|
|
#endif
|
|
|
|
#if defined(GPIO_32) || defined(GPIO_23)
|
|
#define PORT_C_AVAILABLE
|
|
#define PORT_D_AVAILABLE
|
|
#define PIN_B6_AVAILABLE
|
|
#define PIN_B7_AVAILABLE
|
|
#endif
|
|
|
|
#if defined(GPIO_32)
|
|
#define PIN_C7_AVAILABLE
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Library implementation
|
|
|
|
namespace io {
|
|
|
|
enum class Dir { IN, OUT };
|
|
|
|
enum class P {
|
|
#ifdef PORT_A_AVAILABLE
|
|
A0 = 0x00,
|
|
A1 = 0x01,
|
|
A2 = 0x02,
|
|
A3 = 0x03,
|
|
A4 = 0x04,
|
|
A5 = 0x05,
|
|
A6 = 0x06,
|
|
A7 = 0x07,
|
|
#endif
|
|
|
|
#ifdef PORT_B_AVAILABLE
|
|
B0 = 0x10,
|
|
B1 = 0x11,
|
|
B2 = 0x12,
|
|
B3 = 0x13,
|
|
B4 = 0x14,
|
|
B5 = 0x15,
|
|
#ifdef PIN_B6_AVAILABLE
|
|
B6 = 0x16,
|
|
#endif
|
|
#ifdef PIN_B7_AVAILABLE
|
|
B7 = 0x17,
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef PORT_C_AVAILABLE
|
|
C0 = 0x20,
|
|
C1 = 0x21,
|
|
C2 = 0x22,
|
|
C3 = 0x23,
|
|
C4 = 0x24,
|
|
C5 = 0x25,
|
|
C6 = 0x26,
|
|
#ifdef PIN_C7_AVAILABLE
|
|
C7 = 0x27,
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef PORT_D_AVAILABLE
|
|
D0 = 0x30,
|
|
D1 = 0x31,
|
|
D2 = 0x32,
|
|
D3 = 0x33,
|
|
D4 = 0x34,
|
|
D5 = 0x35,
|
|
D6 = 0x36,
|
|
D7 = 0x37,
|
|
#endif
|
|
};
|
|
|
|
enum class Bus {
|
|
#ifdef PORT_A_AVAILABLE
|
|
A = 0x00,
|
|
#endif
|
|
#ifdef PORT_B_AVAILABLE
|
|
B = 0x01,
|
|
#endif
|
|
#ifdef PORT_C_AVAILABLE
|
|
C = 0x02,
|
|
#endif
|
|
#ifdef PORT_D_AVAILABLE
|
|
D = 0x03,
|
|
#endif
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Implementation details
|
|
|
|
namespace detail {
|
|
|
|
/*
|
|
The following works in avr-gcc 5.4.0, but is not legal C++, because ptr's are not legal constexpr's:
|
|
constexpr auto *foo = ptr;
|
|
|
|
Workaround is to store the address of the ptr in a uintptr_t and reinterpret_cast it at call site.
|
|
The _SFR_ADDR macro in sfr_defs.h would give the address, but it does that by taking the address of the dereferenced
|
|
pointer and casts it to uint16_t, which is still not a legal constexpr.
|
|
The workaround therefore is to disable the pointer-cast-and-dereference macro _MMIO_BYTE temporarily.
|
|
*/
|
|
|
|
#pragma push_macro("_MMIO_BYTE")
|
|
#undef _MMIO_BYTE
|
|
#define _MMIO_BYTE
|
|
|
|
#ifdef PORT_A_AVAILABLE
|
|
static constexpr uintptr_t PORT_A_DIR_REG_ADDR = DDRA;
|
|
static constexpr uintptr_t PORT_A_OUTPUT_REG_ADDR = PORTA;
|
|
static constexpr uintptr_t PORT_A_INPUT_REG_ADDR = PINA;
|
|
#else
|
|
static constexpr uintptr_t PORT_A_DIR_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_A_OUTPUT_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_A_INPUT_REG_ADDR = 0;
|
|
#endif
|
|
|
|
#ifdef PORT_B_AVAILABLE
|
|
|
|
static constexpr uintptr_t PORT_B_DIR_REG_ADDR = DDRB;
|
|
static constexpr uintptr_t PORT_B_OUTPUT_REG_ADDR = PORTB;
|
|
static constexpr uintptr_t PORT_B_INPUT_REG_ADDR = PINB;
|
|
#else
|
|
static constexpr uintptr_t PORT_B_DIR_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_B_OUTPUT_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_B_INPUT_REG_ADDR = 0;
|
|
#endif
|
|
|
|
#ifdef PORT_C_AVAILABLE
|
|
static constexpr uintptr_t PORT_C_DIR_REG_ADDR = DDRC;
|
|
static constexpr uintptr_t PORT_C_OUTPUT_REG_ADDR = PORTC;
|
|
static constexpr uintptr_t PORT_C_INPUT_REG_ADDR = PINC;
|
|
#else
|
|
static constexpr uintptr_t PORT_C_DIR_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_C_OUTPUT_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_C_INPUT_REG_ADDR = 0;
|
|
#endif
|
|
|
|
#ifdef PORT_D_AVAILABLE
|
|
static constexpr uintptr_t PORT_D_DIR_REG_ADDR = DDRD;
|
|
static constexpr uintptr_t PORT_D_OUTPUT_REG_ADDR = PORTD;
|
|
static constexpr uintptr_t PORT_D_INPUT_REG_ADDR = PIND;
|
|
#else
|
|
static constexpr uintptr_t PORT_D_DIR_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_D_OUTPUT_REG_ADDR = 0;
|
|
static constexpr uintptr_t PORT_D_INPUT_REG_ADDR = 0;
|
|
#endif
|
|
|
|
#pragma pop_macro("_MMIO_BYTE")
|
|
|
|
static constexpr auto getBus(const P pin)
|
|
{
|
|
// Upper 4 bits of pin encode which port this pin is on
|
|
uint8_t port = static_cast<uint8_t>(pin) >> 4 & 0x0F;
|
|
return static_cast<Bus>(port);
|
|
}
|
|
|
|
static constexpr auto getPinBit(const P pin)
|
|
{
|
|
// Lower 4 bits of pin encode which pin bit it is
|
|
uint8_t pinBit = static_cast<uint8_t>(pin) & 0x0F;
|
|
return pinBit;
|
|
}
|
|
|
|
static constexpr auto getDDR(const Bus bus)
|
|
{
|
|
switch (static_cast<uint8_t>(bus)) {
|
|
case 0: // Bus::A
|
|
return PORT_A_DIR_REG_ADDR;
|
|
case 1: // Bus::B
|
|
return PORT_B_DIR_REG_ADDR;
|
|
case 2: // Bus::C
|
|
return PORT_C_DIR_REG_ADDR;
|
|
case 3: // Bus::D
|
|
return PORT_D_DIR_REG_ADDR;
|
|
}
|
|
}
|
|
|
|
static constexpr auto getPORT(const Bus bus)
|
|
{
|
|
switch (static_cast<uint8_t>(bus)) {
|
|
case 0: // Bus::A
|
|
return PORT_A_OUTPUT_REG_ADDR;
|
|
case 1: // Bus::B
|
|
return PORT_B_OUTPUT_REG_ADDR;
|
|
case 2: // Bus::C
|
|
return PORT_C_OUTPUT_REG_ADDR;
|
|
case 3: // Bus::D
|
|
return PORT_D_OUTPUT_REG_ADDR;
|
|
}
|
|
}
|
|
|
|
static constexpr auto getPIN(const Bus bus)
|
|
{
|
|
switch (static_cast<uint8_t>(bus)) {
|
|
case 0: // Bus::A
|
|
return PORT_A_INPUT_REG_ADDR;
|
|
case 1: // Bus::B
|
|
return PORT_B_INPUT_REG_ADDR;
|
|
case 2: // Bus::C
|
|
return PORT_C_INPUT_REG_ADDR;
|
|
case 3: // Bus::D
|
|
return PORT_D_INPUT_REG_ADDR;
|
|
}
|
|
}
|
|
|
|
using reg_ptr_t = volatile uint8_t *;
|
|
|
|
template <uintptr_t Address>
|
|
static inline reg_ptr_t getRegPtr()
|
|
{
|
|
return reinterpret_cast<reg_ptr_t>(Address);
|
|
}
|
|
|
|
template <template <P, uint8_t> typename Func, P pin, P... pins>
|
|
struct CallHelper {
|
|
template <typename... Args>
|
|
[[gnu::always_inline]] static inline void call(Args... args)
|
|
{
|
|
Func<pin, sizeof...(pins)>::call(args...);
|
|
CallHelper<Func, pins...>::call(args...);
|
|
}
|
|
};
|
|
|
|
template <template <P, uint8_t> typename Func, P pin>
|
|
struct CallHelper<Func, pin> {
|
|
template <typename... Args>
|
|
[[gnu::always_inline]] static inline void call(Args... args)
|
|
{
|
|
Func<pin, 0>::call(args...);
|
|
}
|
|
};
|
|
|
|
template <template <P> typename Func, P pin, P... pins>
|
|
struct ReadCallHelper {
|
|
[[gnu::always_inline]] static inline uint8_t call()
|
|
{
|
|
return Func<pin>::call() << sizeof...(pins) | ReadCallHelper<Func, pins...>::call();
|
|
}
|
|
};
|
|
|
|
template <template <P> typename Func, P pin>
|
|
struct ReadCallHelper<Func, pin> {
|
|
[[gnu::always_inline]] static inline uint8_t call()
|
|
{
|
|
return Func<pin>::call();
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Zero overhead Pin object for pretty code without losing performance
|
|
|
|
template <P pin>
|
|
class Pin {
|
|
public:
|
|
// Pin objects cannot be moved or copied
|
|
Pin(const Pin &) = delete;
|
|
Pin(Pin &&) = delete;
|
|
Pin &operator=(const Pin &) = delete;
|
|
Pin &operator=(Pin &&) = delete;
|
|
|
|
// The only valid way to create a Pin object is with the default constructor
|
|
Pin() = default;
|
|
|
|
[[gnu::always_inline]] static inline void dir(const Dir dir)
|
|
{
|
|
constexpr auto bus = detail::getBus(pin);
|
|
constexpr auto pinBit = detail::getPinBit(pin);
|
|
|
|
detail::reg_ptr_t dirRegPtr = detail::getRegPtr<detail::getDDR(bus)>();
|
|
|
|
if (dir == Dir::IN)
|
|
*dirRegPtr &= ~(1 << pinBit);
|
|
else if (dir == Dir::OUT)
|
|
*dirRegPtr |= (1 << pinBit);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void pullup(const bool enable)
|
|
{
|
|
constexpr auto bus = detail::getBus(pin);
|
|
constexpr auto pinBit = detail::getPinBit(pin);
|
|
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(bus)>();
|
|
|
|
if (enable)
|
|
*portRegPtr |= (1 << pinBit);
|
|
else
|
|
*portRegPtr &= ~(1 << pinBit);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void write(const bool value)
|
|
{
|
|
constexpr auto bus = detail::getBus(pin);
|
|
constexpr auto pinBit = detail::getPinBit(pin);
|
|
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(bus)>();
|
|
|
|
if (value)
|
|
*portRegPtr |= (1 << pinBit);
|
|
else
|
|
*portRegPtr &= ~(1 << pinBit);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void toggle()
|
|
{
|
|
constexpr auto bus = detail::getBus(pin);
|
|
constexpr auto pinBit = detail::getPinBit(pin);
|
|
|
|
#ifdef HARDWARE_TOGGLE
|
|
detail::reg_ptr_t pinRegPtr = detail::getRegPtr<detail::getPIN(bus)>();
|
|
*pinRegPtr |= (1 << pinBit);
|
|
#else
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(bus)>();
|
|
*portRegPtr ^= (1 << pinBit);
|
|
#endif
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline bool read()
|
|
{
|
|
constexpr auto bus = detail::getBus(pin);
|
|
constexpr auto pinBit = detail::getPinBit(pin);
|
|
|
|
detail::reg_ptr_t pinRegPtr = detail::getRegPtr<detail::getPIN(bus)>();
|
|
|
|
if (*pinRegPtr >> pinBit & 1)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
[[gnu::always_inline]] Pin &operator=(const bool value)
|
|
{
|
|
write(value);
|
|
return *this;
|
|
}
|
|
|
|
[[gnu::always_inline]] operator bool() const
|
|
{
|
|
return read();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Zero overhead Port object for pretty code without losing performance
|
|
|
|
template <Bus port>
|
|
class Port {
|
|
public:
|
|
// Port objects cannot be moved or copied
|
|
Port(const Port &) = delete;
|
|
Port(Port &&) = delete;
|
|
Port &operator=(const Port &) = delete;
|
|
Port &operator=(Port &&) = delete;
|
|
|
|
// The only valid way to create a Port object is with the default constructor
|
|
Port() = default;
|
|
|
|
[[gnu::always_inline]] static inline void dir(const Dir dir)
|
|
{
|
|
detail::reg_ptr_t dirRegPtr = detail::getRegPtr<detail::getDDR(port)>();
|
|
|
|
if (dir == Dir::IN)
|
|
*dirRegPtr = 0x00;
|
|
else if (dir == Dir::OUT)
|
|
*dirRegPtr = 0xFF;
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void pullup(const bool enable)
|
|
{
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(port)>();
|
|
|
|
if (enable)
|
|
*portRegPtr = 0xFF;
|
|
else
|
|
*portRegPtr = 0x00;
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void write(const uint8_t value)
|
|
{
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(port)>();
|
|
*portRegPtr = value;
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void invert()
|
|
{
|
|
#ifdef HARDWARE_TOGGLE
|
|
detail::reg_ptr_t pinRegPtr = detail::getRegPtr<detail::getPIN(port)>();
|
|
*pinRegPtr = 0xFF;
|
|
#else
|
|
detail::reg_ptr_t portRegPtr = detail::getRegPtr<detail::getPORT(port)>();
|
|
*portRegPtr = ~(*portRegPtr);
|
|
#endif
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline uint8_t read()
|
|
{
|
|
detail::reg_ptr_t pinRegPtr = detail::getRegPtr<detail::getPIN(port)>();
|
|
|
|
return *pinRegPtr;
|
|
}
|
|
|
|
[[gnu::always_inline]] inline Port &operator=(const uint8_t value)
|
|
{
|
|
write(value);
|
|
return *this;
|
|
}
|
|
|
|
[[gnu::always_inline]] inline operator uint8_t() const
|
|
{
|
|
return read();
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Zero overhead Virtual Port object for pretty code without losing performance
|
|
|
|
namespace detail {
|
|
|
|
template <P pin, uint8_t offset>
|
|
struct Callers {
|
|
[[gnu::always_inline]] static void call(const Dir dir)
|
|
{
|
|
Pin<pin>::dir(dir);
|
|
};
|
|
|
|
[[gnu::always_inline]] static void call(const bool enable)
|
|
{
|
|
Pin<pin>::pullup(enable);
|
|
};
|
|
|
|
[[gnu::always_inline]] static void call(const uint8_t value)
|
|
{
|
|
Pin<pin>::write(value >> offset & 1);
|
|
};
|
|
|
|
[[gnu::always_inline]] static void call()
|
|
{
|
|
Pin<pin>::toggle();
|
|
};
|
|
};
|
|
|
|
template <P pin>
|
|
struct readCaller {
|
|
[[gnu::always_inline]] static bool call()
|
|
{
|
|
return Pin<pin>::read();
|
|
};
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
template <P... pins>
|
|
class VirtPort {
|
|
public:
|
|
static_assert(sizeof...(pins) <= 8, "A virtual port cannot have more than 8 pins");
|
|
|
|
// VirtPort objects cannot be moved or copied
|
|
VirtPort(const VirtPort &) = delete;
|
|
VirtPort(VirtPort &&) = delete;
|
|
VirtPort &operator=(const VirtPort &) = delete;
|
|
VirtPort &operator=(VirtPort &&) = delete;
|
|
|
|
// The only valid way to create a VirtPort object is with the default constructor
|
|
VirtPort() = default;
|
|
|
|
[[gnu::always_inline]] static inline void dir(const Dir dir)
|
|
{
|
|
detail::CallHelper<detail::Callers, pins...>::call(dir);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void pullup(const bool enable)
|
|
{
|
|
detail::CallHelper<detail::Callers, pins...>::call(enable);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void write(const uint8_t value)
|
|
{
|
|
detail::CallHelper<detail::Callers, pins...>::call(value);
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline void invert()
|
|
{
|
|
detail::CallHelper<detail::Callers, pins...>::call();
|
|
}
|
|
|
|
[[gnu::always_inline]] static inline uint8_t read()
|
|
{
|
|
return detail::ReadCallHelper<detail::readCaller, pins...>::call();
|
|
}
|
|
|
|
[[gnu::always_inline]] inline VirtPort &operator=(const uint8_t value)
|
|
{
|
|
write(value);
|
|
return *this;
|
|
}
|
|
|
|
[[gnu::always_inline]] inline operator uint8_t() const
|
|
{
|
|
return read();
|
|
}
|
|
};
|
|
|
|
} // namespace io
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
#undef GPIO_32
|
|
#undef GPIO_23
|
|
#undef GPIO_6
|
|
|
|
#undef PORT_A_AVAILABLE
|
|
#undef PORT_B_AVAILABLE
|
|
#undef PORT_C_AVAILABLE
|
|
#undef PORT_D_AVAILABLE
|
|
|
|
#undef PIN_B6_AVAILABLE
|
|
#undef PIN_B7_AVAILABLE
|
|
#undef PIN_C7_AVAILABLE
|