Üvegház vagy üvegház kezelése a világ bármely pontjáról (megvalósítási példa)

Ennek a fejlesztésnek az a célja, hogy adatokat gyűjtsön a helyi érzékelőktől, és ezeket az adatokat továbbítsa az internetre. A felhasználó megnézheti az érzékelőkből származó adatokat a világ bármely pontján, és távoli döntést hozhat bizonyos, az érzékelők mellett helyben elhelyezkedő működtető elemek aktiválásáról.

A projekt felhasználja Arduino UNO és WiFi modul ESP8266-01. Az adatokat a ThingSpeak.com webszolgáltatáson keresztül továbbítják a felhőbe, és az eszközöket az MIT AppInventor segítségével kifejlesztett android alkalmazáson keresztül aktiválják.





Az IoT projekt fő hangsúlya a ThingSpeak.com szolgáltatás lesz. A helyi UNO / ESP-01 eszköz érzékelőktől és a hajtóművek állapotáról ad adatokat, továbbítja azokat az Internetre „rögzítésre” egy adott ThingSpeak.com állapotcsatornán (ThingSpeak.com Status Channel), ugyanaz a helyi eszköz veszi az adatokat ”. egy másik adatcsatornáról, “végrehajtó eszközök csatornájáról” (ThingSpeak.com működtető csatornák) történő olvasás.



Az adatokat hőmérsékleti és relatív páratartalom érzékelő, talaj hőmérséklet és páratartalom érzékelő, valamint környezeti fényérzékelő segítségével gyűjtik. Ezeket az adatokat elküldjük a ThingSpeak szolgáltatásfelhőhöz.

Két végrehajtó eszköz lesz - ez egy víz elektromos szivattyú és egy lámpa. Be- / kikapcsolt állapotuk is a felhőbe kerül. Például az érzékelőkből származó adatok megmutathatják az üvegház vagy az üvegház jelenlegi állapotát. A felhasználó az android alkalmazás segítségével irányítja a végrehajtó eszközöket.




Minden link csak tájékoztató jellegű.






2 x LED (piros és zöld)
1 x
- $3.00
220 V-os lámpa
2 x 330 ohm ellenállás (LED-ekkel használható)
2 x 10K ohmos ellenállás (DHT22 és LDR esetén használható)
1 x 4K7 ohm ellenállás (DS18B20-nál használható)
prototípus tábla
blúz
Külső tápegység az 5 V-os reléhez



Most csatlakoztatnia kell az összes érzékelőt, az ábra szerint.



Az ideális megoldás a projekt részekben történő összeszerelése és tesztelése lenne.

A következő sorrendben:
1. Helyezze be és tesztelje az összes érzékelőt
2.Telepítse és minimálisan konfigurálja az ESP-01-et
3. Változtassa meg az ESP-01 beállítást a végső konfigurációra és tesztre
4. A ThingSpeak Status Channel konfigurálása
5. Telepítse a ThingSpeak kódot az Arduino-ra, és ellenőrizze az érzékelők állapotát a felhőn
6. Készítse el a program első verzióját androidon az érzékelők állapotüzeneteinek ellenőrzésére
7. Szerelje be a hajtóműveket
8. Konfigurálja a ThingSpeak működtető csatornákat
9. Telepítse és ellenőrizze a végrehajtó eszközök kódját az Arduino-n
10. Készítse el a program második verzióját androidon az egész eszközszerelvényhez.



A projekt néhány könyvtárat használ, amelyek benne vannak. Ellenőrizni kell azok rendelkezésre állását. E könyvtárak kezdeti konfigurációja a következő:

// DS18B20
#include 
# beletartozik a 
#define ONE_WIRE_BUS 5 // DS18B20 a D5 érintkezőn
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (világos)
#define ldrPIN 1
int fény = 0;

// A talaj páratartalma
#define soilHumPIN 0
int talajHum = 0;

Most inicializáljuk érzékelőinket és megjelenítjük őket a terminálon:

érvénytelen beállítás ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

üres hurok ()
{
  readSensors ();
  displaySensors ();
  késés (10000);
}

És végül két funkciót fogunk írni: az egyik leolvassa az érzékelők adatait, a másik pedig megjeleníti azokat a képernyőn:

/ ********* Olvasási érzékelők értéke ************* /
void readSensors (érvénytelen)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // A 0-as érzékelő Celcius-ban rögzíti a talajhőmérsékletet
  
  soilHum = térkép (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  fény = térkép (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> fény 100%

}

/ ********* Kijelző érzékelők értéke ************* /
void displaySensors (érvénytelen)
{
  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 ("könnyű (%):");
  Serial.println (könnyű);
  Serial.println ("");
}

A fotó megmutatja, hogyan jelennek meg az adatok a képernyőn.


A forráskód letölthető a szerzőtől.



A modul segítségével a "legbeszélgetés" leggyorsabb módja az AT parancs. A processzornak már van AT parancs processzora. Alapértelmezés szerint a modul gyári beállításai 115200 baud, és a beállításokban 9600 baudot kell beállítani.

Először csatlakoztatnia kell a modult, ahogy az a képen látható



( Vegye figyelembe, hogy az ESP-01 Tx csatlakozója az UNO Tx csatlakozójához csatlakozik, ugyanúgy, mint az Rx csatlakozók egymással. Ez a kapcsolat később megváltozik. ).

Ezután csatlakoztassa az UNO-t a számítógéphez, nyissa meg az IDE-t, és töltse le a példát. Ez üres kód, így nincs ütközés az ESP-01 és az UNO között. Ezt a kódot az ESP-01 csatlakoztatása előtt feltöltötték az Ardunio-ba, hogy megbizonyosodjunk arról, hogy az Ardunio a Tx és Rx csapokat semmi másra nem fogja használni.
Most meg kell nyitnia az IDE soros figyelőt, beállítania kell az átviteli sebességet 115200-ra a beállításokban, és el kell küldenie az AT parancsot az IDE soros monitorra. Az ESP-01-nek OK választ kell küldenie

Most meg kell változtatnia az adatátviteli sebességet az ESP-01 modulban. Ehhez adja meg a parancsot az IDE-ben

AT + CIOBAUD = 9600

Előfordulhat, hogy az ESP-01 visszatér a gyári beállításokhoz, akkor másik parancsot kell használnia:

AT + UART_DEF = , , , , <áramlásvezérlés>

Például 9600 baud / 8 adatbit / 1 stop bit és nincs paritás és áramlásvezérlés

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

Most változtassa meg az adatátviteli sebességet az IDE beállításokban 9600-ra és küldje el az AT parancsot, az OK válasznak meg kell érkeznie.
Ezután át kell állítania a modult STA módba, hogy csatlakozhasson a hálózat hozzáférési pontjához.

AT + CWMODE = 1

Ahhoz, hogy a modul csatlakozzon a hálózathoz, írja be a parancsot AT + CWJAP = "hálózati_név", "hálózati_neve_1"ahol NETWORK_NAME A hálózat neve, és network_name_1 - a hálózat jelszava (a jelszónak és a hálózati névnek idézőjelben kell lennie)
Ha látja a választ WIFI CSATLAKOZTATOTT WIFI IP-T kap, akkor a kapcsolat létrejön. Ellenőrizze az IP-címet a paranccsal

AT + CIFSR

.

A monitoron megjelenő cím felhasználható a jövőben. Miután konfigurálta a modult, csatlakoztathatja azt véglegesen, de ehhez meg kell változtatnia a kapcsolási áramkört, az ábra szerint.


• ESP-01 RX (sárga) -> UNO D7 tű
• ESP-01 TX (narancssárga) -> UNO D6 tű
• ESP-01 Ch-Pd (barna) -> Vcc (3,3 V)
• ESP-01 Reset (kék) -> UNO D8 tű
• ESP-01 Vcc (piros) -> 3,3 V
• ESP-01 Gnd (fekete) -> UNO GND

Vegye figyelembe, hogy a Szoftver soros könyvtár az UNO Pin D7 PIN-kódot használja mint a tx és csatlakozik az ESP-01 kimenetéhez RXmíg az UNO D6 tű mint az rxcsatlakoztatva az ESP-01-hez TX.

Írjon be egy kis kódot az ESP-01 modul helyes kapcsolatának és konfigurációjának ellenőrzéséhez

#include 
SzoftverSerial esp8266 (6.7); // Rx ==> 6. tű; TX ==> Pin7

#define speed8266 9600

érvénytelen beállítás ()
{
  esp8266.begin (speed8266);
  Serial.begin (sebesség8266);
  Serial.println ("ESP8266 Telepítési teszt - AT coomandek használata");
}

üres hurok ()
{
  míg (esp8266.a available ())
  {
    Serial.write (esp8266.read ());
  }
  míg (Serial.avable ())
  {
    esp8266.write (Serial.read ());
  }
}

Most néhány AT csapat. Nézze meg az eredményeket a soros monitorban.



* AT =====> Az ESP8266 visszatér OK
* AT + RST =====> ESP8266 újraindul, és visszatér az OK gombra
* AT + GMR =====> Az ESP8266 visszaadja az AT verziót; SDK verzió; id; rendben
* AT + CWMODE? => Az ESP8266 visszaadja a módtípust
* AT + CWLAP ===> Az ESP8266 visszatér a szoros hozzáférési pontokhoz
* AT + CIFSR ===> ESP8266 visszaküldi a tervezett IP-t

A programkód letölthető a következő webhelyről:

6 érzékelők csatlakoztatása az ESP-01-hez

Az összes érzékelő csatlakoztatása és ellenőrzése, valamint az ESP-01 modul ellenőrzése után elő kell készíteni az adatokat az internetre történő továbbításhoz.





A projekt egyik legfontosabb része a nyílt tárgyak internete platformja, amely lehetővé teszi az érzékelőkből származó adatok gyűjtését, feldolgozását és elemzését. Ehhez lépjen a fiókba, és hozzon létre egyet. Ezután létre kell hoznia egy csatornát, ahol 2 hajtómű, 5 érzékelő és egy tartalék mező lesz.
• 1. mező: 1. működtető (1. eszköz)
• 2. mező: 2. működtető (2. eszköz)
• 3. mező: Levegő hőmérséklete oC-ban (a levegő hőmérséklete Celsius-fokban)
• Filed 4: Levegő relatív páratartalma,% (relatív páratartalom%)
• 5. mező: A talaj hőmérséklete oC-ban (a talaj hőmérséklete gr. Celsius-ban)
• 6. mező: Talajnedvesség% -ban (talajnedvesség% -ban)
• 7. mező: Világosság% -ban (megvilágítás%)
• 8. mező: Tartalék

A 8. mező fenntartva van a jövőbeli bővítéshez vagy a hibakereséshez. Ebben a projektben kommunikációs hibaszámlálóként használják az Arduino / ESP-01 és a ThingSpeak.com között.

Az Állapotcsatorna létrehozása után rögzítenie kell a gombokat, ahogy az a képen látható.



Jelenleg konfigurált felhőszolgáltatásunk van, és érzékelőink helyileg gyűjtik az adatokat. Most el kell vinnie ezeket az adatokat, és el kell küldenie a felhőhöz a ThingSpeak.com webhelyen.

Annak érdekében, hogy adatokat írjon a ThingSpeak csatornára, el kell küldenie egy GET karakterláncot. Ezt három szakaszban végzik.
Küldje el a "Start cmd" parancsot

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

További húrhossz

AT + CIPSEND = 116

És végül egy GET karakterlánc, amely az adatokat a fenntartott Status Channel mezőkbe írja.

GET / frissítés? Api_key = Saját_takarékos_kulcs_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = tartalék

Felhívjuk figyelmét, hogy 16 másodpercen belül csak egyszer kell adatokat írnunk a csatornára.

A beküldött kód mindezt megteszi.

// Thingspeak
Karakterlánc státusChWriteKey = "ÍRJ HOZZA KÖNYVET ITT"; // Állapotcsatorna azonosítója: 385184

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

// DS18B20
#include 
# beletartozik a 
#define ONE_WIRE_BUS 5 // DS18B20 a D5 érintkezőn
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

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

// LDR (világos)
#define ldrPIN 1
int fény = 0;

// A talaj páratartalma
#define soilHumPIN 0
int talajHum = 0;

// Az időzítőkkel használható változók
hosszú writeTimingSeconds = 17; // ==> Adja meg a minta idejét másodpercben az adatok küldéséhez
hosszú startWriteTiming = 0;
rég elteltWriteTime = 0;

// A hajtóművekkel használható változók
logikai pumpa = 0;
logikai lámpa = 0;

int tartalék = 0;
logikai hiba;

érvénytelen beállítás ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startWriteTiming = millis (); // a "programóra" indítása
}

üres hurok ()
{
  start: // címke
  hiba = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (möödottWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (hiba == 1) // Küldje újra, ha az átvitel még nem fejeződött be
  {
    Serial.println ("<<<< HIBA >>>>");
    késés (2000);
    elindulás; // menjen a "start" címkére
  }
}

/ ********* Olvasási érzékelők értéke ************* /
void readSensors (érvénytelen)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // A 0-as érzékelő Celcius-ban rögzíti a talajhőmérsékletet
             
  fény = térkép (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> fény 100%
  soilHum = térkép (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (érvénytelen)
{

  startThingSpeakCmd ();

  // GET készítő karakterlánc
  Karakterlánc getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (szivattyú);
  getStr + = "& field2 =";
  getStr + = Húr (lámpa);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = Karakterlánc (soilTemp);
  getStr + = "& field6 =";
  getStr + = karakterlánc (soilHum);
  getStr + = "& field7 =";
  getStr + = Húr (könnyű);
  getStr + = "& field8 =";
  getStr + = String (tartalék);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* ESP visszaállítása ************* /
érvénytelen EspHardwareReset (érvénytelen)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  késés (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  késés (8000); // Tempo mustário para começar a ler
  Serial.println ("RESET");
}

/ ********* Kommunikáció indítása a ThingSpeak-kel ************* /
void startThingSpeakCmd (érvénytelen)
{
  EspSerial.flush (); // limpa o buffer antes de começ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 ("Hiba"))
  {
    Serial.println ("AT + CIPSTART hiba");
    return;
  }
}

/ ********* küldjön egy GET cmd-t a ThingSpeak ************* /
Karakterlánc sendThingSpeakGetCmd (karakterlánc getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = Húr (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> hossza cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    késleltetés (500); // tempo para processar o GET, a késleltetett megjelenítés elfoglalt nincs próximo comando

    String messageBody = "";
    míg (EspSerial.a available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// a tényleges tartalom üres sor után kezdődik (amelynek hossza 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody kapott:");
    Serial.println (messageBody);
    return messageBody;
  }
  más
  {
    EspSerial.println ("AT + CIPCLOSE"); // figyelmeztető felhasználó
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Újraküldés ...
    tartalék = tartalék + 1;
    hiba = 1;
    visszatérés "hiba";
  }
}

Az előrehaladást a soros monitoron láthatja.

A forráskód letölthető a következő webhelyről:



Először létre kell hoznia egy felhasználói felületet. A képen a fő látható és láthatatlan elemek láthatók.



Ezután blokkokat kell létrehoznia. A menüelemek megfelelnek a képernyőképeinek.

1 Állami változók, amelyeket globálisnak kell nyilvánítani

2 Két másodpercenként (az 1. órától függően) egy eljárást hívnak meg "ReadArduino"


Az eljárás visszaadja a képernyőn megjelenítendő változók értékét. Ebben az esetben a hajtóművek állapotértéke (0 és 1) a jobb észlelés érdekében „BE” és „KI” értékre konvertálódik.

Ezek az értékek (Status) megjelennek a megfelelő „Shortcuts” -ben

3 Az readArduino rutin lényegében az állapotcsatornát olvassa be a ThingSpeak alkalmazásban. Tehát meg kell határoznia az URL-t, amelyet elküld a Thingspeaknek. Ehhez három globális változót kell deklarálni és összevonni, hogy létrehozzuk az URL-t, amelyet a ThingSpeak-hez küldünk. A GET-t el kell küldeni az úgynevezett webes elemre «ArduFarmBotStatusCh»

4 Az előző parancsból kapott szöveg JSon formátumban érkezik. Ezt a szöveget úgy kell feldolgozni, hogy az egyes mezőket elolvassa és tárolja a megfelelő globális változóban.

5 Az utolsó lépés, hogy hívja fel az „Alarm” eljárást, amely két talajérzékelő állapotát elemzi. Ha a hőmérséklet túl alacsony (esetünkben 10 ° C), akkor egy üzenetet kell megjeleníteni. Ugyanez vonatkozik a nedvességre, ha 60% alatt van.

Felhívjuk figyelmét, hogy definiáltunk egy másik időzítőt (Clock2), amelyet úgy programoztunk, hogy másodpercenként futtasson. Csak az üzenet szövegének (fehérről pirosra) színének „váltására” van szükség. Az üzenet villogni kezd.

Az alkalmazás kódja letölthető a következő webhelyről:




A szivattyú és a lámpa be- és kikapcsolásának parancsai távolról érkeznek. Az Ardunio kimenete aktiválja a relét és a LED-et, ezeket a parancsokat végrehajtva. A kép azt mutatja, hogyan kell a hajtóműveket csatlakoztatni. Felhívjuk figyelmét, hogy a GND relé kimenet NEM CSATLAKOZTATVA a GND kimenetreUNO. Ilyen módon kevésbé lesz az interferencia, amikor a relé fut.




Minden művelet megismétli az Állapotcsatorna konfigurálásának eljárását. Mindegyik eszközhöz két csatornát kell létrehozni. Minden csatornához írja be a Csatorna azonosító, az Olvasás és az Írás gombot. Az egyes csatornák csak az első mezőbe írunk. Példa:
Csatorna azonosítója 375598 ==> Piros LED (szivattyú)
◦ 1. mező = 0 ==> Szivattyú KI
◦ 1. mező = 1 ==> szivattyú BE
2. Csatorna azonosítója 375599 ==> LED zöld (lámpa)
◦ 1. mező = 0 ==> A lámpa ki van kapcsolva
◦ 1. mező = 1 ==> Lámpa BE



Amikor adatokat küldtünk a felhőhöz, ezeket az adatokat „megírtuk” a ThingSpeak-hez. Status Channel, ezeket az adatokat „továbbítva” (feltöltve). Most "el kell olvasnunk" az adatokat a működtető csatornaról, ezeket "elfogadni" (letölteni).

Ehhez küldjön egy GET karakterláncot, és ez az eljárás három szakaszból áll.
"Start cmd"

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

Vonalhossz

AT + CIPSEND = 36

És maga a GET karakterlánc

GET / csatornák / 375598 / mezők / 1 / utolsó

A csatornák 10 másodpercenként „olvasódnak”

A GET elküldése után el kell fogadnunk a ThingSpeak válaszát. A válasznak 0 vagy 1 értéknek kell lennie minden csatornán. Ha vannak más értékek, akkor ezeket egyszerűen figyelmen kívül hagyjuk.

A rész és az előző közötti fő különbség csak a függvényben van readThingSpeak (String channelID)
Az alábbiakban bemutatjuk a leírt műveleteket végrehajtó kódot.

// Thingspeak
Karakterlánc canalID1 = "999999"; // Meghajtó1
Karakterlánc canalID2 = "999999"; // Actuator2

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

// Az időzítőkkel használható változók
hosszú readTimingSeconds = 10; // ==> Adja meg a mintavételi időt másodpercben az adatok fogadásához
hosszú startReadTiming = 0;
hosszú idő telt elReadTime = 0;

// Relék
#define ACTUATOR1 10 // RED LED ==> Szivattyú
#define ACTUATOR2 12 // ZÖLD LED ==> Lámpa
logikai pumpa = 0;
logikai lámpa = 0;

int tartalék = 0;
logikai hiba;

érvénytelen beállítás ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, KIMENET);
  pinMode (ACTUATOR2, KIMENET);
  pinMode (HARDWARE_RESET, OUTPUT);

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset do Modulo WiFi
  startReadTiming = millis (); // a "programóra" indítása
}

üres hurok ()
{
  start: // címke
  hiba = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int parancs = readThingSpeak (canalID1);
    if (parancs! = 9) pump = parancs;
    késleltetés (5000);
    parancs = readThingSpeak (canalID2);
    if (parancs! = 9) lámpa = parancs;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (hiba == 1) // Küldje újra, ha az átvitel még nem fejeződött be
  {
    Serial.println ("<<<< HIBA >>>>");
    késés (2000);
    elindulás; // menjen a "start" címkére
  }
}

/ ********* Tegyen intézkedéseket a ThingSpeak parancsok alapján ************* /
void takeActions (érvénytelen)
{
  Serial.print ("Pump:");
  Serial.println (pump);
  Serial.print ("Lámpa:");
  Serial.println (lámpa);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lámpa == 1) digitalWrite (ACTUATOR2, LOW);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Olvassa el az Actuators parancsot a ThingSpeak-ből ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int parancs;
  // GET készítő karakterlánc
  Karakterlánc getStr = "GET / csatornák /";
  getStr + = csatornaID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    parancs = messageDown [7] -48;
    Serial.print ("Parancs kapott:");
    Serial.println (parancs);
  }
  else parancs = 9;
  visszatérési parancs;
}

/ ********* ESP visszaállítása ************* /
érvénytelen EspHardwareReset (érvénytelen)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  késés (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  késés (8000); // Tempo mustário para começar a ler
  Serial.println ("RESET");
}

/ ********* Kommunikáció indítása a ThingSpeak-kel ************* /
void startThingSpeakCmd (érvénytelen)
{
  EspSerial.flush (); // limpa o buffer antes de começ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 ("Hiba"))
  {
    Serial.println ("AT + CIPSTART hiba");
    return;
  }
}

/ ********* küldjön egy GET cmd-t a ThingSpeak ************* /
Karakterlánc sendThingSpeakGetCmd (karakterlánc getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = Húr (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> hossza cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    késleltetés (500); // tempo para processar o GET, a késleltetett megjelenítés elfoglalt nincs próximo comando

    String messageBody = "";
    míg (EspSerial.a available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// a tényleges tartalom üres sor után kezdődik (amelynek hossza 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody kapott:");
    Serial.println (messageBody);
    return messageBody;
  }
  más
  {
    EspSerial.println ("AT + CIPCLOSE"); // figyelmeztető felhasználó
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Újraküldés ...
    tartalék = tartalék + 1;
    hiba = 1;
    visszatérés "hiba";
  }
}

Letöltheti a



Ebben a szakaszban van egy konfigurált működtető csatorna, amely minden eszköznél megváltoztatja az 1. mező értékét. Ellenőriznünk kell, hogy az eszközök megfelelően végrehajtják-e a parancsokat. A projekt végén egy android alkalmazás lesz erre a célra, de böngészőn keresztül is megtehető.

Kapcsolja be a szivattyút (piros LED világít)

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

Szivattyú ki (piros LED nem világít)

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

Kapcsolja be a lámpát (a zöld LED világít)

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

Kapcsolja ki a lámpát (a zöld LED nem világít)

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

Az előző részben volt egy egyszerű program, amely „leolvasta” az adatokat a csatornáról, és megjelenítette a képernyőn. Most azt kell tennünk, hogy a program „írja” a parancsokat a Channal működtető eszközbe, hogy ezeket a parancsokat a vezérlő le tudja olvasni, és a lámpa a szivattyúval megfelelően működjön.

Annak érdekében, hogy a felhasználó parancsokat küldhessen, az alkalmazásnak két gombja van minden eszközhöz. Ha be van kapcsolva, kék, ha kikapcsolt, piros.

Az alkalmazás gombjaira kattintva az eredmény megjelenik a soros monitorban.

A kódot itt lehet letölteni



Ebben a szakaszban van egy teljesen befejezett android alkalmazás, egy teljesen összeállított “vas” rész, de a vezérlőben nincs olyan kód, amely folyamatosan olvassa az adatokat, és parancsokat küldjön a felhőhöz. Csak össze kell kombinálnia a korábban írt kód összes töredékét. Természetesen a kódnak további ellenőrzési lehetőségei vannak (például, ha az ESP-01 lefagy). Ehhez rendszeresen, minden olvasási vagy írási parancs elõtt, egy AT parancsot kell küldeni.És ha az OK válasz nem a modulból származik, akkor a modul erőszakkal újraindított szoftver.

A teljes projektkód letölthető a következő webhelyről:

A címen frissítést kaphat a programfájlokhoz.

Elolvashatja a forrás linkjére vonatkozó megjegyzéseket is, ha valami nem világos.