Archives pour la catégorie Mon réseau

Déménagement du réseau

Changement d’environnement pour mon réseau qui a quitté les combles au profit d’une autre pièce de la maison. Ce nouvel emplacement donne plus d’espace au réseau et le met mieux en valeur de mon point de vue. J’ai aussi profité de hausser le niveau, le bureau lui servant de base disposant de pieds réglables.

IMG_0727_small

IMG_0732_small

IMG_0733_small

IMG_0735_small

IMG_0738_small

Publicités

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

Mon réseau: planter des arbres

Afin de se faire une idée de la meilleure manière de disposer les arbres sur le réseau, je suis parti de photos du réseau après flocage.

dsc_0938

dsc_0936Mon réseau comportant essentiellement des sapins, j’ai trouvé l’image suivante sur le web:

UnSapin

Ensuite, je l’ai copiée et collée sur les 2 photos ci-dessus à l’aide du logiciel « The GIMP », un logiciel open source et gratuit de manipulation d’images.

Sapins_2

Sapins_1

Pour cette simulation informatique, j’ai fait quelques simplifications. Il n’y a que des sapins alors que l’altitude où se situe le réseau correspond plutôt à une forêt mixte de résineux et feuillus avec quelques buissons. Tous les arbres ont la même hauteur, ce qui est loin d’être le cas dans la nature.

Ce « plan d’implantation » des arbres permet de passer des arbres réels aux arbres virtuels. Au passage, j’ai installé un fond de réseau Faller fixé provisoirement avec des punaises.

Reseau82

Reseau84

Reseau86

Le TGV d’un ami, 1ère livrée des années 1980, en visite sur mon réseau.

TgvForum

Reseau94

Reseau91

Reseau89

Mon réseau: décor

Une fois les bandes de plâtre posées sur la moustiquaire, donnons de la couleur au décor !

Les rochers sont peints en plusieurs couches: gris, teinte foncée très diluée et brossage à sec en blanc. La couche de fond pour le flocage en diverses tonalités de brun, clair en montagne, foncé plus bas.

Reseau68

Reseau71

Reseau73_small

Le flocage posé, le réseau, sans arbres, se présente comme suit et on peut toujours faire circuler les trains !

Reseau78 Reseau79

Reseau81_small Reseau80_small

Mon réseau: relief

Suivant le conseil de mon épouse avant d’aller plus loin dans le décor, j’ai construit les bâtiments pour ensuite les placer et organiser les volumes du relief.

reseau20

La gare de St-Niklaus dont l’original se trouve sur la ligne Vièges-Zermatt.

reseau21

La célèbre église de Wassen sur la ligne du Gothard.

reseau22

reseau23

Une scierie motorisée (Faller).

Pour se faire une idée du relief, j’ai d’abord réalisé des profils en carton, plus rapide à découper et à refaire si le résultat ne convient pas.

reseau25

Les profils en carton ont servi de châblon pour découper des pièces de contre-plaqué 4 mm sur lesquelles j’ai agrafé de la moustiquaire métallique.

raseau10

Ensuite, la moustiquaire est recouverte de bande plâtrée, puis d’une couche de plâtre à modeler pour lisser la texture de la bande plâtrée.

raseau12

Les rochers sont faits avec des moules (Woodland Scenics), puis collés sur le relief. Les raccords sont faits avec le plâtre à modeler. C’est aussi le moment pour placer les entrées de tunnel et les murs de soutènement.

raseau11

Et aussi creuser les futurs lacs et rivière.

raseau13

Mon réseau: infrastructure et rampes

L’infrastructure d’un réseau ferroviaire miniature peut se faire avec la technique des cadres ouverts qui présente l’avantage de faciliter les reliefs négatifs. J’ai préféré me restreindre à 2 niveaux et n’avoir que du relief positif, plus simple à réaliser.

Un ami a imprimé le plan à l’échelle 1:1, puis je l’ai reporté sur ma planche de base à l’aide de papier carbone.

reseau13

Les rampes sont tracées sur du contre-plaqué de 4 mm.

reseau18

Raily définit les hauteurs à chaque jointure de voie. Plutôt que de calculer précisément les hauteurs des piliers soutenant les rampes, j’ai défini des piliers de hauteurs standardisées en empilant de petits blocs de contre-plaqué d’épaisseurs connues. Ensuite, par simple règle de 3, enrichie d’un peu de trigonométrie pour les courbes, j’ai calculé les emplacements des piliers.

Après collage des piliers et des rampes, place à la pose provisoire des voies et aux premiers trains.

reseau19

reseau16

reseau17

Article dans Loki 06/2013

Ressortant mes connaissances d’Allemand scolaire et mes souvenirs de pratique professionnelle, j’ai écrit un article décrivant mon réseau pour la revue de modélisme ferroviaire Suisse Loki. Cet article, amélioré par la rédaction du journal, est paru dans l’édition de juin 2013. Un résumé est disponible sur le site du journal.