Gestionarea unei sere sau seră de oriunde în lume (exemplu de implementare)

Scopul acestei dezvoltări este de a colecta date de la senzori locali, de a trimite aceste date pe Internet. Utilizatorul va putea vizualiza datele care provin de la senzori oriunde în lume și poate lua o decizie de la distanță cu privire la activarea anumitor actuatoare care vor fi localizate local, lângă senzori

Proiectul folosește Arduino Modulul UNO și WiFi ESP8266-01. Datele vor fi transmise către cloud prin intermediul serviciului web ThingSpeak.com, iar dispozitivele vor fi activate prin aplicația Android dezvoltată folosind MIT AppInventor.





Obiectivul principal al acestui proiect IoT va fi serviciul ThingSpeak.com. Dispozitivul local UNO / ESP-01 primește date de la senzori și date privind starea actuatoarelor, le trimite la „înregistrare” pe Internet printr-un canal de stare specific ThingSpeak.com (ThingSpeak.com Status Channel), același dispozitiv local primește date, " citind-le dintr-un alt canal de date - „canalul dispozitivelor executive” (ThingSpeak.com Actuator Channel).



Datele vor fi colectate folosind un senzor de temperatură și umiditate relativă, temperatura și umiditatea solului și un senzor de lumină ambientală. Aceste date vor fi trimise către cloud-ul de servicii ThingSpeak.

Vor fi două dispozitive executive - aceasta este o pompă electrică cu apă și o lampă. Starea lor de pornire / oprire va fi, de asemenea, trimisă în cloud. Datele de la senzori, de exemplu, pot afișa starea actuală a unei sere sau a unei sere. Utilizatorul va controla dispozitivele executive folosind aplicația Android.




Toate link-urile sunt doar cu titlu informativ.






2 x LED-uri (roșu și verde)
1 x
- $3.00
Lampa 220V
Rezistență de 2 x 330 ohmi (folosită cu LED-uri)
Rezistență de 2 x 10 ohm (folosită cu DHT22 și LDR)
1 x rezistență 4K7 ohm (folosit cu DS18B20)
bord prototipuri
jumperii
Sursa de alimentare externa pentru releul de 5V CC



Acum trebuie să conectați toți senzorii, așa cum se arată în diagramă.



Soluția ideală ar fi asamblarea și testarea proiectului în piese.

În următoarea secvență:
1. Instalați și testați toți senzorii
2.Instalați și configurați minim ESP-01
3. Modificați configurația ESP-01 la configurația și testarea finală
4. Configurați canalul de stare ThingSpeak
5. Instalați codul ThingSpeak pe Arduino și verificați starea senzorilor din cloud
6. Dezvoltați prima versiune a programului pe Android pentru a verifica mesajele de stare de la senzori
7. Instalați actuatoarele
8. Configurați canalele ThuSpeak Actuators
9. Instalați și testați codul pentru dispozitivele executive pe Arduino
10. Realizați a doua versiune a programului pe Android pentru întregul ansamblu de dispozitiv.



Proiectul folosește câteva biblioteci care sunt incluse în. Este necesar să verificați disponibilitatea acestora. Configurația inițială a acestor biblioteci este următoarea:

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

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

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

// Umiditatea solului
#define solHumPIN 0
int solHum = 0;

Acum inițializăm senzorii și îi afișăm în terminal:

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

nul buclă ()
{
  readSensors ();
  displaySensors ();
  întârziere (10000);
}

Și în final, vom scrie două funcții: una citește citirile de la senzori, iar cealaltă le afișează pe ecran:

/ ********* Citiți valoarea senzorilor ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzorul 0 va capta temperatura solului în Celcius
  
  solHum = hartă (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = hartă (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> light 100%

}

/ ********* Valoarea senzorilor de afișare ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (solTemp);
  Serial.print ("soilHum (%):");
  Serial.println (solHum);
  Serial.print ("light (%):");
  Serial.println (light);
  Serial.println ("");
}

Fotografia arată modul în care datele sunt afișate pe ecran.


Codul sursă poate fi descărcat de la autor.



Cel mai rapid mod de a „vorbi” cu modulul este comanda AT. Procesorul are deja un procesor de comandă AT. În mod implicit, modulul vine cu setări din fabrică de 115200 baud, trebuie să setați 9600 baud în setări.

În primul rând, trebuie să conectați modulul, așa cum se arată în fotografie



( Rețineți că terminalul Tx al ESP-01 este conectat la terminalul Tx al UNO, la fel ca terminalele Rx sunt conectate între ele. Această conexiune va fi modificată ulterior. ).

Apoi conectați UNO la computer, deschideți IDE și descărcați exemplul localizat. Acesta este codul gol, astfel încât să nu existe conflicte între ESP-01 și UNO. Acest cod a fost încărcat în Ardunio înainte de a conecta ESP-01 la el, pentru a fi sigur că Ardunio nu va folosi pinii Tx și Rx pentru altceva.
Acum trebuie să deschideți IDE Serial Monitor, să setați rata de transfer pe 115200 în setări și să trimiteți comanda AT la IDE Serial Monitor. ESP-01 ar trebui să trimită un răspuns OK

Acum trebuie să modificați rata de date din modulul ESP-01. Pentru a face acest lucru, în IDE, dați comanda

AT + CIOBAUD = 9600

Se poate întâmpla ca ESP-01 să revină la setările din fabrică, atunci va trebui să utilizați o altă comandă:

AT + UART_DEF = , , , , 

De exemplu 9600 baud / 8 biți de date / 1 biți de oprire și niciun control de paritate și flux

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

Acum schimbați rata de transfer de date din setările IDE la 9600 și trimiteți comanda AT, răspunsul OK ar trebui să vină.
În continuare, trebuie să comutați modulul în modul STA, astfel încât să se poată conecta la punctul de acces al rețelei.

AT + CWMODE = 1

Pentru ca modulul să se conecteze la rețea, introduceți comanda AT + CWJAP = "nume_rețea", "nume_rețea_1"unde NETWORK_NAME Este numele rețelei dvs. și network_name_1 - parola pentru reteaua ta (parola și numele rețelei trebuie să fie în ghilimele)
Dacă vedeți răspunsul WIFI CONNECTED WIFI GOT IP, atunci conexiunea este stabilită. Verificați adresa IP cu ajutorul comenzii

AT + CIFSR

.

Adresa care apare pe monitorul dvs., o puteți utiliza în viitor. După ce ați configurat modulul, îl puteți conecta permanent, dar pentru aceasta trebuie să schimbați circuitul de comutare, așa cum se arată în figură.


• ESP-01 RX (Galben) -> Pinul UNO D7
• ESP-01 TX (Portocaliu) -> Pinul UNO D6
• ESP-01 Ch-Pd (Maro) -> Vcc (3.3V)
• Resetare ESP-01 (albastru) -> Pin UNO D8
• ESP-01 Vcc (Roșu) -> 3.3V
• ESP-01 Gnd (Negru) -> UNO GND

Rețineți că biblioteca Serial Software folosește pinul UNO Pin D7 ca tx și se conectează la ieșirea ESP-01 RXîn timp ce UNO Pin D6 ca rxconectat la ESP-01 TX.

Introduceți un cod mic pentru a verifica conexiunea și configurația corectă a modulului 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 de configurare ESP8266 - folosiți coomandi AT");
}

nul buclă ()
{
  în timp ce (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Acum câteva echipe AT. Vezi rezultatele în Serial Monitor.



* AT =====> ESP8266 returnează OK
* AT + RST =====> ESP8266 repornește și returnează OK
* AT + GMR =====> ESP8266 returnează versiunea AT; Versiunea SDK; id; în regulă
* AT + CWMODE? => ESP8266 returnează tipul de mod
* AT + CWLAP ===> ESP8266 returnează punctele de acces apropiate
* AT + CIFSR ===> ESP8266 returnează IP-ul desemnat

Codul programului poate fi descărcat la

6 conexiune de senzori și ESP-01

După ce toți senzorii sunt conectați și verificați, precum și modulul ESP-01 este verificat, este necesar să pregătiți datele pentru trimiterea pe internet.





Una dintre cele mai importante părți ale proiectului este platforma IoT deschisă, care vă va permite să colectați date de la senzori, să le prelucrați și să le analizați. Pentru a face acest lucru, accesați și creați-vă contul. În continuare, trebuie să creați un canal în care vor exista 2 actuatoare, 5 senzori și un câmp de rezervă.
• Câmpul 1: Actuatorul 1 (dispozitivul 1)
• Câmp 2: Actuator 2 (dispozitiv 2)
• Câmpul 3: Temperatura aerului în oC (temperatura aerului în grade Celsius)
• Filed 4: Umiditatea relativă a aerului în% (umiditatea relativă în%)
• Câmpul 5: Temperatura solului în oC (temperatura solului în gr. Celsius)
• Câmpul 6: Umiditatea solului în% (umiditatea solului în%)
• Câmp 7: Luminozitate în% (iluminare în%)
• Câmpul 8: Piese de schimb

Câmpul 8 este rezervat pentru extinderea viitoare sau pentru depanare. În acest proiect, este utilizat ca contor de erori de comunicare între Arduino / ESP-01 și ThingSpeak.com.

După ce ați creat Channel Status, trebuie să înregistrați tastele, așa cum se arată în fotografie.



În acest moment, avem un serviciu cloud configurat, iar senzorii noștri colectează date la nivel local. Acum trebuie să luați aceste date și să le trimiteți în cloud pe ThingSpeak.com.

Pentru a scrie date pe canalul ThingSpeak, trebuie să trimiteți un șir GET. Aceasta se va face în trei etape.
Trimite comanda "Start cmd"

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

Lungime ulterioară a șirului

AT + CIPSEND = 116

Și în sfârșit, un șir GET care ne va scrie datele în câmpurile rezervate Status Channel.

GET?

Rețineți că nu ar trebui să scriem date pe canal mai mult de 1 dată în 16 secunde.

Codul trimis va face toate acestea.

// Thingspeak
String statusChWriteKey = "CHEIA TA SCRISĂ AICI"; // Identificarea canalului de stare: 385184

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

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

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

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

// Umiditatea solului
#define solHumPIN 0
int solHum = 0;

// Variabile care vor fi utilizate cu cronometre
long writeTimingSeconds = 17; // ==> Definirea timpului de eșantion în câteva secunde pentru a trimite date
long startWriteTiming = 0;
mult timp scursWriteTime = 0;

// Variabile care vor fi utilizate cu actuatoare
pompă booleană = 0;
lampa booleană = 0;

int rezervă = 0;
eroare booleană;

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 (); // Resetați Modulo WiFi
  startWriteTiming = millis (); // pornirea „ceasului programului”
}

nul buclă ()
{
  începe: // etichetă
  eroare = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (eroare == 1) // Remitere dacă transmisia nu este finalizată
  {
    Serial.println ("<<<< EROARE >>>>");
    întârziere (2000);
    goto start; // accesați eticheta "start"
  }
}

/ ********* Citiți valoarea senzorilor ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzorul 0 va capta temperatura solului în Celcius
             
  light = hartă (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> light 100%
  solHum = hartă (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

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

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / actualizare? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pompă);
  getStr + = "& field2 =";
  getStr + = String (lampă);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (solTemp);
  getStr + = "& field6 =";
  getStr + = String (solHum);
  getStr + = "& field7 =";
  getStr + = String (light);
  getStr + = "& field8 =";
  getStr + = String (rezervă);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Resetare ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Resetare .......");
  digitalWrite (HARDWARE_RESET, LOW);
  întârziere (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necesário para começar a ler
  Serial.println ("RESET");
}

/ ********* Începeți comunicarea cu ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o tampon înainte de a veni un gravar
  
  String 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 ("Eroare"))
  {
    Serial.println ("eroare AT + CIPSTART");
    return;
  }
}

/ ********* trimite un cmd GET către ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (lungime getStr. ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lungimea cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo pentru procesare o GET, sem este întârziere apresenta busy no next comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// conținutul real începe după linia goală (care are lungimea 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody primit:");
    Serial.println (mesajBody);
    returnare mesajBody;
  }
  altfel
  {
    EspSerial.println ("AT + CIPCLOSE"); // utilizator de alertă
    Serial.println ("EROAREA CIPSENDULUI ESP8266: REZENTARE"); // Trimite mai departe ...
    rezervă = rezervă + 1;
    eroare = 1;
    retur „eroare”;
  }
}

Puteți vedea progresul în Serial Monitor.

Codul sursă poate fi descărcat la



Mai întâi trebuie să creezi o interfață de utilizator. Imaginea prezintă principalele elemente vizibile și invizibile.



După aceea, trebuie să creați blocuri. Elementele de meniu corespund numerelor de ecran.

1 Variabilele de stat care ar trebui declarate ca fiind globale

2 La fiecare două secunde (în funcție de Clock1) se apelează la o procedură "ReadArduino"


Procedura returnează valoarea variabilelor care ar trebui să fie afișate pe ecran. În acest caz, valoarea de stare (0 și 1) pentru actuatoare sunt convertite în „ON” și „OFF” pentru o percepție mai bună.

Aceste valori (Status) vor fi afișate în „Comenzile rapide” corespunzătoare.

3 Rutina readArduino va citi în esență canalul de stare din ThingSpeak. Deci, trebuie să determinați adresa URL care va fi trimisă către Thingspeak. Pentru a face acest lucru, 3 variabile globale trebuie declarate și combinate pentru a crea adresa URL care va fi trimisă către ThingSpeak. GET trebuie trimis către o componentă web numită «ArduFarmBotStatusCh»

4 Textul primit de la comanda anterioară va ajunge în format JSon. Acest text trebuie prelucrat astfel încât fiecare câmp să fie citit și stocat în variabila globală corespunzătoare.

5 Ultimul lucru de făcut este să apelați procedura „Alarmă”, care va analiza starea a doi senzori de sol. Dacă temperatura este prea scăzută (în cazul nostru 10oC), trebuie afișat un mesaj. La fel pentru umiditate dacă este sub 60%.

Vă rugăm să rețineți că am definit un alt cronometru (Clock2), programat pentru a-l rula în fiecare secundă. Este necesară „comutarea” culorii textului mesajului (de la alb la roșu). Mesajul va clipi.

Codul aplicației poate fi descărcat la




Comenzile pentru pornirea și oprirea pompei și a lămpii vor fi primite de la distanță. Ieșirea Ardunio va activa releul și ledul, luând aceste comenzi. Imaginea arată cum trebuie conectate actuatoarele. Vă rugăm să rețineți că ieșirea releului GND NU ESTE CONECTAT la ieșire GNDONU. În acest fel, va exista mai puțină interferență de putere atunci când releul funcționează.




Toate acțiunile repetă procedura de configurare a canalului Status. Este necesar să se creeze două canale pentru fiecare dintre dispozitive. Pentru fiecare canal, scrieți ID-ul canalului, citirea și scrierea tastelor. Vom scrie doar în primul câmp al fiecărui canal. De exemplu:
ID canal 375598 ==> LED roșu (pompă)
◦ Field1 = 0 ==> Pump OFF
◦ Field1 = 1 ==> Pump ON
2. ID canal 375599 ==> LED verde (lampă)
◦ Field1 = 0 ==> Lampă stinsă
◦ Field1 = 1 ==> Lampă pornită



Când am trimis date în cloud, am „scris” aceste date în canalul de stare ThingSpeak. Stare, „transmiterea” (încărcarea) acestor date. Acum trebuie să „citim” datele de pe canalul de acționare, „acceptând” (descărcând) aceste date.

Pentru a face acest lucru, trimiteți un șir GET și această procedură constă din 3 etape.
„Start cmd”

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

Lungimea liniei

AT + CIPSEND = 36

Și șirul GET în sine

GET / canale / 375598 / câmpuri / 1 / ultimul

Canalele vor fi „citite” la fiecare 10 secunde

După trimiterea GET-ului, trebuie să acceptăm răspunsul de la ThingSpeak. Răspunsul trebuie să fie 0 sau 1, pentru fiecare canal. Dacă există alte valori, atunci pur și simplu le ignorăm.

Principala diferență între această parte și cea anterioară este doar în funcție readThingSpeak (canal StringID)
Mai jos este codul care efectuează acțiunile descrise.

// Thingspeak
String canalID1 = "999999"; // Actuator1
String canalID2 = "999999"; // Actuator2

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

// Variabile care vor fi utilizate cu cronometre
long readTimingSeconds = 10; // ==> Definirea timpului de eșantion în câteva secunde pentru a primi date
long startReadTiming = 0;
mult timp scursReadTime = 0;

// Relee
#define ACTUATOR1 10 // LED RED ==> Pompă
#define ACTUATOR2 12 // LED VERDE ==> Lampa
pompă booleană = 0;
lampa booleană = 0;

int rezervă = 0;
eroare booleană;

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

  digitalWrite (ACTUATOR1, HIGH); // o módulo relé este ativo em scăzut
  digitalWrite (ACTUATOR2, HIGH); // o módulo relé este ativo em scăzut
  digitalWrite (HARDWARE_RESET, HIGH);

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Resetați Modulo WiFi
  startReadTiming = millis (); // pornirea „ceasului programului”
}

nul buclă ()
{
  începe: // etichetă
  eroare = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    comanda int = readThingSpeak (canalID1);
    if (comanda! = 9) pump = comanda;
    întârziere (5000);
    command = readThingSpeak (canalID2);
    if (comanda! = 9) lamp = comanda;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (eroare == 1) // Remitere dacă transmisia nu este finalizată
  {
    Serial.println ("<<<< EROARE >>>>");
    întârziere (2000);
    goto start; // accesați eticheta "start"
  }
}

/ ********* Ia acțiuni bazate pe comenzile ThingSpeak ************* /
void takeActions (void)
{
  Serial.print ("Pompă:");
  Serial.println (pompă);
  Serial.print ("Lamp:");
  Serial.println (lampă);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  altceva DigitalWrite (ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite (ACTUATOR2, LOW);
  altceva DigitalWrite (ACTUATOR2, HIGH);
}

/ ********* Citiți comanda Actuatorilor de la ThingSpeak ************* /
int readThingSpeak (canal StringID)
{
  startThingSpeakCmd ();
  comandă int;
  // preparacao da string GET
  String getStr = "GET / channel /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (mesajDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Comandă primită:");
    Serial.println (comanda);
  }
  else comanda = 9;
  comanda returnare;
}

/ ********* Resetare ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Resetare .......");
  digitalWrite (HARDWARE_RESET, LOW);
  întârziere (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necesário para começar a ler
  Serial.println ("RESET");
}

/ ********* Începeți comunicarea cu ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o tampon înainte de a veni un gravar
  
  String 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 ("Eroare"))
  {
    Serial.println ("eroare AT + CIPSTART");
    return;
  }
}

/ ********* trimite un cmd GET către ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (lungime getStr. ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lungimea cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo pentru procesare o GET, sem este întârziere apresenta busy no next comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// conținutul real începe după linia goală (care are lungimea 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody primit:");
    Serial.println (mesajBody);
    returnare mesajBody;
  }
  altfel
  {
    EspSerial.println ("AT + CIPCLOSE"); // utilizator de alertă
    Serial.println ("EROAREA CIPSENDULUI ESP8266: REZENTARE"); // Trimite mai departe ...
    rezervă = rezervă + 1;
    eroare = 1;
    retur „eroare”;
  }
}

Îl puteți descărca la



În această etapă, avem un canal actuator configurat care modifică valoarea câmpului 1 pentru fiecare dispozitiv. Trebuie să verificăm dacă dispozitivele funcționează corect comenzile. La sfârșitul proiectului, o aplicație Android va fi folosită pentru asta, dar poate fi realizată și printr-un browser.

Porniți pompa (LED-ul roșu aprins)

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

Pompă oprită (LED roșu stins)

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

Porniți lampa (LED-ul verde este aprins)

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

Opriți lampa (LED-ul verde stins)

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

În partea anterioară, a existat un program simplu care „citea” datele de pe canal și le afișa pe ecran. Acum trebuie să facem din program să „scrie” comenzile din Actuator Channal, astfel încât aceste comenzi să poată fi citite de controler și lampa cu pompa funcționată în consecință.

Pentru ca utilizatorul să poată trimite comenzi, aplicația va avea două butoane pentru fiecare dispozitiv. Dacă este pornit, albastru, dacă este oprit, roșu.

Făcând clic pe butoanele din aplicație, puteți vedea rezultatul în Serial Monitor.

Codul poate fi descărcat la



În această etapă, există o aplicație Android completată complet, o parte „fieră” complet asamblată, dar nu există niciun cod în controler care să citească constant datele și să trimită comenzi în cloud. Trebuie doar să combinați toate fragmentele de cod scrise mai devreme. Desigur, codul are opțiuni suplimentare de verificare (de exemplu, dacă ESP-01 îngheață). Pentru a face acest lucru, periodic, înainte de fiecare comandă de citire sau scriere, este trimisă o comandă AT.Și dacă răspunsul OK nu a venit de la modul, atunci modulul este repornit forțat programatic.

Codul complet al proiectului poate fi descărcat la

La adresă puteți obține actualizări pentru fișierele de program.

Puteți citi și comentarii pe linkul către sursă, dacă ceva nu este clar.