ESP8266 ofrece una solución completa y autónoma de red Wi-Fi, permitiendo que aloje la aplicación o descargue todas las funciones de red Wi-Fi de otro procesador de aplicación.

Cuando el ESP8266 aloja una aplicación y es el único procesador de aplicación en el dispositivo, puede arrancar directamente desde una memoria flash externa. El ESP8266 tiene caché integrada para mejorar el rendimiento y minimizar los requisitos de memoria.

Alternativamente, sirviendo como un adaptador Wi-Fi, se puede agregar acceso a internet inalámbrico a cualquier diseño basado en microcontrolador con una conectividad simple a través de la interfaz UART o la interfaz de puente AHB de la CPU.

Esta biblioteca te permitirá usar el módulo ESP8266 como una unidad de telemetría con cualquier microcontrolador conectado a él a través de serie como registrador. Ten en cuenta que si el registrador no tiene más de un puerto serie, no podrás visualizar la respuesta, pero puede enviar datos sin problemas.

Antes de comenzar, debes elegir qué registrador usar, en este caso decidimos usar un Arduino MEGA.

NOTA IMPORTANTE: Es muy importante saber que vamos a manejar dos códigos, uno para el registrador (Arduino MEGA) y un segundo para la unidad de telemetría (ESP8266).

Requisitos

Cualquier microcontrolador con más de un puerto serie. e.i: Arduino MEGA
Un módulo ESP8266
UartSBee o cualquier dispositivo de Uart a USB
Arduino IDE 1.6.0 o superior
Biblioteca Ubidots Arduino ESP8266
Cuenta de Ubidots

Solicitud de Comando

Hemos diseñado un formato de carga útil simple que puedes usar para enviar/obtener datos de tus dispositivos a/de Ubidots utilizando este protocolo.

Para saber cómo usar el protocolo y aprender a gestionar los datos, consulta el README de la biblioteca en el siguiente enlace.

Configuración

Como mencionamos antes, tenemos que manejar dos códigos. Eso significa que tenemos dos configuraciones diferentes, una para el ESP8266 como unidad de telemetría y una segunda para el Arduino MEGA como registrador.

Unidad de Telemetría - ESP8266

Como sabemos, Telemetría es un proceso de comunicación automatizado mediante el cual se recogen mediciones y otros datos en puntos remotos o inaccesibles y se transmiten a equipos receptores para su monitoreo.

En este caso, estamos utilizando el ESP8266 como una unidad de telemetría. Recogemos los datos del registrador (Arduino MEGA) y el ESP8266 se encargará de enviar los datos recopilados a Ubidots.

Configuración de Hardware - Cableado

ES IMPORTANTE IDENTIFICAR CUIDADOSAMENTE EL PINOUT DEL ESP8266, PORQUE EL ESP8266 PUEDE ROMPERSE SI HACES UNA CONEXIÓN INCORRECTA

Para programar el ESP8266 debes usar un programador como UartSBee, también puedes usar el Arduino MEGA para programar el ESP8266. Para cargar el código en el ESP8266, debes seguir las conexiones a continuación.

Conexiones ESP8266 - Arduino MEGA / ESP8266 - UartSBee:

NOTA: Por favor, ten cuidado con el VCC del ESP8266, solo funciona con una alimentación de 3.3V.

Si estás usando el Arduino MEGA, asegúrate de que no haya otros programas en ejecución y usa el canal de comunicación serie. Además, debes conectar el RST de Arduino a GND (cable verde); si no lo haces, recibirás un error en la consola y no podrás compilar el ESP8266.

Diagrama de conexiones ESP8266 - Arduino MEGA:

Configuración de Firmware - Arduino IDE

1. Ve a la Arduino IDE.

2. Abre el Arduino IDE, selecciona Archivos -> Preferencias e ingresa http://arduino.esp8266.com/stable/package_esp8266com_index.json en el campo de URLs adicionales del Gestor de Placas. Puedes agregar múltiples URLs, separándolas con comas.

3. Abre el Gestor de Placas desde Herramientas -> Placa -> Gestor de Placas e instala la plataforma esp8266. Para encontrar el dispositivo correcto, busca ESP8266 en la barra de búsqueda.

4. Selecciona el Módulo Genérico ESP8266 del menú Herramientas > Placa.

5. Asigna 115200 como velocidad de baudios. Haz clic en Herramientas > Velocidad de Carga: "115200".

6. Descarga la biblioteca UbidotsESP8266Serial aquí.

7. Ahora, haz clic en Sketch -> Incluir Biblioteca -> Agregar Biblioteca .ZIP.

8. Selecciona el archivo .ZIP de UbidotsESP8266Serial y luego "Aceptar" o "Elegir".

9. Cierra el Arduino IDE y ábrelo de nuevo.

10. Pega el código proporcionado a continuación.

Código de la Unidad de Telemetría - ESP8266

Una vez que hayas pegado el código a continuación en el Arduino IDE, deberás asignar los parámetros requeridos para conectar el ESP8266 a Wi-Fi y Ubidots. Por favor, asigna tu SSID de Wi-Fi, contraseña de Wi-Fi y TOKEN de Ubidots donde se indica:

/**************************************** * Incluir Bibliotecas ****************************************/#include "UbidotsESP8266.h"/**************************************** * Definir Constantes ****************************************/namespace {  const char * WIFISSID = "Pon_tu_SSID_WIFI_aquí"; // Asigna tu SSID de WiFi  const char * PASSWORD = "Pon_tu_contraseña_WIFI_aquí"; // Asigna tu contraseña de WiFi  const char * TOKEN = "Pon_tu_Token_Ubidots_aquí"; // Asigna tu TOKEN de Ubidots}Ubidots client(TOKEN);/**************************************** * Funciones Principales ****************************************/void setup() {  Serial.begin(115200);  client.wifiConnection(WIFISSID, PASSWORD);}void loop() {  client.readData(); // Lee el comando del registrador  delay(1000);}

NOTA: La frecuencia de muestreo en el ESP8266 es de 1000 milisegundos

Preguntas Frecuentes y Solución de Problemas

Uno de los problemas más comunes con el ESP8266 es el siguiente:

Si tienes el problema anterior, verifica si las conexiones están en el lugar correcto, comprueba si el RST de Arduino está conectado a GND, también verifica si la placa Módulo Genérico ESP8266 está seleccionada en el Arduino IDE.

NOTA: Si usas el Arduino MEGA para programar el ESP8266, no olvides establecer las nuevas conexiones de cables para poder comunicar los dispositivos a través del puerto serie de hardware.

Registrador - Arduino MEGA

El registrador se encargará de tomar lecturas de los sensores (pines) y enviar valores a la Unidad de Telemetría a través de serie.

Puedes usar cualquier microcontrolador como registrador, pero ten en cuenta que si el registrador (microcontrolador) no tiene más de un puerto serie de hardware, no podrás visualizar la respuesta, pero también es posible enviar datos sin ningún problema.

Decidimos usar el Arduino MEGA como registrador, porque tiene más de un puerto serie de hardware disponible.

Configuración de Hardware - Cableado

Una vez que el código esté cargado en la unidad de telemetría (ESP8266), debes hacer las conexiones correctas para poder comunicar la unidad de telemetría con el registrador a través de serie. Por favor, sigue la tabla a continuación para hacer las conexiones, también verifica las conexiones con el diagrama proporcionado:

Conexiones Arduino MEGA - ESP8266:

Diagrama de Conexiones

Configuración de Firmware - Arduino IDE

1. Una vez que completes el paso anterior, ve al Arduino IDE.

2. Asigna la placa para compilar, en este caso Arduino Mega. Haz clic en Herramientas > Placa: "Arduino/Genuino Mega o Mega 2560".

3. Selecciona el puerto asignado para la placa. Haz clic en Herramientas > Puerto > Selecciona el puerto asignado.

4. Pega el código proporcionado a continuación con las modificaciones requeridas (referencia al siguiente paso).

5. Carga el código en la placa. Luego, verifica que funcione a través del Monitor Serial.

Enviar comando a través de serie - Manual

El siguiente código te permite enviar comandos a través del Monitor Serial. Esto te ayudará a verificar si el registrador y la unidad de telemetría están funcionando juntos.

NOTA: Para saber cómo construir el comando requerido, consulta este enlace.

Una vez que el código esté cargado, abre el Monitor Serial y envía el comando, luego, cuando todo esté programado correctamente, deberías recibir la respuesta "OK" del servidor. Si recibes una respuesta "ERROR", verifica la estructura del comando.

NOTA: Ten en cuenta que la respuesta se imprime con un retorno de carro.

/**************************************** * Definir Constantes ****************************************/char command[128];  // comandochar answer[100]; // respuesta del servidor/**************************************** * Funciones Principales ****************************************/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();    }      /* Envía el comando a la unidad de telemetría */    Serial1.print(command);    i = 0;  }  if (Serial1.available() > 0) {    /* Leyendo la unidad de telemetría */    while (Serial1.available() > 0) {      answer[j++] = (char)Serial1.read();    }    /* Respuesta del servidor */    Serial.print(answer);    j = 0;  }}

Enviar comando a través de serie - Automáticamente

Una vez que verifiques que todo funciona como debería, puedes usar el siguiente código para gestionar las lecturas de tus sensores y enviar los valores a Ubidots.

Como puedes ver en la primera parte del código, solo tienes que asignar tu TOKEN de Ubidots donde se indica. Y también, por favor asigna tus parámetros de dispositivo y variable apropiadamente si ajustaste alguna parte del código proporcionado en esta documentación.

/**************************************** * Definir Constantes ****************************************/namespace {  bool flow_control = true; // controlar el flujo de las solicitudes  const char * USER_AGENT = "UbidotsESP8266"; // Asigna el agente de usuario  const char * VERSION =  "1.0"; // Asigna la versión  const char * METHOD = "POST"; // Establece el método  const char * TOKEN = "........"; // Asigna tu TOKEN de Ubidots  const char * DEVICE_LABEL = "ESP8266"; // Asigna la etiqueta del dispositivo  const char * VARIABLE_LABEL = "temp"; // Asigna la etiqueta de la variable}char telemetry_unit[100]; // respuesta de la unidad de telemetría/* Espacio para almacenar valores a enviar */char str_sensor1[10];char str_sensor2[10];/**************************************** * Funciones Principales ****************************************/void setup() {  Serial.begin(115200);  Serial1.begin(115200);}void loop() {  char* command = (char *) malloc(sizeof(char) * 128);  /* Espera la respuesta del servidor para leer los valores y construir el comando */  /* Mientras la bandera sea verdadera, tomará las lecturas de los sensores, construirá el comando,     y publicará el comando en Ubidots */  if (flow_control) {    /* Lectura analógica */    float sensor1 = analogRead(A0);    float sensor2 = analogRead(A1);    /* 4 es el ancho mínimo, 2 es la precisión; el valor float se copia en str_sensor*/    dtostrf(sensor1, 4, 2, str_sensor1);    dtostrf(sensor2, 4, 2, str_sensor2);    /* Construyendo el comando del registrador */    sprintf(command, "init#");    sprintf(command, "%s%s/%s|%s|%s|", command, USER_AGENT, VERSION, METHOD, TOKEN);    sprintf(command, "%s%s=>", command, DEVICE_LABEL);    sprintf(command, "%s%s:%s", command, VARIABLE_LABEL, str_sensor1);    sprintf(command, "%s|end#final", command);    /* Imprime el comando enviado */    //Serial.println(command);// descomenta esta línea para imprimir el comando    /* Envía el comando a la unidad de telemetría */    Serial1.print(command);    /* libera memoria*/    free(command);    /* Cambia el estado de la bandera a falso. Una vez que los datos se envían, el estado       de la bandera cambiará a verdadero nuevamente */    flow_control = false;  }  /* Leyendo la unidad de telemetría */  int i = 0;  while (Serial1.available() > 0) {    telemetry_unit[i++] = (char)Serial1.read();    /* Cambia el estado de la bandera; permite que se construya el siguiente comando */    flow_control = true;  }  if (flow_control) {    /* Imprime la respuesta del servidor -> OK */    Serial.write(telemetry_unit);    /* libera memoria */    memset(telemetry_unit, 0, i);  }  delay(1000);}

Si deseas enviar más valores, consulta el README de la biblioteca para aprender cómo construir la solicitud que contenga más de una variable. Luego, tendrás que modificar el comando (como se ve arriba) /* Construyendo el comando del registrador */ para incluir una tasa de tráfico de datos que sea mayor que una variable.

Gestión de datos de Ubidots

Una vez que completes los pasos anteriores y funcione sin problemas, ve a tu cuenta de Ubidots para visualizar los datos recibidos.

Resultado

Ahora es el momento de crear un panel de control para gestionar las variables de tu dispositivo. Para aprender más sobre los widgets y eventos de Ubidots, consulta estos tutoriales en video.