Šiltnamio ar šiltnamio valdymas iš bet kurios pasaulio vietos (įgyvendinimo pavyzdys)

Arduino / Šiltnamiai ir židiniai

1 įrenginio koncepcija

Šios plėtros tikslas yra surinkti duomenis iš vietinių jutiklių, siųsti šiuos duomenis į internetą. Vartotojas galės peržiūrėti iš jutiklių gaunamus duomenis bet kurioje pasaulio vietoje ir nuotoliniu būdu priimti sprendimą dėl tam tikrų pavarų, kurios bus įrengtos vietoje šalia jutiklių, įjungimo.

Projektas naudoja Arduino UNO ir „WiFi“ modulis ESP8266-01. Duomenys į debesį bus perduoti per internetinę paslaugą „ThingSpeak.com“, o įrenginiai bus suaktyvinti per „Android“ programą, sukurtą naudojant „MIT AppInventor“.

Šiltnamio ar šiltnamio valdymas iš bet kurios pasaulio vietos (įgyvendinimo pavyzdys)

IP yra fizinių objektų („daiktų“), aprūpintų įmontuotomis technologijomis sąveikaujant tarpusavyje ar su išorine aplinka, kompiuterinio tinklo koncepcija, atsižvelgiant į tokių tinklų organizavimą kaip į reiškinį, galintį atkurti ekonominius ir socialinius procesus, pašalinantį žmogaus dalyvavimo poreikį iš dalies veiksmų ir operacijų.

Pagrindinis šio internetinio projekto akcentas bus „ThingSpeak.com“ paslauga. Vietinis UNO / ESP-01 įrenginys gauna duomenis iš jutiklių ir duomenis apie pavarų būkles, siunčia juos į internetą „įrašydamas“ per tam tikrą „ThingSpeak.com“ būklės kanalą („ThingSpeak.com Status Channel“), tas pats vietinis įrenginys gauna duomenis “. jų skaitymas iš kito duomenų kanalo - „vykdomųjų prietaisų kanalo“ („ThingSpeak.com Actuator Channels“).

Duomenys bus renkami naudojant temperatūros ir santykinės drėgmės jutiklį, dirvožemio temperatūros ir drėgmės jutiklį bei aplinkos šviesos jutiklį. Šie duomenys bus išsiųsti į „ThingSpeak“ paslaugų debesį.

Bus du vykdomieji įtaisai - tai vandens elektrinis siurblys ir lempa. Jų būsena ON / OFF taip pat bus išsiųsta į debesį. Pavyzdžiui, jutiklių duomenys gali parodyti dabartinę šiltnamio ar šiltnamio būklę. Vartotojas valdys vykdomuosius įrenginius naudodamas „Android“ programą.

2 Būtinų komponentų sąrašas

Visos nuorodos yra tik informacinio pobūdžio.

2 x šviesos diodai (raudona ir žalia)
1 x
- $3.00
220 V lempa
2 x 330 omų rezistorius (naudojamas su šviesos diodais)
2 x 10 K omų rezistorius (naudojamas kartu su DHT22 ir LDR)
1 x 4K7 varžos rezistorius (naudojamas su DS18B20)
Duonos lenta
Džemperiai
Išorinis maitinimo šaltinis 5 V nuolatinės srovės relei

3 Geležinė dalis

Dabar turite prijungti visus jutiklius, kaip parodyta schemoje.

Idealus sprendimas būtų surinkti ir išbandyti projektą dalimis.

Tokia seka:
1. Įdiekite ir patikrinkite visus jutiklius
2.Įdiekite ir būtinai sukonfigūruokite ESP-01
3. Pakeiskite ESP-01 sąranką į galutinę konfigūraciją ir patikrinkite
4. Konfigūruokite „ThingSpeak“ būsenos kanalą
5. Įdiekite „ThingSpeak“ kodą „Arduino“ ir patikrinkite jutiklių būklę debesyje
6. Sukurkite pirmąją „Android“ programos versiją, kad patikrintumėte jutiklių būsenos pranešimus
7. Sumontuokite pavaras
8. Konfigūruokite „ThingSpeak“ pavaros kanalus
9. Įdiekite ir išbandykite vykdomųjų prietaisų kodą Arduino
10. Padarykite antrąją „Android“ programos versiją visam įrenginio rinkiniui.

4 Jutiklio jungtis

Projekte naudojamos kelios bibliotekos, kurios yra įtrauktos į. Būtina patikrinti jų prieinamumą. Pradinė šių bibliotekų konfigūracija yra tokia:

// DS18B20
# įtraukite 
# įtraukti 
#define ONE_WIRE_BUS 5 // DS18B20 ant D5 kaiščio
„OneWire oneWire“ (ONE_WIRE_BUS);
„DallasTemperature DS18B20“ (ir „oneWire“);
int dirvožemio temperatūra = 0;

// DHT
# įtraukti „DHT.h“
# įtraukti 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
„int airTemp“ = 0;
int airHum = 0;

// LDR (šviesi)
#define ldrPIN 1
vidinė šviesa = 0;

// Dirvožemio drėgmė
#define soilHumPIN 0
int dirvaHum = 0;

Dabar mes inicijuojame jutiklius ir rodome juos terminale:

negaliojanti sąranka ()
{
  „Serial.begin“ (9600);
  DS18B20.begin ();
  dht.begin ();
}

tuščia kilpa ()
{
  readSensors ();
  displaySensors ();
  vėlavimas (10000);
}

Galiausiai parašysime dvi funkcijas: viena nuskaitys jutiklių rodmenis, o kita juos parodys ekrane:

/ ********* Skaityti jutikliai vertė ************* /
void readSensors (negaliojantis)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Jutiklis 0 fiksuos dirvožemio temperatūrą Celcius mieste
  
  soilHum = žemėlapis (analoginis skaitymas (soilHumPIN), 1023, 0, 0, 100);
 
  šviesa = žemėlapis („analogRead“ („ldrPIN“, 1023, 0, 0, 100)); // LDRDark: 0 ==> lengvas 100%

}

/ ********* Ekrano jutiklių vertė ************* /
void displaySensors (negaliojantis)
{
  Serial.print („airTemp (oC):“);
  Serial.println („airTemp“);
  Serial.print („airHum (%):“);
  Serial.println („airHum“);
  Serial.print („soilTemp (oC):“);
  Serial.println (soilTemp);
  Serial.print („soilHum (%):“);
  Serijos.println (dirvaHum);
  Serijos spausdinimas („šviesa (%):“);
  Serial.println (lengvas);
  Serial.println ("");
}

Nuotraukoje parodyta, kaip duomenys rodomi ekrane.

Šaltinio kodą galima atsisiųsti iš autoriaus.

4 Pagrindinė ESP8266-01 konfigūracija

Greičiausias būdas „susikalbėti“ su moduliu yra AT komanda. Procesorius jau turi AT komandų procesorių. Pagal nutylėjimą modulio gamyklos nustatymai yra 115200 baudų, nustatymuose turite nustatyti 9600 baudų.

Pirmiausia turite prijungti modulį, kaip parodyta nuotraukoje

( Atminkite, kad ESP-01 Tx gnybtas yra prijungtas prie UNO Tx gnybto, kaip ir Rx gnybtai yra sujungti vienas su kitu. Vėliau šis ryšys bus pakeistas. ).

Tada prijunkite UNO prie kompiuterio, atidarykite IDE ir atsisiųskite pateiktą pavyzdį. Tai tuščias kodas, kad tarp ESP-01 ir UNO neliktų konfliktų. Šis kodas buvo įkeltas į „Ardunio“ prieš prijungiant ESP-01 prie jo, siekiant įsitikinti, kad „Ardunio“ nenaudos „Tx“ ir „Rx“ kaiščių niekuo kitu.
Dabar reikia atidaryti IDE Serial Monitor, nustatymuose nustatyti duomenų perdavimo greitį iki 115200 ir nusiųsti AT komandą IDE Serial Monitor. ESP-01 turėtų atsiųsti atsakymą Gerai

Dabar reikia pakeisti duomenų perdavimo spartą ESP-01 modulyje. Norėdami tai padaryti, IDE duokite komandą

AT + CIOBAUD = 9600

Gali atsitikti, kad ESP-01 grįš į gamyklinius nustatymus, tada turėsite naudoti kitą komandą:

AT + UART_DEF = , , , ,

Pavyzdžiui 9600 baudų / 8 duomenų bitai / 1 stop bitai ir nėra pariteto ir srauto valdymo

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

Dabar pakeiskite duomenų perdavimo spartą IDE nustatymuose į 9600 ir atsiųskite komandą AT, turėtų ateiti atsakymas Gerai.
Tada turite perjungti modulį į STA režimą, kad jis galėtų prisijungti prie jūsų tinklo prieigos taško.

AT + CWMODE = 1

Norėdami, kad modulis prisijungtų prie tinklo, įveskite komandą AT + CWJAP = "tinklo_pavadinimas", "tinklo_pavadinimas_1"kur tinklo_pavadinimas Ar jūsų tinklo pavadinimas, ir tinklo_pavadinimas_1 - tinklo slaptažodis (slaptažodis ir tinklo pavadinimas turi būti kabutėse)
Jei matote atsakymą WIFI JUNGTIS WIFI GOT IP, tada ryšys užmegztas. Patikrinkite IP adresą naudodami komandą

AT + CIFSR

.

Adresas, kuris pasirodys monitoriuje, kurį galėsite naudoti ateityje. Sukonfigūravę modulį, galite jį visam laikui prijungti, tačiau tam reikia pakeisti jo perjungimo grandinę, kaip parodyta paveikslėlyje.

• ESP-01 RX (geltona) -> UNO kaištis D7
• ESP-01 TX (oranžinis) -> UNO PIN D6
• ESP-01 Ch-Pd (rudas) -> Vcc (3,3 V)
• „ESP-01 Reset“ (mėlyna) -> UNO PIN D8
• ESP-01 Vcc (raudona) -> 3,3 V
• ESP-01 Gnd (juoda) -> UNO GND

Atminkite, kad programinės įrangos nuosekliojoje bibliotekoje naudojamas UNO PIN D7 kaištis kaip tx ir jis jungiamas prie ESP-01 išvesties Rxo UNO kaištis D6 kaip rxprijungtas prie ESP-01 TX.

Įveskite nedidelį kodą, kad patikrintumėte teisingą ESP-01 modulio ryšį ir konfigūraciją

# įtraukti 
„SoftwareSerial“ esp8266 (6.7); // Rx ==> 6 kaištis; TX ==> Pin7

#define speed8266 9600

negaliojanti sąranka ()
{
  esp8266.begin („speed8266“);
  „Serial.begin“ (greitis8266);
  „Serial.println“ („ESP8266 sąrankos testas - naudokite AT jungiklius“);
}

tuščia kilpa ()
{
  tuo tarpu (esp8266.pasiekiama ())
  {
    Serial.write (esp8266.read ());
  }
  tuo tarpu (Serial.avable ())
  {
    esp8266.write („Serial.read ()“);
  }
}

Dabar kelios AT komandos. Peržiūrėkite rezultatus „Serial Monitor“.

* AT =====> ESP8266 grįžta gerai
* AT + RST =====> ESP8266 paleidžiamas iš naujo ir grįžta gerai
* AT + GMR =====> ESP8266 grąžina AT versiją; SDK versija; id; Gerai
* AT + CWMODE? => ESP8266 grąžina režimo tipą
* AT + CWLAP ===> ESP8266 grąžina artimus prieigos taškus
* AT + CIFSR ===> ESP8266 grąžina suplanuotą IP

Programos kodą galima atsisiųsti iš

6 jutiklių ir ESP-01 prijungimas

Po to, kai visi jutikliai yra prijungti ir patikrinti, taip pat patikrintas ESP-01 modulis, būtina paruošti duomenis siuntimui į internetą.

7 „ThingSpeak“

Viena iš svarbiausių projekto dalių yra atvira IoT platforma, kuri leis jums rinkti duomenis iš jutiklių, juos apdoroti ir analizuoti. Norėdami tai padaryti, eikite į ir sukurkite savo sąskaitą. Toliau turite sukurti kanalą, kuriame bus 2 pavaros, 5 jutikliai ir vienas atsarginis laukas.
• 1 laukas: 1 pavara (1 įtaisas)
• 2 laukas: 2 pavara (2 įtaisas)
• 3 laukas: oro temperatūra oC (oro temperatūra laipsniais Celsijaus)
• Pateikta 4: Santykinė oro drėgmė% (santykinė oro drėgmė%)
• 5 laukas: dirvožemio temperatūra oC (dirvožemio temperatūra gramais pagal Celsijų)
• 6 laukas: dirvožemio drėgnumas% (dirvožemio drėgmė%)
• 7 laukas: Šviesumas% (apšvietimas%)
• 8 laukas: Atsarginė dalis

8 laukas yra skirtas ateityje plėstis arba derinti. Šiame projekte jis naudojamas kaip komunikacijos klaidų skaitiklis tarp „Arduino“ / ESP-01 ir „ThingSpeak.com“.

Sukūrę būsenos kanalą, turite įrašyti klavišus, kaip parodyta nuotraukoje.

8 Jutiklio būsenos siuntimas į debesį

Šiuo metu turime sukonfigūruotą debesies paslaugą, o mūsų jutikliai duomenis renka vietoje. Dabar jums reikia paimti šiuos duomenis ir nusiųsti į debesį tinklalapyje ThingSpeak.com.

Norėdami įrašyti duomenis į „ThingSpeak“ kanalą, turite atsiųsti GET eilutę. Tai bus padaryta trimis etapais.
Siųsti komandą „Pradėti cmd“

AT + CIPSTART = „TCP“, „184.106.153.149“, 80

Tolesnis stygos ilgis

AT + CIPSEND = 116

Galiausiai, GET eilutė, kuri įrašys mūsų duomenis į rezervuotus būsenos kanalo laukus.

GET / atnaujinti? Api_key = Your_saved_key_here & field1 = pump and fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Atminkite, kad neturėtume rašyti duomenų į kanalą daugiau kaip 1 kartą per 16 sekundžių.

Pateiktas kodas visa tai padarys.

// Daiktavardis
Styginių statusasChWriteKey = "JŪSŲ RAŠYMO PAGRINDAS ČIA"; // Būsenos kanalo ID: 385184

# įtraukti 
„SoftwareSerial EspSerial“ (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// DS18B20
# įtraukite 
# įtraukti 
#define ONE_WIRE_BUS 5 // DS18B20 ant D5 kaiščio
„OneWire oneWire“ (ONE_WIRE_BUS);
„DallasTemperature DS18B20“ (ir „oneWire“);
int dirvožemio temperatūra = 0;

// DHT
# įtraukti „DHT.h“
# įtraukti 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
„int airTemp“ = 0;
int airHum = 0;

// LDR (šviesi)
#define ldrPIN 1
vidinė šviesa = 0;

// Dirvožemio drėgmė
#define soilHumPIN 0
int dirvaHum = 0;

// Kintamieji, kurie bus naudojami su laikmačiais
long writeTimingSeconds = 17; // ==> Apibrėžkite mėginio laiką sekundėmis duomenims siųsti
ilgas startWriteTiming = 0;
senpsedWriteTime = 0;

// Kintamieji, kurie bus naudojami su pavaromis
boolean pump = 0;
boolean lempa = 0;

int atsarga = 0;
loginė klaida;

negaliojanti sąranka ()
{
  „Serial.begin“ (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  „digitalWrite“ (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  „EspSerial.begin“ (9600); // „Comunicacao com“ „Modulo WiFi“
  „EspHardwareReset“ (); // Atkurti „Modulo WiFi“
  startWriteTiming = millis (); // „programos laikrodžio“ paleidimas
}

tuščia kilpa ()
{
  pradžia: // etiketė
  klaida = 0;
  
  möödęsWriteTime = millis () - startWriteTiming;
  
  if (möödęsWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (klaida == 1) // Siųsti dar kartą, jei perdavimas nėra baigtas
  {
    „Serial.println“ („<<<< KLAIDA >>>>“);
    vėlavimas (2000 m.);
    pradėti pradėti; // eikite į etiketę „pradėti“
  }
}

/ ********* Skaityti jutikliai vertė ************* /
void readSensors (negaliojantis)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Jutiklis 0 fiksuos dirvožemio temperatūrą Celcius mieste
             
  šviesa = žemėlapis („analogRead“ („ldrPIN“, 1023, 0, 0, 100)); // LDRDark: 0 ==> lengvas 100%
  soilHum = žemėlapis (analoginis skaitymas (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* „Conexao com TCP com“ „Spepepeak“ ******* /
void writeThingSpeak (negalioja)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  Styginė getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = Styga (pompa);
  getStr + = "& field2 =";
  getStr + = Styga (lempa);
  getStr + = "& field3 =";
  getStr + = Styga („airTemp“);
  getStr + = "& field4 =";
  getStr + = Styga („airHum“);
  getStr + = "& field5 =";
  getStr + = Styga (soilTemp);
  getStr + = "& field6 =";
  getStr + = Styga (dirvaHum);
  getStr + = "& field7 =";
  getStr + = Styga (šviesi);
  getStr + = "& field8 =";
  getStr + = Styga (atsarginė);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Atstatyti ESP ************* /
negaliojantis „EspHardwareReset“ (negalioja)
{
  „Serial.println“ („Atstatyti .......“);
  „digitalWrite“ (HARDWARE_RESET, LOW);
  vėlavimas (500);
  „digitalWrite“ (HARDWARE_RESET, HIGH);
  vėlavimas (8000); // Tempo mustário para começar a ler
  „Serial.println“ („RESET“);
}

/ ********* Pradėkite ryšį su „ThingSpeak“ ************** /
negaliojantis startThingSpeakCmd (negalioja)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Styginių 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“ („Klaida“))
  {
    „Serial.println“ („AT + CIPSTART klaida“);
    grįžti
  }
}

/ ********* siųsti „GET cmd“ į „ThingSpeak“ ************* /
Styginė „sendThingSpeakGetCmd“ (eilutė „getStr“)
{
  Stygos cmd = "AT + CIPSEND =";
  cmd + = stygos (getStr.length ());
  „EspSerial.println“ (cmd);
  Serial.print ("enviado ==> length cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    „Serial.print“ („enviado ==> getStr:“);
    Serial.println (getStr);
    uždelsimas (500); // tempo para processar o GET, pusė uždelsimo apresenta užimta nėra próximo comando

    Styginė žinutėBody = "";
    tuo tarpu (EspSerial.avable ())
    {
      Styginių eilutė = EspSerial.readStringUntil ('\ n');
      if (eilutės ilgis () == 1)
      {// tikrasis turinys prasideda po tuščios eilutės (kurios ilgis 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    „Serial.print“ („MessageBody kapott:“);
    Serial.println (messageBody);
    return messageBody;
  }
  dar
  {
    „EspSerial.println“ („AT + CIPCLOSE“); // perspėjimo vartotojas
    „Serial.println“ („ESP8266 CIPSEND ERROR: RESENDING“); // Siųsti dar kartą ...
    atsarginis = atsarginis + 1;
    klaida = 1;
    grąžinti „klaidą“;
  }
}

Galite pamatyti pažangą serijiniame monitoriuje.

Šaltinio kodą galima atsisiųsti iš

9 „Android“ programa - pirma dalis

Pirmiausia turite sukurti vartotojo sąsają. Nuotraukoje parodyti pagrindiniai matomi ir nematomi elementai.

Po to turite sukurti blokus. Meniu elementai atitinka ekrano kopijų numerius.

1 Būsenos kintamieji, kurie turėtų būti paskelbti visuotiniais

2 Kas dvi sekundes (atsižvelgiant į 1 laikrodį) iškviečiama procedūra „skaitytiArduino“

Procedūra grąžina kintamųjų, kurie turėtų būti rodomi ekrane, vertę. Tokiu atveju pavarų būsenos reikšmė (0 ir 1) paverčiama į „ON“ ir „OFF“, kad būtų geriau suvokiama.

Šios vertės (būsena) bus rodomos atitinkamuose „Shortcuts“

3 „ReadArduino“ programa iš esmės skaitys būsenos kanalą „ThingSpeak“. Taigi, jūs turite nustatyti URL, kuris bus išsiųstas į „Thingspeak“. Norėdami tai padaryti, reikia deklaruoti ir sujungti 3 globalius kintamuosius, kad būtų sukurtas URL, kuris bus išsiųstas „ThingSpeak“. GET turėtų būti nusiųstas į žiniatinklio komponentą, vadinamą „ArduFarmBotStatusCh“

4 Iš ankstesnės komandos gautas tekstas bus pateiktas JSon formatu. Šį tekstą reikia apdoroti, kad kiekvienas laukas būtų perskaitytas ir išsaugotas atitinkamame globaliame kintamajame.

5 Paskutinis dalykas, kurį reikia padaryti, yra iškviesti „Signalizacijos“ procedūrą, kuri išanalizuos dviejų dirvožemio jutiklių būklę. Jei temperatūra yra per žema (mūsų atveju 10oC), turėtų būti rodomas pranešimas. Tas pats drėgmės atveju, jei ji yra mažesnė nei 60%.

Atminkite, kad mes apibrėžėme kitą laikmatį („Clock2“), užprogramuotą taip, kad jis veiktų kas sekundę. Reikia tik „perjungti“ pranešimo teksto spalvą (nuo baltos iki raudonos). Žinutė mirksės.

Programos kodą galima atsisiųsti iš

10 pavarų jungimas

Siurblio ir lemputės įjungimo ir išjungimo komandos bus priimamos nuotoliniu būdu. Ardunio išėjimas suaktyvins relę ir šviesos diodą, atlikdamas šias komandas. Nuotraukoje parodyta, kaip reikia sujungti pavaras. Atkreipkite dėmesį, kad GND relės išėjimas NEJUNGTAS į GND išėjimąUNO. Tokiu būdu relė veikia mažiau galios trukdžių.

11 kanalo pavarų konfigūracija (pavaros kanalai)

Visi veiksmai pakartoja Būsenos kanalo konfigūravimo procedūrą. Kiekvienam įrenginiui būtina sukurti du kanalus. Kiekvienam kanalui užrašykite kanalo ID, skaitymo ir rašymo klavišus. Parašysime tik pirmame kiekvieno kanalo lauke. Pavyzdžiui:
Kanalo ID 375598 ==> Raudonas šviesos diodas (siurblys)
◦1 laukas = 0 ==> Siurblys išjungtas
◦1 laukas = 1 ==> Siurblys įjungtas
2. Kanalo ID 375599 ==> Žalia LED (lempa)
◦1 laukas = 0 ==> Lemputė išjungta
◦1 laukas = 1 ==> Lempa įjungta

11 įkrovimo ir bandymo kodų pavarų Ardunio mieste.

Siuntę duomenis į debesį, mes „įrašėme“ šiuos duomenis į „ThingSpeak“. Būsenos kanalas, „perduodamas“ (įkeldamas) šiuos duomenis. Dabar mes turime „perskaityti“ duomenis iš vykdymo kanalo, „priimti“ (atsisiųsti) šiuos duomenis.

Norėdami tai padaryti, atsiųskite GET eilutę ir šią procedūrą sudaro 3 etapai.
„Pradėti cmd“

AT + CIPSTART = „TCP“, „184.106.153.149“, 80

Linijos ilgis

AT + CIPSEND = 36

Ir pati GET eilutė

GET / kanalai / 375598 / laukai / 1 / paskutinis

Kanalai bus „skaitomi“ kas 10 sekundžių

Išsiuntę GET, turime priimti „ThingSpeak“ atsakymą. Kiekvieno kanalo atsakymas turi būti 0 arba 1. Jei yra kokių nors kitų vertybių, mes tiesiog jų nepaisome.

Pagrindinis šios ir ankstesnės dalies skirtumas yra tik funkcijoje „readThingSpeak“ (eilutės kanalo ID)
Žemiau yra kodas, kuris atlieka aprašytus veiksmus.

// Daiktavardis
Styginių kanalasID1 = "999999"; // pavara1
Styginių kanalasID2 = "999999"; // Pavara2

# įtraukti 
„SoftwareSerial EspSerial“ (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// Kintamieji, kurie bus naudojami su laikmačiais
ilgai readTimingSeconds = 10; // ==> Apibrėžkite mėginio laiką sekundėmis, kad gautumėte duomenis
ilgas startReadTiming = 0;
ilgai praėjęsReadTime = 0;

// Relės
#define ACTUATOR1 10 // RED LED ==> Siurblys
#define ACTUATOR2 12 // ŽALIAS LED ==> Lempa
boolean pump = 0;
boolean lempa = 0;

int atsarga = 0;
loginė klaida;

negaliojanti sąranka ()
{
  „Serial.begin“ (9600);
  
  pinMode („ACTUATOR1“, „OUTPUT“);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

  „digitalWrite“ (ACTUATOR1, HIGH); // O būdasulo relé é ativo em LOW
  „digitalWrite“ (ACTUATOR2, HIGH); // O būdasulo relé é ativo em LOW
  „digitalWrite“ (HARDWARE_RESET, HIGH);

  „EspSerial.begin“ (9600); // „Comunicacao com“ „Modulo WiFi“
  „EspHardwareReset“ (); // Atkurti „Modulo WiFi“
  startReadTiming = millis (); // „programos laikrodžio“ paleidimas
}

tuščia kilpa ()
{
  pradžia: // etiketė
  klaida = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int komanda = readThingSpeak („canalID1“);
    if (komanda! = 9) pump = komanda;
    vėlavimas (5000);
    komanda = readThingSpeak („canalID2“);
    if (komanda! = 9) lempa = komanda;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (klaida == 1) // Siųsti dar kartą, jei perdavimas nėra baigtas
  {
    „Serial.println“ („<<<< KLAIDA >>>>“);
    vėlavimas (2000 m.);
    pradėti pradėti; // eikite į etiketę „pradėti“
  }
}

/ ********* Atlikite veiksmus, pagrįstus „ThingSpeak“ komandomis ************* /
negaliojantys veiksmai (negalioja)
{
  Serial.print („Pump:“);
  Serial.println (pompa);
  Serial.print („Lempa:“);
  Serial.println (lempa);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lempa == 1) digitalWrite (ACTUATOR2, LOW);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Skaitykite paleidiklių komandą iš „ThingSpeak“ ************* /
int readThingSpeak (eilutės kanalo ID)
{
  startThingSpeakCmd ();
  int komanda;
  // preparacao da string GET
  Eilutė getStr = "GET / kanalai /";
  getStr + = kanaloID;
  getStr + = "/ laukai / 1 / paskutinis";
  getStr + = "\ r \ n";

  Eilutė messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    komanda = messageDown [7] -48;
    „Serial.print“ („Komanda gauta:“);
    Serial.println (komanda);
  }
  kita komanda = 9;
  grįžimo komanda;
}

/ ********* Atstatyti ESP ************* /
negaliojantis „EspHardwareReset“ (negalioja)
{
  „Serial.println“ („Atstatyti .......“);
  „digitalWrite“ (HARDWARE_RESET, LOW);
  vėlavimas (500);
  „digitalWrite“ (HARDWARE_RESET, HIGH);
  vėlavimas (8000); // Tempo mustário para começar a ler
  „Serial.println“ („RESET“);
}

/ ********* Pradėkite ryšį su „ThingSpeak“ ************** /
negaliojantis startThingSpeakCmd (negalioja)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Styginių 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“ („Klaida“))
  {
    „Serial.println“ („AT + CIPSTART klaida“);
    grįžti
  }
}

/ ********* siųsti „GET cmd“ į „ThingSpeak“ ************* /
Styginė „sendThingSpeakGetCmd“ (eilutė „getStr“)
{
  Stygos cmd = "AT + CIPSEND =";
  cmd + = stygos (getStr.length ());
  „EspSerial.println“ (cmd);
  Serial.print ("enviado ==> length cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    „Serial.print“ („enviado ==> getStr:“);
    Serial.println (getStr);
    uždelsimas (500); // tempo para processar o GET, pusė uždelsimo apresenta užimta nėra próximo comando

    Styginė žinutėBody = "";
    tuo tarpu (EspSerial.avable ())
    {
      Styginių eilutė = EspSerial.readStringUntil ('\ n');
      if (eilutės ilgis () == 1)
      {// tikrasis turinys prasideda po tuščios eilutės (kurios ilgis 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    „Serial.print“ („MessageBody kapott:“);
    Serial.println (messageBody);
    return messageBody;
  }
  dar
  {
    „EspSerial.println“ („AT + CIPCLOSE“); // perspėjimo vartotojas
    „Serial.println“ („ESP8266 CIPSEND ERROR: RESENDING“); // Siųsti dar kartą ...
    atsarginis = atsarginis + 1;
    klaida = 1;
    grąžinti „klaidą“;
  }
}

Galite atsisiųsti iš

12 komandų siuntimo į įrenginius

Šiame etape turime sukonfigūruotą pavaros kanalą, keičiantį kiekvieno lauko 1 lauko vertę. Turime patikrinti, ar įrenginiai tinkamai vykdo komandas. Projekto pabaigoje tam bus naudojama „Android“ programa, tačiau ją taip pat galima atlikti naudojant naršyklę.

Įjunkite siurblį (šviečia raudonas šviesos diodas)

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

Siurblys išjungtas (nedega raudonas šviesos diodas)

https://api.thingspeak.com/update?api_key=Išsaugota „Channel_key_1“ ir „field1 = 0“

Įjunkite lempą (šviečia žalia lemputė)

https://api.thingspeak.com/update?api_key=Išsaugota „Channel_key_2“ & field1 = 1

Išjunkite lempą (žalias šviesos diodas nedega)

https://api.thingspeak.com/update?api_key=Išsaugota „Channel_key_2“ ir „field1 = 0“

14 „Android“ programos pabaiga

Ankstesnėje dalyje buvo paprasta programa, kuri „skaitė“ duomenis iš kanalo ir rodė juos ekrane. Dabar turime priversti programą „parašyti“ komandas „Actuator Channal“, kad valdiklis galėtų nuskaityti šias komandas ir atitinkamai veiktų lemputė su siurbliu.

Kad vartotojas galėtų siųsti komandas, programa turės du mygtukus kiekvienam įrenginiui. Jei įjungtas, mėlynas, jei išjungtas, raudonas.

Spustelėdami programos mygtukus, rezultatą galite pamatyti serijos monitoriuje.

Kodą galima atsisiųsti iš

15 Galutinis susirinkimas

Šiame etape yra visiškai užpildyta „Android“ programa, visiškai sukomplektuota „geležinė“ dalis, tačiau valdiklyje nėra kodo, kuris nuolat skaitytų duomenis ir siųstų komandas į debesį. Jums tereikia sujungti visus anksčiau parašyto kodo fragmentus.Žinoma, kode yra papildomų tikrinimo parinkčių (pvz., Jei ESP-01 užšąla). Tam periodiškai prieš kiekvieną skaitymo ar rašymo komandą periodiškai siunčiama AT komanda.Ir jei atsakymas Gerai nebuvo iš modulio, tada modulis yra priverstinai perkraunama programinė įranga.

Visą projekto kodą galite atsisiųsti iš

Adresu galite gauti programos failų atnaujinimus.

Taip pat galite perskaityti komentarus apie nuorodą į šaltinį, jei kažkas neaišku.