Home Code Arduino
Category:

Arduino

Arduino

Microbit and TSL2591 light-to-digital converter example

by shedboy71

In this article we look at another light-to-digital converter – this time its the TSL2591 and we will connect it to our Microbit

First lets look at the sensor

The TSL2591 is a very high sensitivity light-to-digital converter that transforms light intensity into a digital signal output capable of direct I2C interface. The device combines one broadband photodiode (visible plus infrared) and one infrared-responding photodiode on a single CMOS integrated circuit.

Two integrating ADCs convert the photodiode currents into a digital output that represents the irradiance measured on each channel.

This digital output can be input to a microprocessor where illuminance (ambient light level) in lux is derived using an empirical formula to approximate the human eye response. The TSL2591 supports a traditional level style interrupt that remains asserted until the firmware clears it

Features

  • Highest sensitivity to 188µLux
  • Patented dual-diode architecture
  • 600M:1 dynamic range
  • Programmable interrupt function
  • UV-rejection package

This is the breakout I bought

Parts Required

Once again for ease of use I connect an expansion board to the microbit, I feel this makes it easier to connect to a sensor like the one pictured above using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
TSL2591 TSL2591 Optical Light Sensor Development Board High Dynamic Digital Light Sensor Module
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

microbit and tsl2591

microbit and tsl2591

Code Example

This uses the library from https://github.com/adafruit/Adafruit_TSL2591_Library

This is the default example

[codesyntax lang=”cpp”]

/* TSL2591 Digital Light Sensor */
/* Dynamic Range: 600M:1 */
/* Maximum Lux: 88K */

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_TSL2591.h"

// Example for demonstrating the TSL2591 library - public domain!

// connect SCL to I2C Clock
// connect SDA to I2C Data
// connect Vin to 3.3-5V DC
// connect GROUND to common ground

Adafruit_TSL2591 tsl = Adafruit_TSL2591(2591); // pass in a number for the sensor identifier (for your use later)

/**************************************************************************/
/*
    Displays some basic information on this sensor from the unified
    sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
  sensor_t sensor;
  tsl.getSensor(&sensor);
  Serial.println(F("------------------------------------"));
  Serial.print  (F("Sensor:       ")); Serial.println(sensor.name);
  Serial.print  (F("Driver Ver:   ")); Serial.println(sensor.version);
  Serial.print  (F("Unique ID:    ")); Serial.println(sensor.sensor_id);
  Serial.print  (F("Max Value:    ")); Serial.print(sensor.max_value); Serial.println(F(" lux"));
  Serial.print  (F("Min Value:    ")); Serial.print(sensor.min_value); Serial.println(F(" lux"));
  Serial.print  (F("Resolution:   ")); Serial.print(sensor.resolution, 4); Serial.println(F(" lux"));  
  Serial.println(F("------------------------------------"));
  Serial.println(F(""));
  delay(500);
}

/**************************************************************************/
/*
    Configures the gain and integration time for the TSL2591
*/
/**************************************************************************/
void configureSensor(void)
{
  // You can change the gain on the fly, to adapt to brighter/dimmer light situations
  //tsl.setGain(TSL2591_GAIN_LOW);    // 1x gain (bright light)
  tsl.setGain(TSL2591_GAIN_MED);      // 25x gain
  //tsl.setGain(TSL2591_GAIN_HIGH);   // 428x gain
  
  // Changing the integration time gives you a longer time over which to sense light
  // longer timelines are slower, but are good in very low light situtations!
  //tsl.setTiming(TSL2591_INTEGRATIONTIME_100MS);  // shortest integration time (bright light)
  // tsl.setTiming(TSL2591_INTEGRATIONTIME_200MS);
  tsl.setTiming(TSL2591_INTEGRATIONTIME_300MS);
  // tsl.setTiming(TSL2591_INTEGRATIONTIME_400MS);
  // tsl.setTiming(TSL2591_INTEGRATIONTIME_500MS);
  // tsl.setTiming(TSL2591_INTEGRATIONTIME_600MS);  // longest integration time (dim light)

  /* Display the gain and integration time for reference sake */  
  Serial.println(F("------------------------------------"));
  Serial.print  (F("Gain:         "));
  tsl2591Gain_t gain = tsl.getGain();
  switch(gain)
  {
    case TSL2591_GAIN_LOW:
      Serial.println(F("1x (Low)"));
      break;
    case TSL2591_GAIN_MED:
      Serial.println(F("25x (Medium)"));
      break;
    case TSL2591_GAIN_HIGH:
      Serial.println(F("428x (High)"));
      break;
    case TSL2591_GAIN_MAX:
      Serial.println(F("9876x (Max)"));
      break;
  }
  Serial.print  (F("Timing:       "));
  Serial.print((tsl.getTiming() + 1) * 100, DEC); 
  Serial.println(F(" ms"));
  Serial.println(F("------------------------------------"));
  Serial.println(F(""));
}


/**************************************************************************/
/*
    Program entry point for the Arduino sketch
*/
/**************************************************************************/
void setup(void) 
{
  Serial.begin(9600);
  
  Serial.println(F("Starting Adafruit TSL2591 Test!"));
  
  if (tsl.begin()) 
  {
    Serial.println(F("Found a TSL2591 sensor"));
  } 
  else 
  {
    Serial.println(F("No sensor found ... check your wiring?"));
    while (1);
  }
    
  /* Display some basic information on this sensor */
  displaySensorDetails();
  
  /* Configure the sensor */
  configureSensor();

  // Now we're ready to get readings ... move on to loop()!
}

/**************************************************************************/
/*
    Shows how to perform a basic read on visible, full spectrum or
    infrared light (returns raw 16-bit ADC values)
*/
/**************************************************************************/
void simpleRead(void)
{
  // Simple data read example. Just read the infrared, fullspecrtrum diode 
  // or 'visible' (difference between the two) channels.
  // This can take 100-600 milliseconds! Uncomment whichever of the following you want to read
  uint16_t x = tsl.getLuminosity(TSL2591_VISIBLE);
  //uint16_t x = tsl.getLuminosity(TSL2591_FULLSPECTRUM);
  //uint16_t x = tsl.getLuminosity(TSL2591_INFRARED);

  Serial.print(F("[ ")); Serial.print(millis()); Serial.print(F(" ms ] "));
  Serial.print(F("Luminosity: "));
  Serial.println(x, DEC);
}

/**************************************************************************/
/*
    Show how to read IR and Full Spectrum at once and convert to lux
*/
/**************************************************************************/
void advancedRead(void)
{
  // More advanced data read example. Read 32 bits with top 16 bits IR, bottom 16 bits full spectrum
  // That way you can do whatever math and comparisons you want!
  uint32_t lum = tsl.getFullLuminosity();
  uint16_t ir, full;
  ir = lum >> 16;
  full = lum & 0xFFFF;
  Serial.print(F("[ ")); Serial.print(millis()); Serial.print(F(" ms ] "));
  Serial.print(F("IR: ")); Serial.print(ir);  Serial.print(F("  "));
  Serial.print(F("Full: ")); Serial.print(full); Serial.print(F("  "));
  Serial.print(F("Visible: ")); Serial.print(full - ir); Serial.print(F("  "));
  Serial.print(F("Lux: ")); Serial.println(tsl.calculateLux(full, ir), 6);
}

/**************************************************************************/
/*
    Performs a read using the Adafruit Unified Sensor API.
*/
/**************************************************************************/
void unifiedSensorAPIRead(void)
{
  /* Get a new sensor event */ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  /* Display the results (light is measured in lux) */
  Serial.print(F("[ ")); Serial.print(event.timestamp); Serial.print(F(" ms ] "));
  if ((event.light == 0) |
      (event.light > 4294966000.0) | 
      (event.light <-4294966000.0))
  {
    /* If event.light = 0 lux the sensor is probably saturated */
    /* and no reliable data could be generated! */
    /* if event.light is +/- 4294967040 there was a float over/underflow */
    Serial.println(F("Invalid data (adjust gain or timing)"));
  }
  else
  {
    Serial.print(event.light); Serial.println(F(" lux"));
  }
}


/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop(void) 
{ 
  //simpleRead(); 
  advancedRead();
  // unifiedSensorAPIRead();
  
  delay(500);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Starting Adafruit TSL2591 Test!
Found a TSL2591 sensor
————————————
Sensor: TSL2591
Driver Ver: 1
Unique ID: 2591
Max Value: 88000.00 lux
Min Value: 0.00 lux
Resolution: 0.0010 lux
————————————

————————————
Gain: 25x (Medium)
Timing: 300 ms
————————————

[ 1287 ms ] IR: 1580 Full: 5023 Visible: 3443 Lux: 128.383667
[ 2217 ms ] IR: 1594 Full: 5123 Visible: 3529 Lux: 132.244583
[ 3147 ms ] IR: 1597 Full: 5136 Visible: 3539 Lux: 132.658463
[ 4077 ms ] IR: 1600 Full: 5145 Visible: 3545 Lux: 132.875839

Links

https://ams.com/tsl25911

 

 

Arduino

Microbit and TMP006 Infrared Thermopile Sensor example

by shedboy71

In this article we look at a temperature sensor – this time its the TMP006 and we will connect it to our Microbit

This is the sensor that I will be using

Lets look at some information regarding the sensor

Texas Instruments’ TMP006 is the first in a series of temperature sensors that measure the temperature of an object without the need to make contact with the object.

This sensor uses a thermopile to absorb the infrared energy emitted from the object being measured and uses the corresponding change in thermopile voltage to determine the object temperature.

Infrared sensor voltage range is specified from -40°C to +125°C to enable use in a wide range of applications. Low power consumption along with low operating voltage makes the part suitable for battery-powered applications.

The low package height of the chip-scale format enables standard high volume assembly methods, and can be useful where limited spacing to the object being measured is available.

Features

Complete single-chip digital solution, including integrated MEMS thermopile sensor, signal conditioning, ADC and local temperature reference

Digital output:
Sensor voltage: 7 µV/°C
Local temperature: -40°C to +125°C
SMBus™ compatible interface
Pin-programmable interface addressing
Low supply current: 240 µA
Low minimum supply voltage: 2.2 V

Parts Required

Once again for ease of use I connect an expansion board to the microbit, I feel this makes it easier to connect to a sensor like the one pictured above using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
TMP006 TMP006 Contact-less IR Thermopile Sensor Sensor Module
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

 

Code Example

This uses the library from https://github.com/adafruit/Adafruit_TMP006

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_TMP006.h"

// Connect VCC to +3V (its a quieter supply than the 5V supply on an Arduino
// Gnd -> Gnd
// SCL connects to the I2C clock pin. On newer boards this is labeled with SCL
// otherwise, on the Uno, this is A5 on the Mega it is 21 and on the Leonardo/Micro digital 3
// SDA connects to the I2C data pin. On newer boards this is labeled with SDA
// otherwise, on the Uno, this is A4 on the Mega it is 20 and on the Leonardo/Micro digital 2

Adafruit_TMP006 tmp006;
//Adafruit_TMP006 tmp006(0x41);  // start with a diferent i2c address!

void setup() { 
  Serial.begin(9600);
  Serial.println("Adafruit TMP006 example");

  // you can also use tmp006.begin(TMP006_CFG_1SAMPLE) or 2SAMPLE/4SAMPLE/8SAMPLE to have
  // lower precision, higher rate sampling. default is TMP006_CFG_16SAMPLE which takes
  // 4 seconds per reading (16 samples)
  if (! tmp006.begin()) {
    Serial.println("No sensor found");
    while (1);
  }

  Serial.println("Send s to enter sleep mode, or w to wake up.  Measurements are not updated while asleep!");
}

void loop() {
  // Check for sleep/wake command.
  while (Serial.available() > 0) {
    char c = Serial.read();
    if (c == 'w') {
      Serial.println("Waking up!");
      tmp006.wake();
    }
    else if (c == 's') {
      Serial.println("Going to sleep!");
      tmp006.sleep();
    }
  }

  // Grab temperature measurements and print them.
  float objt = tmp006.readObjTempC();
  Serial.print("Object Temperature: "); Serial.print(objt); Serial.println("*C");
  float diet = tmp006.readDieTempC();
  Serial.print("Die Temperature: "); Serial.print(diet); Serial.println("*C");
   
  delay(4000); // 4 seconds per reading for 16 samples per reading
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Die Temperature: 18.25*C
Object Temperature: 30.85*C
Die Temperature: 18.28*C
Object Temperature: 30.72*C
Die Temperature: 18.37*C
Object Temperature: 19.16*C
Die Temperature: 18.37*C

You can see the difference in the object temperature readings when it was pointing at my hand

Links

 

 

 

 

Arduino

Microbit and VEML7700 lux sensor Arduino based example

by shedboy71

In this article we look at a ambient light digital 16-bit resolution sensor – this time its the VEML7700 and we will connect it to our Microbit

This is the sensor that I will be using


Lets look at some information regarding the sensor

VEML7700 is a high accuracy ambient light digital 16-bit resolution sensor. It includes a high sensitive photo diode, a low noise amplifier, a 16-bit A/D converter and supports an easy to use I2C bus communication interface.
The ambient light result is as digital value available

FEATURES

Integrated modules: ambient light sensor (ALS)
Supply voltage range VDD: 2.5 V to 3.6 V
Communication via I2C interface
Floor life: 72 h, MSL 4, according to J-STD-020
Low shut down current consumption: typ. 0.5 μA

AMBIENT LIGHT FUNCTION

Filtron TM technology adaption: close to real human eye response
O-Trim TM technology adoption: ALS output tolerance≤ 10 %
16-bit dynamic range for ambient light detection from 0 lx to about 120 klx with resolution down to 0.0036 lx/ct,supports low transmittance (dark) lens design
100 Hz and 120 Hz flicker noise rejection
Excellent temperature compensation
High dynamic detection resolution
Software shutdown mode control

Parts Required

Once again for ease of use I connect an expansion board to the microbit, I feel this makes it easier to connect to a sensor like the one pictured above using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
VEML7700 Adafruit 4162 VEML7700 Lux Sensor – I2C Light Sensor
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

microbit and veml7700

microbit and veml7700

 

Code Example

This uses the library from https://github.com/DFRobot/DFRobot_VEML7700

I tried an Adafruit one – could not get the library to work, various errors. The one above worked out of the box

[codesyntax lang=”cpp”]

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

DFRobot_VEML7700 als;

void setup()
{
  Serial.begin(9600);
  als.begin();
}

void loop()
{
  float lux;
  
  als.getALSLux(lux);
  Serial.print("Lux:");
  Serial.print(lux);
  Serial.println(" lx");
  
  delay(200);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this, shine light, cover the sensor to change the lux values

Lux:160.80 lx
Lux:159.59 lx
Lux:153.44 lx
Lux:130.30 lx
Lux:86.00 lx
Lux:25.92 lx
Lux:20.50 lx
Lux:16.27 lx
Lux:13.18 lx
Lux:10.57 lx
Lux:8.41 lx

Links

https://www.vishay.com/docs/84286/veml7700.pdf

 

 

 

Arduino

Microbit and SHTC1 digital humidity sensor example

by shedboy71

In this article we look at another digital humidity sensor – this time its the SHTC1 and we will connect it to our Microbit

This is the sensor that I will be using

Lets look at the sensor

The SHTC1 is a digital humidity sensor designed especially for high-volume consumer electronics applications. This humidity sensor is strictly designed to overcome conventional limits for size, power consumption, and price-performance ratio, in order to fulfill the current and future requirements of the consumer electronics market.

Sensirion’s CMOSens® technology offers a complete sensor system on a single chip, consisting of a capacitive humidity sensor, a band-gap temperature sensor, analog and digital signal processing, A/D converter, calibration data memory, and a digital communication interface supporting I2C fast mode.

The ultra-small, 2 × 2 × 0.75 mm3 DFN package enables applications to be placed in even the most limited of spaces. The sensor covers a humidity measurement range of 0 to 100 %RH and a temperature measurement range of –30°C to 100°C with a typical accuracy of ±3 %RH and ±0.3°C.

The operating voltage of 1.8 V and an energy budget below 1 µJ per measurement make the SHTC1 suitable for mobile or wireless applications running on the lowest power budgets. With the industry-proven quality and reliability of Sensirion’s humidity sensors and constant accuracy over a large measurement range, the SHTC1 humidity sensor offers an unprecedented price-performance ratio.

Features

Interface I²C
Supply voltage 1.8 V
Power consumption 2µW (at 1 reading per second in low power mode)
Measuring range (RH) 0 – 100% relative humidity
Measuring range (T) -30 to +100°C (-22 to +212°F)
Response time (RH) 8s (tau63%)

Parts Required

Once again for ease of use I connect an expansion board to the microbit, I feel this makes it easier to connect to a sensor like the one pictured above using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
SHTC1 CJMCU-189 SHTC1 Digital Temperature and Humidity Sensor
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

Microbit Sensor
3v3 Vcc
Gnd Gnd
SDA – 20 SDA
SCL – 19 SCL

 

Code Example

This uses the library from https://github.com/Sensirion/arduino-sht

[codesyntax lang=”cpp”]

#include <Wire.h>

#include "SHTSensor.h"

SHTSensor sht;
// To use a specific sensor instead of probing the bus use this command:
// SHTSensor sht(SHTSensor::SHT3X);

void setup() {
// put your setup code here, to run once:

Wire.begin();
Serial.begin(9600);
delay(1000); // let serial console settle

if (sht.init()) {
Serial.print("init(): success\n");
} else {
Serial.print("init(): failed\n");
}
sht.setAccuracy(SHTSensor::SHT_ACCURACY_MEDIUM); // only supported by SHT3x

}

void loop() {
// put your main code here, to run repeatedly:

if (sht.readSample()) {
Serial.print("SHT:\n");
Serial.print(" RH: ");
Serial.print(sht.getHumidity(), 2);
Serial.print("\n");
Serial.print(" T: ");
Serial.print(sht.getTemperature(), 2);
Serial.print("\n");
} else {
Serial.print("Error in readSample()\n");
}

delay(1000);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

SHT:
RH: 40.45
T: 23.96
SHT:
RH: 40.56
T: 23.92
SHT:
RH: 40.68
T: 23.84
SHT:
RH: 40.80
T: 23.80

Links

 

 

 

 

Arduino

Microbit and LIS3MDL magnetic field sensor example

by shedboy71

In this article we look at another sensor – this time its the LIS3MDL which is a 3-axis MEMS magnetic field sensor, digital output, I2C, SPI, low power mode, high performance

This is the sensor that I bought

Lets see what the sensor manufacturer says about it

The LIS3MDL has user-selectable full scales of ±4/±8/±12/±16 gauss.
The self-test capability allows the user to check the functioning of the sensor in the final application.
The device may be configured to generate interrupt signals for magnetic field detection.
The LIS3MDL includes an I2C serial bus interface that supports standard and fast mode (100 kHz and 400 kHz) and SPI serial standard interface.
The LIS3MDL is available in a small thin plastic land grid array package (LGA) and is guaranteed to operate over an extended temperature range of -40 °C to +85 °C.

Features

  • Wide supply voltage, 1.9 V to 3.6 V
  • Independent IO supply (1.8 V)
  • ±4/±8/±12/±16 gauss selectable magnetic full scales
  • Continuous and single-conversion modes
  • 16-bit data output
  • Interrupt generator
  • Self-test
  • I2C/SPI digital output interface
  • Power-down mode / low-power mode

Parts Required

Once again for ease of use I connect an expansion board to the microbit, I feel this makes it easier to connect to a sensor like the one pictured above using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
LIS3MDL Taidacent LIS3MDL High Precision 3 Axis Magnetometer Sensor Compass Module Tilt Compensated Compass Replacement HMC5883L
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

Microbit Sensor
3.3v Vcc
Gnd Gnd
SDA – 20 SDA
SCL – 19 SCL

 

Code Example

This uses the library from https://github.com/pololu/lis3mdl-arduino

This is the serial example which as you can guess simply outputs values to the serial port

[codesyntax lang=”cpp”]

/*
The sensor outputs provided by the library are the raw 16-bit values
obtained by concatenating the 8-bit high and low magnetometer data registers.
They can be converted to units of gauss using the
conversion factors specified in the datasheet for your particular
device and full scale setting (gain).

Example: An LIS3MDL gives a magnetometer X axis reading of 1292 with its
default full scale setting of +/- 4 gauss. The GN specification
in the LIS3MDL datasheet (page 8) states a conversion factor of 6842
LSB/gauss (where LSB means least significant bit) at this FS setting, so the raw
reading of 1292 corresponds to 1292 / 6842 = 0.1888 gauss.
*/

#include <Wire.h>
#include <LIS3MDL.h>

LIS3MDL mag;

char report[80];

void setup()
{
  Serial.begin(9600);
  Wire.begin();

  if (!mag.init())
  {
    Serial.println("Failed to detect and initialize magnetometer!");
    while (1);
  }

  mag.enableDefault();
}

void loop()
{
  mag.read();

  snprintf(report, sizeof(report), "M: %6d %6d %6d",
    mag.m.x, mag.m.y, mag.m.z);
  Serial.println(report);

  delay(100);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this, move the sensor about to see the values change

M: -2304 -972 4756
M: -2197 -879 5280
M: -1554 -788 5950
M: -1067 -485 6546
M: -570 182 7095
M: -1822 567 6935
M: -3282 1201 6044

Links

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

 

 

 

Arduino

Microbit and LPS25H piezoresistive pressure sensor example

by shedboy71

In this article we look at a pressure sensor – this time its the LPS25H and we will connect to our Microbit and see what it can do

This is the sensor that I used

Lets see what the manufacturer says about the sensor

The LPS25H is an ultra-compact absolute piezoresistive pressure sensor. It includes a monolithic sensing element and an IC interface able to take the information from the sensing element and to provide a digital signal to the external world.

The sensing element consists of a suspended membrane realized inside a single mono-silicon substrate. It is capable of detecting pressure and is manufactured using a dedicated process developed by ST.

The membrane is very small compared to the traditionally built silicon micromachined membranes. Membrane breakage is prevented by an intrinsic mechanical stopper.
The IC interface is manufactured using a standard CMOS process that allows a high level of integration to design a dedicated circuit which is trimmed to better match the sensing element characteristics.

The LPS25H is available in a cavity holed LGA package (HLGA). It is guaranteed to operate over a temperature range extending from -30 °C to +105 °C. The package is holed to allow external pressure to reach the sensing element.

Features

260 to 1260 mbar absolute pressure range
High-resolution mode: 1 Pa RMS
Low power consumption
Low-resolution mode: 4 μA
High-resolution mode: 25 μA
High overpressure capability: 20x full scale
Embedded temperature compensation
Embedded 24-bit ADC
Selectable ODR from 1 Hz to 25 Hz
SPI and I²C interfaces
Supply voltage: 1.7 to 3.6 V
High shock survivability: 10,000 g

 

Parts Required

 

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
LPS25H Diybigworld LPS25HTR ST CJMCU-25 Miniature high Precision Pressure Sensor Temperature Compensation
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

 

Microbit Sensor
3v3 3v3
Gnd Gnd
SDA – 20 SDA
SCL – 19 SCL

Code Example

This uses the library from https://github.com/pololu/lps-arduino

This is the Serialmetric example

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <LPS.h>

LPS ps;

void setup()
{
  Serial.begin(9600);
  Wire.begin();

  if (!ps.init())
  {
    Serial.println("Failed to autodetect pressure sensor!");
    while (1);
  }

  ps.enableDefault();
}

void loop()
{
  float pressure = ps.readPressureMillibars();
  float altitude = ps.pressureToAltitudeMeters(pressure);
  float temperature = ps.readTemperatureC();
  
  Serial.print("p: ");
  Serial.print(pressure);
  Serial.print(" mbar\ta: ");
  Serial.print(altitude);
  Serial.print(" m\tt: ");
  Serial.print(temperature);
  Serial.println(" deg C");

  delay(100);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this

p: 1015.95 mbar a: -22.49 m t: 22.00 deg C
p: 1016.00 mbar a: -22.84 m t: 22.01 deg C
p: 1016.11 mbar a: -23.80 m t: 22.01 deg C
p: 1016.16 mbar a: -24.21 m t: 22.04 deg C
p: 1016.04 mbar a: -23.18 m t: 22.08 deg C
p: 1016.06 mbar a: -23.35 m t: 22.14 deg C
p: 1016.00 mbar a: -22.84 m t: 22.24 deg C
p: 1015.97 mbar a: -22.65 m t: 22.36 deg C

 

Links

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

Arduino

Microbit and LPS22HB absolute pressure sensor example

by shedboy71

In this article we look at another pressure sensor – this time its the LPS22HB piezoresistive absolute pressure sensor and we will connect it to our Microbit

This is the sensor I used

Here is some technical information about this sensor

The LPS22HB is an ultra-compact piezoresistive absolute pressure sensor which functions as a digital output barometer. The device comprises a sensing element and an IC interface which communicates through I2C or SPI from the sensing element to the application.

The sensing element, which detects absolute pressure, consists of a suspended membrane manufactured using a dedicated process developed by ST.

The LPS22HB is available in a full-mold, holed LGA package (HLGA). It is guaranteed to operate over a temperature range extending from -40 °C to +85 °C. The package is holed to allow external pressure to reach the sensing element.

Features

  • 260 to 1260 hPa absolute pressure range
  • Current consumption down to 3 μA
  • High overpressure capability: 20x full-scale
  • Embedded temperature compensation
  • 24-bit pressure data output
  • 16-bit temperature data output
  • ODR from 1 Hz to 75 Hz
  • SPI and I²C interfaces
  • Embedded FIFO
  • Interrupt functions: Data Ready, FIFO flags, pressure thresholds
  • Supply voltage: 1.7 to 3.6 V
  • High shock survivability: 22,000 g

 

Parts Required

I used an expansion board connected to the Micro:bit, this makes it easier to connect sensors using connecting wire

Name Link
Microbit BBC Micro:bit Micro-Controller with Motion Detection, Compass, LED Display and Bluetooth
LPS22HB Semoic Lps22Hb Pressure Resistance Pressure Sensor Module for High Intensity Industrial Control
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board Microbit expansion board

Schematic/Connection

I used the I2C connection for the sensor

Microbit Sensor
3v3 3v3
Gnd Gnd
SDA – 20 SDA
SCL – 19 SCL

Code Example

This uses the library from hhttps://github.com/adrien3d/IO_LPS22HB

[codesyntax lang=”cpp”]

#include <Wire.h>

#include "IO_LPS22HB.h"

IO_LPS22HB lps22hb;

void setup()
{
  Serial.begin(9600);
  Serial.println("IoThings LPS22HB Arduino Test");
  
  lps22hb.begin(0x5D);
  
  byte who_am_i = lps22hb.whoAmI();
  Serial.print("Who Am I? 0x");
  Serial.print(who_am_i, HEX);
  Serial.println(" (expected: 0xB1)");
  if (who_am_i != LPS22HB_WHO_AM_I_VALUE) 
  {
  Serial.println("Error while retrieving WHO_AM_I byte...");
    while (true) {
    // loop forever
    }
  }
}

void loop()
{
  Serial.print("P=");
  Serial.print(lps22hb.readPressure());
  Serial.print(" mbar, T=");
  Serial.print(lps22hb.readTemperature());
  Serial.println("C");
  delay(300);
}

[/codesyntax]

 

 

Output

Open the serial monitor and you should see something like this

P=1014.41 mbar, T=23.33C
P=1014.42 mbar, T=23.41C
P=1014.41 mbar, T=23.45C
P=1014.41 mbar, T=23.47C
P=1014.40 mbar, T=23.45C
P=1014.39 mbar, T=23.40C

 

Links

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

 

 

Arduino

Micro:bit and BMA400 acceleration sensor example with the Arduino IDE

by shedboy71

In this article we look at another acceleration sensor – this time its the BMA400

Lets look at the sensor before we explore how to connect it to a micro:bit

The BMA400 is the first real ultra-low power acceleration sensor without compromising on performance. Featuring 12-bit digital resolution, continuous measurement and a defined selectable bandwidth combined with ultra-low power the BMA400 allows low-noise measurement of accelerations in three perpendicular axes. The BMA400 thus senses tilt, orientation, tab/double tab, and enables plug ’n’ play step counting with activity recognition especially suited for wearable devices, which need a long-lasting battery lifetime.

Thanks to the continuous measurement principle and always-defined bandwidth, the BMA400 is the ideal solution for smart home applications such as smart indoor climate systems and smart home security systems. In the latter, the BMA400 can distinguish between real alarm situations like broken glass and false signals coming from random vibrations. Thereby, the new acceleration sensor avoids false alarms.

Features

Parameter Technical data
Measurement range ±2 g, ±4 g, ±8 g, ±16 g
Digital resolution 12 bit
Output Data Rate (ODR) 12.5 Hz to 800 Hz
Low path filter bandwidth Selectable 0.48xODR or 0.24xODR
Current consumption (independent from ODR due to continuous measurement) Max. performance: 14.5 μA
Typical use case: 5.8 μA
Low power use case: 3.5μA
Noise density Max. performance: 180 μg/√Hz (Z: x 1.45)
Typical use case: 300 μg/√Hz (Z: x 1.45)
Low power: 415 μg/√Hz (Z: x 1.45)
Ultra low power / Auto-wake-up mode 800 nA @ 25 Hz ODR
Embedded features
  • Step counter (< 4 μA overall)
  • Activity recognition (walking, running, standing still)
  • Activity change
  • Orientation
  • Tab/Double tab (< 8 μA overall)
  • General interrupt 1 and 2 (programmable via thresholds, timer, logical AND/OR operations)
  • 1 kB FIFO
Offset ±80 mg
TCO ±1 mg/K
Interface SPI & I²C & 2 Interrupt pins
Supply voltage 1.71 V up to 3.6 V

Parts Required

 

Name Link
Micro:bit Micro Bit Development Board
BMA400 BMA400 Acceleration Sensor
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board GPIO Expansion Board For micro:bit

Schematic/Connection

microbit and bma400

microbit and bma400

 

Code Example

This uses the library from https://github.com/Seeed-Studio/Grove_3Axis_Digital_Accelerometer_BMA400

[codesyntax lang=”cpp”]

#include “BMA400.h”

float x = 0, y = 0, z = 0;
int16_t temp = 0;

void setup(void)
{
Wire.begin();

Serial.begin(115200);
while(!Serial);
Serial.println(“BMA400 Raw Data”);

while(1)
{
if(bma400.isConnection())
{
bma400.initialize();
Serial.println(“BMA400 is connected”);
break;
}
else Serial.println(“BMA400 is not connected”);

delay(2000);
}
}

void loop(void)
{
bma400.getAcceleration(&x, &y, &z);
temp = bma400.getTemperature();

Serial.print(x);
Serial.print(“,”);
Serial.print(y);
Serial.print(“,”);
Serial.print(z);
Serial.print(“,”);

Serial.print(temp);

Serial.println();

delay(500);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

BMA400 is connected
-320.31,812.50,410.16,29
-486.33,861.33,291.02,23
-765.62,1039.06,310.55,30
0.00,0.00,0.00,23
0.00,0.00,0.00,23
-353.52,878.91,201.17,29
0.00,0.00,0.00,23
-261.72,933.59,156.25,29
-160.16,921.87,400.39,30

 

Links

https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMA400-DS000.pdf

https://github.com/BoschSensortec/BMA400-API

https://www.bosch-sensortec.com/bst/products/all_products/bma400_1

 

 

Arduino

Micro:bit and BMP388 barometric pressure sensor example with the Arduino IDE

by shedboy71

Another sensor for the collection – it is a BMP388 by Bosch Sensortec, so lets crack on and try this out with a Micro:bit again

On with the manufacturers information

BMP388 Information

The BMP388 is a very small, low-power and low-noise 24 bit absolute barometric pressure sensor. It enables accurate altitude tracking and is specifically suited for drone applications. The best-in-class TCO of the BMP388 between 0-65°C for accurate altitude measurement over a wide temperature range greatly enhances the drone flying experience by making accurate steering easier.

It is compatible for use with other Bosch sensors, including BMI088 for better performance, robustness and stability.

The BMP388 sensor offers outstanding design flexibility, providing a single package solution that is easy to integrate into other existing and upcoming devices such as smart homes, industrial products and wearables.

It is more accurate than its predecessors, covering a wide measurement range from 300 hPa to 1250 hPa. BMP388 exhibits an attractive price-performance ratio coupled with low power consumption. It is available in a compact 10-pin 2.0 x 2.0 x 0.75 mm³ LGA package with metal lid.

  • Operating voltage: 3.3V/5V
  • Communication interface: I2C/SPI
  • Barometric pressure operation range: 300~1250hPa
  • Barometric pressure absolute accuracy: ±0.40hPa (@900~1100hPa, 25~40℃)
  • Barometric pressure relative accuracy: ±0.08hPa (@900~1100hPa, 25~40℃)
  • Temperature coefficient offset: ±0.75Pa/K (@700~1100hPa, -20~65℃)）
  • Temperature absolute accuracy: ±0.5℃ (0~65℃）
  • Possible resolution: 0.016Pa (high precision mode)
  • Possible sampling rate: 200Hz
  • Operating voltage: -40~85℃

If you purchase a module they will have a 3.3v regulator on board, you will also have the option of I2C or SPI, here is the module that I located.

Parts Required

I connected a expansion board to a Micro:bit and then the sensor via connecting wire

Name Link
Micro:bit Micro Bit Development Board
BMP388 24-bit low noise BMP388 digital temperature atmospheric pressure sensor
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board GPIO Expansion Board For micro:bit

Schematic/Connection

I decided to use the sensor in I2C mode

microbit and bmp388

microbit and bmp388

Code Example

I used the library from adafruit – https://github.com/adafruit/Adafruit_BMP3XX. 

This library can be installed via the library manager. This is the default example and I have removed some of the SPI code and code comments since I was using the sensor in I2C mode

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BMP3XX.h"


#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BMP3XX bmp; // I2C


void setup() {
  Serial.begin(115200);
  while (!Serial);
  Serial.println("BMP388 test");

  if (!bmp.begin()) {
    Serial.println("Could not find a valid BMP3 sensor, check wiring!");
    while (1);
  }

  // Set up oversampling and filter initialization
  bmp.setTemperatureOversampling(BMP3_OVERSAMPLING_8X);
  bmp.setPressureOversampling(BMP3_OVERSAMPLING_4X);
  bmp.setIIRFilterCoeff(BMP3_IIR_FILTER_COEFF_3);
  //bmp.setOutputDataRate(BMP3_ODR_50_HZ);
}

void loop() {
  if (! bmp.performReading()) {
    Serial.println("Failed to perform reading :(");
    return;
  }
  Serial.print("Temperature = ");
  Serial.print(bmp.temperature);
  Serial.println(" *C");

  Serial.print("Pressure = ");
  Serial.print(bmp.pressure / 100.0);
  Serial.println(" hPa");

  Serial.print("Approx. Altitude = ");
  Serial.print(bmp.readAltitude(SEALEVELPRESSURE_HPA));
  Serial.println(" m");

  Serial.println();
  delay(2000);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Temperature = 26.64 *C
Pressure = 1005.61 hPa
Approx. Altitude = 63.83 m

Temperature = 26.59 *C
Pressure = 1005.60 hPa
Approx. Altitude = 63.86 m

Temperature = 26.52 *C
Pressure = 1005.60 hPa
Approx. Altitude = 63.85 m

 

Links

 

 

Summary

A nice little sensor but at just over $8 but one again there are cheaper sensors available which have the same functionality and for most projects have acceptable performance.

Newer Posts
Older Posts

Adblock Detected

Please support us by disabling your AdBlocker extension from your browsers for our website.