Author

shedboy71

Arduino Due and VEML6075 sensor

by shedboy71 7th January 2019

written by shedboy71

Another VEML sensor, this time its a VEML6075 and again we connect it to an Arduino Due

The VEML6075 senses UVA and UVB light and incorporates photodiode, amplifiers, and analog / digital circuits into a single chip using a CMOS process. When the UV sensor is applied, it is able to detect UVA and UVB intensity to provide a measure of the signal strength as well as allowing for UVI measurement.

The VEML6075 provides excellent temperature compensation capability for keeping the output stable under changing temperature. VEML6075’s functionality is easily operated via the simple command format of I2C (SMBus compatible) interface protocol. VEML6075’s operating voltage ranges from 1.7 V to 3.6 V.

Parts List

Amount	Part Type
1	VEML6075
1	Compatible DUE R3 Board SAM3X8E 32-bit ARM Cortex-M3

Layout

arduino due and VEML6075 layout

Code

Again we use a library and again its an adafruit one

This is the full example

[codesyntax lang=”cpp”]

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

Adafruit_VEML6075 uv = Adafruit_VEML6075();

void setup() {
  Serial.begin(115200);
  Serial.println("VEML6075 Full Test");
  if (! uv.begin()) {
    Serial.println("Failed to communicate with VEML6075 sensor, check wiring?");
  }
  Serial.println("Found VEML6075 sensor");

  // Set the integration constant
  uv.setIntegrationTime(VEML6075_100MS);
  // Get the integration constant and print it!
  Serial.print("Integration time set to ");
  switch (uv.getIntegrationTime()) {
    case VEML6075_50MS: Serial.print("50"); break;
    case VEML6075_100MS: Serial.print("100"); break;
    case VEML6075_200MS: Serial.print("200"); break;
    case VEML6075_400MS: Serial.print("400"); break;
    case VEML6075_800MS: Serial.print("800"); break;
  }
  Serial.println("ms");

  // Set the high dynamic mode
  uv.setHighDynamic(false);
  // Get the mode
  if (uv.getHighDynamic()) {
    Serial.println("High dynamic reading mode");
  } else {
    Serial.println("Normal dynamic reading mode");
  }

  // Set the mode
  uv.setForcedMode(false);
  // Get the mode
  if (uv.getForcedMode()) {
    Serial.println("Forced reading mode");
  } else {
    Serial.println("Continuous reading mode");
  }

  // Set the calibration coefficients
  uv.setCoefficients(2.22, 1.33,  // UVA_A and UVA_B coefficients
                     2.95, 1.74,  // UVB_C and UVB_D coefficients
                     0.001461, 0.002591); // UVA and UVB responses
}


void loop() {
  Serial.print("Raw UVA reading:  "); Serial.println(uv.readUVA());
  Serial.print("Raw UVB reading:  "); Serial.println(uv.readUVB());
  Serial.print("UV Index reading: "); Serial.println(uv.readUVI());

  delay(1000);
}

[/codesyntax]

Output

Open the serial monitor – this is what I saw but I tested this indoors

VEML6075 Full Test
Failed to communicate with VEML6075 sensor, check wiring?
Found VEML6075 sensor
Integration time set to 50ms
Normal dynamic reading mode
Continuous reading mode
Raw UVA reading: 0.00
Raw UVB reading: 0.00
UV Index reading: 0.00
Raw UVA reading: 0.00
Raw UVB reading: 0.00
UV Index reading: 0.00

Links

https://www.vishay.com/docs/84304/veml6075.pdf

I2C Interface 3.3V Board Based on VEML6075 UVA UVB Light Sensor Module

7th January 2019 0 comment

Arduino Due

Arduino Due and VEML6070 UV sensor

by shedboy71 27th December 2018

written by shedboy71

In this example we look at an VEML6070 UV sensor and connect it to an Arduino Due

Lets take a look at the sensor first

The VEML6070 is an advanced ultraviolet (UV) light sensor with I2C protocol interface and designed by the CMOS process. It is easily operated via a simple I2C command. The active acknowledge (ACK) feature with threshold windows setting allows the UV sensor to send out a UVI alert message. Under a strong solar UVI condition, the smart ACK signal can be easily implemented by the software programming. VEML6070 incorporates a photodiode, amplifiers, and analog / digital circuits into a single chip. VEML6070’s adoption of FiltronTM UV technology provides the best spectral sensitivity to cover UV spectrum sensing. It has an excellent temperature compensation and a robust refresh rate setting that does not use an external RC low pass filter.

VEML6070 has linear sensitivity to solar UV light and is easily adjusted by an external resistor. Software shutdown mode is provided, which reduces power consumption to be less than 1 μA. VEML6070’s operating voltage ranges from 2.7 V to 5.5 V.

You can find out about the UV index at the following link – https://en.wikipedia.org/wiki/Ultraviolet_index

The easiest way to work with this sensor is to buy a module – this is a picture of the module that I bought

Layout

arduino due and VEML6070 layout

Code

I used the Adafruit library – https://github.com/adafruit/Adafruit_VEML6070

[codesyntax lang=”cpp”]

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

Adafruit_VEML6070 uv = Adafruit_VEML6070();

void setup() 
{
  Serial.begin(9600);
  Serial.println("VEML6070 Test");
  uv.begin(VEML6070_1_T);  // pass in the integration time constant
}


void loop() 
{
  Serial.print("UV light level: "); 
  Serial.println(uv.readUV());
  delay(1000);
}

[/codesyntax]

Output

Open the serial monitor – just as a note in my example I was indoors

VEML6070 Test
UV light level: 0
UV light level: 0
UV light level: 0
UV light level: 0
UV light level: 0
UV light level: 0

Link

You can pick up one of these sensors for about $2.50

UV sensor module VEML6070 UV Sensitivity Detection Sensor for Arduino

27th December 2018 0 comment

Arduino Due and SHT20 sensor

by shedboy71 7th December 2018

written by shedboy71

In this article we connect an SHT20 sensor to an Arduino Due

The SHT2x series consists of a low-cost version with the SHT20 humidity sensor. the SHT2x provides calibrated, linearized sensor signals in digital, I2C format. The SHT2x humidity sensor series contains a capacitive-type humidity sensor, a band-gap temperature sensor, and specialized analog and digital integrated circuits – all on a single CMOSens® chip. This yields superior sensor performance in terms of accuracy and stability as well as minimal power consumption.

Every sensor is individually calibrated and tested. Furthermore, the resolution of the SHT2x humidity sensor can be changed on command (8/12 bit up to 12/14 bit for RH/T) and a checksum helps to improve communication reliability.

Performance

Size: 3 x 3 x 1.1mm
Output: I²C digital, PWM, SDM
Supply voltage range: 2.1 to 3.6V
Energy consumption: 3.2µW (at 8 bit, 1 measurement/s)
RH operating range: 0 – 100%RH
T operating range: -40°C to +125°C (-40°F to +257°F)
RH response time: 8 sec (tau63%)

Parts List

Amount	Part Type
1	Temperature and humidity detection sensor module SHT20
1	Compatible DUE R3 Board SAM3X8E 32-bit ARM Cortex-M3

Schematics/Layout

arduino due and SHT20 layout

Code

We use the following library – https://github.com/DFRobot/DFRobot_SHT20

[codesyntax lang=”cpp”]

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

DFRobot_SHT20    sht20;

void setup()
{
    Serial.begin(9600);
    Serial.println("SHT20 Example!");
    sht20.initSHT20();                                  // Init SHT20 Sensor
    delay(100);
    sht20.checkSHT20();                                 // Check SHT20 Sensor
}

void loop()
{
    float humd = sht20.readHumidity();                  // Read Humidity
    float temp = sht20.readTemperature();               // Read Temperature
    Serial.print("Time:");
    Serial.print(millis());
    Serial.print(" Temperature:");
    Serial.print(temp, 1);
    Serial.print("C");
    Serial.print(" Humidity:");
    Serial.print(humd, 1);
    Serial.print("%");
    Serial.println();
    delay(1000);
}

[/codesyntax]

Output

Open the serial monitor – this is what I saw

SHT20 Example!
End of battery: no
Heater enabled: no
Disable OTP reload: yes
Time:202 Temperature:18.8C Humidity:64.3%
Time:1302 Temperature:18.8C Humidity:64.3%
Time:2402 Temperature:18.8C Humidity:64.2%
Time:3502 Temperature:20.2C Humidity:64.4%
Time:4602 Temperature:23.3C Humidity:67.4%
Time:5702 Temperature:24.7C Humidity:72.2%
Time:6802 Temperature:25.5C Humidity:75.0%
Time:7902 Temperature:26.1C Humidity:76.2%
Time:9002 Temperature:26.7C Humidity:76.7%

Links

Sensirion_Humidity_Sensors_SHT20_Datasheet.pdf

7th December 2018 0 comment

Arduino Due

Arduino Due and CCS811 gas sensor example

by shedboy71 23rd November 2018

written by shedboy71

In this article we connect a CCS811 gas sensor to an Arduino Due

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

Features

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

Specs

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

Parts List

Amount	Part Type
1	CJMCU-811 CCS811 Air Quality Gas Sensor
1	Compatible DUE R3 Board SAM3X8E 32-bit ARM Cortex-M3

Schematics/Layout

Remember and connect WAKE to gnd

arduino due and CCS811 layout

Code

We use the adafruit library which can be added using the library manager

[codesyntax lang=”cpp”]

#include “Adafruit_CCS811.h”

Adafruit_CCS811 ccs;

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

Serial.println(“CCS811 test”);

if(!ccs.begin()){
Serial.println(“Failed to start sensor! Please check your wiring.”);
while(1);
}

//calibrate temperature sensor
while(!ccs.available());
float temp = ccs.calculateTemperature();
ccs.setTempOffset(temp – 25.0);
}

void loop() {
if(ccs.available()){
float temp = ccs.calculateTemperature();
if(!ccs.readData()){
Serial.print(“CO2: “);
Serial.print(ccs.geteCO2());
Serial.print(“ppm, TVOC: “);
Serial.print(ccs.getTVOC());
Serial.print(“ppb Temp:”);
Serial.println(temp);
}
else{
Serial.println(“ERROR!”);
while(1);
}
}
delay(500);
}

[/codesyntax]

Output

Open the serial monitor – this is what I saw. The higher CO2 level was when I breathed on the sensor

CO2: 742ppm, TVOC: 52ppb Temp:22.61
CO2: 629ppm, TVOC: 34ppb Temp:21.88
CO2: 460ppm, TVOC: 9ppb Temp:20.01
CO2: 400ppm, TVOC: 0ppb Temp:21.88
CO2: 400ppm, TVOC: 0ppb Temp:24.61
CO2: 400ppm, TVOC: 0ppb Temp:25.00
CO2: 400ppm, TVOC: 0ppb Temp:24.61
CO2: 400ppm, TVOC: 0ppb Temp:24.61

Links

ccs811 datasheet

23rd November 2018 0 comment

Arduino Due

Arduino Due and TMP175 sensor

by shedboy71 6th November 2018

written by shedboy71

Another sensor or module to cross our path, this time we will look at the TMP175 digital temperature sensors

The TMP175 devices is a digital temperature sensors ideal for NTC and PTC thermistor replacement. The device offers a typical accuracy of ±1°C without requiring calibration or external component signal conditioning. IC temperature sensors are highly linear and do not require complex calculations or look-up tables to derive the temperature. The on-chip 12-bit ADC offers resolutions down to 0.0625°C.

The TMP175 feature SMBus, Two-Wire, and I²C interface compatibility. The TMP175 device allows up to 27 devices on one bus. . The TMP175 feature an SMBus Alert function.

The TMP175 are ideal for extended temperature measurement in a variety of communication, computer, consumer, environmental, industrial, and instrumentation applications.

Features

TMP175: 27 Addresses
Digital Output: SMBus™, Two-Wire™, and I²C
Interface Compatibility
Resolution: 9 to 12 Bits, User-Selectable
Accuracy:
- ±1°C (Typical) from –40°C to 125°C
- ±2°C (Maximum) from –40°C to 125°C
Low Quiescent Current: 50-µA, 0.1-µA Standby
Wide Supply Range: 2.7 V to 5.5 V
Small 8-Pin MSOP and 8-Pin SOIC Packages

Connection

Module Connection	Arduino Due Connection
VCC	3v3
GND	Gnd
SDA	SDA
SCL	SCL

Code

[codesyntax lang=”cpp”]

#include <Wire.h> 

byte TempHi;              // Variable hold data high byte
byte TempLo;              // Variable hold data low byte
boolean P_N;              // Bit flag for Positive and Negative
unsigned int Decimal;     // Variable hold decimal value

void Cal_Temp();
/*******************************************************************************
                      Setup
*******************************************************************************/ 
void setup() 
{ 
  Serial.begin(9600);
  Wire.begin();             // join i2c bus (address optional for master) 
  delay(1000);
} 
 
/*******************************************************************************
                      Main Loop
*******************************************************************************/  
void loop() 
{
  const int I2C_address = 0x37;  // I2C write address 
    
  delay(100);
  Wire.beginTransmission(I2C_address);
  Wire.write(1);             // Setup configuration register
  Wire.write(0x60);          // 12-bit
  Wire.endTransmission(); 
  
  Wire.beginTransmission(I2C_address);
  Wire.write(0);             // Setup Pointer Register to 0
  Wire.endTransmission(); 
  
  while (1)
  {
    delay(1000);
    
    // Read temperature value
    Wire.requestFrom(I2C_address, 2);
    while(Wire.available())          // Checkf for data from slave
    {                                
      TempHi = Wire.read();       // Read temperature high byte
      TempLo = Wire.read();       // Read temperature low byte
    } 
    Cal_Temp ();
    
    // Display temperature
    Serial.print("The temperature is ");
    if (P_N == 0)
      Serial.print("-");
    Serial.print(TempHi,DEC);
    Serial.print(".");
    Serial.print(Decimal,DEC);
    Serial.println(" degree C");
  }  
}

void Cal_Temp()
{
  if (TempHi&0x80)          // If bit7 of the TempHi is HIGH then the temperature is negative
    P_N = 0;
  else                      // Else the temperature is positive
    P_N = 1;
  
  TempHi = TempHi & 0x7F;   // Remove sign
  TempLo = TempLo & 0xF0;   // Filter out last nibble
  TempLo = TempLo >>4;      // Shift right 4 times
  Decimal = TempLo;
  Decimal = Decimal * 625;  // Each bit = 0.0625 degree C
    
}

[/codesyntax]

Output

Open up the trusty serial monitor and you will see something like this all going well

The temperature is 18.6250 degree C
The temperature is 18.6250 degree C
The temperature is 18.6250 degree C
The temperature is 18.6250 degree C
The temperature is 19.1250 degree C
The temperature is 22.5000 degree C
The temperature is 24.1250 degree C
The temperature is 25.3125 degree C
The temperature is 26.3125 degree C

Link

1pcs CJMCU-175 TMP175 27 Address Digital Temperature Sensor

6th November 2018 0 comment

Arduino Due

Arduino Due and MPL3115A2 example

by shedboy71 24th October 2018

written by shedboy71

In this example we connect a MPL3115A2 to an Arduino Due

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

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

• Operating range: 20 kPa to 110 kPa absolute pressure
• Calibrated range: 50 kPa to 110 kPa absolute pressure
• Calibrated temperature output: −40 °C to 85 °C
• I2C digital output interface
• Fully compensated internally
• Precision ADC resulting in 0.1 meter of effective resolution
• Direct reading
– Pressure: 20-bit measurement (Pascals) 20 to 110 kPa
– Altitude: 20-bit measurement (meters) –698 to 11,775 m
– Temperature: 12-bit measurement (°C) –40 °C to 85 °C
• Programmable interrupts
• Autonomous data acquisition
– Embedded 32-sample FIFO
– Data logging up to 12 days using the FIFO
– One-second to nine-hour data acquisition rate
• 1.95 V to 3.6 V supply voltage, internally regulated
• 1.6 V to 3.6 V digital interface supply voltage
• Operating temperature from −40 °C to +85 °C

Parts List

Amount	Part Type
1	MPL3115A2 I2C Intelligent Temperature Pressure Altitude Sensor V2.0 For Arduino
1	Compatible DUE R3 Board SAM3X8E 32-bit ARM Cortex-M3

Schematics/Layout

arduino due and mpl3115a2

Code

Again we use a library and again its an adafruit one – https://github.com/adafruit/Adafruit_MPL3115A2_Library

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <Adafruit_MPL3115A2.h>

// Power by connecting Vin to 3-5V, GND to GND
// Uses I2C - connect SCL to the SCL pin, SDA to SDA pin
// See the Wire tutorial for pinouts for each Arduino
// http://arduino.cc/en/reference/wire
Adafruit_MPL3115A2 baro = Adafruit_MPL3115A2();

void setup() {
  Serial.begin(9600);
  Serial.println("Adafruit_MPL3115A2 test!");
}

void loop() {
  if (! baro.begin()) {
    Serial.println("Couldnt find sensor");
    return;
  }
  
  float pascals = baro.getPressure();
  // Our weather page presents pressure in Inches (Hg)
  // Use http://www.onlineconversion.com/pressure.htm for other units
  Serial.print(pascals/3377); Serial.println(" Inches (Hg)");

  float altm = baro.getAltitude();
  Serial.print(altm); Serial.println(" meters");

  float tempC = baro.getTemperature();
  Serial.print(tempC); Serial.println("*C");

  delay(250);
}

[/codesyntax]

Output

Open the serial monitor – here are my results

Links

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

24th October 2018 0 comment

Arduino Due

Arduino Due and MLX90615 example

by shedboy71 13th October 2018

written by shedboy71

The MLX90615 is a miniature infrared thermometer for non-contact temperature measurements. Both the IR sensitive thermopile detector chip and the signal conditioning ASIC are integrated in the same miniature TO-46 can.

The infrared thermometer comes factory calibrated with a digital SMBus output giving full access to the measured temperature in the complete temperature range(s) with a resolution of 0.02 °C. The sensor achieves an accuracy of ±0.2°C within the relevant medical temperature range. The user can choose to configure the digital output to be PWM.

Features and benefits

Factory calibrated in wide temperature range: -20 to 85°C for sensor temperature and -40 to 115°C for object temperature
High accuracy of 0.5°C over wide temperature range (0..+50 C for both Ta and To)
Medical accuracy of 0.2°C in a limited temperature range
Measurement resolution of 0.02°C
SMBus compatible digital interface for fast temperature readings and building sensor networks
Customizable PWM output for continuous reading
3V supply voltage with power saving mode

Parts List

Amount	Part Type
1	1PCS MLX90615 Digital Infrared Temperature Sensor for Arduino
1	Compatible DUE R3 Board SAM3X8E 32-bit ARM Cortex-M3

Layout

Code Example

This particular example comes from the following library which I installed – https://github.com/skiselev/MLX90615

I had issues with one of the other libraries – this one works just fine

[codesyntax lang=”cpp”]

#include <Wire.h>
#include <mlx90615.h>

MLX90615 mlx = MLX90615();

void setup()
{
Serial.begin(9600);
Serial.println(“Melexis MLX90615 infra-red temperature sensor test”);
mlx.begin();
Serial.print(“Sensor ID number = “);
Serial.println(mlx.get_id(), HEX);
}

void loop()
{
Serial.print(“Ambient = “);
Serial.print(mlx.get_ambient_temp());
Serial.print(” *C\tObject = “);
Serial.print(mlx.get_object_temp());
Serial.println(” *C”);
delay(500);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this. I moved a hot object near the sensor when the second value increased

Links

https://www.melexis.com/-/media/files/documents/datasheets/mlx90615-datasheet-melexis.pdf

13th October 2018 0 comment

MBed

STM32 Nucleo and TSL2561 Luminosity Sensor example

by shedboy71 29th July 2018

written by shedboy71

This TSL2561 is an I2C light-to-digital converter TSL2561 that transforms light intensity to a digital signal. The TSL2561 features a selectable light spectrum range due to its dual light sensitive diodes: infrared and full spectrum. You can switch among three detection modes to take your readings. They are infrared mode, full spectrum and human visible mode.

When running under the human visible mode, this sensor will give you readings just close to your eye feelings.

Features

Selectable detection modes
High resolution 16-Bit digital output at 400 kHz I2C Fast-Mode
Wide dynamic range: 0.1 – 40,000 LUX
Wide operating temperature range: -40°C to 85°C
Programmable interrupt function with User-Defined Upper and lower threshold settings

Here is a typical module that makes it easier to work with the sensor

tsl2561

Layout and Connection

Code

We use this as a basis – https://os.mbed.com/users/anhnt2407/code/TSL2561_Light_sensor/

Update the tsl2561.h for STM32 nucleo

#define TSL2561_I2C_PINNAME_SDA PB_9
#define TSL2561_I2C_PINNAME_SCL PB_8

[codesyntax lang=”cpp”]

#include “mbed.h”
#include “TSL2561.h”

Serial PC(USBTX, USBRX);

#define PC_PRINTX(z,x) if(z==1) PC.printf(x);
#define PC_PRINTLNX(z,x) if(z==1) {PC.printf(x); PC.printf(“\r\n”);}
#define PC_PRINTXY(z,x, y) if(z==1) PC.printf(x, y);
#define PC_PRINTLNXY(z,x, y) if(z==1) {PC.printf(x, y); PC.printf(“\r\n”);}

DigitalOut myled(LED1);
TSL2561 tsl2561(TSL2561_ADDR_FLOAT);

Timer setuptimer;
Timer executetimer;

void setup(void){

if (tsl2561.begin()) {
PC_PRINTLNX(1,”TSL2561 Sensor Found”);
} else {
PC_PRINTLNX(1,”TSL2561 Sensor not Found”);
}

// You can change the gain on the fly, to adapt to brighter/dimmer tsl2561 situations
tsl2561.setGain(TSL2561_GAIN_0X); // set no gain (for bright situtations)
tsl2561.setTiming(TSL2561_INTEGRATIONTIME_402MS); // longest integration time (dim tsl2561)

// Now we’re ready to get readings!
}

int main() {

PC_PRINTLNX(1,”———-START————-“);
setuptimer.start();
setup();
setuptimer.stop();
PC_PRINTLNXY(1,”Setup time: %f”,setuptimer.read());
setuptimer.reset();

uint16_t x,y,z;

while(1) {

executetimer.start();
x = tsl2561.getLuminosity(TSL2561_VISIBLE);
y = tsl2561.getLuminosity(TSL2561_FULLSPECTRUM);
z = tsl2561.getLuminosity(TSL2561_INFRARED);
executetimer.stop();

PC_PRINTLNXY(1,”Visible: %d”,x);
PC_PRINTLNXY(1,”Full Spectrum: %d”,y);
PC_PRINTLNXY(1,”Infrared: %d”,z);
PC_PRINTLNXY(1,”Execution Time: %f”,executetimer.read());
executetimer.reset();

// wait(1);
PC_PRINTLNX(1,”———-COMPLETE————-“);
}
}

[/codesyntax]

Testing

Using a terminal program like teraterm you should see something like this

tsl2561 output

Links

Free Shipping 1pcs GY-2561 TSL2561 Luminosity Sensor Breakout infrared Light Sensor module integrating sensor AL

29th July 2018 0 comment

MBed

STM32 Nucleo and LM75 temperature sensor example

by shedboy71 21st July 2018

written by shedboy71

In this example we connect an LM75 to a STM32 Nucleo and we will use the MBEd compiler

The LM75 temperature sensor includes a delta-sigma analog-to-digital converter, and a digital overtemperature detector. The host can query the LM75 through its I²C interface to read temperature at any time. The open-drain overtemperature output (OS) sinks current when the programmable temperature limit is exceeded.

The OS output operates in either of two modes, comparator or interrupt. The host controls the temperature at which the alarm is asserted (TOS) and the hysteresis temperature below which the alarm condition is not valid (THYST). Also, the LM75’s TOS and THYST registers can be read by the host.

The address of the LM75 is set with three pins to allow multiple devices to work on the same bus. Power-up is in comparator mode, with defaults of TOS = +80°C and THYST = +75°C. The 3.0V to 5.5V supply voltage range, low supply current, and I²C interface make the LM75 ideal for many applications in thermal management and protection.

Key Features

SO (SOP) and µMAX® (µSOP) Packages
I²C Bus Interface
Separate Open-Drain OS Output Operates as Interrupt or Comparator/Thermostat Input
Register Readback Capability
Power-Up Defaults Permit Stand-Alone Operation as a Thermostat
3.0V to 5.5V Supply Voltage
Low Operating Supply Current 250µA (typ), 1mA (max)
4µA (typ) Shutdown Mode Minimizes Power Consumption
Up to Eight LM75s Can Be Connected to a Single Bus

Layout

I2C device you can power it from 3.3 or 5v

stm32nucleo and lm75

Code

I used this library – https://os.mbed.com/users/chris/code/LM75B/

[codesyntax lang=”cpp”]

#include “mbed.h”
#include “LM75B.h”

LM75B tmp(I2C_SDA, I2C_SCL);
Serial pc(SERIAL_TX, SERIAL_RX);

int main ()
{
while (1) {
pc.printf(“%.2f celsius\r\n”,tmp.read());
wait(1.0);
}
}

[/codesyntax]

Output

Using a serial terminal program you should see something like this

lm75 output

Links

LM75 temperature sensor high speed I2C interface high precision development board module

21st July 2018 0 comment

MBed

STM32 Nucleo and MS5611 barometric pressure sensor example

by shedboy71 14th July 2018

written by shedboy71

In this example we connect an MS5611 to an STM32 Nucleo – in this case it was a Nucleo-F446RE

This barometric pressure sensor is optimized for altimeters and variometers with an altitude resolution of 10 cm. The sensor module includes a high linearity pressure sensor and an ultra-low power 24 bit ΔΣ ADC with internal factory calibrated coefficients. It provides a precise digital 24 Bit pressure and temperature value and different operation modes that allow the user to optimize for conversion speed and current consumption. A high resolution temperature output allows the implementation of an altimeter/thermometer function without any additional sensor.

Features

High resolution module, 10 cm
Fast conversion down to 1 ms
Low power, 1 µA (standby < 0.15 µA)
QFN package 5.0 x 3.0 x 1.0 mm³
Supply voltage 1.8 to 3.6 V
Integrated digital pressure sensor (24 bit ΔΣ ADC)
Operating range: 10 to 1200 mbar, -40 to +85 °C
I²C and SPI interface up to 20 MHz
No external components (Internal oscillator)
Excellent long term stability

Connection

ST32 Nucleo	Module connection
3v3	Vcc
Gnd	Gnd
SCL	SCL
SDA	SDA

Here is a layout

stm32nucleo and ms5611

Code

Import this into the MBEd compiler – https://os.mbed.com/teams/Aerodyne/code/MS5611Example/

I slightly modified to loop the output, thats about it

[codesyntax lang=”cpp”]

/* MS5611 Pressure sensor example
Aerodyne Labs
2014
*/
#include “mbed.h”

//Only uncomment the one needed.
//#include “MS5611SPI.h”
#include “MS5611I2C.h”

int main() {
//Only uncomment the I2C or SPI version.
//MS5611SPI ms5611(p11, p12, p13, p10);
//MS5611I2C ms5611(p9, p10, false);
//PB_9 and PB_8 for Nucleo boards
MS5611I2C ms5611(PB_9, PB_8, false);
//Print the Coefficients from the
ms5611.printCoefficients();
while(1) {
printf(“Pressure = %.0f Pa \r\n”, ms5611.getPressure());
printf(“Temperature = %.2f degC \r\n”, ms5611.getTemperature());
printf(“Altitude = %.2f m \r\n”, ms5611.getAltitude());
printf(“——————-\r\n”);
wait(2.0f);
}
}

[/codesyntax]

Output

Use a program like teraterm and you should see something like this

ms5611 output

Link

GY-63 MS5611-01BA03 Precision MS5611 Atmospheric Pressure Sensor Module Height Sensor Module

14th July 2018 0 comment

Arduino Due

Arduino Due and TM1637 7 segment display example

by shedboy71 6th July 2018

written by shedboy71

A common display module that you can buy on the internet contain the Tm1638 driver chip, I was interested in this one which is the TM1637 which appears to be a more basic version which can only control a display, the TM1638 can also control LED’s, buttons and two displays at the same time.

This is a common anode 4-digit tube display module which uses the TM1637 driver chip; Only 2 connections are required to control the 4-digit 8-segment displays

Here is the module

Features of the module

Display common anode for the four red LED
Powered supply by 3.3V/5V
Four common anode tube display module is driven by IC TM1637
Can be used for Arduino devices, two signal lines can make the MCU control 4 8 digital tube. Digital tube 8 segment is adjustable

Here is how to hook the module up, the good news is this worked with my Arduino Due and 3.3v

Schematic

arduino due and TM1637

Code

There is a library for this IC, you can get it from https://github.com/avishorp/TM1637 , as usual there is a built in example but here is a simple sketch

[codesyntax lang=”cpp”]

#include <TM1637Display.h>

const int CLK = 3; //Set the CLK pin connection to the display
const int DIO = 2; //Set the DIO pin connection to the display

int numCounter = 0;

TM1637Display display(CLK, DIO); //set up the 4-Digit Display.

void setup()
{
display.setBrightness(0x0a); //set the diplay to maximum brightness
}

void loop()
{
for(numCounter = 0; numCounter < 1000; numCounter++) //Iterate numCounter
{
display.showNumberDec(numCounter); //Display the numCounter value;
delay(1000);
}
}

[/codesyntax]

Links

1pcs SAMIORE ROBOT 4 Bits TM1637 Red Digital Tube LED Display Module & Clock LED

6th July 2018 0 comment

Arduino Due

OPT3001 Digital Ambient Light Sensor and Arduino example

by shedboy71 22nd June 2018

written by shedboy71

In this example we will connect an OPT3001 to an Arduino Due

The OPT3001 is a sensor that measures the intensity of visible light. The spectral response of the sensor tightly matches the photopic response of the human eye and includes significant infrared rejection.

The OPT3001 is a single-chip lux meter, measuring the intensity of light as visible by the human eye. The precision spectral response and strong IR rejection of the device enables the OPT3001 to accurately meter the intensity of light as seen by the human eye regardless of light source. The strong IR rejection also aids in maintaining high accuracy when industrial design calls for mounting the sensor under dark glass for aesthetics. The OPT3001 is designed for systems that create light-based experiences for humans, and an ideal preferred replacement for photodiodes, photoresistors, or other ambient light sensors with less human eye matching and IR rejection.

Measurements can be made from 0.01 lux up to 83k lux without manually selecting full-scale ranges by using the built-in, full-scale setting feature. This capability allows light measurement over a 23-bit effective dynamic range.

The digital operation is flexible for system integration. Measurements can be either continuous or single-shot. The control and interrupt system features autonomous operation, allowing the processor to sleep while the sensor searches for appropriate wake-up events to report via the interrupt pin. The digital output is reported over an I2C- and SMBus-compatible, two-wire serial interface.

Features

Precision Optical Filtering to Match Human Eye:
- Rejects > 99% (typ) of IR
Automatic Full-Scale Setting Feature Simplifies Software and Ensures Proper Configuration
Measurements: 0.01 lux to 83 k lux
23-Bit Effective Dynamic Range With
Automatic Gain Ranging
12 Binary-Weighted Full-Scale Range Settings:
< 0.2% (typ) Matching Between Ranges
Low Operating Current: 1.8 µA (typ)
Operating Temperature Range: –40°C to +85°C
Wide Power-Supply Range: 1.6 V to 3.6 V
5.5-V Tolerant I/O

Connection

Arduino Due	CJMCU-3001
3.3v	Vcc
Gnd	Gnd
SDA	SDA
SCL	SCL

Code

This example uses the following library https://github.com/closedcube/ClosedCube_OPT3001_Arduino

[codesyntax lang=”cpp”]

/*

This is example for ClosedCube OPT3001 Digital Ambient Light Sensor breakout board 

Initial Date: 02-Dec-2015

Hardware connections for Arduino Uno:
VDD to 3.3V DC
SDA to A4
SCL to A5
GND to common ground

Written by AA for ClosedCube

MIT License

*/

#include <Wire.h>
#include <ClosedCube_OPT3001.h>

ClosedCube_OPT3001 opt3001;

#define OPT3001_ADDRESS 0x44

void setup()
{
	Serial.begin(9600);
	Serial.println("ClosedCube OPT3001 Arduino Test");

	opt3001.begin(OPT3001_ADDRESS);
	Serial.print("OPT3001 Manufacturer ID");
	Serial.println(opt3001.readManufacturerID());
	Serial.print("OPT3001 Device ID");
	Serial.println(opt3001.readDeviceID());

	configureSensor();
	printResult("High-Limit", opt3001.readHighLimit());
	printResult("Low-Limit", opt3001.readLowLimit());
	Serial.println("----");
}

void loop()
{
	OPT3001 result = opt3001.readResult();
	printResult("OPT3001", result);
	delay(500);
}

void configureSensor() {
	OPT3001_Config newConfig;
	
	newConfig.RangeNumber = B1100;	
	newConfig.ConvertionTime = B0;
	newConfig.Latch = B1;
	newConfig.ModeOfConversionOperation = B11;

	OPT3001_ErrorCode errorConfig = opt3001.writeConfig(newConfig);
	if (errorConfig != NO_ERROR)
		printError("OPT3001 configuration", errorConfig);
	else {
		OPT3001_Config sensorConfig = opt3001.readConfig();
		Serial.println("OPT3001 Current Config:");
		Serial.println("------------------------------");
		
		Serial.print("Conversion ready (R):");
		Serial.println(sensorConfig.ConversionReady,HEX);

		Serial.print("Conversion time (R/W):");
		Serial.println(sensorConfig.ConvertionTime, HEX);

		Serial.print("Fault count field (R/W):");
		Serial.println(sensorConfig.FaultCount, HEX);

		Serial.print("Flag high field (R-only):");
		Serial.println(sensorConfig.FlagHigh, HEX);

		Serial.print("Flag low field (R-only):");
		Serial.println(sensorConfig.FlagLow, HEX);

		Serial.print("Latch field (R/W):");
		Serial.println(sensorConfig.Latch, HEX);

		Serial.print("Mask exponent field (R/W):");
		Serial.println(sensorConfig.MaskExponent, HEX);

		Serial.print("Mode of conversion operation (R/W):");
		Serial.println(sensorConfig.ModeOfConversionOperation, HEX);

		Serial.print("Polarity field (R/W):");
		Serial.println(sensorConfig.Polarity, HEX);

		Serial.print("Overflow flag (R-only):");
		Serial.println(sensorConfig.OverflowFlag, HEX);

		Serial.print("Range number (R/W):");
		Serial.println(sensorConfig.RangeNumber, HEX);

		Serial.println("------------------------------");
	}
	
}

void printResult(String text, OPT3001 result) {
	if (result.error == NO_ERROR) {
		Serial.print(text);
		Serial.print(": ");
		Serial.print(result.lux);
		Serial.println(" lux");
	}
	else {
		printError(text,result.error);
	}
}

void printError(String text, OPT3001_ErrorCode error) {
	Serial.print(text);
	Serial.print(": [ERROR] Code #");
	Serial.println(error);
}

[/codesyntax]

Output

Open the serial monitor and you should see something like this

OPT3001: 248.16 lux
OPT3001: 19.08 lux
OPT3001: 12.85 lux
OPT3001: 18.91 lux
OPT3001: 230.24 lux
OPT3001: 218.64 lux
OPT3001: 15.07 lux
OPT3001: 53.40 lux
OPT3001: 173.28 lux
OPT3001: 145.44 lux

Link

OPT3001 CJMCU-3001 ambient light sensor eye like measurement light intensity single chip illumination meter

22nd June 2018 0 comment

Newer Posts

Older Posts