Optimiser une communication Bluetooth

**Nounours18200** · 19/06/2021, 14h31

Bonjour,

Mon programme tournant sur une MEGA 2560 réceptionne par Bluetooth les ordres venant d'un Smartphone, puis il les traite.

Même si pour l'instant je me contente de retransmettre les ordres reçus sur le moniteur série (j'intègrerai ça dans mon vrai programme plus tard), ça fonctionne parfaitement avec un HC-06.

Le problème est que c'est trop lent: il se passe environ 1 seconde entre l'appui sur le bouton et l'affichage sur le moniteur série.
Je sais que d'autres ont eu le même problème (forums U.S., mais je n'ai pas vraiment compris) mais je cherche juste une solution simple pour accélérer les choses: pas envie de monter une usine à gaz.

Voici mon code:

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
 
 
String Incoming_value; // déclare "Incoming_value" comme une CHAINE qui recevra le nom du bouton du smartphone
                       //on ne l'initialise pas semble-t-il
 
void setup() 
{
  Serial.begin(9600); // on définit la vitesse à 9600  sur le moniteur série ? ou sur la lecture HC06 ?      
//  pinMode(13, OUTPUT); // on connectera la LED de contrôle sur la pin 13 de l'Arduino   
 
}
 
void loop()
{
  if(Serial.available() > 0)  // quand on appuiera sur un bouton du Smartphone, cette valeur deviendra forcément supérieure à 1
                              // et ça voudra dire qu'une valeur reçue est disponible
  {
    Incoming_value = Serial.readString(); // une valeur ayant été reçue, on la transfère dans notre chaine "incoming value"  
                                          // mais pas sûr que ça lise la chaine d'un coup....
    Serial.print("RX recu = ");     // essaie pour faire afficher ça sur le Moniteur serie
    Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série
    Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
 
 
    if (Incoming_value.equals("REWIND")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button1: REWIND");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button1
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }
 
    if (Incoming_value.equals("PLAY")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {     
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button2: PLAY");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button2
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }

J'ai tronqué le code puisque les tests qui suivent sont similaires.

Comment faire pour optimiser la vitesse de traitement ??

Merci !

**Jay M** · 19/06/2021, 19h49

Bonjour

Le problème n’est pas dans le traitement mais dans le timeout de la réception qui par défaut est de 1s.
Cf la doc

Description
Serial.readString() reads characters from the serial buffer into a String. The function terminates if it times out (see setTimeout()).

Il faut éviter ces fonctions fournies par arduino si on est pressé et lire les caractères quand ils arrivent et les stocker dans un buffer ou une String. Il faudra un marqueur de fin de commande, généralement on prend ‘\n’

**Nounours18200** · 20/06/2021, 11h00

si on est pressé et lire les caractères quand ils arrivent et les stocker dans un buffer ou une String

Merci Jay M, je m'en doutais un peu mais as-tu le bout de code à utiliser ? parce que c'est la toute 1ère fois que j'utilise un module Bluetooth !...

Les exemples que j'ai trouvés jusqu'à présent ne m'ont pas paru limpides... Il me semble qu'il faut utiliser Serial.readBytes()

Thanks

**Nounours18200** · 20/06/2021, 12h18

Bon j'ai fait le bout de code qui est super rapide à l'affichage , mais pas tout à fait fonctionnel puisqu'il affiche sur le Moniteur série autant de lignes que le HC06 en reçoit...

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
void setup() 
{
  Serial.begin(9600); // on définit la vitesse à 9600  sur le moniteur série ? ou sur la lecture HC06 ?      
//  pinMode(13, OUTPUT); // on connectera la LED de contrôle sur la pin 13 de l'Arduino   
 
}
 
void loop()
{
  if(Serial.available() > 0)  // quand on appuiera sur un bouton du Smartphone, cette valeur deviendra forcément supérieure à 1
                              // et ça voudra dire qu'une valeur reçue est disponible
  {
 
 
	char Caractere[14]; // taille maximum envoyé par le spartphone correspondant à la chaine "COUNTER RESET" de 13 caractères
	byte i;
	while(Serial.available()) Caractere[i++] = Serial.read();
 
    Serial.print("RX recu = ");     // essaie pour faire afficher ça sur le Moniteur serie
 
    // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série Mis en commentaire par rapport au pgm précédent
	Serial.print(Caractere);  // devrait envoyer la chaine reçue sur le Moniteur série
    Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
 
    // Comment vider la chaine Caractere pour la préparer à la prochaine réception ???
 
    /* if (Incoming_value.equals("STOP")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button1: STOP");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button1
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }
    // on fera l'action appropriée dans une version ultérieure, si la lecture du buffer fonctionne   
	*/         
  }
 
 
}

Par exemple, si le HC06 reçoit la chaine "STOP", le Moniteur série va afficher:

RX recu = S*
RX recu = ST*
RX recu = STO*
RX recu = STOP

Vous avez une idée de comment je pourrais détecter la fin de transmission de façon à ce que la chaîne "Caractere" soit complète et que je puisse ensuite la tester ??? Je suppose qu'il faut que j'essaie de détecter le caractère "\0"...

Et si l'affichage se fait pour chaque caractère,c'est peut-être parce que le proc est plus rapide à faire le While que ce que les caractères arrivent dans le buffer ?

**jpbbricole** · 20/06/2021, 16h01

Bonjour Nounours18200

Envoyé par Nounours18200

Vous avez une idée de comment je pourrais détecter la fin de transmission de façon à ce que la chaîne "Caractere" soit complète et que je puisse ensuite la tester ??? Je suppose qu'il faut que j'essaie de détecter le caractère "\0"...

Tu as tout ici, c'est ce que j'emploie dans mes liaisons Bluetooth, à toi d'adapter en fonction de ton caractère de fin de commande.
Pendant l'acquisition d'une chaîne sur le canal Bluetooth, le reste du programme n'est pas entravé.

J'ai adapté mon programme à ton Mega:

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
#define btSerial Serial1
 
//------------------------------------- Liaison Bluetooth
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande
 
//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande
 
void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
}
 
void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("\nRecption Bluetooth ")); Serial.println(btTexte);
		cmdExecute(btTexte);
 
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		Serial.print(F("Recption Console ")); Serial.println(btTexte);
		cmdExecute(cmdTexte);
 
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
}
 
/*---------------------------------------------------------------------------
	Execution de la ligne de commande
'*----------------------------------------------------------------------------
*/
void cmdExecute(String cmdRx)
{
	Serial.print(F("Traitement de la commande ")); Serial.println(cmdRx);
}
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
}
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}

Si btCmdRecue est true, btTexte contient la commande reçue.
Tu peux recevoir des commandes depuis Blurtooth (Serial1) et depuis la console (Serial)

Je n'ai pas testé, je le ferais ce soir, mais en principe, pas de problème.

EDIT: C'est testé, liaison BT à 9600 BT Tx sur 19 Rx1 et BT Rx sur 18 Tx1, c'est OK

Cordialement
jpbbricole

**Jay M** · 20/06/2021, 17h21

Il manque le break

Code :

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

1
2
3
4
5
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
                        break; // on a reçu la commande on arrête de lire le port série et on la traite
		}

**Nounours18200** · 20/06/2021, 18h00

@jpbbricole:
là tu m'en bouches un coin !!
faut que j'arrive à comprendre comment ça marche, je ne connaissais pas la commande "btSerialEvent"...

C'est plus sophistiqué que ce dont j'ai besoin (pour l'instant) puisque tu dis que le programme principal n'est pas stoppé, et dans mon cas je me contente de déclencher des actions en fonction de la commande reçue

Pour l'instant il ne m'affiche rien sur le moniteur quand j'envoie une commande sur le Bluetooth...

Faut que j'arrive à le faire apparaître sur le Moniteur série: ensuite seulement je pourrai déclencher les actions à faire selon la commande reçue.

Ne rigoles pas trop fort: je fais des choses assez sympa en Arduino, mais concernant le Bluetooth, je suis une buse absolue ! jamais touché avant aujourd'hui...

@Jay M:

Il manque le break

et tu le mets où le break ? s'il manque réellement, or ça me fait l'air correct

....

**Nounours18200** · 20/06/2021, 18h26

Bon je suis surement une buse, mais chez moi ça ne marche pas, au sens où lorsque j'essaie d'afficher la commande reçue sur le moniteur série, celui affiche des lignes sans s'arrêter même lorsque mon application n'envoie aucun caractère .

Voici le petit ajout que j'ai fait dans la section Bluetooth pour faire afficher la valeur de "btTexte" sur le moniteur série: puisque c'est à partir de la valeur reçue que je déciderai des action à faire dans la suite de mon programme:

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
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
	Serial.print("RX recu = ");     // essaie pour faire afficher ça sur le Moniteur serie
	Serial.print(btTexte);  // devrait envoyer la chaine reçue sur le Moniteur série
	Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
}

Si je la mets plus haut dans le code juste après la 1ère partie du IF comme ci-dessous, alors là rien ne s'imprime du tout dans le Moniteur série...

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
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
			Serial.print("RX recu = ");     // essaie pour faire afficher ça sur le Moniteur serie
	        Serial.print(btTexte);  // devrait envoyer la chaine reçue sur le Moniteur série
	        Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
 
	}
 
}

Je galère depuis 3 jours, je dois vraiment me faire vieux ou j'ai les yeux qui voient double à force de m'énerver sur ce bout de code !

A quel endroit puis-je récupérer la commande complète???

**jpbbricole** · 20/06/2021, 18h40

Bonsoir Nounours18200

Envoyé par Nounours18200

celui affiche des lignes sans s'arrêter même lorsque mon application n'envoie aucun caractère .

Oui, c'est normal, tu ne doit pas ajouter ça ici, btSerialEvent() est appelé en permanence dans loop.
Dans l'exemple que je t'ai donné, l'affichage des données reçues depuis BT et la console, s'affichent déjà.
Essaies d'utiliser l'exemple "tel quel" et, ensuite, adaptes-le à tes désirs.
Si tu le désires, je peut te guider sur le comment traiter les commandes reçues.

EDIT:
PS: Postes tout ton code pour que je puisse voire comment insérer au mieux btSerialEvent()
A+
Cordialement
jpbbricole

**Nounours18200** · 20/06/2021, 18h59

Une nouvelle fois, mille mercis, je sature avec ce pb...

Voici le code dans sa totalité:

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
 
#define btSerial Serial1
 
//------------------------------------- Liaison Bluetooth
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande
 
//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande
 
void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
}
 
void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("\nRecption Bluetooth ")); Serial.println(btTexte);
		cmdExecute(btTexte);
 
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		Serial.print(F("Recption Console ")); Serial.println(btTexte);
		cmdExecute(cmdTexte);
 
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
}
 
/*---------------------------------------------------------------------------
	Execution de la ligne de commande
'*----------------------------------------------------------------------------
*/
void cmdExecute(String cmdRx)
{
	Serial.print(F("Traitement de la commande ")); Serial.println(cmdRx);
}
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
 
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
 
	}
 
}
 
 
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}
 
    /* if (Incoming_value.equals("REWIND")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button1: REWIND");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button1
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }
    // on fera l'action appropriée dans une version ultérieure, si la lecture du buffer fonctionne   
	*/

Oui, c'est normal, tu ne doit pas ajouter ça ici, btSerialEvent() est appelé en permanence dans loop.
Dans l'exemple que je t'ai donné, l'affichage des données reçues depuis BT et la console, s'affichent déjà.

Ben non: chez moi rien ne s'affiche sur le Moniteur série lorsque j'envoie des commandes Bluetooth. Et je sais que mon smartphone envoie bien des commandes puisque qu'avec un autre code j'arrive à le voir, alors que là rien ne s'affiche chez moi...

Si tu le désires, je peut te guider sur le comment traiter les commandes reçues.

En fait ce dont j'ai besoin c'est de pouvoir récupérer dans une chaîne de caractères, chez toi ça me semble être "btCmdRecue", la commande reçue complète. Par exemple si mon Smartphone envoie "STOP", où puis-je récupérer ce "STOP" ?

Ensuite je ferai des "if" en cascade sur cette chaîne représentant la commande reçue, et pour chaque valeur de la chaine de caractère je déclencherai les actions voulues. Je le fais déjà depuis des lustres avec les codes reçus d'une télécommande infra-rouge.

Mais tant que je ne récupère pas la commande reçue par Bluetooth en un seul morceau, je ne peux rien faire...

Encore merci pour ton aide (là ma tête est en train de fumer...)

**Jay M** · 20/06/2021, 19h32

Pour le break c’est ici:

Code :

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

1
2
3
4
5
6
 
if (monChar == '\n') // If new line char received = end of command line
{
btCmdRecue = true;
break; // on a reçu la commande on arrête de lire le port série et on la traite
}

(Mais vous ne verrez pas le bug si les commandes arrivent lentement, c’est pour cela que ça suffit à JP).

Sinon vous êtes sûr de bien envoyer le \n comme marqueur de fin ?

**jpbbricole** · 20/06/2021, 20h05

Bonsoir Nounours18200

Petite question subsidiaire, to smartphone est-il sous Android?

A+
Cordialement
jpbbricole

**jpbbricole** · 20/06/2021, 20h53

Bonsoir Nounours18200

Super, la Suisse a gagné!

Voilà ma "prose", j'ai fait un "traitement" des commandes, le programme reconnaît les ordres Rewind, FORWARD et backward. Les noms de commandes ne sont pas sensibles à la casse.
Charges ce programme

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
 
#define btSerial Serial1
 
//------------------------------------- Liaison Bluetooth
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande
 
//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande
 
void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
}
 
void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("\nRecption Bluetooth ")); Serial.println(btTexte);
		cmdExecute(btTexte);
 
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		Serial.print(F("\nRecption Console ")); Serial.println(btTexte);
		cmdExecute(cmdTexte);
 
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
}
 
/*---------------------------------------------------------------------------
	Execution de la ligne de commande
'*----------------------------------------------------------------------------
*/
void cmdExecute(String cmdRx)
{
	boolean cmdConnue = true;
 
	cmdRx.replace(" ", "");     // Supprimer les espaces inutiles
	cmdRx.toUpperCase();     // Tout en majuscules
 
	if (cmdRx == "REWIND")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else if (cmdRx == "BACKWARD")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else if (cmdRx == "FORWARD")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else
	{
		cmdConnue = false;     // Commande inconnue
	}
 
	if (cmdConnue == false)
	{
		Serial.print(F("Commande >> ")); Serial.print(cmdRx); Serial.println(F(" << INCONNUE!!"));
	}
}
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
//		Serial.println(monChar);
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
 
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
}
 
 
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}
 
    /* if (Incoming_value.equals("REWIND")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button1: REWIND");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button1
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }
    // on fera l'action appropriée dans une version ultérieure, si la lecture du buffer fonctionne   
	*/

et avant d'essayer avec BT, essaies ces commandes depuis le moniteur de l'IDE Arduino avec ces paramètres.
Nouvelle ligne 115200 baud

Si ça fonctionne, essaies ces ordres depuis BT. Si ça ne fonctionne pas, ôtes la remarque à cette ligne dans btSerialEvent()

Code :

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

1
2
 
//		Serial.println(monChar);

et recharges le programme, envoies une commande depuis BT, tu devrait avoir la commande qui s'affiche en colonne dans le moniteur.
R
E
W
I
N
D

Si tu vois ça et que la commande ne s'exécute pas, c'est un problème de terminaison.
Si tu est sous Android, je te proposerai d'essayer un programme terminal BT.

A+
Cordialement
jpbbricole

**Nounours18200** · 20/06/2021, 21h10

Pour le break c’est ici:

@Jay M: OK, mais comme pour jpbbricole, les commandes ne doivent théoriquement pas arriver trop vite; je vais le rajouter quand même par précaution

Petite question subsidiaire, to smartphone est-il sous Android?

@jpbbricole:

oui, c'est un Samsung S8, et ça ne vient pas du téléphone puisqu'avec un autre code je reçois bien les commandes par Bluetooth.
Mais si je tape "STOP", je reçois "S" puis"ST" puis "STO", puis "STOP"; ...

Sinon vous êtes sûr de bien envoyer le \n comme marqueur de fin ?

ça c'est moins simple à voir, mais je pense que oui: côté Smartphone l'appli a été faite avec AppInventor, et AppInventor renvoie une chaîne de caractères.

Super, la Suisse a gagné!

zut j'ai raté le match...

Charges ce programme et avant d'essayer avec BT, essaies ces commandes depuis le moniteur de l'IDE Arduino avec ces paramètres.
Nouvelle ligne 115200 baud

Je ne comprends pas bien: il n'y a que 2 lignes dans ton code ??

Si tu est sous Android, je te proposerai d'essayer un programme terminal BT.

ça ça ne correspond pas du tout au besoin, car l'objet est de lire les commandes envoyées par appui sur un bouton d'une application, pas du tout depuis un terminal BT.

Il m'est venu une idée pour aider à résoudre le doute sur le caractère de fin de ligne: je peux m'arranger pour que la longueur de la chaîne émise par les boutons soit toujours la même, par exemple 13 caractères.

----> Est-ce que ça simplifierait la reconnaissance ?

(parce que la lecture caractère par caractère ne me paraît pas évidente à maîtriser).

Une autre piste serait de revenir à la lecture d'une chaîne entière tel qu'expliqué au tout début du sujet: le seul problème était la lenteur dont on m'a dit qu'elle était due à un délai d'une seconde par défaut: si on pouvait réduire ce délai, la solution serait trouvée...
----> Est-ce possible ou pas ?

Je dois m'arrêter là pour ce soir car ma fille vient d'arriver et je dois m'en occuper, mais je lirai vos réponses dès demain,

Bonne soirée et encore merci pour votre aide,

**jpbbricole** · 20/06/2021, 21h28

Bonsoir Nounours18200

Envoyé par Nounours18200

oui, c'est un Samsung S8, et ça ne vient pas du téléphone puisqu'avec un autre code je reçois bien les commandes par Bluetooth.
Mais si je tape "STOP", je reçois "S" puis"ST" puis "STO", puis "STOP"; ...

Demain je te fais un tuto pour utiliser un autre programme, provisoirement.

Envoyé par Nounours18200

Je ne comprends pas bien: il n'y a que 2 lignes dans ton code ??

C'est corrigé, l'émotion de la victoire

Envoyé par Nounours18200

Il m'est venu une idée pour aider à résoudre le doute sur le caractère de fin de ligne: je peux m'arranger pour que la longueur de la chaîne émise par les boutons soit toujours la même, par exemple 13 caractères.

Ca compliquerai les choses

Bonne soirée
Cordialement
jpbbricole

**Jay M** · 20/06/2021, 21h50

Envoyé par Nounours18200

Mais si je tape "STOP", je reçois "S" puis"ST" puis "STO", puis "STOP"; ...

Oui ce que vous voyez ce sont les caractères qui arrivent un à un. Le mot est en train de se former. Le code attend une marque de fin de commande, ici le \n qui n’est pas forcément émis - faudrait voir le code appInventor

**Nounours18200** · 21/06/2021, 10h18

C'est corrigé, l'émotion de la victoire

ben je ne vois toujours que 2 lignes ... J'ai l'impression d'être un peu perdu là...

Demain je te fais un tuto pour utiliser un autre programme, provisoirement.

ça ce serait le top, là je pédale dans la semoule comme on dit !

Je vais tenter un truc en attendant, mais j'ai plus confiance en toi qu'en moi sur ce coup là...

Le code attend une marque de fin de commande, ici le \n qui n’est pas forcément émis - faudrait voir le code appInventor

AppInventor me génère un .APK: je n'ai pas vu le code proprement dit, et je ne crois pas que l'on puisse le voir.
Mais ce qui me fait dire que les chaînes sont correctement émises c'est qu'avec mon 1er programme qui lit les chaines depuis Bluetooth (celui qui est lent et à l'origine de ce sujet), les chaînes sont parfaitement reçues: certes c'est trop lent, mais ça fonctionne parfaitement.
S'il manquait le caractère "\n", elles ne seraient pas correctement reçues non ?...

**Nounours18200** · 21/06/2021, 10h59

Bon, je crois que je progresse un peu !

J'ai essayé un code donné par quelqu'un qui essaie de faire à peu près la même chose que moi.
Voici le code:

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
 
#include <SoftwareSerial.h>
 
SoftwareSerial HC06(18, 19);
int r_en = 2;
int l_en = 4;
int rr_en = 8;
int ll_en = 10;
int pwmr = 3;
int pwml = 5;
int pwmrr = 11;
int pwmll = 9;
String messageRecu;
 
void setup() {
  HC06.begin(9600); 
  Serial.begin(9600);
  pinMode(r_en, OUTPUT);
  pinMode(l_en, OUTPUT);
  pinMode(pwmr, OUTPUT);
  pinMode(pwml, OUTPUT);
  pinMode(rr_en, OUTPUT);
  pinMode(ll_en, OUTPUT);
  pinMode(pwmrr, OUTPUT);
  pinMode(pwmll, OUTPUT);
  digitalWrite(r_en, HIGH);
  digitalWrite(l_en, HIGH);
  digitalWrite(rr_en, HIGH);
  digitalWrite(ll_en, HIGH);
 
}
 
void loop()
{
   while(HC06.available())
    {
      delay(3);
      char c = HC06.read();
      messageRecu += c;
    }
    if (messageRecu.length() >0)
    {
      Serial.println(messageRecu);
    /*  if (messageRecu == "1")
      {
        avancer();
      }
      if (messageRecu == "2")
      {
        reculer();
      }    
      if (messageRecu == "3")
      {
        gauche();
      }    
      if (messageRecu == "4")
      {
        droite();
      }         
    
      messageRecu="";
      stop();*/
    }
  }

Les variables d'en-tête ne nous intéressent pas, c'est juste le principe de fonctionnement.
J'ai modifié légèrement le code pour ne pas avoir à définir des Niméros de pins pour RX et TX, puisque le HC06 est directement connecté au pins RX et TX de la MEGA.

Le code devient donc:

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
 
// Code trouvé sur: https://openclassrooms.com/forum/sujet/arduino-mega-et-hc06
/* Nom du programme: D:\ELECTRONIQUE\ARDUINO\ARDUINO-BLUETOOTH\Arduino avec APPINVENTOR\HC-05 Bluetooth avec MEGA\MEBT_openclassroom_100\MEBT_openclassroom_100.ino
 
*/
 
 
#include <SoftwareSerial.h>
 
// SoftwareSerial HC06(18, 19); mis en commentaire pour utiliser les pins RX et TX classiques de la MEGA 2562
int r_en = 2;
int l_en = 4;
int rr_en = 8;
int ll_en = 10;
int pwmr = 3;
int pwml = 5;
int pwmrr = 11;
int pwmll = 9;
String messageRecu;
 
void setup() {
  // HC06.begin(9600); mis en commentaire puisqu'on ne définit plus SoftwareSerial HC06
  Serial.begin(9600);
  pinMode(r_en, OUTPUT);
  pinMode(l_en, OUTPUT);
  pinMode(pwmr, OUTPUT);
  pinMode(pwml, OUTPUT);
  pinMode(rr_en, OUTPUT);
  pinMode(ll_en, OUTPUT);
  pinMode(pwmrr, OUTPUT);
  pinMode(pwmll, OUTPUT);
  digitalWrite(r_en, HIGH);
  digitalWrite(l_en, HIGH);
  digitalWrite(rr_en, HIGH);
  digitalWrite(ll_en, HIGH);
 
}
 
void loop()
{
   // while(HC06.available())
	  while(Serial.available()) 
    {
      delay(3);
      char c = Serial.read();
      messageRecu += c;
    }
    if (messageRecu.length() >0)
    {
      Serial.println(messageRecu);
    /*  if (messageRecu == "1")
      {
        avancer();
      }
      if (messageRecu == "2")
      {
        reculer();
      }    
      if (messageRecu == "3")
      {
        gauche();
      }    
      if (messageRecu == "4")
      {
        droite();
      }         
    
      messageRecu="";
      stop();*/
    }
  }

Lorsque j'utilise mon appli AppInventor, la Mega reçoit bien les chaines de caractères, mais ne s'arrête jamais d'imprimer sur le moniteur série (ce qui me paraît normal puisque l'impression sur le Moniteur se trouve en dehors du While, mais forcément dans la void loop du programme).

Il suffirait donc d'adapter ce code pour qu'il lise 1 seule commande à la fois puis sorte de la boucle While.

Je vois 2 façons de faire:

Modifier mon appli Smartphone pour que chaque chaîne de caractère se termine par un caractère spécial, par exemple "Z", et si on détecte "Z" on sort du While par un Break: c'est possible ça d'après vous ?
Modifier mon appli Smartphone pour que toutes les chaînes de caractères aient la même longueur (disons 14 caractères), et quand on a lu le 14ème caractère on sort de la boucle While par un Break

Dans les 2 cas le buffer devrait être vidé, donc la condition de déclenchement du While devrait être fausse si aucune autre commande n'a été émise.

Pour que l'impression ne se fasse qu'une seule fois sur le Moniteur Série, il me semble qu'il faut rapatrier tout le reste du code, y compris les actions (qui sont provisoirement mises en commentaire), à l'intérieur de la boucle While.

Ce n'est surement pas aussi élégant que le code de jpbbricole, mais ça devrait marcher...

Qu'en pensez-vous ?

**jpbbricole** · 21/06/2021, 11h32

Envoyé par Nounours18200

ben je ne vois toujours que 2 lignes

Non, non, c'est bien corrigé!
Je te le remets ici:

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
 
#define btSerial Serial1
 
//------------------------------------- Liaison Bluetooth
bool btCmdRecue = false;         // Si une nouvelle commande a été reçue
String btTexte = "";             // Texte de la commande
 
//------------------------------------- Ligne de commandes
bool cmdNouvelleRecue = false;      // Si une nouvelle commande a été reçue
String cmdTexte = "";               // Texte de la commande
 
void setup() 
{
	Serial.begin(115200);
	btSerial.begin(9600);
}
 
void loop()  
{
	//--------------------------------- Ecoute du port BT
	btSerialEvent();    
	if (btCmdRecue)      // Si une nouvelle commande depuis BT
	{
		Serial.print(F("\nRecption Bluetooth ")); Serial.println(btTexte);
		cmdExecute(btTexte);
 
		btTexte = "";
		btCmdRecue = false;
	}
	//--------------------------------- Ecoute du port serie
	//serialEvent();           // Enlever le commentaire si l'appel ne se fait pas automatiquement
	if (cmdNouvelleRecue)      // Si une nouvelle commande depuis le moniteur
	{
		Serial.print(F("\nRecption Console ")); Serial.println(btTexte);
		cmdExecute(cmdTexte);
 
		cmdTexte = "";
		cmdNouvelleRecue = false;
	}
}
 
/*---------------------------------------------------------------------------
	Execution de la ligne de commande
'*----------------------------------------------------------------------------
*/
void cmdExecute(String cmdRx)
{
	boolean cmdConnue = true;
 
	cmdRx.replace(" ", "");     // Supprimer les espaces inutiles
	cmdRx.toUpperCase();     // Tout en majuscules
 
	if (cmdRx == "REWIND")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else if (cmdRx == "BACKWARD")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else if (cmdRx == "FORWARD")
	{
		Serial.print(cmdRx); Serial.println(F("\ts'execute"));
	}
	else
	{
		cmdConnue = false;     // Commande inconnue
	}
 
	if (cmdConnue == false)
	{
		Serial.print(F("Commande >> ")); Serial.print(cmdRx); Serial.println(F(" << INCONNUE!!"));
	}
}
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis Bluetooth
'*------------------------------------------------------------------------
*/
void btSerialEvent()                                       
{
	while (btSerial.available())
	{
		char monChar = (char)btSerial.read();     // Char received from IDE monitor
//		Serial.println(monChar);
		if (monChar == '\n')                      // If new line char received = end of command line
		{
			btCmdRecue  = true;
 
		}
		else
		{
			if (monChar >= ' ') {btTexte += monChar;}     // >= ' ' to avoid not wanted ctrl char.
		}
	}
}
 
 
 
/*-----------------------------------------------------------------------
	Réception de commandes depuis le moniteur
'*------------------------------------------------------------------------
*/
void serialEvent()                                       
{
	while (Serial.available())
	{
		char monChar = (char)Serial.read();     // Char received from IDE monitor
		if (monChar == '\n')                    // If new line char received = end of command line
		{
			cmdNouvelleRecue  = true;
		}
		else
		{
			if (monChar >= ' ') {cmdTexte += monChar;}     // >= ' ' to avoid unwanted ctrl char.
		}
	}
}
 
    /* if (Incoming_value.equals("REWIND")) // pour comparer une chaine decaractères dans un IF, le + simple est d'utiliser la fonction".equals" comme indiquée
       {
           // Serial.print(Incoming_value); // Envoie la valeur de Incoming_value reçue sur le Moniteur série  
           Serial.print("Appui sur Button1: REWIND");      // on envoie sur le Moniteur Série qu'on a détecté l'appui sur Button1
           Serial.print("\n");             // on fait un retour à la ligne pour que la prochaine valeur s'affiche sur la ligne d'après
       }
    // on fera l'action appropriée dans une version ultérieure, si la lecture du buffer fonctionne   
	*/

Pour le tuto, je viens de faire ça ici, sauf que BT Tx sur 19 Rx1 et BT Rx sur 18 Tx1

Dans les boutons M1, M2, M3 tu mets, respectivement:
M1 = Name Rew Value REWIND
M2 = Name Back Value BACKWARD
M3 = Name Forw Value FORWARD

Tu devrait avoir ça
Rew Back Forw M4 M5 M6...

Cette méthode utilise la terminaison \n

Cordialement
jpbbricole

**Nounours18200** · 21/06/2021, 14h38

Salut jpbbricole,

Bonne nouvelle: je suis arrivé à m'en sortir en corrigeant le code dont je t'ai parlé, et en utilisant 'Z' comme caractère me permettant de détecter une fin de chaine --> j'ai donc rajouté 'Z' à la fin de chaque chaine envoyée par mon smartphone.
Voici mon code modifié:

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
 
#include <SoftwareSerial.h>
 
// SoftwareSerial HC06(18, 19); mis en commentaire pour utiliser les pins RX et TX classiques de la MEGA 2562
int r_en = 2;
int l_en = 4;
int rr_en = 8;
int ll_en = 10;
int pwmr = 3;
int pwml = 5;
int pwmrr = 11;
int pwmll = 9;
String messageRecu;
 
void setup() {
  // HC06.begin(9600); mis en commentaire puisqu'on ne définit plus SoftwareSerial HC06
  Serial.begin(9600);
  pinMode(r_en, OUTPUT);
  pinMode(l_en, OUTPUT);
  pinMode(pwmr, OUTPUT);
  pinMode(pwml, OUTPUT);
  pinMode(rr_en, OUTPUT);
  pinMode(ll_en, OUTPUT);
  pinMode(pwmrr, OUTPUT);
  pinMode(pwmll, OUTPUT);
  digitalWrite(r_en, HIGH);
  digitalWrite(l_en, HIGH);
  digitalWrite(rr_en, HIGH);
  digitalWrite(ll_en, HIGH);
 
}
 
void loop()
{
   // while(HC06.available())
	  while(Serial.available()) 
    {
      delay(3);
      char c = Serial.read();
      messageRecu += c;
	  if(c == 'Z') 
	  {
		  Serial.println(messageRecu);
		  break;
	  }
    }
    /*
	if (messageRecu.length() >0)
    {
      Serial.println(messageRecu);
	*/
 
    /*  if (messageRecu == "1")
      {
        avancer();
      }
      if (messageRecu == "2")
      {
        reculer();
      }    
      if (messageRecu == "3")
      {
        gauche();
      }    
      if (messageRecu == "4")
      {
        droite();
      }         
    */
      messageRecu="";
     // stop(); je ne comprends pas à quoi sert ce stop()
 
  }

Ce n'est pas très élégant nous sommes d'accord (!); mais ça fonctionne nickel !, et je peux enfin continuer à écrire mon programme...

Mais il est évident que ton approche est bien meilleure (détection de '\n') sauf que mes précédents essais n'ont pas fonctionné. Ca pourrait être dû au fait que l'appli smartphone n'envoie pas '\n' à la fin des chaînes, mais je n'y crois pas trop...

Je vais donc provisoirement marquer ce sujet en "résolu", et si tu le veux bien, je te recontacterai pour quelques précisions sur ton approche quand j'aurai avancé et porté mon programme sur les Mega Pro mini (CH340G) que j'utilise pour mes projets "finis" sur circuit imprimé.

Une nouvelle fois merci à toi: tu es vraiment au top en Arduino...

A bientôt,
Michel

Optimiser une communication Bluetooth

Arduino

Discussions similaires

Partager

Partager