Questa pagina è stata tradotta con la traduzione automatica. Fai clic qui per vedere l'ultima versione in inglese.

Sensore di umidità che utilizza richieste HTTP POST al canale

Questo esempio mostra come pubblicare più campi di dati su un canale ThingSpeak™ da un dispositivo che si riattiva dalla modalità di sospensione profonda. Leggi un sensore di umidità del suolo e pubblichi il valore su un canale ThingSpeak . La richiesta HTTP POST viene eseguita scrivendo su un client di comunicazione senza una libreria separata. La scrittura diretta della richiesta HTTP sul client della rete wireless può offrire maggiore flessibilità e velocità rispetto alla libreria di comunicazione ThingSpeak .

Hardware supportato

ESP8266-12
NodoMCU ESP8266-12
Arduino con connessione Ethernet o wireless (con alcune modifiche al codice)

In questo esempio, l'ADC integrato legge un sensore di umidità e invia il valore e il tempo trascorso in due campi di un canale ThingSpeak . È possibile modificare il POST per riempire fino a otto campi con dati.

Questa immagine mostra un ufficio con un sensore di umidità collegato a un NodeMCU ESP8266-12. Il NodeMCU fornisce una connessione di rete wireless. Il sensore di umidità è alimentato da un pin dati sulla scheda, che limita il tempo di accensione del sensore. Questo design riduce la potenza e prolunga la durata del sensore. Tra una misurazione e l'altra, l'intero dispositivo viene messo in modalità di sospensione profonda per risparmiare energia. Una volta pubblicati i dati sul canale, è possibile impostare le reazioni ai dati. Ad esempio, puoi impostare l'app React per avvisarti che il livello di umidità è basso.

Prerequisiti

1) Creare un canale ThingSpeak , come mostrato in Collect Data in a New Channel.

2) Nella scheda Impostazioni canale abilitare il campo 1. È possibile fornire un nome di campo informativo come Moisture Value.

3) Prendere nota della chiave API di scrittura dalla scheda Chiavi API . Questo valore è necessario nel codice utilizzato per programmare il tuo dispositivo. Per ulteriori informazioni, vedere Channel Configurations e Channel Properties.

Hardware richiesto

Scheda basata su ESP8266 o scheda Arduino con connessione Inernet (NodeMCU ESP8266-12E utilizzato per questa dimostrazione)
Sensore di umidità del suolo (ad esempio, Sparkfun Moisture Sensor)
Cavi di avviamento (almeno 4)
Cavo USB

Schema e collegamenti

1) Collegare VCC del sensore di umidità al pin D7 sul NodeMCU.

2) Collegare il sensore Gnd alla terra del NodeMCU.

3) Collegare il pin Sig del sensore al pin A0 del NodeMCU.

4) Collegare il pin Rst del NodeMCU al pin D0 del NodeMCU, per abilitare il risveglio dal sonno profondo.

Programma il tuo dispositivo

1) Scarica l'ultimo IDE Arduino®.

2) Aggiungi il pacchetto scheda ESP8266.

a) Inserisci https://arduino.esp8266.com/stable/package_esp8266com_index.json in URL aggiuntivi del Board Manager sotto File > Preferenze.

b) Scegli Strumenti > Bacheche > Gestore bacheche. Cerca ESP8266 nella barra di ricerca e installa il pacchetto.

3) Selezionare la porta e la scheda appropriate nell'IDE di Arduino. L'hardware utilizzato per generare questo esempio utilizzava l'opzione Node MCU 1.0 (ESP 8266–12E) .

4) Creare l'applicazione: Apri una nuova finestra nell'IDE di Arduino e salva il file. Aggiungi il codice fornito nella sezione Codice. Assicurati di modificare le informazioni sulla rete wireless e la chiave API nel codice.

5) Dopo aver caricato con successo il tuo programma, puoi monitorare l'output utilizzando il monitor seriale o la pagina di visualizzazione del canale.

Codice

1) Includere la libreria ESP8266WiFi e inizializzare le variabili per l'hardware e la raccolta dati. Modifica le informazioni di rete e scrivi la chiave API nel tuo codice.

#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) Nella funzione setup , avviare il monitor seriale, connettersi alla rete wireless e inizializzare i pin del dispositivo che si utilizza.

// 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) Nel ciclo principale, leggere il monitor del suolo e memorizzarlo nell'array data . PUBBLICA i dati su ThingSpeak, quindi metti il dispositivo in modalità di risparmio energetico.

// 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) Utilizzare la funzione readSoil per fornire alimentazione al sensore, quindi leggere la tensione in uscita utilizzando l'ADC. Spegnere l'alimentazione dopo la misurazione.

// 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) Connetti il tuo dispositivo alla rete wireless utilizzando la funzione 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) Costruisci la stringa di dati da pubblicare sul tuo canale. Connettiti a ThingSpeak e utilizza il client Wi-Fi per completare un POST HTTP.

// 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) Attendere e ricevere la risposta dal server utilizzando 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;
}

È possibile determinare l'intervallo di valori utile monitorando il canale durante i cicli umido e asciutto. Il numero letto dall'ADC e pubblicato sul tuo canale è proporzionale alla tensione e quindi proporzionale all'umidità del suolo. I valori variano a seconda della temperatura, dell'umidità e del tipo di terreno. Una volta che conosci i valori per il terreno asciutto, puoi utilizzare l'app React per generare una notifica che è ora di innaffiare la pianta. Per ulteriori informazioni sulla configurazione di React, vedere React App.