Lecture tram

Bonjour à tous,

Je pose mon sujet car je débute en prog et que je commence à plus très bien comprendre .
Je vous explique j’ai une sonde de forage avec deux capteurs à l’interieur. A la sortie de la sonde je renvoie mes données en RS232 à l’Arduino Uno (entre j’ai un MAX232). La trame est envoyé avec un débit de 1200bauds et elle fait 23octets

Avec un code simple j’arrive à afficher ma tram sur le moniteur serial d’arduino mais je n’arrive pas à la traiter par octets et retomber sur mes mesures.
Je vous joins mon code :

#include <SoftwareSerial.h>

SoftwareSerial mySerial (2, 3);
int incomingByte = 0;   // for incoming serial data
int val = 0;

void setup() {
  Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
  mySerial.begin(1200);
}

void loop() {

  // send data only when you receive data:
  if (mySerial.available() > 0) {
    // read the incoming byte:
    incomingByte = mySerial.read();

    // say what you got:
    //Serial.print("I received: ");
    Serial.println(incomingByte, HEX);
  }
}

J’espère être arrivé à me fais comprendre
Si quelqu’un sait comment faire sa serait super sympa !
Merci à tous

Oui, je peux essayer ;-) Que contient exactement la trame (son format) ? arrives-tu à lire ses 23 octets ?

Je pense qu'il va simplement falloir regrouper les octets dans les bon types de données.

Si vous voulez comprendre comment bien écouter le port série vous pouvez jeter un oeil à mon petit tuto sur le sujet

Vous aurez la trame dans un buffer restera à l’analyser, pour cela il faut connaître sa structure

Bonjour,

Merci pour ces réponses. Depuis j'ai fais quelque avancées ! La trame envoyé ressemble à :" ..z.§.© ..ä ..Ë}. DoÓ.ÿ"

Avec l'arduino j'arrive bien à la lire et l'afficher en hexa avec mes 23 octets. Mon seul probleme est que je veux la stocker en hexa pour pouvoir la traiter par la suite. La trame en hexa : 13 03 7A 09 A7 03 A9 20 04 04 E4 20 09 09 CB 7D 01 20 44 6F D3 7F FF 13 étant le caractère de début et 7F FF le caractère de fin.

J'ai une autre question pour afficher ma trame lorsque je lis octet par octet et que je l'affiche dans le serial IDE il me manque des 0. Par exemple :

13 03 7A 09 A7 03 A9 20 04 04 E4 20 09 09 CB 7D 01 20 44 6F D3 7F FF --> 1337A9A73A92044E42099CB7D120446FD37FFF

Donc je n'ai plus la bonne trame ! il faut que je fasse un println pour avoir tous les octets mais ils sont pas sur la meme ligne..

print n’affiche pas le zéro en tête. Il faut l’ajouter à la main
remplace Serial.print(incomingByte, HEX);par

if (incomingByte<16) Serial.print("0");
Serial.print(incomingByte, HEX);

EDIT: correction sur la valeur dans le test

LoicFondasol: Avec l'arduino j'arrive bien à la lire et l'afficher en hexa avec mes 23 octets. Mon seul probleme est que je veux la stocker en hexa pour pouvoir la traiter par la suite. La trame en hexa : 13 03 7A 09 A7 03 A9 20 04 04 E4 20 09 09 CB 7D 01 20 44 6F D3 7F FF

La trame que tu reçois est en hexa, elle est stockée en interne en hexa.

fdufnews: La trame que tu reçois est en hexa, elle est stockée en interne en hexa.

Humm, hummm...

La trame, émise, reçue, stockée, n'est ni en hexa, ni en décimal, ni en ASCII. Elle est en octets. Chaque octet contient 8 bits, ordonnés, qui peuvent être à 0 ou à 1.

Oui, bien sûr, tout le monde sait cela, ça n'empêche pas les débutants de se faire des noeuds.

Ce n'est que lorsqu'on veut [u]interpréter[/u] la trame, par exemple la visualiser, qu'on utilise diverses méthodes de représentation de ces octets arides.

Si on [u]sait[/u] que la trame contient du texte, on la visualisera en ASCII, en UTF-8... Sinon, selon sa culture, ses besoins, on voudra la voir en décimal, en hexadécimal, en binaire...

Il ne faut pas confondre le [u]support/u avec le [u]sens[/u] qu'on leur donne. Faire le raccourci sans s'en rendre compte est une source commune d'erreurs pour les débutants.

Merci,

J'ai testé ta solution fdunews et ca marche pas.

Ma trame que je recois sur l'arduino par mon pic n'est pas en hexa. C'est dans le code de mon arduino que je demande de l'afficher en Hexa.

Je recois 23 octets. et j'aimerais les afficher en hexa et pouvoir les traiter en découpant la trame pour en récupérer mes données

LoicFondasol: J'ai testé ta solution fdunews et ca marche pas.

La solution de fdunews fonctionne, mais il faut définir incomingByte comme byte et non int, autrement ça va faire des valeurs négatives. Tu peux aussi insérer des espaces avec Serial.print(' ');

LoicFondasol: Je recois 23 octets. et j'aimerais les afficher en hexa et pouvoir les traiter en découpant la trame pour en récupérer mes données

En quoi le fait de les afficher en haxa va influer sur le traitement et le découpage de la trame?

Pour afficher un octet en hexa, le bout de code -qui traône partout- peut vous être utile:

uint8_t octet2Print;
if (octet2Print < 16) Serial.print('0');
Serial.print(octet2Print, HEX);
Serial.print(' '); // pour séparer
#include <SoftwareSerial.h>

SoftwareSerial mySerial (2, 3);
byte incomingByte = 0;   // for incoming serial data
int val = 0;

void setup() {
  Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
  mySerial.begin(1200);
}

void loop() {

  // send data only when you receive data:
  if (mySerial.available() > 0) {
    // read the incoming byte:
    incomingByte = mySerial.read();

    // say what you got:
    //Serial.print("I received: ");
    if (incomingByte<10) {
      Serial.print("0");
      Serial.print(incomingByte, HEX); }
    //Serial.println(incomingByte, HEX);
  }
}



Lorsque j'utilise ce code, la trame en sortie n'est pas bonne.. 
Avec l'affichage en hexa je peux utiliser la datasheet de ma sonde est comprendre mes données. C'est plus simple pour moi et c'est mon patron qui le demande ;)

Je me suis planté, ce n’est pas

if (incomingByte<10) {

mais
if (incomingByte<16) {puisqu’on affiche de l’hexa

Re,

J’ai utilisé vos méthodes mais je n’arrive pas à avoir ma trame
Dans le serial de l’IDE arduino je retrouve en réponse : 00 00 00 00 00 00 00 00 00 00 00 00
Ainsi de suite…

Le code utilisé :

#include <SoftwareSerial.h>

SoftwareSerial mySerial (2, 3);
byte incomingByte = 0;   // for incoming serial data
int val = 0;

void setup() {
  Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
  mySerial.begin(1200);
}

void loop() {

  // send data only when you receive data:
  if (mySerial.available() > 0) {
    // read the incoming byte:
    incomingByte = mySerial.read();
   
    // say what you got:
    //Serial.print("I received: ");

    //Serial.println(incomingByte, HEX);
  }
    uint8_t incomingByte;
    if (incomingByte < 16) {Serial.print('0');
    Serial.print(incomingByte, HEX);
    Serial.print(' '); // pour séparer
}
}

Il ne faut pas redéfinir incomingByte

void loop() {

  // send data only when you receive data:
  if (mySerial.available() > 0) {
    // read the incoming byte:
   uint8_t    incomingByte = mySerial.read(); // pas la peine de la décalere en variable globale
   
  
    if (incomingByte < 0x10) Serial.print('0'); // pas besoin de mettre un curlybrace pour une instruction...
    Serial.print(incomingByte, HEX);
    Serial.print(' '); // pour séparer
  }
}

Merci pour votre aide pour cette étape.

je retrouve bien les trames envoyées!

13 03 5D 09 4E 03 85 00 03 04 E9 00 0A 0A 92 7D 01 11 70 5F 33 7F FF

Je recois cette trame toute les 150ms, comment puis je faire pour dire qu'elle commence à enregistrer lorsque 0x13 est lu et d'arreter lorsque 0xFF est lu? J'ai essayé en utilisant un if suivi d'un for mais le résultat n'a rien donné..

Lisez le tuto sur le port série...

Bonjour,

Maintenant j'arrive à recevoir ma chaîne exactement comme je le souhaite dans le serial monitor. Mais derrière je veux utiliser LabVIEW ( ordre du patron ). Mais des lors que j'ouvre le port com avec labVIEW et que je veux lire ma trame depuis l'arduino elle contient des erreurs.

Est ce le bon endroit pour poser ma question ?

J'aimerais voir sous mon programme LabVIEW la mime trame que j'ai dans mon serial monitor.

Merci.

LoicFondasol:
Mais derrière je veux utiliser LabVIEW ( ordre du patron ). Mais des lors que j’ouvre le port com avec labVIEW et que je veux lire ma trame depuis l’arduino elle contient des erreurs.

Je ne comprends pas bien comment tout ça est connecté, et je ne suis peut-être pas le seul. Un petit croquis aiderait je pense.

Ci-joint un petit schéma pour essayer de mieux vous faire comprendre le projet…

J’ai un pic16F… qui envoie un signal 12V/-12V à un max232 qui convertit se signal en un signal 0/5V pour que l’arduino puisse communiquer.

Avec l’Arduino UNO je veux lire ma tram et la convertir en hexa.
Puis avec LabVIEW je veux effectuer tout mon traitement.

C’est a dire extraction de me données/Analyse/Visualisation et enregistrement dans un tableur. Cette partie ne vous concerne moins puisque c’est pas Arduino.

Mon seul probleme maintenant c’est que dans le serial monitor de l’arduino j’ai ma trame propre qui s’envoie mais dans LabView quand je viens lire le port com ou est branché l’arduino. La trame n’est plus la même et elle fausse.

Donc j’aimerais savoir comment faire. S’il suffit de faire un serial.Write de ma trame pour que je puisse la lire correctement ou s’il faut faire plus compliqué.