LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

jeudi 25 mai 2017

48 visiteurs en ce moment

Gestion d’une gare cachée (3)

Remplissage et vidange

. Par : Jean-Luc

Dans « Gestion d’une gare cachée (2) » nous avons posé les bases d’une conception objet pour notre gare cachée. Cette conception est fondée sur un graphe où chaque nœud est un élément de voie. Nous avons développé un algorithme de parcours exhaustif de ce graphe pour trouver, tout en déterminant la position des aiguilles, une voie de la gare cachée. Toutefois, il nous manque un algorithme pour trouver une voie libre et pour trouver une voie occupée. Nous allons maintenant ajouter ces deux algorithmes.

Le premier algorithme que nous allons ajouter est très proche de celui que nous avons développé dans le précédent article. Seul le critère de sélection de la voie en gare change. Au lieu de chercher une voie possédant l’identifiant voulu, nous allons chercher une voie libre. Le second algorithme recherchera aléatoirement une voie occupée dans la gare. Il nous faut donc ajouter une variable membre booléenne dans la classe VoieGare que nous appellerons libre. Cette variable sera initialisée à true car nous supposons qu’au démarrage du système la gare cachée est entièrement vide. La classe VoieGare devient donc :

  1. /*
  2.  * Classe pour les voies de gare
  3.  */
  4. class VoieGare : public Voie
  5. {
  6. private:
  7. bool mLibre;
  8.  
  9. public:
  10. VoieGare(byte identifiant) : Voie(identifiant) { mLibre = true; }
  11. virtual bool creeCheminVers(byte identifiant);
  12. };

Il nous reste maintenant à écrire nos deux algorithmes.

Trouver une voie libre

Nous allons non seulement la trouver mais établir au passage les positions des aiguilles qui permettent d’y amener un train. Tout d’abord, il faut ajouter une fonction membre virtuelle dans la classe de base. Cette fonction membre, creeCheminVersLibre retourne un identifiant de voie, donc un byte [1]. Elle retournera un identifiant de voie si une voie libre est trouvée et son chemin établi, et l’identifiant spécial AUCUNE_VOIE si toutes les voies sont occupées.

  1. /*
  2.  * Classe de base des éléments de voie
  3.  *
  4.  * Fonctions virtuelles de recherche de chemin et identifiant
  5.  */
  6. class Voie
  7. {
  8. private:
  9. byte mIdentifiant;
  10.  
  11. public:
  12. Voie(byte identifiant) { mIdentifiant = identifiant; }
  13. byte idVoie() { return mIdentifiant; }
  14. virtual bool creeCheminVers(byte identifiant) = 0;
  15. virtual byte creeCheminVersLibre() = 0;
  16. };

Pour une voie de la gare, creeCheminVersLibre va simplement retourner l’identifiant de la voie si cette voie est libre, ou AUCUNE_VOIE si cette voie est occupée, mais nous allons également en profiter pour afficher l’identifiant de la voie si elle est trouvée libre afin de tester le système et également de passer mLibre à false puisqu’il s’agit maintenant d’occuper cette voie.

  1. byte VoieGare::creeCheminVersLibre()
  2. {
  3. if (mLibre) {
  4. Serial.print(F("Occupation de : "));
  5. afficheVoie(idVoie());
  6. Serial.println();
  7. mLibre = false;
  8. return idVoie();
  9. }
  10. else {
  11. return AUCUNE_VOIE;
  12. }
  13. }

Un aiguillage demandera aux deux voies qui lui sont connectées, droite et déviée, si elle est libre. On commencera par la connexion droite. Si une voie libre est trouvée, les aiguilles sont positionnées en conséquence. C’est très similaire à la fonction creeCheminVers.

  1. byte Aiguillage::creeCheminVersLibre()
  2. {
  3. byte voie;
  4. if (mVoieDroite != NULL && mVoieDeviee != NULL) {
  5. /* Uniquement si correctement connecte */
  6. /* Cherche la destination cote voie droite */
  7. voie = mVoieDroite->creeCheminVersLibre();
  8. if (voie != AUCUNE_VOIE) {
  9. /* Destination trouvee cote droit */
  10. afficheVoie(idVoie());
  11. Serial.println(F(": Droit"));
  12. return voie;
  13. }
  14. else {
  15. /* Cherche la destination cote voie deviee */
  16. voie = mVoieDeviee->creeCheminVersLibre();
  17. if (voie != AUCUNE_VOIE) {
  18. /* destination trouvee cote devie */
  19. afficheVoie(idVoie());
  20. Serial.println(F(": Devie"));
  21. return voie;
  22. }
  23. else {
  24. /* destination non trouvee */
  25. return AUCUNE_VOIE;
  26. }
  27. }
  28. }
  29. }

Enfin, la voie d’entrée se contente de demander à la voie qui lui est connectée si elle elle libre, la demande se propageant le long du graphe jusqu’à une voie de gare.

  1. byte VoieExtreme::creeCheminVersLibre()
  2. {
  3. if (mVoie != NULL) {
  4. return mVoie->creeCheminVersLibre();
  5. }
  6. }

Nous pouvons maintenant tester notre programme. Le test est simple, on ajoute des trains dans la gare jusqu’à ce qu’elle soit pleine. Pour cela nous ajoutons une fonction de test qui affiche en clair si une voie libre est trouvée.

  1. void testLibre()
  2. {
  3. if (voieEntree.creeCheminVersLibre() != AUCUNE_VOIE)
  4. Serial.println(F("TROUVE"));
  5. else
  6. Serial.println(F("NON TROUVE"));
  7. }

Il faut également compléter la fonction d’affichage du nom d’une voie en clair. Nous n’y avions mis que les aiguillages, il faut maintenant afficher le nom des voies de la gare.

  1. case VOIE_GARE_0:
  2. Serial.print("Voie gare 0"); break;
  3. case VOIE_GARE_1:
  4. Serial.print("Voie gare 1"); break;
  5. case VOIE_GARE_2:
  6. Serial.print("Voie gare 2"); break;
  7. case VOIE_GARE_3:
  8. Serial.print("Voie gare 3"); break;

Enfin nous ajoutons la séquence de test à la fin de setup

  1. Serial.println("***** TEST de chemin vers libre");
  2. testLibre();
  3. testLibre();
  4. testLibre();
  5. testLibre();
  6. testLibre();

Comme notre gare a quatre voies, les quatre premiers appels à testLibre trouveront une voie et le dernier échouera. On a bien le résultat escompté :

***** TEST de chemin vers libre
Occupation de : Voie gare 0
Aiguillage E0: Droit
TROUVE
Occupation de : Voie gare 3
Aiguillage E2: Droit
Aiguillage E1: Droit
Aiguillage E0: Devie
TROUVE
Occupation de : Voie gare 2
Aiguillage E2: Devie
Aiguillage E1: Droit
Aiguillage E0: Devie
TROUVE
Occupation de : Voie gare 1
Aiguillage E1: Devie
Aiguillage E0: Devie
TROUVE
NON TROUVE

Sélectionner un train

Pour extraire un train de la gare, nous pourrions procéder de la même manière en inversant le critère de sélection. Au lieu de chercher une voie libre, nous chercherions une voie occupée. Mais, l’ordre de recherche d’une voie étant toujours le même, cette façon de faire conduirait à une circulation uniforme.

Au lieu de cela, nous allons sélectionner une voie de gare occupée aléatoirement. Il nous manque pour cela un moyen de savoir si une voie est occupée. En effet, la variable membre libre est privée. Nous ajoutons une fonction membre occupee à la classe VoieGare qui retourne true si la voie est occupée.

  1. bool occupee() { return ! mLibre; }

Et nous écrivons une fonction qui sélectionne aléatoirement une voie occupée. Il faut tout d’abord recenser les voies occupées. Le plus simple est de parcourir chacune des 4 voies de la gare et, si elle est occupée, ajouter son identifiant dans un tableau. Appelons ce tableau voiesOccupees. Ensuite, connaissant le nombre de voies occupées, nous tirons un nombre aléatoire entre 0 et ce nombre - 1 afin de sélectionner la voie occupée. Pour en savoir plus sur l’aléatoire, vous pouvez lire l’article « Comment gérer l’aléatoire ? » [2]. Le plus simple est également que les voies de la gare soient dans un tableau, nous en profitons pour mettre le nombre de voies dans une constante :

  1. const int TAILLE_GARE = 4;
  2.  
  3. VoieGare voieGare[TAILLE_GARE] = {
  4. VoieGare(VOIE_GARE_0),
  5. VoieGare(VOIE_GARE_1),
  6. VoieGare(VOIE_GARE_2),
  7. VoieGare(VOIE_GARE_3)
  8. };

Il faut également faire attention au fait que la gare peut être entièrement vide. Dans ce cas, le tableau des voies occupées sera vide et nous serons dans l’incapacité de retourner un identifiant de voie. Pour cela, nous ajoutons un identifiant spécial nomme AUCUNE_VOIE. Nous retournerons cet identifiant si aucune voie n’est occupée. Voici cette fonction que nous appellerons selectionneTrain :

  1. /*
  2.  * Sélectionne aléatoirement un des trains des voies occupées
  3.  */
  4. byte selectionneTrain()
  5. {
  6. byte voiesOccupees[TAILLE_GARE];
  7. byte indexVoieOccupee = 0;
  8. /* Parcoure les voies de la gare */
  9. for (byte indexVoieGare = 0; indexVoieGare < TAILLE_GARE; indexVoieGare++) {
  10. if (voieGare[indexVoieGare].occupee()) {
  11. /* Une voie occupee est trouvée, on ajoute son identifiant à notre tableau */
  12. voiesOccupees[indexVoieOccupee++] = voieGare[indexVoieGare].idVoie();
  13. }
  14. }
  15. if (indexVoieOccupee > 0) {
  16. /* Au moins une voie occupée a été trouvée */
  17. /* Tire au hasard une voie occupée */
  18. byte voie = random(0, indexVoieOccupee);
  19. /* et retourne la voie */
  20. return voiesOccupees[voie];
  21. }
  22. else {
  23. /* la gare est vide ! */
  24. return AUCUNE_VOIE;
  25. }
  26. }

Cette fonction retournant l’identifiant de la voie de gare sur laquelle le train stationne, il suffit ensuite d’appeler creeCheminVers(...) avec comme argument cet identifiant pour manœuvrer les aiguilles et extraire ce train de la gare. Il manque seulement une fonction membre de la classe VoieGare permettant de libérer une voie de la gare une fois que le train est parti. Ajoutons la.

  1. void libere() { mLibre = true; }

Et, enfin, une fonction permettant de parcourir les voies de la gare et de libérer celle dont l’identifiant est passé en argument. Appelons cette fonction libereVoieGare.

  1. void libereVoieGare(byte identifiant)
  2. {
  3. for (byte indexVoieGare = 0; indexVoieGare < TAILLE_GARE; indexVoieGare++) {
  4. if (voieGare[indexVoieGare].idVoie() == identifiant) {
  5. /* La voie d'indentifiant correspondant est trouvée */
  6. voieGare[indexVoieGare].libere();
  7. /* Comme on a trouvé, on sort de la boucle */
  8. break;
  9. }
  10. }
  11. }

Il reste à tester tout cela. À la suite du test de remplissage que nous avons fait ci-dessous, ajoutons un test de vidage aléatoire.

  1. randomSeed(getSeed());
  2. Serial.println("***** TEST de vidange de la gare");
  3. while (true)
  4. {
  5. byte identifiant = selectionneTrain();
  6. if (identifiant != AUCUNE_VOIE) {
  7. Serial.print("Selectionne le train de : ");
  8. afficheVoie(identifiant);
  9. Serial.println();
  10. voieSortie.creeCheminVers(identifiant);
  11. libereVoieGare(identifiant);
  12. }
  13. else {
  14. break;
  15. }
  16. }
  17. Serial.println("TERMINE");

Voici une des sorties possibles de ce test, une des sorties car la vidange étant aléatoire, une autre séquence peut être obtenue.

Selectionne le train de : Voie gare 1
Aiguillage S2: Devie
Aiguillage S1: Droit
Aiguillage S0: Devie
Selectionne le train de : Voie gare 2
Aiguillage S1: Devie
Aiguillage S0: Devie
Selectionne le train de : Voie gare 0
Aiguillage S2: Droit
Aiguillage S1: Droit
Aiguillage S0: Devie
Selectionne le train de : Voie gare 3
Aiguillage S0: Droit
TERMINE

Voici le sketch complet avec tous les tests :

Sketch de gare cachée
Tous les objets et fonctions ainsi que le test.

Nous avons maintenant toutes les structures de données et toutes les fonctions pour gérer notre gare cachée. Notez que c’est directement adaptable à n’importe quelle taille de gare, il suffit de créer les objets correspondant aux éléments de voies, de les connecter et de mettre à jour la constante TAILLE_GARE ainsi que les tests.

Le prochain article traitera des capteurs et des actionneurs que nous allons utiliser.

[1Ceci nous limite à 256 identifiants de voie ce qui est suffisant pour une gare cachée.

[2D’ailleurs, nous intégrons la fonction getSeed() décrite à la fin de cet article.

6 Messages

Réagissez à « Gestion d’une gare cachée (3) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Projets »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

La rétro-signalisation sur Arduino

Décodeur pour aiguillage à solénoïdes sur Arduino

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Les derniers articles

La PWM : Qu’est ce que c’est ? (4)


Jean-Luc

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"


Christian Bézanger

Réalisation d’un affichage de gare ARRIVEE DEPART


Gilbert

Contrôleur à télécommande infrarouge pour centrale DCC++


Daniel

La PWM : Qu’est ce que c’est ? (3)


Jean-Luc

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)


bobyAndCo

Un gestionnaire en C++ pour votre réseau (4)


Pierre59

Un décodeur DCC pour 16 feux tricolores


Dominique, JPClaude, Thierry

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)


bobyAndCo

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)


Dominique

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

La rétro-signalisation sur Arduino

L’Arduino et le système de commande numérique DCC

Une barrière infrarouge

Comment piloter trains et accessoires en DCC avec un Arduino (1)

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Un chenillard de DEL

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un capteur RFID

Comment piloter trains et accessoires en DCC avec un Arduino (3)