Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la versión original en inglés.

Actualización masiva usando un Arduino o un ESP8266

Este ejemplo muestra cómo utilizar una placa Arduino® MKR1000 o una placa ESP8266 conectada a una red Wi-Fi® para recopilar continuamente la intensidad de la señal Wi-Fi y actualizar de forma masiva un canal ThingSpeak™.

Puede utilizar la API Bulk-Write JSON Data para recopilar datos por lotes y enviarlos a los canales de ThingSpeak. Esta estrategia reduce el uso de energía de sus dispositivos. En este ejemplo, recopila datos una vez cada 15 segundos y actualiza su canal una vez cada 2 minutos utilizando una placa Arduino MKR1000. Dado que la placa Arduino MKR1000 y ESP8266 no tienen un reloj en tiempo real, puede utilizar la marca de tiempo relativa para mensajes de actualización masiva.

Configuración

Cree un canal como se muestra en Recopilar datos en un nuevo canal.
Si está utilizando una placa Arduino MKR1000, incluya las bibliotecas WiFi101.h y SPI.h en su boceto Arduino. Si está utilizando una placa ESP8266, incluya las bibliotecas EthernetClient.h y ESP8266WiFi.h a su boceto Arduino

Código

1) Comience por incluir las bibliotecas apropiadas para su hardware.

// #include<EthernetClient.h> //Uncomment this library to work with ESP8266
// #include<ESP8266WiFi.h> //Uncomment this library to work with ESP8266

#include<SPI.h> // Comment this to work with ESP8266 board
#include<WiFi101.h> // Comment this to work with ESP8266 board

2) Inicialice el jsonBuffer para contener los datos JSON.

char jsonBuffer[500] = "["; // Initialize the jsonBuffer to hold data

3) Defina las credenciales de Wi-Fi para conectar su placa Arduino a la red e inicialice la biblioteca del cliente de Wi-Fi.

char ssid[] = "YOUR-NETWORK-SSID"; //  Your network SSID (name)
char pass[] = "YOUR-NETWORK-PWD"; // Your network password
WiFiClient client; // Initialize the Wi-Fi client library

4) Definir el servidor ThingSpeak.

char server[] = "api.thingspeak.com"; // ThingSpeak Server

5) Defina otras variables globales que realicen un seguimiento de la última hora de conexión y de la última actualización. Además, defina intervalos de tiempo para actualizar los datos y publicarlos en ThingSpeak.

/* Collect data once every 15 seconds and post data to ThingSpeak channel once every 2 minutes */
unsigned long lastConnectionTime = 0; // Track the last connection time
unsigned long lastUpdateTime = 0; // Track the last update time
const unsigned long postingInterval = 120L * 1000L; // Post data every 2 minutes
const unsigned long updateInterval = 15L * 1000L; // Update once every 15 seconds

6) Utilice el método setup para inicializar la transferencia de datos en serie y conectarse a la red Wi-Fi.

void setup() {
  Serial.begin(9600);
  // Attempt to connect to Wi-Fi network
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print("Attempting to connect to SSID: ");
    Serial.println(ssid);
    WiFi.begin(ssid, pass);  // Connect to WPA/WPA2 network. Change this line if using open or WEP network
    delay(10000);  // Wait 10 seconds to connect
  }
  Serial.println("Connected to Wi-Fi");
  printWiFiStatus(); // Print Wi-Fi connection information
}

7) En el método loop , llame al método updatesJson para actualizar el jsonBuffer con datos una vez por segundo.

void loop() {
  // If update time has reached 1 second, then update the jsonBuffer
  if (millis() - lastUpdateTime >=  updateInterval) {
    updatesJson(jsonBuffer);
  }
}

8) Defina el método updatesJson para actualizar continuamente el jsonBuffer con datos. Dado que Arduino MKR1000 no tiene un reloj en tiempo real, utiliza el parámetro 'delta_t' para definir una marca de tiempo relativa en segundos entre mensajes sucesivos. Si su dispositivo tiene un reloj en tiempo real, puede utilizar una marca de tiempo absoluta. Reemplace el parámetro 'delta_t' con el parámetro 'created_at' . Formatee los mensajes como JSON en un formato mencionado en Bulk-Write JSON Data. Llame al método httpRequest para enviar datos a ThingSpeak una vez cada 2 minutos.

// Updates the josnBuffer with data
void updatesJson(char* jsonBuffer){
  /* JSON format for updates parameter in the API
   *  This example uses the relative timestamp as it uses the "delta_t". 
   *  You can also provide the absolute timestamp using the "created_at" parameter instead of "delta_t".
   *  "[{\"delta_t\":0,\"field1\":-70},{\"delta_t\":3,\"field1\":-66}]"
   */
  // Format the jsonBuffer as noted above
  strcat(jsonBuffer,"{\"delta_t\":");
  unsigned long deltaT = (millis() - lastUpdateTime)/1000;
  size_t lengthT = String(deltaT).length();
  char temp[4];
  String(deltaT).toCharArray(temp,lengthT+1);
  strcat(jsonBuffer,temp);
  strcat(jsonBuffer,",");
  long rssi = WiFi.RSSI(); 
  strcat(jsonBuffer, "\"field1\":");
  lengthT = String(rssi).length();
  String(rssi).toCharArray(temp,lengthT+1);
  strcat(jsonBuffer,temp);
  strcat(jsonBuffer,"},");
  // If posting interval time has reached 2 minutes, update the ThingSpeak channel with your data
  if (millis() - lastConnectionTime >=  postingInterval) {
        size_t len = strlen(jsonBuffer);
        jsonBuffer[len-1] = ']';
        httpRequest(jsonBuffer);
  }
  lastUpdateTime = millis(); // Update the last update time
}

9) Defina el método httpRequest para enviar datos a ThingSpeak e imprimir el código de respuesta del servidor. Un código de respuesta 202 indica que el servidor ha aceptado la solicitud de preprocesamiento.

// Updates the ThingSpeakchannel with data
void httpRequest(char* jsonBuffer) {
  /* JSON format for data buffer in the API
   *  This example uses the relative timestamp as it uses the "delta_t".
   *  You can also provide the absolute timestamp using the "created_at" parameter instead of "delta_t".
   *  "{\"write_api_key\":\"YOUR-CHANNEL-WRITEAPIKEY\",\"updates\":[{\"delta_t\":0,\"field1\":-60},{\"delta_t\":15,\"field1\":200},{\"delta_t\":15,\"field1\":-66}]
   */
  // Format the data buffer as noted above
  char data[500] = "{\"write_api_key\":\"YOUR-CHANNEL-WRITEAPIKEY\",\"updates\":"; // Replace YOUR-CHANNEL-WRITEAPIKEY with your ThingSpeak channel write API key
  strcat(data,jsonBuffer);
  strcat(data,"}");
  // Close any connection before sending a new request
  client.stop();
  String data_length = String(strlen(data)+1); //Compute the data buffer length
  Serial.println(data);
  // POST data to ThingSpeak
  if (client.connect(server, 80)) {
    client.println("POST /channels/YOUR-CHANNEL-ID/bulk_update.json HTTP/1.1"); // Replace YOUR-CHANNEL-ID with your ThingSpeak channel ID
    client.println("Host: api.thingspeak.com");
    client.println("User-Agent: mw.doc.bulk-update (Arduino ESP8266)");
    client.println("Connection: close");
    client.println("Content-Type: application/json");
    client.println("Content-Length: "+data_length);
    client.println();
    client.println(data);
  }
  else {
    Serial.println("Failure: Failed to connect to ThingSpeak");
  }
  delay(250); //Wait to receive the response
  client.parseFloat();
  String resp = String(client.parseInt());
  Serial.println("Response code:"+resp); // Print the response code. 202 indicates that the server has accepted the response
  jsonBuffer[0] = '['; //Reinitialize the jsonBuffer for next batch of data
  jsonBuffer[1] = '\0';
  lastConnectionTime = millis(); //Update the last conenction time
}

10) Defina el método printWiFiStatus para imprimir la dirección IP de su dispositivo y la intensidad de la señal.

void printWiFiStatus() {
  // Print the SSID of the network you're attached to:
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // Print your device IP address:
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // Print the received signal strength:
  long rssi = WiFi.RSSI();
  Serial.print("signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

Ejemplos relacionados

Más acerca de

Bulk-Write JSON Data