esphome/esphome/components/cm1106/cm1106.cpp

#include "cm1106.h"
#include "esphome/core/log.h"

#include <cinttypes>

namespace esphome::cm1106 {

ESPHOME_LOG_TAG(TAG, "cm1106");
static constexpr uint8_t C_M1106_CMD_GET_CO2[4] = {0x11, 0x01, 0x01, 0xED};
static constexpr uint8_t C_M1106_CMD_SET_CO2_CALIB[6] = {0x11, 0x03, 0x03, 0x00, 0x00, 0x00};
static constexpr uint8_t C_M1106_CMD_SET_CO2_CALIB_RESPONSE[4] = {0x16, 0x01, 0x03, 0xE6};
// The factory default ABC calibration cycle differs between CM1106 models, so
// every ABC write applies the configured cycle and baseline explicitly.
static constexpr uint8_t C_M1106_CMD_SET_ABC_STATUS[10] = {0x11, 0x07, 0x10, 0x64, 0x00, 0x0F, 0x01, 0x90, 0x64, 0x00};
static constexpr uint8_t C_M1106_CMD_SET_ABC_STATUS_RESPONSE[4] = {0x16, 0x01, 0x10, 0xD9};

static constexpr uint8_t CM1106_ABC_FLAG_ENABLE = 0x0;
static constexpr uint8_t CM1106_ABC_FLAG_DISABLE = 0x2;
uint8_t cm1106_checksum(const uint8_t *response, size_t len) {
  uint8_t crc = 0;
  for (size_t i = 0; i < len - 1; i++) {
    crc -= response[i];
  }
  return crc;
}

void CM1106Component::setup() {
  uint8_t response[8] = {0};
  if (!this->cm1106_write_command_(C_M1106_CMD_GET_CO2, sizeof(C_M1106_CMD_GET_CO2), response, sizeof(response))) {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
    this->mark_failed();
    return;
  }

  if (this->abc_boot_logic_ != CM1106_ABC_NONE) {
    this->abc_set_(this->abc_boot_logic_ == CM1106_ABC_ENABLED);
  }
}

void CM1106Component::update() {
  uint8_t response[8] = {0};
  if (!this->cm1106_write_command_(C_M1106_CMD_GET_CO2, sizeof(C_M1106_CMD_GET_CO2), response, sizeof(response))) {
    ESP_LOGW(TAG, "Reading data failed!");
    this->status_set_warning();
    return;
  }

  if (response[0] != 0x16 || response[1] != 0x05 || response[2] != 0x01) {
    ESP_LOGW(TAG, "Unexpected response: %02X %02X %02X %02X", response[0], response[1], response[2], response[3]);
    this->status_set_warning();
    return;
  }

  uint8_t checksum = cm1106_checksum(response, sizeof(response));
  if (response[7] != checksum) {
    ESP_LOGW(TAG, "Checksum doesn't match: 0x%02X!=0x%02X", response[7], checksum);
    this->status_set_warning();
    return;
  }

  const uint16_t ppm = response[3] << 8 | response[4];
  const uint8_t status = response[5];
  if (status & 0x1) {
    ESP_LOGW(TAG, "Preheating; CO₂=%uppm", ppm);
    this->status_set_warning();
    return;
  }
  if (status) {
    ESP_LOGW(TAG, "Status: %02X", status);
  }
  this->status_clear_warning();

  ESP_LOGD(TAG, "CO₂=%uppm DF4=%02X", ppm, response[6]);
  if (this->co2_sensor_ != nullptr)
    this->co2_sensor_->publish_state(ppm);
}

void CM1106Component::calibrate_zero(uint16_t ppm) {
  uint8_t cmd[6];
  memcpy(cmd, C_M1106_CMD_SET_CO2_CALIB, sizeof(cmd));
  cmd[3] = ppm >> 8;
  cmd[4] = ppm & 0xFF;
  if (this->send_command_expect_ack_(cmd, sizeof(cmd), C_M1106_CMD_SET_CO2_CALIB_RESPONSE)) {
    ESP_LOGD(TAG, "Successfully calibrated sensor to %uppm", ppm);
  }
}

void CM1106Component::abc_set_(bool enabled) {
  ESP_LOGD(TAG, "%sabling automatic baseline calibration", enabled ? LOG_STR_LITERAL("En") : LOG_STR_LITERAL("Dis"));
  uint8_t cmd[10];
  memcpy(cmd, C_M1106_CMD_SET_ABC_STATUS, sizeof(cmd));
  cmd[4] = enabled ? CM1106_ABC_FLAG_ENABLE : CM1106_ABC_FLAG_DISABLE;
  cmd[5] = this->abc_cycle_;
  cmd[6] = this->abc_baseline_ >> 8;
  cmd[7] = this->abc_baseline_ & 0xFF;
  if (this->send_command_expect_ack_(cmd, sizeof(cmd), C_M1106_CMD_SET_ABC_STATUS_RESPONSE)) {
    ESP_LOGD(TAG, "Successfully set ABC status");
  }
}

bool CM1106Component::send_command_expect_ack_(const uint8_t *command, size_t command_len, const uint8_t *ack) {
  uint8_t response[4] = {0};
  if (!this->cm1106_write_command_(command, command_len, response, sizeof(response))) {
    ESP_LOGW(TAG, "Command %02X failed", command[2]);
    this->status_set_warning();
    return false;
  }
  if (memcmp(response, ack, sizeof(response)) != 0) {
    ESP_LOGW(TAG, "Unexpected response: %02X %02X %02X %02X", response[0], response[1], response[2], response[3]);
    this->status_set_warning();
    return false;
  }
  this->status_clear_warning();
  return true;
}

bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t command_len, uint8_t *response,
                                            size_t response_len) {
  // Empty RX Buffer
  while (this->available())
    this->read();
  this->write_array(command, command_len - 1);
  this->write_byte(cm1106_checksum(command, command_len));
  this->flush();

  if (response == nullptr)
    return true;

  return this->read_array(response, response_len);
}

void CM1106Component::dump_config() {
  ESP_LOGCONFIG(TAG, "CM1106:");
  LOG_SENSOR("  ", "CO2", this->co2_sensor_);
  if (this->abc_boot_logic_ != CM1106_ABC_NONE) {
    ESP_LOGCONFIG(TAG,
                  "  Automatic baseline calibration on boot: %s\n"
                  "  ABC calibration cycle: %u days\n"
                  "  ABC baseline: %uppm",
                  ONOFF(this->abc_boot_logic_ == CM1106_ABC_ENABLED), this->abc_cycle_, this->abc_baseline_);
  }
  if (this->is_failed()) {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
  }
}

}  // namespace esphome::cm1106