LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

jeudi 14 novembre 2019

15 visiteurs en ce moment

Traductions du blog de Geoff Bunza

Communications entre JMRI et Arduino

Pour pilotez votre réseau avec JMRI

. Par : Dominique, Nopxor

JMRI [1] est un projet et une communauté de développeurs qui ont créé des outils en Java pour le contrôle par ordinateur des modèles réduits ferroviaires. Ces outils sont accessibles selon les règles de la Free Software Foundation’s GNU General Public License (GPL). Il comprend notamment DecoderPro® qui permet de programmer les décodeurs et un panneau de commande PanelPro™ pour configurer la topographie et la signalisation.

On trouvera un tour d’horizon des applications et possibilités de JMRI en français ici [2], ainsi qu’une liste des matériels supportés parmi lesquels on trouve maintenant les centrales DCC à base du logiciel DCC++ [3], donc l’Arduino, mais il manquait une interface plus générale entre JMRI et Arduino pour remonter les états de la rétrosignalisation et pour actionner les appareils de voie.

Geoff Bunza est un modéliste américain de Portland (Orégon) qui publie de nombreux projets sur le modélisme et l’Arduino [4]. Il nous a donné l’autorisation [5] de publier une traduction en français de deux de ses contributions sur les communications entre JMRI et Arduino.

C’est l’ensemble de ces opportunités qui nous a amené a publier cet article largement inspiré du blog de Geoff. Toute l’équipe de Locoduino le remercie (ainsi que son traducteur Nopxor) d’en faire profiter ainsi les modélistes français.

Avant propos important

JMRI (Java Model Railroad Interface) est un logiciel gratuit fonctionnant sous Windows, Linux ou Macintosh et pouvant exécuter une multitude de fonctions. Il est bien connu pour la programmation des décodeurs DCC complexes grâce à son application DecoderPro. Il est également utilisé pour la modélisation et la gestion de réseau, la rétrosignalisation, la signalisation, la commutation des aiguilles, le contrôle des itinéraires, le contrôle des trains, l’interface avec les contrôles WiFi et les commandes avec des téléphones portables. La version 4.14 est la version actuelle de JMRI, du moins à la date de publication de cet article.

Cet article n’est pas une présentation ni un mode d’emploi complet de JMRI, il se limite à la mise en oeuvre des interfaces avec l’Arduino décrites ci-après.
Pour démarrer avec JMRI, il est recommandé de se rendre sur le site de JMRI indiqué plus haut. Pour les francophones purs et durs, on pourra démarrer avec la table des matières et l’index général en français où le lecteur pourra consulter en détail chacune des notions traitées dans cet article comme les tableaux de capteurs et les tableaux d’aiguillages.

JMRI a, en particulier, l’avantage de s’interfacer à de nombreuses technologies grâce à l’ajout de scripts Python (langage Jython très proche). Ici aussi, il n’est pas question de présenter Python, mais chacun pourra comprendre la programmation qui est utilisée dans les scripts de cet article car ils ne font appel qu’à des notions extrêmement basique où Python se révèle semblable au C, le langage de l’Arduino.

A titre d’exemple, les scripts présentés ici servent à établir des communications entre JMRI sur votre PC et l’Arduino, via le port USB. Accessoirement JMRI offre la possibilité d’appeler manuellement un script à l’aide d’un bouton que vous pourrez ajouter sur la fenêtre d’accueil de JMRI comme celle-ci :

Exemple de fenêtre de démarrage personnalisée
Les boutons Start_sensors et Stop_sensors sont bien entendu des exemples.

L’article vous montrera en détail comment mettre en oeuvre ces scripts qui sont livrés tout fait avec le programme Arduino.

Autre remarque importante : On peut choisir la langue française dans les préférences de JMRI, comme dans tout logiciel. Sauf que les développeurs de JMRI n’ont pas traduit toute l’interface et il reste des menus déroulants et boites à cocher en anglais. Le texte de cet article en tient compte.

Enfin, nous n’avons pas voulu franciser les sketchs de Geoff Bunza, originellement en anglais, pour lui permettre d’apporter un peu de support éventuellement. Nous dérogerons donc à la règle habituelle sur Locoduino, mais vous ne nous en voudrez pas trop !

Il a deux parties distinctes correspondant à deux articles distincts sur le blog de Geoff Bunza. Nous avons décidé de les regrouper ici car elle partagent beaucoup de choses en commun.

Ces deux parties décrivent pas à pas la mise en oeuvre de 2 projets distincts :

  1. La remontée de rétrosignalisations à JMRI à partir des ports d’entrée/sortie d’un Arduino.
  2. La transmission des commandes d’aiguillage de JMRI vers des ports d’entrée/sortie d’un Arduino.

Cet article ne va pas au delà des ports d’entrée/sortie d’Arduino, vers votre réseau, sachant que vous pouvez trouver sur Locoduino de nombreux projets qu’il vous sera facile d’adapter ainsi à JMRI. En particulier il ne décrit ni les capteurs réels, ni les actionneurs que vous serez amené à raccorder à votre Arduino.

Du fait de la description de 2 projets, même s’ils ont des similitudes, la description donnée reste complète pour ceux qui ne réaliseraient qu’un des 2 projets. Cela pourra donner l’impression de répétitions.

 


1ère Partie - Communications de Arduino vers JMRI - rétrosignalisation

D’après l’article : JMRI Sensors A plenty for Any Layout

Plusieurs des fonctions de JMRI doivent savoir où se trouvent les locomotives et les wagons. Il doit donc recevoir les états de la rétrosignalisation. JMRI utilise des capteurs pour cela, regroupés dans un tableau de capteurs.

Traditionnellement, les modélistes utilisent la connexion entre JMRI et leur centrale pour remonter la rétrosignalisation ; selon des protocoles tels que S88, LocoNet, ExpressNet, etc.. qui nécessitent l’achat d’une centrale du commerce. Nous allons voir comment faire communiquer ces capteurs de rétrosignalisation avec JMRI, par l’intermédiaire de l’Arduino, sans matériel supplémentaire.

Des quantités de capteurs pour JMRI à partir d’un Arduino

Cet article détaille l’implémentation d’un jeu ou canal de capteurs, qui se connecte directement à JMRI et non via une station de base DCC et vous pourrez exploiter plusieurs canaux en branchant plusieurs Arduino !

Ce projet vous montrera comment connecter jusqu’à 68 capteurs à JMRI avec un seul Arduino et comment faire pour configurer vos capteurs dans JMRI. Cela vous permettra de choisir n’importe quel type de capteur actif à l’état bas (ou à l’état haut, on verra comment) et de l’acheminer vers un tableau de capteurs JMRI. Il initialisera automatiquement tous les capteurs que vous avez configurés lors de la connexion à JMRI. La connexion matérielle sera faite avec la plupart des cartes Arduino du commerce, mais il y aura beaucoup moins de capteurs avec un Arduino Uno ou Nano. Les Arduino se connecteront via n’importe quel port USB à votre ordinateur exécutant JMRI. Ce sera le même port série USB que vous utilisez pour programmer l’Arduino. On verra aussi comment configurer la table des capteurs dans JMRI.

Le code pour Arduino et pour JMRI est disponible ici :
Sensor_Scan1_4

sensor_scan1_4

Détails de construction

Ce canal de capteur est construit avec un Arduino Mega 2560 et un Mega Sensor Shield en option..

Arduino Mega
Carte capteurs

Une alternative consiste à utiliser une carte Arduino Mega 2560 Strong :

Arduino Mega 2560 Strong

Le Mega Sensor Shield se connecte sur la carte Mega 2560 et dispose de deux bornes à vis où vous pouvez connecter une alimentation 5 V pour alimenter l’ensemble et même les capteurs connectés.

Chaque capteur (et sa broche de signal (S) correspondante) est numéroté de 2 à 53 sur la carte, puis de A0 à A15 (correspondant aux capteurs 54 à 69). Les broches 0 et 1 sont réservées pour la communication USB. Chaque connexion numérotée sur le shield fournit un groupe de 3 broches avec la connexion du capteur (S), une broche +5V (V) et une masse (connexion côté G). La plupart des capteurs disponibles agiront comme un commutateur reliant la broche S à la broche G.

Vous pouvez utiliser un commutateur ou des contacts d’un relais en tant que capteur JMRI en connectant vous-même les contacts de commutateur aux points S et G.

Les capteurs peuvent prendre différentes formes. Comme indiqué précédemment, ceux qui présentent un intérêt sont ceux actifs à l’état bas. Les capteurs de consommation de courant de cantons seront souvent utilisés. Mais si certains de vos capteurs sont actifs à l’état haut, une option de configuration dans le panneau de capteurs vous permettra de les prendre en compte aussi.

L’Arduino Mega 2560 utilisera les 68 broches (2 à 53 et A0 à A15) comme entrées de capteurs numériques. Un Arduino Uno ou un Nano auront 18 broches disponibles (broches numériques 2-13 et A0-A5 ou broches numériques 14-19) pour les capteurs. Il existe deux types de sketch dans l’archive ci-dessus pour charger un Mega ou l’un des Arduino plus petits.

Les deux sketchs supposent que toutes les broches sont scannées en tant que capteurs et correspondent aux noms de capteur JMRI définis par l’utilisateur : AR : 2-69 pour le MEGA ou AR : 2-19 pour le Uno/Nano.

La désignation AR est complètement arbitraire, mais si vous souhaitez la modifier, vous devez éditer le script JMRI Sensor_Scan Python fourni.

Lorsque vous téléchargez le sketch Arduino sur votre carte, vous devez noter le port série de votre ordinateur utilisé pour la communication entre l’IDE Arduino et votre carte. Vous devez toujours brancher votre câble USB Arduino sur le même port (prise USB) afin que votre système d’exploitation puisse attribuer le même port série. Si vous changez d’ordinateur, il est probable que le numéro de port USB soit différent.
Ceci est important et vous devez vous assurer que le script JMRI Sensor_Scan Python indique bien le port utilisé ligne 82 :

Sur Windows :

  1. a = SerialSensorMux ("COM5")

Sur Macintosh :

  1. a = SerialSensorMux("/dev/cu.usbmodemFA1211")

Téléchargez le sketch approprié sur votre Arduino, montez un sensor shield si nécessaire et laissez la carte connectée à votre ordinateur sur lequel vous exécuterez JMRI.

Vous pouvez tester que le sketch fonctionne en ouvrant la fenêtre du moniteur série réglée sur la vitesse 19200 bauds, puis en tapant un caractère puis validez : une série de lettres A suivie d’un caractère variable s’affiche : C’est bon signe !

Maintenant, avant de démarrer JMRI, vous devez soit avoir mis votre carte sous tension, soit simplement avoir appuyé sur le bouton de reset de votre carte.

Ouvrez PanelPro et ouvrez votre tableau de capteurs.

Allez au bas de la fenêtre du tableau des capteurs et cliquez sur Add…

La connexion système peut être définie pour des adresses internes ou matérielles.
Sélectionnez Internal dans la liste déroulante.

  • Dans l’espace Adresse matérielle, indiquez simplement 0 (zéro) ;
  • Dans l’espace Nom d’utilisateur, mettez simplement AR ;
  • Cochez la case Ajouter une plage séquentielle ;
  • Pour le nombre d’éléments, entrez 70 pour un Mega 2560 et 20 pour un Uno, Pro Mini ou un Nano.
  • Puis cliquez sur Créer

Retournez à votre tableau de capteurs et cliquez sur l’étiquette Nom d’utilisateur en haut de la colonne pour obtenir un tri propre par tous les noms d’utilisateur que vous venez de créer.

Supprimez maintenant les entrées IS0 et IS1, car nous ne les utiliserons pas. Vous devez maintenant avoir 68 capteurs dans le tableau avec les noms d’utilisateur IS2 à IS68. Ceux-ci seront initialisés par votre Mega au démarrage. Enregistrez votre travail en tant que panneau en utilisant Panneaux ➔ Enregistrer les panneaux…, nommez-le et enregistrez-le pour plus tard.

Maintenant, localisez l’endroit ou vous avez dézippé le fichier Sensor_Scan.py que vous avez modifié avec le port COM approprié.

Réinitialisez l’Arduino Mega (avec le bouton reset). Dans le menu JMRI, allez à Panneaux ➔ Exécuter le script et sélectionnez votre fichier Sensor_Scan.py. Exécutez le script et vous devriez voir tous vos capteurs passer d’Inconnu à Inactif ou Actif, en fonction de ce que vous avez connecté à chaque broche.

Rappelez-vous que connecter une broche de signal numérique (S) à la masse (G ou GND) active le capteur. Si vous utilisez des capteurs qui sont « Actif haut », c’est-à-dire qu’ils sont au niveau haut lorsqu’ils détectent quelque chose, alors il faut changer la ligne 18 du croquis Arduino :

  1. #define Sensors_Active_Low 1

par :

  1. #define Sensors_Active_Low 0

Le capteur IS2 (AR2) est au niveau bas, il est donc actif.

Comment ça marche

Les Arduino ont une ligne série disponible pour une utilisation générale.
C’est le même port série utilisé pour télécharger le sketch dans la carte. Une fois configuré, le même port série est disponible pour la communication avec votre ordinateur.

Il existe actuellement de nombreux composants internes à JMRI, et JMRI fournit un accès à sa structure interne via des scripts écrits en Python, ainsi qu’en jython pour Java Python.

Ces scripts permettent aux modélistes d’ajouter des fonctionnalités supplémentaires à JMRI sans développer une interface majeure pour JMRI telle que Digitrax, CMRI ou DCC++.

L’Arduino attend qu’un jeu de caractères du script JMRI initie la communication.
Lorsque le script JMRI Sensor_Scan.py démarre, il envoie le message d’initialisation à l’Arduino. Il active ensuite la mise à jour de tous les capteurs dont il est responsable (c’est-à-dire toutes les broches valides pour lesquelles il est configuré). L’Arduino envoie ensuite un message de mise à jour du capteur sur 2 octets à 19200 bauds à JMRI, qui met ensuite à jour le capteur approprié, en faisant correspondre le numéro du capteur reçu de l’Arduino au nom défini par l’utilisateur, comme AR : 54.

Le programme Arduino

Ce programme est écrit en anglais, la langue de l’auteur. Nous avons décidé de le laisser tel quel, mais vous comprendrez facilement comment il marche.
Ce programme est très simple et très court : Avant le setup(), la configuration et variables locales sont définies.

  1. #define Sensor_Pin_Max 70 // Max sensor pin NUMBER (plus one) Mega=70,Uno,Pro Mini,Nano=20
  2. #define Sensor_Pin_Start 2 // Starting Sensor Pin number (usually 2 as 0/1 are TX/RX
  3. #define Sensor_Offset 0 // This Offset will be ADDED to the value of each Sensor_Pin to determine the sensor
  4. // number sent to JMRI, so pin D12 will set sensor AR:(12+Sensor_Offset) in JMRI
  5. // This would allow one Arduino Sensor channel to set sensors 2-69 and another to
  6. // Set sensors 70-137 for example; this offset can also be negative
  7. #define Sensors_Active_Low 1 // Set Sensors_Active_Low to 1 if sensors are active LOW
  8. // Set Sensors_Active_Low to 0 if sensors are active HIGH
  9. #define open_delay 15 // longer delay to get past script initialization
  10. #define delta_delay 4 // Short delay to allow the script to get all the characters
  11. int i;
  12. char sensor_state [70]; // up to 70 sensors on a Mega 2560
  13. char new_sensor_state ; // temp to process the possible state change
  14. char incomingByte = 0; // working temp for character processing

Puis, dans le setup(), le programme attend une séquence de caractères en provenance de JMRI, puis lit et sauvegarde l’état de tous les capteurs dans sa table sensor_state[] et envoie à PanelPro les états correspondants pour mettre à jour le tableau des capteurs. Maintenant il est prêt à transmettre tous les prochains changements.

  1. void setup(){
  2. Serial.begin(19200); // Open serial connection.
  3. while (Serial.available() == 0); // wait until we get a charater from JMRI
  4. incomingByte=Serial.read(); // get the first character
  5. while ((Serial.available() > 0) && (incomingByte != '!')) incomingByte=Serial.read(); //get past !!!
  6. while ((Serial.available() > 0) ) incomingByte=Serial.read(); //flush anything else
  7. delay(open_delay); // take a breath
  8. for ( i=Sensor_Pin_Start; i<Sensor_Pin_Max; i++) { //Initialize all sensors in JMRI and grab each sensor
  9. pinMode(i, INPUT_PULLUP); // define each sensor pin as coming in
  10. sensor_state[i] = (digitalRead( i ))^Sensors_Active_Low; // read & save each sensor state & invert if necessary
  11. Serial.print("A"); Serial.print (char((sensor_state[i]<<7)+i+Sensor_Offset)); // send "A <on/off><snesor #>" to JMRI script
  12. delay(delta_delay); // in milliseconds, take a short breath as not to overwhelm JMRI's seraial read
  13. }
  14. }

Ensuite dans la loop(), de façon répétitive, le programme teste tous les capteurs et, en cas de changement, envoie la lettre A suivie d’un caractère signifiant on/off et enfin le numéro du capteur.

  1. void loop() {
  2. for ( i=Sensor_Pin_Start; i<Sensor_Pin_Max; i++) { // scan every sensor over and over for any sensor changes
  3. new_sensor_state = (digitalRead( i ))^Sensors_Active_Low; // read & save each sensor state & invert if necessary
  4. if (new_sensor_state != sensor_state[i] ) { // check if the sensor changed -> if yes update JMRI
  5. Serial.print("A"); Serial.print (char((new_sensor_state<<7)+i+Sensor_Offset)); // send "A <on/off><snesor #>" to JMRI script
  6. sensor_state[i] = new_sensor_state ; // save the updated sensor state
  7. delay(delta_delay); // in milliseconds, take a short breath as not to overwhelm JMRI's seraial read
  8. }
  9. }
  10. }

Notes JMRI supplémentaires

Ranger vos scripts au bon endroit

Les scripts Python que vous avez téléchargés en lisant cet article se trouvent quelque part dans votre ordinateur, dans le dossier de téléchargement de votre navigateur, mais ce n’est pas leur meilleure place ! Lorsque vous exécutez la commande Panneaux / Exécuter le script… vous voyez que le dossier par défaut se nomme jython et se trouve dans le même dossier que l’application PanelPro. Une bonne pratique consiste donc à déplacer les scripts que vous avez téléchargés dans ce dossier jython, après avoir modifié le nom du port de communication et, éventuellement, inversé les ports qui seraient actifs bas.

L’ajout de boutons sur la fenêtre d’accueil Panel Pro

Une fois que vous ouvrez JMRI PanelPro, dans le menu, cliquez sur Modifier ➔ Préférences… Une fenêtre Préférences s’ouvrira. Cliquez sur Démarrage, puis en bas de la fenêtre, cliquez sur Add, puis sur Add script to button…

Donnez un nom au bouton (ce sera le texte sur le bouton) et naviguez jusqu’au script que vous voulez exécuter lorsque vous cliquez sur le bouton puis sur OK

Si vous avez enregistré votre panneau, vous pouvez également cliquer sur Add ➔ Open file… et laisser JMRI ouvrir votre panneau au démarrage.

Vous pouvez également cliquer sur le bouton Add button to main window… pour avoir des boutons pour ouvrir des tableaux, des fenêtres de sortie de script, allumer l’alimentation, etc.

Toutes ces mêmes actions peuvent être configurées pour s’exécuter à la mise sous tension en sélectionnant Add ➔ Perform action… de manière similaire.

Une fois que vous avez configuré tout cela, assurez-vous de l’ordre de la liste des actions de démarrage en sélectionnant un élément dans la liste (clic simple) et en cliquant sur Move Up / Down au bas de la fenêtre.

Une fois que vous avez terminé, cliquez sur Enregistrer dans le coin inférieur gauche de la fenêtre. Il vous sera demandé si vous voulez redémarrer.

Quand vous redémarrez, JMRI apparaîtra avec tous les boutons placés dans l’ordre d’entrée dans la table, et toutes les actions que vous avez spécifiées seront effectuées au démarrage de JMRI.

Tout ou partie de ceux-ci peuvent être supprimés en sélectionnant la ligne d’action et en utilisant le bouton Remove en bas à droite de la fenêtre.

Mais là nous allons au delà de l’objectif de cet article. Nous vous conseillons de lire la documentation de JMRI.

Avant de démarrer JMRI, n’oubliez pas d’allumez l’Arduino ou d’appuyez sur le bouton reset de l’Arduino.

Il existe un script appelé SensorSerialClose.py dans le fichier zip. Si vous le lancez, il force la fermeture du port série pour lequel il est configuré. Si le script Sensor_Scan.py est en cours d’exécution, cela a pour effet de mettre fin à ce script.

Cela évite à JMRI de laisser ouvert le port COM, ce qui empêcherait de ré-exécuter Sensor_Scan.py avec succès.

Si vous exécutez SensorSerialClose.py, le port sera fermé et cela vous permettra de :

  1. Redémarrer l’Arduino en appuyant sur le bouton reset
  2. Redémarrer le script Sensor_Scan avec succès.

Les scripts Sensor_Scan.py et SensorSerialClose.py doivent tous deux faire référence au même port COM. Vous pouvez copier et renommer ces 2 scripts pour chaque canal de port COM que vous créez.

Vous pouvez avoir plusieurs canaux ou groupes de capteurs fonctionnant en même temps via différents ports série USB. Dans les sketchs Arduino, vous trouverez des informations sur la manière de définir la plage de numéros de capteurs pouvant être attribués à chaque groupe.

Vous pouvez utiliser autant de groupes de capteurs que vous avez des ports série USB.

Pour exécuter plusieurs groupes de capteur, vous devez rendre chaque script de balayage de capteurs indépendant l’un de l’autre. Vous devrez éditer et copier chaque script pour chaque port COM et modifier les lignes suivantes :

ligne 17 : global extporta # le nom extporta doit être unique pour chaque port de communication
ligne 22 : self.port = extporta # comme ci-dessus
ligne 23 : extporta = self.port # comme ci-dessus
ligne 82 : a = SerialSensorMux ("COM8") # Ce COMx DOIT correspondre à un canal Arduino spécifique.
ligne 85 : a.setName ("script SerialSensorMux8") # Attribuez-lui un nom unique afin d'éviter toute confusion.

Pour une raison interne au logiciel, on ne peut pas utiliser export8, export9, etc. Ceux-ci doivent se terminer par un caractère alphabétique et non par un nombre, comme exporta, exportb, exportc, …

 


2ème Partie - Communications JMRI vers Arduino

D’après l’article : What This Is All About : Getting Lots of Bits Out of JMRI

Nous allons maintenant aborder la fonction symétrique de la précédente : Envoyer de nombreuses données ou commandes de JMRI vers Arduino.

JMRI est capable de surveiller les trains et les voies comme on l’a vu dans la première partie, mais aussi de mettre en place des systèmes de commande et de signalisation pour pratiquement tous les réseaux. Parmi ces éléments de commande de base, les aiguillages sont vus comme un commutateur binaire.

Cette partie de l’article détaille l’implémentation d’un canal ou groupe de données JMRI, qui transmet des données du tableau d’aiguillages JMRI en bloc et de manière incrémentielle au fur et à mesure des modifications apportées au cours des opérations.

Cela donne au modéliste la possibilité de connecter (par canal) environ 68 commandes d’aiguillages aux broches numériques d’un Arduino Mega (18 pour un Uno, Nano ou Mini), et c’est entièrement opérationnel avec toutes les applications JMRI. Plusieurs canaux peuvent fonctionner simultanément et ne dépendent d’aucune station de base ou centrale DCC.

Ce n’est pas un tutoriel sur les subtilités de JMRI. Il s’agit d’un projet facile à construire où vous pouvez faire correspondre de nombreux commutateurs JMRI internes avec des dispositifs réels (voyants, écrans de contrôle, moteurs, servos, signaux, etc.) à faible coût.

De quoi s’agit-il : Obtenir beaucoup de commandes en sortie de JMRI

Certaines des applications de JMRI doivent initier des commutations d’aiguillages, mais plus encore. Elles peuvent allumer une lumière ou un moteur ou une animation. Elles peuvent associer le temps d’une horloge rapide pour séquencer les lumières de la ville et des bâtiments. Elles peuvent allumer des témoins à distance, sur un TCO, pour indiquer la position du train dans un canton. Ces données ou informations doivent sortir de JMRI pour être utilisées. Cet article décrit un mécanisme pour y parvenir.

Nous allons nous concentrer sur le tableau d’aiguillages dans JMRI car il représente généralement les sorties sur deux états : direct ou dévié.

Nous allons prendre jusqu’à 68 entrées du tableau à la fois et les connecter aux 68 broches d’un Arduino Mega 2560. Dès lors s’offre à vous une multitude de possibilités de contrôle et d’affichage. L’Arduino initialisera automatiquement tous les aiguillages que vous avez configuré lors de la connexion à JMRI. La connexion matérielle peut être faite avec la plupart des cartes Arduino du commerce (non modifiées). L’Arduino Mega 2560 supportera jusqu’à 68 aiguillages, un Arduino Uno, Pro Mini ou Nano supportera jusqu’à 18 sorties.

Ceux-ci se connecteront via n’importe quel port USB à votre ordinateur exécutant JMRI. Ce sera le même port série USB que vous utilisez pour charger la carte Arduino. Un script , Turnout_Table_Build.py, est inclus et doit être exécuté dans JMRI pour configurer le tableau d’aiguillage avec la convention de dénomination appropriée pour ces canaux.

Les scripts JMRI et les sketchs Arduino peuvent être téléchargés ici :
scripts et sketchs. La version 1.1 est la version actuelle.

Code "jmriturnoutchannels1_1"

Détails de construction

Cette carte de sortie d’aiguillages est construite avec un Arduino Mega 2560 et éventuellement avec un Mega Sensor shield, ou une carte Arduino Mega 2560 Strong, comme présenté plus haut.

Le Mega Sensor Shield se connecte sur la carte Arduino Mega 2560. Il est doté de deux bornes à vis permettant de brancher une alimentation de 5V pour alimenter l’ensemble. Cette carte facilite la connexion de vos appareils. Chaque broche de signal (S) correspondante est numérotée sur la carte de 2 à 53, puis de A0 à A15. Ceux-ci correspondront directement aux numéros d’aiguillages dans le tableau JMRI. Les broches 0 et 1 sont réservées pour la communication USB et ne sont donc pas utilisées. Chaque connexion numérotée sur le shield fournit un groupe de 3 broches avec la connexion de signal (S), une broche +5V (V) et une masse (connexion côté négatif G).

L’Arduino Mega 2560 utilisera les 68 broches comme sorties numériques. Un Arduino Uno et un Nano auront 18 broches disponibles (broches numériques 2-13 et A0-A5 pour les sorties. Il existe deux types de sketchs préconfigurés pour un Mega ou pour un Uno/Nano/Mini. Les deux sketchs supposent que toutes les broches sont configurées en tant que sorties et correspondent aux noms d’aiguillage définis par l’utilisateur JMRI de AT2-AT69 ou AT2-AT19. La désignation AT est complètement arbitraire, mais si vous souhaitez la modifier, vous devrez éditer le script JMRI TurnoutDataTransfer.py fourni.

Lorsque vous téléchargez le sketch Arduino sur votre carte, vous devez noter le port série de votre ordinateur utilisé pour la communication entre l’IDE Arduino et votre carte. Vous devez toujours brancher votre câble USB Arduino sur le même port / prise USB afin que votre système d’exploitation puisse attribuer le même port USB. Si vos ordinateurs changent, il est probable que le numéro de port USB soit différent. Cela est important car vous devez vous assurer que le script Python JMRI TurnoutDataTransfer.py est modifié ligne 17 : portname = "COM5" avec le numéro de port COM correct. Ou sur Macintosh : /dev/cu.usbmodemFA1211 par exemple.

Téléchargez le sketch Arduino sur votre carte, fixez un shield de capteur si nécessaire et laissez la carte connectée à votre ordinateur sur lequel vous exécuterez JMRI.

Configuration du tableau d’aiguillages JMRI

Vous avez quelques options pour configurer votre tableau d’aiguillages pour le transfert de données vers votre Arduino. Le script de transfert JMRI qui communiquera avec votre Arduino recherchera un ensemble de noms d’utilisateurs dans votre tableau d’aiguillages configurés en tant que AT2 - AT69, ou moins si vous le souhaitez. Donc, si vous avez déjà des entrées dans votre tableau déjà configurées et que vous ne leur avez pas donné de noms d’utilisateur, vous pouvez éditer chaque entrée et les ajouter dans l’ordre, comme AT2, AT3, AT4, etc…. ou vous pouvez utiliser le script inclus dans la liste. Fichier zip appelé : Turnout_Table_Build.py qui ressemble à ceci :

  1. import jarray
  2. import jmri
  3. import java
  4. import purejavacomm
  5.  
  6. # Define a turnout
  7. def DataSet(sname, uname) :
  8.     t = turnouts.newTurnout(sname, uname)
  9.     t.setState(THROWN)
  10. # Create a list of turnouts
  11. first_turnout = 2
  12. last_turnout  = 69
  13. for x in range(first_turnout, last_turnout+1) :
  14.     ssname = "IT"+str(x)
  15.     uuname = "AT"+str(x)
  16.     DataSet(ssname,uuname)

Et vous obtenez ce résultat :

Vous pouvez remplacer first_turnout et last_turnout par la plage que vous souhaitez. N’oubliez pas que l’Arduino Mega 2560 peut en prendre en charge 68 et les Uno, Nano, jusqu’à 18. À l’aide du préfixe du nom de système, le système les configurera comme des aiguillages référencés en interne (et non une adresse matérielle). Ce script est plus facile à utiliser que l’ajout manuel dans le tableau d’aiguillages. Une fois les entrées correctes, pensez à enregistrer votre panneau en utilisant Panneaux ➔ Sauvegarder les panneaux…, puis nommez-le et enregistrez-le pour plus tard.

Localisez l’endroit où vous avez décompressé le fichier TurnoutDataTransfer.py que vous avez modifié avec le port COM approprié. Copiez-le au passage dans le dossier des scripts PanelPro / Jython comme expliqué plus haut.

Dans le menu JMRI, allez à Panneaux ➔ Exécuter Script et sélectionnez votre fichier TurnoutDataTransfer.py. Exécutez le script et vous devriez voir tous vos aiguillages passer de Inconnu à Closed. Si vous ne voulez pas que les aiguillages soient initialisés au démarrage, supprimez simplement la ligne 44 du script TurnoutDataTransfer.py : turnout.setCommandedState (CLOSED)

Options dans les sketchs Arduino

Ces commentaires (indiqués également dans les sketchs Arduino, mais en anglais pour respecter le travail de l’auteur) décrivent quelques options supplémentaires pour vous :

Le sketch est préconfiguré pour un Arduino Mega 2560, broches 2 à 69, sans inversion ni décalage. La transmission est de la forme ATxxx.S où :

  • AT est le préfixe du nom d’utilisateur provenant du tableau d’aiguillage JMRI.
  • xxx est le numéro d’aiguillage (le nom d’utilisateur est construit sous la forme AT123), et
  • S est l’état de l’aiguillage où Closed ou Dévié = 0 et Thrown ou Droit = 1. La transmission est reçue de JMRI via le script Python : TurnoutDataTransfer.py. On suppose que l’Arduino démarre avant le script Python. Le script configurera les « écouteurs » pour tous ses aiguillages et ne les mettra à jour que lorsqu’ils changeront. L’Arduino mettra à jour la broche appropriée, qui peut avoir un décalage et être inversée. Le port série attribué à cet Arduino doit correspondre au port série du script TurnoutDataTransfer.py correspondant.
  1. #define Data_Pin_Max 70 // N ° maximum de la broche du capteur (plus une) Mega = 70, Uno, Pro Mini, Nano = 20
  2. #define Data_Pin_Start 2 // Nombre de broches de capteur de départ (généralement 2 car 0/1: TX / RX)
  3. #define Data_Pin_Offset 0 // Ce décalage sera ajouté à la valeur de chaque numéro d'aiguillage pour déterminer le code de données
  4. // numéro utilisé par l'Arduino, donc la broche AT12 définira la broche 12 + Data_Offset)
  5. // Ceci permettrait à un canal de données Arduino Turnout d’utiliser les broches 2-69 de l’attribut AT2-69 et à un autre
  6. // utilise AT70-137 pour définir ses broches 2-69 par exemple; ce décalage peut aussi être négatif
  7. #define Data_Invert 0 // Définissez Data_Active_Low sur 1 pour inverser incomin. Données d'aiguillage Closed = 1 Thrown = 0
  8. // Définissez Data_Active_Low sur 0 pour ne pas toucher aux données entrantes. Closed = 0 Thrown = 1

Derniers commentaires

Ne vous focalisez pas sur le terme Aiguillage (Turnout) !! C’est un retour aux premiers jours de DCC et à sa terminologie. Il s’agit simplement en fait d’un commutateur. MAIS, avec l’alimentation et les connexions internes à JMRI, ceux-ci peuvent être liés et contrôlés par beaucoup d’autres choses. Commencez donc simplement par les considérer comme un commutateur.

Les modélistes qui connaissent bien les Arduino se rendront vite compte que si vous pouvez définir un seul bit de sortie sur un Arduino, vous pouvez faire beaucoup plus que simplement l’activer ou le désactiver. Il devrait être possible de surcharger le Mega 2560 avec un peu plus de code, et par exemple, utiliser les bits d’aiguillages pour déplacer des servos. Notamment pour des mouvements lents à l’aide de la bibliothèque SlowMotionServo décrite dans l’article « La bibliothèque SlowMotionServo ».

Il convient également de noter, en raison de l’élégance avec laquelle JMRI est construit, que vous devriez également pouvoir extraire des informations d’autres tableaux (comme des lumières ou les signaux) dans JMRI. Chaque canal de sortie vers un Arduino doit être unique, mais cela ne devrait pas être une limitation avec les hubs USB et les ports série USB.

Pour exécuter plusieurs canaux (groupes) de capteurs, vous devez rendre chaque script TurnoutDataTransfer.py indépendant l’un de l’autre.

Vous devrez éditer et copier chaque script pour chaque port COM et modifier les lignes suivantes :

ligne 16 : global extportin # le nom extportin doit être unique pour chaque port de communication
ligne 17 : portname = "COM8" # COMx DOIT être identique au port Arduino correspondant
ligne 22 : port = extportin # comme ci-dessus
ligne 23 : extportin = port # comme ci-dessus

Là encorei, on ne peut pas utiliser exportin8, exportin9, etc. Ceux-ci doivent se terminer par un caractère alphabétique et non par un nombre, comme exportina, exportinb, exportinc, …

Cet article vous permet donc d’établir une connexion entre des données de JMRI et des broches d’un ou plusieurs Arduino, dans les 2 sens. Cela suppose que vous avez prévu de connecter directement vos équipements (capteurs et/ou actionneurs) sur un ou plusieurs Arduino Mega (ou Uno/Nano/Mini).

Dans un prochain article nous vous présenterons une manière de déporter les broches de lecture de détecteurs ou de sortie vers des actionneurs, via un bus CAN, sans changer la configuration et les réglages de JMRI !

Pour exploiter les nombreuses possibilités de JMRI et approfondir les notions rapidement survolées par cet article, rendez vous dans sa documentation en ligne.

15 Messages

Réagissez à « Communications entre JMRI et Arduino »

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 »

Un chenillard de DEL

Enseigne de magasin

Feux tricolores

Multi-animations lumineuses

L’Arduino et le système de commande numérique DCC

Un décodeur d’accessoire DCC versatile basé sur Arduino

Un moniteur de signaux DCC

Une barrière infrarouge

Un capteur RFID

Un TCO xpressnet

Une animation sonore

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Un décodeur DCC pour 16 feux tricolores

Calcul de la vitesse d’un train miniature avec l’Arduino

La génèse d’un réseau 100% Arduino

Une horloge à échelle H0

Simulateur de soudure à arc

Un automatisme de Passage à Niveau

La rétro-signalisation sur Arduino

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

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

Etude d’un passage à niveau universel

Réalisation pratique d’un système de mesure de vitesse à l’échelle N

Une Passerelle entre le bus S88 et le bus CAN pour la rétro signalisation

Un décodeur DCC pour 16 feux tricolores

Block Automatique Lumineux avec la carte shield "Arduino 4 relays"

Réalisation d’un affichage de gare ARRIVEE DEPART

Ménage à trois (Ordinateur, Arduino, réseau)

Realisation d’un va-et-vient automatique et réaliste

Souris et centrale sans fil

Communications entre JMRI et Arduino

Annonces en gare avec la RFID

Comment piloter trains et accessoires en DCC avec un Arduino (1)

Comment piloter trains et accessoires en DCC avec un Arduino (2)

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Comment piloter trains et accessoires en DCC avec un Arduino (4)

SGDD : Système de Gestion DD (1)

SGDD : Système de Gestion DD (2)

SGDD : Système de Gestion DD (3)

La PWM : Qu’est-ce que c’est ? (1)

La PWM : Qu’est-ce que c’est ? (2)

La PWM : Qu’est ce que c’est ? (3)

La PWM : Qu’est ce que c’est ? (4)

Mise en oeuvre du Bus CAN entre modules Arduino (1)

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Un gestionnaire en C++ pour votre réseau (1)

Un gestionnaire en C++ pour votre réseau (2)

Un gestionnaire en C++ pour votre réseau (3)

Un gestionnaire en C++ pour votre réseau (4)

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

Réalisation de centrales DCC avec le logiciel libre DCC++ (2)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Contrôleur à télécommande infrarouge pour centrale DCC++

Gestion d’une gare cachée (1)

Gestion d’une gare cachée (2)

Gestion d’une gare cachée (3)

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

La carte Satellite V1

Les derniers articles

Annonces en gare avec la RFID


bobyAndCo, Catplus, Christian

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

La carte Satellite V1


bobyAndCo, Dominique, Jean-Luc, Thierry

Communications entre JMRI et Arduino


Dominique, Nopxor

Souris et centrale sans fil


tony04

Realisation d’un va-et-vient automatique et réaliste


Dominique

Ménage à trois (Ordinateur, Arduino, réseau)


Christian

La PWM : Qu’est ce que c’est ? (4)


Jean-Luc

Les articles les plus lus

La PWM : Qu’est-ce que c’est ? (1)

Feux tricolores

Comment piloter trains et accessoires en DCC avec un Arduino (3)

Réalisation de centrales DCC avec le logiciel libre DCC++ (3)

Un chenillard de DEL

Une barrière infrarouge

Réalisation de centrales DCC avec le logiciel libre DCC++ (1)

L’Arduino au coeur des systèmes de pilotage analogiques ou numériques

Mise en oeuvre du Bus CAN entre modules Arduino (2)

Calcul de la vitesse d’un train miniature avec l’Arduino