Gestion d'une serre ou d'une serre de n'importe où dans le monde (exemple de mise en œuvre)

Le but de ce développement est de collecter des données à partir de capteurs locaux, d'envoyer ces données sur Internet. L'utilisateur pourra visualiser partout dans le monde les données provenant des capteurs et décider à distance de l'activation de certains actionneurs qui seront localisés localement, à côté des capteurs

Le projet utilise Arduino Module UNO et WiFi ESP8266-01. Les données seront transmises au cloud via le service Web ThingSpeak.com et les appareils seront activés via l'application Android développée à l'aide de MIT AppInventor.





L'objectif principal de ce projet IoT sera le service ThingSpeak.com. L'appareil UNO / ESP-01 local reçoit des données des capteurs et des données sur l'état des actionneurs, les envoie à Internet «enregistrant» via un canal d'état ThingSpeak.com spécifique (ThingSpeak.com Status Channel), le même appareil local reçoit des données ». en les lisant à partir d'un autre canal de données, «le canal des appareils exécutifs» (ThingSpeak.com Actuator Channels).



Les données seront collectées à l'aide d'un capteur de température et d'humidité relative, de la température et de l'humidité du sol et d'un capteur de lumière ambiante. Ces données seront envoyées au cloud du service ThingSpeak.

Il y aura deux appareils exécutifs - c'est une pompe électrique à eau et une lampe. Leur état ON / OFF sera également envoyé au cloud. Les données des capteurs, par exemple, peuvent afficher l'état actuel d'une serre ou d'une serre. L'utilisateur contrôlera les appareils exécutifs à l'aide de l'application Android.




Tous les liens sont à titre informatif uniquement.






2 x LED (rouge et verte)
1 x
- $3.00
Lampe 220V
Résistance 2 x 330 ohms (utilisée avec les LED)
Résistance 2 x 10K ohms (utilisée avec DHT22 et LDR)
1 x résistance 4K7 ohm (utilisée avec DS18B20)
Planche à pain
Cavaliers
Alimentation externe pour relais 5V DC



Vous devez maintenant connecter tous les capteurs, comme indiqué sur le schéma.



La solution idéale serait d'assembler et de tester le projet en plusieurs parties.

Dans l'ordre suivant:
1. Installez et testez tous les capteurs
2.Installer et configurer au minimum ESP-01
3. Modifiez la configuration ESP-01 pour la configuration finale et testez
4. Configurer le canal d'état ThingSpeak
5. Installez le code ThingSpeak sur Arduino et vérifiez l'état des capteurs sur le cloud
6. Développer la première version du programme sur Android pour vérifier les messages d'état des capteurs
7. Installer des actionneurs
8. Configurer les canaux des actionneurs ThingSpeak
9. Installer et tester le code pour les appareils exécutifs sur Arduino
10. Créez la deuxième version du programme sur Android pour l'ensemble de l'appareil.



Le projet utilise certaines bibliothèques incluses dans. Il est nécessaire de vérifier leur disponibilité. La configuration initiale de ces bibliothèques est la suivante:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 sur la broche D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTempérature DS18B20 (& oneWire);
int solTemp = 0;

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

// LDR (léger)
#define ldrPIN 1
int light = 0;

// Humidité du sol
# définir le sol HumPIN 0
int solHum = 0;

Maintenant, nous initialisons nos capteurs et les affichons dans le terminal:

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

boucle vide ()
{
  readSensors ();
  displaySensors ();
  retard (10000);
}

Et enfin, nous allons écrire deux fonctions: l'une lit les lectures des capteurs, et l'autre les affiche à l'écran:

/ ********* Valeur des capteurs de lecture ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  solTemp = DS18B20.getTempCByIndex (0); // Le capteur 0 capturera la température du sol en Celcius
  
  solHum = carte (analogRead (solHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> léger 100%

}

/ ********* Valeur des capteurs d'affichage ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("soilTemp (oC):");
  Serial.println (soilTemp);
  Serial.print ("solHum (%):");
  Serial.println (solHum);
  Serial.print ("light (%):");
  Serial.println (light);
  Serial.println ("");
}

La photo montre comment les données sont affichées à l'écran.


Le code source peut être téléchargé auprès de l'auteur.



Le moyen le plus rapide de "parler" avec le module est la commande AT. Le processeur possède déjà un processeur de commande AT. Par défaut, le module est livré avec des paramètres d'usine de 115200 bauds, vous devez définir 9600 bauds dans les paramètres.

Tout d'abord, vous devez connecter le module, comme indiqué sur la photo



( Notez que la borne Tx de l'ESP-01 est connectée à la borne Tx de UNO, tout comme les bornes Rx sont connectées entre elles. Cette connexion sera modifiée ultérieurement. ).

Connectez ensuite UNO à l'ordinateur, ouvrez l'IDE et téléchargez l'exemple qui se trouve. Il s'agit d'un code vide afin qu'il n'y ait aucun conflit entre ESP-01 et UNO. Ce code a été téléchargé sur Ardunio avant d'y connecter l'ESP-01, afin d'être sûr qu'Ardunio n'utilisera pas les broches Tx et Rx pour autre chose.
Vous devez maintenant ouvrir le moniteur série IDE, définir le débit en bauds à 115200 dans les paramètres et envoyer la commande AT au moniteur série IDE. ESP-01 devrait envoyer une réponse OK

Vous devez maintenant modifier le débit de données dans le module ESP-01. Pour ce faire, dans l'EDI, donnez la commande

AT + CIOBAUD = 9600

Il peut arriver que l'ESP-01 revienne aux réglages d'usine, alors vous devrez utiliser une autre commande:

AT + UART_DEF = , , , , 

Par exemple 9600 bauds / 8 bits de données / 1 bits d'arrêt et aucune parité et contrôle de flux

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

Maintenant, changez le taux de transfert de données dans les paramètres IDE à 9600 et envoyez la commande AT, la réponse OK devrait venir.
Ensuite, vous devez basculer le module en mode STA afin qu'il puisse se connecter au point d'accès de votre réseau.

AT + CWMODE = 1

Pour que le module se connecte au réseau, entrez la commande AT + CWJAP = "nom_réseau", "nom_réseau_1"où nom_réseau Est le nom de votre réseau, et nom_réseau_1 - mot de passe pour votre réseau (le mot de passe et le nom du réseau doivent être entre guillemets)
Si vous voyez la réponse WIFI CONNECTÉ WIFI GOT IP, alors la connexion est établie. Vérifiez l'adresse IP avec la commande

AT + CIFSR

.

L'adresse qui apparaît sur votre moniteur, vous pourrez l'utiliser à l'avenir. Une fois que vous avez configuré le module, vous pouvez le connecter en permanence, mais pour cela, vous devez changer son circuit de commutation, comme indiqué sur la figure.


• ESP-01 RX (jaune) -> UNO Pin D7
• ESP-01 TX (Orange) -> UNO Pin D6
• ESP-01 Ch-Pd (marron) -> Vcc (3,3 V)
• Réinitialisation ESP-01 (bleu) -> UNO Pin D8
• ESP-01 Vcc (rouge) -> 3,3 V
• ESP-01 Gnd (Noir) -> UNO GND

Notez que la bibliothèque Software Serial utilise la broche UNO Pin D7 comme tx et il se connecte à la sortie de ESP-01 Rxtandis que UNO Pin D6 comme rxconnecté à ESP-01 TX.

Entrez un petit code afin de vérifier la connexion et la configuration correctes du module ESP-01

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

#define speed8266 9600

void setup ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("Test de configuration ESP8266 - utiliser les co-mandats AT");
}

boucle vide ()
{
  tout (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Maintenant quelques équipes AT. Voir les résultats dans le moniteur série.



* AT =====> ESP8266 renvoie OK
* AT + RST =====> ESP8266 redémarrage et retourne OK
* AT + GMR =====> ESP8266 renvoie la version AT; Version du SDK; id; Ok
* AT + CWMODE? => ESP8266 renvoie le type de mode
* AT + CWLAP ===> ESP8266 renvoie des points d'accès proches
* AT + CIFSR ===> ESP8266 renvoie l'IP désigné

Le code du programme peut être téléchargé sur

6 connexion de capteurs et ESP-01

Une fois tous les capteurs connectés et vérifiés, ainsi que le module ESP-01 vérifié, il est nécessaire de préparer les données pour l'envoi sur Internet.





L'une des parties les plus importantes du projet est la plate-forme ouverte IoT, qui vous permettra de collecter des données à partir de capteurs, de les traiter et de les analyser. Pour ce faire, accédez à et créez votre compte. Ensuite, vous devez créer un canal où il y aura 2 actionneurs, 5 capteurs et un champ de sauvegarde.
• Champ 1: actionneur 1 (appareil 1)
• Champ 2: actionneur 2 (appareil 2)
• Champ 3: Température de l'air en oC (température de l'air en degrés Celsius)
• Classé 4: Humidité relative de l'air en% (humidité relative en%)
• Champ 5: Température du sol en oC (Température du sol en gr. Celsius)
• Champ 6: Humidité du sol en% (humidité du sol en%)
• Champ 7: Luminosité en% (illumination en%)
• Champ 8: Rechange

Le champ 8 est réservé pour une expansion future ou pour le débogage. Dans ce projet, il est utilisé comme compteur d'erreurs de communication entre Arduino / ESP-01 et ThingSpeak.com.

Une fois que vous avez créé le canal d'état, vous devez enregistrer les clés, comme indiqué sur la photo.



Pour le moment, nous avons un service cloud configuré et nos capteurs collectent des données localement. Vous devez maintenant prendre ces données et les envoyer au cloud sur ThingSpeak.com.

Afin d'écrire des données sur le canal ThingSpeak, vous devez envoyer une chaîne GET. Cela se fera en trois étapes.
Envoyez la commande "Start cmd"

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

Longueur de chaîne supplémentaire

AT + CIPSEND = 116

Et enfin, une chaîne GET qui écrira nos données dans les champs réservés du canal d'état.

OBTENIR / mettre à jour? Api_key = your_saved_key_here & field1 = pump & fieldlamp = 0 & field3 = airTemp & field4 = airHum & field5 = solTemp & field6 = solHum & field7 = light & field8 = rechange

Veuillez noter que nous ne devons pas écrire de données sur le canal plus d'une fois en 16 secondes.

Le code soumis fera tout cela.

// Thingspeak
String statusChWriteKey = "VOTRE CLÉ D'ÉCRITURE ICI"; // ID du canal d'état: 385184

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

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 sur la broche D5
OneWire oneWire (ONE_WIRE_BUS);
DallasTempérature DS18B20 (& oneWire);
int solTemp = 0;

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

// LDR (léger)
#define ldrPIN 1
int light = 0;

// Humidité du sol
# définir le sol HumPIN 0
int solHum = 0;

// Variables à utiliser avec les temporisateurs
long writeTimingSeconds = 17; // ==> Définissez le temps d'échantillonnage en secondes pour envoyer des données
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variables à utiliser avec les actionneurs
pompe booléenne = 0;
lampe booléenne = 0;

int spare = 0;
erreur booléenne;

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 (); // Réinitialiser do Modulo WiFi
  startWriteTiming = millis (); // démarrage de "l'horloge du programme"
}

boucle vide ()
{
  start: // label
  erreur = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (erreur == 1) // Renvoyer si la transmission n'est pas terminée
  {
    Serial.println ("<<<< ERROR >>>>");
    retard (2000);
    goto start; // aller à l'étiquette "start"
  }
}

/ ********* Valeur des capteurs de lecture ************* /
void readSensors (void)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  solTemp = DS18B20.getTempCByIndex (0); // Le capteur 0 capturera la température du sol en Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> léger 100%
  solHum = carte (analogRead (solHumPIN), 1023, 0, 0, 100);

}

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

  startThingSpeakCmd ();

  // preparacao da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& field1 =";
  getStr + = String (pompe);
  getStr + = "& field2 =";
  getStr + = String (lampe);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (soilTemp);
  getStr + = "& field6 =";
  getStr + = String (solHum);
  getStr + = "& field7 =";
  getStr + = String (light);
  getStr + = "& field8 =";
  getStr + = String (rechange);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Réinitialiser ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Réinitialisation .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retard (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  délai (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Commencez la communication avec 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 ==> Démarrer cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Erreur"))
  {
    Serial.println ("erreur AT + CIPSTART");
    retour
  }
}

/ ********* envoyer un cmd GET à ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> longueur 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 occupé no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Ligne de chaîne = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// le contenu réel commence après une ligne vide (qui a une longueur 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody reçu:");
    Serial.println (messageBody);
    return messageBody;
  }
  d'autre
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerte l'utilisateur
    Serial.println ("ESP8266 ERREUR CIPSEND: RENVOI"); // Renvoyer ...
    rechange = rechange + 1;
    erreur = 1;
    retourner "erreur";
  }
}

Vous pouvez voir la progression dans le moniteur série.

Le code source peut être téléchargé sur



Vous devez d'abord créer une interface utilisateur. L'image montre les principaux éléments visibles et invisibles.



Après cela, vous devez créer des blocs. Les éléments du menu correspondent aux numéros de capture d'écran.

1 Variables d'état qui doivent être déclarées comme globales

2 Toutes les deux secondes (selon Clock1) une procédure est appelée "readArduino"


La procédure renvoie la valeur des variables qui doivent être affichées à l'écran. Dans ce cas, la valeur d'état (0 et 1) des actionneurs est convertie en «ON» et «OFF» pour une meilleure perception.

Ces valeurs (Statut) seront affichées dans les «Raccourcis» correspondants

3 La routine readArduino lira essentiellement le canal d'état dans ThingSpeak. Vous devez donc déterminer l'URL qui sera envoyée à Thingspeak. Pour ce faire, 3 variables globales doivent être déclarées et combinées pour créer l'URL qui sera envoyée à ThingSpeak. GET doit être envoyé à un composant Web appelé "ArduFarmBotStatusCh"

4 Le texte reçu de la commande précédente arrivera au format JSon. Ce texte doit être traité pour que chaque champ soit lu et stocké dans la variable globale correspondante.

5 La dernière chose à faire est d'appeler la procédure «Alarme», qui analysera l'état de deux capteurs de sol. Si la température est trop basse (dans notre cas 10oC), un message devrait s'afficher. Idem pour l'humidité si elle est inférieure à 60%.

Veuillez noter que nous avons défini un autre temporisateur (Clock2), programmé pour qu'il s'exécute chaque seconde. Il suffit de "changer" la couleur du texte du message (du blanc au rouge). Le message clignote.

Le code d'application peut être téléchargé sur




Les commandes pour allumer et éteindre la pompe et la lampe seront reçues à distance. La sortie d'Ardunio activera le relais et la LED, en prenant ces commandes. L'image montre comment les actionneurs doivent être connectés. Veuillez noter que la sortie relais GND NON CONNECTÉ à la sortie GNDUNO. De cette façon, il y aura moins d'interférences de puissance lorsque le relais est en marche.




Toutes les actions répètent la procédure de configuration du canal d'état. Il est nécessaire de créer deux canaux pour chacun des appareils. Pour chaque canal, écrivez l'ID de canal, les touches de lecture et d'écriture. Nous n'écrirons que dans le premier champ de chaque canal. Pour un exemple:
ID de canal 375598 ==> LED rouge (pompe)
◦ Champ1 = 0 ==> Pompe arrêtée
◦ Champ1 = 1 ==> Pompe ON
2. ID de canal 375599 ==> LED verte (lampe)
◦ Champ1 = 0 ==> Lampe éteinte
◦ Champ1 = 1 ==> Lampe allumée



Lorsque nous avons envoyé des données vers le cloud, nous avons «écrit» ces données sur le canal d'état de ThingSpeak, «transmettant» (téléchargeant) ces données. Nous devons maintenant «lire» les données du canal de l'actionneur, «accepter» (télécharger) ces données.

Pour ce faire, envoyez une chaîne GET et cette procédure se compose de 3 étapes.
"Démarrer cmd"

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

Longueur de ligne

AT + CIPSEND = 36

Et la chaîne GET elle-même

GET / canaux / 375598 / champs / 1 / dernier

Les chaînes seront «lues» toutes les 10 secondes

Après avoir envoyé le GET, nous devons accepter la réponse de ThingSpeak. La réponse doit être 0 ou 1, pour chaque canal. S'il existe d'autres valeurs, nous les ignorons simplement.

La principale différence entre cette partie et la précédente réside uniquement dans la fonction readThingSpeak (String channelID)
Voici le code qui effectue les actions décrites.

// Thingspeak
String canalID1 = "999999"; // Actuator1
String canalID2 = "999999"; // Actuator2

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

// Variables à utiliser avec les temporisateurs
long readTimingSeconds = 10; // ==> Définissez le temps d'échantillonnage en secondes pour recevoir des données
long startReadTiming = 0;
long elapsedReadTime = 0;

// Relais
#define ACTUATOR1 10 // LED ROUGE ==> Pompe
#define ACTUATOR2 12 // LED VERTE ==> Lampe
pompe booléenne = 0;
lampe booléenne = 0;

int spare = 0;
erreur booléenne;

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 (); // Réinitialiser do Modulo WiFi
  startReadTiming = millis (); // démarrage de "l'horloge du programme"
}

boucle vide ()
{
  start: // label
  erreur = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    commande int = readThingSpeak (canalID1);
    if (commande! = 9) pompe = commande;
    retard (5000);
    command = readThingSpeak (canalID2);
    if (command! = 9) lamp = command;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (erreur == 1) // Renvoyer si la transmission n'est pas terminée
  {
    Serial.println ("<<<< ERROR >>>>");
    retard (2000);
    goto start; // aller à l'étiquette "start"
  }
}

/ ********* Prenez des mesures basées sur les commandes ThingSpeak ************* /
void takeActions (nul)
{
  Serial.print ("Pompe:");
  Serial.println (pompe);
  Serial.print ("Lampe:");
  Serial.println (lampe);
  if (pump == 1) digitalWrite (ACTUATOR1, LOW);
  sinon digitalWrite (ACTUATOR1, HIGH);
  if (lampe == 1) digitalWrite (ACTUATOR2, LOW);
  sinon digitalWrite (ACTUATOR2, HIGH);
}

/ ********* Lire la commande Actuators de ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  commande int;
  // preparacao da string GET
  String getStr = "GET / canaux /";
  getStr + = channelID;
  getStr + = "/ champs / 1 / dernier";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    command = messageDown [7] -48;
    Serial.print ("Commande reçue:");
    Serial.println (commande);
  }
  sinon, commande = 9;
  commande de retour;
}

/ ********* Réinitialiser ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Réinitialisation .......");
  digitalWrite (HARDWARE_RESET, LOW);
  retard (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  délai (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Commencez la communication avec 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 ==> Démarrer cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Erreur"))
  {
    Serial.println ("erreur AT + CIPSTART");
    retour
  }
}

/ ********* envoyer un cmd GET à ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> longueur 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 occupé no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Ligne de chaîne = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// le contenu réel commence après une ligne vide (qui a une longueur 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody reçu:");
    Serial.println (messageBody);
    return messageBody;
  }
  d'autre
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerte l'utilisateur
    Serial.println ("ESP8266 ERREUR CIPSEND: RENVOI"); // Renvoyer ...
    rechange = rechange + 1;
    erreur = 1;
    retourner "erreur";
  }
}

Vous pouvez le télécharger sur



À ce stade, nous avons un canal d'actionneur configuré qui change la valeur du champ 1 pour chaque appareil. Nous devons vérifier que les appareils exécutent correctement les commandes. À la fin du projet, une application Android sera utilisée pour cela, mais cela peut également se faire via un navigateur.

Allumez la pompe (LED rouge allumée)

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

Pompe éteinte (LED rouge éteinte)

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

Allumez la lampe (la LED verte est allumée)

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

Éteignez la lampe (LED verte éteinte)

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

Dans la partie précédente, il y avait un programme simple qui «lisait» les données du canal et les affichait à l'écran. Nous devons maintenant faire en sorte que le programme «écrive» les commandes dans Actuator Channal, afin que ces commandes puissent être lues par le contrôleur et que la lampe avec la pompe fonctionne en conséquence.

Pour que l'utilisateur puisse envoyer des commandes, l'application aura deux boutons pour chaque appareil. S'il est allumé, bleu; s'il est éteint, rouge.

En cliquant sur les boutons de l'application, vous pouvez voir le résultat dans le moniteur série.

Le code peut être téléchargé sur



À ce stade, il existe une application Android entièrement terminée, une partie «fer» entièrement assemblée, mais il n'y a pas de code dans le contrôleur qui lirait constamment des données et enverrait des commandes au cloud. Il vous suffit de combiner tous les fragments du code écrit précédemment. Bien sûr, le code a des options de vérification supplémentaires (par exemple, si ESP-01 se fige). Pour ce faire, périodiquement, avant chaque commande de lecture ou d'écriture, une commande AT est envoyée.Et si la réponse OK ne vient pas du module, le module est redémarré de force par programme.

Le code de projet complet peut être téléchargé sur

À l'adresse, vous pouvez obtenir des mises à jour pour les fichiers de programme.

Vous pouvez également lire les commentaires sur le lien vers la source, si quelque chose n'est pas clair.