Esta página se ha traducido mediante traducción automática. Haga clic aquí para ver la última versión en inglés.

Sensor de humedad que utiliza solicitudes HTTP POST para canalizar

Este ejemplo muestra cómo publicar múltiples campos de datos en un canal ThingSpeak™ desde un dispositivo que se despierta del sueño profundo. Lees un sensor de humedad del suelo y publicas el valor en un canal de ThingSpeak. La solicitud HTTP POST se ejecuta escribiendo en un cliente de comunicación sin una biblioteca separada. Escribir directamente la solicitud HTTP al cliente de la red inalámbrica puede ofrecer mayor flexibilidad y velocidad en comparación con la biblioteca de comunicación ThingSpeak.

Hardware compatible

ESP8266-12
NodoMCU ESP8266-12
Arduino con conexión Ethernet o inalámbrica (con algunos ajustes de código)

En este ejemplo, el ADC integrado lee un sensor de humedad y publica el valor y el tiempo transcurrido en dos campos de un canal ThingSpeak. Puede modificar el POST para completar hasta ocho campos con datos.

Esta imagen muestra una planta de oficinas con un sensor de humedad conectado a un NodeMCU ESP8266-12. El NodeMCU proporciona una conexión de red inalámbrica. El sensor de humedad se alimenta mediante un pin de datos en la placa, que limita el tiempo que la alimentación del sensor está encendida. Este diseño reduce la energía y extiende la vida útil del sensor. Entre mediciones, todo el dispositivo se pone en modo de suspensión profunda para ahorrar energía. Una vez que los datos se publican en el canal, puede configurar reacciones a los datos. Por ejemplo, puede configurar la aplicación React para que le notifique que el nivel de humedad es bajo.

Requisitos previos

1) Cree un canal ThingSpeak, como se muestra en Collect Data in a New Channel.

2) En la pestaña Configuración de canal habilite el campo 1. Puede proporcionar un nombre de campo informativo como Moisture Value.

3) Tenga en cuenta la clave API de escritura desde la pestaña Claves API. Necesita este valor en el código utilizado para programar su dispositivo. Para obtener información adicional, consulte Channel Configurations y Channel Properties.

Hardware requerido

Placa basada en ESP8266 o placa Arduino con conexión a Internet (NodeMCU ESP8266-12E utilizado para esta demostración)
Sensor de humedad del suelo (por ejemplo, el Sparkfun Moisture Sensor)
Cables de puente (al menos 4)
cable USB

Esquema y Conexiones

1) Conecte el VCC del sensor de humedad al pin D7 del NodeMCU.

2) Conecte el sensor Gnd a la tierra del NodeMCU.

3) Conecte el pin Sig del sensor al pin A0 del NodeMCU.

4) Conecte el primer pin de NodeMCU al pin D0 de NodeMCU para permitir el despertar del sueño profundo.

Programe su dispositivo

1) Descargue el último IDE de Arduino®.

2) Agregue el paquete de placa ESP8266.

a) Ingrese https://arduino.esp8266.com/stable/package_esp8266com_index.json en URL adicionales de Board Manager en Archivo > Preferencias.

b) Elija Herramientas > Tableros > Administrador de tableros. Busque ESP8266 en la barra de búsqueda e instale el paquete.

3) Seleccione el puerto y la placa apropiados en el IDE de Arduino. El hardware utilizado para generar este ejemplo utilizó la opción Node MCU 1.0 (ESP 8266–12E) .

4) Crea la aplicación: Abra una nueva ventana en el IDE de Arduino y guarde el archivo. Agregue el código proporcionado en la sección Código. Asegúrese de editar la información de la red inalámbrica y la clave API en el código.

5) Después de cargar exitosamente su programa, puede monitorear la salida usando el monitor serial o la página de visualización de su canal.

Código

1) Incluya la biblioteca ESP8266WiFi e inicialice las variables para el hardware y la recopilación de datos. Edite la información de la red y escriba la clave API en su código.

#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) En la función setup , inicie el monitor serial, conéctese a la red inalámbrica e inicialice los pines del dispositivo que utiliza.

// 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) En el bucle principal, lea el monitor de suelo y guárdelo en la matriz data . PUBLICAR los datos en ThingSpeak y luego poner el dispositivo en modo de bajo 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) Utilice la función readSoil para proporcionar energía al sensor y luego lea el voltaje en la salida usando el ADC. Apague la alimentación después de la medición.

// 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) Conecte su dispositivo a la red inalámbrica usando la función 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) Cree la cadena de datos para publicar en su canal. Conéctese a ThingSpeak y use el cliente Wi-Fi para completar una 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) Espere y reciba la respuesta del servidor usando 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;
}

Puede determinar el rango útil de valores monitoreando su canal durante ciclos húmedos y secos. El número leído por el ADC y publicado en su canal es proporcional al voltaje y, por lo tanto, proporcional a la humedad del suelo. Los valores varían según la temperatura, la humedad y el tipo de suelo. Una vez que conozca los valores de suelo seco, puede usar la aplicación React para generar una notificación de que es hora de regar la planta. Para obtener más información sobre cómo configurar React, consulte React App.