Published September 24, 2017 © GPL3+

NucleoL476RG to Ubidots

Post data to Ubidots with NucleoL476 over wifi.

BeginnerProtip1 hour1,157

Things used in this project

Hardware components

STMicroelectronics STM32 Nucleo-64 Board

STMicroelectronics X-Nucleo-IDW01M1

Software apps and online services

Arm MBED

Story

Objective

This tutorial explains how to send datas to the Ubidots site using the STMicroelectronics ODE ecosystem:

NucleoL476 with STM32L476RG

X-Nucleo-IDW01M1 wifi shield

MBed OS online compiler

Background

I was looking for an IoT platform that would allow to post data and also be able to define alerts in the case where a value of a sensor crossed a critical threshold.

On the web today there is a multitude of cloud service and most offer a free plan (limited to a handful of devices and in number of data sent)

IoT providers public and Open Source :

https://www.postscapes.com/internet-of-things-platforms/

Then after doing some concluding test with Thingspeak, I discovered Ubidots (https://ubidots.com/). There are tons of equivalent projects based on hardware Arduino, ESP8266 and others. We can also find for each IoT cloud provider the specific libraries of each of the popular platforms (Arduino familly, Energia ...)

But I wanted to present the possibility of the microcontroller STM32. This opens up an infinity of aplication projects, metering sensors, home automation and so on.

Let's go.

STEP 1: Ubidots settings

First you need to create an Ubidots account

Ubidots main page

On Devices Tab. And we will create a new device (with Add Device)

Set "NucleoL476 " to device name. Then clic to open device settings.

Devices creation

Now inside NucleoL476 we will create 3 variables with following name, level, temperature and battery.

Variables creation

Each variables are ready to be updated by Nucleo board over Wifi.

STEP 2: API credential

We need to write a code for STM32L476RG to communicate over wifi and update values of 3 variables.

This will be done later by using Mbed online compiler.

For Wifi local acces point, we define 2 strings.

/* Wifi Acces Point Settings */  
#define AP_SSID         "YOUR_WIFI_SSID"			 
#define AP_PASSWORD     "YOUR_WIFI_PASSWORD"

And to be able to connect the hardware and authenticate it with Ubidots with TCP, we need to define 2 other strings.

#define UBIDOTS_TOKEN   "YOUR_UBIDOTS_TOKEN" 
#define UBIDOTS_DEVICE  "YOUR_UBIDOTS_LABEL_DEVICE"

The first string UBIDOTS_TOKEN should be read from your account API Credentials (see below)

API Credentials

The second string is the Device Label Name that we create in Step 1: "NucleoL476"

You only need to change these define to implement this tutorial.

STEP 3: Hadware and Mbed

Now we can attach the X-Nucleo-IDW01M1 over NucleoL476RG board with Morpho connector.

NucleoL476RG with IDW01M1 wifi shield

Important note: Some X-Nucleo-IDW01M1 board have a little modification to perform. Check if R21 resistor is mounted. If R21 is soldered, you must remove it.

Now go to Mbed OS (https://os.mbed.com/), sign in and open the online compiler.

Mbed Online compiler

Create a new project and configure it with your hardware (here NucleoL476)

Connect the Nucleo mini USB to your computer, and note Virtual Com port assigned by your operating system.

Open a serial terminal at 115200 bauds, 8 bit and 1 stop bit Xon/Xoff disabled (like Teraterm or Putty)

STEP 4: Mbed Code

The code is available as attached file below.

You can copy and paste it into Mbed Compiler. It is well commented and should not be an issue.

You must include some additionnal library such:

NetworkSocketAPI

X_NUCLEO_IDW01M1v2 as well

and mbed

level variable is a boolean and show the status of the User blue button on the Nucleo Board.

temperature variable is updated with STM32 Internal temperature sensor connected to ADC.

Then battery variable is updated with VBAT / 3 Internal ADC Channel.

After reset, the program will convert ADC internal channel for VBAT and internal temperature sensor of the mcu. It's an example and you can use any data. The converted values are stored into vbat and temp variables.

It will also get the status of the User button of the Nucleo Board (the blue button).

And try to connect to a wifi network, with SSID and WPA key you have provided.

Then it wil make a TCP socket connection with Ubidots api.

If connetion is etablished, the application will constuct the a Rest API command HTTP request, and POST the HTTP command.

POST /api/v1.6/devices/{LABEL_DEVICE}/?token={TOKEN} HTTP/1.1
Host: things.ubidots.com
Content-Type: application/json
Content-Length: 76

{"temperature": %0.2f, "battery": %0.2f, "level\": %d}

For more informations, see https://ubidots.com/docs/api/#rest-api-reference

By using a terminal console you will see each step of the program. And the feedback response for HTTP request (if you get 200 it's OK)

Now you should see your data online.

The application will enter into a blinky loop. And you need to restart it by a reset if you want to send data again.

This is a simple tutorial and it is fully functionnal.

You can use it for your own project, and it'easy to implement other data posting for real environmental sensors.

I hope you enjoy it. Any feedback is welcome.

main.cpp

/*
	Copyright (C) 2017 romain reicher

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
    About 
    ---------------------------------------------------------------------

	Send sensors value to Ubidots.
	This example sends 3 variables to Ubidots.
		- STM32L476 VBAT/3 internal channel in mV
		- STM32L476 Internal Temperature Sensor in C
		- The status of onboard User Button (blue) on NucleoL476RG 
	Use NucleoL476RG with X-Nucleo-IDW01M1v2 wifi shield
 
	Important note: Some IDW01M1 wifi shield had resistor R21 mounted
					which interfere with STLink/SWD programmer.
 					Please unmount R21 to fix it.
 
    romain reicher
    Date     :	20/09/2017
    Revision :  v0.1  
*/


#include "mbed.h"
#include "SpwfInterface.h"  
#include "TCPSocket.h"

/* Wifi Acces Point Settings */ 
#define AP_SSID         "YOUR_WIFI_SSID"			
#define AP_PASSWORD     "YOUR_WIFI_PASSWORD"
#define UBIDOTS_SERVER  "things.ubidots.com"
#define UBIDOTS_PORT    80
#define UBIDOTS_TOKEN   "YOUR_UBIDOTS_TOKEN"
#define UBIDOTS_DEVICE  "YOUR_UBIDOTS_LABEL_DEVICE"

/* Communication ressources */
SpwfSAInterface spwf(D8, D2, false);    
Serial pc(USBTX, USBRX);

/* Digital ressources */
DigitalOut myLed(LED1);
DigitalIn myButton(USER_BUTTON);

/* Analog ressources */
AnalogIn adc_vbat(ADC_VBAT);    // VBAT / 3 internal to ADC channel
AnalogIn adc_temp(ADC_TEMP);    // Internal Temp Sensor to ADC Channel

/* Global variables */
float temp = adc_temp.read() * 100;		// Converted in C
float batt = adc_vbat.read() * 30000;   // Converted in mV  
bool level = false;

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main() 
{
    /* Configure Serial baud rate */
    pc.baud(115200);
    
	/* Update level variable state depending USER_BUTTON state */
    if (myButton == 0)
        level = true;
    else
        level = false;
    
    TCPSocket socket(&spwf);
    char sendBuffer[256];
    char message[64];
    int err;
	
    /* ######################## WIFI CONNECTION ######################## */

    pc.printf("IDW01M1 NetworkSocketAPI TCP Client Ubidots\r\n");
    pc.printf("Connecting to AP\r\n");
    
    //* Connect to wifi acces point */    
    if(spwf.connect(AP_SSID, AP_PASSWORD, NSAPI_SECURITY_WPA2)) 
    {      
        pc.printf("Now connected\r\n");
    } 
    else
    {
        pc.printf("Error connecting to AP.\r\n");
        return -1;
    }   
    
    /* #################### GET CONNECTION INFOS ######################## */
    
    /* Get and print network connection parameters ip and mac adress */   
    const char *ip = spwf.get_ip_address();
    const char *mac = spwf.get_mac_address();    

    pc.printf("IP address is: %s\r\n", ip ? ip : "No IP");
    pc.printf("MAC address is: %s\r\n", mac ? mac : "No MAC");
    
    /* ##################### UBIDOATS SEND DATA ######################### */

    printf("Sending HTTP Data to Ubidots...\r\n");
 
    /* Open a socket , create a TCP connection to Ubidots */
    err = socket.connect(UBIDOTS_SERVER, UBIDOTS_PORT); 
    if (err!=0) 
    {
      pc.printf("\r\nCould not connect to Socket, err = %d!!\r\n", err); 
      return -1;
    } 
    else 
        pc.printf("\r\nconnected to host server\r\n"); 
    
    /* Construct content of HTTP command */
    sprintf(message, "{\"temperature\": %0.2f, \"battery\": %0.2f, \"level\": %d}", temp, batt, (int)level);
    printf("Content Length = %d\r\n", (int)strlen(message));
    
    /* Construct HTTP command to send */
    sprintf(sendBuffer, "POST /api/v1.6/devices/%s/?token=%s HTTP/1.1\r\nHost: things.ubidots.com\r\nContent-Type: application/json\r\nContent-Length: %d\r\n\r\n%s", UBIDOTS_DEVICE, UBIDOTS_TOKEN, (int)strlen(message),message); 
    pc.printf("HTTP command %s\r\n", sendBuffer);
    wait(2.0);
     
    /* Send http request to Ubidots */ 
    int scount = socket.send(sendBuffer, (int)strlen(sendBuffer));
    printf("sent %d [%.*s]\r\n", scount, strstr(sendBuffer, "\r\n") - sendBuffer, sendBuffer);

    /* Receive a simple http response and print out the response line */
    char respBuffer[64];
    int rcount = socket.recv(respBuffer, sizeof respBuffer);
    printf("recv %d [%.*s]\r\n", rcount, strstr(respBuffer, "\r\n") - respBuffer, respBuffer);

    /* Close the socket to return its memory and bring down the network interface */
    pc.printf("Close Socket\r\n");
    socket.close();
    
    /* Disconnect */
    pc.printf("Disconnect Wifi\r\n");
    spwf.disconnect();
    wait(1.0);
    pc.printf("Done\r\n");

    myLed = 0;
        
    while(1) 
    {
		myLed = !myLed;
		wait(1.0);
    }
}