Emission/reception avec myserial sur nano

Bonjour

Je fais un échange de données entre un Nano et un Mega.
Ceci avec des STRUCT comme on m'avais indiqué de faire.

Dans le sens Nano vers mega pas de problème.

Dans le sens mega vers nano, ça merdoie.

c.a.d: la valeur que j'envoie du mega est reçue correctement quelques secondes, et après
ça indique -13608 (toujours cette valeur).

Je précise que c'est sur la même ligne TX/RX.

que j'essaie de passer un float ou un int idem même problème, seule la valeur finale change.

Problème de timing ? de mémoire tampon du nano? ou mon code?

code mega

#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>
// Réception sur Mega 2560
// SDA=20  SCL=21
// Serial 1 (TX 18, RX 19)

LiquidCrystal_I2C lcd(0x3F, 20, 4);

int envoi1 = 196; //test envoi vers ch1
float envoi2 = 14.5;
int envoi3 = 123;
int envoi4 = 456;

struct Receivedech1
{
  float tempch1; //temperature
  float consch1; // consigne
  int statusch1; // status

};

struct Sendversch1 // Infos a envoyer vers CH1
{
int send1;
  //float send2;
  //int send3;
  //int send4;

};

void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);
  lcd.init(); //initialise le lcd
  lcd.clear();
  lcd.backlight();

}

void loop() {
  Receivedech1 dech1;
  if (Serial1.available())
  {
    Serial1.readBytes((byte *)&dech1, sizeof dech1);
    Serial.println(dech1.tempch1, 1); // temperature
    Serial.println(dech1.consch1, 1); // consigne
    Serial.println(dech1.statusch1);// status
  }

  Sendversch1 depart;
  depart.send1 = envoi1;
  //depart.send2 = envoi2;
  //depart.send3 = envoi3;
  //depart.send4 = envoi4;

  //serial.println(depart.se1,1);
  Serial1.write((byte *)&depart, sizeof depart);
 

  lcd.setCursor(0, 0);
  lcd.print(dech1.tempch1, 1);
  lcd.setCursor(0, 1);
  lcd.print(dech1.consch1, 1);
  lcd.setCursor(15, 1);
  lcd.print(dech1.statusch1);

 lcd.setCursor(0, 2);
  lcd.print(depart.send1, 1);
/*
lcd.setCursor(10, 2);
  lcd.print(depart.send2, 1);

lcd.setCursor(0, 3);
  lcd.print(depart.send3);

lcd.setCursor(10, 3);
  lcd.print(depart.send4);
*/
}

code nano

// +++++ NANO Oldbootloader +++

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>
#include <EEPROM.h>
#include <SoftwareSerial.h>
const byte BROCHE_ONEWIRE = 2; // DS18B20

#define One_WIRE_BUS1 2
OneWire oneWire1(One_WIRE_BUS1);
DallasTemperature sensors1(&oneWire1);
LiquidCrystal_I2C lcd(0x27, 20, 4);


int potarPin = A0; // Potar valeur de consigne
int potarValue = 0;

float tempch1 = 0; // Temperature chambre 1
float cons = 0; // Consigne
float val = 0; // Valeur potar pour consigne
int hystplus = 10;
int hystmoins = 3;


struct Sendversch2 // Infos a envoyer vers CH2
{
  float send1;
  float send2;
  int send3;
  //int send4;
};

struct receive // données recues de CH2
{
int recept1;
  //float recept2;
  //int recept3;
  //int recept4;
};

SoftwareSerial mySerial(10, 11); // RX, TX

void setup() {
 Serial.begin(9600);
  mySerial.begin(9600);
  sensors1.begin();
  //sensors1.setResolution(12);
  lcd.init(); //initialise le lcd
  lcd.clear();
  lcd.backlight();
}

void loop() {

  // +++++ Lecture temperature sur ds18b20 résolution a 12 +++++
  sensors1.requestTemperatures();
  float tempch1 = sensors1.getTempCByIndex(0);
  //int resolv1=sensors1.getResolution();

  // ++++ Lecture valeur potar +++
  potarValue = analogRead(potarPin);
  val = potarValue * (30.0 / 1023.0); // force la valeur entre 0 et 30



  // +++++ Emission données vers CH2 +++++
  Sendversch2 valeurs;
  valeurs.send1 = tempch1;
  valeurs.send2 = val;
  valeurs.send3 = hystplus;
  //valeurs.send4 = hystmoins;
  mySerial.write((byte *)&valeurs, sizeof valeurs);



  //+++++ Reception données de CH2 +++++
  receive recu;
  if (mySerial.available())
  {
    mySerial.readBytes((byte *)&recu, sizeof recu);
    Serial.println(recu.recept1, 1);
    // Serial.println(recu.recept2, 1);
    //Serial.println(recu.recept3);
    //Serial.println(recu.recept4);
  }

  lcd.setCursor(0, 0);
  lcd.print("T");
  lcd.setCursor(1, 0);
  lcd.print((char)223);
  lcd.setCursor(2, 0);
  lcd.print("=");

  lcd.setCursor(3, 0);
  lcd.print(tempch1, 1);
  lcd.setCursor(7, 0);
  lcd.print((char)223);

  lcd.setCursor(9, 0);
  lcd.print("C=");
  lcd.setCursor(11, 0);
  lcd.print(cons, 1);
  lcd.setCursor(15, 0);
  lcd.print((char)223);

  lcd.setCursor(0, 1);
  lcd.print("Val=");
  lcd.setCursor(4, 1);
  lcd.print(val, 1);
  lcd.setCursor(8, 1);
  lcd.print((char)223);

  lcd.setCursor(10, 1);
  lcd.print(recu.recept1, 1);
  /*
    lcd.setCursor(10, 1);
    if (etat == HIGH) {
      lcd.print("Marche");
    }
    if (etat == LOW) {
      lcd.print("Arret ");
    }
  */
  // EEPROM.get(0, mem);
  //Serial.println(tps2);
  //Serial.println(flag);
  //Serial.println(val);
  //Serial.println(cons);


  //Serial.println(resolv1);

}

Merci de votre intérêt

En appelant readBytes vous bloquez jusqu’à un timeout et ça peut vite dégénérer car vous ne testez que si vous avez un seul octet reçu avant de l’appeler

Si vous voulez comprendre comment bien écouter le port série (ou gérer un flux asynchrone genre keypad) vous pouvez jeter un oeil à mon petit tuto sur le sujet

Merci pour cette réponse

je comprend le coup du timeout mais
J'utilise ce readbytes aussi sur le mega et sans soucis...

peut-on modifier ce timeout?

ps:j'ai déjà lu ce bon tuto (entre autres), mais j'avoue ne pas tout saisir...je vais relire

Bonjour,

On peut modifier ce timeout avec Serial.setTimeout(), mais je doute que ce soit le problème car il est a 1s par défaut et ce serait étonnant qu'il y ait plus d'une seconde entre deux caractères.

Le lcd est lent aussi et va peut être créer une famine au niveau de la réception sur software serial et on perdrait potentiellement des octets . Suffit d’en perdre un pour que ça timeout

Bonjour

C'est encore moi avec mes soucis de transmission.

J'ai trouvé sur le forum anglais une méthode d'émission/réception.
Sans les maudits String et avec des marqueurs de début et de fin.

On peux y passer du texte, des int et des floats, et ça fonctionne.

Sauf que:
On ne peux envoyer tout cela que sous la forme
ex pour des floats

Serial1.write("<11.1,22.2,33.3,44.4>");

Et bien sur moi je voudrais par exemple

Serial1.print(<(temperature),(consigne),(hysteresismoins),(hysteresisplus)>);

Cela fait 2 jours que je me bat avec et je me résous a demander de l'aide encore une fois.

Donc, comment faire pour envoyer correctement et surement les floats dans le bon format?

ci-joint le code complet de réception

// Example 5 - Receive with start- and end-markers combined with parsing

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data
char messageFromPC[numChars] = {0};
int integerFromPC = 0;
float floatFromPC1 = 0.0;
float floatFromPC2 = 0.0;
float floatFromPC3 = 0.0;
float floatFromPC4 = 0.0;
boolean newData = false;

//============

void setup() {
  Serial.begin(9600);
  Serial.println("This demo expects 3 pieces of data - text, an integer and a floating point value");
  Serial.println("Enter data in this style <HelloWorld, 12, 24.7>  ");
  Serial.println();
}

//============

void loop() {
  recvWithStartEndMarkers();
  if (newData == true) {
    strcpy(tempChars, receivedChars);
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
    parseData();
    showParsedData();
    newData = false;
  }
}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();

    if (recvInProgress == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void parseData() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");     // get the first part - the string
  //strcpy(messageFromPC, strtokIndx); // copy it to messageFromPC
  floatFromPC1 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  //integerFromPC = atoi(strtokIndx);     // convert this part to an integer
  floatFromPC2 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ",");
  floatFromPC3 = atof(strtokIndx);     // convert this part to a float

  strtokIndx = strtok(NULL, ",");
  floatFromPC4 = atof(strtokIndx);

}

//============

void showParsedData() {
  /*
    Serial.print("Message ");


    Serial.println(messageFromPC);
    Serial.print("Integer ");
    Serial.println(integerFromPC);
    Serial.print("Float ");
  */

  Serial.println(floatFromPC1, 1);
  Serial.println(floatFromPC2, 1);
  Serial.println(floatFromPC3, 1);
  Serial.println(floatFromPC4, 1);

}[code]




Merci de votre compréhension

Tout simplement en envoyant par petits bouts :wink:

 Serial1.write(‘<‘);
Serial1.print(temperature,2);
Serial1.write(‘,‘);
Serial1.print(consigne,2);
Serial1.write(‘,‘);
Serial1.print(hysteresismoins,2);
Serial1.write(‘,‘);
Serial1.print(hysteresisplus,2);
Serial1.write(‘>‘);

Le 2 dans les print c’est pour dire deux chiffres après la virgule, en imaginant que ce sont des float

Effectivement Serial Input Basics Est un bon tuto (que je référence dans mon petit tuto sur le sujet)

Bon

ça reçoit,mais ça part un peu en vrille...

J’envoie des valeurs fixes (pour commencer)
22.6
19.8
1.5
0.6

et je reçois

22.6
19.8
1.0
19.8
22.6
19.8
1.5
0.6
22.6
19.8
1.0
19.8
22.6
19.8
1.0
19.8
22.6
19.8
1.5
0.6
22.6
19.8
1.0
19.8
22.6
19.8
1.0
19.8
22.6
19.8
1.5
0.6
22.6
19.8
1.0

peut-être une modif a faire dans la partie réception ?
qui est prévue pour recevoir des char ?

Essayez déjà de voir si la réception se passe bien, changez

 if (newData == true) {
    strcpy(tempChars, receivedChars);
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
    parseData();
    showParsedData();
    newData = false;
  }

par

if (newData) {
    serial.println(receivedChars);
    newData = false;
}

Alors j'obtiens ça

22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,<22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,<22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,<22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6
22.6,<22.6,19.8,1.5,0.6
22.6,19.8,1.5,0.6

Au cas ou

c'est moi qui ais mis une décimale.

Je doit quitter le forum pour aujourdh'ui

Y’a un soucis car vous recevez des trucs louches

22.6,[color=red]<[/color]22.6,19.8,1.5,0.6

Mais je pense que le souci principal c’est parce que vous recevez sur serial qui est aussi connecté sur la console... vous ne pouvez pas avoir deux acteurs qui jouent sur la même connexion série

Si vous n’êtes pas sur une mega qui a plusieurs ports série matériels, il faut utiliser un port software serial pour la réception et conserver serial pour l’affichage sur votre pc

Et bien sûr il faut que les GNDs des cartes soient connectés

Bonjour

A toutes fin utiles je rappelle que les transmissions s'effectue entre une mega et une nano.

Sur le nano, je me sert des broches 10 et 11, avec SoftwareSerial.h, donc pas de conflit avec serial.

Sur la mega c'est avec serial1 en 18 et 19.

L'alimentation en 5V de mes 2 cartes est interconnectée et est donnée par la prise USB, donc pas de soucis de gnd.

En revanche il existe déjà une transmission du nano vers la mega, qui fonctionne correctement.
mais qui n'utilise pas ce même bout de programme pour la réception.

Je vais retirer cette transmission pour voir si ce n'est pas elle qui fout la grouille.

Je fais des tests dans la matinée.

Bonne journée

Résultat des courses

en réduisant au strict minimum des 2 cotés la réception est nickel

Toutefois j'ai essayé de remettre le bout de code d'origine

if (newData == true) {
    strcpy(tempChars, receivedChars);
    // this temporary copy is necessary to protect the original data
    //   because strtok() used in parseData() replaces the commas with \0
    parseData();
    showParsedData();
    newData = false;
    }

et la ça merdoie

avec le code

 if (newData) {
    Serial.println(receivedChars);
    newData = false;
  }

c'est bon (peut-on le laisser comme ça?)

Question 1:
Comme je dois faire une com dans les 2 sens, est-ce que je dois utiliser un port différent pour l'émission et la réception?

Question 2:
Est-ce que la méthode avec les struct pose un problème (ça fonctionnait très bien seule).

struct ch1versch2 // Infos a envoyer vers CH2
{
  float val1; // Temperature
  float val2; // Consigne
  int val3; // Status
};

=================

 ch1versch2 valeurs;
  valeurs.val1 = tempch1;
  valeurs.val2 = cons;
  valeurs.val3 = etat;
  mySerial.write((byte *)&valeurs, sizeof valeurs);

ou dois-je adopter aussi la méthode du forum anglais?

Question 3: pour ma culturation perso
C'est quoi l'utilité des guillemets simples dans le code ci-dessous

Serial1.write('<');
  Serial1.print(temp, 1);
  Serial1.write(',');
  Serial1.print(cons, 1);
  Serial1.write(',');
  Serial1.print(hystch1moins, 1);
  Serial1.write(',');
  Serial1.print(hystch1tplus, 1);
  Serial1.write('>');

Merci pour votre aide

gandalf60:
Bonjour

A toutes fin utiles je rappelle que les transmissions s'effectue entre une mega et une nano.

Sur le nano, je me sert des broches 10 et 11, avec SoftwareSerial.h, donc pas de conflit avec serial.

Je ne comprends pas ce que vous dites, dans le code que vous avez publié plus haut comme étant celui du récepteur vous avez dans la fonction de réception

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;

  while (Serial.available() > 0 && newData == false) {
    rc = Serial.read();

je vois bien écrit que vous lisez Serial et pas une instance de software serial...

En revanche il existe déjà une transmission du nano vers la mega, qui fonctionne correctement.
mais qui n'utilise pas ce même bout de programme pour la réception.

Vous voulez dire que le code que vous avez partagé n’est pas celui utilisé ? Comment voulez vous qu’on vous aide alors ? Vous savez qu’on ne peut pas écouter deux software serial en même temps ?

c'est bon (peut-on le laisser comme ça?)

ben la vous n’analysez plus les données reçues... la duplication dans le nouveau buffer ne sert à rien puisque vous traitez le message avant d’aller en écouter un autre

Question 1:
Comme je dois faire une com dans les 2 sens, est-ce que je dois utiliser un port différent pour l'émission et la réception?.

Vous avez déjà deux ports, un Tx et un Rx, ils sont indépendants

Question 2:
Est-ce que la méthode avec les struct pose un problème (ça fonctionnait très bien seule)

Ça envoie les données en binaire donc pas la même approche pour décoder. C’est plus efficace mais moins simple pour debugger. De plus on ne pleut plus simplement mettre un marqueur de début et de fin puisque tous les octets sont potentiellement utilisés dans les valeurs numériques

Question 3: pour ma culturation perso
C'est quoi l'utilité des guillemets simples dans le code ci-dessous

La méthode print qu’on utilise avec des chaînes des caractères (reconnues par des guillemets) appelle en fait pour chaque caractère à tour de rôle ( donc avec des apostrophes) la méthode write. Donc en mettant directement write on gagne du temps. De plus à chaque fois que vous écrivez une chaîne entre guillemets le compilateur alloue un caractère de plus poivrot marquer la fin de la chaîne donc quand vous écrivez [color=purple]”<“[/color] vous avez alloué deux octets, ce qui est du gaspillage de mémoire

En bref donc, l’appel de write quand on sait qu’on envoie qu’un seul octet est bcp plus efficace

Publiez le vrai code sinon on peut pas vous aider...

Mea culpa, je suis vraiment désolé, c'est une erreur de ma part.

J'ai envoyé le code d'origine, dans le mien j'ai effectivement remplacé par myserial.

je joint le code actuel utilisé

#include <SoftwareSerial.h>

const byte numChars = 32;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

// variables to hold the parsed data
char messageFromPC[numChars] = {0};
int integerFromPC = 0;
float floatFromPC1 = 0.0;
float floatFromPC2 = 0.0;
float floatFromPC3 = 0.0;
float floatFromPC4 = 0.0;
boolean newData = false;

SoftwareSerial mySerial(10, 11); // RX, TX

void setup() {
  Serial.begin(9600);
  mySerial.begin(9600);
}

void loop() {

  recvWithStartEndMarkers();
  /*
     if (newData == true) {
     strcpy(tempChars, receivedChars);
     // this temporary copy is necessary to protect the original data
     //   because strtok() used in parseData() replaces the commas with \0
     parseData();
     showParsedData();
     newData = false;
     }
  */
  if (newData) {
    Serial.println(receivedChars);
    newData = false;
  }

}

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;
  //while (Serial.available() > 0 && newData == false) {
  while (mySerial.available() > 0 && newData == false) {
    //rc = Serial.read();
    rc = mySerial.read();
    if (recvInProgress == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

void parseData() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  strtokIndx = strtok(tempChars, ",");     // get the first part - the string
  //strcpy(messageFromPC, strtokIndx); // copy it to messageFromPC
  floatFromPC1 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  //integerFromPC = atoi(strtokIndx);     // convert this part to an integer
  floatFromPC2 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ",");
  floatFromPC3 = atof(strtokIndx);     // convert this part to a float

  strtokIndx = strtok(NULL, ",");
  floatFromPC4 = atof(strtokIndx);

}

//============

void showParsedData() {
  /*
    Serial.print("Message ");


    Serial.println(messageFromPC);
    Serial.print("Integer ");
    Serial.println(integerFromPC);
    Serial.print("Float ");
  */

  Serial.println(floatFromPC1, 1);
  Serial.println(floatFromPC2, 1);
  Serial.println(floatFromPC3, 1);
  Serial.println(floatFromPC4, 1);

}

Le code complet en émission

// Réception sur Mega 2560
// SDA=20  SCL=21
// Serial 1 (TX 18, RX 19)


float temp = 22.6;
float cons = 19.8;
float hystch1moins = 1.5;
float hystch1tplus = 0.6;


void setup() {
  Serial.begin(9600);
  Serial1.begin(9600);
}

void loop() {

  Serial1.write('<');
  Serial1.print(temp, 1);
  Serial1.write(',');
  Serial1.print(cons, 1);
  Serial1.write(',');
  Serial1.print(hystch1moins, 1);
  Serial1.write(',');
  Serial1.print(hystch1tplus, 1);
  Serial1.write('>');










}

edit: je ne sais pas si cela a un rapport, mais le moniteur se lance une fois sur dix

Voilà le code en réception nettoyé avec la console série à 115200 bauds.
Prenez l'habitude de ne pas gardez ce qui ne sert à rien et d'utiliser des noms de variables parlant, par exemple mySerial est un nom un peu stupide

#include <SoftwareSerial.h>
SoftwareSerial communicationMegaSerial(10, 11); // RX, TX

const byte numChars = 32;
char receivedChars[numChars];
boolean newData = false;

// variables to hold the parsed data
float floatFromPC1 = 0.0;
float floatFromPC2 = 0.0;
float floatFromPC3 = 0.0;
float floatFromPC4 = 0.0;

//============

void recvWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  char startMarker = '<';
  char endMarker = '>';
  char rc;
  while (communicationMegaSerial.available() > 0 && newData == false) {
    rc = communicationMegaSerial.read();
    if (recvInProgress == true) {
      if (rc != endMarker) {
        receivedChars[ndx] = rc;
        ndx++;
        if (ndx >= numChars) {
          ndx = numChars - 1;
        }
      }
      else {
        receivedChars[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        ndx = 0;
        newData = true;
      }
    }

    else if (rc == startMarker) {
      recvInProgress = true;
    }
  }
}

//============

bool parseData() {      // split the data into its parts

  char * strtokIndx; // this is used by strtok() as an index

  floatFromPC1 = 0;
  floatFromPC2 = 0;
  floatFromPC3 = 0;
  floatFromPC4 = 0;

  strtokIndx = strtok(receivedChars, ",");     // get the first part - the string
  if (strtokIndx == NULL) {
    Serial.println(F("Erreur format message 1"));
    return false;
  }
  floatFromPC1 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
  if (strtokIndx == NULL) {
    Serial.println(F("Erreur format message 2"));
    return false;
  }
  floatFromPC2 = atof(strtokIndx);

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) {
    Serial.println(F("Erreur format message 3"));
    return false;
  }
  floatFromPC3 = atof(strtokIndx);     // convert this part to a float

  strtokIndx = strtok(NULL, ",");
  if (strtokIndx == NULL) {
    Serial.println(F("Erreur format message 4"));
    return false;
  }
  floatFromPC4 = atof(strtokIndx);
  return true;
}

//============

void showParsedData()
{
  Serial.println(floatFromPC1, 1);
  Serial.println(floatFromPC2, 1);
  Serial.println(floatFromPC3, 1);
  Serial.println(floatFromPC4, 1);
}

//============

void setup()
{
  Serial.begin(115200);
  communicationMegaSerial.begin(9600);
}

void loop()
{
  recvWithStartEndMarkers();
  if (newData) {
    Serial.println(receivedChars);
    if (parseData()) showParsedData();
    newData = false;
  }
}

côté emission, ne balancez pas les données "à fond la caisse" commencez une fois par seconde

// Réception sur Mega 2560
// SDA=20  SCL=21
// Serial 1 (TX 18, RX 19)


float temp = 22.6;
float cons = 19.8;
float hystch1moins = 1.5;
float hystch1tplus = 0.6;


void setup() {
  Serial.begin(115200);
  Serial1.begin(9600);
}

void loop() 
{
  Serial1.write('<');
  Serial1.print(temp, 1);
  Serial1.write(',');
  Serial1.print(cons, 1);
  Serial1.write(',');
  Serial1.print(hystch1moins, 1);
  Serial1.write(',');
  Serial1.print(hystch1tplus, 1);
  Serial1.write('>');
  delay(1000); // on ne va pas surcharger la communication série. on envoie un message par seconde
}

j'ai tapé ces codes ici, donc il se peut qu'il y ait un bug, mais ça devrait vous donner une idée de la structure

à utiliser avec les terminaux Séries ouverts à 115200 bauds.

Pas de chance il y a un bug

voici la réception

⸮2 ⸮Kq⸮I⸮
V#⸮⸮⸮i⸮=⸮
V+⸮⸮2 ⸮⸮R+⸮A⸮I^⸮⸮
V+⸮⸮⸮i

vous avez bien pris en compte ce que j'ai dit:

à utiliser avec les terminaux Séries ouverts à 115200 bauds.

?