Je vais vous décrire mon projet de commande des aiguillages à solénoïdes. Ces aiguillages Marklin en échelle Z demandent une impulsion d'environ 500mA mais avec une courte durée de 50 ms . Il y a donc deux aspects à prendre en compte, le premier est la durée, c’est à l’Arduino de gérer cette durée, le second est de générer un courant suffisant, que l’Arduino ne peut fournir, par une interface en sortie des broches de l’Arduino.

Durée de l’impulsion

Elle ne pose aucun problème en programmation Arduino puisque prise en compte dans la bibliothèque UAD, il suffit donc de déterminer par des tests la durée optimale en ms et de fixer cette valeur dans le programme.

Génération du courant d’impulsion

Il existe plusieurs possibilités pour réaliser cette génération, les relais, l’interface L298N, le L9110 ou l’interface ULN2803A. On trouve l’ensemble de ces composants pour quelques Euros.
Mon choix se porte sur des L9110. L’interface L9110 permet de contrôler un moteur CC (c’est un pont en H). Il admet des tensions entre 2,5V et 12V pour une intensité de 800mA par sortie en continu.

L9110
Les aiguillages Marklin fonctionnent en 12v CC, c'est parfait.
Le schéma est en pièce jointe. IA et IB sont les commandes des sorties OA et OB respectivement, actives quand elles sont au niveau bas LOW. Et le schéma de connexion est lui aussi en pièce jointe
La bobine 1 est activée quand IA est au niveau bas LOW et la bobine 2 quand IB est au niveau bas LOW.

Capture du 2020 07 24 06 30 42
Je vais tester ce composant qui par l'usage annoncé de signal de commande des solénoïdes en PWM pourrait autoriser un déplacement lent des lames d'aiguilles plus réaliste.
Outre deux boutons de commande d'itinéraire, je vais placer sur cet Arduino un module Bluetooth pour piloter les itinéraires avec mon smartphone.


Affaire à suivre..

Après pas mal de recherches et surtout d'essais, j'ai trouvé la méthode pour un démarrage, arrêt progressif et marche arrière en échelle Z. J'ai découpé la valeur du signal PWM en 14 niveaux pour piloter en douceur le moteur de la locomotive, en marche avant , en marche arrière (en réglant en passant la différence de vitesse en marche arrière plus rapide qu'en marche avant pour une même tension sur la voie !) .
J'ai réglé aussi le problème du comportement différent de la locomotive roulant "haut le pied" et attelée à son train.
Voici la vidéo pour vous montrer le résultat :

La vidéo

Pour les amateurs, voici le code arduino :

/*
programme de gestion d'un mini TCO de pilotage d'un train
en date du vendredi 17 juillet 2020 à 16h00
il y a 14 paliers de vitesse prédéfinis
suite aux tests sur le circuit certains paliers en basse vitesse 
ne sont pas utilisés et en marche arrière la vitesse a été limitée 
 
*/
 
// variables pour la commande du relais inverseur
 
int RELAIS = 7; // Relais sur la PIN 7, fil gris
int etatrelais = 0; // variable d'état du relais
 
// variables pour la commande du module PWM L298
 
int SENS_0 = 9; // fil violet sur IN3
int SENS_1 = 8; // fil vert sur IN4
int REGLAGEVITESSE = 10; // fil bleu sur EN B
 
// variables pour fixer les différentes vitesses possibles de circulation du train avec 14 pas de vitesse possibles
 
int vitessePalier_0 = 0 ; // vitesse de service palier 0 (train complètement à l'arrêt)
 
int vitessePalier_1 = 18; // vitesse de service palier 1
 
int vitessePalier_2 = 36 ; // vitesse de service palier 2
 
int vitessePalier_3 = 54 ; // vitesse de service palier 3
 
int vitessePalier_4 = 72 ; // vitesse de service palier 4
 
int vitessePalier_5 = 91; // vitesse de service palier 5
 
int vitessePalier_6 = 109; // vitesse de service palier 6
 
int vitessePalier_7 = 127; // vitesse de service palier 7
 
int vitessePalier_8 = 145; // vitesse de service palier 8
 
int vitessePalier_9 = 163; // vitesse de service palier 9 
 
int vitessePalier_10 = 182; // vitesse de service palier 10
 
int vitessePalier_11 = 200; // vitesse de service palier 11
 
int vitessePalier_12 = 218; // vitesse de service palier 12
 
int vitessePalier_13 = 236; // vitesse de service palier 13
 
int vitessePalier_14 = 255; // vitesse de service palier 14 (vitesse max)
 
// variables pour les boutons du choix du mode de circulation du train
 
int bouton_noir = 2;// bouton noir sur la PIN 2, fil marron // alloué au démarrage en marche arrière
int bouton_vert = 3; // bouton vert sur la PIN 3, fil blanc // alloué au démarrage en marche avnt
int bouton_jaune = 4; // bouton jaune sur la PIN 4, fil jaune // alloué à l'arrêt progressif
int bouton_rouge = 5; // bouton rouge sur la PIN 5, fil orange // alloué à l'arrêt d'urgence
 
// variables d'état des boutons de commande de vitesse, su sens de déplacement ou d'arrêt progressif ou d'urgence
 
int etatboutonvert = 0; // etat actuel du bouton vert 
int etatboutonjaune = 0; // etat actuel du bouton jaune 
int etatboutonrouge = 0; // etat actuel du bouton rouge 
int etatboutonnoir = 0; // etat actuel du bouton noir
 
void setup() {
 
// relais inverseur
 
pinMode(RELAIS, OUTPUT);
 
// L298
pinMode(SENS_0,OUTPUT);
pinMode(SENS_1,OUTPUT);
pinMode(REGLAGEVITESSE,OUTPUT);
 
// boutons poussoirs de démarrage progressif en marche avant, de démarrage progressif en marche arrière, d'arrêt progressif et d'arrêt d'urgence
 
pinMode(bouton_vert, INPUT); // démarrage progressif en marche avant
pinMode(bouton_jaune, INPUT); // démarrage progressif en marche arrière
pinMode(bouton_rouge, INPUT); // arrêt progressif
pinMode(bouton_noir, INPUT); // arrêt d'urgence
 
// initialisation du circuit
 
analogWrite(REGLAGEVITESSE,vitessePalier_0); // le train est à l'arrêt complet et le système attend le premier appui sur un bouton 
digitalWrite(RELAIS,1); // on positionne le relais pour démarrage en marche avant
 
}
 
void loop() {
  
// gestion des vitesses sur le circuit selon l'appui sur un des 4 boutons
 
// cas du démarrage du train par appui sur le bouton vert pour la circulation avec la locomotive en tête de convoi
 
// lecture de l'état du bouton poussoir vert
 
etatboutonvert = digitalRead(bouton_vert); 
 
 if (etatboutonvert == HIGH) {
  
 // on démarre en marche avant
 
digitalWrite(RELAIS,0); // on positionne le relais pour la marche avant sens horaire de parcours de la boucle
 
 // début de la séquence de démarrage
 
analogWrite(REGLAGEVITESSE, vitessePalier_5); // vitesse de service palier 5
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_6); // vitesse de service palier 6
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_7); // vitesse de service palier 7
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_8); // vitesse de service palier 8
delay(1000);
 analogWrite(REGLAGEVITESSE, vitessePalier_9); // vitesse de service palier 9
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_10); // vitesse de service palier 10
delay(1000);
 
}
// fin de la séquence de démarrage en marche avant
 
// cas du démarrage du train par appui sur le bouton noir pour la circulation avec la locomotive en queue de convoi
 
// lecture de l'état du bouton poussoir noir
 
etatboutonnoir = digitalRead(bouton_noir); 
 
// Y a-t-il eu un appui sur le bouton noir
 
if (etatboutonnoir == HIGH)  {
 
 
// on positionne le relais pour l'inversion de la tension de voie
 
digitalWrite(RELAIS,1); // on positionne le relais pour la marche arrière sens anti horaire de parcours de la boucle
 
// début de la séquence de démarrage
 
analogWrite(REGLAGEVITESSE, vitessePalier_5); // vitesse de service palier 5
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_6); // vitesse de service palier 6
delay(1000);
analogWrite(REGLAGEVITESSE, vitessePalier_7); // vitesse de service palier 7
delay(1000);
//analogWrite(REGLAGEVITESSE, vitessePalier_8); // vitesse de service palier 8
//delay(1000);
 
}
// fin de la séquence de démarrage en marche arrière
 
// début de la séquence d'arrêt progressif
 
// lecture de l'état du bouton poussoir jaune
 
etatboutonjaune = digitalRead(bouton_jaune); 
 
// Y a-t-il eu un appui sur le bouton jaune
 
if (etatboutonjaune == HIGH)  {
 
// début de la séquence d'arrêt progressif
 
analogWrite(REGLAGEVITESSE, vitessePalier_7); // vitesse de service palier 7
delay(2000);
analogWrite(REGLAGEVITESSE, vitessePalier_6); // vitesse de service palier 6
delay(2000);
analogWrite(REGLAGEVITESSE, vitessePalier_5); // vitesse de service palier 5
delay(2000);
analogWrite(REGLAGEVITESSE, vitessePalier_4); // vitesse de service palier 4
delay(2000);
analogWrite(REGLAGEVITESSE, vitessePalier_0); // vitesse de service palier 0 arrêt complet
 
}
 
// fin de la séquence d'arrêt progressif
 
// début de la séquence d'arrêt d'urgence
 
// lecture de l'état du bouton poussoir rouge
 
etatboutonrouge = digitalRead(bouton_rouge); 
 
// Y a-t-il eu un appui sur le bouton rouge
 
if (etatboutonrouge == HIGH) {
 
analogWrite(REGLAGEVITESSE,vitessePalier_0); // arrêt
 
// fin de l'arrêt d'urgence
  
}
}

Voici le futur circuit du projet en Z Analogduino..

"Y a pu ka" faire

 

Voir la vidéo de l'essai de roulement

Avertissement (amical) :

L'échelle utilisée est le Z, inutile donc de m'opposer des solutions de digitalisation, à moins que vous ayez une astuce pour loger un décodeur DCC dans une locomotive de la taille d'un morceau de sucre. Pour autant je ne souhaite pas en rester à l'usage du transformateur livré par Marklin avec ses boîtes de début et donc regarder ce qu'on pourrait faire avec un microcontrôleur comme l'Arduino.

Par ailleurs, la démarche étant pédagogique, il m'a semblé interessant d'imaginer un "rail pivotant" au croisement des deux voies des boucles de retournement. Ce "rail pivotant" évite un croisement par le dessus d'une des voies avec une pente très forte, et d'autre part il va permette d'aborder l'utilisation d'un servomoteur avec l'Arduino. Mais dans cet article je n'aborderai que la logique du "rail pivotant" et pas celle du servomoteur qui est plus classique et qui sera rédigée ultérieurement.

Merci de votre compréhension.

logique rail pivotant

Avec cette option de "rail pivotant" il y aura désormais 7 cantons sur le circuit, le rail sur un plateau tournant grâce à un servomoteur est le septième, il est alimenté et polarisé comme les 6 autres avec les mêmes équipements électroniques sous contrôle d'un Arduino.

Les tronçons ou demi cantons sont visibles sur ce schéma.

Les « demi cantons » 5/1 et 5/2 sont alimentés et polarisés ensemble.

Les « demi cantons » 6/1 et 6/2 sont alimentés et polarisés ensemble.

Il y a plusieurs possibilités :

  1. il y a un train qui rentre sur le demi canton 5/1 vers le canton 7,

  2. il y a un train qui rentre sur le demi canton 5/2 vers le canton 7,

  3. il y a un train qui rentre sur le demi canton 6/1 vers le canton 7,

  4. il y a un train qui rentre sur le demi canton 6/2 vers le canton 7,

  5. il y a un train sur le demi canton 5/1 s'éloignant du canton 7,

  6. il y a un train sur le demi canton 5/2 s'éloignant du canton 7,

  7. il y a un train sur le demi canton 6/1 s'éloignant du canton 7,

  8. il y a un train sur le demi canton 6/2 s'éloignant du canton 7.

Il y a une possibilité particulière qui est qu'il n'y a pas de train sur les cantons de retournement.

Admettons qu'il s'agisse de la situation initiale du logigramme.

En fait il suffit de connaître à ce moment-là la position du canton 7.

  • - soit il permet de joindre les demi cantons 5/1 et 5/2.

  • - soit il permet de joindre les demi cantons 6/1 et 6/2.

A la mise sous tension du circuit il faudra que le système aille « lire » la dernière position du canton 7.

Pour cela il faudra enregistrer cette position non pas en mémoire vive de l'Arduino qui est volatile et dont le contenu disparaît à l'arrêt de l'alimentation du micro contrôleur mais dans la mémoireEEPROM.

Logique de traitement :

Dès qu'un train est détecté en entrée sur un demi canton, quel qu'il soit, il faut que l'Arduino exécute certaines tâches sur le canton 7 (en dehors du positionnement face aux rails de sortie par un servomoteur, piloté par l'Arduino, et qui sera traité dans un autre document).

Cas du canton 5 :

Il y a un train qui rentre sur le demi canton 5/1 vers le canton 7, ou il y a un train qui rentre sur le demi canton 5/2 vers le canton 7.

Dans les deux cas l'Arduino doit :

  • - vérifier la position du canton 7, 

  • - le faire pivoter s'il y a lieu, 

  • - le polariser comme le sont les demi cantons 5/1 et 5/2, selon le sens de circulation du train.

Cas du canton 6 :

Il y a un train qui rentre sur le demi canton 6/1 vers le canton 7,il y a un train qui rentre sur le demi canton 6/2 vers le canton 7,

Dans les deux cas l'Arduino doit :

  • - vérifier la position du canton 7, 

  • - le faire pivoter s'il y a lieu, 

  • - le polariser comme le sont les demi cantons 6/1 et 6/2, selon le sens de circulation du train.

Cas de détection des trains s'éloignant du canton 7 :

Tant qu'un train est détecté sur un des demi cantons, ou sur le canton 7, la situation du canton 7 (position, alimentation, polarisation) reste inchangée et elle est même protégée par inhibition de toute action sur le servomoteur en particulier.

Rappel sur l'architecture matérielle du canton 7 :

L'alimentation de traction 12v commune aux 7 cantons 

alimentation 12V

Le module d'alimentation qui permet de choisir une vitesse du train sur ce canton adaptée à sa configuration mécanique particulière.

module alimentation

Le relais de coupure de tension 

relai coupure

Le relais inverseur de polarité de voie 

relai inverseur

Le module de mesure d'intensité de courant sur les voies (présence du train et coupe circuit) 

Capture décran 2020 05 03 à 10.26.35

Avertissement (amical) : L'échelle utilisée est le Z, inutile donc de m'opposer des solutions de digitalisation, à moins que vous ayez une astuce pour loger un décodeur DCC dans une locomotive de la taille d'un morceau de sucre. Pour autant je ne souhaite pas en rester à l'usage du transformateur livré par Marklin avec ses boîtes de début et donc regarder ce qu'on pourrait faire avec un microcontrôleur comme l'Arduino. Merci de votre compréhension.

 

Tiny electric motor in a Z scale model locomotive

 

Nous avons vu qu'à partir d'une alimentation continue commune à l'ensemble du circuit avec un ampérage suffisant pour l'usage en nombre de trains, de cantons occupés, etc. on souhaitait "différencier" l'alimentation de chaque canton pour rendre les grandes fonctions comme la protection des convois, les boucles de retournement, etc. exploitables.

Nous allons utiliser des petits, peu coûteux mais robustes modules  d'alimentation LM 2596 pour, à partir de l'alimentation "centrale", nous permettre cette gestion "fine" des cantons.

module alimentation

Acheté chez AliExpress

Lien vers la référence d'achat, cliquez ici

Prix affiché : 0,6€

Ce module utilise un circuit intégré de Texas Intrument LM2596 qui est un régulateur de tension protégé contre les surtensions. Il va nous permettre de fixer, canton par canton, en fonction de la réalité du canton (ligne droite, pente, courbe, zone d'aiguille, etc.) la tension appliquée au moteur de la loco.

Dans notre cas, la tension d'entrée sera de 12v et à l'aide de la résistance variable par vis (bloc bleu sur l'image avec la petite vis sur le dessus) nous pourrons ajuster la tension de sortie.

Cela nous permettra d'ajuster par un essai en vraie grandeur sur le circuit, la tension sur le canton pour une circulation réaliste du train selon la pente, la courbe, la zone d'aiguilles, etc.

Caractéristiques techniques 

 Nom: module Buck DC-DC LM2596

Tension d'entrée: 4 V à 35 V
Tension de sortie: 1.23 V-30 V
Courant de sortie: 3A (maximum)
Efficacité de Conversion: 92% (maximum)
Ondulation de sortie: <30 mV
Fréquence de commutation 150 KHz
Température de fonctionnement:-45° + 85°
Taille: 43mm * 21mm * 14mm (longueur * largeur * hauteur)
La plage de tension d'entrée: 3.2 V à 40 V cc (la tension d'entrée doit être supérieure à la tension de sortie de 1.5 V ci-dessus),
La plage de tension de sortie: 1.25 V à 35 V tension réglable, haute efficacité (92%) de régulation, le courant de sortie maximal le plus élevé toléré est de 3 A, ce qui est suffisant pour une loco, toute échelle possible sur un seul canton.

Procédure proposée pour régler la tension de sortie (appliquée sur la voie) :

- Alimentation d'entrée dans notre usage à environ 12v, la led doit être allumée, le module fonctionne correctement,

 - Circuit sans charge (pas de loco), ajustez le bouton du potentiomètre bleu (dans le sens des aiguilles d'une montre, il augmente la tension de sortie, il la diminue dans le sens antihoraire). Un voltmètre est utile pour ajuster la tension de sortie requise.

 - Circuit avec charge (loco sur les rails), ajustez le bouton de potentiomètre bleu (dans le sens des aiguilles d'une montre, il augmente la tension de sortie, il la diminue dans le sens antihoraire). Vérifier si la tension préalablement fixée assure un bon fonctionnement de la loco. Si la vitesse de déplacement est trop ou pas assez rapide à votre sens, ajuster la.

Remarque :

Il est recommandé d'utiliser sur une période assez longue le module car en fonctionnement la température du LM 2596 s'accroit et la tension de sortie peut légèrement changer, de même qu'en roulant les caractèristiques du moteur en charge sur le canton peuvent aussi varier.

Dans ce cas, il convient peut être d'ajuster à nouveau la tension de sortie toujours en gardant le différentiel minimum de 1.5 V entre la tension d'entrée et de sortie.