Transmission ASCII bidirectionnelle sans fils

Soft Serveur :

/*
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);
}
/* ************************************************************************ */

serveur01.zip (2.41 KB)

Soft Client :

/*
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);
}
/* ************************************************************************ */

client01.zip (2.32 KB)

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.

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.

Re,
Merci pour le retour.

al1fch:
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.

al1fch:
+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. :wink:

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

Ok pour les qualitatifs :slight_smile:

icare:
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"
:grin:

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'

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.

icare:
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.

C'est ton topic "à toi" :wink:

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.
photo1.png

photo2.png

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:
wSerialCom.jpg

Plaque à pastilles côté cuivre:
wSerialCuiv.jpg

Plaques à pastilles double face : 54 x 36 mm

Re,
Les mêmes images sans l'effet de transparence.
wSerialComST.jpg
wSerialCuivST.jpg

Re,
La même chose en composants discrets:

wSerialComp.jpg

wSerialCuiv.jpg

:wink:

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é
:smiley:

Bonsoir,

Artouste:
Edit
retrouvé
:smiley:

:wink:

Bonjour,
Du plan de câblage à la réalisation.

photo3.png

photo4.png

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.

comp.jpg

cuivre.jpg

Bonjour,
Voila le théorie d'implantation est une chose la réalisation en est une autre. Voici le résultat finale.

photo5.png

photo6.png

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.

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).

photo7.png

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