Add support for LTR390 (#1505)

* Add support for ltr390

* Fix linting errors

* Fix more linting errors

* Linting fixes continued

* Linting forever

* Another one

* Fix regression and linting

* Fix narrowing conversion

* Add test and bugfix

* Add codeowners

* Update CODEOWNERS

* Update sensor defs

* Reformatted with black

* Fixed device class import

* Update CODEOWNERS

* Update CODEOWNERS

* Adding all config options

As requested https://github.com/esphome/esphome/pull/1505#discussion_r597326897

* Moving test to different config file

test1.yml runs out of memory

* Update according to comments

* Add safety clause to reading modes

* Fix clang-tidy complaint

* Revert change to i2c component

* Fix for changes in dev

* Revert "Revert change to i2c component"

This reverts commit 2810df59e9.

Co-authored-by: Otto winter <otto@otto-winter.com>
Co-authored-by: Oxan van Leeuwen <oxan@oxanvanleeuwen.nl>

CODEOWNERS

@@ -74,6 +74,7 @@ esphome/components/json/* @OttoWinter
 esphome/components/ledc/* @OttoWinter
 esphome/components/light/* @esphome/core
 esphome/components/logger/* @esphome/core
+esphome/components/ltr390/* @sjtrny
 esphome/components/max7219digit/* @rspaargaren
 esphome/components/mcp23008/* @jesserockz
 esphome/components/mcp23017/* @jesserockz

esphome/components/i2c/i2c.h

@@ -13,8 +13,6 @@ namespace i2c {
 class I2CDevice;
 class I2CRegister {
  public:
-  I2CRegister(I2CDevice *parent, uint8_t a_register) : parent_(parent), register_(a_register) {}
-
   I2CRegister &operator=(uint8_t value);
   I2CRegister &operator&=(uint8_t value);
   I2CRegister &operator|=(uint8_t value);
@@ -24,6 +22,10 @@ class I2CRegister {
   uint8_t get() const;
 
  protected:
+  friend class I2CDevice;
+
+  I2CRegister(I2CDevice *parent, uint8_t a_register) : parent_(parent), register_(a_register) {}
+
   I2CDevice *parent_;
   uint8_t register_;
 };

esphome/components/ltr390/ltr390.cpp

@@ -0,0 +1,166 @@
+#include "ltr390.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+#include <bitset>
+
+namespace esphome {
+namespace ltr390 {
+
+static const char *const TAG = "ltr390";
+
+static const float GAINVALUES[5] = {1.0, 3.0, 6.0, 9.0, 18.0};
+static const float RESOLUTIONVALUE[6] = {4.0, 2.0, 1.0, 0.5, 0.25, 0.125};
+static const uint32_t MODEADDRESSES[2] = {0x0D, 0x10};
+
+uint32_t little_endian_bytes_to_int(const uint8_t *buffer, uint8_t num_bytes) {
+  uint32_t value = 0;
+
+  for (int i = 0; i < num_bytes; i++) {
+    value <<= 8;
+    value |= buffer[num_bytes - i - 1];
+  }
+
+  return value;
+}
+
+optional<uint32_t> LTR390Component::read_sensor_data_(LTR390MODE mode) {
+  const uint8_t num_bytes = 3;
+  uint8_t buffer[num_bytes];
+
+  // Wait until data available
+  const uint32_t now = millis();
+  while (true) {
+    std::bitset<8> status = this->reg(LTR390_MAIN_STATUS).get();
+    bool available = status[3];
+    if (available)
+      break;
+
+    if (millis() - now > 100) {
+      ESP_LOGW(TAG, "Sensor didn't return any data, aborting");
+      return {};
+    }
+    ESP_LOGD(TAG, "Waiting for data");
+    delay(2);
+  }
+
+  if (!this->read_bytes(MODEADDRESSES[mode], buffer, num_bytes)) {
+    ESP_LOGW(TAG, "Reading data from sensor failed!");
+    return {};
+  }
+
+  return little_endian_bytes_to_int(buffer, num_bytes);
+}
+
+void LTR390Component::read_als_() {
+  auto val = this->read_sensor_data_(LTR390_MODE_ALS);
+  if (!val.has_value())
+    return;
+  uint32_t als = *val;
+
+  if (this->light_sensor_ != nullptr) {
+    float lux = (0.6 * als) / (GAINVALUES[this->gain_] * RESOLUTIONVALUE[this->res_]) * this->wfac_;
+    this->light_sensor_->publish_state(lux);
+  }
+
+  if (this->als_sensor_ != nullptr) {
+    this->als_sensor_->publish_state(als);
+  }
+}
+
+void LTR390Component::read_uvs_() {
+  auto val = this->read_sensor_data_(LTR390_MODE_UVS);
+  if (!val.has_value())
+    return;
+  uint32_t uv = *val;
+
+  if (this->uvi_sensor_ != nullptr) {
+    this->uvi_sensor_->publish_state(uv / LTR390_SENSITIVITY * this->wfac_);
+  }
+
+  if (this->uv_sensor_ != nullptr) {
+    this->uv_sensor_->publish_state(uv);
+  }
+}
+
+void LTR390Component::read_mode_(int mode_index) {
+  // Set mode
+  LTR390MODE mode = std::get<0>(this->mode_funcs_[mode_index]);
+
+  std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
+  ctrl[LTR390_CTRL_MODE] = mode;
+  this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
+
+  // After the sensor integration time do the following
+  this->set_timeout(((uint32_t) RESOLUTIONVALUE[this->res_]) * 100, [this, mode_index]() {
+    // Read from the sensor
+    std::get<1>(this->mode_funcs_[mode_index])();
+
+    // If there are more modes to read then begin the next
+    // otherwise stop
+    if (mode_index + 1 < this->mode_funcs_.size()) {
+      this->read_mode_(mode_index + 1);
+    } else {
+      this->reading_ = false;
+    }
+  });
+}
+
+void LTR390Component::setup() {
+  ESP_LOGCONFIG(TAG, "Setting up ltr390...");
+
+  // reset
+  std::bitset<8> ctrl = this->reg(LTR390_MAIN_CTRL).get();
+  ctrl[LTR390_CTRL_RST] = true;
+  this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
+  delay(10);
+
+  // Enable
+  ctrl = this->reg(LTR390_MAIN_CTRL).get();
+  ctrl[LTR390_CTRL_EN] = true;
+  this->reg(LTR390_MAIN_CTRL) = ctrl.to_ulong();
+
+  // check enabled
+  ctrl = this->reg(LTR390_MAIN_CTRL).get();
+  bool enabled = ctrl[LTR390_CTRL_EN];
+
+  if (!enabled) {
+    ESP_LOGW(TAG, "Sensor didn't respond with enabled state");
+    this->mark_failed();
+    return;
+  }
+
+  // Set gain
+  this->reg(LTR390_GAIN) = gain_;
+
+  // Set resolution
+  uint8_t res = this->reg(LTR390_MEAS_RATE).get();
+  // resolution is in bits 5-7
+  res &= ~0b01110000;
+  res |= res << 4;
+  this->reg(LTR390_MEAS_RATE) = res;
+
+  // Set sensor read state
+  this->reading_ = false;
+
+  // If we need the light sensor then add to the list
+  if (this->light_sensor_ != nullptr || this->als_sensor_ != nullptr) {
+    this->mode_funcs_.emplace_back(LTR390_MODE_ALS, std::bind(&LTR390Component::read_als_, this));
+  }
+
+  // If we need the UV sensor then add to the list
+  if (this->uvi_sensor_ != nullptr || this->uv_sensor_ != nullptr) {
+    this->mode_funcs_.emplace_back(LTR390_MODE_UVS, std::bind(&LTR390Component::read_uvs_, this));
+  }
+}
+
+void LTR390Component::dump_config() { LOG_I2C_DEVICE(this); }
+
+void LTR390Component::update() {
+  if (!this->reading_ && !mode_funcs_.empty()) {
+    this->reading_ = true;
+    this->read_mode_(0);
+  }
+}
+
+}  // namespace ltr390
+}  // namespace esphome

esphome/components/ltr390/ltr390.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/optional.h"
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/i2c/i2c.h"
+#include <tuple>
+
+namespace esphome {
+namespace ltr390 {
+
+enum LTR390CTRL {
+  LTR390_CTRL_EN = 1,
+  LTR390_CTRL_MODE = 3,
+  LTR390_CTRL_RST = 4,
+};
+
+// enums from https://github.com/adafruit/Adafruit_LTR390/
+
+static const uint8_t LTR390_MAIN_CTRL = 0x00;
+static const uint8_t LTR390_MEAS_RATE = 0x04;
+static const uint8_t LTR390_GAIN = 0x05;
+static const uint8_t LTR390_PART_ID = 0x06;
+static const uint8_t LTR390_MAIN_STATUS = 0x07;
+static const float LTR390_SENSITIVITY = 2300.0;
+
+// Sensing modes
+enum LTR390MODE {
+  LTR390_MODE_ALS,
+  LTR390_MODE_UVS,
+};
+
+// Sensor gain levels
+enum LTR390GAIN {
+  LTR390_GAIN_1 = 0,
+  LTR390_GAIN_3,  // Default
+  LTR390_GAIN_6,
+  LTR390_GAIN_9,
+  LTR390_GAIN_18,
+};
+
+// Sensor resolution
+enum LTR390RESOLUTION {
+  LTR390_RESOLUTION_20BIT,
+  LTR390_RESOLUTION_19BIT,
+  LTR390_RESOLUTION_18BIT,  // Default
+  LTR390_RESOLUTION_17BIT,
+  LTR390_RESOLUTION_16BIT,
+  LTR390_RESOLUTION_13BIT,
+};
+
+class LTR390Component : public PollingComponent, public i2c::I2CDevice {
+ public:
+  float get_setup_priority() const override { return setup_priority::DATA; }
+  void setup() override;
+  void dump_config() override;
+  void update() override;
+
+  void set_gain_value(LTR390GAIN gain) { this->gain_ = gain; }
+  void set_res_value(LTR390RESOLUTION res) { this->res_ = res; }
+  void set_wfac_value(float wfac) { this->wfac_ = wfac; }
+
+  void set_light_sensor(sensor::Sensor *light_sensor) { this->light_sensor_ = light_sensor; }
+  void set_als_sensor(sensor::Sensor *als_sensor) { this->als_sensor_ = als_sensor; }
+  void set_uvi_sensor(sensor::Sensor *uvi_sensor) { this->uvi_sensor_ = uvi_sensor; }
+  void set_uv_sensor(sensor::Sensor *uv_sensor) { this->uv_sensor_ = uv_sensor; }
+
+ protected:
+  optional<uint32_t> read_sensor_data_(LTR390MODE mode);
+
+  void read_als_();
+  void read_uvs_();
+
+  void read_mode_(int mode_index);
+
+  bool reading_;
+
+  // a list of modes and corresponding read functions
+  std::vector<std::tuple<LTR390MODE, std::function<void()>>> mode_funcs_;
+
+  LTR390GAIN gain_;
+  LTR390RESOLUTION res_;
+  float wfac_;
+
+  sensor::Sensor *light_sensor_{nullptr};
+  sensor::Sensor *als_sensor_{nullptr};
+
+  sensor::Sensor *uvi_sensor_{nullptr};
+  sensor::Sensor *uv_sensor_{nullptr};
+};
+
+}  // namespace ltr390
+}  // namespace esphome

esphome/components/ltr390/sensor.py

@@ -0,0 +1,98 @@
+import esphome.codegen as cg
+import esphome.config_validation as cv
+from esphome.components import i2c, sensor
+from esphome.const import (
+    CONF_ID,
+    CONF_GAIN,
+    CONF_LIGHT,
+    CONF_RESOLUTION,
+    UNIT_LUX,
+    ICON_BRIGHTNESS_5,
+    DEVICE_CLASS_ILLUMINANCE,
+)
+
+CODEOWNERS = ["@sjtrny"]
+DEPENDENCIES = ["i2c"]
+
+ltr390_ns = cg.esphome_ns.namespace("ltr390")
+
+LTR390Component = ltr390_ns.class_(
+    "LTR390Component", cg.PollingComponent, i2c.I2CDevice
+)
+
+CONF_AMBIENT_LIGHT = "ambient_light"
+CONF_UV_INDEX = "uv_index"
+CONF_UV = "uv"
+CONF_WINDOW_CORRECTION_FACTOR = "window_correction_factor"
+
+UNIT_COUNTS = "#"
+UNIT_UVI = "UVI"
+
+LTR390GAIN = ltr390_ns.enum("LTR390GAIN")
+GAIN_OPTIONS = {
+    "X1": LTR390GAIN.LTR390_GAIN_1,
+    "X3": LTR390GAIN.LTR390_GAIN_3,
+    "X6": LTR390GAIN.LTR390_GAIN_6,
+    "X9": LTR390GAIN.LTR390_GAIN_9,
+    "X18": LTR390GAIN.LTR390_GAIN_18,
+}
+
+LTR390RESOLUTION = ltr390_ns.enum("LTR390RESOLUTION")
+RES_OPTIONS = {
+    20: LTR390RESOLUTION.LTR390_RESOLUTION_20BIT,
+    19: LTR390RESOLUTION.LTR390_RESOLUTION_19BIT,
+    18: LTR390RESOLUTION.LTR390_RESOLUTION_18BIT,
+    17: LTR390RESOLUTION.LTR390_RESOLUTION_17BIT,
+    16: LTR390RESOLUTION.LTR390_RESOLUTION_16BIT,
+    13: LTR390RESOLUTION.LTR390_RESOLUTION_13BIT,
+}
+
+CONFIG_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.GenerateID(): cv.declare_id(LTR390Component),
+            cv.Optional(CONF_LIGHT): sensor.sensor_schema(
+                UNIT_LUX, ICON_BRIGHTNESS_5, 1, DEVICE_CLASS_ILLUMINANCE
+            ),
+            cv.Optional(CONF_AMBIENT_LIGHT): sensor.sensor_schema(
+                UNIT_COUNTS, ICON_BRIGHTNESS_5, 1, DEVICE_CLASS_ILLUMINANCE
+            ),
+            cv.Optional(CONF_UV_INDEX): sensor.sensor_schema(
+                UNIT_UVI, ICON_BRIGHTNESS_5, 5, DEVICE_CLASS_ILLUMINANCE
+            ),
+            cv.Optional(CONF_UV): sensor.sensor_schema(
+                UNIT_COUNTS, ICON_BRIGHTNESS_5, 1, DEVICE_CLASS_ILLUMINANCE
+            ),
+            cv.Optional(CONF_GAIN, default="X3"): cv.enum(GAIN_OPTIONS),
+            cv.Optional(CONF_RESOLUTION, default=18): cv.enum(RES_OPTIONS),
+            cv.Optional(CONF_WINDOW_CORRECTION_FACTOR, default=1.0): cv.float_range(
+                min=1.0
+            ),
+        }
+    )
+    .extend(cv.polling_component_schema("60s"))
+    .extend(i2c.i2c_device_schema(0x53)),
+    cv.has_at_least_one_key(CONF_LIGHT, CONF_AMBIENT_LIGHT, CONF_UV_INDEX, CONF_UV),
+)
+
+TYPES = {
+    CONF_LIGHT: "set_light_sensor",
+    CONF_AMBIENT_LIGHT: "set_als_sensor",
+    CONF_UV_INDEX: "set_uvi_sensor",
+    CONF_UV: "set_uv_sensor",
+}
+
+
+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)
+
+    cg.add(var.set_gain_value(config[CONF_GAIN]))
+    cg.add(var.set_res_value(config[CONF_RESOLUTION]))
+    cg.add(var.set_wfac_value(config[CONF_WINDOW_CORRECTION_FACTOR]))
+
+    for key, funcName in TYPES.items():
+        if key in config:
+            sens = await sensor.new_sensor(config[key])
+            cg.add(getattr(var, funcName)(sens))

tests/test2.yaml

@@ -238,6 +238,20 @@ sensor:
       name: 'Inkbird IBS-TH1 Humidity'
     battery_level:
       name: 'Inkbird IBS-TH1 Battery Level'
+  - platform: ltr390
+    uv:
+      name: "LTR390 UV"
+    uv_index:
+      name: "LTR390 UVI"
+    light:
+      name: "LTR390 Light"
+    ambient_light:
+      name: "LTR390 ALS"
+    gain: "X3"
+    resolution: 18
+    window_correction_factor: 1.0
+    address: 0x53
+    update_interval: 60s
   - platform: sgp40
     name: 'Workshop VOC'
     update_interval: 5s