Styring av et drivhus eller drivhus fra hvor som helst i verden (eksempel på implementering)

Arduino / Drivhus og hotbeds

1 Enhetskonsept

Hensikten med denne utviklingen er å samle inn data fra lokale sensorer, sende disse dataene til Internett. Brukeren kan overalt i verden se dataene fra sensorene og eksternt kunne bestemme aktiveringen av visse aktuatorer som vil være lokalisert ved siden av sensorene.

Prosjektet bruker Arduino UNO og WiFi-modul ESP8266-01. Data vil bli overført til skyen gjennom ThingSpeak.com webtjeneste, og enheter vil bli aktivert gjennom android-applikasjonen utviklet ved hjelp av MIT AppInventor.

Styring av et drivhus eller drivhus fra hvor som helst i verden (eksempel på implementering)

IoT er et konsept for et datanettverk av fysiske objekter (“ting”) utstyrt med innebygde teknologier for interaksjon med hverandre eller med det ytre miljø, og vurderer organisering av slike nettverk som et fenomen som kan omstrukturere økonomiske og sosiale prosesser, og eliminere behovet for menneskelig deltakelse fra en del av handlinger og operasjoner.

Hovedfokuset for dette IoT-prosjektet vil være ThingSpeak.com-tjenesten. Den lokale UNO / ESP-01-enheten mottar data fra sensorer og data om statusen til aktuatorer, sender den til Internett "innspilling" gjennom en spesifikk ThingSpeak.com statuskanal (ThingSpeak.com Status Channel), den samme lokale enheten mottar data, " å lese dem fra en annen datakanal - "kanalen for utøvende enheter" (ThingSpeak.com Actuator Channels).

Data vil bli samlet inn ved hjelp av en sensor for temperatur og relativ fuktighet, jordtemperatur og luftfuktighet og en sensor for omgivelseslys. Disse dataene blir sendt til ThingSpeak-tjenesten skyen.

Det vil være to utøvende enheter - dette er en vannelektrisk pumpe og en lampe. Deres ON / OFF-status vil også bli sendt til skyen. Data fra sensorer, for eksempel, kan vise gjeldende tilstand for et drivhus eller drivhus. Brukeren vil kontrollere de utøvende enhetene ved hjelp av Android-applikasjonen.

2 Liste over nødvendige komponenter

Alle lenker er kun til informasjonsformål.

2 x lysdioder (rød og grønn)
1 x
- $3.00
220V lampe
2 x 330 ohm-motstand (brukt med lysdioder)
2 x 10K ohm-motstand (brukt med DHT22 og LDR)
1 x 4K7 ohm-motstand (brukt med DS18B20)
Labkort
jumpers
Ekstern strømforsyning for relé 5V DC

3 Jerndel

Nå må du koble til alle sensorene, som vist i diagrammet.

Den ideelle løsningen ville være å sette sammen og teste prosjektet i deler.

I følgende sekvens:
1. Installer og test alle sensorer
2.Installer og minimum konfigurer ESP-01
3. Endre ESP-01-oppsettet til den endelige konfigurasjonen og testen
4. Konfigurer ThingSpeak-statuskanal
5. Installer ThingSpeak-kode på Arduino og sjekk statusen til sensorer på skyen
6. Utvikle den første versjonen av programmet på Android for å sjekke statusmeldinger fra sensorer
7. Installer aktuatorer
8. Konfigurer ThingSpeak Actuators kanaler
9. Installer og test kode for utøvende enheter på Arduino
10. Lag den andre versjonen av programmet på Android for hele enhetssamlingen.

4 Sensortilkobling

Prosjektet bruker noen biblioteker som er inkludert i. Det er nødvendig å sjekke tilgjengeligheten. Den første konfigurasjonen av disse bibliotekene er som følger:

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

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

// LDR (lett)
#define ldrPIN 1
int lys = 0;

// Jordfuktighet
#definere jordHumPIN 0
intjordHum = 0;

Nå initialiserer vi sensorene våre og viser dem i terminalen:

ugyldig oppsett ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

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

Til slutt skriver vi to funksjoner: den ene leser avlesningene fra sensorene, og den andre viser dem på skjermen:

/ ********* Les sensors verdi ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperaturer ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 vil fange opp Jordtemperatur i Celcius
  
  jordHum = kart (analogRead (jordHumPIN), 1023, 0, 0, 100);
 
  lys = kart (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lys 100%

}

/ ********* Display sensors verdi ************* /
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 ("lett (%):");
  Serial.println (lett);
  Serial.println ("");
}

Bildet viser hvordan dataene vises på skjermen.

Kildekode kan lastes ned fra forfatteren.

4 ESP8266-01 grunnleggende konfigurasjon

Den raskeste måten å "snakke" med modulen er AT-kommandoen. Prosessoren har allerede en AT-kommandoprosessor. Som standard har modulen fabrikkinnstillinger på 115200 baud, du må angi 9600 baud i innstillingene.

For det første må du koble modulen, som vist på bildet

( Merk at Tx-terminalen til ESP-01 er koblet til Tx-terminalen til UNO, akkurat som Rx-terminalene er koblet til hverandre. Denne forbindelsen vil bli endret senere. ).

Koble deretter UNO til datamaskinen, åpne IDE og last ned eksemplet som er plassert. Dette er tom kode, slik at det ikke er konflikter mellom ESP-01 og UNO. Denne koden ble lastet opp til Ardunio før du koblet ESP-01 til den, for å være sikker på at Ardunio ikke vil bruke Tx- og Rx-pinnene til noe annet.
Nå må du åpne IDE Serial Monitor, sette baud rate til 115200 i innstillingene og sende AT-kommandoen til IDE Serial Monitor. ESP-01 skal sende svar OK

Nå må du endre datahastigheten i ESP-01-modulen. For å gjøre dette, gi IDE kommandoen i IDE

AT + CIOBAUD = 9600

Det kan hende at ESP-01 går tilbake til fabrikkinnstillingene, da må du bruke en annen kommando:

AT + UART_DEF = , , , ,

For eksempel 9600 baud / 8 databiter / 1 stoppbiter og ingen paritet og flytkontroll

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

Nå endrer du dataoverføringshastigheten i IDE-innstillingene til 9600 og sender AT-kommandoen, OK svaret skulle komme.
Deretter må du bytte modulen til STA-modus slik at den kan koble seg til tilgangspunktet til nettverket.

AT + CWMODE = 1

Angi kommandoen for at modulen skal koble seg til nettverket AT + CWJAP = "nettverksnavn", "nettverksnavn_1"hvor NETWORK_NAME Er navnet på nettverket ditt, og network_name_1 - passord for nettverket ditt (passord og nettverksnavn må være i anførselstegn)
Hvis du ser svaret WIFI-tilkoblet WIFI GOT IP, så blir forbindelsen opprettet. Bekreft IP-adressen med kommandoen

AT + CIFSR

.

Adressen som vises på skjermen din, kan du bruke i fremtiden. Når du har konfigurert modulen, kan du koble den til permanent, men for dette må du endre byttekretsen, 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 Reset (blå) -> UNO Pin D8
• ESP-01 Vcc (rød) -> 3.3V
• ESP-01 Gnd (svart) -> UNO GND

Merk at Software Serial-biblioteket bruker UNO Pin D7-pinnen som tx og den kobles til utgangen fra ESP-01 RXmens UNO Pin D6 som rxkoblet til ESP-01 TX.

Skriv inn en liten kode for å kontrollere riktig tilkobling og konfigurasjon av ESP-01-modulen

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

#definere hastighet8266 9600

ugyldig oppsett ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Setup test - bruk AT coomands");
}

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

Nå noen få AT-lag. Se resultatene i Serial Monitor.

* AT =====> ESP8266 returnerer OK
* AT + RST =====> ESP8266 start på nytt og returnerer OK
* AT + GMR =====> ESP8266 returnerer AT-versjon; SDK-versjon; id; OK
* AT + CWMODE? => ESP8266 returnerer modustype
* AT + CWLAP ===> ESP8266 returnerer nære tilgangspunkt
* AT + CIFSR ===> ESP8266 returnerer designid IP

Programkode kan lastes ned på

6 tilkobling av sensorer og ESP-01

Etter at alle sensorene er tilkoblet og sjekket, samt ESP-01-modulen er sjekket, er det nødvendig å forberede dataene for sending til Internett.

7 ThingSpeak

En av de viktigste delene av prosjektet er den åpne IoT-plattformen, som lar deg samle inn data fra sensorer, behandle og analysere dem. For å gjøre dette, gå til og opprett kontoen din. Deretter må du opprette en kanal der det vil være 2 aktuatorer, 5 sensorer og ett sikkerhetskopifelt.
• Felt 1: Aktuator 1 (enhet 1)
• Felt 2: Aktuator 2 (enhet 2)
• Felt 3: Lufttemperatur i oC (lufttemperatur i grader Celsius)
• Filed 4: Luftrelativ fuktighet i% (Relativ fuktighet i%)
• Felt 5: Jordtemperatur i oC (Jordtemperatur i gr. Celsius)
• Felt 6: Jordfuktighet i% (jordfuktighet i%)
• Felt 7: Lysstyrke i% (belysning i%)
• Felt 8: Reserve

Felt 8 er forbeholdt fremtidig utvidelse eller for feilsøking. I dette prosjektet brukes det som en kommunikasjonsfeil-teller mellom Arduino / ESP-01 og ThingSpeak.com.

Når du har opprettet statuskanalen, må du registrere tastene, som vist på bildet.

8 Sende sensorstatus til skyen

For øyeblikket har vi en konfigurert skytjeneste og sensorene våre samler inn data lokalt. Nå må du ta disse dataene og sende dem til skyen på ThingSpeak.com.

For å skrive data til ThingSpeak-kanalen, må du sende en GET-streng. Dette vil bli gjort i tre trinn.
Send kommandoen "Start cmd"

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

Ytterligere strenglengde

AT + CIPSEND = 116

Og til slutt, en GET-streng som vil skrive dataene våre i de reserverte statuskanalfeltene.

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

Vær oppmerksom på at vi ikke skal skrive data til kanalen mer enn 1 gang på 16 sekunder.

Den innsendte koden vil gjøre alt dette.

// Thingspeak
String statusChWriteKey = "DIN SKRIFTNøkkel HER"; // Statuskanal-ID: 385184

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

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

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

// LDR (lett)
#define ldrPIN 1
int lys = 0;

// Jordfuktighet
#definere jordHumPIN 0
intjordHum = 0;

// Variabler som skal brukes med tidtakere
lange writeTimingSeconds = 17; // ==> Definer eksempeltid i sekunder for å sende data
lang startWriteTiming = 0;
lang elapsedWriteTime = 0;

// Variabler som skal brukes med aktuatorer
boolsk pumpe = 0;
boolsk lampe = 0;

int spare = 0;
boolsk feil;

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Tilbakestill do Modulo WiFi
  startWriteTiming = millis (); // starte "programklokken"
}

void loop ()
{
  start: // label
  feil = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (skrivTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (feil == 1) // Send på nytt hvis overføringen ikke er fullført
  {
    Serial.println ("<<<< FEIL >>>>");
    forsinkelse (2000);
    skal starte; // gå til etiketten "start"
  }
}

/ ********* Les sensors verdi ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperaturer ();
  jordTemp = DS18B20.getTempCByIndex (0); // Sensor 0 vil fange opp Jordtemperatur i Celcius
             
  lys = kart (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> lys 100%
  jordHum = kart (analogRead (jordHumPIN), 1023, 0, 0, 100);

}

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

  startThingSpeakCmd ();

  // preparacao da streng GET
  String getStr = "FÅ / oppdater? 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 + = String (jordTemp);
  getStr + = "& felt6 =";
  getStr + = String (jordHum);
  getStr + = "& felt7 =";
  getStr + = String (lett);
  getStr + = "& felt8 =";
  getStr + = String (ekstra);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

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

/ ********* Start kommunikasjon 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:");
  Serial.println (cmd);

  if (EspSerial.find ("Feil"))
  {
    Serial.println ("AT + CIPSTART-feil");
    tilbake;
  }
}

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

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

    StrengmeldingBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktisk innhold starter etter tom linje (som har lengde 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody mottatt:");
    Serial.println (messageBody);
    returnere melding;
  }
  annet
  {
    EspSerial.println ("AT + CIPCLOSE"); // varsle bruker
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Send på nytt ...
    reserve = reserve + 1;
    feil = 1;
    returner "feil";
  }
}

Du kan se fremdriften i Serial Monitor.

Kildekode kan lastes ned kl

9 Android-app - del en

Først må du opprette et brukergrensesnitt. Bildet viser de viktigste synlige og usynlige elementene.

Etter det må du lage blokker. Menyelementer tilsvarer skjermdumpnumrene.

1 Angi variabler som bør deklareres som globale

2 Hvert andre sekund (avhengig av klokke1) kalles en prosedyre "ReadArduino"

Prosedyren returnerer verdien av variablene som skal vises på skjermen. I dette tilfellet konverteres tilstandsverdien (0 og 1) for aktuatorene til “ON” og “OFF” for bedre oppfatning.

Disse verdiene (Status) vil vises i de tilsvarende "Snarveier"

3 ReadArduino-rutinen vil i det vesentlige lese statuskanalen i ThingSpeak. Så du må bestemme nettadressen som skal sendes til Thingspeak. For å gjøre dette, må 3 globale variabler deklareres og kombineres for å opprette URL-adressen som vil bli sendt til ThingSpeak. GET skal sendes til en webkomponent som heter «ArduFarmBotStatusCh»

4 Tekst mottatt fra forrige kommando vil komme i JSon-format. Denne teksten må behandles slik at hvert felt blir lest og lagret i den tilsvarende globale variabelen.

5 Den siste tingen å gjøre er å kalle prosedyren “Alarm”, som vil analysere tilstanden til to jordføler. Hvis temperaturen er for lav (i vårt tilfelle 10oC), skal en melding vises. Det samme for fuktighet hvis det er under 60%.

Vær oppmerksom på at vi har definert en annen timer (Clock2), som er programmert til å kjøre den hvert sekund. Det er bare nødvendig å "bytte" fargen på meldingsteksten (fra hvit til rød). Meldingen blinker.

Søknadskode kan lastes ned kl

10 Tilkobling av aktuatorer

Kommandoer for å slå pumpen og lampen på og av vil bli mottatt eksternt. Ardunios utgang vil aktivere reléet og LED ved å ta disse kommandoene. Bildet viser hvordan aktuatorene skal kobles til. Vær oppmerksom på at GND reléutgang IKKE TILKOBLET til GND-utgangUNO. På denne måten blir det mindre strømforstyrrelser når reléet kjører.

11 konfigurasjon av kanalaktuatorer (Actuators Channels)

Alle handlinger gjentar prosedyren for konfigurering av statuskanalen. Det er nødvendig å lage to kanaler for hver av enhetene. Skriv kanal-ID-, lese- og skrive-tastene for hver kanal. Vi vil bare skrive i det første feltet av hver kanal. For et eksempel:
Channel ID 375598 ==> LED Red (Pump)
◦ Felt1 = 0 ==> Pumpe AV
◦ Felt1 = 1 ==> Pumpe PÅ
2. Kanal-ID 375599 ==> LED-grønn (lampe)
◦ Felt1 = 0 ==> Lampe AV
◦ Felt1 = 1 ==> Lampe PÅ

11 lasting og testing av kodeaktuatorer i Ardunio.

Da vi sendte data til skyen, "skrev vi" disse dataene til ThingSpeak. Statuskanal, "overfører" (laster opp) disse dataene. Nå må vi "lese" dataene fra aktuatorkanalen, "akseptere" (laste ned) disse dataene.

For å gjøre dette, send en GET-streng, og denne prosedyren består av tre trinn.
"Start cmd"

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

Linjelengde

PÅ + CIPSEND = 36

Og selve GET-strengen

GET / kanaler / 375598 / felt / 1 / sist

Kanaler blir "lest" hvert 10. sekund

Etter å ha sendt GET, må vi godta svaret fra ThingSpeak. Svaret må være 0 eller 1 for hver kanal. Hvis det er andre verdier, ignorerer vi dem ganske enkelt.

Hovedforskjellen mellom denne delen og den forrige er bare i funksjonen readThingSpeak (String channelID)
Nedenfor er koden som utfører de beskrevne handlingene.

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

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

// Variabler som skal brukes med tidtakere
lenge readTimingSeconds = 10; // ==> Definer eksempeltid i sekunder for å motta data
lang startReadTiming = 0;
lang forløptReadTime = 0;

// Reléer
#define ACTUATOR1 10 // RED LED ==> Pumpe
#define ACTUATOR2 12 // GRØNN LED ==> Lampe
boolsk pumpe = 0;
boolsk lampe = 0;

int spare = 0;
boolsk feil;

ugyldig oppsett ()
{
  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 (); // Tilbakestill do Modulo WiFi
  startReadTiming = millis (); // starte "programklokken"
}

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

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int kommando = readThingSpeak (canalID1);
    if (kommando! = 9) pumpe = kommando;
    forsinkelse (5000);
    kommando = readThingSpeak (canalID2);
    if (kommando! = 9) lampe = kommando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (feil == 1) // Send på nytt hvis overføringen ikke er fullført
  {
    Serial.println ("<<<< FEIL >>>>");
    forsinkelse (2000);
    skal starte; // gå til etiketten "start"
  }
}

/ ********* Gjør handlinger basert på ThingSpeak-kommandoer ************* /
void takeActions (ugyldig)
{
  Serial.print ("Pump:");
  Serial.println (pumpe);
  Serial.print ("Lampe:");
  Serial.println (lampe);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  annet digitalWrite (ACTUATOR1, HIGH);
  if (lampe == 1) digitalWrite (ACTUATOR2, LOW);
  annet digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Les Actuators kommando fra ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int kommando;
  // preparacao da streng GET
  String getStr = "GET / channel /";
  getStr + = channelID;
  getStr + = "/ felt / 1 / sist";
  getStr + = "\ r \ n";

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

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

/ ********* Start kommunikasjon 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:");
  Serial.println (cmd);

  if (EspSerial.find ("Feil"))
  {
    Serial.println ("AT + CIPSTART-feil");
    tilbake;
  }
}

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

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

    StrengmeldingBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// faktisk innhold starter etter tom linje (som har lengde 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody mottatt:");
    Serial.println (messageBody);
    returnere melding;
  }
  annet
  {
    EspSerial.println ("AT + CIPCLOSE"); // varsle bruker
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Send på nytt ...
    reserve = reserve + 1;
    feil = 1;
    returner "feil";
  }
}

Du kan laste den ned på

12 sende kommandoer til enheter

På dette stadiet har vi en konfigurert aktuatorkanal som endrer verdien til felt 1 for hver enhet. Vi må bekrefte at enhetene fungerer ordentlig. På slutten av prosjektet vil en Android-applikasjon brukes til dette, men det kan også gjøres gjennom en nettleser.

Slå på pumpen (rød LED på)

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

Pumpe av (rød LED av)

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

Slå på lampen (grønn LED lyser)

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

Slå av lampen (grønn LED av)

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

14 Avslutte Android-programmet

I forrige del var det et enkelt program som "leste" dataene fra kanalen og viste dem på skjermen. Nå må vi gjøre at programmet "skriver" kommandoene i aktuator Channal, slik at disse kommandoene kan leses av kontrolleren og lampen med pumpen fungerer deretter.

Slik at brukeren kan sende kommandoer, vil applikasjonen ha to knapper for hver enhet. Hvis den er slått på, blå; hvis den er slått av, rød.

Ved å klikke på knappene i applikasjonen, kan du se resultatet i Serial Monitor.

Koden kan lastes ned på

15 Sluttforsamling

På dette stadiet er det en fullstendig Android-applikasjon, en ferdig montert maskinvaredel, men det er ingen kode i kontrolleren som stadig vil lese dataene og sende kommandoer til skyen. Du trenger bare å kombinere alle fragmentene av koden som er skrevet tidligere. Selvfølgelig har koden flere bekreftelsesalternativer (for eksempel hvis ESP-01 fryser). For å gjøre dette, med jevne mellomrom, før hver lese- eller skrivekommando, sendes en AT-kommando.Og hvis svaret OK ikke kom fra modulen, startes modulen tvangsstyrt programmatisk.

Hele prosjektkoden kan lastes ned kl

På adressen kan du få oppdateringer for programfiler.

Du kan også lese kommentarer på lenken til kilden, hvis noe ikke er klart.