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
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
Bonjour Icare
jette un oeil sur çà
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é...)
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.
@+
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.
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)
-
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()
-
disparition du client
l'exemple WiFiWebserver , qui utilise ESP8266.H , contient parexemple ce code
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
Bonjour al1fch,
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
al1fch:
- 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
al1fch:
2) disparition du client
l'exemple WiFiWebserver , qui utilise ESP8266.H , contient parexemple ce codevoid 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:
/* ************************************************************************ */
/* 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 .....
@+
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
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.
al1fch:
la solution du 'ping' pour détecter la perte du client me parait plutôt élégante et rationnelle.
Ok pour les qualitatifs
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"
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"
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.
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:
Plaque à pastilles côté cuivre:
Plaques à pastilles double face : 54 x 36 mm
Re,
Les mêmes images sans l'effet de transparence.