Hantering av växthus eller växthus var som helst i världen (exempel på implementering)

Arduino / Växthus och hotbeds

1 Enhetskoncept

Syftet med denna utveckling är att samla in data från lokala sensorer, skicka denna information till Internet. Användaren kommer att kunna se data som kommer från sensorerna var som helst i världen och fatta ett avlägset beslut om aktivering av vissa ställdon som kommer att lokaliseras lokalt, bredvid sensorerna

Projektet använder Arduino UNO och WiFi-modul ESP8266-01. Data kommer att överföras till molnet via ThingSpeak.com webbtjänst, och enheter kommer att aktiveras via Android-applikationen utvecklad med MIT AppInventor.

Hantering av växthus eller växthus var som helst i världen (exempel på implementering)

IoT är ett koncept för ett datornätverk med fysiska föremål ("saker") utrustade med inbyggd teknik för att interagera med varandra eller med den yttre miljön, med hänsyn till organisationen av sådana nätverk som ett fenomen som kan bygga om ekonomiska och sociala processer, vilket eliminerar behovet av mänskligt deltagande från en del av åtgärder och operationer.

Huvudfokus för detta IoT-projekt kommer att vara tjänsten ThingSpeak.com. Den lokala UNO / ESP-01-enheten tar emot data från sensorer och data om ställdonets status, skickar den till Internet "inspelning" via en specifik ThingSpeak.com-statuskanal (ThingSpeak.com Status Channel), samma lokala enhet får data, " läser ”dem från en annan datakanal -” kanalen för exekutiva enheter ”(ThingSpeak.com Actuator Channels).

Data samlas in med hjälp av en sensor för temperatur och relativ fuktighet, markens temperatur och luftfuktighet och en sensor för omgivande ljus. Denna information kommer att skickas till ThingSpeak-tjänstmolnet.

Det kommer att finnas två exekutiva enheter - det här är en vattenelektrisk pump och en lampa. Deras ON / OFF-status skickas också till molnet. Data från sensorer, till exempel, kan visa det nuvarande tillståndet för ett växthus eller växthus. Användaren kommer att styra exekutiva enheter med Android-applikationen.

2 Lista över nödvändiga komponenter

Alla länkar är endast för informationssyfte.

2 x lysdioder (röd och grön)
1 x
- $3.00
220V lampa
2 x 330 ohm-motstånd (används med lysdioder)
2 x 10K ohm-motstånd (används med DHT22 och LDR)
1 x 4K7 ohm-motstånd (används med DS18B20)
prototyper ombord
hoppare
Extern strömförsörjning för relä 5V DC

3 Järndel

Nu måste du ansluta alla sensorer, som visas i diagrammet.

Den ideala lösningen skulle vara att montera och testa projektet i delar.

I följande sekvens:
1. Installera och testa alla sensorer
2.Installera och lägsta konfigurera ESP-01
3. Ändra ESP-01-inställningen till den slutliga konfigurationen och testet
4. Konfigurera ThingSpeak-statuskanalen
5. Installera ThingSpeak-kod på Arduino och kontrollera status för sensorer på molnet
6. Utveckla den första versionen av programmet på Android för att kontrollera statusmeddelanden från sensorer
7. Installera ställdon
8. Konfigurera ThingSpeak Actuators kanaler
9. Installera och testa kod för exekutiva enheter på Arduino
10. Gör den andra versionen av programmet på Android för hela enhetens enhet.

4 Sensoranslutning

Projektet använder vissa bibliotek som ingår i. Det är nödvändigt att kontrollera deras tillgänglighet. Den ursprungliga konfigurationen av dessa bibliotek är som följer:

// DS18B20
#include 
#include 
# definiera ONE_WIRE_BUS 5 // DS18B20 på stift D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
intjordTemp = 0;

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

// LDR (lätt)
#definiera ldrPIN 1
int ljus = 0;

// Jordfuktighet
#definier jordHumPIN 0
intjordHum = 0;

Nu initialiserar vi våra sensorer och visar dem i terminalen:

ogiltig installation ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

void loop ()
{
  readSensors ();
  displaySensorer ();
  fördröjning (10000);
}

Och slutligen kommer vi att skriva två funktioner: en läser avläsningarna från sensorerna, och den andra visar dem på skärmen:

/ ********* Läs sensors värde ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperaturures ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 kommer att fånga jordtemp i Celcius
  
  jordHum = karta (analogRead (jordHumPIN), 1023, 0, 0, 100);
 
  ljus = karta (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lätt 100%

}

/ ********* Display sensors värde ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("earthTemp (oC):");
  Serial.println (jordTemp);
  Serial.print ("jordHum (%): ");
  Serial.println (jordHum);
  Serial.print ("lätt (%):");
  Serial.println (lätt);
  Serial.println ("");
}

Fotot visar hur data visas på skärmen.

Källkod kan laddas ner från författaren.

4 ESP8266-01 grundkonfiguration

Det snabbaste sättet att "prata" med modulen är AT-kommandot. Processorn har redan en AT-kommandoprocessor. Som standard har modulen fabriksinställningar på 115200 baud, du måste ställa in 9600 baud i inställningarna.

Först måste du ansluta modulen, som visas på fotot

( Observera att Tx-terminalen på ESP-01 är ansluten till Tx-terminalen i UNO, precis som Rx-terminalerna är anslutna till varandra. Denna anslutning ändras senare. ).

Anslut sedan UNO till datorn, öppna IDE och ladda ner exemplet som finns. Detta är tom kod så att det inte finns några konflikter mellan ESP-01 och UNO. Den här koden laddades upp till Ardunio innan ESP-01 anslutits till den, för att vara säker på att Ardunio inte kommer att använda Tx- och Rx-stiften för något annat.
Nu måste du öppna IDE Serial Monitor, ställa in baudhastigheten till 115200 i inställningarna och skicka AT-kommandot till IDE Serial Monitor. ESP-01 ska skicka ett svar OK

Nu måste du ändra datahastigheten i ESP-01-modulen. För att göra detta i IDE, ge kommandot

AT + CIOBAUD = 9600

Det kan hända att ESP-01 återgår till fabriksinställningarna, då måste du använda ett annat kommando:

AT + UART_DEF = , , , ,

Till exempel 9600 baud / 8 databitar / 1 stoppbitar och ingen paritet och flödeskontroll

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

Ändra nu dataöverföringshastigheten i IDE-inställningarna till 9600 och skicka AT-kommandot, OK-svaret skulle komma.
Därefter måste du växla modulen till STA-läge så att den kan ansluta till nätverkets åtkomstpunkt.

AT + CWMODE = 1

Ange kommandot för att modulen ska ansluta till nätverket AT + CWJAP = "nätverksnamn", "nätverksnamn_1"var NETWORK_NAME Är namnet på ditt nätverk, och network_name_1 - lösenord för ditt nätverk (lösenord och nätverksnamn måste vara i citattecken)
Om du ser svaret WIFI-anslutna WIFI GOT IP, sedan upprättas anslutningen. Verifiera IP-adressen med kommandot

AT + CIFSR

.

Adressen som visas på din bildskärm kan du använda i framtiden. När du har konfigurerat modulen kan du ansluta den permanent, men för detta måste du ändra dess kopplingskrets, som visas i figuren.

• ESP-01 RX (gul) -> UNO Pin D7
• ESP-01 TX (Orange) -> UNO Pin D6
• ESP-01 Ch-Pd (brun) -> Vcc (3.3V)
• ESP-01 Återställ (blå) -> UNO Pin D8
• ESP-01 Vcc (röd) -> 3,3 V
• ESP-01 Gnd (svart) -> UNO GND

Observera att programmet Serial Library använder UNO Pin D7-stiftet som tx och den ansluts till utgången från ESP-01 RXmedan UNO Pin D6 som rxansluten till ESP-01 TX.

Ange en liten kod för att kontrollera korrekt anslutning och konfiguration av ESP-01-modulen

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

# definiera hastighet8266 9600

ogiltig installation ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Inställningstest - använd AT-coomands");
}

void loop ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  medan (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Nu några AT-lag. Se resultaten i Serial Monitor.

* AT =====> ESP8266 returnerar OK
* AT + RST =====> ESP8266 starta om och returnerar OK
* AT + GMR =====> ESP8266 returnerar AT-versionen; SDK-version; id; OK
* AT + CWMODE? => ESP8266 returnerar modetyp
* AT + CWLAP ===> ESP8266 returnerar nära åtkomstpunkter
* AT + CIFSR ===> ESP8266 returnerar designid IP

Programkoden kan laddas ner på

6 anslutning av sensorer och ESP-01

När alla sensorer är anslutna och kontrollerade, samt ESP-01-modulen har kontrollerats, är det nödvändigt att förbereda data för att skicka till Internet.

7 ThingSpeak

En av de viktigaste delarna av projektet är den öppna IoT-plattformen, som kommer att samla in data från sensorer, bearbeta och analysera dem. För att göra detta, gå till och skapa ditt konto. Därefter måste du skapa en kanal där det finns två ställdon, 5 sensorer och ett säkerhetsfält.
• Fält 1: Ställdon 1 (enhet 1)
• Fält 2: Ställdon 2 (enhet 2)
• Fält 3: Lufttemperatur i oC (lufttemperatur i grader Celsius)
• Filed 4: Luft Relativ luftfuktighet i% (Relativ luftfuktighet i%)
• Fält 5: Jordtemperatur i oC (jordtemperatur i gr. Celsius)
• Fält 6: Jordfuktighet i% (markfuktighet i%)
• Fält 7: Ljusstyrka i% (belysning i%)
• Fält 8: Reservdel

Fält 8 är reserverat för framtida expansion eller för felsökning. I detta projekt används det som en kommunikationsfelräknare mellan Arduino / ESP-01 och ThingSpeak.com.

När du har skapat statuskanalen måste du spela in knapparna, som visas på fotot.

8 Skicka sensorstatus till molnet

Just nu har vi en konfigurerad molntjänst och våra sensorer samlar in data lokalt. Nu måste du ta dessa data och skicka dem till molnet på ThingSpeak.com.

För att skriva data till ThingSpeak-kanalen måste du skicka en GET-sträng. Detta görs i tre steg.
Skicka kommandot "Start cmd"

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

Ytterligare stränglängd

AT + CIPSEND = 116

Och slutligen en GET-sträng som skriver våra data i de reserverade statuskanalfälten.

GET / update? Api_key = Your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = earthTemp & field6 = earthHum & field7 = light & field8 = spare

Observera att vi inte ska skriva data till kanalen mer än 1 gång på 16 sekunder.

Den skickade koden gör allt detta.

// Thingspeak
String statusChWriteKey = "DIN SKRIVNYCKEL HÄR"; // Statuskanal-id: 385184

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

// DS18B20
#include 
#include 
# definiera ONE_WIRE_BUS 5 // DS18B20 på stift D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
intjordTemp = 0;

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

// LDR (lätt)
#definiera ldrPIN 1
int ljus = 0;

// Jordfuktighet
#definier jordHumPIN 0
intjordHum = 0;

// Variabler som ska användas med timers
lång skrivningTimingSekunder = 17; // ==> Definiera provtid i sekunder för att skicka data
lång startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variabler som ska användas med ställdon
boolean pump = 0;
boolesk lampa = 0;

int reserv = 0;
booleskt fel;

ogiltig installation ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Återställ do Modulo WiFi
  startWriteTiming = millis (); // starta "programklockan"
}

void loop ()
{
  start: // etikett
  fel = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (skrivTimingSekunder * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Skicka igen om överföringen inte är klar
  {
    Serial.println ("<<<< FEL >>>>");
    försening (2000);
    börja; // gå till etiketten "start"
  }
}

/ ********* Läs sensors värde ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperaturures ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 kommer att fånga jordtemp i Celcius
             
  ljus = karta (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lätt 100%
  jordHum = karta (analogRead (jordHumPIN), 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 (pump);
  getStr + = "& field2 =";
  getStr + = String (lampa);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (earthTemp);
  getStr + = "& field6 =";
  getStr + = String (jordHum);
  getStr + = "& field7 =";
  getStr + = String (lätt);
  getStr + = "& field8 =";
  getStr + = String (reserv);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Återställ ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Återställer .......");
  digitalWrite (HARDWARE_RESET, LOW);
  fördröjning (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  fördröjning (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Börja kommunikationen med ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffert antes de começar a gravar
  
  Sträng 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 ("Fel"))
  {
    Serial.println ("AT + CIPSTART-fel");
    återvända;
  }
}

/ ********* skicka en GET cmd till ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Sträng cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> längd cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    fördröjning (500); // tempo para processar o GET, sem este fördröjning apresenta upptagen ingen próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktiskt innehåll börjar efter tom rad (som har längd 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody fick:");
    Serial.println (messageBody);
    returnera meddelandeBody;
  }
  annars
  {
    EspSerial.println ("AT + CIPCLOSE"); // varnar användare
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Skicka igen ...
    reserv = reserv + 1;
    fel = 1;
    returnera "fel";
  }
}

Du kan se framstegen i Serial Monitor.

Källkod kan laddas ner på

9 Android-app - del ett

Först måste du skapa ett användargränssnitt. Bilden visar de viktigaste synliga och osynliga elementen.

Efter det måste du skapa block. Menyalternativ motsvarar skärmdumpsnummer.

1 Ange variabler som bör deklareras som globala

2 Varannan sekund (beroende på klocka 1) anropas en procedur "ReadArduino"

Proceduren returnerar värdet på de variabler som ska visas på skärmen. I detta fall konverteras tillståndsvärdet (0 och 1) för ställdonna till “ON” och “OFF” för bättre uppfattning.

Dessa värden (Status) visas i motsvarande ”Genvägar”

3 ReadArduino-rutinen kommer i huvudsak att läsa statuskanalen i ThingSpeak. Så du måste bestämma webbadressen som ska skickas till Thingspeak. För att göra detta måste 3 globala variabler deklareras och kombineras för att skapa URL: en som skickas till ThingSpeak. GET ska skickas till en webbkomponent som heter «ArduFarmBotStatusCh»

4 Text som erhållits från föregående kommando kommer att komma i JSon-format. Denna text måste bearbetas så att varje fält läses och lagras i motsvarande globala variabel.

5 Det sista att göra är att kalla "Alarm" -förfarandet, som kommer att analysera tillståndet för två jordgivare. Om temperaturen är för låg (i vårt fall 10oC), bör ett meddelande visas. Detsamma för fukt om det är under 60%.

Observera att vi har definierat en annan timer (Clock2), programmerad att den ska köras varje sekund. Det behövs bara för att "växla" färgen på meddelandeteksten (från vit till röd). Meddelandet blinkar.

Ansökningskod kan laddas ner på

10 Anslutning av ställdon

Kommandon för att slå på och stänga av pump och lampa kommer att tas emot på distans. Ardunios utgång aktiverar reläet och lysdioden och tar dessa kommandon. Bilden visar hur manöverorganen ska anslutas. Observera att GND-reläutgång INTE ANSLUTEN till GND-utgångUNO. På så sätt blir det mindre effektstörning när reläet körs.

11 konfiguration av kanalmanöverdon (Actuators Channels)

Alla åtgärder upprepar proceduren för att konfigurera statuskanalen. Det är nödvändigt att skapa två kanaler för var och en av enheterna. Skriv kanal-ID, läs- och skrivtangenter för varje kanal. Vi skriver bara i det första fältet på varje kanal. Till exempel:
Channel ID 375598 ==> LED Red (Pump)
◦ Fält1 = 0 ==> Pump AV
◦ Fält1 = 1 ==> Pump PÅ
2. Kanal-ID 375599 ==> LED-grön (lampa)
◦ Fält1 = 0 ==> Lampa AV
◦ Fält1 = 1 ==> Lampa PÅ

11 lastning och testning av kodaktuatorer i Ardunio.

När vi skickade data till molnet "skrev vi" dessa data till ThingSpeak. Statuskanal, "överför" (laddar upp) dessa data. Nu måste vi "läsa" data från Ställdonskanalen, "acceptera" (ladda ner) dessa data.

För att göra detta, skicka en GET-sträng och denna procedur består av tre steg.
"Start cmd"

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

Linjelängd

AT + CIPSEND = 36

Och själva GET-strängen

GET / kanaler / 375598 / fält / 1 / sist

Kanalerna kommer att "läsas" var tionde sekund

Efter att ha skickat GET måste vi acceptera svaret från ThingSpeak. Svaret måste vara antingen 0 eller 1 för varje kanal. Om det finns andra värden ignorerar vi dem helt enkelt.

Den största skillnaden mellan den här delen och den föregående är bara i funktionen readThingSpeak (String channelID)
Nedan visas koden som utför de beskrivna åtgärderna.

// Thingspeak
String canalID1 = "999999"; // Ställdon1
String canalID2 = "999999"; // Ställdon2

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

// Variabler som ska användas med timers
länge readTimingSeconds = 10; // ==> Definiera provtid i sekunder för att ta emot data
lång startReadTiming = 0;
lång förflutitReadTime = 0;

// Reläer
#define ACTUATOR1 10 // RED LED ==> Pump
#define ACTUATOR2 12 // GRÖN LED ==> Lampa
boolean pump = 0;
boolesk lampa = 0;

int reserv = 0;
booleskt fel;

ogiltig installation ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  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 (); // Återställ do Modulo WiFi
  startReadTiming = millis (); // starta "programklockan"
}

void loop ()
{
  start: // etikett
  fel = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int kommando = readThingSpeak (canalID1);
    if (kommando! = 9) pump = kommando;
    fördröjning (5000);
    kommando = readThingSpeak (canalID2);
    if (kommando! = 9) lampa = kommando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Skicka igen om överföringen inte är klar
  {
    Serial.println ("<<<< FEL >>>>");
    försening (2000);
    börja; // gå till etiketten "start"
  }
}

/ ********* Vidta åtgärder baserade på ThingSpeak-kommandon ************* /
void takeActions (void)
{
  Serial.print ("Pump:");
  Serial.println (pump);
  Serial.print ("Lampa:");
  Serial.println (lampa);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  annars digitalWrite (ACTUATOR1, HIGH);
  if (lampa == 1) digitalWrite (ACTUATOR2, LOW);
  annars digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Läs Actuators kommando från ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int kommando;
  // Preparacao da string GET
  String getStr = "GET / channel /";
  getStr + = channelID;
  getStr + = "/ fält / 1 / sista";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    kommando = meddelandeDown [7] -48;
    Serial.print ("Kommando mottagen:");
    Serial.println (kommando);
  }
  annat kommando = 9;
  returkommando;
}

/ ********* Återställ ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Återställer .......");
  digitalWrite (HARDWARE_RESET, LOW);
  fördröjning (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  fördröjning (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Börja kommunikationen med ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffert antes de começar a gravar
  
  Sträng 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 ("Fel"))
  {
    Serial.println ("AT + CIPSTART-fel");
    återvända;
  }
}

/ ********* skicka en GET cmd till ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Sträng cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> längd cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    fördröjning (500); // tempo para processar o GET, sem este fördröjning apresenta upptagen ingen próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktiskt innehåll börjar efter tom rad (som har längd 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody fick:");
    Serial.println (messageBody);
    returnera meddelandeBody;
  }
  annars
  {
    EspSerial.println ("AT + CIPCLOSE"); // varnar användare
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Skicka igen ...
    reserv = reserv + 1;
    fel = 1;
    returnera "fel";
  }
}

Du kan ladda ner den på

12 skicka kommandon till enheter

I detta skede har vi en konfigurerad ställdonskanal som ändrar värdet på fält 1 för varje enhet. Vi måste verifiera att enheterna fungerar kommandona ordentligt. I slutet av projektet kommer en Android-applikation att användas för detta, men det kan också göras via en webbläsare.

Slå på pumpen (röd lysdiod på)

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

Pump av (röd LED av)

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

Slå på lampan (grön LED lyser)

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

Stäng av lampan (grön LED av)

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

14 Avsluta Android-programmet

I föregående del fanns det ett enkelt program som "läste" data från kanalen och visade det på skärmen. Nu måste vi göra programmet "skriva" kommandona i Actuator Channal, så att dessa kommandon kan läsas av regulatorn och lampan med pumpen fungerar i enlighet därmed.

Så att användaren kan skicka kommandon kommer applikationen att ha två knappar för varje enhet. Om den är påslagen, blå; om den är avstängd, röd.

Genom att klicka på knapparna i applikationen kan du se resultatet i Serial Monitor.

Koden kan laddas ner på

15 Slutmontering

I detta skede finns det en fullständig Android-applikation, en helt monterad "järn" -del, men det finns ingen kod i kontrollenheten som ständigt skulle läsa data och skicka kommandon till molnet. Du behöver bara kombinera alla fragment av koden som har skrivits tidigare. Naturligtvis har koden ytterligare verifieringsalternativ (till exempel om ESP-01 fryser). För att göra detta skickas ett AT-kommando regelbundet före varje läs- eller skrivkommando.Och om svaret OK inte kom från modulen, startas modulen tvungen igen programmatiskt.

Den fullständiga projektkoden kan laddas ner på

På adressen kan du få uppdateringar för programfiler.

Du kan också läsa kommentarer på länken till källan, om något inte är klart.