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
| /******************************************************************************
Name: Commande d'aiguillages et de leurs LED
Created: 29.09.2020
Author: jpbbricole
Remarques: Version avec LED et commandes moniteur
'******************************************************************************
*/
#include <JC_Button.h> // https://github.com/JChristensen/JC_Button
//===================================== 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[] =
{
// 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, 255, 22, 255, 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}
};
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[] =
{
// 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", "", ""}
};
const int bpNombreMax = sizeof(bpAig)/sizeof(bpAig[0]);
Button *bpRead[bpNombreMax]; // JC_Button.h
//===================================== Commandes moniteur
String monCommandRx; // Commande recue
boolean monCommandNew; // Si nouvelle commande
void setup()
{
Serial.begin(115200);
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
{
monitCmdRecue(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
pinMode(aiguilles[aig].ledGDport[gd], OUTPUT);
digitalWrite(aiguilles[aig].ledGDport[gd], !aigLedEtatOn); // LED eteinte
}
// 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];
}
digitalWrite(ledOnPort, aigLedEtatOn); // LED eteinte
digitalWrite(ledOffPort, !aigLedEtatOn); // 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");
}
}
//===================================== 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 <<<"));
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
}
}
}
//===================================== Divers
//------------------------------------- Initialisation de la gare
void gareInitialisation()
{
Serial.println(F("\n\t>>> Initialisation de la gare <<<"));
monitCmdRecue("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 monitCmdRecue(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
{
cmdExec = cmdRx.substring(0, cmdRx.indexOf(",") +1);
monitCmdExecute(cmdExec);
cmdRx.replace(cmdExec, "");
}
if (cmdRx.length() > 3) // S'il reste une commande dans la chaine cmdRx
{
monitCmdExecute(cmdRx);
}
}
void monitCmdExecute(String cmdExec)
{
boolean cmdExecOk = false;
cmdExec.replace(",", ""); // Supprimer les virgules
if (cmdExec.startsWith("AIG=")) // Commande aiguillage
{
cmdExec.replace("AIG=", "");
cmdExecOk = aigCommande(cmdExec, false);
}
if (cmdExec.startsWith("BP="))
{
cmdExec.replace("BP=", "");
cmdExecOk = bpCommande(cmdExec, false);
}
Serial.print("Execution de: " + cmdExec);
if (cmdExecOk)
{
Serial.println(F(" = OK"));
}
else
{
Serial.println(F(" = Commande inconnue !!!"));
}
}
//===================================== 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.
}
}
} |
Envoyé par jpbbricole
Répondre avec citation
Partager