Správa skleníku nebo skleníku odkudkoli na světě (příklad implementace)

Arduino / Skleníky a pařeniště

1 Koncept zařízení

Účelem tohoto vývoje je shromažďovat data z lokálních senzorů a posílat je na internet. Uživatel bude moci kdekoli na světě prohlížet data přicházející ze senzorů a vzdáleně rozhodovat o aktivaci určitých akčních členů, které budou umístěny lokálně vedle senzorů

Projekt využívá Arduino UNO a WiFi modul ESP8266-01. Data budou přenášena do cloudu prostřednictvím webové služby ThingSpeak.com a zařízení budou aktivována prostřednictvím aplikace pro Android vyvinuté pomocí MIT AppInventor.

Správa skleníku nebo skleníku odkudkoli na světě (příklad implementace)

IoT je koncept počítačové sítě fyzických objektů („věcí“), která je vybavena vestavěnými technologiemi pro vzájemnou interakci mezi sebou nebo s vnějším prostředím, přičemž organizaci takových sítí považuje za jev, který může obnovit hospodářské a sociální procesy a vylučuje potřebu lidské účasti z části akcí a operací.

Hlavním zaměřením tohoto projektu IoT bude služba ThingSpeak.com. Místní zařízení UNO / ESP-01 přijímá data ze senzorů a data o stavu akčních členů, odešle je do internetového „záznamu“ prostřednictvím specifického stavového kanálu ThingSpeak.com (ThingSpeak.com Status Channel), stejné místní zařízení přijímá data, “ čtení „z jiného datového kanálu,„ kanálu výkonných zařízení “(ThingSpeak.com Actuator Channels).

Data budou shromažďována pomocí senzoru teploty a relativní vlhkosti, teploty půdy a vlhkosti a senzoru okolního světla. Tato data budou odeslána do cloudu služeb ThingSpeak.

Budou zde dvě výkonná zařízení - toto je vodní elektrické čerpadlo a lampa. Jejich stav ON / OFF bude také odeslán do cloudu. Například data ze senzorů mohou zobrazovat aktuální stav skleníku nebo skleníku. Uživatel bude ovládat výkonná zařízení pomocí aplikace pro Android.

2 Seznam požadovaných součástí

Všechny odkazy jsou pouze informativní.

2 x LED (červená a zelená)
1 x
- $3.00
220V lampa
2 x 330 ohm rezistor (používá se s LED)
2 x 10 K ohm rezistor (používá se s DHT22 a LDR)
1 x 4K7 ohmový rezistor (používá se s DS18B20)
Prkénko
Svetry
Externí napájení pro relé 5V DC

3 Železná část

Nyní musíte připojit všechny senzory, jak je znázorněno na obrázku.

Ideálním řešením by bylo sestavit a otestovat projekt po částech.

V následujícím pořadí:
1. Nainstalujte a otestujte všechny senzory
2.Nainstalujte a minimální konfiguraci ESP-01
3. Změňte nastavení ESP-01 na konečnou konfiguraci a test
4. Nakonfigurujte stavový kanál ThingSpeak
5. Nainstalujte ThingSpeak kód na Arduino a zkontrolujte stav senzorů v cloudu
6. Vytvořte první verzi programu pro Android a zkontrolujte stavové zprávy ze senzorů
7. Namontujte ovladače
8. Konfigurace kanálů ThingSpeak Actuators
9. Nainstalujte a otestujte kód pro výkonná zařízení v Arduino
10. Vytvořte druhou verzi programu pro Android pro celou sestavu zařízení.

4 Připojení senzoru

Projekt používá některé knihovny, které jsou zahrnuty v. Je nutné zkontrolovat jejich dostupnost. Počáteční konfigurace těchto knihoven je následující:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 na pinu 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)
#definovat ldrPIN 1
int light = 0;

// Půdní vlhkost
#define soilHumPIN 0
int soilHum = 0;

Nyní inicializujeme naše senzory a zobrazujeme je v terminálu:

neplatné nastavení ()
{
  Serial.egegin (9600);
  DS18B20.egegin ();
  dht.begin ();
}

prázdná smyčka ()
{
  readSensors ();
  displaySensors ();
  zpoždění (10000);
}

Nakonec napíšeme dvě funkce: jedna přečte hodnoty ze senzorů a druhá je zobrazí na obrazovce:

/ ********* Hodnota Read Sensors ************** /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTempericates ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzor 0 zachytí půdní teplotu v Celcius
  
  soilHum = mapa (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  light = mapa (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> světlo 100%

}

/ ********* Hodnota senzorů displeje ************** /
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 ("");
}

Fotografie ukazuje, jak jsou data zobrazena na obrazovce.

Zdrojový kód si můžete stáhnout od autora.

4 Základní konfigurace ESP8266-01

Nejrychlejším způsobem, jak „mluvit“ s modulem, je příkaz AT. Procesor již má příkazový procesor AT. Ve výchozím nastavení je modul dodáván s továrním nastavením 115200 baudů, v nastavení musíte nastavit 9600 baudů.

Nejprve musíte modul připojit, jak je znázorněno na fotografii

( Všimněte si, že terminál Tx ESP-01 je připojen k terminálu Tx UNO, stejně jako terminály Rx jsou vzájemně propojeny. Toto připojení bude později změněno. ).

Poté připojte UNO k počítači, otevřete IDE a stáhněte si příklad, který je umístěn. Toto je prázdný kód, takže mezi ESP-01 a UNO neexistují žádné konflikty. Tento kód byl nahrán do Ardunio před připojením ESP-01, aby bylo jisté, že Ardunio nebude používat piny Tx a Rx pro nic jiného.
Nyní musíte otevřít sériový monitor IDE, v nastavení nastavit přenosovou rychlost na 115200 a odeslat příkaz AT do sériového monitoru IDE. ESP-01 by měl poslat odpověď OK

Nyní musíte změnit rychlost přenosu dat v modulu ESP-01. Chcete-li to provést, zadejte v IDE příkaz

AT + CIOBAUD = 9600

Může se stát, že se ESP-01 vrátí do továrního nastavení, pak budete muset použít jiný příkaz:

AT + UART_DEF = , , , ,

Například 9600 baudů / 8 datových bitů / 1 stop bitů a žádná kontrola parity a toku

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

Nyní změňte rychlost přenosu dat v nastavení IDE na 9600 a odešlete příkaz AT, měla by přijít odpověď OK.
Dále musíte přepnout modul do režimu STA, aby se mohl připojit k přístupovému bodu vaší sítě.

AT + CWMODE = 1

Chcete-li se modul připojit k síti, zadejte příkaz AT + CWJAP = "network_name", "network_name_1"kde název_sítě Je název vaší sítě a network_name_1 - heslo pro vaši síť (heslo a název sítě musí být v uvozovkách)
Pokud vidíte odpověď WIFI PŘIPOJENO WIFI GOT IP, pak se naváže spojení. Ověřte IP adresu příkazem

AT + CIFSR

.

Adresa, která se objeví na monitoru, můžete použít v budoucnu. Jakmile nakonfigurujete modul, můžete jej připojit trvale, ale za tímto účelem musíte změnit jeho spínací obvod, jak je znázorněno na obrázku.

• ESP-01 RX (žlutá) -> UNO Pin D7
• ESP-01 TX (oranžová) -> UNO Pin D6
• ESP-01 Ch-Pd (hnědá) -> Vcc (3,3 V)
• ESP-01 Reset (modrý) -> UNO Pin D8
• ESP-01 Vcc (červený) -> 3,3 V
• ESP-01 Gnd (Black) -> UNO GND

Knihovna softwaru Serial používá pin UN7 Pin D7 jako tx a připojuje se k výstupu ESP-01 Rxzatímco UNO Pin D6 jako rxpřipojeno k ESP-01 TX.

Zadejte malý kód, abyste zkontrolovali správné připojení a konfiguraci modulu ESP-01

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

#definovat rychlost8266 9600

neplatné nastavení ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Setup test - použijte AT coomands");
}

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

Nyní několik AT týmů. Výsledky najdete v Serial Monitoru.

* AT =====> ESP8266 vrací OK
* AT + RST =====> ESP8266 se restartuje a vrací OK
* AT + GMR =====> ESP8266 vrací verzi AT; Verze SDK; id; Dobře
* AT + CWMODE? => ESP8266 vrátí typ režimu
* AT + CWLAP ===> ESP8266 vrací blízké přístupové body
* AT + CIFSR ===> ESP8266 vrací určenou IP

Programový kód si můžete stáhnout na adrese

6 připojení senzorů a ESP-01

Po připojení a kontrole všech senzorů a kontrole modulu ESP-01 je nutné připravit data pro odeslání na internet.

7 ThingSpeak

Jednou z nejdůležitějších částí projektu je otevřená platforma IoT, která vám umožní shromažďovat data ze senzorů, zpracovávat je a analyzovat. Chcete-li to provést, přejděte na a vytvořte si svůj účet. Dále musíte vytvořit kanál, kde budou 2 ovladače, 5 senzorů a jedno záložní pole.
• Pole 1: Pohon 1 (zařízení 1)
• Pole 2: Pohon 2 (zařízení 2)
• Pole 3: Teplota vzduchu v oC (teplota vzduchu ve stupních Celsia)
• Soubor 4: Relativní vlhkost vzduchu v% (relativní vlhkost v%)
• Pole 5: Teplota půdy v oC (teplota půdy v gr. Celsia)
• Pole 6: Vlhkost půdy v% (vlhkost půdy v%)
• Pole 7: Svítivost v% (osvětlení v%)
• Pole 8: Náhradní

Pole 8 je vyhrazeno pro budoucí rozšíření nebo pro ladění. V tomto projektu se používá jako čítač chyb v komunikaci mezi Arduino / ESP-01 a ThingSpeak.com.

Jakmile vytvoříte stavový kanál, musíte zaznamenat klíče, jak je znázorněno na fotografii.

8 Odesílání stavu senzoru do cloudu

V tuto chvíli máme nakonfigurovanou cloudovou službu a naše senzory shromažďují data lokálně. Nyní musíte vzít tato data a odeslat je do cloudu na webu ThingSpeak.com.

Abyste mohli zapisovat data do kanálu ThingSpeak, musíte poslat řetězec GET. To bude provedeno ve třech fázích.
Odeslat příkaz "Start cmd"

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

Další délka řetězce

AT + CIPSEND = 116

A konečně řetězec GET, který zapíše naše data do vyhrazených polí Status Channel.

GET / update? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = náhradní

Mějte prosím na paměti, že bychom neměli zapisovat data do kanálu více než 1krát za 16 sekund.

Zadaný kód vše provede.

// Thingspeak
String statusChWriteKey = "VAŠE WRITE KEY HERE"; // ID stavového kanálu: 385184

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

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 na pinu 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)
#definovat ldrPIN 1
int light = 0;

// Půdní vlhkost
#define soilHumPIN 0
int soilHum = 0;

// Proměnné pro použití s časovači
long writeTimingSeconds = 17; // ==> Definujte čas vzorkování v sekundách pro odeslání dat
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Proměnné pro použití s pohony
booleovské čerpadlo = 0;
booleovská lampa = 0;

int náhradní = 0;
booleovská chyba;

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startWriteTiming = millis (); // spuštění "programových hodin"
}

prázdná smyčka ()
{
  start: // label
  chyba = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Znovu odeslat, pokud není přenos dokončen
  {
    Serial.println ("<<<< CHYBA >>>>");
    zpoždění (2000);
    začátek; // přejděte na štítek „start“
  }
}

/ ********* Hodnota Read Sensors ************** /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTempericates ();
  soilTemp = DS18B20.getTempCByIndex (0); // Senzor 0 zachytí půdní teplotu v Celcius
             
  light = mapa (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> světlo 100%
  soilHum = mapa (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 (čerpadlo);
  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 (neplatné)
{
  Serial.println („Obnovení .......“);
  digitalWrite (HARDWARE_RESET, LOW);
  zpoždění (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  zpoždění (8000); // Tempo needário para começar a ler
  Serial.println („RESET“);
}

/ ********* Zahájení komunikace 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");
    návrat
  }
}

/ ********* poslat GET cmd na ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> délka cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      Řetězec = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// skutečný obsah začíná po prázdném řádku (který má délku 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody obdržel:“);
    Serial.println (messageBody);
    návrat messageBody;
  }
  jinde
  {
    EspSerial.println („AT + CIPCLOSE“); // upozornění uživatele
    Serial.println („ESP8266 CIPSEND ERROR: RESENDING“); // Znovu odeslat ...
    náhradní = náhradní + 1;
    chyba = 1;
    návrat "chyba";
  }
}

Postup můžete vidět na sériovém monitoru.

Zdrojový kód lze stáhnout na adrese

9 aplikace pro Android - první část

Nejprve musíte vytvořit uživatelské rozhraní. Obrázek ukazuje hlavní viditelné a neviditelné prvky.

Poté musíte vytvořit bloky. Položky nabídky odpovídají číslům snímků obrazovky.

1 Státní proměnné, které by měly být deklarovány jako globální

2 Každé dvě sekundy (v závislosti na Clock1) je vyvolán postup "readArduino"

Procedura vrací hodnotu proměnných, které by se měly zobrazit na obrazovce. V tomto případě je hodnota stavu (0 a 1) pro pohony převedena na „ON“ a „OFF“ pro lepší vnímání.

Tyto hodnoty (Stav) se zobrazí v odpovídajících „Zkratkách“

3 Rutina readArduino v podstatě přečte stavový kanál v ThingSpeak. Musíte tedy určit adresu URL, která bude zaslána na server Thingspeak. Chcete-li to provést, musí být deklarovány a kombinovány 3 globální proměnné, aby se vytvořila adresa URL, která bude odeslána do ThingSpeak. GET by měl být odeslán na webovou komponentu s názvem "ArduFarmBotStatusCh"

4 Text přijatý z předchozího příkazu dorazí ve formátu JSon. Tento text musí být zpracován tak, aby každé pole bylo čteno a uloženo v odpovídající globální proměnné.

5 Poslední věcí, kterou musíte udělat, je zavolat proceduru „Alarm“, která bude analyzovat stav dvou senzorů půdy. Pokud je teplota příliš nízká (v našem případě 10 ° C), měla by se zobrazit zpráva. Totéž platí pro vlhkost, pokud je pod 60%.

Upozorňujeme, že jsme definovali jiný časovač (Clock2), naprogramovaný tak, aby byl spuštěn každou sekundu. Stačí pouze „přepnout“ barvu textu zprávy (z bílé na červenou). Zpráva bude blikat.

Aplikační kód si můžete stáhnout na

10 Připojení pohonů

Příkazy pro zapnutí a vypnutí čerpadla a lampy budou přijímány vzdáleně. Výstup Ardunio aktivuje relé a LED, přičemž tyto příkazy přijme. Obrázek ukazuje, jak mají být akční členy připojeny. Vezměte prosím na vědomí, že reléový výstup GND NENÍ PŘIPOJENO na výstup GNDUNO. Tímto způsobem dojde k menšímu rušení výkonu, když je relé v chodu.

11 konfigurace ovladačů kanálů (akční členy)

Všechny akce opakují postup konfigurace kanálu stavu. Pro každé zařízení je nutné vytvořit dva kanály. Pro každý kanál musíte napsat klíče ID kanálu, čtení a zápis. Budeme psát pouze v prvním poli každého kanálu. Například:
ID kanálu 375598 ==> LED červená (čerpadlo)
◦ Pole1 = 0 ==> Čerpadlo vypnuto
◦ Field1 = 1 ==> Pump ON
2. ID kanálu 375599 ==> LED zelená (lampa)
◦ Pole1 = 0 ==> Lampa vypnutá
◦ Pole1 = 1 ==> Lampa svítí

11 načítání a testování ovladačů kódu v Ardunio.

Když jsme poslali data do cloudu, „zapisovali jsme“ je do ThingSpeak. Stavový kanál „přenášel“ (nahrával) tato data. Nyní musíme „číst“ data z kanálu aktuátoru a „přijmout“ (stáhnout) tato data.

To provedete odesláním řetězce GET a tento postup se skládá ze 3 fází.
"Start cmd"

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

Délka řádku

AT + CIPSEND = 36

A samotný řetězec GET

GET / kanály / 375598 / pole / 1 / poslední

Kanály budou „čteny“ každých 10 sekund

Po odeslání GET musíme přijmout odpověď od ThingSpeak. Odpověď musí být pro každý kanál buď 0 nebo 1. Pokud existují jiné hodnoty, jednoduše je ignorujeme.

Hlavní rozdíl mezi touto a předchozí částí je pouze ve funkci readThingSpeak (String channelID)
Níže je kód, který provádí popsané akce.

// Thingspeak
String canalID1 = "999999"; // Pohon1
String canalID2 = "999999"; // Pohon2

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

// Proměnné pro použití s časovači
long readTimingSeconds = 10; // ==> Definujte čas vzorkování v sekundách pro příjem dat
dlouhý startReadTiming = 0;
long elapsedReadTime = 0;

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

int náhradní = 0;
booleovská chyba;

neplatné nastavení ()
{
  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 (); // spuštění "programových hodin"
}

prázdná smyčka ()
{
  start: // label
  chyba = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int command = readThingSpeak (canalID1);
    if (command! = 9) pump = command;
    zpoždění (5000);
    command = readThingSpeak (canalID2);
    if (příkaz! = 9) lampa = příkaz;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Znovu odeslat, pokud není přenos dokončen
  {
    Serial.println ("<<<< CHYBA >>>>");
    zpoždění (2000);
    začátek; // přejděte na štítek „start“
  }
}

/ ********* Podnikněte kroky založené na příkazech ThingSpeak *************/
void takeActions (neplatné)
{
  Serial.print ("Pump:");
  Serial.println (čerpadlo);
  Serial.print ("Lamp:");
  Serial.println (lampa);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  jinde digitalWrite (ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite (ACTUATOR2, LOW);
  jinde digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Přečtěte si příkaz Actuators from ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int pří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 ("Příkaz obdržel:");
    Serial.println (příkaz);
  }
  jinak příkaz = 9;
  příkaz pro návrat;
}

/ ********* Reset ESP ************* /
void EspHardwareReset (neplatné)
{
  Serial.println („Obnovení .......“);
  digitalWrite (HARDWARE_RESET, LOW);
  zpoždění (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  zpoždění (8000); // Tempo needário para começar a ler
  Serial.println („RESET“);
}

/ ********* Zahájení komunikace 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");
    návrat
  }
}

/ ********* poslat GET cmd na ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> délka cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      Řetězec = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// skutečný obsah začíná po prázdném řádku (který má délku 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print („MessageBody obdržel:“);
    Serial.println (messageBody);
    návrat messageBody;
  }
  jinde
  {
    EspSerial.println („AT + CIPCLOSE“); // upozornění uživatele
    Serial.println („ESP8266 CIPSEND ERROR: RESENDING“); // Znovu odeslat ...
    náhradní = náhradní + 1;
    chyba = 1;
    návrat "chyba";
  }
}

Můžete si ji stáhnout na adrese

12 odesílání příkazů do zařízení

V této fázi máme nakonfigurovaný kanál ovladače, který mění hodnotu pole 1 pro každé zařízení. Musíme ověřit, že zařízení správně zpracovává příkazy. Na konci projektu se k tomu použije aplikace pro Android, ale lze ji také provést pomocí prohlížeče.

Zapněte čerpadlo (červená LED svítí)

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

Čerpadlo vypnuto (červená LED nesvítí)

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

Zapněte lampu (zelená LED svítí)

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

Vypněte lampu (zelená LED zhasne)

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

14 Ukončení programu Android

V předchozí části byl jednoduchý program, který „přečetl“ data z kanálu a zobrazil je na obrazovce. Nyní musíme udělat program, aby „zapisoval“ příkazy v kanále akčního členu, aby tyto příkazy mohly číst řídicí jednotka a lampa s čerpadlem pracovala odpovídajícím způsobem.

Aby mohl uživatel posílat příkazy, bude mít aplikace pro každé zařízení dvě tlačítka. Pokud je zapnutá, modrá; pokud je vypnutá, červená.

Kliknutím na tlačítka v aplikaci zobrazíte výsledek v Serial Monitor.

Kód lze stáhnout na adrese

15 Konečná montáž

V této fázi existuje plně dokončená aplikace pro Android, kompletně sestavená hardwarová část, ale v kontroléru není žádný kód, který by neustále načítal data a odeslal příkazy do cloudu. Stačí kombinovat všechny fragmenty dříve napsaného kódu. Samozřejmě, kód má další možnosti ověření (například pokud ESP-01 zamrzne). Chcete-li to pravidelně provádět, před každým příkazem čtení nebo zápisu je odeslán příkaz AT.A pokud odpověď OK nepochází z modulu, je modul násilně restartován programově.

Celý kód projektu si můžete stáhnout na adrese

Na adresu získáte aktualizace programových souborů.

Pokud něco není jasné, můžete si také přečíst komentáře k odkazu na zdroj.