ESP8266-01 Notification

Bonjour,

Je suis en train de réaliser un projet en utilisant un Arduino EELEGO MEGA 2560 R3 et un ESP8266-01. Afin de mener à bien mon projet j'ai réalisé quelques tests afin de mieux comprendre l'environnement que j'utilise, mais après pas mal de test je ne sais plus quoi faire.
J'aimerai dans un premier temps allumer une LED grâce à mon Arduino MEGA grâce à un bouton poussoir, dès lors que cette LED est allumé, je voudrais qu'elle envoie un message à l'ESP qui lit le message et agis en conséquence.
Si la LED est éteinte, rien ne se passe,
Si la LED est allumé, je voudrai que l'ESP envoi une notification sur mon smartphone grâce à l'application Blynk.
Ensuite si possible j'aimerai contrôler cette LED avec un bouton sur l'application Blynk.

J'ai déjà paramétré mon ESP-01 pour qu'il se connecte à ma livebox et à l'application blynk grace au token fournit mais je n'arrive pas à recevoir de notification sur mon application.
Je ne comprends pas bien comment l'ESP peut lire l'information que je lui envoi depuis l'arduino et avec quelle fonction.

Pouvez vous m'aider à résoudre mon problème,

Merci beaucoup,

cocog59

Tu peux utiliser une ligne série.
Il te faut

  • deux broches GPIO libres sur l'Arduino
  • un petit circuit qui adapte les tensions (5V pour Arduino, 3,3V pour ESP)
  • la bibliothèque SofwareSerial pour piloter la ligne côté Arduino, ce qui implique un débit "modéré" sur la ligne série.
    [Edit]
    Rectification tu as une carte MEGA, qui possède déjà plusieurs ligne séries intégrées. Il te faut quand même le circuit adaptateur de tension.

Bonjour

Sur ce forum on trouve plus d'utilisateurs des ESP8266 ou ESP32 seuls, sans carte Arduino !!
C'est plus simple, pratique et offre davantage de possibilitités.
Mais parfois arrivent des demandes pour 'ajouter du WiFi' à une réalisation à base d carte Arduino classique.

Pour la connection matérielle entre un ESP-01 et une carte Arduino voici un des schémas souvent proposés :
arduinoplusESP-01.png
Source : site Blynk , http://help.blynk.cc/en/articles/605485-esp8266-with-at-firmware

Code : deux voies selon que l'ESP-01 possède le firmware de commandes AT ou qu'il est flashé avec un code perso.

+Voir ce tutoriel de J-M-L pour des éléments de gestion de l'ESP-01 par des commandes AT
https://forum.arduino.cc/index.php?topic=501923.0

arduinoplusESP-01.png

biggil:
Tu peux utiliser une ligne série.
Il te faut

  • deux broches GPIO libres sur l'Arduino
  • un petit circuit qui adapte les tensions (5V pour Arduino, 3,3V pour ESP)
  • la bibliothèque SofwareSerial pour piloter la ligne côté Arduino, ce qui implique un débit "modéré" sur la ligne série.
    [Edit]
    Rectification tu as une carte MEGA, qui possède déjà plusieurs ligne séries intégrées. Il te faut quand même le circuit adaptateur de tension.

Merci pour ta réponse,
Oui, j'utilise une alimentation séparé que je peux moduler en 3.3V ou 5V,
J'utilise aussi la bibliothèque SoftwareSerial sur les pin 10 et 11 pour piloter la ligne, cependant je ne comprends pas, lorsque l'information arrive a mon esp, comment il peut m'envoyer la notification sur mon smartphone vu que sur le programme de l'esp je ne peux pas utiliser la fonction digitalRead() parce que je connais pas le numéro des pins de l'ESP. (C'est ma réflexion ^^)
Voici le code que j'utilise sur l'Arduino:

#include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11); 
int ledPin = 5;
int buttonApin = 9;
int buttonBpin = 8;

//byte leds = 0;

void setup() 
{
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(ledPin, OUTPUT);
  pinMode(buttonApin, INPUT_PULLUP);  
  pinMode(buttonBpin, INPUT_PULLUP);  
}

void loop() 
{
  if (digitalRead(buttonApin) == LOW)
  {
    digitalWrite(ledPin, HIGH);
    mySerial.write("c");
  }
  if (digitalRead(buttonBpin) == LOW)
  {
    digitalWrite(ledPin, LOW);
  }
  
}

Et voici le code je j'ai mis sur l'ESP :

#define BLYNK_PRINT Serial

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "****************";

// Your WiFi credentials.
// Set password to "" for open networks.
char ssid[] = "SFR-****";
char pass[] = "************";


String val;

void setup()
{
  // Debug console
  
   Serial.begin(115200);
   pinMode(0, OUTPUT);
   pinMode(2, INPUT);

  Blynk.begin(auth, ssid, pass);
  // You can also specify server:
  //Blynk.begin(auth, ssid, pass, "blynk-cloud.com", 80);
  //Blynk.begin(auth, ssid, pass, IPAddress(192,168,1,100), 8080);
delay(2000);
}

void loop()
{
  Blynk.run();
  val = digitalRead(2);
  if (val=="c") {
    Blynk.notify("Hey, Blynkers! Mon matériel peut push désormais !");
     }
}

Niveau branchement
ESP Arduino

  • VCC et RST branchés au 3.3V
  • GRD sur GRD
  • GPIO 0 sur la pin 11
  • GPIO 2 sur la pin 10

al1fch:
Bonjour

Sur ce forum on trouve plus d'utilisateurs des ESP8266 ou ESP32 seuls, sans carte Arduino !!
C'est plus simple, pratique et offre davantage de possibilitités.
Mais parfois arrivent des demandes pour 'ajouter du WiFi' à une réalisation à base d carte Arduino classique.

Pour la connection matérielle entre un ESP-01 et une carte Arduino voici un des schémas souvent proposés :

Merci pour ta réponse,
Oui j'imagine que c'est plus facile d'utiliser un ESP seul et de le configurer mais j'ai un projet plus complexe derrière qui demande d'utiliser pas mal de pin de l'arduino, c'est pour ça que je voulais ajouter un module wifi sur celle ci.
J'ai déjà effectué ce schéma et cela ne change pas mon problème ^^

Tout au début lorsque j'essayais de comprendre comment utiliser l'esp, j'ai utilisé ces lignes de code afin d'initialiser mon ESP :

#include <SoftwareSerial.h>

SoftwareSerial ESP8266(10, 11);

String NomduReseauWifi = "*********"; // Garder les guillements
String MotDePasse      = "***********"; // Garder les guillements

/****************************************************************/
/*                             INIT                             */
/****************************************************************/
void setup()
{
  Serial.begin(115200);
  ESP8266.begin(115200);  
  initESP8266();
}
/****************************************************************/
/*                        BOUCLE INFINIE                        */
/****************************************************************/
void loop()
{
   while(ESP8266.available())
   {    
     Serial.println(ESP8266.readString());
   }   
}
/****************************************************************/
/*                Fonction qui initialise l'ESP8266             */
/****************************************************************/
void initESP8266()
{  
  Serial.println("**********************************************************");  
  Serial.println("**************** DEBUT DE L'INITIALISATION ***************");
  Serial.println("**********************************************************");  
  envoieAuESP8266("AT+RST");
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  envoieAuESP8266("AT+CWMODE=3");
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  envoieAuESP8266("AT+CWJAP=\""+ NomduReseauWifi + "\",\"" + MotDePasse +"\"");
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  envoieAuESP8266("AT+CIFSR");
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  envoieAuESP8266("AT+CIPMUX=1");   
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  envoieAuESP8266("AT+CIPSERVER=1,80");
  recoitDuESP8266(10000);
  Serial.println("**********************************************************");
  Serial.println("***************** INITIALISATION TERMINEE ****************");
  Serial.println("**********************************************************");
  Serial.println("");  
}

/****************************************************************/
/*        Fonction qui envoie une commande à l'ESP8266          */
/****************************************************************/
void envoieAuESP8266(String commande)
{  
  ESP8266.println(commande);
}
/****************************************************************/
/*Fonction qui lit et affiche les messages envoyés par l'ESP8266*/
/****************************************************************/
void recoitDuESP8266(const int timeout)
{
  String reponse = "";
  long int time = millis();
  while( (time+timeout) > millis())
  {
    while(ESP8266.available())
    {
      char c = ESP8266.read();
      reponse+=c;
    }
  }
  Serial.print(reponse);   
}

Ces lignes m'ont permis d'activer le wifi et de connecter l'esp à ma box.
Par contre quand j'envoyais directement des commandes AT dans le moniteur série, cela ne renvoyait rien, mais vu que cela a finit par fonctionner avec le code ci-dessus, j'ai finit par me dire que c'est exactement la même chose.
Merci pour le tutoriel concernant l'utilisation de l'ESP suivant les commande AT mais j'aimerai vraiment incorporer mon propre code dans l'ESP.

Avec une carte Mega qui possède plusieurs ports série matériels pourquoi utiliser SoftwareSerial, qui de plus ne fonctionne pas très bien a 115200 bauds ?

(Pour gérer un grand nombre d'E/S il est possible d'ajouter un extenseur I2C a une carte ESP32 déjà bien pourvue., idem pour des cartes type NodeMCU ou D1 Mini)

Il y a encore quelques utilisateurs d'ESP-01 en commandes AT sur ce forum.Ils pourront au besoin aider. Pour moi ça remonte aux tout début 2015 et j'ai totalement oublié cette façon de faire et abandonné les ESP-01.

al1fch:
Avec une carte Mega qui possède plusieurs ports série matériels pourquoi utiliser SoftwareSerial, qui de plus ne fonctionne pas très bien a 115200 bauds ?

(Pour gérer un grand nombre d'E/S il est possible d'ajouter un extenseur I2C a une carte ESP32 déjà bien pourvue., idem pour des cartes type NodeMCU ou D1 Mini)

Il y a encore quelques utilisateurs d'ESP-01 en commandes AT sur ce forum.Ils pourront au besoin aider. Pour moi ça remonte aux tout début 2015 et j'ai totalement oublié cette façon de faire et abandonné les ESP-01.

C'est vrai que je pourrais utiliser les RX et TX déjà présent matériellement sur la carte mais je ne sais pas trop m'en servir, je vais essayer de les utiliser.
Vraiment, je pense, pour moi ce qu'il me manque actuellement c'est quelque chose (une fonction, ...) que je téléverserai sur l'esp qui me permettra de lire les valeurs que j'envoi à l'esp et d'agir en conséquence (un peu comme digitalRead(pin), que j'aimerai bien utiliser mais je ne connais pas le numéro des pin de l'esp et je sais pas s'il est possible de faire comme ça)

Merci quand même pour ton aide

les Rx et TX de la carte ESP-01 , sous firmware AT, servent au dialogue des commandes es AT et aussi a l'émission par l'ESP-01 des données demandées sur Internet. Du point de vue des fonctionnalités de l'ESP-01 on est limité à celles fournies dans la liste des commandes AT

En abandonnant le firmware AT il est possible de coder ce que l'on veut dans l'ESP-01 grâce à l'ID Arduino (dans la limite de la mémoire disponible) et en utilsiant la plus part des librairies disponibles.

Il est alors possible d'imaginer le protocole de son choix entre carte Arduino classique et ESP-01
C'est la double page blanche avec codage sous Arduino des deux côtés !

Ah d'accord je comprends,

Mais du coup lorsque je veux lire l'information sur le pin RX de l'ESP ou le pin GPIO0, comment je peux coder ça?
Car dans l'arduino si je veux récupérer l'information sur le pin 5 par exemple j'ai juste a écrire DigitalRead(5)
Mais dans l'esp je ne sais pas comment sont définit les pins. Est-ce que le pin GPIO0 est définit comme le pin 0, le RX comme le pin 1, etc ?

Oui, ils ont définis comme cela.
Dans une programmation de l'ESP-01 sous IDE Arduino on utilise par exemple :
digitalRead(n) pour lire l'état du GPIOn
GPIO ESP01.png

GPIO ESP01.png

Ah ok d'accord je comprends mieux, je vais essayer de faire un code suivant ces explications, merci beaucoup.

J'ai une autre question ^^:
DigitalRead ne permet que lire l'état donc soit HIGH soit LOW, comment pourrait-on envoyer un caractère à l'ESP, pas exemple le caractère "A" et qu'il lise bien "A"? Existe t'il une fonction qui permet ça ?

Pour exploiter une ligne série, tu n'utilises pas directemnt les valeurs lues sur une broche. C'est possible mais complexe.
Tu utilises une objet Serial.
Le même qui te permet, sur l'Arduino, de discuter avec le moniteur série.
Donc, sur l'ESP:

void setup ()
{
  Serial.begin (115200);
  .../...
}

void loop ()
{
  .../...
  if ( Serial.availaible() > 0 ) {
    char c = Serial.read();
   // ou autre méthode pour lire plusieurs caractères...
  .../...
  }
}

Côté émetteur, c'est pareil. Sur le Mega tu as Serial1, Serial2...

Merci beaucoup pour votre aide, j'ai enfin réussi a obtenir une réponse de mon ESP lorsque j'envoi une information à partir de l'arduino. J'ai utilisé le code que biggil m'a fournit et ça a fonctionné.

Par contre je n'ai aucune réaction de l'ESP lorsque j'utilise des digitalRead() sur le pin RX de l'ESP (que j'ai définit comme étant le pin 1 grâce a

int RX = 1;
pinMode(1, INPUT);

).
Pourtant j'ai bien branché les broches RX sur TX et TX sur RX pourtant et je ne comprends pas pourquoi ^^

comme je te l'ai dit, tu n'utilises pas digitalRead(), ni pinMode() sur les broches RX et TX (si tant est que tu les utilises pour la ligne série). Tu déclares un objet Serial et tu le laisse tripoter ces broches.
Ton message n'est pas clair : tu dis que ça marche, mais que ça ne marche pas.
Envoie le code complet côté ESP please.

Une borne multifonction comme Tx/gpio1 ne peut pas tout faire a la fois. A la mise sous tension elle est connectée a l'Uart et devient Tx. Pour l'utiliser en tant que gpio1 il faut au préalable la déconnecter de l'Uart

pinMode(1, FUNCTION_3)

Pour Rx/gpio3
pinnMode(3, FUNCTION_3)

Mais pourquoi délaisser Rx s'il s'agit de faire entrer un octet comme dit plus haut ?

biggil:
comme je te l'ai dit, tu n'utilises pas digitalRead(), ni pinMode() sur les broches RX et TX (si tant est que tu les utilises pour la ligne série). Tu déclares un objet Serial et tu le laisse tripoter ces broches.
Ton message n'est pas clair : tu dis que ça marche, mais que ça ne marche pas.
Envoie le code complet côté ESP please.

Ok d'accord j'avais mal compris ta phrase,
Alors oui, ça fonctionne en utilisant la méthode que tu m'as fournis, mais ça ne fonctionne pas en utilisant la méthode digitalRead et pinmode sur les broches TX et RX
Voici mon code

#define BLYNK_PRINT Serial

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

char auth[] = "************";
char ssid[] = "******";
char pass[] = "***********";

void setup()
{
  // Debug console
  
   pinMode(3, OUTPUT); //inutile surement
   pinMode(1, INPUT); //inutile surement 

  Blynk.begin(auth, ssid, pass);

delay(2000);

Blynk.notify("Les Notifications fonctionnent");
Serial.begin(115200);
}

void loop()
{
  Blynk.run();

   if ( Serial.available() > 0 ) {
   
      if (Serial.read() == 'c') {
      Blynk.notify("Hey, Blynkers! Mon matériel peut push désormais !");
      delay(5000);
      }
  }         
}

Ca fonctionne avec ce code, cependant j'ai des notifications en boucle sur mon portable, faut que je modifie ça ^^

al1fch:
Une borne multifonction comme Tx/gpio1 ne peut pas tout faire a la fois. A la mise sous tension elle est connectée a l'Uart et devient Tx. Pour l'utiliser en tant que gpio1 il faut au préalable la déconnecter de l'Uart

pinMode(1, FUNCTION_3)

Pour Rx/gpio3
pinnMode(3, FUNCTION_3)

Mais pourquoi délaisser Rx s'il s'agit de faire entrer un octet comme dit plus haut ?

Ah ok pour l'Uart je ne savais pas ça. Merci pour l'info,
En fait je ne savais pas de base s'il était possible d'envoyer des caractères à l'ESP, des états, ou autre chose, je faisais des tests. Et dans tous les cas ça peut tjs m'être utile de savoir ça ^^

Pour avoir une idée de ce que l'on peut demander , sous IDE Arduino, à un ESP8266 voir la partie de gauche de ce site : 150+ ESP8266 NodeMCU Projects, Tutorials and Guides with Arduino IDE​ | Random Nerd Tutorials

l'ESP-01 est juste une version étriquée des cartes à ESP8266 (peu de GPIO, pas d'entrée analogique...)

Merci pour le site internet, je vais aller y faire un tour pour voir ce que je peux faire avec un ESP!
Oui c'est vrai que c'est assez restreint la version 01

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.