Décodage d'un message complexe serial

Bonjour!

En vue d'un projet plus compliqué que ça, j'essaie actuellement de faire une communication série avec mon arduino pour simuler une future communication de téléphone à ESP32 et à arduino nano (ou micro à voir) et pour ceci je simule un envoi d'information via le serial IDE à mon arduino afin d'apprendre son fonctionnement. Le soucis, j'arrive à faire une communication simple mais ce que je voudrais faire, ce serait de décoder un message plus complexe tel que un message comprenant des valeurs pour tel ou tel élément.

Je donne un exemple, si j'envoi un message tel que Ledval_R0G255B255, par exemple, via liaison serial, j'aimerai pouvoir le décoder en:

  • Ledval_ > appel de fonction pour établir la couleur d'une led RGB
  • R pour la couleur Rouge
  • 0 pour la valeur de R
  • G pour la couleur Verte
  • 255 pour la valeur de G
  • B pour la couleur Bleue
  • 255 pour la valeur de B

Mais je souhaiterai également voir pour envoyer des informations différentes tel que des valeurs alpha/numériques du même principe qu'au dessus entre arduino et ESP32 comme des valeurs capteur et donc les coder du genre VBatXX% par exemple ou autres (je ne me rappelle plus qu'elle autres informations j'ai besoin).

Pour le moment j'utilise un code tel que ceci:

void ExecuteCommandSerial(){
  while (Serial.available() > 0){
    TexteSerial = Serial.readString();
    Serial.print("I received: ");
    Serial.println(TexteSerial);
    if (TexteSerial.equals(Situation1)){
      Serial.print("I received: ");
      Serial.println(TexteSerial);
      Serial.print("Situation 1 séléctionnée et ");           //possibilité d'effectuer une commande matérielle sur cette zone
      Serial.println("situation 1 éffectuée");
      for (int i, i > 0, i--){
        bar.setLevel(LedGraph --);
      }
    }
    if (TexteSerial.equals(stringOne)){
      Serial.print("I received: ");
      Serial.println(TexteSerial + stringOne);
      Serial.print("Situation 2 séléctionnée et ");           //possibilité d'effectuer une commande matérielle sur cette zone
      Serial.println("situation 2 éffectuée");
    }
    if (TexteSerial.equals(Situation3)){
      Serial.print("I received: ");
      Serial.println(TexteSerial);
      Serial.print("Situation 3 séléctionnée et ");           //possibilité d'effectuer une commande matérielle sur cette zone
      Serial.println("situation 3 éffectuée");
    }
    break;
  }
}

Mais ce n'est pas pratique pour tout. Surtout si on envoi des valeurs qui changent en permanence. ^^

Le fait de faire des échanges d'informations de cette façon me permettrais de décrypter plus facilement les données d'informations auquel j'échange entre ces différents modules.

Si vous avez une idée de comment faire ou bien des idées plus simple cela m'aiderai grandement. Sachant que je ne sais pas encore comment faire les échanges également entre l'application et le module ESP32 mais je pense transférer des informations sur ce principe.

Je vous en remercie si vous avez des idées ou autres à proposer.

Il y a plusieurs solutions. Tout dépend du but final, et surtout du moyen utilisé pour envoyer les commandes :

  • trame binaire
  • commande en clair avec séparateurs
  • commandes en clair avec données de taille fixe

Mais dans tous les cas je te déconseille la classe String.

Voir ici : commander-un-arduino-par-la-ligne-serie

plus vous structurerez les données dans votre ligne de commande, plus ce sera simple à décoder.

Si vous décider d'envoyer la commande sous form JSON par exemple vous pourriez même utiliser la bibliothèque associée qui va se charger de tout décoder pour vous

sinon un truc simple du genre marquer de début + une suite de clé:valeur séparées par des virgules ou fabulation en enfin un caractère de fin de trame c'est assez simple à décoder

par exemple un truc du genre <R:12,G:13,B:120,vabtt:5>

hbachetti:
Il y a plusieurs solutions. Tout dépend du but final, et surtout du moyen utilisé pour envoyer les commandes :

  • trame binaire
  • commande en clair avec séparateurs
  • commandes en clair avec données de taille fixe

Mais dans tous les cas je te déconseille la classe String.

Voir ici : commander-un-arduino-par-la-ligne-serie

Le but final de cette manip est l'envoi depuis une application mobile contrôlée par wifi d'établir par exemple la couleur d'une led RGB où on a en premier lieu choisi les couleurs via l'application à l'aide de barre et selon la position de chaque couleurs (voir même en plus la luminosité) lorsque j'appuie sur un bouton de l'application, cela envoi les information de chaque niveau en un paquet de donnée groupée au lieu d'envoyer une informations pour chaque données.

Je sais pas si c'est clair ou non? ^^

J-M-L:
plus vous structurerez les données dans votre ligne de commande, plus ce sera simple à décoder.

Si vous décider d'envoyer la commande sous form JSON par exemple vous pourriez même utiliser la bibliothèque associée qui va se charger de tout décoder pour vous

sinon un truc simple du genre marquer de début + une suite de clé:valeur séparées par des virgules ou fabulation en enfin un caractère de fin de trame c'est assez simple à décoder

par exemple un truc du genre <R:12,G:13,B:120,vabtt:5>

Je vois l'idée oui mais le soucis est que je ne vois pas comment faire exactement. J'ai vu qu'il y avait possibilité de lire une par une les informations sur une char mais pour une valeur allant à 255 en hexa serait FF mais ça compterai 16 et ensuite 16 et le multiplier me donnera zéro pour toute valeur décimale inférieur à 17 ( 0xF = 0 et 1x0=0 etc)
Pour ce qui est du json, je ne connais pas le langage ou même comment faire. Je suis débutant. ^^

Sinon le coder de cette façon

<R:12,G:13,B:120,vabtt:5>

m'intéresse c'est plus clair visuellement mais je doute savoir comment lire une formulation comme ça. ou même l'écrire sur l'arduino. J'ai cherché toute la journée (h+7 donc la journée où je suis :wink: :smiley: ) et peu de ce que j'ai trouvé m'a aider à le réaliser. ^^

Si l'un d'entre vous a un exemple à proposer je serais preneur

lorsque j'appuie sur un bouton de l'application, cela envoi les information de chaque niveau en un paquet de donnée groupée au lieu d'envoyer une informations pour chaque données.

Tu peux formater les données de différentes manières comme je l'ai expliqué plus haut, ou comme J-M-L le propose :

"<R:12,G:13,B:120>"
ou :
"R12;G13;B120\n"

Tu peux même les formater comme ceci :
"LED1 12 13 120"
LED1 étant la commande, suivie de 3 valeurs RGB séparées par des espaces.

A toi de choisir le format qui t'arrange.

Si l'un d'entre vous a un exemple à proposer je serais preneur

Mon article (voir #1) ne comporte pas suffisamment d'exemples ?

Quand on écrit 0xF ce n'est pas une multiplication, c'est un moyen de montrer que l'on écrit un nombre en hexadécimal

0xF c'est F en hexa donc 15 en décimal, et ce n'est pas 0.

hbachetti:
Tu peux formater les données de différentes manières comme je l'ai expliqué plus haut, ou comme J-M-L le propose :

"<R:12,G:13,B:120>"
ou :
"R12;G13;B120\n"

Tu peux même les formater comme ceci :
"LED1 12 13 120"
LED1 étant la commande, suivie de 3 valeurs RGB séparées par des espaces.

A toi de choisir le format qui t'arrange.

Mon article (voir #1) ne comporte pas suffisamment d'exemples ?

La façon dont J-M-L propose m'intéresse. C'est un peu cette façon de formuler que je recherche oui. Le soucis que j'ai sur ceci est comment fait-on pour détecter chaque parties afin de les répartir pour différents groupes? Tel que ValRGB appelle la commande d'enregistrement de valeur selon les caractères suivant?

Exemple: si j'envoi <ValRGB,R:10,G:26,B:150>
ValRGB appelle une fonction pour set les couleurs suivante
R = 10
G = 26
B = 150
Comment détecter quand il faut changer de lecture d'informations selon les caractères spéciaux?
J'ai également ceci qui m'aide un peu à la compréhension avec ton site que j'ai vu également mais ça me laisse un peu confus. Désolé.

PS: Oui j'ai vu ton site et une partie m'a intéressé ( partie 1.2.3 et 1.2.4 ) mais ça me laisse confus sur la compréhension. :confused:

lesept:
Quand on écrit 0xF ce n'est pas une multiplication, c'est un moyen de montrer que l'on écrit un nombre en hexadécimal

0xF c'est F en hexa donc 15 en décimal, et ce n'est pas 0.

Je voulais dire 0 fois F non pas 0xF. Je voulais parler d'une multiplication des valeurs pour arriver à résultat max de 256. ^^

J'avais fait ça : GitHub - Tahitibob35/SerialComm: Serial communication library for Arduino
pour une communication série un peu avancée...

Il y a un moyen très simple d'envoyer des données - si on connait leur nombre et nature à l'écriture du code : en binaire.

Tu crées une structure et tu la peuples avec tes données

struc PaquetdeDonnees {
  char rouge;
  char vert;
  char bleu;
  // etc, c'est un exemple, tu mets tes données en liste
};

Sur la ligne de transmission, tu envoies la structure, renseignée, en un seul coup, en en binaire (utiliser write() )

PaquetdeDonnees paquet;
// renseigner paquet...
Serial.write ( &paquet, sizeof paquet );

A l'autre bout, les données sont reçues par

PaquetdeDonnees paquetrecu;
Serial.readBytes ( &paquetrecu, sizeof paquetrecu );

et hop, les données sobt arrivées rangées dans la structure.
Il n'y a aucun décodage à faire !

Mais - il y a un mais - 3 conditions sont nécessaires

  • il fut demander aux 2 compilateurs (s'il y en a "un à chaque bout") de tasser les sructures, il faut déclarer ainsi :
struct __attribute__((__packed__)) PaquetdeDonnees { ... };
  • il faut préciser explicitement la taille des membres de la struct :
int16_t  x; // en non pas int x;
  • il faut que les processeurs del'émetteur et du récepteur aient la même endianness

Si ces conditions sont réunies, cette solution est la plus directe.

@biggil
Oui c’est une option. Cela dit, S’il y a des commandes très différentes ou à longueur variable passer une structure ne suffit pas ou alors on risque d’avoir à envoyer beaucoup de données pour rien

Vous en êtes vous sorti avec les exemples sur le site de Henri ?

tahitibob35:
J'avais fait ça : GitHub - Tahitibob35/SerialComm: Serial communication library for Arduino
pour une communication série un peu avancée...

Désolé, je ne sais pas précisément où regarder sur ton lien. ^^' Trop d'informations


biggil:
Il y a un moyen très simple d'envoyer des données - si on connait leur nombre et nature à l'écriture du code : en binaire.

Tu crées une structure et tu la peuples avec tes données

struc PaquetdeDonnees {

char rouge;
  char vert;
  char bleu;
  // etc, c'est un exemple, tu mets tes données en liste
};




Sur la ligne de transmission, tu envoies la structure, renseignée, en un seul coup, en en binaire (utiliser write() )


PaquetdeDonnees paquet;
// renseigner paquet...
Serial.write ( &paquet, sizeof paquet );




A l'autre bout, les données sont reçues par 


PaquetdeDonnees paquetrecu;
Serial.readBytes ( &paquetrecu, sizeof paquetrecu );



et hop, les données sobt arrivées rangées dans la structure.
[u]Il n'y a aucun décodage à faire ![/u]

**Mais** - il y a un mais - 3 conditions sont nécessaires
- il fut demander aux 2 compilateurs (s'il y en a "un à chaque bout") de tasser les sructures, il faut déclarer ainsi :


struct attribute((packed)) PaquetdeDonnees { ... };



- il faut préciser explicitement la taille des membres de la struct :


int16_t  x; // en non pas int x;



- il faut que les processeurs del'émetteur et du récepteur aient la même endianness

Si ces conditions sont réunies, cette solution est la plus directe.

Je crois réussir un peu à comprendre comment faire avec ce que tu me donne.
Le soucis que j'ai pour le moment est que je compte envoyer des informations depuis l'application mobile (application mobile créée avec MIT AppInventor2) sous forme de texte. Je ne suis pas encore assez expérimenté pour savoir comment faire d'une meilleure façon. J'ai omis de parler de ce détail. Du coup, je ne sais pas encore exactement comment sont structurées les informations envoyés par l'application mais entre le module ESP et l'arduino.

Je viens de découvrir de ce que tu me parle avec les Serial.write(butfer, length) et le Serial.readBytes( buffer, length). Ça m'aidera un peu plus oui.

Mais je ne suis pas sûr de bien comprendre la partie Serial.readBytes() de comment ça fonctionne. Une fois les informations reçues ça me les enregistrerai directement sur les valeurs du deuxième module c'est bien ça? Le Serial.readBytesuntil() ça ne pourrait pas aider également?

Pour la partie:

Mais - il y a un mais - 3 conditions sont nécessaires

  • il fut demander aux 2 compilateurs (s'il y en a "un à chaque bout") de tasser les sructures, il faut déclarer ainsi :
    Code: [Select]
    struct attribute((packed)) PaquetdeDonnees { ... };

  • il faut préciser explicitement la taille des membres de la struct :
    Code: [Select]
    int16_t x; // en non pas int x;

  • il faut que les processeurs del'émetteur et du récepteur aient la même endianness

Je ne comprends de ce dont il s'agît. Désolé. ^^


C'est une peu ça que je pense @biggil. Des variables seront probablement de longueurs différente. Tel que le nom de la valeur que je cible à changer et les valeurs numériques de 0 à 255.

Vous en êtes vous sorti avec les exemples sur le site de Henri ?

Le site de Henri? Désolé, qui est donc ce Henri?

Henri : moi.

La solution proposée par biggil repose sur une transmission binaire des données.
L'ARDUINO reçoit une structure de 3 bytes R, G, B.
Ton appli AppInventor2 devra donc fabriquer un paquet de 3 bytes R, G, B.
C'est certainement possible, mais je ne connais pas AppInventor2.
Par contre tu ne pourras pas simuler ton appli dans le terminal ARDUINO.

La solution de J-M-L repose sur l'envoi d'une commande en clair ValRGB suivie de 3 couples variable=valeur.
Elle permet d'envoyer les données dans n'importe quel ordre R, G, B ou G, R, B ou B, G, R etc.
Elle permet également de n'envoyer que R ou G ou B ou R, G ou G, B etc.
Elle implique une analyse caractère par caractère de la chaîne reçue. Je doute que tu en sois capable.

Ma solution repose sur l'envoi d'une commande en clair ValRGB suivie de 3 valeurs : ValRGB R G B.
L'ordre R, G, B doit forcément être respecté et les 3 paramètres doivent être présents.
Principe :

  • comparaison sur X caractères de la commande.
  • récupération des valeurs avec sscanf, ce qui simplifie les choses.
  char s[30] = "ValRGB 10 26 150";
  if (strncmp(s, "ValRGB", 6) == 0) {
    Serial.print("cmd="); Serial.println("ValRGB");
    int r, g, b;
    int t = sscanf(s + 6, "%d %d %d", &r, &g, &b);
    if (t != 3) {
      Serial.print("missing data or separator, exit");
      return;
    }
    Serial.print(r); Serial.print(" "); Serial.print(g); Serial.print(" ");  Serial.println(b);
  }
  else {
    Serial.print("cmd="); Serial.println("???");
  }

Bien entendu la chaîne s doit être renseignée par Serial.readBytesuntil()
voir mon article 3.2. ReadBytesUntil

Voilà c'est tout.

hbachetti:
Henri : moi.

La solution proposée par biggil repose sur une transmission binaire des données.
L'ARDUINO reçoit une structure de 3 bytes R, G, B.
Ton appli AppInventor2 devra donc fabriquer un paquet de 3 bytes R, G, B.
C'est certainement possible, mais je ne connais pas AppInventor2.
Par contre tu ne pourras pas simuler ton appli dans le terminal ARDUINO.

La solution de J-M-L repose sur l'envoi d'une commande en clair ValRGB suivie de 3 couples variable=valeur.
Elle permet d'envoyer les données dans n'importe quel ordre R, G, B ou G, R, B ou B, G, R etc.
Elle permet également de n'envoyer que R ou G ou B ou R, G ou G, B etc.
Elle implique une analyse caractère par caractère de la chaîne reçue. Je doute que tu en sois capable.

Ma solution repose sur l'envoi d'une commande en clair ValRGB suivie de 3 valeurs : ValRGB R G B.
L'ordre R, G, B doit forcément être respecté et les 3 paramètres doivent être présents.
Principe :

  • comparaison sur X caractères de la commande.
  • récupération des valeurs avec sscanf, ce qui simplifie les choses.
  char s[30] = "ValRGB 10 26 150";

if (strncmp(s, "ValRGB", 6) == 0) {
    Serial.print("cmd="); Serial.println("ValRGB");
    int r, g, b;
    int t = sscanf(s + 6, "%d %d %d", &r, &g, &b);
    if (t != 3) {
      Serial.print("missing data or separator, exit");
      return;
    }
    Serial.print(r); Serial.print(" "); Serial.print(g); Serial.print(" ");  Serial.println(b);
  }
  else {
    Serial.print("cmd="); Serial.println("???");
  }




Bien entendu la chaîne s doit être renseignée par Serial.readBytesuntil()
voir mon article 3.2. ReadBytesUntil

Voilà c'est tout.

Ok ok ça marche. Eh bien merci Henri. ^^ Je comprends un peu plus comment ça fonctionne avec ton exemple et pour ce qui est de l'exemple J-M-L, oui je pense que je n'ai pas encore ce niveau pour réussir à comprendre.
J'ai également découvert les fonctions is... pour la lecture de caractères. Si je fais de la lecture de donnée char[] par ce principe, est-il possible d'arriver au résultat souhaité avec plus de détail?

Tel que si je mets dans un char ce que j'ai envoyé depuis le serial tel "ValRGB,10:26:150\0", je peux réussir à envoyer jusqu'à ce que j'atteigne un espace ou même le \n chaque valeur dans un String operator tel que le ValRGB dans un string pour une comparaison, le premier caractère spécial ',' va indiquer que l'on doit changer pour du int, les deux points changer d'integer et le \0 pour finir la chaine de caractère et stopper la décomposition. (PS: Pour la lecture du \0 afin d'ordonner l'arrêt de la lecture de la chaîne me paraît encore un peu incertain à savoir comment le ça fonctionne exactement. À voir... :slight_smile: )

C'est du même principe que ce que tu m'a indiqué mais d'une façon que je comprends un peu plus et d'une façon de faire que je saurais probablement plus facilement assimiler. ^^

Edit: Je viens de trouver ceci qui pourrait représenter ce que j'essaie d'expliquer. ^^

Si je fais de la lecture de donnée char[] par ce principe, est-il possible d'arriver au résultat souhaité avec plus de détail?

Lire caractère par caractère avec Serial.read() jusqu'à rencontrer '\n' revient au même que lire avec

Serial.readBytesUntil('\n', buffer, longeur)

Tel que si je mets dans un char ce que j'ai envoyé depuis le serial tel "ValRGB,10:26:150\0", je peux réussir à envoyer jusqu'à ce que j'atteigne un espace ou même le \n chaque valeur dans un String operator tel que le ValRGB dans un string pour une comparaison, le premier caractère spécial ',' va indiquer que l'on doit changer pour du int, les deux points changer d'integer et le \0 pour finir la chaine de caractère et stopper la décomposition. (PS: Pour la lecture du \0 afin d'ordonner l'arrêt de la lecture de la chaîne me paraît encore un peu incertain à savoir comment le ça fonctionne exactement. À voir... :slight_smile: )

Une chaîne du type "ValRGB,10:26:150\0" ne pourra pas être décomposée avec sscanf().
Pourquoi ? simplement parce que ',' et ':' sont considérés par sscanf() comme des caractères comme les autres, alors que l'espace est un séparateur natif pour cette fonction.
Donc cela simplifie grandement les choses.

Avec mon exemple l'application AppInventor2 devra envoyer "ValRGB 10 26 150\n", le '\n' étant utile uniquement pour indiquer à Serial.readBytesUntil() que c'est la fin.
Si '\n' est absent Serial.readBytesUntil() retournera quand même les bonnes données, simplement avec un temps de retard (le timeout : 1s par défaut).

L'intérêt est que tu pourras tester le code avec la console de l'IDE. Il faut activer l'option "Nouvelle ligne" en bas à droite, ce qui permettra d'envoyer le '\n'.

hbachetti:
Lire caractère par caractère avec Serial.read() jusqu'à rencontrer '\n' revient au même que lire avec

Serial.readBytesUntil('\n', buffer, longeur)

Très bien. Ce sera donc avec cette fonction que je ferais mon bizness. ^^ C'est également plus simple. ^^

hbachetti:
Une chaîne du type "ValRGB,10:26:150\0" ne pourra pas être décomposée avec sscanf().
Pourquoi ? simplement parce que ',' et ':' sont considérés par sscanf() comme des caractères comme les autres, alors que l'espace est un séparateur natif pour cette fonction.
Donc cela simplifie grandement les choses.

Avec mon exemple l'application AppInventor2 devra envoyer "ValRGB 10 26 150\n", le '\n' étant utile uniquement pour indiquer à Serial.readBytesUntil() que c'est la fin.
Si '\n' est absent Serial.readBytesUntil() retournera quand même les bonnes données, simplement avec un temps de retard (le timeout : 1s par défaut).

L'intérêt est que tu pourras tester le code avec la console de l'IDE. Il faut activer l'option "Nouvelle ligne" en bas à droite, ce qui permettra d'envoyer le '\n'.

Parfait! Si un espace simplifie les chose, je prends à 100%! Plus lisible et fait le taff que demander de mieux! ^^

Si '\n' est absent Serial.readBytesUntil() retournera quand même les bonnes données, simplement avec un temps de retard (le timeout : 1s par défaut).

C'est pour cela que j'ai vu l'utilisation de millis() de temps en temps sur certains programmes? Ou c'est pour tout autre chose?
La chose à laquelle je viens de penser également. En ce qui concerne la longueur, je peut mettre une valeur élevée quelconque tant que le \n est placé à une valeur inférieure a length c'est bien ça?

Edit:
Du coup si je compose une partie de mon code pour cette lecture Serial de cette façon j'ai bon non?

void LectureMessLEDRGB (){
  String TexteSerial;
  int R;
  int G;
  int B;
  while (Serial.available() > 0){
    Serial.readBytesUntil(' ', TexteSerial, 50);
    Serial.readBytesUntil(' ', R, 50);
    Serial.readBytesUntil(' ', G, 50);
    Serial.readBytesUntil('\n', B, 50);
  break;
}

Je suppose qu'il y a plus simple à faire ou qu'il y a une erreur mais je suis pas suffisamment expérimenté pour savoir. ^^

Tout faux.

R G et B sont des entiers.

    Serial.readBytesUntil(' ', R, 50);

readBytesUntil() attend un caractère ('\n'), un buffer (de char) et une longueur.

Je ne vois pas pourquoi ne pas utiliser sscanf() puisqu'elle fait tout ça en une seule opération.

La fonction ne devrait pas s'appeler LectureMessLEDRGB car j'ai lu ceci dans ta demande :

En vue d'un projet plus compliqué que ça, j'essaie actuellement de faire une communication série avec mon arduino pour simuler une future communication

J'en déduis qu'il y aura plusieurs commandes possibles, avec éventuellement des arguments différents.
D'où la commande "AUTRE" dans le code ci-dessous.

#define MAX_LEN   30

void setup()
{
  Serial.begin(115200);
  Serial.println("Serial DEMO");
}

void loop()
{
  lecture();
}

void lecture()
{
  if (!Serial.available()) {
    return;
  }
  Serial.println("receiving");
  char buf[MAX_LEN];
  memset(buf, 0, MAX_LEN);
  if (Serial.readBytesUntil('\n', buf, MAX_LEN) > 0) {
    Serial.print("buf="); Serial.println(buf);
    if (strncmp(buf, "ValRGB", 6) == 0) {
      Serial.print("cmd="); Serial.println("ValRGB");
      int r, g, b;
      int t = sscanf(buf + 6, "%d %d %d", &r, &g, &b);
      if (t != 3) {
        Serial.print("missing data or separator, exit");
        return;
      }
      Serial.print(r); Serial.print(" "); Serial.print(g); Serial.print(" ");  Serial.println(b);
    }
    else if (strncmp(buf, "AUTRE", 5) == 0) {
      Serial.print("cmd="); Serial.println("AUTRE");
    }
    else {
      Serial.println("Unknown command");
    }
  }
}

J'espère que c'est plus clair.
Le terminal est réglé sur 115200 baud, à toi de choisir une autre valeur.

La doc de readBytesUntil() et de sscanf() sur lesquelles il faudrait te pencher.

Merci pour ceci. Je venais de me pencher sur sscanf le temps de ta deuxième réponse. J'ai fini par créer un petit bout de code comme ceci. ^^ J'ai récupérer un exemple sur le site de cplusplus.com pour comprendre comment il fonctionne mais certaines partie de l'exemple j'ai pas trop bien compris à quoi servait le int i par exemple. ^^ (http://www.cplusplus.com/reference/cstdio/sscanf/)

C'est également le seul endroit où j'ai pu trouver une référence assez compréhensible. ^^

void ReadCharSerial(){

int Q;

char InfosRecue[Q];
Q = Serial.availableForWrite();
Serial.readBytes(InfosRecue, Q);

sscanf (InfosRecue,"%s %d %d %d");
printf ("%s %d %d %d\n");

}

Ceci est un exemple dédié que pour la LEDRGB mais je pense avoir compris un peu son fonctionnement.

Je vais analyser le code que tu as fourni pour le comprendre et l'assimiler. ^^ Il est bien plus complexe que ce que j'ai pu créer donc faut que je puisse réussir à comprendre toutes les parties et subtilités.

PS: Ne fais pas attention au nom de fonction. J'écris quasi tout le temps quelque chose de random le temps de l'essai jusqu'à que la fonction globale interne soit valide. ^^

Edit: Je pense que le soucis également qui se fait est que je n'ai pas la connaissance de la fonction strncmp. Je vais chercher ça.

Edit2: Mon code n'est pas valide, je comprends l'erreur que j'ai fais dans la partie sscanf. J'ai oublié des informations à écrire.

Je vais analyser le code que tu as fourni pour le comprendre et l'assimiler.

Cela vaudrait mieux effectivement.