CRC Error on ESP wroom 32 when using SGP30 Sensor

[strumberr]

Hello,

I have been encountering an issue when trying to use the SGP30 air quality sensor with the ESP32, and I don't know why!
I have checked the pins and wiring multiple times, but I haven't found anything out of the ordinary...
Any help will be much appreciated.

This is the error:

Traceback (most recent call last):
  File "<stdin>", line 23, in <module>
  File "uSGP30.py", line 71, in __init__
  File "uSGP30.py", line 173, in get_serial
  File "uSGP30.py", line 223, in _i2c_read_words_from_cmd
RuntimeError: CRC Error

Here is my code:

import uSGP30
import machine

I2C_SCL_GPIO = const(22)
I2C_SDA_GPIO = const(21)
I2C_FREQ = const(4000)
i2c = machine.I2C(-1,
    scl=machine.Pin(I2C_SCL_GPIO, machine.Pin.OUT),
    sda=machine.Pin(I2C_SDA_GPIO, machine.Pin.OUT),
    freq=I2C_FREQ
)

print(i2c.scan())
sgp30 = uSGP30.SGP30(i2c)

co2eq_ppm, tvoc_ppb = sgp30.measure_iaq()
print(co2eq_ppm, tvoc_ppb)

Here is the code for the library:

from math import exp
from utime import sleep_ms
from micropython import const

# General SGP30 settings
SGP30_DEFAULT_I2C_ADDR = const(0x58)
SGP30_WORD_LEN = const(2)
SGP30_CRC8_POLYNOMIAL = const(0x31)
SGP30_CRC8_INIT = const(0xFF)
SGP30_CRC8_FINAL_XOR = const(0xFF)
SGP30_MEASURE_TEST_PASS = const(0xD400)

# SGP30 feature set measurement commands (Hex Codes)
# From datasheet section 6.3
SGP30_CMD_IAQ_INIT_HEX = [0x20, 0x03]
SGP30_CMD_IAQ_INIT_WORDS = const(0)
SGP30_CMD_IAQ_INIT_MAX_MS = const(10)
SGP30_CMD_MEASURE_IAQ_HEX = [0x20, 0x08]
SGP30_CMD_MEASURE_IAQ_WORDS = const(2)
SGP30_CMD_MEASURE_IAQ_MS = const(12)
SGP30_CMD_GET_IAQ_BASELINE_HEX = [0x20, 0x15]
SGP30_CMD_GET_IAQ_BASELINE_WORDS = const(2)
SGP30_CMD_GET_IAQ_BASELINE_MAX_MS = const(10)
SGP30_CMD_SET_IAQ_BASELINE_HEX = [0x20, 0x1E]
SGP30_CMD_SET_IAQ_BASELINE_WORDS = const(0)
SGP30_CMD_SET_IAQ_BASELINE_MAX_MS = const(10)
SGP30_CMD_SET_ABSOLUTE_HUMIDITY_HEX = [0x20, 0x61]
SGP30_CMD_SET_ABSOLUTE_HUMIDITY_WORDS = const(0)
SGP30_CMD_SET_ABSOLUTE_HUMIDITY_MAX_MS = const(10)
SGP30_CMD_MEASURE_TEST_HEX = [0x20, 0x32]
SGP30_CMD_MEASURE_TEST_WORDS = const(1)
SGP30_CMD_MEASURE_TEST_MAX_MS = const(220)
SGP30_CMD_GET_FEATURE_SET_HEX = [0x20, 0x2F]
SGP30_CMD_GET_FEATURE_SET_WORDS = const(1)
SGP30_CMD_GET_FEATURE_SET_MAX_MS = const(10)
SGP30_CMD_MEASURE_RAW_HEX = [0x20, 0x50]
SGP30_CMD_MEASURE_RAW_WORDS = const(2)
SGP30_CMD_MEASURE_RAW_MAX_MS = const(25)
SGP30_CMD_GET_TVOC_INCEPTIVE_HEX = [0x20, 0xB3]
SGP30_CMD_GET_TVOC_INCEPTIVE_WORDS = const(1)
SGP30_CMD_GET_TVOC_INCEPTIVE_MAX_MS = const(10)
SGP30_CMD_SET_TVOC_BASELINE_HEX = [0x20, 0x77]
SGP30_CMD_SET_TVOC_BASELINE_WORDS = const(0)
SGP30_CMD_SET_TVOC_BASELINE_MAX_MS = const(10)

# TODO: Soft Reset (datasheet section 6.4)

# Obtaining Serial ID (datasheet section 6.5)
SGP30_CMD_GET_SERIAL_ID_HEX = [0x36, 0x82]
SGP30_CMD_GET_SERIAL_ID_WORDS = const(3)
SGP30_CMD_GET_SERIAL_ID_MAX_MS = const(10)


class SGP30:
    """
    A driver for the SGP30 gas sensor.
    :param i2c: The "I2C" object to use. This is the only required parameter.
    :param int address: (optional) The I2C address of the device.
    :param boolean measure_test: (optional) Whether to run on-chip test during initialisation.
    :param boolean iaq_init: (optional) Whether to initialise SGP30 algorithm / baseline.
    """

    def __init__(
        self, i2c, addr=SGP30_DEFAULT_I2C_ADDR, measure_test=False, iaq_init=True
    ):
        """ Initialises the sensor and display stats """
        self._i2c = i2c
        if addr not in self._i2c.scan():
            raise IOError("No SGP30 device found on I2C bus")
        self.addr = addr
        self.serial = self.get_serial()
        self.feature_set = self.get_feature_set()
        if measure_test:
            if SGP30_MEASURE_TEST_PASS != self.measure_test():
                raise RuntimeError("Device failed the on-chip test")
        print(
            "SGP30 device discovered...\n"
            + "I2C address: "
            + str(self.addr)
            + "\n"
            + "Serial ID: "
            + str(self.serial)
            + "\n"
            + "Feature set: "
            + str(self.feature_set)
            + "\n"
            + "Initialise algo: "
            + str(iaq_init)
        )
        if iaq_init:
            self.iaq_init()

    def iaq_init(self):
        """ Initialises the IAQ algorithm """
        self._i2c_read_words_from_cmd(
            SGP30_CMD_IAQ_INIT_HEX, SGP30_CMD_IAQ_INIT_MAX_MS, SGP30_CMD_IAQ_INIT_WORDS
        )

    def measure_iaq(self):
        """ Measures the CO2eq and TVOC """
        return self._i2c_read_words_from_cmd(
            SGP30_CMD_MEASURE_IAQ_HEX,
            SGP30_CMD_MEASURE_IAQ_MS,
            SGP30_CMD_MEASURE_IAQ_WORDS,
        )

    def get_iaq_baseline(self):
        """ Retreives the IAQ algorithm baseline for CO2eq and TVOC """
        return self._i2c_read_words_from_cmd(
            SGP30_CMD_GET_IAQ_BASELINE_HEX,
            SGP30_CMD_GET_IAQ_BASELINE_MAX_MS,
            SGP30_CMD_GET_IAQ_BASELINE_WORDS,
        )

    def set_iaq_baseline(self, co2eq, tvoc):
        """ Sets the previously recorded IAQ algorithm baseline for CO2eq and TVOC """
        if co2eq == 0 and tvoc == 0:
            raise ValueError("Invalid baseline values used")
        buffer = []
        for value in [tvoc, co2eq]:
            arr = [value >> 8, value & 0xFF]
            arr.append(generate_crc(arr))
            buffer += arr
        self._i2c_read_words_from_cmd(
            SGP30_CMD_SET_IAQ_BASELINE_HEX + buffer,
            SGP30_CMD_SET_IAQ_BASELINE_MAX_MS,
            SGP30_CMD_SET_IAQ_BASELINE_WORDS,
        )

    def set_absolute_humidity(self, absolute_humidity):
        """ Sets absolute humidity compensation. To disable,
        set 0. """
        buffer = []
        arr = [absolute_humidity >> 8, absolute_humidity & 0xFF]
        arr.append(generate_crc(arr))
        buffer += arr
        self._i2c_read_words_from_cmd(
            SGP30_CMD_SET_ABSOLUTE_HUMIDITY_HEX + buffer,
            SGP30_CMD_SET_ABSOLUTE_HUMIDITY_MAX_MS,
            SGP30_CMD_SET_ABSOLUTE_HUMIDITY_WORDS,
        )

    def measure_test(self):
        """ Runs on-chip self test """
        return self._i2c_read_words_from_cmd(
            SGP30_CMD_MEASURE_TEST_HEX,
            SGP30_CMD_MEASURE_TEST_MAX_MS,
            SGP30_CMD_MEASURE_TEST_WORDS,
        )[0]

    def get_feature_set(self):
        """ Retrieves feature set of sensor """
        return self._i2c_read_words_from_cmd(
            SGP30_CMD_GET_FEATURE_SET_HEX,
            SGP30_CMD_GET_FEATURE_SET_MAX_MS,
            SGP30_CMD_GET_FEATURE_SET_WORDS,
        )[0]

    def measure_raw(self):
        """ Returns raw H2 and Ethanol signals, used for part verification and testing """
        return self._i2c_read_words_from_cmd(
            SGP30_CMD_MEASURE_RAW_HEX,
            SGP30_CMD_MEASURE_RAW_MAX_MS,
            SGP30_CMD_MEASURE_RAW_WORDS,
        )

    # TODO: Get TVOC inceptive baseline
    # TODO: Set TVOC baseline
    # TODO: Soft Reset (datasheet section 6.4)

    def get_serial(self):
        """ Retrieves sensor serial """
        serial = self.serial = self._i2c_read_words_from_cmd(
            SGP30_CMD_GET_SERIAL_ID_HEX,
            SGP30_CMD_GET_SERIAL_ID_MAX_MS,
            SGP30_CMD_GET_SERIAL_ID_WORDS,
        )
        return hex(int.from_bytes(bytearray(serial), "large"))

    @property
    def co2eq(self):
        """ Carbon Dioxide Equivalent in parts per million (ppm) """
        return self.measure_iaq()[0]

    @property
    def baseline_co2eq(self):
        """ Carbon Dioxide Equivalent baseline value """
        return self.get_iaq_baseline()[0]

    @property
    def tvoc(self):
        """ Total Volatile Organic Compound in parts per billion (ppb) """
        return self.measure_iaq()[1]

    @property
    def baseline_tvoc(self):
        """ Total Volatile Organic Compound baseline value """
        return self.get_iaq_baseline()[1]

    @property
    def raw_h2(self):
        """ Raw H2 signal """
        return self.measure_raw()[0]

    @property
    def raw_ethanol(self):
        """ Raw Ethanol signal """
        return self.measure_raw()[1]

    def _i2c_read_words_from_cmd(self, command, delay, reply_size):
        """ Runs an SGP command query, gets a reply and CRC results if necessary """
        self._i2c.writeto(self.addr, bytes(command))
        sleep_ms(delay)
        if not reply_size:
            return None
        crc_result = bytearray(reply_size * (SGP30_WORD_LEN + 1))
        self._i2c.readfrom_into(self.addr, crc_result)
        result = []
        for i in range(reply_size):
            word = [crc_result[3 * i], crc_result[3 * i + 1]]
            crc = crc_result[3 * i + 2]
            if generate_crc(word) != crc:
                raise RuntimeError("CRC Error")
            result.append(word[0] << 8 | word[1])
        return result


def generate_crc(data):
    """ 8-bit CRC algorithm for checking data.
    Calculation described in section 6.6 of SGP30 datasheet """
    crc = SGP30_CRC8_INIT
    # Calculates 8-Bit CRC checksum with given polynomial
    for byte in data:
        crc ^= byte
        for _ in range(8):
            if crc & 0x80:
                crc = (crc << 1) ^ SGP30_CRC8_POLYNOMIAL
            else:
                crc <<= 1
    return crc & 0xFF


def convert_r_to_a_humidity(temp_c, r_humidity_perc, fixed_point=True):
    """ Converts relative to absolute humidity as per the equation
    found in datasheet """
    a_humidity_gm3 = 216.7 * (
        (r_humidity_perc / 100 * 6.112 * exp(17.62 * temp_c / (243.12 + temp_c)))
        / (273.15 + temp_c)
    )
    # Return in 8.8 bit fixed point format (for setting humidity compensation), if not
    # simply return the calculated value in g/m^3
    if fixed_point:
        a_humidity_gm3 = (int(a_humidity_gm3) << 8) + (int(a_humidity_gm3 % 1 * 256))
    return a_humidity_gm3

I have tried running an I2C.scan(), and it returns a list of values:

[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119]

It also finds that the address is "88".

The only thing I know right now, is that it's not communicating properly...

Thanks.

[davefes]

Try SoftI2C, I got a warning that machine.I2C is deprecated when I tried import a n older DS3231 program. Changed to SoftI2C and at least the warning disappeared..

[robert-hh]

@davefes machine.I2C(-1, ...) is deprecated. But there there is no need to use SoftI2C.

@strumberr About the list returned by i2c.scan(): if every possible address is shown, then there is a communication problem. If only the sensor is on the bus, the list should contain only the address of the sensor. It looks as if the SDA line is permanently low, e.g. because of missing pull-up resistors.
B.T.W: You do not have to set the Pin mode in the instantiation of I2C. And even if, for I2C it must be Pin.OPEN_DRAIN.

[davefes]

I'll re-read the pros and cons of SoftI2C. Thanks.