Siltumnīcas vai siltumnīcas apsaimniekošana no jebkuras vietas pasaulē (ieviešanas piemērs)

Arduino / Siltumnīcas un siltumnīcas

1 Ierīces koncepcija

Šīs izstrādes mērķis ir apkopot datus no vietējiem sensoriem, nosūtīt šos datus uz internetu. Lietotājs varēs skatīt datus, kas nāk no sensoriem, jebkur pasaulē un attālināti pieņemt lēmumu par noteiktu pievadu aktivizēšanu, kas atradīsies lokāli blakus sensoriem.

Projekts izmanto Arduino UNO un WiFi modulis ESP8266-01. Dati tiks pārsūtīti uz mākoni, izmantojot tīmekļa pakalpojumu ThingSpeak.com, un ierīces tiks aktivizētas, izmantojot android lietojumprogrammu, kas izstrādāta, izmantojot MIT AppInventor.

Siltumnīcas vai siltumnīcas apsaimniekošana no jebkuras vietas pasaulē (ieviešanas piemērs)

IoT ir fizisku priekšmetu (“lietu”) datortīkla koncepcija, kas aprīkots ar iebūvētām tehnoloģijām, lai mijiedarbotos savā starpā vai ar ārējo vidi, šādu tīklu organizēšanu uzskatot par fenomenu, kas var atjaunot ekonomiskos un sociālos procesus, novēršot nepieciešamību pēc cilvēku līdzdalības daļu darbību un operāciju.

Šī IoT projekta galvenā uzmanība tiks pievērsta pakalpojumam ThingSpeak.com. Vietējā UNO / ESP-01 ierīce saņem datus no sensoriem un datus par pievadu stāvokli, nosūta tos uz interneta “ierakstīšanu” caur īpašu ThingSpeak.com statusa kanālu (ThingSpeak.com Status Channel), tā pati vietējā ierīce saņem datus, " to nolasīšana no cita datu kanāla - “izpildierīču kanāls” (ThingSpeak.com izpildmehānisma kanāli).

Dati tiks vākti, izmantojot temperatūras un relatīvā mitruma sensoru, augsnes temperatūras un mitruma sensoru un apkārtējās gaismas sensoru. Šie dati tiks nosūtīti pakalpojuma mākonī ThingSpeak.

Būs divas izpildierīces - tas ir ūdens elektriskais sūknis un lampa. Viņu statuss ON / OFF tiks nosūtīts arī uz mākoni. Piemēram, sensoru dati var parādīt siltumnīcas vai siltumnīcas pašreizējo stāvokli. Lietotājs kontrolēs izpildvaras ierīces, izmantojot android lietojumprogrammu.

2 Nepieciešamo komponentu saraksts

Visas saites ir paredzētas tikai informatīviem nolūkiem.

2 x gaismas diodes (sarkanā un zaļā)
1 x
- $3.00
220V lampa
2 x 330 omi rezistors (izmantojams ar gaismas diodēm)
2 x 10K omu rezistors (izmantojams ar DHT22 un LDR)
1 x 4K7 omu rezistors (izmantojams kopā ar DS18B20)
Maizes dēlis
Džemperi
Ārējā barošanas avota relejs 5V DC

3 Dzelzs daļa

Tagad jums jāpievieno visi sensori, kā parādīts diagrammā.

Ideāls risinājums būtu projekta salikšana un pārbaude pa daļām.

Šādā secībā:
1. Uzstādiet un pārbaudiet visus sensorus
2.Instalējiet un minimāli konfigurējiet ESP-01
3. Mainiet ESP-01 iestatījumu uz galīgo konfigurāciju un pārbaudi
4. Konfigurējiet ThingSpeak Status Channel
5. Instalējiet ThingSpeak kodu Arduino un pārbaudiet sensoru statusu mākonī
6. Izstrādājiet pirmo programmas versiju android, lai pārbaudītu sensoru statusa ziņojumus
7. Uzstādiet izpildmehānismus
8. Konfigurējiet ThingSpeak Actuators kanālus
9. Instalējiet un pārbaudiet izpildvaras ierīču kodu Arduino
10. Izveidojiet otro programmas versiju android visā ierīces komplektācijā.

4 Sensora savienojums

Projektā tiek izmantotas dažas bibliotēkas, kas ir iekļautas programmā. Ir jāpārbauda to pieejamība. Sākotnējā šo bibliotēku konfigurācija ir šāda:

// DS18B20
# iekļaut 
# iekļaut 
#definējiet ONE_WIRE_BUS 5 // DS18B20 uz D5 kontakta
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

// DHT
# iekļaut "DHT.h"
# iekļaut 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (gaišs)
#definēt ldrPIN 1
int gaisma = 0;

// Augsnes mitrums
#definēt augsniHumPIN 0
int augsneHum = 0;

Tagad mēs inicializējam savus sensorus un parādām tos terminālī:

iestatīšana nav spēkā ()
{
  Sērijas.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

tukšs cilpa ()
{
  readSensors ();
  displaySensors ();
  kavēšanās (10000);
}

Visbeidzot, mēs uzrakstīsim divas funkcijas: viena nolasa sensoru rādījumus, bet otra tos parādīs ekrānā:

/ ********* Lasīt sensorus vērtība ************* /
void readSensors (spēkā neesošs)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Sensors 0 uztver augsnes tempu pēc Celcius
  
  soilHum = karte (analogRead (soilHumPIN), 1023, 0, 0, 100);
 
  gaisma = karte (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> gaisma 100%

}

/ ********* Displeja sensoru vērtība ************* /
void displaySensors (spēkā neesošs)
{
  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 ("gaišs (%):");
  Serial.println (light);
  Serial.println ("");
}

Fotoattēlā redzams, kā dati tiek parādīti ekrānā.

Avota kodu var lejupielādēt no autora.

4 ESP8266-01 pamata konfigurācija

Ātrākais veids, kā "sarunāties" ar moduli, ir AT komanda. Procesoram jau ir AT komandu procesors. Pēc noklusējuma moduļa rūpnīcas iestatījumi ir 115200 baud, iestatījumos jums jāiestata 9600 baud.

Pirmkārt, jums jāpieslēdz modulis, kā parādīts fotoattēlā

( Ņemiet vērā, ka ESP-01 Tx spaile ir savienota ar UNO Tx spaili, tāpat kā Rx spailes ir savienotas viena ar otru. Šis savienojums tiks mainīts vēlāk. ).

Pēc tam pievienojiet UNO datoram, atveriet IDE un lejupielādējiet piemēru, kas atrodas. Šis ir tukšs kods, lai starp ESP-01 un ANO nebūtu pretrunu. Šis kods tika augšupielādēts Ardunio pirms ESP-01 pievienošanas tam, lai pārliecinātos, ka Ardunio neizmanto Tx un Rx tapas kaut kam citam.
Tagad jums ir jāatver IDE seriālais monitors, iestatījumos iestatiet pārsūtīšanas ātrumu uz 115200 un nosūtiet AT komandu uz IDE seriālo monitoru. ESP-01 jānosūta atbilde Labi

Tagad jums jāmaina datu pārraides ātrums modulī ESP-01. Lai to izdarītu, IDE dod komandu

AT + CIOBAUD = 9600

Var gadīties, ka ESP-01 atgriežas pie rūpnīcas iestatījumiem, tad jums būs jāizmanto cita komanda:

AT + UART_DEF = , , , ,

Piemēram 9600 baud / 8 datu biti / 1 pieturas biti un nav paritātes un plūsmas kontroles

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

Tagad mainiet datu pārsūtīšanas ātrumu IDE iestatījumos uz 9600 un nosūtiet komandu AT, atbildei OK vajadzētu parādīties.
Pēc tam modulis jāpārslēdz uz STA režīmu, lai tas varētu izveidot savienojumu ar jūsu tīkla piekļuves punktu.

AT + CWMODE = 1

Lai modulis izveidotu savienojumu ar tīklu, ievadiet komandu AT + CWJAP = "tīkla_ nosaukums", "tīkla_ nosaukums_1"kur tīkla_vārds Ir jūsu tīkla nosaukums, un tīkla_vārds_1 - tīkla parole (parolei un tīkla nosaukumam jābūt pēdiņās)
Ja redzat atbildi WIFI PIEVIENOTS WIFI GOT IP, tad savienojums tiek izveidots. Pārbaudiet IP adresi ar komandu

AT + CIFSR

.

Adrese, kas parādās monitorā, kuru varat izmantot nākotnē. Kad modulis ir konfigurēts, jūs to varat pastāvīgi savienot, taču tas ir jāmaina tā komutācijas ķēdē, kā parādīts attēlā.

• ESP-01 RX (dzeltens) -> UNO tapa D7
• ESP-01 TX (oranžs) -> UNO tapa D6
• ESP-01 Ch-Pd (brūns) -> Vcc (3,3 V)
• ESP-01 atiestatīšana (zils) -> UNO tapa D8
• ESP-01 Vcc (sarkans) -> 3,3 V
• ESP-01 Gnd (melns) -> UNO GND

Ņemiet vērā, ka programmatūras seriālā bibliotēka izmanto UNO PIN D7 tapu kā tx un tas ir savienots ar ESP-01 izvadi Rxsavukārt UNO Pin D6 kā rxsavienots ar ESP-01 TX.

Ievadiet nelielu kodu, lai pārbaudītu pareizu ESP-01 moduļa savienojumu un konfigurāciju

# iekļaut 
SoftwareSerial esp8266 (6.7); // Rx ==> 6. piespraude; TX ==> Pin7

#definēt ātrumu8266 9600

iestatīšana nav spēkā ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 iestatīšanas pārbaude - izmantojiet AT koomandas");
}

tukšs cilpa ()
{
  kamēr (esp8266.pieejams ())
  {
    Serial.write (esp8266.read ());
  }
  savukārt (Serial.avable ())
  {
    esp8266.write (Serial.read ());
  }
}

Tagad dažas AT komandas. Rezultātus skatiet seriālajā monitorā.

* AT =====> ESP8266 atgriežas labi
* AT + RST =====> ESP8266 restartējas un atgriežas OK
* AT + GMR =====> ESP8266 atgriež AT versiju; SDK versija; id; Labi
* AT + CWMODE? => ESP8266 atgriež režīma veidu
* AT + CWLAP ===> ESP8266 atgriež tuvu piekļuves punktus
* AT + CIFSR ===> ESP8266 atgriež projektēto IP

Programmas kodu var lejupielādēt vietnē

6 sensoru un ESP-01 savienojums

Pēc tam, kad visi sensori ir savienoti un pārbaudīti, kā arī ir pārbaudīts modulis ESP-01, ir jāsagatavo dati nosūtīšanai uz internetu.

7 ThingSpeak

Viena no vissvarīgākajām projekta daļām ir atvērtā IoT platforma, kas ļaus jums savākt datus no sensoriem, tos apstrādāt un analizēt. Lai to izdarītu, dodieties uz un izveidojiet savu kontu. Tālāk jums jāizveido kanāls, kurā būs 2 pievadi, 5 sensori un viens rezerves lauks.
• 1. lauks: 1. izpildmehānisms (1. ierīce)
• 2. lauks: 2. izpildmehānisms (2. ierīce)
• 3. lauks: gaisa temperatūra oC (gaisa temperatūra grādos pēc Celsija)
• Iesniegts 4: Gaisa relatīvais mitrums% (relatīvais mitrums%)
• 5. lauks: augsnes temperatūra oC (augsnes temperatūra gr. Pēc Celsija)
• 6. lauks: augsnes mitrums% (augsnes mitrums%)
• 7. lauks: spilgtums% (apgaismojums%)
• 8. lauks: rezerves

8. lauks ir paredzēts paplašināšanai nākotnē vai atkļūdošanai. Šajā projektā tas tiek izmantots kā komunikācijas kļūdu skaitītājs starp Arduino / ESP-01 un ThingSpeak.com.

Kad esat izveidojis statusa kanālu, jums ir jāreģistrē taustiņi, kā parādīts fotoattēlā.

8 Sensora statusa nosūtīšana mākonim

Pašlaik mums ir konfigurēts mākoņa pakalpojums, un mūsu sensori datus vāc lokāli. Tagad jums ir jāņem šie dati un jānosūta uz mākoni vietnē ThingSpeak.com.

Lai ierakstītu datus ThingSpeak kanālā, jums jānosūta GET virkne. Tas tiks veikts trīs posmos.
Nosūtīt komandu "Start cmd"

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

Turpmāks stīgas garums

AT + CIPSEND = 116

Visbeidzot, GET virkne, kas ierakstīs mūsu datus rezervētajos statusa kanāla laukos.

GET / atjaunināt? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = soilTemp & field6 = soilHum & field7 = light & field8 = spare

Lūdzu, ņemiet vērā, ka mums nevajadzētu rakstīt datus kanālam vairāk kā 1 reizi 16 sekundēs.

Iesniegtais kods to visu darīs.

// Lietas runa
Stīgas statussChWriteKey = "JŪSU RAKSTĪT ATSLĒGU ŠEIT"; // Status Channel id: 385184

# iekļaut 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// DS18B20
# iekļaut 
# iekļaut 
#definējiet ONE_WIRE_BUS 5 // DS18B20 uz D5 kontakta
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int soilTemp = 0;

// DHT
# iekļaut "DHT.h"
# iekļaut 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (gaišs)
#definēt ldrPIN 1
int gaisma = 0;

// Augsnes mitrums
#definēt augsniHumPIN 0
int augsneHum = 0;

// Mainīgie, kas izmantojami ar taimeriem
ilgi writeTimingSeconds = 17; // ==> Definējiet parauga laiku sekundēs, lai nosūtītu datus
ilgi startWriteTiming = 0;
ilgi pagājisWriteTime = 0;

// Mainīgie elementi, kas izmantojami ar izpildmehānismiem
Būla pumpis = 0;
Būla lampa = 0;

int rezerves = 0;
Būla kļūda;

iestatīšana nav spēkā ()
{
  Sērijas.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Atiestatīt Modulo WiFi
  startWriteTiming = millis (); // "programmas pulksteņa" palaišana
}

tukšs cilpa ()
{
  sākums: // etiķete
  kļūda = 0;
  
  pagājušaisWriteTime = millis () - startWriteTiming;
  
  ja (pagājušaisWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (kļūda == 1) // Nosūtīt atkārtoti, ja pārsūtīšana nav pabeigta
  {
    Serial.println ("<<<< KĻŪDA >>>>");
    kavēšanās (2000);
    goto sākums; // dodieties uz iezīmi "sākums"
  }
}

/ ********* Lasīt sensorus vērtība ************* /
void readSensors (spēkā neesošs)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soilTemp = DS18B20.getTempCByIndex (0); // Sensors 0 uztver augsnes tempu pēc Celcius
             
  gaisma = karte (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> gaisma 100%
  soilHum = karte (analogRead (soilHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (spēkā neesošs)
{

  startThingSpeakCmd ();

  // preparacao da string GET
  Virkne getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = stīgas (pumpis);
  getStr + = "& field2 =";
  getStr + = stīga (lampa);
  getStr + = "& field3 =";
  getStr + = virkne (airTemp);
  getStr + = "& field4 =";
  getStr + = stīga (airHum);
  getStr + = "& field5 =";
  getStr + = virkne (soilTemp);
  getStr + = "& field6 =";
  getStr + = stīgas (soilHum);
  getStr + = "& field7 =";
  getStr + = stīga (viegla);
  getStr + = "& field8 =";
  getStr + = stīga (rezerves);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Reset ESP ************* /
spēkā neesošs EspHardwareReset (spēkā neesošs)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  kavēšanās (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  kavēšanās (8000); // Tempo mustário para começar a ler
  Serial.println ("RESET");
}

/ ********* Sāciet saziņu ar ThingSpeak ************** /
void startThingSpeakCmd (spēkā neesošs)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Virkne 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 ("Error"))
  {
    Serial.println ("AT + CIPSTART kļūda");
    atgriezties
  }
}

/ ********* nosūtiet GET cmd uz ThingSpeak ************* /
Virkne sendThingSpeakGetCmd (virkne getStr)
{
  Stīgas cmd = "AT + CIPSEND =";
  cmd + = stīga (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);
    kavēšanās (500); // tempo para processar o GET, sem este delay apresenta aizņemts bez próximo comando

    Virkne messageBody = "";
    savukārt (EspSerial.avable ())
    {
      Virknes līnija = EspSerial.readStringUntil ('\ n');
      if (līnijas garums () == 1)
      {// faktiskais saturs sākas pēc tukšas rindas (kuras garums ir 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody saņemts:");
    Serial.println (messageBody);
    return messageBody;
  }
  cits
  {
    EspSerial.println ("AT + CIPCLOSE"); // brīdinājuma lietotājs
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Nosūtīt atkārtoti ...
    rezerves = rezerves + 1;
    kļūda = 1;
    atgriezt "kļūdu";
  }
}

Seriālajā monitorā varat redzēt progresu.

Avota kodu var lejupielādēt vietnē

9 android lietotne - pirmā daļa

Vispirms jāizveido lietotāja interfeiss. Attēlā redzami galvenie redzamie un neredzamie elementi.

Pēc tam jums jāizveido bloki. Izvēlnes vienumi atbilst ekrānuzņēmumu numuriem.

1 Stāvokļa mainīgie, kas jādeklarē kā globāli

2 Ik pēc divām sekundēm (atkarībā no 1. pulksteņa) tiek izsaukta procedūra "lasītArduino"

Procedūra atgriež mainīgo vērtību, kas būtu jāparāda ekrānā. Šajā gadījumā pievada stāvokļa vērtība (0 un 1) tiek pārveidota uz “ON” un “OFF”, lai labāk uztvertu.

Šīs vērtības (statuss) tiks parādītas atbilstošajos saīsnēs

3 ReadArduino rutīna būtībā nolasīs statusa kanālu vietnē ThingSpeak. Tātad, jums jānosaka URL, kas tiks nosūtīts uz vietni Thingspeak. Lai to izdarītu, jādeklarē un jāapvieno 3 globālie mainīgie, lai izveidotu vietrādi URL, kas tiks nosūtīts ThingSpeak. GET jānosūta uz tīmekļa komponentu ar nosaukumu "ArduFarmBotStatusCh"

4 No iepriekšējās komandas saņemtais teksts tiks nosūtīts JSon formātā. Šis teksts jāapstrādā tā, lai katrs lauks tiktu nolasīts un saglabāts attiecīgajā globālajā mainīgajā.

5 Pēdējā lieta, kas jādara, ir izsaukt “Signalizācijas” procedūru, kurā tiks analizēts divu augsnes sensoru stāvoklis. Ja temperatūra ir pārāk zema (mūsu gadījumā 10 ° C), vajadzētu parādīt ziņojumu. Tas pats mitrumam, ja tas ir mazāks par 60%.

Lūdzu, ņemiet vērā, ka mēs esam definējuši citu taimeri (Clock2), kas ir ieprogrammēts tā darbībai katru sekundi. Tas ir nepieciešams tikai, lai "pārslēgtu" ziņojuma teksta krāsu (no baltas uz sarkanu). Ziņa mirgos.

Pieteikuma kodu var lejupielādēt vietnē

10 izpildmehānismu savienojums

Komandas sūkņa un lampas ieslēgšanai un izslēgšanai tiks saņemtas no attāluma. Ardunio izeja aktivizēs releju un gaismas diodi, ņemot šīs komandas. Attēlā parādīts, kā jāpievada izpildmehānismi. Lūdzu, ņemiet vērā, ka GND releja izeja NAV PIEVIENOTS uz GND izvadiUNO. Tādā veidā relejam darbojoties, būs mazāk enerģijas traucējumu.

11 kanālu izpildmehānismu (izpildmehānismu kanāli) konfigurācija

Visas darbības atkārto statusa kanāla konfigurēšanas procedūru. Katrai no ierīcēm ir jāizveido divi kanāli. Katram kanālam uzrakstiet kanāla ID, lasīšanas un rakstīšanas taustiņus. Mēs rakstīsim tikai katra kanāla pirmajā laukā. Piemēram:
Kanāla ID 375598 ==> Sarkans gaismas diode (sūknis)
◦ 1. lauks = 0 ==> Pump OFF
◦ 1. lauks = 1 ==> Sūknis ieslēgts
2. Kanāla ID 375599 ==> LED zaļa (lampa)
◦ 1. lauks = 0 ==> Lampa izslēgta
◦ 1. lauks = 1 ==> Lampa ON

11 iekraušanas un pārbaudes koda izpildmehānismi Ardunio.

Kad mēs nosūtījām datus uz mākoni, mēs tos “uzrakstījām” ThingSpeak. Statusa kanālā, “pārraidot” (augšupielādējot) šos datus. Tagad mums ir “jāizlasa” dati no pievada kanāla, “jāpieņem” (lejupielādējot) šos datus.

Lai to izdarītu, nosūtiet GET virkni, un šī procedūra sastāv no 3 posmiem.
"Start cmd"

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

Līnijas garums

AT + CIPSEND = 36

Un pati GET virkne

GET / kanāli / 375598 / lauki / 1 / pēdējais

Kanāli tiks “nolasīti” ik pēc 10 sekundēm

Pēc GET nosūtīšanas mums ir jāpieņem ThingSpeak atbilde. Atbildei jābūt vai nu 0, vai 1 katram kanālam. Ja ir kādas citas vērtības, mēs tās vienkārši ignorējam.

Galvenā atšķirība starp šo daļu un iepriekšējo ir tikai funkcijā readThingSpeak (virknes kanālsID)
Zemāk ir kods, kas veic aprakstītās darbības.

// Lietas runa
Stīgu kanālsID1 = "999999"; // 1. izpildmehānisms
Stīgu kanālsID2 = "999999"; // 2. izpildmehānisms

# iekļaut 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// Mainīgie, kas izmantojami ar taimeriem
ilgi readTimingSeconds = 10; // ==> Definējiet parauga laiku sekundēs datu saņemšanai
garš startReadTiming = 0;
ilgi pagājisReadTime = 0;

// Releji
#define ACTUATOR1 10 // RED LED ==> Sūknis
#define ACTUATOR2 12 // GREEN LED ==> Lampa
Būla pumpis = 0;
Būla lampa = 0;

int rezerves = 0;
Būla kļūda;

iestatīšana nav spēkā ()
{
  Sērijas.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Atiestatīt Modulo WiFi
  startReadTiming = millis (); // "programmas pulksteņa" palaišana
}

tukšs cilpa ()
{
  sākums: // etiķete
  kļūda = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (lapse lapseReadTime> (readTimingSeconds * 1000))
  {
    int komanda = readThingSpeak (canalID1);
    if (komanda! = 9) pump = komanda;
    kavēšanās (5000);
    komanda = readThingSpeak (canalID2);
    if (komanda! = 9) lampa = komanda;
    veikt darbības ();
    startReadTiming = millis ();
  }
  
  if (kļūda == 1) // Nosūtīt atkārtoti, ja pārsūtīšana nav pabeigta
  {
    Serial.println ("<<<< KĻŪDA >>>>");
    kavēšanās (2000);
    goto sākums; // dodieties uz iezīmi "sākums"
  }
}

/ ********* Veiciet darbības, pamatojoties uz ThingSpeak komandām ************* /
spēkā neesošas darbības (spēkā neesošas)
{
  Serial.print ("Pump:");
  Serial.println (pump);
  Serial.print ("Lampa:");
  Serial.println (lampa);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  else digitalWrite (ACTUATOR1, HIGH);
  if (lampa == 1) digitalWrite (ACTUATOR2, LOW);
  else digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Lasīt izpildmehānismu komandu no ThingSpeak ************* /
int readThingSpeak (virknes kanālsID)
{
  startThingSpeakCmd ();
  int komanda;
  // preparacao da string GET
  Virkne getStr = "GET / kanāli /";
  getStr + = kanāla ID;
  getStr + = "/ lauki / 1 / pēdējais";
  getStr + = "\ r \ n";

  Virkne messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    komanda = messageDown [7] -48;
    Serial.print ("Komanda saņemta:");
    Serial.println (komanda);
  }
  cits komanda = 9;
  atgriešanās komanda;
}

/ ********* Reset ESP ************* /
spēkā neesošs EspHardwareReset (spēkā neesošs)
{
  Serial.println ("Reseting .......");
  digitalWrite (HARDWARE_RESET, LOW);
  kavēšanās (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  kavēšanās (8000); // Tempo mustário para começar a ler
  Serial.println ("RESET");
}

/ ********* Sāciet saziņu ar ThingSpeak ************** /
void startThingSpeakCmd (spēkā neesošs)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Virkne 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 ("Error"))
  {
    Serial.println ("AT + CIPSTART kļūda");
    atgriezties
  }
}

/ ********* nosūtiet GET cmd uz ThingSpeak ************* /
Virkne sendThingSpeakGetCmd (virkne getStr)
{
  Stīgas cmd = "AT + CIPSEND =";
  cmd + = stīga (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);
    kavēšanās (500); // tempo para processar o GET, sem este delay apresenta aizņemts bez próximo comando

    Virkne messageBody = "";
    savukārt (EspSerial.avable ())
    {
      Virknes līnija = EspSerial.readStringUntil ('\ n');
      if (līnijas garums () == 1)
      {// faktiskais saturs sākas pēc tukšas rindas (kuras garums ir 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody saņemts:");
    Serial.println (messageBody);
    return messageBody;
  }
  cits
  {
    EspSerial.println ("AT + CIPCLOSE"); // brīdinājuma lietotājs
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Nosūtīt atkārtoti ...
    rezerves = rezerves + 1;
    kļūda = 1;
    atgriezt "kļūdu";
  }
}

Jūs to varat lejupielādēt vietnē

12 komandu nosūtīšana uz ierīcēm

Šajā posmā mums ir konfigurēts pievada kanāls, kas maina katras ierīces 1. lauka vērtību. Mums jāpārbauda, vai ierīces pareizi izstrādā komandas. Projekta beigās tam tiks izmantota android lietojumprogramma, taču to var izdarīt arī caur pārlūku.

Ieslēdziet sūkni (deg sarkanā gaismas diode)

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

Sūknis izslēgts (sarkanā gaismas diode nedeg)

https://api.thingspeak.com/update?api_key=saglabāts Channel_key_1 & field1 = 0

Ieslēdziet lampu (deg zaļa gaismas diode)

https://api.thingspeak.com/update?api_key=Saglabāts Channel_key_2 & field1 = 1

Izslēdziet lampu (zaļā gaismas diode nedeg)

https://api.thingspeak.com/update?api_key=Saglabāts Channel_key_2 & field1 = 0

14 Android programmas beigšana

Iepriekšējā daļā bija vienkārša programma, kas “nolasīja” datus no kanāla un parādīja tos uz ekrāna. Tagad mums jāpanāk programmai “rakstīt” komandas pievads Channal, lai kontrolieris varētu nolasīt šīs komandas un attiecīgi darbotos lampa ar sūkni.

Lai lietotājs varētu sūtīt komandas, lietojumprogrammai būs divas pogas katrai ierīcei. Ja ieslēgts, zils, ja izslēgts, sarkans.

Noklikšķinot uz pogām lietojumprogrammā, rezultātu var redzēt seriālajā monitorā.

Kodu var lejupielādēt vietnē

15 Noslēguma montāža

Šajā posmā ir pilnībā pabeigta android lietojumprogramma, pilnībā samontēta aparatūras daļa, bet kontrollerī nav koda, kas pastāvīgi lasītu datus un nosūtītu komandas mākonim. Jums vienkārši jāapvieno visi iepriekš uzrakstītie koda fragmenti. Protams, kodam ir papildu verifikācijas iespējas (piemēram, ja ESP-01 sasalst). Lai to izdarītu, periodiski pirms katras lasīšanas vai rakstīšanas komandas tiek nosūtīta AT komanda.Un, ja atbilde Labi nenāca no moduļa, modulis ir piespiedu kārtā pārstartēta programmatūra.

Pilnu projekta kodu var lejupielādēt vietnē

Pēc adreses jūs varat saņemt programmas failu atjauninājumus.

Varat arī izlasīt komentārus par saiti uz avotu, ja kaut kas nav skaidrs.