344 lines
7.3 KiB
C++
344 lines
7.3 KiB
C++
#pragma once
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "config.hpp"
|
|
#include "hardware0.hpp"
|
|
#include "hardware1.hpp"
|
|
#include "software.hpp"
|
|
#include "utils.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;
|
|
|
|
if (num < 0) {
|
|
num = -num;
|
|
++cnt;
|
|
}
|
|
|
|
do {
|
|
num /= 10;
|
|
++cnt;
|
|
} while (num > 0);
|
|
|
|
return cnt;
|
|
}
|
|
|
|
template <typename T, size_t Base>
|
|
static constexpr size_t maxNumDigits()
|
|
{
|
|
T minDigits = cntDigits<T, util::NumericLimits<T>::min(), Base>();
|
|
T maxDigits = cntDigits<T, util::NumericLimits<T>::max(), Base>();
|
|
|
|
return (minDigits < maxDigits) ? maxDigits : minDigits;
|
|
}
|
|
|
|
} // namespace detail
|
|
|
|
template <class Driver>
|
|
class Uart {
|
|
public:
|
|
// 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 typename Driver::data_t &byte)
|
|
{
|
|
Driver::txByte(byte);
|
|
}
|
|
|
|
static bool rxByte(typename Driver::data_t &byte)
|
|
{
|
|
return Driver::rxByte(byte);
|
|
}
|
|
|
|
static bool peek(typename Driver::data_t &byte)
|
|
{
|
|
return Driver::peek(byte);
|
|
}
|
|
|
|
static bool peek()
|
|
{
|
|
return Driver::peek();
|
|
}
|
|
|
|
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>
|
|
static inline void txNumber(const T &val)
|
|
{
|
|
// static_assert(util::is_integral_v<T>, "Only supported on integral types");
|
|
|
|
constexpr size_t numDigits = detail::maxNumDigits<T, Base>();
|
|
typename Driver::data_t buffer[numDigits];
|
|
typename Driver::data_t *bufEnd = buffer + numDigits - 1;
|
|
|
|
T digits = val;
|
|
|
|
if (digits < 0) {
|
|
digits = -digits;
|
|
txByte('-');
|
|
}
|
|
|
|
do {
|
|
typename Driver::data_t lastDigit = digits % Base;
|
|
*bufEnd-- = '0' + lastDigit;
|
|
digits /= Base;
|
|
} while (digits > 0);
|
|
|
|
for (typename Driver::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;
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
Uart &operator<<(const int &val)
|
|
{
|
|
txNumber(val);
|
|
return *this;
|
|
}
|
|
|
|
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 implemented");
|
|
}
|
|
|
|
template <typename... Ts>
|
|
Uart &operator<<(double) const
|
|
{
|
|
static_assert(util::always_false_v<Ts...>, "Not implemented");
|
|
}
|
|
|
|
template <typename... Ts>
|
|
Uart &operator<<(long double) const
|
|
{
|
|
static_assert(util::always_false_v<Ts...>, "Not implemented");
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// 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 implemented");
|
|
}
|
|
|
|
template <typename... Ts>
|
|
Uart &operator>>(double &) const
|
|
{
|
|
static_assert(util::always_false_v<Ts...>, "Not implemented");
|
|
}
|
|
|
|
template <typename... Ts>
|
|
Uart &operator>>(long double &) const
|
|
{
|
|
static_assert(util::always_false_v<Ts...>, "Not implemented");
|
|
}
|
|
|
|
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<Mode::ASYNCHRONOUS, cfg>>;
|
|
|
|
#ifdef HAS_UART1
|
|
template <typename cfg = Config<>>
|
|
using Uart1 = Uart<Hardware1<Mode::ASYNCHRONOUS, cfg>>;
|
|
#endif
|
|
|
|
} // namespace uart
|
|
|
|
#undef FORCE_INLINE
|
|
#undef HAS_UART1
|