Category:

Code

BH1745NUC Luminance and Colour Sensor and Wemos Lolin32 example

by shedboy71 28th February 2020

In this article we look at a BH1745NUC Luminance and Colour Sensor and connect it to an Wemos Lolin32

The BH1745NUC is digital color sensor IC with I²C bus interface. This IC senses Red, Green and Blue light (RGB) and converts them to digital values. The high sensitivity, wide dynamic range and excellent Ircut characteristics makes this IC the most suitable to obtain the illuminance and color temperature of ambient light for adjusting LCD backlight of TV, mobile phone and tablet PC. It is possible to detect very wide range light intensity. (0.005 – 40k lx)

Specifications:

VCC Voltage Range: 2.3V to 3.6V
Maximum Sensitivity: 0.005Lx/step
Current Consumption: 130μA (Typ)
Standby Mode Current: 0.8μA (Typ)
Operating Temperature Range: -40°C to +85°C

Features

The High Sensitivity and Wide Dynamic Range (0.005 – 40k lx)
Supports Low Transmittance (Dark) Window
Correspond to I²C Bus Interface
Low Current by Power Down Function
Rejecting 50Hz/60Hz Light Noise
Correspond to 1.8V Logic Interface
Programmable Interrupt Function
It is possible to select 2 type of I²C bus slave address (ADDR =’L’: “0111000”, ADDR =’H’: “0111001”)

Here is a typical module that I used

Parts Required

I connected a Wemos ESP32 (Lolin32) and then the sensor via connecting wire

Name	Link
ESP32		Aliexpress link Amazon Ebay
BH1745NUC		Aliexpress link Ebay link Amazon Link
Connecting cables		Aliexpress link Amazon Ebay

Schematic/Connection

Be careful as I used a CJMCU-1745 – the sensor is rated at 2.3V to 3.6V. So use the 3.3v out

ESP32	Sensor
3.3v	VIN
Gnd	Gnd
SDA/21	SDA
SCL/22	SCL

Code Example

This is a controleverything example – they have code examples for various platforms

#include <Wire.h>

// I2C address of the BH1745NUC
#define Addr 0x38

void setup()
{
    // Initialise I2C communication as MASTER
    Wire.begin();
    // Initialise serial communication, set baud rate = 9600
    Serial.begin(9600);

    // Start I2C Transmission
    Wire.beginTransmission(Addr);
    // Select mode control register1
    Wire.write(0x41);
    // Set RGBC measurement time 160 msec
    Wire.write(0x00);
    // Stop I2C Transmission
    Wire.endTransmission();
    
    // Start I2C Transmission
    Wire.beginTransmission(Addr);
    // Select mode control register2
    Wire.write(0x42);
    // Set measurement mode is active, gain = 1x
    Wire.write(0x90);
    // Stop I2C Transmission
    Wire.endTransmission();
    
    // Start I2C Transmission
    Wire.beginTransmission(Addr);
    // Select mode control register3
    Wire.write(0x44);
    // Set default value
    Wire.write(0x02);
    // Stop I2C Transmission
    Wire.endTransmission();
    delay(300);
}

void loop()
{
    unsigned int data[8];
    for(int i = 0; i < 8; i++)
    {
        // Start I2C Transmission
        Wire.beginTransmission(Addr);
        // Select data register
        Wire.write((80+i));
        // Stop I2C Transmission
        Wire.endTransmission();
        
        // Request 1 byte of data from the device
        Wire.requestFrom(Addr, 1);
        
        // Read 8 bytes of data
        // Red lsb, Red msb, Green lsb, Green msb, Blue lsb, Blue msb
        // cData lsb, cData msb
        if(Wire.available() == 1)
        {
            data[i] = Wire.read();
        }
        delay(300);
    }

    // Convert the data
    int red = ((data[1] & 0xFF) * 256) + (data[0] & 0xFF);
    int green = ((data[3] & 0xFF) * 256) + (data[2] & 0xFF);
    int blue = ((data[5] & 0xFF) * 256) + (data[4] & 0xFF);
    int cData = ((data[7] & 0xFF) * 256) + (data[6] & 0xFF);
    
    // Output data to serial monitor
    Serial.print("Red Color luminance  : ");
    Serial.println(red);
    Serial.print("Green Color luminance : ");
    Serial.println(green);
    Serial.print("Blue Color luminance : ");
    Serial.println(blue);
    Serial.print("Clear Data Color luminance : ");
    Serial.println(cData);
}

Output

Open the serial monitor and you should see something like the following

Red Color luminance : 0
Green Color luminance : 0
Blue Color luminance : 55
Clear Data Color luminance : 65
Red Color luminance : 57
Green Color luminance : 9
Blue Color luminance : 5
Clear Data Color luminance : 7

Place different colored objects beside the sensor and check the values

Code

An ESP32 and BMA400 acceleration sensor example

by shedboy71 10th February 2020

In this article we look at another acceleration sensor – this time its the BMA400 and we will connect it to a Wemos Lolin32

Lets look at the BMA400 – this is from the vendor

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
ESP32		Aliexpress link Amazon Ebay
BMA400		Aliexpress link Ebay link
Connecting cables		Aliexpress link Amazon Ebay

Schematic/Connection

ESP32	Module
3.3v	Vcc
Gnd	Gnd
SDA/21	SDA
SCL/22	SCL

Code Example

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

#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);
}

Output

Open the serial monitor and you should see something like this – I was seeing intermittent readings, BMA400 not connnected. I checked the wiring and sometimes it would work and sometimes it would not. Haven’t gotten to the bottom it

BMA400 is connected
-625.00,-804.69,189.45,32
0.00,0.00,0.00,23
-619.14,-683.59,54.69,32
0.00,0.00,0.00,23
-740.23,-712.89,-80.08,23
-656.25,-751.95,31.25,31
0.00,0.00,0.00,23
-714.84,-583.98,166.02,31
0.00,0.00,0.00,23
-849.61,-716.80,-128.91,32
0.00,0.00,0.00,23
-884.77,-433.59,62.50,32

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

enviro:bit TCS3472 sensor and bpi:bit Arduino code example

by shedboy71 7th January 2020

In this example we look at the enviro:bit which is an add on from pimoroni which has a BME280 temperature, pressure, and humidity sensor fitted to it a long with a TCS3472 light and colour sensor and a MEMS microphone

Lets look at the enviro:bit fitted to a bpi:bit

enviro:bit and bpi:bit

Features:

Comes fully-assembled and ready to use.
BME280 temperature, pressure, and humidity sensor.
TCS3472 light and colour sensor.
MEMS microphone.
Compatible with micro:bit.
Microsoft MakeCode and MicroPython support.
No soldering required!

Lets look at the TCS34725

The TCS3472 device provides a digital return of red, green, blue (RGB), and clear light sensing values. An IR blocking filter, integrated on-chip and localized to the color sensing photodiodes, minimizes the IR spectral component of the incoming light and allows color measurements to be made accurately.

The high sensitivity, wide dynamic range, and IR blocking filter make the TCS3472 an ideal color sensor solution for use under varying lighting conditions and through attenuating materials. This data is transferred via an I2C to the host.

Features

Integrated IR blocking filter
3.8M:1 dynamic range
Four independent analog-to-digital converters
A reference channel for color analysis (clear channel photodiode)

Benefits

Minimizes IR and UV spectral component effects to produce accurate color measurement
Enables accurate color and ambient light sensing under varying lighting conditions
Minimizes motion/transient errors
Clear channel provides a reference which allows for isolation of color content

Parts List

Name	link
Banana PI Bit board	Banana PI Bit board with EPS32
envirobit	Pimoroni enviro:bit for BBC micro:bit

Code

You need to import the adafruit TCS34725 library – you can add this via the library manager

[codesyntax lang=”cpp”]

#include <Wire.h>
#include "Adafruit_TCS34725.h"
   
/* Initialise with default values (int time = 2.4ms, gain = 1x) */
// Adafruit_TCS34725 tcs = Adafruit_TCS34725();

/* Initialise with specific int time and gain values */
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);

void setup(void) {
  Serial.begin(9600);
  
  if (tcs.begin()) {
    Serial.println("Found sensor");
  } else {
    Serial.println("No TCS34725 found ... check your connections");
    while (1);
  }
  
  // Now we're ready to get readings!
}

void loop(void) {
  uint16_t r, g, b, c, colorTemp, lux;
  
  tcs.getRawData(&r, &g, &b, &c);
  colorTemp = tcs.calculateColorTemperature(r, g, b);
  lux = tcs.calculateLux(r, g, b);
  
  Serial.print("Color Temp: "); 
  Serial.print(colorTemp, DEC); 
  Serial.print(" K - ");
  Serial.print("Lux: "); 
  Serial.print(lux, DEC); 
  Serial.print(" - ");
  Serial.print("R: "); 
  Serial.print(r, DEC); 
  Serial.print(" ");
  Serial.print("G: "); 
  Serial.print(g, DEC);
  Serial.print(" ");
  Serial.print("B: "); 
  Serial.print(b, DEC); 
  Serial.print(" ");
  Serial.print("C: "); 
  Serial.print(c, DEC); 
  Serial.print(" ");
  Serial.println(" ");
}

[/codesyntax]

Output

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

Color Temp: 7173 K – Lux: 11 – R: 31 G: 26 B: 26 C: 39
Color Temp: 5645 K – Lux: 14 – R: 41 G: 32 B: 31 C: 53
Color Temp: 5153 K – Lux: 30 – R: 80 G: 63 B: 59 C: 103
Color Temp: 4887 K – Lux: 36 – R: 94 G: 74 B: 68 C: 133
Color Temp: 5310 K – Lux: 23 – R: 60 G: 48 B: 45 C: 93
Color Temp: 4981 K – Lux: 42 – R: 113 G: 88 B: 82 C: 167
Color Temp: 5565 K – Lux: 274 – R: 834 G: 633 B: 620 C: 974
Color Temp: 5653 K – Lux: 261 – R: 822 G: 618 B: 611 C: 937

Code webduino

enviro:bit BME280 sensor and bpi:bit Arduino code example

by shedboy71 21st December 2019

Lets look at the enviro:bit fitted to a bpi:bit

enviro:bit and bpi:bit

Features:

Comes fully-assembled and ready to use.
BME280 temperature, pressure, and humidity sensor.
TCS3472 light and colour sensor.
MEMS microphone.
Compatible with micro:bit.
Microsoft MakeCode and MicroPython support.
No soldering required!

Lets look at the BME280 sensor now

The BME280 is an integrated environmental sensor developed specifically for mobile applications where size and low power consumption are key design constraints. The unit combines individual high linearity, high accuracy sensors for pressure, humidity and temperature in an 8-pin metal-lid 2.5 x 2.5 x 0.93 mm³ LGA package, designed for low current consumption (3.6 μA @1Hz), long term stability and high EMC robustness.

The humidity sensor features an extremely fast response time which supports performance requirements for emerging applications such as context awareness, and high accuracy over a wide temperature range. The pressure sensor is an absolute barometric pressure sensor with features exceptionally high accuracy and resolution at very low noise. The integrated temperature sensor has been optimized for very low noise and high resolution. It is primarily used for temperature compensation of the pressure and humidity sensors, and can also be used for estimating ambient temperature.

The BME280 supports a full suite of operating modes which provides the flexibility to optimize the device for power consumption, resolution and filter performance.

Parts List

Name	link
Banana PI Bit board	Banana PI Bit board with EPS32
envirobit	Pimoroni enviro:bit for BBC micro:bit

Code

You need to import the BME280 and sensor libraries into the Arduino IDE. The BME280 sensor is set to 0x76 on the envirobit

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme; // I2C


unsigned long delayTime;

void setup() {
    Serial.begin(9600);
    while(!Serial);    // time to get serial running
    Serial.println(F("BME280 test"));

    unsigned status;
    
    // default settings
    // (you can also pass in a Wire library object like &Wire2)
    status = bme.begin(0x76);  
    if (!status) {
        Serial.println("Could not find a valid BME280 sensor, check wiring, address, sensor ID!");
        Serial.print("SensorID was: 0x"); Serial.println(bme.sensorID(),16);
        Serial.print("        ID of 0xFF probably means a bad address, a BMP 180 or BMP 085\n");
        Serial.print("   ID of 0x56-0x58 represents a BMP 280,\n");
        Serial.print("        ID of 0x60 represents a BME 280.\n");
        Serial.print("        ID of 0x61 represents a BME 680.\n");
        while (1);
    }
    
    Serial.println("-- Default Test --");
    delayTime = 1000;

    Serial.println();
}


void loop() { 
    printValues();
    delay(delayTime);
}


void printValues() {
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    Serial.println(" *C");

    Serial.print("Pressure = ");

    Serial.print(bme.readPressure() / 100.0F);
    Serial.println(" hPa");

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

    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");

    Serial.println();
}

[/codesyntax]

Output

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

Temperature = 21.40 *C
Pressure = 1009.94 hPa
Approx. Altitude = 27.61 m
Humidity = 41.04 %

Temperature = 21.40 *C
Pressure = 1009.92 hPa
Approx. Altitude = 27.74 m
Humidity = 41.03 %

Temperature = 21.39 *C
Pressure = 1009.90 hPa
Approx. Altitude = 27.90 m
Humidity = 41.04 %

Code webduino

BPI:bit and on board light-dependent resistors example

by shedboy71 6th December 2019

In this article we look at the 2 LDRs which are fitted to the BPI:bit

webduino:bit

If you do not know what an LDR is , here is a quick recap from wikipedia that explains them nicely

A photoresistor (or light-dependent resistor, LDR, or photo-conductive cell) is a light-controlled variable resistor. The resistance of a photoresistor decreases with increasing incident light intensity; in other words, it exhibits photoconductivity. A photoresistor can be applied in light-sensitive detector circuits, and light-activated and dark-activated switching circuits.

A photoresistor is made of a high resistance semiconductor. In the dark, a photoresistor can have a resistance as high as several megaohms , while in the light, a photoresistor can have a resistance as low as a few hundred ohms. If incident light on a photoresistor exceeds a certain frequency, photons absorbed by the semiconductor give bound electrons enough energy to jump into the conduction band. The resulting free electrons (and their hole partners) conduct electricity, thereby lowering resistance. The resistance range and sensitivity of a photoresistor can substantially differ among dissimilar devices.

The sensor uses the following GPIO pins

Light Sensor(L)	GPIO 36	Analog Input
Light Sensor(R)	GPIO 39	Analog Input

Parts Required

Name	Link
Banana PI Bit board	Banana PI Bit board with EPS32

$19.50 for this board is a good price for all the features

Code

In this example we read the basic values read in from the LDRs using an analogRead, with this value then you can work out a rough light percentage. This is fairly standard LDR code that you can use.

[codesyntax lang=”cpp”]

int LDRValue0=0;
int LDRValue1=0;

void setup() 
{
  Serial.begin(9600);
  //Light Sensor(L)   GPIO 36   Analog Input
  //Light Sensor(R)   GPIO 39   Analog Input 
  pinMode(LIGHT_SENSOR1,INPUT);
  pinMode(LIGHT_SENSOR2,INPUT);
}

void loop() 
{
  //Get the ADC values
  LDRValue0 = analogRead(LIGHT_SENSOR1);
  LDRValue1 = analogRead(LIGHT_SENSOR2);
  //Serial print
  Serial.println("-------------------------------");
  Serial.println("ADC raw value:");        
  Serial.print("Left : ");
  Serial.print(LDRValue0);
  Serial.print(" Right : ");
  Serial.println(LDRValue1);
  //Get brightness Percentage
  double lumLevel0 = (LDRValue0 / 4095.00);
  double lumLevel1 = (LDRValue1 / 4095.00);
  Serial.println("Brightness level (Percentage):");
  Serial.print("Left : ");
  Serial.print((lumLevel0 * 100.00),2);
  Serial.print("%");
  Serial.print(" Right : ");
  Serial.print((lumLevel1 * 100.00),2);          
  Serial.println("%");
  delay(1000);
}

[/codesyntax]

Output

Here is an example of my output, I covered the right LDR and uncovered it. you can see the values are changing in the output I saw via the Serial monitor

——————————-
ADC raw value:
Left : 4095 Right : 310
Brightness level (Percentage):
Left : 100.00% Right : 7.57%
——————————-
ADC raw value:
Left : 4095 Right : 3611
Brightness level (Percentage):
Left : 100.00% Right : 88.18%
——————————-

Code webduino

BPI:bit and MPU-9250 Nine-Axis example using the Arduino IDE

by shedboy71 27th November 2019

In this article we look the MPU-9250 Nine-Axis (Gyro + Accelerometer + Compass) MEMS MotionTracking™ Device which is fitted to the BPI:bit

webduino:bit

The sensor uses the following GPIO

MPU9250_SCL	GPIO 22	Digital Output
MPU9250_SDA	GPIO 21	Digital Output
MPU9250_INT	GPIO 16	Digital Input

Parts Required

Name	Link
Banana PI Bit board	Banana PI Bit board with EPS32

$19.50 for this board is a good price

Features

Lets look at the sensor features from the manufacturer

Gyroscope Features
The triple-axis MEMS gyroscope in the MPU-9250 includes a wide range of features:

Digital-output X-, Y-, and Z-Axis angular rate sensors (gyroscopes) with a user-programmable full-scale range of ±250, ±500, ±1000, and ±2000°/sec and integrated 16-bit ADCs
Digitally-programmable low-pass filter
Gyroscope operating current: 3.2mA
Sleep mode current: 8μA

Accelerometer Features
The triple-axis MEMS accelerometer in MPU-9250 includes a wide range of features:

Digital-output triple-axis accelerometer with a programmable full scale range of ±2g, ±4g, ±8g and ±16g and integrated 16-bit ADCs
Accelerometer normal operating current: 450μA
Low power accelerometer mode current: 8.4μA at 0.98Hz, 19.8μA at 31.25Hz
Sleep mode current: 8μA
User-programmable interrupts
Wake-on-motion interrupt for low power operation of applications processor

Magnetometer Features
The triple-axis MEMS magnetometer in MPU-9250 includes a wide range of features:

3-axis silicon monolithic Hall-effect magnetic sensor with magnetic concentrator
Wide dynamic measurement range and high resolution with lower current consumption.
Output data resolution of 14 bit (0.6μT/LSB) or 16 bit (15μT/LSB)
Full scale measurement range is ±4800μT
Magnetometer normal operating current: 280μA at 8Hz repetition rate
Self-test function with internal magnetic source to confirm magnetic sensor operation on end products

Additional Features
The MPU-9250 includes the following additional features:

Auxiliary master I2C bus for reading data from external sensors (e.g. pressure sensor)
3.5mA operating current when all 9 motion sensing axes and the DMP are enabled
VDD supply voltage range of 2.4 – 3.6V
VDDIO reference voltage for auxiliary I2C devices
Smallest and thinnest QFN package for portable devices: 3x3x1mm
Minimal cross-axis sensitivity between the accelerometer, gyroscope and magnetometer axes
512 byte FIFO buffer enables the applications processor to read the data in bursts
Digital-output temperature sensor
User-programmable digital filters for gyroscope, accelerometer, and temp sensor
10,000 g shock tolerant
400kHz Fast Mode I2C for communicating with all registers
1MHz SPI serial interface for communicating with all registers
20MHz SPI serial interface for reading sensor and interrupt registers

Code

You can roll your own code but I chose a library in the Arduino library manager called the MPU9250_asukiaaa

This is one of the default code examples

[codesyntax lang=”cpp”]

#include <MPU9250_asukiaaa.h>

#ifdef _ESP32_HAL_I2C_H_
#define SDA_PIN 21
#define SCL_PIN 22
#endif

MPU9250_asukiaaa mySensor;
float aX, aY, aZ, aSqrt, gX, gY, gZ, mDirection, mX, mY, mZ;

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

#ifdef _ESP32_HAL_I2C_H_ // For ESP32
  Wire.begin(SDA_PIN, SCL_PIN);
  mySensor.setWire(&Wire);
#endif

  mySensor.beginAccel();
  mySensor.beginGyro();
  mySensor.beginMag();

  // You can set your own offset for mag values
  // mySensor.magXOffset = -50;
  // mySensor.magYOffset = -55;
  // mySensor.magZOffset = -10;
}

void loop() {
  uint8_t sensorId;
  if (mySensor.readId(&sensorId) == 0) {
    Serial.println("sensorId: " + String(sensorId));
  } else {
    Serial.println("Cannot read sensorId");
  }

  if (mySensor.accelUpdate() == 0) {
    aX = mySensor.accelX();
    aY = mySensor.accelY();
    aZ = mySensor.accelZ();
    aSqrt = mySensor.accelSqrt();
    Serial.println("accelX: " + String(aX));
    Serial.println("accelY: " + String(aY));
    Serial.println("accelZ: " + String(aZ));
    Serial.println("accelSqrt: " + String(aSqrt));
  } else {
    Serial.println("Cannod read accel values");
  }

  if (mySensor.gyroUpdate() == 0) {
    gX = mySensor.gyroX();
    gY = mySensor.gyroY();
    gZ = mySensor.gyroZ();
    Serial.println("gyroX: " + String(gX));
    Serial.println("gyroY: " + String(gY));
    Serial.println("gyroZ: " + String(gZ));
  } else {
    Serial.println("Cannot read gyro values");
  }

  if (mySensor.magUpdate() == 0) {
    mX = mySensor.magX();
    mY = mySensor.magY();
    mZ = mySensor.magZ();
    mDirection = mySensor.magHorizDirection();
    Serial.println("magX: " + String(mX));
    Serial.println("maxY: " + String(mY));
    Serial.println("magZ: " + String(mZ));
    Serial.println("horizontal direction: " + String(mDirection));
  } else {
    Serial.println("Cannot read mag values");
  }

  Serial.println("at " + String(millis()) + "ms");
  Serial.println(""); // Add an empty line
  delay(500);
}

[/codesyntax]

Output

Here is an example of my output

sensorId: 113
accelX: -0.06
accelY: -0.08
accelZ: 1.04
accelSqrt: 1.04
gyroX: 0.67
gyroY: -0.49
gyroZ: -0.55
magX: 95.13
maxY: 8.12
magZ: -105.38
horizontal direction: 85.12
at 102570ms

Links

https://www.invensense.com/products/motion-tracking/9-axis/mpu-9250/

https://www.invensense.com/download-pdf/mpu-9250-datasheet/

Code webduino

BPI-Bit RGB led matrix test

by shedboy71 12th November 2019

In this article we take a quick look at the 25 RGB led matrix which is on the BPI-Bit, we will try out a basic example using the Arduino IDE – there are other ways to use this. We will look at these in other articles

webduino:bit

Code

This code example needs the following library installed – https://github.com/Makuna/NeoPixelBus. you can download the zip file or install via the library manager

This is the NeoPixeltest code example with a few tweaks

[codesyntax lang=”cpp”]

#include <NeoPixelBus.h>

const uint16_t PixelCount = 25; 
const uint8_t PixelPin = 4;  

#define colorSaturation 2
#define LED_POWER      2

// three element pixels, in different order and speeds
NeoPixelBus<NeoGrbFeature, Neo800KbpsMethod> strip(PixelCount, PixelPin);
//NeoPixelBus<NeoRgbFeature, Neo400KbpsMethod> strip(PixelCount, PixelPin);


RgbColor red(colorSaturation, 0, 0);
RgbColor green(0, colorSaturation, 0);
RgbColor blue(0, 0, colorSaturation);
RgbColor white(colorSaturation);
RgbColor black(0);

HslColor hslRed(red);
HslColor hslGreen(green);
HslColor hslBlue(blue);
HslColor hslWhite(white);
HslColor hslBlack(black);


void setup()
{
    Serial.begin(115200);
    while (!Serial); // wait for serial attach

    Serial.println();
    Serial.println("Initializing...");
    Serial.flush();

    // this resets all the neopixels to an off state
    strip.Begin();
    strip.Show();


    Serial.println();
    Serial.println("Running...");
    pinMode(LED_POWER, OUTPUT);
    digitalWrite(LED_POWER, HIGH);
}


void loop()
{
    delay(5000);

    Serial.println("Colors R, G, B, W...");

    // set the colors, 
    // if they don't match in order, you need to use NeoGrbFeature feature
    strip.SetPixelColor(0, red);
    strip.SetPixelColor(1, green);
    strip.SetPixelColor(2, blue);
    strip.SetPixelColor(3, white);
    // the following line demonstrates rgbw color support
    // if the NeoPixels are rgbw types the following line will compile
    // if the NeoPixels are anything else, the following line will give an error
    //strip.SetPixelColor(3, RgbwColor(colorSaturation));
    strip.Show();


    delay(5000);

    Serial.println("Off ...");

    // turn off the pixels
    strip.SetPixelColor(0, black);
    strip.SetPixelColor(1, black);
    strip.SetPixelColor(2, black);
    strip.SetPixelColor(3, black);
    strip.Show();

    delay(5000);

    Serial.println("HSL Colors R, G, B, W...");

    // set the colors, 
    // if they don't match in order, you may need to use NeoGrbFeature feature
    strip.SetPixelColor(0, hslRed);
    strip.SetPixelColor(1, hslGreen);
    strip.SetPixelColor(2, hslBlue);
    strip.SetPixelColor(3, hslWhite);
    strip.Show();


    delay(5000);

    Serial.println("Off again...");

    // turn off the pixels
    strip.SetPixelColor(0, hslBlack);
    strip.SetPixelColor(1, hslBlack);
    strip.SetPixelColor(2, hslBlack);
    strip.SetPixelColor(3, hslBlack);
    strip.Show();

}

[/codesyntax]

You will see 4 LEDs flash on and off

Code webduino

bpi:bit and scroll:bit display examples

by shedboy71 27th October 2019

In a previous article we looked at the scroll:bit, this is an add on from Pimoroni which contains a lot of LEDs, in fact there are 119 in total in a 17 x 7 matrix – its controlled by a IS31FL3731 LED matrix driver chip.

This is what the scroll:bit looks like fitted to a bpi:bit

bpi:bit and scroll:bit

Parts List

The scroll:bit costs about $18.99 from the US.

Here are a couple of links to the products

Part	Link
Banana PI Bit board	Banana PI Bit board with ESP32
scroll:bit	Pimoroni Scroll:bit

Code

You need to to install the Adafruit_GFX and Adafruit_IS31FL3731 libraries, you can add these using the library manager.

The key thing is that the Featherwing version is the same size as the scroll:bit. So in the code you need to use

Adafruit_IS31FL3731_Wing ledmatrix = Adafruit_IS31FL3731_Wing();

These 2 examples work fairly well

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_IS31FL3731.h>

// If you're using the full breakout...
//Adafruit_IS31FL3731 ledmatrix = Adafruit_IS31FL3731();
// If you're using the FeatherWing version
Adafruit_IS31FL3731_Wing ledmatrix = Adafruit_IS31FL3731_Wing();


// The lookup table to make the brightness changes be more visible
uint8_t sweep[] = {1, 2, 3, 4, 6, 8, 10, 15, 20, 30, 40, 60, 60, 40, 30, 20, 15, 10, 8, 6, 4, 3, 2, 1};

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

  if (! ledmatrix.begin()) {
    Serial.println("IS31 not found");
    while (1);
  }
  Serial.println("IS31 found!");
}

void loop() {
  // animate over all the pixels, and set the brightness from the sweep table
  for (uint8_t incr = 0; incr < 24; incr++)
    for (uint8_t x = 0; x < 16; x++)
      for (uint8_t y = 0; y < 9; y++)
        ledmatrix.drawPixel(x, y, sweep[(x+y+incr)%24]);
  delay(20);
}

[/codesyntax]

and now for the second example

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_IS31FL3731.h>

// If you're using the full breakout...
//Adafruit_IS31FL3731 matrix = Adafruit_IS31FL3731(17,7);
// If you're using the FeatherWing version
Adafruit_IS31FL3731_Wing matrix = Adafruit_IS31FL3731_Wing();

static const uint8_t PROGMEM
  smile_bmp[] =
  { B00111100,
    B01000010,
    B10100101,
    B10000001,
    B10100101,
    B10011001,
    B01000010,
    B00111100 },
  neutral_bmp[] =
  { B00111100,
    B01000010,
    B10100101,
    B10000001,
    B10111101,
    B10000001,
    B01000010,
    B00111100 },
  frown_bmp[] =
  { B00111100,
    B01000010,
    B10100101,
    B10000001,
    B10011001,
    B10100101,
    B01000010,
    B00111100 };


void setup() {

  Serial.begin(9600);
  Serial.println("ISSI manual animation test");
  if (! matrix.begin()) {
    Serial.println("IS31 not found");
    while (1);
  }
  Serial.println("IS31 Found!");
  
}


void loop() {
  matrix.setRotation(0);

  matrix.clear();
  matrix.drawBitmap(3, 0, smile_bmp, 8, 8, 255);
  delay(500);
  
  matrix.clear();
  matrix.drawBitmap(3, 0, neutral_bmp, 8, 8, 64);
  delay(500);

  matrix.clear();
  matrix.drawBitmap(3, 0, frown_bmp, 8, 8, 32);
  delay(500);

  matrix.clear();
  matrix.drawPixel(0, 0, 255);  
  delay(500);

  matrix.clear();
  matrix.drawLine(0,0, matrix.width()-1, matrix.height()-1, 127);
  delay(500);

  matrix.clear();
  matrix.drawRect(0,0, matrix.width(), matrix.height(), 255);
  matrix.fillRect(2,2, matrix.width()-4, matrix.height()-4, 20);
  delay(500);

  matrix.clear();
  matrix.drawCircle(8,4, 4, 64);
  matrix.drawCircle(8,4, 2, 32);
  delay(500);


  matrix.setTextSize(1);
  matrix.setTextWrap(false);  // we dont want text to wrap so it scrolls nicely
  matrix.setTextColor(100);
  for (int8_t x=0; x>=-32; x--) {
    matrix.clear();
    matrix.setCursor(x,0);
    matrix.print("Hello");
    delay(100);
  }

  matrix.setTextSize(2);
  matrix.setTextWrap(false);  // we dont want text to wrap so it scrolls nicely
  matrix.setTextColor(32);
  matrix.setRotation(1);
  for (int8_t x=7; x>=-64; x--) {
    matrix.clear();
    matrix.setCursor(x,0);
    matrix.print("World");
    delay(100);
  }
}

[/codesyntax]

bpi:bit and scroll:bit

Code

ESP32 True random number generator example

by shedboy71 9th October 2019

The ESP32 contains a hardware random number generator, values from it can be obtained using esp_random().

When Wi-Fi or Bluetooth are enabled, numbers returned by hardware random number generator (RNG) can be considered true random numbers. Without Wi-Fi or Bluetooth enabled, hardware RNG is a pseudo-random number generator

esp_random() description
Get one random 32-bit word from hardware RNG.

The hardware RNG is fully functional whenever an RF subsystem is running (ie Bluetooth or WiFi is enabled). For random values, call this function after WiFi or Bluetooth are started.

If the RF subsystem is not used by the program, the function bootloader_random_enable() can be called to enable an entropy source. bootloader_random_disable() must be called before RF subsystem or I2S peripheral are used. See these functions’ documentation for more details.

Any time the app is running without an RF subsystem (or bootloader_random) enabled, RNG hardware should be considered a PRNG. A very small amount of entropy is available due to pre-seeding while the IDF bootloader is running, but this should not be relied upon for any use.

Code

[codesyntax lang=”cpp”]

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

void loop()
{
Serial.println("-----------");
Serial.println(esp_random());
Serial.println(random(100));
Serial.println(random(1,100));
delay(1000);
}

[/codesyntax]

Output

Open the serial monitor
3296550307
18
3
———–
1828082797
8
21
———–
3150364294
91
92
———–
1412556175
97
92

Code

ESP32 built in hall effect sensor example

by shedboy71 23rd September 2019

One feature of the ESP32 that sometimes goes unnoticed is the built in hall effect sensor.

Lets look at a hall effect sensor and how it works – from wikipedia

A Hall effect sensor is a device that is used to measure the magnitude of a magnetic field. Its output voltage is directly proportional to the magnetic field strength through it.

Hall effect sensors are used for proximity sensing, positioning, speed detection, and current sensing applications.

Frequently, a Hall sensor is combined with threshold detection so that it acts as and is called a switch. Commonly seen in industrial applications such as the pictured pneumatic cylinder, they are also used in consumer equipment; for example some computer printers use them to detect missing paper and open covers. They can also be used in computer keyboards, an application that requires ultra-high reliability.

Hall sensors are commonly used to time the speed of wheels and shafts, such as for internal combustion engine ignition timing, tachometers and anti-lock braking systems. They are used in brushless DC electric motors to detect the position of the permanent magnet. In the pictured wheel with two equally spaced magnets, the voltage from the sensor will peak twice for each revolution. This arrangement is commonly used to regulate the speed of disk drives.

In a Hall effect sensor, a thin strip of metal has a current applied along it. In the presence of a magnetic field, the electrons in the metal strip are deflected toward one edge, producing a voltage gradient across the short side of the strip (perpendicular to the feed current). Hall effect sensors have an advantage over inductive sensors in that, while inductive sensors respond to a changing magnetic field which induces current in a coil of wire and produces voltage at its output, Hall effect sensors can detect static (non-changing) magnetic fields.

In its simplest form, the sensor operates as an analog transducer, directly returning a voltage. With a known magnetic field, its distance from the Hall plate can be determined. Using groups of sensors, the relative position of the magnet can be deduced.

When a beam of charged particles passes through a magnetic field, forces act on the particles and the beam is deflected from a straight path. The flow of electrons through a conductor form a beam of charged carriers. When an conductor is placed in a magnetic field perpendicular to the direction of the electrons, they will be deflected from a straight path. As a consequence, one plane of the conductor will become negatively charged and the opposite side will become positively charged. The voltage between these planes is called the Hall voltage.[2]

When the force on the charged particles from the electric field balances the force produced by magnetic field, the separation of them will stop. If the current is not changing, then the Hall voltage is a measure of the magnetic flux density. Basically, there are two kinds of Hall effect sensors. One is linear which means the output of voltage linearly depends on magnetic flux density; the other is called threshold which means there will be a sharp decrease of output voltage at each magnetic flux density.

Code

[codesyntax lang=”cpp”]

int val = 0;
void setup()
{
Serial.begin(9600);
}

void loop()
{
val = hallRead();
// print the results to the serial monitor:
Serial.print("sensor = ");
Serial.println(val);//to graph
delay(500);
}

[/codesyntax]

Output

Open the serial monitor and if you have a magnet then put it close to your ESP32

sensor = 20
sensor = 14
sensor = 17
sensor = 19
sensor = 17
sensor = 14
sensor = 18
sensor = 68
sensor = 78

If you reverse the magnet so that the other polarity is close to the ESP32 the readings will be negative

Code

Using a ESP32 with a BMP388 barometric pressure sensor

by shedboy71 10th September 2019

In this article we look at another sensor – it is a BMP388 by Bosch Sensortec, so lets crack on and try this out with an ESP32 module again – Wemos Lolin32 for those that are interested

On with the manufacturers information from the website

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

Name	Link
ESP32		Aliexpress link Amazon Ebay
BMP388		Aliexpress link Ebay link Amazon Link
Connecting cables		Aliexpress link Amazon Ebay

Schematic/Connection

I decided to use the sensor in I2C mode

esp32 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

#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);
}

Output

Open the serial monitor and you should see something like this

BMP388 test
Temperature = 23.84 *C
Pressure = 848.40 hPa
Approx. Altitude = 1472.89 m

Temperature = 26.95 *C
Pressure = 994.54 hPa
Approx. Altitude = 156.94 m

Temperature = 26.99 *C
Pressure = 994.53 hPa
Approx. Altitude = 157.01 m

Code

HDC2080 humidity and temperature sensor connected to a ESP32

by shedboy71 24th August 2019

In this article we look at yet another humidity and temperature sensor from TI – this time its the HDC2080 which we will connect up to an ESP32, the Wemos Lolin32 in this case but you can use any ESP32 based module

Lets look at some of the technical blurb on this sensor from the manufacturer

HDC2080 Information

The HDC2080 device is an integrated humidity and temperature sensor that provides high accuracy measurements with very low power consumption in a small DFN package. The capacitive-based sensor includes new integrated digital features and a heating element to dissipate condensation and moisture. The HDC2080 digital features include programmable interrupt thresholds to provide alerts and system wake-ups without requiring a microcontroller to be continuously monitoring the system. Combined with programmable sampling intervals, a low power consumption, and a support for a 1.8-V supply voltage, the HDC2080 is designed for battery-operated systems.

The HDC2080 provides high accuracy measurement capability for a wide range of environmental monitoring and Internet of Things (IoT) applications such as smart thermostats and smart home assistants. For designs where printed-circuit board (PCB) area is critical, a smaller CSP package option is available thru the HDC2010 with complete software compatibility with the HDC2080.

For applications with strict power-budget restrictions, Auto Measurement Mode enables the HDC2080 to automatically initiate temperature and humidity measurements. This feature allows users to configure a microcontroller into deep sleep mode because the HDC2080 is no longer dependent upon the microcontroller to initiate a measurement.

Programable temperature and humidity thresholds in the HDC2080 allow the device to send a hardware interrupt to wake up the microcontroller when necessary. In addition, the power consumption of the HDC2080 is significantly reduced, which helps to minimize self-heating and improve measurement accuracy.

The HDC2080 is factory-calibrated to 0.2°C temperature accuracy and 2% relative humidity accuracy.

Features

Relative humidity range: 0% to 100%
Humidity accuracy: ±2% (typical), ±3% (maximum)
Temperature accuracy: ±0.2°C (typical), ±0.4°C (maximum)
Sleep mode current: 50 nA (typical), 100 nA (maximum)
Average supply current (1 measurement/second)
300 nA: RH% only (11 bit)
550 nA: RH% (11 bit) + temperature (11 bit)

Temperature range:
Operating: –40°C to 85°C
Functional: –40°C to 125°C
Supply voltage range: 1.62 V to 3.6 V

Parts Required

I connected a sensor shield to an Arduino and then the sensor via connecting wire

Name	Link
ESP32		Aliexpress link Amazon Ebay
HDC2080		Aliexpress link Ebay link Amazon Link
Connecting cables		Aliexpress link Amazon Ebay

Schematic/Connection

This is a 3.3v rated sensor

esp32 and hdc2080

Code Example

I used the library from https://github.com/tinkeringtech/HDC2080_breakout

This is the default example with a few cosmetic changes

#include <HDC2080.h>

#define ADDR 0x40
HDC2080 sensor(ADDR);

float temperature = 0, humidity = 0;

void setup() {

Serial.begin(9600);
Serial.println("TinkeringTech HDC2080 Test");

// Initialize I2C communication
sensor.begin();

// Begin with a device reset
sensor.reset();

// Set up the comfort zone
sensor.setHighTemp(48); // High temperature of 28C
sensor.setLowTemp(2); // Low temperature of 22C
sensor.setHighHumidity(95); // High humidity of 55%
sensor.setLowHumidity(10); // Low humidity of 40%

// Configure Measurements
sensor.setMeasurementMode(TEMP_AND_HUMID); // Set measurements to temperature and humidity
sensor.setRate(ONE_HZ); // Set measurement frequency to 1 Hz
sensor.setTempRes(FOURTEEN_BIT);
sensor.setHumidRes(FOURTEEN_BIT);

//begin measuring
sensor.triggerMeasurement();
}

void loop() {

Serial.print("Temperature (C): ");
Serial.print(sensor.readTemp());
Serial.print("\t\tHumidity (%): ");
Serial.println(sensor.readHumidity());

// Wait 1 second for the next reading
delay(2000);

}

Output

Open the serial monitor and you should see something like this

Temperature (C): 23.75 Humidity (%): 46.44
Temperature (C): 23.82 Humidity (%): 46.40
Temperature (C): 23.79 Humidity (%): 46.43
Temperature (C): 23.79 Humidity (%): 46.39
Temperature (C): 23.79 Humidity (%): 46.41
Temperature (C): 23.80 Humidity (%): 46.39

Links

https://www.ti.com/lit/gpn/hdc2080

Newer Posts

Older Posts

Code

Parts Required

Schematic/Connection

Code Example

Output

Features

Parts Required

Schematic/Connection

Code Example

Output

Links

Features

Benefits

Parts List

Code

Output

Parts List

Code

Output

Parts Required

Code

Output

Parts Required

Features

Code

Output

Links

Parts List

Code

Code

Output

Code

Output

BMP388 Information

Parts Required

Schematic/Connection

Code Example

Output

HDC2080 Information

Parts Required

Schematic/Connection

Code Example

Output

Links

Adblock Detected