Salut,
Ce tutoriel va présenter un système existant pour réaliser des automatismes en mode “lego” basé sur la plateforme Arduino Nano.
A la fin du tutoriel, nous aurons un montage simple pour détecter la présence d’un matériel roulant sur un rail contact et déclencher des automatismes en conséquence. Pour 11 €. Et une vidéo de démonstration.
Il est la brique de base que je vais utiliser ensuite pour mes automatismes, à commencer par celui de la fosse d’inspection.
Objectif : pas de fer à souder, pas de câblage compliqué, pas de résistance/condo/… à rajouter et bien sur un prix mini mini. Si tu sais brancher un M84, tu sais utiliser un Arduino à la sauce Julaye
!
14 mai 2021 : simplification de certains tutoriels pour détecter le STOP + correction d’un branchement
17 mai 2021 : nouvelle version de Tuto6 avec une carte opto isolée type DST-1R4P-N ou DST-1R8P-N
Table des matières
- Tuto01 à Tuto05 : les bases (ci-après)
- Annexe A et B : schéma pour Tuto01 à Tuto05 et matériel nécessaire
- Add-on Tuto6 : Etat de la Voie : libre, occupée, STOP
- Add-on Tuto7 : un afficheur 4 x 7 segments optionnel
- Annexe C - Les fichiers téléchargeables des tutoriels 01 à 07
- Variante avec carte opto isolée type DST-1R4P-N ou DST-1R8P-N
Dans les épisodes précédents :
- Le carton plume
- Noyer la voie C
- Kitbashing d’un pont tournant
- Kitbashing d’une fosse d’inspection
- Un garde-corps en laiton
6.1 Le contexte
Pour mes réalisations, j’ai besoin d’automatismes qui sont basés sur des fonctionnalités de base :
- détecter la présence d’un matériel roulant
- détecter une ou plusieurs entrées
- actionner une ou plusieurs sorties
- utiliser des timers
- combiner tout ça
J’ai donné par exemple le cahier des charges des lumières de la fosse d’inspection ici.
J’ai été déçu par une petite carte électronique YYC-2S sensée faire (une partie) du job, qui m’a quand même couté 11.69 euros, et qui s’est avérée incapable de détecter proprement la présence ou l’absence de la locomotive sur la fosse. il aurait fallut ajouter des trucs devant et derrière pour filtrer le signal, pour combiner deux entrées …
Une autre option est d’utiliser des logiciels comme iTrain pour réaliser ces automatismes. C’est une belle option mais je ne suis pas convaincue par cette approche. Si l’ordinateur est indisponible, plus d’automatisme.
Je vous rappelle que dans mon approche je souhaite pouvoir tout piloter depuis une simple MS2.
En discutant avec un ami, il me dit : il te faut un automate.
Mais je vais y rajouter une contrainte : je veux que tout soit simple et se connecte facilement comme lorsque l’on branche un M84.
Il me faut une solution “LEGO” et pas cher !
6.2 Cahier des charges
Il me faut un automate avec :
- des entrées digitales et analogiques
- des sorties relais
- une entrée pour détecter l’occupation d’un rail
- des timers
- facile à programmer
- facile à cabler
- et pas cher
6.3 Solution retenue
Mon choix s’est fixé sur l’Arduino Nano que j’ai pris expressément chez AZ-Delivery. Le packaging est au top, la documentation à télécharger (en anglais) est limpide et le kit tombe littéralement en marche.
Les fonctions de base sont remplis par (de gauche à droite sur la photo) :
- une carte entrée analogique 0-25V pour interfacer le rail contact : Capteur de tension DC0-25V pour Arduino chez Stemedu
- une carte Arduino Nano : AZDelivery Mini Nano Card V3.0 Atmega328 CH340 version à puce soudée avec câble USB
- une carte sortie relais (1 relais, 2 relais, 4 relais ou 8 relais selon les besoins) : AZDelivery 5 x 1 Canal KF-301 Module relais 5V Low-Level-Trigger
Chez AZ-Delivery, la carte Arduino est vendu par lot de 3 et les cartes relais par lot de 5. La carte analogique de Stemedu est vendue par lot de 5.
En prix de revient unitaire, il faut compter 1.70 € la sortie relais, 6.50 € le Nano et 2.40 € la carte analogique ! soit un total de 10.60 €, moins cher que la petite carte électronique YYC-2S !
Comme je ne veux rien souder et avoir un câblage simplifié, j’ai commandé un lot de câble avec des connecteurs mâle-male, femelle-mâle et femelle-femelle : 40 de chaque pour 10 € le lots de 140, soit 8 centimes la connexion.
Les câbles sont nappés mais chaque brin se détache très facilement. Et nous avons des couleurs comme le rouge, le brun, le jaune, le bleu et le noir, couleurs très utiles dans notre contexte 
Notre montage final du tutoriel utilise 7 brins ce qui fait un montage à 11.16 €, toujours moins cher que la petite carte électronique YYC-2S !
6.4 Montage pour le tutoriel
Pour réaliser ce tutoriel, il vous faut trois coupons voie C type 24188, celui du milieu étant transformé en rail à contact (avec un fil bleu et des isolations 74030), les deux autres étant alimentés par une Digibox et sa MS2 :
On peut faire l’équivalent avec de la voie M ou de la voie K bien évidemment, le principal étant d’isoler un rail du coupon central et d’y connecter un fil bleu qui nous servira de signal de présence/absence d’un matériel roulant.
6.5 Installation de l’Arduino Nano
Il faut ouvrir la documentation fournie avec l’Arduino Nano (à télécharger sur le site de AZ-Delivery) et l’installation est expliquée :
-
télécharger l’environnement de développement Arduino IDE à l’adresse suivante : https://www.arduino.cc/en/software (Windows, Linux et Mac sont supportés),
-
installer le logiciel et le lancer
- choisir la carte “Arduino Nano”,
-
brancher le cable USB entre l’Arduino Nano et l’ordinateur, la led de mise sous tension verte doit s’allumer,
-
choisir le port USB qui est apparu (la mention sera différente en fonction de votre environnement),
- choisir le processeur “ATmega328P (Old Bootloader)”
- choisir l’application d’exemple “Blink” et la lancer en clichant sur le bouton → qui se trouve dans la fenêtre “Blink”
L’écran “Blink” doit afficher un message de réussite :
- Et l’Arduino Nano doit faire clignoter sa led rouge correspondant à une sortie digitale 13
6.6 Tuto01
Notre premier tutoriel va consister à ouvrir et fermer notre relais à une fréquence d’une seconde.
Le branchement est archi simple :
- L’arduino Nano est alimenté par son cable USB.
- Connecter la pin GND de l’Arduino Nano avec la pin GND de la carte relais (cable femelle-femelle noir)
- Connecter la pin +5V de l’Arduino Nano avec la pin VCC de la carte relais (cable femelle-femelle rouge)
A ce stade, la carte relais est alimentée.
- Connecter la sortie D3 de l’Arduino avec l’entrée IN de la carte relais (cable femelle-femelle jaune)
Le fait de passer la sortie D3 à 1 (HIGH) commute le relais COMMON - NO et à 0 (LOW) commute le relais COMMON - NC. Tout simplement.
La carte relais étant munis d’une led rouge (carte alimentée) et d’une led verte (allumé si relais COMMON-NC, éteinte sinon), il va être facile de vérifier si notre programme fonctionne.
On fait menu Fichier → Nouveau et on copie le programme ci-après.
Le programme est simple et auto explicatif avec les commentaires que j’ai inséré :
// Tuto01
// Exemple pour le forum 3rails / Julie Dumortier / Licence GPL
//
// ouvre puis ferme un relais à la fréquence de 1 seconde
//
// Retrouvez ce tutoriel sur le lien : https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep6-quelques-automatismes-arduino-nano/18361
// défini la broche (pin) utilisée pour commander le relais : D3
int relaisPin = 3;
// code executé une seule fois au démarrage du module (ou après un reset)
void setup() {
// programme la sortie digitale D3 en sortie
// le In du relais est connecté à cette sortie D3
pinMode(relaisPin, OUTPUT);
}
// code executé en permanence (une boucle)
void loop() {
// relais COMMON - NO (led verte éteinte)
digitalWrite(relaisPin,HIGH);
// attends une seconde (unité de temps : millisecondes)
delay(1000);
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
// attends une seconde
delay(1000);
}
On télécharge et on exécute le programme toujours avec la flèche → qui se trouve dans cette fenêtre Tuto01. Le relais doit s’ouvrir et se fermer une fois par seconde …
A ce stade, si vous voulez avoir une meilleure compréhension des commandes que j’ai utilisé pour ce petit exemple, vous pouvez allez sur l’aide en ligne :
6.7 Tuto02
Le second tutoriel va introduire un outil important pour la mise au point de vos petits programmes : la console, une fenêtre dans votre Arduino IDE qui peut afficher des messages en provenance de la carte via la connexion USB.
Vous pouvez ouvrir cette console par le menu Outils → Moniteur série. Elle ressemble à ça :
Il faut choisir une vitesse de communication - je préconise 57600 bauds - et il faudra parametrer la même vitesse dans la carte Arduino. Ce paramétrage se fait dans la fonction setup() qui porte bien son nom.
Là aussi le programme est assez simple et commenté, on écrit un X ou un O au rythme du relais qui se ferme et qui s’ouvre :
// Tuto02
// Exemple pour le forum 3rails / Julie Dumortier / Licence GPL
//
// ouvre puis ferme un relais à la fréquence de 1 seconde
// affiche O ou X dans la console
//
// Retrouvez ce tutoriel sur le lien : https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep6-quelques-automatismes-arduino-nano/18361
// défini la broche (pin) utilisée pour commander le relais : D3
int relaisPin = 3;
// code executé une seule fois au démarrage du module (ou après un reset)
void setup() {
// programme la sortie digitale D3 en sortie
// le In du relais est connecté à cette sortie D3
pinMode(relaisPin, OUTPUT);
// ouvre le port série (console de l'outil) avec la vitesse 57600 bauds
// attention que le paramètre sur la console soit bien 57600 !
Serial.begin(57600);
}
// code executé en permanence (une boucle)
void loop() {
// relais COMMON - NO (led verte éteinte)
digitalWrite(relaisPin,HIGH);
// envoie X sur la console
Serial.println("X");
// attends une seconde (unité de temps : millisecondes)
delay(1000);
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
// envoie O sur la console
Serial.println("O");
// attends une seconde
delay(1000);
}
Et le contenu de la console :
6.8 Tuto03
Au lieu d’afficher des X et des O, nous allons lire une valeur analogique sur l’entrée A3 et nous allons l’afficher au rythme d’un affichage par seconde. Et nous continuons à ouvrir et fermer le relais sur le même rythme.
Bien évidemment, la valeur affichée est totalement aléatoire puisque l’entrée analogique est en l’air, connectée à rien du tout.
Le programme se complique un tout petit peu avec la fonction de lecture analogique. Rien qui ne soit incompréhensible, les commentaires et les noms des fonctions parlent d’eux-même :
// Tuto03
// Exemple pour le forum 3rails / Julie Dumortier / Licence GPL
//
// ouvre puis ferme un relais à la fréquence de 1 seconde
// affiche la valeur analogique lue sur une entrée
//
// Retrouvez ce tutoriel sur le lien : https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep6-quelques-automatismes-arduino-nano/18361
// défini la broche (pin) utilisée pour commander le relais : D3
int relaisPin = 3;
// défini la broche (pin) utilisée pour lire la valeur analogique : A3
int anaPin = 3;
// variable pour stocker la valeur lue
int val = 0;
// code executé une seule fois au démarrage du module (ou après un reset)
void setup() {
// programme la sortie digitale D3 en sortie
// le In du relais est connecté à cette sortie D3
pinMode(relaisPin, OUTPUT);
// ouvre le port série (console de l'outil) avec la vitesse 57600 bauds
// attention que le paramètre sur la console soit bien 57600 !
Serial.begin(57600);
}
int lectureAna()
{
return analogRead(anaPin);
}
// code executé en permanence (une boucle)
void loop() {
// relais COMMON - NO (led verte éteinte)
digitalWrite(relaisPin,HIGH);
// lis la valeur analogique
val = lectureAna();
// envoie la valeur sur la console
Serial.println(val);
// attends une seconde (unité de temps : millisecondes)
delay(1000);
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
// lis la valeur analogique
val = lectureAna();
// envoie la valeur sur la console
Serial.println(val);
// attends une seconde
delay(1000);
}
Et le contenu de la console (avec des valeurs aléatoires) :
6.9 Tuto04
Il est temps d’aller lire ce qui se passe sur notre rail de contact, sur notre fil bleu
Nous allons brancher la carte analogique 0-25V de la manière suivante :
-
sortie S connectée à l’entrée A3 de l’Arduino (cable femelle-femelle jaune)
-
entrée + : non utilisée
-
entrée - connectée à l’autre sortie GND de l’Arduino (cable femelle-femelle noir)
-
entrée VCC - connectée au cable B de la voie (cable femelle-mâle rouge)
-
entrée GND - connectée au cable bleu du rail de contact
Le programme va consister à lire la valeur analogique en provenance du rail de contact (fil bleu), l’afficher, et en fonction d’un seuil de commander le relais.
// Tuto04
// Exemple pour le forum 3rails / Julie Dumortier / Licence GPL
//
// affiche la valeur analogique lue sur une entrée
// si elle est supérieur à un seuil : relais C - NO
// sinon relais C - NC
//
// Retrouvez ce tutoriel sur le lien : https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep6-quelques-automatismes-arduino-nano/18361
// défini la broche (pin) utilisée pour commander le relais : D3
int relaisPin = 3;
// défini la broche (pin) utilisée pour lire la valeur analogique : A3
int anaPin = 3;
// variable pour stocker la valeur lue
int val = 0;
// variable pour stocker le seuil
int seuil = 500;
// code executé une seule fois au démarrage du module (ou après un reset)
void setup() {
// programme la sortie digitale D3 en sortie
// le In du relais est connecté à cette sortie D3
pinMode(relaisPin, OUTPUT);
// ouvre le port série (console de l'outil) avec la vitesse 57600 bauds
// attention que le paramètre sur la console soit bien 57600 !
Serial.begin(57600);
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
}
int lectureAna()
{
return analogRead(anaPin);
}
// code executé en permanence (une boucle)
void loop() {
// lis la valeur analogique
val = lectureAna();
// envoie la valeur sur la console
Serial.println(val);
if (val > seuil) {
// relais COMMON - NO (led verte éteinte)
digitalWrite(relaisPin,HIGH);
} else {
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
}
// attends 100 ms
delay(100);
}
L’exécution du programme permet de voir le comportement des valeurs en fonction de la position du wagon (attention, wagon avec des roues conductrices, je me suis faite avoir avec un wagon de @vincentlj avec un axe plastique 
) :
Désolée pour le bruit, Ryco déménage des trucs puis s’intéresse au relais qui claque …
On remarque avec cette vidéo que le rail inoccupé renvoi une valeur proche de 0. la rail occupé retourne une valeur qui correspond au fil rouge (courant de traction) mais parfois des 0 : il s’agit des shunts du signal numérique. Il va falloir filtrer !
6.10 Tuto05
Nous allons reprendre l’exemple précédent et réaliser une fonction qui nous dit si la voie est occupée ou libre. Pour ce faire, nous allons réaliser un filtre rudimentaire.
Le programme est commenté :
// Tuto05
// Exemple pour le forum 3rails / Julie Dumortier / Licence GPL
//
// affiche la valeur analogique lue sur une entrée
// si elle est supérieur à un seuil : relais C - NC
// sinon relais C - NO si l'absence de contact est confirmé (filtre)
//
// Retrouvez ce tutoriel sur le lien : https://forum.3rails.fr/t/une-debutante-dans-le-decor-ep6-quelques-automatismes-arduino-nano/18361
// défini la broche (pin) utilisée pour commander le relais : D3
int relaisPin = 13;
// défini la broche (pin) utilisée pour lire la valeur analogique : A3
int anaPin = 3;
// variable pour stocker la valeur lue
int val = 0;
// variable pour stocker le seuil de déclenchement
int seuil = 384;
// variable pour compter les déclenchements
int nbFiltre = 16;
// on va filter le signal bas pendant 192 ms pour décider que la voie est libre
int msFiltre = 192;
// code executé une seule fois au démarrage du module (ou après un reset)
void setup() {
// programme la sortie digitale D3 en sortie
// le In du relais est connecté à cette sortie D3
pinMode(relaisPin, OUTPUT);
pinMode(anaPin,INPUT_PULLUP);
// ouvre le port série (console de l'outil) avec la vitesse 57600 bauds
// attention que le paramètre sur la console soit bien 57600 !
Serial.begin(57600);
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
}
// retourne 1 si la voie est libre
int voieLibre()
{
int n = msFiltre;
int c = 0;
int v = 0;
// tant que le signal est bas on continue
while (n>0) {
v = analogRead(anaPin);
if (v>seuil) {
c = c + 1;
}
if (c>nbFiltre) {
// la voie est encore occupée
// attends la fin du compteur
delay(n);
// et retourne l'état d'occupation
return 0;
}
// attends 1 ms
delay(1);
// et boucle
n = n - 1;
}
// il est resté bas --> la voie est libre
return 1;
}
// code executé en permanence (une boucle)
void loop() {
if (voieLibre()) {
// relais COMMON - NC (led verte allumée)
digitalWrite(relaisPin,LOW);
Serial.println("voie libre");
} else {
// relais COMMON - NO (led verte éteinte)
digitalWrite(relaisPin,HIGH);
Serial.println("voie occupée");
}
// attends 100 ms pour refaire un test
delay(100);
}
La nouvelle vidéo montre la fonctionnalité mise en oeuvre :
Bilan : nous avons un montage simple à 11.16 € et un petit programme qui permet de détecter l’occupation d’une voie, pour allumer par exemple les lumières de notre fosse. Et ajouter tous les automatismes que nous voulons (lumière forcée, délais d’allumage, délais d’extinction, mode veille …). Nous aborderons cet automatisme complet dans la partie automatisme de l’épisode 4 à suivre very soon !
6.11 THAT’S ALL FOLKS !
Ce tutoriel est maintenant terminé. Vous pouvez explorer d’autres capacité de votre carte avec les tutoriels du site Arduino :
A vous de jouer !
Retrouvez tous les épisodes de la débutante en clickant ici !
en ramenant de la tension de la voie sur une entrée digitale VCC 5V … Processeur détruit en moins d’une seconde. Je comprends pourquoi les Nano sont livrés par trois 
!
