esphome 2024.9.2__py3-none-any.whl → 2024.10.0__py3-none-any.whl

esphome/components/st7701s/st7701s.cpp

@@ -8,8 +8,14 @@ namespace st7701s {
 void ST7701S::setup() {
   esph_log_config(TAG, "Setting up ST7701S");
   this->spi_setup();
+  this->write_init_sequence_();
+
   esp_lcd_rgb_panel_config_t config{};
   config.flags.fb_in_psram = 1;
+#if ESP_IDF_VERSION_MAJOR >= 5
+  config.bounce_buffer_size_px = this->width_ * 10;
+  config.num_fbs = 1;
+#endif  // ESP_IDF_VERSION_MAJOR
   config.timings.h_res = this->width_;
   config.timings.v_res = this->height_;
   config.timings.hsync_pulse_width = this->hsync_pulse_width_;
@@ -21,7 +27,6 @@ void ST7701S::setup() {
   config.timings.flags.pclk_active_neg = this->pclk_inverted_;
   config.timings.pclk_hz = this->pclk_frequency_;
   config.clk_src = LCD_CLK_SRC_PLL160M;
-  config.sram_trans_align = 64;
   config.psram_trans_align = 64;
   size_t data_pin_count = sizeof(this->data_pins_) / sizeof(this->data_pins_[0]);
   for (size_t i = 0; i != data_pin_count; i++) {
@@ -34,15 +39,21 @@ void ST7701S::setup() {
   config.de_gpio_num = this->de_pin_->get_pin();
   config.pclk_gpio_num = this->pclk_pin_->get_pin();
   esp_err_t err = esp_lcd_new_rgb_panel(&config, &this->handle_);
+  ESP_ERROR_CHECK(esp_lcd_panel_reset(this->handle_));
+  ESP_ERROR_CHECK(esp_lcd_panel_init(this->handle_));
   if (err != ESP_OK) {
     esph_log_e(TAG, "lcd_new_rgb_panel failed: %s", esp_err_to_name(err));
   }
-  ESP_ERROR_CHECK(esp_lcd_panel_reset(this->handle_));
-  ESP_ERROR_CHECK(esp_lcd_panel_init(this->handle_));
-  this->write_init_sequence_();
   esph_log_config(TAG, "ST7701S setup complete");
 }
 
+void ST7701S::loop() {
+#if ESP_IDF_VERSION_MAJOR >= 5
+  if (this->handle_ != nullptr)
+    esp_lcd_rgb_panel_restart(this->handle_);
+#endif  // ESP_IDF_VERSION_MAJOR
+}
+
 void ST7701S::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                              display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
   if (w <= 0 || h <= 0)
@@ -160,10 +171,12 @@ void ST7701S::write_init_sequence_() {
   this->write_data_(val);
   ESP_LOGD(TAG, "write MADCTL %X", val);
   this->write_command_(this->invert_colors_ ? INVERT_ON : INVERT_OFF);
-  this->set_timeout(120, [this] {
-    this->write_command_(SLEEP_OUT);
-    this->write_command_(DISPLAY_ON);
-  });
+  // can't avoid this inline delay due to the need to complete setup before anything else tries to draw.
+  delay(120);  // NOLINT
+  this->write_command_(SLEEP_OUT);
+  this->write_command_(DISPLAY_ON);
+  this->spi_teardown();  // SPI not needed after this
+  delay(10);
 }
 
 void ST7701S::dump_config() {

esphome/components/st7701s/st7701s.h

@@ -33,6 +33,8 @@ class ST7701S : public display::Display,
  public:
   void update() override { this->do_update_(); }
   void setup() override;
+  void complete_setup_();
+  void loop() override;
   void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                       display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
 

esphome/components/switch/__init__.py

@@ -14,7 +14,7 @@ from esphome.const import (
     CONF_ON_TURN_ON,
     CONF_RESTORE_MODE,
     CONF_TRIGGER_ID,
-    CONF_WEB_SERVER_ID,
+    CONF_WEB_SERVER,
     DEVICE_CLASS_EMPTY,
     DEVICE_CLASS_OUTLET,
     DEVICE_CLASS_SWITCH,
@@ -156,9 +156,8 @@ async def setup_switch_core_(var, config):
         mqtt_ = cg.new_Pvariable(mqtt_id, var)
         await mqtt.register_mqtt_component(mqtt_, config)
 
-    if (webserver_id := config.get(CONF_WEB_SERVER_ID)) is not None:
-        web_server_ = await cg.get_variable(webserver_id)
-        web_server.add_entity_to_sorting_list(web_server_, var, config)
+    if web_server_config := config.get(CONF_WEB_SERVER):
+        await web_server.add_entity_config(var, web_server_config)
 
     if (device_class := config.get(CONF_DEVICE_CLASS)) is not None:
         cg.add(var.set_device_class(device_class))

esphome/components/tca9555/__init__.py

@@ -0,0 +1,72 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import i2c
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_INPUT,
+    CONF_INVERTED,
+    CONF_MODE,
+    CONF_NUMBER,
+    CONF_OUTPUT,
+)
+
+CODEOWNERS = ["@mobrembski"]
+
+AUTO_LOAD = ["gpio_expander"]
+DEPENDENCIES = ["i2c"]
+MULTI_CONF = True
+
+tca9555_ns = cg.esphome_ns.namespace("tca9555")
+
+TCA9555Component = tca9555_ns.class_("TCA9555Component", cg.Component, i2c.I2CDevice)
+TCA9555GPIOPin = tca9555_ns.class_("TCA9555GPIOPin", cg.GPIOPin)
+
+CONF_TCA9555 = "tca9555"
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.declare_id(TCA9555Component),
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x21))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+
+def validate_mode(value):
+    if not (value[CONF_INPUT] or value[CONF_OUTPUT]):
+        raise cv.Invalid("Mode must be either input or output")
+    if value[CONF_INPUT] and value[CONF_OUTPUT]:
+        raise cv.Invalid("Mode must be either input or output")
+    return value
+
+
+TCA9555_PIN_SCHEMA = pins.gpio_base_schema(
+    TCA9555GPIOPin,
+    cv.int_range(min=0, max=15),
+    modes=[CONF_INPUT, CONF_OUTPUT],
+    mode_validator=validate_mode,
+    invertable=True,
+).extend(
+    {
+        cv.Required(CONF_TCA9555): cv.use_id(TCA9555Component),
+    }
+)
+
+
+@pins.PIN_SCHEMA_REGISTRY.register(CONF_TCA9555, TCA9555_PIN_SCHEMA)
+async def tca9555_pin_to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_parented(var, config[CONF_TCA9555])
+
+    cg.add(var.set_pin(config[CONF_NUMBER]))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
+    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
+    return var

esphome/components/tca9555/tca9555.cpp

@@ -0,0 +1,140 @@
+#include "tca9555.h"
+#include "esphome/core/log.h"
+
+static const uint8_t TCA9555_INPUT_PORT_REGISTER_0 = 0x00;
+static const uint8_t TCA9555_INPUT_PORT_REGISTER_1 = 0x01;
+static const uint8_t TCA9555_OUTPUT_PORT_REGISTER_0 = 0x02;
+static const uint8_t TCA9555_OUTPUT_PORT_REGISTER_1 = 0x03;
+static const uint8_t TCA9555_POLARITY_REGISTER_0 = 0x04;
+static const uint8_t TCA9555_POLARITY_REGISTER_1 = 0x05;
+static const uint8_t TCA9555_CONFIGURATION_PORT_0 = 0x06;
+static const uint8_t TCA9555_CONFIGURATION_PORT_1 = 0x07;
+
+namespace esphome {
+namespace tca9555 {
+
+static const char *const TAG = "tca9555";
+
+void TCA9555Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up TCA9555...");
+  if (!this->read_gpio_modes_()) {
+    this->mark_failed();
+    return;
+  }
+  if (!this->read_gpio_outputs_()) {
+    this->mark_failed();
+    return;
+  }
+}
+void TCA9555Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "TCA9555:");
+  LOG_I2C_DEVICE(this)
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, "Communication with TCA9555 failed!");
+  }
+}
+void TCA9555Component::pin_mode(uint8_t pin, gpio::Flags flags) {
+  if (flags == gpio::FLAG_INPUT) {
+    // Set mode mask bit
+    this->mode_mask_ |= 1 << pin;
+  } else if (flags == gpio::FLAG_OUTPUT) {
+    // Clear mode mask bit
+    this->mode_mask_ &= ~(1 << pin);
+  }
+  // Write GPIO to enable input mode
+  this->write_gpio_modes_();
+}
+void TCA9555Component::loop() { this->reset_pin_cache_(); }
+
+bool TCA9555Component::read_gpio_outputs_() {
+  if (this->is_failed())
+    return false;
+  uint8_t data[2];
+  if (!this->read_bytes(TCA9555_OUTPUT_PORT_REGISTER_0, data, 2)) {
+    this->status_set_warning("Failed to read output register");
+    return false;
+  }
+  this->output_mask_ = (uint16_t(data[1]) << 8) | (uint16_t(data[0]) << 0);
+  this->status_clear_warning();
+  return true;
+}
+
+bool TCA9555Component::read_gpio_modes_() {
+  if (this->is_failed())
+    return false;
+  uint8_t data[2];
+  bool success = this->read_bytes(TCA9555_CONFIGURATION_PORT_0, data, 2);
+  if (!success) {
+    this->status_set_warning("Failed to read mode register");
+    return false;
+  }
+  this->mode_mask_ = (uint16_t(data[1]) << 8) | (uint16_t(data[0]) << 0);
+
+  this->status_clear_warning();
+  return true;
+}
+bool TCA9555Component::digital_read_hw(uint8_t pin) {
+  if (this->is_failed())
+    return false;
+  bool success;
+  uint8_t data[2];
+  success = this->read_bytes(TCA9555_INPUT_PORT_REGISTER_0, data, 2);
+  this->input_mask_ = (uint16_t(data[1]) << 8) | (uint16_t(data[0]) << 0);
+
+  if (!success) {
+    this->status_set_warning("Failed to read input register");
+    return false;
+  }
+
+  this->status_clear_warning();
+  return true;
+}
+
+void TCA9555Component::digital_write_hw(uint8_t pin, bool value) {
+  if (this->is_failed())
+    return;
+
+  if (value) {
+    this->output_mask_ |= (1 << pin);
+  } else {
+    this->output_mask_ &= ~(1 << pin);
+  }
+
+  uint8_t data[2];
+  data[0] = this->output_mask_;
+  data[1] = this->output_mask_ >> 8;
+  if (!this->write_bytes(TCA9555_OUTPUT_PORT_REGISTER_0, data, 2)) {
+    this->status_set_warning("Failed to write output register");
+    return;
+  }
+
+  this->status_clear_warning();
+}
+
+bool TCA9555Component::write_gpio_modes_() {
+  if (this->is_failed())
+    return false;
+  uint8_t data[2];
+
+  data[0] = this->mode_mask_;
+  data[1] = this->mode_mask_ >> 8;
+  if (!this->write_bytes(TCA9555_CONFIGURATION_PORT_0, data, 2)) {
+    this->status_set_warning("Failed to write mode register");
+    return false;
+  }
+  this->status_clear_warning();
+  return true;
+}
+
+bool TCA9555Component::digital_read_cache(uint8_t pin) { return this->input_mask_ & (1 << pin); }
+
+float TCA9555Component::get_setup_priority() const { return setup_priority::IO; }
+
+void TCA9555GPIOPin::setup() { this->pin_mode(this->flags_); }
+void TCA9555GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
+bool TCA9555GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
+void TCA9555GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
+std::string TCA9555GPIOPin::dump_summary() const { return str_sprintf("%u via TCA9555", this->pin_); }
+
+}  // namespace tca9555
+}  // namespace esphome

esphome/components/tca9555/tca9555.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include "esphome/components/gpio_expander/cached_gpio.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace tca9555 {
+
+class TCA9555Component : public Component,
+                         public i2c::I2CDevice,
+                         public gpio_expander::CachedGpioExpander<uint8_t, 16> {
+ public:
+  TCA9555Component() = default;
+
+  /// Check i2c availability and setup masks
+  void setup() override;
+  void pin_mode(uint8_t pin, gpio::Flags flags);
+
+  float get_setup_priority() const override;
+
+  void dump_config() override;
+
+  void loop() override;
+
+ protected:
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
+  /// Mask for the pin mode - 1 means output, 0 means input
+  uint16_t mode_mask_{0x00};
+  /// The mask to write as output state - 1 means HIGH, 0 means LOW
+  uint16_t output_mask_{0x00};
+  /// The state read in digital_read_hw - 1 means HIGH, 0 means LOW
+  uint16_t input_mask_{0x00};
+
+  bool read_gpio_modes_();
+  bool write_gpio_modes_();
+  bool read_gpio_outputs_();
+};
+
+/// Helper class to expose a TCA9555 pin as an internal input GPIO pin.
+class TCA9555GPIOPin : public GPIOPin, public Parented<TCA9555Component> {
+ public:
+  void setup() override;
+  void pin_mode(gpio::Flags flags) override;
+  bool digital_read() override;
+  void digital_write(bool value) override;
+  std::string dump_summary() const override;
+
+  void set_pin(uint8_t pin) { this->pin_ = pin; }
+  void set_inverted(bool inverted) { this->inverted_ = inverted; }
+  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
+
+ protected:
+  uint8_t pin_;
+  bool inverted_;
+  gpio::Flags flags_;
+};
+
+}  // namespace tca9555
+}  // namespace esphome

esphome/components/tcs34725/tcs34725.cpp

@@ -1,6 +1,8 @@
 #include "tcs34725.h"
 #include "esphome/core/log.h"
 #include "esphome/core/hal.h"
+#include <algorithm>
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace tcs34725 {
@@ -13,10 +15,7 @@ static const uint8_t TCS34725_REGISTER_ID = TCS34725_COMMAND_BIT | 0x12;
 static const uint8_t TCS34725_REGISTER_ATIME = TCS34725_COMMAND_BIT | 0x01;
 static const uint8_t TCS34725_REGISTER_CONTROL = TCS34725_COMMAND_BIT | 0x0F;
 static const uint8_t TCS34725_REGISTER_ENABLE = TCS34725_COMMAND_BIT | 0x00;
-static const uint8_t TCS34725_REGISTER_CDATAL = TCS34725_COMMAND_BIT | 0x14;
-static const uint8_t TCS34725_REGISTER_RDATAL = TCS34725_COMMAND_BIT | 0x16;
-static const uint8_t TCS34725_REGISTER_GDATAL = TCS34725_COMMAND_BIT | 0x18;
-static const uint8_t TCS34725_REGISTER_BDATAL = TCS34725_COMMAND_BIT | 0x1A;
+static const uint8_t TCS34725_REGISTER_CRGBDATAL = TCS34725_COMMAND_BIT | 0x14;
 
 void TCS34725Component::setup() {
   ESP_LOGCONFIG(TAG, "Setting up TCS34725...");
@@ -74,20 +73,21 @@ float TCS34725Component::get_setup_priority() const { return setup_priority::DAT
  *  @return Color temperature in degrees Kelvin
  */
 void TCS34725Component::calculate_temperature_and_lux_(uint16_t r, uint16_t g, uint16_t b, uint16_t c) {
-  float r2, g2, b2; /* RGB values minus IR component */
-  float sat;        /* Digital saturation level */
-  float ir;         /* Inferred IR content */
-
-  this->illuminance_ = 0;  // Assign 0 value before calculation
-  this->color_temperature_ = 0;
-
-  const float ga = this->glass_attenuation_;  // Glass Attenuation Factor
-  static const float DF = 310.f;              // Device Factor
-  static const float R_COEF = 0.136f;         //
-  static const float G_COEF = 1.f;            // used in lux computation
-  static const float B_COEF = -0.444f;        //
-  static const float CT_COEF = 3810.f;        // Color Temperature Coefficient
-  static const float CT_OFFSET = 1391.f;      // Color Temperatuer Offset
+  float sat; /* Digital saturation level */
+
+  this->illuminance_ = NAN;
+  this->color_temperature_ = NAN;
+
+  const float ga = this->glass_attenuation_;            // Glass Attenuation Factor
+  static const float DF = 310.f;                        // Device Factor
+  static const float R_COEF = 0.136f;                   //
+  static const float G_COEF = 1.f;                      // used in lux computation
+  static const float B_COEF = -0.444f;                  //
+  static const float CT_COEF = 3810.f;                  // Color Temperature Coefficient
+  static const float CT_OFFSET = 1391.f;                // Color Temperatuer Offset
+  static const float MAX_ILLUMINANCE = 100000.0f;       // Cap illuminance at 100,000 lux
+  static const float MAX_COLOR_TEMPERATURE = 15000.0f;  // Maximum expected color temperature in Kelvin
+  static const float MIN_COLOR_TEMPERATURE = 1000.0f;   // Maximum reasonable color temperature in Kelvin
 
   if (c == 0) {
     return;
@@ -138,69 +138,66 @@ void TCS34725Component::calculate_temperature_and_lux_(uint16_t r, uint16_t g, u
   if (c >= sat) {
     if (this->integration_time_auto_) {
       ESP_LOGI(TAG, "Saturation too high, sample discarded, autogain ongoing");
+      return;
     } else {
-      ESP_LOGW(
-          TAG,
-          "Saturation too high, sample with saturation %.1f and clear %d treat values carefully or use grey filter",
-          sat, c);
-    }
-  }
-
-  /* AMS RGB sensors have no IR channel, so the IR content must be */
-  /* calculated indirectly. */
-  ir = ((r + g + b) > c) ? (r + g + b - c) / 2 : 0;
-
-  /* Remove the IR component from the raw RGB values */
-  r2 = r - ir;
-  g2 = g - ir;
-  b2 = b - ir;
-
-  // discarding super low values? not recemmonded, and avoided by using auto gain.
-  if (r2 == 0) {
-    // legacy code
-    if (!this->integration_time_auto_) {
       ESP_LOGW(TAG,
-               "No light detected on red channel, switch to auto gain or adjust timing, values will be unreliable");
+               "Saturation too high, sample with saturation %.1f and clear %d lux/color temperature cannot reliably "
+               "calculated, reduce integration/gain or use a grey filter.",
+               sat, c);
       return;
     }
   }
 
   // Lux Calculation (DN40 3.2)
 
-  float g1 = R_COEF * r2 + G_COEF * g2 + B_COEF * b2;
+  float g1 = R_COEF * (float) r + G_COEF * (float) g + B_COEF * (float) b;
   float cpl = (this->integration_time_ * this->gain_) / (ga * DF);
-  this->illuminance_ = g1 / cpl;
 
-  // Color Temperature Calculation (DN40)
-  /* A simple method of measuring color temp is to use the ratio of blue */
-  /* to red light, taking IR cancellation into account. */
-  this->color_temperature_ = (CT_COEF * b2) / /** Color temp coefficient. */
-                                 r2 +
-                             CT_OFFSET; /** Color temp offset. */
-}
+  this->illuminance_ = std::max(g1 / cpl, 0.0f);
 
-void TCS34725Component::update() {
-  uint16_t raw_c;
-  uint16_t raw_r;
-  uint16_t raw_g;
-  uint16_t raw_b;
-
-  if (this->read_data_register_(TCS34725_REGISTER_CDATAL, raw_c) != i2c::ERROR_OK) {
-    this->status_set_warning();
+  if (this->illuminance_ > MAX_ILLUMINANCE) {
+    ESP_LOGW(TAG, "Calculated illuminance greater than limit (%f), setting to NAN", this->illuminance_);
+    this->illuminance_ = NAN;
     return;
   }
-  if (this->read_data_register_(TCS34725_REGISTER_RDATAL, raw_r) != i2c::ERROR_OK) {
-    this->status_set_warning();
+
+  if (r == 0) {
+    ESP_LOGW(TAG, "Red channel is zero, cannot compute color temperature");
     return;
   }
-  if (this->read_data_register_(TCS34725_REGISTER_GDATAL, raw_g) != i2c::ERROR_OK) {
-    this->status_set_warning();
-    return;
+
+  // Color Temperature Calculation (DN40)
+  /* A simple method of measuring color temp is to use the ratio of blue */
+  /* to red light. */
+
+  this->color_temperature_ = (CT_COEF * (float) b) / (float) r + CT_OFFSET;
+
+  // Ensure the color temperature stays within reasonable bounds
+  if (this->color_temperature_ < MIN_COLOR_TEMPERATURE) {
+    ESP_LOGW(TAG, "Calculated color temperature value too low (%f), setting to NAN", this->color_temperature_);
+    this->color_temperature_ = NAN;
+  } else if (this->color_temperature_ > MAX_COLOR_TEMPERATURE) {
+    ESP_LOGW(TAG, "Calculated color temperature value too high (%f), setting to NAN", this->color_temperature_);
+    this->color_temperature_ = NAN;
   }
-  if (this->read_data_register_(TCS34725_REGISTER_BDATAL, raw_b) != i2c::ERROR_OK) {
+}
+
+void TCS34725Component::update() {
+  uint8_t data[8];  // Buffer to hold the 8 bytes (2 bytes for each of the 4 channels)
+
+  // Perform burst
+  if (this->read_register(TCS34725_REGISTER_CRGBDATAL, data, 8) != i2c::ERROR_OK) {
     this->status_set_warning();
+    ESP_LOGW(TAG, "Error reading TCS34725 sensor data");
     return;
   }
+
+  // Extract the data
+  uint16_t raw_c = encode_uint16(data[1], data[0]);  // Clear channel
+  uint16_t raw_r = encode_uint16(data[3], data[2]);  // Red channel
+  uint16_t raw_g = encode_uint16(data[5], data[4]);  // Green channel
+  uint16_t raw_b = encode_uint16(data[7], data[6]);  // Blue channel
+
   ESP_LOGV(TAG, "Raw values clear=%d red=%d green=%d blue=%d", raw_c, raw_r, raw_g, raw_b);
 
   float channel_c;
@@ -211,7 +208,7 @@ void TCS34725Component::update() {
   if (raw_c == 0) {
     channel_c = channel_r = channel_g = channel_b = 0.0f;
   } else {
-    float max_count = this->integration_time_ * 1024.0f / 2.4;
+    float max_count = this->integration_time_ <= 153.6f ? this->integration_time_ * 1024.0f / 2.4f : 65535.0f;
     float sum = raw_c;
     channel_r = raw_r / sum * 100.0f;
     channel_g = raw_g / sum * 100.0f;
@@ -254,7 +251,8 @@ void TCS34725Component::update() {
     // change integration time an gain to achieve maximum resolution an dynamic range
     // calculate optimal integration time to achieve 70% satuaration
     float integration_time_ideal;
-    integration_time_ideal = 60 / ((float) raw_c / 655.35) * this->integration_time_;
+
+    integration_time_ideal = 60 / ((float) std::max((uint16_t) 1, raw_c) / 655.35f) * this->integration_time_;
 
     uint8_t gain_reg_val_new = this->gain_reg_;
     // increase gain if less than 20% of white channel used and high integration time

esphome/components/tem3200/sensor.py

@@ -0,0 +1,55 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+
+from esphome.const import (
+    CONF_ID,
+    CONF_TEMPERATURE,
+    DEVICE_CLASS_TEMPERATURE,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_CELSIUS,
+)
+
+CODEOWNERS = ["@bakerkj"]
+DEPENDENCIES = ["i2c"]
+
+tem3200_ns = cg.esphome_ns.namespace("tem3200")
+
+TEM3200Component = tem3200_ns.class_(
+    "TEM3200Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+CONF_RAW_PRESSURE = "raw_pressure"
+
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(TEM3200Component),
+            cv.Optional(CONF_TEMPERATURE): sensor.sensor_schema(
+                unit_of_measurement=UNIT_CELSIUS,
+                accuracy_decimals=1,
+                device_class=DEVICE_CLASS_TEMPERATURE,
+                state_class=STATE_CLASS_MEASUREMENT,
+            ),
+            cv.Optional(CONF_RAW_PRESSURE): sensor.sensor_schema(
+                accuracy_decimals=0, state_class=STATE_CLASS_MEASUREMENT
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x28))
+)
+
+
+async def to_code(config):
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+
+    if temperature_config := config.get(CONF_TEMPERATURE):
+        sens = await sensor.new_sensor(temperature_config)
+        cg.add(var.set_temperature_sensor(sens))
+
+    if raw_pressure_config := config.get(CONF_RAW_PRESSURE):
+        sens = await sensor.new_sensor(raw_pressure_config)
+        cg.add(var.set_raw_pressure_sensor(sens))