Les principaux composants :

Tout d’abord le logiciel ; j’ai choisi JMRI qui est gratuit, très complet et aussi très performant. En fait, nous allons voir qu’il s’agit d’un ensemble d’applications ayant chacune une mission précise et qui communiquent entre elles. On y trouve des manettes pour les locomotives avec la possibilité de commander la vitesse, inverser le sens de roulement et actionner les fonctions des locomotives : éclairage, bruit du moteur, sifflets et autres fonctions sympathiques disponibles dans les décodeurs. On y trouve également un module pour lire et modifier les CV’s. Et on y trouve aussi une solution complète de gestion de réseau. Nous verrons cela un peu plus en détail par la suite. Ce logiciel est disponible sur Mac, sur PC et sous Linux.

Le second élément d’une centrale DCC, c’est la partie commande DCC. Dans une centrale du commerce, ceci n’est pas vraiment « visible » car intégrée à l’ensemble. Dans nos montages en DIY, il s’agit d’une carte Arduino sur laquelle va s’exécuter un nouveau logiciel pour délivrer sur les rails un signal électrique bien spécifique. C’est véritablement cette partie qui constitue le DCC, système numérique de commande de locomotive qui fait l’objet d’une normalisation NMRA pour permettre que n’importe quelle locomotive « DCC » puisse être pilotée par n’importe quelle centrale « DCC ». Dans la solution proposée, il s’agira d’un Arduino UNO ou MEGA selon les options que vous souhaiterez et surtout, s’exécutant sur cet Arduino, l’excellent logiciel DCC++ écrit par le développeur Gregg E. Berman. Ce logiciel est lui aussi gratuit.

Enfin, le troisième élément est constitué par la partie « puissance » appelée souvent « booster ». Il va falloir fournir aux rails un courant d’autant plus puissant que l’on souhaitera faire rouler un nombre conséquent de locomotives. On va utiliser une carte électronique un peu particulière qui va être capable de délivrer la puissance électrique mais aussi « d’injecter » dans ce courant des informations pour la commande des locomotives. Le DCC, est en effet un codage numérique d’informations (suite de 0 et de 1) qui est véhiculé par le courant même de puissance.

Il existe une pléthore de ces cartes dites « moteur » dans le monde de l’électronique car elles ne sont pas spécifiques au modélisme ferroviaire. Elles sont souvent, soit très bon marché (environ 2€) mais peu puissantes, ou, vous l’avez deviné, puissantes mais plus chères. Nous vous avons présenté dans Locoduino toutes les principales cartes qui répondent à ces critères, soit plutôt de prix, soit plutôt de performance. Nous vous avons même fournis les informations sur la manière de les intégrer dans différents environnements, voir à ce propos « Réalisation de centrales DCC avec le logiciel libre DCC++ (3) »

J’ai cependant découvert récemment une carte dont on n’avait pas parlé jusque-là, assez puissante, suffisamment en tous cas pour des réseaux faisant tourner simultanément une vingtaine de locomotives en HO et de l’ordre de 30 en N, polyvalente car elle permet d’alimenter tout à la fois les voies principales et une voie de programmation et à un prix raisonnable de 10 à 12€. Le nom de cette carte est : L9110S Dual Motor Driver.

Voici la centrale telle que je l’ai fabriquée pour mon propre usage et qui rassemble donc tous les ingrédients dont je viens de vous parler. Pour faire tourner le logiciel JMRI, il vous faudra cependant en plus un ordinateur (ou un Raspberry).

On a, à gauche sur la photo, une alimentation 18V 10A, à sa droite, un convertisseur de tension pour l’alimentation de l’Arduino en 9V, à droite encore, l’Arduino et enfin la carte L9110S Dual Motor Driver.

Le matériel nécessaire :

Alimentation :

On trouve assez facilement sur internet des alimentations à découpage. Pour du HO, on choisira 18V. Pour du N, on choisira une alimentation de 15V. Pour ce qui est du choix de l’ampérage, on se portera sur des valeurs proches de 10A dans le cas où l’on souhaite une certaine puissance sur le réseau.

Pour le calcul de consommation, on prendra tout d’abord en compte le nombre de locomotives, la nature du réseau et l’âge des locomotives. Les locomotives récentes ont des moteurs peu gourmands, les vielles locos digitalisées consomment beaucoup plus. On prendra également en compte certaines fonctions spécifiques comme les fumigènes sur les locos vapeur dont la consommation est de l’ordre de 0,5A.

Si vous faites par exemple rouler simultanément 10 locomotives récentes, la consommation totale maximale sera donc de : 10 X 0,4A = 4A. Avec une alimentation de 10A, cela vous laisse une bonne marge de sécurité.

Mais si vous faites maintenant rouler simultanément 10 locomotives anciennes digitalisées, la consommation totale maximale pourrait être de : 10 X 0,8A = 8A. Ceci serait alors un maximum car il est nécessaire que vous gardiez une marge de sécurité d’au moins 2A.

L’alimentation est le matériel le plus cher de cette liste à 25€ environ.

Voici celle que j’ai acheté sur e-bay :

Pour le N, cette alimentation secteur régulée de 15V 7A conviendra parfaitement.

Convertisseur de tension :

Vous n’aurez pas besoin de ce convertisseur si la carte Arduino est reliée directement à l’ordinateur qui exécute JMRI. Votre carte sera alors en effet reliée à l’ordinateur par le port USB et alimentée par ce même port USB.

Dans mon cas, j’ai choisi de connecter mon Arduino à mon réseau WiFi/Ethernet domestique, le convertisseur est donc nécessaire pour l’alimentation de l’Arduino. Comme vous pouvez le voir, on en trouve pour moins de 4€ sur internet.

J’ai choisi la liaison Ethernet tout simplement pour avoir plus de liberté. Mon ordinateur pouvant se trouver dans un autre endroit de la pièce, voir dans une autre pièce de ma maison !

Il faut préciser que DCC++ nécessite d’être exécuté sur un Arduino Mega si l’on souhaite une liaison Ethernet.

Carte Arduino :

La carte Arduino sert à exécuter DCC++. Le choix de la carte se fera en fonction du type de liaison que vous souhaitez adopter. En USB vous pourrez choisir un Arduino UNO, en Ethernet, vous devrez obligatoirement utiliser un MEGA (comme sur la photo).

Notez que vous pouvez utiliser un MEGA avec une liaison USB. Cette précision me semble importante pour le cas où vous décideriez de commencer en USB mais que vous envisagez d’évoluer vers de l’Ethernet.

L’autre choix que vous devrez faire portera sur l’origine de votre Arduino ; une carte « officielle » ou un clone provenant en générale de Chine ou de Hong Kong même s’il est écrit dessus « made in Italia » !!!

Pour un UNO, le prix est de 2€ environ pour le clone contre 20€ pour la carte officielle. Pour un MEGA, on est à 8€ environ pour un clone, mais l’on passe à 30€ pour un officiel.

Voici les liens vers le site officiel Arduino pour :

• UNO
• MEGA

Shield Ethernet :

Si vous retenez la solution d’une liaison Ethernet pour ne pas être obligé d’avoir votre ordinateur à proximité de l’Arduino ou tout simplement pour que votre ordinateur soit en liaison WiFi avec la centrale, vous opterez pour un shield Ethernet (Rappel, Arduino MEGA obligatoire dans ce cas).

Le prix pour la version officielle est de 17 € alors que l’on peut trouver des clones à partir de 5€.

Voici la configuration avec un Arduino MEGA et son shield Ethernet.

Carte moteur L9110S Dual Motor Driver :

Je le dis d’emblée, cette carte m’a totalement conquis dès que je l’ai essayée. Et pourtant, j’ai réalisé des centrales DCC avec à peu près toutes les cartes existantes : La POLOLU MC33926 ou encore avec le LMD18200 que nous plébiscitons depuis longtemps à Locoduino.

C’est tout d’abord la polyvalence de la carte qui me séduit. Comme elle dispose de deux sorties, on peut d’emblée envisager d’avoir sur son réseau une voie de programmation (bien pratique) en plus de l’alimentation du réseau et ce, sans avoir à tout débrancher comme par exemple lorsque l’on a qu’un seul LMD18200.

C’est ensuite sa puissance : celle que j’ai acheté est une 10A (elle existe aussi en 15A) ce qui est largement suffisant même pour des réseaux d’une vingtaine de locomotives, et donc, pour le public que je vise dans cet article.

Pour donner une comparaison, la POLOLU MC33926 qui a des fonctionnalités similaires (2 sorties) mais seulement 3A, est en vente à 29,95$ sur le site de son fabricant.

Ah, oui, je ne vous ai pas encore donné le prix de la L9110S. Eh bien comme vous le voyez, 11,95€ sur ebay port compris.

La carte est magnifique, la gravure parfaite. Les borniers à visser sont solides, on ne craint pas de les péter à chaque fois que l’on sert un câble, (péter les borniers pas les câbles).

Le seul petit reproche que je lui fais est qu’il n’y a pas de LED témoin pour nous indiquer s’il y a du courant sur les sorties. Comme pour le LMD18200, j’ai donc ajouté une LED sur chaque sortie, une diode pour la tension inverse et une résistance de 870 Ω. On peut aller jusqu’à 1KΩ.

La cathode de la LED devra être reliée à l’anode de la diode et bien sûr, inversement l’anode de la LED devra être reliée à cathode de la diode. Ce petit schéma extrait du (très utile) cours d’électronique de Christian montre comment repérer la cathode et l’anode sur une diode.

Sur une LED, l’anode (+) est plus longue que la cathode(-).

MAX471 :

Un MAX471 pour la mesure d’intensité et couper l’alimentation en cas de sur tension ou de court-circuit. Là aussi, c’est du classique maintenant sur Locoduino.

Le MAX471 ne peut supporter un courant au-delà de 3A. De toutes les façons, DCC++ est paramétré par défaut pour couper l’alimentation avant d’avoir atteint cette limite de 3A. Si vous envisagez de dépasser 3A, vous devrez utiliser par exemple un ACS712 qui supporte lui jusqu’à 20A.

SENSEUR-COURANT-ACS712

Pour l’implantation d’un ACHS-7122, voir sur le forum : https://forum.locoduino.org/index.p...

Il faudra également modifier des paramètres dans le logiciel DCC++ ce que nous verrons plus loin.

Comme vous le voyez, j’ai porté la section des câbles d’alimentation à 1,5mm². Je n’avais que du câble rigide d’électricien mais finalement, je trouve cela plus propre que du câble souple.

Pour la sortie d’alimentation des voies principales, j’ai mis des câbles souples en 2,5mm² qui sont à connecter au feeder sous le plateau. Pour la voie de programmation, qui par principe ne doit alimenter qu’une seule locomotive, je me suis contenté d’une section de 0,5mm².

Tous les câbles sont solidement attachés au support. Qui ne s’est jamais pris les pieds dedans ?

Voilà donc pour le matériel. Et maintenant, le petit récapitulatif budgétaire :

Moins de 60€ pour une version Ethernet avec des clones Arduino.

Schéma de câblage :

- avec un Arduino UNO.

- avec un Arduino MEGA

Les commandes DCC : DCC++

Est-il encore nécessaire de présenter DCC++ que nous avons découvert il y maintenant un peu plus de 5 ans, qui s’est largement imposé dans toute la communauté du DIY en matière de commandes DCC et que nous même à Locoduino avons utilisé dans de multiples configurations différentes avec toujours le même succès.

Si vous souhaitez avoir une présentation détaillée :

L’installation du logiciel sur la carte (UNO ou MEGA) se fait comme pour n’importe quel sketch Arduino à l’aide de l’environnement de développement Arduino (IDE). Ce n’est pas l’objet de traiter ce point ici ce qui est par ailleurs largement fait sur internet et sur Locoduino :

• Installation de l’IDE Arduino
• Bien utiliser l’IDE d’Arduino (1)
• Bien utiliser l’IDE d’Arduino (2)

La version officielle de DCC++ est disponible ici en téléchargement :

en cliquant sur le bouton vert « Clone or download »

Vous placerez ensuite le dossier téléchargé dans le bon répertoire de votre ordinateur ; de préférence le dossier Arduino du répertoire Documents.

Que vous utilisiez un Arduino UNO ou un MEGA, le fichier à ouvrir est le même : « DCCpp_Uno.ino ».

A l’ouverture du fichier, vous serez peut-être étonné de voir plusieurs onglets en haut de la fenêtre.

C’est une bonne pratique de développement que de séparer le code en fichiers séparés, surtout s’il est long et/ou complexe.

Vous allez cliquer sur l’onglet « Config.h » et vous allez pouvoir ajouter fièrement votre nouvelle carte ligne 16 :

//  2 = L9110S Dual Motor Driver      (MAX 28V/10A PER CHANNEL)

Et vous allez valider cette option en modifiant la ligne 18 comme ci :

#define MOTOR_SHIELD_TYPE   2

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE MOTOR_SHIELD_TYPE ACCORDING TO THE FOLLOWING TABLE:
//
//  0 = LMD18200 Motor Driver         (MAX 28V/3A PER CHANNEL)
//  1 = POLOLU MC33926 MOTOR SHIELD   (MAX 28V/3A PER CHANNEL)
//  2 = L9110S Dual Motor Driver      (MAX 28V/10A PER CHANNEL)

#define MOTOR_SHIELD_TYPE   2    

Ensuite, vous allez sélectionner le type de communication selon que vous utilisez une liaison Série/USB ou Ethernet.

Dans mon cas qui suis en Ethernet, mon shield correspond au choix 1.

/////////////////////////////////////////////////////////////////////////////////////
//
// DEFINE COMMUNICATIONS INTERFACE
//
//  0 = Built-in Serial Port
//  1 = Arduino.cc Ethernet/SD-Card Shield
//  2 = Arduino.org Ethernet/SD-Card Shield
//  3 = Seeed Studio Ethernet/SD-Card Shield W5200

#define COMM_INTERFACE   1

/////////////////////////////////////////////////////////////////////////////////////

Si vous utilisez Ethernet, assurez-vous qu’il n’y ait pas « // » devant #define IP_ADDRESS { 192, 168, 1, 200 }

Vous devez obtenir ceci :

// DEFINE STATIC IP ADDRESS *OR* COMMENT OUT TO USE DHCP
//

#define IP_ADDRESS { 192, 168, 1, 200 }

/////////////////////////////////////////////////////////////////////////////////////

Si vous utilisez le port USB, vous n’avez rien à changer.

Vous allez maintenant cliquer sur l’onglet « DCCpp_Uno.h », vous rendre ligne 84, ajouter une ligne et coller ceci :

#elif MOTOR_SHIELD_TYPE == 2

  #define MOTOR_SHIELD_NAME "L9110S Dual Motor Driver"

  #define SIGNAL_ENABLE_PIN_MAIN 3
  #define SIGNAL_ENABLE_PIN_PROG 11

  #define CURRENT_MONITOR_PIN_MAIN A0
  #define CURRENT_MONITOR_PIN_PROG A0

  #define DIRECTION_MOTOR_CHANNEL_PIN_A 12
  #define DIRECTION_MOTOR_CHANNEL_PIN_B 13

Voilà, votre application DCC++ est maintenant configurée pour vos besoins.

Assurez-vous dans le menu Outils que les paramètres correspondants à votre carte sont bien sélectionnés, ici un Arduino MEGA :

Puis pour finir, vous allez charger le sketch sur la carte :

Voilà, c’est fini pour l’application DCC++. Bien sûr, vous n’aurez plus à faire tous ces réglages sauf si vous changez de carte ou de configuration.

Nous allons maintenant nous assurer que tout fonctionne :

A droite de la fenêtre du sketch, vous allez ouvrir le moniteur série en cliquant sur l’icon en forme de loupe :

Vous devriez voir apparaître une nouvelle fenêtre avec ce texte si vous êtes en USB : <iDCC++ BASE STATION FOR ARDUINO MEGA / L9110S Dual Motor Driver: V-1.2.1+ / Jun 25 2019 11:02:57><N0: SERIAL>

Si vous n’avez rien ou des caractères incompréhensibles, assurez-vous que la vitesse 115200 bauds est bien sélectionné en bas de la fenêtre.

Si vous avez une configuration Ethernet, assurez-vous que le shield est connecté à l’un des ports Ethernet de votre box.

Pour ceux qui auraient des difficultés à se connecter sur leur box compte tenu de l’éloignement en particulier, vous pouvez avoir recours à la technologie CPL :
https://fr.wikipedia.org/wiki/Coura...

C’est ce que j’ai adopté pour moi avec succès après avoir testé différentes solutions. Vous mettrez alors un boitier CPL dans la pièce où se trouve votre Arduino et le tour est joué.

Revenons à nos réglages, si vous avez une liaison Ethernet, l’écran du moniteur devrait afficher ceci : <iDCC++ BASE STATION FOR ARDUINO MEGA / L9110S Dual Motor Driver: V-1.2.1+ / Jun 25 2019 11:02:57><N1: 192.168.1.200>

A la fin de la ligne apparaît l’adresse IP choisie pendant les réglages.

Nous allons maintenant tester que DCC++ communique bien avec la carte moteur en lui envoyant l’ordre de se mettre sous tension.

Si vous avez choisi la configuration Ethernet, vous allez devoir revenir au réglages Série/USB en saisissant 0 au lieu de 1 à la suite de COMM_INTERFACE ligne 35.

Chargez le code sur la carte. Assurez-vous que ce sont bien les paramètres de la liaison USB qui s’affichent dans le moniteur.

Si vous êtes déjà en port USB, vous n’avez bien sûr rien à faire.

Assurez-vous que la carte moteur est bien sous tension.

Saisissez : <1> dans la barre de saisie du moniteur puis validez avec la touche return :

Les caractères <p1> devraient s’ajouter à la ligne dans le moniteur de l’IDE, mais surtout, les deux LED’s sur la carte moteur doivent s’allumer.

Cela indique qu’il y a du courant en sortie de la carte sur la voie principale et sur la voie de programmation. BRAVO !

Une dernière précision. Je vous disais plus haut que vous pouviez augmenter sur DCC++ le seuil de l’intensité à se par exemple pour utiliser un ASC712 à la place du MAX471.

Cela se fait en sélectionnant l’onglet "CurrentMonitor.h" à la ligne 16 : #define  CURRENT_SAMPLE_MAX 300

La valeur de 300 doit correspondre à environ 1,5A. Vous pouvez donc jouer sur cette valeur si vous souhaitez augmenter le seuil de déclenchement. L’échelle de correspondance étant linéaire, un réglage de 600 doit correspondre à 3A environ.

Il ne nous reste plus qu’à voir le logiciel JMRI.

What is JMRI ?

Sur la page d’accueil du site www.jmri.org, on y apprend que : JMRI est un projet qui vise à développer des applications pour contrôler par ordinateur des réseaux ferrés miniature.

Je rappelle que JMRI peut fonctionner sur Mac et PC mais aussi sur Raspberry.

Rassurez-vous, un grande partie de la documentation a été traduite en partie en français http://jmri.org/help/fr/webtoc.shtml par une communauté de bénévoles.

Il existe par ailleurs de très nombreux tutos sur Youtube en particulier qui vous permettront une prise en main rapide. C’est que l’utilisation basique de JMRI, ce qu’il faut connaître pour programmer à minima ses locomotives mais surtout les faire rouler, s’amuser avec, cet apprentissage donc est très facile et rapide. Il vous faudra tout au plus entre ½ et une journée !

JMRI permet aussi de piloter ses locomotives à partir d’une tablette ou d’un smartphone ce qui offre des perspectives de jeu intéressantes.

JMI, c’est une communauté très importante de contributeurs, des développeurs qui font évoluer les applications, mais aussi utilisateurs qui échangent et mettent à dispositions des tutos pour aider les autres.

JMRI offre de nombreux outils qui permettent de gérer de façon très automatisée la détection des trains, leur circulation pour éviter par exemple les collisions, qui gèrent la signalisation, les aiguillages etc… Nous n’irons pas jusque-là car nous dépasserions largement le cadre que je me suis fixé. Je ne doute pas que les plus expérimentés d’entre vous prendront le relai dans une suite logique à cet article.

Pour installer JMRI, rendez-vous tout d’abord sur la page de téléchargent, http://jmri.org/download/index.shtml

Choisissez votre configuration, puis laissez-vous guider.

Une fois l’installation terminée, lancez l’application PanelPro. Comme il s’agit d’une première ouverture, PanelPro va vous demander de créer un « profile ». Ici j’entre myJmri et je valide.

Puis je vais devoir choisir le système, ici DCC++

Ensuite le type de connexion. Soit SerialPort si votre configuration est USB/Série…

…ou DCC++ Ethernet si vous avez choisi la même configuration que moi.

PanelPro vous demande de redémarrer l’application.

Une fenêtre spécifique me demande d’entrer mes paramètres de connexion. Attention, l’adresse IP qui m’était proposée par défaut était 192.168.0.200. J’ai bien sûr du corriger avec la même adresse IP que celle entrée dans les paramètres de DCC++ soit 192.168.1.200.

Pensez à sauver ces réglages en bas à gauche de la fenêtre.

L’étape suivante consiste à lancer l’application DecoderPro. A l’ouverture, nous avons une fenêtre telle que celle-ci.

Vous allez cliquer sur le bouton jaune en haut et au milieu de la fenêtre pour mettre le réseau sous tension jusqu’à ce que le bouton soit vert. Les LED’s de votre carte L9110S doivent alors s’allumer. Si ce n’est pas le cas, il faut reprendre les réglages.

Assurerez-vous que l’option en bas à droite « Programmation sur voie de programmation » est bien activée.

Posez une locomotive sur la voie de programmation.

Et cliquez sur le gros bouton en bas à droite « Programme »

Une nouvelle fenêtre va apparaître,

Cliquez sur le bouton « Lire le type depuis le décodeur ». Votre locomotive devrait se mettre à bouger sur les rails. Après quelques secondes, le programme va vous proposer de sélectionner un type de décodeur, et quelques fois plusieurs. Si vous connaissez la référence exacte de votre décodeur, vous allez alors le sélectionner parmi les propositions, sinon, choisissez l’une ou l’autre des propositions qui vous sont offertes, il ne s’agit en effet que de variantes de décodeurs pour un même fabricant ce qui ne va pas changer le comportement de vos locomotives.

Ici j’ai le choix entre deux décodeurs Lenz, le LE1035 et le LE1835. J’ai choisi le dernier.

Le programme m’indique que l’adresse du décodeur est 16 et qu’il s’agit d’une adresse DCC courte. Entrez le nom de la locomotive à la place de <nouvelle machine> puis validez en cliquant sur le bouton sauver.

La locomotive apparaît dans une liste qui pour JMRI s’appelle un inventaire. Sélectionnez-la et appuyez sur le bouton « régulateur ».

Une fenêtre de pilotage pour cette locomotive s’ouvre.

Placez-la maintenant sur la voie principale de votre réseau. Ca-y est, vous allez pouvoir faire rouler votre première locomotive et activer les différentes fonctions disponibles sur son décodeur.

A vous maintenant de poursuivre la découverte vous-même. Comme par exemple donner des titres aux boutons plutôt que des nom F0, F1,F…

Conclusion :

Il n’est pas dans l’objectif de cet article d’aller plus loin dans l’apprentissage de JMRI qui je le répète est très complet et très puissant.

Sans doute chercherez vous à utiliser JMRI pour piloter vos locomotives à partir de smartphones ou de tablettes en WiFI pour augmenter le plaisir du jeu. Sans doute aurez-vous aussi envie de pouvoir piloter vos aiguillages et voir la signalisation s’activer en fonction de l’état du réseau.

Vous découvrirez cela au grès de vos envies et de vos besoins. Il y a sur Locoduino de nombreux articles pour faire évoluer votre centrale et votre réseau, comme l’article Communications entre JMRI et Arduino. Vous avez aussi la documentation de JMRI et de nombreux tutoriels sur le net. Un sujet dédié à JMRI a été spécialement ouvert sur le Forum (http://forum.locoduino.org/index.ph...) pour vous permettre d’échanger vos expériences.

Au travers de cet article, nous avons construit pas à pas, et sans difficultés particulières, une centrale DCC à la fois puissante, polyvalente, évolutive et économique. L’aventure en vaut assurément le coup. Cette centrale sera unique car ce sera la vôtre, celle que vous aurez réalisée.

Prenez du plaisir à jouer !