Arduino Serial Communication

Version imprimable

09/04/2021, 13h02
jemelacool12

Arduino Serial Communication
émetteur

Code:

Serial.println('B');

Récepteur
Code:

1 2 if(received == 'B') received = Serial.read();
Ca cela fonctionne mais me limite la 26 lettre et donc 26 possibilité.

ce que moi je voudrais mais que j'arrive pas a écrire

émetteur

Code:

Serial.println("'213");

Récepteur
Code:

1 2 if(received == "213") received = Serial.read();
ou

émetteur

Code:

Serial.println("'led_rouge_N-0004");

Récepteur
Code:

1 2 if(received == "led_rouge_N-0004") received = Serial.read();
et ça cela ne marche pas , je dois faire une faute avec ' ' ou " " ou je ne sais pas parce que je suis pas programmeur :oops:

Salut

ce serait bien de lire received avant de le tester, non? :)
Code:

1 2 if(received == 'B') received = Serial.read();
Notez que read() ne lit qu'un seul octet (et l'enlève du buffer d'entrée). bien sûr, ce n'est pas limité à 26, vous pouvez aussi envoyer n'importe quel autre symbole, il y a 255 possibilités dans un octet (en code ascii vous avez les majuscules, minuscules, les chiffres et de nombreux symboles comme le point, la virgule, etc)

Comment faire pour gérer de plus longs messages:

Solution 1:
Avec les contraintes associées (sur le timeout et le blocage du code ainsi que le risque de morcellement mémoire lié aux Strings) vous pouvez utiliser les fonctions "bloquantes" proposées par l'IDE. (utile si le code ne fait rien d'autre qu'attendre une saisie)
si vous faites tourner ce code avec le moniteur série ouvert à 115200 bauds
Code:

1 2 3 4 5 6 7 8 9 10 void setup() { Serial.begin(115200); } void loop() { Serial.println(F("Entrez un message et validez")); while (Serial.available() == 0); // on attend l'arrivée du premier caractère String recu = Serial.readString(); Serial.print(F("reçu: ")); Serial.println(recu); }
vous pouvez taper du texte et il sera lu correctement. Vous verrez cependant qu'il y a une seconde d'attente environ entre le moment ou vous validez et le moment où c'est affiché. C'est parce que la fonction readString() ne sait pas vraiment quand s'arrêter de lire, et donc attend un timeout de 1s par défaut

Solution 2:
Si vous configurez le moniteur série pour envoyer une "Nouvelle Ligne" (NL) comme fin de ligne alors on peut utiliser cette information pour ne pas attendre la fin du timeout et répondre dès qu'on a reçu ce NL (code '\n' en programmation). Si vous essayez ce code vous verrez que c'est plus rapide
Code:

1 2 3 4 5 6 7 8 9 10 void setup() { Serial.begin(115200); } void loop() { Serial.println(F("Entrez un message et validez")); while (Serial.available() == 0); // on attend l'arrivée du premier caractère String recu = Serial.readStringUntil('\n'); Serial.print(F("reçu: ")); Serial.println(recu); }
Solution 3: le faire proprement en gérant de manière asynchrone les caractères quand ils arrivent. gros avantage, pas de blocage du code, vous pouvez faire autre chose en attendant les messages (par exemple piloter votre robot sans attendre le flux d'entrée de données d'un GPS connecté sur le port série).

Vous trouverez de nombreux tutorials, voici 3 bons articles à lire que je recommande:
- pour les anglophones:
* Serial Input Basics (très détaillé avec une progression dans les fonctionnalités)

- pour les francophones:
* Les tutos d'eskimon: généralités-sur-la-voie-série
* Ecouter le Port Série ou un keypad (applicable à 1 flux de données asynchrone )

Receveur

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
void Test() {
 
 lcd.clear();
 lcd.setCursor(2,0);
 lcd.print("Test  Cibles");
 delay(1000);
 Serial.println('S'); //Envoie S pour demarrer esclave
 
 
 while (1) {
 
 
   if (Serial.available()>0) {          // Si des données sont disponibles
    received = Serial.read();          // On les récupère
 
 
 //Cibles 1
         if(received == 'A') // Recois A depuis Esclave = Cible 1
           {buttonStateUP=1;}
           else { buttonStateUP=0;}
        if (buttonStateUP != lastButtonStateUP) 
          {
       if ( buttonStateUP == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 1 HIT" );
            tone(12, 200, 300);}
          lastButtonStateUP = buttonStateUP;
          }
 
 //Cible 2         
         if(received == 'B') // Recois B depuis Esclave = Cible 2
           {buttonStateDown=1;}
           else { buttonStateDown=0;}
        if (buttonStateDown != lastButtonStateDown) 
          {
       if ( buttonStateDown == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 2 HIT" );
            tone(12, 400, 300);}
          lastButtonStateDown = buttonStateDown;
          }
 
//Cible 3           
         if(received == 'C') // Recois C depuis Esclave = Cible 3
           {buttonStateLeft=1;}
           else { buttonStateLeft=0;}
        if (buttonStateLeft != lastButtonStateLeft) 
          {
       if ( buttonStateLeft == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 3 HIT" );
            tone(12, 600, 300);}
          lastButtonStateLeft = buttonStateLeft;
          }
 
 
//Cible 4
         if(received == 'D') // Recois D depuis Esclave = Cible 4
           {buttonStateRight=1;}
           else { buttonStateRight=0;}
        if (buttonStateRight != lastButtonStateRight) 
          {
       if ( buttonStateRight == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Zone 4 HIT" );
            tone(12, 800, 300);}
          lastButtonStateRight = buttonStateRight;
          }
 
//Cible 5          
         if(received == 'E') // Recois E depuis Esclave = Cible 5
           {buttonStateSelect=1;}
           else { buttonStateSelect=0;}
        if (buttonStateSelect != lastButtonStateSelect) 
          {
       if ( buttonStateSelect == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 5 HIT" );
            tone(12, 1000, 300);}
          lastButtonStateSelect = buttonStateSelect;
          }
 
 
//Cible  6         
         if(received == 'F') // Recois F depuis Esclave = Cible 6
           {buttonState6=1;}
           else { buttonState6=0;}
        if (buttonState6 != lastButtonState6) 
          {
       if ( buttonState6 == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 6 HIT" );
            tone(12, 1200, 300);}
          lastButtonStateSelect = buttonStateSelect;
          }          
   }
 }
} // fin test

Emetteur

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
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
//Variable
int LEDRouge = 13;
int LEDVert = 12;
int LEDJaune = 11;
int received; //reception RF/PC
void Jeux();
const int threshold= 100;
 
const int sensorPin0= 0;
const int sensorPin1= 1;
const int sensorPin2= 2;
const int sensorPin3= 3;
const int sensorPin4= 4;
const int sensorPin5= 5;
const int sensorPin6= 6;
 
int led_R1= 24;
int led_R2= 28;
int led_R3= 32;
int led_R4= 36;
int led_R5= 40;
int led_R6= 44;
 
int led_G1= 23;
int led_G2= 27;
int led_G3= 31;
int led_G4= 35;
int led_G5= 39;
int led_G6= 43; 
 
int led_B1= 22;
int led_B2= 26;
int led_B3= 30;
int led_B4= 35;
int led_B5= 39;
int led_B6= 43;
 
int buzzer_1= 25;
int buzzer_2= 29;
int buzzer_3= 33;
int buzzer_4= 37;
int buzzer_5= 41;
int buzzer_6= 45;
 
//Variable pour l'état actuel du bouton poussoir
int buttonStateC1 = 0;         
int lastButtonStateC1 = 0;     
int buttonStateC2 = 0;         
int lastButtonStateC2 = 0;     
int buttonStateC3 = 0;         
int lastButtonStateC3 = 0;
int buttonStateC4 = 0;         
int lastButtonStateC4 = 0;
int buttonStateC5 = 0;         
int lastButtonStateC5 = 0;
int buttonStateC6 = 0;         
int lastButtonStateC6 = 0;
int buttonStateC7 = 0;         
int lastButtonStateC7 = 0; 
int buttonStateC8 = 0;         
int lastButtonStateC8 = 0;
 
 
void setup() {
  Serial.begin(9600);
 
  pinMode(LEDRouge, OUTPUT);
  pinMode(LEDVert, OUTPUT);
  pinMode(LEDJaune, OUTPUT);
 
  pinMode(buzzer_1, OUTPUT);
  pinMode(buzzer_2, OUTPUT);
  pinMode(buzzer_3, OUTPUT);
  pinMode(buzzer_4, OUTPUT);
  pinMode(buzzer_5, OUTPUT);
  pinMode(buzzer_6, OUTPUT);
 
  pinMode(led_R1, OUTPUT);
  pinMode(led_R2, OUTPUT);
  pinMode(led_R3, OUTPUT);
  pinMode(led_R4, OUTPUT);
  pinMode(led_R5, OUTPUT);
  pinMode(led_R6, OUTPUT);
 
  pinMode(led_G1, OUTPUT);
  pinMode(led_G2, OUTPUT);
  pinMode(led_G3, OUTPUT);
  pinMode(led_G4, OUTPUT);
  pinMode(led_G5, OUTPUT);
  pinMode(led_G6, OUTPUT);
 
  pinMode(led_B1, OUTPUT);
  pinMode(led_B2, OUTPUT);
  pinMode(led_B3, OUTPUT);
  pinMode(led_B4, OUTPUT);
  pinMode(led_B5, OUTPUT);
  pinMode(led_B6, OUTPUT); 
 
 
} // fin setup
 
 
 
void loop() {
 
     digitalWrite(LEDRouge, HIGH);
     digitalWrite(LEDVert, LOW);
     digitalWrite(LEDJaune, LOW);
 
  while(1) {
     if (Serial.available()>0) {          // Si des données sont disponibles
    received = Serial.read();          // On les récupère
    if(received == 'S') {Jeux();}
 
     }
     } // fin while     
}  //fin loop
 
//----------------------------------------------------------------------------------------------------------------
 
void Jeux() {
 
     digitalWrite(LEDRouge, LOW);
     digitalWrite(LEDVert, HIGH);
     digitalWrite(LEDJaune, LOW);
 
 while(1) {    
 
  if (Serial.available()>0) {          // Si des données sont disponibles
    received = Serial.read();          // On les récupère
    if(received == 'F') {loop(); }
  }
 
 
  // Lecture boutons
 
         int val0= analogRead(sensorPin0);
//Cibles 1
         if(val0 >= threshold) // Cible pin 0
           {buttonStateC1=1;}
           else { buttonStateC1=0;}
        if (buttonStateC1 != lastButtonStateC1) 
          {
       if ( buttonStateC1 == 1) 
          {Serial.println('A');            
            analogWrite(led_G1, 255);
            tone(buzzer_1, 2093, 500);
  //          tone(buzzer_1, 500 );
            delay(500);           
            analogWrite(led_G1, 0);
   //         noTone(buzzer_1);
   }
          lastButtonStateC1 = buttonStateC1;
          }
 
         int val1= analogRead(sensorPin1);
 //Cible 2         
         if(val1 >= threshold) // Cible pin 1
           {buttonStateC2=1;}
           else { buttonStateC2=0;}
        if (buttonStateC2 != lastButtonStateC2) 
          {
       if ( buttonStateC2 == 1) 
          {Serial.println('B');
            analogWrite(led_G2, 255);
            tone(buzzer_2, 2093, 500);
            delay(500);           
            analogWrite(led_G2, 0);
    //        noTone(buzzer_2);
    }
          lastButtonStateC2 = buttonStateC2;
          }
 
        int val2= analogRead(sensorPin2);  
//Cible 3          
         if(val2 >= threshold) // Cibles pin 2
           {buttonStateC3=1;}
           else { buttonStateC3=0;}
        if (buttonStateC3 != lastButtonStateC3) 
          {
       if ( buttonStateC3 == 1) 
          {Serial.println('C');
            analogWrite(led_G3, 255);
            tone(buzzer_3, 2093, 500);
            delay(500);           
            analogWrite(led_G3, 0);
    //        noTone(buzzer_3);
    }
          lastButtonStateC3 = buttonStateC3;
          }
 
        int val3= analogRead(sensorPin3);
//Cible 4
                   if(val3 >= threshold) // Cible pin 3
           {buttonStateC4=1;}
           else { buttonStateC4=0;}
        if (buttonStateC4 != lastButtonStateC4) 
          {
       if ( buttonStateC4 == 1) 
          {Serial.println('D');
            analogWrite(led_G4, 255);
            tone(buzzer_4, 2093, 500);
            delay(500);           
            analogWrite(led_G4, 0);
     //       noTone(buzzer_4);
     }
          lastButtonStateC4 = buttonStateC4;
          }
 
        int val4= analogRead(sensorPin4); 
//Cible 5          
                   if(val4 >= threshold) // Cible pin 4
           {buttonStateC5=1;}
           else { buttonStateC5=0;}
        if (buttonStateC5 != lastButtonStateC5) 
          {
       if ( buttonStateC5 == 1) 
          {Serial.println('E');
            analogWrite(led_G5, 255);
            tone(buzzer_5, 2093, 500);
            delay(500);           
            analogWrite(led_G5, 0);
          //  noTone(buzzer_5);
          }
          lastButtonStateC5 = buttonStateC5;
          }
 
 
         int val5= analogRead(sensorPin5);
 //Cible 6          
                   if(val5 >= threshold) // Cible pin 5
           {buttonStateC6=1;}
           else { buttonStateC6=0;}
        if (buttonStateC6 != lastButtonStateC6) 
          {
       if ( buttonStateC6 == 1) 
          {Serial.println('F');
            analogWrite(led_G6, 255);
            tone(buzzer_6, 2093, 500);
            delay(500);           
            analogWrite(led_G6, 0);
        //    noTone(buzzer_6);
        }
          lastButtonStateC6 = buttonStateC6;
          }
 
          int val6= analogRead(sensorPin6);
 
 
 
 } 
} // fin jeux

C'est pour du tire sur cible airsoft
le mec qui a crée ça ne fait que 6 cible a 15m dans son jardin
moi ce que je veux en faire c'est une centaine de cible sur un parcours commando de 4ha
plusieurs arduino mega relié par lora.
je ne sais pas si cela sera + de 255 et je voudrai que ce soit

Code:

1
2
3
4
5
6
7
8
9
10
11
12
//Cible  336         
         if(received == '336') // Recois F depuis Esclave = Cible 336
           {buttonState336=1;}
           else { buttonState336=0;}
        if (buttonState336 != lastButtonState336) 
          {
       if ( buttonState336 == 1) 
          { lcd.setCursor(3,1);
            lcd.print("Cible 336 HIT" );
            tone(12, 1200, 300);}
          lastButtonStateSelect = buttonStateSelect;
          }

pour que ce soit plus facile à écrire et ne pas me tromper dans le choix du caractère attribuer :D
et le plus rapide pour pas perdre de temps en timeout d'1s.

09/04/2021, 18h33
Jay M

Salut

A mon Avis Il faut repenser le code... mettre des tableaux etc.

Je suppose que un Arduino va surveiller un certain nombre de cibles et dès qu’une cible est touchée un message radio est envoyé vers un central. Est-ce que la latence est un enjeu (Lora ce n’est pas un foudre de guerre mais envoyer quelques octets au lieu d’un seul ça ne va pas changer grand chose)

Quelle topologie réseau Lora ? Vous avez du courant sur place pour alimenter tout cela (rien que pour Lora comptez 100 mA pendant la transmission +20 dBm, ∼30 mA pendant l'écoute radio active)
09/04/2021, 18h47
jemelacool12

la topologie ... un bois pas trop boisé sur 800m max.
je travaille en photovoltaïque donc 12v dc
les cibles seront touché une seul a la fois tout le long du parcours donc y'a pas tant d'information qui passe
si le temps de latence n'est que de milliseconde c'est négligeable. C'est pour le fun , pas une compétition internationnal :mouarf:
réécriture ...:calim2: non ,j'ai deja du mal a tout comprendre :mouarf:
ou il va falloir m'aider :weird:
tableau ?
09/04/2021, 19h06
Jay M

Vous avez testé si votre Lora passe dans 800m boisés?
09/04/2021, 19h21
jemelacool12

oui j'ai tester dans le bois ça passe sans soucis
je l'ai même tester aussi dans les airs 4400m du sol pendant une chute libre , ça passe 8-)
09/04/2021, 20h13
Jay M

Dans les airs c’est plus facile - c’est 800m en environnement boisé qui est plus touchy.

Concrètement vous pouvez décrire le matos que vous avez ?
09/04/2021, 20h36
jemelacool12

Citation:

Envoyé par Jay M

Dans les airs c’est plus facile - c’est 800m en environnement boisé qui est plus touchy.

Concrètement vous pouvez décrire le matos que vous avez ?

Heltec lora v2
https://heltec.org/wp-content/upload...48_800X800.png
https://heltec.org/project/wifi-lora-32/
10/04/2021, 13h48
Jay M

OK pour la partie LORA, vous aviez aussi parlé d'Arduino MEGA? quelle détection sur la cible?
10/04/2021, 16h11
jemelacool12

1 pièce(s) jointe(s)

la détection se fait par un piezo avec un pont de résistance 1m ohm
Pièce jointe 595370

c'est la fiche de montage de base , moi je ne sais pas faire des dessins comme ça ^^
moi, il y aura un arduino mega pour recolter les infos
10/04/2021, 17h36
Jay M

OK pour vous ça ne va pas passer par le port série

- les esclaves seront des Heltec lora v2 donc je suppose.
- l'entrée GPIO2 semble être une entrée analogique
https://resource.heltec.cn/download/...LoRa_32_V2.pdf
==> elle devrait convenir pour vos cibles (vérifier la tension)
- il faut que l'esclave envoie par LORA son message à chaque détection

- le maître Heltec lora v2 écoute les messages et décode l'information et envoie sur son port série de l'information a l'arduino MEGA qui met à jour l'affichage (ou c'est directement sur le maître Heltec que c'est fait)

y'a plus qu'à :)
11/04/2021, 18h34
Jay M
PS/ j'ai regardé les exemples et on peut envoyer un message complexe directement (comprenant plusieurs octets)
Code:

1 2 3 LoRa.beginPacket(); LoRa.print("Cible #12"); LoRa.endPacket();