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

**Jay M** · 21/06/2021, 18h05

Attention à ne pas avoir de commande qui contient la lettre Z

Le code de JP capture bien les données qui arrivent et donc je pense que c’est plutôt le \n qui n’est pas envoyé. Pour le savoir il suffirait d’afficher le code ascii des caractères reçus

**Nounours18200** · 28/06/2021, 19h26

Me voici de retour après quelques jours passés à tester/peaufiner/assembler mes cartes: mon programme et mes cartes électroniques fonctionnent bien, donc je suis en train d'assembler tout ça dans un beau boîtier bien classe.

Attention à ne pas avoir de commande qui contient la lettre Z

Oui évidemment, dans ce cas là ça poserait problème ! mais pour mon usage actuel, ce problème ne se pose pas...

Le code de JP capture bien les données qui arrivent et donc je pense que c’est plutôt le \n qui n’est pas envoyé. Pour le savoir il suffirait d’afficher le code ascii des caractères reçus

C'est aussi ce que je pense...(bien que j'avais détecté un caractère bizarre sur le moniteur série en fin de ligne, dans une ancienne version de mon programme que je n'ai pas gardée).

Effectivement ce serait bien plus rassurant et surtout bien plus "sérieux" comme approche ! et ça permettrait de pérenniser la solution pour des applications futures.

Je ne serai pas contre un coup de main pour afficher ces caractères ASCII : si vous avez du temps pour adapter le code, je suis preneur !!