Category:

Arduino

The Sino:bit : an open source relative of the Micro:bit

by shedboy71 22nd July 2023

The Sino:bit is a derivative of the Calliope Mini, which is a derivative of the BBC Micro:bit.

It uses the same nRF51822 MCU from Nordic and to keep the compatibility at a maximum it also uses the same accelerometer and magnetometer.

It provides 2 user-readable buttons. It has a large matrix of LEDs for displaying whatever you want. This allows for the support of Chinese, Japanese, Hindi, Arabic, and other non-Latin character-based languages

The Sino:bit has 3 pads/holes for alligator clips. You get a power and ground one but you also have 6 pads for I/O. The micro:bit exposes pins 0, 1, 2 whereas the sino:bit exposes pins 0, 1, 2, 3, 4, and 5.

The Sino:bit has a 12×12 LED matrix in place of a 5×5 matrix. The LED matrix is driven by a dedicated LED matrix driver chip instead of by the board’s CPU with the micro:bit. However, one important difference between the boards is that the micro:bit supports 10 levels of brightness for each individual pixel, whereas the sino:bit only supports 16 levels that apply to all pixels at once.

The sino:bit has grove style connectors for serial UART and I2C bus access which makes it easy to connect to many existing grove sensors.

The sino:bit exposes all of the processor’s GPIO pins through a 13×2 pin header near the bottom of the board, you will need to solder a header yourself here as it is unpopulated.

You do not get any pins on the bottom of the device like the microbit, so any external board will not work out of the box with the Sino:bit

Arduino

Download and install the Arduino IDE (At least v1.6.12)
Start the Arduino IDE
Go into Preferences
Add https://sandeepmistry.github.io/arduino-nRF5/package_nRF5_boards_index.json as an “Additional Board Manager URL”
Open the Boards Manager from the Tools -> Board menu and install “Nordic Semiconductor nRF5 Boards”
Select your nRF5 board from the Tools -> Board menu
NOTE: During installation it takes the Arduino IDE a few minutes to extract the tools after they have been downloaded, please be patient.

#include <sinobit.h>

Sinobit matrix = Sinobit();

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

  matrix.begin();
  delay(100);
  matrix.clearScreen();
}

void loop() 
{
  // set a pixel
  matrix.drawPixel(0, 0, 1);
  matrix.writeScreen();
  delay(500);
  
  // clear a pixel!
  matrix.drawPixel(0, 0, 0);
  matrix.writeScreen();
  delay(500);
}

Links

https://github.com/sinobitorg/hardware
https://www.elecrow.com/sino-bit-v1-0.html

Arduino

Microbit and VCNL4040 Proximity and Ambient Light Sensor Arduino example

by shedboy71 14th July 2022

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

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

Arduino

Microbit and SHT40 Digital Humidity Sensor Arduino example

by shedboy71 14th June 2022

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 mm³
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

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/

Arduino

Microbit and DPS310 barometric pressure sensor Arduino example

by shedboy71 14th May 2022

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

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.16 *C
Pressure = 987.25 hPa

Links

Datasheet

Arduino

Microbit and LTR390 UV Light Sensor Arduino example

by shedboy71 14th April 2022

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

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

Arduino

Microbit and PCT2075 temperature-to-digital converter Arduino example

by shedboy71 14th March 2022

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

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

Arduino

Microbit and VL6180X sensor Arduino example

by shedboy71 14th February 2022

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 I²C interface. Optional additional functions, such as measurement ready and threshold interrupts, are provided by two programmable GPIO pins.

Key Features

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

This was my sensor of choice that I used

Parts Required

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

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

Arduino

Microbit and AHT20 temperature and humidity sensor Arduino example

by shedboy71 14th January 2022

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 I²C 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	I²C 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

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 10th May 2020

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

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

Newer Posts

Older Posts