ESP32 et UDP – Transmission locale en temps réel

// Variables et librairies
import hypermedia.net.*;

UDP client;
int screen_x = 3;   //Agrandissement de l'écran
int screen_h = 240; //Taille de l'écran horizontal de la puce TTGO T Display
int screen_v = 135; //Taille de l'écran vertical de la puce TTGO T Display

int old_x;
int old_y;


// Elément à changer selon l'IP du serveur, son port, et la fréquence des données
String ip_server   = "xxx.xxx.xxx.xxx"; // IP du serveur distant
int    port_server = 1234;              // Port du serveur distant
int    port_client = 6000;              // valeur aléatoire, normalement non utilisée
int    frequence   = 100;               // fréquence d'actualisation (oui j'ai mis, 100 Hz, pas 60 Hz)


// Lancement de l'écran (se lance avant "setup()")
void settings()
{
  size(screen_v*screen_x, screen_h*screen_x);
}


// Lancement du client, connexion au serveur et fixation du framerate
void setup()
{
  frameRate(frequence);
  client = new UDP(this, port_client);
  client.listen(true);
}


// Rafraichissement de l'écran et envoi de la position de la souris au serveur
void draw()
{
  int x = mouseX;
  int y = mouseY;
  
  if(old_x != x || old_y != y)
  {
    old_x = x;
    old_y = y;
    
    background(20);
    square(x, y, 3*screen_x);
  
    // Contrairement au TCP, il n'est pas nécessaire de voir si le client est actif
    // Car on ne vérifie pas si les données sont bien reçues en UDP
    println(str(x) + " " + str(y));
    client.send( str(x/screen_x) + " " + str(y/screen_x) + "\0" , ip_server, port_server );
  }
}


// Ecoute des informations rentrant par le "port_client"
void receive( byte[] data, String ip, int port )
{
  data = subset(data, 0, data.length-2);
  String message = new String( data );

  println( "receive: \""+message+"\" from "+ip+" on port "+port );
}

//Librairies nécessaires au serveur TCP
#include "WiFi.h"
#include "AsyncUDP.h"
#include "config.h"


//Librairies et paramètres de base nécessaires à l'écran
#include <TFT_eSPI.h>
#include <SPI.h>
#include "esp_adc_cal.h"

#ifndef TFT_DISPOFF
  #define TFT_DISPOFF 0x28
#endif

#ifndef TFT_SLPIN
  #define TFT_SLPIN   0x10
#endif

#define TFT_MOSI  19
#define TFT_SCLK  18
#define TFT_CS     5
#define TFT_DC    16
#define TFT_RST   23
#define TFT_BL     4  // Display backlight control pin

TFT_eSPI tft = TFT_eSPI(135, 240); // Invoke custom library

AsyncUDP udp;

//Initialisation
void setup()
{
  //Initialisation connexion série (pour les logs)
  Serial.begin(115200);
  Serial.println("\n\nHello World");
  
  //Initilisation écran
  tft_init();

  //Connection WiFi à un routeur
  WiFi.mode(WIFI_STA);
  WiFi.begin(ROUTEUR_SSID, ROUTEUR_PASSWORD);
  if (WiFi.waitForConnectResult() != WL_CONNECTED)
  {
    tft_echec_connexion();
    while(1)
    {
      Serial.println("WiFi Failed");
      delay(1000);
    }
  }
  Serial.printf("Connected to %s, IP %s \n", ROUTEUR_SSID, WiFi.localIP().toString().c_str());
  tft_show_ip(WiFi.localIP());

  //Lancement du serveur
  if(udp.listen(SERVER_HOST_PORT)) //Si le serveur UDP peut écouter sur le port "SERVER_HOST_PORT"
  {
    udp_listen(); //Démarrer l'écoute du serveur
  }
}


//Loop, peut être laissé vide
void loop()
{
  delay(1000);
  udp.broadcast("Anyone here?");
}

#ifndef CONFIG_H
  #define CONFIG_H
  
  #define ROUTEUR_SSID     "ssid"      //ssid de votre routeur
  #define ROUTEUR_PASSWORD "password"  //mot de passe de votre routeur
  
  #define SERVER_HOST_PORT 1234
  #define SERVER_HOST_NAME "esp_server"

#endif // CONFIG_H

//Initialisation de l'écran
void tft_init()
{
  tft.init();
  tft.setRotation(0);
  tft.fillScreen(TFT_BLACK);
  tft.setTextSize(2);
  tft.setTextColor(TFT_RED);
  tft.setCursor(0, 0);
  tft.setTextDatum(MC_DATUM);
  tft.println("Hello World\n");
}

//Simulation de la souris à l'écran à partir de la trame data
void tft_mouse(char* data_, size_t len)
{
  static int vx = 0;
  static int vy = 0;

  int old_vx = vx;
  int old_vy = vy;

  char temp[20] = "";
  
  strncpy(temp, data_, len);
  temp[len] = 0;
  sscanf(temp, "%d %d", &vx, &vy);

  if(old_vx != vx || old_vy != vy)
  {
    sprintf(temp, "%d %d %d %d", old_vx, old_vy, vx, vy);
    tft.fillRect(old_vx, old_vy, 3, 3, 0x000070);
    tft.fillRect(vx, vy, 3, 3, TFT_GREEN);
  }
}

//Affichage de l'IP sur l'écran
void tft_show_ip(IPAddress data_)
{
  tft.setTextSize(2);
  tft.setTextColor(TFT_RED);
  tft.setCursor(0, 16);
  tft.println(data_);
}

//Affichage de l'IP sur l'écran
void tft_echec_connexion()
{
  tft.setTextSize(2);
  tft.setTextColor(TFT_RED);
  tft.setCursor(0, 16);
  tft.println("echec de connexion au WiFi");
}

long temps = 0;


//Configuration du serveur
void udp_listen()
{
  Serial.printf("Server UDP %s Listening on IP : %s", SERVER_HOST_NAME, WiFi.localIP().toString().c_str());

  //Activation de l'évènement : Je reçoit une trame UDP
  udp.onPacket([](AsyncUDPPacket packet)
  {
    int len = packet.length();
    if(len > 8) len = 8; //protection

    float delai = (float)(millis() - temps);
    temps = millis();

    //Données reçues (log)
    Serial.printf("\nData from %s (%2.0f Hz) : ", packet.remoteIP().toString().c_str(), 1000.0/delai );
    Serial.write(packet.data(), len);
    //udp_log(&packet); //activez ceci si vous voulez un log détaillé et envoyer une réponse au client
    
    //Envoi des données à l'écran
    tft_mouse((char*)packet.data(), packet.length());
  });
}


//Log UDP, non activé par défaut, voir fonction précédente
void udp_log(AsyncUDPPacket* packet)
{
  //Lecture complète de la trame UDP reçue
  Serial.print(" UDP Packet Type: ");
  Serial.print(packet->isBroadcast()?"Broadcast":packet->isMulticast()?"Multicast":"Unicast");
  Serial.print(", From: ");
  Serial.print(packet->remoteIP());
  Serial.print(":");
  Serial.print(packet->remotePort());
  Serial.print(", To: ");
  Serial.print(packet->localIP());
  Serial.print(":");
  Serial.print(packet->localPort());
  Serial.print(", Length: ");
  Serial.print(packet->length());
  Serial.print(", Data: ");
  Serial.write(packet->data(), packet->length());
  Serial.println();
  
  //Réponse au client
  packet->printf("Got %u bytes of data", packet->length());
}