Home Tags Posts tagged with "Arduino"
Tag:

Arduino

Arduino

Microbit and VCNL4040 Proximity and Ambient Light Sensor Arduino example

by shedboy71

In this article we look at another Proximity and Ambient Light Sensor – this time its the VCNL4040 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

VCNL4040 integrates a proximity sensor (PS), ambientlight sensor (ALS), and a high power IRED into one small package. It incorporates photodiodes, amplifiers, and analog to digital converting circuits into a single chip by CMOS process.

The 16-bit high resolution ALS offers excellent sensing capabilities with sufficient selections to fulfill most applications whether dark or high transparency lens design.

High and low interrupt thresholds can be programmed for both ALS and PS, allowing the component to use a minimal amount of the microcontrollers resources.

The proximity sensor features an intelligent cancellation scheme, so that cross talk phenomenon is eliminated effectively. To accelerate the PS response time, smart persistence prevents the misjudgment of proximity sensing but also keeps a fast response time.

In active force mode, a single measurement can be requested, allowing another good approach for more design flexibility to fulfill different kinds of applications with more power saving.

The patented Filtron technology achieves ambient light spectral sensitivity closest to real human eye response and offers the best background light cancellation capability(including sunlight) without utilizing the microcontrollers ’resources.

VCNL4040 provides an excellent temperature compensation capability for keeping output stable under various temperature configurations. ALS and PS functions are easily set via the simple command format of I2C(SMBus compatible) interface protocol.

Operating voltage ranges from 2.5 V to 3.6 V.

Here is the sensor I purchased from the good folks at Adafruit (via Pimoroni in the UK)

vcnl4040 board

vcnl4040 board

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 Offical Microbit V2 Development Board
VCNL4040 SEN-15177 Optical Sensor Development Tools xx Proximity Sensor Breakout – 20cm, VCNL4040 (Qwiic)
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

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

 

Code Example

This sensor uses a couple of libraries, both of which can be installed using the library manager. if you search for the VCNL4040 one first and you are using a newer version of the Arduino IDE it will install the other one as well.

You need the Adafruit library for the VCNL4040 –https://github.com/adafruit/Adafruit_VCNL4040

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is mainly the default example

[codesyntax lang=”cpp”]

#include <Adafruit_VCNL4040.h>

Adafruit_VCNL4040 vcnl4040 = Adafruit_VCNL4040();

void setup() {
  Serial.begin(115200);
  // Wait until serial port is opened
  while (!Serial) { delay(1); }

  Serial.println("Adafruit VCNL4040 Config demo");

  if (!vcnl4040.begin()) {
    Serial.println("Couldn't find VCNL4040 chip");
    while (1);
  }
  Serial.println("Found VCNL4040 chip");

  //vcnl4040.setProximityLEDCurrent(VCNL4040_LED_CURRENT_200MA);
  Serial.print("Proximity LED current set to: ");
  switch(vcnl4040.getProximityLEDCurrent()) {
    case VCNL4040_LED_CURRENT_50MA: Serial.println("50 mA"); break;
    case VCNL4040_LED_CURRENT_75MA: Serial.println("75 mA"); break;
    case VCNL4040_LED_CURRENT_100MA: Serial.println("100 mA"); break;
    case VCNL4040_LED_CURRENT_120MA: Serial.println("120 mA"); break;
    case VCNL4040_LED_CURRENT_140MA: Serial.println("140 mA"); break;
    case VCNL4040_LED_CURRENT_160MA: Serial.println("160 mA"); break;
    case VCNL4040_LED_CURRENT_180MA: Serial.println("180 mA"); break;
    case VCNL4040_LED_CURRENT_200MA: Serial.println("200 mA"); break;
  }
  
  //vcnl4040.setProximityLEDDutyCycle(VCNL4040_LED_DUTY_1_40);
  Serial.print("Proximity LED duty cycle set to: ");
  switch(vcnl4040.getProximityLEDDutyCycle()) {
    case VCNL4040_LED_DUTY_1_40: Serial.println("1/40"); break;
    case VCNL4040_LED_DUTY_1_80: Serial.println("1/80"); break;
    case VCNL4040_LED_DUTY_1_160: Serial.println("1/160"); break;
    case VCNL4040_LED_DUTY_1_320: Serial.println("1/320"); break;
  }

  //vcnl4040.setAmbientIntegrationTime(VCNL4040_AMBIENT_INTEGRATION_TIME_80MS);
  Serial.print("Ambient light integration time set to: ");
  switch(vcnl4040.getAmbientIntegrationTime()) {
    case VCNL4040_AMBIENT_INTEGRATION_TIME_80MS: Serial.println("80 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_160MS: Serial.println("160 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_320MS: Serial.println("320 ms"); break;
    case VCNL4040_AMBIENT_INTEGRATION_TIME_640MS: Serial.println("640 ms"); break;
  }


  //vcnl4040.setProximityIntegrationTime(VCNL4040_PROXIMITY_INTEGRATION_TIME_8T);
  Serial.print("Proximity integration time set to: ");
  switch(vcnl4040.getProximityIntegrationTime()) {
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_1T: Serial.println("1T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_1_5T: Serial.println("1.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_2T: Serial.println("2T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_2_5T: Serial.println("2.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_3T: Serial.println("3T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_3_5T: Serial.println("3.5T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_4T: Serial.println("4T"); break;
    case VCNL4040_PROXIMITY_INTEGRATION_TIME_8T: Serial.println("8T"); break;
  }

  //vcnl4040.setProximityHighResolution(false);
  Serial.print("Proximity measurement high resolution? ");
  Serial.println(vcnl4040.getProximityHighResolution() ? "True" : "False");

  Serial.println("");

}

void loop() {
  
  Serial.print("Proximity:"); Serial.println(vcnl4040.getProximity());
  Serial.print("Ambient light:"); Serial.println(vcnl4040.getLux());
  Serial.print("Raw white light:"); Serial.println(vcnl4040.getWhiteLight());
  Serial.println("");
 
  delay(500);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Proximity:1
Ambient light:11
Raw white light:10

Proximity:1
Ambient light:12
Raw white light:11

Proximity:1
Ambient light:11
Raw white light:11

Links

https://www.vishay.com/docs/84274/vcnl4040.pdf

microbit and sht40 layout
Arduino

Microbit and SHT40 Digital Humidity Sensor Arduino example

by shedboy71

In this article we look at another Digital Humidity Sensor – this time its the SHT40 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

The SHT40 builds on a completely new and optimized CMOSens® chip that offers reduced power consumption and improved accuracy specifications. With the extended supply voltage range from 1.08 V to 3.6 V, it’s the perfect fit for mobile and battery-driven applications.

Size 1.5 x 1.5 x 0.5 mm3
Output I²C
Supply voltage range 1.08 to 3.6 V
Energy consumption 0.4µA (at meas. rate 1 Hz)
RH operating range 0 – 100% RH
T operating range -40 to +125°C (-40 to +257°F)
RH response time 6 sec (tau63%)

 

Here is the sensor I purchased from the good folks at Adafruit (via Pimoroni in the UK)

adafruit SHT40

Unlike earlier SHT sensors, this sensor has a true I2C interface for easy interfacing with only two wires (plus power and ground!).

Thanks to the voltage regulator and level shifting circuitry that Adafruit have included on the breakout it is also 3V or 5V compliant.

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 Offical Microbit V2 Development Board
SHT40 https://www.adafruit.com/product/4885

https://shop.pimoroni.com/products/adafruit-sensirion-sht40-temperature-humidity-sensor-stemma-qt-qwiic
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

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

microbit and sht40 layout

microbit and sht40 layout

Code Example

This example uses a couple of libraries, both of which can be installed using the library manager. if you search for the SHT40 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which is useful.

You need the Adafruit library for the SHT40 – https://github.com/adafruit/Adafruit_SHT4X

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is mainly the default example

[codesyntax lang=”cpp”]

/*************************************************** 
  This is an example for the SHT4x Humidity & Temp Sensor

  Designed specifically to work with the SHT4x sensor from Adafruit
  ----> https://www.adafruit.com/products/4885

  These sensors use I2C to communicate, 2 pins are required to  
  interface
 ****************************************************/

#include "Adafruit_SHT4x.h"

Adafruit_SHT4x sht4 = Adafruit_SHT4x();

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

  while (!Serial)
    delay(10);     // will pause Zero, Leonardo, etc until serial console opens

  Serial.println("Adafruit SHT4x test");
  if (! sht4.begin()) {
    Serial.println("Couldn't find SHT4x");
    while (1) delay(1);
  }
  Serial.println("Found SHT4x sensor");
  Serial.print("Serial number 0x");
  Serial.println(sht4.readSerial(), HEX);

  // You can have 3 different precisions, higher precision takes longer
  sht4.setPrecision(SHT4X_HIGH_PRECISION);
  switch (sht4.getPrecision()) {
     case SHT4X_HIGH_PRECISION: 
       Serial.println("High precision");
       break;
     case SHT4X_MED_PRECISION: 
       Serial.println("Med precision");
       break;
     case SHT4X_LOW_PRECISION: 
       Serial.println("Low precision");
       break;
  }

  // You can have 6 different heater settings
  // higher heat and longer times uses more power
  // and reads will take longer too!
  sht4.setHeater(SHT4X_NO_HEATER);
  switch (sht4.getHeater()) {
     case SHT4X_NO_HEATER: 
       Serial.println("No heater");
       break;
     case SHT4X_HIGH_HEATER_1S: 
       Serial.println("High heat for 1 second");
       break;
     case SHT4X_HIGH_HEATER_100MS: 
       Serial.println("High heat for 0.1 second");
       break;
     case SHT4X_MED_HEATER_1S: 
       Serial.println("Medium heat for 1 second");
       break;
     case SHT4X_MED_HEATER_100MS: 
       Serial.println("Medium heat for 0.1 second");
       break;
     case SHT4X_LOW_HEATER_1S: 
       Serial.println("Low heat for 1 second");
       break;
     case SHT4X_LOW_HEATER_100MS: 
       Serial.println("Low heat for 0.1 second");
       break;
  }
  
}


void loop() {
  sensors_event_t humidity, temp;
  
  uint32_t timestamp = millis();
  sht4.getEvent(&humidity, &temp);// populate temp and humidity objects with fresh data
  timestamp = millis() - timestamp;

  Serial.print("Temperature: "); 
  Serial.print(temp.temperature); 
  Serial.println(" degrees C");
  Serial.print("Humidity: "); 
  Serial.print(humidity.relative_humidity); 
  Serial.println("% rH");

  Serial.print("Read duration (ms): ");
  Serial.println(timestamp);

  delay(1000);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Temperature: 20.74 degrees C
Humidity: 44.26% rH
Read duration (ms): 10
Temperature: 20.75 degrees C
Humidity: 44.27% rH
Read duration (ms): 10
Temperature: 20.73 degrees C
Humidity: 44.24% rH
Read duration (ms): 10

Links

https://www.sensirion.com/en/download-center/humidity-sensors/humidity-sensor-sht4x/

 

microbit and dps310 layout
Arduino

Microbit and DPS310 barometric pressure sensor Arduino example

by shedboy71

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

First lets take a look at the sensor in question, this is from the datasheet

The pressure sensor element is based on a capacitive sensing principle which guarantees high precision during temperature changes. The small package makes the DPS310 ideal for mobile applications and wearable devices.

The internal signal processor converts the output from the pressure and temperature sensor elements to 24 bit results.

Each unit is individually calibrated, the calibration coefficients calculated during this process are stored in the calibration registers. The coefficients are used in the application to convert the measurement results to high accuracy pressure and temperature values.

The result FIFO can store up to 32 measurement results, allowing for a reduced host processor polling rate. Sensor measurements and calibration coefficients are available through the serial I2C or SPI interface.

The measurement status is indicated by status bits or interrupts on the SDO pin.

Features

  • Supply voltage range 1.7V to 3.6V
  • Operation range 300hPa – 1200hPa
  • Sensor’s precision 0.002hPa
  • Relative accuracy ±0.06hPa
  • Pressure temperature sensitivity of 0.5Pa/K
  • Temperature accuracy  ±0.5C°

 

This is the sensor that 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 Offical Microbit V2 Development Board
DPS310 DPS310 Precision Barometric Pressure / Altitud
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

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

microbit and dps310 layout

microbit and dps310 layout

Code Example

This example uses a couple of libraries, both of which can be installed using the library manager. if you search for the DPS310 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which is useful.

You need the Adafruit library for the https://github.com/adafruit/Adafruit_DPS310

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is one of the simple test examples

[codesyntax lang=”cpp”]

// This example shows how to read temperature/pressure

#include <Adafruit_DPS310.h>

Adafruit_DPS310 dps;

void setup() 
{
  Serial.begin(115200);
  while (!Serial) delay(10);

  Serial.println("DPS310");
  if (! dps.begin_I2C()) {             // Can pass in I2C address here
  {
    Serial.println("Failed to find DPS");
  }
    while (1) yield();
  }
  Serial.println("DPS OK!");

  dps.configurePressure(DPS310_64HZ, DPS310_64SAMPLES);
  dps.configureTemperature(DPS310_64HZ, DPS310_64SAMPLES);
}

void loop() 
{
  sensors_event_t temp_event, pressure_event;
  
  while (!dps.temperatureAvailable() || !dps.pressureAvailable()) 
  {
    return; // wait until there's something to read
  }

  dps.getEvents(&temp_event, &pressure_event);
  Serial.print(F("Temperature = "));
  Serial.print(temp_event.temperature);
  Serial.println(" *C");

  Serial.print(F("Pressure = "));
  Serial.print(pressure_event.pressure);
  Serial.println(" hPa"); 

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

[/codesyntax]

Output

Open the serial monitor and you should see something like this

TemTemperature = 21.14 *C
Pressure = 987.25 hPa

Temperature = 21.15 *C
Pressure = 987.25 hPa

Temperature = 21.15 *C
Pressure = 987.25 hPa

Temperature = 21.16 *C
Pressure = 987.25 hPa

Links

Datasheet

 

microbit and ltr390 layout
Arduino

Microbit and LTR390 UV Light Sensor Arduino example

by shedboy71

In this article we look at another UV Light Sensor – this time its the LTR390 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

This sensor converts light intensity to a digital output signal capable of direct I2C interface.

It provides a linear ALS response over a wide dynamic range, and is well suited to applications under high ambient brightness.

The sensor has a programmable interrupt with hysteresis to response to events and that removes the need to poll the sensor for a reading which improves system efficiency.

This CMOS design and factory-set one time trimming capability ensure minimal sensor-to-sensor variations forease of manufacturability to the end customers.

Features

I2C interface capable of Standard mode @100kHz or Fast mode @400kHz communication; 1.8V logic compatible
Ambient Light / Ultraviolet light(UVS)Technology in one ultra-small 2x2mm Chip LED package
Very low power consumption with sleep mode capability
Operating voltage ranges: 1.7V to 3.6V
Operating temperature ranges: -40 to +85 ºC
Built-in temperature compensation circuit
Programmable interrupt function for ALS , UVS with upper and lower thresholds
RoHS and Halogen free compliant

UVS/ALS Features

  • 13 to 20 bits effective resolution
  • Wide dynamic range of 1:18,000,000 with linear response
  • Close to human eye spectral response
  • Automatic rejection for 50Hz/60Hz lighting flicker

This is the sensor that 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 Offical Microbit V2 Development Board
LTR390 Adafruit Industries Adafruit LTR390 UV Light Sensor – Stemma QTQwiic
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

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

microbit and ltr390 layout

microbit and ltr390 layout

Code Example

This sensor uses a couple of libraries, both of which can be installed using the library manager. if you search for the LTR390 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which makes things a bit easier.

You need the Adafruit library for the https://github.com/adafruit/Adafruit_LTR390

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is the simple test example

[codesyntax lang=”cpp”]

#include "Adafruit_LTR390.h"

Adafruit_LTR390 ltr = Adafruit_LTR390();

void setup() {
  Serial.begin(115200);
  Serial.println("Adafruit LTR-390 test");

  if ( ! ltr.begin() ) {
    Serial.println("Couldn't find LTR sensor!");
    while (1) delay(10);
  }
  Serial.println("Found LTR sensor!");

  ltr.setMode(LTR390_MODE_UVS);
  if (ltr.getMode() == LTR390_MODE_ALS) {
    Serial.println("In ALS mode");
  } else {
    Serial.println("In UVS mode");
  }

  ltr.setGain(LTR390_GAIN_3);
  Serial.print("Gain : ");
  switch (ltr.getGain()) {
    case LTR390_GAIN_1: Serial.println(1); break;
    case LTR390_GAIN_3: Serial.println(3); break;
    case LTR390_GAIN_6: Serial.println(6); break;
    case LTR390_GAIN_9: Serial.println(9); break;
    case LTR390_GAIN_18: Serial.println(18); break;
  }

  ltr.setResolution(LTR390_RESOLUTION_16BIT);
  Serial.print("Resolution : ");
  switch (ltr.getResolution()) {
    case LTR390_RESOLUTION_13BIT: Serial.println(13); break;
    case LTR390_RESOLUTION_16BIT: Serial.println(16); break;
    case LTR390_RESOLUTION_17BIT: Serial.println(17); break;
    case LTR390_RESOLUTION_18BIT: Serial.println(18); break;
    case LTR390_RESOLUTION_19BIT: Serial.println(19); break;
    case LTR390_RESOLUTION_20BIT: Serial.println(20); break;
  }

  ltr.setThresholds(100, 1000);
  ltr.configInterrupt(true, LTR390_MODE_UVS);
}

void loop() 
{
  if (ltr.newDataAvailable()) 
  {
      Serial.print("UV data: "); 
      Serial.println(ltr.readUVS());
  }
  
  delay(100);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this

UV data: 0
UV data: 0
UV data: 0
UV data: 0
UV data: 0
UV data: 0
UV data: 0

Links

Datasheet

 

microbit and pct2075 layout
Arduino

Microbit and PCT2075 temperature-to-digital converter Arduino example

by shedboy71

In this article we look at another temperature sensors – this time its the PCT2075 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

The PCT2075 is a temperature-to-digital converter featuring ±1 °C accuracy over ‑25 °C to +100 °C range. It uses an on-chip band gap temperature sensor and Sigma-Delta A‑to‑D conversion technique with an overtemperature detection output that is a drop-in replacement for other LM75 series thermal sensors.

The device contains a number of data registers: Configuration register to store the device settings such as device operation mode, OS operation mode, OS polarity and OS fault queue; temperature register to store the digital temp reading, set-point registers to store programmable over temperature shutdown and hysteresis limits, and programmable temperature sensor sampling time Tidle, that can be communicated by a controller via the 2-wire serial I²C-bus Fast-mode Plus interface.

The PCT2075 also includes an open-drain output which becomes active when the temperature exceeds the programmed limits. The OS output operates in either of two selectable modes: OS comparator mode or OS interrupt mode.

Its active state can be selected as either HIGH or LOW. The fault queue that defines the number of consecutive faults in order to activate the OS output is programmable as well as the set-point limits.

The PCT2075 can be configured for different operation conditions. It can be set in normal mode to periodically monitor the ambient temperature, or in shut-down mode to minimize power consumption.

The temperature register always stores an 11-bit two’s complement data, giving a temperature resolution of 0.125 °C. This high temperature resolution is particularly useful in applications of measuring precisely the thermal drift or runaway.

When the device is accessed the conversion in process is not interrupted and accessing the device continuously without waiting at least one conversion time between communications will not prevent the device from updating the Temp register with a new conversion result.

The new conversion result will be available immediately after the Temp register is updated. It is also possible to read just one of the temperature register bytes without lock-up.

The PCT2075 powers up in the normal operation mode with the OS in comparator mode, temperature threshold of 80 °C and hysteresis of 75 °C, so that it can be used as a stand-alone thermostat with those pre-defined temperature set points.

The default set points can be modified during manufacture and ordered under custom part number.

This is the sensor that I bought, it is an adafruit version

 

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 Offical Microbit V2 Development Board
PCT2075 PCT2075 Temperature Sensor – STEMMA QT / Qwiic
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

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

microbit and pct2075 layout

microbit and pct2075 layout

Code Example

This example uses a couple of libraries, both of which can be installed using the library manager

You need the Adafruit library for the PCT2075 from https://github.com/adafruit/Adafruit_PCT2075

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is the simple test example that comes with the library

[codesyntax lang=”cpp”]

#include <Adafruit_PCT2075.h>


Adafruit_PCT2075 PCT2075;

void setup() 
{
  PCT2075 = Adafruit_PCT2075();

  Serial.begin(115200);
  // Wait until serial port is opened
  while (!Serial) 
  { 
    delay(1); 
  }
  Serial.println("Adafruit PCT2075 Test");

  if (!PCT2075.begin()) 
  {
    Serial.println("Couldn't find PCT2075 chip");
    while (1);
  }
  
  Serial.println("Found PCT2075 chip");

}

void loop() {
  Serial.print("Temperature: "); 
  Serial.print(PCT2075.getTemperature());
  Serial.println(" C");
  delay(1000);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this

 

Links

Datasheet

 

microbit and vl6180x layout
Arduino

Microbit and VL6180X sensor Arduino example

by shedboy71

In this article we look at another temperature and humidity sensors – this time its the VL6180X and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

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 I2C 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

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 Offical Microbit V2 Development Board
VL6180X VL6180X Range Finder Optical Ranging Sensor Module
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

If you have an ESP32 board with a STEMMA QT cables, you can use these:

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

microbit and vl6180x layout

microbit 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

This is the simple test example that comes with the 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

Open the serial monitor and you should see something like this

Lux: 0.00
Range: 16
Lux: 0.00
Range: 16
Lux: 0.00
Range: 14
Lux: 0.00
Range: 15
Lux: 0.00
Range: 14

Links

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

 

microbit and aht20 layout
Arduino

Microbit and AHT20 temperature and humidity sensor Arduino example

by shedboy71

In this article we look at another temperature and humidity sensors – this time its the AHT20 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

AHT20, as a new generation of temperature and humidity sensors, has established a new standard in size and intelligence.

It is embedded in a double row flat no-lead package suitable for reflow soldering, with a bottom of 3 x 3 mm and a height of 1.0 mm.

The sensor outputs calibrated digital signals in standard IAHT20, as a new generation of temperature and humidity sensors, has established a new standard in size and intelligence.

It is embedded in a double row flat no-lead package suitable for reflow soldering, with a bottom of 3 x 3 mm and a height of 1.0 mm.

The sensor outputs calibrated digital signals in standard I2C format. The AHT20 is equipped with a newly designed ASIC chip, an improved MEMS semiconductor capacitive humidity sensing element and a standard on-chip temperature sensing element.

Supply voltage DC : 2.0 – 5.5V
Measuring range (humidity) 0 ~ 100% RH
Measuring range (temperature) -40 ~ + 85 ℃
Humidity accuracy ± 2 % RH ( 25 ℃ )
Temperature accuracy ± 0.3 ℃
Resolution temperature: 0.01℃ Humidity: 0.024%RH
Response time temperature: 5s humidity: 8s 1/e (63%)
Output signal I2C signal

 

 

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 Offical Microbit V2 Development Board
AHT20 AHT20 Temperature and Humidity Sensor Module High-precision Humidity Sensor
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire
expansion board micro: bit expansion board

Schematic/Connection

The layout below shows a Microbit, I used a Microbit v1

If you have an ESP32 board with a STEMMA QT cables, you can use these:

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

microbit and aht20 layout

microbit and aht20 layout

Code Example

This example uses a couple of libraries, both of which can be installed using the library manager. if you search for the AHT20 one first and you are using a newer version of the Arduino IDE it will install the other one as well – which makes things a bit easier.

You need the Adafruit library for the AHT20 from https://github.com/adafruit/Adafruit_AHTX0

You also need an I2C support library from the same folks for the library above to work and that is available from – https://github.com/adafruit/Adafruit_BusIO

This is the simple test example that comes with the library

[codesyntax lang=”cpp”]

#include <Adafruit_AHTX0.h>

Adafruit_AHTX0 aht;

void setup() 
{
  Serial.begin(115200);
  Serial.println("Adafruit AHT10/AHT20 demo!");

  if (! aht.begin()) 
  {
    Serial.println("Could not find AHT? Check wiring");
    while (1) 
    delay(10);
  }
  Serial.println("AHT10 or AHT20 found");
}

void loop() 
{
  sensors_event_t humidity, temp;
  aht.getEvent(&humidity, &temp);
  // populate temp and humidity objects with fresh data
  Serial.print("Temperature: "); 
  Serial.print(temp.temperature); 
  Serial.println(" degrees C");
  Serial.print("Humidity: "); 
  Serial.print(humidity.relative_humidity); 
  Serial.println("% rH");

  delay(500);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Temperature: 20.99 degrees C
Humidity: 43.30% rH
Temperature: 20.99 degrees C
Humidity: 43.32% rH
Temperature: 21.01 degrees C
Humidity: 43.27% rH
Temperature: 20.99 degrees C
Humidity: 43.32% rH
Temperature: 21.74 degrees C
Humidity: 42.96% rH

Links

Product download pdf

 

Arduino

Microbit and VCNL4010 proximity and ambient light sensor Arduino example

by shedboy71

In this article we look at another acceleration sensor – this time its the VCNL4010 and we will connect it to our Microbit and see what it can do

First lets take a look at the sensor in question, this is from the datasheet

The VCNL4010 is a fully integrated proximity and ambient light sensor. Fully integrated means that the infrared emitter is included in the package. It has 16 bit resolution. It includes a signal processing IC and features standard I2C communication interface. It features an interrupt function.

PROXIMITY FUNCTION
• Built-in infrared emitter and photo-pin-diode for proximity
function
• 16 bit effective resolution for proximity detection range
ensures excellent cross talk immunity
• Programmable LED drive current from 10 mA to 200 mA in
10 mA steps
• Excellent ambient light suppression by modulating the
infrared signal
• Proximity distance up to 200 mm

AMBIENT LIGHT FUNCTION
• Built-in ambient light photo-pin-diode with close-tohuman-eye sensitivity
• 16 bit dynamic range from 0.25 lx to 16 klx
• 100 Hz and 120 Hz flicker noise rejection

FEATURES

• Integrated modules: infrared emitter (IRED), ambient light sensor (ALS-PD), proximity sensor (PD), and signal conditioning IC
• Interrupt function
• Supply voltage range VDD: 2.5 V to 3.6 V
• Supply voltage range IR anode: 2.5 V to 5 V
• Communication via I2C interface
• I2C Bus H-level range: 1.7 V to 5 V
• Low stand by current consumption: 1.5 μA

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
VCNL4010 Multiple Function Sensor Development Tools Proximity/Light Sensor VCNL4000 (1 piece)
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 VCNL4010

microbit and VCNL4010

Code Example

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

This is the default example

[codesyntax lang=”cpp”]

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

Adafruit_VCNL4010 vcnl;

void setup() 
{
  Serial.begin(9600);
  Serial.println("VCNL4010 test");

  if (! vcnl.begin())
  {
    Serial.println("Sensor not found :(");
    while (1);
  }
  Serial.println("Found VCNL4010");
}


void loop() 
{
   Serial.print("Ambient: "); 
   Serial.println(vcnl.readAmbient());
   Serial.print("Proximity: ");
   Serial.println(vcnl.readProximity());
   delay(100);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this

VCNL4010 test
Found VCNL4010
Ambient: 427
Proximity: 2384
Ambient: 594
Proximity: 2374
Ambient: 592
Proximity: 2375
Ambient: 596
Proximity: 2375
Ambient: 598
Proximity: 2380
Ambient: 582
Proximity: 2409

Links

https://www.vishay.com/docs/83462/vcnl4010.pdf

 

Books

Learn the Micro:Bit using the Arduino IDE ebook

by shedboy71

The micro:bit is a great little board for learning, its easy to add support for this in the Arduino IDE which opens up many examples which you can see in this ebook that we have written and published on the Kindle store

Here are the contents of the ebook, so you can see exactly what you get

Introducing the Micro:bit 4
Setting up the Arduino IDE 6
Install the Arduino IDE 6
Adding support for the Micro:bit 8
Flashing a SoftDevice 8
Micro:Bit Features 9
LED matrix 9
Buttons 12
micro:bit onboard 3-axis accelerometer using the Arduino IDE 13
micro:bit magnetometer with the Arduino IDE 15
Basic Examples 17
External LED example 17
Arduino and RGB LED example 20
Micro:bit and LDR example using the Arduino IDE 23
Basic Sensor Projects 26
Temperature readings using a TMP102 26
Temperature, pressure and altitude with a BMP280 30
Temperature measurement using an LM75 sensor 34
Micro:bit and Si1145 sensor example 36
MAX30102 pulse and heart-rate monitor sensor and micro:bit 42
VEML6040 color sensor and micro:bit 46
ADS1115 analog-to-digital converter and micro:bit 49
PAJ7620 gesture sensor and micro:bit example 52
MLX90615 infrared thermometer and micro:bit example 56
MPL3115A2 absolute pressure sensor example 59
VL53L0X Time-of-Flight sensor and micro:bit 63
MS5611 barometric pressure sensor example 67
OPT3001 Digital Ambient Light Sensor 70
MAG3110 magnetic sensor example 74
MMA7660 accelerometer example 79
HDC1080 humidity and temperature sensor example 82
micro:bit and OLED display example 85
bme280 environmental sensor example 88
MICRO:BIT and I2C LCD example 94
micro:bit and TM1637 7 segment display example 96
Si7021 I2C Humidity and Temperature Sensor example 99
TEMT6000 ambient light sensor 103
Microbit and GUVA-S12SD UV Sensor 106
AM2320 temperature and humidity sensor 109
DHT12 temperature sensor 112
micro:bit and TCS34725 Color Sensor 116
micro:bit and HMC5883L magnetometer example 120
MCP4725 DAC example 123
SHT31 temperature and humidity sensor 126
micro:bit and bmp180 sensor example 130
In review 134

We recieve a percentage of the sales from Amazon which we reinvest into this site with regards domain name renewal, web site hosting and purchasing any parts we use – we don’t get any samples or freebies from any companies (although would be more than grateful if anyone wished to supply us any parts). We also have other plans such as designing boards, youtube content and even Android apps.

So please support the site by purchasing the ebook from the following links

 

Site Link
Amazon US Buy here
Amazon UK Buy here
Amazon DE Buy here
Amazon FR Buy here
Amazon ES Buy here
Amazon IT Buy here
Amazon NL Buy here
Amazon JP Buy here
Amazon BR Buy here
Amazon CA Buy here
Amazon MX Buy here
Amazon AU Buy here
Amazon IN Buy here
Newer Posts
Older Posts