LOCODUINO

Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO

.
Par : JPClaude

DIFFICULTÉ :

Sur nos réseaux il est nécessaire de contrôler un certain nombre d’articles comme la détection de présence avec le cantonnement et la position des aiguillages qui ont un impact direct avec le roulement de nos trains et d’autres articles, plus pour l’esthétique, comme les animations ou les feux de signalisation. La détection a été abordée avec le bus S88 et maintenant avec le travail de mes collègues avec le bus CAN beaucoup plus performant. Le contrôle des aiguillages à solénoïde a également été abordé dans un article précédent. Nous souhaitons ici proposer une solution pour réaliser un décodeur de feux de signalisation à deux ou trois feux gérés par des commandes DCC.

Réalisation de la carte décodeur

Les feux de signalisation sur nos réseaux n’ont aucune influence sur le roulement de nos trains, ils sont juste là pour créer un environnement réaliste. Si vous êtes comme moi un peu réfractaire à comprendre la complexité des signaux SNCF, je me limite, au moins pour l’instant, à des signaux à deux ou trois feux. Je vous propose donc de réaliser un décodeur pour ce type de signaux.

Feux de signalisation

Le principe est assez simple puisque cela revient à allumer ou éteindre des leds, ce que nos Arduino font très bien. Les signaux en DCC sont considérés comme des accessoires possédant une adresse (dans le cas des signaux à deux feux) ou deux adresses (dans le cas des signaux à trois feux). Il suffit donc de coller un capteur de signaux DCC à un Arduino qui exécutera la commande reçue et allumera (ou éteindra) les bonnes leds. Dans notre approche l’alimentation des leds est faite par le courant DCC.
Le schéma suivant reprend la capture des signaux DCC classique basée sur un 6N137 auquel on ajoute en parallèle un pont et un régulateur 8V pour l’alimentation de l’Arduino et des leds. Cela est raisonnable car nous le verrons dans le cas des signaux à trois feux il n’y aura que 5 leds allumées et dans le cas des signaux à deux feux, 8 leds allumées. Un strap a été prévu suivant la polarité des signaux (leds avec commun positif ou négatif). L’Arduino reçoit les commandes DCC sur la broche 2 (interruption 0) et renvoie le résultat sur les broches 3 à A4 suivant les cas. Cela tient sur une carte classique 6x10 et est la même que ce soit des signaux à deux ou trois feux.

Carte décodeur signalisation
Architecture de la carte

Et voici le typon correspondant :

Typon de la carte décodeur

(NB : petite astuce pour ceux qui se lance dans la réalisation, le problème est d’aligner convenablement le perçage pour l’Arduino NANO. Pour cela j’utilise une plaque d’essai qui me sert de guide :

Perçage de la carte décodeur

Et tout se passe bien.)
Pour ceux qui connaissent Eagle et qui font leur carte via des fournisseurs voici les fichiers Eagle :

Fichiers Eagle

et le zip Gerber qui va avec :

Fichier Gerber

et obtient des cartes quasi professionnelles :

signalisation carte
signalisation carte montée

L’algorithme

Le programme permet de gérer aussi bien les signaux à deux feux que ceux à trois feux. Par contre on ne peut mélanger les deux types sur une même carte.
Pour les signaux à trois feux la carte admet 5 signaux dont les leds sont contrôlées par les broches 3 à A3 en triplet.

Signal1 broches 3,4,5
Signal2 broches 6,7,8
Signal3 broches 9,10,11
Signal4 broches 12,13,A0
Signal5 broches A1,A2,A3

Les adresses paires correspondent aux leds vertes et rouges.
Les adresses impaires correspondent aux leds jaunes.

Pour les signaux à deux feux la carte admet 8 signaux dont les leds sont contrôlées par les broches 3 à A4 par paire.

Signal1 broches 3,4
Signal2 broches 5,6
Signal3 broches 7,8
Signal4 broches 9,10
Signal5 broches 11,12
Signal6 broches 13, A0
Signal7 broches A1, A2
Signal8 broches A3, A4

Chaque signal possède une adresse unique.

L’algorithme est simple et ne demande que trois paramètres de configuration :
MODE : détermine le niveau de commande des leds en fonction de la polarité commune, LOW si le commun est positif, HIGH si le commun est négatif.
FIRST_ID_DCC : correspond à la première adresse des signaux, les adresses des signaux suivants en découleront (linéaire dans le cas BICOLOR, par paire dans le cas TRICOLOR).
NB_TRAFFIC_LIGHT : détermine la nature des signaux, TRICOLOR pour des signaux à trois feux ou BICOLOR pour des signaux à deux feux.
Un dernier paramètre ne sert qu’à permettre de visualiser la bonne configuration et peut être omis par la suite, c’est le paramètre CONSOLE.

Le reste de l’algorithme reste inchangé quel que soit le type de signaux.

Paramètres internes

Ils déterminent les paramètres du DCC (insertion de la librairie Minabay, broche d’interruption), évitent les commandes multiples ayant même adresse et/ou même commande (previous_address/previous_position) et si une mise à jour est nécessaire (update_light).

Ils décrivent les signaux (BICOLOR ou TRICOLOR), la broche de départ des leds des signaux (FIRST_PIN) et les couleurs possibles (GREEN, RED, YELLOW).
Ils définissent la structure d’un signal (light) qui possède une adresse (address), une couleur courante (current_position), les broches des leds associées (green, red et yellow) et si une requête de changement est demandée (activation_request).
L’ensemble des signaux est regroupé dans un tableau (traffic_light[]).
Le setup instancie le DCC et détermine les adresses des signaux (address), linéaire dans le cas BICOLOR, par paire dans le cas TRICOLOR, les broches des leds (green, red, yellow) et positionne tous les signaux au rouge. Voici par exemple des configurations :

Pour des signaux à deux feux :

traffic light0
green led on pin : 3 , DCC address : 90/0
red led on pin : 4 , DCC address : 90/1
traffic light1
green led on pin : 5 , DCC address : 91/0
red led on pin : 6 , DCC address : 91/1
traffic light2
green led on pin : 7 , DCC address : 92/0
red led on pin : 8 , DCC address : 92/1
traffic light3
green led on pin : 9 , DCC address : 93/0
red led on pin : 10 , DCC address : 93/1
traffic light4
green led on pin : 11 , DCC address : 94/0
red led on pin : 12 , DCC address : 94/1
traffic light5
green led on pin : 13 , DCC address : 95/0
red led on pin : 14 , DCC address : 95/1
traffic light6
green led on pin : 15 , DCC address : 96/0
red led on pin : 16 , DCC address : 96/1
traffic light7
green led on pin : 17 , DCC address : 97/0
red led on pin : 18 , DCC address : 97/1

Et des signaux pour trois feux :

traffic light0
green led on pin : 3 , DCC address : 90/0
red led on pin : 4 , DCC address : 90/1
yellow led on pin : 5 , DCC address : 91/0
traffic light1
green led on pin : 6 , DCC address : 92/0
red led on pin : 7 , DCC address : 92/1
yellow led on pin : 8 , DCC address : 93/0
traffic light2
green led on pin : 9 , DCC address : 94/0
red led on pin : 10 , DCC address : 94/1
yellow led on pin : 11 , DCC address : 95/0
traffic light3
green led on pin : 12 , DCC address : 96/0
red led on pin : 13 , DCC address : 96/1
yellow led on pin : 14 , DCC address : 97/0
traffic light4
green led on pin : 15 , DCC address : 98/0
red led on pin : 16 , DCC address : 98/1
yellow led on pin : 17 , DCC address : 99/0

L’algorithme consiste à tester le DCC (méthode BasicDecoderPacket_Handler).
Ce dernier décode l’adresse reçue, vérifie s’il y a un changement depuis la dernière fois (cela évite les commandes multiples). S’il y a changement en fonction du type de signal (BICOLOR ou TRICOLOR) on calcule l’index du signal concerné en fonction de l’adresse reçue et la led concernée. Dans le cas TRICOLOR il y a deux adresses par signal, si l’adresse est impaire c’est le signal jaune qui est concerné. Le DCC met à jour les paramètres du signal et prévient d’un changement.
Si un changement a eu lieu on le propage au bon signal (méthode activation_traffic_light). Cette méthode recherche les signaux en attente de traitement (activation_request) et exécute les commutations des leds du signal en fonction de la demande (current_position).

Le programme Arduino

/*
 * Decoder for traffic light with three or two leds on ARDUINO NANO
 * 
 * by default the red leds are switched on
 * pin 2 receives DCC interrupts
 * 
 * TRAFFIC LIGHT WITH THREE leds (GREEN, RED, YELLOW)
 * 5 decoders of traffic lights with three leds on Arduino NANO/UNO
 * the leds are controlled by pins 3 to A3 by triplet
 * traffic light 1 : 3,4,5
 * traffic light 2 : 6,7,8
 * traffic light 3 : 9,10,11
 * traffic light 4 : 12,13,A0
 * traffic light 5 : A1,A2,A3
 * two addresses by traffic light
 * even addresses for green and red lights
 * odd addresses for yellow light
 * 
 * TRAFFIC LIGHT WITH TWO leds (GREEN, RED)
 * 8 decoders of traffic lights with two leds on Arduino NANO/UNO
 * the leds are controlled by pins 3 to A4 by pair
 * traffic light 1 : 3,4
 * traffic light 2 : 5,6
 * traffic light 3 : 7,8
 * traffic light 4 : 9,10
 * traffic light 5 : 11,12
 * traffic light 6 : 13,A0
 * traffic light 7 : A1,A2
 * traffic light 8 : A3,A4
 * one address by traffic light
 * 
 * CONFIGURATION
 * MODE : determined by the common of the led, LOW if common = HIGH, HIGH if common = LOW
 * FIRST_ID_DCC : DCC address of the first traffic light
 * NB_TRAFFIC_LIGHT : determined by the kind of traffic light, BICOLOR for two leds, TRICOLOR for three leds
 * 
 */

/***************************************************************************************           
 *            CONFIGURATION SETTING
 *            
 ****************************************************************************************/
 
#define CONSOLE                             // output console, delete this after checking the configuration
#define MODE   LOW                          // LOW or HIGH
#define FIRST_ID_DCC   90                   // first DCC address, DCC_CODE
#define NB_TRAFFIC_LIGHT  TRICOLOR           //  TRICOLOR or BICOLOR 

/**********************************************************************************  
 *   DON'T CHANGE THE FOLLOWING
 *********************************************************************************/
 
/******************************************************************************
 *    INTERNAL PARAMETERS
 *    
 ********************************************************************************/
 
//  DCC

#include <DCC_Decoder.h>                 // Minabay library
#define kDCC_INTERRUPT    0             // pin 2 receives DCC interrupts
int previous_address = 0;               // avoids multiple DCC addresses
int previous_position = 2;              // avoids multiple DCC orders
volatile boolean update_light;          // set if an update should be processed after DCC control

// traffic light

#define BICOLOR  8                     // 8 traffic lights with two leds
#define TRICOLOR 5                     // 5 traffic lights with three leds
#define FIRST_PIN         3             // pin of the first traffic light
#define GREEN             0             // address DCC/0
#define RED               1             // address DCC/1 
#define YELLOW            2             // address DCC+1/0

// traffic light definition

struct light {
  int address;                    // its DCC address
  int current_position;           // green / red / yellow
  int green;                      // pin of the green led
  int red;                        // pin of the red led
  int yellow;                     // pin of the yellow led
  boolean activation_request;     // request of activation
};
light traffic_light[NB_TRAFFIC_LIGHT];    // the set of traffic light

/********************************************************************
 * method called if a request is made by the DCC
 * 
 *******************************************************************/
 
void activation_traffic_light() {
  for (int i = 0; i < NB_TRAFFIC_LIGHT; i++)                 // for all traffic lights
  {
    if (traffic_light[i].activation_request == true)  // if the traffic_light is waiting for activation
    {
      switch(traffic_light[i].current_position)            // we look the current position
      { 
        case GREEN :{                                                     // if green led
                      digitalWrite(traffic_light[i].green,MODE);         // switch on green
                      digitalWrite(traffic_light[i].red,!MODE);          // switch off red
                      if ( NB_TRAFFIC_LIGHT == TRICOLOR){digitalWrite(traffic_light[i].yellow,!MODE);} // switch off yellow
                      #ifdef CONSOLE
                        Serial.print("activation -> traffic light");Serial.print(i);Serial.println(" : green led");
                      #endif
                      break;}
        case RED : {                                                  // if red led
                      digitalWrite(traffic_light[i].green,!MODE);      // switch off green
                      digitalWrite(traffic_light[i].red,MODE);         // switch on red
                      if ( NB_TRAFFIC_LIGHT == TRICOLOR){digitalWrite(traffic_light[i].yellow,!MODE);} // switch off yellow
                      #ifdef CONSOLE
                        Serial.print("activation -> traffic light");Serial.print(i);Serial.println(" : red led");
                      #endif
                     break;}
         case YELLOW : {                                                  // if yellow led
                      digitalWrite(traffic_light[i].green,!MODE);         // switch off green 
                      digitalWrite(traffic_light[i].red,!MODE);           // switch off red
                      digitalWrite(traffic_light[i].yellow,MODE);         // switch on yellow
                      #ifdef CONSOLE
                        Serial.print("activation -> traffic light");Serial.print(i);Serial.println(" : yellow led");
                      #endif
                     break;}
         }
           }
       traffic_light[i].activation_request = false;            // the traffic light is updated
      }
  update_light = false;                                        // all updates are made
}

/************************************************************************************* 
 *  DCC method
 *  
 ***********************************************************************************/

void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
{  
  
  address -= 1; address *= 4; address += 1; address += (data & 0x06) >> 1;    // DCC address decoding
  int led = (data & 0x01) ? GREEN : RED;                                      // DCC/0 or DCC/1
  int traffic_light_index = address;                                          // index of a traffic light   
  int color = led;                                                            // the color of the led
  boolean activation = false;
  if ((address != previous_address) || ((led != previous_position)&&(address == previous_address))){ // if we change the address or the led
        switch (NB_TRAFFIC_LIGHT) {
          case BICOLOR : {      // if the address is in our range for traffic light with two leds
                    if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + NB_TRAFFIC_LIGHT)){ 
                      traffic_light_index = address - FIRST_ID_DCC;                                  // index of the traffic light
                      activation = true;}
                        break;}
          case TRICOLOR : {     // if the address is in our range for traffic light with three leds
                    if ((address >= FIRST_ID_DCC) && (address < FIRST_ID_DCC + (2*NB_TRAFFIC_LIGHT))){ 
                      if (address%2 != 0) {  traffic_light_index = address - 1; color = YELLOW;}         // if odd address => yellow led
                        traffic_light_index = (traffic_light_index - FIRST_ID_DCC)/2;                    // index of the traffic light
                        activation = true;}
                        break;}
        }
     traffic_light[traffic_light_index].activation_request =  activation;    // activation is requested
     traffic_light[traffic_light_index].current_position = color;            // state is requested (color of the led)
     update_light = activation;                                              // traffic light update is requested
    }
   previous_address = address; previous_position = led;                    // the current activation is saved
  }
/**********************************************************************************************
 *  setup
 * 
 ******************************************************************************************/

void setup() {
  int pin_jump = 0;                                                     // a jump for traffic light pins
  int traffic_light_jump = 0;                                           // a jump for traffic light number
  for (int i=0; i<NB_TRAFFIC_LIGHT; i++){                               // for all the traffic lights
    traffic_light[i].activation_request = false;                        // no activation request
    traffic_light[i].green = pin_jump + FIRST_PIN;                      // pin number of the green led
    pinMode(traffic_light[i].green, OUTPUT);                            // green led in output(ID DCC/0)                                                                                                                                                                                                                                                                   
    digitalWrite(traffic_light[i].green, !MODE);                       // green led switch off
    traffic_light[i].red = 1+ pin_jump + FIRST_PIN;                    // pin number of the red led
    pinMode(traffic_light[i].red, OUTPUT);                             // red led in output  (ID DCC/1)
    digitalWrite(traffic_light[i].red, MODE);                          // red led switch on
    if (NB_TRAFFIC_LIGHT == TRICOLOR) {                                // if three leds
      traffic_light[i].address = traffic_light_jump + FIRST_ID_DCC + i;   // its DCC ID
      traffic_light[i].yellow = 2+ pin_jump + FIRST_PIN;               // pin number of the yellow led
      pinMode(traffic_light[i].yellow, OUTPUT);                        // yellow led in output  (ID DCC+1/0)
      digitalWrite(traffic_light[i].yellow, !MODE);                    // yellow led switch off
      traffic_light_jump++;                                             // the following traffic light 
      pin_jump+=3;                                                     // the following pin for three leds
          }
    else {                                                             // if two leds
         traffic_light[i].address = FIRST_ID_DCC + i;                  // its DCC ID
        pin_jump+=2;                                                   // the following pin for two leds
        }
 
  }
  
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);   // instanciate the DCC
  DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT );                                   // its IT
  update_light = false;                                                             // no update
  
  #ifdef CONSOLE
   Serial.begin(115200);
   for (int i=0; i<NB_TRAFFIC_LIGHT; i++){
    Serial.print("traffic light");Serial.println(i);
    Serial.print("\t green led on pin : ");Serial.print(traffic_light[i].green);Serial.print(" , DCC address : ");Serial.print(traffic_light[i].address);Serial.println("/0"); 
    Serial.print("\t red led on pin : ");Serial.print(traffic_light[i].red);Serial.print(" , DCC address : ");Serial.print(traffic_light[i].address);Serial.println("/1");
    if (NB_TRAFFIC_LIGHT == TRICOLOR) {
      Serial.print("\t yellow led on pin : ");Serial.print(traffic_light[i].yellow);Serial.print(" , DCC address : ");Serial.print(traffic_light[i].address+1);Serial.println("/0");
      }
   }
  #endif
}

/*************************************************************************
 * loop
 * 
 ******************************************************************/
 
void loop() {
  DCC.loop();                                              // Is there a DCC command ?
  if (update_light) {activation_traffic_light();}          // if yes, activation of traffic lights
}

Le programme à télécharger ici :

Decoder traffic light

Ce petit décodeur de signaux est facile à réaliser pour un coût très modique. Il marche très bien sur mon réseau avec mon ECOS et TrainController. Pour ceux qui possède une Cameo silhouette on peut même réaliser ses propres feux et potence dont voici une première ébauche.

Potence en papier

et son utilisation avec une ECOS :

signalisation ECOS
signalisation portique

la bibliothèque minabay pour le DCC

minabay dcc decoder

106 Messages

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO 5 mai 2016 21:21, par Michel PERRINOT

    Bonjour,

    Bientôt à la retraite, je reprends contact avec le modélisme ferroviaire surtout avec le digital.

    J’ai exploré cette facette avec un petit module d’essais. (Multi Mauss, Digitalisation d’ancienne motrice, Commande d’aiguillage le tout piloté aussi par Train Controller)

    Il y a quelques années, j’ai touché un peu au micro-Controller (petit automate avec DELPHI) Le plaisir de faire soit même des montages est toujours attrayant.

    J’ai découvert votre site et vu qu’avec l’ARDUINO NANO ont pouvait réaliser quelques montages en particulier pour les signaux.

    Est-ce possible de vous achetez un module en état de marche (CI et Arduino programmé) afin de découvrir l’Arduino et ces possibilités.

    Merci par avance de votre réponse.

    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 5 mai 2016 22:56, par Dominique

    Bonjour Michel,

    J’espère ne pas vous décevoir, car ce site, Locoduino, n’est pas un site commercial, mais seulement un site d’entre-aide pour que chacun puisse faire soi-même les modules dont il a besoin.

    Il arrive que l’un d’entre nous fasse un circuit imprimé et organise quelques achats groupés qu’il partage avec d’autres membres, mais ce n’est pas un kit à vendre.

    Mais vous semblez prêt à découvrir l’Arduino et c’est l’essentiel. Un Arduino ne se vend pas "programmé" contrairement à d’autres microcontrolleurs. Il est même extrêmement facile à programmer.

    Je vous encourage donc à en acheter un (un Nano ou un Uno pour commencer) en consultant la rubrique Atelier, installer l’iDE et programmer par vous-même les exemples donnés dans ce site qui sont téléchargeables.

    Je suis convaincu que c’est ce que vous vouliez.

    Amicalement

    Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 29 mai 2016 17:02, par Michel PERRINOT

      Bonjour Dominique,

      Désolé, pour mon retour de mail tardif (problème de réseaux)
      Merci pour votre réponse et votre aide sur le site, j’ai commandé le matériel pour me lancer dans la réalisation du montage ci-dessus. J’aurais certainement des questions dans le futur à vous poser sur l’Arduino.

      Bonne journée.

      Cordialement.

      Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 17 mai 2016 00:21, par thomas

    Bonjour

    debutant dans l’arduino vous serais t il possible de mettre la liste des composants de ce montage par avance merci

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 juin 2016 18:53, par Michel PERRINOT

    Bonjour,

    Débutant dans l’univers de l’Arduino et suite à mon mail du 5 Mai, ci-dessus, j’ai acheté une carte Arduino UNO et chargé quelques petits programmes de test, clignotement de led ect.. pour une prise de contact avec la carte et IDE, impeccable.
    J’ai voulu chargé votre programme, ci-dessus, et j’ai un message d’erreur ci-dessous :

    C :\Documents and Settings\Administrateur\Mes documents\Arduino\decoder_traffic_light\decoder_traffic_light.ino:60:64 : fatal error : DCC_Decoder.h : No such file or directory

    #include <DCC_Decoder.h> // Minabay library

    J’ai essayé de trouvé cette bibliothèque en vain. Pouvez-vous me la faire suivre et me dire ou je dois mettre ce fichier pour que le programme trouve cette bibliothèque.

    Il y a t’il d’autres manip à faire pour que le programme fonctionne ?

    Merci par avance de votre réponse.

    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 juin 2016 20:57, par JPClaude

    Bonsoir,
    j’ai rajouté en fin d’article la bibliothèque en question, c’est la seule.
    Il faut la placer dans le répertoire "libraries" de l’Arduino.
    Cordialement.

    Répondre

  • precision 8 juillet 2016 02:24, par Dominique

    bonjour,

    vous serait-il possible d’ajouter un schéma du circuit SVP, car je ne comprend pas le schéma entre la photo de la carte et le typon ??
    circuit très intéressant a tester pour moi car il cumule un test avec un Nano et le DCC ;o)
    donc je testerais sur plaque d’essai, d’ou cette demande de schéma !

    cordialement

    Dominique

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 18 novembre 2016 21:53, par Patrick

    Salut,

    Dans la fonction : BasicAccDecoderPacket_Handler()

    Dans le test : if ((address != previous_address) | ((led != previous_position)&(address == previous_address)))

    il y a possibilité de bug... Il faut utiliser les operateurs || et &&. Mais comme vous l’avez fait ailleurs dans le code, je pense que c’est juste un oubli...

    Patrick

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 décembre 2016 16:13, par Henkens henri

    Bonjour,
    J’ai construit votre décodeur qui fonctionne parfaitement lorsque j’utilise les commandes de la centrale par contre j’utilise le logiciel CDMrail pour commander le réseau et il m’oblige a avoir la première adresse impaire pour fonctionner.
    Pourriez vous me dire quelle lignes de programme je devrait changer pour que cela fonctionne.
    La 1ere adresse devrait être 89 au lieu de 90 par exemple.
    J’ai essaye de mettre 89 en première adresse, mais cela ne fonctionne plus correctement.
    Cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 9 décembre 2016 09:46, par JPClaude

    Bonjour,
    Voici les modifications à entreprendre :

    Lignes à changer

    16 * odd addresses for green and red lights
    17 * even addresses for yellow light

    46 #define FIRST_ID_DCC 89 // first DCC address, DCC_CODE

    152 if (address%2 == 0) traffic_light_index = address - 1 ; color = YELLOW ; // if even address => yellow led

    résultat

    traffic light0
    green led on pin : 3 , DCC address : 89/0
    red led on pin : 4 , DCC address : 89/1
    yellow led on pin : 5 , DCC address : 90/0
    traffic light1
    green led on pin : 6 , DCC address : 91/0
    red led on pin : 7 , DCC address : 91/1
    yellow led on pin : 8 , DCC address : 92/0
    traffic light2
    green led on pin : 9 , DCC address : 93/0
    red led on pin : 10 , DCC address : 93/1
    yellow led on pin : 11 , DCC address : 94/0
    traffic light3
    green led on pin : 12 , DCC address : 95/0
    red led on pin : 13 , DCC address : 95/1
    yellow led on pin : 14 , DCC address : 96/0
    traffic light4
    green led on pin : 15 , DCC address : 97/0
    red led on pin : 16 , DCC address : 97/1
    yellow led on pin : 17 , DCC address : 98/0

    En espérant avoir répondu à votre question.
    Cordialement.
    JP

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 9 décembre 2016 14:20, par Henkens henri

    Bonjour,
    Un grand merci pour votre réponse.
    J’ai fait les modifications et cela fonctionne parfaitement.
    Cordialement
    HH

    Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 17 novembre 2019 14:15, par Francois

      Bonjour,

      Modification pour CDMRAIL.

      Pouvez-vous m’envoyer le code, car moi je ne sais pas pourquoi, je n’y arrive pas, j’ai beau modifier les lignes comme indiqué, rien a faire ça ne fonctionne pas.
      Un grand merci

      Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 novembre 2019 18:05, par Francois

      Bonjour,

      Vous dite que cela fonctionne très bien avec CDM Rail, quelle version utilisez Vous ?

      Pour ma part quand j’utilise la commande Lenz LH100 avec l’adresse 89 et 90 tout va bien le rouge le vert et le jaune.

      Par contre quand j’essaye de piloter avec CDM Rail rien ne se passe !!!

      J’ai essayer tous les decodeurs possible dans le logiciel, cela ne fonctionne pas.

      Je n’ai rien trouvé sur le forum de CDM Rail.

      Merci pour votre aide

      Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 20 février 2017 18:49, par ETHUIN Daniel

    Bonjour

    une belle réalisation que vous nous avez proposé. Aussi je me suis empressé de la réaliser sur une plaque d’essai.
    Branchée sur mon réseau HO avec le logiciel Itrain, les 5 signaux fonctionnent à la perfection.

    Un grand merci. Cordialement.
    Daniel

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 20 février 2017 21:42, par JPClaude

    Bonsoir,
    très heureux et merci de votre retour.
    Bon amusement.
    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 11 avril 2017 12:17, par Philippe DEVREKER

    Bonjour à tous

    Je viens de tester avec succès le programme en pilotant avec une console lenz. Je passe en simulation avec le logiciel CDM Rail qui m’oblige à changer l’adresse de départ en nombre impair, j’ai donc modifier de 90 à 91 et là je n’ai plus que les diodes rouges et vertes mais pas les jaunes.

    Quelqu’un aurait-il eu ce problème ? Merci d’avance.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 11 avril 2017 12:32, par JPClaude

    Bonjour,
    le problème a déjà été posé, voir ci dessus les modifications à faire aux lignes 16, 17, 46 et 152.
    Cela provient que dans le programme on teste la parité des adresses.
    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 25 avril 2017 10:32, par Michel PERRINOT

    Bonjour à tous,
    J’ai réalisé le montage, proposé, qui fonctionne très bien mais j’ai un problème de paramétrage avec TrainContoller.
    Avec un signal 3 feux, j’ai la verte, puis la rouge et à l’allumage de la jaune, la rouge reste allumée.
    Pouvez-vous me faire une copie d’écran du réglage trois feux que vous avez mis dans TrainController. SVP
    Est-il possible de rajouter un bouton poussoir qui permettrait de passer en mode programmation d’adresse et qui après une action dans TrainController mémoriserait l’adresse dans le programme ?
    Merci par avance de votre réponse.
    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 26 avril 2017 13:27, par Michel PERRINOT

    Bonjour,
    J’ai résolu mon problème de led rouge qui restait allumée pendant le feux jaune (mauvais câblage des leds avec la fonction HIGH et LOW).
    Est-il possible de rajouter un bouton qui permettrait de passer en mode programmation d’adresse et qui après une action dans TrainController mémoriserait l’adresse dans le programme ?
    Avez-vous quelques lignes de code sur ce sujet.SVP
    Merci par avance de votre réponse.
    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 27 avril 2017 17:10, par JPClaude

    Bonjour,
    On peut effectivement passer en mode programmation mais n’ayant pas un réseau suffisamment grand et n’ayant pas 512 accessoires, j’ai pris le principe d’avoir des banques d’adresses fixes, par exemple 1 à 100 pour les signaux, 101 à 200 pour les aiguillages etc… ce qui simplifie grandement le programme Arduino. Par exemple pour les signaux à 3 feux chaque décodeur représente 10 adresses pour 5 signaux, si je réserve une banque d’adresses (1 à 50 par exemple) je peux avoir 25 signaux et si je change un signal de décodeur je modifie son adresse au sein de RRTC ce qui se fait très simplement (à noter que je ne change pas la position de mes signaux toutes les trente secondes !!!seulement en cas de modification du réseau et alors changer son adresse depuis RRTC reste la meilleure solution.)
    En espérant (ne pas) avoir répondu à votre question.
    Bien cordialement.
    JP

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 28 avril 2017 01:11, par Michel PERRINOT

    Bonsoir,

    Merci pour votre réponse, c’est effectivement une bonne solution que je pratique. C’était pour moi un exercice pour m’initier à la programmation d’Arduino.

    Bonne soirée.

    Cordialement.

    Répondre

  • Trop de données DCC à récupérer 1er décembre 2017 21:31, par Loco28

    Bonsoir,
    J’utilise une bibliothèque (DCC_COMMANDER) pour récupérer des données sous CDM-RAIL.
    Tout se passe bien pour les aiguillages, par contre pour les feux, quand trop d’ordres passent en même temps, je loupe des commandes alors que je suis en train de traiter les précédentes. On me dit qu’il faudrait que je passe par un système d’interruption pour empiler les données dans une pile, mais j’ignore vraiment comment faire.
    Où pourrais-je trouver quelques informations sur la manière de faire ?

    Répondre

    • Trop de données DCC à récupérer 2 décembre 2017 10:16, par Jean-Luc

      Bonjour.
      une trame DCC c’est 45 bits environ, soit au plus court 5,22ms pour un trame. cest très long et l’Arduino a le temps de faire beaucoup de choses entre l’arrivée de deux couples adresse/valeur. Appelez vous des fonctions bloquantes comme delay ?

      Répondre

      • Trop de données DCC à récupérer 2 décembre 2017 13:53, par Loco28

        Non, j’ai évité les fonctions type "delay".
        Le traitement d’une donnée comprend, en général, :
        * un test de valeur pour voir si l’adresse est dans la bonne plage
        * si oui, un teste de l’action à faire (0 ou 1)
        * le remplissage d’un tableau (1 ou 2 valeurs parmi 8)
        * l’envoi de ce tableau vers un registre à décalage

        Bref, rien de très long mais trop cependant.
        j’ai fait un test de lecture sans aucun traitement après et je vois bien toutes les données.
        C’est donc bien la durée du traitement qui fait que je loupe des données.
        Il faudrait que je puisse stocker les données dans une file FIFO que je traite après.
        Mais sous ARDUINO, je ne vois pas comment faire.

        Répondre

        • Trop de données DCC à récupérer 2 décembre 2017 20:49, par Dominique

          Un exemple de "FIFO" est donné dans l’article 148.

          C’est un buffer circulant que vous pouvez appliquer à votre problème.

          Voir en ligne : http://www.locoduino.org/spip.php++cs_INTERRO++a...

          Répondre

          • Trop de données DCC à récupérer 4 décembre 2017 20:13, par Loco28

            Bonsoir,

            Avec l’aide de beaucoup d’entre vous, je pense avoir résolu mon problème en stockant les données brutes DCC dans 2 fichiers, lors de la routine d’interruption.
            Le traitement des données se fera ensuite dans la "loop", à l’emplacement des instructions Serial.print.
            Seul inquiétude : je stock dans 2 fichiers différents (storadresse et storaction) qui, théoriquement sont remplis et vidés en même temps mais je préfèrerais des opérations plus synchrones.
            Est-il possible de faire un tableau à "2 cases" ?

            Ci-dessous mon code :

            #include <DCC_Decoder.h>
            #define kDCC_INTERRUPT 0 // pin 2 for UNO
            #include <CircularBuffer.h>

            CircularBuffer storadresse ;
            CircularBuffer storaction ;

            int add = 0 ;
            int act = 0 ;
            int old_add = 0 ;
            int old_act = 0 ;
            int action = 0 ;

            //Handler DCC
            void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data)
            //Serial.print(address) ;
            //Serial.print(" ") ;
            //Serial.println(data) ;
            storadresse.push (address) ;
            storaction.push (data) ;

            void setup()
            DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true) ;
            DCC.SetupDecoder( 0x00, 0x00, kDCC_INTERRUPT ) ;
            Serial.begin (115200) ;
            Serial.println("Debut test") ;

            void loop()
            DCC.loop() ;

            while(!storadresse.isEmpty())
            add = storadresse.shift() ;
            act = storaction.shift() ;

            if ((add != old_add) || (act != old_act))
            old_add = add ;
            old_act = act ;
            // Conversion de l’adresse NMRA en adresse decodeur d’accessoire
            add -= 1 ;
            add *= 4 ;
            add += 1 ;
            add += (act & 0x06) >> 1 ;
            action =(act & 0x01) ;
            Serial.print(add) ;
            Serial.print(" ") ;
            Serial.println(action) ;

            //fin nouvelle donnée
            //fin while
            //fin loop

            Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 6 décembre 2017 16:31, par Loco28

    Bonjour,

    Tout allait bien jusqu’au dernier Serial.println(action).
    J’ai réalisé ensuite le traitement des données (un test 0 ou 1 sur action et un petit calcul à partir de add pour envoyer une valeur).
    Problème, j’utilise la fonction SHIFTOUT pour envoyer cette valeur vers un registre à décalage et là, rien ne se passe. j’ai vérifié, je passe bien par cette fonction, les valeurs CLOCK, LATCH, DATA n’ont pas changé et pourtant les sorties du registre ne bougent pas (alors qu’avant, avec le même traitement des données fonctionnait parfaitement).
    La seule constatation que je fait, c’est que CIRCULARBUFFER utilise une fonction .shift. N’y a t il pas ambiguité avec SHIFTOUT ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 25 décembre 2017 18:53, par Loco28

    Bonjour,

    J’utilise la fonction DCC.loop() mais sans savoir ce qu’elle fait et j’aime pas.

    * d’où vient cette fonction (DCC Decoder ?),
    * a quoi sert-elle ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 26 décembre 2017 11:20, par JPClaude

    Le programme utilise la bibliothèque minabay de nom DCC_decoder.
    Cette bibliothèque, en particulier, récupère les commandes DCC.
    Il faut donc périodiquement l’interroger pour savoir si une nouvelle commande DCC est arrivée.
    expliqué dans DCC_decoder.h :
    // Call at least once from mainloop. Not calling frequently enough and library will miss data bits !
    void loop() ;
    cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 24 mars 2018 17:37, par jp

    Super article,
    je me bat avec l’arduino pour faire une version 4 feux de 3 leds en version pwm , pour avoir un effet ++ : l’allumage et extinction lentes (réglables) des leds façon ampoule a incandescence ...

    programme modifié :
    for (int fadeValue = 255 ; fadeValue >= 0 ; fadeValue -= 5)
    analogWrite(pins[i][0], fadeValue)

    cela fonctionne mais allume les led allumées (donc éteint puis allume), et éteint les led déja éteintes .. (donc allume puis éteint).

    il faut mémoriser toutes les valeurs des sorties pour les comparer au commandes ?
    une autre idée ?
    vous avez un bout de code ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 27 mars 2018 18:11, par jp

    je viens de lire l’article, très intéressant en effet .. reste plus qu’a expérimenter !

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 28 mars 2018 09:32, par JPClaude

    Bonjour,
    je ne sais pas si cela répond à la question car je n’ai pas essayé cette librairie mais visiblement elle permet le fading sans blocage du programme, bibliothèque LEDFader sur https://github.com/jgillick/arduino....
    Cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 28 mars 2018 13:09, par Jean-Luc

    Bonjour JP,

    Entretemps je suis parti sur quelque chose de similaire dans l’idée mais plus adapté à nos applications : gestion du « fading » mais également du clignotement et passage du clignotement à un état on/off sans discontinuité. Ça devrait être assez rapide à faire.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 28 mars 2018 20:06, par jp

    chouette une library !
    par contre je n’arrive a passer les variables d’adresse des pins :
    LightDimmer led1([i],HIGH) ... ou LightDimmer led1(i,HIGH)..
    je fait une erreur ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 avril 2018 22:29, par Guy

    Bonsoir,
    Très belle conception cependant je souhaite utilisé un système ROCO multimaus qui fonctionne avec le logiciel RocRail sans aucun souci. J’ai réalisé mon premier module avec un arduino nano cependant il semble qu’il y ait un problème de communication entre lui et RocRail. Y a t’il des réglages particuliers pour les signaux, comme pour les adresses, (à partir de l’adresse 90, les paramètres du logiciel etc...
    Merci par avance de l’aide que vous pourrez m’apporter.
    Bonne soirée

    Répondre

  • Besoin de feux tricolore carrefour avec pieton 13 septembre 2018 17:26, par Perminet Afi

    Bonjour,
    j’ai vu une de vos publication Feux tricolores miniatures [ Maquette faite maison ] - avec microcontrôleur. Comment faire pour obtenir ce projet.
    Vraiment besoin.
    Cordialement Perminent

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 14 novembre 2019 18:13, par Francois Constant

    Bonjour,
    Comment changer l’adresse du décodeur

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 16 novembre 2019 14:51, par Francois

    Bonjour,

    Avec le programme original tout est Ok.
    Fonctionnement parfait.

    Si je change le codage des lignes 16, 17, 46 et 152, comme vous le mentionnez, pour fonctionner avec CDMRAIL, première adresse impair ça ne fonctionne pas.

    J’ai fait copier coller les instructions pour etre sur de ne pas faire d’erreur.

    Pouvez vous m’aider

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 16 novembre 2019 15:08, par Francois

    Bonjour,
    Est il possible d’ajouter une fonction de Fadding entre l’extinction et l’allumage des feux

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 16 novembre 2019 17:24, par Francois

    Bonjour,

    Rien a faire, j’ai recommencer la modification des lignes 16, 17, 46 et 152, rien n’y fait.

    A la mise sous tension la led rouge est allumée, je programme l’adresse 89/0 et c’est la led orange qui s’allume et puis tout est bloqué.

    Help Help...

    Cordialement

    Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 23 janvier 2020 22:23, par msport

      Je viens de me lancer la réalisation de ce sympathique montage et je vois qu’il y a une ligne à mettre en commentaire pour rendre le sketch opérationnel :
      // #define CONSOLE // output console, delete this after checking the configuration
      Mais j’ai un autre souci, si le feu orange passe bien en fixe, le vert est fugitif, il repasse au rouge mais c’est peut-être mon mode d’envoi de mes ordres initialement prévu pour les solénoïdes. Il faut que je vérifie.

      Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 1er février 2020 15:46, par msport

      Après quelques petites balades dans le programme, retour à la ligne 152 où il apparait qu’il manque les accolades dans la ligne proposée (cf la ligne originale)
      donc :

      if (address%2 == 0) traffic_light_index = address - 1 ; color = YELLOW ;

      Vous ne voyez pas les accolades que j’ai mises ? Ne vous précipitez pas chez l’ophtalmo, c’est un mauvais coup de l’éditeur de texte qui les a pris pour l’option caractères gras ! Comme dans le message d’origine.

      Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 19 décembre 2019 18:48, par reinsch

    Bonjour,,
    peut on brancher 2 ou 3 arduino derriere l’opto ( broche 6) ou faut il un montage opto pour chaque arduino

    cordialement guy

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 20 décembre 2019 12:16, par msport

    Sur le principe pas de problème, à tester.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 6 février 2020 09:35, par Constant

    Bonjour quelqu’un a t’il réalisé le montage pour l’utiliser avec CDM RAIL, est ce que cela fonctionne avec les adresse impaires, moi je n’y arrive pas .
    est ce que je pourrais recevoir le code complet modifier.
    Merci d’avance
    Bien a vous

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 février 2020 13:47, par Constant

    Bonjour a tous .
    Enfin la libération , après avoir corrigé le code et ajouter les accolades, le système fonctionne bien avec CDMRAIL, attention dans la programmation du signal il faut indiquer le type de décodeur : LDT LS DEC autrement ça ne fonctionne pas.
    Je remercie la communauté de l’aide apportée, et je vais maintenant essayé de résoudre le problème avec le décodeur 16 signaux.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 7 avril 2020 18:33, par Guy

    Bonjour,

    Je souhaiterai savoir comment je peux déclarer l’adressage du décodeur dans ROCRAIL ?

    Merci par avance de vos aides

    Cdt

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 7 avril 2020 21:36, par msport

    Bonjour,
    Rocrail est un logiciel propriétaire et c’est sur un forum qui lui est dédié que vous devriez poser votre question.
    Ce décodeur fonctionne à partir d’une adresse qui commence à :
    * FIRST_ID_DCC : DCC address of the first traffic light
    Cordialement

    Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 avril 2020 17:36, par Guy

      Bonsoir,

      Effectivement j’ai trouvé l’information sur le site de RocRail, en revanche les feux fonctionnent certes mais l’extinction d’une couleur se trouve en même temps que l’allumage d’une autre comme si il manquait une tempo ou que l’arduino nano exécutait trop rapidement les ordres de la centrale ; est-ce normal où y a t’il des réglages à faire ? Merci pour votre aide

      Cordialement

      Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 8 avril 2020 18:18, par msport

    Si je comprends votre problème, vous souhaiteriez un allumage/extinction progressif ? Il me semble que la question a été évoquée ailleurs dans le forum, à vous de l’adapter.
    Cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 15 novembre 2020 23:19, par FrancoisJ

    Bonjour a tous
    Super sujet !

    Ou puis je trouver le fichier ino final pour utiliser avec cdm rail ? Je n’ai pas reussi a faire une version qui marche.

    Merciiiii

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 16 novembre 2020 09:55, par msport

    Bonjour,

    je sais plus si il marche, mais c’est au moins une tentative.

    Cordialement

    Voir en ligne : Version pour CDM Rail

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 11 février 2021 14:16, par Delestre jean-Louis

    Bonjour,

    J’essaie d’utiliser ce superbe montage à partir d’une centrale DCC++ sur arduino et de JMRI, mais je n’y arrive pas. Qeulle est donc la commande à envoyer à ce décodeur à partir de JRMI ?

    Un grand merci.

    Cordialement.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 11 février 2021 14:56, par msport

    Pour tester l’adresse DCC 90, il faut envoyer <a 23 1 1> via la console.
    pour l’adresse DCC 91, il faut envoyer <a 23 2 1>

    Mettre les rails sous tension avec <1>

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 26 mai 2021 17:27, par François

    Bonjour, j’ai réalisé la carte complète je n’ai plus qu’à téléchargé le programme dans l’arduino nano pour faire les tests j’ai cependant une question à quoi sert le strap entre les résistance de 10K et le bornier de 6 fiches ? comment doit il être monté dans le cadre de feux bicolores ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 27 mai 2021 09:06, par François

    Bonjour Jean Pierre,
    je dois être un peu stupide et je ne comprends toujours pas. Je donne afin d’imager un peu un exemple : j’ai une potence équipé de trois feux équipés chacun de deux leds une rouge et une verte chaque led a sa propre résistance et il y a un fils commun qui est le grd qui relie le moins de chaque résistance. comment dois-je relier la strap ?

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 27 mai 2021 09:14, par jean-pierre

    Le fil commun des leds sur le bornier "common led".
    le strap sur GND.
    le fil de chaque led sur une entrée Gx pour le vert et Rx pour le rouge.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 30 juin 2021 19:08, par Emile-Viktor

    Bonjour !
    J’ai testé ce montage avec une Arduino UNO et quelque composant que j’avais sur place, malheureusement, ça n’a pas marché, la seule différence entre mon montage et celui indiqué ci-dessus est la référence de l’optocoupleur, qui est un 4N35 (le seul que j’avais chez moi) et je pense que cela vient de cet optocoupleur.
    Donc pensez vous que le 4N35 sera-t-il adapté pour ce genre de montage ? Sur sa datasheet, il est indiqué qu’il a un temps de réponse de 3µs, ceux qui est assez pour le signal DCC...
    J’avoue que j’ai quelque base en électronique grâce à mes études, mais pas assez pour des choses de ce type.
    Merci de votre réponse
    A bientôt

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 4 janvier 2022 22:45, par Mario

    Bonsoir,
    J’ai réalisé décodeur dcc pour des signaux tricolore avec le programme modifié pour une exploitation avec cdm rail (ligne 16, 17, 46 et 152 comme indiqué plus haut)
    Si vous voulez tester les signaux lors de la configuration il est nécessaire de cocher : "Autoriser le pilotage des signaux" dans options => RUN
    attention dans la programmation du signal il faut indiquer le type de décodeur : LDT LS DEC

    Merci pour le partage de ce décodeur
    MR

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 21 juin 2022 17:55, par Pierre

    Bonjour à tous,
    Je viens de réaliser la carte et quand je mets sous tension (sans signal DCC) ce sont tous les signaux Jaunes qui sont allumés alors que dans les explications de Jean Claude ce devrait être les rouges. J’ai peut être raté quelque chose ?
    Merci pour votre aide.
    Arduinotement vôtre

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 juin 2022 18:19, par msport

    Bonjour,
    faites décoder le DCC et dites nous ce qu’il en est.
    Les LED orange ont un numéro de pin pair comme les rouges en mode BICOLOR, la remarque vaut probablement pour le mode BICOLOR.
    Cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 juin 2022 21:11, par Pierre

    Bonjour à tous,
    Essai cette AM au club et surtout analyse de mon câblage par un collègue des plaques de test qui simulent les feux 3 leds.
    J’ai fait simplement une erreur sur ces plaques de test.
    Résultat avec une centrale DIGIKEYS et le logiciel traincontroler. Une fois que l’on a compris comment il fallait paramétrer un signal 3 feux cela fonctionne nickel.
    Pour ma part j’ai réalisé un circuit via une CNC en mettant le commun au +5V et cette version pour feux uniquement 5 x 3 leds, des connecteurs circuit imprimé au pas de 2.54 pour chaque feux. Pour un réseau fixe je pense que cela ne pose pas de PB.
    Je n’ai pas encore regardé sur le forum mais nous avons besoin de 24 feux 4 leds sur notre réseau. Y-a-t-il un PRG de fait pour cette configuration ?
    Encore bravo pour cette réalisation.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 juin 2022 21:37, par trimarco232

    Bonjour,
    il faudrait précise quel type(s) de signaux et quelles sont les différentes indications souhaitées

    Répondre

    • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 23 juin 2022 11:20, par Pierre

      Bonjour à tous,
      Voici donc le besoin d’un feux à 4 leds.
      De haut en bas : Rouge , Vert, Rouge, Jaune.
      Cela permet de faire le fonctionnement suivant :
      1- Le carré : les deux rouges
      2- Le sémaphore : le deuxième rouge (entre le Vert et Jaune),
      3- L’avertissement (ralentissement) : Le jaune,
      4- Le passage libre : le vert.
      Normalement il y a aussi l’œilleton mais nous avons pensé que nous le mettrons pas.
      Par rapport à la réalisation feux 3 leds il faudrait ajouter la commande "Le carré".
      Est-ce que je suis assez clair dans mes explications.
      Merci pour votre aide.
      Arduinotement vôtre
      Pierre

      Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 23 juin 2022 18:22, par trimarco232

    c’est très clair, merci
    avant toute chose, je dois préciser que je suis nouveau sur ce topic, j’invite donc tout le monde à intervenir pour donner des avis ;
    je pars du principe de modifier le moins possible le soft existant
    les feux visés sont, de haut en bas : carre, green, red, yellow
    les indications envisagées sont RED(red), GREEN(green), YELLOW(yellow), CARRE(carre + red)
    " Par rapport à la réalisation feux 3 leds il faudrait ajouter la commande "Le carré" "
    .
    la réalisation 3 feux utilise 2 adresses d’accessoires, par exemple 90/0/1 et 91/0 : nous utiliserons la possibilité libre 91/1 pour l’indication CARRE
    .
    on dispose de 16 broches : ça fait 4 signaux de 4 feux ; il faudrait donc 6 nanos pour commander les 24 signaux
    .
    .
    hors sujet, on peut envisager de :

    • laisser 2 adresses libres pour d’autres indications (carré violet, feux vert, jaune, ou rouge clignotants, préannonce ...)
    • il reste 2 broches libres sur le nano, ce qui permet d’envisager + de choses, comme la cde de 2 œilletons
    • introduire, à la fin, la bibliothèque de Jean-Luc pour l’allumage / extinction progressifs
      .
      je reviens pour la suite ...

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 24 juin 2022 01:21, par trimarco232

    j’ai mis le code dans le forum
    rubrique "shields et modules"
    "extension 4 feux pour décodeur de signaux à 2 ou 3 feux"

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 5 juillet 2022 22:42, par Bardiaux

    Bonjour

    Dans votre programme <un décodeur DCC pour les signaux à deux et trois feux sur Arduino/Uno,il y a 8 signaux à deux feux et 5 signaux à trois feux, le problème est que moi j’ai 15 signaux à trois feux donc j’ai 10 signaux à trois feux supplèmentaires, je fait comment pour les lignes de code qui manquent ?
    Merci de votre réponse.

    Cordialement

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 18 juillet 2022 19:06, par bardiaux

    Bonjour
    Programme pour les feux c’est ok. Je voudrais savoir comment installer 5 cartes arduino :
    1 carte Arduino Uno pour entréees et sorties de gare,
    1 carte Arduino Uno pour mes servomoteurs,
    1 carte Arduino Uno pour mes S88 pour mes détecteurs de présence,
    1 carte Arduino Méga 2560 pour ma grue Marklin 7051.
    Merci de votre réponse.
    Cordialemennnt

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 22 septembre 2022 23:01, par Phil95

    Bonjour à tous,

    Je suis parti du code source de ce projet pour en faire un décodeur pour 8 servo-moteurs et je n’arrive pas à le faire fonctionner, sachant que :

    • Les servos fonctionnent si je retire le code DCC
    • Le décodage DCC fonctionne si je remplace la commande de servo par un simple digitalWrite.

    J’en déduit que la bibliothèque DCC utilisée ici n’est pas compatible avec la biblio servo.

    Est-ce que quelqu’un à déjà réussi à faire fonctionner ces 2 bibliothèques ensemble ?

    Répondre

  • Un décodeur DCC pour les Servos sur Arduino NANO/UNO 23 septembre 2022 17:32, par msport

    Bonjour,

    vous pouvez regarder le projet finalisé Quad Servo DCC Decoder de JT Chamberlain.

    Mais également le programme de Rudy Boer
    https://rudysmodelrailway.wordpress...
    puis
    https://www.dropbox.com/s/qkhrc147m...

    Cordialement

    Voir en ligne : Quad Servo DCC Decoder

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 17 août 2023 14:53, par Martial

    Bonjour,

    J’utilise ce code avec satisfaction depuis quelques temps déjà.
    Je voudrais utiliser le même principe mais en utilisant un arduino mega 2560.
    J’ai un problème avec le #define kDCC_INTERRUPT.
    Comme la documentation varie selon où on cherche j’ai essayé les INTERRUPT 0 à 5 en utilisant les broches D2 D3 D18 D19 D20 et D21 mais rien n’y fait, la commande n’est jamais exécutée. Faut-il modifier autre chose ?
    Pour être sûr qu’il n’y a pas une autre erreur j’ai utilisé un arduino LEONARDO et là cela fonctionne.
    Merci d’avance pour votre aide.

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 1er octobre 2023 16:05, par Olivier

    Bonjour,

    En cherchant les composants sur internet pour réaliser la carte, je me rends compte que certains ne sont pas/plus en vente (apparement car je n’ai pas testé tous les fournisseurs), et dans certain cas, il y plusieurs possibilités. Pour ma recherche, je me suis basé sur la liste de composant reprise dans un des premiers messages de ce sujet.

    Comme je ne suis pas expert en électronique, l’un d’entre vous pourrait refaire une liste des composants à jour (et idéalement avec des liens). Ce serait TOP.

    Merci,

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 2 octobre 2023 11:32

    Bonjour,

    J’ai regardé sur https://www.distrelec.be/fr/

    Par exemple pour les condensateur 100 nF
    https://www.distrelec.be/fr/condens...

    Voici,

    Merci pour to aide

    NB : j’ai été voir le lien que tu as mis mais c’est pour commander des aiguillages

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 2 octobre 2023 14:58, par msport

    Bonjour,
    la question était la disponibilité des composants.
    A la fin de l’article cité, il y a les liens vers les composants habituels des décodeurs.
    Seul le programme change comme vous le verrez dans les articles 321 et 322 :

    Voir en ligne : Signalisation et sonorisation du va-et-vient pour deux trains

    Répondre

  • Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO 21 novembre 2023 23:52, par Laurent

    Bonjour,
    comment avoir tous les feux au départ au vert et non au rouge
    Merci

    Répondre

Réagissez à « Un décodeur DCC pour les signaux à deux ou trois feux sur Arduino NANO/UNO »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Projets »

Les derniers articles

Les articles les plus lus