cm1106.cpp

Go to the documentation of this file.

#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))) {
    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    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(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
    return false;
  }
  if (!this->status_comm_result(memcmp(response, ack, sizeof(response)) == 0)) {
    ESP_LOGW(TAG, "Unexpected response: %02X %02X %02X %02X", response[0], response[1], response[2], response[3]);
    return false;
  }
  return true;
}
 
bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t command_len, uint8_t *response,
                                            size_t response_len) {
  this->discard_available();
  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_);
  }
}
 
}  // namespace esphome::cm1106