Gestión de un invernadero o invernadero desde cualquier parte del mundo (ejemplo de implementación)

El propósito de este desarrollo es recopilar datos de sensores locales, enviar estos datos a Internet. El usuario podrá ver en cualquier parte del mundo los datos provenientes de los sensores y decidir de forma remota la activación de ciertos actuadores que se ubicarán localmente, junto a los sensores.

El proyecto usa Arduino UNO y módulo WiFi ESP8266-01. Los datos se transmitirán a la nube a través del servicio web ThingSpeak.com, y los dispositivos se activarán a través de la aplicación de Android desarrollada utilizando el MIT AppInventor.





El enfoque principal de este proyecto de IoT será el servicio ThingSpeak.com. El dispositivo local UNO / ESP-01 recibe datos de sensores y datos sobre el estado de los actuadores, los envía a Internet "grabando" a través de un canal de estado específico de ThingSpeak.com (ThingSpeak.com Status Channel), el mismo dispositivo local recibe datos ". leerlos "desde otro canal de datos:" el canal de dispositivos ejecutivos "(ThingSpeak.com Actuator Channels).



Los datos se recopilarán utilizando un sensor de temperatura y humedad relativa, temperatura y humedad del suelo y un sensor de luz ambiental. Estos datos se enviarán a la nube del servicio ThingSpeak.

Habrá dos dispositivos ejecutivos: esta es una bomba eléctrica de agua y una lámpara. Su estado ON / OFF también se enviará a la nube. Los datos de los sensores, por ejemplo, pueden mostrar el estado actual de un invernadero o invernadero. El usuario controlará los dispositivos ejecutivos utilizando la aplicación de Android.




Todos los enlaces son solo para fines informativos.






2 x LED (rojo y verde)
1 x
- $3.00
Lámpara 220V
2 x resistencia de 330 ohmios (utilizada con LED)
2 x resistencia de 10K ohmios (utilizada con DHT22 y LDR)
1 x resistencia 4K7 ohm (utilizada con DS18B20)
Tablero de pan
Puentes
Fuente de alimentación externa para relé 5V DC



Ahora necesita conectar todos los sensores, como se muestra en el diagrama.



La solución ideal sería ensamblar y probar el proyecto en partes.

En la siguiente secuencia:
1. Instale y pruebe todos los sensores
2)Instalar y configurar mínimo ESP-01
3. Cambie la configuración ESP-01 a la configuración final y pruebe
4. Configure el canal de estado de ThingSpeak
5. Instale el código ThingSpeak en Arduino y verifique el estado de los sensores en la nube
6. Desarrolle la primera versión del programa en Android para verificar los mensajes de estado de los sensores
7. Instalar actuadores
8. Configurar canales de actuadores ThingSpeak
9. Instalar y probar código para dispositivos ejecutivos en Arduino
10. Haga la segunda versión del programa en Android para todo el ensamblaje del dispositivo.



El proyecto utiliza algunas bibliotecas incluidas en. Es necesario verificar su disponibilidad. La configuración inicial de estas bibliotecas es la siguiente:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 en el pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int sueloTemp = 0;

// DHT
# incluye "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (ligero)
#define ldrPIN 1
int luz = 0;

// Humedad del suelo
#definir sueloHUMPIN 0
int sueloHum = 0;

Ahora inicializamos nuestros sensores y los mostramos en el terminal:

configuración nula ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

bucle vacío ()
{
  readSensors ();
  displaySensors ();
  retraso (10000);
}

Y finalmente, escribiremos dos funciones: una lee las lecturas de los sensores y la otra las muestra en la pantalla:

/ ********* Leer el valor de los sensores ************* /
lectura vacía Sensores (vacío)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // El sensor 0 capturará la temperatura del suelo en Celcius
  
  sueloHum = mapa (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> ligero 100%

}

/ ********* Display Sensores value ************* /
pantalla vacía Sensores (vacío)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (soilTemp);
  Serial.print ("sueloHum (%):");
  Serial.println (sueloHum);
  Serial.print ("light (%):");
  Serial.println (luz);
  Serial.println ("");
}

La foto muestra cómo se muestran los datos en la pantalla.


El código fuente se puede descargar del autor.



La forma más rápida de "hablar" con el módulo es el comando AT. El procesador ya tiene un procesador de comando AT. Por defecto, el módulo viene con configuraciones de fábrica de 115200 baudios, necesita establecer 9600 baudios en las configuraciones.

En primer lugar, debe conectar el módulo, como se muestra en la foto.



( Tenga en cuenta que el terminal Tx del ESP-01 está conectado al terminal Tx de UNO, al igual que los terminales Rx están conectados entre sí. Esta conexión se cambiará más tarde. ).

Luego conecte UNO a la computadora, abra el IDE y descargue el ejemplo que se encuentra. Este es un código vacío para que no haya conflictos entre ESP-01 y UNO. Este código se cargó en Ardunio antes de conectarle el ESP-01, para asegurarse de que Ardunio no utilizará los pines Tx y Rx para nada más.
Ahora debe abrir el monitor serie IDE, establecer la velocidad en baudios en 115200 en la configuración y enviar el comando AT al monitor serie IDE. ESP-01 debería enviar una respuesta OK

Ahora necesita cambiar la velocidad de datos en el módulo ESP-01. Para hacer esto, en el IDE, dé el comando

AT + CIOBAUD = 9600

Puede suceder que el ESP-01 vuelva a la configuración de fábrica, luego deberá usar otro comando:

AT + UART_DEF = , , , , 

Por ejemplo 9600 baudios / 8 bits de datos / 1 bits de parada y ninguno control de paridad y flujo

AT + UART_DEF = 9600,8,1,0,0

Ahora cambie la velocidad de transferencia de datos en la configuración IDE a 9600 y envíe el comando AT, la respuesta correcta debería venir.
A continuación, debe cambiar el módulo al modo STA para que pueda conectarse al punto de acceso de su red.

AT + CWMODE = 1

Para que el módulo se conecte a la red, ingrese el comando AT + CWJAP = "nombre de red", "nombre de red_1"donde nombre_de_red Es el nombre de su red y nombre_de_ red_1 - contraseña para su red (la contraseña y el nombre de la red deben estar entre comillas)
Si ves la respuesta WIFI CONECTADO WIFI GOT IP, entonces se establece la conexión. Verifique la dirección IP con el comando

AT + CIFSR

.

La dirección que aparece en su monitor, puede usar en el futuro. Una vez que haya configurado el módulo, puede conectarlo permanentemente, pero para esto necesita cambiar su circuito de conmutación, como se muestra en la figura.


• ESP-01 RX (Amarillo) -> UNO Pin D7
• ESP-01 TX (Naranja) -> UNO Pin D6
• ESP-01 Ch-Pd (Marrón) -> Vcc (3.3V)
• Reinicio ESP-01 (Azul) -> UNO Pin D8
• ESP-01 Vcc (rojo) -> 3.3V
• ESP-01 Gnd (Negro) -> UNO GND

Tenga en cuenta que la biblioteca de software de serie utiliza el pin UNO Pin D7 como tx y se conecta a la salida de ESP-01 Rxmientras que UNO Pin D6 como rxconectado a ESP-01 TX.

Ingrese un código pequeño para verificar la conexión y configuración correctas del módulo ESP-01

#include 
Software Serie esp8266 (6.7); // Rx ==> Pin 6; TX ==> Pin7

#define speed8266 9600

configuración nula ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("Prueba de configuración ESP8266 - usar comandos AT");
}

bucle vacío ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Ahora unos pocos equipos AT. Vea los resultados en el Monitor de serie.



* AT =====> ESP8266 devuelve OK
* AT + RST =====> ESP8266 reinicia y devuelve OK
* AT + GMR =====> ESP8266 devuelve la versión AT; Versión SDK; id; Ok
* AT + CWMODE? => ESP8266 devuelve el tipo de modo
* AT + CWLAP ===> ESP8266 devuelve puntos de acceso cercanos
* AT + CIFSR ===> ESP8266 devuelve IP designada

El código del programa se puede descargar en

6 conexión de sensores y ESP-01

Una vez que todos los sensores están conectados y verificados, así como el módulo ESP-01 está marcado, es necesario preparar los datos para enviarlos a Internet.





Una de las partes más importantes del proyecto es la plataforma abierta de IoT, que le permitirá recopilar datos de sensores, procesarlos y analizarlos. Para hacer esto, vaya y cree su cuenta. A continuación, debe crear un canal donde habrá 2 actuadores, 5 sensores y un campo de respaldo.
• Campo 1: Actuador 1 (dispositivo 1)
• Campo 2: Actuador 2 (dispositivo 2)
• Campo 3: Temperatura del aire en oC (temperatura del aire en grados Celsius)
• Archivado 4: Humedad relativa del aire en% (Humedad relativa en%)
• Campo 5: Temperatura del suelo en oC (Temperatura del suelo en gr. Celsius)
• Campo 6: Humedad del suelo en% (humedad del suelo en%)
• Campo 7: Luminosidad en% (iluminación en%)
• Campo 8: repuesto

El campo 8 está reservado para futuras expansiones o para depuración. En este proyecto, se utiliza como contador de errores de comunicación entre Arduino / ESP-01 y ThingSpeak.com.

Una vez que haya creado el Canal de estado, debe grabar las claves, como se muestra en la foto.



Por el momento, tenemos un servicio en la nube configurado y nuestros sensores recopilan datos localmente. Ahora debe tomar estos datos y enviarlos a la nube en ThingSpeak.com.

Para escribir datos en el canal ThingSpeak, debe enviar una cadena GET. Esto se hará en tres etapas.
Enviar el comando "Iniciar cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Longitud de cuerda adicional

AT + CIPSEND = 116

Y finalmente, una cadena GET que escribirá nuestros datos en los campos reservados del Canal de estado.

OBTENER / actualizar? Api_key = Your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Tenga en cuenta que no debemos escribir datos en el canal más de 1 vez en 16 segundos.

El código enviado hará todo esto.

// Thingspeak
String statusChWriteKey = "SU CLAVE DE ESCRITURA AQUÍ"; // Identificación del canal de estado: 385184

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 en el pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int sueloTemp = 0;

// DHT
# incluye "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (ligero)
#define ldrPIN 1
int luz = 0;

// Humedad del suelo
#definir sueloHUMPIN 0
int sueloHum = 0;

// Variables para usar con temporizadores
largo writeTimingSeconds = 17; // ==> Definir tiempo de muestra en segundos para enviar datos
largo startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variables para usar con actuadores
bomba booleana = 0;
lámpara booleana = 0;

int repuesto = 0;
error booleano;

configuración nula ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startWriteTiming = millis (); // iniciando el "reloj del programa"
}

bucle vacío ()
{
  inicio: // etiqueta
  error = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Reenviar si la transmisión no se completa
  {
    Serial.println ("<<<< ERROR >>>>");
    retraso (2000);
    ir a inicio; // ir a la etiqueta "inicio"
  }
}

/ ********* Leer el valor de los sensores ************* /
lectura vacía Sensores (vacío)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // El sensor 0 capturará la temperatura del suelo en Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> ligero 100%
  sueloHum = mapa (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
Void writeThingSpeak (nulo)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = Cadena (bomba);
  getStr + = "& field2 =";
  getStr + = Cadena (lámpara);
  getStr + = "& field3 =";
  getStr + = Cadena (airTemp);
  getStr + = "& field4 =";
  getStr + = Cadena (airHum);
  getStr + = "& field5 =";
  getStr + = String (soilTemp);
  getStr + = "& field6 =";
  getStr + = Cadena (sueloHum);
  getStr + = "& field7 =";
  getStr + = Cadena (luz);
  getStr + = "& field8 =";
  getStr + = Cadena (repuesto);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Restablecer ESP ************* /
vacío EspHardwareReset (vacío)
{
  Serial.println ("Reseteando .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retraso (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necesario para começar a ler
  Serial.println ("RESET");
}

/ ********* Iniciar comunicación con ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Cadena cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Error"))
  {
    Serial.println ("error AT + CIPSTART");
    volver
  }
}

/ ********* enviar un cmd GET a ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Cadena cmd = "AT + CIPSEND =";
  cmd + = Cadena (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> cmd longitud:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo para processar o GET, sem este delay apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Línea de cadena = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// el contenido real comienza después de una línea vacía (que tiene una longitud 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody recibido:");
    Serial.println (messageBody);
    return messageBody;
  }
  otra cosa
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerta al usuario
    Serial.println ("ESP8266 ERROR CIPSEND: RESENDING"); // Reenviar ...
    repuesto = repuesto + 1;
    error = 1;
    devolver "error";
  }
}

Puede ver el progreso en el Monitor de serie.

El código fuente se puede descargar en



Primero necesitas crear una interfaz de usuario. La imagen muestra los principales elementos visibles e invisibles.



Después de eso, necesitas crear bloques. Los elementos del menú corresponden a los números de captura de pantalla.

1 Variables de estado que deben declararse como globales

2 Cada dos segundos (según Clock1) se llama un procedimiento "leer Arduino"


El procedimiento devuelve el valor de las variables que deberían mostrarse en la pantalla. En este caso, el valor de estado (0 y 1) para los actuadores se convierte en "ON" y "OFF" para una mejor percepción.

Estos valores (Estado) se mostrarán en los "Accesos directos" correspondientes

3 La rutina readArduino esencialmente leerá el canal de estado en ThingSpeak. Por lo tanto, debe determinar la URL que se enviará a Thingspeak. Para hacer esto, se deben declarar y combinar 3 variables globales para crear la URL que se enviará a ThingSpeak. GET debe enviarse a un componente web llamado "ArduFarmBotStatusCh"

4 El texto recibido del comando anterior llegará en formato JSon. Este texto debe procesarse para que cada campo se lea y se almacene en la variable global correspondiente.

5 Lo último que debe hacer es llamar al procedimiento de "Alarma", que analizará el estado de dos sensores de suelo. Si la temperatura es demasiado baja (en nuestro caso 10oC), se debe mostrar un mensaje. Lo mismo para la humedad si está por debajo del 60%.

Tenga en cuenta que hemos definido otro temporizador (Clock2), programado para que se ejecute cada segundo. Solo es necesario "cambiar" el color del texto del mensaje (de blanco a rojo). El mensaje parpadeará.

El código de la aplicación se puede descargar en




Los comandos para encender y apagar la bomba y la lámpara se recibirán de forma remota. La salida de Ardunio activará el relé y el LED, tomando estos comandos. La imagen muestra cómo deben conectarse los actuadores. Tenga en cuenta que la salida de relé GND NO CONECTADO a la salida GNDUNO De esta manera, habrá menos interferencia de potencia cuando el relé esté funcionando.




Todas las acciones repiten el procedimiento para configurar el canal de estado. Es necesario crear dos canales para cada uno de los dispositivos. Para cada canal, escriba las teclas ID de canal, Lectura y Escritura. Solo escribiremos en el primer campo de cada canal. Por un ejemplo:
ID de canal 375598 ==> LED rojo (bomba)
◦ Campo1 = 0 ==> Bomba apagada
◦ Campo1 = 1 ==> Bomba ENCENDIDA
2. ID de canal 375599 ==> LED verde (lámpara)
◦ Campo1 = 0 ==> Lámpara apagada
◦ Campo1 = 1 ==> Lámpara ENCENDIDA



Cuando enviamos datos a la nube, "escribimos" estos datos en ThingSpeak. Canal de estado, "transmitiendo" (cargando) estos datos. Ahora tenemos que "leer" los datos del canal del actuador, "aceptar" (descargar) estos datos.

Para hacer esto, envíe una cadena GET y este procedimiento consta de 3 etapas.
"Iniciar cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Longitud de la línea

AT + CIPSEND = 36

Y la cadena GET en sí

GET / canales / 375598 / fields / 1 / last

Los canales serán "leídos" cada 10 segundos

Después de enviar el GET, debemos aceptar la respuesta de ThingSpeak. La respuesta debe ser 0 o 1, para cada canal. Si hay otros valores, simplemente los ignoramos.

La principal diferencia entre esta parte y la anterior está solo en la función readThingSpeak (String channelID)
A continuación se muestra el código que realiza las acciones descritas.

// Thingspeak
String canalID1 = "999999"; // Actuador1
String canalID2 = "999999"; // Actuador2

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// Variables para usar con temporizadores
largo readTimingSeconds = 10; // ==> Definir tiempo de muestra en segundos para recibir datos
largo startReadTiming = 0;
long elapsedReadTime = 0;

// Relés
#define ACTUATOR1 10 // LED ROJO ==> Bomba
#define ACTUATOR2 12 // LED VERDE ==> Lámpara
bomba booleana = 0;
lámpara booleana = 0;

int repuesto = 0;
error booleano;

configuración nula ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

  digitalWrite (ACTUATOR1, HIGH); // o módulo relé é ativo em LOW
  digitalWrite (ACTUATOR2, HIGH); // o módulo relé é ativo em LOW
  digitalWrite (HARDWARE_RESET, HIGH);

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startReadTiming = millis (); // iniciando el "reloj del programa"
}

bucle vacío ()
{
  inicio: // etiqueta
  error = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    comando int = readThingSpeak (canalID1);
    if (comando! = 9) bomba = comando;
    retraso (5000);
    comando = readThingSpeak (canalID2);
    if (comando! = 9) lámpara = comando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Reenviar si la transmisión no se completa
  {
    Serial.println ("<<<< ERROR >>>>");
    retraso (2000);
    ir a inicio; // ir a la etiqueta "inicio"
  }
}

/ ********* Tomar acciones basadas en los comandos de ThingSpeak ************* /
anular takeActions (nulo)
{
  Serial.print ("Bomba:");
  Serial.println (bomba);
  Serial.print ("Lámpara:");
  Serial.println (lámpara);
  if (bomba == 1) digitalWrite (ACTUATOR1, LOW);
  de lo contrario digitalWrite (ACTUATOR1, HIGH);
  if (lámpara == 1) digitalWrite (ACTUATOR2, LOW);
  de lo contrario digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Leer el comando Actuadores de ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  comando int;
  // preparacao da string GET
  Cadena getStr = "GET / canales /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (mensajeAbajo [5] == 49)
  {
    comando = mensajeAbajo [7] -48;
    Serial.print ("Comando recibido:");
    Serial.println (comando);
  }
  comando else = 9;
  comando de retorno;
}

/ ********* Restablecer ESP ************* /
vacío EspHardwareReset (vacío)
{
  Serial.println ("Reseteando .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retraso (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necesario para começar a ler
  Serial.println ("RESET");
}

/ ********* Iniciar comunicación con ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Cadena cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Error"))
  {
    Serial.println ("error AT + CIPSTART");
    volver
  }
}

/ ********* enviar un cmd GET a ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Cadena cmd = "AT + CIPSEND =";
  cmd + = Cadena (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> cmd longitud:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo para processar o GET, sem este delay apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Línea de cadena = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// el contenido real comienza después de una línea vacía (que tiene una longitud 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody recibido:");
    Serial.println (messageBody);
    return messageBody;
  }
  otra cosa
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerta al usuario
    Serial.println ("ESP8266 ERROR CIPSEND: RESENDING"); // Reenviar ...
    repuesto = repuesto + 1;
    error = 1;
    devolver "error";
  }
}

Puedes descargarlo en



En esta etapa, tenemos un canal de actuador configurado que cambia el valor del campo 1 para cada dispositivo. Debemos verificar que los dispositivos resuelvan los comandos correctamente. Al final del proyecto, se usará una aplicación de Android para esto, pero también se puede hacer a través de un navegador.

Encienda la bomba (LED rojo encendido)

https://api.thingspeak.com/update?api_key=Saved_channel_key_1&field1=1

Bomba apagada (LED rojo apagado)

https://api.thingspeak.com/update?api_key=Saved Channel_key_1 & field1 = 0

Encienda la lámpara (el LED verde está encendido)

https://api.thingspeak.com/update?api_key=Saved_channel_key_2&field1=1

Apague la lámpara (LED verde apagado)

https://api.thingspeak.com/update?api_key=Saved Channel_key_2 & field1 = 0

En la parte anterior había un programa simple que "leía" los datos del canal y los mostraba en la pantalla. Ahora tenemos que hacer que el programa "escriba" los comandos en Actuator Channal, para que el controlador pueda leer estos comandos y la lámpara con la bomba funcionó en consecuencia.

Para que el usuario pueda enviar comandos, la aplicación tendrá dos botones para cada dispositivo. Si está encendido, azul; si está apagado, rojo.

Al hacer clic en los botones de la aplicación, puede ver el resultado en el Monitor de serie.

El código se puede descargar en



En esta etapa, hay una aplicación de Android completamente completa, una parte de "hierro" completamente ensamblada, pero no hay código en el controlador que lea constantemente los datos y envíe comandos a la nube. Solo necesita combinar todos los fragmentos del código escrito anteriormente. Por supuesto, el código tiene opciones de verificación adicionales (por ejemplo, si ESP-01 se congela). Para hacer esto, periódicamente, antes de cada comando de lectura o escritura, se envía un comando AT.Y si la respuesta OK no vino del módulo, entonces el módulo se reinicia por la fuerza del software.

El código completo del proyecto se puede descargar en

En la dirección puede obtener actualizaciones para los archivos de programa.

También puede leer los comentarios en el enlace a la fuente, si algo no está claro.