ESP8266 offers a complete and self-contained Wi-Fi networking solution, allowing it to either host the application or to offload all Wi-Fi networking functions from another application processor.

When the ESP8266 hosts an application and it is the only application processor in the device, and therefore able to boot up directly from an external flash. The ESP8266 has integrated cache to improve the performance and minimize the memory requirements.

Alternately, serving as a Wi-Fi adapter, wireless internet access can be added to any microcontroller-based design with simple connectivity through UART interface or the CPU AHB bridge interface.

This library will let you use the ESP8266 module as a telemetry unit with any microcontroller connected to it via serial as logger. Please note that if the logger does not have more than one serial port you will not able to visualize the response, but it can send data without any issues.

Before to start, you must choose which logger to use, in this case we decided use an Arduino MEGA.

IMPORTANT NOTE: It's very important know that we're going to manage two codes, one for the logger(Arduino MEGA), and a second for the telemetry unit(ESP8266).

Requirements

Command Request

We have designed a simple payload format you can use to send/get data from your devices to/from Ubidots using this protocol.

To know how to use the protocol and learn how to manage the data please reference to the README of the library on following link.

Setup

As we mentioned before, we have to manage two codes. That's mean we have two different setups, one for the ESP8266 as telemetry unit and a second one for the Arduino MEGA as logger.

Telemetry unit - ESP8266

As we know Telemetry is an automated communications process by which measurements and other data is collected at remote or inaccessible points and transmitted to receiving equipment for monitoring.

In this case, we are using the ESP8266 as a telemetry unit. We collect the data from the logger (Arduino MEGA) and the ESP8266 will be in charge of sending the collected data to Ubidots.

Hardware setup - Wiring

IT IS IMPORTANT IDENTIFY CAREFULLY THE PINOUT OF THE ESP8266, BECAUSE THE ESP8266 CAN BREAK IF YOU MAKE A WRONG CONNECTION

To program the ESP8266 you have to use a programmer as UartSBee, also you can use the Arduino MEGA to program the ESP8266. To upload the code into the ESP8266 you have to follow the connections below.

  • ESP8266 - Arduino MEGA / ESP8266 - UartSBee connections:

NOTE: Please be careful with the VCC of the ESP8266, it works only with a 3.3V supply.

If you're using the Arduino MEGA, makes sure that there are no other programs running and use the serial communication channel. Also, you have to set Arduino RST to GND(green wire); if you do not, you will get a console error and will not able to compile the ESP8266.

ESP8266 - Arduino MEGA diagram connections:

Firmware Setup - Arduino IDE

1. Go to the Arduino IDE.

2. Open the Arduino IDE, select Files -> Preferences and enter http://arduino.esp8266.com/stable/package_esp8266com_index.json into Additional Board Manager URLs field. You can add multiple URLs, separating them with commas.

3. Open Boards Manager from Tools -> Board -> Boards Manager and install esp8266 platform. To simply find the correct device, search ESP8266 within the search bar.

4. Select the Generic ESP8266 Module from Tools > Board menu.

5. Assigns 115200 as baudrate. Click on Tools > Upload Speed: "115200".

6. Download the UbidotsESP8266Serial library here.

7. Now, click on Sketch -> Include Library -> Add .ZIP Library.

8. Select the .ZIP file of UbidotsESP8266Serial and then "Accept" or "Choose".

9. Close the Arduino IDE and open it again.

10. Paste the code provide below.

Telemetry Unit - ESP8266 code

Once you have pasted the code below into the Arduino IDE, you will have to assign the parameters required to connect the ESP8266 to Wi-Fi and Ubidots. Please assign your Wi-Fi SSID, Wi-Fi password, and Ubidots TOKEN where are indicated:

/****************************************
 * Include Libraries
 ****************************************/
#include "UbidotsESP8266.h"

/****************************************
 * Define Constants
 ****************************************/
namespace {
  const char * WIFISSID = "Put_your_WIFI_SSID_here"; // Assign your WiFi SSID
  const char * PASSWORD = "Put_your_WIFI_password_here"; // Assign your WiFi password
  const char * TOKEN = "Put_your_Ubidots_Token_here"; // Assign your Ubidots TOKEN
}

Ubidots client(TOKEN);

/****************************************
 * Main Functions
 ****************************************/
void setup() {
  Serial.begin(115200);
  client.wifiConnection(WIFISSID, PASSWORD);
}

void loop() {
  client.readData(); // Reads the command from the logger
  delay(1000);
}

NOTE: The sampling frequency on the ESP8266 is of 1000 milliseconds

FAQs and Troubleshooting

One of the most common troubleshooting with the ESP8266 is this one:

If you got the issue above, please verify if the connections are in the right way, check if the Arduino RST is setted to GND , also verify if the board Generic ESP8266 Module is selected on the Arduino IDE.

NOTE: If you use the Arduino MEGA to program the ESP8266 don't forget establish the new wires connections to be able to communicate the devices through the hardware serial port.

Logger -  Arduino MEGA

The logger will be in charge of taking sensor (pin) readings and send values to the Telemetry Unit via serial.

You can use any microcontroller as logger, but please note that if the logger (microcontroller) does not have more than one hardware serial ports you will not able to visualize the response, but it is also possible to send data without any issue.

We decided to used the Arduino MEGA as logger, because it has more than one hardware serial ports available.

Hardware setup - Wiring

Once the code is uploaded into the telemetry unit (ESP8266), you have to make the right connections to be able to communicate the telemetry unit with the logger via serial. Please follow the table below to make the connections, also verify the connections with the diagram provided:

  • Arduino MEGA - ESP8266 Connections:

Diagram Connections

Firmware Setup - Arduino IDE

1. Once you completed the step before go to the Arduino IDE.

2. Assign the board to compile, in this case Arduino Mega. Click on Tools > Board: "Arduino/Genuino Mega or Mega 2560".

3. Select the Port assigned for the board. Click on Tools > Port > Select the port assgined.

4. Paste the code provided below with the modification required (reference to the next step).

5. Upload the code into the board. Then, verify it works through the Serial Monitor.

Send command via serial - Manual

The following code lets you send commands through the Serial Monitor. This will help you to verify if the logger and the Telemetry unit are working together.

NOTE: To know how to build the command required, reference to this link.

Once the code is uploaded, open the Serial Monitor and send the command, then, when all is programmed correctly, you have to receive the "OK" response from the server. If you receive an "ERROR" response verify the structure of the command.

NOTE: Take in count that the response is printed with a carriage return.

/****************************************
 * Define Constants
 ****************************************/
char command[700];  // command
char answer[100]; // answer from server

/****************************************
 * Main Functions
 ****************************************/
void setup() {
  Serial.begin(115200);
  Serial1.begin(115200);
}

void loop() {
 
  int i = 0;
  int j = 0;
 
  if (Serial.available()){
    while (Serial.available() > 0) {
      command[i++] = (char)Serial.read();
    }  
    /* Sends the command to the telemetry unit */
    Serial1.print(command);
    i = 0;
  }

  if (Serial1.available() > 0) {
    /* Reading the telemetry unit */
    while (Serial1.available() > 0) {
      answer[j++] = (char)Serial1.read();
    }
    /* Response from the server */
    Serial.print(answer);
    j = 0;
  }
}

Send command via serial - Automatically

Once you verify that everythings works as it should, you can use the following code to manage your sensors readings and send the values to Ubidots.

As you can see at the first part of the code you just have to assign your Ubidots TOKEN where is indicated. And also, please assign your device and variable parameters apporpriately if you adjusted any portion of code provided in this documentation.

/****************************************
 * Define Constants
 ****************************************/
namespace {
  const char * USER_AGENT = "UbidotsESP8266"; // Assgin the user agent
  const char * VERSION =  "1.0"; // Assign the version
  const char * METHOD = "POST"; // Set the method
  const char * TOKEN = "Put_your_Ubidots_token_here"; // Assign your Ubidots TOKEN
  const char * DEVICE_NAME = "telemetry"; // Assign the desire device name
  const char * DEVICE_LABEL = "ESP8266"; // Assign the device label
  const char * VARIABLE_LABEL_1 = "temperature"; // Assign the variable label
  const char * VARIABLE_LABEL_2 = "humidity"; // Assign the variable label
}

char command[700]; // command
char telemetry_unit[100]; // response of the telemetry unit

/* Space to store values to send */
char str_sensor1[10];
char str_sensor2[10];

/****************************************
 * Main Functions
 ****************************************/
void setup() {
  Serial.begin(115200);
  Serial1.begin(115200);
}

void loop() {

  /* Analog reading */
  float sensor1 = analogRead(A0);
  float sensor2 = analogRead(A1);
 
  /* 4 is mininum width, 2 is precision; float value is copied onto str_sensor*/
  dtostrf(sensor1, 4, 2, str_sensor1);
  dtostrf(sensor2, 4, 2, str_sensor2);

  /* Building the logger command */
  sprintf(command, "init#");
  sprintf(command, "%s%s/%s|%s|%s|", command, USER_AGENT, VERSION, METHOD, TOKEN);
  sprintf(command, "%s%s:%s=>", command, DEVICE_NAME, DEVICE_LABEL);
  sprintf(command, "%s%s:%s", command, VARIABLE_LABEL_1, str_sensor1);
  //sprintf(command, "%s,%s:%s", command, VARIABLE_LABEL_2, str_sensor2); // uncomment this line to send sensor 2 values
  sprintf(command, "%s|end#final", command);

  /* Prints the command sent */
  //Serial.println(command);// uncomment this line to print the command
 
  /* Sends the command to the telemetry unit */
  Serial1.print(command);

  /* Reading the telemetry unit */
  int i = 0;
  while (Serial1.available() > 0) {
    telemetry_unit[i++] = (char)Serial1.read();
  }
  Serial.println(telemetry_unit);
  i = 0;
  delay(5000);
}

If you desire sending more values, reference the README of the library to learn how to build the request containing more than one variable. Then, you will have to modify the command (as seen above) /* Building the logger command */ to include a data traffic rate that is greater than one variable.

Ubidots' data management 

Once the you complete the steps above and works without any issue, go to your Ubidots account to visualize the data received.

Result

Now it is time to create a dashboard to manage the variables of your device. To learn more about Ubidots widgets and events, check out these video tutorials.

Happy hacking :)

Did this answer your question?