Home Tags Posts tagged with "stm32"
Tag:

stm32

STM32

STM32 Nucleo and ADXL337 accelerometer Arduino example

by shedboy71
written by shedboy71

In this article we connect an ADXL337 accelerometer to an STM32 Nucleo, the example was written in the Arduino IDE

The ADXL337 is a small, thin, low power, complete 3-axis accelerometer with signal conditioned voltage outputs. The product measures acceleration with a minimum full-scale range of ±3g. It can measure the static acceleration of gravity in tiltsensing applications, as well as dynamic acceleration resulting from motion, shock, or vibration.

The user selects the bandwidth of the accelerometer using the CX, CY, and CZ capacitors at the XOUT, YOUT, and ZOUTpins. Bandwidths can be selected to suit the application, with a range of 0.5 Hz to 1600 Hz for X and Y axes, and a range of 0.5 Hz to 550 Hz for the Z axis.

 

Parts List

Name Link
STM32 Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
ADXL337 3-axis ADXL337 GY-61 Replacement ADXL335 Module Analog Output Accelerometer
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Connection

Module STM32 Nucleo
Vcc 3.3v
Gnd Gnd
X_OUT A0
Y_OUT A1
Z_OUT A2

Code

No libraries required – this is a sparkfun example

[codesyntax lang=”cpp”]

// Make sure these two variables are correct for your setup
int scale = 3; // 3 (±3g) for ADXL337, 200 (±200g) for ADXL377


void setup()
{
  // Initialize serial communication at 115200 baud
  Serial.begin(115200);
}

// Read, scale, and print accelerometer data
void loop()
{
  // Get raw accelerometer data for each axis
  int rawX = analogRead(A0);
  int rawY = analogRead(A1);
  int rawZ = analogRead(A2);
  
  // Scale accelerometer ADC readings into common units
  // Scale map depends on if using a 5V or 3.3V microcontroller
  float scaledX, scaledY, scaledZ; // Scaled values for each axis
  scaledX = mapf(rawX, 0, 675, -scale, scale); // 3.3/5 * 1023 =~ 675
  scaledY = mapf(rawY, 0, 675, -scale, scale);
  scaledZ = mapf(rawZ, 0, 675, -scale, scale);

  // Print out raw X,Y,Z accelerometer readings
  Serial.print("X: "); 
  Serial.println(rawX);
  Serial.print("Y: "); 
  Serial.println(rawY);
  Serial.print("Z: "); 
  Serial.println(rawZ);
  Serial.println();
  
  // Print out scaled X,Y,Z accelerometer readings
  Serial.print("X: "); 
  Serial.print(scaledX); 
  Serial.println(" g");
  Serial.print("Y: "); 
  Serial.print(scaledY); 
  Serial.println(" g");
  Serial.print("Z: "); 
  Serial.print(scaledZ); 
  Serial.println(" g");
  Serial.println();
  
  delay(2000); // Minimum delay of 2 milliseconds between sensor reads (500 Hz)
}

// Same functionality as Arduino's standard map function, except using floats
float mapf(float x, float in_min, float in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

[/codesyntax]

 

Output

Open the serial monitor and you will see something like this

X: 483
Y: 465
Z: 444

X: 1.29 g
Y: 1.13 g
Z: 0.95 g

X: 610
Y: 532
Z: 501

X: 2.42 g
Y: 1.73 g
Z: 1.45 g

Links

https://www.analog.com/media/en/technical-documentation/data-sheets/ADXL337.pdf

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and Si1145 example using the Arduino IDE

by shedboy71
written by shedboy71

In this article we connect an STM32 Nucleo to an Si1145 sensor – the code is written in the Arduino IDE

The Si1145/46/47 is a low-power, reflectance-based, infrared proximity, ultraviolet (UV) index, and ambient light sensor with I2C digital interface and programmableevent interrupt output. This touchless sensor IC includes an analog-to-digital converter, integrated high-sensitivity visible and infrared photodiodes, digital signal processor, and one, two, or three integrated infrared LED drivers with fifteen selectable drive levels. The Si1145/46/47 offers excellent performance under a wide dynamic range and a variety of light sources including direct sunlight. The Si1145/46/47 can also work under dark glass covers.

The photodiode response and associated digital conversion circuitry provide excellent immunity to artificial light flicker noise and natural light flutter noise. With two or more LEDs, the Si1146/47 is capable of supporting multiple-axis proximity motion detection. The Si1145/46/47 devices are provided in a 10-lead 2×2 mm QFN package and are capable of operation from 1.71 to 3.6 V over the –40 to +85 °C temperature range.

 

Parts List

name Link
STM32 Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
Si1145 SI1145 UV IR Visible Sensor I2C GY1145 Light Breakout Board Module
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

 

Layout

Nucleo and Si1145 layout

Nucleo and Si1145 layout

 

Code

This example requires the Adafruit Si1145 library, you can add this via the library manager or download from https://github.com/adafruit/Adafruit_SI1145_Library

[codesyntax lang=”cpp”]

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

Adafruit_SI1145 uv = Adafruit_SI1145();

void setup() {
  Serial.begin(9600);
  
  Serial.println("Adafruit SI1145 test");
  
  if (! uv.begin()) {
    Serial.println("Didn't find Si1145");
    while (1);
  }

  Serial.println("OK!");
}

void loop() {
  Serial.println("===================");
  Serial.print("Vis: "); Serial.println(uv.readVisible());
  Serial.print("IR: "); Serial.println(uv.readIR());
  
  // Uncomment if you have an IR LED attached to LED pin!
  //Serial.print("Prox: "); Serial.println(uv.readProx());

  float UVindex = uv.readUV();
  // the index is multiplied by 100 so to get the
  // integer index, divide by 100!
  UVindex /= 100.0;  
  Serial.print("UV: ");  Serial.println(UVindex);

  delay(1000);
}

[/codesyntax]

 

Output

Open the serial monitor window and you will see something like this

===================
Vis: 262
IR: 260
UV: 0.03
===================
Vis: 262
IR: 260
UV: 0.03
===================
Vis: 265
IR: 368
UV: 0.04
===================

Link

https://www.silabs.com/documents/public/data-sheets/Si1145-46-47.pdf

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and TMP102 Arduino example

by shedboy71
written by shedboy71

In this article we look at the TMP102 digital sensor and we will connect it up to an STM32 Nucleo – the example code is written in the Arduino IDE

The TMP102 device is a digital temperature sensor ideal for NTC/PTC thermistor replacement where high accuracy is required. The device offers an accuracy of ±0.5°C without requiring calibration or external component signal conditioning. Device temperature sensors are highly linear and do not require complex calculations or lookup tables to derive the temperature. The on-chip 12-bit ADC offers resolutions down to 0.0625°C.

The TMP102 device features SMBus™, two-wire and I2C interface compatibility, and allows up to four devices on one bus. The device also features an SMBus alert function. The device is specified to operate over supply voltages from 1.4 to 3.6 V with the maximum quiescent current of 10 µA over the full operating range.

The TMP102 device is ideal for extended temperature measurement in a variety of communication, computer, consumer, environmental, industrial, and instrumentation applications. The device is specified for operation over a temperature range of –40°C to 125°C.

Layout

 

Nucleo and TMP102

Nucleo and TMP102

 

Parts List

Name Link
STM32 Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
TMP102 breakout TMP102 Digital Temperature Sensor Breakout Board Module 12-bit 1.4V To 3.6VDC Sensor Module Temperature Module
connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Code

This is from the Arduino site with a few tweaks

[codesyntax lang=”cpp”]

#include "Wire.h"
#define TMP102_I2C_ADDRESS 72 /* This is the I2C address for our chip. */

void setup() 
{
  Wire.begin(); // start the I2C library
  Serial.begin(115200); //Start serial communication at 115200 baud
}

void loop() 
{
  getTemp102();
  delay(5000); //wait 5 seconds before printing our next set of readings. 
}

void getTemp102()
{
  byte firstbyte, secondbyte; //these are the bytes we read from the TMP102 temperature registers
  int val; /* an int is capable of storing two bytes, this is where we "chuck" the two bytes together. */ 
  float convertedtemp; /* We then need to multiply our two bytes by a scaling factor, mentioned in the datasheet. */ 
  float correctedtemp; 

  Wire.beginTransmission(TMP102_I2C_ADDRESS); //Say hi to the sensor. 
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(TMP102_I2C_ADDRESS, 2);
  Wire.endTransmission();

  firstbyte      = (Wire.read()); 
  secondbyte     = (Wire.read()); 
  /*The first byte contains the most significant bits, and 
   the second the less significant */
    val = firstbyte;
    if ((firstbyte & 0x80) > 0) 
    {
      val |= 0x0F00;
    } 
    val <<= 4; 
 /* MSB */
    val |= (secondbyte >> 4);    
/* LSB is ORed into the second 4 bits of our byte.
Bitwise maths is a bit funky, but there's a good tutorial on the playground*/
    convertedtemp = val*0.0625;
    correctedtemp = convertedtemp - 5; 
    /* See the above note on overreading */


  Serial.print("firstbyte is ");
  Serial.print("\t");
  Serial.println(firstbyte, BIN);
  Serial.print("secondbyte is ");
  Serial.print("\t");
  Serial.println(secondbyte, BIN);
  Serial.print("Concatenated byte is ");
  Serial.print("\t");
  Serial.println(val, BIN);
  Serial.print("Converted temp is ");
  Serial.print("\t");
  Serial.println(val*0.0625);
  Serial.print("Corrected temp is ");
  Serial.print("\t");
  Serial.println(correctedtemp);
  Serial.println();
}

[/codesyntax]

 

Output

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

firstbyte is 10101
secondbyte is 10000
Concatenated byte is 101010001
Converted temp is 21.06
Corrected temp is 16.06

firstbyte is 10100
secondbyte is 11100000
Concatenated byte is 101001110
Converted temp is 20.87
Corrected temp is 15.88

firstbyte is 10100
secondbyte is 11100000
Concatenated byte is 101001110
Converted temp is 20.87
Corrected temp is 15.88

Link

http://www.ti.com/lit/gpn/tmp102

0 comment
0 FacebookTwitterPinterestEmail
MBed

STM32 Nucleo and MPL3115A2 pressure sensor MBed example

by shedboy71
written by shedboy71

In this example we connect a MPL3115A2 sensor to a STM32 Nucleo and the example will use the MBed compiler

The MPL3115A2 is a compact, piezoresistive, absolute pressure sensor with an I2C digital interface. MPL3115A2 has a wide operating range of 20 kPa to 110 kPa, a range that covers all surface elevations on earth. The MEMS is temperature compensated utilizing an on-chip temperature sensor. The pressure and temperature data is fed into a high resolution ADC to provide fully compensated and digitized outputs for pressure in Pascals and temperature in °C.

The compensated pressure output can then be converted to altitude, utilizing the formula stated in Section 9.1.3 “Pressure/altitude” provided in meters.The internal processing in MPL3115A2 removes compensation and unit conversion load from the system MCU, simplifying system design

Parts List

Here are the parts that I used

Name Link
STM32 Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
MPL3115A2 MPL3115A2 I2C Intelligent Temperature Pressure Altitude Sensor V2.0
Connecting cable Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Schematics/Layout

stm32 nucleo and MPL3115A2 sensor

stm32 nucleo and MPL3115A2 sensor

 

Code

I imported the following example and library into the MBed compiler – https://os.mbed.com/teams/MSS/code/test_MPL3115A2/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "MSS.h"
#include "MPL3115A2.h"
#define MPL3115A2_I2C_ADDRESS (0x60)

int main() {
    double alt, bar, temp ;
    MPL3115A2 mpl(PIN_SDA, PIN_SCL, MPL3115A2_I2C_ADDRESS) ;
    
    printf("=== test MPL3115A2 for %s (%s) ===\n") ;
    printf("Altitude(m), Pressure(hPa),   Temperature(c)\n") ;
    
    while(1) 
    {
        alt = mpl.getAltitude() ;
        bar = mpl.getPressure() ;
        temp = mpl.getTemperature() ;
        printf("%6.2f,   %6.2f, %6.2f\n",alt, bar, temp) ;
        wait(1) ;
    }
}

[/codesyntax]

Output

Using a serial monitor program like Teraterm connect to the serial port of your STM32 nucleo

mpl3115a2 output

mpl3115a2 output

Links

https://www.nxp.com/docs/en/data-sheet/MPL3115A2.pdf

0 comment
0 FacebookTwitterPinterestEmail
MBed

VL53L0X and STM32 Nucleo MBed example

by shedboy71
written by shedboy71

In this example we connect a VL53L0X to a STM32 Nucleo

The VL53L0X is a new generation Time-of-Flight (ToF) laser-ranging module housed in the smallest package on the market today, providing accurate distance measurement whatever the target reflectances unlike conventional technologies. It can measure absolute distances up to 2m, setting a new benchmark in ranging performance levels, opening the door to various new applications.

The VL53L0X integrates a leading-edge SPAD array (Single Photon Avalanche Diodes) and embeds ST’s second generation FlightSenseTM patented technology.

Here is a typical module

The VL53L0X’s 940 nm VCSEL emitter (Vertical Cavity Surface-Emitting Laser), is totally invisible to the human eye, coupled with internal physical infrared filters, it enables longer ranging distances, higher immunity to ambient light, and better robustness to cover glass optical crosstalk.

 

Parts List

This is the parts that I used

Name Link
ST Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
VL53L0X VL53L0X Time-of-Flight (ToF) Laser Ranging Sensor Breakout 940nm
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Schematics/Layout

stm32 nucleo and VL53L0X sensor

stm32 nucleo and VL53L0X sensor

 

Code

You need to import this example into the MBed compiler. Build it and copy the bin file to the MBEd drive that is present on your PC

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "vl53l0x_api.h"
#include "vl53l0x_platform.h"
#include "vl53l0x_i2c_platform.h"

Serial pc(SERIAL_TX, SERIAL_RX);

void print_pal_error(VL53L0X_Error Status){
    char buf[VL53L0X_MAX_STRING_LENGTH];
    VL53L0X_GetPalErrorString(Status, buf);
    printf("API Status: %i : %s\n", Status, buf);
}

void print_range_status(VL53L0X_RangingMeasurementData_t* pRangingMeasurementData){
    char buf[VL53L0X_MAX_STRING_LENGTH];
    uint8_t RangeStatus;

    /*
     * New Range Status: data is valid when pRangingMeasurementData->RangeStatus = 0
     */

    RangeStatus = pRangingMeasurementData->RangeStatus;

    VL53L0X_GetRangeStatusString(RangeStatus, buf);
    printf("Range Status: %i : %s\n", RangeStatus, buf);

}


VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev) {
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    uint8_t NewDatReady=0;
    uint32_t LoopNb;

    // Wait until it finished
    // use timeout to avoid deadlock
    if (Status == VL53L0X_ERROR_NONE) {
        LoopNb = 0;
        do {
            Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDatReady);
            if ((NewDatReady == 0x01) || Status != VL53L0X_ERROR_NONE) {
                break;
            }
            LoopNb = LoopNb + 1;
            VL53L0X_PollingDelay(Dev);
        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);

        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
            Status = VL53L0X_ERROR_TIME_OUT;
        }
    }

    return Status;
}

VL53L0X_Error WaitStopCompleted(VL53L0X_DEV Dev) {
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    uint32_t StopCompleted=0;
    uint32_t LoopNb;

    // Wait until it finished
    // use timeout to avoid deadlock
    if (Status == VL53L0X_ERROR_NONE) {
        LoopNb = 0;
        do {
            Status = VL53L0X_GetStopCompletedStatus(Dev, &StopCompleted);
            if ((StopCompleted == 0x00) || Status != VL53L0X_ERROR_NONE) {
                break;
            }
            LoopNb = LoopNb + 1;
            VL53L0X_PollingDelay(Dev);
        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);

        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
            Status = VL53L0X_ERROR_TIME_OUT;
        }

    }

    return Status;
}


int main()
{
  
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    VL53L0X_Dev_t MyDevice;
    VL53L0X_Dev_t *pMyDevice = &MyDevice;
    VL53L0X_Version_t                   Version;
    VL53L0X_Version_t                  *pVersion   = &Version;
    VL53L0X_DeviceInfo_t                DeviceInfo; 
    
    int32_t status_int;
    
    pc.printf("VL53L0X API Simple Ranging Example\r\n");
    
    // Initialize Comms
    pMyDevice->I2cDevAddr      = 0x52;
    pMyDevice->comms_type      =  1;
    pMyDevice->comms_speed_khz =  400;
    
    pc.printf("Init comms\r\n");
    
    if(Status == VL53L0X_ERROR_NONE)
    {
        status_int = VL53L0X_GetVersion(pVersion);
        if (status_int != 0)
            Status = VL53L0X_ERROR_CONTROL_INTERFACE;
    }
    pc.printf("VL53L0X API Version: %d.%d.%d (revision %d)\r\n", pVersion->major, pVersion->minor ,pVersion->build, pVersion->revision);
        
        int addr;
        
        addr = VL53L0X_scan();
        printf("Device found at: %i\r\n", addr);
        //uint8_t data;
        //data=0;
        if(Status == VL53L0X_ERROR_NONE)
    {
            printf ("Call of VL53L0X_DataInit\n");
            uint16_t osc_calibrate_val=0;
            Status = VL53L0X_RdWord(&MyDevice, VL53L0X_REG_OSC_CALIBRATE_VAL,&osc_calibrate_val);
            printf("%i\n",osc_calibrate_val);
      Status = VL53L0X_DataInit(&MyDevice); // Data initialization
      print_pal_error(Status);
    }

        if(Status == VL53L0X_ERROR_NONE)
    {
        Status = VL53L0X_GetDeviceInfo(&MyDevice, &DeviceInfo);
        if(Status == VL53L0X_ERROR_NONE)
        {
            printf("VL53L0X_GetDeviceInfo:\n");
            printf("Device Name : %s\n", DeviceInfo.Name);
            printf("Device Type : %s\n", DeviceInfo.Type);
            printf("Device ID : %s\n", DeviceInfo.ProductId);
            printf("ProductRevisionMajor : %d\n", DeviceInfo.ProductRevisionMajor);
        printf("ProductRevisionMinor : %d\n", DeviceInfo.ProductRevisionMinor);

        if ((DeviceInfo.ProductRevisionMinor != 1) && (DeviceInfo.ProductRevisionMinor != 1)) {
            printf("Error expected cut 1.1 but found cut %d.%d\n",
                       DeviceInfo.ProductRevisionMajor, DeviceInfo.ProductRevisionMinor);
                Status = VL53L0X_ERROR_NOT_SUPPORTED;
            }
        }
        print_pal_error(Status);
    }

        VL53L0X_RangingMeasurementData_t    RangingMeasurementData;
        VL53L0X_RangingMeasurementData_t   *pRangingMeasurementData    = &RangingMeasurementData;
        Status = VL53L0X_ERROR_NONE;
        uint32_t refSpadCount;
        uint8_t isApertureSpads;
        uint8_t VhvSettings;
        uint8_t PhaseCal;

    if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StaticInit\n");
            Status = VL53L0X_StaticInit(pMyDevice); // Device Initialization
            // StaticInit will set interrupt by default
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_PerformRefCalibration\n");
            Status = VL53L0X_PerformRefCalibration(pMyDevice,
                    &VhvSettings, &PhaseCal); // Device Initialization
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_PerformRefSpadManagement\n");
            Status = VL53L0X_PerformRefSpadManagement(pMyDevice,
                    &refSpadCount, &isApertureSpads); // Device Initialization
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {

            printf ("Call of VL53L0X_SetDeviceMode\n");
            Status = VL53L0X_SetDeviceMode(pMyDevice, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in single ranging mode
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StartMeasurement\n");
            Status = VL53L0X_StartMeasurement(pMyDevice);
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            uint32_t measurement;
            uint32_t no_of_measurements = 32;

            uint16_t* pResults = (uint16_t*)malloc(sizeof(uint16_t) * no_of_measurements);

            for(measurement=0; measurement<no_of_measurements; measurement++)
            {

                Status = WaitMeasurementDataReady(pMyDevice);

                if(Status == VL53L0X_ERROR_NONE)
                {
                    Status = VL53L0X_GetRangingMeasurementData(pMyDevice, pRangingMeasurementData);

                    *(pResults + measurement) = pRangingMeasurementData->RangeMilliMeter;
                    printf("In loop measurement %lu: %d\n", measurement, pRangingMeasurementData->RangeMilliMeter);

                    // Clear the interrupt
                    VL53L0X_ClearInterruptMask(pMyDevice, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
                    VL53L0X_PollingDelay(pMyDevice);
                } else {
                    break;
                }
            }

            if(Status == VL53L0X_ERROR_NONE)
            {
                for(measurement=0; measurement<no_of_measurements; measurement++)
                {
                    printf("measurement %lu: %d\n", measurement, *(pResults + measurement));
                }
            }

            free(pResults);
        }


        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StopMeasurement\n");
            Status = VL53L0X_StopMeasurement(pMyDevice);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Wait Stop to be competed\n");
            Status = WaitStopCompleted(pMyDevice);
        }

        if(Status == VL53L0X_ERROR_NONE)
        Status = VL53L0X_ClearInterruptMask(pMyDevice,
            VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
    while (true)
        if (pc.readable())
            pc.putc(pc.getc());
}

[/codesyntax]

 

Output

Use a program like teraterm and open the serial port of your STM32 Nucleo

 

Links

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

0 comment
0 FacebookTwitterPinterestEmail
MBed

STM32 Nucleo and CCS911 sensor MBed example

by shedboy71
written by shedboy71

In this example we will connect a CCS811 gas sensor to an STM32 Nucleo and the code example will be written in the MBed compiler, lets look at the sensor

CCS811 is a low-power digital gas sensor solution, which integrates a gas sensor solution for detecting low levels of VOCs typically found indoors, with a microcontroller unit (MCU) and an Analog-to-Digital converter to monitor the local environment and provide an indication of the indoor air quality via an equivalent CO2 or TVOC output over a standard I2C digital interface.

Features

Integrated MCU
On-board processing
Standard digital interface
Optimised low power modes
IAQ threshold alarms
Programmable baseline
2.7mm x 4.0mm LGA package
Low component count
Proven technology platform

Specs

Interface I²C
Supply Voltage [V] 1.8 to 3.6
Power Consumption [mW] 1.2 to 46
Dimension [mm] 2.7 x 4.0 x 1.1 LGA
Ambient Temperature Range [°C] -40 to 85
Ambient Humidity Range [% r.h.] 10 to 95

Parts List

 

Amount Part Type
1 CJMCU-811 CCS811 Air Quality Gas Sensor
1 STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino

 

 

Schematics/Layout

Remember and connect WAKE to gnd

stm32 nucleo and ccs811 sensor

stm32 nucleo and ccs811 sensor

Code

Again we use a library this is the adafruit one – you can use the library manager and add this.

And this is the out of the box example

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "CCS811.h"


Serial pc(USBTX, USBRX);

#ifdef TARGET_UBLOX_EVK_ODIN_W2
CCS811 ccs811(PF_0, PF_1);
#else
CCS811 ccs811(I2C_SDA, I2C_SCL);
#endif


uint16_t eco2, tvoc;


void CCS811Callback(void)
{

    ccs811.readData(&eco2, &tvoc);

    pc.printf("eCO2 reading :%dppm, TVOC reading :%dppb\r\n", eco2, tvoc);

}


int main()
{
    ccs811.init();
    wait(1);

    while(1) {
//        ccs811.readstatus(); //0x90 reports everything working, 0x98 measurement ready to be used
        wait(1);
        CCS811Callback();
        wait(1);
    }
}

[/codesyntax]

 

Output

Open Teraterm and connect to the assigned port of the STM32 nucleo

You should see something like this

ccs811 output

ccs811 output

 

Links

ccs811 datasheet

0 comment
0 FacebookTwitterPinterestEmail