serial_proxy.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <esphome/api/model/enums.hpp>
#include <esphome/api/subsystems/subsystem.hpp>
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace esphome::api {
 
struct SerialProxyConfig {
    std::uint32_t instance = 0;
    std::uint32_t baudrate = 0;
    bool flow_control = false;
    SerialProxyParity parity = SerialProxyParity::None;
    std::uint32_t stop_bits = 1;
    std::uint32_t data_size = 8;
};
 
struct SerialProxyData {
    std::uint32_t instance = 0;
    std::string data;
};
 
struct SerialProxyResponse {
    std::uint32_t instance = 0;
    SerialProxyRequestType type = SerialProxyRequestType::Subscribe;
    SerialProxyStatus status = SerialProxyStatus::Ok;
    std::string error_message;
};
 
struct SerialProxyLineStates {
    bool rts = false;  
    bool dtr = false;  
 
    static constexpr std::uint32_t rts_bit = 1U << 0;
    static constexpr std::uint32_t dtr_bit = 1U << 1;
 
    [[nodiscard]] static SerialProxyLineStates from_bits(const std::uint32_t bits) {
        return {(bits & rts_bit) != 0, (bits & dtr_bit) != 0};
    }
    [[nodiscard]] std::uint32_t to_bits() const {
        return (rts ? rts_bit : 0U) | (dtr ? dtr_bit : 0U);
    }
};
 
struct SerialProxyModemPins {
    std::uint32_t instance = 0;
    SerialProxyLineStates lines;
};
 
class SerialPort;
 
class SerialProxy : public Subsystem {
public:
    using DataHandler = std::function<void(const SerialProxyData&)>;
    using ResponseHandler = std::function<void(const SerialProxyResponse&)>;
    using ModemPinsHandler = std::function<void(const SerialProxyModemPins&)>;
 
    explicit SerialProxy(Client& client) : Subsystem(client) {}
 
    [[nodiscard]] SerialPort instance(std::uint32_t index);
 
    void on_data(DataHandler handler);
 
    void on_data(std::uint32_t instance, DataHandler handler);
 
    void on_request_response(ResponseHandler handler);
 
    void on_modem_pins(ModemPinsHandler handler);
 
    void request(std::uint32_t instance, SerialProxyRequestType type) const;
 
    void configure(const SerialProxyConfig& config) const;
 
    void write(std::uint32_t instance, const std::string& data) const;
 
    void get_modem_pins(std::uint32_t instance, ModemPinsHandler once = {});
 
    void set_modem_pins(std::uint32_t instance, SerialProxyLineStates lines) const;
 
    void set_modem_pins_raw(std::uint32_t instance, std::uint32_t line_states) const;
 
private:
    void ensure_modem_pins_handler();
    void ensure_data_handler();
 
    DataHandler data_handler_;
    std::unordered_map<std::uint32_t, DataHandler> instance_data_handlers_;
    ResponseHandler response_handler_;
    ModemPinsHandler modem_pins_handler_;
    std::unordered_map<std::uint32_t, std::vector<ModemPinsHandler>> pending_modem_pins_;
    bool data_registered_ = false;
    bool modem_pins_registered_ = false;
};
 
class SerialPort {
public:
    SerialPort(SerialProxy& proxy, const std::uint32_t instance)
        : proxy_(&proxy), instance_(instance) {}
 
    [[nodiscard]] std::uint32_t index() const noexcept {
        return instance_;
    }
 
    void subscribe() const {
        proxy_->request(instance_, SerialProxyRequestType::Subscribe);
    }
    void unsubscribe() const {
        proxy_->request(instance_, SerialProxyRequestType::Unsubscribe);
    }
    void flush() const {
        proxy_->request(instance_, SerialProxyRequestType::Flush);
    }
 
    void configure(SerialProxyConfig config) const {
        config.instance = instance_;
        proxy_->configure(config);
    }
    void write(const std::string& data) const {
        proxy_->write(instance_, data);
    }
 
    void get_modem_pins(SerialProxy::ModemPinsHandler once = {}) const {
        proxy_->get_modem_pins(instance_, std::move(once));
    }
    void set_modem_pins(const SerialProxyLineStates lines) const {
        proxy_->set_modem_pins(instance_, lines);
    }
 
    void on_data(SerialProxy::DataHandler handler) const {
        proxy_->on_data(instance_, std::move(handler));
    }
 
private:
    SerialProxy* proxy_;
    std::uint32_t instance_;
};
 
inline SerialPort SerialProxy::instance(const std::uint32_t index) {
    return SerialPort(*this, index);
}
 
}  // namespace esphome::api