Gestione di una serra o serra da qualsiasi parte del mondo (esempio di implementazione)

Lo scopo di questo sviluppo è quello di raccogliere dati da sensori locali, inviare questi dati a Internet. L'utente sarà in grado in qualsiasi parte del mondo di visualizzare i dati provenienti dai sensori e decidere da remoto sull'attivazione di determinati attuatori che saranno localizzati localmente, accanto ai sensori

Il progetto utilizza Arduino Modulo UNO e WiFi ESP8266-01. I dati verranno trasmessi al cloud tramite il servizio Web ThingSpeak.com e i dispositivi verranno attivati ​​tramite l'applicazione Android sviluppata utilizzando MIT AppInventor.





L'obiettivo principale di questo progetto IoT sarà il servizio ThingSpeak.com. Il dispositivo UNO / ESP-01 locale riceve i dati dai sensori e i dati sullo stato degli attuatori, li invia a Internet "registrando" attraverso uno specifico canale di stato ThingSpeak.com (ThingSpeak.com Status Channel), lo stesso dispositivo locale riceve i dati ", leggendoli "da un altro canale di dati," il canale dei dispositivi esecutivi "(ThingSpeak.com Actuator Channels).



I dati verranno raccolti utilizzando un sensore di temperatura e umidità relativa, temperatura e umidità del suolo e un sensore di luce ambientale. Questi dati verranno inviati al cloud del servizio ThingSpeak.

Ci saranno due dispositivi esecutivi: questa è una pompa elettrica per l'acqua e una lampada. Il loro stato ON / OFF verrà inoltre inviato al cloud. I dati dei sensori, ad esempio, possono visualizzare lo stato corrente di una serra o di una serra. L'utente controllerà i dispositivi esecutivi utilizzando l'applicazione Android.




Tutti i collegamenti sono solo a scopo informativo.






2 x LED (rosso e verde)
1 x
- $3.00
Lampada 220V
2 resistori da 330 ohm (usati con i LED)
2 resistori da 10 K ohm (usati con DHT22 e LDR)
1 resistenza 4K7 ohm (utilizzata con DS18B20)
scheda di prototipazione
ponticelli
Alimentatore esterno per relè 5V DC



Ora è necessario collegare tutti i sensori, come mostrato nel diagramma.



La soluzione ideale sarebbe quella di assemblare e testare il progetto in parti.

Nella seguente sequenza:
1. Installare e testare tutti i sensori
2.Installa e configura almeno ESP-01
3. Modificare l'impostazione ESP-01 sulla configurazione finale e test
4. Configurare il canale di stato ThingSpeak
5. Installa il codice ThingSpeak su Arduino e controlla lo stato dei sensori sul cloud
6. Sviluppa la prima versione del programma su Android per controllare i messaggi di stato dai sensori
7. Installare gli attuatori
8. Configurare i canali degli attuatori ThingSpeak
9. Installare e testare il codice per i dispositivi esecutivi su Arduino
10. Crea la seconda versione del programma su Android per l'intero assemblaggio del dispositivo.



Il progetto utilizza alcune librerie incluse in. È necessario verificare la loro disponibilità. La configurazione iniziale di queste librerie è la seguente:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 sul pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (leggero)
#define ldrPIN 1
int light = 0;

// Umidità del suolo
#define soilHumPIN 0
int soilHum = 0;

Ora inizializziamo i nostri sensori e li visualizziamo nel terminale:

void setup ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

void loop ()
{
  readSensors ();
  displaySensors ();
  ritardo (10000);
}

E infine, scriveremo due funzioni: una legge le letture dai sensori e l'altra le visualizza sullo schermo:

/ ********* Valore dei sensori di lettura ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Il sensore 0 acquisirà Temp. Suolo in Celcius
  
  soilHum = map (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> leggero 100%

}

/ ********* Valore dei sensori di visualizzazione ************* /
display vuoto Sensori (vuoto)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (soilTemp);
  Serial.print ("soilHum (%):");
  Serial.println (soilHum);
  Serial.print ("light (%):");
  Serial.println (leggero);
  Serial.println ("");
}

La foto mostra come i dati vengono visualizzati sullo schermo.


Il codice sorgente può essere scaricato dall'autore.



Il modo più veloce di "parlare" con il modulo è il comando AT. Il processore ha già un processore di comandi AT. Per impostazione predefinita, il modulo viene fornito con impostazioni di fabbrica di 115200 baud, è necessario impostare 9600 baud nelle impostazioni.

Innanzitutto, è necessario collegare il modulo, come mostrato nella foto



( Notare che il terminale Tx dell'ESP-01 è collegato al terminale Tx di UNO, proprio come i terminali Rx sono collegati tra loro. Questa connessione verrà modificata in seguito. ).

Quindi collegare UNO al computer, aprire l'IDE e scaricare l'esempio che si trova. Questo è un codice vuoto in modo che non ci siano conflitti tra ESP-01 e UNO. Questo codice è stato caricato su Ardunio prima di collegare ESP-01 ad esso, per essere sicuro che Ardunio non utilizzerà i pin Tx e Rx per nient'altro.
Ora è necessario aprire il monitor seriale IDE, impostare la velocità di trasmissione su 115200 nelle impostazioni e inviare il comando AT al monitor seriale IDE. ESP-01 dovrebbe inviare una risposta OK

Ora è necessario modificare la velocità dei dati nel modulo ESP-01. Per fare questo, nell'IDE, dare il comando

AT + CIOBAUD = 9600

Può succedere che ESP-01 ritorni alle impostazioni di fabbrica, quindi dovrai usare un altro comando:

AT + UART_DEF = , , , , 

Per esempio 9600 baud / 8 bit di dati / 1 bit di stop e nessuna parità e controllo del flusso

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

Ora modifica la velocità di trasferimento dei dati nelle impostazioni IDE su 9600 e invia il comando AT, la risposta OK dovrebbe arrivare.
Successivamente, è necessario passare il modulo in modalità STA in modo che possa connettersi al punto di accesso della rete.

AT + CWMODE = 1

Per consentire al modulo di connettersi alla rete, immettere il comando AT + CWJAP = "nome_ rete", "nome_ rete_1"dove NETWORK_NAME È il nome della tua rete e network_name_1 - password per la tua rete (la password e il nome della rete devono essere tra virgolette)
Se vedi la risposta WIFI CONNESSO WIFI GOT IP, quindi viene stabilita la connessione. Verificare l'indirizzo IP con il comando

AT + CIFSR

.

L'indirizzo che appare sul monitor, è possibile utilizzare in futuro. Dopo aver configurato il modulo, è possibile collegarlo in modo permanente, ma per questo è necessario modificare il suo circuito di commutazione, come mostrato nella figura.


• ESP-01 RX (giallo) -> UNO Pin D7
• ESP-01 TX (arancione) -> UNO Pin D6
• ESP-01 Ch-Pd (marrone) -> Vcc (3.3V)
• Ripristino ESP-01 (blu) -> UNO Pin D8
• ESP-01 Vcc (rosso) -> 3,3 V.
• ESP-01 Gnd (nero) -> UNO GND

Si noti che la libreria seriale software utilizza il pin D7 UNO Pin come tx e si collega all'uscita di ESP-01 RXmentre UNO Pin D6 come rxcollegato a ESP-01 TX.

Immettere un piccolo codice per verificare la corretta connessione e configurazione del modulo ESP-01

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

#define speed8266 9600

void setup ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("Test di installazione di ESP8266 - usa i codici AT");
}

void loop ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Ora alcune squadre AT. Vedi i risultati nel monitor seriale.



* AT =====> ESP8266 restituisce OK
* AT + RST =====> ESP8266 si riavvia e restituisce OK
* AT + GMR =====> ESP8266 restituisce la versione AT; Versione SDK; id; bene
* AT + CWMODE? => ESP8266 restituisce il tipo di modalità
* AT + CWLAP ===> ESP8266 restituisce punti di accesso vicini
* AT + CIFSR ===> ESP8266 restituisce un IP designato

Il codice del programma può essere scaricato all'indirizzo

6 collegamento dei sensori e ESP-01

Dopo che tutti i sensori sono stati collegati e controllati, così come il modulo ESP-01 è stato verificato, è necessario preparare i dati per l'invio a Internet.





Una delle parti più importanti del progetto è la piattaforma IoT aperta, che ti permetterà di raccogliere dati da sensori, elaborarli e analizzarli. Per fare ciò, vai a e crea il tuo account. Successivamente, è necessario creare un canale in cui saranno presenti 2 attuatori, 5 sensori e un campo di backup.
• Campo 1: attuatore 1 (dispositivo 1)
• Campo 2: attuatore 2 (dispositivo 2)
• Campo 3: temperatura dell'aria in oC (temperatura dell'aria in gradi Celsius)
• Archiviato 4: Umidità relativa dell'aria in% (Umidità relativa in%)
• Campo 5: temperatura del suolo in oC (temperatura del suolo in gr. Celsius)
• Campo 6: umidità del suolo in% (umidità del suolo in%)
• Campo 7: luminosità in% (illuminazione in%)
• Campo 8: riserva

Il campo 8 è riservato per future espansioni o per il debug. In questo progetto, viene utilizzato come contatore degli errori di comunicazione tra Arduino / ESP-01 e ThingSpeak.com.

Dopo aver creato il canale di stato, è necessario registrare le chiavi, come mostrato nella foto.



Al momento, abbiamo un servizio cloud configurato e i nostri sensori raccolgono dati localmente. Ora devi prendere questi dati e inviarli al cloud su ThingSpeak.com.

Per scrivere i dati sul canale ThingSpeak, è necessario inviare una stringa GET. Questo sarà fatto in tre fasi.
Invia il comando "Avvia cmd"

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

Ulteriore lunghezza della corda

AT + CIPSEND = 116

E infine, una stringa GET che scriverà i nostri dati nei campi riservati del canale di stato.

OTTIENI / aggiorna? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Tieni presente che non dovremmo scrivere dati sul canale più di 1 volta in 16 secondi.

Il codice inviato farà tutto questo.

// Thingspeak
String statusChWriteKey = "LA TUA CHIAVE DI SCRITTURA QUI"; // ID canale stato: 385184

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

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 sul pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (leggero)
#define ldrPIN 1
int light = 0;

// Umidità del suolo
#define soilHumPIN 0
int soilHum = 0;

// Variabili da utilizzare con i timer
long writeTimingSeconds = 17; // ==> Definisce il tempo di campionamento in secondi per inviare i dati
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variabili da utilizzare con gli attuatori
pompa booleana = 0;
lampada booleana = 0;

int spare = 0;
errore booleano;

void setup ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Ripristina do Modulo WiFi
  startWriteTiming = millis (); // avvio del "clock di programma"
}

void loop ()
{
  inizio: // etichetta
  errore = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (errore == 1) // Rinvia se la trasmissione non è stata completata
  {
    Serial.println ("<<<< ERRORE >>>>");
    ritardo (2000);
    vai all'inizio; // vai all'etichetta "start"
  }
}

/ ********* Valore dei sensori di lettura ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Il sensore 0 acquisirà Temp. Suolo in Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> leggero 100%
  soilHum = map (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

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

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pump);
  getStr + = "& field2 =";
  getStr + = String (lampada);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (soilTemp);
  getStr + = "& field6 =";
  getStr + = String (soilHum);
  getStr + = "& field7 =";
  getStr + = String (light);
  getStr + = "& field8 =";
  getStr + = String (ricambio);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Ripristina ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Reimpostazione .......");
  digitalWrite (HARDWARE_RESET, LOW);
  ritardo (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necessario per la riproduzione
  Serial.println ("RESET");
}

/ ********* Avvia la comunicazione con ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Stringa 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 ("Errore"))
  {
    Serial.println ("Errore AT + CIPSTART");
    tornare;
  }
}

/ ********* invia un cmd OTTIENI a ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Stringa cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lunghezza cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// il contenuto effettivo inizia dopo una riga vuota (che ha lunghezza 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody ricevuto:");
    Serial.println (messageBody);
    return messageBody;
  }
  altro
  {
    EspSerial.println ("AT + CIPCLOSE"); // avvisa l'utente
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Rinvia ...
    spare = spare + 1;
    errore = 1;
    restituisce "errore";
  }
}

Puoi vedere i progressi nel monitor seriale.

Il codice sorgente può essere scaricato all'indirizzo



Per prima cosa devi creare un'interfaccia utente. L'immagine mostra i principali elementi visibili e invisibili.



Successivamente, è necessario creare blocchi. Le voci di menu corrispondono ai numeri di screenshot.

1 Variabili di stato che dovrebbero essere dichiarate come globali

2 Ogni due secondi (a seconda di Clock1) viene chiamata una procedura "ReadArduino"


La procedura restituisce il valore delle variabili che devono essere visualizzate sullo schermo. In questo caso, il valore di stato (0 e 1) per gli attuatori viene convertito in "ON" e "OFF" per una migliore percezione.

Questi valori (Stato) verranno visualizzati nei corrispondenti "Collegamenti"

3 La routine readArduino leggerà essenzialmente il canale di stato in ThingSpeak. Quindi, è necessario determinare l'URL che verrà inviato a Thingspeak. Per fare ciò, 3 variabili globali devono essere dichiarate e combinate per creare l'URL che verrà inviato a ThingSpeak. GET deve essere inviato a un componente Web chiamato «ArduFarmBotStatusCh»

4 Il testo ricevuto dal comando precedente arriverà nel formato JSon. Questo testo deve essere elaborato in modo che ogni campo venga letto e memorizzato nella corrispondente variabile globale.

5 L'ultima cosa da fare è chiamare la procedura "Allarme", che analizzerà lo stato di due sensori del suolo. Se la temperatura è troppo bassa (nel nostro caso 10 ° C), dovrebbe essere visualizzato un messaggio. Lo stesso per l'umidità se è inferiore al 60%.

Si noti che abbiamo definito un altro timer (Clock2), programmato per farlo funzionare ogni secondo. È solo necessario "cambiare" il colore del testo del messaggio (da bianco a rosso). Il messaggio lampeggerà.

Il codice dell'applicazione può essere scaricato all'indirizzo




I comandi di accensione e spegnimento della pompa e della lampada verranno ricevuti in remoto. L'uscita di Ardunio attiverà il relè e il LED, assumendo questi comandi. L'immagine mostra come devono essere collegati gli attuatori. Notare che l'uscita relè GND NON CONNESSO all'uscita GNDUNO. In questo modo ci saranno meno interferenze di potenza quando il relè è in funzione.




Tutte le azioni ripetono la procedura per la configurazione del canale Status. È necessario creare due canali per ciascuno dei dispositivi. Per ciascun canale, scrivere i tasti ID canale, Leggi e Scrivi. Scriveremo solo nel primo campo di ciascun canale. Per un esempio:
ID canale 375598 ==> LED rosso (pompa)
◦ Campo1 = 0 ==> Pompa OFF
◦ Campo1 = 1 ==> Pompa ON
2. ID canale 375599 ==> LED verde (lampada)
◦ Campo1 = 0 ==> Lampada spenta
◦ Campo1 = 1 ==> Lampada accesa



Quando abbiamo inviato dati sul cloud, abbiamo "scritto" questi dati su ThingSpeak. Canale di stato, "trasmettendo" (caricando) questi dati. Ora dobbiamo "leggere" i dati dal canale degli attuatori, "accettare" (scaricare) questi dati.

Per fare ciò, inviare una stringa GET e questa procedura è composta da 3 fasi.
"Avvia cmd"

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

Lunghezza della linea

AT + CIPSEND = 36

E la stessa stringa GET

GET / canali / 375598 / campi / 1 / ultimo

I canali verranno "letti" ogni 10 secondi

Dopo aver inviato il GET, dobbiamo accettare la risposta da ThingSpeak. La risposta deve essere 0 o 1, per ciascun canale. Se ci sono altri valori, semplicemente li ignoriamo.

La differenza principale tra questa parte e quella precedente è solo nella funzione readThingSpeak (String channelID)
Di seguito è riportato il codice che esegue le azioni descritte.

// Thingspeak
String canalID1 = "999999"; // Attuatore 1
String canalID2 = "999999"; // Attuatore2

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

// Variabili da utilizzare con i timer
long readTimingSeconds = 10; // ==> Definisce il tempo di campionamento in secondi per ricevere i dati
long startReadTiming = 0;
long elapsedReadTime = 0;

// Relè
#define ACTUATOR1 10 // LED ROSSO ==> Pompa
#define ACTUATOR2 12 // LED VERDE ==> Lampada
pompa booleana = 0;
lampada booleana = 0;

int spare = 0;
errore booleano;

void setup ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Ripristina do Modulo WiFi
  startReadTiming = millis (); // avvio del "clock di programma"
}

void loop ()
{
  inizio: // etichetta
  errore = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int command = readThingSpeak (canalID1);
    if (comando! = 9) pump = comando;
    ritardo (5000);
    command = readThingSpeak (canalID2);
    if (comando! = 9) lampada = comando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (errore == 1) // Rinvia se la trasmissione non è stata completata
  {
    Serial.println ("<<<< ERRORE >>>>");
    ritardo (2000);
    vai all'inizio; // vai all'etichetta "start"
  }
}

/ ********* Esegui azioni basate sui comandi ThingSpeak ************* /
void takeActions (void)
{
  Serial.print ("Pump:");
  Serial.println (pompa);
  Serial.print ("Lamp:");
  Serial.println (lampada);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite (ACTUATOR2, LOW);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Leggi il comando Attuatori da ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  comando int;
  // preparacao da string GET
  String getStr = "GET / canali /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Comando ricevuto:");
    Serial.println (comando);
  }
  else command = 9;
  comando di ritorno;
}

/ ********* Ripristina ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Reimpostazione .......");
  digitalWrite (HARDWARE_RESET, LOW);
  ritardo (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necessario per la riproduzione
  Serial.println ("RESET");
}

/ ********* Avvia la comunicazione con ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Stringa 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 ("Errore"))
  {
    Serial.println ("Errore AT + CIPSTART");
    tornare;
  }
}

/ ********* invia un cmd OTTIENI a ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Stringa cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lunghezza cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// il contenuto effettivo inizia dopo una riga vuota (che ha lunghezza 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody ricevuto:");
    Serial.println (messageBody);
    return messageBody;
  }
  altro
  {
    EspSerial.println ("AT + CIPCLOSE"); // avvisa l'utente
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Rinvia ...
    spare = spare + 1;
    errore = 1;
    restituisce "errore";
  }
}

Puoi scaricarlo da



In questa fase, abbiamo un canale dell'attuatore configurato che modifica il valore del campo 1 per ciascun dispositivo. Dobbiamo verificare che i dispositivi elaborino correttamente i comandi. Alla fine del progetto, verrà utilizzata un'applicazione Android per questo, ma può anche essere eseguita tramite un browser.

Accendere la pompa (LED rosso acceso)

https://api.thingspeak.com/update?api_key=Сохраненный_ключ_канала_1&field1=1

Pompa spenta (LED rosso spento)

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

Accendi la lampada (il LED verde è acceso)

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

Spegni la lampada (LED verde spento)

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

Nella parte precedente, c'era un semplice programma che "leggeva" i dati dal canale e li visualizzava sullo schermo. Ora dobbiamo fare in modo che il programma “scriva” i comandi in Actuator Channal, in modo che questi comandi possano essere letti dal controller e la lampada con la pompa abbia funzionato di conseguenza.

In modo che l'utente possa inviare comandi, l'applicazione avrà due pulsanti per ciascun dispositivo. Se acceso, blu; se spento, rosso.

Facendo clic sui pulsanti nell'applicazione, è possibile visualizzare il risultato nel monitor seriale.

Il codice può essere scaricato all'indirizzo



In questa fase, esiste un'applicazione Android completamente completata, una parte "iron" completamente assemblata, ma non c'è alcun codice nel controller che legga costantemente i dati e invii comandi al cloud. Devi solo combinare tutti i frammenti del codice scritti in precedenza. Naturalmente, il codice ha opzioni di verifica aggiuntive (ad esempio, se ESP-01 si blocca). Per fare ciò, periodicamente, prima di ogni comando di lettura o scrittura, viene inviato un comando AT.E se la risposta OK non proviene dal modulo, il modulo viene riavviato forzatamente a livello di codice.

Il codice completo del progetto può essere scaricato all'indirizzo

All'indirizzo è possibile ottenere aggiornamenti per i file di programma.

Puoi anche leggere i commenti sul link alla fonte, se qualcosa non è chiaro.