Fix misaligned ifdef-endif pair

hardware.hpp

@@ -4,6 +4,7 @@
 
 #include "../type/type.hpp"
 
+#include <math.h>
 #include <stdint.h>
 
 #define FORCE_INLINE __attribute__((always_inline))
@@ -12,7 +13,6 @@ namespace uart {
 
 enum class Mode {
 	ASYNCHRONOUS,
-	ASYNCHRONOUS_2X,
 	SYNCHRONOUS_MASTER,
 	SYNCHRONOUS_SLAVE,
 	SPI,
@@ -46,7 +46,12 @@ class Hardware {
   public:
 	static void init() FORCE_INLINE
 	{
-		constexpr auto BaudVal = calcBaud();
+		constexpr auto AbsDoubleError = fabs(calcBaudError<true>());
+		constexpr auto AbsNormalError = fabs(calcBaudError<false>());
+		static_assert(AbsDoubleError <= 3.0 || AbsNormalError <= 3.0, "Baud rate error over 3%, probably unusable");
+
+		constexpr auto UseDoubleSpeed = (AbsDoubleError < AbsNormalError);
+		constexpr auto BaudVal = calcBaudVal<UseDoubleSpeed>();
 
 		*getRegPtr<Registers::BAUD_REG_H_ADDR>() = static_cast<uint8_t>(BaudVal >> 8);
 		*getRegPtr<Registers::BAUD_REG_L_ADDR>() = static_cast<uint8_t>(BaudVal);
@@ -62,6 +67,11 @@ class Hardware {
 		constexpr uint8_t ControlRegB = DataBitsValues.regBVal | EnableRx | EnableTx | InterruptVal;
 		constexpr uint8_t ControlRegC = DataBitsValues.regCVal | ParityVal | StopBitsVal | ModeVal;
 
+		if constexpr (UseDoubleSpeed)
+			*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() |= (1 << CtrlFlagsA::SPEED_2X);
+		else
+			*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() &= ~(1 << CtrlFlagsA::SPEED_2X);
+
 		*getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() = ControlRegB;
 		*getRegPtr<Registers::CTRL_STAT_REG_C_ADDR>() = ControlRegC;
 	}
@@ -134,13 +144,39 @@ class Hardware {
 		uint8_t regBVal = 0;
 	};
 
-	static constexpr auto calcBaud()
+	template <bool DoubleSpeed = true>
+	static constexpr auto calcBaudVal()
 	{
-		// The actual formula is (F_CPU / (16 * baudRate)) - 1, but this one has the advantage of rounding correctly
+		if constexpr (DoubleSpeed) {
-		constexpr auto BaudVal = (F_CPU + 8 * cfg::BAUD_RATE) / (16 * cfg::BAUD_RATE) - 1;
+			constexpr auto BaudVal = static_cast<uint16_t>(round(F_CPU / (8.0 * cfg::BAUD_RATE) - 1));
 			return BaudVal;
 		}
 
+		constexpr auto BaudVal = static_cast<uint16_t>(round(F_CPU / (16.0 * cfg::BAUD_RATE) - 1));
+		return BaudVal;
+	}
+
+	template <uint16_t BaudVal, bool DoubleSpeed = true>
+	static constexpr auto calcBaudRate()
+	{
+		if constexpr (DoubleSpeed) {
+			constexpr auto BaudRate = static_cast<uint32_t>(round(F_CPU / (8.0 * (BaudVal + 1))));
+			return BaudRate;
+		}
+
+		constexpr auto BaudRate = static_cast<uint32_t>(round(F_CPU / (16.0 * (BaudVal + 1))));
+		return BaudRate;
+	}
+
+	template <bool DoubleSpeed = true>
+	static constexpr auto calcBaudError()
+	{
+		constexpr auto BaudVal = calcBaudVal<DoubleSpeed>();
+		constexpr auto ClosestBaudRate = calcBaudRate<BaudVal, DoubleSpeed>();
+		constexpr auto BaudError = (static_cast<double>(ClosestBaudRate) / cfg::BAUD_RATE - 1) * 100;
+		return BaudError;
+	}
+
 	static constexpr auto calcDataBits()
 	{
 		DataBitsVal dataBitsVal;
@@ -340,9 +376,9 @@ class InterruptHardware {
   protected:
 	static void rxIntHandler() FORCE_INLINE
 	{
-		auto data = HardwareImpl::rxByteInterrupt();
+		const auto data = HardwareImpl::rxByteInterrupt();
 
-		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) {
 			sm_rxBuf.head = tmpHead;
@@ -355,7 +391,7 @@ class InterruptHardware {
 	static void dataRegEmptyIntHandler() FORCE_INLINE
 	{
 		if (sm_txBuf.head != sm_txBuf.tail) {
-			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;
 			HardwareImpl::txByteInterrupt(sm_txBuf.buf[tmpTail]);
 		} else

hardware0.hpp

@@ -1,5 +1,4 @@
-#ifndef UART_HARDWARE_0_HPP
+#pragma once
-#define UART_HARDWARE_0_HPP
 
 #include <stdint.h>
 
@@ -82,8 +81,10 @@ constexpr int operator<<(const int &lhs, const ControlFlagsB0 &rhs) { return lhs
 constexpr int operator<<(const int &lhs, const ControlFlagsC0 &rhs) { return lhs << static_cast<int>(rhs); }
 // clang-format on
 
-extern void (*fnRx0IntHandler)();
+#if defined(__AVR_ATmega328P__)
-extern void (*fnDataReg0EmptyIntHandler)();
+#define USART0_RX_vect USART_RX_vect
+#define USART0_UDRE_vect USART_UDRE_vect
+#endif
 
 #else
 #error "This chip is not supported"
@@ -100,70 +101,56 @@ template <class cfg, Mode mode>
 class Hardware0<cfg, Driven::INTERRUPT, mode>
     : public detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
                                        detail::ControlFlagsC0, cfg, mode> {
-	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;
-		detail::fnDataReg0EmptyIntHandler = dataRegEmptyIntHandler;
-
 		HardwareImpl::init();
 		sei();
 	}
+
+  private:
+	using HardwareImpl = detail::Hardware<detail::Registers0, detail::ControlFlagsA0, detail::ControlFlagsB0,
+	                                      detail::ControlFlagsC0, cfg, Driven::INTERRUPT, mode>;
+
+	using InterruptHardwareImpl = detail::InterruptHardware<detail::Registers0, detail::ControlFlagsA0,
+	                                                        detail::ControlFlagsB0, detail::ControlFlagsC0, cfg, mode>;
+
+	// Must be friends with Uart interface to call these private handlers
+	template <class Driver>
+	friend class Uart;
+
+	static void rxIntHandler() FORCE_INLINE
+	{
+		InterruptHardwareImpl::rxIntHandler();
+	}
+
+	static void dataRegEmptyIntHandler() FORCE_INLINE
+	{
+		InterruptHardwareImpl::dataRegEmptyIntHandler();
+	}
 };
 
 } // namespace uart
 
-#undef FORCE_INLINE
-
-#endif
-
 //////////////////////////////////////////////////////////////////////////
 
-#ifdef UART0_INT_VECTORS
+// Forward declare interrupt functions to allow adding them as friends
-
+extern "C" {
-#include <avr/interrupt.h>
+void USART0_RX_vect() __attribute__((signal));
-
+void USART0_UDRE_vect() __attribute__((signal));
-namespace uart {
-namespace detail {
-
-#if defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega328P__)
-
-#if defined(__AVR_ATmega328P__)
-#define USART0_RX_vect USART_RX_vect
-#define USART0_UDRE_vect USART_UDRE_vect
-#endif
-
-void (*fnRx0IntHandler)() = nullptr;
-void (*fnDataReg0EmptyIntHandler)() = nullptr;
-
-ISR(USART0_RX_vect)
-{
-	if (fnRx0IntHandler)
-		fnRx0IntHandler();
 }
 
-ISR(USART0_UDRE_vect)
+// clang-format off
-{
+#define REGISTER_UART0_INT_VECTORS(uart_type) \
-	if (fnDataReg0EmptyIntHandler)
+	ISR(USART0_RX_vect)                       \
-		fnDataReg0EmptyIntHandler();
+	{                                         \
-}
+		uart_type::rxIntHandler();            \
+	}                                         \
+	ISR(USART0_UDRE_vect)                     \
+	{                                         \
+		uart_type::dataRegEmptyIntHandler();  \
+	}                                         \
+	struct _##uart_type {}
+// clang-format on
 
-#else
+#undef FORCE_INLINE
-#error "This chip is not supported"
-#endif
-
-} // namespace detail
-} // namespace uart
-
-#undef UART0_INT_VECTORS
-
-#endif

hardware1.hpp

@@ -1,5 +1,4 @@
-#ifndef UART_HARDWARE_1_HPP
+#pragma once
-#define UART_HARDWARE_1_HPP
 
 #include <stdint.h>
 
@@ -82,9 +81,6 @@ constexpr int operator<<(const int &lhs, const ControlFlagsB1 &rhs) { return lhs
 constexpr int operator<<(const int &lhs, const ControlFlagsC1 &rhs) { return lhs << static_cast<int>(rhs); }
 // clang-format on
 
-extern void (*fnRx1IntHandler)();
-extern void (*fnDataReg1EmptyIntHandler)();
-
 #define HAS_UART1
 
 #endif
@@ -102,65 +98,63 @@ template <class cfg, Mode mode>
 class Hardware1<cfg, Driven::INTERRUPT, mode>
     : public detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
                                        detail::ControlFlagsC1, cfg, mode> {
-	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;
-		detail::fnDataReg1EmptyIntHandler = dataRegEmptyIntHandler;
-
 		HardwareImpl::init();
 		sei();
 	}
+
+  private:
+	using HardwareImpl = detail::Hardware<detail::Registers1, detail::ControlFlagsA1, detail::ControlFlagsB1,
+	                                      detail::ControlFlagsC1, cfg, Driven::INTERRUPT, mode>;
+
+	using InterruptHardwareImpl = detail::InterruptHardware<detail::Registers1, detail::ControlFlagsA1,
+	                                                        detail::ControlFlagsB1, detail::ControlFlagsC1, cfg, mode>;
+
+	// Must be friends with Uart interface to call these private handlers
+	template <class Driver>
+	friend class Uart;
+
+	static void rxIntHandler() FORCE_INLINE
+	{
+		InterruptHardwareImpl::rxIntHandler();
+	}
+
+	static void dataRegEmptyIntHandler() FORCE_INLINE
+	{
+		InterruptHardwareImpl::dataRegEmptyIntHandler();
+	}
 };
 
 #endif
 
 } // namespace uart
 
-#undef FORCE_INLINE
-
-#endif
-
 //////////////////////////////////////////////////////////////////////////
 
-#ifdef UART1_INT_VECTORS
+#ifdef HAS_UART1
 
-#include <avr/interrupt.h>
+// Forward declare interrupt functions to allow adding them as friends
-
+extern "C" {
-namespace uart {
+void USART1_RX_vect() __attribute__((signal));
-namespace detail {
+void USART1_UDRE_vect() __attribute__((signal));
-
-#if defined(__AVR_ATmega1284P__)
-
-void (*fnRx1IntHandler)() = nullptr;
-void (*fnDataReg1EmptyIntHandler)() = nullptr;
-
-ISR(USART1_RX_vect)
-{
-	if (fnRx1IntHandler)
-		fnRx1IntHandler();
 }
 
-ISR(USART1_UDRE_vect)
+// clang-format off
-{
+#define REGISTER_UART1_INT_VECTORS(uart_type) \
-	if (fnDataReg1EmptyIntHandler)
+	ISR(USART1_RX_vect)                       \
-		fnDataReg1EmptyIntHandler();
+	{                                         \
-}
+		uart_type::rxIntHandler();            \
+	}                                         \
+	ISR(USART1_UDRE_vect)                     \
+	{                                         \
+		uart_type::dataRegEmptyIntHandler();  \
+	}                                         \
+	struct _##uart_type {                     \
+	}
+// clang-format off
 
 #endif
 
-} // namespace detail
+#undef FORCE_INLINE
-} // namespace uart
-
-#undef UART1_INT_VECTORS
-
-#endif

uart.hpp

@@ -5,9 +5,7 @@
 #include "config.hpp"
 #include "software.hpp"
 
-#undef UART0_INT_VECTORS
 #include "hardware0.hpp"
-#undef UART1_INT_VECTORS
 #include "hardware1.hpp"
 
 #include "../flash/flash.hpp"
@@ -356,6 +354,25 @@ class Uart {
 	{
 		static_assert(type::always_false_v<Ts...>, "Not implemented");
 	}
+
+  private:
+	friend void ::USART0_RX_vect();
+	friend void ::USART0_UDRE_vect();
+
+#ifdef HAS_UART1
+	friend void ::USART1_RX_vect();
+	friend void ::USART1_UDRE_vect();
+#endif
+
+	static void rxIntHandler() FORCE_INLINE
+	{
+		Driver::rxIntHandler();
+	}
+
+	static void dataRegEmptyIntHandler() FORCE_INLINE
+	{
+		Driver::dataRegEmptyIntHandler();
+	}
 };
 
 template <typename cfg = Config<>>