esphome 2025.2.1__py3-none-any.whl → 2025.3.0__py3-none-any.whl

esphome/components/tormatic/tormatic_protocol.h

@@ -0,0 +1,211 @@
+#pragma once
+
+#include "esphome/components/cover/cover.h"
+
+/**
+ * This file implements the UART protocol spoken over the on-board Micro-USB
+ * (Type B) connector of Tormatic and Novoferm gates manufactured as of 2016.
+ * All communication is initiated by the component. The unit doesn't send data
+ * without being asked first.
+ *
+ * There are two main message types: status requests and commands.
+ *
+ * Querying the gate's status:
+ *
+ * | sequence  |        length       |    type   |       payload       |
+ * | 0xF3 0xCB | 0x00 0x00 0x00 0x06 | 0x01 0x04 | 0x00 0x0A 0x00 0x01 |
+ * | 0xF3 0xCB | 0x00 0x00 0x00 0x05 | 0x01 0x04 | 0x02 0x03 0x00      |
+ *
+ * This request asks for the gate status (0x0A); the only other value observed
+ * in the request was 0x0B, but replies were always zero. Presumably this
+ * queries another sensor on the unit like a safety breaker, but this is not
+ * relevant for an esphome cover component.
+ *
+ * The second byte of the reply is set to 0x03 when the gate is in fully open
+ * position. Other valid values for the second byte are: (0x0) Paused, (0x1)
+ * Closed, (0x2) Ventilating, (0x3) Opened, (0x4) Opening, (0x5) Closing. The
+ * meaning of the other bytes is currently unknown and ignored by the component.
+ *
+ * Controlling the gate:
+ *
+ * | sequence  |        length       |    type   |       payload       |
+ * | 0x40 0xFF | 0x00 0x00 0x00 0x06 | 0x01 0x06 | 0x00 0x0A 0x00 0x03 |
+ * | 0x40 0xFF | 0x00 0x00 0x00 0x06 | 0x01 0x06 | 0x00 0x0A 0x00 0x03 |
+ *
+ * The unit acks any commands by echoing back the message in full. However,
+ * this does _not_ mean the gate has started closing. The component only
+ * considers status replies as authoritative and simply fires off commands,
+ * ignoring the echoed messages.
+ *
+ * The payload structure is as follows: [0x00, 0x0A] (gate), followed by
+ * one of the states normally carried in status replies: (0x0) Pause, (0x1)
+ * Close, (0x2) Ventilate (open ~20%), (0x3) Open/high-torque reverse. The
+ * protocol implementation in this file simply reuses the GateStatus enum
+ * for this purpose.
+ */
+
+namespace esphome {
+namespace tormatic {
+
+using namespace esphome::cover;
+
+// MessageType is the type of message that follows the MessageHeader.
+enum MessageType : uint16_t {
+  STATUS = 0x0104,
+  COMMAND = 0x0106,
+};
+
+inline const char *message_type_to_str(MessageType t) {
+  switch (t) {
+    case STATUS:
+      return "Status";
+    case COMMAND:
+      return "Command";
+    default:
+      return "Unknown";
+  }
+}
+
+// MessageHeader appears at the start of every message, both requests and replies.
+struct MessageHeader {
+  uint16_t seq;
+  uint32_t len;
+  MessageType type;
+
+  MessageHeader() = default;
+  MessageHeader(MessageType type, uint16_t seq, uint32_t payload_size) {
+    this->type = type;
+    this->seq = seq;
+    // len includes the length of the type field. It was
+    // included in MessageHeader to avoid having to parse
+    // it as part of the payload.
+    this->len = payload_size + sizeof(this->type);
+  }
+
+  std::string print() {
+    return str_sprintf("MessageHeader: seq %d, len %d, type %s", this->seq, this->len, message_type_to_str(this->type));
+  }
+
+  void byteswap() {
+    this->len = convert_big_endian(this->len);
+    this->seq = convert_big_endian(this->seq);
+    this->type = convert_big_endian(this->type);
+  }
+
+  // payload_size returns the amount of payload bytes to be read from the uart
+  // buffer after reading the header.
+  uint32_t payload_size() { return this->len - sizeof(this->type); }
+} __attribute__((packed));
+
+// StatusType denotes which 'page' of information needs to be retrieved.
+// On my Novoferm 423, only the GATE status type returns values, Unknown
+// only contains zeroes.
+enum StatusType : uint16_t {
+  GATE = 0x0A,
+  UNKNOWN = 0x0B,
+};
+
+// GateStatus defines the current state of the gate, received in a StatusReply
+// and sent in a Command.
+enum GateStatus : uint8_t {
+  PAUSED,
+  CLOSED,
+  VENTILATING,
+  OPENED,
+  OPENING,
+  CLOSING,
+};
+
+inline CoverOperation gate_status_to_cover_operation(GateStatus s) {
+  switch (s) {
+    case OPENING:
+      return COVER_OPERATION_OPENING;
+    case CLOSING:
+      return COVER_OPERATION_CLOSING;
+    case OPENED:
+    case CLOSED:
+    case PAUSED:
+    case VENTILATING:
+      return COVER_OPERATION_IDLE;
+  }
+  return COVER_OPERATION_IDLE;
+}
+
+inline const char *gate_status_to_str(GateStatus s) {
+  switch (s) {
+    case PAUSED:
+      return "Paused";
+    case CLOSED:
+      return "Closed";
+    case VENTILATING:
+      return "Ventilating";
+    case OPENED:
+      return "Opened";
+    case OPENING:
+      return "Opening";
+    case CLOSING:
+      return "Closing";
+    default:
+      return "Unknown";
+  }
+}
+
+// A StatusRequest is sent to request the gate's current status.
+struct StatusRequest {
+  StatusType type;
+  uint16_t trailer = 0x1;
+
+  StatusRequest() = default;
+  StatusRequest(StatusType type) { this->type = type; }
+
+  void byteswap() {
+    this->type = convert_big_endian(this->type);
+    this->trailer = convert_big_endian(this->trailer);
+  }
+} __attribute__((packed));
+
+// StatusReply is received from the unit in response to a StatusRequest.
+struct StatusReply {
+  uint8_t ack = 0x2;
+  GateStatus state;
+  uint8_t trailer = 0x0;
+
+  std::string print() { return str_sprintf("StatusReply: state %s", gate_status_to_str(this->state)); }
+
+  void byteswap(){};
+} __attribute__((packed));
+
+// Serialize the given object to a new byte vector.
+// Invokes the object's byteswap() method.
+template<typename T> std::vector<uint8_t> serialize(T obj) {
+  obj.byteswap();
+
+  std::vector<uint8_t> out(sizeof(T));
+  memcpy(out.data(), &obj, sizeof(T));
+
+  return out;
+}
+
+// Command tells the gate to start or stop moving.
+// It is echoed back by the unit on success.
+struct CommandRequestReply {
+  // The part of the unit to control. For now only the gate is supported.
+  StatusType type = GATE;
+  uint8_t pad = 0x0;
+  // The desired state:
+  // PAUSED = stop
+  // VENTILATING = move to ~20% open
+  // CLOSED = close
+  // OPENED = open/high-torque reverse when closing
+  GateStatus state;
+
+  CommandRequestReply() = default;
+  CommandRequestReply(GateStatus state) { this->state = state; }
+
+  std::string print() { return str_sprintf("CommandRequestReply: state %s", gate_status_to_str(this->state)); }
+
+  void byteswap() { this->type = convert_big_endian(this->type); }
+} __attribute__((packed));
+
+}  // namespace tormatic
+}  // namespace esphome

esphome/components/touchscreen/binary_sensor/__init__.py

@@ -19,6 +19,7 @@ CONF_X_MIN = "x_min"
 CONF_X_MAX = "x_max"
 CONF_Y_MIN = "y_min"
 CONF_Y_MAX = "y_max"
+CONF_USE_RAW = "use_raw"
 
 
 def _validate_coords(config):
@@ -46,6 +47,7 @@ CONFIG_SCHEMA = cv.All(
     .extend(
         {
             cv.GenerateID(CONF_TOUCHSCREEN_ID): cv.use_id(Touchscreen),
+            cv.Optional(CONF_USE_RAW, default=False): cv.boolean,
             cv.Required(CONF_X_MIN): cv.int_range(min=0, max=2000),
             cv.Required(CONF_X_MAX): cv.int_range(min=0, max=2000),
             cv.Required(CONF_Y_MIN): cv.int_range(min=0, max=2000),
@@ -69,6 +71,7 @@ async def to_code(config):
     await cg.register_component(var, config)
     await cg.register_parented(var, config[CONF_TOUCHSCREEN_ID])
 
+    cg.add(var.set_use_raw(config[CONF_USE_RAW]))
     cg.add(
         var.set_area(
             config[CONF_X_MIN],

esphome/components/touchscreen/binary_sensor/touchscreen_binary_sensor.cpp

@@ -9,7 +9,13 @@ void TouchscreenBinarySensor::setup() {
 }
 
 void TouchscreenBinarySensor::touch(TouchPoint tp) {
-  bool touched = (tp.x >= this->x_min_ && tp.x <= this->x_max_ && tp.y >= this->y_min_ && tp.y <= this->y_max_);
+  bool touched;
+  if (this->use_raw_) {
+    touched =
+        (tp.x_raw >= this->x_min_ && tp.x_raw <= this->x_max_ && tp.y_raw >= this->y_min_ && tp.y_raw <= this->y_max_);
+  } else {
+    touched = (tp.x >= this->x_min_ && tp.x <= this->x_max_ && tp.y >= this->y_min_ && tp.y <= this->y_max_);
+  }
 
   if (!this->pages_.empty()) {
     auto *current_page = this->parent_->get_display()->get_active_page();

esphome/components/touchscreen/binary_sensor/touchscreen_binary_sensor.h

@@ -25,6 +25,7 @@ class TouchscreenBinarySensor : public binary_sensor::BinarySensor,
     this->y_min_ = y_min;
     this->y_max_ = y_max;
   }
+  void set_use_raw(bool use_raw) { this->use_raw_ = use_raw; }
   int16_t get_x_min() { return this->x_min_; }
   int16_t get_x_max() { return this->x_max_; }
   int16_t get_y_min() { return this->y_min_; }
@@ -38,7 +39,8 @@ class TouchscreenBinarySensor : public binary_sensor::BinarySensor,
   void release() override;
 
  protected:
-  int16_t x_min_, x_max_, y_min_, y_max_;
+  int16_t x_min_{}, x_max_{}, y_min_{}, y_max_{};
+  bool use_raw_{};
   std::vector<display::DisplayPage *> pages_{};
 };
 

esphome/components/touchscreen/touchscreen.cpp

@@ -74,6 +74,9 @@ void Touchscreen::loop() {
 void Touchscreen::add_raw_touch_position_(uint8_t id, int16_t x_raw, int16_t y_raw, int16_t z_raw) {
   TouchPoint tp;
   uint16_t x, y;
+  if (this->swap_x_y_) {
+    std::swap(x_raw, y_raw);
+  }
   if (this->touches_.count(id) == 0) {
     tp.state = STATE_PRESSED;
     tp.id = id;
@@ -90,10 +93,6 @@ void Touchscreen::add_raw_touch_position_(uint8_t id, int16_t x_raw, int16_t y_r
     x = this->normalize_(x_raw, this->x_raw_min_, this->x_raw_max_, this->invert_x_);
     y = this->normalize_(y_raw, this->y_raw_min_, this->y_raw_max_, this->invert_y_);
 
-    if (this->swap_x_y_) {
-      std::swap(x, y);
-    }
-
     tp.x = (uint16_t) ((int) x * this->display_width_ / 0x1000);
     tp.y = (uint16_t) ((int) y * this->display_height_ / 0x1000);
   } else {

esphome/components/udp/udp_component.h

@@ -70,7 +70,9 @@ class UDPComponent : public PollingComponent {
   }
 #endif
   void add_address(const char *addr) { this->addresses_.emplace_back(addr); }
+#ifdef USE_NETWORK
   void set_listen_address(const char *listen_addr) { this->listen_address_ = network::IPAddress(listen_addr); }
+#endif
   void set_port(uint16_t port) { this->port_ = port; }
   float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
 
@@ -144,8 +146,9 @@ class UDPComponent : public PollingComponent {
   std::vector<BinarySensor> binary_sensors_{};
   std::map<std::string, std::map<std::string, binary_sensor::BinarySensor *>> remote_binary_sensors_{};
 #endif
-
+#ifdef USE_NETWORK
   optional<network::IPAddress> listen_address_{};
+#endif
   std::map<std::string, Provider> providers_{};
   std::vector<uint8_t> ping_header_{};
   std::vector<uint8_t> header_{};

esphome/components/web_server/list_entities.cpp

@@ -9,180 +9,184 @@
 namespace esphome {
 namespace web_server {
 
-ListEntitiesIterator::ListEntitiesIterator(WebServer *web_server) : web_server_(web_server) {}
+#ifdef USE_ARDUINO
+ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, DeferredUpdateEventSource *es)
+    : web_server_(ws), events_(es) {}
+#endif
+#ifdef USE_ESP_IDF
+ListEntitiesIterator::ListEntitiesIterator(const WebServer *ws, AsyncEventSource *es) : web_server_(ws), events_(es) {}
+#endif
+ListEntitiesIterator::~ListEntitiesIterator() {}
 
 #ifdef USE_BINARY_SENSOR
-bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *binary_sensor) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_binary_sensor(binary_sensor::BinarySensor *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(
-      this->web_server_->binary_sensor_json(binary_sensor, binary_sensor->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::binary_sensor_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_COVER
-bool ListEntitiesIterator::on_cover(cover::Cover *cover) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_cover(cover::Cover *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->cover_json(cover, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::cover_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_FAN
-bool ListEntitiesIterator::on_fan(fan::Fan *fan) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_fan(fan::Fan *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->fan_json(fan, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::fan_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_LIGHT
-bool ListEntitiesIterator::on_light(light::LightState *light) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_light(light::LightState *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->light_json(light, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::light_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_SENSOR
-bool ListEntitiesIterator::on_sensor(sensor::Sensor *sensor) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_sensor(sensor::Sensor *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->sensor_json(sensor, sensor->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::sensor_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_SWITCH
-bool ListEntitiesIterator::on_switch(switch_::Switch *a_switch) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_switch(switch_::Switch *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->switch_json(a_switch, a_switch->state, DETAIL_ALL).c_str(),
-                                  "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::switch_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_BUTTON
-bool ListEntitiesIterator::on_button(button::Button *button) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_button(button::Button *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->button_json(button, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::button_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_TEXT_SENSOR
-bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *text_sensor) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_text_sensor(text_sensor::TextSensor *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(
-      this->web_server_->text_sensor_json(text_sensor, text_sensor->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::text_sensor_all_json_generator);
   return true;
 }
 #endif
 #ifdef USE_LOCK
-bool ListEntitiesIterator::on_lock(lock::Lock *a_lock) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_lock(lock::Lock *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->lock_json(a_lock, a_lock->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::lock_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_VALVE
-bool ListEntitiesIterator::on_valve(valve::Valve *valve) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_valve(valve::Valve *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->valve_json(valve, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::valve_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_CLIMATE
-bool ListEntitiesIterator::on_climate(climate::Climate *climate) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_climate(climate::Climate *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->climate_json(climate, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::climate_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_NUMBER
-bool ListEntitiesIterator::on_number(number::Number *number) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_number(number::Number *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->number_json(number, number->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::number_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_DATETIME_DATE
-bool ListEntitiesIterator::on_date(datetime::DateEntity *date) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_date(datetime::DateEntity *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->date_json(date, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::date_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_DATETIME_TIME
-bool ListEntitiesIterator::on_time(datetime::TimeEntity *time) {
-  this->web_server_->events_.send(this->web_server_->time_json(time, DETAIL_ALL).c_str(), "state");
+bool ListEntitiesIterator::on_time(datetime::TimeEntity *obj) {
+  if (this->events_->count() == 0)
+    return true;
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::time_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_DATETIME_DATETIME
-bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *datetime) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_datetime(datetime::DateTimeEntity *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->datetime_json(datetime, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::datetime_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_TEXT
-bool ListEntitiesIterator::on_text(text::Text *text) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_text(text::Text *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->text_json(text, text->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::text_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_SELECT
-bool ListEntitiesIterator::on_select(select::Select *select) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_select(select::Select *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->select_json(select, select->state, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::select_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_ALARM_CONTROL_PANEL
-bool ListEntitiesIterator::on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *a_alarm_control_panel) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_alarm_control_panel(alarm_control_panel::AlarmControlPanel *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(
-      this->web_server_->alarm_control_panel_json(a_alarm_control_panel, a_alarm_control_panel->get_state(), DETAIL_ALL)
-          .c_str(),
-      "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::alarm_control_panel_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_EVENT
-bool ListEntitiesIterator::on_event(event::Event *event) {
+bool ListEntitiesIterator::on_event(event::Event *obj) {
+  if (this->events_->count() == 0)
+    return true;
   // Null event type, since we are just iterating over entities
-  const std::string null_event_type = "";
-  this->web_server_->events_.send(this->web_server_->event_json(event, null_event_type, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::event_all_json_generator);
   return true;
 }
 #endif
 
 #ifdef USE_UPDATE
-bool ListEntitiesIterator::on_update(update::UpdateEntity *update) {
-  if (this->web_server_->events_.count() == 0)
+bool ListEntitiesIterator::on_update(update::UpdateEntity *obj) {
+  if (this->events_->count() == 0)
     return true;
-  this->web_server_->events_.send(this->web_server_->update_json(update, DETAIL_ALL).c_str(), "state");
+  this->events_->deferrable_send_state(obj, "state_detail_all", WebServer::update_all_json_generator);
   return true;
 }
 #endif