chaque zone (ou canton, mais une zone peut inclure une aiguille, pas un canton normalement)
est-il possible de montrer un exemple simple ?
les traitements des signaux remontés par les capteurs aux passage des trains appellent-ils les méthodes des objets directement ?
///////////// PROTOTYPE CLASSE AIGUILLE ////////////////////
class Aiguille {
private:
byte index; // 0.. MaxAIG-1
boolean etat=true; // directe (true) ou deviee false)
Zone* zone; // la Zone ou est l'aiguille
public:
Aiguille(byte a_index, Zone* z) { // constructeur
index = a_index;
zone=z;
}
boolean directer() { // commande de l'aiguille en position directe
this->etat=true;
output.id = 0x40;
output.length = 1;
output.data.bytes[0] = this->index + 0xC0;
Can0.sendFrame(output);
return true;
}
boolean devier() { // commande de l'aiguille en position déviée
this->etat=false;
output.id = 0x40;
output.length = 1;
output.data.bytes[0] = this->index + 0x80;
Can0.sendFrame(output);
return true;
}
boolean directe() { // demande d'état
return this->etat;
} // méthode utilitaire};
};
////////////////// PROTOTYPE CLASSE ZONE ////////////////////
class Zone {
public:
byte index; // 0.. MaxZone-1
boolean etat; // libre ou occupé
Signal* signalPair;
Signal* signalImpair; // les signaux éventuels de la zone
Zone(byte a_index, Signal* sp, Signal* si) { // constructeur
index = a_index;
signalPair=sp;
signalImpair=si; }
virtual Zone* suivantePaire() { return NULL; } // la zone suivante paire (éventuellement vide)
virtual Zone* suivanteImpaire() { return NULL; } // la zone suivante impaire (éventuellement vide)
virtual void actions() {} // les actions spécifiques à faire en cas d'occupation
virtual void desactions() {} // les actions spécifiques à faire en cas de libération
boolean occupee() { return etat; } // méthode utilitaire
boolean libre() { return !etat; } // méthode utilitaire
void occuper() { // appelée par la rétrosignalisation
// fait tout ce qu'il y a à faire en cas d'occupation (actions communes à toutes les zones)
actions(); // fait les actions spécifiques à une zone
}
void liberer() { // appelée par la rétrosignalisation
// fait tout ce qu'il y a à faire en cas de libération (actions communes à toutes les zones)
desactions(); // fait les actions spécifiques à une zone
}
Zone* selonAiguille(Aiguille* a,Zone* z1,Zone* z2) { return a->directe()?z1:z2; } // méthode utilitaire
};
////////////// HERITAGES CLASSES ZONES REELLES ////////////////////
// les zones reelles (héritages de Zone)
// 0 gare base loisirs (pair/droite= 1 impair/gauche=0=butoir)
class Z0 : public Zone { // 0 gare base loisirs (pair/droite= 1 impair/gauche=0=butoir)
public:
Z0(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
virtual Zone* suivantePaire();
virtual Zone* suivanteImpaire();
};
// 1 VV centre (pair/droite=2, impair/gauche=0)
class Z1 : public Zone { // 1 VV centre (pair/droite=2, impair/gauche=0)
public:
Z1(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
virtual Zone* suivantePaire();
virtual Zone* suivanteImpaire();
};
// 2 liaison VV-Hor (pair/droite=3siPdroite, impair/gauche=1+aiguillePdevié=4)
class Z2 : public Zone {
public:
Z2(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
virtual Zone* suivantePaire();
virtual Zone* suivanteImpaire();
};
// 3 gare centre (droite/pair=3=butoir, gauche/impair=2)
class Z3 : public Zone {
public:
Z3(byte ai, Signal* sp, Signal* si):Zone(ai,sp,si) {}
virtual Zone* suivantePaire();
virtual Zone* suivanteImpaire();
};
etc…
/////////////////// DECLARATIONS ZONES ////////////////////
// zones
Zone* z0=new Z0(0,NULL,s2);
Zone* z1=new Z1(1,NULL,s2);
Zone* z2=new Z2(2,NULL,NULL);
Zone* z3=new Z3(3,s2,NULL);
Zone* z4=new Z4(4,s2,c2);
Zone* z5=new Z5(5,s2,c2);
Zone* z6=new Z6(6,s2,c2);
Zone* z7=new Z7(7,s2,c2);
Zone* z8=new Z8(8,s2,c2);
Zone* z9=new Z9(9,s2,c2);
etc…
const int MaxZone = 40;
Zone* listez[MaxZone]= {
z0, z1, z2, z3, z4, z5, z6, z7, z8, z9, z10, z11, z12, z13, z14, z15,
z16, z17, z18, z19, z20, z21, z22, z23, z24, z25, z26, z27, z28, z29, z30,
z31, z32, z33, z34, z35, z36, z37, z38, z39
};
/////////////////// DECLARATIONS AIGUILLES ////////////////////
// aiguilles
Aiguille* a0=new Aiguille(0,z26); //A
Aiguille* a1=new Aiguille(1,z26); //B
Aiguille* a2=new Aiguille(2,z15); //C
Aiguille* a3=new Aiguille(3,z26); //D
Aiguille* a4=new Aiguille(4,z15); //E
Aiguille* a5=new Aiguille(5,z14); //F
Aiguille* a6=new Aiguille(6,z14); //G
Aiguille* a7=new Aiguille(7,z12); //H
Aiguille* a8=new Aiguille(8,z12); //I
Aiguille* a9=new Aiguille(9,z29); //J
Aiguille* a10=new Aiguille(10,z38); //K
Aiguille* a11=new Aiguille(11,z29); //L
Aiguille* a12=new Aiguille(12,z39); //M
Aiguille* a13=new Aiguille(13,z6); //N
Aiguille* a14=new Aiguille(14,z35); //O
Aiguille* a15=new Aiguille(15,z2); //P
Aiguille* a16=new Aiguille(16,z4); //Q
Aiguille* a17=new Aiguille(17,z17); //R
Aiguille* a18=new Aiguille(18,z24); //S
Aiguille* a19=new Aiguille(19,z37); //T TJD demi a5 vers deviation
Aiguille* a20=new Aiguille(20,z37); //U TJD demi a6 vers deviation
const int MaxAig = 21;
Aiguille* listea[MaxAig]= {
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20
};
selonAiguille(Aiguille* a,Zone* z1,Zone* z2) { return a->directe()?z1:z2; } ///////////////////// METHODES PARTICULIERES DES ZONES ///////////////////////
// les methodes des zones
// Z0 gare base loisirs (pair/droite= z1 impair/gauche=butoir)
Zone* Z0::suivantePaire() { return z1; }
Zone* Z0::suivanteImpaire() { return NULL; }
// 1 VV centre (pair/droite=2, impair/gauche=0)
Zone* Z1::suivantePaire() { return z2; }
Zone* Z1::suivanteImpaire() { return z0; }
// 2 liaison VV-Hor (pair/droite=3, impair/gauche=1+aiguillePdevié=4)
Zone* Z2::suivantePaire() { return selonAiguille(a15,z3,NULL); }
Zone* Z2::suivanteImpaire() { return selonAiguille(a15,z1,selonAiguille(a16,NULL,z4)); }
// 3 gare centre (droite/pair=3=butoir, gauche/impair=2)
Zone* Z3::suivantePaire() { return NULL; }
Zone* Z3::suivanteImpaire() { return z2; }
// 4 GC Hor Ext (pair=6+aiguilleQdevié=2, impair=17)
Zone* Z4::suivantePaire() { return selonAiguille(a16,selonAiguille(a13,NULL,z7),selonAiguille(a15,NULL,z3)); }
Zone* Z4::suivanteImpaire() { return selonAiguille(a17,NULL,z16); }
// 5 GC Hor Int (pair=6, impair=17)
Zone* Z5::suivantePaire() { return selonAiguille(a13,z7,NULL); }
Zone* Z5::suivanteImpaire() { return selonAiguille(a17,z16,NULL); }
// 6 sortie GC Hor (pair=7, impair=5+aiguilleNdevié=4) - Normalement pas utilisé
Zone* Z6::suivantePaire() { return z7; }
Zone* Z6::suivanteImpaire() { return selonAiguille(a13,z5,selonAiguille(a16,z4,NULL)); }
etc..
zonedepart = 5;
Show("5 ");
zindex = 5;
for (int i=0; i<10; i++) {
zt = senstrain? listez[zindex]->suivantePaire() : listez[zindex]->suivanteImpaire();
if (zt == NULL) break;
zindex = zt->index;
tft.print(zindex);
tft.print(" ");
}
PRS1_DB1 v0.1 du 11 mars 2016
Toutes les aiguilles sont droites
aiguilles 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
> > A 0
aiguilles 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
> I 13
Itineraires sens horaire a partir de 13->15->16->17->5->6->7->8->9->10->11->12->13->boucle
> I 13 <
Itineraires sens trigo a partir de 13->12->11->10->9->8->7->6->5->17->16->15->13->boucle
> I 40
Itineraires sens horaire a partir de 40->0->1->2->3->41->fin
// 0 gare quai droit (zone paire = z2 si a0 droite, impaire = z5 si a1 droite)
Zone* Z0::suivantePaire() { return selonAiguille(a0,z2,NULL); }
Zone* Z0::suivanteImpaire() { return selonAiguille(a1,z5,NULL); }
/* si on accepte de passer les aiguilles en entrant par un talon, quelle que soit leur position
* alors on peut définir ces methodes comme :
* Zone* Z0::suivantePaire() { return z2; }
* Zone* Z0::suivanteImpaire() { return z5; }
*/
// 1 gare quai gauche (zone paire = z2 si a0 deviée, impaire = z5 si a0 déviée)
Zone* Z1::suivantePaire() { return selonAiguille(a0,NULL,z2); }
Zone* Z1::suivanteImpaire() { return selonAiguille(a1,NULL,z5); }
/* si on accepte de passer les aiguilles en entrant par un talon, quelle que soit leur position
* alors on peut définir ces methodes comme :
* Zone* Z1::suivantePaire() { return z2; }
* Zone* Z1::suivanteImpaire() { return z5; }
*/
// 2 aiguille a0 (zone paire = z3, impaire = z0 si a0 droite ou z1 si a0 deviée)
Zone* Z2::suivantePaire() { return z3; }
Zone* Z2::suivanteImpaire() { return selonAiguille(a0,z0,z1); }
// 3 boucle est (zone paire = z4, impaire = z2)
Zone* Z3::suivantePaire() { return z4; }
Zone* Z3::suivanteImpaire() { return z2; }
// 4 boucle ouest (zone paire = z5, impaire = z3)
Zone* Z4::suivantePaire() { return z5; }
Zone* Z4::suivanteImpaire() { return z3; }
// 5 aiguille a1 (zone paire = z0 si a1 droite ou z1 si a1 déviée, impaire = z4)
Zone* Z5::suivantePaire() { return selonAiguille(a1,z0,z1); }
Zone* Z5::suivanteImpaire() { return z4; }
suivantePaire() et suivanteImpaire() des objets Zone.Effectivement, je me demandais aussi où était vraiment décrite la topologie du réseau.
J'attends donc avec impatience le 4ème article !! ;D
Etape 4 : la modélisation de mon réseau commence maintenant par l’écriture des méthodes particulières « suivantePaire » et « suivanteImpaire »
Ce qui veut dire que la topologie du réseau n'est en fait pas décrite explicitement, malgré cela le gestionnaire fonctionne tout à fait normalement, c'est donc le train lors de ses déplacements qui décrit d'une certaine façon la topologie du réseau ???
Quand on voit comment marche la recherche d'itinéraires, on doit facilement la rendre indépendante de la gestion du réseau proprement dite.
int NO_PORT=0;Bonjour,Bonjour
J'ai réussi a faire fonctionner Locodrome4 en retirant le paramètre "P2D" dans le Setup ligne 49 commande "size(1100,500,P2D); "
size(2560,1600); (en JAVA2D) et on m'a demandé de mettre :size(2560,1600, P2D); (en Processing 2D)2) je n'ai pas encore trouvé de site pour telecharger la version 3.2.3 de Processing qui effectivement semble être un solution
J'ai aussi la version qu'il te faut (116 Mo), via le site grosfichiers, mais j'ai besoin de ton adresse mail...
// 6 sortie GC Hor (pair=7, impair=5+aiguilleNdevié=4)
class Z6 : public Zone {
public:
Z6(int n,Signal* sp,Signal* si):Zone(n,sp,si) {}// constructeur
virtual Zone* suivantePaire();
virtual Zone* suivanteImpaire();
virtual void actions();
virtual void desactions();
};
class S5:public SemaphoreBAL {
public:
S5(int n):SemaphoreBAL(n) {} // constructeur mini
virtual Signal* suivant();
virtual Signal* precedent();
virtual boolean cantonOccupe();
};
class CRR3:public CarreAvertissementRappelRalentissement {
public:
CRR3(int n):CarreAvertissementRappelRalentissement(n) {} // constructeur mini
virtual Signal* suivant();
virtual Signal* precedent();
virtual boolean ralentissement30();
};
class CV1:public CarreViolet {
public:
CV1(int n):CarreViolet(n) {} // constructeur mini
virtual Signal* suivant();
virtual Signal* precedent();
};
//X27a30 = de z27 à z30 avec Carré C1
class X27a30:public Itineraire {
public:
X27a30(int n):Itineraire(n) {}
virtual boolean formable();
virtual void former();
virtual boolean deformable();
virtual void deformer();
virtual void tracer(boolean b);
};
// declarations des objets réels
SignalBAL* s1=new S1(0);
SignalBAL* s2=new S2(1);
SignalBAL* s3=new S3(2);
SignalBAL* sr4=new SR4(3);
SignalBAL* s5=new S5(4);
SignalBAL* s6=new S6(5);
SignalBAL* s7=new S7(6);
SignalBAL* sr8=new SR8(7);
Signal* c1=new C1(8);
Signal* c2=new C2(9);
Signal* c4=new C4(10);
Signal* crr2=new CRR2(11);
Signal* crr4=new CRR4(12);
Signal* c3=new C3(13);
Signal* c5=new C5(14);
Signal* c6=new C6(15);
Signal* c7=new C7(16);
Signal* c8=new C8(17);
Signal* cr1=new CR1(18);
Signal* cr2=new CR2(19);
Signal* crr1=new CRR1(20);
Signal* crr3=new CRR3(21);
Signal* cv1=new CV1(22);
Signal* cv2=new CV2(23);
Signal* cv3=new CV3(24);
Signal* cv4=new CV4(25);
Signal* cv5=new CV5(26);
Signal* cv6=new CV6(27);
Signal* cv7=new CV7(28);
Signal* cv8=new CV6(29);
#define MaxSignal 30
Signal* tableSignaux[MaxSignal] {s1,s2,s3,sr4,s5,s6,s7,sr8,c1,c2,c4,crr2,crr4,c3,c5,c6,
c7,c8,cr1,cr2,crr1,crr3,cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8}; // la table des signaux
/////////////////// DECLARATIONS des ZONES ////////////////////
Zone* z0=new Z0(0,NULL,NULL); // n° / signal-pair / signal-impair
Zone* z1=new Z1(1,NULL,NULL);
Zone* z2=new Z2(2,NULL,NULL);
Zone* z3=new Z3(3,NULL,NULL);
Zone* z4=new Z4(4,c7,NULL);
Zone* z5=new Z5(5,c6,NULL);
Zone* z6=new Z6(6,NULL,NULL);
Zone* z7=new Z7(7,s5,NULL);
Zone* z8=new Z8(8,s6,s5);
Zone* z9=new Z9(9,s7,s6);
Zone* z10=new Z10(10,sr8,s7);
Zone* z11=new Z11(11,crr4,sr8);
Zone* z12=new Z12(12,NULL,NULL);
Zone* z13=new Z13(13,c4,c8); // c8 ou NULL ?
Zone* z14=new Z14(14,c5,c5); // c5 ou NULL ?
Zone* z15=new Z15(15,NULL,NULL);
Zone* z16=new Z16(16,crr3,cv5); // cv5 ou NULL ?
Zone* z17=new Z17(17,NULL,NULL);
Zone* z18=new Z18(18,NULL,cv3);
Zone* z19=new Z19(19,NULL,NULL);
Zone* z20=new Z20(20,NULL,NULL);
Zone* z21=new Z21(21,NULL,NULL);
Zone* z22=new Z22(22,NULL,cr1);
Zone* z23=new Z23(23,NULL,cr2);
Zone* z24=new Z24(24,NULL,NULL);
Zone* z25=new Z25(25,NULL,crr2);
Zone* z26=new Z26(26,NULL,NULL);
Zone* z27=new Z27(27,NULL,c1);
Zone* z28=new Z28(28,cv1,c2);
Zone* z29=new Z29(29,NULL,NULL);
Zone* z30=new Z30(30,cv6,s1);
Zone* z31=new Z31(31,s1,s2);
Zone* z32=new Z32(32,s2,s3);
Zone* z33=new Z33(33,s3,sr4);
Zone* z34=new Z34(34,sr4,crr1);
Zone* z35=new Z35(35,NULL,NULL);
Zone* z36=new Z36(36,NULL,cv2);
Zone* z37=new Z37(37,cv7,cv8);
Zone* z38=new Z38(38,cv4,NULL);
Zone* z39=new Z39(39,NULL,NULL);
Zone* z40=new Z40(40,NULL,NULL);
Zone* z41=new Z41(41,NULL,NULL);
Zone* z42=new Z42(42,NULL,NULL);
Zone* z43=new Z43(43,NULL,NULL);
Zone* z44=new Z44(44,NULL,NULL);
Zone* z45=new Z45(45,NULL,NULL);
Zone* z46=new Z46(46,NULL,NULL);
#define MaxZone 47
Zone* tableZones[MaxZone]= { // liste des pointeurs de zone pour la retrosignalisation
z0, z1, z2, z3, z4, z5, z6, z7, z8, z9, z10, z11, z12, z13, z14, z15,
z16, z17, z18, z19, z20, z21, z22, z23, z24, z25, z26, z27, z28, z29, z30,
z31, z32, z33, z34, z35, z36, z37, z38, z39, z40, z41, z42, z43, z44, z45, z46 };
/////////////////// DECLARATIONS des AIGUILLES ////////////////////
Aiguille* a0=new Aiguille(0,z26); //dans z26
Aiguille* a1=new Aiguille(1,z26); //dans z26
Aiguille* a2=new Aiguille(2,z15); //dans z15
Aiguille* a3=new Aiguille(3,z44); //dans z44
Aiguille* a4=new Aiguille(4,z15); //dans z15
Aiguille* a5=new Aiguille(5,z42); //dans z42
Aiguille* a6=new Aiguille(6,z43); //dans z43
Aiguille* a7=new Aiguille(7,z12); //dans z12
Aiguille* a8=new Aiguille(8,z12); //dans z12
Aiguille* a9=new Aiguille(9,z29); //dans z29
Aiguille* a10=new Aiguille(10,z38); //dans z38
Aiguille* a11=new Aiguille(11,z29); //dans z29
Aiguille* a12=new Aiguille(12,z38); //dans z38
Aiguille* a13=new Aiguille(13,z39); //dans z39
Aiguille* a14=new Aiguille(14,z35); //dans z35
Aiguille* a15=new Aiguille(15,z2); //dans z2
Aiguille* a16=new Aiguille(16,z6); //dans z6
Aiguille* a17=new Aiguille(17,z17); //dans z17
Aiguille* a18=new Aiguille(18,z24); //dans z24
Aiguille* a19=new Aiguille(19,z45); //dans z45 coté pair
Aiguille* a20=new Aiguille(20,z46); //dans z46 coté impair
#define MaxAig 21
Aiguille* tableAiguilles[MaxAig]= {
a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20 };
/////////////////
Itineraire *x4a7=new X4a7(0);
Itineraire *x5a7=new X5a7(1);
Itineraire *x7a11=new X7a11(2);
Itineraire *x11a13=new X11a13(3);
Itineraire *x11a14=new X11a14(4);
Itineraire *x13a16=new X13a16(5);
Itineraire *x14a16=new X14a16(6);
Itineraire *x16a4=new X16a4(7);
Itineraire *x16a5=new X16a5(8);
Itineraire *x22a25=new X22a25(9);
Itineraire *x23a25=new X23a25(10);
Itineraire *x25a27=new X25a27(11);
Itineraire *x25a28=new X25a28(12);
Itineraire *x27a30=new X27a30(13);
Itineraire *x28a30=new X28a30(14);
Itineraire *x30a34=new X30a34(15);
Itineraire *x34a22=new X34a22(16);
Itineraire *x34a23=new X34a23(17);
Itineraire *x28a36=new X28a36(18);
Itineraire *x36a28=new X36a28(19);
Itineraire *x14a18=new X14a18(20);
Itineraire *x18a14=new X18a14(21);
Itineraire *x14a38=new X14a38(22);
Itineraire *x38a14=new X38a14(23);
Itineraire *x13a30=new X13a30(24);
Itineraire *x14a30=new X14a30(25);
Itineraire *x25a13=new X25a13(26);
Itineraire *x25a14=new X25a14(27);
Itineraire *x14a11=new X14a11(28);
Itineraire *x13a11=new X13a11(29);
Itineraire *x16a13=new X16a13(30);
Itineraire *x16a14=new X16a14(31);
Itineraire *x30a27=new X30a27(32);
Itineraire *x30a28=new X30a28(33);
Itineraire *x4a3=new X4a3(34);
Itineraire *x3a4=new X3a4(35);
Itineraire *x3a1=new X3a1(36);
Itineraire *x30a13=new X30a13(37);
Itineraire *x30a14=new X30a14(38);
Itineraire *x37a18=new X37a18(39);
Itineraire *x18a37=new X18a37(40);
Itineraire *x37a38=new X37a38(41);
Itineraire *x38a37=new X38a37(42);
#define MaxItineraire 43
Itineraire* tableItineraires[MaxItineraire] {
x4a7,x5a7,x7a11,x11a13,x11a14,x13a16,x14a16,x16a4,x16a5,x22a25,
x23a25,x25a27,x25a28,x27a30,x28a30,x30a34,x34a22,x34a23,x28a36,x36a28,
x14a18,x18a14,x14a38,x38a14,x13a30,x14a30,x25a13,x25a14,x14a11,x13a11,
x16a13,x16a14,x30a27,x30a28,x4a3,x3a4,x3a1,x30a13,x30a14,x37a18,x18a37,x37a38,x38a37}; // la table des itineraires pour tco
Zone* Z12::suivantePaire() { return selonAiguille(a7,z13,selonAiguille(a6,NULL,z43)); }
Zone* Z12::suivanteImpaire() { return selonAiguille(a8,z11,selonAiguille(a11,NULL,z29)); } // !! changement de sens sur z30
void Z12::actions() { aubiner(crr4,c8,c6); }
void Z12::desactions() { detruire(x11a13,x13a11,x11a14,x14a11);detruire(x13a30,x30a13,x14a30,x30a14); }Signal* CRR2::suivant() { return selonAiguille(a0,selonAiguille(a1,c1,selonAiguille(a3,NULL,c2)),selonAiguille(a2,NULL,selonAiguille(a4,c8,c4))); }
Signal* CRR2::precedent() { return selonAiguille(a18,cr1,cr2); }
boolean CRR2::ralentissement30() { return a1->deviee()?true:false; }
boolean X4a7::formable() { return libres(x4a7,x3a4,x4a3,x5a7) && libres(z6,z7,z39); }
void X4a7::former() { a16->directer(); a13->devier(); c7->ouvrir(); }
boolean X4a7::deformable() { return libres(z4,z6,z39); }
void X4a7::deformer() { c7->fermer(); }
void X4a7::tracer(boolean b) { trace(b,z4,z6,z39);z7->tracer(b); }// commandes du TCO, des aiguilles et des signaux
// ne sert que pour l'interface avec le TCO virtuel
/////////////////////////////////////////////////////////////////////////////
enum {CODE_AIGUILLE,CODE_ZONE,CODE_SIGNAL,CODE_CARRE,
CODE_BOUTON,CODE_BOUTON_CLI,CODE_ERREUR,CODE_INFO,CODE_CAB,CODE_MEM,CODE_TRAIN};
void tco(byte c,byte x,byte n) { byte buf[3]; // code numero info
if (TCO) { buf[0]=c; buf[1]=n; buf[2]=x; Serial.write(buf,3); return; }
switch(c) { // mise en forme pour affichage sur le moniteur serie
case CODE_AIGUILLE: Serial.print('A'); break; // manoeuvre aiguille
case CODE_ZONE: Serial.print('Z'); break; // coloration zone (sur tco)
case CODE_SIGNAL: Serial.print('S'); break; // manoeuvre signal (semaphore)
case CODE_CARRE: Serial.print('C'); break; // manoeuvre signal (carre)
case CODE_BOUTON: Serial.print('B'); break; // coloration bouton (sur tco)
case CODE_BOUTON_CLI: Serial.print('b'); break; // coloration bouton clignotant (sur tco)
case CODE_ERREUR: Serial.print('E'); break; // erreur
case CODE_INFO: Serial.print('I'); break; // info
case CODE_CAB: Serial.print('s'); break; // cabsignal
case CODE_MEM: Serial.print('M'); break; // memoire RAM disponible (borne a 4095)
case CODE_TRAIN: Serial.print('T'); break; // suivi des trains
default: Serial.print('?');
}
Serial.print(n);
if (c==CODE_ERREUR || c==CODE_INFO) return;
Serial.print('=');
if (c==CODE_AIGUILLE) { if (x) Serial.print('/'); else Serial.print('|'); }
else { //Serial.println(x);
switch(x) { // mise en forme des couleurs
case COULEUR_GRISE: Serial.print('G'); break;
case COULEUR_ROUGE: Serial.print('R'); break;
case COULEUR_BLANCHE: Serial.print('B'); break;
case COULEUR_JAUNE: Serial.print('J'); break;
case COULEUR_VERTE: Serial.print('V'); break;
case COULEUR_ROSE: Serial.print('r'); break;
default: Serial.print('?');
}
}
Serial.print(' ');
}
void loop() { Itineraire* it; char code=0;
if (Serial.available()>=1) { // test si retrosignalisation ou commande
code=Serial.read();
if (!TCO) { Serial.println(); Serial.print(code); Serial.print(':'); Serial.print(' '); }
if (code=='X') { // commande de reinitialisation
reset();
}
if (code>='0' && code <='8') { // commande d'itineraire
it=tableItineraires[code-'0'];
if (it->enAttente()) it->effacer(); else // destruction
if (it->libre()) it->formation(); else // essai de formation
if (it->forme()) it->destruction(); // essai de destruction
if (!TCO && it->enAttente()) Serial.print('m');
}
if (code>='A' && code <='F') { // occupation zone (retrosignalisation)
tableZones[code-'A']->occuper();
}
if (code>='a' && code <='f') { // liberation zone (retrosignalisation)
tableZones[code-'a']->liberer();
}
if (code=='s') train1->invSens();
if (code=='S') train2->invSens();
code=0; return;
}
// test itineraires en attente
for (int i=0; i<MaxItineraire; i++) {
it=tableItineraires[i];
if (it->enAttente()) {
if (!TCO && it->formable()) { Serial.println('('); Serial.println(i); Serial.print(')'); Serial.print(':'); Serial.print(' '); }
if (it->formable()) it->formation();
}
}
} // fin loopvoid execCode(int c) {
int code = c;
Itineraire* it;
///////////////// TRAITEMENT ITINERAIRE ////////////
if (code>=0 && code <MaxItineraire) { // commande d'itineraire
it=tableItineraires[code];
if (it->enAttente()) it->effacer(); else // destruction
if (it->libre()) it->formation(); else // essai de formation
if (it->forme()) it->destruction(); // essai de destruction
if (!TCO && it->enAttente()) Serial.print('m');
}
///////////////// TRAITEMENT OCCUPATION ////////////
if (code>=100 && code <100+MaxZone) { // occupation zone (retrosignalisation)
tableZones[code-100]->occuper();
}
///////////////// TRAITEMENT LIBERATION ////////////
if (code>=200 && code <200+MaxZone) { // liberation zone (retrosignalisation)
tableZones[code-200]->liberer();
}
///////////////// INVERSION DE SENS ////////////
if (code==300) train1->invSens();
if (code==301) train2->invSens();
return;
} 0 A13=/R E46Z4= Z6= Z39= Z7= B0=B
4 A7=/R A6=/R C11=? C6=? Z11= Z12= Z43= Z14= B4=B
104 E202Z4=
106 E46T6=? Z6=
139 T39=? Z39=
107 T7=? Z7=
204 T4=G Z4=
206 Z4= Z6= B0=G T6=G Z6=
239 T39=G Z39=
108 C3=V T8=? Z8=
207 T7=G Z7=
109 C4=V T9=? Z9=
208 C3=B T8=G Z8=
110 C5=V T10=? Z10=
209 C4=B C3=R T9=G Z9=
111 C6=V T11=? Z11=
210 C5=B C4=R T10=G Z10=
112 C11=? T12=? Z12=
143 T43=? Z43=
114 T14=? Z14=
211 C6=B C5=R T11=G Z11=
212 Z11= Z12= B4=G T12=G Z12=
243 T43=G Z43=
6 A5=/R A4=/R C13=B Z42= Z15= Z16= B6=B
Je n'y ai jamais bien réfléchi, mais les boucles de retournement posent-elles un problème pour le déplacement des trains sur le locodrome ?