Problème de conversion avec les char* et string

Bonjour à tous...
Je suis sur un projet avec deux ESP32S; le premier récupère les tags de Foobar via le wifi et un serveur FTP et transmet différentes info au deuxième ESP32S via le port série (à terme ça sera par radio).
Le deuxième ESP32S reçoit la trame et la découpe vers les bonnes variables char* avec strtok dans le but d'afficher certaines sur deux bandeaux LED. J'utilise la bibliothèque Parola et celle-ci impose comme type de variable du char. Je veux afficher deux variables sur le premier bandeau donc je dois coller les valeurs de deux variables char* dans une seule pour l'envoyer à Parola. J'arrive à transformer tout ça en String mais après impossible de transformer le résultat en char*.
En gros je veux afficher deux variables "Album" et "Artiste" et elles doivent se retrouver dans "TextHaut".

Je mets le code.

//ESP32S
//Programme pour afficher les tags sur deux bandeaux LED. Liaison par radio au premier ESP32

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

// Define the number of devices we have in the chain and the hardware interface
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 16

// Bandeau haut
#define CLK_PINH   27
#define DATA_PINH  25
#define CS_PINH    26
MD_Parola AffichHaut = MD_Parola(HARDWARE_TYPE, DATA_PINH, CLK_PINH, CS_PINH, MAX_DEVICES);

// Bandeau bas
#define CLK_PINB   28    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#define DATA_PINB  29    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#define CS_PINB    30    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
MD_Parola AffichBas = MD_Parola(HARDWARE_TYPE, DATA_PINB, CLK_PINB, CS_PINB, MAX_DEVICES);

char *EtatFoo = "";
char *Artiste = "";
char *Album = "";
char *Titre = "";
char *Bitrate = "";
char *Codec = "";
char *Duree = "";
char *TextHaut = "";
char *TextBas = "";
char *SerialRead = "";
char *SerialUse = "";
char *WifiEtat = "";
char *FtpEtat = "";
String SerialReadTmp;
int PortSerie;

String SerialUseTest; // A supprimer à la fin



// Mise en forme des tags dans les variables
void ExtrTags(){
  //Extract des tags vers les variables
  // int WifiEtat = WifiEtatChar;
  // int FtpEtat = FtpEtatChar;
  // WifiEtatChar = strtok(SerialUse, "<");
  // FtpEtatChar = strtok(NULL, "<");
  WifiEtat = strtok(SerialUse, "<");
  FtpEtat = strtok(NULL, "<");
  EtatFoo = strtok(NULL, "<");
  Artiste = strtok(NULL, "<");
  Album = strtok(NULL, "<");
  Titre = strtok(NULL, "<");
  Bitrate = strtok(NULL, "<");
  Codec = strtok(NULL, "<");
  Duree = strtok(NULL, "<");
  SerialUse = "";

  // Envoi vers le moniteur série
  // A supprimer à la fin
  Serial.print("WifiEtat: ");
  Serial.println(WifiEtat);
  Serial.print("FtpEtat: ");
  Serial.println(FtpEtat);
  Serial.print("EtatFoo: ");
  Serial.println(EtatFoo);
  Serial.print("Artiste: ");
  Serial.println(Artiste);
  Serial.print("Album: ");
  Serial.println(Album);
  Serial.print("Titre: ");
  Serial.println(Titre);
  Serial.print("Bitrate: ");
  Serial.println(Bitrate);
  Serial.print("Codec: ");
  Serial.println(Codec);
  Serial.print("Duree: ");
  Serial.println(Duree);
  }

void Afficher(){
  if(AffichHaut.displayAnimate()) {
    Serial.println("Affichage Haut en cours");  // A supprimer à la fin
    AffichHaut.displayText(TextHaut, AffichHaut.getTextAlignment(), AffichHaut.getSpeed(), AffichHaut.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichHaut.displayReset();
  }
 
  if(AffichBas.displayAnimate()) {
   Serial.println("Affichage Bas en cours");  // A supprimer à la fin
    AffichBas.displayText(TextBas, AffichBas.getTextAlignment(), AffichBas.getSpeed(), AffichBas.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichBas.displayReset();
  }
}


void setup() {
  //Initialisation moniteur série
  //A supprimer à la fin
  Serial.begin(115200);
  Serial.println("Initialisation du moniteur série");

  //Initialisation du port série
  Serial2.begin(115200);

  // Initialisation des bandeaux LED
  AffichHaut.begin();
  AffichHaut.setIntensity(0);
  AffichHaut.setTextAlignment(PA_LEFT);
  AffichHaut.setSpeed(50);
  AffichHaut.setPause(3000);
  AffichHaut.displayClear();
  AffichBas.begin();
  AffichBas.setIntensity(0);
  AffichBas.setTextAlignment(PA_LEFT);
  AffichBas.setSpeed(50);
  AffichBas.setPause(3000);
  AffichBas.displayClear();

  WifiEtat, FtpEtat, PortSerie = 0;
}


void loop() {
  //Reception des tags depuis ESP32S via le port série
  if(Serial2.available() > 0){
    Serial.println("Reception port série en cours");  // A supprimer à la fin
    SerialReadTmp = "";
    SerialReadTmp = Serial.readString();
    SerialReadTmp.toCharArray(SerialRead, 100);
    Serial.println(SerialRead);  // A supprimer à la fin
    SerialUse = SerialRead;
    Serial.print("Trame venant du port série");  // A supprimer à la fin
    TEST = SerialUse;
    Serial.println(TEST);  // A supprimer à la fin
    ExtrTags();

    // Formatage des données reçues du port série: < WifiSend < FtpSend < FoobarSend




      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      // METTRE EN FORME SerialUse avec les bons tags
      Afficher();
    }
}

Merci à tous et bon dimanche ^^

Au passage c'est mieux de faire

char *EtatFoo = nullptr;
char *Artiste = nullptr;
char *Album = nullptr;
char *Titre = nullptr;
char *Bitrate = nullptr;
...

plutôt que de pointer vers une chaîne vide

Avec cela vous ne réservez aucune mémoire pour le contenu du texte

donc vous ne pourrez pas "mettre du texte dedans". il faut un buffer

char  texteHaut[81]; // de la place pour 80 catactères et le nul final
char texteBas[81];   // de la place pour 80 catactères et le nul final

ensuite si vous voulez fabriquer un contenu à partir de vos pointeurs issus de strtok() vous pouvez utilisez sprintf() ou mieux snprintf() (pour ne pas déborder)

par exemple:

snprintf(texteHaut, sizeof texteHaut, "artiste: %s, Album: %s", Artiste, Album);

vous pouvez utiliser %s pour représenter l'endroit où il faudra injecter du texte en provenance d'un pointeur vers des caractères (lisez la doc si vous voulez mettre des nombres sous différents formats)

Ahhhh merci beaucoup ^^

Je regarde tout de suite la doc pour comprendre comment fonctionne snprintf.
Par contre là j'ai un doute. Il vaut mieux utiliser char *Album = nullptr ou char Album [81] ? nullptr ne réserve rien en mémoire mais [81] va en réserver pour 81 caractères.

strtok extrait des pointeurs qui pointent au sein d'un buffer, donc tout ce qui provient de strtok, c'est OK de les déclarer sous forme de pointeurs (j'ai supposé que SerialUse dans votre code était un buffer bien formé) et de les initialiser avec nullptr (ie au début avant le strtok ils ne pointent vers rien du tout)

par contre si vous voulez fabriquer une zone de stockage il faut allouer de la mémoire, donc le tableau de caractères

Voici un exemple de trame que le deuxième ESP32S va recevoir sur le port série à chaque changement de moreau ou d'état de Foobar (play, pause, stop)
"1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02"
EtatWifi<EtatFtp<EtatFoo<Artiste<Album<Titre<Codec<Duree

OK

il faut que ce message
1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02
soit bien dans un buffer modifiable de type tableau de caractères ➜ pour écouter le port série vous pouvez jeter un oeil à mon petit tuto sur le sujet

ensuite vous pouvez en effet appliquer vos strtok() qui vont convertir les '<' en caractères nuls et conserver des pointeurs vers les zones de débuts dans ce buffer

ensuite vous utilisez snprintf() pour fabriquer votre message de sortie, il aussi un buffer modifiable de type tableau de caractères

Voila, j'ai modifier le code pour tester la gestion des tags et à l'exécution j'ai des messages d'erreur et l'ESP32S qui reboot en boucle.


ELF file SHA256: 0000000000000000

Backtrace: 0x4000c6f2:0x3ffb1f30 0x400d3b21:0x3ffb1f50 0x400d0c61:0x3ffb1f70 0x400d0dc6:0x3ffb1f90 0x400d1f45:0x3ffb1fb0 0x400860ed:0x3ffb1fd0

Rebooting...
ets Jul 29 2019 12:21:46

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
Initialisation du moniteur série
Reception port série en cours
Trame venant du port série1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02
Guru Meditation Error: Core  1 panic'ed (LoadStoreError). Exception was unhandled.
Core 1 register dump:
PC      : 0x4000c6f2  PS      : 0x00060930  A0      : 0x800d3b24  A1      : 0x3ffb1f30  
A2      : 0x3f4001b6  A3      : 0x00000000  A4      : 0x3ffb844c  A5      : 0x00000001  
A6      : 0x00ff0000  A7      : 0xff000000  A8      : 0x3f4001b7  A9      : 0x3f4001b8  
A10     : 0x3f400120  A11     : 0x0000003c  A12     : 0x0000003c  A13     : 0x0000ff00  
A14     : 0x00ff0000  A15     : 0xff000000  SAR     : 0x0000001f  EXCCAUSE: 0x00000003  
EXCVADDR: 0x3f4001b7  LBEG    : 0x400014fd  LEND    : 0x4000150d  LCOUNT  : 0xffffffff  

ELF file SHA256: 0000000000000000

Backtrace: 0x4000c6f2:0x3ffb1f30 0x400d3b21:0x3ffb1f50 0x400d0c61:0x3ffb1f70 0x400d0dc6:0x3ffb1f90 0x400d1f45:0x3ffb1fb0 0x400860ed:0x3ffb1fd0

Rebooting...

Voici le code de test

//ESP32S
//Programme pour afficher les tags sur deux bandeaux LED. Liaison par radio au premier ESP32

char *EtatFoo = nullptr;
char *Artiste = nullptr;
char *Album = nullptr;
char *Titre = nullptr;
char *Bitrate = nullptr;
char *Codec = nullptr;
char *Duree = nullptr;
char *TexteHaut = nullptr;
char *TexteBas = nullptr;
char *SerialRead = nullptr;
char *SerialUse = nullptr;
char *WifiEtat = nullptr;
char *FtpEtat = nullptr;
String SerialReadTmp;

// Mise en forme des tags dans les variables
void ExtrTags(){
  WifiEtat = strtok(SerialUse, "<");
  FtpEtat = strtok(NULL, "<");
  EtatFoo = strtok(NULL, "<");
  Artiste = strtok(NULL, "<");
  Album = strtok(NULL, "<");
  Titre = strtok(NULL, "<");
  Bitrate = strtok(NULL, "<");
  Codec = strtok(NULL, "<");
  Duree = strtok(NULL, "<");
  SerialUse = "";

  // Envoi vers le moniteur série
  // A supprimer à la fin
  Serial.print("WifiEtat: ");
  Serial.println(WifiEtat);
  Serial.print("FtpEtat: ");
  Serial.println(FtpEtat);
  Serial.print("EtatFoo: ");
  Serial.println(EtatFoo);
  Serial.print("Artiste: ");
  Serial.println(Artiste);
  Serial.print("Album: ");
  Serial.println(Album);
  Serial.print("Titre: ");
  Serial.println(Titre);
  Serial.print("Bitrate: ");
  Serial.println(Bitrate);
  Serial.print("Codec: ");
  Serial.println(Codec);
  Serial.print("Duree: ");
  Serial.println(Duree);
  }

void setup() {
  //Initialisation moniteur série
  //A supprimer à la fin
  Serial.begin(115200);
  Serial.println("Initialisation du moniteur série");

  WifiEtat, FtpEtat = 0;
}

// Boucle de test
void loop() {
  //Reception des tags depuis ESP32S via le port série
    Serial.println("Reception port série en cours");  // A supprimer à la fin
    SerialRead = "1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02";
    SerialUse = SerialRead;
    Serial.print("Trame venant du port série");  // A supprimer à la fin
    Serial.println(SerialUse);  // A supprimer à la fin
    ExtrTags();

    // Formatage des données reçues du port série: < WifiSend < FtpSend < FoobarSend
    // snprintf(texteHaut, sizeof texteHaut, "artiste: %s, Album: %s", Artiste, Album)
    snprintf(TexteHaut, sizeof TexteHaut, "%s - %s", Artiste, Album);
    snprintf(TexteBas, sizeof TexteBas, "%s - %s", Titre, Duree);
    delay(5000);
}

// "1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02"

vous ne pouvez pas faire cela car la chaîne est câblée en dur et non modifiable. son type c'est const char *, pas char *

voici un exemple

const size_t tailleMaxMessage = 100;
const char * separateurs = "<";

char messageRecu[tailleMaxMessage];
char TexteHaut[tailleMaxMessage];
char TexteBas[tailleMaxMessage];

void analyser(char * message) {
  char * WifiEtat   = strtok(message, separateurs);
  char * FtpEtat    = strtok(NULL, separateurs);
  char * EtatFoo    = strtok(NULL, separateurs);
  char * Artiste    = strtok(NULL, separateurs);
  char * Album      = strtok(NULL, separateurs);
  char * Titre      = strtok(NULL, separateurs);
  char * Bitrate    = strtok(NULL, separateurs);
  char * Codec      = strtok(NULL, separateurs);
  char * Duree      = strtok(NULL, separateurs);

  Serial.print("WifiEtat: ");   Serial.println(WifiEtat);
  Serial.print("FtpEtat: ");    Serial.println(FtpEtat);
  Serial.print("EtatFoo: ");    Serial.println(EtatFoo);
  Serial.print("Artiste: ");    Serial.println(Artiste);
  Serial.print("Album: ");      Serial.println(Album);
  Serial.print("Titre: ");      Serial.println(Titre);
  Serial.print("Bitrate: ");    Serial.println(Bitrate);
  Serial.print("Codec: ");      Serial.println(Codec);
  Serial.print("Duree: ");      Serial.println(Duree);


  snprintf(TexteHaut, sizeof TexteHaut, "%s - %s", Artiste, Album);
  snprintf(TexteBas, sizeof TexteBas, "%s - %s", Titre, Duree);

  Serial.print("TexteHaut: ");  Serial.println(TexteHaut);
  Serial.print("TexteBas: ");   Serial.println(TexteBas);
}


void setup() {
  Serial.begin(115200);
  // simulation de réception dans messageRecu
  strlcpy(messageRecu, "1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02", tailleMaxMessage);

  // analyse du message et fabrication de TexteHaut et TexteBas
  analyser(messageRecu);
}

void loop() {}

Ahhh d'accord. Je voulais tester sans trop me prendre la tète ben c'est raté lol
Merci encore pour ton aide, je regarde ça tout à l'heure.

Bonsoir...
Déja un grand merci pour ton aide ^^

J'ai un problème de reboot de l'ESP32S et je ne comprends pas d'où ça vient donc j'ai fait des essaies à partir de ton code et l'affichage sur les deux bandeau LED fonctionne très bien. Pour la boucle Loop ça tourne en boucle mais je verrai ça après ainsi que pour la liaison série

Voici le code qui fonctionne:

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

// Define the number of devices we have in the chain and the hardware interface
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 16

// Afficheur haut
#define CLK_PINH   27
#define DATA_PINH  25
#define CS_PINH    26
MD_Parola AffichHaut = MD_Parola(HARDWARE_TYPE, DATA_PINH, CLK_PINH, CS_PINH, MAX_DEVICES);

// Afficheur bas
#define CLK_PINB   13    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#define DATA_PINB  14    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
#define CS_PINB    12    //Mettre les pins XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
MD_Parola AffichBas = MD_Parola(HARDWARE_TYPE, DATA_PINB, CLK_PINB, CS_PINB, 8);

const size_t TailleMaxMessage = 100;
char TexteHaut[TailleMaxMessage];
char TexteBas[TailleMaxMessage];

// Affichage des bandeaux
void Afficher() {
  // A supprimer à la fin
  if(AffichHaut.displayAnimate()) {
    AffichHaut.displayText(TexteHaut, AffichHaut.getTextAlignment(), AffichHaut.getSpeed(), AffichHaut.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichHaut.displayReset();
  }
 
  if(AffichBas.displayAnimate()) {
    AffichBas.displayText(TexteBas, AffichBas.getTextAlignment(), AffichBas.getSpeed(), AffichBas.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichBas.displayReset();
  }
}

// const size_t TailleMaxMessage = 100;
const char * separateurs = "<";

char messageRecu[TailleMaxMessage];
// char TexteHaut[TailleMaxMessage];
// char TexteBas[TailleMaxMessage];

void analyser(char * message) {
  Serial.print(message);
  char * WifiEtat   = strtok(message, separateurs);
  char * FtpEtat    = strtok(NULL, separateurs);
  char * EtatFoo    = strtok(NULL, separateurs);
  char * Artiste    = strtok(NULL, separateurs);
  char * Album      = strtok(NULL, separateurs);
  char * Titre      = strtok(NULL, separateurs);
  char * Bitrate    = strtok(NULL, separateurs);
  char * Codec      = strtok(NULL, separateurs);
  char * Duree      = strtok(NULL, separateurs);

  Serial.print("WifiEtat: ");   Serial.println(WifiEtat);
  Serial.print("FtpEtat: ");    Serial.println(FtpEtat);
  Serial.print("EtatFoo: ");    Serial.println(EtatFoo);
  Serial.print("Artiste: ");    Serial.println(Artiste);
  Serial.print("Album: ");      Serial.println(Album);
  Serial.print("Titre: ");      Serial.println(Titre);
  Serial.print("Bitrate: ");    Serial.println(Bitrate);
  Serial.print("Codec: ");      Serial.println(Codec);
  Serial.print("Duree: ");      Serial.println(Duree);


  snprintf(TexteHaut, sizeof TexteHaut, "%s - %s", Artiste, Album);
  snprintf(TexteBas, sizeof TexteBas, "%s - %s", Titre, Duree);

  Serial.print("TexteHaut: ");  Serial.println(TexteHaut);
  Serial.print("TexteBas: ");   Serial.println(TexteBas);
}


void setup() {
    // Initialisation des bandeaux LED
  AffichHaut.begin();
  AffichHaut.setIntensity(0);
  AffichHaut.setTextAlignment(PA_LEFT);
  AffichHaut.setSpeed(30);
  AffichHaut.setPause(3000);
  AffichHaut.displayClear();
  AffichBas.begin();
  AffichBas.setIntensity(0);
  AffichBas.setTextAlignment(PA_LEFT);
  AffichBas.setSpeed(30);
  AffichBas.setPause(3000);
  AffichBas.displayClear();

  Serial.begin(115200);
  // simulation de réception dans messageRecu
  strlcpy(messageRecu, "1<1<playing<Massive Attack<Collected<Danny The Dog<191<MP3<6:02", TailleMaxMessage);

  // analyse du message et fabrication de TexteHaut et TexteBas
  analyser(messageRecu);
}

void loop() {
  Afficher();
}

Voici mon code qui fait rebooter

// ESP32S
// Programme pour afficher les tags sur deux bandeaux LED. Liaison par radio au premier ESP32

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

// Define the number of devices we have in the chain and the hardware interface
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 16

// Afficheur haut
#define CLK_PINH   27
#define DATA_PINH  25
#define CS_PINH    26
MD_Parola AffichHaut = MD_Parola(HARDWARE_TYPE, DATA_PINH, CLK_PINH, CS_PINH, MAX_DEVICES);

// Afficheur bas
#define CLK_PINB   13 
#define DATA_PINB  14
#define CS_PINB    12
MD_Parola AffichBas = MD_Parola(HARDWARE_TYPE, DATA_PINB, CLK_PINB, CS_PINB, MAX_DEVICES);

#define RXD2 16
#define TXD2 17

char *EtatFoo = nullptr;
char *Artiste = nullptr;
char *Album = nullptr;
char *Titre = nullptr;
char *Bitrate = nullptr;
char *Codec = nullptr;
char *Duree = nullptr;

const size_t TailleMaxMessage = 100;
const char * separateurs = "<";
char TexteHaut[TailleMaxMessage];
char TexteBas[TailleMaxMessage];

char SerialRead[TailleMaxMessage];
char *SerialUse = nullptr;
char *WifiEtat = nullptr;
char *FtpEtat = nullptr;

String SerialReadTmp;

// Mise en forme des tags dans les variables
void ExtrTags(char * message) {
  WifiEtat = strtok(message, separateurs);
  FtpEtat  = strtok(NULL, separateurs);
  EtatFoo  = strtok(NULL, separateurs);
  Artiste  = strtok(NULL, separateurs);
  Album    = strtok(NULL, separateurs);
  Titre    = strtok(NULL, separateurs);
  Bitrate  = strtok(NULL, separateurs);
  Codec    = strtok(NULL, separateurs);
  Duree    = strtok(NULL, separateurs);
}

// Envoi vers le moniteur série  // A supprimer à la fin
void MoniSerie(){
  Serial.print("WifiEtat: ");   Serial.println(WifiEtat);
  Serial.print("FtpEtat: ");    Serial.println(FtpEtat);
  Serial.print("EtatFoo: ");    Serial.println(EtatFoo);
  Serial.print("Artiste: ");    Serial.println(Artiste);
  Serial.print("Album: ");      Serial.println(Album);
  Serial.print("Titre: ");      Serial.println(Titre);
  Serial.print("Bitrate: ");    Serial.println(Bitrate);
  Serial.print("Codec: ");      Serial.println(Codec);
  Serial.print("Duree: ");      Serial.println(Duree);
  }

// Affichage des bandeaux
void Afficher() {
  // A supprimer à la fin
  Serial.print("TexteHaut: ");  Serial.println(TexteHaut);
  Serial.print("TexteBas: ");   Serial.println(TexteBas);

  if(AffichHaut.displayAnimate()) {
    AffichHaut.displayText(TexteHaut, AffichHaut.getTextAlignment(), AffichHaut.getSpeed(), AffichHaut.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichHaut.displayReset();
  }
 
  if(AffichBas.displayAnimate()) {
    AffichBas.displayText(TexteBas, AffichBas.getTextAlignment(), AffichBas.getSpeed(), AffichBas.getPause(),PA_MESH ,PA_MESH );  //PA_BLINDS   PA_MESH
    AffichBas.displayReset();
  }
}


void setup() {
  //Initialisation moniteur série  //A supprimer à la fin
  Serial.begin(115200);
  Serial.println("Initialisation du moniteur série");

  Serial2.begin(115200, SERIAL_8N1, RXD2, TXD2);  //Initialisation du port série

  // Initialisation des bandeaux LED
  AffichHaut.begin();
  AffichHaut.setIntensity(0);
  AffichHaut.setTextAlignment(PA_LEFT);
  AffichHaut.setSpeed(40);
  AffichHaut.setPause(3000);
  AffichHaut.displayClear();
  AffichBas.begin();
  AffichBas.setIntensity(0);
  AffichBas.setTextAlignment(PA_LEFT);
  AffichBas.setSpeed(40);
  AffichBas.setPause(3000);
  AffichBas.displayClear();

  WifiEtat, FtpEtat = 0;
}


void loop() {
  //Reception des tags depuis ESP32S via le port série
  // while(Serial2.available()) {
    Serial.println("Reception port série en cours");  // A supprimer à la fin
    SerialReadTmp = Serial.readString();
    SerialReadTmp.toCharArray(SerialRead, TailleMaxMessage);
    Serial.println(SerialRead);  // A supprimer à la fin
    Serial.print("Trame venant du port série: ");  // A supprimer à la fin
    Serial.println(SerialRead);  // A supprimer à la fin

    ExtrTags(SerialRead);

    MoniSerie();  // A supprimer à la fin

    // Formatage des données pour les Afficheurs
    snprintf(TexteHaut, sizeof TexteHaut, "%s - %s", Artiste, Album);
    snprintf(TexteBas, sizeof TexteBas, "%s - %s", Titre, Duree);

    // strlcpy(TexteHaut, "Affichage texte HAUT", TailleMaxMessage);
    // strlcpy(TexteBas, "Affichage texte Bas", TailleMaxMessage);

    Afficher();
    }
// }

Avec ces deux lignes

    snprintf(TexteHaut, sizeof TexteHaut, "%s - %s", Artiste, Album);
    snprintf(TexteBas, sizeof TexteBas, "%s - %s", Titre, Duree);

j'ai le message suivant:

ets Jul 29 2019 12:21:46

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
Initialisation du moniteur série

begin: exit

begin: exit
Reception port série en cours

Trame venant du port série: 
WifiEtat: 
FtpEtat: 
EtatFoo: 
Artiste: 
Album: 
Titre: 
Bitrate: 
Codec: 
Duree: 
Guru Meditation Error: Core  1 panic'ed (LoadProhibited). Exception was unhandled.
Core 1 register dump:
PC      : 0x400014fd  PS      : 0x00060530  A0      : 0x800d9df8  A1      : 0x3ffb1ba0  
A2      : 0x00000000  A3      : 0xfffffffc  A4      : 0x000000ff  A5      : 0x0000ff00  
A6      : 0x00ff0000  A7      : 0xff000000  A8      : 0x00000000  A9      : 0x3ffb1e70  
A10     : 0x00000003  A11     : 0x00060523  A12     : 0x00060520  A13     : 0x0000ff00  
A14     : 0x00ff0000  A15     : 0xff000000  SAR     : 0x0000000a  EXCCAUSE: 0x0000001c  
EXCVADDR: 0x00000000  LBEG    : 0x400014fd  LEND    : 0x4000150d  LCOUNT  : 0xffffffff  

ELF file SHA256: 0000000000000000

Backtrace: 0x400014fd:0x3ffb1ba0 0x400d9df5:0x3ffb1bb0 0x400d7ec2:0x3ffb1ec0 0x400d11d9:0x3ffb1f80 0x400d6325:0x3ffb1fb0 0x40086155:0x3ffb1fd0

Rebooting...

Si je remplace les deux lignes "strlcpy" par celles ci ça fonctionne mais ça rame

strlcpy(TexteHaut, "Affichage texte HAUT", TailleMaxMessage);
strlcpy(TexteBas, "Affichage texte Bas", TailleMaxMessage);

Le fait qu’il n’ait rien decodé devrait vous donner une piste

Il faudrait virer la gestion par readString, c’est pas solide…(timeout, gestion des fins de ligne, …) et appliquer l’approche asynchrone dont je parle dans mon tuto sur le port serie

Bonjour mimikrakra

Sans caractère de terminaison donc c'est le timout du serial qui termine la lecture (1000 millisecondes).

Il faut mettre un Serial.setTimeout(100), dans setup.

Ou lis ton port avec Serial.readStringUntil('\n') et envoies ton message avec \n comme terminaison.
Pour nettoyer la chaîne reçue: chaineRecue..trim();

Info sur readStringUntil et trim()

Cordialement
jpbbricole

Ca reste fragile parce que 100 est arbitraire- tout dépendra de l’émetteur et donc hors de contrôle du code

Ça c’est mieux parce qu’on a un marqueur de fin mais il restera le timeout à gérer et on double le besoin en mémoire pour le message

L’approche avec l’appel à une fonction d’écoute qui répond true quand le message est prêt est quasiment aussi simple (la fonction est dispo dans mon tuto) et a l’avantage de ne pas bloquer le code du tout ça peut être utile suivant les besoins.

Excusez moi, mais je ne comprends pas:

J'aurais écrit:


    snprintf(TexteHaut, sizeof (TexteHaut), "%s - %s", Artiste, Album);

-sizeof est une fonction-

Pas que:

Bonjour,

C'est un opérateur, donc le code de @mimikrakra est correct.

c'est un opérateur (son action est définie à la compilation*, pas de mise sur la pile du 'paramètre') et tout dépend de son paramètre

  • on met des parenthèses pour un type, par exemple sizeof(unsigned long)
  • on n'a pas besoin des parenthèses pour une variable, par exemple sizeof x

* ➜ dans les versions récentes ou extensions à la GCC, ça peut être aussi résolu au run time pour les VLA par example.

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

void loop() {
  uint8_t tableau[random(10, 21)];
  Serial.println(sizeof tableau);
  delay(500);
}

Désolé d'avoir mis une information inexacte (j'ai pris l'habitude de considèrer sizeof comme une fonction, ce qui n'a pas de conséquences -deux parenthèses en trop..- et j'étais donc intrigué)

Oui en mettant tout le temps les parenthèses on ne risque pas de se tromper. Mais c’est fun de se souvenir de ces détails pour briller lors de votre prochain cocktail mondain.. :wink:

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.