Posturi Populare

Alegerea Editorului - 2020

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

1 Concept de dispozitiv


Scopul acestei dezvoltări este de a colecta date de la senzori locali, de a trimite aceste date pe Internet. Utilizatorul va putea vedea oriunde în lume să vadă datele provenite de la senzori și să decidă de la distanță activarea anumitor actuatoare care vor fi localizate local, lângă senzori
Proiectul utilizează modulul Arduino 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.
IoT este conceptul unei rețele de calculatoare de obiecte fizice („lucruri”) echipate cu tehnologii încorporate pentru interacționarea între ele sau cu mediul extern, considerând organizarea acestor rețele ca un fenomen care poate reconstrui procesele economice și sociale, eliminând nevoia de participare umană dintr-o parte din acțiuni și operațiuni.

Obiectivul principal al acestui proiect IoT va fi serviciul ThingSpeak.com. Dispozitivul local UNO / ESP-01 primește date de la senzori și date despre starea actuatoarelor, le trimite la „înregistrare” pe Internet printr-un canal de stare specific ThingSpeak.com (canalul de stare ThingSpeak.com), același dispozitiv local primește date, " citind „ele dintr-un alt canal de date,„ canalul de acționare ”(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 transmise 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 curentă a unei sere sau a unei sere. Utilizatorul va controla dispozitivele executive folosind aplicația Android.

2 Lista componentelor necesare


Toate link-urile sunt doar cu titlu informativ.
Arduino UNO (microcontroler)
ESP8266-01 (modul de comunicare)
DHT22 (senzor de umiditate relativă)
DS18B20 (senzor digital de temperatură cu 1 fir, utilizat pentru măsurarea temperaturii solului)
YL-69 + LM393 (senzor de umiditate a solului)
LDR (senzor de lumină)
2 x LED-uri (roșu și verde)
1 x Modul releu cu 2 canale Releu DC 5V
Pompa de curent continuu 5V - 3,00 USD
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 Prototyping
jumperii
Sursa de alimentare externa pentru releul de 5V CC

3 Partea de fier


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 minimizați configurarea 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 Actuatori ThingSpeak
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.

4 Conexiune senzor


Proiectul folosește câteva biblioteci care fac parte din IDE Arduino. 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 "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 (); } loop void () {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:
/ ********* Valoarea senzorilor de citire ************* / void readSensors (void) {airTemp = dht.readTemperature (); airHum = dht.readHumidity (); DS18B20.requestTemperatures (); soilTemp = DS18B20.getTempCByIndex (0); // Senzorul 0 va capta temperatura solului în Celcius soilHum = 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 pe GITHUB al autorului

4 ESP8266-01 configurație de bază


Cea mai rapidă modalitate de „chat” 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 care este Fișier> Exemple> 01.Basics> BareMinimum. 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, ar trebui să vină răspunsul OK.
Î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) -> UNO Pin 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"); } void loop () {while (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, trebuie să pregătiți datele pentru trimiterea pe internet.

7 ThingSpeak


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, urmați linkul ș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âmp 5: Temperatura solului în oC (Temperatura solului în 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.

8 Trimiterea stării senzorului către cloud


Î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. Acest lucru se va face în trei pași.
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 / actualizare? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Rețineți că nu trebuie 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"; // ID canal 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 "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 cronometrele long writeTimingSeconds = 17; // ==> Definirea timpului de eșantion în câteva secunde pentru a trimite date lung startWriteTiming = 0; mult timp scursWriteTime = 0; // Variabile care urmează să fie utilizate cu pompa booleană a actuatoarelor = 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"} bucla de void () {start: // eroare de etichetă = 0; elapsedWriteTime = millis () - startWriteTiming; if (elapsedWriteTime> (writeTimingSeconds * 1000)) {readSensors (); writeThingSpeak (); startWriteTiming = millis (); } if (eroare == 1) // Remitere dacă transmisia nu este finalizată {Serial.println ("<<< >>>"); întârziere (2000); goto start; // accesați eticheta "start"}} / ********* Valoarea senzorilor de citire ************* / void readSensors (void) {airTemp = dht.readTemperature () ; airHum = dht.readHumidity (); DS18B20.requestTemperatures (); soilTemp = DS18B20.getTempCByIndex (0); // Senzorul 0 va capta temperatura solului în lumina Celcius = hartă (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> light 100% soilHum = 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); întârziere (8000); // Tempo necesar pentru a obține o serie Serial.println ("RESET"); } / ********* Începeți comunicarea cu ThingSpeak ************* / void startThingSpeakCmd (void) {EspSerial.flush (); // limpa o tampon înainte de vençar a 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 GET cmd la ThingSpeak ************* / String sendThingSpeakGetCmd (String getStr) {String cmd = "AT + CIPSEND ="; cmd + = String (lungime getStr. ()); EspSerial.println (cmd); Serial.print ("enviado ==> lungime 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; } else {EspSerial.println ("AT + CIPCLOSE"); // alerta utilizator Serial.println ("EROAREA CIPSENDULUI ESP8266: REZENTARE"); // Trimitere ... rezervă = rezervă + 1; eroare = 1; retur „eroare”; }}

Puteți vedea progresul în Serial Monitor.

Codul sursă poate fi descărcat la

9 aplicații android - prima parte


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 captură.
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 celor 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 aici

10 Racordarea actuatoarelor


Comenzile de pornire și oprire a 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 concluzia GND UNO. În acest fel, va exista mai puțină interferență de putere atunci când releul funcționează.

11 configurația actuatoarelor de canal (canale actuatoare)


Toate acțiunile repetă procedura pentru configurarea canalului Status. Este necesar să se creeze două canale pentru fiecare dintre dispozitive. Pentru fiecare canal, trebuie să scrieți codul ID, 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ă

11 actuatoare de coduri de încărcare și testare în Ardunio.


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 Actuator, „acceptând” (descărcând) aceste date.
Pentru a face acest lucru, trimiteți șirul 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” o dată la 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 // Variabilele care vor fi utilizate cu cronometre de citire îndelungatăTimingSeconds = 10; // ==> Definirea timpului de eșantion în câteva secunde pentru a primi date de început 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é is ativo em LOW digitalWrite (ACTUATOR2, HIGH); // o módulo relé este ativo în LOW digitalWrite (HARDWARE_RESET, HIGH); EspSerial.begin (9600); // Comunicacao com Modulo WiFi EspHardwareReset (); // Resetați Modulo WiFi startReadTiming = millis (); // pornirea "ceasului programului"} bucla de void () {start: // eroare de etichetă = 0; elapsedReadTime = millis () - startReadTiming; if (elapsedReadTime> (readTimingSeconds * 1000)) {int command = 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 ("<<< >>>"); întârziere (2000); goto start; // accesați eticheta "start"}} / ********* Efectuați 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); } / ********* Citeste comanda Actuatorilor de la ThingSpeak ************* / int readThingSpeak (String channelID) {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 (messageDown5 == 49) {command = messageDown7-48; Serial.print ("Comandă primită:"); Serial.println (comanda); } else command = 9; comanda returnare; } / ********* Resetare ESP ************* / void EspHardwareReset (void) {Serial.println ("Resetare ..."); digitalWrite (HARDWARE_RESET, LOW); întârziere (500); digitalWrite (HARDWARE_RESET, HIGH); întârziere (8000); // Tempo necesar pentru a obține o serie Serial.println ("RESET"); } / ********* Începeți comunicarea cu ThingSpeak ************* / void startThingSpeakCmd (void) {EspSerial.flush (); // limpa o tampon înainte de vençar a 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 GET cmd la ThingSpeak ************* / String sendThingSpeakGetCmd (String getStr) {String cmd = "AT + CIPSEND ="; cmd + = String (lungime getStr. ()); EspSerial.println (cmd); Serial.print ("enviado ==> lungime 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; } else {EspSerial.println ("AT + CIPCLOSE"); // alerta utilizator Serial.println ("EROAREA CIPSENDULUI ESP8266: REZENTARE"); // Trimitere ... rezervă = rezervă + 1; eroare = 1; retur „eroare”; }}

Îl poți descărca aici

12 trimiterea de comenzi către dispozitive


În această etapă, avem un canal configurat pentru actuatoare care modifică valoarea câmpului 1 pentru fiecare dispozitiv. Trebuie să verificăm dacă dispozitivele funcționează corect comenzile. В конце проекта для этого будет использоваться андроид приложение, но так же это можно сделать посредством браузера.
Включить насос (красный светодиод включен)
//api.thingspeak.com/update?api_key=Сохраненный_ключ_канала_1&field1=1

Насос выключить (красный светодиод выключен)
//api.thingspeak.com/update?api_key=Сохраненный_ключ_канала_1&field1=0

Лампу включить (зеленый светодод включен)
//api.thingspeak.com/update?api_key=Сохраненный_ключ_канала_2&field1=1

Лампу выключить (зеленый светодиод выключен)
//api.thingspeak.com/update?api_key=Сохраненный_ключ_канала_2&field1=0

14 Завершение программы андроид


В предыдущей части была простая программа, которая "читала" данные из канала и выводила их на экран. Теперь надо сделать, чтобы программа "писала" команды в Actuator Channal, так чтобы эти команды могли быть прочитаны контроллером и лампа с насосом соответственно отрабатывали.
Чтобы пользователь мог отправлять команды, в приложении будут по две кнопки на каждое устройство. Если включено- синяя, если выключено- красная.
Нажимая кнопки в приложении можно видеть результат в Serial Monitor.
Код можно скачать по ссылке

15 Финальная сборка


На данном этапе есть полностью завершенное андроид приложение, полностью собранная "железная" часть, но нет кода в контроллере, который бы постоянно читал данные и отправлял команды на облако. Надо просто объединить все фрагменты кода, написанного ранее.В конечно коде есть дополнительные опции проверки (на пример если ESP-01 зависнет). Для этого, периодически, перед каждой командой чтения или записи отправляется команда АТ. И если от модуля не пришел ответ ОК, то модуль принудительно программно перезагружается.
Полный код проекта можно скачать по ссылке
По адресу ArduFarmBot_Light можно взять обновления для файлов программы.
Так же можно почитать комментарии по ссылке на источник, если что-то не понятно.

Lasă Un Comentariu