Nous proposons dans cet article la réalisation d’un décodeur d’ aiguillages à solénoïdes sur une base d’Arduino NANO aussi bien en mode TCO (et oui on peut s’amuser sans avoir le DCC) pour quatre aiguillages avec leurs boutons et leurs leds de positionnement, qu’en mode DCC pour huit aiguillages et une extension avec la bibliothèque de Thierry pour Arduino MEGA qui permet d’avoir jusqu’à 32 aiguillages. On présente d’abord de façon rapide le principe des aiguillages à solénoïdes, puis les interfaces possibles de commande de ces derniers, enfin les réalisations de ces décodeurs et des idées de réalisation de cartes. En fin d’article vous trouverez également un petit circuit qui permet de protéger les bobines en cas de dysfonctionnement (bouton coincé ou circuit intégré qui dégénère), cela m’est arrivé avec un ULN2803A qui a maintenu ses sorties du fait d’une mauvaise soudure (adieu pour la bobine concernée).
Décodeur pour aiguillage à solénoïdes sur Arduino
.
Par :
DIFFICULTÉ : 
<
Principe des aiguillages à solénoïdes
Ces aiguillages sont basés sur des moteurs à deux bobines avec un barre en fer doux attirée d’un côté ou de l’autre en fonction de l’alimentation d’une des bobines. Le principe est donc simple, si on alimente une bobine l’aiguille se déplace dans un sens, si on alimente l’autre elle se déplace dans l’autre sens. Ces bobines demandent un fort courant (500mA à 2A pour certain modèle) mais sur un laps de temps très court sous peine de voir griller les bobines. Il existe plusieurs types d’aiguillage, les simples à deux directions, les triples à trois directions et les TJD (Traversée Jonction Double) à quatre positions. Un aiguillage simple est composé d’un moteur, les aiguillages triples de deux moteurs, on peut aller jusqu’à quatre moteurs pour des TJD. Dans tous les cas il suffit de savoir générer la bonne impulsion pour faire varier un des moteurs.
Par exemple dans le cas d’un simple aiguillage il suffit d’envoyer l’impulsion sur une des bobines pour faire varier la position de l’aiguillage. Il suffit de deux broches (une pour chaque sens) et une adresse DCC (DCC/0 et DCC/1).
Dans le cas d’aiguillage triple il faut commander deux moteurs. Il faut donc 4 broches et deux adresses DCC. N’ayant que trois directions, il faut faire attention au mouvement des aiguilles. Par exemple dans le cas des aiguillages PECO type SL99 il faut respecter la table de vérité suivante :
Il y donc une position interdite. Il faut faire attention lorsque l’on branche les points A, B, C et D sur les broches de l’Arduino.
La commande des aiguillages à solénoïdes
Nous ne parlons ici que des aiguillages à solénoïdes. Ces aiguillages demandent une impulsion entre 500mA et 2A pour les plus gros mais avec une courte durée de 50 à 300ms généralement. 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 puisque prise en compte dans la bibliothèque UAD, il suffit donc de déterminer la durée en ms et de fournir cette valeur au 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. Je souligne que je n’ai pas utilisé le L293D car il monopolise trop de broches sur le MEGA.
Les relais
On trouve des interfaces qui vont de 2 à 16 relais à 1RT. Ce qui veut dire qu’un seul relais ne peut commander qu’une seule bobine, il faut donc deux relais pour un moteur d’aiguillage. Chaque broche INx est reliée à une broche de l’Arduino. Lorsque la broche est haute (HIGH) le relais est au repos et lorsqu’elle est basse (LOW) le relais travaille.
Les bornes du relais sont les suivantes :
- GND : la masse de l’Arduino
- VCC : le 5V de l’Arduino
- IN1 à INx : les broches de commande des relais, connectées aux broches digitales de l’Arduino, actives quand LOW.
- STRAP : si le strap est mis on utilise le 5v de l’Arduino, les optocoupleurs sont shuntés, si on enlève le strap il faut fournir une tension (5V ou 12V suivant le type de relais), dans ce cas les optocoupleurs agissent et isolent l’Arduino.
- COMMUN : alimentation du relais (jusqu’à 220V et 10A !!), le commun des bobines.
- Permanent : sortie permanente du relais (position repos)
- Commuté : sortie commutée du relais (position travail), l’entrée d’une bobine
Les relais permettent d’avoir de forte puissance et donc de s’adapter à tout type d’aiguillage, mais ont l’inconvénient d’être bruyants et consommateurs d’énergie. La consommation est de 70mA par relais actionné.
Voici la connexion pour un aiguillage
L’interface L298N
Cette interface contient un double pont H, il peut contrôler deux moteurs CC ou un moteur pas à pas. Ce module supporte des courants de 3A max (2A en fonctionnement continu). La puissance maximale est de 25W. Il possède des diodes de protection rapide pour le pont en H et une grande capacité de filtrage. Ce module coûte moins de 5€.
Les bornes sont les suivantes :
- 1 : - de la bobine 1 du moteur 1
- 2 : - de la bobine 2 du moteur 1
- 3 : strap 12V, il faut l’enlever si on utilise une tension supérieure à 12V (35V max)
- 4 : tension du moteur (enlever le strap si supérieur à 12V), le + commun des moteurs
- 5 : GND, relier les masses de l’Arduino et de l’alimentation externe
- 6 : sortie 5V si le strap est mis (peut alimenter l’Arduino)
- 7 : enable jumper pour le moteur 1 (à connecter dans le cas PWM), laisser le strap ici
- 8, 9, 10, 11 : les entrées de commande de l’Arduino, actives quand LOW
- 12 : enable jumper pour le moteur 2 (à connecter dans le cas PWM), laisser le strap ici
- 13 : - de la bobine 1 du moteur 2
- 14 : - de la bobine 2 du moteur 2
Ce petit module est très intéressant car d’un coût très faible et permettant de gérer des aiguilles à forte demande d’intensité, comme les moteurs PECO. Il ne demande que 36mA au maximum par broche.
Voici la connexion pour un aiguillage
L’interface L9110
Ce composant 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. (Je remercie Denis qui m’a fait connaitre ce composant). Le schéma est le suivant :
IA et IB sont les commandes des sorties OA et OB respectivement, actives quand LOW.
et le schéma de connection est le suivant :
La bobine 1 est activée quand IA est LOW et la bobine 2 quand IB est LOW.
L’interface ULN2803A
Ce composant offre 8 sorties en Darlington pour une tension de 50V max et 500mA par sortie (attention pas de mélange de tension en sortie). Sa structure est simple comme le montre le schéma suivant :
Les connections sont des plus faciles, il faut relier les entrées 1 à 8 aux broches de commande de l’Arduino, actives quand HIGH, les sorties 1 à 8 aux moins des bobines et la broche 10 au plus des moteurs (diodes anti-retour).
Afin d’avoir plus d’intensité on peut relier deux sorties entre elles ce qui permet d’avoir 1A, mais attention pas plus sinon ça chauffe !!.
Voici la connexion pour un aiguillage
Conclusion
On a donc à notre disposition un panel large pour gérer nos aiguillages que l’on peut résumer de la manière suivante :
Réalisation d’un décodeur pour 4 aiguillages à solénoïdes en mode TCO (sans DCC)
Dans ce mode 4 aiguillages peuvent être contrôlés par 4 boutons et 8 leds qui fournissent au TCO la position des aiguilles. Les commandes des moteurs pour cet exemple sont faites via des ULN2803A qui ont l’avantage d’être simple à mettre en place et qui fournissent un courant d’un ampère pour une tension max de 35V. Le schéma de principe est le suivant :
Chaque bouton est une bascule qui change la position d’un aiguillage et allume la led correspondante. Les leds sont commandées par 4 ports de l’Arduino, une partie des leds (bobine1) sont commandées au plus, l’autre partie (bobine2) est commandé au moins. Pour ceux qui le souhaitent voici une idée de carte à réaliser. Les borniers d’aiguillages permettent de connecter les bobines des aiguillages, les borniers leds permettent de connecter les leds du TCO (en tenant compte des polarités) et les borniers boutons pour les boutons du TCO en mode PULLUP :
Le programme INO est le suivant (fichier cde_aiguillage_Nano_TCO) :
/*
* commande de 4 aiguillages sur Arduino UNO/NANO sans DCC avec bouton et led pour TCO
* les boutons sont traites avec anti-rebond
* Les leds indiquent la position de l'aiguillage sur le TCO
* Configuration :
* aiguillage 1 : bobine1 : broche 3, bobine2 : broche 4
* aiguillage 2 : bobine1 : broche 5, bobine2 : broche 6
* aiguillage 3 : bobine1 : broche 7, bobine2 : broche 8
* aiguillage 4 : bobine1 : broche 9, bobine2 : broche 10
* led aiguillage 1 : broche 11
* led aiguillage 2 : broche 12
* led aiguillage 3 : broche 13
* led aiguillage 4 : broche A0
* bouton aiguillage 1 : broche A1
* bouton aiguillage 2 : broche A2
* bouton aiguillage 3 : broche A3
* bouton aiguillage 4 : broche A4
*
*/
/******************************************************************************************
*
* LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur
* CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne
* *********************************************************************************************/
#define CONSOLE // sortie console du deroulement
#define DEBIT_CONSOLE 115200 // le debit de la console
#define ACTIVATION 250 // duree d'activation des bobines en ms ( a modifier si necessaire)
/***********************************************************************************************
*
* LES PARAMETRES INTERNES
*
* ************************************************************************************************/
#define TRAVAIL LOW // LOW pour Relais, L298N, L9110; HIGH pour ULN2803A
#define REPOS HIGH // HIGH pour Relais, L298N, L9110; LOW pour ULN2803A
#define BOBINE1 HIGH // position sur bobine1
#define BOBINE2 LOW // position sur bobune2
#define DELAI_ANTI_REBOND 50
/////////////////// LES AIGUILLAGES ///////////////////////////////////////////////////////
#define FIRST_PIN 3 // broche de depart des aiguillages
//// STRUCTURE D'UN AIGUILLAGE ////
struct TurnOut {
int position_actuelle; // etat, bobine1 ou bobine2
int bobine1; // broche bobine 1
int bobine2; // broche bobine 2
int bouton; // broche du bouton TCO a bascule
int etat_bouton;
int ledBobine; // broche de la Led TCO pour les bobines
boolean demande_activation; // demande d'activation, bouton bascule
};
#define NB_TURNOUT 4 // le nombre d'aiguillages
TurnOut turnout[NB_TURNOUT]; // l'ensemble des aiguillages
/********************************************************************
*
* METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE BOUTON
* Determine periodiquement les bobines a activer
*
*******************************************************************/
void activation_aiguillage(int i) {
int etat = turnout[i].position_actuelle;
if (turnout[i].demande_activation == true) // si l'aiguillage i est en attente d'activation
{
if (turnout[i].position_actuelle==BOBINE1){ // bobine 1 --> bobine 2
digitalWrite(turnout[i].bobine2,TRAVAIL); // activation
delay(ACTIVATION); // duree de l'activation
digitalWrite(turnout[i].bobine2,REPOS); // arret de l'activation
digitalWrite(turnout[i].ledBobine, LOW);
etat = BOBINE2;
#ifdef CONSOLE
Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine2");
#endif
}
else{ // bobine 2 --> bobine 1
digitalWrite(turnout[i].bobine1,TRAVAIL); // activation
delay(ACTIVATION); // duree de l'activation
digitalWrite(turnout[i].bobine1,REPOS); // arret de l'activation
digitalWrite(turnout[i].ledBobine, HIGH);
etat = BOBINE1;
#ifdef CONSOLE
Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine1");
#endif
}
}
turnout[i].position_actuelle = etat; // etat de la bascule
turnout[i].demande_activation = false; // l'aiguillage a etait traite
}
/*************************************************************************************
*
* METHODE de test des boutons avec anti rebond
* determine si un aiguillage est concerne par l'appui d'un bouton
*
***********************************************************************************/
boolean boutonTest(int i)
{ turnout[i].demande_activation = false;
int etat = digitalRead(turnout[i].bouton);
int tempo = millis();
while ((millis() - tempo) < DELAI_ANTI_REBOND) {}
if (etat == LOW){turnout[i].demande_activation = true;}
return turnout[i].demande_activation;
}
/**********************************************************************************************
*
* le setup
* initialise les aiguillages
*
******************************************************************************************/
void setup() {
int decal = 0;
for (int i=0; i<NB_TURNOUT; i++){ // pour tous les aiguillages
turnout[i].demande_activation = false; // pas de demande d'activation
turnout[i].position_actuelle = BOBINE1; // par defaut sur bobine 1
turnout[i].bobine1 = decal+FIRST_PIN; // numero de broche de la bobine 1
pinMode(turnout[i].bobine1, OUTPUT); // bobine 1 en sortie
digitalWrite(turnout[i].bobine1, REPOS); // bobine 1 au repos
turnout[i].bobine2 = 1+decal+FIRST_PIN; // numero de la broche de la bobine 2
pinMode(turnout[i].bobine2, OUTPUT); // bobine 2 en sortie
digitalWrite(turnout[i].bobine2, REPOS); // bobine 2 au repos
turnout[i].ledBobine = FIRST_PIN + i +8; // les led du TCO
pinMode(turnout[i].ledBobine, OUTPUT);
digitalWrite(turnout[i].ledBobine,HIGH); // bobine 1 allumee par defaut
delay(ACTIVATION);
digitalWrite(turnout[i].ledBobine,LOW);
delay(ACTIVATION);
digitalWrite(turnout[i].ledBobine,HIGH);
turnout[i].bouton = FIRST_PIN + i +12; // le bouton du TCO
pinMode(turnout[i].bouton,INPUT_PULLUP);
turnout[i].etat_bouton = HIGH;
decal+=2; // on passe aux aiguillages suivants
}
#ifdef CONSOLE
Serial.begin(DEBIT_CONSOLE);
for (int i=0; i<NB_TURNOUT; i++){
Serial.print("aiguillage");Serial.println(i);
Serial.print("\t bobine 1 sur broche : ");Serial.println(turnout[i].bobine1);
Serial.print("\t bobine 2 sur broche : ");Serial.println(turnout[i].bobine2);
Serial.print("\t bouton TCO sur broche : ");Serial.println(turnout[i].bouton);
Serial.print("\t Led TCO sur broche : ");Serial.println(turnout[i].ledBobine);
}
#endif
}
/*************************************************************************
* boucle
*
******************************************************************/
void loop() {
for (int i = 0;i<NB_TURNOUT;i++) {if (boutonTest(i)) activation_aiguillage(i);}Un exemple de séquence :
aiguillage0
bobine 1 sur broche : 3
bobine 2 sur broche : 4
bouton TCO sur broche : 15
Led TCO sur broche : 11
aiguillage1
bobine 1 sur broche : 5
bobine 2 sur broche : 6
bouton TCO sur broche : 16
Led TCO sur broche : 12
aiguillage2
bobine 1 sur broche : 7
bobine 2 sur broche : 8
bouton TCO sur broche : 17
Led TCO sur broche : 13
aiguillage3
bobine 1 sur broche : 9
bobine 2 sur broche : 10
bouton TCO sur broche : 18
Led TCO sur broche : 14
activation -> aiguillage0 : bobine2
activation -> aiguillage0 : bobine1
activation -> aiguillage1 : bobine2
activation -> aiguillage1 : bobine1
activation -> aiguillage2 : bobine2
activation -> aiguillage2 : bobine1
activation -> aiguillage3 : bobine2
activation -> aiguillage3 : bobine1
Réalisation d’un décodeur pour 8 aiguillages à solénoïdes en mode DCC
Si on utilise le mode DCC, on récupère les ports utilisés par les boutons et les leds pour augmenter les possibilités à 8 aiguillages. Le schéma de principe devient le suivant :
Et une idée de carte à réaliser :
et sa réalisation :
Le programme INO est le suivant (fichier cde_aiguillage_Nano_DCC) :
/*
* decodeur de 8 aiguillages sur Arduino UNO/NANO
* Les aiguillages sont commandes par des sorties sur les broches a partir de la broche 3 par paire (aiguillage 1 = (3,4) etc...)
* ces sorties peuvent etre utilisees directement pour commander des ULN2803 ou les inputs de relais ou L298N
*
*/
/******************************************************************************************
*
* LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur
* CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne
* FIRST_ID_DCC : premiere adresse DCC de depart, premier aiguillage (FIRST_ID_DCC sur broche 3), second aiguillage (FIRST_ID_DCC+1 sur broche 4, etc..)
* NB_TURNOUT : le nombre d'aiguillages = 8
*
*********************************************************************************************/
#define CONSOLE // sortie console du deroulement
#define DEBIT_CONSOLE 115200 // le debit de la console
#define FIRST_ID_DCC 40 // ID DCC de départ
#define ACTIVATION 250 // duree d'activation des bobines en ms ( a modifier si necessaire)
#define NB_TURNOUT 8 // le nombre d'aiguillages
/***********************************************************************************************
*
* LES PARAMETRES INTERNES
*
* ************************************************************************************************/
//////////////////// LE DCC /////////////////////////////////////////////////////////////////
#include <DCC_Decoder.h> // la bibliothèque de Minabay
#define kDCC_INTERRUPT 0 // la pin 2 qui recoit les interruptions du signal DCC
int adresse_precedente = 0; // evite les commandes multiples DCC
int ancienne_position = 2;
volatile boolean MAJ_activation; // si des MAJ a faire apres controle du DCC
/////////////////// LES AIGUILLAGES ///////////////////////////////////////////////////////
#define FIRST_PIN 3 // broche de depart des aiguillages
#define BOBINE1 0 // adresse DCC/0
#define BOBINE2 1 // adresse DCC/1
//// STRUCTURE D'UN AIGUILLAGE ////
struct TurnOut {
int adresse; // son adresse DCC
int position_actuelle; // directe / deviee
int bobine1; // broche bobine 1
int bobine2; // broche bobine 2
boolean demande_activation; // demande d'activation
};
TurnOut turnout[NB_TURNOUT]; // l'ensemble des aiguillages
/********************************************************************
*
* METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE DCC
* Determine periodiquemùent les bobines a activer
*
*******************************************************************/
void activation_aiguillage() {
for (int i = 0; i < NB_TURNOUT; i++) // on balaie tous les aiguillages
{
if (turnout[i].demande_activation == true) // si l'aiguillage i est en attente d'activation
{
switch(turnout[i].position_actuelle) // on regarde la position demandee
{
case BOBINE1 :{ // si bobine 1
digitalWrite(turnout[i].bobine1,HIGH); // activation
delay(ACTIVATION); // duree de l'activation
digitalWrite(turnout[i].bobine1,LOW); // arret de l'activation
#ifdef CONSOLE
Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine1");
#endif
break;}
case BOBINE2 : { // si bobine 2
digitalWrite(turnout[i].bobine2,HIGH); // activation
delay(ACTIVATION); // duree de l'activation
digitalWrite(turnout[i].bobine2,LOW); // arret de l'activation
#ifdef CONSOLE
Serial.print("activation -> aiguillage");Serial.print(i);Serial.println(" : bobine2");
#endif
break;}
}
turnout[i].demande_activation = false; // l'aiguillage a etait traite
}
}
MAJ_activation = false; // on a fait toutes les MAJ
}
/*************************************************************************************
*
* METHODE APPELEE A CHAQUE IT DU DCC
* determine si un aiguillage est concerne par la commande DCC
*
***********************************************************************************/
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{
address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1; // decodage adresse DCC
int bobine = (data & 0x01) ? BOBINE1 : BOBINE2; // quelle bobine est concernee DCC/bobine
// si on change d'adresse ou de position, evite les commandes repetitives
if ((address != adresse_precedente) | ((bobine != ancienne_position)&(address == adresse_precedente))){
if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + NB_TURNOUT)) // si une de nos adresses
{turnout[address - FIRST_ID_DCC].demande_activation = true; // aiguillage en demande d'activation
turnout[address - FIRST_ID_DCC].position_actuelle = bobine; // etat demande (n° de bobine)
MAJ_activation = true; // MAJ demandee
}
adresse_precedente = address; ancienne_position = bobine; // evite de traiter plusieurs fois la meme commande DCC
}
}
/**********************************************************************************************
*
* le setup
* initialise le DCC et les aiguillages
*
******************************************************************************************/
void setup() {
int decal = 0;
for (int i=0; i<NB_TURNOUT; i++){ // pour tous les aiguillages
turnout[i].adresse = FIRST_ID_DCC + i; // son ID DCC
turnout[i].demande_activation = false; // pas de demande d'activation
turnout[i].bobine1 = decal+FIRST_PIN; // numero de broche de la bobine 1
pinMode(turnout[i].bobine1, OUTPUT); // bobine 1 en sortie (ID DCC/0)
digitalWrite(turnout[i].bobine1, LOW); // bobine 1 au repos
turnout[i].bobine2 = 1+decal+FIRST_PIN; // numero de la broche de la bobine 2
pinMode(turnout[i].bobine2, OUTPUT); // bobine 2 en sortie (ID DCC/1)
digitalWrite(turnout[i].bobine2, LOW); // bobine 2 au repos
decal+=2; // on passe aux aiguillages suivants
}
/***********************************************************
* La methode appellee par le DCC
******************************************/
DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); // le DCC
DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT ); // son IT
MAJ_activation = false; // pas de MAJ a priori
#ifdef CONSOLE
Serial.begin(DEBIT_CONSOLE);
for (int i=0; i<NB_TURNOUT; i++){
Serial.print("aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse);
Serial.print("\t bobine 1 sur broche : ");Serial.println(turnout[i].bobine1);
Serial.print("\t bobine 2 sur broche : ");Serial.println(turnout[i].bobine2);
}
#endif
}
/*************************************************************************
* boucle
*
******************************************************************/
void loop() {
DCC.loop(); // demande DCC ?
if (MAJ_activation) {activation_aiguillage();} // si oui activation des aiguillages
}Et un exemple de séquences :
aiguillage0 , code DCC : 40
bobine 1 sur broche : 3
bobine 2 sur broche : 4
aiguillage1 , code DCC : 41
bobine 1 sur broche : 5
bobine 2 sur broche : 6
aiguillage2 , code DCC : 42
bobine 1 sur broche : 7
bobine 2 sur broche : 8
aiguillage3 , code DCC : 43
bobine 1 sur broche : 9
bobine 2 sur broche : 10
aiguillage4 , code DCC : 44
bobine 1 sur broche : 11
bobine 2 sur broche : 12
aiguillage5 , code DCC : 45
bobine 1 sur broche : 13
bobine 2 sur broche : 14
aiguillage6 , code DCC : 46
bobine 1 sur broche : 15
bobine 2 sur broche : 16
aiguillage7 , code DCC : 47
bobine 1 sur broche : 17
bobine 2 sur broche : 18
activation -> aiguillage0 : bobine2
activation -> aiguillage0 : bobine1
activation -> aiguillage1 : bobine2
activation -> aiguillage1 : bobine1
activation -> aiguillage2 : bobine2
activation -> aiguillage2 : bobine1
activation -> aiguillage3 : bobine2
activation -> aiguillage3 : bobine1
Réalisation d’un décodeur pour Arduino MEGA en mode DCC avec la bibliothèque UAD
Avec l’utilisation d’un Arduino MEGA le nombre d’aiguillages explose et peut aller jusqu’à 32 !!!
Nous utilisons ici la bibliothèque UAD de Thierry qui va nous faciliter la configuration du décodeur.
Comme on a pu le voir précédemment, suivant les interfaces il faut envoyer des commandes soit en mode « HIGH » soit en mode « LOW ». Pour cela le programme fournit deux méthodes de setup l’une pour des commandes en mode « HIGH » l’autre pour des commandes en mode « LOW » soit en mode TCO (SetupDigital, SetupDigital_Inverted) soit en mode DCC (SetupDccDigital, SetupDccDigital_Inverted) . Dans notre cas particulier la méthode SetupDigital s’applique uniquement à l’interface avec les ULN2803A, dans les autres cas (relais, ULN298N) la méthode SetupDigital_Inverted doit être appelée, ce qui veut dire qu’il peut y avoir mélange de relais et d’ULN298N mais pas d’ULN2803A. Le programme INO se base sur une classe turnOut donnée en fin d’article (fichier turnOut).
Voici un schéma de principe pour contrôler 16 aiguillages à base d’ULN2803A :
Au centre les 16 pins allant vers les broches de l’Arduino.
Et une idée de carte à réaliser :
En mode TCO il y a un bouton par aiguillage, deux leds pour les positions d’un aiguillage et ses deux bobines, soit 5 broches par aiguillage. Pour la première commande d’aiguillage on obtient donc :
Bouton sur la broche 3,
led bobine1 sur la broche 4,
led bobine2 sur la broche 5,
bobine1 sur la broche 6,
et bobine2 sur la broche 7,
et ainsi de suite.
En mode DCC il n’y a qu’un bouton de test (par défaut sur la broche A15) et une led témoin sur la broche 53, on obtient donc la séquence suivante :
Bobine1 sur broche 3,
Bobine2 sur broche 4,
Et ainsi de suite.
Le programme INO en mode TCO
/*
* decodeur pour des aiguilles à solenoide et a 2 positions sur Arduino MEGA
* en mode TCO
* bouton : pin x
* led bobine 1 : pin x + 1
* led bobine 2 : pin x + 2
* bobine 1 : pin x + 3
* bobine 2 : pin x + 4
*
*/
/********************************************************************
* PARAMETRES DE CONFIGURATION
*
*********************************************************************/
#define NB_TURN_OUT 4 // nombre d'aiguillages
#define ACTIVATION 250 // activation des bobines de 250 ms
/**********************************************************************
* LES PARAMETRES INTERNES
*
*************************************************************************/
#include <UniversalAccessoryDecoder.h> // la biliotheque UAD
#include "TurnOut.h" // la classe des aiguillages
TurnOut aiguilles; // une instance des aiguillages
/*
* pour le setup il faut donner :
* le nombre d'aiguille
* la duree d'activation de l'aiguille
* par defaut la tension est MAX = 255
* on peut modifier cette valeur comme troisieme argument du setup
*
*/
void setup() {
aiguilles.SetupDigital(NB_TURN_OUT,ACTIVATION); // commande = HIGH
//aiguilles.SetupDigital_Inverted(NB_TURN_OUT,ACTIVATION); // ou commande = LOW
}
/*
* la boucle se limite a une methode
*/
void loop() {aiguilles.Loop();}et le même en mode DCC :
/*
* decodeur pour des aiguilles à solenoide et a 2 positions sur Arduino MEGA
* en mode DCC
* base sur le project: <DCC Accessory Decoder> de Thierry PARIS
*
* aiguille y : bobine1 pin x (IdDccy/0), bobine2 pin x+1 (IdDccy/1)
* nombre max d'aiguille y
*
* interruption int0 pour le DCC sur pin 2
*
*/
/********************************************************************
* PARAMETRES DE CONFIGURATION
*
*********************************************************************/
#define NB_TURN_OUT 4 // nombre d'aiguillages
#define ID_DCC 40 // adresse DCC de depart du premier aiguillage
#define ACTIVATION 250 // activation de 250ms
/**********************************************************************
* LES PARAMETRES INTERNES
*
*************************************************************************/
#include <UniversalAccessoryDecoder.h> // la biliotheque UAD
#include "TurnOut.h" // la classe des aiguillages
TurnOut aiguilles; // une instance des aiguillages
/*
* pour le setup il faut donner :
* le nombre d'aiguille
* l'adresse de debut DCC
* la duree d'activation de l'aiguille
* par defaut la tension est MAX = 255
* on peut modifier cette valeur comme quatrieme argument du setup
* par defaut la broche de la led de test DCC est a la broche 53,
* on peut modifier cette valeur comme cinquieme argument du setup
* la broche du bouton est par defaut en A15,
* on peut modifier cette valeur en sixieme argument du setup
*
*/
void setup() {
aiguilles.SetupDccDigital_Inverted(NB_TURN_OUT,ID_DCC,ACTIVATION); // commande = LOW
//aiguilles.SetupDccDigital(NB_TURN_OUT,ID_DCC,ACTIVATION); // ou commande = HIGH
}
/*
* la boucle se limite a une methode
*/
void loop() {aiguilles.LoopDcc();}et un exemple de séquences
Universal Accessories Decoder V4.14.
Developed by Thierry Paris.
*** Setup started.
ButtonsCommander Setup
*** Setup Finished. Memory used = 545 bytes
Avec le bouton de test
DCCToggle : Accessory 0 DccId 40 / 0
AccessoryMotor MoveToggle() : DriverPortArduino 3 MoveLeftDir() at speed 255
255
DriverPortArduino 3 MoveStop()
DCCToggle : Accessory 1 DccId 40 / 1
AccessoryMotor MoveToggle() : DriverPortArduino 4 MoveLeftDir() at speed 255
255
DriverPortArduino 4 MoveStop()
Avec des commandes DCC
DCCToggle : Accessory 1 DccId 40 / 1
AccessoryMotor MoveToggle() : DriverPortArduino 4 MoveRightDir() at speed 255
DriverPortArduino 4 MoveStop()
DCCToggle : Accessory 0 DccId 40 / 0
AccessoryMotor MoveToggle() : DriverPortArduino 3 MoveRightDir() at speed 255
DriverPortArduino 3 MoveStop()
Circuit de protection des solénoïdes
Le circuit suivant permet de protéger l’alimentation des bobines en fournissant une décharge capacitive lors de l’appel et en protégeant les bobines par la durée de recharge du condensateur de l’ordre de 100 ms en laissant un courant de fuite limité à 13,5 mA admissible par les bobines.
L’entrée consiste en une alimentation continue entre 12 et 20 V (ajouter un pont de diode en cas d’alimentation alternative).
En sortie, il faut relier la borne positive au commun des aiguillages et la borne négative au GND de l’Arduino.
Conclusion
Pour un très faible coût et des interfaces de puissance simples il est possible de créer des décodeurs d’aiguillages à solénoïdes. Les programmes sont simples et permettent de réaliser rapidement ces décodeurs sans rentrer dans la complexité de la réalisation logicielle. L’ensemble des possibilités présentées ont été testées sur une console ECOS pour le DCC et fonctionnent parfaitement... Vous trouverez ici bas les programmes et une idée de typons pour réaliser les cartes.
111 Messages
-
Décodeur pour aiguillage à solénoïdes sur Arduino 15 novembre 2015 11:00
Bravo pour cet article très clair et tout à fait dans le cœur des préoccupations des modélistes ferroviaires : fabriquer quelque chose d’utile pour leur réseau de trains miniatures.
Ceux qui n’ont pas encore essayé Arduino peuvent maintenant se lancer car ils ont tout sous la main pour réussir un premier projet.
-
Merci pour votre encouragement mais je le dois à la qualité du site de LOCODUINO qui soulève plein d’idées et de solutions à nos problèmes de modéliste.
Cordialement.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 16 novembre 2015 09:49, par DDEFF
Ce qui est intéressant dans cet article, c’est le fait que tout ce qui concerne l’alimentation des bobines soit regroupé en un seul endroit.
Chacun trouve réponse au problème qu’il se pose, que ce soit en DCC ou en analogique.On voit bien la simplification apportée par l’Arduino et, en DCC, la puissance de la bibliothèque UAD.
A part ça, étrange mélange de français et d’anglais ... :-)
-
Décodeur pour aiguillage à solénoïdes sur Arduino 29 janvier 2016 11:04, par Philippe DEVREKER
Bonjour
J’ai téléchargé le programme Nano Tco sur l’arduino nano mais cela ne l’fonctionne pas. les interrupteurs sont bien pris en compte, et les diodes simulant les bobines sont sur les bonnes sorties.
le défaut est que lorsque l’on bascule l’interrupteur 0, les diodes simulant les bobines(aiguillage 0 bobine 1 et 2) clignotent alternativement sans arrêter .Merci pour votre réponse, car je suis très intéressé par vos articles sur le modélisme ferroviaire et l’arduino et pour le coup cela ne commence pas très fort.
-
Décodeur pour aiguillage à solénoïdes sur Arduino 29 janvier 2016 12:37
Bonjour,
Je viens de refaire les tests et tout fonctionne très bien.
Il faut utiliser impérativement des boutons poussoirs et non des interrupteurs.
Avec ces derniers vous avez effectivement des problèmes.
J’espère avoir répondu à votre question.
Cordialement.
JP-
Bonjour
Merci pour votre célérité à me répondre. C’est exact, cela fonctionne mieux avec des poussoirs, Mea Culpa j’aurais du y penser mais avec l’âge l’esprit fonctionne moins vite.
A bientôt certainement pour d’autres questions notamment sur le bus can qui m’est totalement étranger.
Bon Week-End
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 5 février 2016 16:58, par Gilles29
Bonjour
Merci pour ce travail .
je compte utiliser des L298n pour mes aiguilles Marklin.
j’ai téléversé le sketch Turn_out , séléctionné la méthode setupdccdigital .
le L298N réagit bien aux ordres DCC , mais quelquesoit l’ordre envoyé , il ne se déactive pas , la led témoin de la sortie scintille rapidement , il faut envoyer une adresse qui ne concerne pas ce module pour que le clignotement s’arrête .
J’ai sans doute oublier quelque chose pas je ne trouve pas . j’utilise un Nano .
Merci d’avance pour l’aide
Gilles-
Bonjour,
vu le peu d’information sur votre configuration (liens entre les pins Arduino et le LN298N) j’ai du mal à vous répondre.
Par contre si vous utilisez des LN298N il faut utiliser SetupDigital_Inverted."la méthode SetupDigital s’applique uniquement à l’interface avec les ULN2803A, dans les autres cas (relais, ULN298N) la méthode SetupDigital_Inverted doit être utilisée"
Le problème provient peut-être de là ?
Tenez- moi informé.
Cordialement.JP
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 12 février 2016 19:30, par Wapata
Bonjour, ce montage n’est pas compatible avec des aiguillages à UNE bobine, style kato, où l’on doit inverser le sens du courant. Une idée de composant à utiliser pour cette configuration ?
Merci.-
Il faut un petit pont en H pour celà. À ma connaissance les aiguillages Kato consomment 600mA. Par exemple celui ci permettra de piloter 2 aiguillages Kato http://www.electrodragon.com/produc...
Celui ci permet la même chose avec 1A : http://www.electrodragon.com/produc...-
Merci pour le lien !
Mais, n’y a t il pas un risque de faire un court-circuit ’logiciel’ avec cette méthode, à l’initialisation de l’arduino ou autre ?
Marrant, j’aurais jamais pensé à regarder du côté des contrôleurs de moteurs pas à pas.
-
-
J’utilise des L293D pour mes aiguillages Kato depuis plusieurs mois.
Aucun soucis rencontré.Voir en ligne : http://www.tme.eu/fr/Document/82db6...
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 20 novembre 2016 11:32, par Jean-Pierre
Bonjour,
J’ai deux arduino mega et surtout 50 aiguillages peco et autant de moteurs comment faire pour passer de 32 à 50 moteurs,et bien entendue la commande se fera avec des relais et pour la protection bobine est qu’il en faut une par moteur ou une pour plusieurs moteurs, je dispose d’une console ecos et le logiciel de commande des trains sur l’ordinateur sera CDM.
Merci d’avance
Jean-Pierre
-
Décodeur pour aiguillage à solénoïdes sur Arduino 20 novembre 2016 15:02, par JPClaude
Bonjour,
Je ne connais pas le logiciel CDM mais je vais répondre à vos deux questions :
1) la première en ce qui concerne la protection des aiguillages il ne faut pas en mettre autant que de moteurs, il faut simplement savoir qu’il y a un temps de latence d’environ 100ms, cela dépend de votre réseau mais avec trois ou quatre bien réparties il n’y a pas de problème.
2) pour augmenter le nombre de broches de l’Arduino on peut utiliser des registres à décalage 74HC595 qui ne prennent que trois broches de l’Arduino pour huit sorties. On peut même les mettre en série (voir ci_dessous des exemples). Par contre il faut réécrire complétement le programme qui ne prend pas en charge ce cas. Mais si vous avez deux Méga il suffit de donner la première adresse du premier aiguillage au premier Méga (par exemple 40) et au second la première adresse qui suit (par exemple 72).Par contre avec 50 aiguillages je préconiserais plutôt l’utilisation de Nano qui permet une meilleure répartition sur le réseau et une réduction importante du câblage. Chaque Nano peut prendre en charge 8 aiguillages en mode DCC.
Exemple 74HC595 unique :
/************************************************************************************** * Contrôle d'un registre à décalage 74HC595, avec l'utilisation de la fonction shiftOut. * On allume 4 LEDs paires, et ensuite 4 LEDs impaires, en boucle. * Connexions: Arduino broche 2 -- 74HC595 broche 15 (entrée des données) * Arduino broche 3 -- 74HC595 broche 12 (latch) * Arduino broche 4 -- 74HC595 broche 11 (clock) * https://www.arduino.cc/en/Tutorial/ShiftOut ***************************************************************************************/ #define data 2 #define latch 3 #define clock 4 void setup() { pinMode(data, OUTPUT); pinMode(latch, OUTPUT); pinMode(clock, OUTPUT); } void loop() { // d'abord, nous allumons toutes les LEDs paires digitalWrite(latch,LOW); // intialisation de la pin 12 du 595 shiftOut(data, clock, MSBFIRST, 0b01010101); digitalWrite(latch,HIGH); // contenu de la mémoire transféré à la sortie du 595 delay (500); // on attend un peu // ensuite nous allumons toutes les LEDs impaires digitalWrite(latch,LOW); // initialisation de la pin 12 du 595 shiftOut(data, clock, MSBFIRST, 0b10101010); digitalWrite(latch,HIGH); // contenu de la mémoire transféré à la sortie du 595 delay (500); // on attend un peu }et un exemple avec deux en séries :
/* cas de deux registres à décalage 74HC595 en série * on envoie le poids fort puis le poids faible */ const int verrou = 11; // le Latch const int donnee = 10 // la Data const int horloge = 12; /: le top de décalage char octetInf = 8; //un exemple en binaire : 00001111 char octetSup = 35; //un exemple en binaire : 11111111 void setup() { //on déclare les broches en sortie pinMode(verrou, OUTPUT); pinMode(donnee, OUTPUT); pinMode(horloge, OUTPUT); //puis on envoie les données juste une fois //on commence par mettre le verrou digitalWrite(verrou, LOW); //on envoie la donnée de poids fort d'abord shiftOut(donnee, horloge, MSBFIRST, octetSup); //on envoie la donnée de poids faible shiftOut(donnee, horloge, MSBFIRST, octetInf); //et on relache le verrou pour mettre à jour les données digitalWrite(verrou, HIGH); } void loop() { }Cordialement.
JPC -
Décodeur pour aiguillage à solénoïdes sur Arduino 21 novembre 2016 14:13, par Jean-Pierre
Merci, parce que acheter des décodeurs tous fait cela revient cher, mais avec Arduino cela est pas mal question prix et ne coute pas cher du moins. Pour l’instant je réfléchi à tous cela et si j’ai un problème je reviendrai vers vous.
Jean-Pierre
-
Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 14:42, par dupont
ou trouver la liste des composants electronique merci
-
Bonjour,
je ne comprends pas votre question, est-ce ou trouver la liste des composants ? il me semble que cela se trouve sur les schéma, ou est-ce ou acheter les composants ? un petit tour sur le WEB vous fournira une multitude de boutiques.
Cordialement.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 19:20, par Benoit
Bonsoir,
Je souhaiterais connecter mes 2 leds à la même sortie que mon relais pour économiser des pins. C’est à dire modifier le schéma et utiliser un transistor entre le relais et l’Arduino pour contrôler mes leds.
Je comprends la connectique pour alimenter ma led lorsque j’active mon relais. Mais j’ai doute pour alimetner mon autre led en état bas.
Est-ce possible ?
Merci -
Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 21:02, par JPClaude
Bonjour,
je ne comprends pas bien votre question.
1) sur quel modèle êtes vous ? mode TCO sans DCC, mode DCC, MEGA avec DCC UAD ?
2) Comment voyez-vous la chose, les solénoïdes sont sur impulsion, les LED sur du continu, avez-vous un schéma de votre idée, ou se trouve votre relais ?
Cordialement.-
Bonsoir,
1) Je suis un modèle TCO sans DCC
2) Je me suis mélangé les pinceaux, désolé. Je voulais gérer la coupure d’une section de voie et non la commande d’aiguillage mais le schéma m’inspirait. En partant de ce schéma, mon idée était de connecter la sortie de l’arduino à la base d’un transistor, le collecteur ou l’émetteur vers la masse ou 5V et l’émetteur ou le collecteur serait connecter au relais et aux 2 leds. Une des leds s’allume à l’état haut et l’autre à l’état bas.
Cordialement
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 24 janvier 2017 09:30
si la commande est continue, il suffit de mettre en parallèle une LED sur la commande du relais et une autre en parallèle sur la sortie du relais vers le rail dans le bon sens suivant les alimentations (avec des résistances de protection). Quand le relais est au repos c’est la LED de commande qui s’allume (ou s’éteint) et la LED de sortie qui s’éteint (ou s’allume), quand le relais travaille c’est la LED de commande qui s’éteint (ou s’allume) et la LED de sortie qui s’allume (ou s’éteint).
-
Super, effectivement, c’est plus simple merci !
Et désolé d’avoir mélangé les sujets.
Merci
-
-
Décodeur pour 8 aiguillage à solénoïdes sur Arduino 15 février 2017 12:07, par Henkens henri
Bonjour,
Je voudrais modifier le programme afin de pouvoir faire fonctionner les aiguillages par paires avec 2 adresses se suivant et pouvant chacune commander indifféremment les 2 aiguillages en même temps.
Exemple adresse 60 et 61
60 commande sur broche 3 et 4 + 5 et 6
61 commande sur broche 5 et 6 + 3 et 4
Soit 4 groupes de deux
Pourriez vous m’aider SVP
Merci d’avance
Cordialement -
Décodeur pour aiguillage à solénoïdes sur Arduino 15 février 2017 14:55, par JPClaude
Bonjour,
visiblement vous voulez gérer des aiguillages doubles du type PECO.
Je n’ai pas beaucoup de temps en ce moment mais voici un programme qui peut répondre à votre problème (je n’ai pas eu le temps de le tester in situ).
Bien cordialement./* * decodeur de 4 aiguillages double sur Arduino UNO/NANO * Les aiguillages sont commandes par des sorties sur les broches a partir de la broche 3 par quadruple (aiguillage double 1 = (3,4,5,6) etc...) * adresse premier aiguillage paire (X), adresse second aiguillage impaire (X+1) * ces sorties peuvent etre utilisees directement pour commander des ULN2803 ou les inputs de relais ou L298N * */ /****************************************************************************************** * * LES PARAMETRES DE CONFIGURATION a definir par l'utilisateur * CONSOLE : pour avoir le deroulement du programme, si pas necessaire supprimer la ligne * FIRST_ID_DCC : premiere adresse DCC de depart, premier aiguillage (FIRST_ID_DCC sur broche 3), second aiguillage (FIRST_ID_DCC+1 sur broche 4, etc..) * NB_TURNOUT : le nombre d'aiguillages = 4 * *********************************************************************************************/ #define CONSOLE // sortie console du deroulement #define DEBIT_CONSOLE 115200 // le debit de la console #define FIRST_ID_DCC 40 // ID DCC de départ #define ACTIVATION 250 // duree d'activation des bobines en ms ( a modifier si necessaire) #define NB_TURNOUT 4 // le nombre d'aiguillages /*********************************************************************************************** * * LES PARAMETRES INTERNES * * ************************************************************************************************/ //////////////////// LE DCC ///////////////////////////////////////////////////////////////// #include <DCC_Decoder.h> // la bibliothèque de Minabay #define kDCC_INTERRUPT 0 // la pin 2 qui recoit les interruptions du signal DCC int adresse_precedente = 0; // evite les commandes multiples DCC int ancienne_position = 2; volatile boolean MAJ_activation; // si des MAJ a faire apres controle du DCC /////////////////// LES AIGUILLAGES /////////////////////////////////////////////////////// #define FIRST_PIN 3 // broche de depart des aiguillages #define BOBINE1 0 // adresse DCC/0 #define BOBINE2 1 // adresse DCC/1 //// STRUCTURE D'UN AIGUILLAGE //// struct TurnOutDouble { int adresse; // son adresse DCC premier aiguillage DCC (paire), [on deduit le second aiguillage DCC+1 (impaire)] int position_actuelle_A; // directe / deviee premier aiguillage (0,1) int bobine_A1; // broche bobine 1 premiere aiguille int bobine_A2; // broche bobine 2 premiere aiguille int position_actuelle_B; // directe / deviee second aiguillage (0,1) int bobine_B1; // broche bobine 1 second aiguille int bobine_B2; // broche bobine 2 seconde aiguille boolean attente; // attente de la deuxieme adresse boolean demande_activation; // true, false }; TurnOutDouble turnout[NB_TURNOUT]; // l'ensemble des aiguillages /******************************************************************** * * METHODE APPELEE SI UNE DEMANDE DE MISE A JOUR PAR LE DCC * Determine periodiquemùent les bobines a activer * *******************************************************************/ void activation_aiguillage() { for (int i = 0; i < NB_TURNOUT; i++) // on balaie tous les aiguillages { if (turnout[i].demande_activation) { // si un des deux aiguillages a modifier if (turnout[i].attente) { // si en attente activation if (turnout[i].position_actuelle_A == BOBINE1) { // bobine A1 concernee digitalWrite(turnout[i].bobine_A1,HIGH); // activation delay(ACTIVATION); // duree de l'activation digitalWrite(turnout[i].bobine_A1,LOW); // arret de l'activation #ifdef CONSOLE Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A1"); #endif } else { // si bobine A2 digitalWrite(turnout[i].bobine_A2,HIGH); // activation delay(ACTIVATION); // duree de l'activation digitalWrite(turnout[i].bobine_A2,LOW); // arret de l'activation #ifdef CONSOLE Serial.print("activation -> premier aiguillage");Serial.print(i);Serial.println(" : bobine_A2"); #endif } if (turnout[i].position_actuelle_B == BOBINE1) { // si bobine B1 digitalWrite(turnout[i].bobine_B1,HIGH); // activation delay(ACTIVATION); // duree de l'activation digitalWrite(turnout[i].bobine_B1,LOW); // arret de l'activation #ifdef CONSOLE Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B1"); #endif } else { // si bobine B2 digitalWrite(turnout[i].bobine_B2,HIGH); // activation delay(ACTIVATION); // duree de l'activation digitalWrite(turnout[i].bobine_B2,LOW); // arret de l'activation #ifdef CONSOLE Serial.print("activation -> second aiguillage");Serial.print(i);Serial.println(" : bobine_B2"); #endif } turnout[i].attente = false; // on a termine le traitement } else { // sinon on attend la deuxieme activation turnout[i].attente = true; } turnout[i].demande_activation = false; // activation realisee } } MAJ_activation = false; // on a fait toutes les MAJ } /************************************************************************************* * * METHODE APPELEE A CHAQUE IT DU DCC * determine si un aiguillage est concerne par la commande DCC * ***********************************************************************************/ void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data) { address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1; // decodage adresse DCC int bobine = (data & 0x01) ? BOBINE1 : BOBINE2; // quelle bobine est concernee DCC/bobine // si on change d'adresse ou de position, evite les commandes repetitives if ((address != adresse_precedente) | ((bobine != ancienne_position)&(address == adresse_precedente))){ adresse_precedente = address; ancienne_position = bobine; // evite de traiter plusieurs fois la meme commande DCC if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (NB_TURNOUT*2))){ // si une de nos adresses if ((address%2)==0){ address = address - FIRST_ID_DCC; // adresse paire = premier aiguillage turnout[address].position_actuelle_A = bobine; // on place la bobine concernee } else { address = address - (FIRST_ID_DCC - 1); // adresse impaire = second aiguillage turnout[address].position_actuelle_B = bobine; // on place la bobine bobine concernee } turnout[address].demande_activation = true; // demande d'activation } MAJ_activation = true; // MAJ demandee } } /********************************************************************************************** * * le setup * initialise le DCC et les aiguillages * ******************************************************************************************/ void setup() { int decal = 0; int index = 0; for (int i=0; i<NB_TURNOUT; i++){ // pour tous les aiguillages turnout[i].adresse = FIRST_ID_DCC + index; // premier aiguillage : son ID DCC turnout[i].bobine_A1 = decal+FIRST_PIN; // numero de broche de la bobine A1 pinMode(turnout[i].bobine_A1, OUTPUT); // bobine A1 en sortie (ID DCC/0) digitalWrite(turnout[i].bobine_A1, LOW); // bobine A1 au repos turnout[i].bobine_A2 = 1+decal+FIRST_PIN; // numero de la broche de la bobine A2 pinMode(turnout[i].bobine_A2, OUTPUT); // bobine A2 en sortie (ID DCC/1) digitalWrite(turnout[i].bobine_A2, LOW); // bobine A2 au repos turnout[i].bobine_B1 = 2+decal+FIRST_PIN; // numero de broche de la bobine B1 pinMode(turnout[i].bobine_B1, OUTPUT); // bobine B1 en sortie (ID DCC+1/0) digitalWrite(turnout[i].bobine_B1, LOW); // bobine B1 au repos turnout[i].bobine_B2 = 3+decal+FIRST_PIN; // numero de la broche de la bobine B2 pinMode(turnout[i].bobine_B2, OUTPUT); // bobine B2 en sortie (ID DCC+1/1) digitalWrite(turnout[i].bobine_B2, LOW); // bobine B2 au repos decal+=4; // on passe aux broches suivantes index+=2; // adresse suivante } /*********************************************************** * La methode appellee par le DCC ******************************************/ DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true); // le DCC DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT ); // son IT MAJ_activation = false; // pas de MAJ a priori #ifdef CONSOLE Serial.begin(DEBIT_CONSOLE); for (int i=0; i<NB_TURNOUT; i++){ Serial.print("premier aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse); Serial.print("\t bobine A1 sur broche : ");Serial.println(turnout[i].bobine_A1); Serial.print("\t bobine A2 sur broche : ");Serial.println(turnout[i].bobine_A2); Serial.print("second aiguillage");Serial.print(i);Serial.print(" , code DCC : ");Serial.println(turnout[i].adresse+1); Serial.print("\t bobine B1 sur broche : ");Serial.println(turnout[i].bobine_B1); Serial.print("\t bobine B2 sur broche : ");Serial.println(turnout[i].bobine_B2); } #endif } /************************************************************************* * boucle * ******************************************************************/ void loop() { DCC.loop(); // demande DCC ? if (MAJ_activation) {activation_aiguillage();} // si oui activation des aiguillages }-
Merci beaucoup,
Je fait des essais et je vous tient au courant des résultats
Cordialement
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 1er mars 2017 12:37, par Régis Renard
Bonjour,
Super présentation.Petite question, n’étant pas électronicien, je voudrais savoir si le montage proposé pour un Arduino nano en mode DCC fonctionne également pour un train Marklin qui utilise du courant alternatif ?
Bien à vous.
-
Décodeur pour aiguillage à solénoïdes sur Arduino 1er mars 2017 14:41, par JPClaude
Bonjour,
je ne suis pas un spécialiste de Marklin mais il me semble que leur protocole n’est pas compatible avec la norme DCC NMRA.
Je pense donc que cela ne devrait pas fonctionner.
Cordialement.-
Au contraire, Marklin fonctionne sans problème avec le protocole DCC mais il est vrai que cela n’a pas toujours été le cas.
D’où ma question concernant votre schéma et le courant alternatif.
Bien à vous.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 3 mars 2017 16:47, par JPClaude
Je ne comprends pas votre question.
Etes-vous en digital ou en analogique ?
Quelle console avez-vous, avec quel protocole ?
Cordialement. -
Décodeur pour aiguillage à solénoïdes sur Arduino 8 juin 2017 15:13, par PascalR
Bonjour et merci pour cet excellent dossier qui ouvre de nombreuses possibilités de commande des aiguillages. N’étant pas doué en électronique j’ai quelques difficultés à identifier tous les composants malgré schémas et images.
Sur le schéma "8 décodeurs aiguillages DCC sur NANO" :
- Sous le bornier "Alim DCC", quelle est le type de diode : 1N4545 ou 1N4548 ?
- Les deux résistances sous "décodage DCC" sont bien des 10k ? en 1/4W ou 1/2W ?
- Quel est ce composant marqué "Alim NANO via DCC" entre les deux condensateurs ?
- Enfin peut-on utiliser un pont redresseur SIP 2A au lieu du 1A et 50V car pour le moment je ne trouve pas et je voudrais garder le typon ?
En vous remerciant, bien cordialement.Pascal
-
Décodeur pour aiguillage à solénoïdes sur Arduino 8 juin 2017 17:33, par JPClaude
Bonjour,
1) type de diode sous le bornier DCC : C’est une diode de commutation de type 1N4148 ou 1N4154 (je n’ai pas les datasheet des 1N4545 ou 1N4548, mais il faut pouvoir commuter quelques centaines de milliampère sous 25V)
2) résistances sous décodage DCC : des 10K 1/4W (ça chauffe pas là)
3) composant marqué alim Nano via DCC : c’est un régulateur classique 78M08 qui fournit du 8V (encadré par deux condensateurs non polarisés de 100nF et avec radiateur car ici ça chauffe un petit peu)
4) pont redresseur : OK pas de problème, c’est ce que j’ai mis personnellement.
cordialement.
JP -
Décodeur pour aiguillage à solénoïdes sur Arduino 13 août 2017 11:55, par Clemsang
Bonjour,
Je suis en train de planifier un micro réseau. J’aimerais piloter un unique aiguillage Jouef avec un Arduino Uno.
Je compte utiliser le composant L298N : une sortie moteur pour l’aiguillage et l’autre pour piloter la voie. Partie voie déjà programmée et fonctionne, pour l’aiguillage je suis perdu.
Quelle est la durée maximale pour ne pas détruire la bobine et quelle est la tension minimale ?
Si quelqu’un a déjà adapté pour ce composant, j’accepte un coup de main.
Merci beaucoup-
Bonsoir,
Tout d’abord il faudrait mesurer la résistance du solénoïde, ça donnerait l’intensité maximum en butée.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 22 février 2018 12:08, par Sylvain Faure
Bonjour,
j’ai des soucis avec la résolution des images concernant les images des cartes à réaliser concernant ce projet, je n’arrive pas bien à lire les caractères, pouvez-vous m’aider svp ?
Vos site est super et j’ai beaucoup apprécié l’article concernant l’équipe de Locoduino dans le dernier Locorevue.
Bien amicalement,
Sylvain
-
Décodeur pour aiguillage à solénoïdes sur Arduino 23 février 2018 19:04, par JPClaude
Bonsoir,
j’ai rajouter en fin d’article un fichier schema.zip qui contient l’ensemble des schémas au format pdf beaucoup plus lisible.
J’espère que cela vous conviendra.
Bien cordialement.
JPC -
Décodeur pour aiguillage à solénoïdes sur Arduino 3 septembre 2018 19:30, par JEAN MICHEL
Bonjour,
Excellent dossier !!
Du coup mon collègue et moi voudrions fabriquer pour nos réseaux
des Nano DDC et Nano Tco , mais quand nous avons voulu faire faire les CI
cela c’est compliqué ...
On nous demande les fichiers Gerber , mais débutants nous ne savons pas faire...
Peut être savez vous ou l’on pourrai se procurer ces fichier ?
Par avance Merci
Cordialement
Jean Michel-
Bonjour,
J’ai réalisé par gravure a l’anglaise un circuit imprimé permettant de piloter 8 aiguillages avec un arduino Nano et le programme ci dessus.
Il comprend tous les composants et borniers il suffit de raccorder et cela marche.
Je peux vous fournir les Gerbers et excellon pour réaliser ce circuit.
Je pourrai même vous graver des circuits si vous voulez.
Contactez moi si vous voulez plus d’infos et photos.
Cordialement
Henri Henkens-
Bonjour,
Nous vous remercions de votre réponse,
Nous avons trouvé un site pour fabriquer les CI et nous les avons fait faire ,ces montages fonctionnent très bien ...
Merci encore a tous
Cordialement
Jean michel-
Bonjour,
Je suis intéressé par les CI. Où puis-je me les procurer ou les faire faire ?
-
-
Bonjour,
je suis intéressé par les fichiers Gerbers et excellon de vos PCB, je pratique également la gravure à l’anglaise avec une petite cnc3018.
Je voulais aussi savoir si il serait possible de piloter des moteurs Peco PL-11, en effet avec mes décodeurs déjà existant sur mon réseau il n’est pas possible de les déclencher par cause de manque de puissance.Merci pour votre réponse
vlb@outlook.be
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 5 février 2019 15:21, par Jean-Francois CP
GE-NI-AL ! : votre article est clair, complet, précis : bravo et surtout merci pour cet excellent partage !
J’ai utilisé cet article pour piloter des aiguilles via TCO (pas DCC) avec des ULN2803A et suis ravi du résultat !
J’aurais juste une remarque, c’est que, lorsqu’on arrête le système, si une aiguille est en position "bobine2", au rallumage du système, c’est la LED associée à l’état "bobine1" qui s’allume... => j’ai ajouté l’activation des "bobine1" des aiguilles dans le setup et comme ça, toutes mes aiguilles sont remises a l’état conforme à la LED du TCO au rallumage du système.
...à moins que j’ai raté quelque chose dans votre code ?
Encore merci !
Jean-François -
Décodeur pour aiguillage à solénoïdes sur Arduino 4 mars 2019 12:09, par Phil
bonjour, j’aimerai me lancer avec un arduino mega dans ce project pour commander au début 8 aiguillages et probablement plus plus par la suite.
ma question est la suivante, puis-je utiliser le programme (commande aiguillages NANO TCO) ecrit pour le Nano sur un Mega ou faut-il apporté des modifications ?
merci de m’éclairé a ce sujet
Phil -
Décodeur pour aiguillage à solénoïdes sur Arduino 23 mars 2019 08:53, par JFCP43
Bonjour,
Merci pour cet article qui m’a permis de réaliser un premier TCO à base de Nano sans DCC opérationnel !Bon, je partage le seul souci que j’ai eu, si ça peut servir à d’autres ! :
- tout marchait bien... tant qu’aucune aiguille n’était réellement reliée aux sorties de mes ULN2803.
- mais une fois les aiguilles reliées pour de vrai... ben ça marchait qq instants puis tout devenait aléatoire, se figeait, et souvent l’Arduino redémarrait tout seul !
=> à priori, le problème venait du fait que je n’utilisais qu’une alimentation 12VDC pour alimenter l’Arduino ET mes aiguilles. Une fois que j’ai séparé les deux (= 2 alimentations 12VDC, avec juste leur masse (GND) en commun), tout fonctionne !
Cependant, une question demeure : normalement, les bobines des aiguilles sont faites pour fonctionner en alternatif et non en continu => vous joignez un schéma permettant de protéger les bobines par le biais d’une décharge capacitive, mais si on voulait juste utiliser une alimentation alternative pour piloter les bobines, est-ce que ce serait faisable ? en séparant les GND de chaque alimentation ?
En tout cas, d’après ce que j’ai pu lire ici ou là, cette protection n’est pas une option en cas d’utilisation d’une alimentation continue si on ne veut pas griller ses bobines à plus ou moins long terme... or dans mon programme, j’ai ajouté l’utilisation d’itinéraires pilotant 3 ou 4 aiguilles les unes après les autres : est-ce que le condensateur aura bien le temps de se recharger et jouer son rôle entre chaque pilotage d’aiguille... ?
-
Bonjour,
le temps de recharge du condensateur est indiqué dans l’article : 100ms. C’est la constante RC, 22 x 4700x10-6 = 103ms.-
Donc, si je reste sur une valeur supérieure à 100ms pour l’impulsion envoyée à mes ULN2803 (250ms par défaut dans votre programme), comme les aiguilles sont pilotées les unes après les autres (et non simultanément), ça devrait le faire ! => merci de votre réponse !
Et pour une alimentation alternative... pas envisageable à cause des ULN2803 fonctionnant en continu, c’est ça ?-
L’ULN ne peut pas piloter de l’alternatif. L’alternatif c’est pénible à gérer. Soit on met des relais soit on met un triac (pour chaque moteur d’aiguillage). Dans tous les cas ça demande du matériel supplémentaire.
-
OK, va pour la décharge capacitive alors ! ;o)
En tout cas, merci pour votre programme, j’ai réussi à le modifier pour :- piloter 5 aiguilles,
- remplacer les LEDs standards contre un ensemble de WS2812B qui ne prennent qu’une broche de l’Arduino pour être pilotées (et gérer leur couleur / luminosité aussi)
- ajouter un bouton à 2 positions et sa LED associée pour gérer des itinéraires,
- gérer des "conditions de départ" = un itinéraire ou une position des aiguilles par défaut à l’allumage.
Du coup, j’ai deux choix de commande : soit aiguille par aiguille, soit itinéraire par itinéraire et j’aime le pilotage ainsi procuré, pour un coût très maitrisé : MERCI !
Bon, soyons honnête, je n’ai par contre pas réussi à conserver le mode de programmation "objet" : il faut encore que je travaille là dessus et sur la notion de "structures", mais il y a matière à faire sur ce site, je ne désespère donc pas !
-
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 4 avril 2019 16:33, par daufinsyd
Bonjour,
Merci beaucoup pour cet article ! Je me suis récemment remis au modélisme et ce site est une vraie mine d’or :)
.
Je vais probablement ouvrir un sujet sur le forum mais en attendant j’aimerais avoir votre avis pour savoir si j’ai bien compris (j’avoue que c’est encore la pagaille dans mon esprit avec tous les articles du site).
.
Sachant que je souhaite utiliser JMRI couplé à DCC++ : pour contrôler des aiguillages électriques, il faut donc un arduino relié à un (ou plusieurs) relais et y téléverser la bonne bibliothèque (par exemple celle pour MEGA de cette page ou celle-ci https://www.locoduino.org/spip.php?...).
.
Dans ce cas l’arduino est relié à JMRI (via usb ou autre) et celui-ci "détecte" les aiguillages. JMRI enverra les commandes DCC au bon arduino qui se chargera de générer le bon signal pour le relai.
.
Ceci implique également que l’arduino soit exclusivement dédié à la gestion des aiguillages (sauf si on utilise la bibliothèque "universelle / accessoire" dans quel cas il pourrait faire d’autres choses ?).
.
Si vous pouviez m’aiguillez, histoire de savoir si je suis sur la bonne voie ou si je fais totalement fausse route, ça serait top :)
.
Merci pour vos réponses-
Je ne suis pas utilisateur de JMRI mais DCC++ (version bibliothèque DCCpp) peut commander les aiguilles (turnout) en même temps qu’il génère le DCC pour les rails.
Par conséquent il n’y a que l’Arduino supportant DCCpp à relier à JMRI soit en USB, soit en Ethernet. Relisez la doc DCC++.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 20 octobre 2019 18:56, par JPB
Bonsoir,
Pas encore familier avec les lignes de programmation, j’ai copié le programme "sans DCC" et l’ai téléversé sur mon Arduino. Accompagné d’une carte 16 relais, ce code fonctionne bien et les poussoirs /leds font bien leur travail...
Seul bémol, mes relais sont actifs en permanence et ne se mettent au repos que pendant la phase de commande (250 ms par défaut)
Je cherche en vain depuis deux jours à inverser la commande pour que mes relais restent au repos et s’activent quand j’en ai besoin. (relais actifs à l’état bas des entrées et confirmé dans votre texte). Le tout sans artifice supplémentaire si possible.
D’autant plus que lors de la mise sous tension, avec le câblage actuel, les bobines sont alimentées pendant au moins 5 secondes avant que l’arduino ne les mettent au repos. Déjà faillit en griller deux !
Une aide peut-être ? avec les explications de la modif dans le code si possible...
Merci -
Décodeur pour aiguillage à solénoïdes sur Arduino 20 octobre 2019 21:38, par msport
Je n’ai pas relu le programme "commande de 4 aiguillages sur Arduino UNO/NANO sans DCC avec bouton et led pour TCO", mais très basiquement, si les commandes sont inversées par rapport à ce que vous souhaitez, il faut remplacer tous les LOW par des HIGH et réciproquement pour les sorties vers les bobines.
Cela dit, quand on utilise les cartes à 8 relais suivant le schéma du lien ci-dessous, les relais sont bien activés par un LOW.
Comme les relais ont un contact repos et un travail, il suffit d’en changer.Voir en ligne : Carte 8 relais
-
Décodeur pour aiguillage à solénoïdes sur Arduino 20 octobre 2019 21:40, par Dominique
Peut-être mettre un HIGH à la place d’un LOW ou vice versa, selon le matériel que vous utilisez.
Ah, on est plusieurs à partager ce point de vue !!! -
Décodeur pour aiguillage à solénoïdes sur Arduino 21 octobre 2019 13:11, par JPB
Bonjour,
Merci pour ces réponses... Je vais tester ce soir vos remarques.
Quand vous écrivez : "sur la carte 8 relais, les relais sont bien activés par un état bas" . Je confirme cet état et le fait que mes 8 relais (sur les 16) sont bien activés par un état bas (sortie de carte arduino) à la mise en route du programme... D’ou ma question sur la possibilité d’inverser la programmation et de laisser ces relais au repos donc sans rien consommer au lieu de les alimenter en permanence ! Donner juste l’impulsion - état LOW - quand je souhaite commander une bobine.
Réponse après les tests...
Bonne journée
-
Décodeur pour aiguillage à solénoïdes sur Arduino 21 octobre 2019 16:23, par Jean-Pierre
Bonjour,
Cela provient que le programme présenté initialement se base sur des ULN2803A qui sont commandés à l’état haut.
J’ai modifié le programme pour le rendre paramétrable, il suffit pour cela de redéfinir les deux lignes suivantes au début du programme ino sans DCC en fonction des composants utilisés :#define TRAVAIL LOW // LOW pour Relais, L298N, L9110 ; HIGH pour ULN2803A
#define REPOS HIGH // HIGH pour Relais, L298N, L9110 ; LOW pour ULN2803ATélécharger la nouvelle version, cela devrait résoudre votre problème.
Bien cordialement. -
Décodeur pour aiguillage à solénoïdes sur Arduino 21 octobre 2019 17:44, par JPB
Ah voilà ... Super ! tout fonctionne comme je le souhaite.
Merci pour votre soutien. J’ai déjà appris beaucoup en quelques jours mais je ne suis pas aussi alerte à 59 ans avec le modernisme qu’il y a 30 ans !
:)
-
Décodeur pour aiguillage à solénoïdes sur Arduino 21 octobre 2019 21:30, par trimarco232
"Comme les relais ont un contact repos et un travail, il suffit d’en changer"
c’est un cas typique où il faut surtout éviter de faire ça ! -
Branchement aiguillages électrique avec arduino 22 décembre 2019 22:48, par duffour olivier
Bonjour,je viens de m’inscrire et je suis en recherche de branchement d’aiguillage commander avec un inverseur (interrupteur flash).Je ne suis pas calé en arduino.Il y a un branchement en haut de la page : Arduino/relais/moteur mais je n’ai pas le interrupteur et le programme.Si vous aviez un photo et m’expliquer comment programmé.
D’avance merci à vous.
Olivier -
Décodeur pour aiguillage à solénoïdes sur Arduino 23 décembre 2019 23:02, par msport
Bonjour,
comme vous débutez, commencez par prendre connaissance des articles : http://locoduino.org/spip.php?id_mo...
http://locoduino.org/spip.php?article217
et peut-être plus généralement ;
http://locoduino.org/spip.php?article186 -
Décodeur pour aiguillage à solénoïdes sur Arduino 17 juillet 2020 11:52, par Juan
Bonjour,
Tout d’abord, félicitations pour cet excellent travail. Très intéressant et très bien expliqué.
Eh bien, je prévois d’installer le sketch avec la bibliothèque UAD en mode DCC, et j’aimerais utiliser plusieurs 74HC595. Pourriez-vous me dire comment l’ino devrait être modifié ?
Merci beaucoup,
Juan.
-
Décodeur pour aiguillage à solénoïdes sur Arduino 17 juillet 2020 11:56, par Juan
Bonjour,
Tout d’abord, félicitations pour cet excellent travail. Très intéressant et très bien expliqué.Eh bien, je prévois d’installer le sketch avec la bibliothèque UAD en mode DCC, et en utilisant plusieurs 74HC595. Pourriez-vous me dire comment l’ino devrait être modifié ?
Merci beaucoup,
Juan
-
Décodeur pour aiguillage à solénoïdes sur Arduino 4 janvier 2021 10:26, par Jean-Luc
Bonjour, Quel travail remarquable que celui-ci. Afin d’éviter l’usage fastidieux de la Multimaus avec le système numérique ROCO, je souhaite opter pour un retour à la commande manuelle par TCO classique. Avec une petite douzaine d’aiguillages à commander, j’ai pensé - peut-être à tort - que la réalisation de 3 modules sur base d’Arduino Nano + ULN2803A serait la bonne solution. Chaque module pris séparément fonctionne de façon irréprochable. Le problème se pose lorsque j’utilise les modules supplémentaires : l’appui sur un bouton poussoir déclenche, de temps en temps et aléatoirement le changement de position de l’un ou l’autre aiguillage. Ce phénomène pourrait-il être dû à un problème mécanique (bouton poussoir) ou alors électronique ? N’étant ni électricien ni électronicien, je cherche la solution à cet inconvénient. Merci d’avance pour la solution proposée.
Jean-Luc -
Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino 4 janvier 2021 17:01, par msport
Bonjour,
Je vous suggère de poster des précisions sur le forum (avec schéma si utile)
CordialementVoir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Décodeur pour aiguillage à solénoïdes sur Arduino 3 février 2021 22:35, par Jean-Baptiste
J’ai perdu ! Les solénoïdes Jouef ne mangent que de l’alternatif, pas du continu.
Il va donc falloir utiliser une carte à relais.Par contre, est-ce qu’il n’est pas possible de commander simplement un pont en H (ou autre idée) afin de générer un signal 50Hz ?
J’ai un vieux transfo Jouef, mais ça prend une place conséquente.
Merci d’avance pour votre aide.-
Mais non, mais non, tout ceux qui ont gagné ont joué !
Sauf si ils sont rouillés les solénoïdes Jouef fonctionnent aussi en continu.
Il faut peut-être passer à 15V CC en n’insistant pas trop sur le bouton.
De quel modèle s’agit-il ? Et est-on sur qu’il fonctionne en alternatif ?-
C’est du vieux Jouef, acheté d’occasion, je ne connais pas la référence.
Bobine testée sous 12V , elle est totalement fonctionnelle. Sous 18Vcc, ça fait une bonne étincelle sur le fil de test, ça ressemble fortement à un court-circuit (si je me souviens de mes vieux cours, une self en courant continu a une résistance tendant vers 0).J’aimerais éviter de rajouter un bloc d’alimentation à mon circuit provisoire. Je me demande s’il est possible de prélever le 18Vcc et de l’onduler avec un nano, par exemple.
Peut-être que c’est une mauvaise idée à cause des courants d’appels importants de la self qui pourraient perturber la stabilité de l’alimentation (2A) ?
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 5 février 2021 10:10, par msport
Pour du dépannage, postez une photo sur le fil correspondant du forum :
Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Décodeur pour aiguillage à solénoïdes sur Arduino 11 février 2021 19:26, par Romain
Bonjour,
Je cherche a réaliser un décodeur DCC pour aiguilles solénoïde avec un MEGA2560. J’ai donc réalisé le montage électrique qui va bien et chargé le programme pour faire un test sur 4 aiguilles (remplacées par des LED pour le test). Mais après une commande via Multimaus rien ne se passe. J’ai téléchargé un moniteur DCC pour vérifier que le montage électrique est bon...tout est bon, l’Arduino lit la trame DCC.
j’ai remis le programme DCC pour MEGA (plus haut) et toujours rien. Quand je branche une LED témoin sur Pin53 elle clignote (donc normal), et quand je fais un test via le bouton de test en A15, le fonctionnement est tout bon, les sortie s’active pendant le temps prévu.
Mais j’ai remarqué que quand je "verifie" le programme il me met plein de message d’erreurs.
avez vous déjà rencontré ce problème ou est ce que je me suis trompé avec la bibliothèque ou autre...je ne trouve pas le problème.
si quelqu’un a déjà eu le cas.
merci -
Décodeur pour aiguillage à solénoïdes sur Arduino 11 février 2021 21:06, par msport
Pour du dépannage, allez sur le fil correspondant du forum :
Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Décodeur pour aiguillage à 8 solénoïdes sur Arduino nano en DCC 14 février 2021 13:31, par Jean Louis
Bonjour, a tous
Nouveau sur ce forum très bien fait et surtout nouveau en Arduino
j’ai un petit soucis lors du téléversement du Prg dans l’Arduino Nano
j’ai une alarme "impossible de trouver la bibliothèque h" Autrement dit il s’arrête à :#include <DCC_Decoder.h> // la bibliothèque de Minabay !?C’est quoi cette foutue bibliothèque ? et ou la trouver, et au cas ou ou faut il la mettre dans le répertoire ? sous les Documents ou bien sur c :\Arduino ?? Voilà je suis un peut perdu...Mais je débute..
D’ailleurs certains vont surement rigoler, mais une fois l’Arduino branché en USB, après avoir lu le prog, faut il le téléverser dedans, et reste il en mémoire ? j’espère que oui...lol
Merci de votre aide
Jean LouisVoir en ligne : Décodeur pour aiguillage à 8 solénoïdes sur Arduino nano en DCC
-
Décodeur pour aiguillage à solénoïdes sur Arduino 14 février 2021 17:46, par msport
Effectivement pour éviter de déclencher l’hilarité générale, il vaudrait mieux commencer par le début. (lien ci-dessous)
En deuxième semaine, vous pourrez consulter Installer une bibliothèque, on vous donnera le lien mais si vous êtes en avance vous trouverez la page avec "Rechercher" en haut à droite.
En troisième semaine, on vous donnera des conseils pour taper "#include <DCC_Decoder.h> " dans Google et trouver la bibliothèque correspondante.
Cependant pour des conseils qui vous sont personnels et n’enrichissent pas le sujet, allez sur le fil correspondant du forum ou postez sur le fil Débuter.Voir en ligne : Arduino : toute première fois !
-
Ok
Merci pour les conseils
Désolé pour le dérangement....
J’ai trouvé les bibliothèques qu’il manquait
Cdt
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino DCC 12 avril 2021 17:52, par Denizot
bonjour,
Je cherche à réaliser le montage afin de commander 8 aiguillages avec l’arduino nano, mais je ne trouve pas la liste des composants électroniques mise à part les ULN2803A et l’arduino nano quelqu’un peut il m’aider merci -
Décodeur pour aiguillage à solénoïdes sur Arduino 12 avril 2021 22:41, par msport
Bonjour,
c’est le montage en mode TCO (sans DCC) que vous souhaitez réaliser ?
les LED ne sont pas nécessaires au fonctionnement (et d’ailleurs, il y a une erreur dans le schéma, il vaut mieux attendre la correction pour les monter).
Par ailleurs, les composants sont repérés sur le schéma, il suffit de faire le décompte des boutons, des LED, des diodes 1N4148 (en final inutiles) et des résistances de 2200 ohms. Tout y est indiqué.-
Bonjour,
Le montage que je souhaite réaliser est le suivant : Réalisation d’un décodeur pour 8 aiguillages à solénoïdes en mode DCC. j’ai réussi à déterminer à grand peine tous les composants en utilisant une loupe sur mon écran de PC, mais il me manque le voltage du condensateur 2200Uf qui n’apparait nul part.
merci d’avance-
Bonjour,
ce condensateur reçoit la tension redressée du DCC. Elle sera toujours inférieure à celle qui alimente la centrale. Vous pouvez vous contenter de 16V. A noter aussi que sa capacité est largement surdimensionnée compte tenu de la fréquence du DCC, mais qui peut le plus peut le moins.
Par ailleurs, nous sommes plusieurs à avoir constaté que pour obtenir un fonctionnement à coup sur de la partie détection (dite montage Mynabay) avec un 6N137, il y a lieu de mettre un petit condensateur (entre 22 et 100 pF, commencer avec 27pF) entre les pattes 2 et 3 du 6N137 - en parallèle avec la diode 1N4148.-
Re bonjour,
Au sujet du condensateur 2200uf je ne pense pas pouvoir me contenter de 16V car à la sortie de ma centrale de marque Rocco j’ai 20,4V
Pour le reste merci pour l’info le schéma serait donc le suivant : relier les deux pistes par le condensateur 27 uf en provenance du signal DCC passant par la diode 1N4148 et la piste provenant de la résistance 1K ? positionner le condensateur en aval de ces deux composants ?-
Au lieu de 16V, 25V ne posera pas de problème si l’empattement convient.
Mais il est probable que votre mesure de 20,4V faite avec le calibre alternatif de votre multimètre ne reflète pas la tension réelle compte tenu du facteur 1,4 qui ne correspond pas aux signaux carrés du DCC. Faites une mesure en tension continue après un pont de diodes pour savoir ce qu’il en est.
27 pico Farad et non micro Farad, à mettre en parallèle avec la 1N4148, donc en aval de la 1K. et non de la 1N4148. Il n’est pas obligatoirement nécessaire.-
je ne trouve pas de condensateur de 2200uf à 25v à 16v oui mais ma mesure en courant continu, avec mon multimètre en sortie d’un pont de diode est de 22,9v.
Comme il n’y a pas mieux qu’un petit schéma pour le condo de 27 pico farad, pourrais-je compter sur vous ?
d’avance merci
-
-
-
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 21:28, par msport
A mon avis, vous pouvez utiliser un 1000 µF 25V sans problème. Il y a plus que de la marge pour alimenter un Nano et les ULN2803.
Vous trouverez le schéma de la partie interface pour décodeur sur le site de Dave Bodnar.
Votre centrale est une z21 ? Il y a un bloc secteur qui l’alimente ? D’origine ? Qu’y a t il d’indiqué dessus ?
Voir en ligne : D. Bodnar booster
-
Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 22:02, par Denizot
Merci pour l’info du condensateur 1000 uf 25 v devrait effectivement être au top.
Pour ma central c’est une simple 10764 alimenté par un transformateur conrad de 4.4 amp 16 volts alternatif et controlé encore une fois ce jour.
Pour ce qui est du schéma, je ne l’ai pas trouvé derrière le lien indiqué !!
merci encore de votre aide -
Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 11:21, par msport
Vérifiez la tension maximale des décodeurs et accessoires que vous utilisez.
Si le transfo ROCO 10851 de 54 Watts délivre 20 V continus, le transfo 10725 ROCO (dit universel) de 50 VA fournit une tension continue de 16 V.
Si vous redressez une tension de 16 V alternatif vous obtenez une tension de 16 V x 1,4 = 22,4 V. Ce que vous constatez.Le schéma souhaité figure comme cinquième illustration en descendant sur la page que je vous ai indiquée. Utilisez la molette de votre souris.
-
Bonjour,
J’en suis à me demander si nous parlons bien de la même chose, mais j’ai mis un pont de diodes en sortie de transformateur pour alimenter la centrale Rocco donc en 16V continue, mais la si les locos fonctionnent les fonctions elles non, même l’inversion de l’éclairage ne fonctionne plus ? Alors qu’alimenté en alternatif je ne rencontre aucun problème !!!! j’avoue que vous avez semé le doute dans mon esprit.
Et puis le lien que vous m’avez donné m’amène sur la description d’un Booster DCC qui même au niveau de la cinquième illustration n’a rien à voir avec mon problème du positionnement du condensateur de 27 pico farad ??? merci quand même-
On passe sur le forum, ce qu’on aurait du faire depuis le début (sans schéma ou photo, difficile de deviner)
Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Bonsoir,
Je suis d’accord avec vous en effet, je n’ai aucun problème avec mon matériel, et les 22.4 volts sur ma voie me convient très bien, je cherche seulement à suivre vos conseils et placer le condo de 27 pico farad au bon endroit sur mon circuit imprimé, rien de plus.
-
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 18:10, par msport
Le bon lien.
Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 18:56, par msport
Le schéma mis sur le forum est-il clair pour vous ?
Lien ci-dessous.Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino
-
Le schéma sur le forum, devrait certainement être clair si je le trouvais malheureusement je ne le trouve pas, je dois vraiment être un peu C.. maintenant vous me parlez de flèches et pour faire un peu d’humour j’ai beau suivre les cowboys et les indiens je ne vois pas de quelles flèches vous me parlez ? si seulement il était possible de poster un petit schéma sur votre site, il n’y aurait aucune polémique.
cordialement
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 21:17, par msport
Je ne sais pas quoi vous dire de plus que de cliquer sur le lien "Dépannage ... " qui suit "Voir en ligne :" Ce texte, en bleu ciel, qui est dit cliquable, vous emmènera droit sur l’article où j’ai déposé à votre intention les schémas en question.
-
Décodeur pour aiguillage à solénoïdes sur Arduino 15 avril 2021 12:43, par Denizot
Bonjour,
Et bien moi non plus je ne sais pas quoi vous dire, je me suis dit peut être que mon navigateur google ne veut pas afficher les liens dont vous me parlez, je vais donc ouvrir l’URL dans Edge, résultat identique, donc j’essaie avec firefox, pareil. Une fois sur le forum "dépannage" vos deux derniers messages ne m’ouvrent aucun lien ? il n’y a aucun "voir en ligne en bleu ciel" ???
cordialement.
il n’est pas toujours facile à un non électronicien de tout comprendre dans la logique d’un professionnel et c’est normal, mais, si on ajoute à cela une incompréhensibilité dû au dialogue par le système des forums cela devient un véritable casse tête et je dirais même plus, une prise de tête. -
Décodeur pour aiguillage à solénoïdes sur Arduino 15 avril 2021 14:29, par Jean-Luc
Il n’y a rien de mystérieux.
Les images attachées aux messages du forum Locoduino ne sont pas visibles des visiteurs. Pour tout voir, il faut s’inscrire sur le forum puis s’y connecter.
Par ailleurs, il faut faire la distinction entre un lien et l’endroit où il mène car si le vocabulaire déraille, personne ne se comprend. Quand msport parle de lien, c’est le texte cliquable qui apparaît au bas de ses messages ci-dessus. Quand Denizot parle de lien, c’est l’endroit où il mène (c’est pas un lien du coup).-
Merci Jean Luc,
Effectivement une fois inscrit sur le forum les schémas apparaissent comme par magie
merci Msport pour ta patience et les dessins que j’ai enfin pu voir.
je vous tiens au courant de la suite de mon travail.
et encore bravo pour tous ces développements à base d’Arduino.-
Super réalisé de A à Z cela fonctionne à merveille, bravo pour pour le travail fournit et la patience avec des gens comme moi qui ne comprennent pas toujours tout du premier coup. Une autre question, car j’ai fouillé sur le site et je n’ai pas trouvé, existe-t-il sur le même principe de décodeur, la possibilité de commander en DCC 8 aiguillages avec de petits servo moteur ?
-
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 15 mai 2021 23:17, par msport
je ne pense pas qu’il y ait un article dédié sur Locoduino.
En fait il faudrait adapter ce projet qui délivre une information tout ou rien en 0-5V. Mais au delà, il faut prévoir de régler les butées.
C’est à la lecture des articles sur "Passage à niveau géré par Arduino" et "La bibliothèque SlowMotionServo", "Satellite V1" que vous verrez ce qu’il est possible de faire.
Pour un projet terminé, il y a un article qui décrit une telle réalisation très aboutie sur Model Railroad Hobbyist MRH mais c’est pour l’amateur averti et anglophone.Voir en ligne : Quad Servo DCC Decoder
-
Merci beaucoup pour votre réponse je vais allez jeter un oeil sur le lien
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 30 mars 2022 17:23, par Gilles Corbel
Bonjour à tous ,
J’ai téléversé le schéma pour faire fonctionner 20 aiguillages
sur une carte Mega .
Une fois changé les paramètres et adapter le programme aux L298N
tout fonctionne correctement sauf que au démarrage certains aiguillages vibrent fortement , cela dure environ 3/4 secondes et tout se calme ensuite .
Et cela arrive aussi quand pour une raison X , le courant digital est coupé et qu’à la remise de celui-ci ,ça recommence ..
A force certains moteurs ont chauffé .
Y a -t-il un moyen de désactiver la phase d’initialisation de l’Arduino ? et que les positions des aiguilles restent en mémoire ?Merci d’avance pour l’aide
Cordialement
Gilles -
Décodeur pour aiguillage à solénoïdes sur Arduino 31 mars 2022 18:28, par msport
Bonjour,
je crains que la réponse se fasse attendre, en effet l’article qui présente la bibliothèque correspondante (UniversalAccessoryDecoder) commence par cet avertissement :
Attention : cette bibliothèque a été remplacée par Bibliothèque Commanders et Bibliothèque Accessories (1), etc.
CordialementVoir en ligne : Un décodeur d’accessoires universel
-
Décodeur pour aiguillage à solénoïdes sur Arduino 6 mai 2022 19:00, par Auzereau Alain
Bonjour.
je cherche un code pour piloter 24 aiguilles par bouton ,avec servos sg90 (angle et vitesse) et fin de courses (1 pour la pointe de coeur et un 2eme pour la signalisation.pouvez vous me guider pour avancer sur ce projet.( j ai realisé les moteurs aiguilles avec servo et fin de courses ).avec vos projets ,j ai réalisé une dcc++ et une telecommande infra rouge , merci a
l equipe locoduino qui me motive à poursuivre la mise en place de mon réseau.encore merci,Alain
-
Décodeur pour aiguillage à solénoïdes sur Arduino 6 mai 2022 20:23, par msport
Bonjour,
en cascadant deux PCA9685 et en adaptant le code fourni sur la page ci-dessous, je pense que vous aurez la solution à votre problème.
Cordialement
Voir en ligne : Contrôler plusieurs servomoteurs avec le PCA9685
-
Décodeur pour aiguillage à solénoïdes sur Arduino 11 janvier 20:40, par Christian
Bonjour je possede une carte ARDUINO UNO et je souhaite connaitre le cablage avec ma carte relais Keyes Funduino pour faire fonctionner les moteurs d’aiguillage fleischmann que je posséde
Voulez vous m’aider s’il vous plait...
Merci -
Décodeur pour aiguillage à solénoïdes sur Arduino 11 janvier 21:11, par msport
Bonsoir,
comme précisé dans l’article ci-dessous, pour un dépannage, veuillez poster votre demande sur le forum. Vous pourrez y mettre une photo de votre carte.
Elle devrait néanmoins ne pas être différente de celle du paragraphe La commande des aiguillages à solénoïdes ci-dessus, où il y a un schéma pour une sortie de Mega sur un module 8 relais. A dupliquer autant que de besoin.
CordialementVoir en ligne : Où et comment demander de l’aide ?
-
Décodeur pour aiguillages solénoïdes avec MEGA 20 avril 21:49, par Cyirl
Bonsoir à vous,
Je suis tout nouveau sur le forum. Pour la petite histoire, pendant le covid, j’ai retrouvé le train échelle N de mon grand-père (année 1970 !). En voulant le moderniser, je suis tombé sur votre site extrêmement enrichissant.
J’ai essayé de me débrouiller tout seul mais là je bloque !!
J’ai une carte NANO où j’ai installé la centrale numérique ==> OK
Je l’ai connecté à CDM-RAIL ==> OKLà, je suis sur la partie "DECODEUR aiguillages"
Matériel : une carte MEGA
Interface :L298N- j’ai installé le programme pour la NANO (cde_aiguillage_nano_dcc.zip). Programme très simple sur ma MEGA. Cela marche parfaitement depuis CDM-RAIL
- je souhaiterais mettre plus d’aiguillages donc j’ai téléversé le programme mega.zip
Il est noté qu’avec L298N - mode « LOW » et mode UNIQUEMENT en mode DCC ==> SetupDccDigital_Inverted. Et là, j’ai branché et le courant est arrivé en continu !!!
Je pense avoir grillé mes 2 aiguillages en tests !!!
J’ai uniquement activé dans Turn_Out : aiguilles.SetupDccDigital_Inverted(NB_TURN_OUT,ID_DCC,ACTIVATION)
J’ai du faire une erreur
Merci pour vos réponses !!
CyrilVoir en ligne : Décodeur pour aiguillage à solénoïdes sur Arduino
-
Bonjour,
désolé pour vos soucis.
L’article date de 2015 et l’auteur n’intervient plus sur Locoduino depuis plusieurs années.
Par ailleurs, la bibliothèque UAD n’est plus maintenue par son auteur, remplacée par Accessories en 2016
Ceci pour dire que vous risquez d’attendre longtemps une réponse qui nécessite de maitriser le C++.
Mais une centrale DCC++ pilotée par CDM-rail devrait pouvoir commander autant de décodeurs que de besoin, les décodeurs recevant leurs ordres en DCC, avec l’avantage de pouvoir les décentraliser.
CordialementVoir en ligne : Accessories
-
Décodeur pour aiguillage à solénoïdes sur Arduino 21 avril 07:46
Bonjour
Merci beaucoup pour votre réponse rapide
Je regarde donc l’article du site associé a "accessories" et je reviens vers vous si nécessaire !
Merci bien.
Cyril -
Décodeur pour aiguillage à solénoïdes sur Arduino 24 août 21:19, par Jean-Baptiste
Bonjour,
Je voulais savoir s’il existait un circuit complémentaire en PNP à l’ULN2803 ?
L’idée serait d’utiliser ce circuit pour commander un moteur MP1 de MTB avec une seule sortie d’arduino (voie normale à l’état bas, voie deviée à l’état haut).
A défaut, quelle paire de transistor ou MOS serait conseillée pour cette application ? -
Décodeur pour aiguillage à solénoïdes sur Arduino 24 août 22:19, par msport
-
Décodeur pour aiguillage à solénoïdes sur Arduino 10 novembre 17:12, par DenisL
Bonjour,
je me penche actuellement sur la commande d’aiguilles Peco en DCC et je lis avec grand intérêt ce site. Je vais commencer par utiliser une carte à relais.
Dans le paragraphe "Réalisation d’un décodeur pour 8 aiguillages à solénoïdes en mode DCC", on trouve au début un schéma Fritzing. Il me semble que ce schéma comporte une erreur : le 6N137 ne serait-il pas numéroté à l’envers ? La numérotation ne correspond pas à celle de Minabay.
J’ai bien noté aussi qu’il peut être nécessaire d’ajouter un condensateur 270 pF en parallèle de la 1N4148.
Concernant la résistance de 1 kOhm, je comprends mal pourquoi il serait nécessaire de prévoir une résistance de 1 W (comme je l’ai lu par ailleurs) : l’intensité qui passe dans le circuit d’entrée du 6N137 est-elle si élevée pour exiger une telle puissance et pouvoir de dissipation de chaleur ?
J’en suis au stade de la réflexion ; je n’ai pas encore touché au "hardware".
Merci pour vos réponses (et pour l’ensemble de ce merveilleux site !).-
Bonjour,
Merci pour vos compliments.
pour ma part, je n’arrive pas à lire de numérotation sur le Fritzing. Pour autant, le circuit imprimé montre le bon ordre avec l’encoche du circuit intégré.
Un condensateur de 22 pF à 270 pF en parallèle de la 1N4148 peut être utile. Pour moi, c’est OK avec 47pF.
Pour la puissance, vous pouvez faire le calcul :
Supposons 20V comme alimentation et négligeons les pertes de le centrale, diode et opto :
On retrouve cette tension sur les rails. P= 20x20 / 1000 = 0,4W. Vaut mieux éviter d’utiliser une 0,5W proche de ses possibilités.
Maintenant vous pouvez refaire le calcul avec votre tension et en retirant les pertes.
Il est toujours utile de réviser ses classiques.
-
-
Décodeur pour aiguillage à solénoïdes sur Arduino 11 novembre 16:32, par DenisL
Merci pour votre réponse.
Oui, en effet, le dessin du circuit imprimé est correct heureusement ; pour ma part, j’arrive à lire les n° des pattes du 6N137 sur le schéma Fritzing et je confirme qu’il ne faut pas se fier à ces numéros (je ne pense pas utiliser votre circuit imprimé).
Concernant la puissance nécessaire pour la résistance, votre explication me permet de comprendre le problème. Comme je n’ai pas de résistances 1W, je vais donc monter deux résistances de 2KOhm 1/4W en parallèle à la place de la 1K. Comme j’ai 16 V dans la voie (comme vous, j’ignore les pertes), chaque résistance dissipera donc P=16x16/2000=0,12 W, ce qui est en effet bien plus tolérable pour des résistances 1/4W, autrement on n’aurait pas de marge même avec 16V seulement.
Et maintenant, au fer à souder ! :-) Je reviendrai ici si j’ai une expérience utile à partager. Merci encore.