Beheer van een kas of kas van overal ter wereld (uitvoeringsvoorbeeld)

Het doel van deze ontwikkeling is om gegevens te verzamelen van lokale sensoren, deze gegevens naar het internet te sturen. De gebruiker kan gegevens afkomstig van de sensoren overal ter wereld bekijken en op afstand een beslissing nemen over de activering van bepaalde actuatoren die lokaal naast de sensoren worden geplaatst

Het project maakt gebruik van Arduino UNO en WiFi-module ESP8266-01. Gegevens worden via de ThingSpeak.com-webservice naar de cloud verzonden en apparaten worden geactiveerd via de Android-applicatie die is ontwikkeld met de MIT AppInventor.





De belangrijkste focus van dit IoT-project zal de ThingSpeak.com-service zijn. Het lokale UNO / ESP-01-apparaat ontvangt gegevens van sensoren en gegevens over de status van actuatoren, stuurt het naar het internet "opname" via een specifiek ThingSpeak.com-statuskanaal (ThingSpeak.com-statuskanaal), hetzelfde lokale apparaat ontvangt gegevens, " ze te lezen vanaf een ander datakanaal - "het kanaal van uitvoerende apparaten" (ThingSpeak.com Actuator-kanalen).



Gegevens worden verzameld met behulp van een temperatuur- en relatieve vochtigheidssensor, bodemtemperatuur en vochtigheid en een omgevingslichtsensor. Deze gegevens worden naar de ThingSpeak-servicewolk gestuurd.

Er zullen twee uitvoerende apparaten zijn: dit is een elektrische waterpomp en een lamp. Hun AAN / UIT-status wordt ook naar de cloud gestuurd. Gegevens van sensoren kunnen bijvoorbeeld de huidige staat van een kas of kas weergeven. De gebruiker bestuurt de uitvoerende apparaten met behulp van de Android-applicatie.




Alle links zijn alleen voor informatieve doeleinden.






2 x LED's (rood en groen)
1 x
- $3.00
220V lamp
2 x 330 ohm weerstand (gebruikt met leds)
2 x 10K ohm-weerstand (gebruikt met DHT22 en LDR)
1 x 4K7 ohm-weerstand (gebruikt met DS18B20)
Broodplank
Truien
Externe voeding voor relais 5V DC



Nu moet je alle sensoren aansluiten, zoals weergegeven in het diagram.



De ideale oplossing zou zijn om het project in delen te monteren en te testen.

In de volgende volgorde:
1. Installeer en test alle sensoren
2.Installeer en configureer ESP-01 minimaal
3. Verander de ESP-01 setup naar de uiteindelijke configuratie en test
4. Configureer ThingSpeak Status Channel
5. Installeer ThingSpeak-code op Arduino en controleer de status van sensoren in de cloud
6. Ontwikkel de eerste versie van het programma op Android om statusberichten van sensoren te controleren
7. Installeer actuatoren
8. Configureer ThingSpeak Actuators-kanalen
9. Installeer en test code voor uitvoerende apparaten op Arduino
10. Maak de tweede versie van het programma op Android voor de volledige apparaatassemblage.



Het project maakt gebruik van enkele bibliotheken die zijn opgenomen in. Het is noodzakelijk om hun beschikbaarheid te controleren. De initiële configuratie van deze bibliotheken is als volgt:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 op pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int dirtTemp = 0;

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

// LDR (licht)
#define ldrPIN 1
int light = 0;

// Bodemvochtigheid
#define bodemHumPIN 0
int bodemHum = 0;

Nu initialiseren we onze sensoren en geven ze weer in de terminal:

ongeldige setup ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

leegte lus ()
{
  readSensors ();
  displaySensors ();
  vertraging (10000);
}

En tot slot schrijven we twee functies: de ene leest de metingen van de sensoren en de andere geeft ze weer op het scherm:

/ ********* Waarde van sensoren lezen ************* /
void readSensors (nietig)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  bodemTemp = DS18B20.getTempCByIndex (0); // Sensor 0 registreert de bodemtemperatuur in Celcius
  
  bodemHum = kaart (analogRead (bodemHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> licht 100%

}

/ ********* Weergavesensoren waarde ************* /
nietige weergave Sensoren (nietig)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("bodemTemp (oC):");
  Serial.println (bodemTemp);
  Serial.print ("dirtHum (%):");
  Serial.println (bodemHum);
  Serial.print ("light (%):");
  Serial.println (licht);
  Serial.println ("");
}

De foto laat zien hoe de gegevens op het scherm worden weergegeven.


Broncode kan worden gedownload van de auteur.



De snelste manier om met de module te "praten" is het AT-commando. De processor heeft al een AT-opdrachtprocessor. Standaard wordt de module geleverd met fabrieksinstellingen van 115200 baud, je moet 9600 baud instellen in de instellingen.

Eerst moet u de module aansluiten, zoals weergegeven op de foto



( Merk op dat de Tx-terminal van de ESP-01 is verbonden met de Tx-terminal van UNO, net zoals de Rx-terminals met elkaar zijn verbonden. Deze verbinding wordt later gewijzigd. ).

Verbind vervolgens UNO met de computer, open de IDE en download het voorbeeld dat zich bevindt. Dit is een lege code zodat er geen conflicten zijn tussen ESP-01 en UNO. Deze code is geüpload naar Ardunio voordat de ESP-01 erop werd aangesloten, om er zeker van te zijn dat Ardunio de Tx- en Rx-pinnen voor niets anders zal gebruiken.
Nu moet je de IDE Serial Monitor openen, de baudrate instellen op 115200 in de instellingen en het AT-commando naar de IDE Serial Monitor sturen. ESP-01 zou een antwoord OK moeten sturen

Nu moet u de gegevenssnelheid in de ESP-01-module wijzigen. Geef hiervoor de opdracht in de IDE

AT + CIOBAUD = 9600

Het kan voorkomen dat de ESP-01 terugkeert naar de fabrieksinstellingen, dan heeft u een ander commando nodig:

AT + UART_DEF = , , , , 

Bijvoorbeeld 9600 baud / 8 databits / 1 stopbits en geen pariteits- en stroomregeling

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

Verander nu de gegevensoverdrachtsnelheid in de IDE-instellingen naar 9600 en stuur het AT-commando, het OK-antwoord zou moeten komen.
Vervolgens moet u de module in STA-modus zetten, zodat deze verbinding kan maken met het toegangspunt van uw netwerk.

AT + CWMODE = 1

Voer de opdracht in om de module verbinding te laten maken met het netwerk AT + CWJAP = "netwerknaam", "netwerknaam_1"waar netwerknaam Is de naam van uw netwerk en netwerknaam_1 - wachtwoord voor uw netwerk (wachtwoord en netwerknaam moeten tussen aanhalingstekens staan)
Als je het antwoord ziet WIFI VERBONDEN WIFI HEEFT IP, dan wordt de verbinding tot stand gebracht. Controleer het IP-adres met de opdracht

AT + CIFSR

.

Het adres dat in uw monitor verschijnt, kunt u in de toekomst gebruiken. Nadat u de module heeft geconfigureerd, kunt u deze permanent aansluiten, maar hiervoor moet u het schakelcircuit wijzigen, zoals weergegeven in de afbeelding.


• ESP-01 RX (geel) -> UNO Pin D7
• ESP-01 TX (oranje) -> UNO Pin D6
• ESP-01 Ch-Pd (bruin) -> Vcc (3.3V)
• ESP-01 Reset (blauw) -> UNO Pin D8
• ESP-01 Vcc (rood) -> 3,3V
• ESP-01 GND (zwart) -> UNO GND

Merk op dat de Software Serial-bibliotheek de UNO Pin D7-pin gebruikt zoals tx en het maakt verbinding met de output van ESP-01 Rxterwijl UNO Pin D6 zoals rxaangesloten op ESP-01 TX.

Voer een kleine code in om de juiste aansluiting en configuratie van de ESP-01-module te controleren

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

#define speed8266 9600

ongeldige setup ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Setup-test - gebruik AT coomands");
}

leegte lus ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  terwijl (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Nu een paar AT-teams. Zie de resultaten in de seriële monitor.



* AT =====> ESP8266 geeft OK terug
* AT + RST =====> ESP8266 herstart en geeft OK terug
* AT + GMR =====> ESP8266 retourneert AT-versie; SDK-versie; id; Ok
* AT + CWMODE? => ESP8266 retourneert modustype
* AT + CWLAP ===> ESP8266 retourneert nauwe toegangspunten
* AT + CIFSR ===> ESP8266 retourneert designided IP

Programmacode kan worden gedownload op

6 aansluiting van sensoren en ESP-01

Nadat alle sensoren zijn aangesloten en gecontroleerd en de ESP-01-module is gecontroleerd, is het noodzakelijk om de gegevens voor te bereiden voor verzending naar internet.





Een van de belangrijkste onderdelen van het project is het open IoT-platform, waarmee u gegevens van sensoren kunt verzamelen, verwerken en analyseren. Ga hiervoor naar en maak uw account aan. Vervolgens moet u een kanaal maken met 2 actuatoren, 5 sensoren en één back-upveld.
• Veld 1: Actuator 1 (apparaat 1)
• Veld 2: Actuator 2 (apparaat 2)
• Veld 3: Luchttemperatuur in oC (luchttemperatuur in graden Celsius)
• Gearchiveerd 4: Relatieve luchtvochtigheid in% (relatieve vochtigheid in%)
• Veld 5: Bodemtemperatuur in oC (Bodemtemperatuur in gr. Celsius)
• Veld 6: bodemvochtigheid in% (bodemvocht in%)
• Veld 7: helderheid in% (verlichting in%)
• Veld 8: reserve

Veld 8 is gereserveerd voor toekomstige uitbreiding of voor foutopsporing. In dit project wordt het gebruikt als een communicatiefoutteller tussen Arduino / ESP-01 en ThingSpeak.com.

Nadat u het statuskanaal hebt gemaakt, moet u de sleutels opnemen, zoals weergegeven op de foto.



Momenteel hebben we een geconfigureerde clouddienst en verzamelen onze sensoren lokaal data. Nu moet u deze gegevens nemen en naar de cloud verzenden op ThingSpeak.com.

Om gegevens naar het ThingSpeak-kanaal te schrijven, moet u een GET-reeks verzenden. Dit gebeurt in drie fasen.
Stuur het commando "Start cmd"

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

Verdere snaarlengte

AT + CIPSEND = 116

En tot slot een GET-reeks die onze gegevens in de gereserveerde Status Channel-velden zal schrijven.

KRIJG / update? Api_key = uw_ opgeslagen_sleutel & veld1 = pomp & veldlamp = 0 & veld3 = airTemp & veld4 = airHum & veld5 = bodemTemp & veld6 = bodemHum & veld7 = licht & veld8 = reserve

Houd er rekening mee dat we niet meer dan 1 keer in 16 seconden gegevens naar het kanaal moeten schrijven.

De ingediende code doet dit allemaal.

// Thingspeak
String statusChWriteKey = "UW SCHRIJFSLEUTEL HIER"; // Statuskanaal-id: 385184

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

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 op pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int dirtTemp = 0;

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

// LDR (licht)
#define ldrPIN 1
int light = 0;

// Bodemvochtigheid
#define bodemHumPIN 0
int bodemHum = 0;

// Variabelen voor gebruik met timers
lang writeTimingSeconds = 17; // ==> Definieer sample tijd in seconden om gegevens te verzenden
lange startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variabelen voor gebruik met actuatoren
booleaanse pomp = 0;
booleaanse lamp = 0;

int spare = 0;
booleaanse fout;

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Reset doen Modulo WiFi
  startWriteTiming = millis (); // de "programmaklok" starten
}

leegte lus ()
{
  start: // label
  fout = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Opnieuw verzenden als verzending niet is voltooid
  {
    Serial.println ("<<<< FOUT >>>>");
    vertraging (2000);
    ga naar start; // ga naar label "start"
  }
}

/ ********* Waarde van sensoren lezen ************* /
void readSensors (nietig)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  bodemTemp = DS18B20.getTempCByIndex (0); // Sensor 0 registreert de bodemtemperatuur in Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> licht 100%
  bodemHum = kaart (analogRead (bodemHumPIN), 1023, 0, 0, 100);

}

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

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pomp);
  getStr + = "& field2 =";
  getStr + = String (lamp);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (bodemTemp);
  getStr + = "& field6 =";
  getStr + = String (bodemHum);
  getStr + = "& field7 =";
  getStr + = String (licht);
  getStr + = "& field8 =";
  getStr + = String (reserve);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Reset ESP ************* /
nietig EspHardwareReset (nietig)
{
  Serial.println ("Resetten .......");
  digitalWrite (HARDWARE_RESET, LOW);
  vertraging (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  vertraging (8000); // Tempo noodzakelijk voor para começar a ler
  Serial.println ("RESET");
}

/ ********* Start communicatie met ThingSpeak ************** /
nietig startThingSpeakCmd (nietig)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String 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-fout");
    terugkeer
  }
}

/ ********* stuur een GET cmd naar ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    terwijl (EspSerial.available ())
    {
      Tekenreeksregel = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// de daadwerkelijke inhoud begint na een lege regel (die lengte 1 heeft)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody ontvangen:");
    Serial.println (messageBody);
    messageBody retourneren;
  }
  anders
  {
    EspSerial.println ("AT + CIPCLOSE"); // alert gebruiker
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Opnieuw verzenden ...
    reserve = reserve + 1;
    fout = 1;
    "fout" retourneren;
  }
}

U kunt de voortgang zien in de seriële monitor.

Broncode kan worden gedownload op



Eerst moet je een gebruikersinterface maken. De afbeelding toont de belangrijkste zichtbare en onzichtbare elementen.



Daarna moet je blokken maken. Menu-items komen overeen met screenshotnummers.

1 Geef variabelen op die als globaal moeten worden gedeclareerd

2 Elke twee seconden (afhankelijk van Clock1) wordt een procedure aangeroepen "readArduino"


De procedure retourneert de waarde van de variabelen die op het scherm moeten worden weergegeven. In dit geval wordt de statuswaarde (0 en 1) voor actuatoren omgezet naar "AAN" en "UIT" voor een betere perceptie.

Deze waarden (Status) worden weergegeven in de bijbehorende "Snelkoppelingen"

3 De readArduino-routine leest in wezen het statuskanaal in ThingSpeak. U moet dus de URL bepalen die naar Thingspeak wordt verzonden. Om dit te doen, moeten 3 globale variabelen worden gedeclareerd en gecombineerd om de URL te creëren die naar ThingSpeak wordt gestuurd. GET moet worden verzonden naar een webcomponent genaamd "ArduFarmBotStatusCh"

4 Tekst ontvangen van de vorige opdracht komt aan in JSon-formaat. Deze tekst moet worden verwerkt zodat elk veld wordt gelezen en opgeslagen in de bijbehorende globale variabele.

5 Het laatste dat u moet doen, is de 'Alarm'-procedure oproepen, die de toestand van twee bodemsensoren analyseert. Als de temperatuur te laag is (in ons geval 10oC), moet er een bericht worden weergegeven. Hetzelfde geldt voor vocht als het lager is dan 60%.

Houd er rekening mee dat we een andere timer (Clock2) hebben gedefinieerd, geprogrammeerd om deze elke seconde te laten lopen. Het is alleen nodig om de kleur van de berichttekst te "wisselen" (van wit naar rood). Het bericht gaat knipperen.

Applicatiecode kan worden gedownload op




Commando's voor het in- en uitschakelen van de pomp en lamp worden op afstand ontvangen. De output van Ardunio zal het relais en de LED activeren, met deze opdrachten. De afbeelding laat zien hoe de actuatoren moeten worden aangesloten. Houd er rekening mee dat GND-relaisuitgang NIET AANGESLOTEN naar GND outputUNO. Op deze manier is er minder stroomstoring wanneer het relais loopt.




Alle acties herhalen de procedure voor het configureren van het statuskanaal. Voor elk apparaat moeten twee kanalen worden gemaakt. Schrijf voor elk kanaal de kanaal-ID, lees- en schrijftoetsen. We schrijven alleen in het eerste veld van elk kanaal. Bijvoorbeeld:
Kanaal-ID 375598 ==> LED rood (pomp)
◦ Veld1 = 0 ==> Pomp UIT
◦ Veld1 = 1 ==> Pomp AAN
2. Kanaal-ID 375599 ==> LED groen (lamp)
◦ Veld1 = 0 ==> Lamp UIT
◦ Veld1 = 1 ==> Lamp AAN



Toen we gegevens naar de cloud stuurden, 'schreven' we deze gegevens naar het ThingSpeak.Status-kanaal en 'verzenden' (uploaden) deze gegevens. Nu moeten we de gegevens van het Actuator-kanaal 'lezen' en deze gegevens 'accepteren' (downloaden).

Stuur hiervoor een GET-string en deze procedure bestaat uit 3 fasen.
'Start cmd'

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

Lijn lengte

AT + CIPSEND = 36

En de GET-string zelf

GET / kanalen / 375598 / velden / 1 / laatste

Kanalen worden elke 10 seconden "gelezen"

Na het verzenden van de GET moeten we de reactie van ThingSpeak accepteren. Het antwoord moet voor elk kanaal 0 of 1 zijn. Als er andere waarden zijn, negeren we ze gewoon.

Het belangrijkste verschil tussen dit onderdeel en het vorige zit alleen in de functie readThingSpeak (String channelID)
Hieronder vindt u de code die de beschreven acties uitvoert.

// Thingspeak
String canalID1 = "999999"; // Actuator 1
String canalID2 = "999999"; // Actuator 2

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

// Variabelen voor gebruik met timers
lang readTimingSeconds = 10; // ==> Definieer Sample tijd in seconden om gegevens te ontvangen
lange startReadTiming = 0;
lang verstrekenReadTime = 0;

// Relais
#define ACTUATOR1 10 // RODE LED ==> Pomp
#define ACTUATOR2 12 // GROENE LED ==> Lamp
booleaanse pomp = 0;
booleaanse lamp = 0;

int spare = 0;
booleaanse fout;

ongeldige setup ()
{
  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 (); // Reset doen Modulo WiFi
  startReadTiming = millis (); // de "programmaklok" starten
}

leegte lus ()
{
  start: // label
  fout = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int commando = readThingSpeak (canalID1);
    if (commando! = 9) pomp = commando;
    vertraging (5000);
    commando = readThingSpeak (canalID2);
    if (commando! = 9) lamp = commando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Opnieuw verzenden als verzending niet is voltooid
  {
    Serial.println ("<<<< FOUT >>>>");
    vertraging (2000);
    ga naar start; // ga naar label "start"
  }
}

/ ********* Acties ondernemen op basis van ThingSpeak-opdrachten ************* /
nietig takeActions (nietig)
{
  Serial.print ("Pump:");
  Serial.println (pomp);
  Serial.print ("Lamp:");
  Serial.println (lamp);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  anders digitalWrite (ACTUATOR1, HIGH);
  if (lamp == 1) digitalWrite (ACTUATOR2, LOW);
  anders digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Lees het commando Actuators van ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int commando;
  // preparacao da string GET
  String getStr = "GET / channels /";
  getStr + = channelID;
  getStr + = "/ velden / 1 / laatste";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Opdracht ontvangen:");
    Serial.println (opdracht);
  }
  anders commando = 9;
  commando teruggeven;
}

/ ********* Reset ESP ************* /
nietig EspHardwareReset (nietig)
{
  Serial.println ("Resetten .......");
  digitalWrite (HARDWARE_RESET, LOW);
  vertraging (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  vertraging (8000); // Tempo noodzakelijk voor para começar a ler
  Serial.println ("RESET");
}

/ ********* Start communicatie met ThingSpeak ************** /
nietig startThingSpeakCmd (nietig)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String 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-fout");
    terugkeer
  }
}

/ ********* stuur een GET cmd naar ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> lenght cmd:");
  Serial.println (cmd);

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

    String messageBody = "";
    terwijl (EspSerial.available ())
    {
      Tekenreeksregel = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// de daadwerkelijke inhoud begint na een lege regel (die lengte 1 heeft)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody ontvangen:");
    Serial.println (messageBody);
    messageBody retourneren;
  }
  anders
  {
    EspSerial.println ("AT + CIPCLOSE"); // alert gebruiker
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Opnieuw verzenden ...
    reserve = reserve + 1;
    fout = 1;
    "fout" retourneren;
  }
}

Je kunt het downloaden op



In dit stadium hebben we een geconfigureerd actuatorkanaal dat de waarde van veld 1 voor elk apparaat verandert. We moeten controleren of de apparaten de opdrachten correct uitvoeren. Aan het einde van het project wordt hiervoor een Android-applicatie gebruikt, maar dit kan ook via een browser.

Zet de pomp aan (rode LED aan)

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

Pomp uit (rode LED uit)

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

Zet de lamp aan (groene LED brandt)

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

Schakel de lamp uit (groene LED uit)

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

In het vorige deel was er een eenvoudig programma dat de gegevens van het kanaal "las" en op het scherm weergeeft. Nu moeten we het programma de commando's in Actuator Channal laten "schrijven", zodat deze commando's gelezen kunnen worden door de controller en de lamp met de pomp dienovereenkomstig werkte.

Om ervoor te zorgen dat de gebruiker opdrachten kan verzenden, heeft de applicatie twee knoppen voor elk apparaat. Indien ingeschakeld, blauw; indien uitgeschakeld, rood.

Door op de buttons in de applicatie te klikken, zie je het resultaat in de Serial Monitor.

De code kan worden gedownload op



In dit stadium is er een volledig voltooide Android-applicatie, een volledig geassembleerd hardwaregedeelte, maar er is geen code in de controller die constant de gegevens zou lezen en opdrachten naar de cloud zou sturen. U hoeft alleen maar alle fragmenten van de eerder geschreven code te combineren. Natuurlijk heeft de code aanvullende verificatie-opties (bijvoorbeeld als ESP-01 vastloopt). Om dit te doen, wordt periodiek voor elk lees- of schrijfcommando een AT-commando verzonden.En als het antwoord OK niet uit de module kwam, wordt de module programmatisch met geweld opnieuw opgestart.

De volledige projectcode is te downloaden op

Op het adres kun je updates krijgen voor programmabestanden.

Je kunt ook opmerkingen lezen over de link naar de bron, als er iets niet duidelijk is.