Chronometre avec arrêt à distance

Version imprimable

Bonjour je suis en train de réaliser un chronometre pour mes élèves. Le projet final devrait avoir deux boitiers avec des cartes arduino uno.
une pour la mise en route et le reset
l'autre pour l'arrêt du chrono.

Je réussi à faire un chronometre sur le boitier 1 avec le bouton start et un reset.

j'ai acheté des cartes nrf24l01 pour la communication entre les deux cartes mais je n'arrive pas a configurer l'arrêt à distance

pourriez vous m'aider
merci

voici le programme du boitier 1 :slight_smile:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/ Inclure le code de la bibliothèque:
#include <LiquidCrystal.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
// Initialiser la bibliothèque avec les numéros des broches de l'interface
LiquidCrystal_I2C lcd(0x3f, 20, 4);
// La broche Numérique 6 est reliée au Bouton1. On lui donne le nom BtStartStop.
int BtStartStop = 6;
// La broche Numérique 7 est reliée au Bouton2. On lui donne le nom BtReset.
int BtReset = 7;
// Déclaration variable EtatBtStartStop qui va servir à stocker une valeur au format bool.
bool EtatBtStartStop;
// Déclaration variable EtatBtReset qui va servir à stocker une valeur au format bool.
bool EtatBtReset;
// Déclaration variable EtatBoutonAppuyer qui va servir à stocker une valeur au format int.
int EtatBoutonAppuyer;
// Etc...
int EtatChronoOnOFF;
int TempsEcoule;
int Milliseconde;
int Seconde;
int Minute;
 
// Variable pour stocker la valeur du timer interne du microcontrôleur (millis()) au format int unsigned long
unsigned long currentTime = 0;
// Variable pour Mémoriser la valeur du timer interne du microcontrôleur "currentTime" pour par la suite la comparer
// au format int unsigned long
unsigned long previousTime = 0;
 
void setup() {
// Faire de la broche du BtStartStop une entrée avec activation de la résistance de rappel interne de l'ARDUINO .
pinMode(BtStartStop, INPUT_PULLUP);
// Faire de la broche du BtReset une entrée avec activation de la résistance de rappel interne de l'ARDUINO .
pinMode(BtReset, INPUT_PULLUP);
lcd.init();
lcd.backlight();
// Configurez le nombre de colonnes et de lignes de l'écran LCD :
lcd.begin(20,4);
// Imprime un message sur l'écran LCD.
 
lcd.setCursor(2,1);
lcd.print ("** Boitier 1 **");
}
 
void loop() {
// Lit la broche d'entrée du BtStartStop et stock ça valeur dans EtatBtStartStop.
EtatBtStartStop = digitalRead(BtStartStop);
// Lit la broche d'entrée du BtReset et stock ça valeur dans EtatBtReset.
EtatBtReset = digitalRead(BtReset);
// Si EtatBtStartStop == LOW et EtatBoutonAppuyer == 0 on exécute les actions entre {}
if (EtatBtStartStop == LOW && EtatBoutonAppuyer == 0) {
// La variable EtatBoutonAppuyer prend la valeur de 1.
EtatBoutonAppuyer = 1;
// Si EtatChronoOnOFF = 0 alors EtatChronoOnOFF = 1 et inversement.
EtatChronoOnOFF = !EtatChronoOnOFF;
}
// Si EtatBtReset == LOW et EtatChronoOnOFF == 0 et EtatBoutonAppuyer == 0 on exécute les actions entre {}
if (EtatBtReset == LOW && EtatChronoOnOFF == 0 && EtatBoutonAppuyer == 0) {
// La variable EtatBoutonAppuyer prend la valeur de 1.
EtatBoutonAppuyer = 1;
// La variable Milliseconde prend la valeur de 0.
Milliseconde = 0;
//Etc...
Seconde = 0;
Minute = 0;
 
}
// Si EtatBtStartStop == HIGH et EtatBtReset == HIGH on exécute les actions entre {}
if (EtatBtStartStop == HIGH && EtatBtReset == HIGH) {
// La variable EtatBoutonAppuyer prend la valeur de 0.
EtatBoutonAppuyer = 0;
}
//On stocke la valeur du timer interne du microcontrôleur de l'arduino qu'ont récupére grace à millis() dans la variable currentTime
currentTime = millis();
//On calcule la valeur de TempsEcoule en effectuant une soustraction entre currentTime et previousTime.
TempsEcoule = currentTime - previousTime;
//On stocke la valeur du timer interne du microcontrôleur de l'arduino qu'ont récupére grace à millis() dans la variable previousTime
previousTime = millis();
 
// Si EtatChronoOnOFF == 1 on exécute les actions entre {}
if (EtatChronoOnOFF == 1) {
// On calcule la valeur de Milliseconde en effectuant une addition entre Milliseconde et TempsEcoule.
Milliseconde = Milliseconde + TempsEcoule;
// Si Milliseconde > 999 on exécute les actions entre {}
if (Milliseconde > 999) {
Milliseconde = Milliseconde - 1000;
// On incrémente la variable Seconde de + 1
Seconde++;
}
if (Seconde > 59) {
Seconde = 0;
Minute++;
}
 
}
// Placer le curseur sur la colonne 9, ligne 1 du LCD
// (note : la ligne 0 est la première ligne, puisque le comptage commence par 0):
lcd.setCursor(9, 3);
// Imprime un message sur l'écran LCD.
lcd.print(":");
// Si la variable Milliseconde est plus grande que 99 on exécute les actions entre {}
if (Milliseconde > 99) {
// Placer le curseur sur la colonne 10, ligne 1 du LCD
lcd.setCursor(10, 3);
// Imprime la valeur de la variable Milliseconde sur l'écran LCD
lcd.print(Milliseconde);
}
// Sinon si la variable Milliseconde est plus grande que 99 on exécute les actions entre {}
else if (Milliseconde > 9 && Milliseconde < 100) {
//Etc...
lcd.setCursor(10, 3);
lcd.print("0");
lcd.setCursor(11, 3);
lcd.print(Milliseconde);
}
else if (Milliseconde > 0 && Milliseconde < 10) {
lcd.setCursor(10, 3);
lcd.print("00");
lcd.setCursor(12, 3);
lcd.print(Milliseconde);
}
else {
lcd.setCursor(9, 3);
lcd.print(":000");
}
 
lcd.setCursor(6, 3);
lcd.print(":");
if (Seconde < 10) {
lcd.setCursor(7, 3);
lcd.print("0");
lcd.setCursor(8, 3);
lcd.print(Seconde);
}
else {
lcd.setCursor(7, 3);
lcd.print(Seconde);
}
 
lcd.setCursor(3, 3);
 
if (Minute < 10) {
lcd.setCursor(4, 3);
lcd.print("0");
lcd.setCursor(5, 3);
lcd.print(Minute);
}
else {
lcd.setCursor(4, 3);
lcd.print(Minute);
}
 
}

Bonjour,

Quelques réflexions en préambule :

Les commentaires doivent apporter une information complémentaire ou explicative. La simple reprise des instructions ne sert à rien à moins de considérer que le lecteur ne connaît rien au langage utilisé.
L'indentation du code serait un plus (pour certains langages c'est même une obligation). Avec une indentation, on s'aperçoit immédiatement que certains blocs ne sont pas à la bonne place (comme le test des secondes > 59 qui n'a de sens qu'après une incrémentation des secondes, c'est à dire dans le bloc du test Milliseconde > 999).
Le bourrage manuel avec des 0 pour la présentation des temps peut se comprendre dans un code pédagogique, mais un sprintf permet de faire le job en 2 lignes au lieu de 23.
Pourquoi actualiser les temps alors qu'ils ne sont utilisés que si le Chrono est actif (conseil : les mettre dans le boc suivant le test sur l'activation du chrono). C'est du reste un problème potentiel : à l'activation du chrono il faudrait sans doute actualiser le temps mémorisé sinon on risque d'avoir, non pas un dépassement limité (i.e. +1s) des 999 ms, mais de plusieurs secondes voire minutes et ce n'est pas traité.
Similairement, il n'est pas utile d'actualiser l'affichage en dehors du bloc lié au test sur l'activation du chrono.
Un délai anti rebond évitera des comportements inopportuns (répétitions non voulues). La solution simple de delay() peut être remplacée par l'utilisation de millis() si elle perturbe l'affichaqe du temps.

Proposition de code, non testé donc sans doute empreint de bugs pédagogiques :D
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 // Inclure le code de la bibliothèque: #include <LiquidCrystal.h> #include <Wire.h> #include <LiquidCrystal_I2C.h> // Initialiser la bibliothèque adresse puis les numéros des broches LiquidCrystal_I2C lcd(0x3f, 20, 4); int BtStartStop = 6; // Broche Numérique 6 reliée au Bouton1 nommée BtStartStop int BtReset = 7; // Broche Numérique 7 reliée au Bouton2 nommée BtReset. int btnStatusOld = 3; // Etat enregistré des deux broche 6 et 7 (3 <=> boutons non appuyés) bool ChronoOn = false; uint32_t TimeLast = 0; // Dernière valeur lue du timer du microcontrôleur uint32_t Milliseconde; unsigned Seconde, Minute; void setup() { pinMode(BtStartStop, INPUT_PULLUP); // BtStartStop en entrée avec résistance de rappel pinMode(BtReset, INPUT_PULLUP); // BtReset en entrée avec résistance de rappel lcd.init(); lcd.backlight(); lcd.begin(20, 4); // LCD de 20 colonnes et 4 lignes lcd.setCursor(2,1); lcd.print ("** Boitier 1 **"); } void loop() { // btnStatus = 0: tous appuyés, 1: BtReset appuyé, 2: BtStartStop appuyé, 3: aucun appuyé int btnStatus = digitalRead(BtStartStop) + digitalRead(BtReset) << 1; if(btnStatus <> btnStatusOld) { switch(btnStatus | ~btnStatusOld) { // Seuls les événements d'appuis : 1 -> 0 case 0: // >>> Appui des 2 <<< Pas de break => traiter appui sur BtReset ! btnStatus = 1; // Passage suivant en cas 2 (00|~01 = 00|10 = 10) case 1: // >>> Appui sur BtReset <<< if(!ChronoOn) { Milliseconde = 0; Seconde = Minute = 0; } break; case 2: // >>> Appui sur BtStartStop <<< ChronoOn ^= true; // Inverser l'état (actualiser TimeLast si true ?) } btnStatusOld = btnStatus; delay(15); // Anti rebond } if(ChronoOn) { uint32_t TimeNow = millis(); uint32_t TimeDelta = TimeNow - TimeLast; // Temps passé depuis la dernière lecture TimeLast = TimeNow; Milliseconde += TimeDelta; if(Milliseconde > 999) { // Suppose que Milliseconde + TimeDelta < 2 s ! Milliseconde -= 1000; Seconde++; if(Seconde > 59) { Seconde = 0; Minute++; } } char str[24]; // Attention : formatage limité à 99 59:999 sprintf(str, "%0.2d %0.2d:%0.3d", Minute, Seconde, Milliseconde); lcd.setCursor(4, 3); lcd.print(str); } }
J'ai utilisé un automate réduit aux transitions descendantes (appui sur un bouton). C'est concis mais pas nécessairement plus simple à lire. Cela permet aussi de traiter l'appui simultané des deux boutons (très peu réaliste mais qui doit malgré tout être pris en considération) presque sans code supplémentaire.

Salutations

21/07/2024, 20h09
raphreb

Merci beaucoup pour toutes ces remarques.
Je vais analyser tout cela .... c'est un gros boulot pour moi qui débute:D:D

encore merci pour votre aide
21/07/2024, 21h50
raphreb

J'ai avancé sur le projet depuis hier..
grâce à ce tuto : https://passionelectronique.fr/tutor...02%2C525%20MHz

j'ai alégé le code et réussi à faire comuniquer les deux arduino.
voici mes deux programmes :

je vais poster deux messages différents pour mes deux programmes :
- un pour le boitier haut (qui commande l'arrêt)
- un pour le boitier bas (qui possede le chrono et le depart) et si on appui deux fois sur le bouton départ il y a une remise à zéro

je vais tenir compte de vos remarques pour améloirer la performence du programme...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
/*
 
  BOITIER ESCALADE BAS
  Fichier:      sketch_jul19b - Recepteur
  Description:  Réception d'un message "stop" depuis un autre arduino nano, via un NRF24L01
 
 
  Librairie utilisée : RF24
 
  
*/
#include <SPI.h>
#include <RF24.h>
#include <LiquidCrystal.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
#define pinCE 7         // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN 8        // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel "PIPE1"  // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données de l'émetteur
 
RF24 radio(pinCE, pinCSN);  // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;  // Mise au format "byte array" du nom du tunnel
char message[32];                // Avec cette librairie, on est "limité" à 32 caractères par message
// Initialiser la bibliothèque avec les numéros des broches de l'interface
LiquidCrystal_I2C lcd(0x3f, 20, 4);
 
// La broche Numérique 6 est reliée au Bouton1. On lui donne le nom BtStartStop.
int BtStartStop = 6;
// La broche Numérique 5 est reliée au Bouton2. On lui donne le nom BtReset.
int BtReset = 5;
// Déclaration variable EtatBtStartStop qui va servir à stocker une valeur au format bool.
bool EtatBtStartStop;
// Déclaration variable EtatBtReset qui va servir à stocker une valeur au format bool.
bool EtatBtReset;
// Déclaration variable EtatBoutonAppuyer qui va servir à stocker une valeur au format int.
int EtatBoutonAppuyer;
// Etc...
int EtatChronoOnOFF;
int TempsEcoule;
int Milliseconde;
int Seconde;
int Minute;
 
// Variable pour stocker la valeur du timer interne du microcontrôleur (millis()) au format int unsigned long
unsigned long currentTime = 0;
// Variable pour Mémoriser la valeur du timer interne du microcontrôleur "currentTime" pour par la suite la comparer
// au format int unsigned long
unsigned long previousTime = 0;
 
 
void setup() {
  // Faire de la broche du BtStartStop une entrée avec activation de la résistance de rappel interne de l'ARDUINO .
  pinMode(BtStartStop, INPUT_PULLUP);
  // Faire de la broche du BtReset une entrée avec activation de la résistance de rappel interne de l'ARDUINO .
  //pinMode(BtReset, INPUT_PULLUP);
 
  // Partie NRF24
  radio.begin();                      // Initialisation du module NRF24
  radio.openReadingPipe(0, adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que ce soit, ici)
 
 
  lcd.init();
  lcd.backlight();
  // Configurez le nombre de colonnes et de lignes de l'écran LCD :
  lcd.begin(20, 4);
  // Imprime un message sur l'écran LCD.
  // Configurez le nombre de colonnes et de lignes de l'écran LCD :
  lcd.setCursor(2, 0);
  lcd.print("Chrono Escalade");
  lcd.setCursor(2, 1);
  lcd.print("** Boitier 1 **");
}
 
void loop() {
  // Lit la broche d'entrée du BtStartStop et stock ça valeur dans EtatBtStartStop.
  EtatBtStartStop = digitalRead(BtStartStop);
  // Lit la broche d'entrée du BtReset et stock ça valeur dans EtatBtReset.
  //EtatBtReset = digitalRead(BtReset);
 
  // Si EtatBtStartStop == LOW et EtatBoutonAppuyer == 0 on exécute les actions entre {}
  if (EtatBtStartStop == HIGH && EtatBoutonAppuyer == 0) {
    // La variable EtatBoutonAppuyer prend la valeur de 1.
    EtatBoutonAppuyer = 1;
    // Si EtatChronoOnOFF = 0 alors EtatChronoOnOFF = 1 et inversement.
    EtatChronoOnOFF = !EtatChronoOnOFF;
  }
 
  // Si EtatBtReset == LOW et EtatChronoOnOFF == 0 et EtatBoutonAppuyer == 0 on exécute les actions entre {}
  if (EtatChronoOnOFF == 0 && EtatBoutonAppuyer == 0) {
    // La variable EtatBoutonAppuyer prend la valeur de 1.
    EtatBoutonAppuyer = 1;
    // La variable Milliseconde prend la valeur de 0.
    Milliseconde = 0;
    //Etc...
    Seconde = 0;
    Minute = 0;
  }
 
  // Si EtatBtStartStop == HIGH et EtatBtReset == HIGH on exécute les actions entre {}
  if (EtatBtStartStop == LOW) {
    // La variable EtatBoutonAppuyer prend la valeur de 0.
    EtatBoutonAppuyer = 0;
  }
 
  if (radio.available()) {
    radio.read(&message, sizeof(message));  // Si un message vient d'arriver, on le charge dans la variable "message"
    //lcd.setCursor(7, 2);
    //lcd.print(message);
 
    EtatChronoOnOFF = !EtatChronoOnOFF;
  }
 
  //On stocke la valeur du timer interne du microcontrôleur de l'arduino qu'ont récupére grace à millis() dans la variable currentTime
  currentTime = millis();
  //On calcule la valeur de TempsEcoule en effectuant une soustraction entre currentTime et previousTime.
  TempsEcoule = currentTime - previousTime;
  //On stocke la valeur du timer interne du microcontrôleur de l'arduino qu'ont récupére grace à millis() dans la variable previousTime
  previousTime = millis();
 
  // Si EtatChronoOnOFF == 1 on exécute les actions entre {}
  if (EtatChronoOnOFF == 1) {
    // On calcule la valeur de Milliseconde en effectuant une addition entre Milliseconde et TempsEcoule.
    Milliseconde = Milliseconde + TempsEcoule;
    // Si Milliseconde > 999 on exécute les actions entre {}
    if (Milliseconde > 999) {
      Milliseconde = Milliseconde - 1000;
      // On incrémente la variable Seconde de + 1
      Seconde++;
    }
    if (Seconde > 59) {
      Seconde = 0;
      Minute++;
    }
  }
  // Placer le curseur sur la colonne 9, ligne 1 du LCD
  // (note : la ligne 0 est la première ligne, puisque le comptage commence par 0):
  lcd.setCursor(9, 3);
  // Imprime un message sur l'écran LCD.
  lcd.print(":");
  // Si la variable Milliseconde est plus grande que 99 on exécute les actions entre {}
  if (Milliseconde > 99) {
    // Placer le curseur sur la colonne 10, ligne 1 du LCD
    lcd.setCursor(10, 3);
    // Imprime la valeur de la variable Milliseconde sur l'écran LCD
    lcd.print(Milliseconde);
  }
  // Sinon si la variable Milliseconde est plus grande que 99 on exécute les actions entre {}
  else if (Milliseconde > 9 && Milliseconde < 100) {
    //Etc...
    lcd.setCursor(10, 3);
    lcd.print("0");
    lcd.setCursor(11, 3);
    lcd.print(Milliseconde);
  } else if (Milliseconde > 0 && Milliseconde < 10) {
    lcd.setCursor(10, 3);
    lcd.print("00");
    lcd.setCursor(12, 3);
    lcd.print(Milliseconde);
  } else {
    lcd.setCursor(9, 3);
    lcd.print(":000");
  }
 
  lcd.setCursor(6, 3);
  lcd.print(":");
  if (Seconde < 10) {
    lcd.setCursor(7, 3);
    lcd.print("0");
    lcd.setCursor(8, 3);
    lcd.print(Seconde);
  } else {
    lcd.setCursor(7, 3);
    lcd.print(Seconde);
  }
 
  lcd.setCursor(3, 3);
 
  if (Minute < 10) {
    lcd.setCursor(4, 3);
    lcd.print("0");
    lcd.setCursor(5, 3);
    lcd.print(Minute);
  } else {
    lcd.setCursor(4, 3);
    lcd.print(Minute);
  }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
 
  BOITIER ESCALADE HAUT
  Fichier:      sketch_jul20a - Emetteur
  Description:  Réception d'un message "stop" depuis un autre arduino nano, via un NRF24L01
  
 
  Librairie utilisée : RF24
 
  
*/
#include <SPI.h>
#include <RF24.h>
 
#include <LiquidCrystal.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
#define pinCE 7         // On associe la broche "CE" du NRF24L01 à la sortie digitale D7 de l'arduino
#define pinCSN 8        // On associe la broche "CSN" du NRF24L01 à la sortie digitale D8 de l'arduino
#define tunnel "PIPE1"  // On définit le "nom de tunnel" (5 caractères) à travers lequel on va recevoir les données de l'émetteur
 
RF24 radio(pinCE, pinCSN);  // Instanciation du NRF24L01
 
const byte adresse[6] = tunnel;  // Mise au format "byte array" du nom du tunnel
char message[32];                // Avec cette librairie, on est "limité" à 32 caractères par message
 
// Initialiser la bibliothèque avec les numéros des broches de l'interface
LiquidCrystal_I2C lcd(0x3f, 20, 4);
 
void setup() {
 
  lcd.init();
  lcd.backlight();
  // Configurez le nombre de colonnes et de lignes de l'écran LCD :
  lcd.begin(20, 4);
 
 
 
  // Partie NRF24
  radio.begin();                      // Initialisation du module NRF24
  radio.openReadingPipe(0, adresse);  // Ouverture du tunnel en LECTURE, avec le "nom" qu'on lui a donné
  radio.setPALevel(RF24_PA_MIN);      // Sélection d'un niveau "MINIMAL" pour communiquer (pas besoin d'une forte puissance, pour nos essais)
  radio.startListening();             // Démarrage de l'écoute du NRF24 (signifiant qu'on va recevoir, et non émettre quoi que ce soit, ici)
}
 
void loop() {
  // On vérifie à chaque boucle si un message est arrivé
  if (radio.available()) {
    radio.read(&message, sizeof(message));  // Si un message vient d'arriver, on le charge dans la variable "message"
    lcd.setCursor(2, 0);
    lcd.print(message);
  }
}

22/07/2024, 14h53
Jay M

attention, avec

Code:

radio.read(&message, sizeof(message)); // Si un message vient d'arriver, on le charge dans la variable "message"

vous allez lire les octets envoyés mais si vous n'avez pas envoyé un caractère nul à la fin ('\0') vous n'aurez pas une c-string dans votre tableau message

le tableau message est une variable globale, donc au début tous les 32 octets ont à 0

par exemple si vous envoyez "Hello" la première fois c'est OK, vous avez Hello et des à derrière donc le print() va fonctionner
si ensuite vous envoyez quelque chose de plus long "Coucou", ça va aller Car "Hello" aura été remplacé par "Couco" puis le "u" replace un 0 et il y a encore de 0 derrière
mais si ensuite vous envoyez quelque chose de plus court à nouveau comme "Hello", vous aurez dans le buffer "Hello" suivi du "u" et des 0 et donc l'écran affichera "Hellou"