SGP41 air quality sensor module, VOC and NOx, I2C, 3.3V

The SGP41 sensor module from Sensirion monitors indoor air quality through two distinct signals, one for volatile organic compounds (VOC) and one for nitrogen oxides (NOx). In this tutorial we set up the module with an ESP32 board, since the sensor's I2C interface works natively at 3.3 V, the same logic voltage used by the ESP32, without needing a level converter.

How it works:

The SGP41 sensor has two MOX sensing elements, each with its own micro-heater plate. Each element produces a 16-bit raw signal, SRAW_VOC and SRAW_NOX, proportional to the logarithm of the gas-sensitive layer's resistance. These raw signals aren't directly useful, which is why they're passed through the Sensirion Gas Index Algorithm, running on the microcontroller, which converts them into a VOC Index and a NOx Index on a scale from 1 to 500.

Before the first measurement after each power-up, the sensor needs to be conditioned for 10 s, a period during which the NOx element's hotplate is brought up to its working temperature. After conditioning, the raw signals are read once per second and each value is run through the Gas Index Algorithm, which compares the new reading with the average of the last hours of operation and calculates the corresponding index. A VOC Index of 100 means the air is on average the same as over the last 24 h, while a NOx Index of 1 means there are no oxidizing gases present.

What you need:

• 1 x SGP41 air quality sensor module, VOC and NOx, I2C, 1.6V
• 1 x ESP32-DevKitC development board, ESP32-WROOM-32D, 38P
• 1 x 830 point MB-102 Breadboard
• 4 x 40 Dupont wires 20cm, Male-Male

Wiring:

The module is powered at 3.3 V, the same voltage as the ESP32's I2C interface, so the connection is made directly, without a logic level converter. If you're testing the sensor with an Arduino UNO board, power the module from the board's 3.3V pin and route the SDA and SCL lines through a bidirectional logic level converter, since the UNO's I2C pins work at 5 V.

Libraries:

Sensirion I2C SGP41, by Sensirion, for communication with the sensor.

Sensirion Gas Index Algorithm, by Sensirion, for calculating the VOC Index and NOx Index from the raw signals.

Wire, the standard library for I2C communication, included with the ESP32 board package.

The code:

The program conditions the sensor at startup, then reads the raw signals every second and displays them along with the VOC Index and NOx Index.

/*
  SGP41 VOC and NOx Air Quality Sensor with ESP32
  Board: ESP32 Dev Module
  Wiring:
    SGP41 VCC -> ESP32 3V3
    SGP41 GND -> ESP32 GND
    SGP41 SDA -> ESP32 GPIO21
    SGP41 SCL -> ESP32 GPIO22
  Libraries to install from Library Manager:
    Sensirion I2C SGP41 (Sensirion)
    Sensirion Gas Index Algorithm (Sensirion)
*/
#include <Wire.h>
#include <SensirionI2CSgp41.h>
#include <VOCGasIndexAlgorithm.h>
#include <NOxGasIndexAlgorithm.h>
// I2C pins used on the ESP32 dev board
#define I2C_SDA_PIN 21
#define I2C_SCL_PIN 22
// Default humidity and temperature values used when no external RH/T sensor is connected
// 0x8000 corresponds to 50% RH, 0x6666 corresponds to 25 degC, as defined by Sensirion
const uint16_t defaultRh = 0x8000;
const uint16_t defaultT = 0x6666;
SensirionI2CSgp41 sgp41;
VOCGasIndexAlgorithm vocAlgorithm;
NOxGasIndexAlgorithm noxAlgorithm;
uint16_t error;
char errorMessage[256];
void setup() {
  Serial.begin(115200);
  delay(1000);
  // Start I2C bus on the chosen SDA and SCL pins
  Wire.begin(I2C_SDA_PIN, I2C_SCL_PIN);
  sgp41.begin(Wire);
  Serial.println("SGP41 conditioning, please wait 10 seconds...");
  // Conditioning must run for 10 s before the first raw signal measurement
  uint16_t srawVoc = 0;
  for (int i = 0; i < 10; i++) {
    error = sgp41.executeConditioning(defaultRh, defaultT, srawVoc);
    if (error) {
      Serial.print("Error during conditioning: ");
      Serial.println(error);
    }
    delay(1000);
  }
  Serial.println("Conditioning done, starting measurements.");
}
void loop() {
  uint16_t srawVoc = 0;
  uint16_t srawNox = 0;
  // Read raw VOC and NOx signals once per second
  error = sgp41.measureRawSignals(defaultRh, defaultT, srawVoc, srawNox);
  if (error) {
    Serial.print("Error reading raw signals: ");
    Serial.println(error);
  } else {
    // Convert raw signals into VOC Index and NOx Index using the Gas Index Algorithm
    int32_t vocIndex = vocAlgorithm.process(srawVoc);
    int32_t noxIndex = noxAlgorithm.process(srawNox);
    Serial.print("SRAW_VOC: ");
    Serial.print(srawVoc);
    Serial.print("  SRAW_NOX: ");
    Serial.print(srawNox);
    Serial.print("  VOC Index: ");
    Serial.print(vocIndex);
    Serial.print("  NOx Index: ");
    Serial.println(noxIndex);
  }
  delay(1000);
}

How the code works:

In the definitions section, the sgp41 object is created from the SensirionI2CSgp41 class, for communication with the sensor, along with the vocAlgorithm and noxAlgorithm objects from the VOCGasIndexAlgorithm and NOxGasIndexAlgorithm libraries, which take the raw signals in turn and return the indices. The defaultRh and defaultT constants hold the default humidity and temperature values used when no external humidity sensor is available.

In setup, the serial port is initialized, the I2C bus is started with Wire.begin on pins GPIO21 and GPIO22, sgp41.begin is called to bind the object to the bus, then a loop runs calling executeConditioning for 10 iterations, one per second, as required by the sensor before the first measurement.

In loop, measureRawSignals is called once per second, using a delay of 1000 ms, srawVoc and srawNox are retrieved, and each algorithm's process function converts the raw signal into the corresponding index. The results are displayed on the serial monitor with Serial.print, along with the raw signals, for verification.

Result:

Open the serial monitor at 115200 baud. After the 10 s conditioning period, a line appears on screen every second with the raw signals and the VOC Index and NOx Index, the latter needing a few hours of continuous operation to reach fully stable values.

SGP41 conditioning, please wait 10 seconds...
Conditioning done, starting measurements.
SRAW_VOC: 24981  SRAW_NOX: 15234  VOC Index: 100  NOx Index: 1
SRAW_VOC: 24975  SRAW_NOX: 15231  VOC Index: 99  NOx Index: 1
SRAW_VOC: 24988  SRAW_NOX: 15229  VOC Index: 101  NOx Index: 1
SRAW_VOC: 25102  SRAW_NOX: 15240  VOC Index: 108  NOx Index: 1
SRAW_VOC: 25310  SRAW_NOX: 15255  VOC Index: 124  NOx Index: 1
SRAW_VOC: 25006  SRAW_NOX: 15233  VOC Index: 102  NOx Index: 1

Common issues:

The serial monitor shows nothing: check that the serial speed is set to 115200 baud in Serial.begin and in the serial monitor, and check that you've selected the correct ESP32 board in the Arduino IDE.

The sensor doesn't respond at address 0x59: check the SDA and SCL wires, don't swap them, and check that the module is powered at 3.3 V, not 5 V.

VOC Index or NOx Index stay stuck at the same value for a long time: make sure you're calling measureRawSignals every second without interruption, since the Gas Index Algorithm needs a continuous stream of readings to adapt.

NOx Index shows high values that don't go down: let the sensor run continuously for a few hours, since the NOx Index takes longer to fully stabilize after startup than the VOC Index.

Values seem off compared to the real environment: enable humidity compensation by sending actual temperature and humidity values from an external sensor into measureRawSignals, instead of the default values.

Limitations and tips:

The SGP41 module provides a relative estimate of air quality, not an exact concentration of substances, and shouldn't be used as a safety detector for toxic or combustible gases. For stable results, keep the sensor running continuously, without repeated power cycling, and avoid mounting it near direct heat sources or strong air currents. For better accuracy, add an external temperature and humidity sensor, such as the SHT40, whose readings can be fed into the SGP41 for compensation. Based on this setup, you can build a controlled ventilation system that automatically turns on a fan or air purifier when the VOC Index or NOx Index exceeds a set threshold.