Discussion :

[Jsiorat]

Pour revenir au chapitre alimentation, avant que ça se gâte, je te conseille de mettre des drivers entre l'Arduino et les LED, il y en a d'excellents et pas cher, l'ULN2803. achètes-en une poignée, ça peut toujours servir, tu peux même faire tirer des relais avec. C'est l'équivalent d'un transistor NPN, mais il y en a 8 dans un boitier, donc plus facile à câbler et il y a même la diode de protection intégrée. Ensuite tu alimentes tes breadboard au moyen d'un chargeur USB ou d'une alimentation 5V., en mettant leur GND avec celui de l'Arduino. Ainsi ton Mega sera soulagé, il n'aura plus à supporter le courant des LED.
Je pense que, avec un ULN2803, tu pourrais faire marcher tes moteurs d'aiguille, si c'est du CC, je n'ai, malheureusement plus ce matériel pour essayer.

Les LEDs sur mon TCO sont donc des 3mm, vert, et si je me souviens bien, elles consomment nettement moins que les LEDs rouge !

C'est bien ceux-là ?

[jpbbricole]

Salut Jacques

Oui, je viens d'essayer, ça fonctionne impec!, juste mettre tes LED en anode commune et

Code :

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

#define lpwmPolarite SOFTPWM_NORMAL  // SOFTPWM_NORMAL ou SOFTPWM_INVERTED

Dans le programme

Tu veux un schéma de principe?

PS:J'ai retrouvé ma maquette de train d'il y a ~40ans, du Lima bon marché, la semaine prochaine je démonte une aguille pour essayer. Tes aiguilles fonctionnent à quelle tension, AC ou DC?

A+
Cordialement
jpbbricole

[Jsiorat]

Salut Jacques

Oui, je viens d'essayer, ça fonctionne impec!, juste mettre tes LED en anode commune et

Tu veux un schéma de principe?

Tes aiguilles fonctionnent à quelle tension, AC ou DC?

=> toutes mes aiguilles sont en alternatif !
14 / 16 v ;
Pièce jointe 581159

Je ne comprends pas les LEDs en anode commune ! C'est le driver qui va gérer la répartition ?
Ok pour le schéma ...

[Jsiorat]

PS:J'ai retrouvé ma maquette de train d'il y a ~40ans, du Lima bon marché, la semaine prochaine je démonte une aguille pour essayer. Tes aiguilles fonctionnent à quelle tension, AC ou DC?

J'ai récupéré le train de mon père qui est un Rocal échelle TT 1/120 ! Intermédiaire entre le H0 et le N et c'est beaucoup plus joli que le N !écartement est de 12mm !

Pour essayer ton code, il te faut 2 aiguilles : une droite et une gauche !

[jpbbricole]

Bonsoir Jacques

Je ne comprends pas les LEDs en anode commune !
C'est le driver qui va gérer la répartition ?
...

Le driver ULN2803 ne gère rien, il ne fait que fournir le courant nécessaire à l'allumage des LED tout en demandant, pour ce faire, le minimum (des clopinettes par rapport a des LED) de courant au Mega.

Un montage à anode commune signifie, que dans un réseau de LED commandées par un Mega, en l'occurrence, le côté de la diode qui est connectée au port du Mega est la cathode (le côté aplati à la base de la LED) et l'autre côté, l'anode est connect à l'alimentation positive comme toutes les autres LED du montage, c'est pourquoi on dit que les anodes sont communes puisque toutes ensembles. Il faut donc un 0 logique sur la borne le l'Arduino pour allumer cette LED.
Pour le montage à cathode commune, la diode est tournée dans l'autre sens et les cathodes sont toutes ensembles au GND du montage, toujours à travers des résistances. C'est le cas de ton montage. Il faut un 1 logique sur la borne le l'Arduino pour allumer cette LED.

Voilà un exemple, à multiplier autant que nécessaire.


Je ne suis pas un spécialiste du Fritz!!!
Pour la livraison de la dernière version du programme, ce sera plutôt demain.

A+
Cordialement
jpbbricole

[jpbbricole]

Bonjour Jacques

Voilà la dernière version (0.95), pour mettre à jour, il suffit de remplacer ARDDEV_AiguillagesBledMonitSoftPwm.ino par celle-ci

J'ai modifié les commandes

Code :

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

1
2
3
4
5
6
7
	> > > Liste des commandes < < <  Prog. vers. 1.10
?
BP=
AIG=
LPWMTEST=
LPWMTESTALL=
CMDTRACE=

BP= commande bouton poussoir BP=C2_V2 ou BP=C1_V1,BP=C2_V2,BP=C3_V3
AIG= commande d'aiguillage AIG=A2_G ou AIG=A2_G,AIG=B1_D,AIG=B3_D
LPWMTEST= Test la LED en argument, qui s'allume progressivement et, après 20 sec., s'éteint de même
LPWMTESTALL= Allume toutes les LED à l'intensité en argument (0-255)
CMDTRACE= Si = 1, affiche plus de détails de l'exécution d'une commande BP= et AIG=.

CMDTRACE=0 et commande BP=C1_V1
Commande moniteur: BP=C1_V1
Execution de: BP=C1_V1 = OK

CMDTRACE=1 et commande BP=C1_V1
Commande moniteur: BP=C1_V1
Commande bp C1_V1
Aiguille G1 Droite
LED 41 On
LED 40 Off
Aiguille A1 Gauche
LED 42 On
LED 43 Off
Aiguille A3 Droite
LED 47 On
LED 46 Off
Execution de: BP=C1_V1 = OK

Par defaut CMDTRACE=0 boolean cmdMonTrace = false;

Le 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
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
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
/******************************************************************************
    Name:       Commande d'aiguillages et de leurs LED
    Created:    04.10.2020
    Author:     jpbbricole
        
        Remarques:      Version avec LED SoftPWM et commandes moniteur
                LPWM       devient LPWMTEST=ledPort
                LPWMALLOFF devient LPWMTESTALL=intensite0-255
'******************************************************************************
*/
#define  progrVersion 0.95
#include <JC_Button.h>							// https://github.com/JChristensen/JC_Button 
#include <SoftPWM.h>                            // https://github.com/bhagman/SoftPWM
                                                // https://github.com/bhagman/SoftPWM#notes
 
//===================================== 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"};
 
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)
#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
boolean cmdMonTrace = false;           // Trace des commandes dans console
 
struct cmdMonitDef
{String nom; String paramStr; int paramInt; float paramFl;};
cmdMonitDef cmdMonitRx;
//------------------------------------- Liste des commandes index et syntaxe
enum cmdMoniteurIndex {cmdMonitBp, cmdMonitAig, cmdMonitLpwmTest, cmdMonitLpwmTestAll, cmdMonitCmdTrace, cmdMonitNombre};
char* cmdMonitSyntax[] = {"BP"      , "AIG",      "LPWMTEST",        "LPWMTESTALL",       "CMDTRACE"};
 
 
void setup()
{
	Serial.begin(115200);
	delay(500);
 
	aigLpwmInitialisation();
	bpInitialisation();
	aigInitialisation();
	aigIu.index = -1;                  // Pas d'aiguille selectionnee
 
 
	cmdMonitHelp();
	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);
}
 
void lpwmTestAll(byte luminosite)
{
	for (int aig = 0; aig < aigNombreMax; aig ++)
	{
		for (int gd = 0; gd < 2; gd ++)
		{
			SoftPWMSetFadeTime(aiguilles[aig].ledGDport[gd], lpwmTempsToOn, lpwmTempsToOff);
			SoftPWMSet(aiguilles[aig].ledGDport[gd], luminosite);
		}
	}
}
//===================================== 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:
	cmdMonitRecue("AIG=B3_D");	ou cmdMonitRecue("BP=C3_V3"); ou
	cmdMonitRecue("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, cmdMonTrace);
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitAig))                    // Aiguille       
	{
		cmdExecOk = aigCommande(cmdMonitRx.paramStr, cmdMonTrace);
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitLpwmTest))               // LED PWM
	{
		lpwmTest(cmdMonitRx.paramStr);
		cmdExecOk = true;
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitLpwmTestAll))            // LED PWM toutes OFF
	{
		lpwmTestAll((byte)cmdMonitRx.paramInt);
		cmdExecOk = true;
	}
	else if (cmdMonitCheck(cmdExec, cmdMonitCmdTrace))               // LED PWM toutes OFF
	{
		if (cmdMonitRx.paramInt > 0)
		{
			cmdMonTrace = true;
		}
		else
		{
			cmdMonTrace = false;
		}
 
		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.print(F("\n\t> > > Liste des commandes < < <  Prog. vers. ")); Serial.println((String)progrVersion);
	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.
		}
	}
}

Bonne soirée
Cordialement
jpbbricole

[Jsiorat]

Bonjour Jacques

Voilà la dernière version (0.95), pour mettre à jour, il suffit de remplacer ARDDEV_AiguillagesBledMonitSoftPwm.ino par celle-ci

Bonsoir JP,

Et tu bosses même le dimanche ? ça t'as occupé parce que tu ne pouvais rien faire d'autre ? je plaisante !
Tu as bossé For Me, Formi, Formidable ! (j'ai déjà fait ce jeu de mots dans une réponse à Jay !)

Je ne sais comment te remercier pour ton aide ; j'ai tenté de faire une vidéo avec mon tel, mais 20 mégas, ça passe pas ! (ou alors, j'm'suis planté !)
A propos des drivers ULN2803, je viens d'en commander chez Amazon pour 3 € ! Si j'ai bien compris il va m'en falloir 2 sur la "planche à pain" !
Comme je t'en ai déjà parlé, je vais devoir gérer le côté Triage de mon train.
Si j'ai bien assimilé ce que tu t'es évertué à m'inculquer, je peux modifier les fichiers "Train_TableauAiguillages" et "Train_TableauBoutonsPoussoir" pour les adapter ...
Est-ce que je me trompe ?

J'ai vu dans le code que tu as fait un #define progrVersion 0.95 ; quel en est l'utilité ?

J'ai une bonne nouvelle ... Ça fonctionne et c'est visuellement magnifique ! J'aimerai avoir comme toi la science infuse pour faire la même chose.

Bonne soirée,
Cordialement Jacques

[Jay M]

j'ai tenté de faire une vidéo avec mon tel, mais 20 mégas, ça passe pas !

Vous pouvez vous créer un compte youTube et charger la vidéo chez Google puis mettre le lien vers cette video youTube ici.

Comme je t'en ai déjà parlé, je vais devoir gérer le côté Triage de mon train.
Si j'ai bien assimilé ce que tu t'es évertué à m'inculquer, je peux modifier les fichiers "Train_TableauAiguillages" et "Train_TableauBoutonsPoussoir" pour les adapter ...
Est-ce que je me trompe ?

C'est fait pour cela. Attention il ne reste de la place que pour 1 seul aiguillage (2 LEDs). Ensuite ça fera 20 LEDs ce qui est la limite dans la bibliothèque SoftPWM. C'est modifiable changez le 20 en ce qu'il faut sur cette ligne

Code :

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

#define SOFTPWM_MAXCHANNELS 20

mais plus on passe de temps dans l'interruption moins on passe de temps dans le programme donc faut rester raisonnable)

[jpbbricole]

Bonsoir Jacques

Et tu bosses même le dimanche ? ça t'as occupé parce que tu ne pouvais rien faire d'autre ? je plaisante !

J'ai toujours à faire, actuellement, pour un ami, toujours avec un Arduino, la gestion d'une pompe en fonction de l'ensoleillement. J'ai quand même "du" sortir pour une promenade et profiter du peu de rayons de soleil.

A propos des drivers ULN2803, je viens d'en commander chez Amazon pour 3 € ! Si j'ai bien compris il va m'en falloir 2 sur la "planche à pain" !

Le nombre de LED / 8.

Si j'ai bien assimilé ce que tu t'es évertué à m'inculquer, je peux modifier les fichiers "Train_TableauAiguillages" et "Train_TableauBoutonsPoussoir" pour les adapter ...
Est-ce que je me trompe ?

Non, c'est bien ça, le moyen le plus sûre et de copier/coller une ligne existante et de modifier les paramètres. Le nombre de bp et d'aiguilles s'adaptent automatiquement.
Attention à la remarque de Jay M, je vais faire l'essai, demain, de cette modification.

J'ai vu dans le code que tu as fait un #define progrVersion 0.95 ; quel en est l'utilité ?

C'est surtout pour moi, pour me repérer et puis "ça fait bien"

J'aimerai avoir comme toi la science infuse pour faire la même chose.

Un bon moyen pour y arriver, continuer à fréquenter ce forum.

Je ne sais comment te remercier pour ton aide ;

En faisant une belle maquette pleine de belles lumières et qui me feras briller les yeux.

Bonne soirée
Cordialement
jpbbricole

[Jsiorat]

Vous pouvez vous créer un compte youTube et charger la vidéo chez Google puis mettre le lien vers cette video youTube ici.


Attention il ne reste de la place que pour 1 seul aiguillage (2 LEDs)

Bonsoir Jay,

Je vais utiliser une seconde carte Méga 2560 pour le triage ou alors j'utiliserai des shield de relays ! J'ai 10 aiguillages à gérer ; Merci pour l'information !

Ok pour la vidéo, je m'en occupe dès que ... j'aurais refait une vidéo correcte.

Bonne soirée Jay,

A+, Jacques

[jpbbricole]

Bonsoir Jacques

Je vais utiliser une seconde carte Méga 2560 pour le triage ou alors j'utiliserai des shield de relays ! J'ai 10 aiguillages à gérer .....

Comment est structuré le programme, il sera assez facile d'envoyer des ordres à un Arduino secondaire, via un Serial, si c'est ton "orientation", je pourrais m'y atteler.

A+
Cordialement
jpbbricole

[Jsiorat]

Bonsoir Jacques

Comment est structuré le programme, il sera assez facile d'envoyer des ordres à un Arduino secondaire, via un Serial, si c'est ton "orientation", je pourrais m'y atteler.

Bonjour JP,

Pour le moment, je vais brancher mon TCO avec un Mega 2560, une breakboard. Tout sera branché à l'exception des moteurs aiguillages mais je vais garder la platine avec les LEDs bleus et jaunes qui m'indiquent l'utilisation des moteurs droit ou gauche. Je m'y attaque aujourd'hui.
Ensuite, je m'attaque au TCO Triage. Avec le TCO Gare, se sont deux choses bien distinctes. Il y a 10 aiguillages dont le fameux G1_G qu'on a déjà sur le TCO Gare, 19 LEDs qui vont indiquées les voies et les aiguillages sélectionnées.
Si je veux utiliser ton code, j'ai juste le nécessaire en tant que broches sur le Mega. Il n'y aura plus d'initialisation GARE (je mettrais les lignes en commentaires pour ne pas effacer quoique se soit ) et j'adapterai les deux fichiers .h après avoir fait un copier/coller.
Je fais une vidéo dès que se sera construit et comme l'a suggéré Jay, je mettrai ici un lien pour la visualiser.
Par la suite, je vais devoir réfléchir à diviser mon circuit en cantons : j'ai trois lignes principales, divisées en 3 cantons (dont l'ensemble gare), chacunes avec zone d'arrêt avec feux rouge/vert, zone de ralentissement avec feux orange de ralentissement (pré-signalisation). Il y a encore beaucoup de gestion à faire avec des UNO R3, la reconnaissance de la présence d'une rame sur un canton au moyen d'interrupteurs ILS et de minuscules aimants collés sous les locomotives et le dernier wagon de la rame. Il faudra jouer sur l'activation de l'ILS, une fois à l'avant et une fois à l'arrière de la rame.
Commence à réfléchir .... (je plaisante ! )
Bonne journée, A+
Jacques

[Jsiorat]

Ce n'est pas une histoire de Législative ou cantonale ... J'ai retrouvé ça dans mes archives.
Ça explique les cantons et les zones d'arrêt sur un circuit !

BJ (non, ce n'est pas la Belle Jardinière, mais Bonne Journée ! )

[jpbbricole]

Bonjour Jacques

Ça explique les cantons et les zones d'arrêt...

Chez moi, c'est le canton de Vaud et les seules zones d'arrêt que je connaisse, c'est les prisons

Commence à réfléchir .... (je plaisante ! )

J'ai déjà des idées bien arrêtées, je te les exposerai dans la journée. Qu'as-tu prévu pour la commande des aiguilles, relais?

BJ à toi et transmet ma BJ à ta BJ

Cordialement
jpbbricole

[Jay M]

Salut à toutes et tous

L’article joint ci dessous répond sans doute à la question de vocabulaire que l’on se posait:

Le circuit ferroviaire est divisé en cantons successifs qui sont des portions de voie sur lesquelles circulent les trains.

Peut être que cette notion de canton peut être appliquée au bout de voie entre deux aiguillages (même si c’est plus général, il semble logique qu’il y ait au minimum un canton entre 2 aiguillages)

==============

@Jacques

Multiplier les Arduinos peut sembler une bonne idée pour séparer les problèmes mais quand vous aurez des trains à cheval sur les cantons gérés par les deux Arduinos (au bout de C1 à l’entrée de votre zone de triage) ça va emmener des complexités de développement et synchronisation, surtout que vos trains sur la nouvelle zone vont par définition devoir circuler dans les deux sens pour rentrer et sortir. Ce n’est pas insurmontable mais source de bugs potentiels.

Il serait peut être bon d’envisager les cartes d’extension de ports en SPI ou I2C dont nous avions parlé précédemment ce qui permettrait de conserver l’ensemble du contrôle dans un seul arduino.

Le besoin en nombre de broches diminuant, Vous pourriez aussi migrer vers un ESP32 ce qui vous donnera beaucoup plus de mémoire pour développer et la possibilité de rajouter une interface Web et Bluetooth sans avoir à rajouter des composants.





—-


PS: @JP Très joli coin le canton de vaud! très bons souvenirs (Il y a un moment...) du sommet des Diablerets en passant par le col du Sanetsch

[jpbbricole]

Bonjour Jay M

PS: @JP Très joli coin le canton de vaud! très bons souvenirs (Il y a un moment...) du sommet des Diablerets en passant par le col du Sanetsch

Belle ballade!
Où je vis,1804 Corsier-sur-Vevey dans le bassin lémanique, on a coutume de dire que "l'on vit dans une carte postale", tant le panorama est beau!

Bonne journée
Cordialement
jpbbricole

[Jay M]

on a coutume de dire que "l'on vit dans une carte postale", tant le panorama est beau!

Oui ce doit être super! Surtout en ces temps de confinement

(Pour le boulot il y a “quelques années” je suis allé quelques fois chez Nestlé - leur campus est super)

[Jsiorat]

Salut à toutes et tous


@Jacques

Multiplier les Arduinos peut sembler une bonne idée pour séparer les problèmes mais quand vous aurez des trains à cheval sur les cantons gérés par les deux Arduinos (au bout de C1 à l’entrée de votre zone de triage) ça va emmener des complexités de développement et synchronisation, surtout que vos trains sur la nouvelle zone vont par définition devoir circuler dans les deux sens pour rentrer et sortir. Ce n’est pas insurmontable mais source de bugs potentiels.

Bonjour Jay,

Bien vu, Dr Watson !

Ce souci de train à cheval sur deux cantons lors de la sortie de la zone de triage est, je crois, résolu dans un document que j'ai sur l'ordinateur et il faut que je le retrouve. C'est le problème de la circulation en double sens sur voie unique.
En circulant de C1 vers V1, il y a un canton avec une zone d'arrêt.

le synopsis est le suivant :
- tant que l'aiguillage C1 est sur droite (vers V1), aucune rame ne peut sortir du triage.
- BP C1 => gauche : contrôle si une rame se trouve dans le canton
oui : sortie interdite ; C1 => droite
non : - canton passe en occupé avec présignalisation orange ;
- rame sort du triage ;
- G1 => D ;
- rame entre en gare vers V1 ou V2 ;
- canton passe en libre
En gros, c'est le schéma basique à développer.

========================
JP :

je dispose de relais Arduino et autres, donc j'ai le choix ! j'ai une préférence pour les relais, parce que ceux-ci vont avoir besoin de 12 V.

A+ Bonne journée à tous !

[Jay M]

- tant que l'aiguillage C1 est sur droite (vers V1), aucune rame ne peut sortir du triage.
- BP C1 => gauche : contrôle si une rame se trouve dans le canton
oui : sortie interdite ; C1 => droite
non : - canton passe en occupé avec présignalisation orange ;
- rame sort du triage ;
- G1 => D ;
- rame entre en gare vers V1 ou V2 ;
- canton passe en libre
En gros, c'est le schéma basique à développer.

Oui ce que je dis c'est qu'il va falloir développer de nouvelles commandes et un protocole pour discuter entre les 2 Arduinos.

Pour le moment les commandes sont uni-directionnelles et sans confirmation de bonne exécution.

Là vous allez envoyer une requête d'un arduino à l'autre pour demander "est-ce qu'une rame se trouve dans le canton? " et il faudra attendre la réponse pour pouvoir effectuer l'action associée à BP C1. rien d'insurmontable (ça se fait fréquemment avec les commandes AT des GSM ou ESP) mais ça nécessite une spécification et du développement supplémentaire surtout si on reste sur une communication UART qui est par nature asynchrone.

[Jsiorat]

Oui ce que je dis c'est qu'il va falloir développer de nouvelles commandes et un protocole pour discuter entre les 2 Arduinos.

Les deux arduino ne sont pas liées l'une par rapport à l'autre ! La 1ère pour la gare, la seconde pour le triage.
La gestion des cantons sera encore à part ! Peut-être que je me plante mais c'est comme ça que je vois la chose !