Bonjour à tous,
Voici la suite du programme de contrôle de mon réseau. Avant de décrire les classes, commençons par le programme principal qui me permettra d'illustrer les principes mis en oeuvre.
//
// Reseau_hivernal.ino
//
// 2019.02.15 Création.
#include <stdint.h>
#include "Affichage.h"
#include "Aiguilles.h"
#include "Boutons.h"
#include "ChefDeGare.h"
#include "GareCachee.h"
#include "Hardware.h"
#include "Itineraire.h"
#include "LED.h"
#include "Signal.h"
#include "Tache.h"
#include "Zone.h"
#define PER_CLIGN 250
LED led_board (LED_BOARD, PER_CLIGN);
Affichage affichage;
Boutons boutons;
Modes selMode;
Aiguilles aiguilles;
#ifdef DEBUG_ZONE
Zone zoneL1 (L1_DET, DELAI_ENTREE_LIGNE, DELAI_SORTIE_LIGNE, "Ligne 1");
Zone zoneL2 (L2_DET, DELAI_ENTREE_LIGNE, DELAI_SORTIE_LIGNE, "Ligne 2");
Zone zoneG1 (G1_DET, DELAI_ENTREE_GARE, DELAI_SORTIE_GARE, "Gare 1");
Zone zoneG2 (G2_DET, DELAI_ENTREE_GARE, DELAI_SORTIE_GARE, "Gare 2");
Zone zoneGC1G (GC1G_DET, 0, DELAI_SORTIE_GARE_CACHEE, "Gare cachée 1G");
Zone zoneGC1D (GC1D_DET, 0, DELAI_SORTIE_GARE_CACHEE, "Gare cachée 1D");
Zone zoneGC2G (GC2G_DET, 0, DELAI_SORTIE_GARE_CACHEE, "Gare cachée 2G");
Zone zoneGC2D (GC2D_DET, 0, DELAI_SORTIE_GARE_CACHEE, "Gare cachée 2D");
#else
Zone zoneL1 (L1_DET, DELAI_ENTREE_LIGNE, DELAI_SORTIE_LIGNE);
Zone zoneL2 (L2_DET, DELAI_ENTREE_LIGNE, DELAI_SORTIE_LIGNE);
Zone zoneG1 (G1_DET, DELAI_ENTREE_GARE, DELAI_SORTIE_GARE);
Zone zoneG2 (G2_DET, DELAI_ENTREE_GARE, DELAI_SORTIE_GARE);
Zone zoneGC1G (GC1G_DET, 0, DELAI_SORTIE_GARE_CACHEE);
Zone zoneGC1D (GC1D_DET, 0, DELAI_SORTIE_GARE_CACHEE);
Zone zoneGC2G (GC2G_DET, 0, DELAI_SORTIE_GARE_CACHEE);
Zone zoneGC2D (GC2D_DET, 0, DELAI_SORTIE_GARE_CACHEE);
#endif
VoieGareCachee voieGC1 (GC1_ABC, &zoneGC1G, &zoneGC1D);
VoieGareCachee voieGC2 (GC2_ABC, &zoneGC2G, &zoneGC2D);
GareCachee gareCachee (&aiguilles, &affichage, &voieGC1, &voieGC2, &zoneL1, &zoneL2);
Signal sigA1 (&aiguilles, C_A1, &zoneL1, SIG_A1_ROUGE, SIG_A1_ORANGE, SIG_A1_VERT);
Signal sigA2 (&aiguilles, C_A2, &zoneL2, SIG_A2_ROUGE, SIG_A2_ORANGE, SIG_A2_VERT);
VoieGare voieG1 (G1_ABC, &zoneG1);
VoieGare voieG2 (G2_ABC, &zoneG2);
#ifdef DEBUG_ITIN
ItinGareVersCachee it_G1_GC_Gauche (&zoneL2, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_GAUCHE, C_A2, DEVIE, POUS_A2_DEV, "Itinéraire G1 GC gauche");
ItinGareVersCachee it_G2_GC_Gauche (&zoneL2, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_GAUCHE, C_A2, NORMAL, POUS_A2_NORM, "Itinéraire G2 GC gauche");
ItinGareVersCachee it_G1_GC_Droite (&zoneL1, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_DROITE, C_A1, DEVIE, POUS_A1_DEV, "Itinéraire G1 GC droite");
ItinGareVersCachee it_G2_GC_Droite (&zoneL1, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_DROITE, C_A1, NORMAL, POUS_A1_NORM, "Itinéraire G2 GC droite");
ItinCacheeVersGare it_GC_G1_Gauche (&zoneL1, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_GAUCHE, C_A1, DEVIE, POUS_A1_DEV, "Itinéraire GC G1 gauche");
ItinCacheeVersGare it_GC_G2_Gauche (&zoneL1, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_GAUCHE, C_A1, NORMAL, POUS_A1_NORM, "Itinéraire GC G2 gauche");
ItinCacheeVersGare it_GC_G1_Droite (&zoneL2, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_DROITE, C_A2, DEVIE, POUS_A2_DEV, "Itinéraire GC G1 droite");
ItinCacheeVersGare it_GC_G2_Droite (&zoneL2, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_DROITE, C_A2, NORMAL, POUS_A2_NORM, "Itinéraire GC G2 droite");
#else
ItinGareVersCachee it_G1_GC_Gauche (&zoneL2, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_GAUCHE, C_A2, DEVIE, POUS_A2_DEV);
ItinGareVersCachee it_G2_GC_Gauche (&zoneL2, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_GAUCHE, C_A2, NORMAL, POUS_A2_NORM);
ItinGareVersCachee it_G1_GC_Droite (&zoneL1, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_DROITE, C_A1, DEVIE, POUS_A1_DEV);
ItinGareVersCachee it_G2_GC_Droite (&zoneL1, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_DROITE, C_A1, NORMAL, POUS_A1_NORM);
ItinCacheeVersGare it_GC_G1_Gauche (&zoneL1, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_GAUCHE, C_A1, DEVIE, POUS_A1_DEV);
ItinCacheeVersGare it_GC_G2_Gauche (&zoneL1, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_GAUCHE, C_A1, NORMAL, POUS_A1_NORM);
ItinCacheeVersGare it_GC_G1_Droite (&zoneL2, &aiguilles, &gareCachee, &voieG1, &voieG2, SENS_DROITE, C_A2, DEVIE, POUS_A2_DEV);
ItinCacheeVersGare it_GC_G2_Droite (&zoneL2, &aiguilles, &gareCachee, &voieG2, &voieG1, SENS_DROITE, C_A2, NORMAL, POUS_A2_NORM);
#endif
Itineraire *apItin[NB_ITIN] = {
&it_G1_GC_Gauche,
&it_G2_GC_Gauche,
&it_G1_GC_Droite,
&it_G2_GC_Droite,
&it_GC_G1_Gauche,
&it_GC_G2_Gauche,
&it_GC_G1_Droite,
&it_GC_G2_Droite
};
ChefDeGare chef (&aiguilles, &gareCachee, &affichage, &selMode, &boutons, &voieG1, &voieG2, apItin);
void setup() {
#ifdef DEBUG
delay (2000);
Serial.begin (115200);
Serial.println ("*** DEBUG ***");
#endif
Tache::setupTaches ();
led_board.clignoter ();
gareCachee.rafraichirLcd ();
} // setup
void loop() {
Tache::loopTaches ();
} // loop
- Toutes les classes sont définies dans des fichiers séparés, raison de la multitude d'includes.
- Tous les objets sont instanciés dans le programme principal par de simples déclarations.
- Si un objet a besoin d'appeler les méthodes d'un autre, il le fait à partir d'un pointeur lors de l'appel de son constructeur. Par exemple, le constructeur VoieGareCahee reçoit 2 pointeurs vers les 2 objets de la classe Zone qui constituent une voie de gare cachée. Le lien cité dans le 1er post de cette série utilise des références, mais cela ne fonctionne pas pour tous les cas de figure, notamment pour passer un tableau d'objets à un autre objet. J'ai donc préféré les pointeurs plus souples d'emploi.
- Les constructeurs des classes Zone et Itineraire existent en 2 versions, selon que l'on souhaite activer le mode debug ou non. En mode debug, on peut ainsi passer une chaîne de caractères identifiant l'instance de l'objet. Comme il me reste en encore assez de RAM, je n'ai pas utilisé la directive PROGMEM permettant de placer ces chaînes en mémoire programme.
- La fonction setup enclenche le mode debug, appelle toutes les méthodes virtuelles setup des objets, puis effectue l'initialisation de la led clignotante et de l'affichage LCD, ces 2 objets ayant besoin d'une initialisation en plus du setup pour des questions de synchronisation au démarrage.
- La fonction loop ne fait qu'appeler toutes les méthodes virtuelles loop des objets.
Le mode debugJ'ai regroupé tous les
#define liés au matériel, ceux d'usage général ainsi que ceux qui enclenchent le mode debug dans le fichier
Hardware.h.
// Debug.
//#define DEBUG_BOUTONS_AN
//#define DEBUG_BOUTONS_STATE
//#define DEBUG_MAIN_LOOP
//#define DEBUG_BOUTONS_ROT
//#define DEBUG_ZONE
//#define DEBUG_GC
//#define DEBUG_AIG
//#define DEBUG_AIG_DEM
//#define DEBUG_LCD
//#define DEBUG_CHEF
//#define DEBUG_ITIN
#define DEBUG (defined DEBUG_MAIN_LOOP || defined DEBUG_BOUTONS_AN || defined DEBUG_BOUTONS_STATE || defined DEBUG_BOUTONS_ROT || \
defined DEBUG_ZONE || defined DEBUG_GC || defined DEBUG_AIG || defined DEBUG_AIG_DEM) || defined DEBUG_LCD || defined DEBUG_CHEF || \
defined DEBUG_ITIN
Chaque instruction
#define DEBUG_XXX peut être décommentée pour permettre d'enclencher le mode debug de la classe correspondante. La dernière instruction
#define DEBUG ... teste si au-moins un des autres
#define DEBUG_XXX est défini. Ainsi, le programme principal peut initialiser la liaison série.
Classe ZoneLe réseau comporte 8 zones de détection: 4 en gare cachée, 2 en gare, 2 en lignes. Les états de l'automate de cette classe sont:
- E_LIBRE: la zone est libre.
- E_ENTREE: un train entre dans la zone sans réservation préalable.
- E_OCCUPEE: un train occupe la zone sans réservation préalable.
- E_RESERVEE_G: la zone est réservée pour un train tournant dans le sens inverse des aiguilles d'une montre.
- E_RESERVEE_D: la zone est réservée pour un train tournant dans le sens des aiguilles d'une montre.
- E_ENTREE_G: un train entre dans la zone dans le sens inverse des aiguilles d'une montre.
- E_ENTREE_D: un train entre dans la zone dans le sens des aiguilles d'une montre.
- E_OCCUPEE_G: un train occupe la zone dans le sens inverse des aiguilles d'une montre.
- E_OCCUPEE_D: un train occupe la zone dans le sens des aiguilles d'une montre.
Le graphe d'états correspondant est:
La réservation préalable des zones est utilisée par les itinéraires. Cela permet de protéger les zones de ligne à voie unique et de déterminer dans quel sens les trains sont en gare. La gare cachée dont les voies comportent 2 zones de détection permettant de déterminer le sens des trains n'a pas besoin de la réservation.
class Zone: public Tache
{
public:
#ifdef DEBUG_ZONE
Zone (uint8_t xPin, uint32_t nxDelaiEntree, uint32_t nxDelaiSortie, const char sxNom[]);
#else
Zone (uint8_t xPin, uint32_t nxDelaiEntree, uint32_t nxDelaiSortie);
#endif
void setup ();
void loop ();
uint8_t bLibre (void);
uint8_t bOccupee (void);
uint8_t bOccupee (uint8_t exSens);
uint8_t bReservee (void);
uint8_t bReservee (uint8_t exSens);
uint8_t bEtatStable (void);
void reserver (uint8_t exSens);
private:
const uint8_t Pin;
const uint32_t nDelaiEntree, nDelaiSortie;
uint32_t tDebut;
#ifdef DEBUG_ZONE
char sNom[32];
#endif
uint8_t eEtat;
};
#include "Hardware.h"
#include "Zone.h"
#define E_LIBRE 0
#define E_RESERVE_G 1
#define E_RESERVE_D 2
#define E_ENTREE_G 3
#define E_ENTREE_D 4
#define E_OCCUPEE_G 5
#define E_OCCUPEE_D 6
#define E_ENTREE 7
#define E_OCCUPEE 8
#ifdef DEBUG_ZONE
Zone::Zone (uint8_t xPin, uint32_t nxDelaiEntree, uint32_t nxDelaiSortie, const char sxNom[]) : Pin (xPin), nDelaiEntree (nxDelaiEntree), nDelaiSortie (nxDelaiSortie)
{
strcpy (sNom, sxNom);
} // Zone::Zone
#else
Zone::Zone (uint8_t xPin, uint32_t nxDelaiEntree, uint32_t nxDelaiSortie) : Pin (xPin), nDelaiEntree (nxDelaiEntree), nDelaiSortie (nxDelaiSortie) {};
#endif
void Zone::setup ()
{
pinMode (Pin, INPUT_PULLUP);
eEtat = E_LIBRE;
} // Zone::setup
void Zone::loop ()
{
uint8_t bCapteur;
bCapteur = digitalRead (Pin);
switch (eEtat)
{
case E_LIBRE:
// Zone initialement libre, train détecté sans réservation préalable.
if (bCapteur == LOW)
{
tDebut = millis ();
eEtat = E_ENTREE;
} // if
break;
case E_ENTREE:
if ((millis () - tDebut) > nDelaiEntree)
{
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": occupée");
#endif
tDebut = millis ();
eEtat = E_OCCUPEE;
} // if
break;
case E_RESERVE_G:
// Zone libre, mais réservée pour un train tournant à gauche.
if (bCapteur == LOW)
{
tDebut = millis ();
eEtat = E_ENTREE_G;
} // if
break;
case E_ENTREE_G:
if ((millis () - tDebut) > nDelaiEntree)
{
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": occupée G");
#endif
tDebut = millis ();
eEtat = E_OCCUPEE_G;
} // if
break;
case E_RESERVE_D:
// Zone libre, mais réservée pour un train tournant à droite.
if (bCapteur == LOW)
{
tDebut = millis ();
eEtat = E_ENTREE_D;
} // if
break;
case E_ENTREE_D:
if ((millis () - tDebut) > nDelaiEntree)
{
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": occupée D");
#endif
tDebut = millis ();
eEtat = E_OCCUPEE_D;
} // if
break;
// Ces 3 états peuvent être traités de la même manière.
case E_OCCUPEE_G:
case E_OCCUPEE_D:
case E_OCCUPEE:
// Si le train est toujours présent, reset du timer.
if (bCapteur == LOW)
{
tDebut = millis ();
}
else if ((millis () - tDebut) > nDelaiSortie)
{
// Plus de train.
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": libre");
#endif
eEtat = E_LIBRE;
} // if
break;
} // switch
} // Zone::loop
uint8_t Zone::bLibre (void)
{
return (eEtat == E_LIBRE);
} // Zone::bLibre
uint8_t Zone::bOccupee (void)
{
return ((eEtat == E_OCCUPEE) || (eEtat == E_OCCUPEE_G) || (eEtat == E_OCCUPEE_D));
} // Zone::setup
uint8_t Zone::bOccupee (uint8_t exSens)
{
return (
((exSens == SENS_GAUCHE) && (eEtat == E_OCCUPEE_G)) ||
((exSens == SENS_DROITE) && (eEtat == E_OCCUPEE_D))
);
} // Zone::bOccupee
uint8_t Zone::bReservee (void)
{
return (
(eEtat == E_RESERVE_G) || (eEtat == E_RESERVE_D)
);
} // Zone::bReservee
uint8_t Zone::bReservee (uint8_t exSens)
{
return (
((exSens == SENS_GAUCHE) && (eEtat == E_RESERVE_G)) ||
((exSens == SENS_DROITE) && (eEtat == E_RESERVE_D))
);
} // Zone::bReservee
uint8_t Zone::bEtatStable (void)
{
// La zone ne doit pas être dans un état où un train entre,
// risque de conflit avec le train sortant.
return (
(eEtat != E_ENTREE) &&
(eEtat != E_ENTREE_G) &&
(eEtat != E_ENTREE_D)
);
} // Zone::bEtatStable
void Zone::reserver (uint8_t exSens)
{
if (eEtat == E_LIBRE)
{
if (exSens == SENS_GAUCHE)
{
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": réservée G");
#endif
eEtat = E_RESERVE_G;
}
else if (exSens == SENS_DROITE)
{
#ifdef DEBUG_ZONE
Serial.print (sNom);
Serial.println (": réservée D");
#endif
eEtat = E_RESERVE_D;
} // if
} // if
} // Zone::reserver
La logique de l'automate est répartie entre la méthode
loop et les méthodes publiques appelées par les autres objets. Comme toutes les autres classes, celle-ci hérite de la classe
Tache.
Cette classe comporte 2 valeurs de timeout qui sont utilisées comme suit:
- nDelaiEntree: pour la transition des états E_ENTREE... vers les états E_OCCUPEE....
- nDelaiSortie: pour la transition des états E_OCUPEE... vers l'état E_LIBRE. C'est en particulier ce timeout qui permet de gérer la détection mono alternance du signal DCC.
Ces timeouts permettent également de gérer l'absence de détection sur les derniers wagons des trains, seules les locos sont détectées.
Voir les contributions
