Manažment skleníka alebo skleníka odkiaľkoľvek na svete (príklad implementácie)

Arduino / Skleníky a varné platne

1 Koncept zariadenia

Účelom tohto vývoja je zhromažďovať údaje z lokálnych senzorov a odosielať ich na internet. Užívateľ bude mať možnosť prezerať údaje pochádzajúce zo senzorov kdekoľvek na svete a robiť vzdialené rozhodnutia o aktivácii určitých akčných členov, ktoré budú umiestnené lokálne vedľa senzorov.

Projekt využíva Arduino UNO a WiFi modul ESP8266-01. Dáta sa prenesú do cloudu prostredníctvom webovej služby ThingSpeak.com a zariadenia sa aktivujú prostredníctvom aplikácie pre Android vyvinutej pomocou MIT AppInventor.

Manažment skleníka alebo skleníka odkiaľkoľvek na svete (príklad implementácie)

IoT je koncept počítačovej siete fyzických objektov („vecí“), ktorý je vybavený vstavanými technológiami na vzájomnú interakciu medzi sebou alebo s vonkajším prostredím, pričom organizáciu takýchto sietí považuje za jav, ktorý môže obnoviť hospodárske a sociálne procesy a vylučuje potrebu ľudskej účasti z časti akcií a operácií.

Hlavným zameraním tohto projektu IoT bude služba ThingSpeak.com. Lokálne zariadenie UNO / ESP-01 prijíma údaje zo senzorov a údaje o stave akčných členov, odosiela ich do internetového „záznamu“ prostredníctvom špecifického stavového kanála ThingSpeak.com (ThingSpeak.com Status Channel), rovnaké miestne zariadenie prijíma údaje, “ ich čítanie z iného dátového kanála - „kanál výkonných zariadení“ (ThingSpeak.com Actuator Channels).

Údaje sa zbierajú pomocou snímača teploty a relatívnej vlhkosti, teploty a vlhkosti pôdy a snímača okolitého svetla. Tieto údaje sa odošlú do cloudu služieb ThingSpeak.

K dispozícii budú dve výkonné zariadenia - toto je vodné elektrické čerpadlo a lampa. Ich stav ZAP / VYP sa pošle aj do cloudu. Napríklad údaje zo senzorov môžu zobrazovať aktuálny stav skleníka alebo skleníka. Užívateľ bude ovládať výkonné zariadenia pomocou aplikácie pre Android.

2 Zoznam požadovaných komponentov

Všetky odkazy slúžia iba na informačné účely.

2 x LED (červená a zelená)
1 x
- $3.00
220 V lampa
2 x 330 ohmový rezistor (používa sa s LED)
2 x 10 K ohmový rezistor (používa sa s DHT22 a LDR)
1 x 4K7 ohmový rezistor (používa sa s DS18B20)
prototyping board
prepojky
Externé napájanie pre relé 5V DC

3 Železná časť

Teraz musíte pripojiť všetky senzory, ako je to znázornené na obrázku.

Ideálnym riešením by bolo zostavenie a testovanie projektu po častiach.

V nasledujúcom poradí:
1. Nainštalujte a otestujte všetky snímače
2.Nainštalujte a nakonfigurujte minimum ESP-01
3. Zmeňte nastavenie ESP-01 na konečnú konfiguráciu a test
4. Nakonfigurujte stavový kanál ThingSpeak
5. Nainštalujte kód ThingSpeak na Arduino a skontrolujte stav senzorov v cloude
6. Vyvinúť prvú verziu programu pre Android na kontrolu stavových správ zo senzorov
7. Namontujte ovládače
8. Nakonfigurujte kanály ThingSpeak Actuators
9. Nainštalujte a otestujte kód pre výkonné zariadenia v Arduino
10. Vytvorte druhú verziu programu pre Android pre celú zostavu zariadenia.

4 Pripojenie senzora

Tento projekt používa niektoré knižnice, ktoré sú zahrnuté v. Je potrebné skontrolovať ich dostupnosť. Počiatočná konfigurácia týchto knižníc je nasledovná:

// DS18B20
#include 
#include 
#definovať ONE_WIRE_BUS 5 // DS18B20 na kolíku 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)
#definovať ldrPIN 1
int light = 0;

// Pôdna vlhkosť
#definovaná pôdaHumPIN 0
int soilHum = 0;

Teraz inicializujeme naše senzory a zobrazíme ich v termináli:

neplatné nastavenie ()
{
  Serial.egegin (9600);
  DS18B20.egegín ();
  dht.begin ();
}

prázdna slučka ()
{
  readSensors ();
  displaySensors ();
  oneskorenie (10000);
}

Nakoniec napíšeme dve funkcie: jedna načíta údaje zo senzorov a druhá ich zobrazí na obrazovke:

/ ********* Hodnota snímača snímania ************** /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTempericates ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzor 0 zachytí pôdnu teplotu v Celcius
  
  soilHum = mapa (analógRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> svetlo 100%

}

/ ********* Hodnota senzorov displeja ************** /
void displaySensors (void)
{
  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 (light);
  Serial.println ("");
}

Fotografia ukazuje, ako sa údaje zobrazujú na obrazovke.

Zdrojový kód si môžete stiahnuť od autora.

4 ESP8266-01 základná konfigurácia

Najrýchlejším spôsobom „rozhovoru“ s modulom je príkaz AT. Procesor už má príkazový procesor AT. V predvolenom nastavení je modul dodávaný s výrobnými nastaveniami 115200 baudov, v nastaveniach musíte nastaviť 9600 baudov.

Najprv musíte pripojiť modul, ako je znázornené na fotografii

( Všimnite si, že terminál Tx ESP-01 je pripojený k terminálu Tx UNO, rovnako ako terminály Rx sú navzájom spojené. Toto pripojenie sa neskôr zmení. ).

Potom pripojte UNO k počítaču, otvorte IDE a stiahnite si príklad, ktorý sa nachádza. Toto je prázdny kód, aby nedošlo k žiadnym konfliktom medzi ESP-01 a UNO. Tento kód bol odovzdaný do Ardunio pred pripojením ESP-01, aby ste sa uistili, že Ardunio nebude používať kolíky Tx a Rx pre nič iné.
Teraz musíte otvoriť sériový monitor IDE, v nastaveniach nastaviť prenosovú rýchlosť na 115200 a poslať príkaz AT na sériový monitor IDE. ESP-01 by mal poslať odpoveď OK

Teraz musíte zmeniť rýchlosť prenosu dát v module ESP-01. Ak to chcete urobiť, v IDE zadajte príkaz

AT + CIOBAUD = 9600

Môže sa stať, že sa ESP-01 vráti na výrobné nastavenia, potom budete musieť použiť iný príkaz:

AT + UART_DEF = , , , ,

Napríklad 9600 baud / 8 dátových bitov / 1 stop bity a žiadna kontrola parity a toku

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

Teraz zmeňte rýchlosť prenosu dát v nastaveniach IDE na 9600 a odošlite príkaz AT, mala by prísť OK odpoveď.
Ďalej musíte prepnúť modul do režimu STA, aby sa mohol pripojiť k prístupovému bodu vašej siete.

AT + CWMODE = 1

Ak sa má modul pripojiť k sieti, zadajte príkaz AT + CWJAP = "network_name", "network_name_1"kde NETWORK_NAME Je názov vašej siete a network_name_1 - heslo pre vašu sieť (heslo a názov siete musia byť v úvodzovkách)
Ak vidíte odpoveď WIFI PRIPOJENÉ WIFI GOT IP, potom sa vytvorí spojenie. Overte IP adresu pomocou príkazu

AT + CIFSR

.

Adresa, ktorá sa zobrazí na monitore, ktorú môžete použiť v budúcnosti. Po nakonfigurovaní modulu ho môžete pripojiť natrvalo, ale na tento účel musíte zmeniť jeho spínací obvod, ako je to znázornené na obrázku.

• ESP-01 RX (žltý) -> UNO Pin D7
• ESP-01 TX (oranžový) -> UNO Pin D6
• ESP-01 Ch-Pd (hnedý) -> Vcc (3,3 V)
• ESP-01 Reset (Modrý) -> UNO Pin D8
• ESP-01 Vcc (červený) -> 3,3 V
• ESP-01 Gnd (Black) -> UNO GND

Upozorňujeme, že knižnica softvérových sériových kódov používa pin PIN D7 UNO ako tx a pripája sa na výstup ESP-01 RXzatiaľ čo UNO Pin D6 ako rxpripojený k ESP-01 TX.

Zadajte malý kód, aby ste skontrolovali správne pripojenie a konfiguráciu modulu ESP-01

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

# definovať rýchlosť8266 9600

neplatné nastavenie ()
{
  esp8266.begin (rýchlosť8266);
  Serial.egegin (speed8266);
  Serial.println ("ESP8266 Setup test - použite AT coomands");
}

prázdna slučka ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Teraz niekoľko AT tímov. Výsledky nájdete v Serial Monitor.

* AT =====> ESP8266 sa vracia v poriadku
* AT + RST =====> ESP8266 sa reštartuje a vráti sa OK
* AT + GMR =====> ESP8266 vracia verziu AT; Verzia SDK; id; OK
* AT + CWMODE? => ESP8266 vracia typ režimu
* AT + CWLAP ===> ESP8266 vracia blízke prístupové body
* AT + CIFSR ===> ESP8266 vracia určenú IP

Programový kód si môžete stiahnuť na

6 pripojenie snímačov a ESP-01

Po pripojení a kontrole všetkých senzorov a skontrolovaní modulu ESP-01 je potrebné pripraviť údaje na odoslanie na internet.

7 ThingSpeak

Jednou z najdôležitejších častí projektu je otvorená platforma IoT, ktorá vám umožní zbierať údaje zo senzorov, spracovávať ich a analyzovať. Ak to chcete urobiť, prejdite na stránku a vytvorte si účet. Ďalej musíte vytvoriť kanál, v ktorom budú 2 ovládače, 5 senzorov a jedno záložné pole.
• Pole 1: Ovládač 1 (zariadenie 1)
• Pole 2: Ovládač 2 (zariadenie 2)
• Pole 3: Teplota vzduchu v oC (teplota vzduchu v stupňoch Celzia)
• Súbor 4: Relatívna vlhkosť vzduchu v% (relatívna vlhkosť v%)
• Pole 5: Teplota pôdy v oC (teplota pôdy v stupňoch Celzia)
• Pole 6: Vlhkosť pôdy v% (vlhkosť pôdy v%)
• Pole 7: Svietivosť v% (osvetlenie v%)
• Pole 8: Náhradné

Pole 8 je vyhradené pre budúce rozšírenie alebo ladenie. V tomto projekte sa používa ako počítadlo chýb v komunikácii medzi Arduino / ESP-01 a ThingSpeak.com.

Po vytvorení stavového kanála je potrebné zaznamenať klávesy, ako je to znázornené na fotografii.

8 Odosielanie stavu senzora do cloudu

Momentálne máme nakonfigurovanú cloudovú službu a naše senzory zhromažďujú údaje lokálne. Teraz musíte vziať tieto údaje a odoslať ich do cloudu na stránke ThingSpeak.com.

Aby ste mohli zapisovať údaje na kanál ThingSpeak, musíte poslať reťazec GET. Uskutoční sa to v troch etapách.
Pošlite príkaz "Start cmd"

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

Ďalšia dĺžka reťazca

AT + CIPSEND = 116

A nakoniec reťazec GET, ktorý zapíše naše údaje do vyhradených polí Status Channel.

ZÍSKAJTE / aktualizujte? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = náhradné

Upozorňujeme, že do kanála by sme nemali zapisovať údaje viac ako raz za 16 sekúnd.

Zadaný kód urobí všetko.

// Thingspeak
String statusChWriteKey = "VAŠE PÍSOMNÉ KĽÚČ TU"; // ID stavového kanála: 385184

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

// DS18B20
#include 
#include 
#definovať ONE_WIRE_BUS 5 // DS18B20 na kolíku 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)
#definovať ldrPIN 1
int light = 0;

// Pôdna vlhkosť
#definovaná pôdaHumPIN 0
int soilHum = 0;

// Premenné, ktoré sa majú používať s časovačmi
long writeTimingSeconds = 17; // ==> Definujte čas vzorkovania v sekundách na odoslanie údajov
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Premenné, ktoré sa majú použiť s ovládačmi
boolovské čerpadlo = 0;
boolovská lampa = 0;

int náhradné = 0;
boolovská chyba;

neplatné nastavenie ()
{
  Serial.egegin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.egegín ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startWriteTiming = millis (); // spustenie „programových hodín“
}

prázdna slučka ()
{
  začiatok: // label
  chyba = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Znovu odošlite, ak prenos nie je dokončený
  {
    Serial.println ("<<<< CHYBA >>>>");
    oneskorenie (2000);
    začiatočný krok; // prejdite na štítok „start“
  }
}

/ ********* Hodnota snímača snímania ************** /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTempericates ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzor 0 zachytí pôdnu teplotu v Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> svetlo 100%
  soilHum = mapa (analógRead (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 (pumpa);
  getStr + = "& field2 =";
  getStr + = String (lampa);
  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 (náhradné);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Reset ESP *************/
void EspHardwareReset (void)
{
  Serial.println („Obnovuje sa .......“);
  digitalWrite (HARDWARE_RESET, LOW);
  oneskorenie (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  oneskorenie (8000); // Tempo needário para começar a ler
  Serial.println („RESET“);
}

/ ********* Začať komunikáciu s ThingSpeak *************/
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer anes de começar gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184,106,154,49"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find („Chyba“))
  {
    Serial.println („chyba AT + CIPSTART“);
    return;
  }
}

/ ********* poslať GET cmd na ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> dĺžka cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// skutočný obsah začína po prázdnom riadku (ktorý má dĺžku 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody obdržal:“);
    Serial.println (messageBody);
    návrat messageBody;
  }
  inak
  {
    EspSerial.println („AT + CIPCLOSE“); // upozorniť používateľa
    Serial.println („ESP8266 CIPSEND ERROR: RESENDING“); // Znovu odoslať ...
    náhradný = náhradný + 1;
    chyba = 1;
    návrat "chyba";
  }
}

Postup môžete vidieť na Serial Monitor.

Zdrojový kód si môžete stiahnuť na

9 android aplikácie - prvá časť

Najprv musíte vytvoriť užívateľské rozhranie. Obrázok zobrazuje hlavné viditeľné a neviditeľné prvky.

Potom musíte vytvoriť bloky. Položky ponuky zodpovedajú číslam snímok obrazovky.

1 Premenné štátu, ktoré by sa mali deklarovať ako globálne

2 Každé dve sekundy (v závislosti od hodín1) sa vyvolá postup "ReadArduino"

Procedúra vracia hodnotu premenných, ktoré by sa mali zobraziť na obrazovke. V takom prípade sa hodnota stavu (0 a 1) pre ovládače prevádza na lepšie zapnutie na „ZAP“ a „VYP“.

Tieto hodnoty (Stav) sa zobrazia v zodpovedajúcich „Skratkách“

3 Rutina readArduino bude v podstate čítať stavový kanál v ThingSpeak. Musíte teda určiť webovú adresu, ktorá sa odošle na server Thingspeak. Ak to chcete urobiť, musíte deklarovať a kombinovať 3 globálne premenné, aby ste vytvorili URL, ktorá sa pošle na ThingSpeak. GET by sa mal odoslať na webový komponent s názvom «ArduFarmBotStatusCh»

4 Text prijatý z predchádzajúceho príkazu dorazí vo formáte JSon. Tento text je potrebné spracovať tak, aby sa každé pole čítalo a ukladalo do zodpovedajúcej globálnej premennej.

5 Posledné, čo musíte urobiť, je vyvolať postup „Alarm“, ktorý bude analyzovať stav dvoch snímačov pôdy. Ak je teplota príliš nízka (v našom prípade 10 ° C), mala by sa zobraziť správa. To isté platí pre vlhkosť, ak je nižšia ako 60%.

Upozorňujeme, že sme definovali iný časovač (Clock2), naprogramovaný tak, aby sa spustil každú sekundu. Stačí iba „prepnúť“ farbu textu správy (z bielej na červenú). Správa bude blikať.

Kód aplikácie si môžete stiahnuť na

10 Pripojenie servopohonov

Príkazy na zapínanie a vypínanie pumpy a lampy sa prijímajú diaľkovo. Výstup Ardunio aktivuje relé a LED, pričom tieto príkazy prijíma. Obrázok ukazuje, ako by sa servopohony mali pripojiť. Upozorňujeme, že výstup relé GND NENÍ PRIPOJENÉ na výstup GNDUNO. Týmto spôsobom bude pri prevádzke relé menšie rušenie výkonu.

11 konfigurácií ovládačov kanálov (akčné členy)

Všetky akcie opakujú postup konfigurácie kanála stavu. Pre každé zariadenie je potrebné vytvoriť dva kanály. Pre každý kanál napíšte tlačidlá ID kanála, Čítanie a Zápis. Píšeme iba do prvého poľa každého kanála. Napríklad:
ID kanála 375598 ==> Červená LED (čerpadlo)
◦ Pole1 = 0 ==> Čerpadlo VYPNUTÉ
◦ Pole1 = 1 ==> Čerpadlo zapnuté
2. ID kanála 375599 ==> LED zelená (lampa)
◦ Pole1 = 0 ==> Lampa VYPNUTÁ
◦ Pole1 = 1 ==> Svieti

11 načítavanie a testovanie ovládačov kódu v Ardunio.

Keď sme poslali dáta do cloudu, tieto údaje sme „zapísali“ do ThingSpeak. Stavový kanál „prenášal“ (odovzdával) tieto údaje. Teraz musíme „prečítať“ údaje z kanála aktuátora a „prijať“ (stiahnuť) tieto údaje.

Ak to chcete urobiť, odošlite reťazec GET a tento postup pozostáva z 3 fáz.
"Start cmd"

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

Dĺžka čiary

AT + CIPSEND = 36

A samotný reťazec GET

GET / kanály / 375598 / polia / 1 / posledný

Kanály sa „prečítajú“ každých 10 sekúnd

Po odoslaní GET musíme prijať odpoveď od ThingSpeak. Odpoveď musí byť 0 alebo 1 pre každý kanál. Ak existujú nejaké ďalšie hodnoty, jednoducho ich ignorujeme.

Hlavný rozdiel medzi touto a predchádzajúcou časťou je iba vo funkcii readThingSpeak (String channelID)
Nižšie je uvedený kód, ktorý vykonáva opísané akcie.

// Thingspeak
String canalID1 = "999999"; // Ovládač1
String canalID2 = "999999"; // Ovládač2

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

// Premenné, ktoré sa majú používať s časovačmi
long readTimingSeconds = 10; // ==> Definujte čas vzorkovania v sekundách na príjem údajov
long startReadTiming = 0;
long elapsedReadTime = 0;

// Relé
#define ACTUATOR1 10 // ČERVENÁ LED ==> Čerpadlo
#define ACTUATOR2 12 // ZELENÁ LED ==> Lampa
boolovské čerpadlo = 0;
boolovská lampa = 0;

int náhradné = 0;
boolovská chyba;

neplatné nastavenie ()
{
  Serial.egegin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startReadTiming = millis (); // spustenie „programových hodín“
}

prázdna slučka ()
{
  začiatok: // label
  chyba = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int príkaz = readThingSpeak (canalID1);
    if (príkaz! = 9) čerpadlo = príkaz;
    oneskorenie (5000);
    command = readThingSpeak (canalID2);
    if (príkaz! = 9) lampa = príkaz;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Znovu odošlite, ak prenos nie je dokončený
  {
    Serial.println ("<<<< CHYBA >>>>");
    oneskorenie (2000);
    začiatočný krok; // prejdite na štítok „start“
  }
}

/ ********* Podniknite kroky na základe príkazov ThingSpeak ************** /
neplatné akcie (neplatné)
{
  Serial.print ("Pump:");
  Serial.println (čerpadlo);
  Serial.print ("Lamp:");
  Serial.println (lampa);
  ak (čerpadlo == 1) digitalWrite (ACTUATOR1, LOW);
  inak digitalWrite (ACTUATOR1, HIGH);
  ak (lampa == 1) digitalWrite (ACTUATOR2, LOW);
  inak digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Prečítajte si príkaz Actuators from ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int príkaz;
  // preparacao da string GET
  String getStr = "GET / kanály /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print („Príkaz prijatý:“);
    Serial.println (príkaz);
  }
  inak príkaz = 9;
  príkaz na návrat;
}

/ ********* Reset ESP *************/
void EspHardwareReset (void)
{
  Serial.println („Obnovuje sa .......“);
  digitalWrite (HARDWARE_RESET, LOW);
  oneskorenie (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  oneskorenie (8000); // Tempo needário para começar a ler
  Serial.println („RESET“);
}

/ ********* Začať komunikáciu s ThingSpeak *************/
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer anes de começar gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184,106,154,49"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Start cmd:");
  Serial.println (cmd);

  if (EspSerial.find („Chyba“))
  {
    Serial.println („chyba AT + CIPSTART“);
    return;
  }
}

/ ********* poslať GET cmd na ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> dĺžka cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// skutočný obsah začína po prázdnom riadku (ktorý má dĺžku 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody obdržal:“);
    Serial.println (messageBody);
    návrat messageBody;
  }
  inak
  {
    EspSerial.println („AT + CIPCLOSE“); // upozorniť používateľa
    Serial.println („ESP8266 CIPSEND ERROR: RESENDING“); // Znovu odoslať ...
    náhradný = náhradný + 1;
    chyba = 1;
    návrat "chyba";
  }
}

Môžete si ho stiahnuť na

12 zasielanie príkazov do zariadení

V tejto fáze máme nakonfigurovaný kanál ovládača, ktorý mení hodnotu poľa 1 pre každé zariadenie. Musíme overiť, či zariadenia správne vypracúvajú príkazy. Na konci projektu sa na tento účel použije aplikácia pre Android, ale dá sa to urobiť aj pomocou prehliadača.

Zapnite čerpadlo (červená LED svieti)

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

Čerpadlo vypnuté (červená LED nesvieti)

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

Zapnite lampu (zelená LED svieti)

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

Vypnite lampu (zelená LED zhasne)

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

14 Ukončenie programu Android

V predchádzajúcej časti existoval jednoduchý program, ktorý „načítal“ údaje z kanála a zobrazil ich na obrazovke. Teraz musíme urobiť program, aby „zapisoval“ príkazy do kanála aktora, aby tieto príkazy mohli čítať kontrolér a lampa s pumpou pracovala zodpovedajúcim spôsobom.

Aby mohol užívateľ odosielať príkazy, bude mať aplikácia pre každé zariadenie dve tlačidlá. Ak je zapnutá, modrá; ak je vypnutá, červená.

Kliknutím na tlačidlá v aplikácii zobrazíte výsledok v Serial Monitor.

Kód si môžete stiahnuť na

15 Finálna montáž

V tejto fáze existuje kompletne dokončená aplikácia pre Android, kompletne zostavená hardvérová časť, ale v kontroléri nie je žiadny kód, ktorý by neustále čítal údaje a posielal príkazy do cloudu. Stačí skombinovať všetky fragmenty kódu napísaného skôr. Samozrejme, kód má ďalšie možnosti overenia (napríklad, ak zamrzne ESP-01). Za týmto účelom sa pravidelne pred každým príkazom na čítanie alebo zápis odosiela príkaz AT.A ak odpoveď OK nepochádza z modulu, modul sa násilne reštartuje programovo.

Celý kód projektu si môžete stiahnuť na

Na adresu môžete získať aktualizácie programových súborov.

Ak niečo nie je jasné, môžete si prečítať komentáre k odkazu na zdroj.