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

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))

esphome/components/tem3200/tem3200.cpp

@@ -0,0 +1,151 @@
+#include "tem3200.h"
+#include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
+
+namespace esphome {
+namespace tem3200 {
+
+static const char *const TAG = "tem3200";
+
+enum ErrorCode {
+  NONE = 0,
+  RESERVED = 1,
+  STALE = 2,
+  FAULT = 3,
+};
+
+void TEM3200Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up TEM3200...");
+
+  uint8_t status(NONE);
+  uint16_t raw_temperature(0);
+  uint16_t raw_pressure(0);
+
+  i2c::ErrorCode err = this->read_(status, raw_temperature, raw_pressure);
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGCONFIG(TAG, "    I2C Communication Failed...");
+    this->mark_failed();
+    return;
+  }
+
+  switch (status) {
+    case RESERVED:
+      ESP_LOGE(TAG, "Invalid RESERVED Device Status");
+      this->mark_failed();
+      return;
+    case FAULT:
+      ESP_LOGE(TAG, "FAULT condition in the SSC or sensing element");
+      this->mark_failed();
+      return;
+    case STALE:
+      ESP_LOGE(TAG, "STALE data. Data has not been updated since last fetch");
+      this->status_set_warning();
+      break;
+  }
+  ESP_LOGCONFIG(TAG, "    Success...");
+}
+
+void TEM3200Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "TEM3200:");
+  LOG_I2C_DEVICE(this);
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Raw Pressure", this->raw_pressure_sensor_);
+  LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+}
+
+float TEM3200Component::get_setup_priority() const { return setup_priority::DATA; }
+
+i2c::ErrorCode TEM3200Component::read_(uint8_t &status, uint16_t &raw_temperature, uint16_t &raw_pressure) {
+  uint8_t response[4] = {0x00, 0x00, 0x00, 0x00};
+
+  // initiate data read
+  i2c::ErrorCode err = this->read(response, 4);
+  if (err != i2c::ERROR_OK) {
+    return err;
+  }
+
+  // extract top 2 bits of first byte for status
+  status = (ErrorCode) (response[0] & 0xc0) >> 6;
+  if (status == RESERVED || status == FAULT) {
+    return i2c::ERROR_OK;
+  }
+
+  // if data is stale; reread
+  if (status == STALE) {
+    // wait for measurement 2ms
+    delay(2);
+
+    err = this->read(response, 4);
+    if (err != i2c::ERROR_OK) {
+      return err;
+    }
+  }
+
+  // extract top 2 bits of first byte for status
+  status = (ErrorCode) (response[0] & 0xc0) >> 6;
+  if (status == RESERVED || status == FAULT) {
+    return i2c::ERROR_OK;
+  }
+
+  // extract top 6 bits of first byte and all bits of second byte for pressure
+  raw_pressure = (((response[0] & 0x3f)) << 8 | response[1]);
+
+  // extract all bytes of 3rd byte and top 3 bits of fourth byte for temperature
+  raw_temperature = ((response[2] << 3) | (response[3] & 0xe0) >> 5);
+
+  return i2c::ERROR_OK;
+}
+
+inline float convert_temperature(uint16_t raw_temperature) {
+  const float temperature_bits_span = 2048;
+  const float temperature_max = 150;
+  const float temperature_min = -50;
+  const float temperature_span = temperature_max - temperature_min;
+
+  float temperature = (raw_temperature * temperature_span / temperature_bits_span) + temperature_min;
+
+  return temperature;
+}
+
+void TEM3200Component::update() {
+  uint8_t status(NONE);
+  uint16_t raw_temperature(0);
+  uint16_t raw_pressure(0);
+  i2c::ErrorCode err = this->read_(status, raw_temperature, raw_pressure);
+
+  if (err != i2c::ERROR_OK) {
+    ESP_LOGW(TAG, "I2C Communication Failed");
+    this->status_set_warning();
+    return;
+  }
+
+  switch (status) {
+    case RESERVED:
+      ESP_LOGE(TAG, "Failed: Device return RESERVED status");
+      this->status_set_warning();
+      return;
+    case FAULT:
+      ESP_LOGE(TAG, "Failed: FAULT condition in the SSC or sensing element");
+      this->mark_failed();
+      return;
+    case STALE:
+      ESP_LOGE(TAG, "Warning: STALE data. Data has not been updated since last fetch");
+      this->status_set_warning();
+      return;
+  }
+
+  float temperature = convert_temperature(raw_temperature);
+
+  ESP_LOGD(TAG, "Got raw pressure=%d, temperature=%.1f°C", raw_pressure, temperature);
+
+  if (this->temperature_sensor_ != nullptr)
+    this->temperature_sensor_->publish_state(temperature);
+  if (this->raw_pressure_sensor_ != nullptr)
+    this->raw_pressure_sensor_->publish_state(raw_pressure);
+
+  this->status_clear_warning();
+}
+
+}  // namespace tem3200
+}  // namespace esphome