Home MBed
Category:

MBed

MBed

STM32 Nucleo and MPL3115A2 pressure sensor MBed example

by shedboy71
written by shedboy71

In this example we connect a MPL3115A2 sensor to a STM32 Nucleo and the example will use the MBed compiler

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

Parts List

Here are the parts that I used

Name Link
STM32 Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
MPL3115A2 MPL3115A2 I2C Intelligent Temperature Pressure Altitude Sensor V2.0
Connecting cable Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Schematics/Layout

stm32 nucleo and MPL3115A2 sensor

stm32 nucleo and MPL3115A2 sensor

 

Code

I imported the following example and library into the MBed compiler – https://os.mbed.com/teams/MSS/code/test_MPL3115A2/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "MSS.h"
#include "MPL3115A2.h"
#define MPL3115A2_I2C_ADDRESS (0x60)

int main() {
    double alt, bar, temp ;
    MPL3115A2 mpl(PIN_SDA, PIN_SCL, MPL3115A2_I2C_ADDRESS) ;
    
    printf("=== test MPL3115A2 for %s (%s) ===\n") ;
    printf("Altitude(m), Pressure(hPa),   Temperature(c)\n") ;
    
    while(1) 
    {
        alt = mpl.getAltitude() ;
        bar = mpl.getPressure() ;
        temp = mpl.getTemperature() ;
        printf("%6.2f,   %6.2f, %6.2f\n",alt, bar, temp) ;
        wait(1) ;
    }
}

[/codesyntax]

Output

Using a serial monitor program like Teraterm connect to the serial port of your STM32 nucleo

mpl3115a2 output

mpl3115a2 output

Links

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

0 comment
0 FacebookTwitterPinterestEmail
MBed

VL53L0X and STM32 Nucleo MBed example

by shedboy71
written by shedboy71

In this example we connect a VL53L0X to a STM32 Nucleo

The VL53L0X is a new generation Time-of-Flight (ToF) laser-ranging module housed in the smallest package on the market today, providing accurate distance measurement whatever the target reflectances unlike conventional technologies. It can measure absolute distances up to 2m, setting a new benchmark in ranging performance levels, opening the door to various new applications.

The VL53L0X integrates a leading-edge SPAD array (Single Photon Avalanche Diodes) and embeds ST’s second generation FlightSenseTM patented technology.

Here is a typical module

The VL53L0X’s 940 nm VCSEL emitter (Vertical Cavity Surface-Emitting Laser), is totally invisible to the human eye, coupled with internal physical infrared filters, it enables longer ranging distances, higher immunity to ambient light, and better robustness to cover glass optical crosstalk.

 

Parts List

This is the parts that I used

Name Link
ST Nucleo STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino
VL53L0X VL53L0X Time-of-Flight (ToF) Laser Ranging Sensor Breakout 940nm
Connecting wire Free shipping Dupont line 120pcs 20cm male to male + male to female and female to female jumper wire

Schematics/Layout

stm32 nucleo and VL53L0X sensor

stm32 nucleo and VL53L0X sensor

 

Code

You need to import this example into the MBed compiler. Build it and copy the bin file to the MBEd drive that is present on your PC

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "vl53l0x_api.h"
#include "vl53l0x_platform.h"
#include "vl53l0x_i2c_platform.h"

Serial pc(SERIAL_TX, SERIAL_RX);

void print_pal_error(VL53L0X_Error Status){
    char buf[VL53L0X_MAX_STRING_LENGTH];
    VL53L0X_GetPalErrorString(Status, buf);
    printf("API Status: %i : %s\n", Status, buf);
}

void print_range_status(VL53L0X_RangingMeasurementData_t* pRangingMeasurementData){
    char buf[VL53L0X_MAX_STRING_LENGTH];
    uint8_t RangeStatus;

    /*
     * New Range Status: data is valid when pRangingMeasurementData->RangeStatus = 0
     */

    RangeStatus = pRangingMeasurementData->RangeStatus;

    VL53L0X_GetRangeStatusString(RangeStatus, buf);
    printf("Range Status: %i : %s\n", RangeStatus, buf);

}


VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev) {
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    uint8_t NewDatReady=0;
    uint32_t LoopNb;

    // Wait until it finished
    // use timeout to avoid deadlock
    if (Status == VL53L0X_ERROR_NONE) {
        LoopNb = 0;
        do {
            Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDatReady);
            if ((NewDatReady == 0x01) || Status != VL53L0X_ERROR_NONE) {
                break;
            }
            LoopNb = LoopNb + 1;
            VL53L0X_PollingDelay(Dev);
        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);

        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
            Status = VL53L0X_ERROR_TIME_OUT;
        }
    }

    return Status;
}

VL53L0X_Error WaitStopCompleted(VL53L0X_DEV Dev) {
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    uint32_t StopCompleted=0;
    uint32_t LoopNb;

    // Wait until it finished
    // use timeout to avoid deadlock
    if (Status == VL53L0X_ERROR_NONE) {
        LoopNb = 0;
        do {
            Status = VL53L0X_GetStopCompletedStatus(Dev, &StopCompleted);
            if ((StopCompleted == 0x00) || Status != VL53L0X_ERROR_NONE) {
                break;
            }
            LoopNb = LoopNb + 1;
            VL53L0X_PollingDelay(Dev);
        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);

        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
            Status = VL53L0X_ERROR_TIME_OUT;
        }

    }

    return Status;
}


int main()
{
  
    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
    VL53L0X_Dev_t MyDevice;
    VL53L0X_Dev_t *pMyDevice = &MyDevice;
    VL53L0X_Version_t                   Version;
    VL53L0X_Version_t                  *pVersion   = &Version;
    VL53L0X_DeviceInfo_t                DeviceInfo; 
    
    int32_t status_int;
    
    pc.printf("VL53L0X API Simple Ranging Example\r\n");
    
    // Initialize Comms
    pMyDevice->I2cDevAddr      = 0x52;
    pMyDevice->comms_type      =  1;
    pMyDevice->comms_speed_khz =  400;
    
    pc.printf("Init comms\r\n");
    
    if(Status == VL53L0X_ERROR_NONE)
    {
        status_int = VL53L0X_GetVersion(pVersion);
        if (status_int != 0)
            Status = VL53L0X_ERROR_CONTROL_INTERFACE;
    }
    pc.printf("VL53L0X API Version: %d.%d.%d (revision %d)\r\n", pVersion->major, pVersion->minor ,pVersion->build, pVersion->revision);
        
        int addr;
        
        addr = VL53L0X_scan();
        printf("Device found at: %i\r\n", addr);
        //uint8_t data;
        //data=0;
        if(Status == VL53L0X_ERROR_NONE)
    {
            printf ("Call of VL53L0X_DataInit\n");
            uint16_t osc_calibrate_val=0;
            Status = VL53L0X_RdWord(&MyDevice, VL53L0X_REG_OSC_CALIBRATE_VAL,&osc_calibrate_val);
            printf("%i\n",osc_calibrate_val);
      Status = VL53L0X_DataInit(&MyDevice); // Data initialization
      print_pal_error(Status);
    }

        if(Status == VL53L0X_ERROR_NONE)
    {
        Status = VL53L0X_GetDeviceInfo(&MyDevice, &DeviceInfo);
        if(Status == VL53L0X_ERROR_NONE)
        {
            printf("VL53L0X_GetDeviceInfo:\n");
            printf("Device Name : %s\n", DeviceInfo.Name);
            printf("Device Type : %s\n", DeviceInfo.Type);
            printf("Device ID : %s\n", DeviceInfo.ProductId);
            printf("ProductRevisionMajor : %d\n", DeviceInfo.ProductRevisionMajor);
        printf("ProductRevisionMinor : %d\n", DeviceInfo.ProductRevisionMinor);

        if ((DeviceInfo.ProductRevisionMinor != 1) && (DeviceInfo.ProductRevisionMinor != 1)) {
            printf("Error expected cut 1.1 but found cut %d.%d\n",
                       DeviceInfo.ProductRevisionMajor, DeviceInfo.ProductRevisionMinor);
                Status = VL53L0X_ERROR_NOT_SUPPORTED;
            }
        }
        print_pal_error(Status);
    }

        VL53L0X_RangingMeasurementData_t    RangingMeasurementData;
        VL53L0X_RangingMeasurementData_t   *pRangingMeasurementData    = &RangingMeasurementData;
        Status = VL53L0X_ERROR_NONE;
        uint32_t refSpadCount;
        uint8_t isApertureSpads;
        uint8_t VhvSettings;
        uint8_t PhaseCal;

    if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StaticInit\n");
            Status = VL53L0X_StaticInit(pMyDevice); // Device Initialization
            // StaticInit will set interrupt by default
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_PerformRefCalibration\n");
            Status = VL53L0X_PerformRefCalibration(pMyDevice,
                    &VhvSettings, &PhaseCal); // Device Initialization
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_PerformRefSpadManagement\n");
            Status = VL53L0X_PerformRefSpadManagement(pMyDevice,
                    &refSpadCount, &isApertureSpads); // Device Initialization
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {

            printf ("Call of VL53L0X_SetDeviceMode\n");
            Status = VL53L0X_SetDeviceMode(pMyDevice, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in single ranging mode
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StartMeasurement\n");
            Status = VL53L0X_StartMeasurement(pMyDevice);
            print_pal_error(Status);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            uint32_t measurement;
            uint32_t no_of_measurements = 32;

            uint16_t* pResults = (uint16_t*)malloc(sizeof(uint16_t) * no_of_measurements);

            for(measurement=0; measurement<no_of_measurements; measurement++)
            {

                Status = WaitMeasurementDataReady(pMyDevice);

                if(Status == VL53L0X_ERROR_NONE)
                {
                    Status = VL53L0X_GetRangingMeasurementData(pMyDevice, pRangingMeasurementData);

                    *(pResults + measurement) = pRangingMeasurementData->RangeMilliMeter;
                    printf("In loop measurement %lu: %d\n", measurement, pRangingMeasurementData->RangeMilliMeter);

                    // Clear the interrupt
                    VL53L0X_ClearInterruptMask(pMyDevice, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
                    VL53L0X_PollingDelay(pMyDevice);
                } else {
                    break;
                }
            }

            if(Status == VL53L0X_ERROR_NONE)
            {
                for(measurement=0; measurement<no_of_measurements; measurement++)
                {
                    printf("measurement %lu: %d\n", measurement, *(pResults + measurement));
                }
            }

            free(pResults);
        }


        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Call of VL53L0X_StopMeasurement\n");
            Status = VL53L0X_StopMeasurement(pMyDevice);
        }

        if(Status == VL53L0X_ERROR_NONE)
        {
            printf ("Wait Stop to be competed\n");
            Status = WaitStopCompleted(pMyDevice);
        }

        if(Status == VL53L0X_ERROR_NONE)
        Status = VL53L0X_ClearInterruptMask(pMyDevice,
            VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
    while (true)
        if (pc.readable())
            pc.putc(pc.getc());
}

[/codesyntax]

 

Output

Use a program like teraterm and open the serial port of your STM32 Nucleo

 

Links

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

0 comment
0 FacebookTwitterPinterestEmail
MBed

STM32 Nucleo and CCS911 sensor MBed example

by shedboy71
written by shedboy71

In this example we will connect a CCS811 gas sensor to an STM32 Nucleo and the code example will be written in the MBed compiler, lets look at the sensor

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 STM32 Development Board NUCLEO-F446RE, STM32 STM32F446RET6 MCU, supports Arduino

 

 

Schematics/Layout

Remember and connect WAKE to gnd

stm32 nucleo and ccs811 sensor

stm32 nucleo and ccs811 sensor

Code

Again we use a library this is the adafruit one – you can use the library manager and add this.

And this is the out of the box example

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "CCS811.h"


Serial pc(USBTX, USBRX);

#ifdef TARGET_UBLOX_EVK_ODIN_W2
CCS811 ccs811(PF_0, PF_1);
#else
CCS811 ccs811(I2C_SDA, I2C_SCL);
#endif


uint16_t eco2, tvoc;


void CCS811Callback(void)
{

    ccs811.readData(&eco2, &tvoc);

    pc.printf("eCO2 reading :%dppm, TVOC reading :%dppb\r\n", eco2, tvoc);

}


int main()
{
    ccs811.init();
    wait(1);

    while(1) {
//        ccs811.readstatus(); //0x90 reports everything working, 0x98 measurement ready to be used
        wait(1);
        CCS811Callback();
        wait(1);
    }
}

[/codesyntax]

 

Output

Open Teraterm and connect to the assigned port of the STM32 nucleo

You should see something like this

ccs811 output

ccs811 output

 

Links

ccs811 datasheet

0 comment
0 FacebookTwitterPinterestEmail
MBed

DS18B20 thermometer and LPC1768 example

by shedboy71
written by shedboy71

The DS18B20 digital thermometer provides 9-bit to 12-bit Celsius temperature measurements and has an alarm function with nonvolatile user-programmable upper and lower trigger points.

The DS18B20 communicates over a 1-Wire bus that by definition requires only one data line (and ground) for communication with a central microprocessor. In addition, the DS18B20 can derive power directly from the data line (“parasite power”), eliminating the need for an external power supply.

Each DS18B20 has a unique 64-bit serial code, which allows multiple DS18B20s to function on the same 1-Wire bus. Thus, it is simple to use one microprocessor to control many DS18B20s distributed over a large area. Applications that can benefit from this feature include HVAC environmental controls, temperature monitoring systems inside buildings, equipment, or machinery, and process monitoring and control systems.

Features

Unique 1-Wire® Interface Requires Only One Port Pin for Communication
Reduce Component Count with Integrated Temperature Sensor and EEPROM
Measures Temperatures from -55°C to +125°C (-67°F to +257°F)
±0.5°C Accuracy from -10°C to +85°C
Programmable Resolution from 9 Bits to 12 Bits
No External Components Required
Parasitic Power Mode Requires Only 2 Pins for Operation (DQ and GND)
Simplifies Distributed Temperature-Sensing Applications with Multidrop Capability
Each Device Has a Unique 64-Bit Serial Code Stored in On-Board ROM

Parts List

Label Part Type Properties
DS1 DS18B20 1-Wire Temperature Sensor
MBED1 mbed LPC1768
R1 4.7kΩ Resistor

Layout

 

mbed and ds18b20

mbed and ds18b20

Code

This uses the mbed library from https://os.mbed.com/components/DS1820/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "DS1820.h"

#define DATA_PIN        A5
 
DS1820 probe(DATA_PIN);
 
int main() 
{
    while(1) 
    {
        probe.convertTemperature(true, DS1820::all_devices);         //Start temperature conversion, wait until ready
        printf("It is %3.1foC\r\n", probe.temperature());
        wait(1);
    }
}

[/codesyntax]

Testing

Using a terminal program such as Teraterm you should see something like this

It is 18.2oC
It is 18.4oC
It is 18.5oC
It is 18.6oC
It is 18.7oC
It is 18.8oC
It is 18.9oC
It is 18.9oC
It is 19.0oC
It is 19.0oC
It is 18.9oC

 

Links

DS18B20 – One Wire Digital Temperature Sensor

0 comment
0 FacebookTwitterPinterestEmail
MBed

HMC5883 sensor and LPC1768 example

by shedboy71
written by shedboy71

The Honeywell HMC5883L is a surface-mount, multi-chip module designed for low-field magnetic sensing with a digital interface for applications such as low cost compassing and magnetometry.

The HMC5883L includes our state-of-theart, high-resolution HMC118X series magneto-resistive sensors plus an ASIC containing amplification, automatic degaussing strap drivers, offset cancellation, and a 12-bit ADC that enables 1° to 2° compass heading accuracy.

The I2C serial bus allows for easy interface. The HMC5883L is a 3.0×3.0x0.9mm surface mount 16-pin leadless chip carrier (LCC). Applications for the HMC5883L include Mobile Phones, Netbooks, Consumer Electronics, Auto Navigation Systems, and Personal Navigation Devices.

The HMC5883L utilizes Honeywell’s Anisotropic Magnetoresistive (AMR) technology that provides advantages over other magnetic sensor technologies. These anisotropic, directional sensors feature precision in-axis sensitivity and linearity.

These sensors’ solid-state construction with very low cross-axis sensitivity is designed to measure both the direction and the magnitude of Earth’s magnetic fields, from milli-gauss to 8 gauss. Honeywell’s Magnetic Sensors are among the most sensitive and reliable low-field sensors in the industry

Parts List

Label Part Type Properties
MBED1 mbed LPC1768
Part1 Triple Axis Magnetometer – HMC5883 Breakout tilt compensated No

Layout

 

Code

I imported the library and example from the following location to use in the MBed online compiler – https://os.mbed.com/components/Grove-3-Axis-Digital-Compass/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "HMC5883L.h"

HMC5883L compass(p9, p10);
 
int main(void)
{
    int16_t data[3] = {0};
    double heading = 0.0f;
    
    compass.init();
    
    while(1) 
    {
        compass.getXYZ(data);
        wait(0.1f);
        heading = compass.getHeadingXYDeg();
        printf("x: %4d, y: %4d, z: %4d\r\n", data[0], data[1], data[2]);
        printf("heading: %3.2f\r\n", heading);
        wait(1.0f);
    }
}

[/codesyntax]

 

Testing

Using a terminal program such as Teraterm you should see something like the following

x: -404, y: 119, z: -318
heading: 157.04
x: -20, y: 463, z: -36
heading: 81.49
x: 539, y: 212, z: 160
heading: 0.00
x: -450, y: -6, z: -233
heading: 176.32
x: 207, y: 459, z: 22
heading: 69.76
x: 126, y: -454, z: -248
heading: 290.98
x: 297, y: 54, z: 485
heading: 12.32
x: 645, y: -144, z: 96
heading: 350.27
x: 170, y: -34, z: 481
heading: 319.64
x: 102, y: -272, z: 431
heading: 290.19
x: 88, y: -278, z: 424
heading: 287.38
x: 80, y: -280, z: 421
heading: 285.65

The values change as I move the sensor about

 

Links

HMC5883 GY-271 3V-5V Triple Axis Compass Magnetometer Sensor Module For Arduino

0 comment
0 FacebookTwitterPinterestEmail
MBed

Connect a PCF8574 expander to an LPC1768

by shedboy71
written by shedboy71

This 8-bit input/output (I/O) expander for the two-line bidirectional bus (I2C) is designed for 2.5-V to 6-V VCC operation.

This is the module I used

The PCF8574 device provides general-purpose remote I/O expansion for most microcontroller families by way of the I2C interface [serial clock (SCL), serial data (SDA)].

The device features an 8-bit quasi-bidirectional I/O port (P0–P7), including latched outputs with high-current drive capability for directly driving LEDs. Each quasi-bidirectional I/O can be used as an input or output without the use of a data-direction control signal. At power on, the I/Os are high. In this mode, only a current source to VCC is active.

Features

Low Standby-Current Consumption of 10 µA Max
I2C to Parallel-Port Expander
Open-Drain Interrupt Output
Compatible With Most Microcontrollers
Latched Outputs With High-Current Drive
Capability for Directly Driving LEDs

 

Parts List

Label Part Type Properties
LED1 Red (633nm) LED package 5 mm [THT]; leg yes; color Red (633nm)
LED2 Red (633nm) LED package 5 mm [THT]; leg yes; color Red (633nm)
LED3 Red (633nm) LED package 5 mm [THT]; leg yes; color Red (633nm)
LED4 Red (633nm) LED package 5 mm [THT]; leg yes; color Red (633nm)
MBED1 mbed 1768 variant mbed; processor NXP/ARM Cortex
R1 220Ω Resistor
R2 220Ω Resistor
R3 220Ω Resistor
R4 220Ω Resistor
U1 PCF8574 package DIP16 [THT]; type PCF8574

Layout

This example schematic shows only 4 resistor and LED pairs, I used 8 pairs for testing

mbed and pcf8574

mbed and pcf8574

Code

This uses this Mbed library – https://os.mbed.com/users/simon/programs/PCF8574

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "PCF8574.h"
 
PCF8574 io(p9,p10,0x40);
 
int main()
{
    while(1) 
    {
        io.write(0x00);
        wait(0.5);
        io.write(0xFF);
        wait(0.5);
    }
 }

[/codesyntax]

Testing

You should the LED’s flashing on and off

Links

PCF8574 IO Expansion Board I/O Expander I2C-Bus Development board

0 comment
0 FacebookTwitterPinterestEmail
MBed

TSL2561 sensor and LPC1768 example

by shedboy71
written by shedboy71

The TSL2561 is a light-to-digital converter that transforms light intensity to a digital signal output capable of an I²C interface. Each device combines one broadband photodiode (visible plus infrared) and one infrared-responding photodiode on a single CMOS integrated circuit capable of providing a near-photopic response over an effective 20-bit dynamic range (16-bit resolution).

Two integrating ADCs convert the photodiode currents to a digital output that represents the irradiance measured on each channel. This digital output can be input to a microprocessor where illuminance (ambient light level) in lux is derived using an empirical formula to approximate the human eye response. The TSL2561 device supports a traditional level style interrupt that remains asserted until the firmware clears it.

Parts List

Label Part Type
MBED1 mbed LPC1768
Part2 Adafruit TSL2561

Layout

 

mbed and TSL2561

mbed and TSL2561

Code

The following example uses the MBed online compiler and is imported from https://os.mbed.com/components/Grove-Digital-Light-Sensor/

[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.setGain(TSL2561_GAIN_16X);      // set 16x gain (for dim situations)
  
  // Changing the integration time gives you a longer time over which to sense tsl2561
  // longer timelines are slower, but are good in very low tsl2561 situtations!
  //tsl2561.setTiming(TSL2561_INTEGRATIONTIME_13MS);  // shortest integration time (bright tsl2561)
  //tsl2561.setTiming(TSL2561_INTEGRATIONTIME_101MS);  // medium integration time (medium tsl2561)
  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) {      
    
       
        // Simple data read example. Just read the infrared, fullspecrtrum diode 
        // or 'visible' (difference between the two) channels.
        // This can take 13-402 milliseconds! Uncomment whichever of the following you want to read
        
        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();
        
        //More advanced data read example. Read 32 bits with top 16 bits IR, bottom 16 bits full spectrum
        //That way you can do whatever math and comparisons you want!
         // uint32_t lum = tsl2561.getFullLuminosity();
       // uint16_t ir, full;
      //  ir = lum >> 16;
      //  full = lum & 0xFFFF;
  
     //   PC_PRINTLNXY(1,"Visible: %d",full - ir);
     //   PC_PRINTLNXY(1,"Full Spectrum: %d",full);
     //   PC_PRINTLNXY(1,"Infrared: %d",ir);  
  
    //    wait(1);
     PC_PRINTLNX(1,"----------COMPLETE-------------");
    }
}

[/codesyntax]

Testing

Using a terminal program such as Teraterm you should see something like

Visible: 372
Full Spectrum: 1764
Infrared: 2116
Execution Time: 1.213755
———-COMPLETE————-
Visible: 3818
Full Spectrum: 9853
Infrared: 2750
Execution Time: 1.213749
———-COMPLETE————-
Visible: 38
Full Spectrum: 221
Infrared: 164
Execution Time: 1.213792
———-COMPLETE————-
Visible: 46
Full Spectrum: 212
Infrared: 165
Execution Time: 1.213857
———-COMPLETE————-

Links

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

0 comment
0 FacebookTwitterPinterestEmail
MBed

ADXL345 accelerometer and LPC1768 example

by shedboy71
written by shedboy71

The ADXL345 is a small, thin, low power, 3-axis accelerometer with high resolution (13-bit) measurement at up to ±16g. Digital output data is formatted as 16-bit twos complement and is accessible through either a SPI (3- or 4-wire) or I2C digital interface.

The ADXL345 is well suited for mobile device applications. It measures the static acceleration of gravity in tilt-sensing applications, as well as dynamic acceleration resulting from motion or shock. Its high resolution (4 mg/LSB) enables measurement of inclination changes less than 1.0°.

Several special sensing functions are provided. Activity and inactivity sensing detect the presence or lack of motion and if the acceleration on any axis exceeds a user-set level. Tap sensing detects single and double taps. Free-fall sensing detects if the device is falling. These functions can be mapped to one of two interrupt output pins. An integrated, patent pending 32-level first in, first out (FIFO) buffer can be used to store data to minimize host processor intervention.

Features

  • Ultralow power: as low as 23 μA in measurement mode and 0.1 μA in standby mode at VS = 2.5 V (typical)
  • Power consumption scales automatically with bandwidth
  • User-selectable resolution
    • Fixed 10-bit resolution
    • Full resolution, where resolution increases with g range, up to 13-bit resolution at ±16 g (maintaining 4 mg/LSB scale factor in all g ranges)

Parts List

Label Part Type
MBED1 mbed LPC 1768
Part1 Adafruit ADXL345

Layout

 

mbed and ADXL345

mbed and ADXL345

Code

You will need to import the library from https://os.mbed.com/components/ADXL345-Accelerometer/ and I used the I2C example as well, which you can see below

[codesyntax lang=”cpp”]

#include "ADXL345_I2C.h"

 ADXL345_I2C accelerometer(p28, p27);
 Serial pc(USBTX, USBRX);

 int main() 
 {
       pc.baud(115200);
     int readings[3] = {0, 0, 0};
     
     pc.printf("Starting ADXL345 test...\n");
     wait(.001);
     pc.printf("Device ID is: 0x%02x\n", accelerometer.getDeviceID());
     wait(.001);
    
     // These are here to test whether any of the initialization fails. It will print the failure
    if (accelerometer.setPowerControl(0x00))
    {
         pc.printf("didn't intitialize power control\n"); 
         return 0;  
    }
     //Full resolution, +/-16g, 4mg/LSB.
     wait(.001);
     
     if(accelerometer.setDataFormatControl(0x0B))
     {
        pc.printf("didn't set data format\n");
        return 0;  
     }
     wait(.001);
     
     //3.2kHz data rate.
     if(accelerometer.setDataRate(ADXL345_3200HZ))
     {
        pc.printf("didn't set data rate\n");
        return 0;    
     }
     wait(.001);
     
     //Measurement mode.
     
     if(accelerometer.setPowerControl(MeasurementMode)) 
     {
        pc.printf("didn't set the power control to measurement\n"); 
        return 0;   
     } 
 
     while (1) 
     {
        wait(0.5);
        accelerometer.getOutput(readings);
        pc.printf("%i, %i, %i\r\n", (int16_t)readings[0], (int16_t)readings[1], (int16_t)readings[2]);
     }
 
 }

[/codesyntax]

Testing

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

-320, 226, 164
-254, -8, 94
-12, -168, -70
-172, -210, 60
-76, -38, -162
-198, 322, 130
-42, -254, -8
-126, 228, 0
-140, 70, -92
-342, 66, 46
-122, 156, 158
-78, 148, 204

Links

GY-291 ADXL345 3-Axis Digital Gravity Sensor Acceleration Module IIC/SPI transmission

0 comment
0 FacebookTwitterPinterestEmail
MBed

MMA7660 accelerometer and Mbed LPC1768 examp

by shedboy71
written by shedboy71

The MMA7660FC is a digital output I²C, very low-power, low-profile capacitive micro-machined accelerometer featuring a low pass filter, compensation for zero-g offset and gain errors and conversion to six-bit digital values at a user configurable output data rate. The device can be used for sensor data changes, product orientation and gesture detection through an interrupt pin (INT). The device is housed in an extremely small 3 mm x 3 mm x 0.9 mm DFN package.

Features

Digital output I²C
3 mm x 3 mm x 0.9 mm DFN package
Low-power current consumption
Off mode: 0.4 µA
Standby mode: 2 µA
Active mode: Configurable down to 47 µA
Low-voltage operation: 2.4 – 3.6-volts
3-axis ±1.5 g MEMS sensor and CMOS interface controller built into one package
Configurable output data rate from one to 120 samples a second
Auto wake/sleep feature for low-power consumption
Tilt orientation detection for portrait/landscape capability
Gesture detection including shake and pulse detection

Layout

MMA7660 module MBed LPC1768
Vcc Vout
Gnd Gnd
SCL Pin 10
SDA Pin 9

Code

More details at https://os.mbed.com/components/MMA7660/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "MMA7660.h"

MMA7660 MMA(p28, p27);

DigitalOut connectionLed(LED1);
PwmOut Zaxis_p(LED2);
PwmOut Zaxis_n(LED3);

int main() {  
    if (MMA.testConnection())
        connectionLed = 1;
        
    while(1) {
        Zaxis_p = MMA.z();
        Zaxis_n = -MMA.z();
    }

}

[/codesyntax]

Testing

Move the sensor and the LED 2 and LED 3 should light on and off

Links

1PCS NEW MMA7660 Replace MMA7260 3 Axis Triaxial accelerometer sensor module

0 comment
0 FacebookTwitterPinterestEmail
MBed

MCP4725 and MBed LPC1768 example

by shedboy71
written by shedboy71

In this example we will connect an MCP4725 Digital-to-Analog Converter to a MBed LPC1768

MCP4725 is a single channel, 12-bit, voltage output Digital-to-Analog Converter with integrated EEPROM and an I2C Compatible Serial Interface.

The MCP4725 DAC offers integrated non-volatile memory (EEPROM) which allows DAC register and configuration bit values to be saves at powered off. The VREF pin or the device VDD can be selected as the DAC’s reference voltage. Power-Down modes enable system current reduction when the DAC output voltage is not required. These devices are available in small 6-pin SOT-23 packages.

Features

12-Bit Resolution
On-Board Non-Volatile Memory (EEPROM)
±0.2 LSB DNL (typ)
External A0 Address Pin
Normal or Power-Down Mode
Fast Settling Time of 6µs (typ)
External Voltage Reference (VDD)
Low Power Consumption
Single-Supply Operation: 2.7V to 5.5V
Standard (100 kbps), Fast (400 kbps) and High Speed (3.4 Mbps) Modes
Extended Temperature Range: -40°C to +125°C

Parts List

Label Part Type
MBED1 mbed
Part1 Adafruit MCP4725 Breakout Board – 12-Bit DAC

Layout

 

Code

This example uses the MBed compiler, you will need to imprt the library and example from https://os.mbed.com/components/MCP4725-12-Bit-Digital-to-Analog-Convert/

[codesyntax lang=”cpp”]

#include <stdbool.h>
#include "mbed.h"
#include "mcp4725.h"

/**
 * A test suite for the MCP4725 DAC Library. This Test Application requires the following:
 *  * An MCP4725 connected to the IC2 bus of the mbed LPC1768.
 *  * The analog out of the MCP1768 connected to Pin15 (analog in) of the mbed LPC1768.
 *  * An optional LED & resistor connected to analog output for visual feedback of the running tests.
 *
 * This application tests the MCP4725 library's setting of the MCP4725's internal registers (inclusing eeprom storage), 
 * it's analog output and power modes.
 *
 */

Serial pc(USBTX, USBRX);
AnalogIn analogIn(p15);

void test_mcp4725_library(PinName sda, PinName scl, MCP4725::BusFrequency bus_frequency, int device_address_bits, char* testName);
int  test_init(MCP4725* interface, char* testName);
int  test_simple_read_write_no_eeprom(MCP4725* interface, enum MCP4725::PowerMode mode, float output_voltage);
int  test_simple_read_write_with_eeprom(MCP4725* interface, enum MCP4725::PowerMode mode, float output_voltage);
int  test_eeprom_write_status(MCP4725* interface);

int main()
{
    pc.printf("Application for testing the MCP4725 interface library\r\n");
    
    test_mcp4725_library(p9, p10, MCP4725::Standard100kHz,  0, "p9, p10, MCP4725::Standard100kHz");
    test_mcp4725_library(p9, p10, MCP4725::Fast400kHz,      0, "p9, p10, MCP4725::Fast400kHz");
    test_mcp4725_library(p9, p10, MCP4725::HighSpeed3_4Mhz, 0, "p9, p10, MCP4725::HighSpeed3_4Mhz");

}



/** Run a set of simple tests on the mcp4725 driver.
     * 
     * @param sda I2C data line pin
     * @param scl I2C clock line pin
     * @param bus_frequency the frequency at which the I2C bus is running.
     * @param device_address_bits The 3bit address bits of the device.
     */
void test_mcp4725_library(PinName sda, PinName scl, MCP4725::BusFrequency bus_frequency, int device_address_bits, char* testName)
{
    //Create our instance of the interface for test
    MCP4725 mcp4725_interface(sda, scl, bus_frequency, device_address_bits);
    
    if(test_init(&mcp4725_interface, testName) == 0)
    {
        test_simple_read_write_no_eeprom(&mcp4725_interface, MCP4725::Normal, 3.0);
        test_simple_read_write_no_eeprom(&mcp4725_interface, MCP4725::PowerDown1k, 1.3);
        test_simple_read_write_no_eeprom(&mcp4725_interface, MCP4725::PowerDown100k, 1.8);
        test_simple_read_write_no_eeprom(&mcp4725_interface, MCP4725::PowerDown500k, 0.5);
        test_simple_read_write_no_eeprom(&mcp4725_interface, MCP4725::Normal, 2.5);
        
        test_simple_read_write_with_eeprom(&mcp4725_interface, MCP4725::Normal, 3.0);
        test_simple_read_write_with_eeprom(&mcp4725_interface, MCP4725::PowerDown1k, 1.3);
        test_simple_read_write_with_eeprom(&mcp4725_interface, MCP4725::PowerDown100k, 1.8);
        test_simple_read_write_with_eeprom(&mcp4725_interface, MCP4725::PowerDown500k, 0.5);
        test_simple_read_write_with_eeprom(&mcp4725_interface, MCP4725::Normal, 2.5);
        
        test_eeprom_write_status(&mcp4725_interface);
    }
    
    
}

/** Initialise the device registers & eeprom. */
int test_init(MCP4725* interface, char* testName)
{
    int result;
    pc.printf("Initialising test '%s': ", testName);
    
    //Prime the device, including its eeprom.
    result = interface->write(MCP4725::Normal, 0, true);
    if(result == 0)
    {
        wait(0.5);
        pc.printf("OK\r\n");
    }
    else
    {
        pc.printf("FAILED: %d\r\n", result);
    }
    
    return result;
}

/* Run a simple read/write test that does not write to eeprom. */
int test_simple_read_write_no_eeprom(MCP4725* interface, enum MCP4725::PowerMode mode, float output_voltage)
{
    enum MCP4725::PowerMode read_mode;
    enum MCP4725::PowerMode read_mode_eeprom;//, write_mode_eeprom;
    int  read_dac_value;
    int  read_dac_value_eeprom;//, write_dac_value_eeprom;
    bool read_eeprom_write_in_progress;
    
    int dac_value = (int) (0xFFF * (output_voltage/3.3) );
    
    pc.printf("\tRead/write test without write to eeprom: ");
    
    interface->write(mode, dac_value, false);
    interface->read(&read_mode, &read_mode_eeprom, &read_dac_value, &read_dac_value_eeprom, &read_eeprom_write_in_progress);
    if( (mode != read_mode) || (dac_value != read_dac_value) || (read_eeprom_write_in_progress == true) || (read_dac_value == read_dac_value_eeprom) )
    {
        pc.printf("Failed - mode=%d, read_mode=%d, dac_value=%d, read_dac_value=%d, eeprom_write_state:%d\r\n", (int)mode, (int)read_mode, dac_value, read_dac_value, read_eeprom_write_in_progress);
        return 1;
    }
    else
    {
        // We need to wait a short period for the output to stabalise.
        wait(0.2);
        
        /* We check at mV resolution. 
         * Resolution of 12bit DAC is 0.8mV
         * Resolution of 16bit ADC is 0.05mV
         */
        int read_value_mv = (analogIn.read() * 3.3) * 100;
        int set_value_mv = ((int)(output_voltage*100));
        
        if( (mode == MCP4725::Normal) && (read_value_mv !=  set_value_mv) )
        {
            pc.printf("Failed: set_value=%dmV, read_value=%dmV\r\n", read_value_mv, set_value_mv);
            return 1;
        }
        else if ( (mode != MCP4725::Normal) && (read_value_mv != 0) )
        {
            pc.printf("Failed: read_value=%dmV, but DAC in PowerDown!\r\n", read_value_mv);
            return 1;
        }
        else
        {
            pc.printf("Passed\r\n");
            return 0;
        }
    }
}


/* Run a simple read/write test that does write to eeprom. */
int test_simple_read_write_with_eeprom(MCP4725* interface, enum MCP4725::PowerMode mode, float output_voltage)
{
    enum MCP4725::PowerMode read_mode;
    enum MCP4725::PowerMode read_mode_eeprom;//, write_mode_eeprom;
    int  read_dac_value;
    int  read_dac_value_eeprom;//, write_dac_value_eeprom;
    bool read_eeprom_write_in_progress;
    int dac_value = (int) (0xFFF * (output_voltage/3.3) );
    
    pc.printf("\tRead/write test with write to eeprom: ");
    
    interface->write(mode, dac_value, true);
    
    wait(0.5); //Wait a short period for the eeprom write to complete.
    interface->read(&read_mode, &read_mode_eeprom, &read_dac_value, &read_dac_value_eeprom, &read_eeprom_write_in_progress);
    
    if( (mode != read_mode) || (dac_value != read_dac_value) || (read_eeprom_write_in_progress == true) || (read_dac_value != read_dac_value_eeprom) || (read_mode != read_mode_eeprom) )
    {
        pc.printf("Failed - mode=%d, read_mode=%d, dac_value=%d, read_dac_value=%d, eeprom_write_state:%d\r\n", (int)mode, (int)read_mode, dac_value, read_dac_value, read_eeprom_write_in_progress);
        return 1;
    }
    else
    {
        pc.printf("Passed\r\n");
        return 0;
    }
}

/** Test to see if the eeprom write status bit is reported correctly. */
int test_eeprom_write_status(MCP4725* interface)
{
    enum MCP4725::PowerMode read_mode;
    enum MCP4725::PowerMode read_mode_eeprom;//, write_mode_eeprom;
    int  read_dac_value;
    int  read_dac_value_eeprom;//, write_dac_value_eeprom;
    bool read_eeprom_write_in_progress;
    
    pc.printf("\tTest eeprom write status: ");
    
    interface->write(MCP4725::Normal, 4095, true);
    
    //Immediately read the device
    interface->read(&read_mode, &read_mode_eeprom, &read_dac_value, &read_dac_value_eeprom, &read_eeprom_write_in_progress);
    
    if( read_eeprom_write_in_progress == false )
    {
        pc.printf("Failed - EEPROM Write not reported as in progress.\r\n");
        return 1;
    }
    else
    {
        wait(0.5); //Wait a short period for the eeprom write to complete.
        interface->read(&read_mode, &read_mode_eeprom, &read_dac_value, &read_dac_value_eeprom, &read_eeprom_write_in_progress);
        
        if( read_eeprom_write_in_progress == false )
        {
            pc.printf("Passed\r\n");
            return 0;
        }
        else
        {
            pc.printf("Failed - EEPROM Write reported as still in progress.\r\n");
            return 1;
        }
    }
}

[/codesyntax]

Testing

Using a terminal program such as TeraTerm you will see something like this

Application for testing the MCP4725 interface library
Initialising test ‘p9, p10, MCP4725::Standard100kHz’: OK
Read/write test without write to eeprom: Failed: set_value=298mV, read_value=300mV
Read/write test without write to eeprom: Passed
Read/write test without write to eeprom: Passed
Read/write test without write to eeprom: Failed: read_value=1mV, but DAC in PowerDown!
Read/write test without write to eeprom: Failed: set_value=249mV, read_value=250mV
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Test eeprom write status: Passed
Initialising test ‘p9, p10, MCP4725::Fast400kHz’: OK
Read/write test without write to eeprom: Failed: set_value=299mV, read_value=300mV
Read/write test without write to eeprom: Passed
Read/write test without write to eeprom: Passed
Read/write test without write to eeprom: Passed
Read/write test without write to eeprom: Failed: set_value=248mV, read_value=250mV
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Read/write test with write to eeprom: Passed
Test eeprom write status: Passed
Initialising test ‘p9, p10, MCP4725::HighSpeed3_4Mhz’: FAILED: 1

 

Links

MCP4725 I2C DAC Breakout Boards

0 comment
0 FacebookTwitterPinterestEmail
MBed

TCS34725 Color sensor and MBed 1768 example

by shedboy71
written by shedboy71

In this example we connect a TCS34725 Color sensor to an MBed 1768, lets look at some details about this sensor first

The TCS34725 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.

  • 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 allows for isolation of color content

 

Parts List

Label Part Type Properties
MBED1 mbed Mbed 1768
Part1 Adafruit TCS34725 RGB Color Sensor

Layout

mbed and TCS34725

mbed and TCS34725

 

 

Code

This example uses the https://os.mbed.com/components/Adafruit-TCS34725-RGB-Color-Sensor/

[codesyntax lang=”cpp”]

#include "mbed.h"

I2C i2c(p9, p10); //pins for I2C communication (SDA, SCL)
Serial pc(USBTX, USBRX);

int sensor_addr = 41 << 1;


int main() {
    pc.baud(9600);

    
    // Connect to the Color sensor and verify whether we connected to the correct sensor. 
    
    i2c.frequency(200000);
    
    char id_regval[1] = {146};
    char data[1] = {0};
    i2c.write(sensor_addr,id_regval,1, true);
    i2c.read(sensor_addr,data,1,false);
    

    
    // Initialize color sensor
    
    char timing_register[2] = {129,0};
    i2c.write(sensor_addr,timing_register,2,false);
    
    char control_register[2] = {143,0};
    i2c.write(sensor_addr,control_register,2,false);
    
    char enable_register[2] = {128,3};
    i2c.write(sensor_addr,enable_register,2,false);
    
    // Read data from color sensor (Clear/Red/Green/Blue)
    
    while (true) { 
        char clear_reg[1] = {148};
        char clear_data[2] = {0,0};
        i2c.write(sensor_addr,clear_reg,1, true);
        i2c.read(sensor_addr,clear_data,2, false);
        
        int clear_value = ((int)clear_data[1] << 8) | clear_data[0];
        
        char red_reg[1] = {150};
        char red_data[2] = {0,0};
        i2c.write(sensor_addr,red_reg,1, true);
        i2c.read(sensor_addr,red_data,2, false);
        
        int red_value = ((int)red_data[1] << 8) | red_data[0];
        
        char green_reg[1] = {152};
        char green_data[2] = {0,0};
        i2c.write(sensor_addr,green_reg,1, true);
        i2c.read(sensor_addr,green_data,2, false);
        
        int green_value = ((int)green_data[1] << 8) | green_data[0];
        
        char blue_reg[1] = {154};
        char blue_data[2] = {0,0};
        i2c.write(sensor_addr,blue_reg,1, true);
        i2c.read(sensor_addr,blue_data,2, false);
        
        int blue_value = ((int)blue_data[1] << 8) | blue_data[0];
        
        // print sensor readings
        
        pc.printf("Clear (%d), Red (%d), Green (%d), Blue (%d)\r\n", clear_value, red_value, green_value, blue_value);
        wait(0.5);
    }
    
}

[/codesyntax]

 

Testing

Using a terminal program such as TeraTerm you should see something like this

Clear (4248), Red (2551), Green (2133), Blue (1913)
Clear (3323), Red (1739), Green (1630), Blue (1458)
Clear (3323), Red (1739), Green (1630), Blue (1458)
Clear (4069), Red (3035), Green (2304), Blue (2184)
Clear (4124), Red (3078), Green (2338), Blue (2215)
Clear (4133), Red (3084), Green (2341), Blue (2218)
Clear (4235), Red (3128), Green (2390), Blue (2244)
Clear (5749), Red (2732), Green (2673), Blue (1664)
Clear (4989), Red (3010), Green (2574), Blue (2025)
Clear (4112), Red (3071), Green (2331), Blue (2210)
Clear (4112), Red (3071), Green (2331), Blue (2210)
Clear (2820), Red (2077), Green (1557), Blue (1474)
Clear (424), Red (275), Green (206), Blue (162)
Clear (409), Red (267), Green (202), Blue (160)
Clear (1167), Red (841), Green (634), Blue (578)
Clear (4342), Red (3158), Green (2387), Blue (2233)
Clear (6270), Red (3737), Green (3013), Blue (2516)
Clear (4007), Red (2979), Green (2250), Blue (2132)

Link

1PCS CJMCU-34725 TCS34725 Color Sensor RGB color sensor development board module

0 comment
0 FacebookTwitterPinterestEmail
MBed

LM75 temperature sensor and MBed 1768 example

by shedboy71
written by shedboy71

In this particular example we connect an LM75 temperature sensor to an MBed 1768

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.

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

mbed and lm75

mbed and lm75

Code

I used the following example for the MBed compiler – https://os.mbed.com/components/LM75B-Temperature-Sensor/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "LM75B.h"

//Create an LM75B object at the default address (ADDRESS_0)
LM75B sensor(p28, p27);

int main()
{
    //Try to open the LM75B
    if (sensor.open()) 
    {
        printf("Device detected!\n");

        while (1) 
        {
            //Print the current temperature
            printf("Temp = %.3f\r\n", (float)sensor);
            //Sleep for 0.5 seconds
            wait(0.5);
        }
    } 
    else 
    {
        error("Device not detected!\n");
    }
}

[/codesyntax]

Testing

using a terminal program such as TeraTerm and you should see something like this

Temp = 30.000
Temp = 29.750
Temp = 29.750
Temp = 29.625
Temp = 29.750
Temp = 29.875
Temp = 30.000
Temp = 30.125
Temp = 30.250
Temp = 30.000
Temp = 29.750
Temp = 29.750
Temp = 29.625

 

Links

LM75 CJMCU-75 temperature sensor high speed I2C interface high precision development board module

0 comment
0 FacebookTwitterPinterestEmail
MBed

MBed 1768 and MLX90614 infrared thermometer example

by shedboy71
written by shedboy71

In this example we will connect an MLX90614 thermometer to an MBed 1768

The MLX90614 is an infrared thermometer for non-contact temperature measurements. Both the IR sensitive thermopile detector chip and the signal conditioning ASIC are integrated in the same TO-39 can. Integrated into the MLX90614 are a low noise amplifier, 17-bit ADC and powerful DSP unit thus achieving high accuracy and resolution of the thermometer.

The 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 user can configure the digital output to be pulse width modulation (PWM). As a standard, the 10-bit PWM is configured to continuously transmit the measured temperature in range of -20 to 120°C, with an output resolution of 0.14°C.

 

Parts List

Label Part Type
MBED1 mbed
U1 MLX90614

Layout

mbed and mlx90614

mbed and mlx90614

Code

We used the online compiler and imported the following into it

https://os.mbed.com/components/MLX90614-I2C-Infrared-Thermometer/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "mlx90614.h"

DigitalOut myled(LED1); //displays I2C wait
I2C i2c(p28,p27);   //sda,scl
Serial pc(USBTX,USBRX);  //serial usb config

MLX90614 IR_thermometer(&i2c);
//setup an MLX90614 using MLX90614 library from
// http://mbed.org/users/aquahika/libraries/MLX90614/lsixz6

float temp; //temperature in degrees C

int main() {
    while (1) {
        myled=1; // if led1 on - waiting on I2C
        if (IR_thermometer.getTemp(&temp)) {
            //gets temperature from sensor via I2C bus
            myled=0;
            //print temperature on PC
            printf("Temperature is %5.1F degrees C\r\n",temp);
        }
        //wait for device to produce next temperature reading
        wait(0.5);
    }
}

[/codesyntax]

Testing

using a terminal program such as TeraTerm you should see something like this

Temperature is 26.4 degrees C
Temperature is 27.0 degrees C
Temperature is 27.0 degrees C
Temperature is 26.9 degrees C
Temperature is 27.0 degrees C
Temperature is 26.9 degrees C
Temperature is 26.8 degrees C
Temperature is 26.8 degrees C

 

Links

MLX90614 non-contact infrared temperature sensor module iic Interface GY-906

datasheet

0 comment
0 FacebookTwitterPinterestEmail
MBed

SHT15 digital humidity sensor and MBed example

by shedboy71
written by shedboy71

In this example we will connect a SHT15 sensor to an MBED 1768, in this example we will be using the MBed online compiler

The SHT1x digital humidity sensor is a reflow solderable sensor. The SHT1x series consists of a low-cost version with the SHT10 humidity sensor, a standard version with the SHT11 humidity sensor, and a high-end version with the SHT15 humidity sensor. As with every other Sensirion sensor type from the SHTxx humidity sensor family, they are fully calibrated and provide a digital output.

The SHT1x humidity sensor series (including SHT10, SHT11, and SHT15) is Sensirion’s family of surface-mountable relative humidity sensors. The humidity sensors integrate sensor elements plus signal processing on a tiny footprint and provide a fully calibrated digital output. A unique capacitive sensor element is used for measuring relative humidity, while temperature is measured by a band-gap sensor. Its CMOSens® technologyguarantees excellent reliability and long-term stability. The humidity sensors are seamlessly coupled to a 14-bit-analog-to-digital converter and a serial interface circuit. This results in superior signal quality, a fast response time, and insensitivity to external disturbances (EMC).

Each SHT1x humidity sensor is individually calibrated in a precision humidity chamber. The calibration coefficients are programmed into an OTP memory on the chip. These coefficients are used to internally calibrate the signals from the sensors. The two-wire serial interface and internal voltage regulation allows for easy and fast system integration.

Parts List

Label Part Type Properties
MBED1 mbed MBED 1768
Part1 SHT1x-Breakout CJMCU

Layout

mbed and sht15

mbed and sht15

Code

https://os.mbed.com/components/SHT15-temperature-and-humidity/

[codesyntax lang=”cpp”]

#include "mbed.h"
#include "SHTx/sht15.hpp"

Serial pc(USBTX, USBRX);
DigitalOut busy(LED1);

// I used p9 and p10 here  but you
SHTx::SHT15 sensor(p9, p10);

int
main() 
{
    // Speed things up a bit.
    sensor.setOTPReload(false);
    sensor.setResolution(true);
    
    while(1) 
    {
        busy = true;
        sensor.update();
        busy = false;
        
        // Temperature in celcius
        sensor.setScale(false);
        pc.printf("Temperature - %3.2f C\r\n", sensor.getTemperature());
      
        // Relative Humidity
        pc.printf("Humdity - %3.2f %%\r\n\n", sensor.getHumidity());
        
        wait(5);
    }
}

[/codesyntax]

Testing

Using a terminal program such as TeraTerm you should see readings like the following

Temperature – 26.06 C
Humdity – 34.90 %
Temperature – 25.94 C
Humdity – 34.78 %
Temperature – 25.90 C
Humdity – 35.28 %
Temperature – 25.82 C
Humdity – 35.20 %
Temperature – 25.70 C
Humdity – 35.61 %
Temperature – 25.62 C
Humdity – 35.53 %
Temperature – 27.54 C
Humdity – 41.73 %
Temperature – 30.26 C
Humdity – 56.96 %

 

Links

Temperature and humidity sensor interface board floor board adapter PCB SHT10 SHT11 SHT15 B board

New and original SENSIRION Digital Humidity Sensor (SHT15)

0 comment
0 FacebookTwitterPinterestEmail