Code

In this article we look at a temperature sensor, the STTS22H sensor from ST and connect it to an ESP32 board

Sensor Information

The STTS22H is an ultralow-power, high-accuracy, digital temperature sensor offering high performance over the entire operating temperature range.

The STTS22H Temperature Sensor is an ultralow-power, high-accuracy, digital temperature sensor from ST Microelectronics and is housed in our standard Qwiic form factor. Thanks to its factory calibration the STTS22H offers high-end accuracy performance over the entire operating temperature range, reaching as low as ±0.5°C without requiring any further calibration at the application level.

The sensor operating mode is user-configurable and allows selecting between different ODRs (down to 1Hz) or the one-shot mode for battery saving. In one-shot mode, the sensor current consumption falls to 1.75µA. Peripheral addresses are also user-configurable and allow up to four different addresses to be specified by manipulating the jumpers on the back of the breakout. In addition, an interrupt pin is available to signal the application whenever the user-selectable high or low threshold has been exceeded.

Features

• Uses I²C interface (Qwiic-enabled)
• Four selectable addresses
  • 0x3C (default), 0x3E, 0x38, 0x3F
• Operating temperature: -40°C to +125°C
• Temperature accuracy (max): ± 0.5°C (-10°C to +60°C)
• Operating voltage: 1.5V to 3.6V
  • Typically 3.3V if using the Qwiic cable
• Ultralow current: 1.75µA in one-shot mode
• Programmable thresholds with interrupt pin
• Programmable operating modes
  • Freerun, one-shot, and Low-ODR
• NIST traceability

Parts Required

You can connect to the sensor using DuPont-style jumper wire.

I use an ESP32 board from Wemos, the Lolin32 – it should work with any ESP32 board

Name	Link
ESP32	Aliexpress link
STTS22H	Aliexpress link
Connecting cables	Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

 

Schematic/Connection

I used 3.3v from the ESP32 board

I also used a Qwiic cable, but if you do not have one, there is an unpopulated set of pins you can solder a header to. This is how you would wire this up

esp32 and STTS22H_bb

 

Code Example

I installed the Sparkfun library using the Arduino ide

Click the Manage Libraries … menu item, search for STTS22H, and select the Sparkfun STTS22H library like this

This is one of the examples that gets installed with the library, with a  few comments and unused lines removed.

#include <Wire.h>
#include "SparkFun_STTS22H.h"

SparkFun_STTS22H mySTTS; 

float temp; 

void setup()
{

    Wire.begin();

    Serial.begin(115200);

    if( !mySTTS.begin() )
    {
        Serial.println("Did not begin.");
        while(1);
    }

    Serial.println("Ready");

    // Other output data rates can be found in the description
    // above. To change the ODR or mode, the device must first be
    // powered down.
    mySTTS.setDataRate(STTS22H_POWER_DOWN);
    delay(10);
    mySTTS.setDataRate(STTS22H_1Hz);

    // Enables incrementing register behavior for the IC.
    // It is not enabled by default as the datsheet states and
    // is vital for reading the two temperature registers.
    mySTTS.enableAutoIncrement();

    delay(100);
}

void loop()
{

    // Only use data ready for one-shot mode or 1Hz output. 
    if( mySTTS.dataReady() ) 
    {
        // Temperature in different units can be retrieved
        // using the following functions.
        //mySTTS.getTemperatureC(&temp);
        mySTTS.getTemperatureK(&temp);
        Serial.print("Temp: "); 
        Serial.print(temp);
        Serial.println("F"); 
    } 
    delay(1000);

}

 

Output

When run you will see something like this in the serial monitor window

Temp: 68.68F
Temp: 68.67F
Temp: 68.74F
Temp: 68.70F
Temp: 68.72F
Temp: 68.72F

 

Links

https://www.st.com/resource/en/datasheet/stts22h.pdf

In this article we connect an VL6180X device to an ESP32

Lets look at the sensor

Sensor Information

First lets look at some information about the sensor from the manufacturer

The VL6180X is a ground-breaking technology allowing absolute distance to be measured independent of target reflectance.

Instead of estimating the distance by measuring the amount of light reflected back from the object (which is significantly influenced by color and surface), the VL6180X precisely measures the time the light takes to travel to the nearest object and reflect back to the sensor (Time-of-Flight).

Combining an IR emitter, a range sensor and an ambient light sensor, the VL6180X is easy to integrate and saves the end-product maker long and costly optical and mechanical design optimizations.

The module is designed for low power operation. Ranging and ALS measurements can be automatically performed at user defined intervals. Multiple threshold and interrupt schemes are supported to minimize host operations.

Host control and result reading is performed using an I²C interface. Optional additional functions, such as measurement ready and threshold interrupts, are provided by two programmable GPIO pins.

Key Features

• Three-in-one smart optical module
  • Proximity sensor
  • Ambient Light Sensor
  • VCSEL light source
• Fast, accurate distance ranging
  • Measures absolute range from 0 to above 10 cm (ranging beyond 10cm is dependent on conditions)
  • Independent of object reflectance
  • Ambient light rejection
  • Cross-talk compensation for cover glass
• Gesture recognition
  • Distance and signal level can be used by host system to implement gesture recognition
• Ambient light sensor
  • High dynamic range
  • Accurate/sensitive in ultra-low light
  • Calibrated output value in lux
• Two programmable GPIO
  • Window and thresholding functions for both ranging and ALS

This was my sensor of choice that I used

Parts Required

The sensor you can pick up in the $12 price range – you can connect to the sensor using a standard header the classic dupont style jumper wire.

Schematic/Connection

ESP32 and VL6180X layout

Code Example

This uses a library from Adafruit installed using the Library Manager in the Arduino IDE. search for VL6180X, and select the Adafruit_VL6180X library. You will also need to add another couple of libraries Adafruit BusIO library and the Adafruit Unified Sensor library

[codesyntax lang=”cpp”]

#include <Wire.h>
#include "Adafruit_VL6180X.h"

Adafruit_VL6180X vl = Adafruit_VL6180X();

void setup() {
  Serial.begin(115200);

  // wait for serial port to open on native usb devices
  while (!Serial) {
    delay(1);
  }
  
  Serial.println("Adafruit VL6180x test!");
  if (! vl.begin()) {
    Serial.println("Failed to find sensor");
    while (1);
  }
  Serial.println("Sensor found!");
}

void loop() {
  float lux = vl.readLux(VL6180X_ALS_GAIN_5);

  Serial.print("Lux: "); Serial.println(lux);
  
  uint8_t range = vl.readRange();
  uint8_t status = vl.readRangeStatus();

  if (status == VL6180X_ERROR_NONE) {
    Serial.print("Range: "); Serial.println(range);
  }

  // Some error occurred, print it out!
  
  if  ((status >= VL6180X_ERROR_SYSERR_1) && (status <= VL6180X_ERROR_SYSERR_5)) {
    Serial.println("System error");
  }
  else if (status == VL6180X_ERROR_ECEFAIL) {
    Serial.println("ECE failure");
  }
  else if (status == VL6180X_ERROR_NOCONVERGE) {
    Serial.println("No convergence");
  }
  else if (status == VL6180X_ERROR_RANGEIGNORE) {
    Serial.println("Ignoring range");
  }
  else if (status == VL6180X_ERROR_SNR) {
    Serial.println("Signal/Noise error");
  }
  else if (status == VL6180X_ERROR_RAWUFLOW) {
    Serial.println("Raw reading underflow");
  }
  else if (status == VL6180X_ERROR_RAWOFLOW) {
    Serial.println("Raw reading overflow");
  }
  else if (status == VL6180X_ERROR_RANGEUFLOW) {
    Serial.println("Range reading underflow");
  }
  else if (status == VL6180X_ERROR_RANGEOFLOW) {
    Serial.println("Range reading overflow");
  }
  delay(500);
}

[/codesyntax]

Output

Here is  an example of what I saw in the serial monitor window

Lux: 0.00
Range: 43
Lux: 0.00
Range: 40
Lux: 0.00
Range: 43
Lux: 0.00
Range: 11
Lux: 0.00
Range: 12

Links

https://www.st.com/resource/en/datasheet/vl6180x.pdf
 

In this article we connect an HTU31 Humidity and Temperature Combination Sensor to an ESP32

Sensor Information

The HTU31 is one of the smallest and most accurate humidity sensors on the market. TE Connectivity precision engineering and 20+ years of experience in humidity and temperature combination sensors, enabled this new product with fast response time, precision measurement, low hysteresis, robustness to reflow assembly process and sustained performance even when exposed to extreme temperature [-40° to 125°C] and humidity [0%RH to 100%RH] environments.

HTU31 humidity & temperature sensor includes both digital (D) and analog (V) versions and combines multiple functions with an application-friendly operating supply voltage range from 3V to 5.5V

#include <Wire.h>
#include "Adafruit_HTU31D.h"

Adafruit_HTU31D htu = Adafruit_HTU31D();
uint32_t timestamp;
bool heaterEnabled = false;

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    delay(10); // wait till serial port opens
  }
  Serial.println("Adafruit HTU31D test");

  if (!htu.begin(0x40)) {
    Serial.println("Couldn't find sensor!");
    while (1);
  }
  timestamp = millis();
}

void loop() {
  sensors_event_t humidity, temp;
  
  htu.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data

  Serial.print("Temp: "); 
  Serial.print(temp.temperature);
  Serial.println(" C");
  
  Serial.print("Humidity: ");
  Serial.print(humidity.relative_humidity);
  Serial.println(" \% RH");

  // every 5 seconds
  if ((millis() - timestamp) > 5000) {
    // toggle the heater
    heaterEnabled = !heaterEnabled;
    if (heaterEnabled) {
      Serial.println("Turning on heater");
    } else {
      Serial.println("Turning off heater");
    }
    if (! htu.enableHeater(heaterEnabled)) {
      Serial.println("Command failed");
    }

    timestamp = millis();
  }

  delay(500);
}

In this article we look at a TLV493D magnetic sensor and we will connect it to an ESP32 development board, its a Lolin D32 pro but pretty much any ESP32 board will do.

First lets look at the sensor

The 3D magnetic sensor TLV493D offers accurate three-dimensional sensing with extremely low power consumption in a small 6-pin package.

With its magnetic field detection in x, y, and z-direction the sensor reliably measures three dimensional, linear and rotation movements.

Applications include joysticks, control elements (white goods, multifunction knops), or electric meters (anti tampering) and any other application that requires accurate angular measurements or low power consumptions.

Features

• 3D magnetic sensing
• Very low power consumption = 10 µA during operations (10 Hz, typ.)
• Power down mode with 7 nA power consumption
• Digital output via 2-wire based standard I2C interface up to 1 MBit/sec
• 12-bit data resolution for each measurement direction
• Bx, By and Bz linear field measurement up to +130 mT
• Excellent matching of X/Y measurement for accurate angle sensing
• Variable update frequencies and power modes (configurable during operation)
• Supply voltage range = 2.8 V…3.5 V, Temperature range Tj = -40°C…125°C
• Triggering by external µC possible
• Interrupt signal available to wake up a microcontroller
• Temperature measurement

Parts Required

Name	Link
ESP32	ESP32 ESP32-WROOM-32 Lua WIFI IOT Development Board
TLV493D	ADA Adafruit (PID 4366) TLV493D Triple-Axis Magnetometer – Stemma QT/Qwiic
Connecting wire	Male to Male + Male to Female and Female to Female Jumper Wire Dupont Cable

Schematic/Connection

I used the Adafruit TLV493 sensor and in this case used the Stemma connection on the sensor

For the STEMMA QT cables, it uses the Qwiic convention:

Black for GND
Red for V+
Blue for SDA
Yellow for SCL

So color coded for ease of use, this layout shows a connection to the module

This example shows an Adafruit ESP32 board connected to the sensor

ESP32 and TLV493D layout

Code Example

This uses the library from Infineon installed using the Library Manager in the Arduino IDE. search for Infineon TLV493, and select theTLV493D-A1B6 library

This is the cartesian example which reads the X, Y, and Z axis measurements in milli-teslas (mT), there are a few examples to investigate

[codesyntax lang=”cpp”]

#include <Tlv493d.h>

// Tlv493d Opject
Tlv493d Tlv493dMagnetic3DSensor = Tlv493d();

void setup() 
{
  Serial.begin(9600);
  while(!Serial);
  Tlv493dMagnetic3DSensor.begin();
}

void loop() {
  Tlv493dMagnetic3DSensor.updateData();
  delay(100);

  Serial.print("X = ");
  Serial.print(Tlv493dMagnetic3DSensor.getX());
  Serial.print(" mT; Y = ");
  Serial.print(Tlv493dMagnetic3DSensor.getY());
  Serial.print(" mT; Z = ");
  Serial.print(Tlv493dMagnetic3DSensor.getZ());
  Serial.println(" mT");
   
  delay(500);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this.

Links

Infineon datasheet