Add new component - Emporia Vue

CODEOWNERS

@@ -51,6 +51,7 @@ esphome/components/dfplayer/* @glmnet
 esphome/components/dht/* @OttoWinter
 esphome/components/ds1307/* @badbadc0ffee
 esphome/components/dsmr/* @glmnet @zuidwijk
+esphome/components/emporia_vue/* @Maelstrom96 @flaviut @krconv
 esphome/components/esp32/* @esphome/core
 esphome/components/esp32_ble/* @jesserockz
 esphome/components/esp32_ble_server/* @jesserockz

esphome/components/emporia_vue/emporia_vue.cpp

@@ -0,0 +1,159 @@
+#include "emporia_vue.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+namespace emporia_vue {
+
+static const char *const TAG = "emporia_vue";
+
+// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
+EmporiaVueComponent *global_emporia_vue_component = nullptr;
+
+void EmporiaVueComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Emporia Vue");
+  LOG_I2C_DEVICE(this);
+  ESP_LOGCONFIG(TAG, "  Sensor Poll Interval: %dms", this->sensor_poll_interval_);
+
+  for (auto *phase : this->phases_) {
+    std::string wire;
+    switch (phase->get_input_wire()) {
+      case PhaseInputWire::BLACK:
+        wire = "BLACK";
+        break;
+      case PhaseInputWire::RED:
+        wire = "RED";
+        break;
+      case PhaseInputWire::BLUE:
+        wire = "BLUE";
+        break;
+    }
+    ESP_LOGCONFIG(TAG, "  Phase Config");
+    ESP_LOGCONFIG(TAG, "    Wire: %s", wire.c_str());
+    ESP_LOGCONFIG(TAG, "    Calibration: %f", phase->get_calibration());
+    LOG_SENSOR("    ", "Voltage", phase->get_voltage_sensor());
+  }
+
+  for (auto *ct_sensor : this->ct_sensors_) {
+    LOG_SENSOR("  ", "CT", ct_sensor);
+    ESP_LOGCONFIG(TAG, "    Phase Calibration: %f", ct_sensor->get_phase()->get_calibration());
+    ESP_LOGCONFIG(TAG, "    CT Port Index: %d", ct_sensor->get_input_port());
+  }
+}
+
+void EmporiaVueComponent::setup() {
+#ifdef USING_OTA_COMPONENT
+  // OTA callback to prevent the i2c task to crash
+  if (this->ota_) {
+    ESP_LOGV(TAG, "Adding OTA state callback");
+    this->ota_->add_on_state_callback([this](ota::OTAState state, float var, uint8_t error_code) {
+      eTaskState i2c_request_task_status = eTaskGetState(this->i2c_request_task_);
+
+      if (state == ota::OTAState::OTA_STARTED &&
+          (i2c_request_task_status == eRunning || i2c_request_task_status == eReady ||
+           i2c_request_task_status == eBlocked)) {
+        ESP_LOGV(TAG, "OTA Update started - Suspending i2c_request_task_");
+        vTaskSuspend(this->i2c_request_task_);
+      }
+      if (state == ota::OTAState::OTA_ERROR && i2c_request_task_status == eSuspended) {
+        ESP_LOGV(TAG, "OTA Update failed - Resuming i2c_request_task_");
+        vTaskResume(this->i2c_request_task_);
+      }
+    });
+  }
+#endif
+
+  global_emporia_vue_component = this;
+
+  this->i2c_data_queue_ = xQueueCreate(1, sizeof(SensorReading));
+  xTaskCreatePinnedToCore(&EmporiaVueComponent::i2c_request_task, "i2c_request_task", 4096, nullptr, 0,
+                          &this->i2c_request_task_, 0);
+}
+
+void EmporiaVueComponent::i2c_request_task(void *pv) {
+  const TickType_t poll_interval = global_emporia_vue_component->get_sensor_poll_interval() / portTICK_PERIOD_MS;
+  TickType_t last_poll;
+  uint8_t last_sequence_num = 0;
+
+  while (true) {
+    last_poll = xTaskGetTickCount();
+    SensorReading sensor_reading;
+
+    i2c::ErrorCode err =
+        global_emporia_vue_component->read(reinterpret_cast<uint8_t *>(&sensor_reading), sizeof(sensor_reading));
+
+    if (err != i2c::ErrorCode::ERROR_OK) {
+      ESP_LOGE(TAG, "Failed to read from sensor due to I2C error %d", err);
+    } else if (sensor_reading.end != 0) {
+      ESP_LOGE(TAG, "Failed to read from sensor due to a malformed reading, should end in null bytes but is %d",
+               sensor_reading.end);
+    } else if (!sensor_reading.is_unread) {
+      ESP_LOGV(TAG, "Ignoring sensor reading that is marked as read");
+    } else {
+      if (last_sequence_num && sensor_reading.sequence_num > last_sequence_num + 1) {
+        ESP_LOGW(TAG, "Detected %d missing reading(s), data may not be accurate!",
+                 sensor_reading.sequence_num - last_sequence_num - 1);
+      }
+
+      xQueueOverwrite(global_emporia_vue_component->i2c_data_queue_, &sensor_reading);
+      ESP_LOGV(TAG, "Added sensor reading with sequence number %d to queue", sensor_reading.sequence_num);
+
+      last_sequence_num = sensor_reading.sequence_num;
+    }
+    vTaskDelayUntil(&last_poll, poll_interval);
+  }
+}
+
+void EmporiaVueComponent::loop() {
+  SensorReading sensor_reading;
+
+  if (xQueueReceive(this->i2c_data_queue_, &sensor_reading, 0) == pdTRUE) {
+    ESP_LOGV(TAG, "Received sensor reading with sequence number %d from queue", sensor_reading.sequence_num);
+    for (PhaseConfig *phase : this->phases_) {
+      phase->update_from_reading(sensor_reading);
+    }
+
+    for (CTSensor *ct_sensor : this->ct_sensors_) {
+      ct_sensor->update_from_reading(sensor_reading);
+    }
+  }
+}
+
+void PhaseConfig::update_from_reading(const SensorReading &sensor_reading) {
+  if (this->voltage_sensor_) {
+    float calibrated_voltage = sensor_reading.voltage[this->input_wire_] * this->calibration_;
+    this->voltage_sensor_->publish_state(calibrated_voltage);
+  }
+}
+
+int32_t PhaseConfig::extract_power_for_phase(const ReadingPowerEntry &power_entry) {
+  switch (this->input_wire_) {
+    case PhaseInputWire::BLACK:
+      return power_entry.phase_black;
+    case PhaseInputWire::RED:
+      return power_entry.phase_red;
+    case PhaseInputWire::BLUE:
+      return power_entry.phase_blue;
+    default:
+      ESP_LOGE(TAG, "Unsupported phase input wire, this should never happen");
+      return -1;
+  }
+}
+
+void CTSensor::update_from_reading(const SensorReading &sensor_reading) {
+  ReadingPowerEntry power_entry = sensor_reading.power[this->input_port_];
+  int32_t raw_power = this->phase_->extract_power_for_phase(power_entry);
+  float calibrated_power = this->get_calibrated_power(raw_power);
+  this->publish_state(calibrated_power);
+}
+
+float CTSensor::get_calibrated_power(int32_t raw_power) const {
+  float calibration = this->phase_->get_calibration();
+
+  float correction_factor = (this->input_port_ < 3) ? 5.5 : 22;
+
+  return (raw_power * calibration) / correction_factor;
+}
+
+}  // namespace emporia_vue
+}  // namespace esphome

esphome/components/emporia_vue/emporia_vue.h

@@ -0,0 +1,142 @@
+#pragma once
+
+#ifdef USE_ESP32
+
+#include <vector>
+
+#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#include "esphome/components/i2c/i2c.h"
+#include "esphome/components/sensor/sensor.h"
+
+#ifdef USING_OTA_COMPONENT
+#include "esphome/components/ota/ota_component.h"
+#endif
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+#include <freertos/task.h>
+
+namespace esphome {
+namespace emporia_vue {
+
+struct __attribute__((__packed__)) ReadingPowerEntry {
+  int32_t phase_black;
+  int32_t phase_red;
+  int32_t phase_blue;
+};
+
+struct __attribute__((__packed__)) SensorReading {
+  bool is_unread;
+  uint8_t checksum;
+  uint8_t unknown;
+  uint8_t sequence_num;
+
+  ReadingPowerEntry power[19];
+
+  uint16_t voltage[3];
+  uint16_t frequency;
+  uint16_t degrees[2];
+
+  uint16_t current[19];
+
+  uint16_t end;
+};
+
+class PhaseConfig;
+class CTSensor;
+
+class EmporiaVueComponent : public Component, public i2c::I2CDevice {
+ public:
+  void dump_config() override;
+
+  void set_sensor_poll_interval(uint32_t sensor_poll_interval) { this->sensor_poll_interval_ = sensor_poll_interval; }
+  uint32_t get_sensor_poll_interval() const { return this->sensor_poll_interval_; }
+  void set_phases(std::vector<PhaseConfig *> phases) { this->phases_ = std::move(phases); }
+  void set_ct_sensors(std::vector<CTSensor *> sensors) { this->ct_sensors_ = std::move(sensors); }
+#ifdef USING_OTA_COMPONENT
+  void set_ota(ota::OTAComponent *ota) { this->ota_ = ota; }
+#endif
+
+  void setup() override;
+  void loop() override;
+
+ protected:
+  static void i2c_request_task(void *pv);
+
+  uint32_t sensor_poll_interval_;
+  std::vector<PhaseConfig *> phases_;
+  std::vector<CTSensor *> ct_sensors_;
+  QueueHandle_t i2c_data_queue_;
+#ifdef USING_OTA_COMPONENT
+  ota::OTAComponent *ota_{nullptr};
+#endif
+  TaskHandle_t i2c_request_task_;
+};
+
+enum PhaseInputWire : uint8_t {
+  BLACK = 0,
+  RED = 1,
+  BLUE = 2,
+};
+
+class PhaseConfig {
+ public:
+  void set_input_wire(PhaseInputWire input_wire) { this->input_wire_ = input_wire; }
+  PhaseInputWire get_input_wire() const { return this->input_wire_; }
+  void set_calibration(float calibration) { this->calibration_ = calibration; }
+  float get_calibration() const { return this->calibration_; }
+  void set_voltage_sensor(sensor::Sensor *voltage_sensor) { this->voltage_sensor_ = voltage_sensor; }
+  sensor::Sensor *get_voltage_sensor() const { return this->voltage_sensor_; }
+
+  void update_from_reading(const SensorReading &sensor_reading);
+
+  int32_t extract_power_for_phase(const ReadingPowerEntry &power_entry);
+
+ protected:
+  PhaseInputWire input_wire_;
+  float calibration_;
+  sensor::Sensor *voltage_sensor_{nullptr};
+};
+
+enum CTInputPort : uint8_t {
+  A = 0,
+  B = 1,
+  C = 2,
+  ONE = 3,
+  TWO = 4,
+  THREE = 5,
+  FOUR = 6,
+  FIVE = 7,
+  SIX = 8,
+  SEVEN = 9,
+  EIGHT = 10,
+  NINE = 11,
+  TEN = 12,
+  ELEVEN = 13,
+  TWELVE = 14,
+  THIRTEEN = 15,
+  FOURTEEN = 16,
+  FIFTEEN = 17,
+  SIXTEEN = 18,
+};
+
+class CTSensor : public sensor::Sensor {
+ public:
+  void set_phase(PhaseConfig *phase) { this->phase_ = phase; };
+  const PhaseConfig *get_phase() const { return this->phase_; }
+  void set_input_port(CTInputPort input_port) { this->input_port_ = input_port; };
+  CTInputPort get_input_port() const { return this->input_port_; }
+
+  void update_from_reading(const SensorReading &sensor_reading);
+  float get_calibrated_power(int32_t raw_power) const;
+
+ protected:
+  PhaseConfig *phase_;
+  CTInputPort input_port_;
+};
+
+}  // namespace emporia_vue
+}  // namespace esphome
+
+#endif  // ifdef USE_ESP32