2 Esp32 connecter

Bonjour je cherche à connecter deux esp32. Un premier esp32 comme serveur et l'autre comme client sa j'ai réussi a le faire. Après j'ai réussi que le client envoie ces données au serveur et j'ai réussi que le serveur récupéré les valeurs de du client mais je n'arrive pas à faire l'inverse c'est à dire que le serveur envoie les au client et que le client les récupère. J'utilise la bibliothèque WiFiServer et WiFiClient.
Avez vous une solution s'il vous plaît.

j'ai réussi que le client envoie ses données au serveur

comment ?

Je voudrais que le serveur esp32 envoie ces données au client esp32 et qu'il les lise. Le serveur esp32 est en mode accès wifi donc le client ce connecte au serveur

oui je comprends bien - une fois qu'ils sont tous les deux sur le même réseau la communication est possible.

ce n'est pas ma question: comment avez vous envoyé des données du "client" au "serveur" et pourquoi n'est-ce pas inversable ? quel protocole de communication utilisez vous ?

Voici le code du serveur :

#include <WiFi.h>
#include <WiFiClient.h>
#include <WiFiServer.h>
#include <WiFiUdp.h>
#include <WiFiClient.h>
#define LED_BUILTIN 2   

//Serveur Avion pour recevoir les reponses de la telecomande
const char *ssid = "Avion_Esp32";
const char *password = "Maison210_Avion_Esp32";
//Communication vers client
const char* ssidtele = "telecommande_Esp32";    //SSID du point d'accès WiFi
const char* passwordtele = "Maison210_telecommande_Esp32";//mot de passe
const char* host = "192.168.4.1";      //ip lum01

int modewifi=0;
WiFiServer serveur(80);

void setup() {
  pinMode(27, OUTPUT);
  Serial.begin(115200);
  Serial.println();
  Serial.println("Configuring access point...");
  WiFi.softAP(ssid, password);
  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(myIP);
  serveur.begin();

  Serial.println("Server started");
 
  
}



void loop() {
 WiFiClient client =serveur.available();
  
  
  if(!client){ 
              
    return; 
    delay(1000);           
  }
  
else{
  Serial.println(F("client"));
  
  while(!client.available()){     
    delay(1);
  }
  while(client.available()){
  char c = client.read();
  Serial.write(c);
  String req = client.readStringUntil('\r');  
  Serial.println(req);
  
  
  
     
  }         
 }
  
}

Et voici le code du client :

#include <WiFi.h>
#include <WiFiClient.h>
#include <WiFiServer.h>

#include <SSD1306.h>
 

SSD1306 display(0x3c,5,4);

//Communication vers serveur
const char* ssid = "Avion_WEsp32";    
const char* password = "Maison210_Avion_Esp32";
const char* host = "192.168.4.1";      

//Serveur telecommande pour recevoir les reponses de l'avion
const char *ssIDserveurtele = "telecommande_Esp32";
const char *passwordtele = "Maison210_telecommande_Esp32";
int msgenvoiye=0;
WiFiServer serveur(80);
void setup()
{
    Serial.begin(115200);
    delay(10);

    // We start by connecting to a WiFi network
    WiFi.begin("Avion_Esp32", "Maison210_Avion_Esp32");

    Serial.println();
    Serial.println();
    Serial.print("Waiting for WiFi... ");
    display.init();
    display.flipScreenVertically();
    display.setFont(ArialMT_Plain_24);
    display.setTextAlignment(TEXT_ALIGN_LEFT);
    display.clear();
    display.display();
    display.drawString(0,0,"Connection");
    while(WiFi.status() != WL_CONNECTED) {
        display.drawString(25,25,".");
        display.display();
        Serial.print(".");
        delay(500);
    }

    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    display.clear();
    display.drawString(0,0,"WiFi Connecter");
    display.display();
    

}




void loop(){
  
     WiFiClient client;         //pour créer une connexion TCP
    const int httpPort = 80;
    if(!client.connect(host, httpPort)){

      Serial.println(F("La connexion a echouee"));
      display.clear();
      display.drawString(0,0,"Echouee");
      display.display();

  }
    while(WiFi.status()== WL_CONNECTED){
                    
    int message=55;
    client.print(String(message) + "\r\n" );
    display.clear();
    display.drawString(0,0,"Message envoyé");
    display.display();
    
    
    
    
    

    
  
    }
    

}

J'ai essayé de faire l'inverse mais sa ne marche pas le "client" ne reçoit pas le message du serveur mais je sais pas si le "serveur" envoie bien le message au "client".

Bonjour,
je viens juste pour suivre l'affaire à toutes fins utiles :confused:
(dans mon esprit le serveur doit attendre une requète pour agir)

Bonjour je suis d'accord mais moi je souhaite faire l'inverse je veux que le client attende une requète pour agir

Trimarco232 +1
Est-ce que ce ne sera pas quelque chose comme le rafraîchissement automatique des pages ? (qui par moment est bien casse pied)

comment comptez vous deviner l'adresse IP du client pour pouvoir le contacter depuis le serveur ?

Il faudrait que le serveur communiquer avec le client par l'adresse IP ?

Parce que sinon pour trouver l'adresse du client j'ai juste a faire

IPAddress myIP = WiFi.softAPIP();
  Serial.println(myIP);

Je n’ai pas la solution mais je tente un truc,

Ne faudrait-il pas que les 2 esp32 soit à la fois client et serveur?

Tu te fabriques une télécommande pour avion radio-guidé non? En terme de distance ça va le faire?

vous avez deux notions de serveur/client à prendre en compte.

1/ le Wi-Fi:
Vous avez un premier arduino qui crée le réseau Wi-Fi. On dit qu'il devient un Point d'Accès (Access Point = AP).
Des clients Wi-Fi vont se connecter sur ce point d'accès. Ils obtiennent une adresse IP depuis l'AP.
Vous pouvez imposer l'adresse IP de ce point d'accès et quand des clients demande à rejoindre ce réseau, ils obtiennent une adresse IP. Vous n'avez pas vraiment la main sur l'IP qui est distribuée

2/ HTTP:
Pour échanger de l'information vous avez besoin d'envoyer des requêtes de communication d'un ESP à l'autre. En déclarant un serveur Web votre arduino est capable de répondre à une requête web par du contenu. Pour envoyer cette requête depuis un client web il faut que ce client connaisse l'adresse IP de ce serveur (ou dans un vrai réseau le nom DNS, on peut aussi bidouiller avec mDNS)

Dans votre cas je vais appelé MASTER l'ESP qui crée le réseau Wi-Fi et SLAVE celui qui rejoint le réseau Wi-Fi

le MASTER peut décider de son adresse IP et du nom du réseau Wi-FI. Donc un SLAVE peut rejoindre le réseau (le nom est connu et câblé en dur dans votre code). un SLAVE peut aussi envoyer une requête HTTP au serveur puisqu'on connait son adresse IP qui est fixe.

Mais l'inverse nécessite un peu plus de travail car vous pouvez avoir 3 clients Wi-Fi qui auront chacun leur adresse IP. Comment allez vous savoir à qui envoyer la requête ?

bien sûr comme dit @Jambe, il faut que chaque ESP offre une interface HTTP, donc embarque un petit serveur web.


En pratique pour un test limité où on connait les clients Wi-Fi à l'avance, on connait leur adresse MAC --> on peut scanner les adresse MAC des clients Wi-Fi et quand on trouve le bon on a son IP et on peut lui envoyer des requêtes...

Vous pourriez aussi faire que l'initiative du contact soit toujours par un SLAVE qui pourrait demander (battement de coeur) au MASTER s'il a besoin de quelque chose. c'est plus bavard sur le réseau mais c'est aussi plus simple :slight_smile:

Oui je fabrique un avion télécommander de A à Z. En terme de distance je pense atteindre plus de 500-600 m c'est pour ça que j'utilise le wifi pour avoir une plus grande distance possible. Et j'avais déjà essayer de mettre les esp32 en serveur et client mais sa ne marche pas et en plus j'avais des pertes de connections donc c'est pas très cool.

Donc si j'ai bien compris il faudrait que dès que le serveur détecte un client il scanne sont adresse MAC et si c'est le bon on prendre son adresse IP et ils peuvent communiquer

tenez voici un bout de code ressorti de mes tests. il faut installer AsyncTCP et ESPAsyncWebServer pour votre ESP32

#include <WiFi.h>
#include <AsyncTCP.h>           // https://github.com/me-no-dev/AsyncTCP
#include <ESPAsyncWebServer.h>  // https://github.com/me-no-dev/ESPAsyncWebServer
#include "esp_wifi.h"

const char* ssid = "ESP32-AP"; // nom du point d'accès Wi-Fi
const char* password = ""; // à utiliser si on ne veut pas un réseau ouvert
AsyncWebServer server(80);
bool softAPEnroute = false;

// UTILITAIRES
void printWiFiEventDetails(WiFiEvent_t event)
{
  Serial.printf("[WiFi-event] event: %d\n", event);

  switch (event) {
    case SYSTEM_EVENT_WIFI_READY:
      Serial.println("WiFi interface ready");
      break;
    case SYSTEM_EVENT_SCAN_DONE:
      Serial.println("Completed scan for access points");
      break;
    case SYSTEM_EVENT_STA_START:
      Serial.println("WiFi client started");
      break;
    case SYSTEM_EVENT_STA_STOP:
      Serial.println("WiFi clients stopped");
      break;
    case SYSTEM_EVENT_STA_CONNECTED:
      Serial.println("Connected to access point");
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      Serial.println("Disconnected from WiFi access point");
      break;
    case SYSTEM_EVENT_STA_AUTHMODE_CHANGE:
      Serial.println("Authentication mode of access point has changed");
      break;
    case SYSTEM_EVENT_STA_GOT_IP:
      Serial.print("Obtained IP address: ");
      Serial.println(WiFi.localIP());
      break;
    case SYSTEM_EVENT_STA_LOST_IP:
      Serial.println("Lost IP address and IP address is reset to 0");
      break;
    case SYSTEM_EVENT_STA_WPS_ER_SUCCESS:
      Serial.println("WiFi Protected Setup (WPS): succeeded in enrollee mode");
      break;
    case SYSTEM_EVENT_STA_WPS_ER_FAILED:
      Serial.println("WiFi Protected Setup (WPS): failed in enrollee mode");
      break;
    case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT:
      Serial.println("WiFi Protected Setup (WPS): timeout in enrollee mode");
      break;
    case SYSTEM_EVENT_STA_WPS_ER_PIN:
      Serial.println("WiFi Protected Setup (WPS): pin code in enrollee mode");
      break;
    case SYSTEM_EVENT_AP_START:
      Serial.println("WiFi access point started");
      break;
    case SYSTEM_EVENT_AP_STOP:
      Serial.println("WiFi access point  stopped");
      break;
    case SYSTEM_EVENT_AP_STACONNECTED:
      Serial.println("Client connected");
      break;
    case SYSTEM_EVENT_AP_STADISCONNECTED:
      Serial.println("Client disconnected");
      break;
    case SYSTEM_EVENT_AP_STAIPASSIGNED:
      Serial.println("Assigned IP address to client");
      break;
    case SYSTEM_EVENT_AP_PROBEREQRECVED:
      Serial.println("Received probe request");
      break;
    case SYSTEM_EVENT_GOT_IP6:
      Serial.println("IPv6 is preferred");
      break;
    case SYSTEM_EVENT_ETH_START:
      Serial.println("Ethernet started");
      break;
    case SYSTEM_EVENT_ETH_STOP:
      Serial.println("Ethernet stopped");
      break;
    case SYSTEM_EVENT_ETH_CONNECTED:
      Serial.println("Ethernet connected");
      break;
    case SYSTEM_EVENT_ETH_DISCONNECTED:
      Serial.println("Ethernet disconnected");
      break;
    case SYSTEM_EVENT_ETH_GOT_IP:
      Serial.println("Obtained IP address");
      break;
    default: break;
  }
}

void printWiFiClients()
{

  // On imprime la liste de nos clients Wi-Fi
  // https://techtutorialsx.com/2019/09/22/esp32-arduino-soft-ap-obtaining-ip-address-of-connected-stations/
  wifi_sta_list_t wifi_sta_list;
  tcpip_adapter_sta_list_t adapter_sta_list;

  memset(&wifi_sta_list, 0, sizeof(wifi_sta_list));
  memset(&adapter_sta_list, 0, sizeof(adapter_sta_list));

  esp_wifi_ap_get_sta_list(&wifi_sta_list);
  tcpip_adapter_get_sta_list(&wifi_sta_list, &adapter_sta_list);

  for (int i = 0; i < adapter_sta_list.num; i++) {

    tcpip_adapter_sta_info_t station = adapter_sta_list.sta[i];

    Serial.print(F("station # ")); Serial.print(i);
    Serial.print(F("\tMAC: "));
    for (int i = 0; i < 6; i++) {
      Serial.printf("%02X", station.mac[i]);
      if (i < 5)Serial.write(':');
    }

    Serial.print(F("\tIP: ")); Serial.println(ip4addr_ntoa(&(station.ip)));
  }
  Serial.println("-----------");
}

void WiFiEvent(WiFiEvent_t event)
{
  printWiFiEventDetails(event);
  if (event == SYSTEM_EVENT_AP_START) {
    Serial.println(F("ESP32-AP EST FONCTIONNEL"));
    softAPEnroute = true;
  }
}

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

  // oublie l'ancienne configuration
  WiFi.disconnect(true);
  delay(1000);

  // enregistre un callback pour les évenements WiFi
  // cf https://github.com/espressif/arduino-esp32/blob/master/libraries/WiFi/examples/WiFiClientEvents/WiFiClientEvents.ino
  WiFi.onEvent(WiFiEvent);

  WiFi.mode(WIFI_AP);
  WiFi.softAP(ssid /*, password */ ); // pas de mot de passe = réseau ouvert

  while (!softAPEnroute) delay(10); // attendre le démarrage du service (Wi-Fi event handler)

  Serial.println("Set softAPConfig");
  IPAddress Ip(192, 168, 1, 1);
  IPAddress NMask(255, 255, 255, 0);
  WiFi.softAPConfig(Ip, Ip, NMask);

  IPAddress myIP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(myIP);


  server.on("/", HTTP_GET, [](AsyncWebServerRequest * request) {
    request->send_P(200, "text/plain", "Salut de l'ESP (AP)");
  });

  server.on("/millis", HTTP_GET, [](AsyncWebServerRequest * request) {
    char buffer[50];
    sprintf(buffer, "MASTER: millis = %lu", millis());
    request->send_P(200, "text/plain", buffer);
  });

  server.on("/total", HTTP_GET, [](AsyncWebServerRequest * request) {
    char buffer[50];
    sprintf(buffer, "%d", WiFi.softAPgetStationNum()); // nombre de client Wi-Fi connectés
    request->send_P(200, "text/plain", buffer);
  });

  server.begin();
}

void loop() {
  printWiFiClients();
  delay(5000);
}

ce code fait plusieurs choses

  • il crée un réseau Wi-Fi avec Adresse IP fixe.

  • il s’abonne (handler) aux événements arrivant sur ce réseau Wi-Fi et affiche cette activité dans le moniteur série (115200 bauds)

  • il obtient les adresses IP et MAC → ici je les affiche toutes les 5 secondes. dans le moniteur série

  • il crée un serveur web qui a 3 entrées
    192.168.1.1/ qui vous salue (“Salut de l’ESP (AP)”)
    192.168.1.1/millis qui vous donne la valeur de millis() sur cet ESP
    192.168.1.1/total qui vous donne le nombre de clients sur ce point d’accès Wi-Fi

Vous pourriez envisager que lorsqu’un client se connecte, il appelle une URL particulière pour enregistrer son IP de façon çe que le MASTER puisse ensuite le contacter directement. (et pour un peu de sécurité vous pouvez vérifier dans la table des clients si l’adresse MAC pour cette IP est bien une carte connue).

thomas456:
En terme de distance je pense atteindre plus de 500-600 m c'est pour ça que j'utilise le wifi pour avoir une plus grande distance possible.

Et ça passe? Ou tu as une antenne particulière?

thomas456:
En terme de distance je pense atteindre plus de 500-600 m c'est pour ça que j'utilise le wifi pour avoir une plus grande distance possible.

vous n'aurez Jamais 500 ou 600m en Wi-Fi, surtout pas avec le réseau créé par un ESP...

je fabrique un avion télécommander de A à Z

HTTP n'est pas le plus adapté des protocoles sans doute pour commander votre avion... vous allez vite le casser ou le perdre...

Même avec une antenne connecter le esp32