Home Author
Author

shedboy71

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
MSP

MSP430FR4133 launchpad blinking LED example

by shedboy71
written by shedboy71

In this example we will take a look at the MSP430FR4133 launchpad from Texas Instruments. There will be a blinky LED example which was written in Code Composer studio.

Lets look at the MSP430Fr133 launchpad first

The MSP-EXP430FR4133 LaunchPad development kit contains everything needed to start developing on the MSP430 Ultra-low-power FRAM-based microcontroller platform, including on-board emulation for programming, debugging and energy measurements. The board features on-board buttons and LEDs for quick integration of a simple user interface as well as a Liquid Crystal Display which showcases the integrated driver with flexible software-configurable pins. The MSP430FR4133 device features LCD support with an integrated 10-bit ADC as well as embedded FRAM, a non-volatile memory known for its ultra-low power, high endurance and high speed write access.

Features

MSP430 ULP MSP430FR4133 MCU 16KB FRAM
16-bit RISC architecture up to 8-MHz FRAM access/ 16-MHz system clock speed
3 x timer blocks
10 channel 10-bit ADC
8 x 32 segment LCD driver with integrated charge pump and configurable pins
EnergyTrace™ technology available for ultra-low-power debugging
20 pin LaunchPad standard leveraging the BoosterPack ecosystem
Onboard eZ-FET emulation
2 buttons and 2 LEDs for user interaction
Low-power alphanumeric segmented LCD

 

Parts List

 

Name Link
MSP430FR4133 LaunchPad development board TI original spot MSP430FR4133 LaunchPad development board MSP-EXP430FR4133

Code

 

As stated this is a Code Composer studio example, so you will need to download that and create a new project. http://processors.wiki.ti.com/index.php/Download_CCS

In this example we will blink the LED on for 1 second and off for 1 second, here is how we will do this

The ACLK increments the peripheral around about every 25µs. Therefore, to count for 1 seconds, we would need to count like this:

1 second / 25µs = 40,000 times

The program counts to 40,000 while the red LED is on. Then, it turns off the red LED and counts to 40,000 one time before turning the red LED back on and repeating.

[codesyntax lang=”cpp”]

#include <msp430.h>

#define RED_LED 0x0001
#define DEVELOPMENT 0x5A80 // Stop the watchdog timer
#define ENABLE_PINS 0xFFFE // Required to use inputs and outputs
#define ACLK 0x0100 // Timer_A ACLK source
#define UP 0x0010
#define TAIFG 0x0001 // Timer A Interrupt flag

main()
{

 WDTCTL = DEVELOPMENT;
 PM5CTL0 = ENABLE_PINS;

 TA0CCR0 = 40000;
 TA0CTL = ACLK | UP;

 P1DIR = RED_LED; // Set red LED as an output
 P1OUT = RED_LED; // Turn red LED on

 while(1)
 {
     if(TA0CTL & TAIFG)
     {
         TA0CTL = TA0CTL & (~TAIFG);
         if (P1OUT & RED_LED) // If the red LED is on
         {
            P1OUT = 0x00;
         }
         else // Else, red LED is off
         {
             P1OUT = RED_LED; // Turn on the red LED
         }
     }
 }
}

[/codesyntax]

You could either change the TA0CCR0 value to change the delay or create a simple loop and say run this 5 times which would simulate a 5 seconds delay

0 comment
0 FacebookTwitterPinterestEmail
Particle Photon

Particle photon and Easy Module Shield examples

by shedboy71
written by shedboy71

On to another Arduino shield and this is one of my favourites, its a low cost shield which contains a variety of resources on it making it ideal for beginners. We will again connect this to a Particle Photon fitted to a Shield Shield for Spark Core and the examples will be written in the web online IDE

here is a picture of the shield

Features

You can see most of the features but here is a quick summary of what is fitted to the shield

two LEDs
two switches
reset button
Measuring temperature and humidity with DHT11 temperature and humidity sensor
Using revolving potentiometer to do analog input
passive buzzer module
Full-color RGB LED
Utilizing photovaristor to detect the brightness of light
LM35D temperature sensor
infrared receiver
2-channel digital port(D7.D8)
1-channel analog port(A3)

 

Code Examples

None of these examples need any external libraries,

Buzzer

[codesyntax lang=”cpp”]

/*
Arduino - Shield shield
5	        D1
*/


int speakerPin = D1;

// Notes defined in microseconds (Period/2) 
// from note C to B, Octaves 3 through 7
int notes[] = 
{0,
/* C,  C#,   D,  D#,   E,   F,  F#,   G,  G#,   A,  A#,   B */
3817,3597,3401,3205,3030,2857,2703,2551,2404,2273,2146,2024,   // 3 (1-12)
1908,1805,1701,1608,1515,1433,1351,1276,1205,1136,1073,1012,   // 4 (13-24)
 956, 903, 852, 804, 759, 716, 676, 638, 602, 568, 536, 506,   // 5 (25-37)
 478, 451, 426, 402, 379, 358, 338, 319, 301, 284, 268, 253,   // 6 (38-50)
 239, 226, 213, 201, 190, 179, 169, 159, 151, 142, 134, 127 }; // 7 (51-62)

#define NOTE_G3  2551
#define NOTE_G4  1276
#define NOTE_C5  956
#define NOTE_E5  759
#define NOTE_G5  638
#define RELEASE  20
#define BPM      100

// notes in the melody:
int melody[] = {NOTE_E5,NOTE_E5,0,NOTE_E5,0,NOTE_C5,NOTE_E5,0,NOTE_G5,0,0,NOTE_G4};

// note durations: 4 = quarter note, 2 = half note, etc.:
int noteDurations[] = {4,4,4,4,4,4,4,4,4,2,4,4};

void setup() {
  // iterate over the notes of the melody:
  for (int thisNote = 0; thisNote < 12; thisNote++) {

    // to calculate the note duration, take one second
    // divided by the note type.
    // e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 60*1000/BPM/noteDurations[thisNote];
    tone(speakerPin, (melody[thisNote]!=0)?(500000/melody[thisNote]):0,noteDuration-RELEASE);

    // blocking delay needed because tone() does not block
    delay(noteDuration);
  }
}

[/codesyntax]

 

LDR example

[codesyntax lang=”cpp”]

int ldrValue = 0;
char *message = "my name is particle";
String aString;

void setup()
{
  // variable name max length is 12 characters long
  Particle.variable("ldrValue", ldrValue);
  if (Particle.variable("mess", message)==false)
  {
      // variable not registered!
  }
  Particle.variable("mess2", aString);

  pinMode(A1, INPUT);
}

void loop()
{
  // Read the analog value of the sensor
  ldrValue = analogRead(A1);
  delay(200);
}

[/codesyntax]

 

LED example

[codesyntax lang=”cpp”]

/*
Arduino - Shield shield	
12	        A4	
13	        A3
*/

#define redLed A4
#define blueLed A3

void setup() 
{
  pinMode(redLed, OUTPUT);
  pinMode(blueLed, OUTPUT);
}
 
void loop() 
{
  digitalWrite(redLed, HIGH);   // turn the LED on (HIGH is the voltage level)
  digitalWrite(blueLed, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);
  digitalWrite(redLed, LOW);    // turn the LED off by making the voltage LOW
  digitalWrite(blueLed, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);
}

[/codesyntax]

 

POT example

[codesyntax lang=”cpp”]

int vrValue = 0;
char *message = "my name is particle";
String aString;

void setup()
{
  // variable name max length is 12 characters long
  Particle.variable("vrValue", vrValue);
  if (Particle.variable("mess", message)==false)
  {
      // variable not registered!
  }
  Particle.variable("mess2", aString);

  pinMode(A0, INPUT);
}

void loop()
{
  // Read the analog value of the sensor
  vrValue = analogRead(A0);
  delay(200);
}

[/codesyntax]

 

RGB led example

[codesyntax lang=”cpp”]

/*
Arduino - Shield shield
9	        D6	 
10      	A2	
11	        A5	
*/

#define redLed D6
#define greenLed A2
#define blueLed A5

void setup()
{

  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  pinMode(blueLed, OUTPUT);  
}
 
void loop()
{
  //red on
  digitalWrite(redLed, HIGH);
  digitalWrite(greenLed, LOW);
  digitalWrite(blueLed, LOW);
  delay(1000);
  //green on
  digitalWrite(redLed, LOW);
  digitalWrite(greenLed, HIGH);
  digitalWrite(blueLed, LOW);
  delay(1000);
  //blue on
  digitalWrite(redLed, LOW);
  digitalWrite(greenLed, LOW);
  digitalWrite(blueLed, HIGH);
  delay(1000);
}

[/codesyntax]

 

Links

$10 for one of these shields

keyestudio Multi-purpose Shield V1 for arduino starter

0 comment
0 FacebookTwitterPinterestEmail
Particle Photon

Particle photon flashing LEDs example

by shedboy71
written by shedboy71

In this example we will connect 6 LEDs to a Shield Shield for Spark Core and flash them on and off

The Photon is a tiny Wi-Fi development kit for creating connected projects and products for the Internet of Things. It’s easy to use, powerful and connected to the Cloud. The tools that make up the Photon’s ecosystem are designed to let you build and create whether you’re an embedded engineer, web developer, Arduino enthusiast or IoT entrepreneur.

You’ll be able to write your firmware in our web or local IDE, deploy it over the air and build your web and mobile apps with ParticleJS and our Mobile SDK. The board itself uses a Broadcom Wi-Fi chip alongside a powerful STM32 ARM Cortex M3 microcontroller. It’s like the Spark Core, but better.

 

 

The shield is an adaptor which will allow you to connect an Arduino shield to a Particle Photon

The shield uses Texas Instruments TXB0108PWR to do voltage conversion in between the Spark Core’s 3.3V logic level and the Arduino’s 5V logic.

Parts List

Part Link
Particle Core Photon Particle Core Photon WiFi Development Board BCM43362 STM32F205 ARM Cortex M3 for the Internet of Things IoT
Shield Shield for Spark Core SPARK CORE ARDUINO SHIELD ADAPTOR Development Boards & Evaluation Kits
LED Test board Link to test board

Connection

The shield shield does not map one to one to the Arduino connections, the LED test board we use will use Arduino pins 8 to 13.

Arduino pin Spark Core pin
0 RX
1 TX
2 D2
3 D0
4 D3
5 D1
6 A7
7 D4
8 D5
9 D6
10 A2
11 A5
12 A4
13 A3
A0 A0
A1 A1
A2 A6

 

Code

The code is written in the https://build.particle.io – the code will be very familiar for people who use the Arduino IDE, you can also flash your device using the IDE

[codesyntax lang=”cpp”]

/*
Arduino - Shield shield
8	        D5	 
9	        D6	 
10      	A2	
11	        A5	
12	        A4	
13	        A3
*/
int led1 = D5; 
int led2 = D6; 
int led3 = A2; 
int led4 = A5; 
int led5 = A4; 
int led6 = A3; 

void setup() {

  // We are going to tell our device that D0 and D7 
  // It's important you do this here, inside the setup() function rather than outside it or in the loop function.

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);
}

// Next we have the loop function, the other essential part of a microcontroller program.

void loop() {
  // To blink the LED, first we'll turn it on...
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  digitalWrite(led5, HIGH);
  digitalWrite(led6, HIGH);
  // We'll leave it on for 1 second...
  delay(1000);

  // Then we'll turn it off...
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  digitalWrite(led5, LOW);
  digitalWrite(led6, LOW);
  // Wait 1 second...
  delay(1000);

  // And repeat!
}

[/codesyntax]

 

Video

A video of the example above in action

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and TSL2561 Luminosity Sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an TSL2561 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

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

Device Pin STM32 Nucleo
GND GND
Vcc / 3.3 (or Vin on Adafruit modules) 3.3 or 5v
SCL D1
SDA D2
ADDR N/C
Int N/C

 

 

stm32 and TSL2561

stm32 and TSL2561

 

Code

We use the Adafruit TS2561 library – this is a cut down version of the default – https://github.com/adafruit/Adafruit_TSL2561

[codesyntax lang=”cpp”]

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

   
Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);


void configureSensor(void)
{
  tsl.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
}


void setup(void) 
{
  Serial.begin(9600);
  Serial.println("Light Sensor Test"); 
  Serial.println("");
  
  /* Initialise the sensor */
  if(!tsl.begin())
  {
    Serial.print("no TSL2561 detected!");
    while(1);
  }
  
  configureSensor();
  
}


void loop(void) 
{  
  /* Get a new sensor event */ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  /* Display the results (light is measured in lux) */
  if (event.light)
  {
    Serial.print(event.light); 
    Serial.println(" lux");
  }
  else
  {
    Serial.println("Sensor overload");
  }
  delay(500);
}

[/codesyntax]

Testing

Open the serial monitor window, mover the sensor to light sources, cover the sensor. you can see in the example below me moving to a bright light source and the value increasing

20.00 lux
22.00 lux
5.00 lux
27.00 lux
6.00 lux
38.00 lux
20.00 lux
17.00 lux
6.00 lux
19.00 lux

Links

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

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and TCS34725 Color Sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an TCS34725 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

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

Connection and Layout

This example is for a STM32 Nucleo connected to the module

stm32 and TCS34725

stm32 and TCS34725

 

Code

We will use the adafruit library – https://github.com/adafruit/Adafruit_TCS34725

This is one of the default example

[codesyntax lang=”cpp”]

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

/* Example code for the Adafruit TCS34725 breakout library */

/* Connect SCL to analog 5
Connect SDA to analog 4
Connect VDD to 3.3V DC
Connect GROUND to common ground */

/* 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, this is what you should see

Color Temp: 2110 K – Lux: 30 – R: 94 G: 57 B: 40 C: 158
Color Temp: 2110 K – Lux: 30 – R: 94 G: 57 B: 40 C: 158
Color Temp: 1908 K – Lux: 421 – R: 1111 G: 657 B: 348 C: 2096
Color Temp: 1909 K – Lux: 3238 – R: 7594 G: 4566 B: 2054 C: 14420
Color Temp: 1990 K – Lux: 34 – R: 112 G: 66 B: 45 C: 194
Color Temp: 1952 K – Lux: 27 – R: 95 G: 55 B: 39 C: 160
Color Temp: 1833 K – Lux: 27 – R: 104 G: 58 B: 41 C: 172
Color Temp: 1776 K – Lux: 195 – R: 651 G: 359 B: 218 C: 1194
Color Temp: 1981 K – Lux: 280 – R: 761 G: 458 B: 267 C: 1458
Color Temp: 1870 K – Lux: 100 – R: 665 G: 287 B: 187 C: 1082
Color Temp: 1681 K – Lux: 141 – R: 777 G: 354 B: 225 C: 1299
Color Temp: 1621 K – Lux: 202 – R: 885 G: 434 B: 267 C: 1530
Color Temp: 1795 K – Lux: 25 – R: 100 G: 55 B: 39 C: 165

 

Links

TCS34725 RGB Light Color Sensor Recognition Module

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and MLX90393 magnetic field sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an MLX90393 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The MLX90393 magnetic field sensor can be reprogrammed to different modes and with different settings at run-time. The sensor offers a 16-bit output proportional to the magnetic flux density sensed along the XYZ axes using the Melexis proprietary Triaxis® technology and also offers a temperature output signal. These digital values are available via I2C and SPI, where the MLX90393 is a slave on the bus.

By selecting which axes are to be measured, the raw data can be used as input for further post-processing, such as for joystick applications, rotary knobs, and more complex 3D position sensing applications. Unparallelled performance is achieved with this sensor, which is primarily targeting industrial and consumer applications.

mlx90393 module

mlx90393 module

Connection

Module STM32 Nucleo
VDD 3v3
Gnd Gnd
SDA SDA – D14
SCL SCL – D15

Code

 

 

 

[codesyntax lang=”cpp”]

// Distributed with a free-will license.
// Use it any way you want, profit or free, provided it fits in the licenses of its associated works.
// MLX90393
// This code is designed to work with the MLX90393_I2CS I2C Mini Module available from ControlEverything.com.
// https://www.controleverything.com/products

#include<Wire.h>

// MLX90393 I2C Address is 0x0C(12)
#define Addr 0x0C

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 Write register command
Wire.write(0x60);
// Set AH = 0x00, BIST disabled
Wire.write(0x00);
// Set AL = 0x5C, Hall plate spinning rate = DEFAULT, GAIN_SEL = 5
Wire.write(0x5C);
// Select address register, (0x00 << 2)
Wire.write(0x00);
// Stop I2C Transmission
Wire.endTransmission();

// Request 1 byte of data
Wire.requestFrom(Addr, 1);

// Read status byte
if(Wire.available() == 1)
{
unsigned int c = Wire.read();
}

// Start I2C Transmission
Wire.beginTransmission(Addr);
// Select Write register command
Wire.write(0x60);
// Set AH = 0x02
Wire.write(0x02);
// Set AL = 0xB4, RES for magnetic measurement = 0
Wire.write(0xB4);
// Select address register, (0x02 << 2)
Wire.write(0x08);
// Stop I2C Transmission
Wire.endTransmission();

// Request 1 byte of data
Wire.requestFrom(Addr, 1);

// Read status byte
if(Wire.available() == 1)
{
unsigned int c = Wire.read();
}
delay(300);
}

void loop()
{
unsigned int data[7];

// Start I2C Transmission
Wire.beginTransmission(Addr);
// Start single meaurement mode, ZYX enabled
Wire.write(0x3E);
// Stop I2C Transmission
Wire.endTransmission();

// Request 1 byte of data
Wire.requestFrom(Addr, 1);

// Read status byte
if(Wire.available() == 1)
{
unsigned int c = Wire.read();
}
delay(100);

// Start I2C Transmission
Wire.beginTransmission(Addr);
// Send read measurement command, ZYX enabled
Wire.write(0x4E);
// Stop I2C Transmission
Wire.endTransmission();

// Request 7 bytes of data
Wire.requestFrom(Addr, 7);

// Read 7 bytes of data
// status, xMag msb, xMag lsb, yMag msb, yMag lsb, zMag msb, zMag lsb
if(Wire.available() == 7);
{
data[0] = Wire.read();
data[1] = Wire.read();
data[2] = Wire.read();
data[3] = Wire.read();
data[4] = Wire.read();
data[5] = Wire.read();
data[6] = Wire.read();
}

// Convert the data
int xMag = data[1] * 256 + data[2];
int yMag = data[3] * 256 + data[4];
int zMag = data[5] * 256 + data[6];

// Output data to serial monitor
Serial.print("Magnetic Field in X-Axis : ");
Serial.println(xMag);
Serial.print("Magnetic Field in Y-Axis : ");
Serial.println(yMag);
Serial.print("Magnetic Field in Z-Axis : ");
Serial.println(zMag);
delay(500);
}

[/codesyntax]

 

Output

Open the serial monitor and you should see something like this

Magnetic Field in X-Axis : 46
Magnetic Field in Y-Axis : 65379
Magnetic Field in Z-Axis : 23
Magnetic Field in X-Axis : 60
Magnetic Field in Y-Axis : 65483
Magnetic Field in Z-Axis : 65518
Magnetic Field in X-Axis : 49
Magnetic Field in Y-Axis : 65499
Magnetic Field in Z-Axis : 65514
Magnetic Field in X-Axis : 47
Magnetic Field in Y-Axis : 65501
Magnetic Field in Z-Axis : 65506
Magnetic Field in X-Axis : 45
Magnetic Field in Y-Axis : 65505
Magnetic Field in Z-Axis : 65503

Links

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

CJMCU-90393, MLX90393 digital 3D Holzer sensor, displacement, angle, rotation, 3D position

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and DS1624 temperature sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an DS1624 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The DS1624 consists of two separate functional units: a 256-byte nonvolatile E2 memory and a direct-to-digital temperature sensor.

The nonvolatile memory is made up of 256 bytes of E2 memory. This memory can be used to store any type of information the user wishes. These memory locations are accessed through the 2-wire serial bus.

The direct-to-digital temperature sensor allows the DS1624 to measure the ambient temperature and report the temperature in a 12-bit word with 0.0625°C resolution. The temperature sensor and its related registers are accessed through the 2-wire serial interface. Figure 1 in the full data sheet shows a block diagram of the DS1624.

Features

Reduces Component Count with Integrated Temperature Sensor and Nonvolatile E2 Memory
Measures Temperatures from -55°C to +125°C in 0.0625°C Increments
±0.5°C Accuracy from 0°C to 70°C
256 Bytes of E2 Memory for Storing Information Such as Frequency Compensation Coefficients
No External Components
Easy-to-Use 2-Wire Serial Interface
Temperature is Read as a 12-Bit Value (2-Byte Transfer)
Available in 8-Pin SO and DIP Packages

 

Connection

Module STm32 Nucleo
VDD 3v3
Gnd Gnd
SDA SDA -D14
SCL SCL – D15

 

Code

I downloaded and imported the following library – https://github.com/bluemurder/DS1624

This is the example so some of the hard graft has already been done for you
[codesyntax lang=”cpp”]

#include <DS1624.h>

// Sensor presents all address pins connected to ground
DS1624 ds1624(0x00);

void setup()
{ 
// Begin serial connection at 9600 baud
Serial.begin(9600);
}

void loop()
{
float temperature;
bool valid;

// Get current temperature
ds1624.GetTemperature(temperature, valid);

// Print it
Serial.println(temperature);

// Wait a while
delay(1000);
}

[/codesyntax]

Testing

Open the serial monitor and you should see the following

27.37
27.31
27.56
28.00
28.25
28.50
28.69

 

Link

https://datasheets.maximintegrated.com/en/ds/DS1624.pdf

CJMCU-1624 DS1624 temperature sensor, high precision digital thermometer with memory function

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and SHT31 temperature and humidity sensors Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an SHT31 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

SHT31 is the next generation of Sensirion’s temperature and humidity sensors. It builds on a new CMOSens® sensor chip that is at the heart of Sensirion’s new humidity and temperature platform.

The SHT3x-DIS has increased intelligence, reliability and improved accuracy specifications compared to its predecessor. Its functionality includes enhanced signal processing, two distinctive and user selectable I2C addresses and communication speeds of up to 1 MHz. The DFN package has a footprint of 2.5 x 2.5 mm2 while keeping a height of 0.9 mm.

This allows for integration of the SHT3x-DIS into a great variety of applications.

Features

Fully calibrated, linearized, and temperature compensated digital output
Wide supply voltage range, from 2.4 V to 5.5 V
I2C Interface with communication speeds up to 1 MHz and two user selectable addresses

sht31

 

Layout

 

stm32 and sht31

stm32 and sht31

Code

This example uses the adafruit sht31 library – https://github.com/adafruit/Adafruit_SHT31

[codesyntax lang=”cpp”]

#include <Arduino.h>
#include <Wire.h>
#include "Adafruit_SHT31.h"

Adafruit_SHT31 sht31 = Adafruit_SHT31();


void setup() 
{
  Serial.begin(9600);
  if (! sht31.begin(0x44)) 
  {
    Serial.println("Couldn't find SHT31");
    while (1) delay(1);
  }
}


void loop() 
{
  float t = sht31.readTemperature();
  float h = sht31.readHumidity();

  if (! isnan(t)) 
  {
    Serial.print("Temp *C = "); Serial.println(t);
  } 
  else 
  { 
    Serial.println("Failed to read temperature");
  }
  
  if (! isnan(h)) 
  {
    Serial.print("Hum. % = "); Serial.println(h);
  } 
  else 
  { 
    Serial.println("Failed to read humidity");
  }
  Serial.println();
  delay(1000);
}

[/codesyntax]

Output

Open the serial monitor and you will see something like this

Temp *C = 21.86
Hum. % = 65.23

Temp *C = 22.00
Hum. % = 69.66

Temp *C = 22.13
Hum. % = 72.73

Temp *C = 22.25
Hum. % = 74.86

Temp *C = 22.35
Hum. % = 75.87

Link

1PCS/LOT SHT31 Temperature & SHT31-D Humidity Sensor module Breakout Weather for Arduino

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and TMP175 digital temperature sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an TMP175 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The TMP75 and TMP175 devices are digital temperature sensors ideal for NTC and PTC thermistor replacement. The devices offer 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 devices are available in the industry standard LM75 SOIC-8 and MSOP-8 footprint.

The TMP175 and TMP75 feature SMBus, Two-Wire, and I2C interface compatibility. The TMP175 device allows up to 27 devices on one bus. The TMP75 allows up to eight 8 on one bus. The TMP175 and TMP75 both feature an SMBus Alert function.

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

Features

  • TMP175: 27 Addresses
  • TMP75: 8 Addresses, NIST Traceable
  • Digital Output: SMBus™, Two-Wire™, and I2C
    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 STM Nucleo 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 the serial monitor window

The temperature is 23.5625 degrees C
The temperature is 23.5625 degrees C
The temperature is 23.6250 degrees C
The temperature is 24.1875 degrees C
The temperature is 25.3750 degrees C
The temperature is 26.2500 degrees C
The temperature is 26.9375 degrees C
The temperature is 27.4375 degrees C
The temperature is 27.5000 degrees C
The temperature is 27.5000 degrees C
The temperature is 27.4375 degrees C

Link

1pcs CJMCU-175 TMP175 27 Address Digital Temperature Sensor

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and MCP9808 digital temperature sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an MCP9808 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The MCP9808 digital temperature sensor converts temperatures between -20°C and +100°C to a digital word with ±0.5°C (max.) accuracy. The MCP9808 comes with user-programmable registers that provide flexibility for temperature sensing applications. The registers allow user-selectable settings such as Shutdown or low-power modes and the specification of temperature Event and Critical output boundaries. When the temperature changes beyond the specified boundary limits, the MCP9808 outputs an Event signal.

The user has the option of setting the event output signal polarity as an active-low or active-high comparator output for thermostat operation, or as temperature event interrupt output for microprocessor-based systems. The event output can also be configured as a Critical temperature output.

This sensor has an industry standard 2-wire, SMBus and Standard I2C™Compatible compatible (100kHz/400kHz bus clock) serial interface, allowing up to eight sensors to be controlled in a single serial bus.

Features

Accuracy:
±0.25°C (typical) from -40°C to +125°C
±0.5°C (maximum) from -20°C to +100°C

User Selectable Measurement Resolution:
0.5°C, 0.25°C, 0.125°C, 0.0625°C

User Programmable Temperature Limits:
Temperature Window Limit
Critical Temperature Limit

User Programmable Temperature Alert Output
Operating Voltage Range: 2.7V to 5.5V

More details about the sensor at http://www.microchip.com/wwwproducts/en/MCP9808

 

Connection

stm32 and mcp9808

stm32 and mcp9808

Code

You will need the adafruit MCP9808 library which is available at https://github.com/adafruit/Adafruit_MCP9808_Library/archive/master.zip

[codesyntax lang=”cpp”]

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

// Create the MCP9808 temperature sensor object
Adafruit_MCP9808 tempsensor = Adafruit_MCP9808();

void setup() {
  Serial.begin(9600);
  
  if (!tempsensor.begin()) 
  {
    Serial.println("Couldn't find MCP9808!");
    while (1);
  }
}

void loop() {
  // Read and print out the temperature, then convert to *F
  float c = tempsensor.readTempC();
  float f = c * 9.0 / 5.0 + 32;
  Serial.print("Temp: "); 
  Serial.print(c); 
  Serial.print(" C\t"); 
  Serial.print(f); 
  Serial.println(" F");
  delay(250);
  
  tempsensor.shutdown_wake(1);
  delay(2000);
  tempsensor.shutdown_wake(0);
  
   
}

[/codesyntax]

 

Results

Open the serial monitor and you should see something like this

Temp: 24.94 C 76.89 F
Temp: 27.50 C 81.50 F
Temp: 28.25 C 82.85 F
Temp: 27.44 C 81.39 F
Temp: 26.75 C 80.15 F
Temp: 26.50 C 79.70 F
Temp: 26.25 C 79.25 F
Temp: 26.06 C 78.91 F
Temp: 25.94 C 78.69 F
Temp: 25.75 C 78.35 F

Links

Adafruit MCP9808 High Accuracy I2C Temperature Sensor Breakout Board [ADA1782]

0 comment
0 FacebookTwitterPinterestEmail
STM32

STM32 Nucleo and HDC1008 sensor Arduino example

by shedboy71
written by shedboy71

OK we are now going to look at an HDC1008 attached to the STM32 Nucleo and all development will be done on the Arduino IDE – Install STM32 support in the Arduino IDE

The HDC1008 is a digital humidity sensor with integrated temperature sensor that provides excellent measurement accuracy at very low power. The device measures humidity based on a novel capacitive sensor. The humidity and temperature sensors are factory calibrated.

The sensing element of the HDC1008 is placed on the bottom part of the device, which makes the HDC1000 more robust against dirt, dust, and other environmental contaminants. The HDC1000 is functional within the full –40°C to +125°C temperature range.

Key Features

  • Relative Humidity (RH) Operating Range 0% to 100%
  • 14 Bit Measurement Resolution
  • Relative Humidity Accuracy ±3%
  • Temperature Accuracy ±0.2°C
  • Supply Voltage 3 V to 5 V
  • I2C Interface

Connection

Code

[codesyntax lang=”python”]

#include<Wire.h>

// HDC1008 I2C address is 0x40(64)
#define hdcAddr 0x40

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

  // Starts I2C communication
  Wire.beginTransmission(hdcAddr);
  // Select configuration register
  Wire.write(0x02);
  // Temperature, humidity enabled, resolultion = 14-bits, heater on
  Wire.write(0x30);
  // Stop I2C Transmission
  Wire.endTransmission();
  delay(300);
}

void loop()
{
  unsigned int data[2];

  Wire.beginTransmission(hdcAddr);
  // Send temp measurement command
  Wire.write(0x00);
  Wire.endTransmission();
  delay(500);

  // Request 2 bytes of data
  Wire.requestFrom(hdcAddr, 2);

  // Read 2 bytes of data for temperature
  if (Wire.available() == 2)
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
  }

  int temp = (data[0] * 256) + data[1];
  float celsTemp = (temp / 65536.0) * 165.0 - 40;
  float fahrTemp = celsTemp * 1.8 + 32;


  Wire.beginTransmission(hdcAddr);
  // Send humidity measurement command
  Wire.write(0x01);
  Wire.endTransmission();
  delay(500);

  // Request 2 bytes of data
  Wire.requestFrom(hdcAddr, 2);
  // Read 2 bytes of data to get humidity
  if (Wire.available() == 2)
  {
    data[0] = Wire.read();
    data[1] = Wire.read();
  }

  // Convert the data
  float humidity = (data[0] * 256) + data[1];
  humidity = (humidity / 65536.0) * 100.0;

  Serial.print("Humidity : ");
  Serial.print(humidity);
  Serial.println(" %RH");
  Serial.print("Celsius : ");
  Serial.print(celsTemp);
  Serial.println(" C");
  Serial.print("Fahrenheit : ");
  Serial.print(fahrTemp);
  Serial.println(" F");
  delay(500);
}

[/codesyntax]

 

Links

HDC1008 Temperature Humidity Sensor Breakout Board for Arduino

0 comment
0 FacebookTwitterPinterestEmail
Newer Posts
Older Posts