rs485_component.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_RS485_RS485_COMPONENT_HPP
#define M5_UNIT_RS485_RS485_COMPONENT_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/stl/byteswap.hpp>
#include <m5_utility/stl/endianness.hpp>
#include <cstring>
#include <memory>
#include <type_traits>
 
namespace m5 {
namespace unit {
 
class AdapterUART;  // forward decl: framework-agnostic UART adapter
 
class RS485Component : public Component {
public:
    struct ISerial {
        virtual ~ISerial()                                         = default;
        virtual int available()                                    = 0;
        virtual int availableForWrite()                            = 0;
        virtual int peek()                                         = 0;
        virtual int read()                                         = 0;
        virtual size_t read(uint8_t *buf, const size_t len)        = 0;
        virtual size_t readBytes(uint8_t *buf, const size_t len)   = 0;
        virtual void flush()                                       = 0;
        virtual void flush(const bool txOnly)                      = 0;
        virtual size_t write(const uint8_t *buf, const size_t len) = 0;
        virtual size_t write(uint8_t b)                            = 0;
        virtual uint32_t baudRate() const                          = 0;
    };
 
    virtual ~RS485Component() = default;
 
    virtual bool begin() override;
 
    struct config_t {
        bool flushRX{true};  
    };
 
 
    inline config_t config()
    {
        return _cfg;
    }
    inline void config(const config_t &cfg)
    {
        _cfg = cfg;
    }
 
    inline operator bool() const
    {
        return isRegistered();
    }
    inline int available()
    {
        return _serial->available();
    }
    inline int availableForWrite()
    {
        return _serial->availableForWrite();
    }
    inline int peek()
    {
        return _serial->peek();
    }
    inline int read()
    {
        return _serial->read();
    }
    inline size_t read(uint8_t *buffer, const size_t size)
    {
        return _serial->read(buffer, size);
    }
    inline size_t read(char *buffer, const size_t size)
    {
        return read(reinterpret_cast<uint8_t *>(buffer), size);
    }
    size_t readBytes(uint8_t *buffer, const size_t length)
    {
        return _serial->readBytes(buffer, length);
    }
    inline size_t readBytes(char *buffer, const size_t length)
    {
        return readBytes(reinterpret_cast<uint8_t *>(buffer), length);
    }
    inline void flush()
    {
        _serial->flush();
    }
    inline void flush(const bool txOnly)
    {
        _serial->flush(txOnly);
    }
    size_t write(const uint8_t d, const bool flush = true);
    size_t write(const uint8_t *buffer, const size_t size, const bool flush = true);
    size_t write(const char *buffer, const size_t size, const bool flush = true);
    size_t write(const char *s, const bool flush = true);
 
 
    template <typename T, bool LittleEndian = true>
    bool readValue(T &value)
    {
        static_assert(std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value,
                      "readValue requires trivially copyable, standard-layout types only");
        value = T{};
        uint8_t buf[sizeof(T)]{};
        size_t got = _serial->readBytes(buf, sizeof(T));
        if (got != sizeof(T)) {
            return false;
        }
        std::memcpy(&value, buf, sizeof(T));
        if (LittleEndian != m5::endian::little) {
            value = byteswap_if_needed(value);
        }
        return true;
    }
    template <typename T, bool LittleEndian = true>
    bool writeValue(const T value)
    {
        static_assert(std::is_trivially_copyable<T>::value && std::is_standard_layout<T>::value,
                      "writeValue requires trivially copyable, standard-layout types only");
        T tmp = value;
        if (LittleEndian != m5::endian::little) {
            tmp = byteswap_if_needed(tmp);
        }
        uint8_t buf[sizeof(T)]{};
        std::memcpy(buf, &tmp, sizeof(T));
        return write(buf, sizeof(T), true) == sizeof(T);
    }
 
protected:
    explicit RS485Component(const uint8_t addr);
 
    inline ISerial *iserial()
    {
        return _serial.get();
    }
 
    virtual std::unique_ptr<ISerial> make_serial(AdapterUART *ad);
 
    // 3-way byteswap dispatch tags: integral/enum, floating-point, other (aggregate).
    struct byteswap_int_tag {
    };
    struct byteswap_float_tag {
    };
    struct byteswap_none_tag {
    };
 
    template <typename T>
    struct byteswap_tag_of {
        using type =
            typename std::conditional<std::is_integral<T>::value || std::is_enum<T>::value, byteswap_int_tag,
                                      typename std::conditional<std::is_floating_point<T>::value, byteswap_float_tag,
                                                                byteswap_none_tag>::type>::type;
    };
 
    template <typename T>
    static T byteswap_if_needed(T v)
    {
        return byteswap_if_needed_impl(v, typename byteswap_tag_of<T>::type{});
    }
 
    // Integral / enum: delegated to m5::stl::byteswap.
    template <typename T>
    static T byteswap_if_needed_impl(T v, byteswap_int_tag)
    {
        return m5::stl::byteswap(v);
    }
 
    // Floating-point: bit-cast to same-size unsigned integer, byteswap, bit-cast back.
    template <typename T>
    static T byteswap_if_needed_impl(T v, byteswap_float_tag)
    {
        static_assert(sizeof(T) == 4 || sizeof(T) == 8,
                      "byteswap_if_needed: only 32-bit / 64-bit floating-point supported");
        typename std::conditional<sizeof(T) == 4, uint32_t, uint64_t>::type u{};
        std::memcpy(&u, &v, sizeof(T));
        u = m5::stl::byteswap(u);
        T out{};
        std::memcpy(&out, &u, sizeof(T));
        return out;
    }
 
    // Aggregate / struct: byte-reverse of the whole object is not meaningful; return as-is.
    template <typename T>
    static T byteswap_if_needed_impl(T v, byteswap_none_tag)
    {
        return v;
    }
 
    std::unique_ptr<ISerial> _serial{};
    config_t _cfg{};
};
 
}  // namespace unit
}  // namespace m5
#endif