Détection et filtrage d'une trame sur port série

Bonjour à tous !

Pour contextualiser un peu :

  • J’ai une trame de caractère ASCII qui arrive sur le pin 8 de mon arduino configuré en port série avec la bibliothèque SoftwareSerial

*J’arrive à lire en temps réel la trame grâce à un switch case en faisant :

Si je lis le caractère ‘A’ en entrée, je l’affiche et je le stocke dans un tableau de 300 caractère

Globalement je fais une géante boucle for dans laquelle j’ai un switch case qui affiche sur le moniteur série et stocke pour chaque indice de i dans un tableau de caractère le lettre qui est lue sur le pin 8.

Pour l’affichage du tableau dans la boucle for tout se passe très bien, car pour reprendre l’exemple ci-dessus :

case ‘A’ : Serial.print(‘A’); tableauDeCaractere = ‘A’;break
case ‘B’ : Serial.print(‘B’); tableauDeCaractere = ‘B’;break
bref vous aurez compris j’affiche une première fois le trame en même temps que je la lis, le problème survient lorsque je veux l’afficher une seconde fois en utilisant l’indice du tableau :
Quand je fais une boucle
for(int i =0; i<300; i++)
{
* Serial.print(tableauDeCaractere*
}
Je n’obtient pas du tout le même résultat que lors du première affichage et les caractères affichés avec la boucle for sont erronés par rapport à ce que je dois réellement afficher.
Je vous met quand même le code pour que ce soit plus clair :
```
*#include <SoftwareSerial.h>
#define startFrame 0x02
#define endFrame 0x03

SoftwareSerial* cptSerial;

char tableauDeChar[300] = {};
char charIn;

int pulseDuration;
int tabPulseDuration[5] = {};
int miniPulseDuration = 10000;
int baudRate;

void checkBaudRate()
{
 
  for(int i =0; i<5; i++)
  {
    tabPulseDuration[i] =  pulseIn(8, HIGH);
  }
  for(int i =0; i<5; i++)
  {
    if(tabPulseDuration[i]<miniPulseDuration)
    {
      miniPulseDuration = tabPulseDuration[i];
    }
  }
  //Serial.println(miniPulseDuration);
  if(miniPulseDuration < 150)
  {
    baudRate = 9600;
  }
  else if(miniPulseDuration < 1000)
  {
    baudRate = 1200;
  }
  //Serial.println(baudRate);
}
void setup() {
 
  Serial.begin(115200);
  cptSerial = new SoftwareSerial(8, 9);
  Serial.println(“Communication OK”);
  checkBaudRate();
  if(baudRate == 1200)
  {
    Serial.println(“mode Historique détecté”);
  }
  if(baudRate == 9600)
  {
    Serial.println(“mode Standard détecté”);
  }
  cptSerial->begin(baudRate);
  Serial.println(“Setup OK”);
 
 
}

void enregistrementTIC() {

uint8_t i = 0;
  char charIn =0;
  while(charIn != startFrame)
  {
    charIn = cptSerial->read()&0x7F;
  }
  while(charIn != endFrame)
  {
    if(cptSerial->available())
    {
        charIn = cptSerial->read()&0x7F;
        switch(charIn)
        {
          case ‘A’ : Serial.print(“A”); tableauDeChar[i] = ‘A’;break;
          case ‘B’ : Serial.print(“B”); tableauDeChar[i] = ‘B’;break;
          case ‘C’ : Serial.print(“C”); tableauDeChar[i] = ‘C’;break;
          case ‘D’ : Serial.print(“D”); tableauDeChar[i] = ‘D’;break;
          case ‘E’ : Serial.print(“E”); tableauDeChar[i] = ‘E’;break;
          case ‘F’ : Serial.print(“F”); tableauDeChar[i] = ‘F’;break;
          case ‘G’ : Serial.print(“G”); tableauDeChar[i] = ‘G’;break;
          case ‘H’ : Serial.print(“H”); tableauDeChar[i] = ‘H’;break;
          case ‘I’ : Serial.print(“I”); tableauDeChar[i] = ‘I’;break;
          case ‘J’ : Serial.print(“J”); tableauDeChar[i] = ‘J’;break;
          case ‘K’ : Serial.print(“K”); tableauDeChar[i] = ‘K’;break;
          case ‘L’ : Serial.print(“L”); tableauDeChar[i] = ‘L’;break;
          case ‘M’ : Serial.print(“M”); tableauDeChar[i] = ‘M’;break;
          case ‘N’ : Serial.print(“N”); tableauDeChar[i] = ‘N’;break;
          case ‘O’ : Serial.print(“O”); tableauDeChar[i] = ‘O’;break;
          case ‘P’ : Serial.print(“P”); tableauDeChar[i] = ‘P’;break;
          case ‘Q’ : Serial.print(“Q”); tableauDeChar[i] = ‘Q’;break;
          case ‘R’ : Serial.print(“R”); tableauDeChar[i] = ‘R’;break;
          case ‘S’ : Serial.print(“S”); tableauDeChar[i] = ‘S’;break;
          case ‘T’ : Serial.print(“T”); tableauDeChar[i] = ‘T’;break;
          case ‘U’ : Serial.print(“U”); tableauDeChar[i] = ‘U’;break;
          case ‘V’ : Serial.print(“V”); tableauDeChar[i] = ‘V’;break;
          case ‘W’ : Serial.print(“W”); tableauDeChar[i] = ‘W’;break;
          case ‘X’ : Serial.print(“X”); tableauDeChar[i] = ‘X’;break;
          case ‘Y’ : Serial.print(“Y”); tableauDeChar[i] = ‘Y’;break;
          case ‘Z’ : Serial.print(“Z”); tableauDeChar[i] = ‘Z’;break;
          case ‘0’ : Serial.print(“0”); tableauDeChar[i] = ‘0’;break;
          case ‘1’ : Serial.print(“1”); tableauDeChar[i] = ‘1’;break;
          case ‘2’ : Serial.print(“2”); tableauDeChar[i] = ‘2’;break;
          case ‘3’ : Serial.print(“3”); tableauDeChar[i] = ‘3’;break;
          case ‘4’ : Serial.print(“4”); tableauDeChar[i] = ‘4’;break;
          case ‘5’ : Serial.print(“5”); tableauDeChar[i] = ‘5’;break;
          case ‘6’ : Serial.print(“6”); tableauDeChar[i] = ‘6’;break;
          case ‘7’ : Serial.print(“7”); tableauDeChar[i] = ‘7’;break;
          case ‘8’ : Serial.print(“8”); tableauDeChar[i] = ‘8’;break;
          case ‘9’ : Serial.print(“9”); tableauDeChar[i] = ‘9’;break;
        }
      }
      i++;
  }
}

void loop()
{
  enregistrementTIC();
  for(int i=0; i<300; i++)
  {
    Serial.print(tableauDeChar[i]);
  }
  Serial.println("\n\nFin trame");
}

_```*
Je vous joints une capture pour que vous voyiez par vous-même,
Si vous avez des éléments de réponse je suis preneur !
Merci d’avance_


Bonjour

pas de UP sur ce forum (encore moins un Up 15h après message initial >:( ) il faut patienter.

le UP risque de ‘promouvoir’ le message … vers la poubelle

Bonjour elkilleros,

En regardant ton code, il y a des choses qui me surprennent.

Donc la fonction enregistrementTIC(), tu remplis ton tableau sans incrémenter i soit est toujours à zéro. peut-être rétirer la variable i dans cette fonction et récupérer par un paramètre de ta fonction qui incrémenterait depuis ta loop.

Deuxième point, tu lis toujours la même valeur de ton port série, est-ce normal?

Cordialement,

Vincent

prendre connaissance des Règles du Forum

@dpclive Déjà merci pour ta réponse

"Donc la fonction enregistrementTIC(), tu remplis ton tableau sans incrémenter i soit est toujours à zéro. peut-être rétirer la variable i dans cette fonction et récupérer par un paramètre de ta fonction qui incrémenterait depuis ta loop." -> J'incrémente bien le i en faisant i++ à la fin de la grande boucle for.

"Deuxième point, tu lis toujours la même valeur de ton port série, est-ce normal?" -> Comment ça ? Je suis pas sûr de comprendre ce point là est ce que tu peux être plus précis s'il te plait.

@al1fch effectivement j'avais pas lu ça, désolé et merci pour la piqûre de rappel, mais pas non plus la peine d'envahir le sujet en postant 2 réponses pour dire la même chose

elkilleros:
@al1fch effectivement j'avais pas lu ça, désolé et merci pour la piqûre de rappel, mais pas non plus la peine d'envahir le sujet en postant 2 réponses pour dire la même chose

Les deux messages sont complémentaires le premier textualise et le deuxième l'illustre, je vais dans le sens d'al1fch et si j'avais vu les messages avant lui il n'y aurait pas eu d'avertissement et ça aurait été poubelle directe.

:smiley:

Ton grand switch … case est inutile

if ( ( charIn >= 'A' && charIn <= 'Z' ) || ( charIn >= '0' && charIn <= '9' ) )
  tableauDeChar[i] = charIn;

fait la même chose en 2 lignes.
De plus tu sors de ta boucle d’enregistrement quand serial.avalaible() répond non.
Mais qui te dit que ta trame est finie ? à 9600 bauds il faut environ 1 ms par octet.
Pour être sûr de ne pas rater la fin, il faut attendre au moins 1 ms avant de décréter que la trame est terminée → utiliser le time_out de Serial.
Et ta fonction enregistrementTIC() pourrait renvoyer le nombre de caractères reçus (information intéressante).