Arduino Forum

International => Français => Le bar => Topic started by: icare on Jul 27, 2018, 02:14 pm

Title: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Jul 27, 2018, 02:14 pm
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
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: Artouste on Jul 27, 2018, 07:17 pm
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 çà (https://www.instructables.com/id/Serial-Port-Over-WiFi/)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: al1fch on Jul 27, 2018, 08:05 pm
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é...)
 (https://www.espressif.com/en/products/software/esp-mesh/overview)
(https://www.espressif.com/sites/default/files/2018.7en.jpg)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Jul 27, 2018, 09:10 pm
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.
@+
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 02, 2018, 04:33 pm
Bonjour,
J'ai fait quelques essais sur la base de la configuration ci-dessous :
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=268685)
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.
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: al1fch on Aug 02, 2018, 11:02 pm
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 (https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/soft-access-point-class.html) 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
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 03, 2018, 10:54 am
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 (https://arduino-esp8266.readthedocs.io/en/latest/esp8266wifi/soft-access-point-class.html) 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 .....
@+
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 02:57 pm
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 :
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=268685)
Schéma :
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269525)

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 ;)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 03:00 pm
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);
}
/* ************************************************************************ */
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 03:00 pm
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);
}
/* ************************************************************************ */
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 03:04 pm
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).
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269534)

[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.
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: al1fch on Aug 08, 2018, 03:33 pm
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.
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 07:24 pm
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 :)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: Artouste on Aug 08, 2018, 08:07 pm
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:
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: al1fch on Aug 08, 2018, 08:15 pm
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'
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 08, 2018, 11:49 pm
Bonsoir Artouste et al1fch,
Il est vrai que vue sous cet angle, on peut envisager une version pour la rubrique "Réalisations et Projets finis".
J'utiliserai encore ce topic pour mettre encore quelques éléments complémentaires et il me servira de base pour la rédaction future.
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: Artouste on Aug 09, 2018, 12:04 am
Bonsoir Artouste et al1fch,
Il est vrai que vue sous cet angle, on peut envisager une version pour la rubrique "Réalisations et Projets finis".
J'utiliserai encore ce topic pour mettre encore quelques éléments complémentaires et il me servira de base pour la rédaction future.
8)

C'est ton topic  "à toi" ;)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 09, 2018, 12:23 am
Re,
L'utilisation des breadboards pour le test de montage reste, pour moi, une hérésie pour le manque de fiabilité des connexions. Par contre son utilisation est des plus pratique.
Alors pour tout ceux qui commencent à acquérir de l'expérience dans le monde de l'expérimentation sur breadboard, il y a lieu d'apporter le plus grand soin aux montages.
Avec peu de moyens (chute de plaques à pastilles, connecteurs HE14, etc...), vous pouvez réaliser des petits adaptateurs pour les composants (résistances, condensateurs, leds, etc...) les plus courants.
Les embouts des fils de connexion doivent avoir les bonnes sections pour assurer un contact correct.
Les dysfonctionnements des montages sont souvent liés aux mauvais contacts.
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269637)

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269639)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 09, 2018, 11:24 am
Bonjour,
A quoi bon un montage sur breadboard, il faut passer à une réalisation plus "solide".
On peut utiliser plusieurs techniques :
- mettre la breadboard dans une boîte (pas top),
- faire un circuit imprimé (cela ne me dit plus rien),
- faire faire un circuit imprimé (trop long),
- la bonne plaque à pastilles.
Pour les montages à l'unité, j'aime bien les plaques à pastilles car elle permettent d'avoir une réalisation propre et fiable.
Les plus courageux pourront réaliser la version CMS. On peut faire mieux, d'un point de vue taille mais avec l'âge cela devient de plus en plus difficile.

Plaque à pastilles côté composants:
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269694)

Plaque à pastilles côté cuivre:
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269696)

Plaques à pastilles double face : 54 x 36 mm
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 09, 2018, 11:28 am
Re,
Les mêmes images sans l'effet de transparence.
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269698)
(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269700)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 09, 2018, 07:08 pm
Re,
La même chose en composants discrets:

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269768)

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=269770)

;)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: Artouste on Aug 09, 2018, 10:39 pm
Bonsoir Icare
tu peux me rappeler le soft qu tu utilise pour tes "plakatrou/plakabandes " ? 8)

çà avait été évoqué , mais ça date "déjà ... un peu"


Edit
retrouvé (http://forum.arduino.cc/index.php?topic=433246.msg2988297#msg2988297)
:D
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 09, 2018, 11:07 pm
Bonsoir,
Edit
retrouvé (http://"http://forum.arduino.cc/index.php?topic=433246.msg2988297#msg2988297")
:D
;)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 11, 2018, 09:29 pm
Bonjour,
Du plan de câblage à la réalisation.

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270040)

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270042)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 13, 2018, 03:06 pm
Bonjour,
Une petite tentative sur une plaque à pastilles de 41 x 31 mm. Je pense qu'il va être difficile de faire plus compact dans ces conditions.

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270168)

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270170)
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 16, 2018, 11:26 pm
Bonjour,
Voila le théorie d'implantation est une chose la réalisation en est une autre. Voici le résultat finale.


(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270608)

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270610)

Il ne me reste plus qu'à mettre le tout dans un petit boîtier pour éviter que les différents circuits ne se chamaillent entre eux (d'un point de vue électrique bien sur).
Au moment de la conception de l'implantation, je ne me suis pas vraiment rendu compte de la compacité du circuit de conversion du niveau de tension des signaux RX et TX.
Title: Re: Transmission ASCII bidirectionnelle sans fils
Post by: icare on Aug 16, 2018, 11:36 pm
Re,
Voici le détail, pour ceux qui souhaitent implanter un convertisseur de niveau de tension 2 voies, sur une plaque à pastilles au pas 2.54 mm.
Un schéma ultra classique de 6 composants (4 résistances et 2 MOSFET canal N) soit 14 connections sur 6 pastilles.
On ne peut pas faire plus compact (4 entrées/sorties, 1 alim 3.3V et 1 alim 5V).

(http://forum.arduino.cc/index.php?action=dlattach;topic=560352.0;attach=270613)

Remarque : il faut toute même un peu de pratique niveau soudure :)
[edit] Il faut lire RX0 en bas à droite du schéma.