avr/uart
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: avr:master
Branches Tags
avr:master avr:stk500v2-library-wip avr:example
..
compare: avr:stk500v2-library-wip
Branches Tags
avr:stk500v2-library-wip avr:master avr:example

2 Commits
master ... stk500v2-l

Author SHA1 Message Date
BlackMark
dd37fa0411 Expose baud rate for use by protocol implementations 2026-08-05 22:02:16 +02:00
BlackMark
430ad479fc Fix volatile compound assignments being deprecated in C++20 2026-08-05 22:02:16 +02:00
6 changed files with 143 additions and 127 deletions
Expand all files Collapse all files

8
config.hpp
View File

@@ -1,6 +1,6 @@
#pragma once #pragma once
#include <cstdint> #include <stdint.h>
namespace uart { namespace uart {
@@ -27,17 +27,17 @@ namespace detail {
template <DataBits dataBits> template <DataBits dataBits>
struct choose_data_type { struct choose_data_type {
using type = std::uint8_t; using type = uint8_t;
}; };
template <> template <>
struct choose_data_type<DataBits::NINE> { struct choose_data_type<DataBits::NINE> {
using type = std::uint16_t; using type = uint16_t;
}; };
} // namespace detail } // namespace detail
template <std::uint32_t baudRate = 9600, DataBits dataBits = DataBits::EIGHT, Parity parity = Parity::NONE, template <uint32_t baudRate = 9600, DataBits dataBits = DataBits::EIGHT, Parity parity = Parity::NONE,
StopBits stopBits = StopBits::ONE> StopBits stopBits = StopBits::ONE>
struct Config { struct Config {
static constexpr auto BAUD_RATE = baudRate; static constexpr auto BAUD_RATE = baudRate;

136
hardware.hpp
View File

@@ -2,8 +2,12 @@
#include "../clock.hpp" #include "../clock.hpp"
#include <cmath> #include "../type/type.hpp"
#include <cstdint>
#include <math.h>
#include <stdint.h>
#define FORCE_INLINE __attribute__((always_inline))
namespace uart { namespace uart {
@@ -21,18 +25,18 @@ enum class Driven {
namespace detail { namespace detail {
using reg_ptr_t = volatile std::uint8_t *; using reg_ptr_t = volatile uint8_t *;
template <std::uintptr_t Address> template <uintptr_t Address>
static inline reg_ptr_t getRegPtr() static inline reg_ptr_t getRegPtr()
{ {
return reinterpret_cast<reg_ptr_t>(Address); return reinterpret_cast<reg_ptr_t>(Address);
} }
template <typename data_t, std::uint8_t Size> template <typename data_t, uint8_t Size>
struct RingBuffer { struct RingBuffer {
std::uint8_t head; uint8_t head;
std::uint8_t tail; uint8_t tail;
data_t buf[Size]; data_t buf[Size];
}; };
@@ -40,17 +44,17 @@ template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename Ct
Mode mode> Mode mode>
class Hardware { class Hardware {
public: public:
[[gnu::always_inline]] static void init() static void init() FORCE_INLINE
{ {
constexpr auto AbsDoubleError = std::fabs(calcBaudError<true>()); constexpr auto AbsDoubleError = fabs(calcBaudError<true>());
constexpr auto AbsNormalError = std::fabs(calcBaudError<false>()); constexpr auto AbsNormalError = fabs(calcBaudError<false>());
static_assert(AbsDoubleError <= 3.0 || AbsNormalError <= 3.0, "Baud rate error over 3%, probably unusable"); static_assert(AbsDoubleError <= 3.0 || AbsNormalError <= 3.0, "Baud rate error over 3%, probably unusable");
constexpr auto UseDoubleSpeed = (AbsDoubleError < AbsNormalError); constexpr auto UseDoubleSpeed = (AbsDoubleError < AbsNormalError);
constexpr auto BaudVal = calcBaudVal<UseDoubleSpeed>(); constexpr auto BaudVal = calcBaudVal<UseDoubleSpeed>();
*getRegPtr<Registers::BAUD_REG_H_ADDR>() = static_cast<std::uint8_t>(BaudVal >> 8); *getRegPtr<Registers::BAUD_REG_H_ADDR>() = static_cast<uint8_t>(BaudVal >> 8);
*getRegPtr<Registers::BAUD_REG_L_ADDR>() = static_cast<std::uint8_t>(BaudVal); *getRegPtr<Registers::BAUD_REG_L_ADDR>() = static_cast<uint8_t>(BaudVal);
constexpr auto DataBitsValues = calcDataBits(); constexpr auto DataBitsValues = calcDataBits();
constexpr auto ParityVal = calcParity(); constexpr auto ParityVal = calcParity();
@@ -60,21 +64,21 @@ class Hardware {
constexpr auto EnableTx = calcTxState<true>(); constexpr auto EnableTx = calcTxState<true>();
constexpr auto InterruptVal = calcInterrupt(); constexpr auto InterruptVal = calcInterrupt();
constexpr std::uint8_t ControlRegB = DataBitsValues.regBVal | EnableRx | EnableTx | InterruptVal; constexpr uint8_t ControlRegB = DataBitsValues.regBVal | EnableRx | EnableTx | InterruptVal;
constexpr std::uint8_t ControlRegC = DataBitsValues.regCVal | ParityVal | StopBitsVal | ModeVal; constexpr uint8_t ControlRegC = DataBitsValues.regCVal | ParityVal | StopBitsVal | ModeVal;
auto ctrlStatRegA = getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>();
if constexpr (UseDoubleSpeed) if constexpr (UseDoubleSpeed)
*ctrlStatRegA = *ctrlStatRegA | (1 << CtrlFlagsA::SPEED_2X); *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() =
*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() | (1 << CtrlFlagsA::SPEED_2X);
else else
*ctrlStatRegA = *ctrlStatRegA & ~(1 << CtrlFlagsA::SPEED_2X); *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() =
*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & ~(1 << CtrlFlagsA::SPEED_2X);
*getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() = ControlRegB; *getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() = ControlRegB;
*getRegPtr<Registers::CTRL_STAT_REG_C_ADDR>() = ControlRegC; *getRegPtr<Registers::CTRL_STAT_REG_C_ADDR>() = ControlRegC;
} }
[[gnu::always_inline]] static bool rxByteBlocking(typename cfg::data_t &byte) static bool rxByteBlocking(typename cfg::data_t &byte) FORCE_INLINE
{ {
if (*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::RECEIVE_COMPLETE)) { if (*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::RECEIVE_COMPLETE)) {
byte = *getRegPtr<Registers::IO_REG_ADDR>(); byte = *getRegPtr<Registers::IO_REG_ADDR>();
@@ -84,27 +88,27 @@ class Hardware {
return false; return false;
} }
[[gnu::always_inline]] static typename cfg::data_t rxByteInterrupt() static typename cfg::data_t rxByteInterrupt() FORCE_INLINE
{ {
return *getRegPtr<Registers::IO_REG_ADDR>(); return *getRegPtr<Registers::IO_REG_ADDR>();
} }
[[gnu::always_inline]] static bool txEmpty() static bool txEmpty() FORCE_INLINE
{ {
return *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::DATA_REG_EMPTY); return *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::DATA_REG_EMPTY);
} }
[[gnu::always_inline]] static bool txComplete() static bool txComplete() FORCE_INLINE
{ {
return *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::TRANSMIT_COMPLETE); return *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::TRANSMIT_COMPLETE);
} }
[[gnu::always_inline]] static void clearTxComplete() static void clearTxComplete() FORCE_INLINE
{ {
*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() |= (1 << CtrlFlagsA::TRANSMIT_COMPLETE); *getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() |= (1 << CtrlFlagsA::TRANSMIT_COMPLETE);
} }
[[gnu::always_inline]] static void txByteBlocking(const typename cfg::data_t &byte) static void txByteBlocking(const typename cfg::data_t &byte) FORCE_INLINE
{ {
while (!txEmpty()) while (!txEmpty())
; ;
@@ -112,12 +116,12 @@ class Hardware {
*getRegPtr<Registers::IO_REG_ADDR>() = byte; *getRegPtr<Registers::IO_REG_ADDR>() = byte;
} }
[[gnu::always_inline]] static void txByteInterrupt(volatile const typename cfg::data_t &byte) static void txByteInterrupt(volatile const typename cfg::data_t &byte) FORCE_INLINE
{ {
*getRegPtr<Registers::IO_REG_ADDR>() = byte; *getRegPtr<Registers::IO_REG_ADDR>() = byte;
} }
[[gnu::always_inline]] static bool peekBlocking() static bool peekBlocking() FORCE_INLINE
{ {
if (*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::RECEIVE_COMPLETE)) { if (*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() & (1 << CtrlFlagsA::RECEIVE_COMPLETE)) {
return true; return true;
@@ -126,45 +130,45 @@ class Hardware {
return false; return false;
} }
[[gnu::always_inline]] static void enableDataRegEmptyInt() static void enableDataRegEmptyInt() FORCE_INLINE
{ {
auto ctrlStatRegB = getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>(); *getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() =
*ctrlStatRegB = *ctrlStatRegB | (1 << CtrlFlagsB::DATA_REG_EMPTY_INT_ENABLE); *getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() | (1 << CtrlFlagsB::DATA_REG_EMPTY_INT_ENABLE);
} }
[[gnu::always_inline]] static void disableDataRegEmptyInt() static void disableDataRegEmptyInt() FORCE_INLINE
{ {
auto ctrlStatRegB = getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>(); *getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() =
*ctrlStatRegB = *ctrlStatRegB & ~(1 << CtrlFlagsB::DATA_REG_EMPTY_INT_ENABLE); *getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() & ~(1 << CtrlFlagsB::DATA_REG_EMPTY_INT_ENABLE);
} }
private: private:
struct DataBitsVal { struct DataBitsVal {
std::uint8_t regCVal = 0; uint8_t regCVal = 0;
std::uint8_t regBVal = 0; uint8_t regBVal = 0;
}; };
template <bool DoubleSpeed = true> template <bool DoubleSpeed = true>
static constexpr auto calcBaudVal() static constexpr auto calcBaudVal()
{ {
if constexpr (DoubleSpeed) { if constexpr (DoubleSpeed) {
constexpr auto BaudVal = static_cast<std::uint16_t>(round(F_CPU / (8.0 * cfg::BAUD_RATE) - 1)); constexpr auto BaudVal = static_cast<uint16_t>(round(F_CPU / (8.0 * cfg::BAUD_RATE) - 1));
return BaudVal; return BaudVal;
} }
constexpr auto BaudVal = static_cast<std::uint16_t>(round(F_CPU / (16.0 * cfg::BAUD_RATE) - 1)); constexpr auto BaudVal = static_cast<uint16_t>(round(F_CPU / (16.0 * cfg::BAUD_RATE) - 1));
return BaudVal; return BaudVal;
} }
template <std::uint16_t BaudVal, bool DoubleSpeed = true> template <uint16_t BaudVal, bool DoubleSpeed = true>
static constexpr auto calcBaudRate() static constexpr auto calcBaudRate()
{ {
if constexpr (DoubleSpeed) { if constexpr (DoubleSpeed) {
constexpr auto BaudRate = static_cast<std::uint32_t>(round(F_CPU / (8.0 * (BaudVal + 1)))); constexpr auto BaudRate = static_cast<uint32_t>(round(F_CPU / (8.0 * (BaudVal + 1))));
return BaudRate; return BaudRate;
} }
constexpr auto BaudRate = static_cast<std::uint32_t>(round(F_CPU / (16.0 * (BaudVal + 1)))); constexpr auto BaudRate = static_cast<uint32_t>(round(F_CPU / (16.0 * (BaudVal + 1))));
return BaudRate; return BaudRate;
} }
@@ -205,7 +209,7 @@ class Hardware {
static constexpr auto calcParity() static constexpr auto calcParity()
{ {
std::uint8_t parityVal = 0; uint8_t parityVal = 0;
if (cfg::PARITY == Parity::EVEN) if (cfg::PARITY == Parity::EVEN)
parityVal = (1 << CtrlFlagsC::PARITY_MODE_1); parityVal = (1 << CtrlFlagsC::PARITY_MODE_1);
@@ -217,7 +221,7 @@ class Hardware {
static constexpr auto calcStopBits() static constexpr auto calcStopBits()
{ {
std::uint8_t stopBitsVal = 0; uint8_t stopBitsVal = 0;
if (cfg::STOP_BITS == StopBits::TWO) if (cfg::STOP_BITS == StopBits::TWO)
stopBitsVal = (1 << CtrlFlagsC::STOP_BIT_SEL); stopBitsVal = (1 << CtrlFlagsC::STOP_BIT_SEL);
@@ -229,7 +233,7 @@ class Hardware {
{ {
static_assert(mode != Mode::SPI, "SPI mode can not be used with uart"); static_assert(mode != Mode::SPI, "SPI mode can not be used with uart");
std::uint8_t modeVal = 0; uint8_t modeVal = 0;
if (mode == Mode::SYNCHRONOUS_MASTER || mode == Mode::SYNCHRONOUS_SLAVE) { if (mode == Mode::SYNCHRONOUS_MASTER || mode == Mode::SYNCHRONOUS_SLAVE) {
modeVal = (1 << CtrlFlagsC::MODE_SEL_0); modeVal = (1 << CtrlFlagsC::MODE_SEL_0);
@@ -241,7 +245,7 @@ class Hardware {
template <bool Enable> template <bool Enable>
static constexpr auto calcRxState() static constexpr auto calcRxState()
{ {
std::uint8_t enableVal = 0; uint8_t enableVal = 0;
if (Enable) if (Enable)
enableVal = (1 << CtrlFlagsB::RX_ENABLE); enableVal = (1 << CtrlFlagsB::RX_ENABLE);
@@ -252,7 +256,7 @@ class Hardware {
template <bool Enable> template <bool Enable>
static constexpr auto calcTxState() static constexpr auto calcTxState()
{ {
std::uint8_t enableVal = 0; uint8_t enableVal = 0;
if (Enable) if (Enable)
enableVal = (1 << CtrlFlagsB::TX_ENABLE); enableVal = (1 << CtrlFlagsB::TX_ENABLE);
@@ -262,7 +266,7 @@ class Hardware {
static constexpr auto calcInterrupt() static constexpr auto calcInterrupt()
{ {
std::uint8_t interruptVal = 0; uint8_t interruptVal = 0;
if (driven == Driven::INTERRUPT) if (driven == Driven::INTERRUPT)
interruptVal = (1 << CtrlFlagsB::RX_INT_ENABLE); interruptVal = (1 << CtrlFlagsB::RX_INT_ENABLE);
@@ -275,35 +279,36 @@ template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename Ct
class BlockingHardware { class BlockingHardware {
public: public:
using data_t = typename cfg::data_t; using data_t = typename cfg::data_t;
static constexpr auto BAUD_RATE = cfg::BAUD_RATE;
static constexpr auto DATA_BITS = cfg::DATA_BITS; static constexpr auto DATA_BITS = cfg::DATA_BITS;
[[gnu::always_inline]] static void init() static void init() FORCE_INLINE
{ {
HardwareImpl::init(); HardwareImpl::init();
} }
[[gnu::always_inline]] static void txByte(const data_t &byte) static void txByte(const data_t &byte) FORCE_INLINE
{ {
HardwareImpl::txByteBlocking(byte); HardwareImpl::txByteBlocking(byte);
} }
[[gnu::always_inline]] static bool rxByte(data_t &byte) static bool rxByte(data_t &byte) FORCE_INLINE
{ {
return HardwareImpl::rxByteBlocking(byte); return HardwareImpl::rxByteBlocking(byte);
} }
[[gnu::always_inline]] static bool peek(data_t &) static bool peek(data_t &) FORCE_INLINE
{ {
static_assert(util::always_false_v<data_t>, "Peek with data is not supported in blocking mode"); static_assert(type::always_false_v<data_t>, "Peek with data is not supported in blocking mode");
return false; return false;
} }
[[gnu::always_inline]] static bool peek() static bool peek() FORCE_INLINE
{ {
return HardwareImpl::peekBlocking(); return HardwareImpl::peekBlocking();
} }
[[gnu::always_inline]] static void flushTx() static void flushTx() FORCE_INLINE
{ {
while (!HardwareImpl::txEmpty()) while (!HardwareImpl::txEmpty())
; ;
@@ -320,11 +325,12 @@ template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename Ct
class InterruptHardware { class InterruptHardware {
public: public:
using data_t = typename cfg::data_t; using data_t = typename cfg::data_t;
static constexpr auto BAUD_RATE = cfg::BAUD_RATE;
static constexpr auto DATA_BITS = cfg::DATA_BITS; static constexpr auto DATA_BITS = cfg::DATA_BITS;
[[gnu::always_inline]] static void txByte(const data_t &byte) static void txByte(const data_t &byte) FORCE_INLINE
{ {
std::uint8_t tmpHead = (sm_txBuf.head + 1) % TX_BUFFER_SIZE; uint8_t tmpHead = (sm_txBuf.head + 1) % TX_BUFFER_SIZE;
while (tmpHead == sm_txBuf.tail) while (tmpHead == sm_txBuf.tail)
; ;
@@ -334,35 +340,35 @@ class InterruptHardware {
HardwareImpl::enableDataRegEmptyInt(); HardwareImpl::enableDataRegEmptyInt();
} }
[[gnu::always_inline]] static bool rxByte(data_t &byte) static bool rxByte(data_t &byte) FORCE_INLINE
{ {
if (sm_rxBuf.head == sm_rxBuf.tail) if (sm_rxBuf.head == sm_rxBuf.tail)
return false; return false;
std::uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE; uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
byte = sm_rxBuf.buf[tmpTail]; byte = sm_rxBuf.buf[tmpTail];
sm_rxBuf.tail = tmpTail; sm_rxBuf.tail = tmpTail;
return true; return true;
} }
[[gnu::always_inline]] static bool peek(data_t &byte) static bool peek(data_t &byte) FORCE_INLINE
{ {
if (sm_rxBuf.head == sm_rxBuf.tail) if (sm_rxBuf.head == sm_rxBuf.tail)
return false; return false;
std::uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE; uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
byte = sm_rxBuf.buf[tmpTail]; byte = sm_rxBuf.buf[tmpTail];
return true; return true;
} }
[[gnu::always_inline]] static bool peek() static bool peek() FORCE_INLINE
{ {
return (sm_rxBuf.head != sm_rxBuf.tail); return (sm_rxBuf.head != sm_rxBuf.tail);
} }
[[gnu::always_inline]] static void flushTx() static void flushTx() FORCE_INLINE
{ {
while (sm_txBuf.head != sm_txBuf.tail) while (sm_txBuf.head != sm_txBuf.tail)
; ;
@@ -374,11 +380,11 @@ class InterruptHardware {
} }
protected: protected:
[[gnu::always_inline]] static void rxIntHandler() static void rxIntHandler() FORCE_INLINE
{ {
const auto data = HardwareImpl::rxByteInterrupt(); const auto data = HardwareImpl::rxByteInterrupt();
const std::uint8_t tmpHead = (sm_rxBuf.head + 1) % RX_BUFFER_SIZE; const uint8_t tmpHead = (sm_rxBuf.head + 1) % RX_BUFFER_SIZE;
if (tmpHead != sm_rxBuf.tail) { if (tmpHead != sm_rxBuf.tail) {
sm_rxBuf.head = tmpHead; sm_rxBuf.head = tmpHead;
@@ -388,10 +394,10 @@ class InterruptHardware {
} }
} }
[[gnu::always_inline]] static void dataRegEmptyIntHandler() static void dataRegEmptyIntHandler() FORCE_INLINE
{ {
if (sm_txBuf.head != sm_txBuf.tail) { if (sm_txBuf.head != sm_txBuf.tail) {
const std::uint8_t tmpTail = (sm_txBuf.tail + 1) % TX_BUFFER_SIZE; const uint8_t tmpTail = (sm_txBuf.tail + 1) % TX_BUFFER_SIZE;
sm_txBuf.tail = tmpTail; sm_txBuf.tail = tmpTail;
HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]); HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]);
} else } else
@@ -421,3 +427,5 @@ volatile RingBuffer<typename InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB
} // namespace detail } // namespace detail
} // namespace uart } // namespace uart
#undef FORCE_INLINE

24
hardware0.hpp
View File

@@ -1,6 +1,6 @@
#pragma once #pragma once
#include <cstdint> #include <stdint.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <avr/io.h> #include <avr/io.h>
@@ -9,6 +9,8 @@
#include "config.hpp" #include "config.hpp"
#include "hardware.hpp" #include "hardware.hpp"
#define FORCE_INLINE __attribute__((always_inline))
namespace uart { namespace uart {
namespace detail { namespace detail {
@@ -30,12 +32,12 @@ The workaround therefore is to disable the pointer cast and dereference macro _M
#define _MMIO_BYTE #define _MMIO_BYTE
struct Registers0 { struct Registers0 {
static constexpr std::uintptr_t IO_REG_ADDR = UDR0; static constexpr uintptr_t IO_REG_ADDR = UDR0;
static constexpr std::uintptr_t CTRL_STAT_REG_A_ADDR = UCSR0A; static constexpr uintptr_t CTRL_STAT_REG_A_ADDR = UCSR0A;
static constexpr std::uintptr_t CTRL_STAT_REG_B_ADDR = UCSR0B; static constexpr uintptr_t CTRL_STAT_REG_B_ADDR = UCSR0B;
static constexpr std::uintptr_t CTRL_STAT_REG_C_ADDR = UCSR0C; static constexpr uintptr_t CTRL_STAT_REG_C_ADDR = UCSR0C;
static constexpr std::uintptr_t BAUD_REG_L_ADDR = UBRR0L; static constexpr uintptr_t BAUD_REG_L_ADDR = UBRR0L;
static constexpr std::uintptr_t BAUD_REG_H_ADDR = UBRR0H; static constexpr uintptr_t BAUD_REG_H_ADDR = UBRR0H;
}; };
#pragma pop_macro("_MMIO_BYTE") #pragma pop_macro("_MMIO_BYTE")
@@ -100,7 +102,7 @@ class Hardware0<cfg, Driven::INTERRUPT, mode>
: public detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0, : public detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
detail::ControlFlagsC0, cfg, mode> { detail::ControlFlagsC0, cfg, mode> {
public: public:
[[gnu::always_inline]] static void init() static void init() FORCE_INLINE
{ {
HardwareImpl::init(); HardwareImpl::init();
sei(); sei();
@@ -117,12 +119,12 @@ class Hardware0<cfg, Driven::INTERRUPT, mode>
template <class Driver> template <class Driver>
friend class Uart; friend class Uart;
[[gnu::always_inline]] static void rxIntHandler() static void rxIntHandler() FORCE_INLINE
{ {
InterruptHardwareImpl::rxIntHandler(); InterruptHardwareImpl::rxIntHandler();
} }
[[gnu::always_inline]] static void dataRegEmptyIntHandler() static void dataRegEmptyIntHandler() FORCE_INLINE
{ {
InterruptHardwareImpl::dataRegEmptyIntHandler(); InterruptHardwareImpl::dataRegEmptyIntHandler();
} }
@@ -150,3 +152,5 @@ void USART0_UDRE_vect() __attribute__((signal));
} \ } \
struct _##uart_type {} struct _##uart_type {}
// clang-format on // clang-format on
#undef FORCE_INLINE

24
hardware1.hpp
View File

@@ -1,6 +1,6 @@
#pragma once #pragma once
#include <cstdint> #include <stdint.h>
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <avr/io.h> #include <avr/io.h>
@@ -9,6 +9,8 @@
#include "config.hpp" #include "config.hpp"
#include "hardware.hpp" #include "hardware.hpp"
#define FORCE_INLINE __attribute__((always_inline))
namespace uart { namespace uart {
namespace detail { namespace detail {
@@ -30,12 +32,12 @@ The workaround therefore is to disable the pointer cast and dereference macro _M
#define _MMIO_BYTE #define _MMIO_BYTE
struct Registers1 { struct Registers1 {
static constexpr std::uintptr_t IO_REG_ADDR = UDR1; static constexpr uintptr_t IO_REG_ADDR = UDR1;
static constexpr std::uintptr_t CTRL_STAT_REG_A_ADDR = UCSR1A; static constexpr uintptr_t CTRL_STAT_REG_A_ADDR = UCSR1A;
static constexpr std::uintptr_t CTRL_STAT_REG_B_ADDR = UCSR1B; static constexpr uintptr_t CTRL_STAT_REG_B_ADDR = UCSR1B;
static constexpr std::uintptr_t CTRL_STAT_REG_C_ADDR = UCSR1C; static constexpr uintptr_t CTRL_STAT_REG_C_ADDR = UCSR1C;
static constexpr std::uintptr_t BAUD_REG_L_ADDR = UBRR1L; static constexpr uintptr_t BAUD_REG_L_ADDR = UBRR1L;
static constexpr std::uintptr_t BAUD_REG_H_ADDR = UBRR1H; static constexpr uintptr_t BAUD_REG_H_ADDR = UBRR1H;
}; };
#pragma pop_macro("_MMIO_BYTE") #pragma pop_macro("_MMIO_BYTE")
@@ -97,7 +99,7 @@ class Hardware1<cfg, Driven::INTERRUPT, mode>
: public detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1, : public detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
detail::ControlFlagsC1, cfg, mode> { detail::ControlFlagsC1, cfg, mode> {
public: public:
[[gnu::always_inline]] static void init() static void init() FORCE_INLINE
{ {
HardwareImpl::init(); HardwareImpl::init();
sei(); sei();
@@ -114,12 +116,12 @@ class Hardware1<cfg, Driven::INTERRUPT, mode>
template <class Driver> template <class Driver>
friend class Uart; friend class Uart;
[[gnu::always_inline]] static void rxIntHandler() static void rxIntHandler() FORCE_INLINE
{ {
InterruptHardwareImpl::rxIntHandler(); InterruptHardwareImpl::rxIntHandler();
} }
[[gnu::always_inline]] static void dataRegEmptyIntHandler() static void dataRegEmptyIntHandler() FORCE_INLINE
{ {
InterruptHardwareImpl::dataRegEmptyIntHandler(); InterruptHardwareImpl::dataRegEmptyIntHandler();
} }
@@ -155,3 +157,5 @@ void USART1_UDRE_vect() __attribute__((signal));
#endif #endif
#undef FORCE_INLINE

4
software.hpp
View File

@@ -3,13 +3,13 @@
#include "config.hpp" #include "config.hpp"
#include "../io/io.hpp" #include "../io/io.hpp"
#include "../util/util.hpp" #include "../type/type.hpp"
namespace uart { namespace uart {
template <io::P rxPin, io::P txPin, class cfg = Config<>> template <io::P rxPin, io::P txPin, class cfg = Config<>>
class Software { class Software {
static_assert(util::always_false_v<cfg>, "Not implemented"); static_assert(type::always_false_v<cfg>, "Not implemented");
public: public:
using data_t = typename cfg::data_t; using data_t = typename cfg::data_t;

74
uart.hpp
View File

@@ -1,8 +1,6 @@
#pragma once #pragma once
#include <limits> #include <stdint.h>
#include <cstdint>
#include "config.hpp" #include "config.hpp"
#include "software.hpp" #include "software.hpp"
@@ -11,17 +9,18 @@
#include "hardware1.hpp" #include "hardware1.hpp"
#include "../flash/flash.hpp" #include "../flash/flash.hpp"
#include "../util/util.hpp"
#define FORCE_INLINE __attribute__((always_inline))
namespace uart { namespace uart {
namespace detail { namespace detail {
template <typename T, T Limit, std::size_t Base> template <typename T, T Limit, size_t Base>
static constexpr std::size_t cntDigits() static constexpr size_t cntDigits()
{ {
T num = Limit; T num = Limit;
std::size_t cnt = 0; size_t cnt = 0;
do { do {
num /= Base; num /= Base;
@@ -31,11 +30,11 @@ static constexpr std::size_t cntDigits()
return cnt; return cnt;
} }
template <typename T, std::size_t Base> template <typename T, size_t Base>
static constexpr std::size_t maxNumDigits() static constexpr size_t maxNumDigits()
{ {
constexpr T MinVal = std::numeric_limits<T>::min(); constexpr T MinVal = type::numeric_limits<T>::min();
constexpr T MaxVal = std::numeric_limits<T>::max(); constexpr T MaxVal = type::numeric_limits<T>::max();
constexpr T MinDigits = cntDigits<T, MinVal, Base>(); constexpr T MinDigits = cntDigits<T, MinVal, Base>();
constexpr T MaxDigits = cntDigits<T, MaxVal, Base>(); constexpr T MaxDigits = cntDigits<T, MaxVal, Base>();
@@ -110,16 +109,16 @@ class Uart {
txByte(ch); txByte(ch);
} }
template <typename T, std::size_t Base = 10, std::size_t Padding = 0, char PadChar = '0', bool LowerCase = true> template <typename T, size_t Base = 10, size_t Padding = 0, char PadChar = '0', bool LowerCase = true>
static void txNumber(const T &val) static void txNumber(const T &val)
{ {
static_assert(std::is_integral_v<T>, "Only supported on integral types"); static_assert(type::is_integral_v<T>, "Only supported on integral types");
static_assert(Base >= 2, "Numbers with base less than 2 make no sense"); static_assert(Base >= 2, "Numbers with base less than 2 make no sense");
static_assert(Base <= 16, "Numbers with base higher than 16 are not supported"); static_assert(Base <= 16, "Numbers with base higher than 16 are not supported");
static_assert(Padding <= detail::maxNumDigits<T, Base>(), "Cannot pad more than maximum length of number"); static_assert(Padding <= detail::maxNumDigits<T, Base>(), "Cannot pad more than maximum length of number");
constexpr char AlphaChar = (LowerCase) ? 'a' : 'A'; constexpr char AlphaChar = (LowerCase) ? 'a' : 'A';
constexpr std::size_t NumDigits = detail::maxNumDigits<T, Base>(); constexpr size_t NumDigits = detail::maxNumDigits<T, Base>();
T digits = val; T digits = val;
@@ -138,10 +137,10 @@ class Uart {
} while (digits > 0); } while (digits > 0);
if (Padding > 0) { if (Padding > 0) {
std::size_t strLen = buffer + NumDigits - (bufEnd + 1); size_t strLen = buffer + NumDigits - (bufEnd + 1);
if (Padding > strLen) { if (Padding > strLen) {
for (std::size_t i = Padding; i > strLen && bufEnd >= buffer; --i) { for (size_t i = Padding; i > strLen && bufEnd >= buffer; --i) {
*bufEnd-- = PadChar; *bufEnd-- = PadChar;
} }
} }
@@ -235,19 +234,19 @@ class Uart {
template <typename... Ts> template <typename... Ts>
Uart &operator<<(float) const Uart &operator<<(float) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator<<(double) const Uart &operator<<(double) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator<<(long double) const Uart &operator<<(long double) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
Uart &operator<<(const bool &val) Uart &operator<<(const bool &val)
@@ -259,7 +258,7 @@ class Uart {
Uart &operator<<(const void *val) Uart &operator<<(const void *val)
{ {
txString(F("0x")); txString(F("0x"));
txNumber<std::uint16_t, 16, 4, '0', false>(reinterpret_cast<std::uint16_t>(val)); txNumber<uint16_t, 16, 4, '0', false>(reinterpret_cast<uint16_t>(val));
return *this; return *this;
} }
@@ -269,91 +268,91 @@ class Uart {
template <typename... Ts> template <typename... Ts>
Uart &operator>>(char &) const Uart &operator>>(char &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(unsigned char &) const Uart &operator>>(unsigned char &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(short &) const Uart &operator>>(short &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(unsigned short &) const Uart &operator>>(unsigned short &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(int &) const Uart &operator>>(int &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(unsigned int &) const Uart &operator>>(unsigned int &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(long &) const Uart &operator>>(long &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(unsigned long &) const Uart &operator>>(unsigned long &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(long long &) const Uart &operator>>(long long &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(unsigned long long &) const Uart &operator>>(unsigned long long &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(float &) const Uart &operator>>(float &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(double &) const Uart &operator>>(double &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(long double &) const Uart &operator>>(long double &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not supported by hardware"); static_assert(type::always_false_v<Ts...>, "Not supported by hardware");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(bool &) const Uart &operator>>(bool &) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
template <typename... Ts> template <typename... Ts>
Uart &operator>>(const void *&) const Uart &operator>>(const void *&) const
{ {
static_assert(util::always_false_v<Ts...>, "Not implemented"); static_assert(type::always_false_v<Ts...>, "Not implemented");
} }
private: private:
@@ -365,12 +364,12 @@ class Uart {
friend void ::USART1_UDRE_vect(); friend void ::USART1_UDRE_vect();
#endif #endif
[[gnu::always_inline]] static void rxIntHandler() static void rxIntHandler() FORCE_INLINE
{ {
Driver::rxIntHandler(); Driver::rxIntHandler();
} }
[[gnu::always_inline]] static void dataRegEmptyIntHandler() static void dataRegEmptyIntHandler() FORCE_INLINE
{ {
Driver::dataRegEmptyIntHandler(); Driver::dataRegEmptyIntHandler();
} }
@@ -386,4 +385,5 @@ using Uart1 = Uart<Hardware1<cfg, Driven::INTERRUPT, Mode::ASYNCHRONOUS>>;
} // namespace uart } // namespace uart
#undef FORCE_INLINE
#undef HAS_UART1 #undef HAS_UART1