Si tuviera que resumir en una línea que es ThingSpeak te diría que es una plataforma para ahorrarte tiempo. Como todo lo que hay en la nube (o pretender ser). En el 2015 había 7, ahora hay 700 (por poner una magnitud), ahorrar código es ganar tiempo lo que tiene mucho valor, el tiempo es oro.
ThingSpeak es un ejemplo de esas plataformas que se han hecho un hueco en este mundillo. Trasladar la responsabilidad del tratamiento de datos es una opción para dedicarte a lo que te gusta que puede ser programar Arduinos y ESPs.
Pero lo que de verdad sorprende de ThingSpeak es su facilidad de uso, aquí los señores de MathWorks se lo han currado, créeme lo que te voy a decir, se tardan 10 minutos en darse de alta y crear un canal (la caja donde se almacenan los datos) y otros 15 en adecuar un código funcional que ya tengas escrito con datos de sensores.
Este artículo va justamente de eso, que veas la facilidad de uso. He simplificado al máximo la placa a utilizar, el código y los datos a subir a la nube, para centrarnos en ThingSpeak.
Adelante.
Indice de contenidos
¿Qué es ThingSpeak?
ThingSpeak es una plataforma de Análisis de datos para Internet de las Cosas IoT, pero 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, aunque, no va a ser nuestra opción, a no ser que seas un monstruo en 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®.
Si te resulta engorroso, construirte un entorno de análisis y visualización de datos, esta es una opción chula, fácil de implementar, lo verás en este artículo.
Si eres un desarrollador y creas páginas web, por ejemplo, es muy fácil añadir estos gráficos en tu página.
Tiene una API para almacenar y recuperar (escribir y leer) datos usando el protocolo HTTP.
Podremos subir datos desde cualquier sensor conectado a un Arduino, ESP32, ESP8266, Raspberry Pi y más, mediante una librería disponible para cada dispositivo y comunicarse con ThingSpeak en la nube, vía conexión HTTP o MQTT.
¿Es seguro este tráfico de datos?
Soporta TLS que permite el cifrado de tu transferencia de información entre dos puntos, tu dispositivo y ThingSpeak.
Una vez los datos estén subidos a ThingSpeak puede acceder a ellos a través de cualquier navegador (recomiendan Google Chrome) y tanto las Cookies, Pop-Ups y JavaScript deben estar activadas y lógicamente una conexión a Internet.
¿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 y efectivamente como estas pensando tenemos a la vista un problema de crecimiento en el futuro.
- 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
- Wemos D1 mini: es un ESP8266 donde la empresa/marca Lolin/Wemos ha encontrado un filón, ya que ha creado a su alrededor un monton de zócalos (shields), donde es posible añadirle funcionalidades sin gastar una gota de estaño, es mi favorito. Desde este dispositivo vamos a enviar datos a la nube de ThingSpeak.
- 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 Wemos D1 mini 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 Wemos D1 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.
Este es nuestro mapa
Ejemplo con ThingSpeak y ESP8266
Ya debes de tener claro la operativa. Si te parece vamos a empezar con la parte del ESP8266 y la extracción de datos que luego subiremos a ThingSpeak.
Ahora sí, empezamos a ensuciarnos las manos.
Paso 1. Comprar el dispositivo Wemos D1 mini
Tengo a mano un LOLIN D1 Mini V3.1.0, lo compré en el Lolin Official Store que tienen en AliExpress, pero ya no tiene ese mismo modelo, tienen el V4.
El V3 se puede encontrar en Amazon y también en AliExpress junto con otros modelos.
Paso 2. Configurar el dispositivo Wemos D1 mini ESP8266 en el IDE Arduino
Si no has trabajado nunca con un ESP8266 tienes que añadir la URL para tarjetas adicionales.
La URL es esta http://arduino.esp8266.com/stable/package_esp8266com_index.json
La añades en el IDE de Arduino, PREFERENCIAS + Gestor de URLs Adicionales de Tarjetas
Queda así:
Seleccionas la tarjeta en el menú de Herramientas + LOLIN(WEMOS) D1 R2 & mini
Abre un Archivo + Nuevo, el código por defecto nos viene bien, solo vas a probar que tienes comunicación con el ESP8266.
|
1 2 3 4 5 6 7 8 9 |
void setup() { // put your setup code here, to run once: } void loop() { // put your main code here, to run repeatedly: } |
Eliges el puerto correcto Herramientas + Puerto + depende de tu sistema operativo /dev/xx para Linux, Mac y COMx para los usuarios de Windows.
Y finalmente subimos el programa a la tarjeta, debe de salirte algo parecido a esto:
Ya tienes conectado correctamente el ESP8266 en tu IDE de Arduino, vamos a añadirle código.
Paso 3. Programación de los datos a subir a ThingSpeak
Acuérdate, 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.
Vamos al código, muy sencillo, lo he simplificado al máximo, simplemente cambiando los parámetros de tu conexión Wifi debe de funcionar. He comentado el código para que no te pierdas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
/* CharlyPascual Este codigo se conecta a tu red wifi y recoge dos tipos de datos: 1.- Realiza un ping a la IP 8.8.8.8 que es el DNS de Google ( podria ser cualquier IP) y recoge la latencia en milisegundos con la libreria ESP82666Ping. Esta libreria puede descargarse desde aqui https://github.com/dancol90/ESP8266Ping 2.- Ejecuta el metodo WiFi.RSSI() de la libreria ESP8266WiFi para darnos en dBm la calidad de la cobertura Wifi del sitio donde estes */ #include <ESP8266WiFi.h> #include <ESP8266Ping.h> // Configuracion Wifi, adaptalo a tu casa const char* ssid = "TU_SSID"; const char* password = "TU_CLAVE"; // IP a la que vas a realizar el ping (puedes poner cualquiera), pero separado por comas // y no por puntos const IPAddress remote_ip(8, 8, 8, 8); void setup() { Serial.begin(115200); // Empezamos conectandonos a la red WiFi Serial.println(); Serial.println(); Serial.print("Conectando "); Serial.println(ssid); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Indicamos los datos de conexión para el monitor serial Serial.println(""); Serial.println("Conectado WiFi"); Serial.println("Direccion IP: "); Serial.println(WiFi.localIP()); //Indicamos a la direccion IP a la que vamos a ejecutar el ping Serial.print("Pinging ip "); Serial.println(remote_ip); } void loop() { //Ejecutamos el metodo para saber la intensidad Wifi y lo asignamos a la variable rssi long rssi = WiFi.RSSI(); Serial.print("RSSI: "); Serial.print(rssi); Serial.println(" dBm"); //Ejecutamos el metodos para realizar el ping y el tiempo en milisegundos, lo //asignamos a la variable avg_time_ms if (Ping.ping(remote_ip)) { int avg_time_ms = Ping.averageTime(); Serial.println("ping OK!!"); Serial.print("Tiempo "); Serial.print(avg_time_ms); Serial.println(" ms"); } else { Serial.println("Error :("); } //Paramos 15 segundos delay(15000); } |
Subimos el código y aquí puedes ver los resultados desde el Serial Monitor del IDE Arduino.
Perfecto, esta parte está cerrada, ya tenemos a mano los datos que queremos subir a ThingSpeak.
Paso 4. Configurar el canal de ThingSpeak
Vas a crear una cuenta en ThingSpeak y configurar un canal. Su creación es muy simple, en un par de clics y rellenando una serie de datos lo tendremos disponible sin mayor complicación.
Creamos la cuenta en su página web pulsando en el botón Get Started For Free.
Clic en Create one!
Rellenas los datos que se piden
Verás un aviso, simplemente haz clic en la cajita si no tienes cuenta en MATLAB.
Te pide verificar tu correo electrónico y continuamos.
Añadimos una clave a nuestra cuenta, aceptamos el Acuerdo de Servicio (que nunca leemos) y continuamos.
Y termina el alta de la cuenta. Hasta aquí la parte alta en ThingSpeak.
Vamos a crear un canal para nuestros datos, clic en New Channel.
Rellena los datos, aparte del nombre y descripción del canal, lo que te interesa son los 8 campos de datos (Field 1….8). Tú en este caso solo vas a utilizar 2, que son los dos que debes de rellenar y clic en Save Channel (abajo del todo en la página).
Y ya lo tienes, configurar el entorno de ThingSpeak es muy sencillo.
De esta pantalla quedaros con 2 parámetros que son necesarios para subir datos desde tu Wemos D1 mini ESP8266 .
- Channel ID : 1641546
- API Keys : Write API Key C018D0EVH8HDDG0M (en la pestaña API Keys)
Y por el mismo precio os explico brevemente lo que estás viendo en esta pantalla:
- Private View: muestra la vista privada. Esta vista solo la puedes ver tú. Aquí se verán los datos de latencia e Intensidad que se envíen desde el Wemos ESP8266 en dos gráficas. Luego veremos cómo configurar estas gráficas.
- Public View: si el canal es público, en esta pestaña te muestra cómo se ve desde fuera. Puede ser interesante tener un canal público para compartir con amigos o clientes (en el caso de utilizar una licencia comercial).
- Channel Settings: aquí encontrarás la información del canal para poder modificarla. Puedes cambiar el nombre, la descripción o los campos que quieres emplear de este canal.
- Sharing: en esta opción puedes seleccionar si el canal es privado (por defecto) o si lo quieres hacer público.
- API Keys: algunos servicios requieren de unas claves para enviar y recibir datos. ThingSpeak es uno de ellos. Luego necesitaremos entrar en este apartado para obtener las API Keys de escritura.
- Data Import/Export: es la pestaña donde podrás importar o exportar datos de forma masiva.
Paso 5. Configurar Wemos ESP8266 para enviar datos a ThingSpeak
Un apunte, he modificado el código para que en vez de utilizar la función delay() utilices como temporizador la función millis(). Esta función nos permite acceder al reloj interno de Wemos D1 devolviendo el valor en milisegundos.
Esta es la actualización del código, el ejemplo vale para temporizar cualquier ejecución de tu programa. En este caso, tienes que modificar la variable intervaloEnvio indicando el tiempo en milisegundos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
//Temporizador ThingSpeak 15seg unsigned long ultimoTiempo = 0; // almacena la ultima vez que se lanzo nuestro evento unsigned long intervaloEnvio = 15000; //intervalo de ejecucion void loop() { // Comprobar si se ha dado la vuelta if (millis() < ultimoTiempo) { // Asignar un nuevo valor ultimoTiempo = millis(); } if ((millis() - ultimoTiempo) > intervaloEnvio) { // Marca de tiempo para el siguiente intervalo ultimoTiempo = millis(); //Ejecutamos el metodo para saber la intensidad Wifi y lo asignamos a la variable rssi long rssi = WiFi.RSSI(); Serial.print("RSSI: "); Serial.print(rssi); Serial.println(" dBm"); //Ejecutamos el metodos para realizar el ping y el tiempo en milisegundos, lo //asignamos a la variable avg_time_ms if (Ping.ping(remote_ip)) { int avg_time_ms = Ping.averageTime(); Serial.println("ping OK!!"); Serial.print("Tiempo "); Serial.print(avg_time_ms); Serial.println(" ms"); } else { Serial.println("Error :("); } } } |
Volvamos al tajo, la parte de extracción de datos ya la tienes hecha, también hemos mejorado la parte del intervalo de tiempo, acuérdate que la versión FREE que vamos a utilizar solo nos permite envío de datos cada 15 segundos.
Vamos a añadir la parte de ThingSpeak, lo primero que debes hacer es cargar la librería que ThingSpeak ha desarrollado para IoT.
Para ello solo la tienes que buscar en el Administrador de librerías del IDE de Arduino, clic en Herramientas + Administrador de Bibliotecas, rellenas el cambo de búsqueda y clic en Instalar.
Te cuento como va a ir esto:
Incluimos la librería ThingSpeak en el código.
|
1 |
#include "ThingSpeak.h" |
Indicamos los datos de acceso a tu canal ThingSpeak
|
1 2 3 |
//Datos acceso Canal ThingSpeak unsigned long myChannelNumber = TU_1641546; const char * myWriteAPIKey = "TU_C018D0EVH8HDDG0M"; |
Creamos un objeto de la clase WifiClient, objeto que utilizara la clase ThingSpeak para crear la petición HTTP y enviar la info a la nube de ThingSpeak.
|
1 |
WiFiClient client; |
Inicializamos la comunicación con ThingSpeak.
|
1 |
ThingSpeak.begin(client); // Inicializamos ThingSpeak |
Almacenamos los datos a enviar a ThingSpeak.
Acuérdate que hay un máximo de 8 campos de datos en variables de la clase ThingSpeak, como vamos a enviar dos tipos de datos tendremos dos líneas de código similares esta:
|
1 |
ThingSpeak.setField(numero, valor); |
Enviamos datos a ThingSpeak con los datos del canal que configuramos.
numeroCanal -> Channel ID
writeAPIKey -> APIKeys
|
1 |
ThingSpeak.writeFields(numeroCanal, writeAPIKey); |
Ahora toca modificar el código, creo que ya te hueles un poco por donde van a ir los tiros ¿te atreves a seguir por tu cuenta?. Es una buena práctica enfrentarse solo a un problema, si no, sigue leyendo.
Aqui lo tienes completo, comentado para que no te pierdas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
/* CharlyPascual Este codigo se conecta a tu red wifi y recoge dos tipos de datos 1.- Realiza un ping a la IP 8.8.8.8 que es el DNS de Google (podría ser cualquier IP) y recoge la latencia en milisegundos con la libreria ESP82666Ping. Esta libreria puede descargarse desde aqui https://github.com/dancol90/ESP8266Ping 2.- Ejecuta el metodo WiFi.RSSI() de la libreria ESP8266WiFi para darnos en dBm la calidad de la cobertura Wifi del sitio donde estes 3.- Gestiona a traves de la libreria ThingSpeak la subida de los valores de los datos anteriores a tu canal en la nube de ThingSpeak */ #include <ESP8266WiFi.h> #include <ESP8266Ping.h> #include "ThingSpeak.h" //Configuracion Wifi, adaptalo a tu caso const char* ssid = "TU_SSID"; const char* password = "TU_CLAVE"; WiFiClient client; //Datos acceso Canal ThingSpeak unsigned long numeroCanal = 1641546; const char * WriteAPIKey = "C018D0EVH8HDDG0M"; //Temporizador ThingSpeak XXseg unsigned long ultimoTiempo = 0; // almacena la ultima vez que se lanzo nuestro evento unsigned long intervaloEnvio = 20000; // 20 segundos int avg_time_ms; // variable global //IP a la que vas a realizar el ping (puedes poner cualquiera) const IPAddress remote_ip(8, 8, 8, 8); //const char* remote_ip = "www.google.com"; // ejemplo con nombre de dominio void setup() { Serial.begin(115200); // Empezamos conectandonos a la red WiFi Serial.println(); Serial.println(); Serial.print("Conectando "); Serial.println(ssid); WiFi.mode(WIFI_STA); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } //Indicamos los datos de conexión para el monitor serial Serial.println(""); Serial.println("Conectado WiFi"); Serial.print("Direccion IP: "); Serial.println(WiFi.localIP()); Serial.print("Pinging ip "); // Indicamos a la direccion IP a la que vamos a ejecutar el ping Serial.println(remote_ip); ThingSpeak.begin(client); // Inicializamos ThingSpeak } void loop() { // Comprobar si se ha dado la vuelta if (millis() < ultimoTiempo) { // Asignar un nuevo valor ultimoTiempo = millis(); } if ((millis() - ultimoTiempo) > intervaloEnvio) { // Marca de tiempo para el siguiente intervalo ultimoTiempo = millis(); // Ejecutamos el metodo para saber la intensidad Wifi y lo asignamos a la variable rssi long rssi = WiFi.RSSI(); Serial.print("RSSI: "); Serial.print(rssi); Serial.println(" dBm"); // Ejecutamos el metodos para realizar el ping y el tiempo en milisegundos, lo // asignamos a la variable avg_time_ms if (Ping.ping(remote_ip)) { avg_time_ms = Ping.averageTime(); Serial.println("ping OK!!"); Serial.print("Tiempo "); Serial.print(avg_time_ms); Serial.println(" ms"); } else { Serial.println("Error :("); } // Tenemos dos variables con son los datos a subir a ThingSpeak // rssi : mide la intensidad de la señal Wifi // avg_time_ms : mide la media de 5 ping ThingSpeak.setField(1, rssi); ThingSpeak.setField(2, avg_time_ms); // subimos los datos a nuestro canal en ThingSpeak //200 es el codigo tipico de una transmision OK en el protocolo HTTP int x = ThingSpeak.writeFields(numeroCanal, WriteAPIKey); if (x == 200) { Serial.println("Canal actualizado."); } else { Serial.println("Problema actualizando Canal, HTTP error code " + String(x)); } } } |
La salida del Serial Monitor.
El resultado de todo nuestro trabajo.
Resumen sobre ThinkSpeak
El código tiene recorrido, para ser óptimo debe de tener una mejor gestión de errores, podríamos utilizar la librería Ticker para gestionar el temporizador y por supuesto añadirle sensores de todo tipo.
Pero como has podido ver, no tiene mucho misterio, sobre todo la parte ThingSpeak, pero si profundizas, el tratamiento de los datos que puede hacerse desde ThingSpeak, es brutal. Incluso tiene un conector para que recibas mensajes a tu cuenta de Twitter.
La versión FREE tiene limitaciones que se le pueden dar una vuelta, por ejemplo, tengo 4 ESP8266 con mediciones de temperatura y humedad ¿podría incluirlas en un único canal?
Yo creo que si, no lo he probado, pero si logro sincronizar los relojes de cada uno de los ESP8266 puedo escribir en mi canal cada 15 segundos utilizando números de campo diferentes desde cada ESP8266. Esto se puede hacer con un cliente NTP.
El servicio NTP (Network Time Protocolo) se emplea comúnmente en todos los sistemas informáticos que deban estar sincronizados a nivel horario, en nuestro caso para los Arduinos y ESPxx existe librerías que nos pueden dar este servicio. Si buscas por NTP en el gestor de librerías del IDE Arduino, lo verás.
Es un poco rebuscado, pero seguro que no soy el primero que lo piensa, te cuento: 4 canales por 8 campos por canal, son 32 campos/datos que puedes subir si no eres muy exigente con los intervalos, un ejemplo con 8 campos distribuidos por cada ESP8266:
- ESP8266_1 — envio a los seg. 15 — campo 1 y 2
- ESP8266_2 — envio a los seg. 30 — campo 3 y 4
- ESP8266_3 — envio al os seg. 45 — campos 5 y 6
- ESP8266_4 — envio a los seg. 60 — campos 7 y 8
Cada minuto lanzarías 4 paquetes de datos a ThingSpeak, uno desde cada ESP8266 y separados 15 segundos entre ellos, al mismo Channel ID y Write API Key. Lo dejo como una posible práctica.
Si no, la versión HOME tiene buena pinta, por 75 € anuales tienes 10 canales a tu disposición, todo depende de tus intereses, ahí no puedo entrar.
Gracias por tu tiempo que también es oro.
Gracias a Depositphotos por la cesión de las imágenes.
