Décoder les trames DCC (Tuto Arduino #01)

Dans ce tutoriel, nous verrons comment décoder les trames DCC émises par une centrale digitale et faire en sorte que la carte Arduino se comporte comme un décodeur d’accessoires. L’Arduino pourra ainsi réagir aux différents ordres émis par la centrale.

Ce tutoriel se base sur les travaux de mynaby qui a développé une librairie pour lire les signaux DCC avec Arduino : http://www.mynabay.com/dcc_monitor/

Ce montage électronique (tuto) est abordé en premier car il constitue la base de tout montage Arduino dès lors que l’on veut étendre sa commande (ex : faite par boutons poussoir reliés aux broches de l’Arduino) avec une commande faite depuis la centrale DCC. Et par extension une commande faite depuis le smartphone/tablette et/ou logiciel de pilotage de réseau (Train Controller, Rocrail, i-Train, etc…).

Pourquoi décoder les trames DCC avec une carte Arduino ?

Une carte Arduino coûte moins de 20€ et offre de nombreuses possibilités. Permettre de la connecter à la centrale permet d’étendre encore plus les possibilités et applications liées au monde du train miniature. Faire son propre décodeur permet également de répondre à des besoins spécifiques.

Décodeur DCC-Arduino pour quelles applications ?

Motoriser un pont tournant

Dans le cadre du Club et la réalisation d’un dépôt ferroviaire nous avions à terme prévu d’y adjoindre une motorisation. Les systèmes propriétaires et vendus par les différents fabricants étant relativement onéreux, l’idée d’utiliser l’Arduino connecté à un moteur afin de motoriser le pont nous semblait être une bonne alternative. D’autant plus que de nombreux tutos sont déjà disponibles sur Internet et qu’il « suffirait » d’adapter le programme à notre utilisation.

Utiliser l’Arduino pour ce type de projet permet d’aller plus loin qu’avec une motorisation du commerce ou nous aurions eu un boîtier avec un moteur et 2 boutons de commandes pour aller de gauche à droite au plus simple.

Mais l’Arduino offre ici des axes d’améliorations importants comme :

  • L’accélération / décélération du moteur pas-à-pas de sa position de départ à celle de destination pour obtenir un bel effet visuel d’accélération et ralenti et ce sans à-coups.
  • Permettre de caler le pont automatiquement face aux voies (sans avoir à tâtonner en appuyant un coup à gauche… un coup à droite sur les boutons de commande)
  • D’aller directement à une voie souhaitée tout en calant la voie en face
  • Paramétrer et ajuster des vitesses de rotation réalistes

Commander des signaux mécaniques

Toujours dans le cadre du club nous avons prévu de mettre en place des signaux mécaniques. Signaux mécaniques pilotés par des servos. L’Arduino est tout à fait apte à mettre en ouvre des servos-moteurs.

Pré-requis

La mise en place de ce premier tuto, relativement simple, nécessite de savoir installer un programme dans l’Arduino. Les prochains tutos nécessiteront quelques connaissances en programmation dès lors qu’il faut adapter le programme à sa propre utilisation. J’essayerais d’être le plus explicite possible sur la partie programmation.

Matériel nécessaire à la réalisation

Partie électronique

Liste des composants utilisés

  • 1x Carte Arduino UNO (U1)
  • 1x Résistance 1KΩ / 1 Watt (R1)
  • 2x Résistance 10KΩ / 1/4 Watt (R2 et R3)
  • 1x Diode 1N4148 (D1)
  • 1x Optocoupleur 6N137 (U2)
  • 1x Plaque d’essais (ou CI imprimé)

La résistance en entrée (DCC) peut être amenée à chauffer de part l’intensité du signal DCC qui va varier (ex : l’ampérage n’est pas le même selon le nombre de locos sur le circuit). Pour éviter l’échauffement on utilise une résistance d’un watt. L’optocoupleur doit être relativement rapide pour « lire » correctement le signal DCC dont la fréquence varie entre 8-10KHz.

Composants optionnels

  • 1x Bornier 2 pôles (connexion au signal DCC)
  • 1x Bornier 3 pôles (connexion à l’Arduino)

Partie programmation

Pour pouvoir décoder les trames nous allons utiliser la libairie <DCC_decoder.h>. Elle peut être téléchargée à l’adresse : https://github.com/MynaBay/DCC_Decoder

Copier le dossier « DCC_Decoder » dans le dossier « librairies » ou est installé l’IDE « Arduino » (logiciel pour compiler et charger les programmes dans la carte Arduino).

Le dossier « DCC_Decoder » s’accompagne également d’un dossier « examples » avec les 2 programmes suivants :

  • DCC_Monitor : Programme qui va monitorer les trames DCC émises par la centrale et ici nous permettre de valider le montage électronique
  • DCC_Basic_Acc_Decoder : Un programme simple, décodeur d’accessoires (ex : signaux lumineux)

Montage électronique

Schéma structurel et principe de fonctionnement

Le câblage relativement simple ne pose pas de problème particulier ici. Basiquement, l’optocoupleur est connecté en entrée au signal DCC et permet d’isoler électriquement les 2 parties. Soit le signal DCC et sa tension de (15-18V) de la partie Arduino qui travaille à une tension de 5V.

L’Arduino récupère le signal sur son entrée Pin#02 qui permet de gérer les interruptions. En informatique, une interruption est un évènement/déclencheur extérieur qui vient interrompre le déroulement du programme principal pour exécuter le programme d’interruption.

À chaque fois qu’un signal DCC est présent sur la patte 2, l’Arduino exécute le programme d’interruption qui ici permet les valeurs qui nous intéressent.

Isolation galvanique entre le signal DCC et l’Arduino.

Typon pour circuit imprimé

Pour les personnes qui ont la possibilité et souhaitent graver le circuit imprimé, il est possible de s’appuyer ce sur typon.

Montage sur plaque d’essais


La plaque d’essais permet de réaliser le montage rapidement sans avoir à souder les composants.

Charger le programme « Moniteur »

Pour valider le montage, nous allons utiliser le programme fourni en exemple intitulé « DCC_Monitor ». Sans avoir à le modifier, il permet d’afficher toutes les trames issues de la centrale et donc de valider que le montage électronique est opérationnel.

Manipulations

  1. Double-cliquer sur le fichier « DCC_Monitor.ino » du dossier du même nom du dossier « examples »
  2. Le programme s’ouvre dans l’éditeur
  3. Dans le menu « Outils », sélectionnez type de carte « Arduino Uno »
  4. Dans le menu « Outils », sélectionnez le port (USB) sur lequel la carte Arduino est connectée
  5. Cliquer sur « Téléverser » pour compiler le programme et l’envoyer vers l’Arduino
  6. Si le programme se charge correctement il est exécuté dans l’Arduino
  7. Si le montage est correct vous devriez voir les trames DCC s’afficher dans le moniteur série (menu « Outils » puis « Moniteur Série »)

Réaliser un décodeur signaux simple

Schéma

Programme utilisé


// Utilisation de la librairie DCC Decoder pour lire les trames DCC
#include "DCC_Decoder.h"

// Adresse de base du Arduino-Decodeur
#define baseAdresse 100  

// Déclaration des éléments par rapport aux broches de l'Arduino
// La LED verte est connectée à la broche 3
// La LED rouge est connectée à la broche 4
const int Led_Verte = 3;
const int Led_Rouge = 4;

// Cette fonction est appelée par la librairie pour 
// chaque activer / désactiver au niveau des adresses
void BasicAccDecoderPacket_Handler(int address, boolean activate, byte data) {
  address -= 1;
  address *= 4;
  address += 1;
  address += (data & 0x06) >> 1;
  //address = address - 4; // cette ligne devra être décommentée si centrale RocoMouse et/ou z21

  boolean enable = (data & 0x01) ? 1 : 0;
 
  // Ex: si adresse de base est 100 alors l'arduino réagit aux adresse 100, 101, 102,...
  // Si l'adresse accessoire envoyée par la centrale correspond à l'une de notre programme
  // Alors on récupère son état (activé/désactivé) et on exécute en conséquence les actions 
  // Ici la gestion de l'alimentation de 2 LEDs.
  switch (address) {
  
    case (baseAdresse): 
      if (enable) {
        digitalWrite(Led_Rouge, LOW);
        digitalWrite(Led_Verte, HIGH);
      } else {
        digitalWrite(Led_Rouge, HIGH);
        digitalWrite(Led_Verte, LOW);
      } 
      break;

    // Cas pour les adresses suivantes
/*
    case (baseAdresse + 1):

      break;

    case (baseAdresse + 2):
     
      break;
*/
  }

}


void setup() {
 
  // Broche des LEDs en mode "Sortie"
  pinMode(Led_Rouge, OUTPUT);
  pinMode(Led_Verte, OUTPUT);
  
  // Init les Voyants, par défaut Rouge actif
  digitalWrite(Led_Rouge, HIGH);
  digitalWrite(Led_Verte, LOW);

  // Les 2 lignes suivantes permettent d'initialiser la librairie DCC Decoder
  DCC.SetBasicAccessoryDecoderPacketHandler(BasicAccDecoderPacket_Handler, true);
  DCC.SetupDecoder( 0x00, 0x00, 0 );
}


void loop() {

  // Appel de la librairie DCC pour lire les valeurs
  DCC.loop();
}


Il ne reste plus qu’à piloter l’adresse 100 depuis votre centrale (ou ordinateur) et basculer entre les états on/off pour allumer le voyant rouge ou vert.

Une Question ?

Vous aimez ? Partager et Liker sur les réseaux sociaux.
  •  
  •  
  •  
  •  
  •