Go Down

Topic: Transmission ASCII bidirectionnelle sans fils (Read 1 time) previous topic - next topic

icare

Jul 27, 2018, 02:14 pm Last Edit: Jul 27, 2018, 02:14 pm by icare
Bonjour à tous,
Après une longue absence indépendamment de ma volonté, je tente un retour.
Pour éviter de chercher de midi à 14h ou plutôt de 14h à midi, je cherche une solution de communication série sans fils via des ESP01.
Si un membre à une ébauche de ce type de communication, je suis preneur .
Merci
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

Artouste

Bonjour à tous,
Après une longue absence indépendamment de ma volonté, je tente un retour.
Pour éviter de chercher de midi à 14h ou plutôt de 14h à midi, je cherche une solution de communication série sans fils via des ESP01.
Si un membre à une ébauche de ce type de communication, je suis preneur .
Merci

Bonjour Icare
jette un oeil sur çà

al1fch

#2
Jul 27, 2018, 08:05 pm Last Edit: Jul 27, 2018, 08:09 pm by al1fch
Bonjour
Dans ta question ,Icare,   tu ne mentionnes pas la contrainte que la communication se place dans un réseau Wifi, si c'est bien le cas tu peux regarder l'exemple HelloMesh qui met en oeuvre un mode de fonctionnement  radio simplifié, non WiFi, des ESP8266.
Avec cette méthode plusieurs ESP8266, hors véritable réseau WiFi,  peuvent s'échanger directement 'sans fil' des informations (pas encore testé pour ce qui me concerne)
ESPMesh est présenté içi par Espressif (principe, débit maxi, capacité...)


icare

Re,
Merci Artouste pour le lien que j'avais visité mais la solution est bien compliquée "and not linux friendly" ;)
Merci al1fch pour cette technique que je vais explorer.

Pour l'instant, j'ai réussi à faire un petit serveur telnet qui transmet le TX de l'esp vers telnet et le telnet vers le RX de l'esp.
Tout fonctionne bien lorsque je me connecte au serveur via putty, par contre je n'arrive pas encore à faire un esp client telnet.

Pour la communication wifi entre les 2 esp, il s'agit d'un réseau créé par l'esp serveur telnet en mode AP.
@+
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

icare

#4
Aug 02, 2018, 04:33 pm Last Edit: Aug 08, 2018, 02:40 pm by icare
Bonjour,
J'ai fait quelques essais sur la base de la configuration ci-dessous :

Le serveur et le client disposent de leds pour indiquer le fonctionnement, à savoir :
- led "défaut" (rouge fixe = pb de wifi et rouge clignaotant = puissance wifi trpo faible)
- led "wifi" (clignotant = en cours de connexion - fixe = connecter au wifi.
- led "client" (clignotant = attente connexion client - fixe = client connecté)
- led "serveur" (clignotant = serveur non dispo - fixe = connecté au serveur)

Lorsque la led "client" clignote (sur le serveur), je me connecte avec putty et la led passe au fixe et la communication se fait dans les 2 directions à 115200 bauds.
Lorsque je ferme la connexion putty, le led "client" redevient clignotante et en attente d'une nouvelle connexion.

Si je fais la même opération en remplaçant le client putty par un second esp (client), la communication s'établit.
Par contre, si j'arrête le client en coupant l'alimentation (sortie non propre), je n'arrive pas à détecter cet état.

Comment peut-on faire cette détection?
Merci pour votre aide.
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

al1fch

#5
Aug 02, 2018, 11:02 pm Last Edit: Aug 02, 2018, 11:15 pm by al1fch
Bonsoir

sans doute plisuieurs façon de faire cette détection de disparition d'une station et d'un client (selon ton schéma le serveur tourne sur l'AP et le client sur la Station)

1) disparition d'une station : le Point d'accès software possède une fonction donnant le nombre de stations connectées, une surveillance est donc possible à ce niveau , voir içi l'API et la fonction SoftAPgetStationNum()

2) disparition du client
l'exemple WiFiWebserver , qui utilise ESP8266.H , contient parexemple  ce code
Code: [Select]

void loop() {
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }


Il ya donc  un test possible de détection de présence de client

icare

#6
Aug 03, 2018, 10:54 am Last Edit: Aug 03, 2018, 10:59 am by icare
Bonjour al1fch,
sans doute plisuieurs façon de faire cette détection de disparition d'une station et d'un client (selon ton schéma le serveur tourne sur l'AP et le client sur la Station)
Exact

1) disparition d'une station : le Point d'accès software possède une fonction donnant le nombre de stations connectées, une surveillance est donc possible à ce niveau , voir içi l'API et la fonction SoftAPgetStationNum()
Je vais explorer cette voie

2) disparition du client
l'exemple WiFiWebserver , qui utilise ESP8266.H , contient parexemple  ce code
Code: [Select]

void loop() {
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }


Il ya donc  un test possible de détection de présence de client
Cela ne détecte pas la disparition du client (coupure sauvage de l'alimentation)

Ci-dessous le loop de mon serveur TCP:

Code: [Select]
/* ************************************************************************ */
/* Boucle infinie                                                           */
/* ************************************************************************ */
void loop() {
#ifdef DEBUG
 static uint8_t compteur = 0;
#endif
 //vérifie si wifi connecté
 if((WiFi_mode == WIFI_STA) && (WiFi.status() != WL_CONNECTED)){
Serial1.println("<1>");
 client.stop();
 server.stop();
 server.close();
 digitalWrite(VERTE, OFF);
 wifiStart();
 demarreServeur(); //démarre le serveur Telnet
 }

 if(!client.connected()){
Serial1.println("<2>");
 //si le serveur est déconnecté, arrêtez le client:
#ifdef DEBUG
 Serial1.println("Deconnecter du serveur");
#endif
// client.stop();
Serial1.println("<2b>");
 clientStart(); //connexion Telnet
Serial1.println("<2t>");
 }

 if(server.hasClient()){
Serial1.println("<3>");
 foundPlace = false;
 if(client || client.connected()){
Serial1.println("<4>");
 //supprime ancienne connexion
 if(client){
Serial1.println("<5>");
 client.stop();
 }
 //nouveau client
 client = server.available();
 foundPlace = true;
 }
 }

 //Telnet --> Serial
 if(client && client.connected()){
 if(client.available()){
 while(client.available()){
 Serial.write(client.read());
 }
 }
 }
 //Serial --> Telnet
 if(Serial.available()){
 size_t len = Serial.available();
 uint8_t sbuf[len];
 Serial.readBytes(sbuf, len);
 if(client && client.connected()){
 client.write(sbuf, len);
 delay(1);
 }
 }
#ifdef DEBUG
 //affichage pour voir si cela fonctionne
 if(millis() - previous >= 2000){
 previous = millis();
 if(compteur < 201){
 client.print("sev -> cli : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 compteur++;
 }else{
 compteur = 0;
 client.print("sev -> cli : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 compteur++;
 }
 }
#endif
}
/* ************************************************************************ */
/* Connexion client                                                         */
/* ************************************************************************ */
void clientStart(){
 while (!client.connected()){
#ifdef DEBUG
 //* pendant attente client
 static uint8_t j = 0;
 if(j > 20){
 j = 0;
 Serial1.println();
 }else{
 Serial1.print("*");
 j++;
 }
#endif
 digitalWrite(VERTE, !digitalRead(VERTE));
 delay(500);
 if(server.hasClient()){
 client = server.available();
 }
 }
 //client connecté
 digitalWrite(VERTE, ON);
#ifdef DEBUG
 Serial1.println();
 Serial1.println("Client connecte");
#endif
}
/* ************************************************************************ */
/* Démarrage serveur                                                        */
/* ************************************************************************ */
void demarreServeur(){
 //démarre le serveur Telnet
 server.begin();
 server.setNoDelay(true);
}
/* ************************************************************************ */
/* Lancement WiFi                                                           */
/* ************************************************************************ */
void wifiStart(){
 WiFi.config(ip, gateway, subnet);
 WiFi.begin(ssid, pass);
 uint16_t temps = 0;
 while (WiFi.status() != WL_CONNECTED && temps++ < TEMPS_WIFI){
#ifdef DEBUG
 //l pendant phase de connexion au wifi
 static uint8_t jj = 0; //20 caractères par ligne
 if(jj > 20){
 jj = 0;
 Serial1.println();
 }else{
// Serial1.print("l");
 Serial1.print(".");
 jj++;
 }
#endif
 digitalWrite(JAUNE, !digitalRead(JAUNE)); //led jaune clignotante
 delay(500);
 }
 digitalWrite(JAUNE, ON); //connecté au wifi
#ifdef DEBUG
 Serial1.println();
#endif
 //temps de connexion trop long
 if(temps >= TEMPS_WIFI){
#ifdef DEBUG
 Serial1.print("Pas de connexion a : ");
 Serial1.println(ssid);
#endif
 while(1){ //on boucle, il faut un reset
 digitalWrite(JAUNE, OFF); //pas de wifi
 digitalWrite(ROUGE, ON); //défaut
 delay(500);
 }
 }
 //message connecté
#ifdef DEBUG
 Serial1.println("WiFi connecte");
#endif
}


En fonctionnement avec putty (client) :
Lorsqu'on ferme la liaison, on passe par <2> puis attente nouvelle connexion
Avec l'ESP client (coupure alim) :
On reste dans la boucle .....
@+
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

icare

#7
Aug 08, 2018, 02:57 pm Last Edit: Aug 08, 2018, 03:08 pm by icare
Bonjour,
Un petit point sur ma transmission série sans fils.
Tout est toujours facile lorsqu'on est sur la "paillasse", mais une fois le montage en place tout se complique. :)
J'utilise  un ESP12 qui  se trouve, bien sur, dans un endroit difficilement accessible. Pour le téléchargement du logiciel, j'utilise OTA et c'est vraiment un confort dont on devient accro.
Par contre, on perd l'utilisation de la sortie série pour le débogage.
Il existe des solutions alternatives en passant par :
- serveur telnet embarqué,
- utilisation de boîtiers spécialisés pour les liaisons séries,
- etc.
Pour ma part, je souhaitais mettre en oeuvre une liaison série sans fils indépendante du réseau wifi utilisé.
Pour les tests j'ai utilisé la configuration suivante :

Schéma :


Nota : Schéma identique pour le serveur et le client.

Côté serveur :
La led rouge signale une erreur, la jaune fixe signale que le réseau wifi est ok. La led verte clignote s'il n'y a aucun client et est fixe si le client est connecté au serveur.

Côté client :
La led rouge signale une erreur, la jaune clignotante indique recherche wifi et est fixe si connecté au wifi. La led verte clignote si le serveur n'est pas disponible et est fixe si connecté au serveur.

Utilisation:
Lorsqu'on coupe l'alimentation du serveur, les diode jaune et verte du client clignote. Si l'on rétablit l'alimentation la procédure de reconnexion se fait.
Lorsqu'on coupe l'alimentation du client, la diode verte du serveur clignote pour signaler la disparition du client.
La détection de la coupure du client a posé le plus de problème. Bien que la solution ne soit pas la plus élégante, je n'ai rien trouvé d'autre.
Pour résumé j'utilise le "ping" pour détecter la disparition du client.
On a un avertissement à la compilation car la librairie <ESP8266Ping.h> utilise une méthode qui a un paramètre non utilisé.
Je reste preneur d'une solution plus élégante ;)
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

icare

#8
Aug 08, 2018, 03:00 pm Last Edit: Aug 08, 2018, 03:07 pm by icare
Soft Serveur :
Code: [Select]
/*
Programme test serveur TCP
Programme principal
nom programme       : serveur01.ino
os                  : sans objet
logiciel            : arduino_1_8_5 + extension ESP
compilateur         :
bibliothèques       :
cible               : ESP-03 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
date de création    : 03/08/2018
date de mise à jour : 06/08/2018
version             : 0.0.1 (X.Y.Z X = stable, Y = màj et Z = en cours)
makefile            :
auteur              : icarePetibles
références          :
Remarques           : d'après soft Stefan Thesen - http://blog.thesen.eu
*/
/*
 *****   *******  ******   *      *  *******  ******
*     *  *        *     *  *      *  *        *     *
*        *        *     *  *      *  *        *     *
 *****   *****    ******    *     *  *****    ******
      *  *        *   *      *   *   *        *   *
*     *  *        *    *      * *    *        *    *
 *****   *******  *     *      *     *******  *     *
*/
#include <ESP8266WiFi.h>
#include <ESP8266Ping.h> //https://github.com/dancol90/ESP8266Ping
/* ************************************************************************ */
/* Déclarations                                                             */
/* ************************************************************************ */
//#define DEBUG
//#define TEST
#define ON LOW
#define OFF HIGH
#define JAUNE 12
#define ROUGE 13
#define VERTE 14
#define TEMPS_WIFI 300 //
const WiFiMode wifi_mode = WIFI_AP; //définir WIFI_AP pour le point d'accès
const char* ssid = "serieWifi"; //nom du AP
const char* password = "curieuse"; //mot de passe
const uint8_t channel = 6; //canal wifi
const int iSerialSpeed = 115200; //vitesse port série
const int iSerialSpeed1 = 115200; //vitesse port série 1
const bool bSuppressLocalEcho = true; //l'écho local dans telnet doit être supprimé (généralement oui)
const IPAddress local_IP(192, 168, 0, 1); //adresse Serveur
//const IPAddress gateway(192, 168, 0, 1);
const IPAddress subnet(255, 255, 255, 0); //masque réseau
const IPAddress client_IP(192, 168, 0, 2); //adresse client
#ifdef TEST
 unsigned long previous = 0UL;
#endif
bool foundPlace = false;

WiFiServer server(23); //Créer une instance du serveur sur le port 23
WiFiClient client; //instance client
/* ************************************************************************ */
/* Initialisation                                                           */
/* ************************************************************************ */
void setup(){
 uint8_t iSet = 0;
 Serial.begin(iSerialSpeed);
#ifdef DEBUG
 Serial1.begin(iSerialSpeed1);
 Serial1.println();
 Serial1.println();
 Serial1.println("mode DEBUG serveur");
#endif
 pinMode(JAUNE, OUTPUT); //pin en sortie
 pinMode(ROUGE, OUTPUT);
 pinMode(VERTE, OUTPUT);
 digitalWrite(JAUNE, HIGH); //led off cde inverse
 digitalWrite(ROUGE, HIGH);
 digitalWrite(VERTE, HIGH);
//#ifdef DEBUG
 forFun(); //message de bienvenue
//#endif
 WiFi.mode(wifi_mode); //AP mode
 //*********************
 //configuration soft-AP
 //*********************
 while(!WiFi.softAPConfig(local_IP, local_IP, subnet) && iSet++ < 20){
#ifdef DEBUG
 Serial1.print(".");
#endif
 digitalWrite(ROUGE, !digitalRead(ROUGE)); //led rouge clignotante
 delay(300);
 } //sortie si ok ou iSet >= 20
#ifdef DEBUG
 Serial1.println();
#endif
 digitalWrite(ROUGE, OFF); //led rouge off
 if(iSet >= 20){
#ifdef DEBUG
 Serial1.println("Erreur de configuration reseau ...");
 Serial1.println();
#endif
 while(1){ //bsf, sortie par reset
 digitalWrite(ROUGE, !digitalRead(ROUGE)); //led rouge clignotante
 delay(100);
 }
 }else{
#ifdef DEBUG
 Serial1.println("Configuration reseau : Ok.");
 Serial1.println();
#endif
 }
 //******************
 //activation soft-AP
 //******************
 iSet = 0;
 while(!WiFi.softAP(ssid, password, channel, 0) && iSet++ < 20){
#ifdef DEBUG
 Serial1.print(".");
#endif
 digitalWrite(JAUNE, !digitalRead(JAUNE)); //led jaune clignotante
 delay(200);
 } //sortie si ok ou iSet >= 20
#ifdef DEBUG
 Serial1.println();
#endif
 digitalWrite(JAUNE, ON); //led jaune on
 if(iSet >= 20){
#ifdef DEBUG
 Serial1.println("Erreur reseau wifi ...");
 Serial1.println();
#endif
 while(1){ //bsf, sortie par reset
 digitalWrite(JAUNE, OFF); //led jaune off
 digitalWrite(ROUGE, ON); //led rouge on
 delay(500);
 }
 }else{
#ifdef DEBUG
 Serial1.println("Wifi : Ok.");
 Serial1.println();
#endif
 }
 //*****************
 //démarrage serveur
 //*****************
 server.begin();
 server.setNoDelay(true);
#ifdef DEBUG
 Serial1.print("Ok! Utilisez 'Telnet ");
 Serial1.print(WiFi.softAPIP());
 Serial1.println(":23' pour vous connecter.");
 Serial1.println();
 Serial1.println("### Fin init ###");
 Serial1.println();
#endif
#ifdef TEST
 previous = millis();
#endif
}
/* ************************************************************************ */
/* Boucle sans fin                                                          */
/* ************************************************************************ */
void loop(){
 uint8_t iLoop = 0;
#ifdef TEST
 static uint8_t compteur = 0;
#endif
 // *******************
 // Client non connecté
 // *******************
 if(!client.connected()){
#ifdef DEBUG
 Serial1.println("Client deconnecte du serveur.");
 Serial1.println();
 Serial1.println("Attente connexion client...");
#endif
 while(!client.connected()){
 if(iLoop++ < 20){
 Serial1.print("*");
 }else{
 Serial1.println();
 iLoop = 0;
 }
 digitalWrite(VERTE, !digitalRead(VERTE));
 delay(500);
 if(server.hasClient()){
 client = server.available();
 }
 }
 digitalWrite(VERTE, ON); //client connecté
#ifdef DEBUG
 Serial1.println();
 Serial1.println("Client connecte.");
 Serial1.println();
#endif
 }
 // *******************
 // Serveur a un client
 // *******************
 if(server.hasClient()){
 foundPlace = false;
 if(client || !client.connected()){
 //supprime ancienne connexion
 if(client){
 client.stop();
 }
 //nouveau client
 client = server.available();
 foundPlace = true;
 }
 }
 // *************************
 // Vérifie si client présent
 // *************************
 if(!Ping.ping(client_IP, 2)){
//Serial1.println("<pas de client>");
 client.stop();
 }
 // *****************
 // Telnet --> Serial
 // *****************
 if(client && client.connected()){
 if(client.available()){
 while(client.available()){
 Serial.write(client.read());
 }
 }
 }
 // *****************
 // Serial --> Telnet
 // *****************
 if(Serial.available()){
 size_t len = Serial.available();
 uint8_t sbuf[len];
 Serial.readBytes(sbuf, len);
 if(client && client.connected()){
 client.write(sbuf, len);
 delay(1);
 }
 }
 // ************
 // Zone de test
 // ************
#ifdef TEST
 //affichage pour voir si cela fonctionne
 if(millis() - previous >= 1000){
 previous = millis();
 if(compteur++ < 200){
 client.print("seveur vers client : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 }else{
 compteur = 0;
 client.print("seveur vers client : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 }
 }
#endif
}
/* ************************************************************************ */
/* Pour le plaisir de voir clignoter les leds                               */
/* ************************************************************************ */
void forFun(){
 delay(500);
 digitalWrite(ROUGE, OFF);
 digitalWrite(JAUNE, OFF);
 digitalWrite(VERTE, OFF);
 delay(500);
 digitalWrite(ROUGE, ON);
 digitalWrite(JAUNE, ON);
 digitalWrite(VERTE, ON);
 delay(500);
 digitalWrite(ROUGE, OFF);
 digitalWrite(JAUNE, OFF);
 digitalWrite(VERTE, OFF);
 delay(500);
 digitalWrite(ROUGE, ON);
 digitalWrite(JAUNE, ON);
 digitalWrite(VERTE, ON);
 delay(500);
 digitalWrite(ROUGE, OFF);
 digitalWrite(JAUNE, OFF);
 digitalWrite(VERTE, OFF);
}
/* ************************************************************************ */
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

icare

#9
Aug 08, 2018, 03:00 pm Last Edit: Aug 08, 2018, 03:28 pm by icare
Soft Client :

Code: [Select]
/*
Programme test client TCP
Programme principal
nom programme       : client01.ino
os                  : sans objet
logiciel            : arduino_1_8_5 + extension ESP
compilateur         :
bibliothèques       :
cible               : ESP-03 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
date de création    : 04/08/2018
date de mise à jour : 08/08/2018
version             : 0.0.1 (X.Y.Z X = stable, Y = màj et Z = en cours)
makefile            :
auteur              : icarePetibles
références          :
Remarques           : d'après soft Stefan Thesen - http://blog.thesen.eu
*/
/*
 *****   *        *  *******  *     *  *******
*     *  *        *  *        **    *     *
*        *        *  *        * *   *     *
*        *        *  *****    *  *  *     *
*        *        *  *        *   * *     *
*     *  *        *  *        *    **     *
 *****   *******  *  *******  *     *     *
*/
#include <ESP8266WiFi.h>
/* ************************************************************************ */
/* Déclarations                                                             */
/* ************************************************************************ */
//#define TEST
//#define DEBUG
#define ON LOW
#define OFF HIGH
#define JAUNE 12
#define ROUGE 13
#define VERTE 14
#define TEMPS_WIFI 300 //
const WiFiMode wifi_mode = WIFI_STA; //définir WIFI_AP pour le point d'accès
const char* ssid = "serieWifi"; //nom du AP
const char* password = "curieuse"; //mot de passe
const int iSerialSpeed = 115200; //vitesse port série
const int iSerialSpeed1 = 115200; //vitesse port série 1
IPAddress local_IP(192, 168, 0, 2);
//IPAddress gateway(192, 168, 0, 10);
IPAddress subnet(255, 255, 255, 0);
IPAddress server(192, 168, 0, 1); //IP serveur TCP
#ifdef TEST
 unsigned long previous = 0UL;
#endif

WiFiClient client; //instance client
/* ************************************************************************ */
/* Initialisation                                                           */
/* ************************************************************************ */
void setup(){
 uint8_t iSet = 0;
 Serial.begin(iSerialSpeed);
#ifdef DEBUG
 Serial1.begin(iSerialSpeed1); //only for debug
 Serial1.println();
 Serial1.println();
 Serial1.println("mode DEBUG client");
#endif
 pinMode(JAUNE, OUTPUT); //pin en sortie
 pinMode(ROUGE, OUTPUT);
 pinMode(VERTE, OUTPUT);
 digitalWrite(JAUNE, HIGH); //led off cde inverse
 digitalWrite(ROUGE, HIGH);
 digitalWrite(VERTE, HIGH);
//#ifdef DEBUG
 forFun(); //ne sert à rien
//#endif
 //*****************
 //configuration STA
 //*****************
 WiFi.mode(wifi_mode); //STA mode
 while(!WiFi.config(local_IP, local_IP, subnet) && iSet++ < 20){
#ifdef DEBUG
 Serial1.print(".");
#endif
 digitalWrite(ROUGE, !digitalRead(ROUGE)); //led rouge clignotante
 delay(300);
 } //sortie si ok ou iSet >= 20
#ifdef DEBUG
 Serial1.println();
#endif
 digitalWrite(ROUGE, OFF); //led rouge off
 if(iSet >= 20){
#ifdef DEBUG
 Serial1.println("Erreur de configuration reseau ...");
#endif
 while(1){ //bsf, sortie par reset
 digitalWrite(ROUGE, !digitalRead(ROUGE)); //led rouge clignotante
 delay(100);
 }
 }
 wifiStart();
#ifdef DEBUG
 Serial1.print("Adresse IP : ");
 Serial1.print(WiFi.localIP());
 Serial1.println();
#endif
#ifdef TEST
 previous = millis();
#endif
 connectServeur(); //connexion au serveur
}
/* ************************************************************************ */
/* Boucle sans fin                                                          */
/* ************************************************************************ */
void loop(){
#ifdef DEBUG
 static uint8_t compteur = 0;
#endif
 // ************************
 // vérifie si wifi connecté
 // ************************
 if((wifi_mode == WIFI_STA) && (WiFi.status() != WL_CONNECTED)){
 client.stop();
 wifiStart(); //démarre wifi
 connectServeur(); //connexion au serveur Telnet
 }
 // *************
 // pas de client
 // *************
 if(!client.connected()){
 //si le client est déconnecté, arrêtez le client:
#ifdef DEBUG
 Serial1.println("Deconnecter du serveur");
#endif
 connectServeur(); //démarre le serveur Telnet
 }
 // *****************
 // Telnet --> Serial
 // *****************
 if(client && client.connected()){
 if(client.available()){
 while(client.available()){
 Serial.write(client.read());
 }
 }
 }
 // *****************
 // Serial --> Telnet
 // *****************
 if(Serial.available()){
 size_t len = Serial.available();
 uint8_t sbuf[len];
 Serial.readBytes(sbuf, len);
 if(client && client.connected()){
 client.write(sbuf, len);
 delay(1);
 }
 }
 // *************
 // zone de tests
 // *************
#ifdef TEST
 //affichage pour voir si cela fonctionne
 if(millis() - previous >= 1500){
 previous = millis();
 if(compteur < 201){
 client.print("client vers serveur : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 compteur++;
 }else{
 compteur = 0;
 client.print("client vers serveur : ");
 client.println(compteur);
// client.printf("\r%u  ", compteur); //aff sur la même ligne (retour à la ligne)
 compteur++;
 }
 }
#endif
}
/* ************************************************************************ */
/* connexion serveur                                                        */
/* ************************************************************************ */
void connectServeur(){
 while(!client.connect(server, 23)){
#ifdef DEBUG
 //* pendant la connexion serveur
 static uint8_t j = 0;
 if(j > 20){
 j = 0;
 Serial1.println();
 }else{
 Serial1.print("*");
 j++;
 }
#endif
 digitalWrite(VERTE, !digitalRead(VERTE));
 delay(500);
 }
 //client connecté
 digitalWrite(VERTE, ON);
#ifdef DEBUG
 Serial1.println();
 Serial1.println("Connecter au serveur");
#endif
}
/* ************************************************************************ */
/* Lancement WiFi                                                           */
/* ************************************************************************ */
void wifiStart(){
 WiFi.begin(ssid, password);
 uint16_t temps = 0;
 digitalWrite(VERTE, OFF); //déconnecté du serveur
 digitalWrite(JAUNE, OFF); //pas de wifi
 while (WiFi.status() != WL_CONNECTED && temps++ < TEMPS_WIFI){
#ifdef DEBUG
 //. pendant phase de connexion au wifi
 static uint8_t jj = 0; //20 caractères par ligne
 if(jj > 20){
 jj = 0;
 Serial1.println();
 }else{
 Serial1.print(".");
 jj++;
 }
#endif
 digitalWrite(JAUNE, !digitalRead(JAUNE)); //led jaune clignotante
 delay(500);
 }
 digitalWrite(JAUNE, ON); //connecté au wifi
#ifdef DEBUG
 Serial1.println();
#endif
 //temps de connexion trop long
 if(temps >= TEMPS_WIFI){
#ifdef DEBUG
 Serial1.print("Pas de connexion a : ");
 Serial1.println(ssid);
#endif
 while(1){ //on boucle, il faut un reset
 digitalWrite(JAUNE, OFF); //pas de wifi
 digitalWrite(ROUGE, ON); //défaut
 delay(500);
 }
 }
 //message connecté
#ifdef DEBUG
 Serial1.println("Connecte au wifi");
#endif
}
/* ************************************************************************ */
/* Pour le plaisir de voir clignoter les leds                               */
/* ************************************************************************ */
void forFun(){
 delay(500);
 digitalWrite(ROUGE, ON);
 digitalWrite(JAUNE, ON);
 digitalWrite(VERTE, ON);
 delay(500);
 digitalWrite(ROUGE, OFF);
 digitalWrite(JAUNE, OFF);
 digitalWrite(VERTE, OFF);
 delay(500);
 digitalWrite(ROUGE, ON);
 digitalWrite(JAUNE, ON);
 digitalWrite(VERTE, ON);
 delay(500);
 digitalWrite(ROUGE, OFF);
 digitalWrite(JAUNE, OFF);
 digitalWrite(VERTE, OFF);
}
/* ************************************************************************ */
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

icare

#10
Aug 08, 2018, 03:04 pm Last Edit: Aug 10, 2018, 10:28 am by icare
Re,
On peut également utiliser les "vieux ESP01" pour faire la même chose. Il faudra juste modifier le soft avec une gestion appropriée de la led (éteinte, allumée, vitesses de clignotement différentes).


[edit]
Le soft fonctionne également si vous mettez le serveur en STA sur votre wifi. Dans ce cas, ssid et password sont ceux de votre wifi. Il va de soi, qu'il faudra également adapter les adresses IP.
Egalement dans ce cas, il suffit du serveur, le client est assuré par une émulation telnet genre puTTy.
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

al1fch

#11
Aug 08, 2018, 03:33 pm Last Edit: Aug 08, 2018, 03:47 pm by al1fch
Merci pour ce retour et cette réalisation intéressante que tu pourrais basculer  côté "Realisations et Projets Finis"

+Schémas clairs :D.... ça change de la filasse multicolore des Fritzings !!!

la solution du 'ping' pour détecter la perte du client me parait plutôt élégante et rationnelle.

icare

Re,
Merci pour le retour.
Merci pour ce retour et cette réalisation intéressante que tu pourrais basculer  côté "Realisations et Projets Finis"
Je ne l'ai pas mis dans la rubrique "Réalisations et Projets Finis" pour 2 raisons :
- je cherchais au départ une solution pour un problème particulier loin d'Arduino,
- par respect pour le forum Arduino car tout mon projet était à base d'ESP.

+Schémas clairs :D.... ça change de la filasse multicolore des Fritzings !!!
Lorsque je vois des schémas ou implantations sous Frizing, je suis pris de violentes quintes de toux. ;)

la solution du 'ping' pour détecter la perte du client me parait plutôt élégante et rationnelle.
Ok pour les qualitatifs :)
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

Artouste

Re,
Merci pour le retour.Je ne l'ai pas mis dans la rubrique "Réalisations et Projets Finis" pour 2 raisons :
- je cherchais au départ une solution pour un problème particulier loin d'Arduino,
- par respect pour le forum Arduino car tout mon projet était à base d'ESP.
Bonsoir Icare
Perso , je considère dans la mesure où tu utilise l'esp au travers de l'IDE "arduino"
que ça remplis toutes les conditions pour en faire un topic dans "Réalisations et Projets Finis"
:smiley-mr-green:

al1fch

#14
Aug 08, 2018, 08:15 pm Last Edit: Aug 08, 2018, 08:21 pm by al1fch
Bonsoir à vous 2

j'étais  en train d'écrire  la même chose qu'Artouste

ESP utilisé en tant que plateforme alternative dans le cadre de l'ouverture via le "Board Manager" donc pas de manque de repect de mon point de vue envers le forum Arduino ....forum  qui d'ailleurs  (dans toutes les langues !) manifeste une forte demande de la part des intervenants quand aux ESP.

D'autre part la réalisation est susceptible de répondre  à des besoins de communication entre cartes Arduino 'de souche'

Go Up