Main Content

Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

Mise à jour en bloc d'un canal ThingSpeak à l'aide d'un panneau de photons à particules

Ouvrir le live script

Cet exemple montre comment utiliser une carte Particle Photon connectée à un réseau Wi-Fi® pour mettre à jour en bloc un canal ThingSpeak ™ . Vous pouvez utiliser l'API Bulk-Write JSON Data pour collecter des données par lots et les envoyer aux canaux ThingSpeak . En utilisant la mise à jour en bloc, vous pouvez réduire la consommation d'énergie de vos appareils. Dans cet exemple, vous collectez des données toutes les 15 secondes et mettez à jour votre canal une fois toutes les 2 minutes à l'aide d'une carte Particle Photon. Étant donné que le Particle Photon est livré avec une horloge en temps réel, vous pouvez utiliser l'horodatage absolu pour les messages de mise à jour en bloc.

Installation

1) Créez un canal, comme indiqué dans Collect Data in a New Channel.

Code

1) Définissez une limite d'un jour pour synchroniser l'heure à partir du nuage de particules.

#define ONE_DAY_MILLIS (24 * 60 * 60 * 1000) // Define 1 day limit for time synchronization
unsigned long lastSync = millis();

2) Initialisez le tampon data pour contenir les données.

char data[800] = ""; // Initialize the data buffer

3) Initialisez la bibliothèque cliente TCP.

TCPClient client; // Initialize the TCP client library

4) Définissez le serveur ThingSpeak , la clé d'API en écriture de votre canal et l'ID de votre canal .

String server = "api.thingspeak.com"; // ThingSpeak Server.
String WriteAPIKey = "YOUR-CHANNEL-WRITEAPIKEY"; // Replace YOUR-CHANNEL-WRITEAPIKEY with your channel write API key.
String ChannelID = "YOUR-CHANNEL-ID"; // Replace YOUR-CHANNEL-ID with your channel ID.

5) Créez des variables globales qui suivent l'heure de la dernière connexion et l'heure de la dernière mise à jour. Définissez ensuite des intervalles de temps pour mettre à jour les données et publiez les données sur 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.
size_t state = 0; // Keep note of first time the updateData() is called.

6) Ne modifiez pas la méthode par défaut setup.

void setup() {
}

7) Utilisez la méthode loop pour appeler la méthode updateData pour mettre à jour le tampon data avec les données une fois toutes les 15 secondes. Demandez également la synchronisation de l'heure à partir du nuage de particules une fois par jour.

void loop() {
    // If update time has reached 15 seconds, then update the data buffer
    if (millis() - lastUpdateTime >= updateInterval) {
      updateData();
  }
    // If last time synchronization is more than one day
    if (millis() - lastSync > ONE_DAY_MILLIS) {
    // Request time synchronization from the Particle Cloud
    Particle.syncTime();
    lastSync = millis();
  }
}

8) Définissez la méthode updateData pour mettre à jour en continu le tampon data avec les données. Étant donné que Particle Photon possède une horloge en temps réel intégrée, vous pouvez utiliser le temps absolu dans l'appel d'API. Utilisez le paramètre time_format=absolute pour définir des horodatages absolus entre les messages successifs. Si votre appareil ne dispose pas d'une horloge en temps réel, vous pouvez utiliser un horodatage relatif. Pour utiliser des horodatages relatifs, remplacez time_format=absolute par time_format=relative. Formatez les messages au format CSV comme mentionné dans Bulk-Write JSON Data. Appelez la méthode httpRequest pour envoyer des données à ThingSpeak toutes les deux minutes.

// Update the data buffer
void updateData(){
    /* CSV format to bulk update.
   *  This function uses the absolute timestamp as it uses the "time_format=absolute" parameter. If your device does not have a real-time clock, 
   *  you can also provide the relative timestamp in seconds using the "time_format=relative" parameter.
   */
    if(state==0){
        strcpy(data,"write_api_key="+WriteAPIKey+"&time_format=absolute&updates=");
    }
    strcat(data,String(Time.local())); // Absolute time stamp.
    strcat(data,"%2C"); // URL encoding for ","
    long randNumber = random(1,300);
    strcat(data,String(randNumber)); // Data to post to field 1.
    strcat(data,"%2C");
    randNumber = random(1,300);
    strcat(data,String(randNumber)); // Data to post to field 2.
    strcat(data,"%2C%2C%2C%2C%2C%2C%2C%2C"); //Include commas after fields 2-8 and lattitude for 8 commas.
    randNumber = random(1,300);
    strcat(data,String(randNumber)); // Mock data to post to longitude.
    strcat(data,"%2C%7C"); // URL encoding for ",|". End with | at the end of a message.
    state = 1; 
    // If posting interval time has reached 2 minutes, then update the ThingSpeak channel with your data.
    if (millis() - lastConnectionTime >= postingInterval) {
        state = 0;
        size_t len = strlen(data);
        data[len-3] = '\0'; // Remove the | from the last message.
        httpRequest(data); // Call httpRequest to send the data to ThingSpeak.
        data[0] = '\0'; // Reinitialise the data buffer.
    }
    lastUpdateTime = millis(); // Update the last update time.
}

9) Définissez la méthode httpRequest pour envoyer des données à ThingSpeak et imprimer le code de réponse du serveur. Le code de réponse 202 indique que le serveur a accepté la demande et traite les données.

// Update the ThingSpeakchannel with data.
void httpRequest(char* csvBuffer) {
     /* CSV format to bulk update.
      * This function posts the data to ThingSpeak server.
   */
    // Compute the data buffer length.
    String data_length = String(strlen(csvBuffer));
    // Close any connection before sending a new request.
    client.stop();
    // POST data to ThingSpeak
    if (client.connect(server, 80)) {
        client.println("POST /channels/"+ChannelID+"/bulk_update HTTP/1.1");
        client.println("Host: "+server);
        client.println("User-Agent: mw.doc.bulk-update (Particle Photon)");
        client.println("Connection: close");
        client.println("Content-Type: application/x-www-form-urlencoded");
        client.println("Content-Length: "+data_length);
        client.println();
        client.println(csvBuffer);
    }
    else {
        Particle.publish("Failure","Failed to update ThingSpeak channel");
    }
    delay(1000); // Wait to receive the response.
    client.parseFloat();
    String resp = String(client.parseInt());
    Particle.publish("Response code",resp); // Print the response code. 202 indicates that the server has accepted the response.
    lastConnectionTime = millis(); // Update the last conenction time.
}

Exemples associés

En savoir plus