COMMANDE AIGUILLAGES ET AUTRES ACCESSOIRES

[Alain]

PROJET :       COMMANDE AIGUILLAGES ET AUTRES ACCESSOIRES

Historique :

Étape 1 :

Au début des années 1990 j’ai utilisé des cartes E/S  avec un PC 486 pour commander les aiguillages et lumières. Un petit circuit munis d’un OPTOCOUPLER permettait la commande des aiguillages via les sorties de la carte des SORTIES . La position de l’aiguillage était confirmée via une  carte des ENTRÉES.

J’ai aussi conçu un logiciel avec VisualBasic permettant de tracer à l’écran un schéma de réseau ferroviaire permettant d’utiliser la souris pour commander les aiguillages à l’aide de carte I/O normales installées dans un ordinateur 486.

Voici quelques exemples des icones disponibles pour tracer le réseau :


       
et

exemples de réseau :


 
Figure #1 – Logiciel pour dessiner un réseau


 
Figure #2 – Exemple réseau Littletown

Il suffisait de cliquer sur l’aiguillage à l’aide de la souris pour en changer la position. Voir les Figures 1 et 2.

Étape 2 :

Il y a quelques années j’ai conçu avec un copain une carte pour commander les trains miniatures de toutes les échelles de Z à G.

Cette carte utilise un microprocesseur PIC30F6010 et est pourvue de :

1.    alimentation de 10A avec sorties 5 Vcc et 20Vcc;
2.    30 entrées numériques;
3.    46 sorties numériques;
4.    4 sorties avec transistors de puissance pour commander la vitesse de deux (2) trains;
5.    un circuit de décharge de condensateur pour actionner les aiguillages.

Cette carte me permet donc de:

1.   commander des bobines d'aiguillages;
2.   commander des moteurs d'aiguillages;
3.   commander des lumières (ampoules ou DEL);
4.   commander des feux de circulation (trains, routes, rues…);
5.   simuler un appareil de soudure à arc;
6.   commander des barrières de passages à niveau avec feux clignotants;
7.   contrôles la circulation de deux trains au travers de croisements;
8.   empêcher des déraillements sur aiguillages en repositionnant l'aiguillage selon la direction d'arrivée du train pour ensuite remettre l'aiguillage dans sa position originale;
9.   contrôler la circulation d'un train au travers d'une boucle de retour;
10.   contrôler la circulation de voies d'évitement;
11.   contrôler la circulation dans une cours de triage;
12.   commander directement la vitesse de deux (2) trains;
13.   contrôler automatiquement deux (2) trains sur un parcours pré sélectionné (départ, arrêt, accélération, ralentissement…)

Cette solution peut être facilement implantée sur un réseau existant car les entrées numériques reçoivent leurs signaux à partir de «reed switch» qui peuvent être facilement ajoutées sous les rails et même remplacer une traverse de voies ferrées à l'échelle HO. Il ne reste qu'à ajouter un petit aimant sous une locomotive ou un wagons pour actionner les «reed switch» au moment opportun.

J'ai implanté cette solution sur mes propres réseaux HO, N et Z.

Cette solution est compatible avec le DCC car la conduite des trains n'est aucunement affectée mais a l'avantage d'automatiser tout le reste.

Projet Arduino :

Dernièrement, j’ai décidé de me tourner vers une solution Arduino car cette solution est probablement beaucoup moins coûteuse que  la carte du microprocesseur PIC30 qui est de fabrication spéciale pour cette application.

Objectifs :

Utiliser Arduino pour :

1.   commander des bobines d'aiguillages;
2.   commander des moteurs d'aiguillages;
3.   commander des lumières (ampoules ou DEL);
4.   commander des feux de circulation (trains, routes, rues…);
5.   simuler un appareil de soudure à arc;
6.   commander des barrières de passages à niveau avec feux clignotants;
7.   contrôles la circulation de deux trains au travers de croisements;
8.   empêcher des déraillements sur aiguillages en repositionnant l'aiguillage selon la direction d'arrivée du train pour ensuite remettre l'aiguillage dans sa position originale;
9.   contrôler la circulation d'un train au travers d'une boucle de retour;
10.   contrôler la circulation de voies d'évitement;
11.   contrôler la circulation dans une cours de triage;
12.   contrôler automatiquement des trains sur un parcours pré sélectionné (départ, arrêt, accélération, ralentissement…)
13.   contrôler trains et accessoires à partir d’un ordinateur avec une interface« Processing »

Les éléments de base de la solution Arduino que j’entrevois sont :

1.   Interface aiguillage (voir Figure # 3)
2.   Décharge de condensateur (voir Figure # 4)
3.   Arduino et shift register (voir Figure # 5)
4.   Reed switch pour les entrées (voir Figure # 6 et # 7)
 

Figure # 3 - Interface aiguillage


Figure # 4 - Décharge de condensateur
 
Note : Seulement deux (2) circuits des sorties du 74HC595 sont indiquées. Le circuit complet comporte huit ( circuits optocoupleurs pour la commande de quatre (4) aiguillages ou accessoires.


Figure # 5 - Arduino et shift register


Figure # 6 – Reed switch
 

Figure # 7 – Position des reed switch sur un aiguillage

Travail à date :

Commande des aiguillages :

Suite au visionnement d'un article sur YouTube de Kevin Darrah, «Part 2 - How to Control a Ton of Inputs using Shift Registers!» (), j’ai conçu un circuit de base avec un SN74HC595 pour les entrées/sorties. Entrées via «reed switch» et les sorties via optocoupleurs et Mosfett (ou transistors) pour commander les aiguillages et/ou la vitesse des trains via les sorties PWM.

J’ai utilisé un circuit d’essais afin de vérifier le bon fonctionnement du circuit électronique proposé (voir Figure # 8 et Figure # 9).
 

Figure # 8 – Circuit d’essais de commande de quatre (4) aiguillages
Les bobines des aiguillages ont été remplacées par des DEL afin de simplifier la vérification.
 

Figure # 9 – Circuit d’essais – 8 entrées SN74HC595 – 8 sorties SN74HC595
J’ai réussi à programmer 8 entrées/sorties avec deux SN74HC595.

Voir la programmation ci-dessous :

#include <SPI.h>
byte Input, Output, Check=1;
int j;
int NombreBit; // nombre pour inscrire 1 dans tous les bit du registre de sortie
int NombreOUT; // nombre SORTIES
int NombreButtons; // nombre de BOUTONS de INPUT
int BitEguale1; // pour mettre bit a 1
int LatchPin = 4;         // declaration pin Ardduino pour Latch
int ReedSwitch = 2;       // declaration pin Ardduino pour INPUT
 
void setup(){

  Serial.begin( 9600 );         // active le Serial Monitor
  Serial.println( "in setup" ); // Annotation pour suivit de progression sur le Serial monitor
  pinMode(13, OUTPUT);// (BRUN)  CLOCK = MUST USE THIS PIN because of SPI
  pinMode(11, OUTPUT);// (VERT)  DATA = MUST USE THIS PIN because of SPI
  pinMode( LatchPin, OUTPUT );  // (BLANC) LATCH
  pinMode( ReedSwitch, INPUT ); // (ROUGE) INPUT from BUTTONS
  BitEguale1 = pow( 2, 8 )-1 ; // = 255 pour un byte de 8 bits = 11111111 
  NombreButtons = 8;
 
  // Setup pour SPI
 
  SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  SPI.begin();
  SPI.transfer(BitEguale1);  //  set all outputs to high on first register
  Serial.println( " SENT 255 " );  // Annotation pour suivit de progression sur le Serial monitor
  SPI.transfer(0);    //  set all outputs to low on first register and transfer 255 to second register to set all pins high
  Serial.println( "SENT 0" );  // Annotation pour suivit de progression sur le Serial monitor
  digitalWrite(LatchPin, HIGH);  // activate register output to display LED
  digitalWrite(LatchPin, LOW);   //  deactivate so that output will n ot change
  attachInterrupt(0, pin_read, RISING);
  Serial.println( "...done with setup!" );  // Annotation pour suivit de progression sur le Serial monitor
}//setuup

void loop(){

}//loop


  void pin_read(){
    Serial.println( "in pin_read" );        // Annotation pour suivit de progression sur le Serial monitor

    for(j=0; j<50; j++)
    delayMicroseconds(1000);

    Check=1;
    for(j=0; j<8; j++){
  SPI.transfer(Check);
  SPI.transfer(Output);
  digitalWrite(LatchPin, HIGH);
  digitalWrite(LatchPin, LOW);
  delayMicroseconds(500);
  if(digitalRead(ReedSwitch)==HIGH)
      bitWrite(Output, j, 1); // lire pin #2 ecrire 1 si HIGH
  else
      bitWrite(Output, j, 0); // ecrire 0 si LOW
         
   Serial.print( "Byte=" );
   Serial.print( j );
   Serial.print( ", position=" );
   Serial.print( j );
   Serial.println( " Next loop "  );
   Serial.print ( Output );
 
  Check = Check<<1;
    }//j
   
  SPI.transfer(BitEguale1);  //  set all outputs to high on first register
  SPI.transfer(Output);
  digitalWrite(LatchPin, HIGH);
  digitalWrite(LatchPin, LOW);

}//pin_read

Le programme semble fonctionner correctement sauf :

   Le premier DEL ne fonctionne pas PROBLEME RÉGLÉ: LE PREMIER OPTO ETAIT DEFECTUEUX

QUESTION :

1)   erreur de programmation Je n’arrive pas à trouver l’erreur. - PROBLEME RÉGLÉ
2)   Je n’arrive cependant pas à trouver la programmation avec trois (3) SN74HC595 en série pour les 24 entrées et trois (3) autres SN74HC595 en série pour les sorties.

La raison des trois SN74HC595 est pour avoir 24 entrées et 24 sorties pour commander huit ( aiguillages (avec trois reed switch par aiguillages) ou 12 aiguillages (reed switch D1 et D2 branchées en parallèle, Figure #5)

Prochaine étape :

Suite à la suggestion de Dominique, je vais essayer le même circuit mais avec un SN74HC597 pour les entrées et un SN74HC595 pour les sorties.

À suivre...

[Dominique]

Bonjour Alain,
 
C’est un grand plaisir de voir un Canadien sur Locoduino. Merci pour votre interêt pour nos articles !

Voici quelques éléments de réponses en attendant une étude de votre sketch :

1) le 74HC595 est une registre à décalage cascadable qui convient parfaitement pour fabriquer des sorties, mais pas des entrées.
Je m’en sers dans mon TCO pour alimenter 72 leds : 36 leds vertes (positions d’aiguilles) avec 5 x 74HC595 chainés et 36 led rouges (occupations des zones) avec aussi 5 x 74HC595 chainés selon ce schéma exemple :



J’ai monté les 10 x 74HC595 sur une platine au format euro avec des borniers à vis et il suffit de 4 fils pour la faire fonctionner (ici avec un Nano pour les tests).
J’ai préféré faire 2 chaines de 5 x 74HC595 plutôt qu’une seule de 10 car les performances m’ont semblé meilleures.
Je n’utilise pas les ports du SPI que j’ai réservé pour le CAN, mais les pins 3, 4, 5, 6 comme vous le verrez dans le soft.

Je trouve d'ailleurs que votre utilisation du SPI est bien compliquée. Vous pouvez facilement changer en vous inspirant de mon code, ça résoudra peut-être le problème.




Pour le soft, voici ce que j’utilise sur un Mega 2560 qui gère aussi les 20 entrées des clés d’aiguilles (sur des pins du 2560 directement) et un bus de communication CAN avec les autres Arduino (sur le bus SPI).
J’ai écrit une petite animation de type « sapin de Noel » au démarrage qui est du plus bel effet et est un excellent test :

Code: [Sélectionner]

///////////////////// Définitions des LEDS /////////////////////////////

// Pin connectee a Clock du 74HC595
const int CLOCK = 3;
// Pin connectee à DataIn du 74HC595
const int DATA = 4;
// Pin connectee a Latch des 2 bancs de 74HC595
const int LATCHV = 5;  // banc de Leds Vertes
const int LATCHR = 6;  // banc de Leds Rouges

// Banc de Leds : bit indexBit of byte indexByte
byte ledrouge[5] = {0, 0, 0, 0, 0};
byte ledverte[5] = {0, 0, 0, 0, 0};

void setup()
{
  bool pos;   // pour une position de clef
 
  //set pins to output so you can control the shift register
  pinMode(LATCHV, OUTPUT);
  pinMode(LATCHR, OUTPUT);
  pinMode(CLOCK, OUTPUT);
  pinMode(DATA, OUTPUT);
 
  animations();
}
 
///////////////////////////////////////////////////////////////////////////////
void affiche_leds()   // rouges et vertes
{
   //Affichage de l'état des 2 bancs ledrouge[5] et ledverte[5]
  TIME = micros();
 
  // Desactivation de latchPin Verte > low
  digitalWrite(LATCHV, LOW);
  // shift out the bits:
  for (int i=0; i<5; i++)
  {
    shiftOut(DATA, CLOCK, MSBFIRST, ledverte[i]);
  }
  //activation de latchPin Verte > high so the LEDs update:
  digitalWrite(LATCHV, HIGH);
 
  // Desactivation de  latchPin Rouge > low
  digitalWrite(LATCHR, LOW);
  // shift out the bits:
  for (int j=0; j<5; j++)
  {
    shiftOut(DATA, CLOCK, MSBFIRST, ledrouge[j]);
  }
  //activation de  latchPin Rouge > high so the LEDs update:
  digitalWrite(LATCHR, HIGH);
}

///////////////////////////////////////////////////////////////////////////////
void affiche_rouges()   // rouges seules
{
  // Desactivation de  latchPin Rouge > low
  digitalWrite(LATCHR, LOW);
  // shift out the bits:
  for (int j=0; j<5; j++)
  {
    shiftOut(DATA, CLOCK, MSBFIRST, ledrouge[j]);
  }
  //activation de  latchPin Rouge > high so the LEDs update:
  digitalWrite(LATCHR, HIGH);
}

///////////////////////////////////////////////////////////////////////////////
void affiche_vertes()   // vertes seules
{ 
  // Desactivation de latchPin Verte > low
  digitalWrite(LATCHV, LOW);
  // shift out the bits:
  for (int i=0; i<5; i++)
  {
    shiftOut(DATA, CLOCK, MSBFIRST, ledverte[i]);
  }
  //activation de latchPin Verte > high so the LEDs update:
  digitalWrite(LATCHV, HIGH);
}


///////////////////////////////////////////////////////////////////////////////
void animation(int tempo)
{
  for (int i=0; i<5; i++)
  {
    for (int j=0; j<8; j++)
    {
      bitSet(ledverte[i], j);
      affiche_vertes();
      delay(tempo);
    }
  }
  for (int i=0; i<5; i++)
  {
    for (int j=0; j<8; j++)
    {
      bitSet(ledrouge[i], j);
      affiche_rouges();
      delay(tempo);
    }
  }
  for (int i=0; i<5; i++)
  {
    for (int j=0; j<8; j++)
    {
      bitClear(ledverte[i], j);
      affiche_vertes();
      delay(tempo);
    }
  }
  for (int i=0; i<5; i++)
  {
    for (int j=0; j<8; j++)
    {
      bitClear(ledrouge[i], j);
      affiche_rouges();
      delay(tempo);
    }
  }
}

Vous trouverez des informations très pertinentes ici :
http://www.gammon.com.au/forum/?id=11518

2) En ce qui concerne les entrées, je pense qu'il faut plutot utiliser le 74HC195.

Vous trouverez ici des conseils d'utilisation garantis :
http://www.gammon.com.au/forum/?id=11979

3) En ce qui concerne Processing, il y a plusieurs articles qui vont y être consacrés bientôt, notamment pour faire un TCO. Mais commander des trains serait aussi possible évidemment.

Je suis d'ailleurs en train de le tester personnellement avec le logiciel DCC++ de Gregg E. Berman, ce tests seront publiés prochainement sur Locoduino.

4) Enfin, vu le nombre d'entrées et de sorties que votre projet utilise, je vous conseille d'intégrer dès le départ un Arduino Mega 2560 qui dispose de 70 entrées/sorties : ça réduit considérablement les besoins de matériels autour.
Personnellement j'ai utilisé des pins de l'Arduino pour les toutes les entrées (capteurs de consommation et clés de commandes d'aiguilles) et des 74HC595 pour les sorties (Leds) car, là ça dépassait les limites du Mega.

Si vous voulez plus de détails sur ma réalisation et son logiciel, je peux vous transmettre mes documents

[Alain]

Bonjour Dominique,

Merci pour les commentaires. Je vais les étudier attentivement.

Je vais essayer d'obtenir le 74HC195 en remplacement du 74HC595 pour les entrées.

Bien que j’utilise un Arduino UNO pour le moment, j’ai aussi en main un MEGA 2560. Je ne vois cependant pas les 70 pin, j’en identifie 54.
Je suis d’accord que l’utilisation du MEGA faciliterait grandement les choses mais je recherche la solution la plus économique. Des  shift register en série coûte beaucoup moins cher qu’une carte Arduino. Lorsque j’aurai trouvé la solution, je pense même faire une vérification avec un Arduino NANO.

Merci pour les commentaires, mais le «processing» viendra plus tard.
Au plaisir
Alain

[Dominique]

54 digitales + 16 analogiques = 70 !

Je n'ai rien contre les extensions matérielles, mais je pense que la difference de coût du Mega par rapport au Nano (6-7$) ne justifie pas les composants externes vu le temps et les $ pour les assembler.

En plus c'est pas la place qui manque sous le réseau !

Derrière mon tableau de bord se cachent plusieurs Mégas et un Due. Les petits Nanos et Minis viendront animer le décor qui reste à faire !

[Alain]

Je laisse tomber le SPI et vais faire un dernier essais avec votre code comme base.

Si cela ne fonctionne pas, j'utiliserai le MEGA à un coût plus élevé.

À Montréal, le MEGA = 35$, UNO = 25$, NANO = 12$ ou alors acheter sur ebay de la Chine!

Alain

[Dominique]

À Montréal, le MEGA = 35$, UNO = 25$, NANO = 12$ ou alors acheter sur ebay de la Chine!

Alain

Bonjour Alain,
Chez nous aussi c'est ce prix là !

Moi j'achète sur eBay : voir l'article "où acheter"
http://www.locoduino.org/spip.php?article13

On trouve des Mega au prix de ton Nano, même en évitant le CH340 qui nécessite l'installation d'un driver chinois.

Il me semble que c'est plus simple de se passer du SPI pour piloter des 595.

Si tu veux je peux t'envoyer le code complet de mon TCO.

Cordialement

[Alain]

Dominique,

Encore une fois merci pour votre aide.
 
Votre TCO serait probablement très utile.

Merci

Cordialement

Alain

[Dominique]

Je l'ai envoyé par mail
Cordialement