Sensore di umidità che utilizza richieste HTTP POST al canale
Questo esempio mostra come post più campi di dati a un canale ThingSpeak ™ da un dispositivo che si riattiva dalla modalità di sospensione profonda. Si legge un sensore di umidità del terreno e post il valore a un canale ThingSpeak. La richiesta HTTP POST viene eseguita scrivendo su un client di comunicazione senza una libreria separata. Scrivere direttamente la richiesta HTTP al client della rete wireless può offrire maggiore flessibilità e velocità rispetto alla libreria di comunicazione ThingSpeak.
Hardware supportato
ESP8266-12
NodeMCU 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 a due campi di un canale ThingSpeak. È possibile modificare il POST per riempire fino a otto campi con dati.
Questa immagine mostra un impianto da 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 in cui il sensore rimane acceso. Questa progettazione riduce la potenza e prolunga la durata del sensore. Tra una misurazione e l'altra, l'intero dispositivo entra 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 in modo che ti avvisi quando il livello di umidità è basso.
Prerequisiti
1) Creare un canale ThingSpeak, come mostrato in Raccogliere dati in un nuovo canale.
2) Nella scheda Impostazioni canale , abilitare il campo 1. È possibile specificare un nome di campo informativo, ad esempio Moisture Value.
3) Annotare la chiave API di scrittura dalla scheda Chiavi API . Questo valore è necessario nel codice utilizzato per programmare il dispositivo. Per ulteriori informazioni, vedere Configurazioni dei canali e Proprietà dei canali.
Hardware richiesto
Scheda basata su ESP8266 o scheda Arduino con connessione Internet (per questa dimostrazione è stato utilizzato NodeMCU ESP8266-12E)
Sensore di umidità del terreno (ad esempio, il sensore di umidità Sparkfun)
Cavi jumper (almeno 4)
Cavo USB
Schema e connessioni
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 NodeMCU Rst al pin NodeMCU D0 per abilitare la riattivazione dalla modalità di sospensione profonda.
Programma il tuo dispositivo
1) Scarica l'ultima versione di Arduino IDE.
2) Aggiungere il pacchetto della scheda ESP8266.
a) Inserisci https://arduino.esp8266.com/stable/package_esp8266com_index.json in URL aggiuntivi del gestore bacheca in 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. Aggiungere il codice fornito nella sezione Codice. Assicurati di modificare le informazioni sulla rete wireless e la chiave API nel codice.
5) Dopo aver caricato correttamente il 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 utilizzati.
// 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. Invia i dati a ThingSpeak, quindi metti il dispositivo in modalità a basso consumo.
// 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. Dopo la misurazione, spegnere l'alimentazione.
// 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) Crea la stringa di dati da post sul tuo canale. Connettiti a ThingSpeak e usa il client Wi-Fi® per completare 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) Attendi e ricevi 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 utile di valori monitorando il canale durante i cicli di bagnato e asciutto. Il numero letto dall'ADC e inviato al tuo canale è proporzionale alla tensione e quindi proporzionale all'umidità del terreno. I valori variano a seconda della temperatura, dell'umidità e del tipo di terreno. Una volta conosciuti i valori del terreno asciutto, puoi usare l'app React per generare una notifica che ti avvisa che è il momento di annaffiare la pianta. Per maggiori informazioni sulla configurazione di React, vedere App React.
