LOCODUINO - Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Le 3 mars 2017.
Par : Christian

DIFFICULTÉ :★☆☆

Comme on l’a vu dans l’article La carte Arduino Uno, les sorties numériques délivrent très peu de courant et pour pouvoir commander certains accessoires sur un réseau, il est nécessaire de compléter les cartes Arduino par un peu d’électronique. Différentes solutions sont possibles parmi lesquelles l’utilisation de relais qui permettent de commander des courants forts à partir de courants faibles ainsi que d’assurer une parfaite isolation galvanique entre ces deux types de courants. Vous trouverez dans l’article Démarrer en électronique un cours d’électronique pour débutants où le chapitre 6 résume ce qu’il faut connaître des relais. Vous pouvez aussi consulter l’article Relais électromagnétique. Cependant, si votre projet se limite à utiliser quatre relais 1 RT (un contact repos et un contact travail par relais), il est plus simple de faire appel à la carte shield 4 Relais d’Arduino que nous allons décrire ici.

Une carte shield disposant de 4 relais de type 1 RT

La carte "Arduino 4 Relays Shield" est une carte au format shield, c’est-à-dire une carte dont la dimension est analogue à une carte Arduino Uno, munie de connecteurs mâles permettant de la connecter dans les connecteurs femelles de la carte Arduino. La figure 1 montre cette carte 4 relais.


Figure 1: La carte shield 4 relais

Comme on le voit sur la figure 1, la carte dispose de 4 relais (en blanc) de type 1 RT : pour chaque relais, un contact commun peut être relié à un contact R lorsque le relais est au repos (c’est-à-dire lorsque le relais n’est pas alimenté) ou bien à un contact travail T lorsque le relais est alimenté. Le contact commun est noté C sur les connecteurs (en bleu), le contact repos est noté NC (normaly connected ou normalement connecté) et le contact travail est noté NO (normaly open ou normalement ouvert si le relais n’est pas alimenté). Les relais sont numérotés de 1 à 4 et les connecteurs associés sont au plus proche de chaque relais.

Pour commander un relais, il suffit de mettre à l’état haut (HIGH) la sortie numérique qui lui est associée. Le tableau suivant résume les sorties à utiliser pour chaque relais.

Relais	Sortie N°
1	4
2	7
3	8
4	12

Les sorties à l’état haut commandent les relais par l’intermédiaire de transistors à effet de champ ; ceux-ci étant sensibles aux décharges électrostatiques, la carte shield est livrée avec ses connecteurs enfichés sur une mousse conductrice et il faut faire attention lorsqu’on manipule la carte de ne pas être porteur de charges électrostatiques (il suffit d’éviter de toucher les connecteurs mâles de la carte shield).

Le lien suivant permet d’afficher le plan de la carte shield :
http://download.arduino.org/product...

On constate que les relais sont munis d’une diode de roue libre (en parallèle avec le bobinage) ainsi que d’une DEL de contrôle qui s’allume lorsque le relais est commandé (qu’on peut voir en haut à gauche de la figure 1 juste sous le bouton RESET). Chaque relais consomme 35 mA, ce qui représente une consommation totale de 140 mA si on commande les quatre relais en même temps.

Tous les signaux de la carte Arduino peuvent être récupérés sur les connecteurs femelles de la carte shield (en noir sur la figure 1), ainsi que sur des connecteurs au format TinkerKit permettant la création de prototypes basés sur les modules du même nom.

Les quatre relais peuvent être utilisés comme des interrupteurs pour commander des accessoires du réseau. Les contacts sont prévus pour supporter 2 A sous 30 V ce qui correspond tout à fait aux courants utilisés en modélisme ferroviaire et comme les relais assurent une isolation galvanique avec les cartes Arduino, on peut tout à fait les utiliser pour commander du courant alternatif comme celui délivré par la sortie accessoire de notre transformateur et ainsi commander des aiguilles à solénoïdes.

Comme application pratique de cette carte shield au modélisme ferroviaire, je vous propose d’élaborer un Block Automatique Lumineux qui pourra être installé sur un circuit ferroviaire de base, comme un ovale de voie souvent proposé par les coffrets de départ. Nous allons ainsi créer sur cet ovale, quatre cantons où deux trains peuvent se suivre sans se rattraper.

Principe du Block Automatique Lumineux (B.A.L)

Le circuit ferroviaire est divisé en cantons successifs qui sont des portions de voie sur lesquelles circulent les trains. La première règle, inviolable, est la suivante :
Un canton ne peut être occupé que par un train et un seul à la fois.

Cela peut paraître évident mais la SNCF autorise parfois un train à entrer, en condition de marche à vue, sur un canton déjà occupé. Dans le cas d’un réseau de trains miniatures en exploitation analogique, la règle précédente doit être absolument respectée.

Une deuxième règle est qu’ un canton ne peut avoir que deux états possibles : soit il est libre, soit il est occupé. S’il est libre, un train peut donc pénétrer dessus, s’il est occupé, le train ne peut pas entrer dans le canton afin de respecter la première règle.

Chaque canton possède à son entrée un signal lumineux à trois feux (vert, rouge, orange). Si le signal est vert (voie libre VL), les deux cantons situés après le signal sont libres et le train peut continuer son chemin. Si le signal est orange (avertissement A), le canton suivant est libre mais pas celui d’après ; le train est averti qu’il aura peut-être à s’arrêter un peu plus loin et il doit ralentir. Si le signal est rouge (sémaphore S), cela veut dire que le canton derrière le signal est occupé et le train ne doit pas franchir le signal.

Cette division du circuit ferroviaire en cantons avec chacun un signal lumineux à trois feux constitue un Block Automatique Lumineux (B.A.L) selon les principes de la SNCF. Le B.A.L permet d’espacer les trains pour être sûr qu’ils ne se rattrapent pas. Le tableau suivant résume ce que nous venons de dire.

Signal du Canton N	Canton N	Canton (N+1)	ZA(N-1) alimentée ?
Vert (VL)	Libre	Libre	oui
Orange(A)	Libre	Occupé	oui
Rouge (S)	Occupé	- - -	non

Dans un train réel, c’est au conducteur de respecter les signaux lumineux. Dans un réseau de trains miniatures, il faut commander les trains. En numérique, il suffit d’envoyer des ordres par l’intermédiaire de la centrale numérique à la locomotive pour que celle-ci obéisse. En analogique, commander les trains revient à commander la voie et pour qu’une locomotive s’arrête devant un signal, il est nécessaire de créer une zone d’arrêt alimentée ou non selon la couleur du signal ; c’est ce qu’indique la dernière colonne du tableau. L’avantage de cette zone d’arrêt est que la locomotive s’arrête juste devant le signal mais l’inconvénient est que l’arrêt et le redémarrage sont brusques puisque le courant est coupé ou remis de façon non progressive.

Si le principe du B.A.L reste simple, sa réalisation devient vite compliquée car un train n’est pas ponctuel mais constitué d’une locomotive et d’un certain nombre de wagons ou voitures qui peuvent se trouver sur plusieurs cantons en même temps. De plus, le train peut être remorqué par deux locomotives (ou plus) ou encore être poussé comme nos trains de banlieue. Toutes ces possibilités compliquent la résolution d’un B.A.L adapté au modélisme ferroviaire et l’exercice que je vous propose est donc limité à un B.A.L extrêmement simplifié comme nous allons le voir.

Constitution du circuit

Pour que cette réalisation soit à la portée des débutants, nous allons considérer dans la suite de cet article que notre B.A.L est installé sur un ovale de voie, lui-même divisé en quatre cantons. Bien évidemment, on peut aussi l’installer sur un réseau plus sophistiqué.

L’ovale de voie est constitué de 12 coupons courbes et 4 coupons droits, chaque coupon étant plus long que les locomotives ou autorails en circulation afin de réaliser facilement les zones d’arrêt en remplaçant certaines éclisses métalliques par des éclisses isolantes. On peut ainsi utiliser un coffret de départ bon marché pour constituer le circuit, mais rien n’empêche d’utiliser également de la voie courbable et de sectionner un des deux rails pour constituer les zones d’arrêt. L’ovale est divisé en quatre cantons de longueurs égales, chaque canton étant constitué d’une zone de pleine voie (ZPV, alimentée en permanence) et d’une zone d’arrêt (ZA, commandée par les relais de la carte shield). La figure 2 montre le circuit à réaliser.


Figure 2: Le circuit ovale avec quatre cantons

L’ovale est parcouru uniquement dans un seul sens, celui des aiguilles d’une montre. Le rail extérieur (en bleu sur la figure 2) est d’un seul tenant et est relié à la borne (-) du transformateur d’alimentation. Le rail intérieur (en rouge) est divisé par des éclisses isolantes (en vert) pour constituer nos quatre zones d’arrêt ; les rails rouges des ZPV sont reliés au (+) du transformateur d’alimentation, les rails rouges des zones d’arrêt sont reliés aux connecteurs NC des relais puisque ce sont eux qui commandent ces zones d’arrêt qui sont constituées d’un seul coupon de voie (droit ou en courbe) sur ce circuit très simple. Il y a donc à prévoir quelques soudures de fils électriques sous les rails afin d’apporter le courant nécessaire à la traction des trains.

Division de l’ovale de voie en quatre cantons

Les cantons sont délimités par des ILS (Interrupteurs à Lames Souples, voir l’article Entrées numériques et résistance pull-up (2)) placés quelques cm plus loin que l’entrée du canton (ils sont repérés par un triangle vert sur la figure 2). Un signal à trois feux se trouve à chaque entrée de canton et est géré par la carte Arduino Uno.

L’ILS situé en entrée de canton peut aussi être considéré comme l’ILS de sortie du canton précédent (dans le sens de marche du train). Quand un train franchit un ILS, il entre dans le canton N et libère le canton N-1. L’entrée dans le canton N met au rouge le signal du canton N et coupe le courant dans la zone d’arrêt du canton N-1 ; ainsi le train suivant s’arrête sur cette zone d’arrêt et ne peut pas sortir du canton N-1 tant que le canton N n’est pas libéré. Ce système permet de respecter la règle numéro 1 citée plus haut. Sur le circuit qui est bouclé, le canton 4 précède le canton 1.

L’ILS d’entrée doit allumer le signal du canton au rouge un peu après que l’engin moteur soit entré, comme dans la réalité. Ceci permet d’éviter de couper le courant dans la zone d’arrêt précédente alors que l’engin moteur n’en est pas complètement sorti. L’ILS doit donc se situer légèrement plus loin que l’entrée de canton afin qu’il soit déclenché lorsque la locomotive a bien quitté le canton précédent ; la distance entre l’entrée du canton et l’ILS est à régler en fonction de votre matériel. Une autre solution pour parvenir au même résultat est de positionner l’aimant actionnant l’ILS sur le premier wagon tracté ou sur la remorque d’un autorail.

L’utilisation d’ILS pour délimiter les cantons présente des avantages et des inconvénients. Parmi les avantages, les ILS peuvent être posés sur un réseau déjà terminé sans rien modifier sur les rails, ce qui permet déjà d’avoir une signalisation fonctionnelle au passage d’un train mais pas d’espacer plusieurs trains puisqu’aucune zone d’arrêt n’est créée. Dans ce cas, on peut se passer de la carte shield et un simple module Arduino Uno prendra en charge la signalisation. Un autre avantage est que les ILS comptent sans état d’âme tout ce qui rentre et sort du canton. Parmi les inconvénients, les trains sont considérés comme ponctuels puisque seule la locomotive est détectée mais pas les wagons qui suivent ; ce système est plutôt à réserver à des circulations d’autorails, de draisines, de locomotives haut-le-pied (sans wagons) ou bien de trains courts constitués d’un ou deux wagons maximum.

Notre circuit en forme d’ovale est maintenant terminé ; il est divisé en quatre cantons, chaque canton est associé à un signal à trois feux donnant l’état d’occupation du canton et dispose d’une zone d’arrêt qui empêche un engin moteur de quitter le canton si le canton suivant n’est pas libre. Voyons maintenant comment le module Arduino va gérer ce circuit.

Gestion du circuit par Arduino

Sur le plan matériel, on voit qu’Arduino doit pouvoir commander le courant dans quatre sections de voie (les zones d’arrêt) et pour le faire, il va utiliser le shield Arduino quatre relais. Comme il ne peut y avoir qu’un engin moteur à la fois sur la zone d’arrêt à commander, on peut penser que le courant maximum sera de 1 A tout au plus (en N ou H0). Les contacts des relais de ce shield sont capable de passer 2 A sous 30 V, ce qui est donc suffisant quelle que soit l’échelle. On rappelle que les broches utilisées pour les quatre relais sont les broches 4, 7, 8 et 12. Il faut de plus quatre broches pour surveiller les ILS, et quatre fois 3 broches pour allumer les signaux à trois feux de type BAL. Au total, on arrive à 20 broches numériques d’entrées-sorties, ce qui tient sur un module Uno. Cependant, pour ne pas avoir à utiliser Tx et Rx, on peut remarquer que l’utilisation d’un relais pour couper le courant sur une zone d’arrêt implique de mettre au rouge le signal correspondant. Les DEL rouges peuvent être connectées aux broches de commande des relais (4, 7, 8 et 12), ce qui économise quatre broches.

Sur le plan logiciel, tout ce qu’il y a à connaître est l’état d’occupation des cantons. On peut utiliser une variable booléenne égale à TRUE (ou 1) si le canton est occupé et FALSE (ou 0) s’il est libre. En fonction de l’état d’occupation des cantons, on règle les signaux à trois feux selon les règles du B.A.L citées plus haut. L’algorithme est donc :
ILS N détecté >>> Canton N occupé, Canton N-1 libéré >>> Signal N au rouge ET ZA (canton N-1) non alimenté ( STOP)

Si un signal est au rouge, la zone d’arrêt qui se trouve devant le signal est non alimentée, ce qui fait qu’aucun train ne peut passer le signal tant que le canton n’est pas libéré. Les feux des signaux sont commandés par un état HIGH sur les broches correspondantes ; ils doivent être à cathodes communes. La figure 3 montre comment relier le module Arduino Uno et son shield « 4 Relays » aux éléments du circuit. Pour chaque signal, un seul feu est allumé à la fois, ce qui permet de n’avoir qu’une seule résistance de limitation par signal (de l’ordre de 330 Ω, voir article Fonctionnement et pilotage d’une DEL).


Figure 3: Liaisons entre carte shield et accessoires du circuit

Le câblage avec le circuit est très simple : les ZPV sont constamment alimentées (1), les ZA le sont par la cartes shield (2), ainsi que les LED rouges des signaux (3), les LED oranges et vertes des signaux sont alimentées par des sorties numériques du module Arduino (4).

(1) : ceci a été expliqué un peu plus haut.
(2) : les ZA sont reliées aux connecteurs NC des relais, les connecteurs C étant reliées au + de la sortie DC du transformateur. Chaque relais alimente la zone d’arrêt du canton précédent, donc le relais 1 alimente la zone d’arrêt du canton 4.
(3) : les sorties 4, 7, 8 et 12 sont à repiquer sur le shield 4 relais
(4) : voir la figure 3

Le logiciel de contrôle

Pour être certain de ne pas louper de fermetures d’ILS, le mieux est de faire appel aux interruptions. Sur un module Arduino Uno, seules deux broches savent gérer les interruptions externes, ce qui est insuffisant puisque nous avons quatre ILS à surveiller. Heureusement pour nous, le microcontrôleur ATmega328P qui équipe les cartes Arduino sait gérer des interruptions externes sur d’autres broches et en utilisant le travail d’autres programmeurs (et notamment une bibliothèque spécialisée), nous pouvons programmer des interruptions externes sur les entrées analogiques du module (au nombre de 6, ce qui est suffisant pour nos 4 ILS qui sont reliés aux entrées analogiques A0 à A3, utilisées comme des entrées numériques). Je vous invite à lire l’article de Jean-Luc Les interruptions (1) afin de comprendre comment utiliser la bibliothèque permettant de créer des interruptions externes sur les broches analogiques. Je n’ai rien fait d’autre que d’adapter son programme aux besoins de mon montage.

La routine d’interruption est très simple puisqu’elle ne fait que gérer les variables booléennes associées aux cantons. Le programme en lui-même règle les signaux en fonction des états d’occupation des cantons. Bien entendu, il vous faudra importer dans l’IDE la bibliothèque « PinChangeInt », comme expliqué dans l’article de Jean-Luc (voir également l’article Installer une bibliothèque). Commentons un peu le programme donné ci-dessous.

La première ligne permet d’utiliser la bibliothèque puis on définit les branchements des ILS et des feux pour chaque signal ainsi que quelques variables. Ensuite, on définit les routines d’interruptions qui seront exécutées lors des fermetures des ILS ; elles ne font que définir l’état d’occupation des cantons concernés. Le setup déclare les entrées d’ILS en INPUT_PULLUP, ce qui évite d’avoir à utiliser des résistances de rappels (on utilise celles internes au microcontrôleur), déclare les sorties pour commander les feux et les relais, puis allume tous les signaux au vert et enfin déclare la façon dont les interruptions externes sont rattachées aux entrées des ILS (voir l’article de Jean-Luc Les interruptions (1)). La fonction loop examine comment allumer les signaux en fonction des états d’occupation des cantons suivants en respectant les règles du B.A.L ; on rappelle qu’un signal positionné au rouge entraîne la coupure du courant sur la ZA précédant le signal. La modification de l’état d’un signal lumineux implique d’éteindre complètement le signal avant d’allumer le feu qui doit l’être.

/*
 * programme "cantons_Arduino.ino"
 * 
 * ce programme gere le cantonnement du locodrome 4 cantons
 * le montage a realiser est celui de la figure 3
 * il utilise la carte shield 4 relais d Arduino
 * la commande d un relais coupe l alimentation de la ZA et par
 * la meme occasion met le signal au rouge
 */

#include <PinChangeInt.h>

// definition des ILS
const byte pinILS1 = A0;
const byte pinILS2 = A1;
const byte pinILS3 = A2;
const byte pinILS4 = A3;

// Signal 1
const byte S1_vert = 2;
const byte S1_orange = 3;
const byte S1_rouge = 4;

// Signal 2
const byte S2_vert = 5;
const byte S2_orange = 6;
const byte S2_rouge = 7;

// Signal 3
const byte S3_vert = 9;
const byte S3_orange = 10;
const byte S3_rouge = 8;

// Signal 4
const byte S4_vert = 11;
const byte S4_orange = 13;
const byte S4_rouge = 12;
 
volatile boolean canton1 = false;
volatile boolean canton2 = false;
volatile boolean canton3 = false;
volatile boolean canton4 = false;
 
const unsigned long dureeAntiRebond = 1;
 
void interruptILS1()
{
  static unsigned long dateDernierChangement = 0;
  
  unsigned long date = millis();
  if ((date - dateDernierChangement) > dureeAntiRebond) {
    canton1 = true;
    canton4 = false;
    dateDernierChangement = date;
  }
}
 
void interruptILS2()
{
  static unsigned long dateDernierChangement = 0;
  
  unsigned long date = millis();
  if ((date - dateDernierChangement) > dureeAntiRebond) {
    canton2 = true;
    canton1 = false;
    dateDernierChangement = date;
  }
}
 
void interruptILS3()
{
  static unsigned long dateDernierChangement = 0;
  
  unsigned long date = millis();
  if ((date - dateDernierChangement) > dureeAntiRebond) {
    canton3 = true;
    canton2 = false;
    dateDernierChangement = date;
  }
}
 
void interruptILS4()
{
  static unsigned long dateDernierChangement = 0;
  
  unsigned long date = millis();
  if ((date - dateDernierChangement) > dureeAntiRebond) {
    canton4 = true;
    canton3 = false;
    dateDernierChangement = date;
  }
}
 
void setup()
{
  /*
   * Programme les broches des ILS en entree
   * et active le pullup interne
   */
  pinMode(pinILS1, INPUT_PULLUP);
  pinMode(pinILS2, INPUT_PULLUP);
  pinMode(pinILS3, INPUT_PULLUP);
  pinMode(pinILS4, INPUT_PULLUP);

  /*
   * Programme les feux des signaux en sortie
   */
   for(int i = 2; i < 14; i++){
    pinMode(i, OUTPUT);
   }

   /*
    * Eteint tous les feux des signaux
    */
    for(int j = 2; j < 14; j++){
      digitalWrite(j, LOW);
    }

    /*
     * Allume les quatre signaux au vert au debut du jeu
     */
     digitalWrite(S1_vert, HIGH);
     digitalWrite(S2_vert, HIGH);
     digitalWrite(S3_vert, HIGH);
     digitalWrite(S4_vert, HIGH);
  
  /*
   * accroche les ISR aux pins
   */
  PCintPort::attachInterrupt(pinILS1, interruptILS1, FALLING);
  PCintPort::attachInterrupt(pinILS2, interruptILS2, FALLING);
  PCintPort::attachInterrupt(pinILS3, interruptILS3, FALLING);
  PCintPort::attachInterrupt(pinILS4, interruptILS4, FALLING);
}
 
void loop()
{
  // Traitement du signal 1
  if(canton1){ // Signal 1 au rouge
    digitalWrite(S1_vert, LOW);
    digitalWrite(S1_orange, LOW);
    digitalWrite(S1_rouge, HIGH); // + ZA4 stop
  }
  if(!canton1 && canton2){ // Signal 1 a l orange
    digitalWrite(S1_vert, LOW);
    digitalWrite(S1_rouge, LOW); // + ZA4 go
    digitalWrite(S1_orange, HIGH);    
  }
  if(!canton1 && !canton2){ // Signal 1 au vert
    digitalWrite(S1_orange, LOW);
    digitalWrite(S1_rouge, LOW);
    digitalWrite(S1_vert, HIGH);    
  }

  // Traitement du signal 2
  if(canton2){ // Signal 2 au rouge
    digitalWrite(S2_vert, LOW);
    digitalWrite(S2_orange, LOW);
    digitalWrite(S2_rouge, HIGH); // + ZA1 stop
  }
  if(!canton2 && canton3){ // Signal 2 a l orange
    digitalWrite(S2_vert, LOW);
    digitalWrite(S2_rouge, LOW); // + ZA1 go
    digitalWrite(S2_orange, HIGH);    
  }
  if(!canton2 && !canton3){ // Signal 2 au vert
    digitalWrite(S2_orange, LOW);
    digitalWrite(S2_rouge, LOW);
    digitalWrite(S2_vert, HIGH);    
  }

  // Traitement du signal 3
  if(canton3){ // Signal 3 au rouge
    digitalWrite(S3_vert, LOW);
    digitalWrite(S3_orange, LOW);
    digitalWrite(S3_rouge, HIGH); // + ZA2 stop
  }
  if(!canton3 && canton4){ // Signal 3 a l orange
    digitalWrite(S3_vert, LOW);
    digitalWrite(S3_rouge, LOW); // + ZA2 go
    digitalWrite(S3_orange, HIGH);    
  }
  if(!canton3 && !canton4){ // Signal 3 au vert
    digitalWrite(S3_orange, LOW);
    digitalWrite(S3_rouge, LOW);
    digitalWrite(S3_vert, HIGH);    
  }

  // Traitement du signal 4
  if(canton4){ // Signal 4 au rouge
    digitalWrite(S4_vert, LOW);
    digitalWrite(S4_orange, LOW);
    digitalWrite(S4_rouge, HIGH); // + ZA3 stop
  }
  if(!canton4 && canton1){ // Signal 4 a l orange
    digitalWrite(S4_vert, LOW);
    digitalWrite(S4_rouge, LOW); // + ZA3 go
    digitalWrite(S4_orange, HIGH);    
  }
  if(!canton4 && !canton1){ // Signal 4 au vert
    digitalWrite(S4_orange, LOW);
    digitalWrite(S4_rouge, LOW);
    digitalWrite(S4_vert, HIGH);    
  }

}

Voici une vidéo de démonstration de ce block automatique lumineux :

Block Automatique Lumineux avec Arduino
par Christian de LOCODUINO

https://vimeo.com/203867251

Améliorations possibles de ce B.A.L

Le B.A.L que nous venons de créer est extrêmement simplifié et présente des limitations : un seul sens de circulation, arrêt et démarrage brusques, non prise en compte des wagons, non possibilité de trains en pousse, etc. Néanmoins, cet exercice est tout de même intéressant car il reproduit le fonctionnement d’un B.A.L sur un circuit de base (un ovale de voie) en permettant la circulation de deux autorails (ou deux locomotives haut-le-pied plutôt que deux longs trains) et sa réalisation ne demande aucun bricolage électronique compliqué puisqu’on fait appel à une carte Arduino Uno et le shield 4 relais. C’est donc un montage à la portée de tout débutant en Arduino, qui peut bien sûr être adapté à un réseau plus complexe.

Une fois les principes de base bien compris, il est possible d’améliorer ce montage. On peut par exemple remplacer les ILS par des détecteurs d’occupation par consommation de courant qui délivreront un signal à Arduino en fonction de la présence d’engins sur la voie. Bien évidemment, pour connaître l’état d’occupation d’un canton, il faut tester l’occupation à la fois sur la ZPV mais aussi sur la ZA du canton ! On peut aussi mémoriser les états des signaux afin de détecter les changements, ce qui permet de faire démarrer les trains progressivement en injectant un courant pulsé sur la voie. On peut aussi réduire la vitesse des trains au passage d’un signal à l’orange de la même façon. Cela demande un peu plus d’électronique mais ce site vous permet de trouver des solutions à tous ces problèmes. À vous de vous amuser en perfectionnant ce montage en fonction de vos besoins.

61 Messages

Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 mars 2017 14:27, par DDEFF

En tant que "gardien du temple" (je préfère ce terme...) je suis très content de la présentation de ton programme :
|
Bien claire, aérée (ne pas hésiter, comme tu l’as fait, à mettre des lignes blanches pour bien distinguer les blocs), bien indentée, avec des noms de variables "parlants".
En gros, un modèle à suivre.
|
Des schémas clairs (Fritzing ?) et une belle vidéo.
|
Bravo !

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 mars 2017 17:36, par Christian Bézanger
  
  Merci Denis pour ces compliments.
  
  Les figures ont été faites avec Gimp (pour le circuit ovale) et une photo de la carte shield pour le montage. Les signaux ont été créés de toutes pièces pour d’autres articles, toujours avec Gimp, donc je récupère par copier-coller. Lorsque je fais des schémas avec Fritzing, je conserve toujours le logo pour l’indiquer, comme tu pourras le voir sur d’autres articles (ATtiny par exemple).
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 mars 2017 15:28, par Roland

Remarquable didacticiel... qui me rappelle mes premiers pas il y a 60 ans avec mon Märklin, 4 signaux et 4 pédales...
L’étape suivante a été d’arrêter le train le plus lent pour permettre au plus rapise de le dépasser... automatiquement...
Des mois de loisir en perspective...
Félicitations

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 mars 2017 17:41, par Christian Bézanger
  
  Merci Roland.
  Ce que j’espère, c’est que des modélistes reproduiront ce montage qui ne demande aucune connaissances spéciales pour arriver au bout. Le coût du B.A.L est estimé entre 40 et 50 euros, un coffret de départ, tout modéliste en a un, par contre les signaux sont assez chers mais on peut en mettre qu’aux endroits visibles, ou les construire soi-même.
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 mars 2017 18:11, par Roland
    
    Comme je fais surtout de l’américain en LGB, j’utilise soit le sémaphore, soit une simple led bicolore "décorée".
    
    Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 20 mars 2017 17:48, par Gponcery

Bonjour,
après lecture je trouve votre article très intéressant,je pense le réaliser pour une boucle de sept cantons avec une carte Mega 2560, et aussi certaines modifications de fonctionnement, comment je peut vous contacter pour vous faire parvenir ces modifications pour avoir votre avis,

à l’avance merci,

cordialement,
gp

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 21 mars 2017 01:26, par Christian
  
  Bonjour,
  
  Le principe sera le même avec un Arduino Mega, avec la possibilité de traiter plus de cantons.
  Pour développer ce projet, le mieux serait d’ouvrir un fil sur notre forum où je pourrai apporter des réponses qui seraient profitables à tous.
  L’espace pour répondre à un article est plutôt réservé à des remarques sur l’article même et ne se prête pas à des échanges réguliers. Avec le forum, vous aurez également des avis d’autres "Arduineurs".
  Cordialement.
  
  Christian
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 18 octobre 2017 08:42, par Gérard Poncery

Bonjour,
Un system parfait pour démarrer, justement dans le cas ou je voudrait remplacer les ILS par des détecteurs d’occupation par consommation de courant qui délivreront un signal à Arduino en fonction de la présence d’engins sur la voie, le fait de ne plus avoir le décalage de l’ILS dans le canton n+1 risque de bloquer le train avec un passage de n à n+1 celui ci [n+1] bloquant automatiquement n, qu’elle pourrait étre la solution ? une temporisation mais comment ???
merci par avance

cordialement

gp

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 5 janvier 2018 23:52, par Christian
  
  Bonjour,
  
  Désolé de répondre si tard, je n’ai pas dû voir passer le mail de prévenance qu’envoie le site à l’auteur.
  Le système est adaptable à des détecteurs d’occupation par consommation de courant. Dans un premier temps, il faut adapter le signal à ce que peut supporter Arduino : des signaux de 5 V maxi.
  Ensuite, il faut considérer le cas ou un train est à cheval sur deux cantons qui se suivent. En effet, avec les ILS, c’est un peu comme si le train était ponctuel (c’est pourquoi je préconise mon montage pour des trains courts comme des autorails). Ici, le train n’est plus ponctuel, ce qui veut dire des cantons plus longs.
  Sinon, la logique de commande des signaux est la même, et si un canton est occupé, la zone d’arrêt du canton précédent doit être non alimentée.
  Le train ne devrait pas être bloqué car s’il est détecté sur [n+1], il est alimenté par [n+1] même si [n] devient de fait non alimenté. Si ce n’est pas le cas, effectivement, il est possible de rajouter une petite temporisation avant de couper [n].
  Il y a sans doute quelques essais à faire (mon réseau n’est pas assez grand pour de grands cantons), mais je ne vois rien d’insurmontable.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 5 janvier 2018 19:30, par marco

bonjour, je voudrais savoir comment est géré la zn ? car si on est en semaphore il faut delivré du 9V (en lgb et non du 18V) car y a de forte chance que mes locos se suivent a la meme vitesse !!!
sauf une ou 2, peut on voir ca sur le forum ?

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 6 janvier 2018 00:02, par Christian
  
  Qu’appelez-vous zn ?
  Si vous regardez la figure 2, vous voyez que mes cantons n’ont que deux zones, une zone de pleine voie ZPV (toujours alimentée) et une zone d’arrêt ZA (alimentée ou non selon la logique du programme).
  La vidéo montre une deuxième loco plus rapide que la première et elle ne la rattrape pas. Ce montage est donc universel quel que soit l’échelle (LGB ou autre, pourvu que ce soit en analogique). Par contre, il n’est pas prévu pour faire des UM ou de la pousse (un montage aussi simple et aussi bon marché a forcément des limitations et un système universel devient vite complexe).
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 6 janvier 2018 12:17, par marco polo

bonjour christian,
ce que j appelle Zn c est la zone neutre ou la ZPV, comme vous l appellez !!
ce que je veux dire cette zpv doit etre alimentée à mi tension si on franchit le feu en avertissement, sinon notre train passerai de la vitesse avertissement lente sur la Zone d arret precedente a la pleine vitesse sur la zpv et de nouveau de ralentir sur la Zone d arret, non ?

et peux on voir en pv si mon montage arduino est realiste ?

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 7 janvier 2018 11:15, par Christian
  
  Bonjour marco polo,
  
  Décidément, toujours autant de mal à comprendre vos abréviations, notamment "voir en pv" (?)
  Vous pouvez, si vous en avez envie, améliorer le montage que j’ai publié et d’ailleurs, j’incite tous les lecteurs à agir ainsi. Donc, effectivement, si le signal est à l’avertissement (jaune), on peu régler la vitesse sur la ZPV pour faire ralentir le train et pour cela, utiliser une PWM, ce qui reste compatible avec le shield. Ce serait donc l’amélioration N°1 à prévoir à mon montage, qu’Arduino règle la vitesse sur les cantons en fonction des états des signaux.
  Ce site publie des idées d’utilisation des cartes Arduino afin de démontrer leur utilité en modélisme ferroviaire. Chaque article doit être accessible au plus grand nombre, c’est pourquoi je me limite à des choses simples qui peuvent être améliorées, en fonction des besoins de chacun. C’est donc au lecteur de réfléchir à ce qu’il peut tirer d’un article, comment améliorer le comportement du montage, et tout ce dont il a besoin se trouve sur ce site, que ce lecteur soit en analogique ou en numérique.
  Avez-vous réalisé le montage que j’ai décrit ? C’est à mon avis l’étape N°1 pour voir ce qui manque en fonction de votre réseau. Pour certains, ce sera remplacer les ILS par des cartes de détection d’occupation, pour d’autre, ce sera introduire des vitesses variables sur les ZPV. Ceux qui ont un grand réseau où de grands cantons sont possibles pourront aussi rajouter une ZR, zone de ralentissement, sur chaque canton. Tout est imaginable.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 7 janvier 2018 14:48, par marco polo

bonjour christian,

désolé pour les abréviations :) ,je vais éviter d’en faire

(en PV, veut dire en privé ou par messagerie)

Bon, je pense que vous avez compris mon problème,
je désire remplacer les ils par des interrupteur de fin de course ou ça : KW4-3Z-3 (comme sur les imprimantes 3d)

je les place dans le crocodile et la loco en passant dessus active le passage et fais changé l’état du feu
avec un transistor (mofset) je régulerai la puissance délivrée sur le rail

par contre utiliser une carte uno par block pour ca vous parait il raisonnable ?

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 7 janvier 2018 16:08, par Christian
  
  Remplacer les ILS par d’autres capteurs est tout à fait possible, l’important étant qu’ils délivrent un signal au passage du train.
  Bien entendu, mettre une carte Uno par canton est également envisageable sauf que cela augmente le prix de revient en conséquence et je ne connais pas le nombre de cantons que vous voulez faire. De plus, les cartes doivent recevoir les informations du canton aval et envoyer leurs informations au canton amont. Ce n’est pas bien compliqué à faire et vous trouverez sur le site des exemples.
  Je vous invite à ouvrir un fil sur notre forum pour parler de votre projet ; ainsi la communauté pourra vous aider. L’espace de communication après article est plutôt réservé à signaler des erreurs dans l’article ou des difficultés d’interprétation. Merci de votre compréhension.
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 9 janvier 2018 18:25, par marco
    
    voila, j ai ouvert le post avec papa, il est aussi nul que moi, mais on apprends ensemble et lui fait les soudures
    que j ai pas le droit de faire
    
    Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 9 février 2018 21:03, par christophe

Bonsoir Christian
Juste quelques lignes pour vous féliciter de tous les articles que vous écrivez sur ce site. Bravo également pour votre remarquable cours d’électronique. Après quelques décennies de jachère pour cette passion, m’y voila revenu avec la même ferveur.
Je découvre cet univers, je dévore les articles, je teste les montages avant de me lancer dans la construction effective d’un réseau et je suis assidu à vos articles comme ceux de Dominique et jean-luc
Toutes ces réalisations m’incitent à poursuivre sur cette "voie" !
Bien sur cet exemple constitue une base de l’apprentissage avec arduino qu’il est indispensable de connaître avant de pouvoir complexifier selon ses exigences.
Pour le bal, j’ai fait le choix (markliniste analogique)de rester dans la tradition d’un rail de roulement pour la traction et l’autre pour la signalisation (les essieux n’étant pas isolés).
Mon projet réside surtout dans la gestion d’une gare terminus avec les itinéraires.
J’ai encore quelques difficultés dans la gestion des bibliothèques - les fichiers zip ne présentent pas de difficultés particulières car ils prennent leur place naturellement. En revanche, je pêche toujours de savoir sous quelle racine ils doivent être placés. Je poursuis par conséquent mes recherches sur le site.
Encore toutes mes félicitations pour la qualité de vos cours ou articles.

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 2 novembre 2018 17:02, par claude

Bonjour,
Je découvre votre site et en vous félicite. Je vous remercie du partage de vos connaissances.
Cette possibilité de cantons sur un réseau analogique simple avec Arduino me conviendrait bien. En regardant du côté des vendeurs, j’ai remarqué l’indisponibilité de la carte shield relais A000110. Peut-on la remplacer par une autre, et laquelle, comportant des relais bistables. Je n’ai pas trouvé de détail des produits et il me semble que ce type de relais (bistable) est préférable. Merci du renseignement.
Claude

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 2 novembre 2018 18:07, par Christian
  
  Bonjour Claude,
  
  La carte que j’ai utilisée comporte quatre relais de type 1RT. Ceux-ci servent à alimenter ou non les zones d’arrêt des cantons. Il n’est donc pas nécessaire de prévoir des relais bistables.
  On trouve couramment des cartes comprenant jusqu’à 16 relais 1RT (de 5V pour être commandés par Arduino). Il suffit de taper cela dans un moteur de recherché.
  Avec une carte 4 relais (celle de l’article), le circuit avait 4 cantons. Avec 16 relais, il pourrait en avoir 16. Mais attention, il faut autant de sortie pour les commander et chaque canton doit aussi avoir son signal à 3 feux, ce qui représente d’autres sorties. Pour un tel projet, il faudrait utiliser une carte Arduino Mega. Mais tout est possible.
  J’espère que vous trouverez votre bonheur.
  Cordialement.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 27 mars 2019 11:23, par guy vilain

tres intéresse par votre BAL .mon restau en N comporte 4 cantons très grand et je dispose des cartes Arduino classiques
malheureusement la Library pinchangeint que j’ai trouve sur le web ne fonctionne pas rejeté par la compilation
pouvez. vous m’indiquer un site ou trouver cette librairie compatible
merci je dispose d’un pc window 10 et d’un emac

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 27 mars 2019 14:37, par Christian

Bonjour Guy,

Essayez cette page pour télécharger la bibliothèque :
https://code.google.com/archive/p/a...

Et tenez-moi au courant.

Christian

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 29 septembre 2019 18:43, par jls62

bonjour a tous
je dèbute avec arduino , j’ai bien charger la bibliotéque "Interrup.h" et le télèchargement se bloque sur les entrées "ILS" pourquoi ,si quelqu’un pourrait m’expliquer , et sur mon shield a 4 relais , en faisant le teste avec un multimetre je ne trouves que 2 relais sur 4
si quelqu’un pourrait m’aidé merci d’avence

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 29 septembre 2019 21:33, par msport

Bonsoir,
le programme fait appel à PinChangeInt.h comme indiqué dans l’article.
C’est cette bibliothèque qu’il faut charger.
Cordialement

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 1er décembre 2019 19:36, par RHic33

Bonsoir,
je me demandais s’il ne valait pas mieux câbler les ZA sur les bornes non connectées des relais par défaut. Ainsi en cas de problème les trains s’arrêtent tous. Seuls les ZA autorisées seraient alimentées.
Un peu comme le câblage des fins de course sur les machine CNC.
Votre avis ?

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 2 décembre 2019 09:50, par Christian
  
  Vous avez parfaitement raison et c’est sans doute comme cela qu’un ingénieur aurait conçu le système, c’est-à-dire pour qu’il soit "fail safe" (une panne met l’ensemble en sécurité).
  Bien évidemment, dans ce cas, il faut changer la logique : la ZA doit être alimentée si le feu est vert OU orange.
  Comme cet article s’adresse aux débutants avant tout, j’ai préféré aller au plus simple mais ceux qui ont compris le programme peuvent dans un deuxième temps l’améliorer pour que la sécurité de circulation soit maximale.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 4 décembre 2019 18:38, par migeon

Bonsoir Christian,votre bloc automatique lumineux me serait bien utile pour gérer la circulation de deux train (JEP) sur un ovale de présentation a une expo que nous devons faire ,mais je rencontre un problème , a la vérification du code que j’ai copier dans l’article , le message"’PCintPort’has not been declared’"et la ligne 136 est grisée
Help !!

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 4 décembre 2019 21:21, par msport

Peut-être une relecture du paragraphe :

Bien entendu, il vous faudra importer dans l’IDE la bibliothèque « PinChangeInt », comme expliqué dans l’article de Jean-Luc (voir également l’article Installer une bibliothèque).

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 5 décembre 2019 14:52, par migeon

Plusieurs bibliothèque trouvées pour "PinChangeInterrupt.h"
Utilisé : S :\Documents\Arduino\libraries\PinChangeInterrupt
Non utilisé : S :\Documents\Arduino\libraries\PinChangeInterrupt-1.2.6
Utilisation de la bibliothèque PinChangeInterrupt version 1.2.2 dans le dossier : S :\Documents\Arduino\libraries\PinChangeInterrupt
exit status 1
’PCintPort’ has not been declared

Encore moi
Voici le message complet affiché que faut il que je fasse
Merci

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 5 décembre 2019 18:36, par msport

Simplement une relecture du paragraphe :

Bien entendu, il vous faudra importer dans l’IDE la bibliothèque « PinChangeInt », comme expliqué dans l’article de Jean-Luc :

La bibliothèque PinChangeInt

Avant d’utiliser cette bibliothèque, il faut l’installer. L’installation est classique. Comme d’habitude, il faut veiller à ce que les noms des dossiers soient cohérents. Pour ma part, j’ai installé la version 2.19beta que l’on trouve ici : http://code.google.com/p/arduino-pi.... Une fois l’archive zip décompressée, donnant un dossier nommé pinchangeint-v2.19beta. À l’intérieur, vous trouverez un dossier PinChangeInt qu’il faut déplacer dans le dossier bibliothèque de votre dossier de travail. Relancez ensuite l’IDE Arduino.

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 décembre 2019 16:33, par migeon jacques

Ç’a y est j’ai pu y arriver , alors je ne sais pas comment mais la verif est faite et le téléversement semble se faire
J’ai simplement effacé la première ligne include pinchange.....,je l’ai reecrite et ç’a marche
Merci pour votre aide .

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 décembre 2019 18:14, par msport

La bibliothèque à utiliser est PinChangeInt.h
et non PinChangeInterrupt.h comme vous l’aviez fait.

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 décembre 2019 19:24, par migeon
  
  Merci , apprendre de ses erreurs c’est avancer a grands pas comme a dit je ne sais qui !
  D’ailleurs ce soir j’ai programmé un attiny 45 !
  Merci encore pour vos réponses a mes questions .
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 décembre 2019 20:41, par msport

La pédagogie est à base de répétition ...

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 22 avril 2020 23:15, par Marc Breton

beaucoup de difficulté avec le programme, il est exact mais, une correction en apporte une autre SVP venez a mon secoure. Ce site pourrait il m’aider, sérieusement j’aimerais beaucoup plus de l’aide de votre par . Cordialement.

Voir en ligne : marc breton

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 23 avril 2020 11:54, par Christian
  
  Vous voulez qu’on vous aide : soit ! Mais à quoi exactement ? Vous ne posez aucune question...
  Vous semblez avoir apporté des modifications au programme pour l’adapter à vos besoins, mais en quel sens ?
  Ce que je peux vous conseiller est d’ouvrir un fil sur notre forum pour exposer vos problèmes. Soyez précis dans ce qui vous arrive car sinon, comment voulez-vous qu’on vous aide ?
  Juste une question : avez-vous testé le programme dans sa version originale donnée dans l’article ? S’il fonctionne, vos problèmes viennent de vos changements et il faut qu’on comprenne pourquoi.
  Mais rien n’est insoluble.
  Cordialement.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 13 juillet 2020 19:48, par Michel

Bonjour, tout d’abord merci pour votre site.
La fig 3 montre comment relier la carte shield aux accessoires du circuit.
Mais comment relier l’ arduino uno à cette carte shield ?
Merci
Cordialement

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 13 juillet 2020 20:00, par Christian
  
  La carte shield est prévue pour s’enficher dans les connecteurs de la carte Arduino UNO (comme toutes les cartes shield). Donc, il n’y a pas besoin de montrer les connexions entre shield et UNO puisqu’elles seront automatiquement assurées. Mais si vous voulez savoir quels signaux de la carte Arduino sont utilisés, vous pouvez consulter le site www.arduino.cc à cette adresse :
  https://store.arduino.cc/arduino-4-...
  ou à celle-ci pour voir les shields qui existent :
  https://store.arduino.cc/arduino-ge...
  Ce qui est important, c’est que tous les signaux d’Arduino UNO sont récupérables sur les connecteurs de la carte shield et ces connecteurs peuvent aussi servir à enficher une autre carte shield (il faut simplement vérifier qu’il n’y a pas d’incompatibilité entre les shields et les signaux que chaque shield utilise et aussi la consommation totale de courant).
  Les cartes shields permettent de développer des projets sans avoir à faire d’électronique, celle-ci étant déjà réalisée sur la carte shield.
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 27 novembre 2020 18:54, par Flusin Christian
    
    Bonjour monsieur,
    c’est avec grand plaisir que je me suis lancé a travailler avec un arduino,etant d’une generation pas trop technique informatique !
    neanmoins, j’ai entrepris ce block automatique ,mais je souhaiterais votre avis concernant le shield relais :
    le programme a bien ete televersé ,les feux changent bien aux passage des ILS,
    seulement ,jutilise un shield relais MICRO HUT que mon fils m’avait ramené de Londres (avant le covid !)
    a l’initialisation,(donc avec tous les feux vert ),j’ai le relais3 qui colle direct,ensuite lors du passage des ILS ,voici le fonctionnement :
    relais 1 collé les autres non,
    relais 2 collé les autres non,
    relais 3 collé les autres non,
    relais 4 colle mais le 3 reste collé,
    retour relais 1 qui fait tomber 3 et 4 ! qu’en pensez vous ? est ce le shield en defaut ou son brochage differe du votre.
    merci d’avance ,cordialement,Chris
    
    Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 27 novembre 2020 23:19, par msport

Bonsoir,
pour que l’auteur ou un autre participant puisse vous donner un avis, postez une copie de la spécification technique de votre shield sur le forum, rubrique "Débuter"
Car le site indique :
Datasheet and operational guide provided upon purchase.
Ce qui importe de comparer c’est :
Relais Sortie N°
1 4
2 7
3 8
4 12

Cordialement

Voir en ligne : 4 Channel 5V Relay Shield Module Board

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 28 novembre 2020 00:51, par Christian

msport a raison : il nous faudrait un peu plus d’informations sur votre shield car nous ne pouvons pas les connaître tous.
Il faut repérer quelles sorties d’Arduino commandent votre shield et ensuite modifier le programme qui est fourni dans l’article pour l’adapter à ces nouvelles sorties.
Les feux pourront éventuellement être réaffectés en fonction des sorties restantes.
Tout cela ne semble pas bien difficile.

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 28 novembre 2020 13:34, par FLUSIN Christian
  
  Bonjour messieurs Christian, et msport,
  Je ne peux malheureusement pas avoir plus de specifications au niveau du shield ,mis a part de vous confirmer que c’est bien exactement celui que l’on voit sur le lien posté par vous,msport.
  J’avais cru comprendre que les shields relay ou autres s’enfichaient simplement dans les brochages de l’arduino,(vu que les feux rouges fonctionnement correctement )et si le fabricant du modele que j’utilise ne fourni pas d’information sur sa methode de cablage interne ,ce ne sera pas facile pour moi .
  Je pense investir dans le shield que vous avez utilisé pour faire l’article "block automatique 4relays"locoduino.
  Je vous remercie tout de même, et je ne manquerai pas de vous tenir au courant en m’inscrivant sur le forum.
  Tres cordialement. Christian
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 28 novembre 2020 15:36, par Christian
    
    En général, dans nos articles pour débutants (1 étoile), nous utilisons du matériel signé Arduino, non pas pour être rémunérés (nous ne le sommes absolument pas ;-) ), mais pour être certain que les débutants n’auront aucun déboire avec ce matériel de très bonne facture.
    Souvent, le matériel qu’on trouve sur eBay est d’origine asiatique et est souvent livré sans notice ou en chinois (dans le meilleur des cas dans un anglais plus qu’approximatif) et c’est la galère pour ceux qui débutent, là où les gens ayant un peu plus d’expérience sauront trouver des informations sur internet.
    Si vous achetez la carte shield Arduino, votre montage fonctionnera à coup sûr, comme le mien a fonctionné pour faire cet article (il suffit de voir la vidéo).
    Mais avant cela, pourquoi ne pas essayer de voir par vous-même quelle sortie commande tel relais. Il suffit de faire un petit programme pour cela et ce serait un excellent exercice ; une petite boucle qui testent les sorties non reliées aux signaux avec un intervalle de temps de quelques secondes pour avoir le temps d’observer ce qui se passe.
    
    Répondre
    - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 28 novembre 2020 17:46, par FLUSIN Christian
      
      Rebonjour Christian,
      Effectivement,l’ecueuil a ete d’utiliser ce shield (pas d’EBAY) ramené de Londres.
      Heureusement ,le fils de 17 ans de mon voisin est un passionné de cette technologie ,je lui raconté mon souci,et il ne lui a pas fallut longtemps pour trouver que mes relais sont commandés par les pins 7,6,5,4 !
      Petite modif du programme ,et ca fonctionne parfaitement.
      Merci a tous ,prenez soin de vous et de votre famille ,
      Cordialement, Christian
      
      Répondre
      - Adaptation du Block Automatique Lumineux pour la carte shield SEEED V2 28 novembre 2020 18:17, par msport
        
        Christian FLUSIN, je vous ai ouvert un nouveau fil sur le forum, pour que vous puissiez faire profiter la communauté du programme modifié.
        
        Locoduino est un site participatif.
        
        Voir en ligne : Adaptation pour la carte shield SEEED V2
        
        Répondre
        
        Adaptation du Block Automatique Lumineux pour la carte shield SEEED V2 29 novembre 2020 09:42, par Christian
        
        Voilà une histoire qui se termine très bien, comme on aime.
        Et en plus, c’est très bien de vous être inscrit sur le forum et d’avoir montré les corrections à faire.
        Ce premier montage qui fonctionne est une très bonne occasion pour mettre le pied à l’étrier : vous en trouverez d’autres pour débutants, notamment dans le domaine de l’animation et le décor du réseau (feux tricolores, enseigne de commerçant, soudure à arc, croix de pharmacie, barrières ou portes animées, etc.)
        A vous de jouer si le coeur vous en dit !
        
        Répondre
    - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 28 novembre 2020 17:55, par msport
      
      Apparemment, votre shield est celui de SEED V2.
      La documentation dit :
      Relais / Sortie N°
      1 / 7
      2 / 6
      3 / 5
      4 / 4
      
      Il faut que vous réaffectiez ces sorties aux feux rouges, et les autres sorties aux feux des zones correspondantes.
      
      Cordialement
      
      Voir en ligne : Relay shield V2.0
      
      Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 9 février 2021 13:28, par Noël CADOUX

Bonjour et merci de tout ce que vous nous apprenez.
J’ai un problème lors de la vérification de ce programme un message d’erreur surligne la ligne 187 et indique le message suivant..(stray’\302’ in program).
Je ne comprends pas la source de cette soi-disant erreur.
Pouvez vous me donner la réponse.
D’avance merci.
Noël

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 9 février 2021 18:06, par Christian
  
  Je viens de faire la manipulation chez moi et tout s’est bien passé, le programme est bien compilé (3326 octets de programme et 78 octets de variables).
  Il faut dire que vous ne donnez pas beaucoup d’informations : votre système d’exploitation, la carte utilisée, etc.
  J’ai déjà eu ce message d’erreur et il semblait provenir de caractères de contrôle cachés (donc difficile à détecter) dans le corps du programme (une recherche internet parle de caractères invalides). Donc, avez-vous utilisé l’option Télécharger du listing et si oui, comment avez-vous copié le texte à partir de la page qui s’ouvre avec cette option ?
  Une solution serait de retaper tout le programme mais il est assez long. C’est efficace tant que vous n’introduisez pas d’erreurs de copie mais ces dernières sont plus faciles à trouver que des caractères cachés.
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 février 2021 11:21, par Noël CADOUX
    
    Bonjour a vous Jean Luc er Christian.
    
    Je viens de voir que ma première réponse n’était pas partie désolé.
    
    Suite à vos commentaires j’ai ressaisi entiérement le croquis et la vérification est bonne.
    
    Il s’agissait bien de plusieurs erreurs de saisie.
    
    Alors merci à vous et à tous ceux qui prennent la peine de répondre à des individus perdus comme moi.
    
    Répondre
    - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 10 février 2021 12:11, par Christian
      
      Cela ne servirait à rien d’écrire des articles sur l’utilisation d’Arduino si nous n’étions plus là ensuite pour aider ceux qui ont tenté l’aventure.
      Content de voir que vos problèmes sont terminés. Je vous souhaite un bon amusement avec ce petit bloc automatique.
      
      Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 9 février 2021 18:17, par Jean-Luc
  
  Bonsoir,
  Vous avez un caractère UTF8 dans votre programme dont le glyphe est quasi identique à un glyphe de caractère ASCII valide. De ce que je vois, sous Windows, taper AltGr-espace au lieu de espace tout seul insère le caractère UTF8 de code \302\240 qui est quasi identique d’aspect à un espace ordinaire. Si vous étiez sous Unix, je vous conseillerais d’utiliser hexdump ou od -c pour trouver ce caractère dans votre texte.
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 2 septembre 2022 22:11, par Dav

Bonsoir,
Superbe programme qui fonctionne nickel. Je n’utilise pas d’ILS, mais des capteurs de consommation de courant. Ça fonctionne, et je cherche à adapter le programme. Je ne maîtrise pas la programmation, même si je la comprends un peu. J’ai besoin de votre aide. Dans la modification que j’envisage, tant qu’un consommateur de courant est présent sur la zone de détection, il y a arrêt. Dès que ce dernier quitte la zone, elle est libérée. Dans le fonctionnement actuel, un consommateur est présent (une motrice), n-1 est coupée, si un wagon reste sur n, alors que la motrice est sur n+1 (décrochement par exemple), n-1 est quand même libérée.

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 septembre 2022 10:03, par Christian
  
  Comme vous l’avez compris, ce programme analyse l’occupation de cantons : le déclenchement d’un I.L.S implique que le canton devient occupé et que le canton précédent devient libre. Pour ne pas louper un déclenchement d’I.L.S, on utilise des interruptions grâce à la bibliothèque PinChangeInt.
  Si vous utilisez des détecteurs à consommation de courant, le problème est simplifié car ce genre de détecteur donne un signal qui dure et qu’on ne risque pas de louper. Il vous faut donc scruter tous vos détecteurs afin de savoir s’ils détectent ou non. Si oui, c’est que le canton est occupé, sinon, il est libre et à partir de ces données, vous effectuez le même traitement pour aubiner les signaux du B.A.L. avec le même algorithme qui est en gras dans l’article. Vous verrez, c’est facile à adapter.
  Je vous invite aussi à lire cet article https://www.locoduino.org/spip.php?... qui devrait vous aider un peu. En effet, une récente mise à jour a abandonné l’utilisation de la bibliothèque qui gère les interruptions. Dans votre cas, vous n’en avez pas besoin comme je l’ai expliqué plus haut.
  Je pense que vous avez maintenant suffisamment d’éléments pour arriver au bout de votre projet.
  
  Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 septembre 2022 19:41, par Christian
  
  Mais est-ce que ce wagon consomme du courant (LED de fin de convoi ou essieux graphités) ?
  
  Répondre
  - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 3 septembre 2022 20:04, par Dav
    
    Bonsoir,
    Oui, les wagons consomment ...
    Dans le programmes, je ne comprends les lignes qui commandent les relais, je n’arrive pas à les identifier.
    
    Répondre
    - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 4 septembre 2022 10:35, par Christian
      
      Les relais de la carte shield sont commandés par les sorties 4, 7, 8 et 12 de la carte Uno, comme l’indique le premier tableau de l’article. Ces sorties commandent aussi les feux rouges des signaux (allumés par un état HIGH) pour la simple raison qu’il faut couper le courant sur la ZA (canton N - 1) quand le signal (canton N) est au rouge (voir l’algorithme en gras dans l’article).
      Donc, le fait de mettre au rouge un signal entrainera la coupure du courant sur la ZA concernée. Ceci est d’ailleurs indiqué par les commentaires de fin de ligne (voir par exemple les lignes de programme 142, 150, 176 et 193 où il est dit ZAx stop).
      En fait, c’est l’architecture de la carte shield qui nous permet de travailler ainsi, mais uniquement avec des signaux à cathodes communes. Jetez un coup d’oeil sur l’article 297 (déjà cité) où les signaux et les relais sont indépendants, ce qui permet d’utiliser des signaux à anodes communes.
      Si votre wagon consomme, il doit être vu par votre détecteur de consommation de courant et s’il se trouve sur le canton N, alors le logiciel doit considéré que ce canton N est occupé. Si la loco est sur le canton N+1, alors le canton N+1 est aussi occupé (cas d’un train à cheval sur deux cantons) : la signalisation suivra comme il se doit. Vérifiez bien que le wagon est détecté.
      
      Répondre
      - Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 4 septembre 2022 11:41, par Dav
        
        Bonjour,
        Merci pour l’info, je n’avais pas saisie que la sortie numérique avec la carte shield était utilisée pour le relais et la commande de la LED.
        
        Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 11 août 10:19, par Roland Matthys

Je suis en LGB analogique avec un peu d’expérience Arduino...
J’essaie de construire le fil d’un block automatique avec un Arduino par canton et deux trains indépendants
Votre article me donne un point de départ...
Où puis-je trouver la suite ?
Merci

Répondre
- Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 11 août 11:46, par Christian
  
  Il y a un article concernant un block automatique avec 8 cantons et une seule carte Mega.
  Si vous voulez un Arduino par canton, faites une recherche sur notre forum et vous trouverez.
  Il reste à définir ce que doit faire cet Arduino sur chaque canton : cela ne dépend que de vous. Pour gérer les feux et la zone d’arrêt, vous pouvez faire appel à un ATtiny par canton, cela vous reviendra moins cher. Il y a une série d’articles sur leur programmation.
  A vous de jouer maintenant...
  
  Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 11 août 14:26, par Roland Matthys

Merci pour votre réponse
L’essentiel du problème est développé dans votre texte
Je cherc=he à développer les 4 points suivants :
1. Détection de présence (développé par ailleurs)
2. Sélection de la source, par relais, à l’ancienne pour DC...
3. Occupation du block suivant (d’Arduino à Arduino)
4. Transfert de la source vers la bloc suivant
C’est tout... la programmation, ça ira !
Je dervrais m’en sortir avec 4 relays par canton :
Stop, 2 sources (même 3), et inversion de marche
mais il faut commuter 10A...
Maintenant je vais à la pêche :-)

Répondre
Block Automatique Lumineux avec la carte shield "Arduino 4 relays" 12 août 13:05, par Christian

Voici ce que je vous conseille :
1- Privilégiez plutôt les détecteurs d’occupation pat consommation de courant
2- Pourquoi faire à l’ancienne ? La PWM sur une unique source de courant et en faisant varier le rapport cyclique en fonction de ce que doit faire le train
3- Problème réglé avec cet article ou celui des 8 cantons
4- Voir point N°3
Il faut piloter un pont en H capable de supporter 10A mais cela doit bien se trouver dans l’industrie...
Je vous conseille d’ouvrir un fil sur notre forum pour parler de votre projet et trouver de l’aide éventuellement (ici, c’est plutôt pour ce qui concerne l’article).

Répondre