Verwaltung eines Gewächshauses oder Gewächshauses von überall auf der Welt (Implementierungsbeispiel)

Der Zweck dieser Entwicklung ist es, Daten von lokalen Sensoren zu sammeln und diese Daten an das Internet zu senden. Der Benutzer kann überall auf der Welt die von den Sensoren kommenden Daten anzeigen und aus der Ferne über die Aktivierung bestimmter Aktuatoren entscheiden, die sich lokal neben den Sensoren befinden

Das Projekt verwendet Arduino UNO- und WiFi-Modul ESP8266-01. Daten werden über den ThingSpeak.com-Webdienst in die Cloud übertragen, und Geräte werden über die mit dem MIT AppInventor entwickelte Android-Anwendung aktiviert.





Das Hauptaugenmerk dieses IoT-Projekts wird auf dem ThingSpeak.com-Dienst liegen. Das lokale UNO / ESP-01-Gerät empfängt Daten von Sensoren und Daten zum Status von Aktuatoren und sendet diese über einen bestimmten ThingSpeak.com-Statuskanal (ThingSpeak.com-Statuskanal) an das Internet. Das gleiche lokale Gerät empfängt Daten. " Lesen “von einem anderen Datenkanal - dem„ Kanal der ausführenden Geräte “(ThingSpeak.com Actuator Channels).



Die Daten werden mit einem Sensor für Temperatur und relative Luftfeuchtigkeit, Bodentemperatur und Luftfeuchtigkeit sowie einem Umgebungslichtsensor erfasst. Diese Daten werden an die ThingSpeak Service Cloud gesendet.

Es wird zwei Exekutivgeräte geben - dies ist eine elektrische Wasserpumpe und eine Lampe. Ihr EIN / AUS-Status wird ebenfalls an die Cloud gesendet. Daten von Sensoren können beispielsweise den aktuellen Zustand eines Gewächshauses oder Gewächshauses anzeigen. Der Benutzer steuert die ausführenden Geräte mithilfe der Android-Anwendung.




Alle Links dienen nur zu Informationszwecken.






2 x LEDs (rot und grün)
1 x
- $3.00
220V Lampe
2 x 330 Ohm Widerstand (wird mit LEDs verwendet)
2 x 10K Ohm Widerstand (verwendet mit DHT22 und LDR)
1 x 4K7 Ohm Widerstand (verwendet mit DS18B20)
Steckbrett
Jumper
Externe Stromversorgung für Relais 5V DC



Jetzt müssen Sie alle Sensoren anschließen, wie in der Abbildung gezeigt.



Die ideale Lösung wäre, das Projekt in Teilen zusammenzubauen und zu testen.

In der folgenden Reihenfolge:
1. Installieren und testen Sie alle Sensoren
2.Installieren und konfigurieren Sie ESP-01 mindestens
3. Ändern Sie das ESP-01-Setup in die endgültige Konfiguration und testen Sie es
4. Konfigurieren Sie den ThingSpeak-Statuskanal
5. Installieren Sie den ThingSpeak-Code auf Arduino und überprüfen Sie den Status der Sensoren in der Cloud
6. Entwickeln Sie die erste Version des Programms auf Android, um Statusmeldungen von Sensoren zu überprüfen
7. Aktuatoren einbauen
8. Konfigurieren Sie die Kanäle von ThingSpeak Actuators
9. Installieren und testen Sie den Code für Executive-Geräte auf Arduino
10. Erstellen Sie die zweite Version des Programms auf Android für die gesamte Gerätebaugruppe.



Das Projekt verwendet einige Bibliotheken, die in enthalten sind. Es ist notwendig, ihre Verfügbarkeit zu überprüfen. Die anfängliche Konfiguration dieser Bibliotheken lautet wie folgt:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 an Pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int groundTemp = 0;

// DHT
#include "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;

// Bodenfeuchtigkeit
#define groundHumPIN 0
int groundHum = 0;

Jetzt initialisieren wir unsere Sensoren und zeigen sie im Terminal an:

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

void loop ()
{
  readSensors ();
  displaySensors ();
  Verzögerung (10000);
}}

Und schließlich werden wir zwei Funktionen schreiben: Eine liest die Messwerte von den Sensoren und die andere zeigt sie auf dem Bildschirm an:

/ ********* Sensorwert lesen ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  BodenTemp = DS18B20.getTempCByIndex (0); // Sensor 0 erfasst die Bodentemperatur in Celcius
  
  BodenHum = Karte (analogRead (BodenHumPIN), 1023, 0, 0, 100);
 
  Licht = Karte (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> Licht 100%

}}

/ ********* Wert der Anzeigesensoren ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("groundTemp (oC):");
  Serial.println (groundTemp);
  Serial.print ("groundHum (%):");
  Serial.println (groundHum);
  Serial.print ("Licht (%):");
  Serial.println (Licht);
  Serial.println ("");
}}

Das Foto zeigt, wie die Daten auf dem Bildschirm angezeigt werden.


Der Quellcode kann vom Autor heruntergeladen werden.



Der schnellste Weg, um mit dem Modul zu "sprechen", ist der AT-Befehl. Der Prozessor verfügt bereits über einen AT-Befehlsprozessor. Standardmäßig verfügt das Modul über die Werkseinstellungen von 115200 Baud. In den Einstellungen müssen Sie 9600 Baud einstellen.

Zunächst müssen Sie das Modul wie auf dem Foto gezeigt anschließen



( Beachten Sie, dass der Tx-Anschluss des ESP-01 mit dem Tx-Anschluss von UNO verbunden ist, genau wie die Rx-Anschlüsse miteinander verbunden sind. Diese Verbindung wird später geändert. ).

Verbinden Sie dann UNO mit dem Computer, öffnen Sie die IDE und laden Sie das Beispiel herunter, das sich befindet. Dies ist ein leerer Code, damit keine Konflikte zwischen ESP-01 und UNO bestehen. Dieser Code wurde vor dem Anschließen des ESP-01 an Ardunio hochgeladen, um sicherzustellen, dass Ardunio die Tx- und Rx-Pins nicht für andere Zwecke verwendet.
Jetzt müssen Sie den IDE Serial Monitor öffnen, die Baudrate in den Einstellungen auf 115200 einstellen und den AT-Befehl an den IDE Serial Monitor senden. ESP-01 sollte eine Antwort OK senden

Jetzt müssen Sie die Datenrate im ESP-01-Modul ändern. Geben Sie dazu in der IDE den Befehl ein

AT + CIOBAUD = 9600

Es kann vorkommen, dass der ESP-01 zu den Werkseinstellungen zurückkehrt. Dann müssen Sie einen anderen Befehl verwenden:

AT + UART_DEF = , , , , 

Zum Beispiel 9600 Baud / 8 Datenbits / 1 Stoppbits und keine Paritäts- und Flusskontrolle

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

Ändern Sie nun die Datenübertragungsrate in den IDE-Einstellungen auf 9600 und senden Sie den AT-Befehl. Die Antwort OK sollte kommen.
Als Nächstes müssen Sie das Modul in den STA-Modus schalten, damit es eine Verbindung zum Access Point Ihres Netzwerks herstellen kann.

AT + CWMODE = 1

Geben Sie den Befehl ein, damit das Modul eine Verbindung zum Netzwerk herstellen kann AT + CWJAP = "Netzwerkname", "Netzwerkname_1"wo Netzwerkname Ist der Name Ihres Netzwerks und Netzwerkname_1 - Passwort für Ihr Netzwerk (Passwort und Netzwerkname müssen in Anführungszeichen stehen)
Wenn Sie die Antwort sehen WIFI CONNECTED WIFI GOT IPDann wird die Verbindung hergestellt. Überprüfen Sie die IP-Adresse mit dem Befehl

AT + CIFSR

.

Die Adresse, die auf Ihrem Monitor angezeigt wird, können Sie in Zukunft verwenden. Nachdem Sie das Modul konfiguriert haben, können Sie es dauerhaft anschließen. Dazu müssen Sie jedoch den Schaltkreis ändern, wie in der Abbildung gezeigt.


• ESP-01 RX (gelb) -> UNO Pin D7
• ESP-01 TX (orange) -> UNO Pin D6
• ESP-01 Ch-Pd (braun) -> Vcc (3,3 V)
• ESP-01 Reset (blau) -> UNO Pin D8
• ESP-01 Vcc (rot) -> 3,3 V.
• ESP-01 Gnd (Schwarz) -> UNO GND

Beachten Sie, dass die Software Serial Library den UNO Pin D7 Pin verwendet wie tx und es verbindet sich mit dem Ausgang von ESP-01 Rxwährend UNO Pin D6 wie rxangeschlossen an ESP-01 TX.

Geben Sie einen kleinen Code ein, um die korrekte Verbindung und Konfiguration des ESP-01-Moduls zu überprüfen

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

#define speed8266 9600

void setup ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266-Setup-Test - AT-Coomands verwenden");
}}

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

Nun ein paar AT-Teams. Siehe die Ergebnisse im seriellen Monitor.



* AT =====> ESP8266 gibt OK zurück
* AT + RST =====> ESP8266 neu starten und OK zurückgeben
* AT + GMR =====> ESP8266 gibt die AT-Version zurück; SDK-Version; id; Ok
* AT + CWMODE? => ESP8266 gibt den Modustyp zurück
* AT + CWLAP ===> ESP8266 gibt geschlossene Zugriffspunkte zurück
* AT + CIFSR ===> ESP8266 gibt die designierte IP zurück

Der Programmcode kann unter heruntergeladen werden

6 Anschluss von Sensoren und ESP-01

Nachdem alle Sensoren angeschlossen und überprüft wurden und das ESP-01-Modul überprüft wurde, müssen die Daten für das Senden an das Internet vorbereitet werden.





Einer der wichtigsten Teile des Projekts ist die offene IoT-Plattform, mit der Sie Daten von Sensoren sammeln, verarbeiten und analysieren können. Gehen Sie dazu zu und erstellen Sie Ihr Konto. Als nächstes müssen Sie einen Kanal erstellen, in dem sich 2 Aktoren, 5 Sensoren und ein Sicherungsfeld befinden.
• Feld 1: Aktor 1 (Gerät 1)
• Feld 2: Aktor 2 (Gerät 2)
• Feld 3: Lufttemperatur in oC (Lufttemperatur in Grad Celsius)
• Abgelegt 4: Relative Luftfeuchtigkeit in% (Relative Luftfeuchtigkeit in%)
• Feld 5: Bodentemperatur in oC (Bodentemperatur in gr. Celsius)
• Feld 6: Bodenfeuchtigkeit in% (Bodenfeuchtigkeit in%)
• Feld 7: Leuchtkraft in% (Beleuchtung in%)
• Feld 8: Ersatz

Feld 8 ist für zukünftige Erweiterungen oder zum Debuggen reserviert. In diesem Projekt wird es als Kommunikationsfehlerzähler zwischen Arduino / ESP-01 und ThingSpeak.com verwendet.

Nachdem Sie den Statuskanal erstellt haben, müssen Sie die Schlüssel wie auf dem Foto gezeigt aufzeichnen.



Derzeit haben wir einen konfigurierten Cloud-Service und unsere Sensoren erfassen Daten lokal. Jetzt müssen Sie diese Daten nehmen und auf ThingSpeak.com an die Cloud senden.

Um Daten in den ThingSpeak-Kanal zu schreiben, müssen Sie eine GET-Zeichenfolge senden. Dies erfolgt in drei Schritten.
Senden Sie den Befehl "Start cmd"

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

Weitere Saitenlänge

AT + CIPSEND = 116

Und schließlich eine GET-Zeichenfolge, die unsere Daten in die reservierten Statuskanalfelder schreibt.

ERHALTEN / aktualisieren?

Bitte beachten Sie, dass wir in 16 Sekunden nicht mehr als einmal Daten in den Kanal schreiben sollten.

Der übermittelte Code erledigt dies alles.

// Dingspeak
String statusChWriteKey = "IHR SCHREIBSCHLÜSSEL HIER"; // Status Channel ID: 385184

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

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 an Pin D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTemperature DS18B20 (& oneWire);
int groundTemp = 0;

// DHT
#include "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;

// Bodenfeuchtigkeit
#define groundHumPIN 0
int groundHum = 0;

// Variablen, die mit Timern verwendet werden sollen
long writeTimingSeconds = 17; // ==> Definieren Sie die Abtastzeit in Sekunden, um Daten zu senden
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variablen, die mit Aktoren verwendet werden sollen
Boolesche Pumpe = 0;
Boolesche Lampe = 0;

int spare = 0;
Boolescher Fehler;

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

  EspSerial.begin (9600); // Comunicacao com Modulo WiFi
  EspHardwareReset (); // Modulo WiFi zurücksetzen
  startWriteTiming = millis (); // Starten der "Programmuhr"
}}

void loop ()
{
  start: // label
  Fehler = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }}
  
  if (error == 1) // Erneut senden, wenn die Übertragung nicht abgeschlossen ist
  {
    Serial.println ("<<<< ERROR >>>>");
    Verzögerung (2000);
    gehe los; // gehe zum Label "start"
  }}
}}

/ ********* Sensorwert lesen ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  BodenTemp = DS18B20.getTempCByIndex (0); // Sensor 0 erfasst die Bodentemperatur in Celcius
             
  Licht = Karte (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> Licht 100%
  BodenHum = Karte (analogRead (BodenHumPIN), 1023, 0, 0, 100);

}}

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

  startThingSpeakCmd ();

  // prepareacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (Pumpe);
  getStr + = "& field2 =";
  getStr + = String (Lampe);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (groundTemp);
  getStr + = "& field6 =";
  getStr + = String (groundHum);
  getStr + = "& field7 =";
  getStr + = String (hell);
  getStr + = "& field8 =";
  getStr + = String (Ersatz);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}}

/ ********* ESP zurücksetzen ************* /
void EspHardwareReset (void)
{
  Serial.println ("Zurücksetzen .......");
  digitalWrite (HARDWARE_RESET, LOW);
  Verzögerung (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo notwendig für ein Kind
  Serial.println ("RESET");
}}

/ ********* Starten Sie die Kommunikation mit ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  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 ("Fehler"))
  {
    Serial.println ("AT + CIPSTART-Fehler");
    zurück
  }}
}}

/ ********* Sende ein GET cmd an ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Länge 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 est delay apresenta beschäftigt no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// Der eigentliche Inhalt beginnt nach einer leeren Zeile (mit der Länge 1).
        messageBody = EspSerial.readStringUntil ('\ n');
      }}
    }}
    Serial.print ("MessageBody empfangen:");
    Serial.println (messageBody);
    return messageBody;
  }}
  sonst
  {
    EspSerial.println ("AT + CIPCLOSE"); // Benutzer benachrichtigen
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Erneut senden ...
    Spare = Spare + 1;
    Fehler = 1;
    return "error";
  }}
}}

Sie können den Fortschritt im seriellen Monitor sehen.

Der Quellcode kann unter heruntergeladen werden



Zuerst müssen Sie eine Benutzeroberfläche erstellen. Das Bild zeigt die wichtigsten sichtbaren und unsichtbaren Elemente.



Danach müssen Sie Blöcke erstellen. Menüpunkte entsprechen den Screenshotnummern.

1 Zustandsvariablen, die als global deklariert werden sollen

2 Alle zwei Sekunden (abhängig von Clock1) wird eine Prozedur aufgerufen "readArduino"


Die Prozedur gibt den Wert der Variablen zurück, die auf dem Bildschirm angezeigt werden sollen. In diesem Fall wird der Zustandswert (0 und 1) für die Aktuatoren zur besseren Wahrnehmung in "EIN" und "AUS" umgewandelt.

Diese Werte (Status) werden in den entsprechenden „Verknüpfungen“ angezeigt.

3 Die readArduino-Routine liest im Wesentlichen den Statuskanal in ThingSpeak. Sie müssen also die URL bestimmen, die an Thingspeak gesendet wird. Dazu müssen 3 globale Variablen deklariert und kombiniert werden, um die URL zu erstellen, die an ThingSpeak gesendet wird. GET sollte an eine Webkomponente namens gesendet werden "ArduFarmBotStatusCh"

4 Der vom vorherigen Befehl empfangene Text kommt im JSon-Format an. Dieser Text muss verarbeitet werden, damit jedes Feld gelesen und in der entsprechenden globalen Variablen gespeichert wird.

5 Als letztes müssen Sie das Alarmverfahren aufrufen, mit dem der Zustand von zwei Bodensensoren analysiert wird. Wenn die Temperatur zu niedrig ist (in unserem Fall 10 ° C), sollte eine Meldung angezeigt werden. Gleiches gilt für Feuchtigkeit, wenn sie unter 60% liegt.

Bitte beachten Sie, dass wir einen anderen Timer (Clock2) definiert haben, der so programmiert ist, dass er jede Sekunde ausgeführt wird. Es ist nur erforderlich, die Farbe des Nachrichtentextes (von weiß nach rot) zu "wechseln". Die Nachricht blinkt.

Der Anwendungscode kann unter heruntergeladen werden




Befehle zum Ein- und Ausschalten der Pumpe und der Lampe werden aus der Ferne empfangen. Der Ausgang von Ardunio aktiviert das Relais und die LED und nimmt diese Befehle entgegen. Das Bild zeigt, wie die Aktuatoren angeschlossen werden sollen. Bitte beachten Sie, dass GND Relais Ausgang NICHT VERBUNDEN zum GND-AusgangUNO. Auf diese Weise treten bei laufendem Relais weniger Stromstörungen auf.




Alle Aktionen wiederholen den Vorgang zum Konfigurieren des Statuskanals. Für jedes Gerät müssen zwei Kanäle erstellt werden. Schreiben Sie für jeden Kanal die Kanal-ID-, Lese- und Schreibtasten. Wir werden nur in das erste Feld jedes Kanals schreiben. Beispielsweise:
Kanal ID 375598 ==> LED rot (Pumpe)
◦ Feld1 = 0 ==> Pumpe AUS
◦ Feld1 = 1 ==> Pumpe EIN
2. Kanal ID 375599 ==> LED grün (Lampe)
◦ Feld1 = 0 ==> Lampe AUS
◦ Feld1 = 1 ==> Lampe EIN



Wenn wir Daten in die Cloud gesendet haben, haben wir diese Daten in den ThingSpeak. Status-Kanal „geschrieben“ und diese Daten „übertragen“ (hochgeladen). Jetzt müssen wir die Daten vom Aktorkanal „lesen“ und diese Daten „akzeptieren“ (herunterladen).

Senden Sie dazu eine GET-Zeichenfolge. Diese Prozedur besteht aus 3 Schritten.
"Start cmd"

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

Zeilenlänge

AT + CIPSEND = 36

Und der GET-String selbst

GET / channel / 375598 / fields / 1 / last

Die Kanäle werden alle 10 Sekunden "gelesen"

Nach dem Senden des GET müssen wir die Antwort von ThingSpeak akzeptieren. Die Antwort muss für jeden Kanal entweder 0 oder 1 sein. Wenn es andere Werte gibt, ignorieren wir sie einfach.

Der Hauptunterschied zwischen diesem und dem vorherigen Teil liegt nur in der Funktion readThingSpeak (String channelID)
Unten finden Sie den Code, der die beschriebenen Aktionen ausführt.

// Dingspeak
String canalID1 = "999999"; // Aktor1
String canalID2 = "999999"; // Aktor2

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

// Variablen, die mit Timern verwendet werden sollen
long readTimingSeconds = 10; // ==> Definieren Sie die Abtastzeit in Sekunden, um Daten zu empfangen
long startReadTiming = 0;
long elapsedReadTime = 0;

// Relais
#define ACTUATOR1 10 // ROTE LED ==> Pumpe
#define ACTUATOR2 12 // GRÜNE LED ==> Lampe
Boolesche Pumpe = 0;
Boolesche Lampe = 0;

int spare = 0;
Boolescher Fehler;

void 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 (); // Modulo WiFi zurücksetzen
  startReadTiming = millis (); // Starten der "Programmuhr"
}}

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

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    int command = readThingSpeak (canalID1);
    if (Befehl! = 9) pump = Befehl;
    Verzögerung (5000);
    command = readThingSpeak (canalID2);
    if (Befehl! = 9) Lampe = Befehl;
    takeActions ();
    startReadTiming = millis ();
  }}
  
  if (error == 1) // Erneut senden, wenn die Übertragung nicht abgeschlossen ist
  {
    Serial.println ("<<<< ERROR >>>>");
    Verzögerung (2000);
    gehe los; // gehe zum Label "start"
  }}
}}

/ ********* Ergreifen Sie Aktionen basierend auf ThingSpeak-Befehlen ************* /
void takeActions (void)
{
  Serial.print ("Pump:");
  Serial.println (Pumpe);
  Serial.print ("Lamp:");
  Serial.println (Lampe);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  sonst digitalWrite (ACTUATOR1, HIGH);
  if (Lampe == 1) digitalWrite (ACTUATOR2, LOW);
  sonst digitalWrite (ACTUATOR2, HIGH);
}}

/ ********* Lesen Sie den Befehl Actuators von ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  int Befehl;
  // prepareacao da string GET
  String getStr = "GET / canal /";
  getStr + = channelID;
  getStr + = "/ fields / 1 / last";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Befehl erhalten:");
    Serial.println (Befehl);
  }}
  sonst Befehl = 9;
  Rückgabebefehl;
}}

/ ********* ESP zurücksetzen ************* /
void EspHardwareReset (void)
{
  Serial.println ("Zurücksetzen .......");
  digitalWrite (HARDWARE_RESET, LOW);
  Verzögerung (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo notwendig für ein Kind
  Serial.println ("RESET");
}}

/ ********* Starten Sie die Kommunikation mit ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  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 ("Fehler"))
  {
    Serial.println ("AT + CIPSTART-Fehler");
    zurück
  }}
}}

/ ********* Sende ein GET cmd an ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Länge 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 est delay apresenta beschäftigt no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      String line = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// Der eigentliche Inhalt beginnt nach einer leeren Zeile (mit der Länge 1).
        messageBody = EspSerial.readStringUntil ('\ n');
      }}
    }}
    Serial.print ("MessageBody empfangen:");
    Serial.println (messageBody);
    return messageBody;
  }}
  sonst
  {
    EspSerial.println ("AT + CIPCLOSE"); // Benutzer benachrichtigen
    Serial.println ("ESP8266 CIPSEND ERROR: RESENDING"); // Erneut senden ...
    Spare = Spare + 1;
    Fehler = 1;
    return "error";
  }}
}}

Sie können es unter herunterladen



Zu diesem Zeitpunkt haben wir einen konfigurierten Aktorkanal, der den Wert von Feld 1 für jedes Gerät ändert. Wir müssen überprüfen, ob die Geräte die Befehle ordnungsgemäß ausführen. Am Ende des Projekts wird hierfür eine Android-Anwendung verwendet, die aber auch über einen Browser ausgeführt werden kann.

Schalten Sie die Pumpe ein (rote LED leuchtet)

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

Abpumpen (rote LED aus)

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

Schalten Sie die Lampe ein (grüne LED leuchtet)

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

Schalten Sie die Lampe aus (grüne LED aus)

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

Im vorherigen Teil gab es ein einfaches Programm, das die Daten aus dem Kanal „las“ und auf dem Bildschirm anzeigte. Jetzt müssen wir das Programm dazu bringen, die Befehle in Actuator Channal zu „schreiben“, damit diese Befehle von der Steuerung gelesen werden können und die Lampe mit der Pumpe entsprechend funktioniert.

Damit der Benutzer Befehle senden kann, verfügt die Anwendung über zwei Schaltflächen für jedes Gerät. Wenn eingeschaltet, blau, wenn ausgeschaltet, rot.

Durch Klicken auf die Schaltflächen in der Anwendung können Sie das Ergebnis im seriellen Monitor anzeigen.

Der Code kann unter heruntergeladen werden



Zu diesem Zeitpunkt gibt es eine vollständig ausgefüllte Android-Anwendung, ein vollständig zusammengebautes "Eisen" -Teil, aber es gibt keinen Code in der Steuerung, der die Daten ständig lesen und Befehle an die Cloud senden würde. Sie müssen nur alle Fragmente des zuvor geschriebenen Codes kombinieren. Natürlich verfügt der Code über zusätzliche Überprüfungsoptionen (z. B. wenn ESP-01 einfriert). Zu diesem Zweck wird regelmäßig vor jedem Lese- oder Schreibbefehl ein AT-Befehl gesendet.Und wenn die Antwort OK nicht vom Modul kam, wird das Modul zwangsweise programmgesteuert neu gestartet.

Der vollständige Projektcode kann unter heruntergeladen werden

Unter der Adresse erhalten Sie Updates für Programmdateien.

Sie können auch Kommentare zum Link zur Quelle lesen, wenn etwas nicht klar ist.