LOCODUINO

Décodeur pour aiguillage à solénoïdes sur Arduino

Le 15 novembre 2015. Par : JPClaude

DIFFICULTÉ :

/*
 * 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);}

/*
 * 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
}

/*
 * 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();}

/*
 * 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();}

106 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 15 novembre 2015 19:19, par JPClaude

    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.

    Répondre

• 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 … :-)

  Répondre

• 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.

  Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 30 janvier 2016 14:14, par Philippe.DEVREKER

    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

    Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 5 février 2016 19:23, par JPClaude

    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

    Répondre

• 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 13 février 2016 11:06

    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/product/l9110-stepper-motor-driver-controller-board-for-arduino/
    Celui ci permet la même chose avec 1A : http://www.electrodragon.com/product/tb6612fng-dual-motor-driver-carrier/

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 13 février 2016 11:17, par Wapata

      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.

      Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 13 juillet 2016 16:16, par Tanguy

    J’utilise des L293D pour mes aiguillages Kato depuis plusieurs mois.
    Aucun soucis rencontré.

    Voir en ligne : http://www.tme.eu/fr/Document/82db6…

    Répondre

• 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

  Répondre

• 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

  Répondre

• 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

  Répondre

• Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 14:42, par dupont

  ou trouver la liste des composants electronique merci

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 15:33, par JPClaude

    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.

    Répondre

• 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

  Répondre

• 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 23 janvier 2017 21:37, par Benoit

    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

    Répondre

• 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).

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 24 janvier 2017 12:59, par benoit

    Super, effectivement, c’est plus simple merci !
    Et désolé d’avoir mélangé les sujets.
    Merci

    Répondre

• 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

  Répondre

• 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
      }

  Télécharger

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 15 février 2017 17:10, par Henkens henri

    Merci beaucoup,
    Je fait des essais et je vous tient au courant des résultats
    Cordialement

    Répondre

• 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.

  Répondre

• 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 2 mars 2017 10:35, par Regis Renard

    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.

    Répondre

• 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.

  Répondre

• 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

  Répondre

• 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

  Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 15 août 2017 20:44, par Jean-Luc

    Bonsoir,

    Tout d’abord il faudrait mesurer la résistance du solénoïde, ça donnerait l’intensité maximum en butée.

    Répondre

• 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

  Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 23 février 2018 21:34

    Fichiers téléchargés !

    Merci beaucoup,

    Sylvain

    Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 27 décembre 2018 12:39, par Henkens Henri

    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

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 26 janvier 2019 19:10, par Engrand jean michel

      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

      Répondre

      • Décodeur pour aiguillage à solénoïdes sur Arduino 18 juin 2019 14:56, par Marco

        Bonjour,

        Je suis intéressé par les CI. Où puis-je me les procurer ou les faire faire ?

        Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 4 juin 2021 22:33, par Pierard Ludovic

      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

      Répondre

• 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

  Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 4 mars 2019 13:05, par Phil

    oups lire 4 et non 8 aiguillages pour mon debut de projet.
    pour un debut ca sera probablement plus facile a mettre en oeuvre
    merci

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 5 mars 2019 10:24, par Phil

      j’ai trouvé la solution était plus bas dans l’article.
      super votre site bravo.
      Phil

      Répondre

• 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… ?

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 23 mars 2019 09:03, par Jean-Luc

    Bonjour,
    le temps de recharge du condensateur est indiqué dans l’article : 100ms. C’est la constante RC, 22 x 4700x10^-6 = 103ms.

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 23 mars 2019 09:47, par JFCP43

      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 ?

      Répondre

      • Décodeur pour aiguillage à solénoïdes sur Arduino 23 mars 2019 11:44, par Jean-Luc

        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.

        Répondre

        • Décodeur pour aiguillage à solénoïdes sur Arduino 23 mars 2019 12:19, par JFCP43

          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 !

          Répondre

• 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?article178).
  .
  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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 5 avril 2019 19:40, par Dominique

    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++.

    Répondre

• 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

  Répondre

• 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

  Répondre

• 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 !!!

  Répondre

• 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

  Répondre

• 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 ULN2803A

  Télécharger la nouvelle version, cela devrait résoudre votre problème.
  Bien cordialement.

  Répondre

• 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 !

   :)

  Répondre

• 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 !

  Répondre

• 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

  Répondre

• 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_mot=26&page=theme
  http://locoduino.org/spip.php?article217
  et peut-être plus généralement ;
  http://locoduino.org/spip.php?article186

  Répondre

• 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.

  Répondre

• 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

  Répondre

• 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

  Répondre

• 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)
  Cordialement

  Voir en ligne : Dépannage suite article décodeur pour aiguillage à solénoïdes sur Arduino

  Répondre

• 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 4 février 2021 16:51, par msport

    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 ?

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 4 février 2021 20:45, par Jean-Baptiste

      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) ?

      Répondre

• 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

  Répondre

• 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

  Répondre

• 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

  Répondre

• 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 Louis

  Voir en ligne : Décodeur pour aiguillage à 8 solénoïdes sur Arduino nano en DCC

  Répondre

• 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 !

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 14 février 2021 18:35, par Jean Louis

    Ok
    Merci pour les conseils
    Désolé pour le dérangement….
    J’ai trouvé les bibliothèques qu’il manquait
    Cdt

    Répondre

• 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

  Répondre

• 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é.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 14:15, par denizot

    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

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 15:08, par msport

      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.

      Répondre

      • Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 16:20, par Denizot

        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 ?

        Répondre

        • Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 19:28, par msport

          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.

          Répondre

          • Décodeur pour aiguillage à solénoïdes sur Arduino 13 avril 2021 21:11, par Denizot

            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

            Répondre

• 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

  Répondre

• 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

  Répondre

• 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.

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 16:42, par Denizot

    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

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 18:06, par msport

      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

      Répondre

      • Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 18:30, par Denizot

        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.

        Répondre

• 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

  Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 14 avril 2021 20:22, par Denizot

    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

    Répondre

• 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.

  Répondre

• 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.

  Répondre

• 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).

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 16 avril 2021 12:14, par Denizot

    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.

    Répondre

    • Décodeur pour aiguillage à solénoïdes sur Arduino 15 mai 2021 16:51, par Denizot

      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 ?

      Répondre

• 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

  Répondre

  • Décodeur pour aiguillage à solénoïdes sur Arduino 16 mai 2021 12:26, par denizot

    Merci beaucoup pour votre réponse je vais allez jeter un oeil sur le lien

    Répondre

• 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

  Répondre

• 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.
  Cordialement

  Voir en ligne : Un décodeur d’accessoires universel

  Répondre

• 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

  Répondre

• 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

  Répondre

• 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

  Répondre

• 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.
  Cordialement

  Voir en ligne : Où et comment demander de l’aide ?

  Répondre

• 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 ⇒ OK

  Là, 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 !!
  Cyril

  Voir en ligne : Décodeur pour aiguillage à solénoïdes sur Arduino

  Répondre

  • Décodeur pour aiguillages solénoïdes avec MEGA 20 avril 22:58, par msport

    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.
    Cordialement

    Voir en ligne : Accessories

    Répondre

• 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

  Répondre

Réagissez à « Décodeur pour aiguillage à solénoïdes sur Arduino »