Problème : création d'une trame/envoie de la trame.

Bonjour,

Je suis actuellement sur la fin de mon projet en entreprise et je bloque sur la trame. On me demande que à la fin du test, Arduino créé une trame selon si les tests sont passé bon ou pas. ( exemple : 0,0,0,0,1,0,0, cette trame indique que notre test qui concerne le centre n’est pas bon.

Le but de se code est de tester les pistes d’une carte, puis les positions d’un capteur à effet hall ( Centre, Nord, Sud). Pour se qui est de tout ses tests il n’y a aucun problème.
La seul chose qui bloque est sur la fin qui concerne cette trame. Ayant cherché la-dessus je n’ai pas trouvé grand chose qui pourrais me guider… Je vous demande donc de l’aide. Merci

Voici le code : (il n’y a pas tout vu que je dépassais les 9000 caractères ^^")

void testContinuite()
{
  // Initialisation des sorties LEDS
  digitalWrite(pinLedRougeStrapp, LOW);
  digitalWrite(pinLedVerte, LOW);

  // Test continuité signaux
  digitalWrite(pinEnvoi, HIGH);
  strapp = digitalRead(pinReception);   // Contrôle continuité entre J3-1 et J3-6 (signaux PS-ST et LIGHT via un strapp entre J1-1 et J1-6)
  if (strapp == HIGH)
  {
    Serial.println("Test continuité signaux : OK");
    erreurStrappSignaux[0] = '0';
  }
  else
  {
    Serial.println("Test continuité signaux : NOK");
    erreurStrappSignaux[0] = '1';
    erreur1++;
  }
  digitalWrite(pinEnvoi, LOW);  // Remise à 0 de la sortie pinEnvoi
  delay(1000);

  // Test continuité Alim 5V
  strapp = digitalRead(pinAlim);    // Contrôle continuité entre J3-5 et J1-4 (+5V)
  if (strapp == HIGH)
  {
    Serial.println("Test continuité Alim 5V : OK");
    erreurStrappAlim[0] = '0';
  }
  else
  {
    Serial.println("Test continuité Alim 5V : NOK");
    erreurStrappAlim[0] = '1';
    erreur1++;
  }
  delay(1000);

  // Test continuité GND
  strapp = digitalRead(pinGnd);   // Contrôle continuité entre J3-3 et J1-3 (AGND)
  if (strapp == LOW)
  {
    Serial.println("Test continuité GND : OK");
    erreurStrappGnd[0] = '0';
  }
  else
  {
    Serial.println("Test continuité GND : NOK");
    erreurStrappGnd[0] = '1';
    erreur1++;
  }
  delay(1000);
}

void testCapteur()
{
  // Initialisation des sorties qui commandent les relais
  digitalWrite(pinRelaisNord, LOW);
  digitalWrite(pinRelaisSud, LOW);


  // Test CENTRE
  neutre = analogRead(pinCapteur);  // On n'envoie pas de courant dans la bobine. Lecture de la valeur transmise par le capteur (CENTRE).
  delay(500);
  Serial.print("Valeur Capteur CENTRE : ");
  Serial.println(neutre);   // Affichage de la valeur CENTRE sur le moniteur

  if ((neutre >= 502) && (neutre <= 514))   // On considère le CENTRE OK si compris entre 502 et 514
  {
    Serial.println("Test capteur (pole CENTRE) : OK");    // Test CENTRE OK
    erreurCapteurCentre[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole CENTRE) : NOK");     // Test CENTRE NOK
    erreurCapteurCentre[0] = '1';
    erreur2++;
  }
  delay(1000);
  resultatCentre = ((neutre * 5) / 1023);

  Serial.print("Résultat Centre : ");
  Serial.print(resultatCentre);
  Serial.println("V");
  delay(2000);


  // Test NORD
  digitalWrite(pinRelaisNord, HIGH);   // On active le relais NORD pour faire passer le courant dans un sens dans la bobine
  delay(500);
  nord = analogRead(pinCapteur);
  Serial.print("Valeur Capteur NORD : ");
  Serial.println(nord);     // affichage de la valeur NORD sur le moniteur

  if ((nord <= 501))    // On considère le NORD OK si inferieur à 502
  {
    Serial.println("Test capteur (pole NORD) : OK");     // affichage de la valeur NORD sur le moniteur
    erreurCapteurNord[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole NORD) : NOK");     // Test NORD NOK
    erreurCapteurNord[0] = '1';
    erreur2++;
  }
  digitalWrite(pinRelaisNord, LOW);
  resultatNord = ((nord * 5) / 1023);

  Serial.print("Résultat Nord : ");
  Serial.print(resultatNord);
  Serial.println("V");
  delay(2000);


  // Test SUD
  digitalWrite(pinRelaisSud, HIGH);   // On active le relais NORD pour faire passer le courant dans un sens dans la bobine
  delay(500);
  sud = analogRead(pinCapteur);
  Serial.print("Valeur Capteur SUD : ");
  Serial.println(sud);     // affichage de la valeur NORD sur le moniteur

  if ((sud >= 515))    // On considère le SUD OK si superieur à 514
  {
    Serial.println("Test capteur (pole SUD) : OK");
    erreurCapteurSud[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole SUD) : NOK");    // Test SUD NOK
    erreurCapteurSud[0] = '1';
    erreur2++;
  }
  digitalWrite(pinRelaisSud, LOW);
  resultatSud = ((sud * 5) / 1023);

  Serial.print("Résultat Sud : ");
  Serial.print(resultatSud);
  Serial.println("V");
  delay(2000);
}

void gestionTrame()
{
  strcpy (trame, erreurBouton);
  strcat (trame, comma);
  strcat (trame, erreurStrappSignaux);
  strcat (trame, comma);
  strcat (trame, erreurStrappAlim);
  strcat (trame, comma);
  strcat (trame, erreurStrappGnd);
  strcat (trame, comma);
  strcat (trame, erreurCapteurCentre);
  strcat (trame, comma);
  strcat (trame, valeurCentre);
  strcat (trame, comma);
  strcat (trame, erreurCapteurNord);
  strcat (trame, comma);
  strcat (trame, valeurNord);
  strcat (trame, comma);
  strcat (trame, erreurCapteurSud);
  strcat (trame, comma);
  strcat (trame, valeurSud);

  Serial.print("Erreur 1 : ");
  Serial.println(erreur1);
  Serial.print("Erreur 2 : ");
  Serial.println(erreur2);

  if (erreur1 == 0 && erreur2 == 0)
    digitalWrite(pinLedVerte, HIGH);

  if (erreur1 > 0)
    digitalWrite(pinLedRougeStrapp, HIGH);

  if (erreur2 > 0)
    digitalWrite(pinLedRougeCpt, HIGH);

  Serial.print("Trame : ");
  Serial.println(trame);
  delay(10000);

}

Pas facile de t'aider sans voir le reste du code, notamment les définitions des variables.

Par exemple,

 erreurCapteurNord[0] = '1';

indique que erreurCapteurNord est un tableau de char. Mais que contient comma ? une virgule : ',' ?

A priori le code semble correct, que t'affichent ces lignes ?

Serial.print("Trame : ");
  Serial.println(trame);

De quel type sont les variables valeurCentre, valeurNord et valeurSud ? Si ce ne sont pas des char, c'est peut-être là que se trouve ton problème, car strcat n'admet que des char en argument.

Si ce sont des int, tu dois les mettre dans un tableau de char avant de faire le strcat : utilise sprintf

  char ligne[10];  // A dimensionner correctement
  sprintf (ligne, "%d",valeursud);
  strcat (trame, ligne);

Déjà voici le code en complet :

// Affectation des entrées sorties de l'arduino
const byte pinSwitch = 4;  // Switch détection presse activée
const byte pinChoixProg = 3; // Interrupteur permettant le test une carte ancienne ou nouvelle version
const byte pinBouton = 2;  // Bouton carte
const byte pinCapteur = A0; // pin Capteur magnétique
const byte pinAlim = 7; // pin J1-4
const byte pinGnd = 8; // pin J1-3
const byte pinLedVerte = 11; // Led Verte Test PASS
const byte pinLedRougeStrapp = 10; // Led Rouge Test NOK continuité
const byte pinLedRougeCpt = 9; // Led Rouge Test NOK capteur
const byte pinEnvoi = 5;
const byte pinReception = 6;
const byte pinRelaisNord = 13; // Relais n°1 (gère le NORD)
const byte pinRelaisSud = 12; // Relais n°2 (gère le SUD)

// Initialisation des variables
int Switch = 0, Bouton = 0;
int i = 0;
long temps = 0, temps1 = 0, temps2 = 0; // Utilisés pour calculer le temps passé entre l'appui switch descente et le BP de la carte
int strapp = 0;
int erreur1 = 0, erreur2 = 0;
float resultatCentre, resultatNord, resultatSud;
float neutre, nord, sud;

// Initialisation des erreurs
char erreurBouton[3] = {0};
char erreurStrappSignaux[3] = {0};
char erreurStrappAlim[3] = {0};
char erreurStrappGnd[3] = {0};
char erreurCapteurCentre[3] = {0};
char erreurCapteurNord[3] = {0};
char erreurCapteurSud[3] = {0};
char valeurCentre[5] = {0};
char valeurNord[5] = {0};
char valeurSud[5] = {0};
char trame[50] = {0};
char comma[2] = ",";

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

  // Configuration des entrées sorties de l'arduino
  pinMode(pinLedRougeCpt, OUTPUT);
  pinMode(pinLedRougeStrapp, OUTPUT);
  pinMode(pinLedVerte, OUTPUT);

  pinMode(pinSwitch,  INPUT);
  pinMode(pinBouton, INPUT_PULLUP);
  pinMode(pinChoixProg, INPUT);

  pinMode(pinRelaisNord, OUTPUT);
  pinMode(pinRelaisSud, OUTPUT);

  pinMode(pinAlim,  INPUT);
  pinMode(pinGnd,  INPUT);

  digitalWrite(pinLedVerte, LOW);
  digitalWrite(pinLedRougeStrapp, LOW);
  digitalWrite(pinLedRougeCpt, LOW);

}

void loop()
{
  Serial.println("*** Attente activation switch descente ***");

  Switch = digitalRead(pinSwitch);

  switch (Switch)
  {
    case LOW:
      Serial.println("En attente ...");
      break;

    case HIGH:
      temps1 = millis();

      Bouton = digitalRead(pinBouton);

      do
      {
        Bouton = digitalRead(pinBouton);
        Serial.println("*** Attente appui bouton de la carte ***");
        //delay(100);
      }
      while (Bouton != LOW);

      temps2 = millis();

      temps = temps2 - temps1;  // On soustrait le temps au moment de l'appui sur le bouton au temps de l'activation du switch descente

      Serial.print("Le temps d'écart est de : ");
      Serial.print(temps);
      Serial.println(" ms");

      if (temps < 100)
      {
        erreurBouton[0] = '1';
        erreur1++;
        Serial.println("Bouton poussoir : NOK => Court-circuit");
      }
      else
      {
        erreurBouton[0] = '0';
        Serial.println("Bouton poussoir : OK");
      }
      testContinuite();
      //delay(3000);
      testCapteur();
      //delay(3000);
      gestionTrame();

      do
      {
        Switch = digitalRead(pinSwitch);
        Serial.println("*** Attente ouverture capot ***");
      }
      while (Switch != LOW);

      digitalWrite(pinLedVerte, LOW);
      digitalWrite(pinLedRougeStrapp, LOW);
      digitalWrite(pinLedRougeCpt, LOW);

      erreur1 = 0;
      erreur2 = 0;

      break;
  }

}

void testContinuite()
{
  // Initialisation des sorties LEDS
  digitalWrite(pinLedRougeStrapp, LOW);
  digitalWrite(pinLedVerte, LOW);

  // Test continuité signaux
  digitalWrite(pinEnvoi, HIGH);
  strapp = digitalRead(pinReception);   // Contrôle continuité entre J3-1 et J3-6 (signaux PS-ST et LIGHT via un strapp entre J1-1 et J1-6)
  if (strapp == HIGH)
  {
    Serial.println("Test continuité signaux : OK");
    erreurStrappSignaux[0] = '0';
  }
  else
  {
    Serial.println("Test continuité signaux : NOK");
    erreurStrappSignaux[0] = '1';
    erreur1++;
  }
  digitalWrite(pinEnvoi, LOW);  // Remise à 0 de la sortie pinEnvoi
  delay(1000);

  // Test continuité Alim 5V
  strapp = digitalRead(pinAlim);    // Contrôle continuité entre J3-5 et J1-4 (+5V)
  if (strapp == HIGH)
  {
    Serial.println("Test continuité Alim 5V : OK");
    erreurStrappAlim[0] = '0';
  }
  else
  {
    Serial.println("Test continuité Alim 5V : NOK");
    erreurStrappAlim[0] = '1';
    erreur1++;
  }
  delay(1000);

  // Test continuité GND
  strapp = digitalRead(pinGnd);   // Contrôle continuité entre J3-3 et J1-3 (AGND)
  if (strapp == LOW)
  {
    Serial.println("Test continuité GND : OK");
    erreurStrappGnd[0] = '0';
  }
  else
  {
    Serial.println("Test continuité GND : NOK");
    erreurStrappGnd[0] = '1';
    erreur1++;
  }
  delay(1000);
}

void testCapteur()
{
  // Initialisation des sorties qui commandent les relais
  digitalWrite(pinRelaisNord, LOW);
  digitalWrite(pinRelaisSud, LOW);


  // Test CENTRE
  neutre = analogRead(pinCapteur);  // On n'envoie pas de courant dans la bobine. Lecture de la valeur transmise par le capteur (CENTRE).
  delay(500);
  Serial.print("Valeur Capteur CENTRE : ");
  Serial.println(neutre);   // Affichage de la valeur CENTRE sur le moniteur

  if ((neutre >= 502) && (neutre <= 514))   // On considère le CENTRE OK si compris entre 502 et 514
  {
    Serial.println("Test capteur (pole CENTRE) : OK");    // Test CENTRE OK
    erreurCapteurCentre[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole CENTRE) : NOK");     // Test CENTRE NOK
    erreurCapteurCentre[0] = '1';
    erreur2++;
  }
  delay(1000);
  resultatCentre = ((neutre * 5) / 1023);

  Serial.print("Résultat Centre : ");
  Serial.print(resultatCentre);
  Serial.println("V");
  delay(2000);


  // Test NORD
  digitalWrite(pinRelaisNord, HIGH);   // On active le relais NORD pour faire passer le courant dans un sens dans la bobine
  delay(500);
  nord = analogRead(pinCapteur);
  Serial.print("Valeur Capteur NORD : ");
  Serial.println(nord);     // affichage de la valeur NORD sur le moniteur

  if ((nord <= 501))    // On considère le NORD OK si inferieur à 502
  {
    Serial.println("Test capteur (pole NORD) : OK");     // affichage de la valeur NORD sur le moniteur
    erreurCapteurNord[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole NORD) : NOK");     // Test NORD NOK
    erreurCapteurNord[0] = '1';
    erreur2++;
  }
  digitalWrite(pinRelaisNord, LOW);
  resultatNord = ((nord * 5) / 1023);

  Serial.print("Résultat Nord : ");
  Serial.print(resultatNord);
  Serial.println("V");
  delay(2000);


  // Test SUD
  digitalWrite(pinRelaisSud, HIGH);   // On active le relais NORD pour faire passer le courant dans un sens dans la bobine
  delay(500);
  sud = analogRead(pinCapteur);
  Serial.print("Valeur Capteur SUD : ");
  Serial.println(sud);     // affichage de la valeur NORD sur le moniteur

  if ((sud >= 515))    // On considère le SUD OK si superieur à 514
  {
    Serial.println("Test capteur (pole SUD) : OK");
    erreurCapteurSud[0] = '0';
  }
  else
  {
    Serial.println("Test capteur (pole SUD) : NOK");    // Test SUD NOK
    erreurCapteurSud[0] = '1';
    erreur2++;
  }
  digitalWrite(pinRelaisSud, LOW);
  resultatSud = ((sud * 5) / 1023);

  Serial.print("Résultat Sud : ");
  Serial.print(resultatSud);
  Serial.println("V");
  delay(2000);
}

void gestionTrame()
{
  strcpy (trame, erreurBouton);
  strcat (trame, comma);
  strcat (trame, erreurStrappSignaux);
  strcat (trame, comma);
  strcat (trame, erreurStrappAlim);
  strcat (trame, comma);
  strcat (trame, erreurStrappGnd);
  strcat (trame, comma);
  strcat (trame, erreurCapteurCentre);
  strcat (trame, comma);
  strcat (trame, valeurCentre);
  strcat (trame, comma);
  strcat (trame, erreurCapteurNord);
  strcat (trame, comma);
  strcat (trame, valeurNord);
  strcat (trame, comma);
  strcat (trame, erreurCapteurSud);
  strcat (trame, comma);
  strcat (trame, valeurSud);

  Serial.print("Erreur 1 : ");
  Serial.println(erreur1);
  Serial.print("Erreur 2 : ");
  Serial.println(erreur2);

  if (erreur1 == 0 && erreur2 == 0)
    digitalWrite(pinLedVerte, HIGH);

  if (erreur1 > 0)
    digitalWrite(pinLedRougeStrapp, HIGH);

  if (erreur2 > 0)
    digitalWrite(pinLedRougeCpt, HIGH);

  Serial.print("Trame : ");
  Serial.println(trame);
  delay(10000);

}

Sinon j'ai bien fais une erreur quand j'ai donné un exemple de trame ça seras plutôt : 0,0,0,0,1,0,0

Donc oui comma contient bien une virgule.

lesept:
A priori le code semble correct, que t'affichent ces lignes ?

Serial.print("Trame : ");

Serial.println(trame);

Elles servent à nous afficher la trame justement sur le moniteur série.

lesept:
De quel type sont les variables valeurCentre, valeurNord et valeurSud ? Si ce ne sont pas des char, c'est peut-être là que se trouve ton problème, car strcat n'admet que des char en argument.

Se sont bien des "char", justement nous avons eu des problèmes avant puisque celle-ci était des int.

Ma question était de savoir ce que tu vois dans la console à l'exécution de ces lignes...

Bonjour,

valeurCentre, valeurNord, valeurSud ne sont mis à jour nulle part, donc sont vides dans ta trame.

Plutot que d'utiliser des char pour tes indicateurs, tu ferais mieux d'utiliser des byte et de les mettre sous forme de chaine de caractère en constituant la trame.
Idem pour les valeurs, tu as déja les variables float resultatCentre, resultatNord, resultatSud, pourquoi ne pas les utiliser et creer des valeurxxxx

Cependant si tu veux faire un minimum de modifs à ton programme, il te suffit de déterminer les valeurxxxx dans ta fonction gestionTrame()

void gestionTrame()
{
  dtostrf(resultatCentre,0,2,valeurCentre);
  dtostrf(resultatNord,0,2,valeurNord);
  dtostrf(resultatSud,0,2,valeurSud);

  strcpy (trame, erreurBouton);
  strcat (trame, comma);
  strcat (trame, erreurStrappSignaux);
  strcat (trame, comma);
  strcat (trame, erreurStrappAlim);
  strcat (trame, comma);
  strcat (trame, erreurStrappGnd);
  strcat (trame, comma);
  strcat (trame, erreurCapteurCentre);
  strcat (trame, comma);
  strcat (trame, valeurCentre);
  strcat (trame, comma);
  strcat (trame, erreurCapteurNord);
  strcat (trame, comma);
  strcat (trame, valeurNord);
  strcat (trame, comma);
  strcat (trame, erreurCapteurSud);
  strcat (trame, comma);
  strcat (trame, valeurSud);

  Serial.print("Erreur 1 : ");
  Serial.println(erreur1);
  Serial.print("Erreur 2 : ");
  Serial.println(erreur2);

  if (erreur1 == 0 && erreur2 == 0)
    digitalWrite(pinLedVerte, HIGH);

  if (erreur1 > 0)
    digitalWrite(pinLedRougeStrapp, HIGH);

  if (erreur2 > 0)
    digitalWrite(pinLedRougeCpt, HIGH);

  Serial.print("Trame : ");
  Serial.println(trame);
  delay(10000);
}

C'est vrai que si ces variables sont binaires (0 ou 1), le plus simple serait un sprintf en utilisant des bytes au lieu de char

sprintf(trame,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",erreurBouton, erreurStrappSignaux, erreurStrappAlim, erreurStrappGnd, erreurCapteurCentre, valeurCentre, erreurCapteurNord, valeurNord, erreurCapteurSud, valeurSud);

Il faut regarder ce que ça donne, et vérifier le format. Peut-être mettre %1d a la place de %d
S'il y a des float, il faudra prendre le format ad-hoc. Exemple %5.2f pour afficher 20.32 a partir de la valeur 20.321098

Attention float (%f) ne marche pas avec sprintf sur ARDUINO.
kamill utilise dtostrf.

Au temps pour moi, ça va compliquer un peu

Oui, mais seulement un peu; On peut utiliser dtosrtf() et %s pour les float et directement %d pour les indicateurs.

Merci pour vos réponses.

lesept:
Ma question était de savoir ce que tu vois dans la console à l’exécution de ces lignes…

Dans le moniteur série je vois

“Trame :
0,0,0, ,1,0,0”

édit : Si vous voulez voir le résultat complet je viens d’ajouter une image du résultat

0 = Test bon
1 = Test faux

Les espaces entre les “,” ne sont pas voulu, nous voulons affichés les valeurs de notre capteur dans la trame ( exemple valeur centre : 2.4 (en volt)

Trame arduino.PNG

kamill:
il te suffit de déterminer les valeurxxxx dans ta fonction gestionTrame()

void gestionTrame()

{
 dtostrf(resultatCentre,0,2,valeurCentre);
 dtostrf(resultatNord,0,2,valeurNord);
 dtostrf(resultatSud,0,2,valeurSud);
}

Je vais essayer cela et je vous redis, merci :slight_smile:

Mais j'aimerais savoir quel serais la plus simple à utiliser dans la votre et décrire plus bas part lesept

lesept:

sprintf(trame,"%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",erreurBouton, erreurStrappSignaux, erreurStrappAlim, erreurStrappGnd, erreurCapteurCentre, valeurCentre, erreurCapteurNord, valeurNord, erreurCapteurSud, valeurSud);

kamill:

void gestionTrame()

{
  dtostrf(resultatCentre,0,2,valeurCentre);
  dtostrf(resultatNord,0,2,valeurNord);
  dtostrf(resultatSud,0,2,valeurSud);
}

Serait-il possible de m’expliquer brièvement qu’est-ce : “dtostrf”, histoire qu’à l’avenir je sache l’utiliser.

Et bien en 3 lignes manquantes se problème est déjà résolu c’est dingue ! :slight_smile:
Maintenant je vois la trame comme je veux avec les résultats du capteur, merci beaucoup ! (voir image)

Mais j’aimerais savoir si l’on peut envoyer cette trame sur l’ordinateur ?

Merci encore pour votre aide.

Résultat Trame Bon.PNG

Résultat Trame Bon.PNG

Function dtostrf()
char * dtostrf(
double __val,
signed char __width,
unsigned char __prec,
char * __s)

La fonction [url=https://www.microchip.com/webdoc/AVRLibcReferenceManual/group__avr__stdlib_1ga060c998e77fb5fc0d3168b3ce8771d42.html]dtostrf[/url]() convertit la valeur passée dans val en une représentation ASCII qui sera stockée dans s. L'appelant est responsable de fournir suffisamment de mémoire dans s.

La conversion se fait au format "[-]d.ddd". La largeur de champ minimale de la chaîne de sortie (y compris le signe possible '.' et le signe possible pour les valeurs négatives) est donnée dans width, et prec détermine le nombre de chiffres après le signe décimal.

La fonction dtostrf() renvoie le pointeur à la chaîne s convertie.

lesept:
La fonction [url=https://www.microchip.com/webdoc/AVRLibcReferenceManual/group__avr__stdlib_1ga060c998e77fb5fc0d3168b3ce8771d42.html]dtostrf[/url]() convertit la valeur passée dans val en une représentation ASCII qui sera stockée dans s. L'appelant est responsable de fournir suffisamment de mémoire dans s.

La conversion se fait au format "[-]d.ddd". La largeur de champ minimale de la chaîne de sortie (y compris le signe possible '.' et le signe possible pour les valeurs négatives) est donnée dans width, et prec détermine le nombre de chiffres après le signe décimal.

La fonction dtostrf() renvoie le pointeur à la chaîne s convertie.

En résumé je dois en conclure que c'est un convertisseur ASCII ?

En partie, car il se limite à convertir des chiffres. sprintf est plus puissant en version complète…

Mais j’aimerais savoir si l’on peut envoyer cette trame sur l’ordinateur ?

Comment veux-tu l’envoyer, quel est ton lien avec l’ordinateur (filaire, sans fil) ?

lesept:
Comment veux-tu l'envoyer, quel est ton lien avec l'ordinateur (filaire, sans fil) ?

Et bien le seul lien entre le PC et Arduino est le câble USB quand je lui envoie le programme. Est-ce suffisant ?

Mais j'aimerais savoir si l'on peut envoyer cette trame sur l'ordinateur ?

Comment veux-tu l'envoyer, quel est ton lien avec l'ordinateur (filaire, sans fil) ?

Et bien le seul lien entre le PC et Arduino est le câble USB quand je lui envoie le programme. Est-ce suffisant ?

si tu vois les trames dans la console de l'IDE Arduino c'est qu'elle sont déjà arrivées dans le PC...

Mais j'aimerais savoir si l'on peut envoyer cette trame sur l'ordinateur ?

Et tu veux en faire quoi ? Les afficher ? Déjà fait sur la console...
Les traiter ?

J'aimerais si cela est possible qu'une fois que le PC à reçu la trame, qu'il écrit dans un fichier .txt ou excel sois la trame complète ou si l'on peut encore compliqué la chose, qu'il n'écrit que les valeurs de mon capteur qui sont dans la trame part exemple 2.46, 1.90, 3.1

Est-ce que c'était assez claire ?