Main Content

Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l’originale in inglese.

Aggiornamento in blocco utilizzando un Arduino o un ESP8266

Apri live script

Questo esempio mostra come utilizzare una scheda Arduino® MKR1000 o una scheda ESP8266 connessa a una rete Wi-Fi® per raccogliere continuamente la potenza del segnale Wi-Fi e aggiornare in blocco un canale ThingSpeak™ .

È possibile utilizzare l'API Bulk-Write JSON Data per raccogliere dati in batch e inviarli ai canali ThingSpeak . Questa strategia riduce il consumo energetico dei tuoi dispositivi. In questo esempio, raccogli i dati una volta ogni 15 secondi e aggiorni il tuo canale una volta ogni 2 minuti utilizzando una scheda Arduino MKR1000. Poiché Arduino MKR1000 e la scheda ESP8266 non dispongono di un orologio in tempo reale, è possibile utilizzare il relativo timestamp per i messaggi di aggiornamento in blocco.

Impostazione

  1. Crea un canale come mostrato in Raccogli dati in un nuovo canale.

  2. Se stai utilizzando una scheda Arduino MKR1000, includi le librerie WiFi101.h e SPI.h nel tuo sketch Arduino. Se utilizzi una scheda ESP8266, includi le librerie EthernetClient.h e ESP8266WiFi.h nel tuo sketch Arduino

Codice

1) Inizia includendo le librerie appropriate per il tuo 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) Inizializzare jsonBuffer per contenere i dati JSON.

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

3) Definire le credenziali Wi-Fi per connettere la scheda Arduino alla rete e inizializzare la libreria client 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) Definire il server ThingSpeak .

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

5) Definire altre variabili globali che tengono traccia dell'ora dell'ultima connessione e dell'ora dell'ultimo aggiornamento. Inoltre, definire gli intervalli di tempo per aggiornare i dati e pubblicare i dati su 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) Utilizzare il metodo setup per inizializzare il trasferimento dati seriale e connettersi alla rete 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) Nel metodo loop , chiamare il metodo updatesJson per aggiornare jsonBuffer con i dati una volta al secondo.

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

8) Definire il metodo updatesJson per aggiornare continuamente il jsonBuffer con i dati. Poiché Arduino MKR1000 non dispone di un orologio in tempo reale, si utilizza il parametro 'delta_t' per definire un timestamp relativo in secondi tra i messaggi successivi. Se il tuo dispositivo è dotato di orologio in tempo reale, puoi utilizzare un timestamp assoluto. Sostituisci il parametro 'delta_t' con il parametro 'created_at' . Formatta i messaggi come JSON in un formato menzionato in Bulk-Write JSON Data. Chiama il metodo httpRequest per inviare dati a ThingSpeak una volta ogni 2 minuti.

// 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) Definire il metodo httpRequest per inviare dati a ThingSpeak e stampare il codice di risposta dal server. Un codice di risposta 202 indica che il server ha accettato la richiesta di precessione.

// 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) Definire il metodo printWiFiStatus per stampare l'indirizzo IP del dispositivo e la potenza del segnale.

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");
}

Esempi correlati

Ulteriori informazioni