ThingSpeak y NodeMCU ESP8266

¿Qué es ThingSpeak?

ThingSpeak es una plataforma de Análisis de datos para Internet de las Cosas IoT, podría analizar cualquier tipo de dato numérico, está en la nube y te permite de una manera muy intuitiva agregar y visualizar datos.

Puedes hacer más cosas, si subes tu propio código. MATLAB, es el lenguaje que hace la magia en ThingSpeak.

Algunas características:

• Configura fácilmente los dispositivos para enviar datos usando los protocolos populares de IoT.
• Visualiza los datos de tu sensor en tiempo real.
• Datos agregados bajo demanda de fuentes de terceros.
• Utiliza la potencia de MATLAB para darle sentido a tus datos IoT.
• Ejecuta tus análisis de IoT automáticamente en función de los horarios o eventos.
• Prototipado y creación de sistemas IoT sin configurar servidores o desarrollar software web.
• Actúa automáticamente sobre tus datos y se comunica contigo empleando servicios de terceros como Twilio® o Twitter®.

¿Es gratis?

Si y no, para nosotros usuarios domésticos que nos gustaría ver nuestros datos gráficamente sí que lo es, con alguna reserva que te detallo.

Tu opción es la licencia FREE que te permite hasta 3 millones de mensajes/año o 8200 mensajes/día. La siguiente opción personal es la licencia HOME que multiplica por 10 casi todos los conceptos.

Las restricciones que tiene la versión FREE abarca otros puntos importantes:

• El límite en el intervalo de envío de mensajes: entendiendo por mensajes cualquier tipo de dato que tú quieras subir a la nube de ThingSpeak, en la versión FREE son 15 segundos, este es tu máximo intervalo.
• Número de Canales: los channels, ThingSpeak los ha llamado canales como los podía haber llamada cajas. Define una comunicación en la que se puede subir datos, que se agrupan, almacenan, analizan y finalmente publican para poder consumirlos a través de un simple navegador.
• En la versión FREE el límite son 4 canales, la recomendación es que cada dispositivo tenga su canal particular.
• Con la versión FREE solo se pueden compartir 3 canales con el público.

¿Cómo funciona ThingSpeak?

Parte ThingSpeak

• Primero debes registrarte en la web de ThingSpeak.
• Configurar un canal (channel). Esta parte es muy importante, porque define los datos que voy a recibir. Cada canal admite 8 campos de datos, 8 posibles datos que vas a poder subir a través de este canal.
  En este artículo voy a subir datos de latencia y calidad de una conexión wifi, pero podrían ser cualquiera, por ejemplo:
  • Temperatura
  • Humedad
  • Presión barométrica
  • Velocidad del viento
  • Dirección del viento
  • Lluvia
  • Nivel de luz
  • Nivel de batería
• Una vez creado el canal, los datos que necesitas para transferir información desde nuestro dispositivo, son el Channel ID y la APIKeys, quédate con estos dos nombres.

Parte Dispositivo

• Los datos:
  • Latencia, ping al DNS de Google que es 8.8.8.8, para medir la latencia que es el tiempo en milisegundos de lo que tarda una señal/paquete en ir al DNS de Google y volver a mi dispositivo.
  • Intensidad de la señal WiFi en dBm.
• Librerías para nuestro ESP8266
  • ESP8266WiFi: vamos a enviar datos a una nube de internet, necesitamos un cliente HTTP.
  • ESP8266Ping: una librería muy sencilla para hacer ping tanto a IP como HOST y que nos devuelve la latencia en milisegundos. Este es su contenedor en GitHub.
  • ThingSpeak: esta librería está desarrollada por MathWorks que es la empresa que esta detrás de ThingSpeak, en su contenedor de GitHub tienes toda la información. Nosotros añadiremos la librería desde el propio IDE Arduino.
  • Por último, un temporizador que nos gestiona la extracción de datos cada 15/20 segundos, aquí voy a utilizar la función millis().

El resumen: utilizando un NodeMCU configurado en nuestro IDE Arduino, capturo cada 15/20 segundos los datos de latencia e intensidad wifi y los envío a ThingSpeak gracias a una librería desarrollada por la misma MathWorks. Previamente, te has dado de alta en ThingSpeak y configurado un canal. Una vez se empiece a subir datos, podrás visualizarlos vía la web de ThingSpeak.

Ejemplo con ThingSpeak y ESP8266

Paso 1. Comprar el dispositivo

Paso 2. Configurar el dispositivo ESP8266 en el IDE Arduino

Paso 3. Programación de los datos a subir a ThingSpeak

ATENCIÓN: 2 tipos de datos que vamos a subir a ThingSpeak.

• Ping al servidor DNS de Google, que es una prueba muy típica cuando queremos comprobar si estamos conectados a Internet, mediremos la latencia que son los milisegundos que tarda en volver un paquete al DNS de Google con esta herramienta que existe en todos los sistemas operativos.

• Intensidad de la señal Wifi RSSI en dBm (decibelios relativos al milivatio), lo que nos indicara la calidad de la cobertura. Os paso esta tabla:

Intensidad de la señal	Calificador	Usos adecuados
-30 dBm	Excelente	Esta es la máxima intensidad de señal alcanzable y será apropiada para cualquier situación de uso.
-50 dBm	Excelente	Este excelente nivel de señal es adecuado para todos los usos de la red.
–65 dBm	Muy bueno	Recomendado para smartphones y tablets.
-67 dBm	Muy bueno	Esta intensidad de señal será suficiente para voz sobre IP y streaming de vídeo.
-70 dBm	Aceptable	Este nivel es la intensidad mínima de la señal requerida para asegurar una entrega de paquetes fiable y le permitirá navegar por la web e intercambiar correos electrónicos.
-80 dBm	Malo	Permite la conectividad básica, pero la entrega de paquetes no es fiable.
-90 dBm	Muy malo	Un ruido que inhibe la mayoría de las funciones.
-100 dBm	Peor	Ruido total.

Bien, vamos a por el código.

Lo único que debes de tener en cuenta es que la librería ESP8266Ping no viene por defecto en el IDE de Arduino tienes que instalarla.

Muy fácil, vete a su contenedor GitHub y descárgate la librería en un fichero ZIP.

Ten cuidado porque existe otra librería que se llama ESP8266-ping que incluye la librería Pinger.h que no es la que se utiliza aquí.

En la pagina web de GitHub clic en CODE + Download ZIP.

Se descarga este fichero ESP8266Ping-master.zip, puedes renombrarlo ESP8266Ping.zip

Ya solo queda incluirlo en el IDE de Arduino en Programa + Incluir Librería + Añadir biblioteca .ZIP, buscamos el fichero ESP8266Ping.zip con el explorador.

Y si todo te ha ido bien debe de aparecer ejemplos de código con esta librería en Archivo + Ejemplos.

Ejemplos de programación con ESP8266

Ejemplo nº1 Blinking LED

En este ejemplo haremos el «hola mundo» de microcontroladores que es hacer parpadear un led.

EL código e el siguiente:

void setup() {
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, HIGH);   // Led ON
  delay(1000);              // pausa 1 seg
  digitalWrite(2, LOW);    // Led OFF
  delay(1000);              // pausa 1seg
}

Como se observa el código es igual como si se estuviera programando un arduino.
En cualquiera de los casos hay que verificar que en el IDE se haya  seleccionado la placa y el puerto correspondiente.

A diferencia de un arduino durante el proceso de carga, en la parte inferior del IDE nos muestra el porcentaje de la carga que se está realizando:

Si han ido bien todos los pasos anteriores, debe parpadear el LED.

Si su led Parpadea entonces significa que tienen todo configurado correctamente y están listos para realizar los siguientes ejemplos.

Código nº2

• Vamos a insertar el Nodemcu en una protoboard, ten cuidado de no equivocarte y poner todo la línea de conexiones en una línes de alimentación.
• Ponemos un LED entre D0 y GND
• Otro LED entre D4 y GND.

IMPORTANTE: Debemos tener en cuenta en el código que D0 es GPIO16 y D4 es GPIO2. No hace falta ponerle resistencia limitadora a los LED ya que la tensión de salida es de 3,3 V.

void setup() {
   pinMode(2, OUTPUT);
   pinMode(16, OUTPUT);
   Serial.begin(9600);
}

void loop() {
  digitalWrite(2, LOW);
  digitalWrite(16, LOW);
  Serial.println("BAJO");
  delay(1000);
  digitalWrite(2, HIGH);
  digitalWrite(16, HIGH);
  Serial.println("ALTO");
  delay(500);
}

LOS TERMINALES DEL NODEMCU.

Esto es muy importante y un poco lioso para los que empiezan. Los terminales del NodeMCU, los GPIO, los terminles en el código.

• Los terminales de la tarjeta NodeMCU se denominan: D0, D1, D2, D3, D4, D5, D6, D7, D8(RX), D9(TX), D10, SD2 y SD3.
• Los terminales del integrado ESP8266-12E, que está soldado a la tarjeta se denominan: GPIO0, GPIO1, GPIO2, GPIO3, GPIO4, GPIO5, GPIO6, GPIO7, GPIO8, GPIO9, GPIO10, GPIO11, GPIO12, GPIO13.

– Y resulta que no coincidien, es decir el D7 NO es el GPIO7. Esta será tu confusión a los largo de todos estos tutoriales.

Aquí tienes la tabla donde relaciono los terminales de la tarjeta NodeMCU con los del ESP8288-13E.

¿Qué quiere decir esto?

– Supongamos que conectamos un LED al terminal D1 de la tarjeta NodeMCU, como indica la imagen:

El terminal D1 de la tarjeta se corresponde con el GPIO5, según la tabla anterior.

– En el código debemos poner el número 5, es decir el GPIO5. No te confundas con el número de terminal de la tarjeta.

Ejemplo nº2 Lectura analógica con ESP8226

EL ESP8266 tiene una sola entrada analógica y al igual que un arduino es de 10 bits pero trabaja con un voltaje de referencia interno de 1V. En el NodeMCU y WeMos en la entrada A0 tiene un divisor de voltaje, para adaptar el rango hasta los 3.3V.

Debemos conectar un potenciómetro en el pin A0  pero usando los 3.3v

A nivel de código es igual como si se trabajase con la entrada A0 de un arduino, como se muestra en el siguiente sketch:

void setup() {
  //Iniciamos la Comunicacion Serial a 9600 baudios
  Serial.begin(9600);
}

void loop() {
  int sensorValue = analogRead(A0); //Lectura del ADC 
  float voltage = sensorValue * (3.3 / 1023.0); //escalamos a voltaje 

  
 //Enviamos por el puerto serie
  Serial.print("ADC= ");
  Serial.print(sensorValue);
  Serial.print("  Voltaje= ");
  Serial.println(voltage); 
  
  delay(100);  
}

Notar también que estamos usando la comunicación serial y en este ejemplo lo utilizamos para enviar el valor de la lectura analogía a la PC

Otro punto que hay que tener en cuenta es que el rango no es exactamente hasta 3.3V, esto es porque el divisor de voltaje esta hecho con valores comerciales de resistencias e incluso una resistencia por más precisa que sea puede tener pequeñas variaciones, y si necesitamos un valor exacto del voltaje es necesario escalar el voltaje correctamente.

Para obtener la ecuación correcta para escalar, necesitamos conectar el pin A0 a 3.3V, seguidamente debemos de anotar el valor del ADC, en nuestro caso 966, dicho valor deberán poner en la ecuación en remplazó del número 1023.

  float voltage = sensorValue * (3.3 / 966.0); //escalamos a voltaje 

Ejemplo nº3 Usando el PWM del ESP8266.

En el  ESP8266 podemos usar todos sus pines GPIO como salidas de PWM, la resolución del PWM es de 10 bits a diferencia de un arduino que es de 8bits. 

Otra diferencia positiva para el ESP8266 es que podemos modificar la frecuencia del PWM, siendo por defecto de 1KHZ.

Para realizar el ejemplo se puede usar la conexión inicial (el Led en el GPIO2) pero es recomendable usar esta función en otro pin puesto que le GPIO2 siempre va a parpadear al iniciar el modulo.

void setup() {
    pinMode(2, OUTPUT);
}

void loop() {
    for (int PWM_duty = 0; PWM_duty < 1023; PWM_duty++) 
    {
      analogWrite(2, PWM_duty);
      delay(1);
    }
    delay(500);
    for (int PWM_duty = 1023; PWM_duty >= 0; PWM_duty--) 
    {
      analogWrite(2, PWM_duty);
      delay(1);
    }
    delay(500);
}

Después de cargar el código el led debe de aumentar y disminuir  su intensidad.

En caso de querer modificar la frecuencia del PWM se debeponer la siguiente línea de código en el void setup () con la frecuencia deseada:

    analogWriteFreq(2000); //2KHz

Ejemplo nº4 Controlando servos con el ESP8266

En este caso hay que tener cuidado con el Pin que usemos, por ejemplo el Pin GPIO2 se utiliza como salida de datos para depurar, por esta razón siempre cuando se inicie o recete el ESP el GPIO2 va a enviar datos por ese pin, eso podría causar movimientos involuntarios en el servo.
En el ejemplo trabajaremos con ese pin pues el ESP-01 solo tiene disponible el GPIO2 pero los que estén trabajando con el NodeMCU o WeMos pueden cambiar de pin.

 
El código es el siguiente:

#include <Servo.h>

Servo myservo; 

void setup() {
  myservo.attach(2);  // servo en el pin 2
}

void loop() {
  for (int angulo = 0; angulo <= 180; angulo += 1) 
  { 
    myservo.write(angulo);              
    delay(10); 
  }
  
  for (int angulo = 180; angulo >= 0; angulo -= 1) 
  { 
    myservo.write(angulo);  
    delay(10);  
  }
}

Ejemplo nº5 Servidor web con ESP8266

En este ejemplo veremos la comunicación wifi y usaremos el ESP8266 como un servidor web. Manipularemos un led que está conectado al GPIO2 del ESP a través de un navegador web.

La conexión es la misma del primer ejemplo y el código es el siguiente:

#include <ESP8266WiFi.h>

const char* ssid = "WifiNaylamp";
const char* password = "123456789";

WiFiServer server(80);

void setup() {
  Serial.begin(9600);
  delay(10);

  //Configuración  del GPIO2
  pinMode(2, OUTPUT);
  digitalWrite(2,LOW);
  
  Serial.println();
  Serial.println();
  Serial.print("Conectandose a red : ");
  Serial.println(ssid);
  
  WiFi.begin(ssid, password); //Conexión a la red
  
  while (WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi conectado");
  
  server.begin(); //Iniciamos el servidor
  Serial.println("Servidor Iniciado");

  Serial.println("Ingrese desde un navegador web usando la siguiente IP:");
  Serial.println(WiFi.localIP()); //Obtenemos la IP
}

void loop() {
  WiFiClient client = server.available();
  if (client) //Si hay un cliente presente
  { 
    Serial.println("Nuevo Cliente");
    
    //esperamos hasta que hayan datos disponibles
    while(!client.available()&&client.connected())
    {
    delay(1);
    }
    
    // Leemos la primera línea de la petición del cliente.
    String linea1 = client.readStringUntil('r');
    Serial.println(linea1);

    if (linea1.indexOf("LED=ON")>0) //Buscamos un LED=ON en la 1°Linea
    {
      digitalWrite(2,HIGH);
    }
    if (linea1.indexOf("LED=OFF")>0)//Buscamos un LED=OFF en la 1°Linea
    {
      digitalWrite(2,LOW);
    }

    client.flush(); 
    Serial.println("Enviando respuesta...");   
    //Encabesado http    
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("Connection: close");// La conexión se cierra después de finalizar de la respuesta
    client.println();
    //Pagina html  para en el navegador
    client.println("<!DOCTYPE HTML>");
    client.println("<html>");
    client.println("<head><title>Naylam Mechatronics</title>");
    client.println("<body>");
    client.println("<h1 align='center'>Test ESP8266</h1>");
    client.println("<div style='text-align:center;'>");
    client.println("<br />");            
    client.println("<button onClick=location.href='./?LED=ON'>LED ON</button>");           
    client.println("<button onClick=location.href='./?LED=OFF'>LED OFF</button>");
    client.println("<br />");
    client.println("</div>");
    client.println("</body>");
    client.println("</html>");
    
    delay(1);
    Serial.println("respuesta enviada");
    Serial.println();

  }
}

En el código se debe modificar las variables correspondientes al nombre y  clave de la red.

Después de cargar el programa es necesario abrir el monitor serial para ver si se ha conectado correctamente a la red, y a la vez  ver la IP que se nos ha asignado.

Posteriormente debemos abrir un navegador y teclear la IP, es necesario que el ordenador o teléfono estén en la misma red al que está conectado el ESP8266. Si todo va bien les debe cargar la siguiente página:

Ahora al presionar los botones de la pantalla, nuestro ESP realizará la acción correspondiente.

En el monitor serial se puede monitorear las peticiones que se hacen al ESP8266, solo mostramos la primera línea de cada petición http pues es allí donde están los datos que pasamos por URL.

https://naylampmechatronics.com/blog/56_usando-esp8266-con-el-ide-de-arduino.html

Instalando el pluggin ESP8266 en Arduino IDE

Este paso es necesario para que  nuestro IDE de arduino reconozca a nuestro ESP8266 como una tarjeta.

Debemos tener ya instalado nuestro Arduino IDE con versión 1.6.4 o superior.

Seguidamente vamos a archivo>Preferencias y en la casilla  “Gestor de URLs Adicionales de Tarjetas” agregamos:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Seguidamente vamos a Herramientas>placa: … >Gestor de Tarjetas

Y buscamos en la lista  “esp8266 by ESP8266 Community“, lo seleccionamos  e instalamos:

La instalación puede tardar un poco, al finalizar, el ítem del ESP8266 debe marcar como instalado.

Ahora en herramientas>placas, deben de estar las nuevas placas instaladas.

Instalación del Driver

 

Este proceso es importante ya que la tarjeta aún después de realizar todo lo anterior en el momento de conectarla no será reconocida por nuestro PC, y lo único que nos falta es instalar el Driver, para ello lo pueden descargar aquí. y el proceso de instalación es el siguiente:

 

1. Se descomprime el archivo .rar y luego ejecutamos «SETUP«:
2. No hace falta modificar nada en el proceso de instalación, sólo queda dar clic en «INSTALL» y esperar unos breves segundos, si todo sale bien deberá decirnos que el proceso ya fue realizado:

En la siguiente imagen podemos ver la configuración que utilizo en mi caso, realmente solo hace falta cambiar la placa escogiendo «NodeMCU 1.0 (ESP – 12E Module)» y la velocidad en sus respectivos 115200 es con la que mejor me va:

Y con esto habremos terminado la configuración e instalación de la NodeMcu para programarla desde el IDE de Arduino.

Cómo programar NodeMCU con el IDE de Arduino

Pines de entrada salida

Todos los pines del ESP12E están cableados hasta el interfaz de la NodeMCU, por lo que tenemos disponible 11 pines de entrada salida y el puerto de entrada analógica.

Los pines GPIO del 6 al 11 están también conectados pero te recomiendo no usarlos. El ESP12E utiliza estos pines para conectar la memoria flash. Si los usas, lo más seguro es que el módulo se reinicie de forma inesperada.

La placa tiene 2 botones, uno conectado al pin de RESET y otro al GPIO0, que permite activar el modo de carga de firmware. Normalmente, no es necesario utilizar estos botones si usamos el IDE de Arduino.

Los pines GPIO 1 y 3 corresponden con el Rx y el Tx del puerto serie. Estos pines están protegidos con resistencias de 470 Ohm.

NodeMCU también facilita el uso del puerto analógico. El ESP8266 tiene un rango de entrada en este puerto de 0 a 1V pero gracias a un divisor de tensión NodeMCU lo extiende de 0 a 3.3V.

A continuación puedes ver el pineado de la NodeMCU original.

El nombre de los pines de NodeMCU tiene una nomenclatura diferente de la que utiliza el ESP8266. Por ejemplo los pines D0, D1, y D2 en la NodeMCU correponden con GPIO16, 5 y 4 en el ESP8266. El framework para Arduino permite utilizar ambas para referirse a los pines de entrada salida.

Estas dos sentencias son equivalentes.

pinMode(D2, OUTPUT);
digitalWrite(D2,HIGH);


pinMode(4, OUTPUT);
digitalWrite(4,HIGH);

Conectando el NodeMCU al PC

Las placas NodeMCU incorporan un conversor USB a serie. Solamente es necesario conectar el puerto USB de la placa a uno de los puertos de nuestro ordenador con un buen cable.

El sistema operativo normalmente detecta el hardware e instala los drivers automáticamente.

Si tienes un sistema operativo MAC, sigue estas instrucciones.

Hay diferentes fabricantes que hacen tarjetas de este tipo. Cada uno puede utilizar conversores diferentes. Los más utilizados son el CP1202 de Silabs, y CH340 del fabricante chino WCH. Hay placas que utilizan el conversor FT232RL de FTDI.

Para configurar el entorno de Arduino te recomiendo ver el video sobre cómo programar el ESP8266 con el IDE de Arduino.

Enlace al vídeo de youtube.

Puede que al principio no sepas para qué sirven las opciones de configuración de la placa. Ésta es la configuración que yo utilizo y que funcionará con todas las NodeMCU. Si el IDE de Arduino no puede programar la placa prueba a bajar el campo «upload speed» a 115200 bps.

NodeMCU: Ejemplos para empezar

Para empezar de la manera más sencilla vamos a aprender cómo utilizar el botón y el led que incluye la NodeMCU. El LED está conectado, internamente, al GPIO2 y el botón al GPIO0.

Lo primero que vamos a hacer es que parpadee el LED de NodeMCU. Copia y pega este código en el IDE de Arduino.

#define LED_BUILTIN 2 void setup() {     // El LED integrado está conectado al pin 2.     pinMode(LED_BUILTIN, OUTPUT); }   void loop() {   // Encender el LED (Está conectado con una resistencia pull-up,   // por eso se enciende si el pin está a nivel bajo)   digitalWrite(LED_BUILTIN, LOW);   delay(1000); // Esperar un segundo   // Apagar el LED   digitalWrite(LED_BUILTIN, HIGH);   delay(1000); // Esperar un segundo }

En el siguiente código vamos a utilizar el botón FLASH de NodeMCU. Este botón nos permite poner en modo carga del firmware. Como ya te he comentado, esto lo hace automáticamente al igual que las placas de Arduino, en un modo normal no tenemos que pulsar nada para cargar nuestro código.

Sin embargo, podemos utilizarlo como un botón normal una vez que se ha cargado el código al NodeMCU pero siempre y cuando se haya iniciado la ejecución. Recuerda, el GPIO donde está conectado el botón FLASH de NodeMCU es el GPIO0.

Carga el siguiente código que lo que hace es encender el LED conectado el GPIO2 cuando se pulsa el botón.

#define LED_BUILTIN 2 #define BUTTON_BUILTIN 0   void setup() {       // El LED integrado está conectado al pin 2.       pinMode(LED_BUILTIN, OUTPUT);       pinMode(BUTTON_BUILTIN, INPUT); }   void loop() {       // Leer el estado del botón. Cuando está pulsado el pin se pone a nivel bajo       int estado = digitalRead(BUTTON_BUILTIN);       // Configurar el LED de acuerdo al estado del botón       digitalWrite(LED_BUILTIN, estado); }

Acceder a una web desde NodeMCU

Cuando tenemos un módulo como el NodeMCU que puede conectarse a Internet mediante WiFi, lo primero que se nos puede ocurrir hacer con él es acceder a datos en la red. Esto podemos hacerlo, por ejemplo, accediendo a una API REST mediante protocolo HTTP.

Las librerías que incluye el framework de Arduino para el ESP8266 hacen que esto sea una tarea muy sencilla.

Conectar a la red WiFi

Lo primero de todo hay que conectar el módulo a la red WiFi. Para ello, dentro de la función setup() configuramos el NodeMCU como cliente WiFi e iniciamos la conexión pasando el nombre de nuestra red y la contraseña.

WiFi.mode(WIFI_STA); // Modo cliente WiFi WiFi.begin(«Nombre_WiFi», «Contraseña»);

Conectar al servidor

Después, una vez que verificamos que la conexión se ha realizado correctamente se puede enviar la petición. En este ejemplo voy a obtener la información de las condiciones meteorológicas. Lo voy a hacer consultando a la API del servicio Weather Underground.

#define HOST «api.wunderground.com» #define APIKEY = «tu clave de la API» // Necesitas obtener tu clave API en                                 // https://www.wunderground.com/weather/api/ WiFiClient client; client.connect(host, 80); // Conectamos al puerto HTTP String url = «/api/» + APIKEY + «/conditions/lang:SP/q/autoip.json» // Enviamos la petición client.print(String(«GET «) + url + » HTTP/1.1\r\n» + «Host: « + HOST+ «\r\n» + «Connection: close\r\n\r\n»);

Ahora ya podemos esperar y leer la respuesta.

while (client.available() == 0) { // Mientras no se ha recibido ningún dato   if (millis() – timeout > 5000) { // Tiempo de espera de 5 segundos   Serial.println(«>>> Superado el tiempo de espera !»);   client.stop(); return; } }   // Leemos la respuesta y la enviamos al monitor serie while(client.available()){   // Mientras quedan datos por leer   String line = client.readStringUntil(‘\r’);   Serial.print(line); }

Si todo ha ido correctamente, esto es lo que vamos a ver en el monitor serie:

"response": {
    "version": "0.1",
    "termsofService": "http://www.wunderground.com/weather/api/d/terms.html",
    "features": {
      "conditions": 1
    }
  },
  "current_observation": {
    "image": {
      "url": "http://icons.wxug.com/graphics/wu2/logo_130x80.png",
      "title": "Weather Underground",
      "link": "http://www.wunderground.com"
    },
    "display_location": {
      "full": "Madrid, Spain",
      "city": "Madrid",
      "state": "M",
      "state_name": "Spain",
      "country": "SP",
      "country_iso3166": "ES",
      "zip": "00000",
      "magic": "1",
      "wmo": "08221",
      "latitude": "40.45000076",
      "longitude": "-3.54999995",
      "elevation": "609.0"
    },
................

Programa completo

El código del sketch será éste. Para hacerlo funcionar necesitas rellenar los datos de tu red WiFi y de la clave del API de Weather Underground que puedes obtener registrándote en su web.

// Esta es la librería para utilizar las funciones de red del ESP8266
#include <ESP8266WiFi.h> 

const char* ssid = "SSID"; // Rellena con el nombre de tu red WiFi
const char* password = "Contraseña"; // Rellena con la contraseña de tu red WiFi

const char* host = "api.wunderground.com";
const char* apiKey = "tu clave API de wunderground.com"; // Puedes obtenerla en
                                                         // https://www.wunderground.com/weather/api/

void setup() {
  Serial.begin(115200);
  delay(10);

  // Conectamos a la red WiFi

  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  /* Configuramos el ESP8266 como cliente WiFi. Si no lo hacemos 
     se configurará como cliente y punto de acceso al mismo tiempo */
  WiFi.mode(WIFI_STA); // Modo cliente WiFi
  WiFi.begin(ssid, password);

  // Esperamos a que estemos conectados a la red WiFi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected"); 
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP()); // Mostramos la IP
}

void loop() {

  Serial.print("connecting to ");
  Serial.println(host);
 
  // Creamos el cliente
  WiFiClient client;
  const int httpPort = 80; // Puerto HTTP
  if (!client.connect(host, httpPort)) {
    // ¿hay algún error al conectar?
    Serial.println("Ha fallado la conexión");
    return;
  }
 
  // Creamos la URL para la petición
  String url = "/api/";
  url += apiKey;
  url += "/conditions/lang:SP/q/autoip.json";
 
  Serial.print("URL de la petición: http://");
  Serial.print(host);
  Serial.print(":");
  Serial.print(httpPort);
  Serial.println(url);
 
  // Enviamos la petición
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
         "Host: " + host + "\r\n" + 
         "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Superado el tiempo de espera !");
      client.stop();
      return;
    }
  }

  // Consutar la memoria libre
  // Quedan un poco más de 40 kB
  Serial.printf("\nMemoria libre en el ESP8266: %d Bytes\n\n",ESP.getFreeHeap());
 
  // Leemos la respuesta y la enviamos al monitor serie
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
 
  Serial.println();
  Serial.println("Cerrando la conexión");

  while(1){
    delay(0); // Siempre que hay un bucle que pueda durar mucho tiempo
              // hay que llamar a la función delay() para atender a los 
              // procesos de la conexión WiFi. Si no se hace el ESP8266
              // generará un error y se reiniciará a los pocos segundos
  }
}

¿Y si tengo que conectarme usando HTTP seguro?

Cada vez más sitios web exigen que las conexiones utilicen el protocolo seguro HTTPS. ¿Qué puedo hacer si el API al que tengo que acceder me obliga a usar comunicación segura?

El ESP8266 no tiene hardware de seguridad para encriptar la comunicación por lo tanto, NodeMCU tampoco. Pero la librería WiFi incluye funciones de encriptación por software. Gracias a esto podremos acceder de una forma muy similar a sitios HTTPS.

Solamente hay que cambiar la declaración WiFiClient client por WiFiClientSecure client. Adicionalmente para asegurarnos de que estamos conectándonos realmente al servidor que queremos se puede comprobar que el certificado es el correcto, comprobando que la huella corresponde con la esperada.

Pero esto tiene un inconveniente. La encriptación y gestión de los certificados mediante software consume alrededor de 20 kB. Esto representa prácticamente la mitad de la memoria disponible para nuestro programa.

 

// Esta es la librería para utilizar las funciones de red del ESP8266
#include <ESP8266WiFi.h> 

const char* ssid = "SSID"; // Rellena con el nombre de tu red WiFi
const char* password = "Contraseña"; // Rellena con la contraseña de tu red WiFi

const char* host = "api.wunderground.com";
const char* apiKey = "tu clave API de wunderground.com"; // Puedes obtenerla en
                                         // https://www.wunderground.com/weather/api/

// Huella digital del certificado del servidor https://www.wunderground.com
const char * fingerprint = "a9 1f b9 fe 35 b8 38 b9 54 67 e7 34 52 8a 24 d4 17 29 fa 32";

void setup() {
  Serial.begin(115200);
  delay(10);

  // Conectamos a la red WiFi

  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
 
  /* Configuramos el ESP8266 como cliente WiFi. Si no lo hacemos 
  se configurará como cliente y punto de acceso al mismo tiempo */
  WiFi.mode(WIFI_STA); // Modo cliente WiFi
  WiFi.begin(ssid, password);

  // Esperamos a que estemos conectados a la red WiFi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected"); 
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP()); // Mostramos la IP
}

void loop() {

  Serial.print("connecting to ");
  Serial.println(host);
 
  // Creamos el cliente
  WiFiClientSecure client;
  const int httpPort = 443; // Puerto HTTPS
  if (!client.connect(host, httpPort)) {
    // ¿hay algún error al conectar?
    Serial.println("Ha fallado la conexión");
    return;
  }

  // Verificamos que el certificado coincide con el esperado
  if(client.verify(fingerprint,host)){
    Serial.println("El certificado es correcto"); 
  } else {
    Serial.println("Error de certificado"); 
  }
 
  // Creamos la URL para la petición
  String url = "/api/";
  url += apiKey;
  url += "/conditions/lang:SP/q/autoip.json";
 
  Serial.print("URL de la petición: https://");
  Serial.print(host);
  Serial.print(":");
  Serial.print(httpPort);
  Serial.println(url);
 
  // Enviamos la petición
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
                "Host: " + host + "\r\n" +
                "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Superado el tiempo de espera !");
      client.stop();
      return;
    }
  }

  // Consutar la memoria libre
  // Utilizando HTTPS se necesitan unos 20 kB de memoria libres adicionales
  Serial.printf("\nMemoria libre en el ESP8266: %d Bytes\n\n",ESP.getFreeHeap());
 
  // Leemos la respuesta y la enviamos al monitor serie
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
 
  Serial.println();
  Serial.println("Cerrando la conexión");

  while(1){
    delay(0); // Siempre que hay un bucle que pueda durar mucho tiempo
              // hay que llamar a la función delay() para atender a los 
              // procesos de la conexión WiFi. Si no se hace el ESP8266
              // generará un error y se reiniciará a los pocos segundos
   }
}