Mon réseau: panneau de contrôle (TCO)

Introduction

Bien qu’exploitant mon réseau en analogique, un peu d’électronique et un microcontrôleur permettent d’assurer une exploitation en toute sécurité, pratiquement sans aucun risque de collision !

Le panneau de contrôle ou TCO dans le jargon (tableau de contrôle optique) se compose des éléments suivants:

reseau10

  • À gauche: la commande des aiguillages et des alimentations de la gare.
  • À droite: 4 régulateurs traction pour: la voie à crémaillère, la zone de manoeuvre, la boucle extérieure, la boucle intérieure.
  • En haut: la commande va-et-vient pour la voie à crémaillère.

Commande des aiguillages et alimentations

États du système

Le réseau est constitué de 2 boucles: intérieure et extérieure (cf. Mon réseau: plan et conception). La boucle intérieure est alimentée par le régulateur rouge, celui le plus à droite, la boucle extérieure par le régulateur bleu, 2ème en partant de la droite. Le régulateur jaune, 3ème en partant de la droite, peut alimenter la zone de manoeuvre.

État initial

tco110

  • Les traversées jonction double (TJD) 1 et 2 sont en position droite.
  • Les aiguilles  1 et 2 (AIG) sont en position droite.
  • La voie 2 est alimentée par le régulateur de la boucle intérieure.
  • La voie 3 est alimentée par le régulateur de la boucle extérieure.

Train de la boucle intérieure en voie 1

tco210

  • Les TJD sont en position déviée.
  • Les aiguilles sont toujours en position droite.
  • La voie 1 est alimentée par le régulateur de la boucle intérieure.
  • La voie 2 n’est pas alimentée, on peut donc y laisser un train à l’arrêt.
  • La voie 3 est toujours alimentée par le régulateur de la boucle extérieure.

Train de la boucle extérieure en voie 2

tco310

  • Les TJD sont en position déviée.
  • Les AIG sont en position déviée.
  • La voie 1 n’est pas alimentée.
  • La voie 2 est alimentée par le régulateur de la boucle extérieure.
  • La voie 3 est alimentée par le régulateur de la zone de manoeuvre.

La zone de manoeuvre est isolée du reste du réseau pour éviter les collisions. Les trains arrivant de la boucle intérieure sont bloqués à l’entrée de la gare.

Train de la boucle extérieure sur la voie 1

tco410

  • Les TJD sont en position droite.
  • Les aiguilles sont en position déviée.
  • La voie 1 est alimentée par le régulateur de la boucle extérieure.
  • La voie 2 n’est pas alimentée.
  • La voie 3 est alimentée par le régulateur de la zone de manoeuvre.

Dans ce cas aussi la zone de manoeuvre est isolée et les trains de la boucle intérieure sont bloqués à l’entrée en gare.

Les 2 derniers états

Envoyons le train de la boucle intérieure en voie 2 tout en continuant à manoeuvrer avec le régulateur jaune. Cela permet d’avoir un 3ème train en mouvement sur la boucle extérieure.

tco510

  • Les TJD sont en position droite.
  • Les aiguilles sont en position droite.
  • La voie 1 n’est pas alimentée.
  • La voie 2 est alimentée par le régulateur de la boucle intérieure.
  • La voie 3 est alimentée par le régulateur de la zone de manoeuvre.

Comme dans les 2 cas précédents, La zone de manoeuvre est isolée. Par contre, les trains venant de la boucle extérieure sont bloqués à l’entrée de la gare.

Le dernier cas, vous l’aurez certainement deviné, consiste à envoyer le train de la boucle intérieure en voie 1.

tco610

  • Les TJD sont en position déviée.
  • Les aiguilles sont en position droite.
  • La voie 1 est alimentée par le régulateur de la boucle intérieure.
  • La voie 2 n’est pas alimentée.
  • La voie 3 est alimentée par le régulateur de la zone de manoeuvre.

Avec cette manière de procéder, les trains ne passent jamais d’une alimentation à une autre car on change dynamiquement l’alimentation des voies de gare selon les positions des TJD et aiguilles. Les modélistes anglophones parlent de cab control et les germanophones de Z-Schaltung. Je n’ai pas trouvé de terme français équivalent !

Réalisation

La base du TCO est une plaque d’aluminium. La partie blanche est produite à l’aide de PowerPoint (certainement que tout autre logiciel de dessin conviendrait aussi) puis imprimée. Le dessus est un plastique transparent (plexiglas ou autre). Le plus difficile était de percer la plaque d’aluminium et celle de plastique à l’identique. J’ai procédé comme suit:

  • Faire une version spéciale du dessin comportant les endroits où percer.
  • Percer la plaque d’aluminium en servant du dessin avec le plan de perçage.
  • Fixer le plastique transparent sur la plaque d’aluminium à l’aide de scotch.
  • Retourner le tout et percer le plastique transparent en servant de la plaque d’aluminium comme gabarit de perçage.

L’électronique est implantée sur 2 plaques à bandes (Veroboard).

reseau11

  • sur la platine de gauche, un microcontrôleur Attiny2313 et les relais (petits boîtiers bleus) de commande des aiguillages,
  • sur la platine de droite, les relais de distribution des alimentations en gare et zone de manoeuvre.

Les schémas correspondants sont:

Microcontrôleur

Les 6 poussoirs sur la droite correspondent aux poussoirs de couleurs du TCO avec la convention suivante:

  • A1: poussoir rouge voie 1.
  • A2: poussoir rouge voie 2.
  • B1: poussoir bleu voie 1.
  • B2: poussoir bleu voie 2.
  • B3: poussoir bleu voie 3.
  • C3: poussoir jaune voie 3.

tco_savignyexpressscan-161009-0001

Leds du TCO

Pour éviter d’utiliser des sorties supplémentaires pour les leds qui affichent l’état des voies de gare au TCO, le montage suivant permet d’allumer les leds en fonction des 3 sorties de commande des relais.

tco_savignyexpressscan-161009-0002

Relais

L’alimentation A correspond au régulateur de la boucle intérieure. L’alimentation B à celui de la boucle extérieure et l’alimentation C à celui de la zone manoeuvre. Cette convention est reprise dans le programme C.

Les 2 voies de chaque côté de la gare comportent des zones d’arrêt. Dans le cas de la voie extérieure, l’aiguille est incluse dans la zone afin de simplifier le câblage. Ces zones d’arrêt permettent d’arrêter les trains entrants selon l’état de la gare (cf la description des états ci-avant). Ces zones d’arrêt ne fonctionnent bien qu’avec des trains classiques, tirés par une locomotive, car la prise de courant se fait en tête de train. Pour des trains réversibles (loco en pousse) ou des rames telles que la prise de courant se fait sur tous les essieux, ces zones d’arrêt ne conviennent pas. Ce n’est pas un problème sur mon réseau époque III / IV où ne circulent que des trains classiques. 

tco_savignyexpressscan-161009-0003

Programme en C

Dans le programme en C du microcontrôleur, les conventions suivantes sont suivies:

  • 1, 2, 3: numéros des voies en partant de la gare.
  • A, B: alimentations traction du circuit intérieur et du circuit extérieur. En rouge, respectivement bleu sur le TCO. Couleurs correspodant aussi aux boutons poussoir.
  • C: alimentation traction de la zone marchandise, peut être commutée avec l’alimentation B. En jaune sur la description des états du TCO. Couleur correspondant aussi au bouton poussoir.
  • B_A1, B_A2, etc: pressions sur le poussoir A1, A2, etc. Le bouton A1 alimente la voie 1 avec le circuit A (rouge) et ainsi de suite.
  • Les états sont nommés: AXB, XAB, AXC, etc. Il s’agit des états possibles des 3 voies de gare:
    • AXB: voie 1 alimentée par A, voie 2 non alimentée, voie 3 alimentée par B.
    • XAB: voie 1 non alimentée, voie 2 alimentée par A, voie 3 alimentée par B.
    • AXC: voie 1 alimentée par A, voie 2 non alimentée, voie 3 alimentée par C.
  • La commande des aiguillages se fait par la fonction CommanderTdjAig dont le but est de commander séparément les TJDs et aiguillages de la gare, ce qui évite de tirer trop de courant de l’alimentation.
  • Il y a aussi quelques fonctions qui ne servent qu’à simuler le programme en le faisant tourner sur PC: GetTexteEvt, GetTexteEtat, GetTexteAiguillage, AfficherEtat.

La structure générale du programme est une boucle infinie, comme toujours sur un microcontrôleur où un programme ne se termine jamais, dont la structure est la suivante:

  • Lire les entrées, les boutons poussoirs en l’occurrence.
  • Déterminer le nouvel état du système et des sorties.
  • Mettre à jour les sorties.
  • Attendre quelques dizaines de millisecondes.
  • Revenir à la lecture des entrées.

Les fonctions principales du programme, appelées dans la boucle principale, sont:

  • TraiterEtat: gestion de la machine d’états pour les 6 états du TCO décrits plus haut dans ce post. Cette fonction appelle ensuite DefinirSorties.
  • DefinirSorties: détermination des sorties en fonction de l’état et mise à jour des sorties. S’il faut commander les TJD et les aiguillages, cette fonction initialise la machine d’états implantée dans la fonction CommanderTjdAig décrite ci-après.
  • CommanderTjdAig: gestion de la machine d’états pour la commande des TJD et aiguillages. Elle commande d’abord les 2 TJD, puis les 2 aiguillages afin d’éviter que les électro-aimants ne tirent trop de courant de l’alimentation accessoires.

Ce programme comporte des fonctions utilisées que pour la mise au point sur PC. À cet effet, 2 directives de compilation sont utilisées:

  • PC compile les appels d’affichage sur écran lorsque le programme est compilé pour PC avec gcc.
  • AVR permet de compiler tout ce qui est spécifique à l’AVR, principalement les entrées-sorties, lorsque le programme est compilé avec avr-gcc.

Avec cette astuce, il est possible de mettre au point la logique du programme en grande partie sur le PC avant de télécharger le programme en version AVR vers le microcontrôleur.

Cliquer sur expand source ci-après pour voir le programme complet.

//
//  Maquette.c
//
//  Programme de contrôle de la maquette "Savigny Express".
//
//  2009.09.11  MHP  Création.
//  2009.10.06  MHP  Simplificatin de la machine d'états.
//  2009.10.10  MHP  Début des tests avec les E/S de l'AVR.
//  2009.10.14  MHP  Commande momentanée des aiguillages.
//  2009.11.04  MHP  Debug amélioré de la commande des aiguillages.
//  2009.11.08  MHP  Ajout de la commande du bit bSela12, oubli !
//  2010.02.11  MHP  Correction des reactions a l'evenement C3.
//
//  Directives de compilation: PC ou AVR.
//

#ifdef AVR
#include <inttypes.h>
#include <avr/io.h>

#define F_CPU 1000000UL
#include <util/delay.h>

// Période en ms.
#define  PERIODE  50

// Boutons poussoirs.
#define BOUTONS  PINB
#define B_A1  _BV(PD6)
#define  B_A2  _BV(PB0)
#define B_B1  _BV(PB1)
#define B_B2  _BV(PB2)
#define  B_B3  _BV(PB3)
#define  B_C3  _BV(PB4)
#define P_A1  (!(PIND & B_A1))
#define P_A2  (!(PINB & B_A2))
#define P_B1  (!(PINB & B_B1))
#define P_B2  (!(PINB & B_B2))
#define P_B3  (!(PINB & B_B3))
#define P_C3  (!(PINB & B_C3))

// Sorties.
#define  SetTJD_D  (PORTD |= _BV(PD0))
#define ClrTJD_D  (PORTD &= ~_BV(PD0))
#define  SetTJD_N  (PORTD |= _BV(PD1))
#define  ClrTJD_N  (PORTD &= ~_BV(PD1))

#define SetAIG_D  (PORTA |= _BV(PA1))
#define ClrAIG_D  (PORTA &= ~_BV(PA1))
#define  SetAIG_N  (PORTA |= _BV(PA0))
#define ClrAIG_N  (PORTA &= ~_BV(PA0))

#define SetSelAB  (PORTD |= _BV(PD2))
#define ClrSelAB  (PORTD &= ~_BV(PD2))
#define SetSel12  (PORTD |= _BV(PD3))
#define ClrSel12  (PORTD &= ~_BV(PD3))
#define SetSel3      (PORTD |= _BV(PD4))
#define ClrSel3      (PORTD &= ~_BV(PD4))
#define  SetSela12  (PORTD |= _BV(PD5))
#define  ClrSela12  (PORTD &= ~_BV(PD5))

// Configuration des ports
#define CONFIG_DDRA  (_BV(PA0)|_BV(PA1))

#define  CONFIG_DDRB  ~(B_A2|B_B1|B_B2|B_B3|B_C3);
#define CONFIG_PULLUPB  (B_A2|B_B1|B_B2|B_B3|B_C3);

#define CONFIG_DDRD  ~(B_A1)
#define CONFIG_PULLUPD  B_A1
#endif

#ifdef PC
#include  <stdio.h>
#endif

#define  NB_PERIODES  4

// Etats: nommés à partir de l'état
// des voies de gares 1, 2 et 3.
enum tEtat {AXB, XAB, AXC, XAC, BXC, XBC};
enum tEtat eEtat;

// Evénements: nommés à partir de la source à connecter à chaque voie.
enum tEvt {A1, B1, A2, B2, B3, C3};

// Commandes des relais.
short bSelAB;
short bSel12;
short bSel3;
short bSela12;

// Positions et commandes des aiguillages.
enum tPosition {NORMAL, DEVIE};
enum tPosition ePosJonctions;
enum tPosition ePosAiguillages;

enum tCommandeAig {IDLE, TJD, AIG} eCommandeAig;
short nNbPeriodes;

// Pour compter les tests en mode PC.
#ifdef PC
int nTest;
#endif

char *GetTexteEvt(enum tEvt xEvt)
{
    #ifdef PC
    switch(xEvt)
    {
        case A1: return("A1");
        case B1: return("B1");
        case A2: return("A2");
        case B2: return("B2");
        case B3: return("B3");
        case C3: return("C3");
    } // switch
    #endif
} // GetTexteEvt

char *GetTexteEtat(enum tEtat xEtat, short xVoie)
{
    #ifdef PC
    switch(xEtat)
    {
        case AXB:
            if(xVoie == 1)
                return("A");
            if(xVoie == 2)
                return("X");
            if(xVoie == 3)
                return("B");

        case XAB:
            if(xVoie == 1)
                return("X");
            if(xVoie == 2)
                return("A");
            if(xVoie == 3)
                return("B");

        case AXC:
            if(xVoie == 1)
                return("A");
            if(xVoie == 2)
                return("X");
            if(xVoie == 3)
                return("C");

        case XAC:
            if(xVoie == 1)
                return("X");
            if(xVoie == 2)
                return("A");
            if(xVoie == 3)
                return("C");

        case BXC:
            if(xVoie == 1)
                return("B");
            if(xVoie == 2)
                return("X");
            if(xVoie == 3)
                return("C");

        case XBC:
            if(xVoie == 1)
                return("X");
            if(xVoie == 2)
                return("B");
            if(xVoie == 3)
                return("C");
    } // switch
    #endif
} // GetTexteEtat

char *GetTexteAiguillage(enum tPosition xPos)
{
    #ifdef PC
    switch (xPos)
    {
        case NORMAL:  return("N");
        case DEVIE:  return("D");
    } // switch
    #endif
} // GetTexteAiguillage

void AfficherEtat(void)
{
#ifdef PC
#define V1 GetTexteEtat(eEtat, 1)
#define V2 GetTexteEtat(eEtat, 2)
#define V3 GetTexteEtat(eEtat, 3)
#define J (bSelAB ? "B" : "A")
#define A (bSela12 ? "X" : "B")
#define P2 (bSelAB ? "X" : "A")
#define P3 (bSel3 ? "X" : "B")
#define PJ GetTexteAiguillage(ePosJonctions)
#define PA GetTexteAiguillage(ePosAiguillages)
#define FA (bSelAB ? "R" : "V")
#define FB (bSela12 ? "R" : "V")

    printf("          /------%s------\\      \n", V1);
    printf("%s----%s--%s%s-------%s------%s%s--%s--%s\n", FA, P2, J, PJ, V2, PJ, J, P2, FA);
    printf("%s------%s%s%s-------%s-------%s%s%s---%s\n", FB, A, PA, P3, V3, P3, PA, A, FB);
    printf("\n");
#endif
} // AfficherEtat

void CommanderTjdAig(void)
{
    switch (eCommandeAig)
    {
        case TJD:
            if (nNbPeriodes == 0)
            {
                #ifdef AVR
                ClrTJD_D;
                ClrTJD_N;
                ClrAIG_D;
                ClrAIG_N;
                (ePosJonctions == DEVIE ? SetTJD_D : SetTJD_N);
                #endif

                #ifdef PC
                (ePosJonctions == DEVIE ? printf("\tTJD DEV\n") : printf("\tTJD NOR\n"));
                #endif
            }
            else if (nNbPeriodes == (NB_PERIODES / 2))
            {
                #ifdef AVR
                ClrTJD_D;
                ClrTJD_N;
                (ePosAiguillages == DEVIE ? SetAIG_D : SetAIG_N);
                #endif

                #ifdef PC
                printf("\tTJD --\n");
                (ePosAiguillages == DEVIE ? printf("\tAIG DEV\n") : printf("\tAIG NOR\n"));
                #endif

                eCommandeAig = AIG;
            } // if
            nNbPeriodes++;
        break;

        case AIG:
            if (nNbPeriodes == NB_PERIODES)
            {
                #ifdef AVR
                ClrTJD_D;
                ClrTJD_N;
                ClrAIG_D;
                ClrAIG_N;
                #endif

                eCommandeAig = IDLE;

                #ifdef PC
                printf("\tAIG --\n");
                #endif

                nNbPeriodes = 0;
            }
            else
                nNbPeriodes++;
        break;

        case IDLE:
        break;
    } // switch
} // CommanderTjdAig

void DefinirSorties(void)
{
    switch(eEtat)
    {
        case AXB :
            bSelAB  = 0;
            bSel12  = 1;
            bSela12  = 0;
            bSel3  = 0;
            ePosJonctions  = DEVIE;
            ePosAiguillages  = NORMAL;
        break;

        case XAB:
           bSelAB  = 0;
           bSel12  = 0;
           bSela12  = 0;
           bSel3  = 0;
           ePosJonctions  = NORMAL;
           ePosAiguillages  = NORMAL;
        break;

        case AXC:
            bSelAB  = 0;
            bSel12  = 1;
            bSela12  = 1;
            bSel3  = 1;
            ePosJonctions  = DEVIE;
            ePosAiguillages  = NORMAL;
        break;

        case XAC:
            bSelAB  = 0;
            bSel12  = 0;
            bSela12  = 1;
            bSel3  = 1;
            ePosJonctions  = NORMAL;
            ePosAiguillages  = NORMAL;
        break;

        case BXC:
            bSelAB  = 1;
            bSel12  = 1;
            bSela12  = 0;
            bSel3  = 1;
            ePosJonctions  = NORMAL;
            ePosAiguillages  = DEVIE;
        break;

        case XBC:
            bSelAB  = 1;
            bSel12  = 0;
            bSela12  = 0;
            bSel3  = 1;
            ePosJonctions  = DEVIE;
            ePosAiguillages  = DEVIE;
        break;
    } // switch

    #ifdef AVR
    (bSelAB ? SetSelAB : ClrSelAB);
    (bSel12 ? SetSel12 : ClrSel12);
    (bSel3 ? SetSel3 : ClrSel3);
    (bSela12 ? SetSela12 : ClrSela12);
    #endif
    eCommandeAig = TJD;
} // DefinirSorties

void SimulerTimeouts(void)
{
#ifdef PC
int nNbTimeouts;

    // On simule quelques timeouts
    for(nNbTimeouts = 0; nNbTimeouts < 8; nNbTimeouts++)
        CommanderTjdAig();
#endif
} // SimulerTimeouts

void TraiterEtat(enum tEvt xEvt)
{
enum tEtat  eProchEtat;

    #ifdef PC
    printf("%02d: Evénement: %s\n", ++nTest, GetTexteEvt(xEvt));
    #endif

    switch(eEtat)
    {
        case AXB:
            if (xEvt == A1) eProchEtat = AXB;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAB;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = AXB;
            if (xEvt == C3) eProchEtat = AXC;
        break;

        case XAB:
            if (xEvt == A1) eProchEtat = AXB;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAB;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = XAB;
            if (xEvt == C3) eProchEtat = XAC;
        break;

        case AXC:
            if (xEvt == A1) eProchEtat = AXC;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAC;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = AXB;
            if (xEvt == C3) eProchEtat = AXC;
        break;

        case XAC:
            if (xEvt == A1) eProchEtat = AXC;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAC;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = XAB;
            if (xEvt == C3) eProchEtat = XAC;
        break;

        case BXC:
            if (xEvt == A1) eProchEtat = AXC;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAC;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = AXB;
            if (xEvt == C3) eProchEtat = BXC;
        break;

        case XBC:
            if (xEvt == A1) eProchEtat = AXC;
            if (xEvt == B1) eProchEtat = BXC;
            if (xEvt == A2) eProchEtat = XAC;
            if (xEvt == B2) eProchEtat = XBC;
            if (xEvt == B3) eProchEtat = XAB;
            if (xEvt == C3) eProchEtat = XBC;
        break;

        default:
        break;
    } // switch

    // Ne changer les sorties que si l'état a changé.
    if (eProchEtat != eEtat)
    {
        eEtat = eProchEtat;
        DefinirSorties();
    } // if

    AfficherEtat();
    SimulerTimeouts();
 } // TraiterEtat

void main(void)
{
    eEtat = XAB;
    eCommandeAig = IDLE;
    nNbPeriodes = 0;
    DefinirSorties();

    #ifdef AVR
    // Entrées à droite du chip avec pull-ups.
    // Sorties à gauche du chip.
    DDRA = CONFIG_DDRA;
    DDRB = CONFIG_DDRB;
    PORTB = CONFIG_PULLUPB;
    DDRD = CONFIG_DDRD;
    PORTD = CONFIG_PULLUPD;

    while (1)
    {
        if (P_A1) TraiterEtat(A1);
        if (P_A2) TraiterEtat(A2);
        if (P_B1) TraiterEtat(B1);
        if (P_B2) TraiterEtat(B2);
        if (P_B3) TraiterEtat(B3);
        if (P_C3) TraiterEtat(C3);

        CommanderTjdAig();
        _delay_ms(PERIODE);
    } // while
    #endif

    #ifdef PC
    nTest = 0;
    printf("*** Etat initial ***\n");
    AfficherEtat();
    SimulerTimeouts();

    TraiterEtat(C3);
    TraiterEtat(A1);
    TraiterEtat(B1);
    TraiterEtat(B2);
    TraiterEtat(B3);
    TraiterEtat(A1);
    TraiterEtat(B1);
    TraiterEtat(B3);
    TraiterEtat(B2);
    TraiterEtat(A1);
    TraiterEtat(A2);
    TraiterEtat(B3);
    TraiterEtat(B1);
    TraiterEtat(A2);
    TraiterEtat(B3);
    TraiterEtat(A1);
    TraiterEtat(C3);
    TraiterEtat(B3);
    TraiterEtat(A2);
    TraiterEtat(C3);
    TraiterEtat(B1);
    TraiterEtat(B3);
    #endif
} // main

Régulateurs traction

Les régulateurs traction font partie d’un bloc de 4 régulateurs trouvé d’occasion sur Internet. Chaque régulateur comporte:

  • Un régulateur linéaire LM317.
  • Un potentiomètre linéaire de commande.
  • Une résistance ajustable pour adapter la tension maximale.
  • Un inverseur de sens de marche.

Les 4 régulateurs sont alimentés en amont par une source de courant unique. Lors du câblage, il est important de garder cela à l’esprit et toujours prévoir des éclisses isolantes sur les 2 rails. En aucun cas de tels régulateurs ne doivent être câblés avec un retour commun sous peine de court-circuit. Un câblage avec retour commun n’est possible qu’avec 2 transfos train séparés.

reseau12

Zone manoeuvre

Les aiguilles de la zone manoeuvre sont actionnées à l’aide d’une matrice de diodes ce qui permet de choisir l’une des 3 voies de garage ou la voie principale à l’aide d’un seul poussoir. Le schéma ci-après montre le principe. Les poussoirs G1, G2 et S (pour la scierie) sélectionnent l’une des 3 voies, le poussoir V permet de poursuivre sur la voie normale. Dans ce schéma: N = normal, D = dévié.

tco_savignyexpressscan-161009-0004

Cette 1ère réalisation repose sur la capacité des aiguilles de n’alimenter que la voie correspondant à la direction courante, pour autant que l’on ait supprimé les contacts aux emplacements montrés ci-dessous.

aiguil10

Hélas la fiabilité n’était pas au rendez-vous et j’ai choisi de doubler chaque aiguille par un relais bistable pour assurer la réalimentation des voies de garage en fonction de la position des aiguilles.

On retrouve la matrice de diodes et 3 bistables 7, 8, 9 alimentés en parallèle avec l’aiguille correspondante.

manoeuvre

Publicités

Une réflexion au sujet de « Mon réseau: panneau de contrôle (TCO) »

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion /  Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s