Module T-Trak quadruple Hieronymus-Station (Jicébé)

Il reste à placer ces deux lignes de code aux bons endroits.
Pour couper le courant en Z_1, je me propose de le faire quand Z_3 détecte un essieu consommateur de courant.
En se reportant au listing complet, c'est dans la partie où Z_3 déclenche des actions qu'il va falloir le placer :

ce qui donne la partie de code :

Code:

//========== Test de la zone Z_3 =============
   if (trav_Z_3==Pas_FAIT)
         {
              //  Les animations prévues quand le train arrive en Z_3 n'ont pas encore été lancées...
              if (digitalRead(Z_3)==OCCUPE)
                      {
                         // ----------Ici, on lance les animations.
                          digitalWrite(STOP_Z_1, DOIT_STOPPER);
                          trav_Z_3==FAIT;  // les animations pour Z_3 ne pourront pas être relancées
                        }   // ----------Fin de " if (digitalRead(Z_3)==OCCUPE)"

A cet endroit, le test "if (trav_Z_3==Pas_FAIT)" indique que le courant n'a pas encore été coupé en Z_1, et le test " if (digitalRead(Z_3)==OCCUPE)" indique qu'une rame est présente en Z_3, et qu'elle peut donc se passer du courant de Z_1 (en espérant que la loco n'est pas en pousse loin en arrière, pas encore en Z_2, alors que l'essieu détecté servait à alimenter les feux de la voiture-pilote...)

Problème : si l'arduino ne lance pas un contre-ordre, le train stoppé en Z_1 restera bloqué indéfiniment.
Comment résoudre ce problème ?
Suspense... Affaire à suivre, bientôt...

Une fois que la zone Z_1 a été mise à l'arrêt par le cantonnement à mis , il faut pouvoir la libérer .
Cela se fait très simplement en mettant "quelque part" la ligne de code :

Code:

digitalWrite(STOP_Z_1, ROULE);

Il faut le faire quand, et seulement quand, le premier convoi a quitté l'ensemble des zones Z_1 à Z_8.
Un endroit est idéal : la partie des réinitialisations :


Le test rendant vrai quand toutes ces zones sont vides, toutes les instructions comprises entre la paire "accolade ouvrante"/accolade fermante" seront alors exécutées.
ce qui donne :

Code:

  //================================================
  //========== Partie 3 : les réinitialisations ===============
  //================================================

   //========== Remise à Zéro des actions liées aux zones Z1 à Z8 =============
       if (
                  (digitalRead(Z_1)==LIBRE)
            &&(digitalRead(Z_2)==LIBRE)
            &&(digitalRead(Z_3)==LIBRE)
            &&(digitalRead(Z_4)==LIBRE)
            &&(digitalRead(Z_5)==LIBRE)
            &&(digitalRead(Z_6)==LIBRE)
            &&(digitalRead(Z_7)==LIBRE)
            &&(digitalRead(Z_8)==LIBRE)
           )    //   Ce test rend VRAI si toutes les zones sont libres.
 
                {    // ----------Tous les zones sont à LIBRE : la rame est donc passée,
                     //on remet les drapeaux à PAS_FAIT pour autoriser à nouveau les animations.
                     trav_Z_1 = PAS_FAIT;
                     trav_Z_2 = PAS_FAIT;
                     trav_Z_3 = PAS_FAIT;
                     trav_Z_4 = PAS_FAIT;
                     trav_Z_5 = PAS_FAIT;
                     trav_Z_6 = PAS_FAIT;
                     trav_Z_7 = PAS_FAIT;
                     trav_Z_8 = PAS_FAIT;
                     digitalWrite(STOP_Z_1, ROULE);  //feu au vert pour Z_1
                }  //  =======Fin de Remise à Zéro des actions à effectuer=============
 

Il y a néanmoins un problème : dans le mode d'emploi que Viessmann fournit avec son détecteur, il conseille de court-circuiter le relais de coupure par une résistance de 1500 ohms.


C'est généralement une bonne idée, mais dans notre cas particulier, si un deuxième train est présent en Z_1 au moment du test, celui-ci rendra toujours  faux (zone occupée par ce deuxième train) et cette deuxième rame rame restera définitivement bloquée...
Pour éviter cela, il faut, par exemple, effacer tout le code que j'ai barré en rouge.


A suivre...[/code]

[/code]

Gestion manuelle de Z_1

Avoir un arrêt automatique en Z_1 pour le cantonnement est une bonne chose, mais pouvoir forcer manuellement cet arrêt, ou pouvoir passer outre cet arrêt, peut rendre de grands services en cas de problèmes de circulation des rames.
Cela peut se faire facilement à l'aide de deux interrupteurs.

Pour forcer manuellement une rame à l'arrêt en Z_1 :
(Nécessaire par exemple quand une rame (flèche orange) sort de la seconde grotte et se dirige vers la gauche du module, cisaillant la voie interne (flèche verte) pour rejoindre la voie externe du réseau :


Pour cela, il faut choisir un pin libre, par exemple 31, et déclarer dans la partie initialisation qu'il s'agit d'une entré, et non d'une sortie

Code:

pinMode(31,INPUT);

Le câblage de cette partie est plutôt simple : on relie la prise de l'arduino à la masse à travers un interrupteur :

Quand l'interrupteur est fermé, le pin est à l'état bas.
Quand l'interrupteur est ouvert, le pin est à l'état ... ???

Aïe, il semble que le contact soit "en l'air", et donc fluctue au gré des parasites.

Il est donc nécessaire de rajouter une résistance de protection pour le relier au +5V=  pour le forcer à l'état haut.
Mais les concepteurs d'arduino ont prévu cela, gravé dans le silicium, et chaque broche digitale est relié à un +5V interne par un interrupteur interne, en position "ouvert" par défaut.
Donc, le schéma électrique devient, en rajoutant en pointillés cette partie ;

Pour mettre en service cette résistance de rappel, dans le code précédent, il suffit de remplacer "INPUT" par PULLUP", ce qui donne :

Code:

pinMode(31,PULLUP);

Autre avantage, par rapport à un simple interrupteur sur le circuit du courant traction de Z_1, on peut rajouter  autant d'interrupteurs que l'on veut, en parallèle, par exemple un devant et un derrière le module :


Forçage manuel à marche.
Un autre interrupteur, défini par exemple ( s'il est branché sur le PIN 32) par

Code:

pinMode(32,PULLUP);

peut forcer à mettre Z_1 sous tension malgré le cantonnement.
Utile, entre autre, si une rame, loco en pousse, avec sa voiture pilote arrivée en Z_3, déclenche le cantonnement alors que l'engin moteur est encore en Z_1.
Un appui sur l'interrupteur permet le redémarrage de la rame
Par contre, il est prudent d'utiliser seulement des interrupteurs fugitifs (boutons de sonnette), sous peine d'oublier de rétablir l'automatisme du cantonnement.


A suivre : ajout de ces morceaux de code au code complet.

Intégration du fonctionnement des interrupteur dans le logiciel

Zone des bibliothèques (les "includes")
Les interrupteurs n'utilisant aucune bibliothèque, il n'y a donc rien à ajouter dans cette partie.


Zone "dictionnaire de langues" : les "#define"
On y renomme en langage "humain pur" les numéros des pins auxquels sont reliés les interrupteurs,
et les états HIGHT/LOW qu'il indiquent à l'arduino.

Code:

   
    // Les PINs  testant les boutons de forçage de Z_1
    #define STOP_Z_1     31   //  Pour forcer Z_1 à stopper
    #define ROULE_Z_1  32    //  Pour forcer Z_1 à rouler

    //Les valeurs rendues par ces boutons
    #define Force_STOP_Z1  LOW
    #define Force_Roule_Z1  LOW

Comme les tests se feront uniquement sur les états bas, il n'est pas nécessaire de renommer les états haut.

Zone "initialisation" (le "setup ()")
Il faut définir ici le mode de fonctionnement de ces deux pins : ce sont des entrées, et qui utilisent les résistances de rappel interne  pour l'état haut :

Code:

  pinMode(STOP_Z_1,   PULLUP);    // le bouton forçant les rames à s'arrêter.
  pinMode(ROULE_Z_1,PULLUP);    // le bouton forçant les rames à rouler.

Ces pins étant des entrées, il n'y a pas à leur donner une valeur initiale, celle-ci étant imposée par l'état des boutons.

il reste le plus délicat : les ajouts dans la partie "boucle" (le "LOOP()") : prochainement...

Il faut maintenant modifier toutes les lignes de code qui manipulent le relais contrôlant le courant de traction en Z_1.
Il faut donc chercher toutes les lignes qui utilisent l'instruction commençant par "digitalWrite(Z_1".
Les chercher "manuellement" sur l'écran ou sur un listing papier, quand il y beaucoup de lignes de code, est pénible, et avec un risque important d'en rater au moins une.
Mais il y a un outil performant pour faire ce travail : l'éditeur de l’Arduino.
On place le curseur sur le premier caractère, et on clique sur le menu déroulant "Edition->Trouver" :

http://jcbecker.free.fr/Modelisme/Mes_Modules/Hieronymus_Station/Arduino/Programmation/Presse-papier00.jpg
Dans la fenêtre qui s'ouvre, on tape "STOP_Z1", et on clique sur "Trouver"

On est dans la zone des "#define", il n'y a rien à modifier.
On recommence cette procédure "Edition-Trouver" et on arrive sur la ligne ci-dessous, encadrée en rouge, dans les animations encadrées en rouge :

http://jcbecker.free.fr/Modelisme/Mes_Modules/Hieronymus_Station/Arduino/Programmation/Presse-papier01.jpg
Il faut empêcher l'exécution de cette ligne si le bouton forçant à la marche est enfoncé.
Cette ligne est donc remplacée par :

Code:

if (digitalRead(PIN_ROULE_Z_1) != FORCE_ROULE_Z_1)
{
digitalWrite(STOP_Z_1, PEUT_ROULER);
}
else
{
digitalWrite(STOP_Z_1, DOIT_STOPPER_);
}

http://jcbecker.free.fr/Modelisme/Mes_Modules/Hieronymus_Station/Arduino/Programmation/Presse-papier02.jpg

Code:

if(digitalRead(PIN_STOP_Z_1) == FORCE_STOP_Z_1)
{
digitalWrite(STOP_Z_1, DOIT_STOPPER_);
}
else
{
digitalWrite(STOP_Z_1, PEUT_ROULER);
}

Lors des premiers plans, j'avais dessiné un interrupteur capable de couper le courant dans l'ensemble des zones  en une seule fois, en cas de panique par exemple (déraillement,...)


Disposant d'un arduino, il est intéressant de remplacer ce interrupteur par un relais, commandé par deux boutons poussoirs fugitifs, comme pour le relais contrôlant Z_1.
Ce qui donne pour le code :
Pour la partie bibliothèques "include" : rien du tout.
Pour la partie dictionnaire de langues "define" :

Code:

#define PIN_SOS_TOUT               33        //  relais  arrêtant toutes les zones alimentées par le détecteur Viessman
#define _RELAIS_TOUT_STOP       LOW
#define _RELAIS_TOUT_ROULE    HIGH

#define PIN_ARRET_TOUT             34        //  Bouton arrêtant toutes les zones alimentées par le détecteur Viessman
#define PIN_REDEMARRE_TOUT      35        //  Bouton remettant sous tension toutes les zones alimentées par le détecteur Viessman
#define FORCE_STOP_TOUT          LOW  //Commande arrêtant toutes les zones alimentées par le détecteur Viessman
#define FORCE_REDEMARRE_TOUT  LOW  //Commande remettant sous tension toutes les zones alimentées par le détecteur Viessman

Pour l'initialisation SETUP () :

Code:

void setup()
     pinMode(PIN_SOS_TOUT,   OUTPUT);                               // Pin en sortie pilotant le relais forçant les rames à s'arrêter.
     pinMode(PIN_ARRET_TOUT,   INPUT_PULLUP);             // Pin en entrée, avec activation de la résistance de rappel interne, testant le bouton forçant les rames à s'arrêter.
     pinMode(PIN_REDEMARRE_TOUT,   INPUT_PULLUP); // lPin en entrée, avec activation de la résistance de rappel interne, testant le bouton forçant les rames à redémarrer.

digitalWrite(PIN_SOS_TOUT, FORCE_REDEMARRE_TOUT); // toutes les zones sont mises sous tension avant le début de la boucle

Pour la boucle LOOP () :
Il y a un piège !
Il y a deux boutons 'A' et 'B' à utiliser.
Il faut donc écrire :

• Si test du bouton "A" réussi alors le travail 'A' est exécuté
  
• Sinon
  Si test du bouton "B" réussi alors le travail 'B' est exécuté
  
• Sinon on ne fait rien
  

Le travail 'A' est donc exécuté si le bouton 'A' est actif, quelque soit l'état des autres boutons.
Le travail 'B' est donc exécuté si  le bouton 'B' est actif ET si  le bouton 'A' n'est pas actif, quelque soit l'état des autres boutons.
Si ni le bouton 'A', ni le bouton 'B' sont actifs, aucune action n'est exécutée, et le relaos reste dans l'état où il est, quelque soit cet état.
Il faut donc mettre en 'A' le plus prioritaire, soit l'arrêt total de tout, ce qui donne le code à placer n'importe où il sera exécuté à chaque occurence de la boucle, par exemple juste après l'accolade de début de la boucle, ou juste après l'accolade de fin de la boucle.:

Code:

void Loop ()
{  // première accolade du LOOP
   if(digitalRead(PIN_ARRET_TOUT) == RELAIS_STOP_TOUT_STOP )
       {
          digitalWrite(PIN_ARRET_TOUT ,FORCE_STOP_TOUT);
       }
        else if (digitalRead(PIN_ARRET_TOUT) == REDEMARRE_TOUT );
       {
          digitalWrite(PIN_ARRET_TOUT ,FORCE_REDEMARRE_TOUT);
        }

Mais pourquoi tout compliquer avec deux boutons fugitif, alors qu'un seul interrupteur ordinaire dont on teste l'état "fermé"/ouvert" suffisait ?"
Deux raisons à cela.
On peut mettre plusieurs poussoirs en parallèle, et ainsi avoir une commande "Panique" sur le module côté "Public" et une autre côté fond de décor.
On peut mettre des "détecteurs de problème" coupant le circuit de traction automatiquement si nécessaire.

A cet effet, je prévois de mettre des détecteurs de température agissant sur le relais "PIN_SOS_TOUT" en cas de température trop élevée selon l'algorithme suivant :

Si température_lue >32,7°C alors DECLENCHER_ALARME
Si température_lue >41,3°C alors COUPER_COURANT_TRACTION_PARTOUT

Ce sera la suite, bientôt...

A suivre