uart/uart.hpp

#pragma once

#include <stdint.h>

#include "config.hpp"
#include "software.hpp"
#include "utils.hpp"

#undef UART0_INT_VECTORS
#include "hardware0.hpp"
#undef UART1_INT_VECTORS
#include "hardware1.hpp"

#include "../flash/flash.hpp"

#define FORCE_INLINE __attribute__((always_inline))

namespace uart {

namespace detail {

template <typename T, T Limit, size_t Base>
static constexpr size_t cntDigits()
{
	T num = Limit;
	size_t cnt = 0;

	do {
		num /= Base;
		++cnt;
	} while (num > 0);

	return cnt;
}

template <typename T, size_t Base>
static constexpr size_t maxNumDigits()
{
	constexpr T minVal = util::NumericLimits<T>::min();
	constexpr T maxVal = util::NumericLimits<T>::max();

	constexpr T minDigits = cntDigits<T, MinVal, Base>();
	constexpr T maxDigits = cntDigits<T, MaxVal, Base>();

	return (minDigits < maxDigits) ? maxDigits : minDigits;
}

} // namespace detail

template <class Driver>
class Uart {
  public:
	using data_t = typename Driver::data_t;

	// Constructing a uart object does not initialize the driver to allow different specializations with the same
	// back-end to exists at the same time
	// Note that init must be called every time when switching specializations with the same back-end
	Uart() = default;

	// Moving and copying uart objects is not supported
	Uart(const Uart &) = delete;
	Uart(Uart &&) = delete;
	Uart &operator=(const Uart &) = delete;
	Uart &operator=(Uart &&) = delete;

	// Before using the uart init must be called
	static void init()
	{
		Driver::init();
	}

	static void txByte(const data_t &byte)
	{
		Driver::txByte(byte);
	}

	static bool rxByte(data_t &byte)
	{
		return Driver::rxByte(byte);
	}

	static bool peek(data_t &byte)
	{
		return Driver::peek(byte);
	}

	static bool peek()
	{
		return Driver::peek();
	}

	static void flushTx()
	{
		Driver::flushTx();
	}

	static void txString(const char *str)
	{
		static_assert(Driver::DATA_BITS == DataBits::EIGHT, "Strings are only supported with 8 data bits");

		while (char ch = *str++)
			txByte(ch);
	}

	static void txString(const ::detail::FlashString *str)
	{
		static_assert(Driver::DATA_BITS == DataBits::EIGHT, "Strings are only supported with 8 data bits");

		const char *strIt = reinterpret_cast<const char *>(str);

		while (char ch = pgm_read_byte(strIt++))
			txByte(ch);
	}

	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(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 size_t numDigits = detail::maxNumDigits<T, Base>();

		data_t buffer[numDigits];
		data_t *bufEnd = buffer + numDigits - 1;

		T digits = val;

		if (digits < 0) {
			digits = -digits;
			txByte('-');
		}

		do {
			data_t lastDigit = digits % Base;
			*bufEnd-- = (lastDigit < 10) ? ('0' + lastDigit) : (alphaChar + lastDigit - 10);
			digits /= Base;
		} while (digits > 0);

		if (Padding > 0) {
			size_t strLen = buffer + numDigits - (bufEnd + 1);

			if (Padding > strLen) {
				for (size_t i = Padding; i > strLen && bufEnd >= buffer; --i) {
					*bufEnd-- = PadChar;
				}
			}
		}

		for (data_t *buf = bufEnd + 1; buf < buffer + numDigits; ++buf)
			txByte(*buf);
	}

	//////////////////////////////////////////////////////////////////////////
	// Output stream overloads

	Uart &operator<<(const char *str)
	{
		txString(str);
		return *this;
	}

	Uart &operator<<(const ::detail::FlashString *str)
	{
		txString(str);
		return *this;
	}

	Uart &operator<<(const char &val)
	{
		txByte(val);
		return *this;
	}

	Uart &operator<<(const signed char &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(const unsigned char &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(const short &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(unsigned short &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(const int &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(const unsigned int &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(const long &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(unsigned long &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(long long &val)
	{
		txNumber(val);
		return *this;
	}

	Uart &operator<<(unsigned long long &val)
	{
		txNumber(val);
		return *this;
	}

	template <typename... Ts>
	Uart &operator<<(float) const
	{
		static_assert(util::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");
	}

	template <typename... Ts>
	Uart &operator<<(long double) const
	{
		static_assert(util::always_false_v<Ts...>, "Not supported by hardware");
	}

	Uart &operator<<(const bool &val)
	{
		txString(val ? F("true") : F("false"));
		return *this;
	}

	Uart &operator<<(const void *val)
	{
		txString(F("0x"));
		txNumber<uint16_t, 16, 4, '0', false>(reinterpret_cast<uint16_t>(val));
		return *this;
	}

	//////////////////////////////////////////////////////////////////////////
	// Input stream overloads

	template <typename... Ts>
	Uart &operator>>(char &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(unsigned char &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(short &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(unsigned short &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(int &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(unsigned int &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(long &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(unsigned long &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(long long &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(unsigned long long &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(float &) const
	{
		static_assert(util::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");
	}

	template <typename... Ts>
	Uart &operator>>(long double &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not supported by hardware");
	}

	template <typename... Ts>
	Uart &operator>>(bool &) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}

	template <typename... Ts>
	Uart &operator>>(const void *&) const
	{
		static_assert(util::always_false_v<Ts...>, "Not implemented");
	}
};

template <typename cfg = Config<>>
using Uart0 = Uart<Hardware0<cfg, Driven::INTERRUPT, Mode::ASYNCHRONOUS>>;

#ifdef HAS_UART1
template <typename cfg = Config<>>
using Uart1 = Uart<Hardware1<cfg, Driven::INTERRUPT, Mode::ASYNCHRONOUS>>;
#endif

} // namespace uart

#undef FORCE_INLINE
#undef HAS_UART1