Håndtering af et drivhus eller drivhus fra hvor som helst i verden (eksempel på implementering)

Arduino / Drivhuse og hotbeds

1 Enhedskoncept

Formålet med denne udvikling er at indsamle data fra lokale sensorer, sende disse data til Internettet. Brugeren vil være i stand til overalt i verden at se dataene der kommer fra sensorerne og eksternt beslutte om aktivering af visse aktuatorer, der vil være lokaliseret lokalt ved siden af sensorer

Projektet bruger Arduino UNO og WiFi modul ESP8266-01. Data overføres til skyen via ThingSpeak.com webtjenesten, og enheder vil blive aktiveret via Android-applikationen udviklet ved hjælp af MIT AppInventor.

Håndtering af et drivhus eller drivhus fra hvor som helst i verden (eksempel på implementering)

IoT er et koncept af et computernetværk af fysiske objekter (“ting”) udstyret med indbyggede teknologier til interaktion med hinanden eller med det ydre miljø, idet man betragter organiseringen af sådanne netværk som et fænomen, der kan omstrukturere økonomiske og sociale processer, hvilket eliminerer behovet for menneskelig deltagelse fra en del af handlinger og operationer.

Hovedfokus for dette IoT-projekt vil være ThingSpeak.com-tjenesten. Den lokale UNO / ESP-01 enhed modtager data fra sensorer og data om status som aktuatorer, sender dem til Internettet "optagelse" via en specifik ThingSpeak.com statuskanal (ThingSpeak.com Status Channel), den samme lokale enhed modtager data, " at læse dem fra en anden datakanal, "kanalen med udøvende enheder" (ThingSpeak.com Actuator Channels).

Data indsamles ved hjælp af en temperatur- og relativ fugtighedsføler, jordtemperatur og -fugtighed og en omgivende lyssensor. Disse data sendes til ThingSpeak-servic skyen.

Der vil være to udøvende enheder - dette er en vandelektrisk pumpe og en lampe. Deres ON / OFF-status sendes også til skyen. Data fra sensorer kan for eksempel vise den aktuelle tilstand for et drivhus eller drivhus. Brugeren vil kontrollere de udøvende enheder ved hjælp af Android-applikationen.

2 Liste over nødvendige komponenter

Alle links er kun til informationsformål.

2 x lysdioder (rød og grøn)
1 x
- $3.00
220V lampe
2 x 330 ohm modstand (brugt med LED)
2 x 10K ohm-modstand (brugt med DHT22 og LDR)
1 x 4K7 ohm-modstand (brugt sammen med DS18B20)
prototyping board
jumpere
Ekstern strømforsyning til relæ 5V DC

3 Jerndel

Nu skal du forbinde alle sensorer, som vist i diagrammet.

Den ideelle løsning ville være at samle og teste projektet i dele.

I følgende rækkefølge:
1. Installer og test alle sensorer
2.Installer og minimum konfigurer ESP-01
3. Skift ESP-01-opsætningen til den endelige konfiguration og test
4. Konfigurer ThingSpeak-statuskanalen
5. Installer ThingSpeak-kode på Arduino og kontroller status for sensorer på skyen
6. Udvikl den første version af programmet på Android for at kontrollere statusmeddelelser fra sensorer
7. Installer aktuatorer
8. Konfigurer ThingSpeak Actuators kanaler
9. Installer og test kode for udøvende enheder på Arduino
10. Lav den anden version af programmet på Android til hele enhedsenheden.

4 Sensorforbindelse

Projektet bruger nogle biblioteker, der er inkluderet i. Det er nødvendigt at kontrollere deres tilgængelighed. Den oprindelige konfiguration af disse biblioteker er som følger:

// DS18B20
#include 
#include 
#definer ONE_WIRE_BUS 5 // DS18B20 på pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperatur DS18B20 (& oneWire);
int jordTemp = 0;

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

// LDR (let)
#definér ldrPIN 1
int lys = 0;

// Jordfugtighed
#definer jordHumPIN 0
int jordHum = 0;

Nu initialiserer vi vores sensorer og viser dem i terminalen:

ugyldig opsætning ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

void loop ()
{
  readSensors ();
  displaySensorer ();
  forsinkelse (10000);
}

Og til sidst vil vi skrive to funktioner: den ene læser målingerne fra sensorerne, og den anden viser dem på skærmen:

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

  DS18B20.requestTemperaturer ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 fanger jordtemperatur i Celcius
  
  jordHum = kort (analog læse (jordHumPIN), 1023, 0, 0, 100);
 
  lys = kort (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> let 100%

}

/ ********* Display sensors værdi ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("jordTemp (oC):");
  Serial.println (earthTemp);
  Serial.print ("earthHum (%):");
  Serial.println (jordHum);
  Serial.print ("let (%):");
  Serial.println (let);
  Serial.println ("");
}

Billedet viser, hvordan dataene vises på skærmen.

Kildekode kan downloades fra forfatteren.

4 ESP8266-01 grundlæggende konfiguration

Den hurtigste måde at "tale" med modulet er AT-kommandoen. Processoren har allerede en AT-kommandoprocessor. Som standard leveres modulet med fabriksindstillinger på 115200 baud, du skal indstille 9600 baud i indstillingerne.

For det første skal du tilslutte modulet, som vist på billedet

( Bemærk, at Tx-terminalen på ESP-01 er tilsluttet Tx-terminalen i UNO, ligesom Rx-terminalerne er forbundet til hinanden. Denne forbindelse ændres senere. ).

Tilslut derefter UNO til computeren, åbn IDE og download det eksempel, der findes. Dette er tom kode, så der ikke er nogen konflikter mellem ESP-01 og UNO. Denne kode blev uploadet til Ardunio, før ESP-01 forbindes til den, for at være sikker på, at Ardunio ikke vil bruge Tx- og Rx-stifterne til noget andet.
Nu skal du åbne IDE Serial Monitor, indstille baudhastigheden til 115200 i indstillingerne og sende AT-kommandoen til IDE Serial Monitor. ESP-01 skal sende et svar OK

Nu skal du ændre datahastigheden i ESP-01-modulet. For at gøre dette skal du i IDE give kommandoen

AT + CIOBAUD = 9600

Det kan ske, at ESP-01 vender tilbage til fabriksindstillingerne, så bliver du nødt til at bruge en anden kommando:

AT + UART_DEF = , , , ,

For eksempel 9600 baud / 8 databits / 1 stopbits og ingen paritet og flowkontrol

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

Skift nu dataoverførselshastigheden i IDE-indstillingerne til 9600 og send AT-kommandoen, OK svaret skulle komme.
Derefter skal du skifte modulet til STA-tilstand, så det kan oprette forbindelse til adgangspunktet på dit netværk.

AT + CWMODE = 1

Indtast kommandoen for at oprette forbindelse til netværket AT + CWJAP = "netværksnavn", "netværksnavn_1"hvor NETWORK_NAME Er navnet på dit netværk, og network_name_1 - adgangskode til dit netværk (adgangskode og netværksnavn skal være i anførselstegn)
Hvis du ser svaret WIFI TILSLUTTET WIFI GOT IP, så oprettes forbindelsen. Bekræft IP-adressen med kommandoen

AT + CIFSR

.

Den adresse, der vises på din skærm, kan du bruge i fremtiden. Når du har konfigureret modulet, kan du tilslutte det permanent, men til dette skal du ændre dets switching circuit, som vist på 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 Nulstilling (blå) -> UNO Pin D8
• ESP-01 Vcc (rød) -> 3.3V
• ESP-01 Gnd (sort) -> UNO GND

Bemærk, at Software Serial-biblioteket bruger UNO Pin D7-pin som tx og forbindes til output fra ESP-01 RXmens UNO Pin D6 som rxtilsluttet ESP-01 TX.

Indtast en lille kode for at kontrollere den korrekte forbindelse og konfiguration af ESP-01-modulet

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

#definér hastighed8266 9600

ugyldig opsætning ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Setup test - brug AT coomands");
}

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

Nu et par AT-hold. Se resultaterne i Serial Monitor.

* AT =====> ESP8266 returnerer OK
* AT + RST =====> ESP8266 genstart og returnerer OK
* AT + GMR =====> ESP8266 returnerer AT-version; SDK version; id; OK
* AT + CWMODE? => ESP8266 returnerer tilstandstype
* AT + CWLAP ===> ESP8266 returnerer tætte adgangspunkter
* AT + CIFSR ===> ESP8266 returnerer designeret IP

Programkode kan downloades på

6 tilslutning af sensorer og ESP-01

Når alle sensorer er tilsluttet og kontrolleret, samt ESP-01-modulet er kontrolleret, er det nødvendigt at forberede dataene til afsendelse til Internettet.

7 ThingSpeak

En af de vigtigste dele af projektet er den åbne IoT-platform, som giver dig mulighed for at indsamle data fra sensorer, behandle og analysere dem. For at gøre dette skal du gå til og oprette din konto. Dernæst skal du oprette en kanal, hvor der vil være 2 aktuatorer, 5 sensorer og et backupfelt.
• Felt 1: Aktuator 1 (enhed 1)
• Felt 2: Aktuator 2 (enhed 2)
• Felt 3: Lufttemperatur i oC (lufttemperatur i grader Celsius)
• Arkiveret 4: Luftrelativ luftfugtighed i% (Relativ luftfugtighed i%)
• Felt 5: Jordtemperatur i oC (Jordtemperatur i gr. Celsius)
• Felt 6: Jordfugtighed i% (jordfugtighed i%)
• Felt 7: Lysstyrke i% (belysning i%)
• Felt 8: Reservedele

Felt 8 er forbeholdt fremtidig udvidelse eller til fejlsøgning. I dette projekt bruges det som en kommunikationsfejltæller mellem Arduino / ESP-01 og ThingSpeak.com.

Når du har oprettet statuskanalen, skal du registrere nøglerne, som vist på billedet.

8 Afsendelse af sensorstatus til skyen

I øjeblikket har vi en konfigureret skytjeneste, og vores sensorer indsamler data lokalt. Nu skal du tage disse data og sende dem til skyen på ThingSpeak.com.

For at skrive data til ThingSpeak-kanalen skal du sende en GET-streng. Dette gøres i tre faser.
Send kommandoen "Start cmd"

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

Yderligere strenglængde

AT + CIPSEND = 116

Og endelig en GET-streng, der skriver vores data i de reserverede statuskanalfelter.

FÅ / opdatering? Api_key = din_saved_key_here & felt1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = earthTemp & field6 = earthHum & field7 = light & field8 = spare

Bemærk, at vi ikke skal skrive data til kanalen mere end 1 gang på 16 sekunder.

Den indsendte kode vil gøre alt dette.

// Thingspeak
String statusChWriteKey = "DIN SKRIFTNøgle HER"; // Statuskanal-id: 385184

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#definér HARDWARE_RESET 8

// DS18B20
#include 
#include 
#definer ONE_WIRE_BUS 5 // DS18B20 på pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperatur DS18B20 (& oneWire);
int jordTemp = 0;

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

// LDR (let)
#definér ldrPIN 1
int lys = 0;

// Jordfugtighed
#definer jordHumPIN 0
int jordHum = 0;

// Variabler, der skal bruges med timere
lang skrivningTimingSeconds = 17; // ==> Definer prøvetid i sekunder for at sende data
lang startWriteTiming = 0;
lang forløbetWriteTime = 0;

// Variabler, der skal bruges sammen med aktuatorer
boolean pumpe = 0;
boolsk lampe = 0;

int reserve = 0;
boolsk fejl;

ugyldig opsætning ()
{
  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 (); // start af "programuret"
}

void loop ()
{
  start: // label
  fejl = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (fejl == 1) // Send igen hvis transmission ikke er afsluttet
  {
    Serial.println ("<<<< FEJL >>>>");
    forsinkelse (2000);
    gå til start; // gå til etiketten "start"
  }
}

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

  DS18B20.requestTemperaturer ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 fanger jordtemperatur i Celcius
             
  lys = kort (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> let 100%
  jordHum = kort (analog læse (jordHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexao com TCP com Thingspeak ******* /
void writeThingSpeak (void)
{

  startThingSpeakCmd ();

  // Preparacao da streng GET
  String getStr = "GET / opdatering? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& felt1 =";
  getStr + = String (pumpe);
  getStr + = "& felt2 =";
  getStr + = String (lampe);
  getStr + = "& felt3 =";
  getStr + = String (airTemp);
  getStr + = "& felt4 =";
  getStr + = String (airHum);
  getStr + = "& felt5 =";
  getStr + = streng (jordTemp);
  getStr + = "& felt6 =";
  getStr + = streng (jordHum);
  getStr + = "& felt7 =";
  getStr + = String (let);
  getStr + = "& felt8 =";
  getStr + = String (ekstra);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Nulstil ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Nulstil .......");
  digitalWrite (HARDWARE_RESET, LOW);
  forsinkelse (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  forsinkelse (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Start kommunikation med ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Streng 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:");
  Seriel.println (cmd);

  if (EspSerial.find ("Fejl"))
  {
    Serial.println ("AT + CIPSTART-fejl");
    vende tilbage;
  }
}

/ ********* send en GET cmd til ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Streng cmd = "AT + CIPSEND =";
  cmd + = streng (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> længde cmd:");
  Seriel.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktisk indhold starter efter tom linje (der har længde 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody modtaget:");
    Serial.println (messageBody);
    return messageBody;
  }
  andet
  {
    EspSerial.println ("AT + CIPCLOSE"); // alarm bruger
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Send igen ...
    reserve = reserve + 1;
    fejl = 1;
    returner "fejl";
  }
}

Du kan se fremskridtene i Serial Monitor.

Kildekode kan downloades på

9 Android-app - del et

Først skal du oprette en brugergrænseflade. Billedet viser de vigtigste synlige og usynlige elementer.

Derefter skal du oprette blokke. Menupunkter svarer til skærmbilledenumre.

1 Angiv variabler, der skal deklareres som globale

2 Hvert andet sekund (afhængigt af ur1) kaldes der en procedure "ReadArduino"

Proceduren returnerer værdien af de variabler, der skal vises på skærmen. I dette tilfælde konverteres tilstandsværdien (0 og 1) for aktuatorer til “ON” og “OFF” for bedre opfattelse.

Disse værdier (Status) vises i de tilsvarende "Genveje"

3 ReadArduino-rutinen vil i det væsentlige læse statuskanalen i ThingSpeak. Så skal du bestemme den URL, der sendes til Thingspeak. For at gøre dette skal 3 globale variabler deklareres og kombineres for at oprette den URL, der sendes til ThingSpeak. GET skal sendes til en webkomponent, der kaldes «ArduFarmBotStatusCh»

4 Tekst modtaget fra den forrige kommando ankommer i JSon-format. Denne tekst skal behandles, så hvert felt læses og gemmes i den tilsvarende globale variabel.

5 Den sidste ting at gøre er at kalde "Alarm" -proceduren, der analyserer to jordføleres tilstand. Hvis temperaturen er for lav (i vores tilfælde 10oC), skal der vises en meddelelse. Det samme for fugt, hvis det er under 60%.

Bemærk, at vi har defineret en anden timer (Clock2), der er programmeret til at køre det hvert sekund. Det er kun nødvendigt for at "skifte" farven på meddelelsesteksten (fra hvid til rød). Meddelelsen blinker.

Ansøgningskode kan downloades på

10 Tilslutning af aktuatorer

Kommandoer til at tænde og slukke pumpen og lampen vil blive modtaget fjernt. Ardunios output aktiverer relæet og LED ved at tage disse kommandoer. Billedet viser, hvordan aktuatorerne skal forbindes. Bemærk, at GND relæudgang IKKE TILSLUTTET til GND outputUNO. På denne måde vil der være mindre strømforstyrrelser, når relæet kører.

11 konfiguration af kanalaktuatorer (Aktuatorer kanaler)

Alle handlinger gentager proceduren for konfiguration af statuskanalen. Det er nødvendigt at oprette to kanaler til hver af enhederne. For hver kanal skal du skrive kanal-ID, læse og skrive tasterne. Vi skriver kun i det første felt på hver kanal. For et eksempel:
Channel ID 375598 ==> LED rød (pumpe)
◦ Felt1 = 0 ==> Pumpe FRA
◦ Felt1 = 1 ==> Pumpe TIL
2. Kanal-ID 375599 ==> LED grøn (lampe)
◦ Felt1 = 0 ==> Lampe FRA
◦ Felt1 = 1 ==> Lampe Tændt

11 indlæsning og test af kodeaktuatorer i Ardunio.

Da vi sendte data til skyen, "skrev vi" disse data til ThingSpeak. Statuskanal, "transmitterer" (uploader) disse data. Nu er vi nødt til at "læse" dataene fra Aktuator Channel, "acceptere" (downloade) disse data.

For at gøre dette, send en GET-streng, og denne procedure består af 3 trin.
"Start cmd"

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

Linjelængde

AT + CIPSEND = 36

Og selve GET-strengen

GET / kanaler / 375598 / felter / 1 / sidste

Kanaler "læses" hvert 10. sekund

Efter at have sendt GET, skal vi acceptere svaret fra ThingSpeak. Svaret skal være enten 0 eller 1 for hver kanal. Hvis der er andre værdier, ignorerer vi dem simpelthen.

Den største forskel mellem denne del og den foregående er kun i funktionen readThingSpeak (String channelID)
Nedenfor er den kode, der udfører de beskrevne handlinger.

// Thingspeak
String canalID1 = "999999"; // Aktuator1
String canalID2 = "999999"; // Aktuator2

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#definér HARDWARE_RESET 8

// Variabler, der skal bruges med timere
lang readTimingSeconds = 10; // ==> Definer prøvetid i sekunder for at modtage data
lang startReadTiming = 0;
lang forløbetReadTime = 0;

// Relæer
#define ACTUATOR1 10 // Rød LED ==> Pumpe
#define ACTUATOR2 12 // GRØN LED ==> Lampe
boolean pumpe = 0;
boolsk lampe = 0;

int reserve = 0;
boolsk fejl;

ugyldig opsætning ()
{
  Serial.begin (9600);
  
  pinMode (ACTUATOR1, OUTPUT);
  pinMode (ACTUATOR2, OUTPUT);
  pinMode (HARDWARE_RESET, OUTPUT);

  digitalWrite (AKTUATOR1, HØJ); // 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 (); // start af "programuret"
}

void loop ()
{
  start: // label
  fejl = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  hvis (forløbetReadTime> (readTimingSeconds * 1000))
  {
    int kommando = readThingSpeak (canalID1);
    if (kommando! = 9) pumpe = kommando;
    forsinkelse (5000);
    kommando = readThingSpeak (canalID2);
    hvis (kommando! = 9) lampe = kommando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (fejl == 1) // Send igen hvis transmission ikke er afsluttet
  {
    Serial.println ("<<<< FEJL >>>>");
    forsinkelse (2000);
    gå til start; // gå til etiketten "start"
  }
}

/ ********* Udfør handlinger baseret på ThingSpeak-kommandoer ************* /
void takeActions (void)
{
  Serial.print ("Pumpe:");
  Serial.println (pumpe);
  Serial.print ("Lampe:");
  Serial.println (lampe);
  if (pumpe == 1) digitalWrite (ACTUATOR1, LOW);
  ellers digitalWrite (ACTUATOR1, HIGH);
  if (lampe == 1) digitalWrite (ACTUATOR2, LOW);
  andet digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Læs Actuators kommando fra ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int kommando;
  // Preparacao da streng GET
  String getStr = "GET / channel /";
  getStr + = channelID;
  getStr + = "/ felter / 1 / sidste";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    kommando = meddelelseDown [7] -48;
    Serial.print ("Kommando modtaget:");
    Serial.println (kommando);
  }
  andet kommando = 9;
  return kommando;
}

/ ********* Nulstil ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Nulstil .......");
  digitalWrite (HARDWARE_RESET, LOW);
  forsinkelse (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  forsinkelse (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Start kommunikation med ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  Streng 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:");
  Seriel.println (cmd);

  if (EspSerial.find ("Fejl"))
  {
    Serial.println ("AT + CIPSTART-fejl");
    vende tilbage;
  }
}

/ ********* send en GET cmd til ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  Streng cmd = "AT + CIPSEND =";
  cmd + = streng (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> længde cmd:");
  Seriel.println (cmd);

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

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktisk indhold starter efter tom linje (der har længde 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody modtaget:");
    Serial.println (messageBody);
    return messageBody;
  }
  andet
  {
    EspSerial.println ("AT + CIPCLOSE"); // alarm bruger
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Send igen ...
    reserve = reserve + 1;
    fejl = 1;
    returner "fejl";
  }
}

Du kan downloade den på

12 sende kommandoer til enheder

På dette trin har vi en konfigureret aktuatorkanal, der ændrer værdien af felt 1 for hver enhed. Vi skal verificere, at enhederne fungerer kommandoerne korrekt. I slutningen af projektet bruges en Android-applikation til dette, men det kan også gøres gennem en browser.

Tænd for pumpen (rød LED tændt)

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

Pumpe slukket (rød LED slukket)

https://api.thingspeak.com/update?api_key=Gemmet Channel_key_1 & felt1 = 0

Tænd lampen (grøn LED er tændt)

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

Sluk lampen (grøn LED slukket)

https://api.thingspeak.com/update?api_key=Besparet Channel_key_2 & felt1 = 0

14 Afslutning af Android-programmet

I den foregående del var der et simpelt program, der "læste" dataene fra kanalen og viste dem på skærmen. Nu er vi nødt til at gøre programmet til at "skrive" kommandoerne i Aktuator Channal, så disse kommandoer kan læses af controlleren og lampen med pumpen fungerer i overensstemmelse hermed.

Så at brugeren kan sende kommandoer, vil applikationen have to knapper til hver enhed. Hvis det er tændt, blåt; hvis det er slået fra, rødt.

Ved at klikke på knapperne i applikationen kan du se resultatet i Serial Monitor.

Koden kan downloades på

15 Afsluttende samling

På dette trin er der en fuldt udført Android-applikation, en fuldt samlet "jern" -del, men der er ingen kode i controlleren, der konstant ville læse data og sende kommandoer til skyen. Du skal bare kombinere alle fragmenter af koden, der er skrevet tidligere. Naturligvis har koden yderligere verificeringsmuligheder (f.eks. Hvis ESP-01 fryser). For at gøre dette, sendes en AT-kommando med jævne mellemrum før hver læse- eller skrivekommando.Og hvis svaret OK ikke kom fra modulet, genstartes modulet med programmering.

Den fulde projektkode kan downloades på

På adressen kan du få opdateringer til programfiler.

Du kan også læse kommentarer på linket til kilden, hvis noget ikke er klart.