Trier une liste UDP

Bonjour,
j'ai commencé à travailler avec un module ESP8266. Le but c'est d'envoyer par un logiciel en temps réel (Max Msp) des valeurs qui seront envoyés par le Module à des Leds (ou autre).
Je suis novice et habitué à travailler avec le Serial en utilisant simplement l'objet Serial.ParseInt pour trier une liste de données (que des chiffres de 0 à 255). Par Wifi j'utilise le protocole UDP (j'ai essayé la librairie OSC ici GitHub - hideakitai/ArduinoOSC: OSC subscriber / publisher for Arduino mais trop compliqué pour un débutant comme moi).
Si je n'envoie qu'une valeur je n'ai pas de souci à bien la recevoir (entre 0 et 255). Voici le code:

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#ifndef STASSID
#define STASSID "Chez_Boulez"
#define STAPSK "F4idm42130"
#endif

unsigned int localPort = 8888;  // local port to listen on

// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE + 1];  // buffer to hold incoming packet,
char ReplyBuffer[] = "acknowledged\r\n";        // a string to send back

WiFiUDP Udp;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(STASSID, STAPSK);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(500);
  }
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
  Serial.printf("UDP server on port %d\n", localPort);
  Udp.begin(localPort);
}

void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if (packetSize) {
    Serial.printf("Received packet of size %d from %s:%d\n    (to %s:%d, free heap = %d B)\n", packetSize, Udp.remoteIP().toString().c_str(), Udp.remotePort(), Udp.destinationIP().toString().c_str(), Udp.localPort(), ESP.getFreeHeap());

    // read the packet into packetBufffer
    byte packetBuffer = Udp.read();
    //packetBuffer[n] = 0;
    Serial.println("Contents:");
    Serial.println(packetBuffer);

   
  }
}

Par contre si j'envoie plusieurs valeurs seulement la première est prise en compte.
Après plusieurs recherche je suis tombé sur un vieux code qu'utilise des String mais je n'ai toujours pas de valeurs en sorties, à part le premier (si c'est du texte).

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#ifndef STASSID
#define STASSID "Chez_Boulez"
#define STAPSK "F4idm42130"
#endif


unsigned int localPort = 8888;  // local port to listen on

// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE];  // buffer to hold incoming packet,

WiFiUDP Udp;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(STASSID, STAPSK);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(500);
  }
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
  Serial.printf("UDP server on port %d\n", localPort);
  Udp.begin(localPort);
}


void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if (packetSize) {

    // read the packet into packetBufffer
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
    // Serial.println("Contents:");
    // Serial.println(packetBuffer);

    
    // Create a new String object to be split
    char *p = (packetBuffer);
    char *str;
    int index = 0;
    String values[3];
    while ((str = strtok_r(p, " ", &p)) != NULL)
    {
      values[index] = str;
      index++;
    }

    String V1 = values[0];
    String V2 = values[1];
    String V3 = values[2];

    // Sending the parts to Serial Monitor
     Serial.println ("V1 ");
     Serial.println(V1);
         Serial.println ("V2 ");
    Serial.println(V2);
        Serial.println ("V3 ");
    Serial.println(V3);
  }
  delay(10);
}
  

Désolé d'avance de mon incompetence et merci de votre aide.
Claudio

Cette commande lit l’ensemble des octets émis et range cela dans le tableau

Il vaudrait mieux écrire
Udp.read(packetBuffer, packetSize);
Puisqu’on sait qu’on a reçu packetSize octets

Et déclarer
byte packetBuffer[UDP_TX_PACKET_MAX_SIZE]; // buffer to hold incoming packet,
Puisqu’on stocke des octets et pas des caractères (même si au final ça reste des octets)

Ensuite il vous suffit de faire une boucle for pour parcourir les packetSize octets reçus et rangés dans le tableau

Il est difficile de lire ton code, si celui-ci n'est pas correctement mis en page.
il y a une balise "< code />" qui est dédié à ça.

Pardon .... il y a eu un bug !
Voici mon message à nouveau

Merci beaucoup de votre réponse rapide. Mais comme je disais je suis vraiment débutant. J'ai cherché de mieux comprendre à partir de votre retour mais je pense que je suis encore bien loin.
Si je déclare byte packetBuffer[UDP_TX_PACKET_MAX_SIZE]; // buffer to hold incoming packet, je ne peux plus voir par le Serial le buffer ?
j'ai un erreur avec ce code:

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#ifndef STASSID
#define STASSID "Chez_Boulez"
#define STAPSK "F4idm42130"
#endif

unsigned int localPort = 8888; // local port to listen on

// buffers for receiving and sending data
byte packetBuffer[UDP_TX_PACKET_MAX_SIZE + 1]; // buffer to hold incoming packet,

WiFiUDP Udp;

void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(STASSID, STAPSK);
while (WiFi.status() != WL_CONNECTED) {
Serial.print('.');
delay(500);
}
Serial.print("Connected! IP address: ");
Serial.println(WiFi.localIP());
Serial.printf("UDP server on port %d\n", localPort);
Udp.begin(localPort);
}

void loop() {
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if (packetSize) {
Serial.printf("Received packet of size %d from %s:%d\n (to %s:%d, free heap = %d B)\n", packetSize, Udp.remoteIP().toString().c_str(), Udp.remotePort(), Udp.destinationIP().toString().c_str(), Udp.localPort(), ESP.getFreeHeap());

// read the packet into packetBufffer


Udp.read(packetBuffer, packetSize);


Serial.println("Contents:");
Serial.println(packetBuffer);


}
}

Pourquoi avec ce prochain code je ne peux pas voir ce qu'il contient le buffer ?

unsigned int localPort = 8888; // local port to listen on

// buffers for receiving and sending data
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; // buffer to hold incoming packet,

WiFiUDP Udp;

void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(STASSID, STAPSK);
while (WiFi.status() != WL_CONNECTED) {
Serial.print('.');
delay(500);
}
Serial.print("Connected! IP address: ");
Serial.println(WiFi.localIP());
Serial.printf("UDP server on port %d\n", localPort);
Udp.begin(localPort);
}

void loop() {
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if (packetSize) {


// read the packet into packetBufffer
Udp.read(packetBuffer, packetSize);


// Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
Serial.println("Contents:");
Serial.println(packetBuffer);

// Create a new String object to be split
char *p = (packetBuffer);
char *str;
int index = 0;
String values[3];
while ((str = strtok_r(p, " ", &p)) != NULL)
{
  values[index] = str;
  index++;
}

String V1 = values[0];
String V2 = values[1];
String V3 = values[2];

// Sending the parts to Serial Monitor
 Serial.println ("V1 ");
 Serial.println(V1);
     Serial.println ("V2 ");
Serial.println(V2);
    Serial.println ("V3 ");
Serial.println(V3);


}
delay(10);
}

Merci d'avance.

Si tu peux écrire ton buffer dans la liaison série.
Si ton buffer contient des caractères ASCII, cela ne pose pas de problème.
Comme tu passais par la liaison série, je suppose que tu échange du texte.

si je charge ce code j'ai une erreur qui s'affiche "no matching function for call to 'println(byte [8193])'"

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#ifndef STASSID
#define STASSID "Chez_Boulez"
#define STAPSK "F4idm42130"
#endif

unsigned int localPort = 8888; // local port to listen on

// buffers for receiving and sending data
byte packetBuffer[UDP_TX_PACKET_MAX_SIZE + 1]; // buffer to hold incoming packet,

WiFiUDP Udp;

void setup() {
Serial.begin(115200);
WiFi.mode(WIFI_STA);
WiFi.begin(STASSID, STAPSK);
while (WiFi.status() != WL_CONNECTED) {
Serial.print('.');
delay(500);
}
Serial.print("Connected! IP address: ");
Serial.println(WiFi.localIP());
Serial.printf("UDP server on port %d\n", localPort);
Udp.begin(localPort);
}

void loop() {
// if there's data available, read a packet
int packetSize = Udp.parsePacket();
if (packetSize) {
Serial.printf("Received packet of size %d from %s:%d\n (to %s:%d, free heap = %d B)\n", packetSize, Udp.remoteIP().toString().c_str(), Udp.remotePort(), Udp.destinationIP().toString().c_str(), Udp.localPort(), ESP.getFreeHeap());

// read the packet into packetBufffer


Udp.read(packetBuffer, packetSize);


Serial.println("Contents:");
Serial.println(packetBuffer);


}
}

Oui tu as déclaré ton buffer un tableau de byte, si c'est des caractéres que tu échange tu aurais le déclarer en tableau de char, je crois, comme tu l'a fait dans l'un des codes que tu as mis au début de ton post.

Justement car J-M-L me conseillait de déclarer plutôt Byte.
Du coup je suis un peu perdu car avec byte pas possible de récupérer les valeurs dans le monitor....

Je ne sais pas trop pourquoi il t'a conseillé ça, en tout cas moi je préfère avoir un nombre entre 0 et 255(byte), plutôt qu'un nombre entre -128 et 127(char).

Mais si ton but finale est d'afficher le texte sur la liaison série, il faut utiliser le type demandé par Serial.print, ou alors faire un cast avec l'instruction suivante:

Serial.println((char*)packetBuffer);

Merci beaucoup Terwal,
effectivement je n'ai plus d'erreur (et je constate que je n'ai pas du tout de bases dans la matière !).
Mon dernier code le voici :

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

#ifndef STASSID
#define STASSID "F4IDM_Wifi"
#define STAPSK "F4idm42130"
#endif


unsigned int localPort = 8888;  // local port to listen on

// buffers for receiving and sending data
byte packetBuffer[UDP_TX_PACKET_MAX_SIZE];  // buffer to hold incoming packet,

WiFiUDP Udp;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(STASSID, STAPSK);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(500);
  }
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
  Serial.printf("UDP server on port %d\n", localPort);
  Udp.begin(localPort);
}


void loop() {
  // if there's data available, read a packet
  int packetSize = Udp.parsePacket();
  if (packetSize) {

    // read the packet into packetBufffer
    Udp.read(packetBuffer, packetSize);
   // Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE);
     Serial.println("Contents:");
  Serial.println((char*)packetBuffer);

    
    // Create a new String object to be split
    char *p = ((char*)packetBuffer);
    char *str;
    int index = 0;
    String values[3];
    while ((str = strtok_r(p, " ", &p)) != NULL)
    {
      values[index] = str;
      index++;
    }

    String V1 = values[0];
    String V2 = values[1];
    String V3 = values[2];

    // Sending the parts to Serial Monitor
     Serial.println ("V1 ");
     Serial.println(V1);
         Serial.println ("V2 ");
    Serial.println(V2);
        Serial.println ("V3 ");
    Serial.println(V3);
  }
  delay(10);
}

Le problème c'est que dans mon Serial les variables V1 V2 et V3 ne reçoivent rien. Voici ce que je reçois dans le Monitor:

Contents:
list
V1
list
V2

V3

Merci d'avance !!!!!

Salut.
Si ton buffer contient des données binaires non imprimables, Serial.print() va afficher des caractères bizarroïdes.
Si ton buffer est déclaré en tableau de bytes, Serial ne possède pas de méthode print() permettant de l'afficher. Fais une boucle pour afficher chaque caractère, en hexa par exemple, avec un espace entre chaque.
Si ton buffer est censé contenir uniquement des caractères ASCII imprimables, déclare le en tableau de char, et affiche le avec Serial.println().

On ne sait pas ce que tu lis, peut être pourrait tu rajouter des println dans le while qui découpe le texte envoyé.
un truc du genre Serial.print("strtok: ");Serial.println(str);

De même comme l'indique @hbachetti , si tu affichais ton buffer en hexadécimal, on pourrait appréhender ce qu'il y a dans ton buffer.

De toutes façons, à partir du moment où l'on utilise strtok(), le buffer est forcément un tableau de char, terminé par '\0'.

Certes, mais là on n'a aucune idée du nombre de strtok qui est effectué, 0, 1, 2, 3, 100, ni de ce qu'il manipule.
Le but n'étant pas que cela solutionne le problème, mais d'avoir un peu de retour si cela se passe bien comme attendue.

Et on n'a aucune idée des données qui sont envoyées, pour l'instant ...

Normalement c'est une liste de nombre, mais effectivement on ne sait pas si c'est du texte, comme il le faisait avec la liaison série, ou maintenant directement des byte
puisqu'il veut trié ces bytes, le plus simple serait de ne plus passer par du texte, mais bien par un tableau de byte, de bout en bout.

Déjà un grand merci à vous de vous intéresser à ce sujet et pour votre aide. Je ne cache pas que j'ai un peu honte car je suis vraiment débutant.
Pour mieux expliquer mon projet de vous joins le code que j'utilise avec la connexion par USB:

/* SERVO */

#include "SPI.h"
#include "WS2801.h"
#include <Adafruit_NeoPixel.h>

int dataPin = 4; // Leds
int clockPin = 5; // Leds
int nbLeds = 151; // nombre Leds
int Laser1= 9;
int Laser2= 11;
int Laser3= 12;

byte ja1, ja2, jb1, jb2, jc1, jc2, jd1, jd2, je1, je2, jf1, jf2, jg1, jg2, jh1, jh2, ji1, ji2;

byte val1a, val2a, val3a, val1b, val2b, val3b, val1c, val2c, val3c, val4a, val4b, val4c, val5a, val5b, val5c, val6a, val6b, val6c, val7a, val7b, val7c, val8a, val8b, val8c,val9a, val9b, val9c;

// Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row
WS2801 strip = WS2801(nbLeds, dataPin, clockPin);

void setup()

{
 
  pinMode(Laser1, OUTPUT); // Laser 1
   pinMode(Laser2, OUTPUT); // Laser 2
    pinMode(Laser3, OUTPUT); // Laser 3
  
strip.begin();
 // Update LED contents, to start they are all 'off'
  strip.show();
  Serial.begin(57600);

}

void loop(){

  while (Serial.available()) {

    ja1 = Serial.parseInt();
    ja2 = Serial.parseInt();
    val1a = Serial.parseInt();
    val1b = Serial.parseInt();
    val1c = Serial.parseInt();

    jb1 = Serial.parseInt();
    jb2 = Serial.parseInt();
    val2a = Serial.parseInt();
    val2b = Serial.parseInt();
    val2c = Serial.parseInt();

    jc1 = Serial.parseInt();
    jc2 = Serial.parseInt();
    val3a = Serial.parseInt();
    val3b = Serial.parseInt();
    val3c = Serial.parseInt();

    jd1 = Serial.parseInt();
    jd2 = Serial.parseInt();
    val4a = Serial.parseInt();
    val4b = Serial.parseInt();
    val4c = Serial.parseInt();

    je1 = Serial.parseInt();
    je2 = Serial.parseInt();
    val5a = Serial.parseInt();
    val5b = Serial.parseInt();
    val5c = Serial.parseInt();

    jf1 = Serial.parseInt();
    jf2 = Serial.parseInt();
    val6a = Serial.parseInt();
    val6b = Serial.parseInt();
    val6c = Serial.parseInt();

    jg1 = Serial.parseInt();
    jg2 = Serial.parseInt();
    val7a = Serial.parseInt();
    val7b = Serial.parseInt();
    val7c = Serial.parseInt();

    jh1 = Serial.parseInt();
    jh2 = Serial.parseInt();
    val8a = Serial.parseInt();
    val8b = Serial.parseInt();
    val8c = Serial.parseInt();

    ji1 = Serial.parseInt();
    ji2 = Serial.parseInt();
    val9a = Serial.parseInt();
    val9b = Serial.parseInt();
    val9c = Serial.parseInt();

     int num1 = Serial.parseInt();
    int num2 = Serial.parseInt();
    int num3 = Serial.parseInt();
    


    if (Serial.read()) {

      {
        byte j;
        for (j = ja1 ; j < ja2; j++) {
          strip.setPixelColor (j, val1a, val1b, val1c);
        }
      }
      {
        byte j;
        for (j = jb1 ; j < jb2; j++)  {
          strip.setPixelColor (j, val2a, val2b, val2c);
        }
      }
      {

        byte j;
        for (j = jc1 ; j < jc2; j++)  {
          strip.setPixelColor (j, val3a, val3b, val3c);
        }
      }
      {
        byte j;
        for (j = jd1 ; j < jd2; j++) {
          strip.setPixelColor (j, val4a, val4b, val4c);
        }
      }
      {
        byte j;
        for (j = je1 ; j < je2; j++)  {
          strip.setPixelColor (j, val5a, val5b, val5c);
        }
      }
      {
        byte j;
        for (j = jf1 ; j < jf2; j++)  {
          strip.setPixelColor (j, val6a, val6b, val6c);
        }
      }
      {
        byte j;
        for (j = jg1 ; j < jg2; j++)  {
          strip.setPixelColor (j, val7a, val7b, val7c);
        }
      }
        {
        byte j;
        for (j = jh1 ; j < jh2; j++)  {
          strip.setPixelColor (j, val8a, val8b, val8c);
        }
       }
        {
        byte j;
        for (j = ji1 ; j < ji2; j++)  {
          strip.setPixelColor (j, val9a, val9b, val9c);
        }
       
        strip.show();
      }
 
      analogWrite(Laser1, num1);
           analogWrite(Laser2, num2);
                analogWrite(Laser3, num3);
    }
  }
}


Cela me permet de moduler en temps réel des Leds adressable et autre.
En fait je voudrais reproduire le même principe mais en utilisant un ESP8266. Du peu que j'avais compris, je me servais du Monitor pour vérifier que toutes les données étaient bien là ! Je croyais que la translation entre le Code pour une connexion Serial et une connexion par Wifi était plus facile, mais je m'aperçois que non.
Si vous pouvez à partir de ces considerations m'aider à transformer ce code pour une connexion Wifi (ou alors m'avouer que c'est trop complexe pour mon niveau) je vous serais très reconnaissant !!!!
Déjà j'arrive à connecter ma carte correctement et à envoyer des données (grand exploit :face_with_open_eyes_and_hand_over_mouth:) mais si je peux aller plus loin ça serait très bien pour mon futur travail !


Et pour information voici ce que j'envoie à partir de mon logiciel.
Normalement je peux envoyer n'importe quel format. Donc adapter les envois si nécessaire.


Par exemple voici pour un protocole WIFI les envois TEST par UDP

c'est parce que je pensais que son système envoyait des trames en binaires