Gestió d’un hivernacle o hivernacle des de qualsevol part del món (exemple d’implementació)

L’objectiu d’aquest desenvolupament és recollir dades de sensors locals, enviar aquestes dades a Internet. L’usuari podrà veure qualsevol part del món per visualitzar les dades procedents dels sensors i decidir de forma remota l’activació de determinats actuadors que es trobaran localment al costat dels sensors

El projecte utilitza Arduino Mòdul UNO i WiFi ESP8266-01. Les dades es transmetran al núvol a través del servei web ThingSpeak.com i els dispositius s’activaran a través de l’aplicació d’android desenvolupada mitjançant l’aplicació MIT AppInventor.





L’objectiu principal d’aquest projecte IoT serà el servei ThingSpeak.com. El dispositiu local UNO / ESP-01 rep dades de sensors i dades sobre l’estat dels actuadors, les envia a Internet “enregistrant” a través d’un canal d’estat específic de ThingSpeak.com (ThingSpeak.com Status Channel), el mateix dispositiu local rep dades, " llegint-los des d’un altre canal de dades, “el canal dels dispositius executius” (ThingSpeak.com Actuator Channel).



Les dades es recopilaran mitjançant un sensor de temperatura i humitat relativa, temperatura i humitat del sòl i un sensor de llum ambiental. Aquestes dades s’enviaran al núvol de servei ThingSpeak.

Hi haurà dos dispositius executius: es tracta d’una bomba elèctrica d’aigua i una làmpada. El seu estat d’encesa / apagada també s’enviarà al núvol. Per exemple, les dades dels sensors poden mostrar l'estat actual d'un hivernacle o hivernacle. L’usuari controlarà els dispositius executius mitjançant l’aplicació Android.




Tots els enllaços són només informatius.






2 x LEDs (vermell i verd)
1 x
- $3.00
Llum de 220V
Resistència de 2 x 330 ohms (usada amb LED)
Resistència de 2 x 10 k ohm (usada amb DHT22 i LDR)
Resistència de 1 x 4K7 ohms (usada amb DS18B20)
Panell
Jumpers
Alimentació externa per a relé de 5 V CC



Ara necessiteu connectar tots els sensors, tal com es mostra al diagrama.



La solució ideal seria muntar i provar el projecte per parts.

A la següent seqüència:
1. Instal·leu i proveu tots els sensors
2Instal·leu i configure mínimament ESP-01
3. Canvieu la configuració i la prova final de la configuració ESP-01
4. Configura el canal d'estat de ThingSpeak
5. Instal·leu el codi ThingSpeak a Arduino i comproveu l'estat dels sensors al núvol
6. Desenvolupi la primera versió del programa a Android per comprovar els missatges d'estat dels sensors
7. Instal·leu actuadors
8. Configureu els canals d'Actuadors ThingSpeak
9. Instal·leu i proveu el codi per a dispositius executius a Arduino
10. Feu la segona versió del programa a Android per a tot el conjunt del dispositiu.



El projecte utilitza algunes biblioteques incloses. Cal comprovar la seva disponibilitat. La configuració inicial d'aquestes biblioteques és la següent:

// DS18B20
#incloure 
#include 
#definir ONE_WIRE_BUS 5 // DS18B20 al pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (Llum)
#define ldrPIN 1
llum lleugera = 0;

// Humitat del sòl
#define soilHumPIN 0
int soilHum = 0;

Ara inicialitzem els nostres sensors i els mostrem al terminal:

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

bucle void ()
{
  readSensors ();
  displaySensors ();
  retard (10000);
}

I, finalment, escriurem dues funcions: una llegeix les lectures dels sensors i l’altra les mostra a la pantalla:

/ ********* Llegiu el valor dels sensors ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // El sensor 0 capturarà la temperatura del sòl a Celcius
  
  soilHum = mapa (analogRead (sòlHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> llum 100%

}

/ ********* Valor dels sensors de visualització ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (sòlTemp);
  Serial.print ("soilHum (%):");
  Serial.println (soilHum);
  Serial.print ("light (%):");
  Serial.println (light);
  Serial.println ("");
}

La foto mostra com es mostren les dades a la pantalla.


El codi font es pot descarregar de l’autor.



La manera més ràpida de "parlar" amb el mòdul és la comanda AT. El processador ja té un processador de comandaments AT. De manera predeterminada, el mòdul inclou una configuració de fabricació de 115200 baud, haureu de configurar 9600 baud en la configuració.

En primer lloc, heu de connectar el mòdul, tal com es mostra a la foto



( Tingueu en compte que el terminal Tx de l’ESP-01 està connectat al terminal Tx d’UNO, de la mateixa manera que els terminals Rx estan connectats entre ells. Aquesta connexió es canviarà més endavant. ).

A continuació, connecteu UNO a l’ordinador, obriu l’IDE ​​i descarregueu l’exemple que es troba. Aquest és un codi buit de manera que no hi hagi conflictes entre ESP-01 i UNO. Aquest codi es va penjar a Ardunio abans de connectar-lo a ESP-01, per tal d’assegurar-se que Ardunio no utilitzarà els pins Tx i Rx per a qualsevol altra cosa.
Ara necessiteu obrir el monitor de IDE Serial Monitor, configureu la velocitat de transmissió en 115200 en la configuració i envieu el comandament AT al monitor serial IDE. ESP-01 hauria d’enviar una resposta d’acord

Ara cal canviar la velocitat de dades al mòdul ESP-01. Per fer-ho, a l'IDE, doneu l'ordre

AT + CIOBAUD = 9600

Es pot produir que l’ESP-01 torni a la configuració de fàbrica, llavors haureu d’utilitzar una altra comanda:

AT + UART_DEF = , , , , 

Per exemple 9600 baud / 8 bits de dades / 1 bits d’aturada i cap paritat i control de flux

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

Ara canvieu la taxa de transferència de dades de la configuració IDE a 9600 i envieu l'ordre AT, hauria de venir la resposta OK.
A continuació, heu de canviar el mòdul en mode STA perquè es pugui connectar al punt d'accés de la vostra xarxa.

AT + CWMODE = 1

Per tal que el mòdul es connecti a la xarxa, introduïu la comanda AT + CWJAP = "nom_ xarxa", "nom_ xarxa_1"on nom de xarxa És el nom de la vostra xarxa i nom de xarxa_1 - contrasenya per a la vostra xarxa (la contrasenya i el nom de la xarxa han de ser entre cometes)
Si veieu la resposta WIFI CONNECTAT WIFI GOT IP, llavors s'estableix la connexió. Verifiqueu l'adreça IP amb la comanda

AT + CIFSR

.

L’adreça que apareix al monitor, la podreu utilitzar en el futur. Un cop configurat el mòdul, podeu connectar-lo de manera permanent, però per a això heu de canviar el seu circuit de commutació, tal com es mostra a la figura.


• ESP-01 RX (Groc) -> Pin UNO D7
• ESP-01 TX (Taronja) -> Pin UNO D6
• ESP-01 Ch-Pd (Marró) -> Vcc (3.3V)
• Restabliment ESP-01 (Blau) -> Pin UNO D8
• ESP-01 Vcc (Vermell) -> 3.3V
• ESP-01 Gnd (Negre) -> UNO GND

Tingueu en compte que la biblioteca del programa informàtic utilitza el pin D7 UNO Pin com tx i es connecta a la sortida d’ESP-01 Rxmentre que UNO Pin D6 com rxconnectat a ESP-01 TX.

Introduïu un codi petit per comprovar la connexió i la configuració correctes del mòdul ESP-01

#incloure 
SoftwareSerial esp8266 (6.7); // Rx ==> Pin 6; TX ==> Pin7

# definir velocitat8266 9600

nul configuració ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("Test de configuració ESP8266: utilitzeu els coomands AT");
}

bucle void ()
{
  mentre que (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  mentre que (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Ara uns quants equips AT. Consulteu els resultats al monitor de sèrie.



* AT =====> ESP8266 retorna bé
* AT + RST =====> ESP8266 es reinicia i torna OK
* AT + GMR =====> ESP8266 retorna la versió AT; Versió SDK; id; D'acord
* AT + CWMODE? => ESP8266 retorna el tipus de mode
* AT + CWLAP ===> ESP8266 retorna els punts d'accés propers
* AT + CIFSR ===> ESP8266 retorna la IP designada

El codi del programa es pot descarregar a

6 connexió de sensors i ESP-01

Després que tots els sensors estiguin connectats i comprovats, a més de comprovar el mòdul ESP-01, és necessari preparar les dades per enviar-les a Internet.





Una de les parts més importants del projecte és la plataforma oberta IoT, que us permetrà recollir dades de sensors, processar-les i analitzar-les. Per fer-ho, aneu a i creeu el vostre compte. A continuació, cal crear un canal on hi haurà 2 actuadors, 5 sensors i un camp de còpia de seguretat.
• Camp 1: actuador 1 (dispositiu 1)
• Camp 2: Actuador 2 (dispositiu 2)
• Camp 3: Temperatura de l’aire en oC (temperatura de l’aire en graus centígrads)
• Arxivat 4: Humitat relativa de l'aire en% (humitat relativa en%)
• Camp 5: Temperatura del sòl en oC (temperatura del sòl en graus centígrads)
• Camp 6: Humitat del sòl en% (humitat del sòl en%)
• Camp 7: Lluminositat en% (il·luminació en%)
• Camp 8: Recanvi

El camp 8 està reservat per a futures expansions o per a depuració. En aquest projecte, s’utilitza com a comptador d’errors de comunicació entre Arduino / ESP-01 i ThingSpeak.com.

Un cop creat el canal d'estat, heu de gravar les tecles, tal com es mostra a la foto.



Actualment, tenim un servei en núvol configurat i els nostres sensors recopilen dades localment. Ara heu d’agafar aquestes dades i enviar-les al núvol a ThingSpeak.com.

Per escriure dades al canal ThingSpeak, heu d’enviar una cadena GET. Això es farà en tres etapes.
Envieu la comanda "Start cmd"

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

Longitud de corda addicional

AT + CIPSEND = 116

I, finalment, una cadena GET que escriurà les nostres dades als camps reservats del Estat d’estat.

GET / actualització? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = recanvi

Tingueu en compte que no hauríem d’escriure dades al canal més d’una vegada en 16 segons.

El codi enviat farà tot això.

// Thingspeak
String statusChWriteKey = "LA TEVA ESCRIBA ESCRIU AQUÍ"; // Identificació del canal d'estat: 385184

#incloure 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#definir HARDWARE_RESET 8

// DS18B20
#incloure 
#include 
#definir ONE_WIRE_BUS 5 // DS18B20 al pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (Llum)
#define ldrPIN 1
llum lleugera = 0;

// Humitat del sòl
#define soilHumPIN 0
int soilHum = 0;

// Variables a utilitzar amb temporitzadors
long writeTimingSeconds = 17; // ==> Definiu el temps d’exemple en segons per enviar dades
long startWriteTiming = 0;
llarg temps transcorregutWriteTime = 0;

// Variables que s’utilitzaran amb actuadors
bomba booleana = 0;
làmpada booleana = 0;

int recanvi = 0;
error booleà;

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Restableix WiFi Modulo
  startWriteTiming = millis (); // arrencant el "rellotge del programa"
}

bucle void ()
{
  inici: // etiqueta
  error = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Envia si no s'ha completat la transmissió
  {
    Serial.println ("<<<< ERROR >>>>");
    retard (2000);
    començar goto; // anar a l'etiqueta "començar"
  }
}

/ ********* Llegiu el valor dels sensors ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // El sensor 0 capturarà la temperatura del sòl a Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> llum 100%
  soilHum = mapa (analogRead (sòlHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (void)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / actualització? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = Cadena (bomba);
  getStr + = "& field2 =";
  getStr + = Cadena (llum);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = Cadena (airHum);
  getStr + = "& field5 =";
  getStr + = String (sòlTemp);
  getStr + = "& field6 =";
  getStr + = String (soilHum);
  getStr + = "& field7 =";
  getStr + = Cadena (llum);
  getStr + = "& field8 =";
  getStr + = Cadena (recanvi);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Restableix ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Reset .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retard (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  retard (8000); // Tempo necessari per arribar a la consecució
  Serial.println ("RESET");
}

/ ********* Comença la comunicació amb ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o tampó abans de venir un 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 ==> Comença cmd:");
  Serial.println (cmd);

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

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

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    retard (500); // temps per processar o GET, sempre que aquest retard no es troba ocupat cap proper comandament

    String messageBody = "";
    mentre que (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// el contingut real comença després de la línia buida (que té una longitud 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody rebut:");
    Serial.println (messageBody);
    tornar el missatgeBody;
  }
  més
  {
    EspSerial.println ("AT + CIPCLOSE"); // usuari d’alerta
    Serial.println ("ERP ESP8266 CIPSEND: RESENDING"); // Envia ...
    recanvi = recanvi + 1;
    error = 1;
    retorna "error";
  }
}

Podeu veure els avenços al Monitor de sèrie.

El codi font es pot descarregar a



Primer cal crear una interfície d’usuari. La imatge mostra els principals elements visibles i invisibles.



Després d'això, heu de crear blocs. Els elements del menú corresponen als números de captura de pantalla.

1 Variables d’estat que haurien de ser declarades globals

2 Cada dos segons (depenent de Clock1) s’anomena procediment "llegirArduino"


El procediment retorna el valor de les variables que s'han de mostrar a la pantalla. En aquest cas, el valor d'estat (0 i 1) dels actuadors es converteix en "ON" i "OFF" per a una millor percepció.

Aquests valors (estat) es mostraran a les "dreceres" corresponents

3 La rutina readArduino bàsicament llegirà el canal d'estat a ThingSpeak. Per tant, heu de determinar l’URL que s’enviarà a Thingspeak. Per fer-ho, s’han de declarar i combinar 3 variables globals per crear l’URL que s’enviarà a ThingSpeak. GET s'ha d'enviar a un component web anomenat "ArduFarmBotStatusCh"

4 El text rebut de la comanda anterior arribarà en format JSon. Aquest text ha de ser processat per tal que cada camp sigui llegit i emmagatzemat a la variable global corresponent.

5 L’últim que cal fer és anomenar el procediment “Alarma”, que analitzarà l’estat de dos sensors del sòl. Si la temperatura és baixa (en el nostre cas a 10 ºC), hauria de mostrar-se un missatge. El mateix per a la humitat si està per sota del 60%.

Tingueu en compte que hem definit un altre temporitzador (Clock2), programat per fer-lo funcionar cada segon. Només cal "canviar" el color del text del missatge (de blanc a vermell). El missatge parpellejarà.

Podeu descarregar el codi de l'aplicació a




Els ordres per encendre i apagar la bomba i la làmpada es rebran de forma remota. La sortida d'Ardunio activarà el relé i el LED, tenint aquests comandaments. La imatge mostra com s’han de connectar els actuadors. Tingueu en compte que la sortida del relé GND NO CONECTATS a la sortida GNDUNO. D’aquesta manera hi haurà menys interferències de potència quan el relé estigui funcionant.




Totes les accions repeteixen el procediment per configurar el canal d'estat. És necessari crear dos canals per a cadascun dels dispositius. Per a cada canal, escriviu les tecles ID de canal, Llegir i escriure. Escrivim només al primer camp de cada canal. Per exemple:
Identificador del canal 375598 ==> LED vermell (bomba)
◦ Camp1 = 0 ==> Bomba desactivada
◦ Camp1 = 1 ==> Bomba encesa
2. Identificador del canal 375599 ==> LED verd (llum)
◦ Camp1 = 0 ==> Llum apagat
◦ Camp1 = 1 ==> Llum ON



Quan vam enviar dades al núvol, vam "escriure" aquestes dades al canal d'estat de ThingSpeak. "Transmetre" (penjar) aquestes dades. Ara hem de "llegir" les dades del canal Actuator, "acceptar" (descarregar) aquestes dades.

Per fer-ho, envieu una cadena GET i aquest procediment consta de 3 etapes.
"Comença cmd"

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

Longitud de línia

AT + CIPSEND = 36

I la cadena GET en si

GET / channels / 375598 / camps / 1 / last

Els canals es llegiran cada 10 segons

Després d’enviar el GET, hem d’acceptar la resposta de ThingSpeak. La resposta ha de ser 0 o 1 per a cada canal. Si hi ha altres valors, simplement els ignorarem.

La diferència principal entre aquesta part i l’anterior només està en la funció readThingSpeak (canal StringID)
A continuació es mostra el codi que realitza les accions descrites.

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

#incloure 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#definir HARDWARE_RESET 8

// Variables a utilitzar amb temporitzadors
long readTimingSeconds = 10; // ==> Definiu el temps de la mostra en segons per rebre dades
long startReadTiming = 0;
llarg temps transcorregutReadTime = 0;

// Relés
#define ACTUATOR1 10 // LED VERMELL ==> Bomba
#define ACTUATOR2 12 // LED VERD ==> Llum
bomba booleana = 0;
làmpada booleana = 0;

int recanvi = 0;
error booleà;

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

  digitalWrite (ACTUATOR1, HIGH); // o mòdul relé és actiu em BAIX
  digitalWrite (ACTUATOR2, HIGH); // o mòdul relé és actiu em BAIX
  digitalWrite (HARDWARE_RESET, HIGH);

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Restableix WiFi Modulo
  startReadTiming = millis (); // arrencant el "rellotge del programa"
}

bucle void ()
{
  inici: // etiqueta
  error = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (transcorregutReadTime> (readTimingSeconds * 1000))
  {
    comando int = readThingSpeak (canalID1);
    if (comanda! = 9) pump = comanda;
    retard (5000);
    command = readThingSpeak (canalID2);
    if (comanda! = 9) lamp = comanda;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Envia si no s'ha completat la transmissió
  {
    Serial.println ("<<<< ERROR >>>>");
    retard (2000);
    començar goto; // anar a l'etiqueta "començar"
  }
}

/ ********* Feu accions basades en les ordres de ThingSpeak ************* /
void takeActions (void)
{
  Serial.print ("Bomba:");
  Serial.println (bomba);
  Serial.print ("Llum:");
  Serial.println (làmpada);
  if (pump == 1) digitalWrite (ACTUATOR1, BAIX);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite (ACTUATOR2, BAIX);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Llegir el comandament dels actuadors de ThingSpeak ************* /
int readThingSpeak (canal String)
{
  startThingSpeakCmd ();
  comandament int;
  // preparacao da string GET
  String getStr = "GET / channel /";
  getStr + = channelID;
  getStr + = "/ camps / 1 / darrer";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Comanda rebuda:");
    Serial.println (comanda);
  }
  else command = 9;
  retornar ordre;
}

/ ********* Restableix ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Reset .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retard (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  retard (8000); // Tempo necessari per arribar a la consecució
  Serial.println ("RESET");
}

/ ********* Comença la comunicació amb ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o tampó abans de venir un 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 ==> Comença cmd:");
  Serial.println (cmd);

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

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

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    retard (500); // temps per processar o GET, sempre que aquest retard no es troba ocupat cap proper comandament

    String messageBody = "";
    mentre que (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// el contingut real comença després de la línia buida (que té una longitud 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody rebut:");
    Serial.println (messageBody);
    tornar el missatgeBody;
  }
  més
  {
    EspSerial.println ("AT + CIPCLOSE"); // usuari d’alerta
    Serial.println ("ERP ESP8266 CIPSEND: RESENDING"); // Envia ...
    recanvi = recanvi + 1;
    error = 1;
    retorna "error";
  }
}

Podeu descarregar-lo a



En aquesta fase, tenim un canal actuador configurat que canvia el valor del camp 1 per a cada dispositiu. Hem de verificar que els dispositius funcionin correctament les ordres. Al final del projecte, s’utilitzarà una aplicació d’android per a això, però també es pot fer a través d’un navegador.

Encendre la bomba (LED vermell encesa)

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

Apagada de la bomba (LED vermell apagat)

https://api.thingspeak.com/update?api_key=Canvi guardat_key_1 & field1 = 0

Encendre la làmpada (el LED verd està encès)

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

Apagueu la làmpada (LED verd apagat)

https://api.thingspeak.com/update?api_key=Canvi guardat_key_2 & field1 = 0

A la part anterior, hi havia un programa senzill que "llegia" les dades del canal i les mostrava a la pantalla. Ara hem de fer que el programa “escrigui” les ordres de l’actuador Channal, de manera que aquestes comandes puguin ser llegides pel controlador i la làmpada amb la bomba funcionada en conseqüència.

Perquè l’usuari pugui enviar ordres, l’aplicació disposarà de dos botons per a cada dispositiu. Si està activat, blau; si està desactivat, vermell.

Fent clic als botons de l'aplicació, podreu veure el resultat a la Serial Monitor.

El codi es pot descarregar a



En aquesta fase, hi ha una aplicació d’android completada, una part de maquinari completament muntada, però no hi ha cap codi que controli les dades de forma constant i enviés ordres al núvol. Només cal combinar tots els fragments del codi escrit anteriorment. Per descomptat, el codi té opcions de verificació addicionals (per exemple, si ESP-01 es congela). Per fer-ho, periòdicament, abans de cada ordre de lectura o escriptura, s’envia una comanda AT.I si la resposta d’acord no prové del mòdul, el mòdul es reinicia de manera programàtica per força.

Podeu descarregar el codi complet del projecte a

A l’adreça podeu obtenir actualitzacions dels fitxers de programes.

També podeu llegir comentaris sobre l’enllaç a la font, si alguna cosa no està clar.