Add automatic selection of double speed based on error

hardware.hpp

@@ -2,9 +2,10 @@
 
 #include "../clock.hpp"
 
-#include <stdint.h>
+#include "../type/type.hpp"
 
-#include "utils.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,24 +46,31 @@ 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");
 
-		*getRegPtr<Registers::BAUD_REG_H_ADDR>() = static_cast<uint8_t>(baudVal >> 8);
+		constexpr auto UseDoubleSpeed = (AbsDoubleError < AbsNormalError);
-		*getRegPtr<Registers::BAUD_REG_L_ADDR>() = static_cast<uint8_t>(baudVal);
+		constexpr auto BaudVal = calcBaudVal<UseDoubleSpeed>();
 
-		constexpr auto dataBitsVal = calcDataBits();
+		*getRegPtr<Registers::BAUD_REG_H_ADDR>() = static_cast<uint8_t>(BaudVal >> 8);
-		constexpr auto parityVal = calcParity();
+		*getRegPtr<Registers::BAUD_REG_L_ADDR>() = static_cast<uint8_t>(BaudVal);
-		constexpr auto stopBitsVal = calcStopBits();
-		constexpr auto modeVal = calcMode();
-		constexpr auto enableRx = calcRxState<true>();
-		constexpr auto enableTx = calcTxState<true>();
-		constexpr auto interruptVal = calcInterrupt();
 
-		constexpr uint8_t controlRegB = dataBitsVal.regBVal | enableRx | enableTx | interruptVal;
+		constexpr auto DataBitsValues = calcDataBits();
-		constexpr uint8_t controlRegC = dataBitsVal.regCVal | parityVal | stopBitsVal | modeVal;
+		constexpr auto ParityVal = calcParity();
+		constexpr auto StopBitsVal = calcStopBits();
+		constexpr auto ModeVal = calcMode();
+		constexpr auto EnableRx = calcRxState<true>();
+		constexpr auto EnableTx = calcTxState<true>();
+		constexpr auto InterruptVal = calcInterrupt();
+		constexpr auto DoubleSpeedVal = calcDoubleSpeedVal<UseDoubleSpeed>();
 
-		*getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() = controlRegB;
+		constexpr uint8_t ControlRegB = DataBitsValues.regBVal | EnableRx | EnableTx | InterruptVal;
-		*getRegPtr<Registers::CTRL_STAT_REG_C_ADDR>() = controlRegC;
+		constexpr uint8_t ControlRegC = DataBitsValues.regCVal | ParityVal | StopBitsVal | ModeVal;
+
+		*getRegPtr<Registers::CTRL_STAT_REG_A_ADDR>() |= DoubleSpeedVal;
+		*getRegPtr<Registers::CTRL_STAT_REG_B_ADDR>() = ControlRegB;
+		*getRegPtr<Registers::CTRL_STAT_REG_C_ADDR>() = ControlRegC;
 	}
 
 	static bool rxByteBlocking(typename cfg::data_t &byte) FORCE_INLINE
@@ -134,11 +141,37 @@ 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;
+			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()
@@ -202,23 +235,23 @@ class Hardware {
 		return modeVal;
 	}
 
-	template <bool enable>
+	template <bool Enable>
 	static constexpr auto calcRxState()
 	{
 		uint8_t enableVal = 0;
 
-		if (enable)
+		if (Enable)
 			enableVal = (1 << CtrlFlagsB::RX_ENABLE);
 
 		return enableVal;
 	}
 
-	template <bool enable>
+	template <bool Enable>
 	static constexpr auto calcTxState()
 	{
 		uint8_t enableVal = 0;
 
-		if (enable)
+		if (Enable)
 			enableVal = (1 << CtrlFlagsB::TX_ENABLE);
 
 		return enableVal;
@@ -233,6 +266,17 @@ class Hardware {
 
 		return interruptVal;
 	}
+
+	template <bool DoubleSpeed>
+	static constexpr auto calcDoubleSpeedVal()
+	{
+		uint8_t doubleSpeedVal = 0;
+
+		if constexpr (DoubleSpeed)
+			doubleSpeedVal = (1 << CtrlFlagsA::SPEED_2X);
+
+		return doubleSpeedVal;
+	}
 };
 
 template <class Registers, typename CtrlFlagsA, typename CtrlFlagsB, typename CtrlFlagsC, class cfg, Mode mode>
@@ -258,7 +302,7 @@ class BlockingHardware {
 
 	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;
 	}
 

software.hpp

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

uart.hpp

@@ -4,7 +4,6 @@
 
 #include "config.hpp"
 #include "software.hpp"
-#include "utils.hpp"
 
 #undef UART0_INT_VECTORS
 #include "hardware0.hpp"
@@ -19,10 +18,10 @@ namespace uart {
 
 namespace detail {
 
-template <typename T, T limit, size_t Base>
+template <typename T, T Limit, size_t Base>
 static constexpr size_t cntDigits()
 {
-	T num = limit;
+	T num = Limit;
 	size_t cnt = 0;
 
 	do {
@@ -36,13 +35,13 @@ static constexpr size_t cntDigits()
 template <typename T, size_t Base>
 static constexpr size_t maxNumDigits()
 {
-	constexpr T minVal = util::NumericLimits<T>::min();
+	constexpr T MinVal = type::numeric_limits<T>::min();
-	constexpr T maxVal = util::NumericLimits<T>::max();
+	constexpr T MaxVal = type::numeric_limits<T>::max();
 
-	T minDigits = cntDigits<T, minVal, Base>();
+	constexpr T MinDigits = cntDigits<T, MinVal, Base>();
-	T maxDigits = cntDigits<T, maxVal, Base>();
+	constexpr T MaxDigits = cntDigits<T, MaxVal, Base>();
 
-	return (minDigits < maxDigits) ? maxDigits : minDigits;
+	return (MinDigits < MaxDigits) ? MaxDigits : MinDigits;
 }
 
 } // namespace detail
@@ -115,16 +114,13 @@ class Uart {
 	template <typename T, size_t Base = 10, size_t Padding = 0, char PadChar = '0', bool LowerCase = true>
 	static void txNumber(const T &val)
 	{
-		static_assert(util::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 <= 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");
 
-		constexpr char alphaChar = (LowerCase) ? 'a' : 'A';
+		constexpr char AlphaChar = (LowerCase) ? 'a' : 'A';
-		constexpr size_t numDigits = detail::maxNumDigits<T, Base>();
+		constexpr size_t NumDigits = detail::maxNumDigits<T, Base>();
-
-		data_t buffer[numDigits];
-		data_t *bufEnd = buffer + numDigits - 1;
 
 		T digits = val;
 
@@ -133,14 +129,17 @@ class Uart {
 			txByte('-');
 		}
 
+		data_t buffer[NumDigits];
+		data_t *bufEnd = buffer + NumDigits - 1;
+
 		do {
-			data_t lastDigit = digits % Base;
+			const data_t lastDigit = digits % Base;
-			*bufEnd-- = (lastDigit < 10) ? ('0' + lastDigit) : (alphaChar + lastDigit - 10);
+			*bufEnd-- = (lastDigit < 10) ? ('0' + lastDigit) : (AlphaChar + lastDigit - 10);
 			digits /= Base;
 		} while (digits > 0);
 
 		if (Padding > 0) {
-			size_t strLen = buffer + numDigits - (bufEnd + 1);
+			size_t strLen = buffer + NumDigits - (bufEnd + 1);
 
 			if (Padding > strLen) {
 				for (size_t i = Padding; i > strLen && bufEnd >= buffer; --i) {
@@ -149,7 +148,7 @@ class Uart {
 			}
 		}
 
-		for (data_t *buf = bufEnd + 1; buf < buffer + numDigits; ++buf)
+		for (data_t *buf = bufEnd + 1; buf < buffer + NumDigits; ++buf)
 			txByte(*buf);
 	}
 
@@ -192,7 +191,7 @@ class Uart {
 		return *this;
 	}
 
-	Uart &operator<<(unsigned short &val)
+	Uart &operator<<(const unsigned short &val)
 	{
 		txNumber(val);
 		return *this;
@@ -216,19 +215,19 @@ class Uart {
 		return *this;
 	}
 
-	Uart &operator<<(unsigned long &val)
+	Uart &operator<<(const unsigned long &val)
 	{
 		txNumber(val);
 		return *this;
 	}
 
-	Uart &operator<<(long long &val)
+	Uart &operator<<(const long long &val)
 	{
 		txNumber(val);
 		return *this;
 	}
 
-	Uart &operator<<(unsigned long long &val)
+	Uart &operator<<(const unsigned long long &val)
 	{
 		txNumber(val);
 		return *this;
@@ -237,19 +236,19 @@ class Uart {
 	template <typename... Ts>
 	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>
 	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>
 	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)
@@ -271,91 +270,91 @@ class Uart {
 	template <typename... Ts>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	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>
 	Uart &operator>>(const void *&) const
 	{
-		static_assert(util::always_false_v<Ts...>, "Not implemented");
+		static_assert(type::always_false_v<Ts...>, "Not implemented");
 	}
 };
 

utils.hpp

@@ -1,143 +0,0 @@
-#pragma once
-
-// Fix for limits.h not exposing LLONG_MIN, LLONG_MIN, and ULLONG_MAX to C++ context
-#ifdef __cplusplus
-#define __STDC_VERSION__ 201112L
-#endif
-
-#include <float.h>
-#include <limits.h>
-
-namespace uart {
-namespace util {
-
-// clang-format off
-template <bool Val> struct set_bool { static constexpr auto value = Val; };
-
-struct true_type : set_bool<true> {};
-struct false_type : set_bool<false> {};
-
-template <typename...> struct always_false : false_type {};
-
-template <typename... Ts> static constexpr auto always_false_v = always_false<Ts...>::value;
-
-template <typename T> struct is_integral : false_type {};
-template <> struct is_integral<bool> : true_type {};
-template <> struct is_integral<char> : true_type {};
-template <> struct is_integral<signed char> : true_type {};
-template <> struct is_integral<unsigned char> : true_type {};
-template <> struct is_integral<short> : true_type {};
-template <> struct is_integral<int> : true_type {};
-template <> struct is_integral<long int> : true_type {};
-template <> struct is_integral<long long int> : true_type {};
-template <> struct is_integral<unsigned short> : true_type {};
-template <> struct is_integral<unsigned int> : true_type {};
-template <> struct is_integral<unsigned long int> : true_type {};
-template <> struct is_integral<unsigned long long int> : true_type {};
-
-template <typename T> static constexpr auto is_integral_v = is_integral<T>::value;
-
-template <typename T, typename U> struct is_same : false_type {};
-template <typename T> struct is_same<T, T> : true_type {};
-
-template <typename T, typename U> static constexpr auto is_same_v = is_same<T, U>::value;
-
-template <typename T>
-struct NumericLimits {
-	static constexpr T min() { return T(); }
-	static constexpr T max() { return T(); }
-};
-
-template <>
-struct NumericLimits<bool> {
-	static constexpr bool min() { return false; }
-	static constexpr bool max() { return true; }
-};
-
-template <>
-struct NumericLimits<char> {
-	static constexpr char min() { return CHAR_MIN; }
-	static constexpr char max() { return CHAR_MAX; }
-};
-
-template <>
-struct NumericLimits<signed char> {
-	static constexpr signed char min() { return SCHAR_MIN; }
-	static constexpr signed char max() { return SCHAR_MAX; }
-};
-
-template <>
-struct NumericLimits<unsigned char> {
-	static constexpr unsigned char min() { return 0; }
-	static constexpr unsigned char max() { return UCHAR_MAX; }
-};
-
-template <>
-struct NumericLimits<short> {
-	static constexpr short min() { return SHRT_MIN; }
-	static constexpr short max() { return SHRT_MAX; }
-};
-
-template <>
-struct NumericLimits<int> {
-	static constexpr int min() { return INT_MIN; }
-	static constexpr int max() { return INT_MAX; }
-};
-
-template <>
-struct NumericLimits<long> {
-	static constexpr long int min() { return LONG_MIN; }
-	static constexpr long int max() { return LONG_MAX; }
-};
-
-template <>
-struct NumericLimits<long long int> {
-	static constexpr long long int min() { return LLONG_MIN; }
-	static constexpr long long int max() { return LLONG_MAX; }
-};
-
-template <>
-struct NumericLimits<unsigned short> {
-	static constexpr unsigned short min() { return 0; }
-	static constexpr unsigned short max() { return USHRT_MAX; }
-};
-
-template <>
-struct NumericLimits<unsigned int> {
-	static constexpr unsigned int min() { return 0; }
-	static constexpr unsigned int max() { return UINT_MAX; }
-};
-
-template <>
-struct NumericLimits<unsigned long int> {
-	static constexpr unsigned long int min() { return 0; }
-	static constexpr unsigned long int max() { return ULONG_MAX; }
-};
-
-template <>
-struct NumericLimits<unsigned long long int> {
-	static constexpr unsigned long long int min() { return 0; }
-	static constexpr unsigned long long int max() { return ULLONG_MAX; }
-};
-
-template <>
-struct NumericLimits<float> {
-	template <typename... Ts> static constexpr float min() { return FLT_MIN; }
-	template <typename... Ts> static constexpr float max() { return FLT_MAX; }
-};
-
-template <>
-struct NumericLimits<double> {
-	template <typename... Ts> static constexpr double min() { return DBL_MIN; }
-	template <typename... Ts> static constexpr double max() { return DBL_MAX; }
-};
-
-template <>
-struct NumericLimits<long double> {
-	template <typename... Ts> static constexpr long double min() { return LDBL_MIN; }
-	template <typename... Ts> static constexpr long double max() { return LDBL_MAX; }
-};
-// clang-format on
-
-} // namespace util
-} // namespace uart