adapter_uart.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_COMPONENT_ADAPTER_UART_HPP
#define M5_UNIT_COMPONENT_ADAPTER_UART_HPP
 
#include "adapter_base.hpp"
#if defined(ESP_PLATFORM)
#include <driver/uart.h>
#endif
 
class HardwareSerial;
 
namespace m5 {
namespace unit {
 
class AdapterUART : public Adapter {
public:
    class UARTImpl : public Adapter::Impl {
    public:
        UARTImpl()          = default;
        virtual ~UARTImpl() = default;
        inline virtual HardwareSerial* getSerial()
        {
            return nullptr;
        }
        virtual void flush()
        {
        }
        virtual void flushRX()
        {
        }
        virtual void setTimeout(const uint32_t)
        {
        }
        virtual size_t available()
        {
            return 0;
        }
#if defined(ESP_PLATFORM)
        virtual uart_port_t uartPort() const
        {
            return UART_NUM_MAX;
        }
#endif
    };
 
    //
#if defined(ARDUINO)
    class SerialImpl : public UARTImpl {
    public:
        explicit SerialImpl(HardwareSerial& serial);
        inline virtual HardwareSerial* getSerial() override
        {
            return _serial;
        }
        virtual void flush() override;
        virtual void flushRX() override;
        virtual void setTimeout(const uint32_t ms) override;
        virtual size_t available() override;
        virtual m5::hal::error::error_t readWithTransaction(uint8_t* data, const size_t len) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
 
    protected:
        HardwareSerial* _serial{};
    };
#endif
 
#if defined(ESP_PLATFORM)
    class ESPIDFImpl : public UARTImpl {
    public:
        explicit ESPIDFImpl(const uart_port_t uart_num) : AdapterUART::UARTImpl(), _uart_num(uart_num)
        {
        }
        virtual void flush() override;
        virtual void flushRX() override;
        virtual void setTimeout(const uint32_t ms) override;
        virtual size_t available() override;
        virtual m5::hal::error::error_t readWithTransaction(uint8_t* data, const size_t len) override;
        virtual m5::hal::error::error_t writeWithTransaction(const uint8_t* data, const size_t len,
                                                             const uint32_t stop) override;
        inline virtual uart_port_t uartPort() const override
        {
            return _uart_num;
        }
 
    protected:
        uart_port_t _uart_num{UART_NUM_1};
        uint32_t _timeout_ms{1000};
    };
#endif
 
#if defined(ARDUINO)
    explicit AdapterUART(HardwareSerial& serial);
#endif
 
#if defined(ESP_PLATFORM)
    explicit AdapterUART(const uart_port_t uart_num);
#endif
 
    inline void flush()
    {
        impl()->flush();
    }
    inline void flushRX()
    {
        impl()->flushRX();
    }
    inline void setTimeout(const uint32_t ms)
    {
        impl()->setTimeout(ms);
    }
    inline size_t available()
    {
        return impl()->available();
    }
#if defined(ESP_PLATFORM)
    inline uart_port_t uartPort() const
    {
        return impl()->uartPort();
    }
#endif
 
    inline UARTImpl* impl()
    {
        return static_cast<UARTImpl*>(_impl.get());
    }
    inline const UARTImpl* impl() const
    {
        return static_cast<UARTImpl*>(_impl.get());
    }
 
protected:
    AdapterUART() : Adapter(Adapter::Type::UART, new UARTImpl())
    {
    }
 
protected:
};
 
}  // namespace unit
}  // namespace m5
#endif