Refactored code to get rid of code duplication

hardware.hpp

@@ -4,6 +4,8 @@
 
 #include <stdint.h>
 
+#include "utils.hpp"
+
 #define FORCE_INLINE __attribute__((always_inline))
 
 namespace uart {
@@ -31,6 +33,13 @@ static inline reg_ptr_t getRegPtr()
 	return reinterpret_cast<reg_ptr_t>(Address);
 }
 
+template <typename data_t, uint8_t Size>
+struct RingBuffer {
+	uint8_t head;
+	uint8_t tail;
+	data_t buf[Size];
+};
+
 template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Driven driven,
           Mode mode>
 class Hardware {
@@ -226,13 +235,153 @@ class Hardware {
 	}
 };
 
-template <typename data_t, uint8_t Size>
+template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Mode mode>
-struct RingBuffer {
+class BlockingHardware {
-	uint8_t head;
+  public:
-	uint8_t tail;
+	using data_t = typename cfg::data_t;
-	data_t buf[Size];
+	static constexpr auto DATA_BITS = cfg::DATA_BITS;
+
+	static void init() FORCE_INLINE
+	{
+		HardwareImpl::init();
+	}
+
+	static void txByte(const data_t &byte) FORCE_INLINE
+	{
+		HardwareImpl::txByteBlocking(byte);
+	}
+
+	static bool rxByte(data_t &byte) FORCE_INLINE
+	{
+		return HardwareImpl::rxByteBlocking(byte);
+	}
+
+	static bool peek([[maybe_unused]] data_t &byte) FORCE_INLINE
+	{
+		static_assert(util::always_false_v<data_t>, "Peek with data is not supported in blocking mode");
+		return false;
+	}
+
+	static bool peek() FORCE_INLINE
+	{
+		return HardwareImpl::peekBlocking();
+	}
+
+	static void flushTx() FORCE_INLINE
+	{
+		while (!HardwareImpl::txEmpty())
+			;
+		while (!HardwareImpl::txComplete())
+			;
+		HardwareImpl::clearTxComplete();
+	}
+
+  private:
+	using HardwareImpl = Hardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, Driven::BLOCKING, mode>;
 };
 
+template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Mode mode>
+class InterruptHardware {
+  public:
+	using data_t = typename cfg::data_t;
+	static constexpr auto DATA_BITS = cfg::DATA_BITS;
+
+	static void txByte(const data_t &byte) FORCE_INLINE
+	{
+		uint8_t tmpHead = (sm_txBuf.head + 1) % TX_BUFFER_SIZE;
+		while (tmpHead == sm_txBuf.tail)
+			;
+
+		sm_txBuf.buf[tmpHead] = byte;
+		sm_txBuf.head = tmpHead;
+
+		HardwareImpl::enableDataRegEmptyInt();
+	}
+
+	static bool rxByte(data_t &byte) FORCE_INLINE
+	{
+		if (sm_rxBuf.head == sm_rxBuf.tail)
+			return false;
+
+		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
+		byte = sm_rxBuf.buf[tmpTail];
+		sm_rxBuf.tail = tmpTail;
+
+		return true;
+	}
+
+	static bool peek(data_t &byte) FORCE_INLINE
+	{
+		if (sm_rxBuf.head == sm_rxBuf.tail)
+			return false;
+
+		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
+		byte = sm_rxBuf.buf[tmpTail];
+
+		return true;
+	}
+
+	static bool peek() FORCE_INLINE
+	{
+		return (sm_rxBuf.head != sm_rxBuf.tail);
+	}
+
+	static void flushTx() FORCE_INLINE
+	{
+		while (sm_txBuf.head != sm_txBuf.tail)
+			;
+		while (!HardwareImpl::txEmpty())
+			;
+		while (!HardwareImpl::txComplete())
+			;
+		HardwareImpl::clearTxComplete();
+	}
+
+  protected:
+	static void rxIntHandler()
+	{
+		auto data = HardwareImpl::rxByteInterrupt();
+
+		uint8_t tmpHead = (sm_rxBuf.head + 1) % RX_BUFFER_SIZE;
+
+		if (tmpHead != sm_rxBuf.tail) {
+			sm_rxBuf.head = tmpHead;
+			sm_rxBuf.buf[tmpHead] = data;
+		} else {
+			// TODO: Handle overflow
+		}
+	}
+
+	static void dataRegEmptyIntHandler() FORCE_INLINE
+	{
+		if (sm_txBuf.head != sm_txBuf.tail) {
+			uint8_t tmpTail = (sm_txBuf.tail + 1) % TX_BUFFER_SIZE;
+			sm_txBuf.tail = tmpTail;
+			HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]);
+		} else
+			HardwareImpl::disableDataRegEmptyInt();
+	}
+
+  private:
+	using HardwareImpl = Hardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, Driven::INTERRUPT, mode>;
+
+	static constexpr auto TX_BUFFER_SIZE = 16;
+	static constexpr auto RX_BUFFER_SIZE = 16;
+
+	static volatile RingBuffer<data_t, TX_BUFFER_SIZE> sm_txBuf;
+	static volatile RingBuffer<data_t, RX_BUFFER_SIZE> sm_rxBuf;
+};
+
+template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Mode mode>
+volatile RingBuffer<typename InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::data_t,
+                    InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::TX_BUFFER_SIZE>
+    InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::sm_txBuf = {0, 0, {0}};
+
+template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Mode mode>
+volatile RingBuffer<typename InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::data_t,
+                    InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::RX_BUFFER_SIZE>
+    InterruptHardware<Registers, CtrlFlagsA, CtrlFlagsB, CtrlFlagsC, cfg, mode>::sm_rxBuf = {0, 0, {0}};
+
 } // namespace detail
 
 } // namespace uart

hardware0.hpp

@@ -89,58 +89,24 @@ extern void (*fnDataReg0EmptyIntHandler)();
 } // namespace detail
 
 template <class cfg = Config<>, Driven driven = Driven::INTERRUPT, Mode mode = Mode::ASYNCHRONOUS>
-class Hardware0 {
+class Hardware0 : public detail::BlockingHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
-  public:
+                                                  detail::ControlFlagsC0, cfg, mode> {
-	using data_t = typename cfg::data_t;
-	static constexpr auto DATA_BITS = cfg::DATA_BITS;
-
-	static void init() FORCE_INLINE
-	{
-		HardwareImpl::init();
-	}
-
-	static void txByte(data_t byte) FORCE_INLINE
-	{
-		HardwareImpl::txByteBlocking(byte);
-	}
-
-	static bool rxByte(data_t &byte) FORCE_INLINE
-	{
-		return HardwareImpl::rxByteBlocking(byte);
-	}
-
-	static bool peek(data_t &byte) FORCE_INLINE
-	{
-		static_cast<void>(byte);
-		static_assert(driven == Driven::BLOCKING, "Peek with data is not supported in blocking mode");
-		return false;
-	}
-
-	static bool peek() FORCE_INLINE
-	{
-		return HardwareImpl::peekBlocking();
-	}
-
-	static void flushTx() FORCE_INLINE
-	{
-		while (!HardwareImpl::txEmpty())
-			;
-		while (!HardwareImpl::txComplete())
-			;
-		HardwareImpl::clearTxComplete();
-	}
-
-  private:
-	using HardwareImpl = detail::Hardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
-	                                      detail::ControlFlagsC0, cfg, driven, mode>;
 };
 
 template <class cfg, Mode mode>
-class Hardware0<cfg, Driven::INTERRUPT, mode> {
+class Hardware0<cfg, Driven::INTERRUPT, mode>
-  public:
+    : public detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
-	using data_t = typename cfg::data_t;
+                                       detail::ControlFlagsC0, cfg, mode> {
-	static constexpr auto DATA_BITS = cfg::DATA_BITS;
+	using detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
+	                                detail::ControlFlagsC0, cfg, mode>::rxIntHandler;
 
+	using detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
+	                                detail::ControlFlagsC0, cfg, mode>::dataRegEmptyIntHandler;
+
+	using HardwareImpl = detail::Hardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
+	                                      detail::ControlFlagsC0, cfg, Driven::INTERRUPT, mode>;
+
+  public:
 	static void init() FORCE_INLINE
 	{
 		detail::fnRx0IntHandler = rxIntHandler;
@@ -149,103 +115,8 @@ class Hardware0<cfg, Driven::INTERRUPT, mode> {
 		HardwareImpl::init();
 		sei();
 	}
-
-	static void txByte(const data_t &byte) FORCE_INLINE
-	{
-		uint8_t tmpHead = (sm_txBuf.head + 1) % TX_BUFFER_SIZE;
-		while (tmpHead == sm_txBuf.tail)
-			;
-
-		sm_txBuf.buf[tmpHead] = byte;
-		sm_txBuf.head = tmpHead;
-
-		HardwareImpl::enableDataRegEmptyInt();
-	}
-
-	static bool rxByte(data_t &byte) FORCE_INLINE
-	{
-		if (sm_rxBuf.head == sm_rxBuf.tail)
-			return false;
-
-		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
-		byte = sm_rxBuf.buf[tmpTail];
-		sm_rxBuf.tail = tmpTail;
-
-		return true;
-	}
-
-	static bool peek(data_t &byte) FORCE_INLINE
-	{
-		if (sm_rxBuf.head == sm_rxBuf.tail)
-			return false;
-
-		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
-		byte = sm_rxBuf.buf[tmpTail];
-
-		return true;
-	}
-
-	static bool peek() FORCE_INLINE
-	{
-		return (sm_rxBuf.head != sm_rxBuf.tail);
-	}
-
-	static void flushTx() FORCE_INLINE
-	{
-		while (sm_txBuf.head != sm_txBuf.tail)
-			;
-		while (!HardwareImpl::txEmpty())
-			;
-		while (!HardwareImpl::txComplete())
-			;
-		HardwareImpl::clearTxComplete();
-	}
-
-  private:
-	using HardwareImpl = detail::Hardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
-	                                      detail::ControlFlagsC0, cfg, Driven::INTERRUPT, mode>;
-
-	static constexpr auto TX_BUFFER_SIZE = 16;
-	static constexpr auto RX_BUFFER_SIZE = 16;
-
-	static volatile detail::RingBuffer<data_t, TX_BUFFER_SIZE> sm_txBuf;
-	static volatile detail::RingBuffer<data_t, RX_BUFFER_SIZE> sm_rxBuf;
-
-	static void rxIntHandler()
-	{
-		auto data = HardwareImpl::rxByteInterrupt();
-
-		uint8_t tmpHead = (sm_rxBuf.head + 1) % RX_BUFFER_SIZE;
-
-		if (tmpHead != sm_rxBuf.tail) {
-			sm_rxBuf.head = tmpHead;
-			sm_rxBuf.buf[tmpHead] = data;
-		} else {
-			// TODO: Handle overflow
-		}
-	}
-
-	static void dataRegEmptyIntHandler() FORCE_INLINE
-	{
-		if (sm_txBuf.head != sm_txBuf.tail) {
-			uint8_t tmpTail = (sm_txBuf.tail + 1) % TX_BUFFER_SIZE;
-			sm_txBuf.tail = tmpTail;
-			HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]);
-		} else
-			HardwareImpl::disableDataRegEmptyInt();
-	}
 };
 
-template <class cfg, Mode mode>
-volatile detail::RingBuffer<typename Hardware0<cfg, Driven::INTERRUPT, mode>::data_t,
-                            Hardware0<cfg, Driven::INTERRUPT, mode>::TX_BUFFER_SIZE>
-    Hardware0<cfg, Driven::INTERRUPT, mode>::sm_txBuf = {0, 0, {0}};
-
-template <class cfg, Mode mode>
-volatile detail::RingBuffer<typename Hardware0<cfg, Driven::INTERRUPT, mode>::data_t,
-                            Hardware0<cfg, Driven::INTERRUPT, mode>::RX_BUFFER_SIZE>
-    Hardware0<cfg, Driven::INTERRUPT, mode>::sm_rxBuf = {0, 0, {0}};
-
 } // namespace uart
 
 #undef FORCE_INLINE

hardware1.hpp

@@ -91,58 +91,24 @@ extern void (*fnDataReg1EmptyIntHandler)();
 #ifdef HAS_UART1
 
 template <class cfg = Config<>, Driven driven = Driven::INTERRUPT, Mode mode = Mode::ASYNCHRONOUS>
-class Hardware1 {
+class Hardware1 : public detail::BlockingHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
-  public:
+                                                  detail::ControlFlagsC1, cfg, mode> {
-	using data_t = typename cfg::data_t;
-	static constexpr auto DATA_BITS = cfg::DATA_BITS;
-
-	static void init() FORCE_INLINE
-	{
-		HardwareImpl::init();
-	}
-
-	static void txByte(const data_t &byte) FORCE_INLINE
-	{
-		HardwareImpl::txByteBlocking(byte);
-	}
-
-	static bool rxByte(data_t &byte) FORCE_INLINE
-	{
-		return HardwareImpl::rxByteBlocking(byte);
-	}
-
-	static bool peek(data_t &byte) FORCE_INLINE
-	{
-		static_cast<void>(byte);
-		static_assert(driven != Driven::BLOCKING, "Peek with data is not supported in blocking mode");
-		return false;
-	}
-
-	static bool peek() FORCE_INLINE
-	{
-		return HardwareImpl::peekBlocking();
-	}
-
-	static void flushTx() FORCE_INLINE
-	{
-		while (!HardwareImpl::txEmpty())
-			;
-		while (!HardwareImpl::txComplete())
-			;
-		HardwareImpl::clearTxComplete();
-	}
-
-  private:
-	using HardwareImpl = detail::Hardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
-	                                      detail::ControlFlagsC1, cfg, driven, mode>;
 };
 
 template <class cfg, Mode mode>
-class Hardware1<cfg, Driven::INTERRUPT, mode> {
+class Hardware1<cfg, Driven::INTERRUPT, mode>
-  public:
+    : public detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
-	using data_t = typename cfg::data_t;
+                                       detail::ControlFlagsC1, cfg, mode> {
-	static constexpr auto DATA_BITS = cfg::DATA_BITS;
+	using detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
+	                                detail::ControlFlagsC1, cfg, mode>::rxIntHandler;
 
+	using detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
+	                                detail::ControlFlagsC1, cfg, mode>::dataRegEmptyIntHandler;
+
+	using HardwareImpl = detail::Hardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
+	                                      detail::ControlFlagsC1, cfg, Driven::INTERRUPT, mode>;
+
+  public:
 	static void init() FORCE_INLINE
 	{
 		detail::fnRx1IntHandler = rxIntHandler;
@@ -151,103 +117,8 @@ class Hardware1<cfg, Driven::INTERRUPT, mode> {
 		HardwareImpl::init();
 		sei();
 	}
-
-	static void txByte(const data_t &byte) FORCE_INLINE
-	{
-		uint8_t tmpHead = (sm_txBuf.head + 1) % TX_BUFFER_SIZE;
-		while (tmpHead == sm_txBuf.tail)
-			;
-
-		sm_txBuf.buf[tmpHead] = byte;
-		sm_txBuf.head = tmpHead;
-
-		HardwareImpl::enableDataRegEmptyInt();
-	}
-
-	static bool rxByte(data_t &byte) FORCE_INLINE
-	{
-		if (sm_rxBuf.head == sm_rxBuf.tail)
-			return false;
-
-		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
-		byte = sm_rxBuf.buf[tmpTail];
-		sm_rxBuf.tail = tmpTail;
-
-		return true;
-	}
-
-	static bool peek(data_t &byte) FORCE_INLINE
-	{
-		if (sm_rxBuf.head == sm_rxBuf.tail)
-			return false;
-
-		uint8_t tmpTail = (sm_rxBuf.tail + 1) % RX_BUFFER_SIZE;
-		byte = sm_rxBuf.buf[tmpTail];
-
-		return true;
-	}
-
-	static bool peek() FORCE_INLINE
-	{
-		return (sm_rxBuf.head != sm_rxBuf.tail);
-	}
-
-	static void flushTx() FORCE_INLINE
-	{
-		while (sm_txBuf.head != sm_txBuf.tail)
-			;
-		while (!HardwareImpl::txEmpty())
-			;
-		while (!HardwareImpl::txComplete())
-			;
-		HardwareImpl::clearTxComplete();
-	}
-
-  private:
-	using HardwareImpl = detail::Hardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
-	                                      detail::ControlFlagsC1, cfg, Driven::INTERRUPT, mode>;
-
-	static constexpr auto TX_BUFFER_SIZE = 16;
-	static constexpr auto RX_BUFFER_SIZE = 16;
-
-	static volatile detail::RingBuffer<data_t, TX_BUFFER_SIZE> sm_txBuf;
-	static volatile detail::RingBuffer<data_t, RX_BUFFER_SIZE> sm_rxBuf;
-
-	static void rxIntHandler()
-	{
-		auto data = HardwareImpl::rxByteInterrupt();
-
-		uint8_t tmpHead = (sm_rxBuf.head + 1) % RX_BUFFER_SIZE;
-
-		if (tmpHead != sm_rxBuf.tail) {
-			sm_rxBuf.head = tmpHead;
-			sm_rxBuf.buf[tmpHead] = data;
-		} else {
-			// TODO: Handle overflow
-		}
-	}
-
-	static void dataRegEmptyIntHandler() FORCE_INLINE
-	{
-		if (sm_txBuf.head != sm_txBuf.tail) {
-			uint8_t tmpTail = (sm_txBuf.tail + 1) % TX_BUFFER_SIZE;
-			sm_txBuf.tail = tmpTail;
-			HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]);
-		} else
-			HardwareImpl::disableDataRegEmptyInt();
-	}
 };
 
-template <class cfg, Mode mode>
-volatile detail::RingBuffer<typename Hardware1<cfg, Driven::INTERRUPT, mode>::data_t,
-                            Hardware1<cfg, Driven::INTERRUPT, mode>::TX_BUFFER_SIZE>
-    Hardware1<cfg, Driven::INTERRUPT, mode>::sm_txBuf = {0, 0, {0}};
-
-template <class cfg, Mode mode>
-volatile detail::RingBuffer<typename Hardware1<cfg, Driven::INTERRUPT, mode>::data_t,
-                            Hardware1<cfg, Driven::INTERRUPT, mode>::RX_BUFFER_SIZE>
-    Hardware1<cfg, Driven::INTERRUPT, mode>::sm_rxBuf = {0, 0, {0}};
-
 #endif
 
 } // namespace uart