esphome 2024.12.3__py3-none-any.whl

esphome/components/lightwaverf/LwTx.cpp

@@ -0,0 +1,208 @@
+// LwTx.cpp
+//
+// LightwaveRF 434MHz tx interface for Arduino
+//
+// Author: Bob Tidey (robert@tideys.net)
+#ifdef USE_ESP8266
+
+#include "LwTx.h"
+#include <cstring>
+#include <Arduino.h>
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+
+namespace esphome {
+namespace lightwaverf {
+
+static const uint8_t TX_NIBBLE[] = {0xF6, 0xEE, 0xED, 0xEB, 0xDE, 0xDD, 0xDB, 0xBE,
+                                    0xBD, 0xBB, 0xB7, 0x7E, 0x7D, 0x7B, 0x77, 0x6F};
+
+static const uint8_t TX_STATE_IDLE = 0;
+static const uint8_t TX_STATE_MSGSTART = 1;
+static const uint8_t TX_STATE_BYTESTART = 2;
+static const uint8_t TX_STATE_SENDBYTE = 3;
+static const uint8_t TX_STATE_MSGEND = 4;
+static const uint8_t TX_STATE_GAPSTART = 5;
+static const uint8_t TX_STATE_GAPEND = 6;
+/**
+  Set translate mode
+**/
+void LwTx::lwtx_settranslate(bool txtranslate) { tx_translate = txtranslate; }
+
+static void IRAM_ATTR isr_t_xtimer(LwTx *arg) {
+  // Set low after toggle count interrupts
+  arg->tx_toggle_count--;
+  if (arg->tx_toggle_count == arg->tx_trail_count) {
+    // ESP_LOGD("lightwaverf.sensor", "timer")
+    arg->tx_pin->digital_write(arg->txoff);
+  } else if (arg->tx_toggle_count == 0) {
+    arg->tx_toggle_count = arg->tx_high_count;  // default high pulse duration
+    switch (arg->tx_state) {
+      case TX_STATE_IDLE:
+        if (arg->tx_msg_active) {
+          arg->tx_repeat = 0;
+          arg->tx_state = TX_STATE_MSGSTART;
+        }
+        break;
+      case TX_STATE_MSGSTART:
+        arg->tx_pin->digital_write(arg->txon);
+        arg->tx_num_bytes = 0;
+        arg->tx_state = TX_STATE_BYTESTART;
+        break;
+      case TX_STATE_BYTESTART:
+        arg->tx_pin->digital_write(arg->txon);
+        arg->tx_bit_mask = 0x80;
+        arg->tx_state = TX_STATE_SENDBYTE;
+        break;
+      case TX_STATE_SENDBYTE:
+        if (arg->tx_buf[arg->tx_num_bytes] & arg->tx_bit_mask) {
+          arg->tx_pin->digital_write(arg->txon);
+        } else {
+          // toggle count for the 0 pulse
+          arg->tx_toggle_count = arg->tx_low_count;
+        }
+        arg->tx_bit_mask >>= 1;
+        if (arg->tx_bit_mask == 0) {
+          arg->tx_num_bytes++;
+          if (arg->tx_num_bytes >= esphome::lightwaverf::LwTx::TX_MSGLEN) {
+            arg->tx_state = TX_STATE_MSGEND;
+          } else {
+            arg->tx_state = TX_STATE_BYTESTART;
+          }
+        }
+        break;
+      case TX_STATE_MSGEND:
+        arg->tx_pin->digital_write(arg->txon);
+        arg->tx_state = TX_STATE_GAPSTART;
+        arg->tx_gap_repeat = arg->tx_gap_multiplier;
+        break;
+      case TX_STATE_GAPSTART:
+        arg->tx_toggle_count = arg->tx_gap_count;
+        if (arg->tx_gap_repeat == 0) {
+          arg->tx_state = TX_STATE_GAPEND;
+        } else {
+          arg->tx_gap_repeat--;
+        }
+        break;
+      case TX_STATE_GAPEND:
+        arg->tx_repeat++;
+        if (arg->tx_repeat >= arg->tx_repeats) {
+          // disable timer nterrupt
+          arg->lw_timer_stop();
+          arg->tx_msg_active = false;
+          arg->tx_state = TX_STATE_IDLE;
+        } else {
+          arg->tx_state = TX_STATE_MSGSTART;
+        }
+        break;
+    }
+  }
+}
+
+/**
+  Check for send free
+**/
+bool LwTx::lwtx_free() { return !this->tx_msg_active; }
+
+/**
+  Send a LightwaveRF message (10 nibbles in bytes)
+**/
+void LwTx::lwtx_send(const std::vector<uint8_t> &msg) {
+  if (this->tx_translate) {
+    for (uint8_t i = 0; i < TX_MSGLEN; i++) {
+      this->tx_buf[i] = TX_NIBBLE[msg[i] & 0xF];
+      ESP_LOGD("lightwaverf.sensor", "%x ", msg[i]);
+    }
+  } else {
+    // memcpy(tx_buf, msg, tx_msglen);
+  }
+  this->lw_timer_start();
+  this->tx_msg_active = true;
+}
+
+/**
+  Set 5 char address for future messages
+**/
+void LwTx::lwtx_setaddr(const uint8_t *addr) {
+  for (uint8_t i = 0; i < 5; i++) {
+    this->tx_buf[i + 4] = TX_NIBBLE[addr[i] & 0xF];
+  }
+}
+
+/**
+  Send a LightwaveRF message (10 nibbles in bytes)
+**/
+void LwTx::lwtx_cmd(uint8_t command, uint8_t parameter, uint8_t room, uint8_t device) {
+  // enable timer 2 interrupts
+  this->tx_buf[0] = TX_NIBBLE[parameter >> 4];
+  this->tx_buf[1] = TX_NIBBLE[parameter & 0xF];
+  this->tx_buf[2] = TX_NIBBLE[device & 0xF];
+  this->tx_buf[3] = TX_NIBBLE[command & 0xF];
+  this->tx_buf[9] = TX_NIBBLE[room & 0xF];
+  this->lw_timer_start();
+  this->tx_msg_active = true;
+}
+
+/**
+  Set things up to transmit LightWaveRF 434Mhz messages
+**/
+void LwTx::lwtx_setup(InternalGPIOPin *pin, uint8_t repeats, bool inverted, int u_sec) {
+  pin->setup();
+  tx_pin = pin;
+
+  tx_pin->pin_mode(gpio::FLAG_OUTPUT);
+  tx_pin->digital_write(txoff);
+
+  if (repeats > 0 && repeats < 40) {
+    this->tx_repeats = repeats;
+  }
+  if (inverted) {
+    this->txon = 0;
+    this->txoff = 1;
+  } else {
+    this->txon = 1;
+    this->txoff = 0;
+  }
+
+  int period1 = 330;
+  /*
+  if (period > 32 && period < 1000) {
+    period1 = period;
+  } else {
+    // default 330 uSec
+    period1 = 330;
+  }*/
+  this->espPeriod = 5 * period1;
+  timer1_isr_init();
+}
+
+void LwTx::lwtx_set_tick_counts(uint8_t low_count, uint8_t high_count, uint8_t trail_count, uint8_t gap_count) {
+  this->tx_low_count = low_count;
+  this->tx_high_count = high_count;
+  this->tx_trail_count = trail_count;
+  this->tx_gap_count = gap_count;
+}
+
+void LwTx::lwtx_set_gap_multiplier(uint8_t gap_multiplier) { this->tx_gap_multiplier = gap_multiplier; }
+
+void LwTx::lw_timer_start() {
+  {
+    InterruptLock lock;
+    static LwTx *arg = this;  // NOLINT
+    timer1_attachInterrupt([] { isr_t_xtimer(arg); });
+    timer1_enable(TIM_DIV16, TIM_EDGE, TIM_LOOP);
+    timer1_write(this->espPeriod);
+  }
+}
+
+void LwTx::lw_timer_stop() {
+  {
+    InterruptLock lock;
+    timer1_disable();
+    timer1_detachInterrupt();
+  }
+}
+
+}  // namespace lightwaverf
+}  // namespace esphome
+#endif

esphome/components/lightwaverf/LwTx.h

@@ -0,0 +1,94 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+#include <vector>
+
+namespace esphome {
+namespace lightwaverf {
+
+// LxTx.h
+//
+// LightwaveRF 434MHz tx interface for Arduino
+//
+// Author: Bob Tidey (robert@tideys.net)
+
+// Include basic library header and set default TX pin
+static const uint8_t TX_PIN_DEFAULT = 13;
+
+class LwTx {
+ public:
+  // Sets up basic parameters must be called at least once
+  void lwtx_setup(InternalGPIOPin *pin, uint8_t repeats, bool inverted, int u_sec);
+
+  // Allows changing basic tick counts from their defaults
+  void lwtx_set_tick_counts(uint8_t low_count, uint8_t high_count, uint8_t trail_count, uint8_t gap_count);
+
+  // Allws multiplying the gap period for creating very large gaps
+  void lwtx_set_gap_multiplier(uint8_t gap_multiplier);
+
+  // determines whether incoming data or should be translated from nibble data
+  void lwtx_settranslate(bool txtranslate);
+
+  // Checks whether tx is free to accept a new message
+  bool lwtx_free();
+
+  // Basic send of new 10 char message, not normally needed if setaddr and cmd are used.
+  void lwtx_send(const std::vector<uint8_t> &msg);
+
+  // Sets up 5 char address which will be used to form messages for lwtx_cmd
+  void lwtx_setaddr(const uint8_t *addr);
+
+  // Send Command
+  void lwtx_cmd(uint8_t command, uint8_t parameter, uint8_t room, uint8_t device);
+
+  // Allows changing basic tick counts from their defaults
+  void lw_timer_start();
+
+  // Allws multiplying the gap period for creating very large gaps
+  void lw_timer_stop();
+
+  // These set the pulse durationlws in ticks. ESP uses 330uSec base tick, else use 140uSec
+  uint8_t tx_low_count = 3;    // total number of ticks in a low (990 uSec)
+  uint8_t tx_high_count = 2;   // total number of ticks in a high (660 uSec)
+  uint8_t tx_trail_count = 1;  // tick count to set line low (330 uSec)
+
+  uint8_t tx_toggle_count = 3;
+
+  static const uint8_t TX_MSGLEN = 10;  // the expected length of the message
+
+  // Transmit mode constants and variables
+  uint8_t tx_repeats = 12;  // Number of repeats of message sent
+  uint8_t txon = 1;
+  uint8_t txoff = 0;
+  bool tx_msg_active = false;  // set true to activate message sending
+  bool tx_translate = true;    // Set false to send raw data
+
+  uint8_t tx_buf[TX_MSGLEN];  // the message buffer during reception
+  uint8_t tx_repeat = 0;      // counter for repeats
+  uint8_t tx_state = 0;
+  uint16_t tx_gap_repeat = 0;  // unsigned int
+
+  // Use with low repeat counts
+  uint8_t tx_gap_count = 33;  // Inter-message gap count (10.9 msec)
+  uint32_t espPeriod = 0;     // Holds interrupt timer0 period
+  uint32_t espNext = 0;       // Holds interrupt next count
+
+  // Gap multiplier byte is used to multiply gap if longer periods are needed for experimentation
+  // If gap is 255 (35msec) then this to give a max of 9 seconds
+  // Used with low repeat counts to find if device times out
+  uint8_t tx_gap_multiplier = 0;  // Gap extension byte
+
+  uint8_t tx_bit_mask = 0;   // bit mask in current byte
+  uint8_t tx_num_bytes = 0;  // number of bytes sent
+
+  InternalGPIOPin *tx_pin;
+
+ protected:
+  uint32_t duty_on_;
+  uint32_t duty_off_;
+};
+
+}  // namespace lightwaverf
+}  // namespace esphome

esphome/components/lightwaverf/__init__.py

@@ -0,0 +1,83 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome import pins
+from esphome import automation
+
+from esphome.const import (
+    CONF_READ_PIN,
+    CONF_ID,
+    CONF_NAME,
+    CONF_WRITE_PIN,
+    CONF_REPEAT,
+    CONF_INVERTED,
+    CONF_PULSE_LENGTH,
+    CONF_CODE,
+)
+from esphome.cpp_helpers import gpio_pin_expression
+
+CODEOWNERS = ["@max246"]
+
+lightwaverf_ns = cg.esphome_ns.namespace("lightwaverf")
+
+
+LIGHTWAVERFComponent = lightwaverf_ns.class_(
+    "LightWaveRF", cg.Component, cg.PollingComponent
+)
+LightwaveRawAction = lightwaverf_ns.class_("SendRawAction", automation.Action)
+
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(LIGHTWAVERFComponent),
+        cv.Optional(CONF_READ_PIN, default=13): pins.internal_gpio_input_pin_schema,
+        cv.Optional(CONF_WRITE_PIN, default=14): pins.internal_gpio_input_pin_schema,
+    }
+).extend(cv.polling_component_schema("1s"))
+
+
+LIGHTWAVE_SEND_SCHEMA = cv.Any(
+    cv.int_range(min=1),
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.use_id(LIGHTWAVERFComponent),
+            cv.Required(CONF_NAME): cv.string,
+            cv.Required(CONF_CODE): cv.All(
+                [cv.Any(cv.hex_uint8_t)],
+                cv.Length(min=10),
+            ),
+            cv.Optional(CONF_REPEAT, default=10): cv.int_,
+            cv.Optional(CONF_INVERTED, default=False): cv.boolean,
+            cv.Optional(CONF_PULSE_LENGTH, default=330): cv.int_,
+        }
+    ),
+)
+
+
+@automation.register_action(
+    "lightwaverf.send_raw",
+    LightwaveRawAction,
+    LIGHTWAVE_SEND_SCHEMA,
+)
+async def send_raw_to_code(config, action_id, template_arg, args):
+    paren = await cg.get_variable(config[CONF_ID])
+    var = cg.new_Pvariable(action_id, template_arg, paren)
+
+    repeats = await cg.templatable(config[CONF_REPEAT], args, int)
+    inverted = await cg.templatable(config[CONF_INVERTED], args, bool)
+    pulse_length = await cg.templatable(config[CONF_PULSE_LENGTH], args, int)
+    code = config[CONF_CODE]
+
+    cg.add(var.set_repeats(repeats))
+    cg.add(var.set_inverted(inverted))
+    cg.add(var.set_pulse_length(pulse_length))
+    cg.add(var.set_data(code))
+    return var
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+
+    pin_read = await gpio_pin_expression(config[CONF_READ_PIN])
+    pin_write = await gpio_pin_expression(config[CONF_WRITE_PIN])
+    cg.add(var.set_pin(pin_write, pin_read))

esphome/components/lightwaverf/lightwaverf.cpp

@@ -0,0 +1,67 @@
+#include "esphome/core/log.h"
+
+#ifdef USE_ESP8266
+
+#include "lightwaverf.h"
+
+namespace esphome {
+namespace lightwaverf {
+
+static const char *const TAG = "lightwaverf.sensor";
+
+static const uint8_t DEFAULT_REPEAT = 10;
+static const bool DEFAULT_INVERT = false;
+static const uint32_t DEFAULT_TICK = 330;
+
+void LightWaveRF::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Lightwave RF...");
+
+  this->lwtx_.lwtx_setup(pin_tx_, DEFAULT_REPEAT, DEFAULT_INVERT, DEFAULT_TICK);
+  this->lwrx_.lwrx_setup(pin_rx_);
+}
+
+void LightWaveRF::update() { this->read_tx(); }
+
+void LightWaveRF::read_tx() {
+  if (this->lwrx_.lwrx_message()) {
+    this->lwrx_.lwrx_getmessage(msg_, msglen_);
+    print_msg_(msg_, msglen_);
+  }
+}
+
+void LightWaveRF::send_rx(const std::vector<uint8_t> &msg, uint8_t repeats, bool inverted, int u_sec) {
+  this->lwtx_.lwtx_setup(pin_tx_, repeats, inverted, u_sec);
+
+  uint32_t timeout = 0;
+  if (this->lwtx_.lwtx_free()) {
+    this->lwtx_.lwtx_send(msg);
+    timeout = millis();
+    ESP_LOGD(TAG, "[%i] msg start", timeout);
+  }
+  while (!this->lwtx_.lwtx_free() && millis() < (timeout + 1000)) {
+    delay(10);
+  }
+  timeout = millis() - timeout;
+  ESP_LOGD(TAG, "[%u] msg sent: %i", millis(), timeout);
+}
+
+void LightWaveRF::print_msg_(uint8_t *msg, uint8_t len) {
+  char buffer[65];
+  ESP_LOGD(TAG, " Received code (len:%i): ", len);
+
+  for (int i = 0; i < len; i++) {
+    sprintf(&buffer[i * 6], "0x%02x, ", msg[i]);
+  }
+  ESP_LOGD(TAG, "[%s]", buffer);
+}
+
+void LightWaveRF::dump_config() {
+  ESP_LOGCONFIG(TAG, "Lightwave RF:");
+  LOG_PIN("  Pin TX: ", this->pin_tx_);
+  LOG_PIN("  Pin RX: ", this->pin_rx_);
+  LOG_UPDATE_INTERVAL(this);
+}
+}  // namespace lightwaverf
+}  // namespace esphome
+
+#endif

esphome/components/lightwaverf/lightwaverf.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#ifdef USE_ESP8266
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/automation.h"
+
+#include <vector>
+
+#include "LwRx.h"
+#include "LwTx.h"
+
+namespace esphome {
+namespace lightwaverf {
+
+#ifdef USE_ESP8266
+
+class LightWaveRF : public PollingComponent {
+ public:
+  void set_pin(InternalGPIOPin *pin_tx, InternalGPIOPin *pin_rx) {
+    pin_tx_ = pin_tx;
+    pin_rx_ = pin_rx;
+  }
+  void update() override;
+  void setup() override;
+  void dump_config() override;
+  void read_tx();
+  void send_rx(const std::vector<uint8_t> &msg, uint8_t repeats, bool inverted, int u_sec);
+
+ protected:
+  void print_msg_(uint8_t *msg, uint8_t len);
+  uint8_t msg_[10];
+  uint8_t msglen_ = 10;
+  InternalGPIOPin *pin_tx_;
+  InternalGPIOPin *pin_rx_;
+  LwRx lwrx_;
+  LwTx lwtx_;
+};
+
+template<typename... Ts> class SendRawAction : public Action<Ts...> {
+ public:
+  SendRawAction(LightWaveRF *parent) : parent_(parent){};
+  TEMPLATABLE_VALUE(int, repeat);
+  TEMPLATABLE_VALUE(int, inverted);
+  TEMPLATABLE_VALUE(int, pulse_length);
+  TEMPLATABLE_VALUE(std::vector<uint8_t>, code);
+
+  void set_repeats(const int &data) { repeat_ = data; }
+  void set_inverted(const int &data) { inverted_ = data; }
+  void set_pulse_length(const int &data) { pulse_length_ = data; }
+  void set_data(const std::vector<uint8_t> &data) { code_ = data; }
+
+  void play(Ts... x) {
+    int repeats = this->repeat_.value(x...);
+    int inverted = this->inverted_.value(x...);
+    int pulse_length = this->pulse_length_.value(x...);
+    std::vector<uint8_t> msg = this->code_.value(x...);
+
+    this->parent_->send_rx(msg, repeats, inverted, pulse_length);
+  }
+
+ protected:
+  LightWaveRF *parent_;
+};
+
+#endif
+}  // namespace lightwaverf
+}  // namespace esphome
+#endif

esphome/components/lilygo_t5_47/__init__.py

@@ -0,0 +1,3 @@
+import esphome.codegen as cg
+
+lilygo_t5_47_ns = cg.esphome_ns.namespace("lilygo_t5_47")

esphome/components/lilygo_t5_47/touchscreen/__init__.py

@@ -0,0 +1,39 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+
+from esphome import pins
+from esphome.components import i2c, touchscreen
+from esphome.const import CONF_ID, CONF_INTERRUPT_PIN
+
+from .. import lilygo_t5_47_ns
+
+CODEOWNERS = ["@jesserockz"]
+DEPENDENCIES = ["i2c"]
+
+LilygoT547Touchscreen = lilygo_t5_47_ns.class_(
+    "LilygoT547Touchscreen",
+    touchscreen.Touchscreen,
+    i2c.I2CDevice,
+)
+
+CONF_LILYGO_T5_47_TOUCHSCREEN_ID = "lilygo_t5_47_touchscreen_id"
+
+CONFIG_SCHEMA = touchscreen.touchscreen_schema("250ms").extend(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(LilygoT547Touchscreen),
+            cv.Required(CONF_INTERRUPT_PIN): cv.All(
+                pins.internal_gpio_input_pin_schema
+            ),
+        }
+    ).extend(i2c.i2c_device_schema(0x5A))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await touchscreen.register_touchscreen(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    interrupt_pin = await cg.gpio_pin_expression(config[CONF_INTERRUPT_PIN])
+    cg.add(var.set_interrupt_pin(interrupt_pin))

esphome/components/lilygo_t5_47/touchscreen/lilygo_t5_47_touchscreen.cpp

@@ -0,0 +1,105 @@
+#include "lilygo_t5_47_touchscreen.h"
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace lilygo_t5_47 {
+
+static const char *const TAG = "lilygo_t5_47.touchscreen";
+
+static const uint8_t POWER_REGISTER = 0xD6;
+static const uint8_t TOUCH_REGISTER = 0xD0;
+
+static const uint8_t WAKEUP_CMD[1] = {0x06};
+static const uint8_t READ_FLAGS[1] = {0x00};
+static const uint8_t CLEAR_FLAGS[2] = {0x00, 0xAB};
+static const uint8_t READ_TOUCH[1] = {0x07};
+
+#define ERROR_CHECK(err) \
+  if ((err) != i2c::ERROR_OK) { \
+    ESP_LOGE(TAG, "Failed to communicate!"); \
+    this->status_set_warning(); \
+    return; \
+  }
+
+void LilygoT547Touchscreen::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up Lilygo T5 4.7 Touchscreen...");
+  this->interrupt_pin_->pin_mode(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
+  this->interrupt_pin_->setup();
+
+  this->attach_interrupt_(this->interrupt_pin_, gpio::INTERRUPT_FALLING_EDGE);
+
+  if (this->write(nullptr, 0) != i2c::ERROR_OK) {
+    ESP_LOGE(TAG, "Failed to communicate!");
+    this->interrupt_pin_->detach_interrupt();
+    this->mark_failed();
+    return;
+  }
+
+  this->write_register(POWER_REGISTER, WAKEUP_CMD, 1);
+  if (this->display_ != nullptr) {
+    if (this->x_raw_max_ == this->x_raw_min_) {
+      this->x_raw_max_ = this->display_->get_native_width();
+    }
+    if (this->y_raw_max_ == this->y_raw_min_) {
+      this->x_raw_max_ = this->display_->get_native_height();
+    }
+  }
+}
+
+void LilygoT547Touchscreen::update_touches() {
+  uint8_t point = 0;
+  uint8_t buffer[40] = {0};
+
+  i2c::ErrorCode err;
+  err = this->write_register(TOUCH_REGISTER, READ_FLAGS, 1);
+  ERROR_CHECK(err);
+
+  err = this->read(buffer, 7);
+  ERROR_CHECK(err);
+
+  if (buffer[0] == 0xAB) {
+    this->write_register(TOUCH_REGISTER, CLEAR_FLAGS, 2);
+    return;
+  }
+
+  point = buffer[5] & 0xF;
+
+  if (point == 1) {
+    err = this->write_register(TOUCH_REGISTER, READ_TOUCH, 1);
+    ERROR_CHECK(err);
+    err = this->read(&buffer[5], 2);
+    ERROR_CHECK(err);
+
+  } else if (point > 1) {
+    err = this->write_register(TOUCH_REGISTER, READ_TOUCH, 1);
+    ERROR_CHECK(err);
+    err = this->read(&buffer[5], 5 * (point - 1) + 3);
+    ERROR_CHECK(err);
+  }
+
+  this->write_register(TOUCH_REGISTER, CLEAR_FLAGS, 2);
+
+  if (point == 0)
+    point = 1;
+
+  uint16_t id, x_raw, y_raw;
+  for (uint8_t i = 0; i < point; i++) {
+    id = (buffer[i * 5] >> 4) & 0x0F;
+    y_raw = (uint16_t) ((buffer[i * 5 + 1] << 4) | ((buffer[i * 5 + 3] >> 4) & 0x0F));
+    x_raw = (uint16_t) ((buffer[i * 5 + 2] << 4) | (buffer[i * 5 + 3] & 0x0F));
+    this->add_raw_touch_position_(id, x_raw, y_raw);
+  }
+
+  this->status_clear_warning();
+}
+
+void LilygoT547Touchscreen::dump_config() {
+  ESP_LOGCONFIG(TAG, "Lilygo T5 47 Touchscreen:");
+  LOG_I2C_DEVICE(this);
+  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
+}
+
+}  // namespace lilygo_t5_47
+}  // namespace esphome

esphome/components/lilygo_t5_47/touchscreen/lilygo_t5_47_touchscreen.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/touchscreen/touchscreen.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+#include <vector>
+
+namespace esphome {
+namespace lilygo_t5_47 {
+
+using namespace touchscreen;
+
+class LilygoT547Touchscreen : public Touchscreen, public i2c::I2CDevice {
+ public:
+  void setup() override;
+
+  void dump_config() override;
+
+  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
+
+ protected:
+  void update_touches() override;
+
+  InternalGPIOPin *interrupt_pin_;
+};
+
+}  // namespace lilygo_t5_47
+}  // namespace esphome