serial_proxy.h

Go to the documentation of this file.

#pragma once
 
// WARNING: This component is EXPERIMENTAL. The API may change at any time
// without following the normal breaking changes policy. Use at your own risk.
// Once the API is considered stable, this warning will be removed.
 
#include "esphome/core/defines.h"
 
#ifdef USE_SERIAL_PROXY
 
#include "esphome/core/component.h"
#include "esphome/core/hal.h"
#include "esphome/components/uart/uart.h"
 
// Include api_pb2.h only when the API is enabled. The full include is needed
// to hold SerialProxyDataReceived by value as a pre-allocated member.
// Guarding prevents pulling conflicting Zephyr logging macro names into
// translation units that include this header without USE_API defined.
#ifdef USE_API
#include "esphome/components/api/api_pb2.h"
#endif
 
// Forward-declare types needed outside the USE_API guard.
namespace esphome::api {
class APIConnection;
namespace enums {
enum SerialProxyPortType : uint32_t;
enum SerialProxyRequestType : uint32_t;
}  // namespace enums
}  // namespace esphome::api
 
namespace esphome::serial_proxy {
 
enum SerialProxyLineStateFlag : uint32_t {
  SERIAL_PROXY_LINE_STATE_FLAG_RTS = 1 << 0,  
  SERIAL_PROXY_LINE_STATE_FLAG_DTR = 1 << 1,  
};
 
enum class SerialProxyResult : uint8_t {
  SERIAL_PROXY_RESULT_OK,                
  SERIAL_PROXY_RESULT_ASSUMED_SUCCESS,   
  SERIAL_PROXY_RESULT_PORT_IN_USE,       
  SERIAL_PROXY_RESULT_INVALID_ARGUMENT,  
  SERIAL_PROXY_RESULT_ERROR,             
  SERIAL_PROXY_RESULT_TIMEOUT,           
  SERIAL_PROXY_RESULT_NOT_SUPPORTED,     
};
 
inline constexpr size_t SERIAL_PROXY_MAX_READ_SIZE = 256;
 
class SerialProxy final : public uart::UARTDevice, public Component {
 public:
  void setup() override;
  void loop() override;
  void dump_config() override;
  float get_setup_priority() const override { return setup_priority::AFTER_CONNECTION; }
 
  uint32_t get_instance_index() const { return this->instance_index_; }
 
  void set_instance_index(uint32_t index) { this->instance_index_ = index; }
 
  void set_name(const char *name) { this->name_ = name; }
 
  const char *get_name() const { return this->name_; }
 
  void set_port_type(api::enums::SerialProxyPortType port_type) { this->port_type_ = port_type; }
 
  api::enums::SerialProxyPortType get_port_type() const { return this->port_type_; }
 
  SerialProxyResult configure(api::APIConnection *api_connection, uint32_t baudrate, bool flow_control, uint8_t parity,
                              uint8_t stop_bits, uint8_t data_size);
 
  api::APIConnection *get_api_connection() { return this->api_connection_; }
 
  SerialProxyResult serial_proxy_request(api::APIConnection *api_connection, api::enums::SerialProxyRequestType type);
 
  void write_from_client(api::APIConnection *api_connection, const uint8_t *data, size_t len);
 
  SerialProxyResult set_modem_pins(api::APIConnection *api_connection, uint32_t line_states);
 
  uint32_t get_modem_pins() const;
 
  uint32_t get_configured_modem_pins() const {
    return (this->rts_pin_ != nullptr ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_RTS) : 0u) |
           (this->dtr_pin_ != nullptr ? static_cast<uint32_t>(SERIAL_PROXY_LINE_STATE_FLAG_DTR) : 0u);
  }
 
  SerialProxyResult flush_port(api::APIConnection *api_connection);
 
  void set_rts_pin(GPIOPin *pin) { this->rts_pin_ = pin; }
 
  void set_dtr_pin(GPIOPin *pin) { this->dtr_pin_ = pin; }
 
 protected:
#ifdef USE_API
  void read_and_send_(size_t available);
 
  bool port_claimed_by_other_(api::APIConnection *api_connection) const;
#endif
 
  uint32_t instance_index_{0};
 
  api::APIConnection *api_connection_{nullptr};
 
#ifdef USE_API
  api::SerialProxyDataReceived outgoing_msg_;
#endif
 
  const char *name_{nullptr};
 
  api::enums::SerialProxyPortType port_type_{};
 
  GPIOPin *rts_pin_{nullptr};
  GPIOPin *dtr_pin_{nullptr};
 
  bool rts_state_{false};
  bool dtr_state_{false};
};
 
}  // namespace esphome::serial_proxy
 
#endif  // USE_SERIAL_PROXY