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

Capteur d'humidité utilisant les requêtes HTTP POST au canal

Cet exemple montre comment publier plusieurs champs de données sur un canal ThingSpeak ™ à partir d'un appareil qui sort d'une veille prolongée. Vous lisez un capteur d'humidité du sol et publiez la valeur sur un canal ThingSpeak . La requête HTTP POST est exécutée en écrivant sur un client de communication sans bibliothèque séparée. L'écriture directe de la requête HTTP sur le client du réseau sans fil peut offrir une flexibilité et une vitesse accrues sur la bibliothèque de communication ThingSpeak .

Matériel pris en charge

ESP8266-12
NodeMCU ESP8266-12
Arduino avec connexion Ethernet ou sans fil (avec quelques ajustements de code)

Dans cet exemple, l'ADC intégré lit un capteur d'humidité et publie la valeur et le temps écoulé dans deux champs d'un canal ThingSpeak . Vous pouvez modifier le POST pour remplir jusqu'à huit champs avec des données.

Cette image montre une usine de bureau avec un capteur d'humidité câblé à un NodeMCU ESP8266-12. Le NodeMCU fournit une connexion réseau sans fil. Le capteur d'humidité est alimenté par une broche de données sur la carte, ce qui limite la durée d'alimentation du capteur. Cette design réduit la puissance et prolonge la durée de vie du capteur. Entre les mesures, l'ensemble de appareil est mis en mode veille profonde pour économiser de l'énergie. Une fois les données publiées sur le canal, vous pouvez configurer des réactions aux données. Par exemple, vous pouvez configurer l'application React pour qu'elle vous avertisse que le niveau d'humidité est bas.

"Conditions préalables"

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

2) Dans l'onglet Paramètres des canaux , activez le champ 1. Vous pouvez fournir un nom de champ informatif tel que Moisture Value.

3) Notez la clé d'API en écriture depuis l'onglet Clés API . Vous avez besoin de cette valeur dans le code utilisé pour programmer votre appareil. Pour plus d'informations, voir Channel Configurations et Channel Properties.

Matériel requis

Carte basée sur ESP8266 ou carte Arduino avec connexion Internet (NodeMCU ESP8266-12E utilisé pour cette démonstration)
Capteur d'humidité du sol (par exemple, le Sparkfun Moisture Sensor)
Fils de liaison (au moins 4)
cable USB

Schéma et connexions

1) Connectez VCC du capteur d'humidité à la broche D7 sur le NodeMCU.

2) Connectez le capteur Gnd à la masse du NodeMCU.

3) Connectez la broche Sig du capteur à la broche A0 du NodeMCU.

4) Connectez la broche NodeMCU Rst à la broche NodeMCU D0, pour activer le réveil du sommeil profond.

Programmez votre appareil

1) Téléchargez le dernier IDE Arduino®.

2) Ajoutez le package de carte ESP8266.

a) Entrez https://arduino.esp8266.com/stable/package_esp8266com_index.json dans URL de Board Manager supplémentaires sous Fichier > Préférences .

b) Choisissez Outils > Tableaux > Gestionnaire de tableaux . Recherchez ESP8266 dans la barre de recherche et installez le package.

3) Sélectionnez le port et la carte appropriés dans l'IDE Arduino. Le hardware utilisé pour générer cet exemple utilisait l'option Node MCU 1.0 (ESP 8266–12E).

4) Créez l'application : Ouvrez une nouvelle fenêtre dans l'IDE Arduino et enregistrez le fichier. Ajoutez le code fourni dans la section Code. Assurez-vous de modifier les informations sur le réseau sans fil et la clé d'API dans le code.

5) Une fois que vous avez réussi à télécharger votre programme, vous pouvez surveiller la sortie à l'aide du moniteur série ou de la page de vue des canaux .

Code

1) Incluez la bibliothèque ESP8266WiFi et initialisez les variables pour le hardware et la collecte de données. Modifiez les informations réseau et écrivez la clé d'API dans votre code.

#include <ESP8266WiFi.h>

// Network information.
#define WIFI_NAME "YOUR_WIFI_NAME"
#define PASSWORD "WIFI_PASSWORD"

// Hardware information.
#define SENSOR_POWER 13                            // Connect the power for the soil sensor here.
#define SOIL_PIN A0                                // Connect the sensor output pin here.
#define TIMEOUT  5000                              // Timeout for server response.
#define SLEEP_TIME_SECONDS 1800

// ThingSpeak information.
#define NUM_FIELDS 2                               // To update more fields, increase this number and add a field label below.
#define SOIL_MOISTURE_FIELD 1                      // ThingSpeak field for soil moisture measurement.
#define ELAPSED_TIME_FIELD 2                       // ThingSpeak field for elapsed time from startup.
#define THING_SPEAK_ADDRESS "api.thingspeak.com"
String writeAPIKey="XXXXXXXXXXXXXXXX";             // Change this to the write API key for your channel.

// Global variables. 
int numMeasure = 5;                                // Number of measurements to average.
int ADCValue = 0;                                  // Moisture sensor reading.
                         
WiFiClient client;

2) Dans la fonction setup, démarrez le moniteur série, connectez-vous au réseau sans fil et initialisez les broches de appareil que vous utilisez.

// Put your setup code here, to run once:
void setup()
{
    Serial.begin( 115200 );   // You may need to adjust the speed depending on your hardware.
    connectWifi();
    pinMode( SENSOR_POWER , OUTPUT );
    digitalWrite( SENSOR_POWER , LOW );   // Set to LOW so no power is flowing through the sensor.
}

3) Dans la boucle principale, lisez le moniteur de sol et stockez-le dans le tableau data. POSTez les données sur ThingSpeak, puis mettez l' appareil en mode basse consommation.

// Put your main code here, to run repeatedly:
void loop()
{
    // Write to successive fields in your channel by filling fieldData with up to 8 values.
    String fieldData[ NUM_FIELDS ];  

    // You can write to multiple fields by storing data in the fieldData[] array, and changing numFields.        
    // Write the moisture data to field 1.
    fieldData[ SOIL_MOISTURE_FIELD ] = String( readSoil( numMeasure ) ); 
    Serial.print( "Soil Moisture = " );
    Serial.println( fieldData[ SOIL_MOISTURE_FIELD ] );
    
    // Write the elapsed time from startup to Field 2.
    fieldData[ ELAPSED_TIME_FIELD ] = String( millis() ); 
    
    HTTPPost( NUM_FIELDS , fieldData );
    
    delay( 1000 );
    Serial.print( "Goodnight for "+String( SLEEP_TIME_SECONDS ) + " Seconds" );
    ESP.deepSleep( SLEEP_TIME_SECONDS * 1000000 );
    // If you disable sleep mode, add delay so you don't post to ThingSpeak too often.
    // delay( 20000 );
}

4) Utilisez la fonction readSoil pour alimenter le capteur, puis lisez la tension à la sortie à l'aide de l'ADC. Coupez l'alimentation après la mesure.

// This function reads the soil moisture sensor numAve times and returns the average.
long readSoil(int numAve)
{
  long ADCValue = 0;
  
  for ( int i = 0; i < numAve; i++ ) {
    digitalWrite( SENSOR_POWER, HIGH );  // Turn power to device on.
    delay(10);    // Wait 10 milliseconds for sensor to settle.
    ADCValue += analogRead( SOIL_PIN );     // Read the value from sensor.
    digitalWrite( SENSOR_POWER, LOW );   // Turn power to device off.
  }
  
  ADCValue = ADCValue / numAve;
  return ADCValue;                    // Return the moisture value.
}

5) Connectez votre appareil au réseau sans fil à l'aide de la fonction connectWiFi.

// Connect to the local Wi-Fi network
int connectWifi()
{
    
    while (WiFi.status() != WL_CONNECTED) {
        WiFi.begin( WIFI_NAME , PASSWORD );
        Serial.println( "Connecting to Wi-Fi" );
        delay( 2500 );
    }
    Serial.println( "Connected" );  // Inform the serial monitor.
}

6) Créez la chaîne de caractère de données à publier sur votre canal. Connectez-vous à ThingSpeak et utilisez le client Wi-Fi pour effectuer un HTTP POST.

// This function builds the data string for posting to ThingSpeak
    // and provides the correct format for the wifi client to communicate with ThingSpeak.
    // It posts numFields worth of data entries, and takes the
    // data from the fieldData parameter passed to it. 
  
int HTTPPost( int numFields , String fieldData[] ){
  
    if (client.connect( THING_SPEAK_ADDRESS , 80 )){

       // Build the postData string.  
       // If you have multiple fields, make sure the sting does not exceed 1440 characters.
       String postData= "api_key=" + writeAPIKey ;
       for ( int fieldNumber = 1; fieldNumber < numFields+1; fieldNumber++ ){
            String fieldName = "field" + String( fieldNumber );
            postData += "&" + fieldName + "=" + fieldData[ fieldNumber ];
            
            }

        // POST data via HTTP.
        Serial.println( "Connecting to ThingSpeak for update..." );
        Serial.println();
        
        client.println( "POST /update HTTP/1.1" );
        client.println( "Host: api.thingspeak.com" );
        client.println( "Connection: close" );
        client.println( "Content-Type: application/x-www-form-urlencoded" );
        client.println( "Content-Length: " + String( postData.length() ) );
        client.println();
        client.println( postData );
        
        Serial.println( postData );
        
        String answer=getResponse();
        Serial.println( answer );
    }
    else
    {
      Serial.println ( "Connection Failed" );
    }
    
}

7) Attendez et recevez la réponse du serveur en utilisant getResponse.

// Wait for a response from the server indicating availability,
// and then collect the response and build it into a string.

String getResponse(){
  String response;
  long startTime = millis();

  delay( 200 );
  while ( client.available() < 1 && (( millis() - startTime ) < TIMEOUT ) ){
        delay( 5 );
  }
  
  if( client.available() > 0 ){ // Get response from server.
     char charIn;
     do {
         charIn = client.read(); // Read a char from the buffer.
         response += charIn;     // Append the char to the string response.
        } while ( client.available() > 0 );
    }
  client.stop();
        
  return response;
}

Vous pouvez déterminer la plage de valeurs utiles en surveillant votre canal sur des cycles humides et secs. Le nombre lu par l'ADC et affiché sur votre canal est proportionnel à la tension, et donc proportionnel à l'humidité du sol. Les valeurs varient en fonction de la température, de l'humidité et du type de sol. Une fois que vous connaissez les valeurs du sol sec, vous pouvez utiliser l'application React pour générer une notification indiquant qu'il est temps d'arroser la plante. Pour plus d'informations sur la configuration de React, voir React App.