AGS10 Sensor

// The AGS10 answers a plain I2C read with 5 bytes: status, 24-bit TVOC (ppb), CRC.
// Note: the sensor requires a SLOW I2C clock (15 kHz or less) and at least
// 2 seconds between reads.
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/i2c.h"

#define I2C_MASTER_SCL_IO  22
#define I2C_MASTER_SDA_IO  21
#define I2C_MASTER_NUM     I2C_NUM_0
#define I2C_MASTER_FREQ_HZ 15000   // AGS10 maximum I2C speed
#define AGS10_ADDR         0x1A

// CRC-8, polynomial 0x31, init 0xFF (per AGS10 datasheet)
static uint8_t ags10_crc(const uint8_t *data, int len) {
    uint8_t crc = 0xFF;
    for (int i = 0; i < len; i++) {
        crc ^= data[i];
        for (int b = 0; b < 8; b++)
            crc = (crc & 0x80) ? (crc << 1) ^ 0x31 : crc << 1;
    }
    return crc;
}

void app_main(void) {
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ,
    };
    ESP_ERROR_CHECK(i2c_param_config(I2C_MASTER_NUM, &conf));
    ESP_ERROR_CHECK(i2c_driver_install(I2C_MASTER_NUM, conf.mode, 0, 0, 0));

    while (1) {
        uint8_t data[5];
        if (i2c_master_read_from_device(I2C_MASTER_NUM, AGS10_ADDR, data, 5, pdMS_TO_TICKS(1000)) == ESP_OK) {
            if (ags10_crc(data, 4) != data[4]) {
                printf("CRC error - check wiring and I2C speed\n");
            } else if (data[0] & 0x01) {
                printf("Sensor not ready (warming up)\n");
            } else {
                uint32_t tvoc = ((uint32_t)data[1] << 16) | ((uint32_t)data[2] << 8) | data[3];
                printf("TVOC: %lu ppb\n", (unsigned long)tvoc);
            }
        } else {
            printf("No response from AGS10\n");
        }
        vTaskDelay(pdMS_TO_TICKS(3000)); // At least 2 s between reads
    }
}

i2c:
  frequency: 10kHz  # the AGS10 requires 15 kHz or less
  sda: GPIO21
  scl: GPIO22

sensor:
  - platform: ags10
    tvoc:
      name: TVOC

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

#include <Arduino.h>
// The AGS10 answers directly with a 5-byte TVOC report - no external library needed.
// I2C address 0x1A; the sensor requires a SLOW I2C clock (15 kHz or less).
#include <Wire.h>

#define AGS10_ADDR 0x1A

// CRC-8, polynomial 0x31, init 0xFF (per AGS10 datasheet)
uint8_t ags10_crc(const uint8_t *data, int len) {
  uint8_t crc = 0xFF;
  for (int i = 0; i < len; i++) {
    crc ^= data[i];
    for (int b = 0; b < 8; b++)
      crc = (crc & 0x80) ? (crc << 1) ^ 0x31 : crc << 1;
  }
  return crc;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();          // SDA=GPIO21, SCL=GPIO22
  Wire.setClock(15000);  // AGS10 maximum I2C speed is 15 kHz
  Serial.println("AGS10 TVOC Sensor Example");
}

void loop() {
  // Reading returns: status, TVOC (3 bytes, big-endian, ppb), CRC
  Wire.requestFrom(AGS10_ADDR, 5);
  if (Wire.available() == 5) {
    uint8_t b[5];
    for (int i = 0; i < 5; i++) b[i] = Wire.read();

    if (ags10_crc(b, 4) != b[4]) {
      Serial.println("CRC error - check wiring and I2C speed");
    } else if (b[0] & 0x01) {
      Serial.println("Sensor not ready (warming up)");
    } else {
      uint32_t tvoc = ((uint32_t)b[1] << 16) | ((uint32_t)b[2] << 8) | b[3];
      Serial.print("TVOC: ");
      Serial.print(tvoc);
      Serial.println(" ppb");
    }
  } else {
    Serial.println("No response from AGS10");
  }
  delay(3000); // Datasheet requires at least 2 seconds between reads
}

from machine import I2C, Pin
from time import sleep

# The AGS10 requires a SLOW I2C clock (15 kHz or less) and answers a plain
# 5-byte read: status, 24-bit TVOC (ppb), CRC-8 - no driver needed.
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=10000)
AGS10_ADDR = 0x1A

def crc8(data):
    crc = 0xFF
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = ((crc << 1) ^ 0x31) & 0xFF if crc & 0x80 else (crc << 1) & 0xFF
    return crc

while True:
    data = i2c.readfrom(AGS10_ADDR, 5)
    if crc8(data[:4]) != data[4]:
        print("CRC error - check wiring and I2C speed")
    elif data[0] & 0x01:
        print("Sensor not ready (warming up)")
    else:
        tvoc = (data[1] << 16) | (data[2] << 8) | data[3]
        print("TVOC: {} ppb".format(tvoc))
    sleep(3)  # at least 2 seconds between reads