Discussion :

[Jsiorat]

Bonsoir à tous!

Je regarde ça demain.
Si j'ai compris le problème, avec les ordres depuis le moniteur ça joue, hormis LPWM=255, mais quand on presse plusieurs bp à la fois, toutes les LED ne s'éteignent pas?

Bonne soirée
Cordialement
jpbbricole

Bonne soirée à toi !
J'ai inclus le bout de code de Jay M, c’était pas compliqué !

Jacques

[Jay M]

Bonne soirée à toi !
J'ai inclus le bout de code de Jay M, c’était pas compliqué !

C’est le code de JP !!

[jpbbricole]

Bonjour

C’est le code de JP !!

Waouw! un moment j'ai cru que Jay s'était mis à coder comme moi! mdr
Jacques, excellent lapsus!

Quels sont les problèmes en suspens?

Bonne journée
Cordialement
jpbbricole

[Jay M]

j'expliquais juste ce qu'il se passait quand vous rentrez LPWM=255 dans le moniteur série.
Ce n'est pas cela qui éteint toutes les LEDs

j'ai cru que Jay s'était mis à coder comme moi! mdr

tant qu'il y aura des manipulations de String partout, ça peut pas être moi

[Jsiorat]

Waouw! un moment j'ai cru que Jay s'était mis à coder comme moi! mdr
Jacques, excellent lapsus!

Quels sont les problèmes en suspens?

Bonjour JP
Je rends publiquement à César ce qui appartient à Cézar ! Milles pardons d'avoir mélangé deux cerveaux !

Le seul et unique soucis :
lorsque on appuis sur l'un des boutons, les LEDs afférentes à ce boutons s'allument en complément de celles déjà allumées.
Je pense qu'il faudrait inclure après l'appui sur le bp, mais avant que le code fasse son travail de reconnaissance des aiguillages à manoeuvrer et des LEDs à allumer,
une commande qui éteint TOUTES les LEDs du TCO ! Ne s'afficheront ensuite que les LEDs affiliées au bp activé.
Je pense aussi qu'il est inutile de contrôler la concordance moteur D ou G avec les LEDs, parce qu'un aiguillage, si il est déjà en position désiré sera ignoré.

Mon TCO est déjà créer avec bp, LEDs vert 3mm, résistance 220 ohms. y a plus qu'a brancher le Mega 2560 et alimenter en 7/12 V.

Avec un tel programme, je reste maître de mon train pour aller en gare.

Il pleut aujourd'hui sur Pamiers, donc j'annule le jardin mais je garde la compagne et le train !

Cordialement, Jacques

[Jsiorat]

C’est le code de JP !!

Bonjour Jay,

Pardon de ne pas avoir reconnu (!) le code de JP

Le résultat reste le même, j'ai inclus ce code là ou il doit être §

Bonne journée et vos avis sont super intéressant à lire, comprendre et mettre en oeuvre.

Cordialement, Jacques

[jpbbricole]

Bonjour Jacques

une commande qui éteint TOUTES les LEDs du TCO ! Ne s'afficheront ensuite que les LEDs affiliées au bp activé.
Je pense aussi qu'il est inutile de contrôler la concordance moteur D ou G avec les LEDs, parce qu'un aiguillage, si il est déjà en position désiré sera ignoré.

Est-ce-que, après une opération le TCO doit s'éteindre au bout d'un certain temps ou seul la dernière opération doit restée affichée?

A signaler que toute modification sera effectuèe à partir de la version du post #111
Si tu as fais des modifications à y apporter il faut me les signaler, passes moi ntes tables aiguilles[] = et bpAig[] =.

A+
Cordialement
jpbbricole

[Jsiorat]

Est-ce-que, après une opération le TCO doit s'éteindre au bout d'un certain temps ou seul la dernière opération doit restée affichée?

jpbbricole

Seule la dernière opération doit restée affiché sur le RCO !

Si tu as fais des modifications à y apporter il faut me les signaler, passes moi ntes tables aiguilles[] = et bpAig[] =.

voila pour la reconnaissance A0 à A15 :

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
if (cmdExec.startsWith("LPWM="))
	{
		int ledIndex;
		cmdExec.replace("LPWM=", "");
 
		if (cmdExec.startsWith("A"))             // Si c'est un port analogique (A0, A1 ...
		{
			cmdExec.replace("A", "");            // Enlever le A
			ledIndex = cmdExec.toInt() + A0;     // Ajouter la valeur de A0 (14 pour le UNO et 54 pour le Mega)
		}
		else
		{
			ledIndex = cmdExec.toInt();
		}
 
		lpwmLedSet(ledIndex, lpwmOn);
		delay(2000);
		lpwmLedSet(ledIndex, !lpwmOn);
 
		cmdExecOk = true;
	}

Maintenant pour l'aiguillage G1, remplacement de 255 (Moteur G) par 21, et 255 (Led G) par 40 ;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
aiguilleDefinition aiguilles[] =
{
	// Position donne la position de l'aiguille au demarrage du programme
	//Nom,   Position, Moteur G, Moteur D, Led G, LED D   255 = port inutilise
	{"G1", aigPosDroite,  21,       22,       40,   41},
	{"A1", aigPosGauche,  23,       24,       42,   43},
	{"A2", aigPosDroite,  25,       26,       44,   45},
	{"A3", aigPosGauche,  27,       28,       46,   47},
	{"A4", aigPosDroite,  29,       30,       48,   49},
	{"B1", aigPosDroite,  31,       32,       50,   51},
	{"B2", aigPosDroite,  33,       34,       52,   53},
	{"B3", aigPosDroite,  35,       36,       A8,   A9},
	{"B4", aigPosDroite,  37,       38,       A10,  A11}
};

C'est tout, en te remerciant encore !

Je réfléchis doucement à faire une interface soit en Access soit avec Visual Studio. J'ai de petites idées qui trottinent ...
A + JP,
Jacques

[jpbbricole]

Bonjour Jacques

Seule la dernière opération doit restée affiché sur le RCO !

OK, dans le courant de la semaine.

voila pour la reconnaissance A0 à A15 :

Cest déjà reporté dans le post #111

Maintenant pour l'aiguillage G1, remplacement de 255 (Moteur G) par 21, et 255 (Led G) par 40 ;

Je vais modifier le programme, surtout sa structure, en séparant les configurations des bp et des aiguilles, du corps principal, en 2 fichiers séparés qui seront ajouté au programme par des #include, ainsi tu pourras les modifier à ta guise, mais pas la structure, bien sur!

Je réfléchis doucement à faire une interface soit en Access soit avec Visual Studio. J'ai de petites idées qui trottinent ...

Une fois de plus, tu vas m'allumer, je suis fan de ce genre d'utilisation! Si tu le veux, je peux te passer un exemple de feuille Excel que j'utilise pour ce faire, elle permet de dialoguer dans les 2 sens (Tx et Rx). Tu peux regarder sur Youtube quelques trucs que j'ai fait avec cette feuille Excel, c'est tout en bas de l'écran.

A+
Cordialement
jpbbricole

[Jsiorat]

A titre perso, le programme tel qu'il actuellement me satisfait pleinement !
Pour le fun, ce même programme en deux parties sera pour "mon éducation !" qui est prioritaire (à l'exception du jardin, de la compagne !)

Quant à la feuille excel, je ne voudrais pas mélanger les choses. Un peut plus tard si tu veux bien !
A+, Jacques

[Jsiorat]

Pour éteindre les LEDs après l'appui sur un BP, est-ce que cette fonction ( dans les lignes 280/290) peut servir ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
============================
void aigLedPwmSet(int ledIndex, bool ledEtat)
{
  boolean lpwmEtat = lpwmValeurOff;
  if (ledEtat > 0)
  {
    lpwmEtat = lpwmValeurOn;
  }
  lpwmLedSet(ledIndex, ledEtat);
}
============================

... en incluant un

Code :

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

1
2
3
4
else
{
  lpwmEtat = 0 ;
}

ou :

Code :

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

1
2
3
4
else
{
  lpwmLedSet(ledIndex, ledEtat = 0);
}

Cordialement, Jacques

[jpbbricole]

Bonsoir Jacques

J'ai ajouté l'extinction des led avant l'action provoquée par la pression d'un nouveau bp, mais pas lors d'une commande AIG=, si tu veux aussi, tu sait où t'adresser .
J'ai passablement remanié les commandes moniteur, ajouté une commande pour éteindre toutes les LEDpwm des aiguilles.

Pour lister les commandes ? dans le moniteur

Code :

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

1
2
3
4
5
6
	> > > Liste des commandes < < <
?
BP=
AIG=
LPWM=
LPWMALLOFF=

Le GROS changement, est la séparation des définitions des bp et des aiguilles du corps principal du programme. Il en résulte 2 nouveaux fichiers
Train_TableauBoutonsPoussoir.h
Train_TableauAiguillages.h
qui doivent se trouver dans le même répertoire que le fichier principal ARDDEV_AiguillagesBledMonitSoftPwm.ino

Il sont inclus dans le programme par les instructions:

Code :

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

1
2
	#include "Train_TableauAiguillages.h"
	#include #include "Train_TableauBoutonsPoussoir.h"

Le nouveau programme ARDDEV_AiguillagesBledMonitSoftPwm.ino:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
/******************************************************************************
    Name:       Commande d'aiguillages et de leurs LED
    Created:    04.10.2020
    Author:     jpbbricole
        
        Remarques:      Version avec LED SoftPWM et commandes moniteur
'******************************************************************************
*/
#include <JC_Button.h>							// https://github.com/JChristensen/JC_Button 
#include <SoftPWM.h>
 
//===================================== Aiguilles
#define aigMotEtatOn HIGH							                      // Etat pour moteur ON
#define aigMotEtatOnTemps 50						                      // Moteur, temps de l'impulsiom ON
enum aiguillesPositionIndex {aigPosGauche, aigPosDroite, aigPosNull};     // Pour indexer le tableau aiguilles[].motGDport[]
String aigPosLabelSh[] ={"G", "D"};
 
//const int aigLedEtatOn = LOW;                                             // Etat du port pour allumer la LED
boolean aigCommandOk;
 
//------------------------------------- Structure de l'objet aiguille
struct aiguilleDefinition
{String nom; byte position; int motGDport[2]; int ledGDport[2];};
 
aiguilleDefinition aiguilles[] =
{
	// contient le tableau de configuration des aiguilles
	#include "Train_TableauAiguillages.h"
};
const int aigNombreMax = sizeof(aiguilles)/sizeof(aiguilles[0]);
 
//------------------------------------- Structure de l'objet aiguille en utilisation
struct aigInUseDef
{int index; byte motPosition; String motPosLabel; String motPosLabelSh;};
aigInUseDef aigIu;                      // Aiguille en utilisation
 
//===================================== Boutons
#define bpMotNombreMax 4						// Nombre de moteurs max par bouton
const boolean bpEtatPresseLOW = true;			// Etat lu du bouton presse
boolean bpCommandeOk = false; 
 
//------------------------------------- Structure de l'objet bouton d'aiguuille (bpAig)
struct bpAigDefinition                                                  
{String nom; byte port; boolean bpOn; String aig_Dir[bpMotNombreMax];};
 
/*
	remplissage de la structure des boutons bp[0] a bp[bpNombreMax-1]
*/
bpAigDefinition bpAig[] = 
{
	// contient le tableau de configuration des aiguilles
	#include "Train_TableauBoutonsPoussoir.h"
};
const int bpNombreMax = sizeof(bpAig)/sizeof(bpAig[0]);
Button *bpRead[bpNombreMax];                     // JC_Button.h
 
 //===================================== Led PWM (lpwm) https://github.com/bhagman/SoftPWM
 //                                                     https://github.com/bhagman/SoftPWM#notes
#define lpwmPolarite SOFTPWM_INVERTED  // SOFTPWM_NORMAL ou SOFTPWM_INVERTED 
#define lpwmOn true
 
byte lpwmValeurOn= 255;                // Valeur pour allumer
byte lpwmValeurOff= 0;                 // Valeur pour eteindre
int lpwmTempsToOn = 500;               // Temps ver l'allumage
int lpwmTempsToOff =500;               // Temps vers l'extinction
 
 //===================================== Commandes moniteur
String monCommandRx;                   // Commande recue
boolean monCommandNew;                 // Si nouvelle commande
 
struct cmdMonitDef
{String nom; String paramStr; int paramInt; float paramFl;};
cmdMonitDef cmdMonitRx;
//------------------------------------- Liste des commandes index et syntaxe
enum cmdMoniteurIndex {cmdMonitBp, cmdMonitAig, cmdMonitLpwm, cmdMonitLpwmAllOff, cmdMonitNombre};
char* cmdMonitSyntax[] = {"BP"      , "AIG",      "LPWM",        "LPWMALLOFF"};
 
 
void setup()
{
	Serial.begin(115200);
	delay(500);
 
	aigLpwmInitialisation();
	bpInitialisation();
	aigInitialisation();
	aigIu.index = -1;                  // Pas d'aiguille selectionnee
 
	gareInitialisation();
}
 
void loop()
{
	if (bpScanStatus())				   // S'il y a un bouton presse                             
	{
		delay(250);					   // Attendre d'eventuelles autres bp
		bpScanStatus();
		bpPressedAction();
	}
 
	/*---------------------------------------------------------------------------------------------------------------------- 
	   Ecoute du moniteur série pour la réception éventuelle de commandes ou paramètres.
	  ----------------------------------------------------------------------------------------------------------------------
	*/
	serialEvent();                     // Lecture du port serie
	if (monCommandNew)                 // Si reçu une nouvelle commande
	{
		cmdMonitRecue(monCommandRx);   // Evaluation de la commande
 
		monCommandRx = "";
		monCommandNew  = false;
	}
}
//===================================== Aiguilles (aig)
void aigInitialisation()
{
	for (int aig = 0; aig < aigNombreMax; aig ++)
	{
		for (int gd = 0; gd < 2; gd ++)
		{
			// Initialisation des moteurs d'aiguilles
			pinMode(aiguilles[aig].motGDport[gd], OUTPUT);
			digitalWrite(aiguilles[aig].motGDport[gd], !aigMotEtatOn);		// Moteur a l'arrêt
 
			//**** Initialisation des LED dans aigLpwmInitialisation() ****
		}
 
		// Mise en position des aiguilles en fonction de aiguilles[x].position
		String initCmd = aiguilles[aig].nom + "_" + aigPosLabelSh[aiguilles[aig].position];
		aigCommandOk = aigCommande(aiguilles[aig].nom + "_" + aigPosLabelSh[aiguilles[aig].position], false);
	}
}
 
/*------------------------------------- Commande d'aiguille
	   G1_D                     A1_G  A3_D         00_0 
	Äiguille G1 a droite  Äiguille A1 a gauche  Inutilise
*/
boolean aigCommande(String aigCmd, boolean aigCmdEcho)
{
	boolean aigExecOk = false;
 
	aigCmdSelection(aigCmd);             // Selection des parametres de l'aiguille en fonction de la commande
                                         // dans la structure aigIu (aiguille in use)
	if (aigIu.index != -1)               // Si aiguille trouvee
	{
		aigMouvement(aigIu, aigCmdEcho);
		aigLedOnOff(aigIu, aigCmdEcho);
 
		aigExecOk = true;
	} 
	else
	{
		Serial.print(F("Commande; >> ")); Serial.print(aigCmd); Serial.println(F(" << Inconnue!!!"));
	}
 
	return aigExecOk;
}
 
/*------------------------------------- Index de l'aiguille
	Selectionne une aiguille en fonction de la commande aiguille_parametre
	G1 ou G1_D, recherche G1 dans le tableau aiguilles.nom[n]
	retourne true si trouvee et renseigne 
	aigIu.index (-1 si pas trouvee) et 
	aigIu.motPosition (aigPosGauche , aigPosDroite ou aigPosNull)
*/
void aigCmdSelection(String aigCmd)
{
	String aigName = "";
	String aigParam = "";                                  // Ce qui est apres le separateur _
	aigIu.index = -1;
 
	aigCmd.toUpperCase();                                  // En majuscules
	byte sepPos = aigCmd.indexOf("_");                     // Position du separateur _
 
	if (sepPos)
	{
		aigName = aigCmd.substring(0, sepPos);             // On retire le _ et le parametre pour garder le nom
		aigParam = aigCmd;
		aigParam.replace(aigName + "_", "");               // On retire le nom et _ pour garder le parametre
	} 
 
	for (int aig = 0; aig < aigNombreMax; aig ++)          // Recherche si l'aiguille existe
	{
		if (aiguilles[aig].nom == aigName)
		{
			aigIu.index = aig;
			break;
		}
	}
 
	if (aigParam == "G")
	{	
		aigIu.motPosLabelSh = "G";
		aigIu.motPosLabel = "Gauche";
		aigIu.motPosition = aigPosGauche;
	} 
	else if (aigParam == "D")
	{	
		aigIu.motPosLabelSh = "D";
		aigIu.motPosLabel = "Droite";
		aigIu.motPosition = aigPosDroite;
	}
	else
	{	aigIu.motPosition = aigPosNull;}
}
 
/*------------------------------------- Aiguille mouvement 
	parametres dans  structure aigIu
*/
void aigMouvement(aigInUseDef aigMouv, boolean echoCmd)
{
	byte motAigPort = aiguilles[aigMouv.index].motGDport[aigMouv.motPosition];
 
	digitalWrite(motAigPort, aigMotEtatOn);       // Moteur ON
	delay(aigMotEtatOnTemps);
	digitalWrite(motAigPort, !aigMotEtatOn);      // Moteur NOT ON
	delay(aigMotEtatOnTemps);
 
	if (echoCmd)
	{
		Serial.print(F("\tAiguille ")); Serial.println(aiguilles[aigMouv.index].nom + " " + aigMouv.motPosLabel);
	}
}
 
//------------------------------------- Aiguille led On/Off
void aigLedOnOff(aigInUseDef aigMouv, boolean echoCmd)
{
	int ledOnPort = aiguilles[aigMouv.index].ledGDport[aigMouv.motPosition];     // Led a allumer
	int ledOffPort = 0;
 
	if (aigMouv.motPosition == aigPosDroite)                                   // Quelle LED eteindre
	{
		ledOffPort = aiguilles[aigMouv.index].ledGDport[aigPosGauche];
	} 
	else
	{
		ledOffPort = aiguilles[aigMouv.index].ledGDport[aigPosDroite];
	}
 
	lpwmLedSet(ledOnPort, lpwmOn);		           // LED allumee
	lpwmLedSet(ledOffPort, !lpwmOn);		           // LED eteinte
 
	if (echoCmd)
	{
		Serial.print(F("\t\tLED ")); Serial.println(String(ledOnPort) + "\t On");
		Serial.print(F("\t\tLED ")); Serial.println(String(ledOffPort) + "\t Off");
	}
}
//------------------------------------- Toutes les LED d'aiguilles eteintes
void aigLedAllOff()
{
	for (int aig = 0; aig < aigNombreMax; aig ++)
	{
		for (int gd = 0; gd < 2; gd ++)
		{
			lpwmLedSet(aiguilles[aig].ledGDport[gd], !lpwmOn);		    // LED a eteindre
		}
	}
 
}
void aigLpwmInitialisation()
{
	SoftPWMBegin(lpwmPolarite);
	SoftPWMSetFadeTime(ALL, 1800, 1800);
 
	for (int aig = 0; aig < aigNombreMax; aig ++)
	{
		for (int gd = 0; gd < 2; gd ++)
		{
			SoftPWMSet(aiguilles[aig].ledGDport[gd], 0);
		}
	}
}
 
 
//===================================== Boutons poussoir (bp)
void bpInitialisation()
{
	//--------------------------------- Initialisation des bp
	for (int b = 0; b < bpNombreMax; b ++)
	{
		bpRead[b] = new Button(bpAig[b].port, 25, true, bpEtatPresseLOW);			// Port Antirebonds PULL_UP actif a LOW
		bpRead[b]->begin();
	}
}
 
/*------------------------------------- Commande de bp
	   C1_V1 ou C2_V3....
	   le syntaxe se trouve dans la structure bpAig[bpIndex].nom
*/
boolean bpCommande(String bpCmd, boolean cmdEcho)
{
	boolean bpExecOk = false;
 
	bpCmd.toUpperCase();
 
	if (cmdEcho)
	{
		Serial.print(F("Commande bp ")); Serial.println(bpCmd);
	}
 
	for (int b = 0; b < bpNombreMax; b ++)                           // Balayage des bp
	{
		if (bpAig[b].nom == bpCmd)                                   // Si le nom du bp correspond
		{
			bpMotAction(b, cmdEcho);
			bpExecOk = true;
		}
	}
	return bpExecOk;
}
 
//------------------------------------- Lecture de l'etat des bp
bool bpScanStatus()
{
	boolean bpEvent = false;
 
	for (int b = 0; b < bpNombreMax; b ++)                           // Balayage des bp
	{
		bpRead[b]->read();
		if (bpRead[b]->wasPressed())
		{
			bpAig[b].bpOn = true;
			bpEvent = true;
		}
	}
	return bpEvent;
}
 
//------------------------------------- Si bp est presse, action
void bpPressedAction()
{
	Serial.println(F("\t>>> Aiguillage <<<"));
	aigLedAllOff();                                                  // Etaindre les LED
 
	for (int b = 0; b < bpNombreMax; b ++)                           // Lister les boutons presses
	{
		if (bpAig[b].bpOn)                                           // Si ce bouton est presse
		{
			Serial.println(bpAig[b].nom);
			bpMotAction(b, true);
			bpAig[b].bpOn = false;                                   // tache bp b terminee
		}
	}
	Serial.println("");
}
//------------------------------------- Mise en action des aiguilles/moteur du bouton
void bpMotAction(int bpIndex, boolean cmdEcho)
{
	for (int mot = 0; mot < bpMotNombreMax; mot ++)                            // Lister les commandes d'aiguilles concernes
	{
		if (bpAig[bpIndex].aig_Dir[mot] != "")
		{
			aigCommandOk = aigCommande(bpAig[bpIndex].aig_Dir[mot], cmdEcho);  // Encoi de la commande d'aiguillage
		}
	}
}
//===================================== LED pwm (lpwm)
void lpwmLedSet(int ledIndex, boolean ledEtat)
{
	byte ledIntensite = ledEtat ? lpwmValeurOn : lpwmValeurOff;
 
	SoftPWMSetFadeTime(ledIndex, lpwmTempsToOn, lpwmTempsToOff);
	SoftPWMSet(ledIndex, ledIntensite);
}
 
//------------------------------------- Lpwm test
void lpwmTest(String lpwmCmd)
{
	int ledIndex;
 
	if (lpwmCmd.startsWith("A"))                 // Si c'est un port analogique (A0, A1 ...
	{
		lpwmCmd.replace("A", "");                // Enlever le A
		ledIndex = lpwmCmd.toInt() + A0;         // Ajouter la valeur de A0 (14 pour le UNO et 54 pour le Mega)
	}
	else
	{
		ledIndex = lpwmCmd.toInt();
	}
 
	lpwmLedSet(ledIndex, lpwmOn);
	delay(2000);
	lpwmLedSet(ledIndex, !lpwmOn);
}
 
//===================================== Divers
//------------------------------------- Initialisation de la gare
void gareInitialisation()
{
	Serial.println(F("\n\t>>> Initialisation de la gare <<<"));
	cmdMonitRecue("BP=C1_V1,BP=C2_V2,BP=C3_V3");
 
	Serial.println(F(""));
}
 
//===================================== Commandes moniteur
/*
	Traite les commandes recues via la ligne do commande (moniteur)
	AIG=B1_G ou BP=C2_V3 commandes individuelles ou 
	AIG=B1_D, AIG=B3_D,BP=C2_V3,AIG=B1_D commandes groupees separees par une virgule.
	Les commandes ne sont pas sensibles aux majuscules ou minuscules.
	Elles peuvent etre mises dans le programme sous la forme:
	monitCmdRecue("AIG=B3_D");	ou monitCmdRecue("BP=C3_V3"); ou
	monitCmdRecue("BP=C1_V1,AIG=B3_D,BP=C3_V3");
*/
 
void cmdMonitRecue(String cmdRx)
{
	String cmdExec = "";
 
	cmdRx.toUpperCase();                                   // Tout en majuscules
	cmdRx.replace(" ", "");                                // Supprimer les espaces
	Serial.print(F("\nCommande moniteur:\t")); Serial.println(cmdRx);
 
	while(cmdRx.indexOf(",") > 0)                          // Tant qu'il y a une virgule pour commande multiple
	{
		cmdExec = cmdRx.substring(0, cmdRx.indexOf(",") +1);
		cmdMonitExecute(cmdExec);
		cmdRx.replace(cmdExec, "");
	}
	if (cmdRx.length() > 3 || cmdRx == "?")                       // S'il reste une commande dans la chaine cmdRx
	{
		cmdMonitExecute(cmdRx);
	}
}
void cmdMonitExecute(String cmdExec)
{
	boolean cmdExecOk;
 
	cmdExec.replace(",", "");                     // Supprimer les virgules
 
	if (cmdExec== "?")                                     // Liste des commandes
	{
		cmdMonitHelp();
		cmdExecOk = true;
	}                                                     
	else if (cmdMonitCheck(cmdExec, cmdMonitBp))                     // Bouton poussoir
	{
		aigLedAllOff();                                              // Etaindre les LED
		cmdExecOk = bpCommande(cmdMonitRx.paramStr, false);
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitAig))                    // Aiguille       
	{
		cmdExecOk = aigCommande(cmdMonitRx.paramStr, false);
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitLpwm))                   // LED PWM
	{
		lpwmTest(cmdMonitRx.paramStr);
		cmdExecOk = true;
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitLpwmAllOff))             // LED PWM toutes OFF
	{
		aigLedAllOff();
		cmdExecOk = true;
	}
	else
	{
		cmdExecOk = false;
	}
 
	Serial.print("Execution de: " + cmdExec);
	if (cmdExecOk)
	{
		Serial.println(F("   = OK"));
	}
	else
	{
		Serial.println(F("   = Commande inconnue !!!"));
	}
}
	/*---------------------------------------------------------------------------------------------------------------------- 
	  Controle la commande recue
	  retourne true si OK ou false si pas 
	  Met les parametres de la commande dans la structure cmdMoniteurRx, le nom = ! si pas reconnue
	  ----------------------------------------------------------------------------------------------------------------------
	*/
boolean cmdMonitCheck(String cmdMonRx, int cmdMonIndex)
{
	bool cmdCheckOk;
 
	String cmdCheck = (String)cmdMonitSyntax[cmdMonIndex]+ "=";
	if (cmdMonRx.startsWith(cmdCheck))
	{
		cmdMonitRx.nom = (String)cmdMonitSyntax[cmdMonIndex];
		cmdMonRx.replace(cmdCheck, "");                               // Garder que le ou les parametres
 
		cmdMonitRx.paramStr = cmdMonRx;
		cmdMonitRx.paramInt = cmdMonRx.toInt();
		cmdMonitRx.paramFl = cmdMonRx.toFloat();
 
		cmdCheckOk = true;
	}
	else
	{
		cmdMonitRx.nom = "!";
 
		cmdCheckOk = false;
	}
	return cmdCheckOk;	
}
 
void cmdMonitHelp()
{
	Serial.println(F("\n\t> > > Liste des commandes < < <"));
	Serial.println(F("?"));
 
	for (int cm = 0; cm < cmdMonitNombre; cm ++)
	{
		Serial.print(cmdMonitSyntax[cm]); Serial.println("=");
	}
	Serial.println("");
}
 
//===================================== Ecoute du port serie
void serialEvent()                                                   // IDE monitor or DRO serial
{
	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
		{
			monCommandNew  = true;
		}
		else
		{
			if (monChar >= ' ') {monCommandRx += monChar;}           // >= ' ' to avoid not wanted ctrl char.
		}
	}
}

Définition des aiguillages Train_TableauAiguillages.h:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
	// Position donne la position de l'aiguille au demarrage du programme
	//Nom,   Position, Moteur G, Moteur D, Led G, LED D   255 = port inutilise
	{"G1", aigPosDroite,  21,       22,       40,   41},
	{"A1", aigPosGauche,  23,       24,       42,   43},
	{"A2", aigPosDroite,  25,       26,       44,   45},
	{"A3", aigPosGauche,  27,       28,       46,   47},
	{"A4", aigPosDroite,  29,       30,       48,   49},
	{"B1", aigPosDroite,  31,       32,       50,   51},
	{"B2", aigPosDroite,  33,       34,       52,   53},
	{"B3", aigPosDroite,  35,       36,       A8,   A9},
	{"B4", aigPosDroite,  37,       38,       A10,  A11}

Définition des bp Train_TableauBoutonsPoussoir.h:

Code :

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

1
2
3
4
5
6
7
8
9
	// Nom,  Port, presse, aigCmd1, aigCmd2, aigCmd2,  aigCmd2
	{"C1_V1",  5,   false, "G1_D",   "A1_G",  "A3_D",     ""},
	{"C1_V2",  6,   false, "G1_D",   "A1_D",  "A4_D",     ""},
	{"C2_V1",  7,   false, "B1_G",   "B3_D",  "A2_G", "A3_G"},
	{"C2_V2",  8,   false, "B1_G",   "B3_D",  "A2_D", "A4_G"},
	{"C2_V3",  9,   false, "B1_D",   "B4_D",      "",     ""},
	{"C3_V1", 10,   false, "B2_G",   "B3_G",  "A2_G", "A3_G"},
	{"C3_V2", 11,   false, "B2_G",   "B3_G",  "A2_D", "A4_G"},
	{"C3_V3", 12,   false, "B2_G",   "B4_G",      "",     ""}

Ainsi, tu peux changer la configuration de tes bp et aiguilles sans que ce soit "écrasé" par une nouvelle version du programme.
A l'ouverture, dans l'IDE Arduino, tu auras 3 onglets.

Je te mets un ZIP avec le répertoire.

A+
Cordialement
jpbbricole

[Jay M]

Salut JP

Dommage d'avoir le '=' dans la commande LPWMALLOFF= alors qu'il n'y a pas de paramètre attendu

si vous modifiez juste un peu le tableau cmdMonitSyntax

Code :

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

char* cmdMonitSyntax[] = {"BP="      , "AIG=",      "LPWM=",        "LPWMALLOFF"};

et comment vous l'utilisez ensuite vous pourriez avoir la commande sans le =. Il n'y a que 3/4 lignes à changer (en gros là où vous devez rajouter ce '=' à la main)


pas très important mais ça fait plus joli !

[Jsiorat]

Salut JP

pas très important mais ça fait plus joli !

Bonjour Jay !
Ca peut nous éviter de l'oublier quand on lance la commande ...

On se prend au jeu du train miniature ?
et toujours des remarques hyper pertinentes !
Qu'en pense JP ?

Bonne journée (en plein soleil ou sous la pluie ?)
Jacques

[Jsiorat]

Bonsoir Jacques

J'ai ajouté l'extinction des led avant l'action provoquée par la pression d'un nouveau bp, mais pas lors d'une commande AIG=, si tu veux aussi, tu sait où t'adresser .
J'ai passablement remanié les commandes moniteur, ajouté une commande pour éteindre toutes les LEDpwm des aiguilles.

Bonjour JP,
Je vais enfin voir comment on crée des onglets dans l'IDE !

je vais aussi voir les différences entre les 2 versions ! Je vais (encore !) me coucher ce soir, un peu plus instruit grâce à toi !

Je regarde ça ce soir, suis absent une grande partie de la journée.
Bonne journée à toi
avec tous mes remerciements pour ton implication dans ce projet, sans toi je n'y serais pas arrivé !
Jacques

[Jsiorat]

La question du jour ...

Lorsqu'on inclut une librairie comme "softPWM.h", tant qu'on est sur l'ordinateur ça ne pose pas de problème parce que l'IDE va chercher la librairie dans un répertoire quelconque sur le disque dur.
Mais quand on va débrancher pour travailler en autonome, la librairie elle est inclue par le programme et copiée dans la mémoire de la Carte Mega ?

[jpbbricole]

Bonjour Jacques

Lorsqu'on inclut une librairie comme "softPWM.h"....
Mais quand on va débrancher pour travailler en autonome, la librairie elle est inclue par le programme et copiée dans la mémoire de la Carte Mega ?

Oui, le compilateur fait un bloc de tout ça et c'est téléversé dans l'Arduino qui est, de ce fait, autonome.

Dommage d'avoir le '=' dans la commande LPWMALLOFF= alors qu'il n'y a pas de paramètre attendu.....
... pas très important mais ça fait plus joli !

Qu'en pense JP ?

Mouai, chez nous on dit que "l'on est ni pour ni contre, bien au contraire"
Plus sérieusement, je trouvais, justement, qu'ajouter les = dans le tableau, c'était pas joli!
Et puis, la finalité de cette commande, LPWMALLOFF=, sera LPWMALL=0 - 255.

Bonne journée (Pas de pluie aujourd'hui)
Cordialement
jpbbricole

[Jay M]

Plus sérieusement, je trouvais, justement, qu'ajouter les = dans le tableau, c'était pas joli!

L’utilisateur ne voit pas le code. Un programmeur doit toujours avoir en tête l’expérience utilisateur, est ce que ce qu’il propose sera simple a comprendre, à utiliser ?

Si vous trouvez le = moche, comme Au final votre analyseur de commande n’en a pas vraiment besoin, vous pourriez le virer partout. On taperait alors LPWM54 comme commande ou BPC3_V3. Mais vous conviendrez que c’est moins parlant cependant car pour l’utilisateur il se dit J’actionne le bouton qui est égal à C3V3... le = est porteur de sens. Mais symétriquement si il tape la commande pour tout éteindre il se dit qu’il a pas besoin de paramètres et donc le = est inutile.

Mais bon c’est pas grave, moi je utilise pas le système !

[jpbbricole]

Salut Jay M

L’utilisateur ne voit pas le code.

Mais moi, oui, et si je ne trouve pas le code "beau" à mon goût, je le corrige jusqu'à ce que. C'est un problème de lisibilité, surtout pour des néophytes.
C'est toute la différence entre l'amateur que je suis et le pro de l'analyse que tu est. Analyses que je trouve, parfois, assez "froides" et/ou sans concessions pour le genre de sire où nous sommes. Site où il faudrait plutôt prôner la tolérance.

Cordialement
jpbbricole

[Jay M]

Comme je vous l'ai déjà dit le français n'est pas ma langue maternelle. Je m'efforce de l'écrire le plus correctement possible et je vous présente mes excuses si mon style est trop direct et (culturellement?) perçu comme "froides et/ou sans concessions". Ce n'est pas l'intention.

De là où je viens on est sans doute beaucoup plus direct.

Je proposais une simple amélioration de l'experience utilisateur et comme dit Jacques

Ca peut nous éviter de l'oublier quand on lance la commande ...

et La modification du code associée était minime.