Moved uart utils to separate type submodule
This commit is contained in:
parent
6f592dd098
commit
41b9ef74f9
@ -2,9 +2,9 @@
|
||||
|
||||
#include "../clock.hpp"
|
||||
|
||||
#include <stdint.h>
|
||||
#include "../type/type.hpp"
|
||||
|
||||
#include "utils.hpp"
|
||||
#include <stdint.h>
|
||||
|
||||
#define FORCE_INLINE __attribute__((always_inline))
|
||||
|
||||
@ -258,7 +258,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;
|
||||
}
|
||||
|
||||
|
||||
@ -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;
|
||||
|
||||
43
uart.hpp
43
uart.hpp
@ -4,7 +4,6 @@
|
||||
|
||||
#include "config.hpp"
|
||||
#include "software.hpp"
|
||||
#include "utils.hpp"
|
||||
|
||||
#undef UART0_INT_VECTORS
|
||||
#include "hardware0.hpp"
|
||||
@ -36,8 +35,8 @@ 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 MaxVal = util::NumericLimits<T>::max();
|
||||
constexpr T MinVal = type::NumericLimits<T>::min();
|
||||
constexpr T MaxVal = type::NumericLimits<T>::max();
|
||||
|
||||
constexpr T MinDigits = cntDigits<T, MinVal, Base>();
|
||||
constexpr T MaxDigits = cntDigits<T, MaxVal, Base>();
|
||||
@ -115,7 +114,7 @@ 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");
|
||||
@ -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");
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
143
utils.hpp
143
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
|
||||
Loading…
Reference in New Issue
Block a user