demande aide pour syntaxe envoi trame liaison serie entre 2 arduino

Bonjour a tous

j'aurai besoin d'un coup de pouce pour faire avance ma programation

voila, l'idee c'est de faire comuniquer 2 carte arduino uno par la liason serie, soit par la hardserie ou la softserie (qui laissera la hardserie dispo pour de l'eventuel debug) je ne sais pas encore faire fonctionner la softserie.

2 carte arduiTX et arduiRX.

la arduiTX sur laquelle est connecté un ds1307 et un dht22 qui realise l'acquision des donné et l'expedition de de celle ci la arduiRX qui recoit les données les traite et les affiche sur un ecran lcd 20x4 classique

J'ai realise le code qui permet l'acquision et l'expedition des 2 trames de données

ce composant comme ceci : 1er trame { 'a' ,heures,minutes,secondes,jour,mois,année,crc,'/n'} ou /n indique la fin de trame 2em trame {'b', temperature,hygrometrie,crc,'/n'}

voila le code realisé pour la carte arduiTX

void loop() 

{
  // tant que la lecture du buffer serie net pas egal (!=) a $
  
  while (Serial.read() != '

mes questions sont : sous quelle forme (syntaxe) je doit declarer mes trames et avec quel syntaxe serial print ou write pour les evoyer ? sous quelle format vont elle etre envoyé ? pourra t-on les utiliser avec une boucle Serial.read() pour la reception ou faudra en + les decoder?

)

  {         Serial.read();                        //lecture octet suivant     //delay(3);                          //delai necessaire a l'operation     digitalWrite(led,LOW);  // extinction de la led    }     // on sort de tant que car reception $ on lit le buffer pour savoir quel typ de donnée on va envoyer (demtrame)     char demtrame = Serial.read();     // on allume la led pour indiquer qu'une transmition est demandé  
  digitalWrite (led,HIGH);    
// si demtrame strictement = au caractere 'a'

if (demtrame == 'a')

{  
  acquitemporel();   debugtemporel();   Serial.println("on envoi la 1er trame");  // on envoi la 1ere trame }         // si demtrame strictement = au caractere 'b'

if (demtrame == 'b')

{     acquitemphygro();   debugtemphygro();   Serial.println("on envoi la 2nd trame"); // on envoi la 2eme trame }    
    // si demtrame strictement = au caractere 'c'

if (demtrame == 'c')

{   Serial.println("on envoi la 3em trame"); // on envoi la 3eme trame } } ```

mes questions sont : sous quelle forme (syntaxe) je doit declarer mes trames et avec quel syntaxe serial print ou write pour les evoyer ? sous quelle format vont elle etre envoyé ? pourra t-on les utiliser avec une boucle Serial.read() pour la reception ou faudra en + les decoder?

bonjour

45 lectures du sujet et personne peut me filer un coup de pouce

dite moi au moi ce qui n'est pas comprehensible dans le sujet ou pourquoi on y aporte pas d'attention en gros qu'est ce qui cloche?

merci

Salut,

.print() ou .write() c'est toi qui voit ... si tu fait .print(), il faut recevoir ta chaine en char. Si .write(), en byte. Et après quelque soit ton choix il faut re-séparer les composantes évidemment.

Le plus simple pour l'émission c'est par exemple de faire :

Serial.print("$");
Serial.print(",");
Serial.print(Variable1);
Serial.print(",");
Serial.println(Variable2);

Et à la réception de détecter le $, de charger ce qui arrive dans un tableau de char, et dès qu'il y a une virgule on prend ce qui est dans le tableau, on fait un coup d' atol() ou d'atof() pour repasser en variable numérique et on continu comme ça jusqu'au \r\n ajouté par println()

bonjour B@tto

merci d’avoir repondu,l’idee c’est pas forcement de faire simple c’est surtout comprendre ce que je fait et pouvoir le reproduire et l’adapter si besoin est .

pour l’expe de données je pense m’orienter vers un Serial.write() dans une boucle pour eviter la repetition successive et une reception en byte

or si je fait un Serial.write(‘a’) ou Serial.Write(’,’) quel est la forme des donnée reçu au bout 8 ou 16bit, bin ou bcd?

sinon pour la fonction atol() ou atof() je ne connait pas du tout peut tu m’en dire plus? svp

j’ai trouvé ça ausi Serial.readBytesUntil() mais je sais pas m’en servir lol

// secondes = datads1307[0] ; minutes =datads1307[1] ; heures = datads1307[2] ; semaine = datads1307[3] ; jours = datads1307[4] ; mois = datads1307[5] ; années = datads1307[6]


 Serial.write('A')
 int TXtempdate[6] = {datads1307[4],datads1307[5],datads1307[6],datads1307[2],datads1307[1],datads1307[0]};
 for (int i=0; i <= 5; i++){Serial.write(TXtempdate[i]); Serial.write(',');}
 Serial.println();

Alors déjà le bcd n'a rien à faire ici, l'ASCII en revanche ;)

Pour write et print : il faut partir de la base. Dans tous les cas, la liaison série envois des bytes, donc un nombre en 0 et 255. Donc on peut envoyer en direct un nombre entre 0 et 255. Ca se fait avec write() :

Serial.write(18);

à la réception :

byte monByte=Serial.read; // mon Byte vaut alors 18

Maintenant il existe la table ASCII qui est une convention qui définie pour chaque nombre entre 0 et 255 un caractère ou une fonction. Par exemple A c'est 65, B c'est 66 ... Mais pour bien voir la différence on va reprendre le 18 d'avant. En ASCII comme on est limité à un caractère, il va falloir envoyé 1 puis 18, soit en ASCII 49 et 56. Je peux alors le faire de plusieurs manières :

Serial.write(49);
Serial.write(56);

A la réception :

char Buffer[2];
Buffer[0]=Serial.read();
Buffer[1]=Serial.read()
byte maVariable=atol(Buffer);

Mais je peux également écrire à l'émission :

Serial.print("18");

ou bien encore :

Serial.write('1');
Serial.write('8');

Les apostrophes renvoi le code ASCII du caractère qu'elles entourent.

Maitenant si à la réception tu fais :

byte Buffer[2];
Buffer[0]=Serial.read();
Buffer[1]=Serial.read()

Ton tableau sera alors {49,56} mais en fait le tableau de char contient les mêmes valeurs, c'est pour le reste de la programmation que ça posera problème, puisque il ne sera pas reconnu comme un tableau de caractère.

On peut s'arranger un peut de toute les manières, ce qui compte c'est que la manière de discuter soit la même. Au passage on note que l'envois en binaire est plus performant en terme de débit : l'envois en ASCII prendre 2 fois plus de temps (et si c'est un nombre >100 3 fois !) mais ce n'est pas forcement embêtant si le débit de donner dont on a besoin est très faible.

pour atol (array to long) et atof (array to float) : elles convertissent une chaine de caractères contenant une valeur en long ou en float :

char nombre[] = 18.254;
float monFloat=atof(nombre);

bonjour b@tto

j'ai teste les 2 liggne de code que ta mis a savoir

char nombre[] = 18.254;
float monFloat=atof(nombre);
Serial.println(monfloat);

et je pense que ya une petite erreur de syntax faut faire ça sinon ca retourne 0.00 avec un print ln

char nombre[] = " 18.254";
float monFloat=atof(nombre);
Serial.println(monfloat);

moin je doit transmettre dht.readTemperature() la valeur d'un sous prog declare comme float avec float t=dht.readTemperature()

float temperature = dht.readTemperature();
char nombre[5] = {temperature} ;
float monFloat=atof(nombre);
Serial.println(monFloat);

ca me renvoi 0.00 je comprend pas ! sans doute la syntaxe que est pas bonne ou j'ai pas compris le principe

Oui tu ne peux pas transformer comme ça un float en tableau de char, faut utiliser sprintf() :

char message[20];
float temperature = dht.readTemperature();
sprintf(message, "%f", temperature); 
float monFloat=atof(message);
Serial.println(monFloat)

Pour le problème juste avant ce ne doit pas être le code exact que tu as utilisé, puisqu'il y a une erreur sur les noms des variables. De plus je ne sais pas si atof apprécie les espaces.

Corrigé :

char nombre[] = "18.254";
float monFloat=atof(nombre);
Serial.println(monFloat);

bonsoir b@tto

merci pour la ligne de code

char message[20];
float temperature = dht.readTemperature();
sprintf(message, "%f", temperature); 
float monFloat=atof(message);
Serial.println(monFloat)

j'ai pas d'erreur a la compilation cependant ça me retourne 0,00

alors j'ai voulu savoir ce que retourne la fonction dht.readTemperature() seul par

Serial.println(dht.readTemperature());

et par la magie de l'arduino j'obtient un float de type 25.50

donc je pousse plus loin mes investigations puisque j'ai un float pourquoi declarer un float dans un float

float monfloat=float temperature

j'ai remplacé directement dans l'expression

char message[20];
sprintf(message, "%f", dht.readTemperature());
float monFloat=atof(message);
Serial.println(monFloat);

et la ca me retourne encore 0.00 je ne sais pas dire si la lecture du capteur ne se fait pas ou si l'expression utilisé doit etre encore adapté

ps : j'ai aucune notion de programmation en c ou c++ je me sert juste de ma logique des refence du site arduino et des notion qu'il me reste en ascembleur motorola 68hc11 )

Serial.println(dht.readTemperature());

et par la magie de l'arduino j'obtient un float de type 25.50

Pas de la magie c'est normal ^^ dht.readTemperature() est un float puisque la fonction retourne un float et que print() prend en charge les float. C'est pour ça que de la même manière on peut très bien faire :

float tempDoublee=dht.readTemperature() * 2;

Et en fait j'ai compris pourquoi mon code et le dernier que tu as posté ne fonctionne pas : la prise en charge des float sur sprintf est très gourmande en flash, donc dans Arduino ce n'est tout simplement pas possible.