unit_SP485.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_RS485_UNIT_SP485_HPP
#define M5_UNIT_RS485_UNIT_SP485_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/stl/byteswap.hpp>
#include <m5_utility/stl/endianness.hpp>
#include <type_traits>
 
class HardwareSerial;
 
namespace m5 {
namespace unit {
 
class UnitSP485 : public Component {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitSP485, 0x00 /*UART*/);
 
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;
    };
 
    UnitSP485();
    virtual ~UnitSP485() = 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:
    inline ISerial *iserial()
    {
        return _serial.get();
    }
 
    template <typename T>
    static T byteswap_if_needed(T v)
    {
        return byteswap_if_needed_impl(v, std::integral_constant < bool,
                                       std::is_integral<T>::value || std::is_enum<T>::value > {});
    }
 
    template <typename T>
    static T byteswap_if_needed_impl(T v, std::true_type)
    {
        return m5::stl::byteswap(v);
    }
 
    template <typename T>
    static T byteswap_if_needed_impl(T v, std::false_type)
    {
        return v;
    }
 
private:
    std::unique_ptr<ISerial> _serial{};
    config_t _cfg{};
};
 
}  // namespace unit
}  // namespace m5
#endif