Modélisation logicielle d'un réseau - le système de Jean-Luc

[savignyexpress]

Bonjour Jean-Luc,

Après avoir à nouveau parcouru les descriptions des modèles de Pierre, Denis et le tien, il me vient une question concernant les trains.

Il faut bien qu'à un moment ou un autre, le système ait une représentation des trains et de leur progression sur le réseau, synchronisée par les détecteurs d'occupation. Ma question est donc: comment les trains sont-ils modélisés ?

En pleine réflexion sur ce sujet pour mon 2ème petit réseau en N, je pense créer une classe Train et l'instancier pour chaque train présent sur le réseau. Charge ensuite aux objets de parcourir les itinéraires.

Peut-être que ma question est superflue si c'est déjà expliqué quelque part et que j'ai manqué ce point.

Merci pour tout ce partage.
Meilleures salutations.

Marc-Henri

[Pierre59]

Bonjour

Normalement la progression des trains est matérialisée sur le TCO par la coloration (en rouge) des zones où est le train (avec décoloration quand le train quitte une zone. C'est la rétrosignalisation qui fournit les occupation et libérations de zones. C'est le système de base, pas besoin d'objet train.

Si on veut faire en plus du suivi des trains (pour savoir quel train est dans quelle zone), il faut bien entendu un objet train (qui reste petit dans ce cas là).

Il est très pratique de pouvoir faire circuler sur le TCO des trains virtuels (comme sur le Locodrome), pour faire de la mise au point (TCO et gestionnaire), pour tester un réseau avant de le construire ou tout simplement pour jouer sans réseau. Dans ce cas l'objet train est assez conséquent.

L'idéal serait de pouvoir visualiser des trains sur le TCO synchronisés avec les trains réels, c'est à dire déplacer les trains virtuels sur le TCO en fonction des déplacements des trains réels. C'est assez délicat mais on y travaille.

Cordialement

Pierre

[Jean-Luc]

Il faut bien qu'à un moment ou un autre, le système ait une représentation des trains et de leur progression sur le réseau, synchronisée par les détecteurs d'occupation. Ma question est donc: comment les trains sont-ils modélisés ?

Bonjour Marc-Henri

Effectivement il est nécessaire d’avoir une représentation des trains. Dans ce qui est présenté ici on a juste le graphe du réseau et la recherche de chemin mais, pour l’instant, pas de liaison avec la detection d’occupation où les trains. Je suis en train de refaire sous forme de bibliothèque et de l’enrichir mais comme j’ai d’autres projets en cours, ce n’est pas pour tout de suite.

En plus de ce qui est présenté je pense ajouter : l’information occupé mis à jour via la détection d’occupation ; Les Block et les UniBlock, portion de rail où un train peut s’arrêter et munis d’une detection de pleine voie et de zone d’arrêt ; La notion d’ensemble d’occupation : détection partagée par plusieurs éléments de voies, typiquement les zones d’aiguilles. En plus du graphe d’éléments de voies, on a un graphe d’occupation de plus forte granularité.

Les Trains qui se baladent sur le graphe d’occupation. Un Train possède une direction de marche et une liste doublement chaînée de pointeurs vers les nœuds contigus du graphe d’occupation, nœuds qu’il occupe. La tête de liste est la tête du train si le train a la direction de marche normale. Si le train est dans la direction de marche inverse, la tête de liste est la queue de train.

(La suite plus tard, je dois filer  )

[Dominique]

Il en trouve 26 et 2 impossibles.
Mais je n'ai pas compris lesquels ... 

Je m'explique :

1) je te fournis le plan de ton reseau avec ma numerotation (celle du programme TCO et de SGDD).

2) Je te fournis aussi le programme Arduino de Jean-Luc, avec la version ton reseau.
Celui-la, tu peux le telle verser sur un Arduino DUE et voir ce qu'il donne.

L'onglet Specifs.h est la description, "comme Jean-Luc" cette fois, de ton reseau.

Pour t'aider je te joins aussi le fichier tansform.txt qui est la traduction numerotation DD -> numerotation JLB.
(numerotation DD = 1000+numerotation DD du plan pour que tout soit bien aligne)
Ce fichier ne sert à rien d'autre qu’a nous aider, pauvres humains 
Il est quand meme genere par l'ordi, sans intervention humaine.

En retirant les // pour voir les taches, tu verras comment travaille le programme de Jean-Luc.
Et tu comprendras ma reponse du debut 

Merci à Jean-Luc et Denis, ma convalescence va me permettre de comprendre cette notion de connecteurs. Je vais commencer par mettre à jour le circuit suite aux dernières modifications... l’année dernière !

[Dominique]

C'est parti !

J'ai repris le schéma de mon réseau que je joins ici : les aiguilles ne changent pas de numéro (a0 à a20), par contre les zones z0 à z41 changent de nom VOIE_0 à VOIE_30. Certaines de ces VOIES sont déclarées en VOIE_GARAGE avec le numéro indiqué sur le schéma.



On voit que j'en ai perdu au passage : toutes les zones contenant une ou plusieurs aiguilles ne sont plus déclarées car remplacées par les aiguilles AIGUILLE_0 à AIGUILLE_20.

Ce qui me donne les identifiants suivants pour tout le réseau :

Code: [Sélectionner]

/*
 Indentifiants du reseau
 */
enum {
    /* voies */
    VOIE_0,
    VOIE_1,
    VOIE_2,
    VOIE_3,
    VOIE_4,
    VOIE_5,
    VOIE_6,
    VOIE_7,
    VOIE_8,
    VOIE_9,
    VOIE_GARAGE_10,
    VOIE_GARAGE_11,
    VOIE_GARAGE_12,
    VOIE_GARAGE_13,
    VOIE_14,
    VOIE_GARAGE_15,
    VOIE_16,
    VOIE_17,
    VOIE_18,
    VOIE_19,
    VOIE_20,
    VOIE_21,
    VOIE_22,
    VOIE_23,
    VOIE_24,
    VOIE_25,
    VOIE_GARAGE_26,
    VOIE_27,
    VOIE_28,
    VOIE_29,
    VOIE_GARAGE_30,
    /* aiguille */
    AIGUILLE_0,
    AIGUILLE_1,
    AIGUILLE_2,
    AIGUILLE_3,
    AIGUILLE_4,
    AIGUILLE_5,
    AIGUILLE_6,
    AIGUILLE_7,
    AIGUILLE_8,
    AIGUILLE_9,
    AIGUILLE_10,
    AIGUILLE_11,
    AIGUILLE_12,
    AIGUILLE_13,
    AIGUILLE_14,
    AIGUILLE_15,
    AIGUILLE_16,
    AIGUILLE_17,
    AIGUILLE_18,
    AIGUILLE_19,
    AIGUILLE_20, //52 elements
    /* Valeur speciale */
    AUCUNE_VOIE
};
Comme les sens de circulation normaux sont indiqués par les flèches, j'ai voulu déclarer les connexions entre les noeuds en suivant le sens de ces flèches.

Comme il y a une circulation interieure dans le sens trigo et une circulation extérieure dans le sens horaire, je tombe sur une petite difficulté pour connecter les aiguilles 0 et 2 à gauche de la gare et 8 et 11 à droite de la gare :

Code: [Sélectionner]

/*
     * Connexions des voies
     */
    // metro
    voieGarage30.connecteAVoie(voie29, ENTRANT);
    voie29.connecteSortantAVoie(voie28, ENTRANT);
    voie28.connecteSortantAVoie(aiguille15, SORTANT_DROIT);
    aiguille15.connecteEntrantAVoie(voie27, ENTRANT);
    voie27.connecteSortantAVoie(voieGarage26, SORTANT);
    // voie circulaire exterieure
    voie4.connecteSortantAVoie(aiguille16, ENTRANT);
    aiguille16.connecteSortantDevieAVoie(aiguille15, SORTANT_DEVIE);
    aiguille16.connecteSortantDroitAVoie(aiguille13, SORTANT_DEVIE);
    voie3.connecteSortantAVoie(aiguille13, SORTANT_DROIT);   
    aiguille13.connecteEntrantAVoie(voie5, ENTRANT);   
    voie5.connecteSortantAVoie(voie6, ENTRANT);
    voie6.connecteSortantAVoie(voie7, ENTRANT);
    voie7.connecteSortantAVoie(voie8, ENTRANT);
    voie8.connecteSortantAVoie(voie9, ENTRANT);
    voie9.connecteSortantAVoie(aiguille8, SORTANT_DROIT);
    aiguille8.connecteEntrantAVoie(aiguille7, ENTRANT);
    aiguille7.connecteSortantDroitAVoie(voie0, ENTRANT);
    aiguille7.connecteSortantDevieAVoie(aiguille6, SORTANT_DEVIE);
    aiguille6.connecteEntrantAVoie(voie1, ENTRANT);
    voie0.connecteSortantAVoie(aiguille4, SORTANT_DROIT);
    voie1.connecteSortantAVoie(aiguille5, ENTRANT);
    aiguille5.connecteSortantDevieAVoie(aiguille4, SORTANT_DEVIE);
    aiguille4.connecteEntrantAVoie(aiguille2, ENTRANT);
    aiguille2.connecteSortantDroitAVoie(voie2, ENTRANT);
    voie2.connecteSortantAVoie(aiguille17, ENTRANT);
    aiguille17.connecteSortantDevieAVoie(voie4, ENTRANT);
    aiguille17.connecteSortantDroitAVoie(voie3, ENTRANT);
    // voie circulaire interieure   
    voie23.connecteSortantAVoie(aiguille18, SORTANT_DROIT);
    voie24.connecteSortantAVoie(aiguille18, SORTANT_DEVIE);
    aiguille18.connecteEntrantAVoie(voie25, ENTRANT);
    voie25.connecteSortantAVoie(aiguille0, ENTRANT);
    aiguille0.connecteSortantDroitAVoie(aiguille1, ENTRANT);
    aiguille1.connecteSortantDroitAVoie(voie16, ENTRANT);
    aiguille1.connecteSortantDevieAVoie(aiguille3, SORTANT_DEVIE);
    voieGarage15.connecteAVoie(aiguille3, SORTANT_DROIT);
    aiguille3.connecteEntrantAVoie(voie17, ENTRANT);
    voie16.connecteSortantAVoie(aiguille9, SORTANT_DROIT);
    voie17.connecteSortantAVoie(aiguille9, SORTANT_DEVIE);
    aiguille9.connecteEntrantAVoie(aiguille11, SORTANT_DROIT);
    aiguille11.connecteEntrantAVoie(voie18, ENTRANT);   
    voie18.connecteSortantAVoie(voie19, ENTRANT);
    voie19.connecteSortantAVoie(voie20, ENTRANT);
    voie20.connecteSortantAVoie(voie21, ENTRANT);
    voie21.connecteSortantAVoie(voie22, ENTRANT);
    voie22.connecteSortantAVoie(aiguille14, ENTRANT);
    aiguille14.connecteSortantDroitAVoie(voie23, ENTRANT);
    aiguille14.connecteSortantDevieAVoie(voie24, ENTRANT);   
    // depot
    voieGarage11.connecteAVoie(aiguille12, SORTANT_DROIT);
    voieGarage12.connecteAVoie(aiguille12, SORTANT_DEVIE);
    voieGarage13.connecteAVoie(aiguille10, SORTANT_DEVIE);
    aiguille12.connecteEntrantAVoie(aiguille10, SORTANT_DROIT);
    aiguille10.connecteEntrantAVoie(aiguille20, ENTRANT);
    aiguille20.connecteSortantDroitAVoie(aiguille6, SORTANT_DROIT);
    aiguille20.connecteSortantDevieAVoie(voie14, ENTRANT); 
    voie14.connecteSortantAVoie(aiguille19, SORTANT_DEVIE);
    aiguille5.connecteSortantDroitAVoie(aiguille19, SORTANT_DROIT);
    aiguille19.connecteEntrantAVoie(voieGarage10, SORTANT);
    // passages voies interieurs <-> exterieures
    aiguille0.connecteSortantDevieAVoie(aiguille2, SORTANT_DEVIE);   
    aiguille8.connecteSortantDevieAVoie(aiguille11, SORTANT_DEVIE);
Au lancement du programme, le moniteur affiche 2 anomalies :

Code: [Sélectionner]

Direction deja fixee : AIGUILLE_2
Direction deja fixee : AIGUILLE_8
Nombre de voies : 52

Peut-être devrais-je déclarer les connexions autrement

En tout cas tous les tests d'itinéraires fonctionnent (je déclare sur le moniteur une voie de départ et une voie d'arrivée et le programme affiche le résultat). exemple :

Code: [Sélectionner]

De VOIE_1 a VOIE_GARAGE_26
VOIE_1 VOIE_2 VOIE_4 VOIE_GARAGE_26 VOIE_27 AIGUILLE_2 AIGUILLE_4 AIGUILLE_5 AIGUILLE_15 AIGUILLE_16 AIGUILLE_17

De VOIE_1 a VOIE_3
VOIE_1 VOIE_2 VOIE_3 AIGUILLE_2 AIGUILLE_4 AIGUILLE_5 AIGUILLE_17

[Jean-Luc]

Au lancement du programme, le moniteur affiche 2 anomalies :

Code: [Sélectionner]

Direction deja fixee : AIGUILLE_2
Direction deja fixee : AIGUILLE_8
Nombre de voies : 52


Les connexions doivent être faites selon une seule direction une fois celle-ci choisie. Tu pars d'un élément et tu tournes dans une seule direction. Il ne faut pas en changer entre le circuit extérieur et intérieur.

Quand tu écris :

Code: [Sélectionner]

    aiguille4.connecteEntrantAVoie(aiguille2, ENTRANT);

La direction de aiguille2 est fixée à DIRECTION_AVANT et celle de aiguille4 à DIRECTION_ARRIERE

Ensuite quand tu écris

Code: [Sélectionner]

aiguille0.connecteSortantDevieAVoie(aiguille2, SORTANT_DEVIE);

Tu tentes de fixer la direction d'aiguille2 à DIRECTION_ARRIERE

D'où le message d'erreur

[Dominique]

Merci Jean-Luc,

Cela a pour conséquence que je ne peux pas décrire les 2 boucles en sens inverse l’une de l’autre, à partir du moment où il y a une liaison entre les deux.

Donc sur une boucle un train circulera en marche avant et sur l’autre boucle un autre train circulera en marche arrière.

[Jean-Luc]

L'orientation du graphe de ton réseau n'a rien à voir avec le sens de circulation normal des trains.

[Dominique]

Voilà, j'ai repris la description, toujours dans le sens horaire et l'erreur n'apparait plus.

Je joins le programme complet avec une trace qui montre comment le programme explore le réseau, c'est très intéressant 

Pour tester il faut entrer au moniteur d'abord le numéro de la voie de départ (ou voie de garage), puis ENTER, puis le numéro de la voie d'arrivée, puis ENTER.

Exemple : On voit bien les retours à l'aiguille précédente pour tester l'autre coté !

Code: [Sélectionner]

Depart VOIE_GARAGE_11 Arrivee VOIE_GARAGE_15
VOIE_GARAGE_11
    AIGUILLE_12
        AIGUILLE_10
            AIGUILLE_20
                AIGUILLE_6
                    VOIE_1
                        AIGUILLE_5
                            AIGUILLE_19
                                VOIE_GARAGE_10
                            AIGUILLE_4
                                AIGUILLE_2
                                    VOIE_2
                                        AIGUILLE_17
                                            VOIE_3
                                                AIGUILLE_13
                                                    VOIE_5
                                                        VOIE_6
                                                            VOIE_7
                                                                VOIE_8
                                                                    VOIE_9
                                                                        AIGUILLE_8
                                                                            AIGUILLE_7
                                                                                VOIE_0
                                                                                    AIGUILLE_4
                                                                                AIGUILLE_6
                                            VOIE_4
                                                AIGUILLE_16
                                                    AIGUILLE_13
                                                    AIGUILLE_15
                                                        VOIE_27
                                                            VOIE_GARAGE_26
                                    AIGUILLE_0
                                        VOIE_25
                                            AIGUILLE_18
                                                VOIE_23
                                                    AIGUILLE_14
                                                        VOIE_22
                                                            VOIE_21
                                                                VOIE_20
                                                                    VOIE_19
                                                                        VOIE_18
                                                                            AIGUILLE_11
                                                                                AIGUILLE_9
                                                                                    VOIE_16
                                                                                        AIGUILLE_1
                                                                                            AIGUILLE_0
                                                                                    VOIE_17
                                                                                        AIGUILLE_3
                                                                                            VOIE_GARAGE_15

Bon, j'ai 2 ans de retard sur Denis mais je me prépare pour la suite ...

Amicalement
Dominique

[DDEFF]

Bravo Dominique !
Je suis content que tu te sois frotté au problème des itinéraires, liés au fait qu'il faut bien décrire le réseau d'une manière ou d'une autre.

La méthode de Jean-Luc est basée sur une remarque "simple" : ce que les modélistes appellent un réseau est pour les mathématiciens un graphe.
Depuis Léonard Euler (1707-1783) et les ponts de Königsberg, on connait la puissance des graphes, avec leurs nœuds et leurs arcs qu'on peut parcourir de différentes façons
De nombreuses recherches (depuis 300 ans !), des bibliothèques pour différents langages : il y a de la matière.
L'autre intérêt de son programme, c'est la gestion très subtile de la place mémoire.
Ce que j'en ai retenu de fondamental, c'est la notion de connecteur, extrêmement puissante.

J'ai (aussi) utilisé cette méthode, avec quelque subtilités supplémentaires :
1°) Je n'ai pas de liste des départs ou des arrivées. On part de n'importe quel signal vers n'importe quel signal.
2°) On peut effacer l'itinéraire en plein milieu (si on s'arrête) et en changer. Et même changer de sens à ce moment.
3°) On peut chaîner les itinéraires automatiquement

Donc, Dominique, tu es sur la bonne voie 

PS : j'ai fini ma nouvelle mouture de mon éditeur (1300 lignes en moins) et il reste quelques bugs sur la nouvelle mouture du gestionnaire, avec une loco. Bientôt sur le forum.
PPS : si on m'avait dit un jour que je caserai les ponts de Königsberg sur Locoduino, je ne l'aurais jamais cru.

[Pierre59]

Les itinéraires pas si faciles que cela en a l'air.

Avec une bonne représentation de la topologie d'un réseau il est assez facile de trouver des chemins entre une voie d'origine et une voie de destination. Avec toutefois deux problèmes classiques :

- en général il y a plusieurs chemins possibles (sur des réseaux pas trop simples) et il faut faire un choix

- il faut éviter les bouclages (beaucoup de nos réseaux sont en boucle)

Un chemin n'est pas forcement un itinéraire. A la SNCF un itinéraire part d'une voie avec un signal CARRE, dans le sens du signal, pour aller vers une voie répertoriée comme fin d'un itinéraire (voies à quai, voies de départ ou d'arrivée, voies de garage, tiroirs, …), voie qui n'a pas forcément de signal. Il faut aussi que toutes les voies empruntées par l'itinéraire soient parcourables dans le sens de l'itinéraire.

Un itinéraire tel que défini précédemment ne sert pas à grand chose, il faut pouvoir l'établir et aussi le détruire. L'établissement nécessite deux phases :

- vérification que l'itinéraire est établissable (vérification des enclanchements)
- établissement effectif de l'itinéraire (manoeuvre des aiguilles et des signaux)

Pour qu'un itinéraire soit établissable plusieurs conditions sont nécessaires :

- pas de cisaillement ou de nez à nez avec d'autres itinéraires déja établis
- en transit rigide toutes les zones de l'itinéraire doivent êtres libres
- en transit souple des zones peuvent êtres occupées, mais les signaux doivent pouvoir présenter le sémaphore
- la zone de la voie d'arrivée doit être libre (pas de train), sinon il faut que le signal à l'origine de l'itinéraire puisse présenter un feu manoeuvre (blanc lunaire)

Si l'itinéraire est établissable alors il faut manoeuvrer les aiguilles, puis ouvrir le ou les signaux en présentant les bons feux.

Un itinéraire est détruit automatiquement par le passage d'un train, mais il doit pouvoir être détruit manuellement sous conditions :

- pas d'enclanchement d'approche (train ayant vu l'avertissement du carré ouvert)
- pas de zones occupées (pas de train dessus)

Il peut être pratique de pouvoir enregistrer les itinéraires non établissables (voire de les sur-enregistrer).

Certains appareils de voie (TJD, TJS, aiguille triple ou croisement) peuvent compliquer la définition de la topologie du réseau ainsi que l'établissement des itinéraires.

Cordialement

Pierre