Discussion :

[Quentin_M]

Bonjour et merci de prêter attention à ce message,
Je suis débutant dans l’Arduino et j'essaye actuellement de coder des programmes afin de faire communiquer deux cartes Arduino (UNO comme maitre et NANO comme esclave) entre elles, le tout consistant à ce qu'elles s'échange des informations entre elles. Je me trouve cependant confronté à quelques difficultés...

Tout d'abords voila le but de ce système:
- un code est tapé sur la UNO (via un clavier); et un message de formalité s'affiche quant à lui sur un écran LCD également connécté.
- si le code est bon, la UNO envoie un message à la NANO, et cette dernière choisit l'action à faire en fonction de ce message qu'elle reçoit.
- L'action (qui en l’occurrence consiste à créer trois variables représentant un chiffre aléatoire entre 0 et 255) est alors effectué, puis envoyé à la UNO (les trois variables doivent être envoyées).
- La UNO doit alors s'approprier ces information et les attribuer trois de ses variables.

Là où le problème survient est lors de la communication de l'esclave vers le maitre (mais la communication du maitre vers l'esclave à elle l'air de marcher...).

Les codes en questions : (je m'excuse de l'intégrer au message mais je ne sais pas le faire autrement)

* Maitre
----------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <Wire.h>
 
#define Slave 0x01
 
#include <LiquidCrystal.h>
int rs = 13;
int en = 12;
int d4 = 7;
int d5 = 6;
int d6 = 5;
int d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
#define ligne_0 0
#define ligne_1 1
#define ligne_2 2
#define ligne_3 3
 
#define colonne_0 8
#define colonne_1 9
#define colonne_2 10
#define colonne_3 11
 
int Na;
int Nb;
int Nc;
 
void setup() {
 
  lcd.begin(16, 2);
  lcd.cursor();
 
  pinMode(ligne_0, OUTPUT);
  pinMode(ligne_1, OUTPUT);
  pinMode(ligne_2, OUTPUT);
  pinMode(ligne_3, OUTPUT);
 
  pinMode(colonne_0, INPUT_PULLUP);
  pinMode(colonne_1, INPUT_PULLUP);
  pinMode(colonne_2, INPUT_PULLUP);
  pinMode(colonne_3, INPUT_PULLUP);
 
  Wire.begin();
}
 
void loop() {
 
 lcd.print("Que voulez vous");
 lcd.setCursor(0 ,1);
 lcd.print("faire ?");
 int menu = oui_non();
 
 if(menu == 'A') {
 
    lcd.clear();
    lcd.print("every things OK");
 
    Wire.beginTransmission(Slave);
    Wire.write(1);
    Wire.endTransmission();
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Na = Wire.read();
    }
    Na = Wire.read();
 
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nb = Wire.read();
    }
    Nb = Wire.read();
 
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nc = Wire.read();
    }
    Nc = Wire.read();
 
    Wire.beginTransmission(Slave);
    Wire.write(5);
    Wire.endTransmission();
 
    lcd.clear();
    lcd.print(Na);
    delay(2000);
    lcd.setCursor(0,1);
    lcd.print(Nb);
    delay(2000);
    lcd.setCursor(0,1);
    lcd.print(Nc);
    delay(2000);
    lcd.clear();
   }
}
 
char oui_non() {
  char bouton = NULL;
  do {
    bouton = bouton_presse();
  } while(bouton == NULL);
 
  delay(100);
  while(bouton_presse() != NULL);
  delay(100);
 
  return bouton;
  lcd.clear();
}
 
char bouton_presse() {
 
  const char boutons[4][4] = {
    'A','B','C','D',
    '3','6','9','#',
    '2','5','8','0',
    '1','4','7','*',
  };
 
 
  for(int ligne=0;ligne<4;ligne++) {
 
    digitalWrite(ligne_0, ligne == 0 ? LOW : HIGH);
    digitalWrite(ligne_1, ligne == 1 ? LOW : HIGH);
    digitalWrite(ligne_2, ligne == 2 ? LOW : HIGH);
    digitalWrite(ligne_3, ligne == 3 ? LOW : HIGH);
 
    int etat_colonne_0 = digitalRead(colonne_0);
    int etat_colonne_1 = digitalRead(colonne_1);
    int etat_colonne_2 = digitalRead(colonne_2);
    int etat_colonne_3 = digitalRead(colonne_3);
 
    if(etat_colonne_0 == LOW) {
    return boutons[ligne][0];
    }
    if(etat_colonne_1 == LOW) {
    return boutons[ligne][1];
    }
    if(etat_colonne_2 == LOW) {
    return boutons[ligne][2];
    }
    if(etat_colonne_3 == LOW) {
    return boutons[ligne][3];
    }
  }
 
  return NULL;
 
}

----------

* esclave

----------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#include <Wire.h>
 
#define Slave 0x01
 
int option;
byte impression;
 
void setup() {
  Wire.begin( Slave);
  Wire.onReceive(commande);
  Wire.onRequest(transmi);
 
  Serial.begin(9600);
  Serial.print("Hey !?");
}
 
 
void loop() {
 commande;
 
  if(option == 1) {
    Serial.print("Salut !!!");
    byte N1 = random(0,255);
    impression = N1;
    transmi;
    Serial.println(N1);
 
    Serial.print("Salut !!");
    byte N2 = random(0,255);
    impression = N2;
    transmi;
    Serial.println(N2);
 
    Serial.print("Salut !");
    byte N3 = random(0,255);
    impression = N3;
    transmi;
    Serial.println(N3);
 
  }
  else {
    if(option == 5){
      option = 'stop';
    }
  }
}
 
char commande() {
  if(Wire.available() > 0) {
  option = Wire.read();
  }
}
 
char transmi() {
  Wire.write(impression);
}

----------


En espérant que vous pourrez m'aider car j'avoue avoir tenté tout ce qui me paraissait pouvoir marcher...

[jpbbricole]

Bonjour Quentin

J'ai regardé tes programmes, "en grand" et la structure du côté slave et surtout:

Wire.onReceive(commande);
Wire.onRequest(transmi);

qui sautent à des étiquettes dans loop()!

Avant d'aller plus loin, ce serait bien que tu fasses un ou deux exemples i2C de Wire.h

A+
Cordialement
jpbbricole

[Quentin_M]

Bonjour,
merci beaucoup pour votre réponse, elle m'a bien aidé !

Je me trouve cependant confronté à un autre problème:
lorsque la NANO envoie (problème retrouvé pour le troisième nombre de la série uniquement) un nombre à un ou deux chiffre seulement, la UNO lui rajoute un dernier chiffre ( exemple: le nombre était de 49 et la UNO l'a retranscrit comme étant 492 (dans ce cas c'était le dernier nombre de la série et les autres nombres étaient intactes, je ne comprends donc pas d'où provient le dernier "2"))

avez vous une astuce pour palier ce problème ?

(voici les codes...)

----------
code maitre (UNO)
----------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <Wire.h>
 
#define Slave 0x01
 
#include <LiquidCrystal.h>
int rs = 13;
int en = 12;
int d4 = 7;
int d5 = 6;
int d6 = 5;
int d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
#define ligne_0 0
#define ligne_1 1
#define ligne_2 2
#define ligne_3 3
 
#define colonne_0 8
#define colonne_1 9
#define colonne_2 10
#define colonne_3 11
 
int Na;
int Nb;
int Nc;
 
void setup() {
 
  lcd.begin(16, 2);
  lcd.cursor();
 
  pinMode(ligne_0, OUTPUT);
  pinMode(ligne_1, OUTPUT);
  pinMode(ligne_2, OUTPUT);
  pinMode(ligne_3, OUTPUT);
 
  pinMode(colonne_0, INPUT_PULLUP);
  pinMode(colonne_1, INPUT_PULLUP);
  pinMode(colonne_2, INPUT_PULLUP);
  pinMode(colonne_3, INPUT_PULLUP);
 
  Wire.begin();
}
 
void loop() {
 
 lcd.print("Que voulez vous");
 lcd.setCursor(0 ,1);
 lcd.print("faire ?");
 int menu = oui_non();
 
 if(menu == 'A') {
 
    lcd.clear();
    lcd.print("every things OK");
 
    Wire.beginTransmission(Slave);
    Wire.write(1);
    Wire.endTransmission();
    delay(500);
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Na = Wire.read();
    }
    Na = Wire.read();
 
    delay(500);
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nb = Wire.read();
    }
    Nb = Wire.read();
 
    delay(500);
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nc = Wire.read();
    }
    Nc = Wire.read();
 
    Wire.beginTransmission(Slave);
    Wire.write(5);
    Wire.endTransmission();
 
    lcd.clear();
    lcd.print(Na);
    delay(2000);
    lcd.setCursor(0,1);
    lcd.print(Nb);
    delay(2000);
    lcd.setCursor(0,1);
    lcd.print(Nc);
    delay(2000);
    lcd.clear();
   }
}
 
char oui_non() {
  char bouton = NULL;
  do {
    bouton = bouton_presse();
  } while(bouton == NULL);
 
  delay(100);
  while(bouton_presse() != NULL);
  delay(100);
 
  return bouton;
  lcd.clear();
}
 
char bouton_presse() {
 
  const char boutons[4][4] = {
    'A','B','C','D',
    '3','6','9','#',
    '2','5','8','0',
    '1','4','7','*',
  };
 
 
  for(int ligne=0;ligne<4;ligne++) {
 
    digitalWrite(ligne_0, ligne == 0 ? LOW : HIGH);
    digitalWrite(ligne_1, ligne == 1 ? LOW : HIGH);
    digitalWrite(ligne_2, ligne == 2 ? LOW : HIGH);
    digitalWrite(ligne_3, ligne == 3 ? LOW : HIGH);
 
    int etat_colonne_0 = digitalRead(colonne_0);
    int etat_colonne_1 = digitalRead(colonne_1);
    int etat_colonne_2 = digitalRead(colonne_2);
    int etat_colonne_3 = digitalRead(colonne_3);
 
    if(etat_colonne_0 == LOW) {
    return boutons[ligne][0];
    }
    if(etat_colonne_1 == LOW) {
    return boutons[ligne][1];
    }
    if(etat_colonne_2 == LOW) {
    return boutons[ligne][2];
    }
    if(etat_colonne_3 == LOW) {
    return boutons[ligne][3];
    }
  }
 
  return NULL;
 
}

----------
code escalve (NANO)
----------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <Wire.h>
 
#define Slave 0x01
 
int option;
byte impression;
 
void setup() {
  Wire.begin( Slave);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
 
  Serial.begin(9600);
  Serial.print("Hey !?");
}
 
 
void loop() {
 
  if(option == 1) {
    Serial.print("Salut !!!");
    byte N1 = random(0,255);
    impression = N1;
    Serial.println(N1);
    delay(750);
    Serial.print("Salut !!");
    byte N2 = random(0,255);
    impression = N2;
    Serial.println(N2);
 
    delay(500);
    Serial.print("Salut !");
    byte N3 = random(0,255);
    impression = N3;
    Serial.println(N3);
 
    option = 'stop';
  }
  else {
    if(option == 5){
      option = 'stop';
    }
  }
}
 
void receiveEvent(int howMany) {
  option = Wire.read();
}
 
void requestEvent() {
  Wire.write(impression);
}

[jpbbricole]

Bonjour Quentin

Le mieux est de mettre tout le code sur le forum, entre balises

Cordialement
jpbbricole

[Jay M]

A quoi correspond ce code (qu'essayez vous de faire) ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Na = Wire.read();
    }
    Na = Wire.read();
 
    delay(500);
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nb = Wire.read();
    }
    Nb = Wire.read();
 
    delay(500);
    Wire.requestFrom(Slave, 1);
    while(1 < Wire.available()) {
      Nc = Wire.read();
    }
    Nc = Wire.read();

[Quentin_M]

Ce code (la partie que vous avez sélectionnée) a pour but de créer chez la NANO (sur ordre de la UNO) trois variable correspondant à trois nombre aléatoire entre 0 et 255. La NANO doit alors les envoyer à la UNO afin que cette dernière attribue ces trois nombre à trois de ses variables. Les "delay()" sont placé là car c'est la seul facon que j'ai trouvé pour coordonner la création des nombres / leur communication (et non leur précédente version) / et l'enregistrement de ces derniers auprès de la UNO.

Le but final de ce code est de créer un coffre fort où la NANO serait la serrure placé en lieu sur, à l'origine d'un code secret; et où la UNO serait l'interface de sécurité permettant la communication entre l'utilisateur et la serrure. (car cette version n°1 des codes secrets (qui sont transmis par vague de trois) sont ensuite soumit à certaines fonctions au niveau de la UNO (lorsque l'utilisateur tapera un code secret sur le clavier afin de valider l'opération) puis la UNO communiquera son résultat à la NANO, qui elle vérifiera si le code renvoyé est bon)

Or pour le moment mon principal problème est d'assurer la correcte transmission des données...

[Jay M]

Vous demandez un seul octet, je ne vois pas pourquoi vous faites les while pour sauter éventuellement plus d'octets qui seraient retournés.

Mais pourquoi ne demandez pas directement 3 octets au slave dans une seule transaction ?

[Quentin_M]

je vous avouerai que j'ai construit ce code en fonction des observation et caractéristiques que j'ai pu observer dans d'autre code présent sur des tutos, forum... je ne comprends donc pas parfaitement le mode de fonctionnement de toutes les lignes mais lorsque quelque chose marchait (et que je ne la comprenait pas complètement) je préférai ne pas y toucher...

Maintenant que vous le dites, j'aurais surement besoin du "while" par la suite car je prévois de transmettre plus qu'un octet une fois que la base de mon code marchera (bien que je ne sache actuellement pas comment m'y prendre, mais à chaque moment son problème !)

pour se qui est de la séparation des trois octets, j'avoue ne pas y avoir pensé et je ne sais pas comment m'y prendre... (il faudrait ensuite que chaque nombre soit associé à une variable...)
cela m'arrangerai si vous pouviez expliquer les avantages que cela aurait vis à vis du code.

(de plus, avez vous une solution pour le problème précédent... ?)

[Jay M]

Voici un exemple où le demandeur envoie une requête pour 3 octets qui sont renvoyés par le fournisseur

LE DEMANDEUR D'INFORMATIONS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
// LE DEMANDEUR D'INFORMATIONS
#include <Wire.h>
 
const byte addresseEsclave = 0x4;
byte valeurs[3];
const byte tailleDesDonnees = sizeof(valeurs); // sizeof donne la taille en octets du tableau valeurs, donc ici 3 octets 
 
void setup()
{
  Serial.begin(115200);   // On démarre la liaison Série
  Wire.begin();           // la maître rejoint le bus I2C (il n'a pas besoin d'adresse)
 
  Serial.println();
  Serial.println(F("DEBUT DEMANDEUR"));
}
 
void loop()
{
  Serial.print(F("DEMANDE D'INFOS --> "));
  // on demande des informations à l'esclave et libére le bus ensuite
  int tailleReponse = Wire.requestFrom(addresseEsclave, tailleDesDonnees);
 
  // a-t'on reçu toutes les données ?
  if (tailleReponse == tailleDesDonnees) {
    Serial.print(F("BONNE RECEPION: "));
    for (byte i = 0; i < tailleDesDonnees; i++) {
      valeurs[i] = Wire.read();
      Serial.print(valeurs[i]);
      Serial.write(' ');
    }
    Serial.println();
  } else {
    Serial.println("MAUVAISE RECEPTION");
    while (Wire.available()) Wire.read(); // on vide ce qui a été reçu et qui n'était pas complet
  }
 
  // on attend 5 secondes et on redemande les infos
  delay(5000);
}

LE FOURNISSEUR D'INFORMATIONS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
// LE FOURNISSEUR D'INFORMATIONS
 
#include <Wire.h>
const byte addresseEsclave = 0x4;
 
byte valeurs[3];
const byte tailleDesDonnees = sizeof(valeurs);  // sizeof donne la taille en octets du tableau valeurs, donc ici 3 octets 
 
volatile bool demandeRecue = false;
 
// cette fonction est appelée automatiquement quand le maître demande des valeurs
void demandeValeurs()
{
  demandeRecue = true;
  for (byte i = 0; i < tailleDesDonnees; i++) {
    valeurs[i] = random(0, 256);
    Wire.write(valeurs[i]);
  }
}
 
void setup()
{
  Serial.begin(115200);           // On démarre la liaison Série
  Wire.begin(addresseEsclave);    // l'esclave rejoint le bus I2C à l'adresse "addresseEsclave"
  Wire.onRequest(demandeValeurs); // on enregistre la fonction appelée lorsqu'il y a une demande
  Serial.println();
  Serial.println(F("DEBUT FOURNISSEUR"));
}
 
void loop() {
  if (demandeRecue) { // si on a reçu une demande, on imprime ce que l'on a émis
    Serial.print(F("ENVOI DE "));
    for (byte i = 0; i < tailleDesDonnees; i++) {
      Serial.print(valeurs[i]); Serial.write(' ');
    }
    Serial.println();
    demandeRecue = false; // on a traité cette demande
  }
}

j'ai commenté le code, ça devrait se comprendre "tout seul", mais n'hésitez pas si vous avez des questions

il faut bien sûr 3 fils entre les 2 cartes Arduinos: GND, SCL et SDA

[Quentin_M]

Tout d'abord merci pour vos conseils.
j'ai essayé d'appliquer votre exemple à mon code (en me l'appropriant et donc le modifiant légèrement...) et j’obtiens correctement les deux premiers nombre mais le dernier quand à lui n'est pas correcte.

par exemple si le dernier nombre est sensé être 79, la UNO le lira comme 41... alors que les deux premiers nombre sont-eux toujours corrects !
"..............................................................." 32 "..........................." 43

Voici les codes :

UNO (maître / receveur) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <Wire.h>
 
#define Slave 0x01
 
#include <LiquidCrystal.h>
int rs = 13;
int en = 12;
int d4 = 7;
int d5 = 6;
int d6 = 5;
int d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
#define ligne_0 8
#define ligne_1 9
#define ligne_2 2
#define ligne_3 3
 
#define colonne_0 A1
#define colonne_1 A0
#define colonne_2 10
#define colonne_3 11
 
int Na;
int Nb;
int Nc;
byte valeurs[3];
byte tailleDesDonnees = sizeof(valeurs);
 
void setup() {
 
  lcd.begin(16, 2);
  lcd.cursor();
 
  pinMode(ligne_0, OUTPUT);
  pinMode(ligne_1, OUTPUT);
  pinMode(ligne_2, OUTPUT);
  pinMode(ligne_3, OUTPUT);
 
  pinMode(colonne_0, INPUT_PULLUP);
  pinMode(colonne_1, INPUT_PULLUP);
  pinMode(colonne_2, INPUT_PULLUP);
  pinMode(colonne_3, INPUT_PULLUP);
 
  Wire.begin();
}
 
void loop() {
 
 lcd.print("Que voulez vous");
 lcd.setCursor(0 ,1);
 lcd.print("faire ?");
 int menu = oui_non();
 
 if(menu == 'A') { 
 
    lcd.clear();
    lcd.print("every things OK");
 
    Wire.beginTransmission(Slave);
    Wire.write(1);
    Wire.endTransmission();
 
    rep();
    Na = valeurs[1];
    Nb = valeurs[2];
    Nc = valeurs[3];
 
    Wire.beginTransmission(Slave);
    Wire.write(5);
    Wire.endTransmission();
 
    lcd.setCursor(0 ,1);
    lcd.print(Na);
    delay(2000);
    lcd.print(" / ");
    lcd.print(Nb);
    delay(2000);
    lcd.print(" / ");
    lcd.print(Nc);
    delay(2000);
    lcd.clear();
   }
}
 
 
char rep() {
  lcd.clear();
  Wire.requestFrom(Slave, tailleDesDonnees);
  delay(500);
  int tailleReponse = Wire.available();
  if (tailleReponse == tailleDesDonnees) {
    lcd.print("BONNE RECEPION: ");
    for (byte i = 0; i < tailleDesDonnees; i++) {
      valeurs[i] = Wire.read();
      lcd.print(valeurs[i]);
    }
  } else {
    lcd.print("MAUVAISE RECEPTION");
    while (Wire.available()) Wire.read();
  }
 
}
 
char oui_non() {
  char bouton = NULL;
  do {
    bouton = bouton_presse();
  } while(bouton == NULL);
 
  delay(100);
  while(bouton_presse() != NULL);
  delay(100);
 
  return bouton;
  lcd.clear();
}
 
char bouton_presse() {
 
  const char boutons[4][4] = {
    'A','B','C','D',
    '3','6','9','#',
    '2','5','8','0',
    '1','4','7','*',
  };
 
 
  for(int ligne=0;ligne<4;ligne++) {
 
    digitalWrite(ligne_0, ligne == 0 ? LOW : HIGH);
    digitalWrite(ligne_1, ligne == 1 ? LOW : HIGH);
    digitalWrite(ligne_2, ligne == 2 ? LOW : HIGH);
    digitalWrite(ligne_3, ligne == 3 ? LOW : HIGH);
 
    int etat_colonne_0 = digitalRead(colonne_0);
    int etat_colonne_1 = digitalRead(colonne_1);
    int etat_colonne_2 = digitalRead(colonne_2);
    int etat_colonne_3 = digitalRead(colonne_3);
 
    if(etat_colonne_0 == LOW) {
    return boutons[ligne][0];
    }
    if(etat_colonne_1 == LOW) {
    return boutons[ligne][1];
    }
    if(etat_colonne_2 == LOW) {
    return boutons[ligne][2];
    }
    if(etat_colonne_3 == LOW) {
    return boutons[ligne][3];
    }
  }
 
  return NULL;
 
}

NANO (esclave / envoyeur) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <Wire.h>
 
#define Slave 0x01
 
int option;
byte impression[3];
byte tailleDesDonnees = sizeof(impression);
 
void setup() {
  Wire.begin( Slave);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
 
  Serial.begin(9600);
  Serial.print("Hey !?");
}
 
 
void loop() {
 
  if(option == 1) {
    byte N1 = random(0,255);
    Serial.println(N1);
    byte N2 = random(0,255);
    Serial.println(N2);
    byte N3 = random(0,255);
    Serial.println(N3);
    impression[1] = N1;
    impression[2] = N2;
    impression[3] = N3;
 
    option = 'stop';
  }
  else {
    if(option == 5){
      option = 'stop';
    }
  }
}
 
void receiveEvent(int howMany) {
  option = Wire.read();
}
 
void requestEvent() {
  byte tailleDesDonnees = sizeof(impression);
  for (byte i = 0; i < tailleDesDonnees; i++) {
    Wire.write(impression[i]);
  }
}

[Jay M]

Vous ne pouvez pas faire ça en C quand option est un int

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 option = 'stop';
  }
  else {
    if(option == 5){
      option = 'stop';
    }

le compilateur doit mettre un warning non?

[Quentin_M]

tout d'abord je ne suis pas sur de la signification de "C" ("char" ?). de plus j'ai par la suite supprimé la partie du code que vous avez sélectionné :
(qui est maintenant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
void loop() {
 
  if(option == 1) {
    byte N1 = random(0,255);
    Serial.println(N1);
    byte N2 = random(0,255);
    Serial.println(N2);
    byte N3 = random(0,255);
    Serial.println(N3);
    impression[1] = N1;
    impression[2] = N2;
    impression[3] = N3;
 
    option = 'stop';
  }
}

lors de la vérification du coté de l'esclave, tout parait correcte; cependant du coté Maitre il y a des écritures rouges (qui ne m’empêchent cependant pas de téléverser le code) que je n'ai malheureusement pas comprises... :

[jpbbricole]

Bonjour Quentin

Pour le message d'erreur, tout est dans le texte:

TwoWire: :requestFrom(int, int)
uint8_t requestFrom(int, int);

Ton programme dit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
byte tailleDesDonnees = sizeof(valeurs);
Wire.requestFrom(Slave, tailleDesDonnees);

D'où le warning du compilateur.
Changes ta déclaration en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int tailleDesDonnees = sizeof(valeurs);

Pour ton problème de données incorrectes, c'est un problème d'indice de tableau, tu déclares:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
byte impression[3];
byte tailleDesDonnees = sizeof(impression);

donc les indices 0, 1 et 2.
Quand tu remplis ton tableau de réponse:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
    impression[1] = N1;
    impression[2] = N2;
    impression[3] = N3;
 
// tu l'envoies:
  for (byte i = 0; i < tailleDesDonnees; i++) {
    Wire.write(impression[i]);
  }

Donc tu envoies ton tableau à partir de l'indice 0!
Tu dois remplir ton tableau ainsi et c'est OK

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    impression[0] = N1;
    impression[1] = N2;
    impression[2] = N3;

Cordialement
jpbbricole

[Quentin_M]

Merci beaucoup à vous deux pour votre si précieuse aide. Vous avez donné un grand coup d'accélérateur à mon projet !

Je pense pouvoir me débrouiller plus ou moins seul pour la suite... mais j’espère que si je faisait de nouveau appel à cette discussion, vous pourrez de nouveau m'aider !
Encore merci, Quentin.

[Quentin_M]

De nouveaux problèmes ont fait leur apparition...

(je conserve cette discussion car l'erreur survient également lors de communications i2c; même si elle y est moins liées que précédemment...)

j'ai quelque peu modifié le code et j'essaye à présent de transmettre trois variable de type "long".
j'utilise pour cela "union", afin de lier chacune de mes variables "long" à un tableau découpant chacun de ses octets; pour ensuite pouvoir les transmettre via le bus i2c (de l'esclave vers le maître).

Or à chaque envoi, le maître récupère systématiquement : (alors que les valeurs envoyées sont sensées être aléatoire...)
× 4294967040
×4294967295
×4294967295

(PS: savez-vous si il est possible, lors d'un calcul, d'au cours de ce dernier dépasser la limite de mémoire que possède la variable; bien qu'il soit par la suite diminué au cours de ce même calcul et qu'à la fin de ce dernier il soit compatible avec la limite de mémoire. Exemple : ("sqrt" étant racine carré)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
unsigned long a;
a = radom(10000000, 100000000);
a = a - 55555555;
a = sqrt(a * a);            // car dans un premier temps "a *a " dépassera la limite de 4 bytes que possède par nature "unsigned long";
                                  // mais la fonction racine carrée la ramenera ensuite dans cette limite... (ce qui sert dans ce cas à ce que le nombre soit toujours positif...)

)


voila les deux codes (je m'excuse du désordre qui y règne, c'est encore une ébauche...)

Esclave :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <Wire.h>
 
#define Slave 0x01
 
int option;
byte impression[3];
byte tailleImpression[3];
int tailleDesDonnees;
byte whatToDo;
byte whatToReceive;
 
// TEST
 
union N1 {
   unsigned long longN1;
   byte longBytesN1[4];
};
 
N1 nombre1;
 
union N2 {
   unsigned long longN2;
   byte longBytesN2[4];
};
 
N2 nombre2;
 
union N3 {
   unsigned long longN3;
   byte longBytesN3[4];
};
 
N3 nombre3;
// TEST
 
void setup() {
  Wire.begin( Slave);
  Wire.onReceive(receiveEvent);
  Wire.onRequest(requestEvent);
 
  Serial.begin(9600);
  Serial.println("Hey !?");
}
 
 
void loop() {
 
  whatToReceive = 1;
 
  if(option == 1) {
    nombre1.longN1 = getSeed();
    Serial.println(nombre1.longN1);
    nombre2.longN2 = getSeed();
    Serial.println(nombre2.longN2);
    nombre3.longN3 = getSeed();
    Serial.println(nombre3.longN3);
 
    whatToDo = 1;
 
    option = 'stop';
  } else {
    if(option == 2) {
      whatToReceive = 2;
 
    }
  }
}
 
unsigned long getSeed() {
  unsigned long seed = 0;
  byte i;
  while(seed < 9999999) {
    i = 27;
    seed = 0;
    while (i > 0) {
      byte firstBit = analogRead(A0) & 0x01;
      byte secondBit = analogRead(A0) & 0x01;
      if (firstBit != secondBit) {
        seed = (seed << 1) | firstBit;
        i--;
      }
    }
    if(seed > 99999999) {
      seed =0;
    }
  }
  return seed;
}
 
void receiveEvent(int howMany) {
  if (whatToReceive == 1) {
    option = Wire.read();
  } else {
    if(whatToReceive == 2) {
 
    } else {
      if(whatToReceive == 3) {
 
      } else {
        if(whatToReceive == 4) { //pour si je veux stocker une variable de la uno sur la carte mémoire sécurisée !!!
 
        } else {
          if(whatToReceive == 5) { //pour si je veux redonner à la UNO une variable qu'elle a stocké sur la carte mémoire sécurisée !!!
 
          }
        }
      }
    }
  }
}
 
void requestEvent() {
  if (whatToDo == 1) {
    ttTransmettre;
  } else {
    if (whatToDo == 2) { //pour transmettre le code d'urgence
 
    } else {
      if( whatToDo == 3) { //pour si je veux retransmettre les données stockées en sécurité !!!
 
      }
    }
  }
}
 
char ttTransmettre () {
  byte tailleDesDonnees1 = sizeof(nombre1.longBytesN1);
  byte tailleDesDonnees2 = sizeof(nombre2.longBytesN2);
  byte tailleDesDonnees3 = sizeof(nombre3.longBytesN3);
  for (byte i = 0; i < tailleDesDonnees1; i++) {
    Wire.write(nombre1.longBytesN1[i]);
  }
  tailleDesDonnees = sizeof(nombre2.longBytesN2);
  for (byte i = 0; i < tailleDesDonnees2; i++) {
    Wire.write(nombre2.longBytesN2[i]);
  }
  tailleDesDonnees = sizeof(nombre3.longBytesN3);
  for (byte i = 0; i < tailleDesDonnees3; i++) {
    Wire.write(nombre3.longBytesN3[i]);
  }
}

Maître :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
 
 
#include <Wire.h>
 
#define Slave 0x01
 
#include <LiquidCrystal.h>
int rs = 13;
int en = 12;
int d4 = 7;
int d5 = 6;
int d6 = 5;
int d7 = 4;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
 
#define ligne_0 8
#define ligne_1 9
#define ligne_2 2
#define ligne_3 3
 
#define colonne_0 A1
#define colonne_1 A0
#define colonne_2 10
#define colonne_3 11
 
int quoiFaire;
byte valeurs[3];
int tailleDesDonnees = sizeof(valeurs);
boolean code_juste;
char code1[4] = {
  '4','9','4','4',
};
char code2[8] = {
  '1','8','1','2','0','9','5','5',
};
 
//TEST
 
union N1 {
   unsigned long longN1;
   byte longBytesN1[4];
};
 
N1 nombre1;
 
union N2 {
   unsigned long longN2;
   byte longBytesN2[4];
};
 
N2 nombre2;
 
union N3 {
   unsigned long longN3;
   byte longBytesN3[4];
};
 
N3 nombre3;
 
//TEST
 
void setup() {
 
  lcd.begin(16, 2);
  lcd.cursor();
 
  pinMode(ligne_0, OUTPUT);
  pinMode(ligne_1, OUTPUT);
  pinMode(ligne_2, OUTPUT);
  pinMode(ligne_3, OUTPUT);
 
  pinMode(colonne_0, INPUT_PULLUP);
  pinMode(colonne_1, INPUT_PULLUP);
  pinMode(colonne_2, INPUT_PULLUP);
  pinMode(colonne_3, INPUT_PULLUP);
 
  Wire.begin();
}
 
void loop() {
 
 lcd.print("Que voulez vous");
 lcd.setCursor(0 ,1);
 lcd.print("faire ?");
 quoiFaire = oui_non();
 
 if(quoiFaire == 'A') {
  lcd.clear();
  lcd.print("Option choisit:");
  lcd.setCursor(0 ,1);
  lcd.print("A");
  delay(2000);
  mdp(1);
 
  if(code_juste == true) {
    Wire.beginTransmission(Slave);
    Wire.write(1);
    Wire.endTransmission();
    delay(2000);
    rep();
 
    lcd.setCursor(0 ,1);
    lcd.print(nombre1.longN1);
    delay(2000);
    lcd.clear();
    lcd.print(nombre2.longN2);
    delay(2000);
    lcd.setCursor(0 ,1);
    lcd.print(nombre3.longN3);
    delay(2000);
    lcd.clear();
  }
 } else {
 
 if(quoiFaire == 'B') {
  lcd.clear();
  lcd.print("Option choisit:");
  lcd.setCursor(0 ,1);
  lcd.print("B");
  delay(2000);
  mdp(1);
 } else {
 
 if(quoiFaire == 'C') {
  lcd.clear();
  lcd.print("Option choisit:");
  lcd.setCursor(0 ,1);
  lcd.print("C");
  delay(2000);
  mdp(1);
 } else {
 
 if(quoiFaire == 'D') {
  lcd.clear();
  lcd.print("Option choisit:");
  lcd.setCursor(0 ,1);
  lcd.print("D");
  delay(2000);
  mdp(2);
 } else {
   quoiFaire = 0;
 }
}
}
}
}
 
char rep() {
  lcd.clear();
  byte tailleDesDonnees1 = sizeof(nombre1.longBytesN1);
  byte tailleDesDonnees2 = sizeof(nombre2.longBytesN2);
  byte tailleDesDonnees3 = sizeof(nombre3.longBytesN3);
  Wire.requestFrom(Slave, tailleDesDonnees1 + tailleDesDonnees2 + tailleDesDonnees3);
  delay(500);
  int tailleReponse = Wire.available();
  if (tailleReponse == tailleDesDonnees1 + tailleDesDonnees2 + tailleDesDonnees3) {
    lcd.print("BONNE RECEPION: ");
    for (byte i = 0; i < tailleDesDonnees1; i++) {
      nombre1.longBytesN1[i] = Wire.read();
    }
    for (byte i = 0; i < tailleDesDonnees2; i++) {
      nombre2.longBytesN2[i] = Wire.read();
    }
    for (byte i = 0; i < tailleDesDonnees3; i++) {
      nombre3.longBytesN3[i] = Wire.read();
    }
  } else {
    lcd.print("MAUVAISE RECEPTION");
    while (Wire.available()) Wire.read();
  }
}
 
char mdp(int option) {
  code_juste = true;
  int taille;
  if(option == 1) {
    taille = 4;
  }
  if(option == 2) {
    taille = 8;
  } else {
    code_juste = 'error';
  }
  char code[taille];
 
  if(taille == 4) {
    for(int set = 0 ; set < taille ; set++ ) {
      code[set] = code1[set];
    }
  }
  if(taille == 2) {
    for(int set = 0 ; set < taille ; set++ ) {
      code[set] = code2[set];
    }
  }
 
  lcd.clear();
  lcd.print("Entrez le code:");
  lcd.setCursor(0 ,1);
 
  char code_tape[taille] = {
   0
  };
 
  for(int nbr_tape = 0 ; nbr_tape < taille ; nbr_tape++ ) {
   code_tape[nbr_tape] = oui_non();
   lcd.print("*");
  }
 
 for(int index=0; index < taille; index++) {
 
   if(code[index] != code_tape[index]) {
     code_juste = false;
     break;
    }
  }
 
 lcd.clear();
 if(code_juste == true) {
   lcd.print("CODE BON");
  }
 
 else {
   lcd.print("CODE INCORRECT");
   lcd.setCursor(0, 1);
   lcd.print("(ou erreur...)");
  }
  delay(2000);
  lcd.clear();
}
 
byte getSeed() {
  byte seed = 10;
  byte i;
  while(seed > 9) {
    seed = 0;
    i = 4;
    while (i > 0) {
      byte firstBit = analogRead(A0) & 0x01;
      byte secondBit = analogRead(A0) & 0x01;
      if (firstBit != secondBit) {
        seed = (seed << 1) | firstBit;
        i--;
      }
    }
  }
  return seed;
}
 
char oui_non() {
  char bouton = NULL;
  do {
    bouton = bouton_presse();
  } while(bouton == NULL);
 
  delay(100);
  while(bouton_presse() != NULL);
  delay(100);
 
  return bouton;
  lcd.clear();
}
 
char bouton_presse() {
 
  const char boutons[4][4] = {
    'A','B','C','D',
    '3','6','9','#',
    '2','5','8','0',
    '1','4','7','*',
  };
 
 
  for(int ligne=0;ligne<4;ligne++) {
 
    digitalWrite(ligne_0, ligne == 0 ? LOW : HIGH);
    digitalWrite(ligne_1, ligne == 1 ? LOW : HIGH);
    digitalWrite(ligne_2, ligne == 2 ? LOW : HIGH);
    digitalWrite(ligne_3, ligne == 3 ? LOW : HIGH);
 
    int etat_colonne_0 = digitalRead(colonne_0);
    int etat_colonne_1 = digitalRead(colonne_1);
    int etat_colonne_2 = digitalRead(colonne_2);
    int etat_colonne_3 = digitalRead(colonne_3);
 
    if(etat_colonne_0 == LOW) {
    return boutons[ligne][0];
    }
    if(etat_colonne_1 == LOW) {
    return boutons[ligne][1];
    }
    if(etat_colonne_2 == LOW) {
    return boutons[ligne][2];
    }
    if(etat_colonne_3 == LOW) {
    return boutons[ligne][3];
    }
  }
 
  return NULL;
 
}

[Jay M]

si vous postez du code incorrect, difficile de valider quoi que ce soit..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
  if (whatToDo == 1) {
    ttTransmettre; // <<== ça n'appelle pas votre fonction, il manque les parenthèses
  } else {

PS: vous n'avez pas besoin de définir 3 types d'union différentes, ce sont toutes les mêmes et imprimer les 4 octets d'un unsigned long ne nécessite pas de faire l'union, faites juste un print en précisant HEX comme format de sortie .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Serial.print(F("0x"));
Serial.print(maVariable, HEX);

(si certains octets en début du unsigned long sont nuls, ils ne seront pas affichés cependant)

[Quentin_M]

Merci pour votre réponse.

Je sais que je m'éloigne du sujet principal de cette discussion mais j'aimerai en profiter pour vous demander si vous aviez des astuces afin de pouvoir exercer des calculs sur un nombre supérieur à ceux compris dans "unsigned long" (qui est de 4 294 96 294 si je ne me trompe pas...)
(Car ne crois pas qu'il y ait des plus grandes variables sur arduino...)

(peut être en répartissant les octets sur deux variables ? si oui comment fait on ?!?)

Merci d'avance !

[Jay M]

vous pouvez utiliser les long long ou unsigned long long, qui seront sur 64 bits mais vous ne pourrez pas les imprimer sur la console.

voici un petit code d'exemple ou on voit une comparaison et une opération mathématique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
unsigned long long xll, yll, difference=0;
 
void setup() {
  Serial.begin(115200);
  Serial.print(F("xll occupera "));
  Serial.print(sizeof(xll));
  Serial.println(F(" octets")); // 8 octets
 
  xll = 0xFF000000000000;
  yll = 0xFF000001FFFFFF;
 
  if (yll > xll) {
    Serial.println(F("yll est plus grand que xll"));
    difference = yll - xll;
  } else {
    Serial.println(F("yll est plus petit ou égal à xll"));
    difference = xll - yll;
  }
 
 
  if (difference <= 0xFFFFFFFF) { // si la différence tient sur 32 bits
    // on peut l'imprimer
    Serial.print(F("La différence est de "));
    Serial.println((uint32_t) difference, HEX);
  } else {
    Serial.println(F("la différence est super grande !"));
  }
}
 
void loop() {}