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 :
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
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 : a = SerialSensorMux ("COM5")
Sur Macintosh : 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 : #define Sensors_Active_Low 1
par : #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.
#define Sensor_Pin_Max 70 // Max sensor pin NUMBER (plus one) Mega=70,Uno,Pro Mini,Nano=20
#define Sensor_Pin_Start 2 // Starting Sensor Pin number (usually 2 as 0/1 are TX/RX
#define Sensor_Offset 0 // This Offset will be ADDED to the value of each Sensor_Pin to determine the sensor
// number sent to JMRI, so pin D12 will set sensor AR:(12+Sensor_Offset) in JMRI
// This would allow one Arduino Sensor channel to set sensors 2-69 and another to
// Set sensors 70-137 for example; this offset can also be negative
#define Sensors_Active_Low 1 // Set Sensors_Active_Low to 1 if sensors are active LOW
// Set Sensors_Active_Low to 0 if sensors are active HIGH
#define open_delay 15 // longer delay to get past script initialization
#define delta_delay 4 // Short delay to allow the script to get all the characters
int i;
char sensor_state [70]; // up to 70 sensors on a Mega 2560
char new_sensor_state ; // temp to process the possible state change
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.
void setup(){
Serial.begin(19200); // Open serial connection.
while (Serial.available() == 0); // wait until we get a charater from JMRI
incomingByte=Serial.read(); // get the first character
while ((Serial.available() > 0) && (incomingByte != '!')) incomingByte=Serial.read(); //get past !!!
while ((Serial.available() > 0) ) incomingByte=Serial.read(); //flush anything else
delay(open_delay); // take a breath
for ( i=Sensor_Pin_Start; i<Sensor_Pin_Max; i++) { //Initialize all sensors in JMRI and grab each sensor
pinMode(i, INPUT_PULLUP); // define each sensor pin as coming in
sensor_state[i] = (digitalRead( i ))^Sensors_Active_Low; // read & save each sensor state & invert if necessary
Serial.print("A"); Serial.print (char((sensor_state[i]<<7)+i+Sensor_Offset)); // send "A <on/off><snesor #>" to JMRI script
delay(delta_delay); // in milliseconds, take a short breath as not to overwhelm JMRI's seraial read
}
}
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.
void loop() {
for ( i=Sensor_Pin_Start; i<Sensor_Pin_Max; i++) { // scan every sensor over and over for any sensor changes
new_sensor_state = (digitalRead( i ))^Sensors_Active_Low; // read & save each sensor state & invert if necessary
if (new_sensor_state != sensor_state[i] ) { // check if the sensor changed -> if yes update JMRI
Serial.print("A"); Serial.print (char((new_sensor_state<<7)+i+Sensor_Offset)); // send "A <on/off><snesor #>" to JMRI script
sensor_state[i] = new_sensor_state ; // save the updated sensor state
delay(delta_delay); // in milliseconds, take a short breath as not to overwhelm JMRI's seraial read
}
}
}
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 :
Redémarrer l’Arduino en appuyant sur le bouton reset
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, ...
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 :
import jarray
import jmri
import java
import purejavacomm
# Define a turnout
def DataSet(sname, uname) :
t = turnouts.newTurnout(sname, uname)
t.setState(THROWN)
# Create a list of turnouts
first_turnout = 2
last_turnout = 69
for x in range(first_turnout, last_turnout+1) :
ssname = "IT"+str(x)
uuname = "AT"+str(x)
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.
#define Data_Pin_Max 70 // N ° maximum de la broche du capteur (plus une) Mega = 70, Uno, Pro Mini, Nano = 20
#define Data_Pin_Start 2 // Nombre de broches de capteur de départ (généralement 2 car 0/1: TX / RX)
#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
// numéro utilisé par l'Arduino, donc la broche AT12 définira la broche 12 + Data_Offset)
// Ceci permettrait à un canal de données Arduino Turnout d’utiliser les broches 2-69 de l’attribut AT2-69 et à un autre
// utilise AT70-137 pour définir ses broches 2-69 par exemple; ce décalage peut aussi être négatif
#define Data_Invert 0 // Définissez Data_Active_Low sur 1 pour inverser incomin. Données d'aiguillage Closed = 1 Thrown = 0
// 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.
Bel article. Mais déjà très (trop) avancé dans l’utilisation de JMRI. Je pense que pour manipuler JMRI à ce niveau il faut déjà être passé par quelques heures à comprendre le fonctionnement de JMRI. Et peut-être commencer par des liens plus "simples" entre JMRI et Arduino.
Pour déterminer la chose je suis passé par du code beaucoup plus simpliste, trouvé sur le site de l’UAICF 58 Nevers. Les aiguilles / itinéraires sont plus simples à paramétrer. Mais ce n’est que pour débuter je le rappelle.
Sinon " via un bus CAN, sans changer la configuration et les réglages de JMRI !" voui évidemment car JMRI cause CAN couramment ;-)
JMRI ne voit que l’Arduino auquel il est connecté par l’USB. C’est Arduino (A) joue le rôle de proxy. Il est relié en CAN a un ensemble d’Arduino (E) distribués sur le réseau. C’est sur ces Arduino que sont implantés les capteurs et/ou les actionneurs. L’Arduino (A) maintient un état des capteurs (lus par JMRI) et un état des actionneurs (écrits par JMRI). Il communique à intervalles réguliers avec les Arduino (E) pour synchroniser les capteurs : les états des capteurs de (E) sont reçus par (A) et mis à disposition de JMRI. Il communique également à intervalles réguliers pour synchroniser les actionneurs. Les états des actionneurs de (A) reçus de JMRI sont diffusés à (E). Rien de plus compliqué. JMRI ne sait pas qu’il y a un système distribué relié par CAN.
JMRI fournit les fonctions Capteur et Aiguillage, une fois configuré pour OpenLCB ou CBUS "Events".
JMRI peut connecter aus réseaux CAN de différentes façons :
Via USB
C’est comme dans l’article (je pense).
Réseau TCP/IP
Il est également possible de joindre via une connexion TCP/IP (Ethernet ou WiFi). Cela peut aller dans un autre séquence JMRI en cours d’exécution ex : un hub OpenLCB, ou directement à un adaptateur IP-CAN.
On verra cela peut-être plus tard.
Avec l’Arduino proxy cité par Jean-Luc, on ouvre une porte vers des choses interessantes que nous préparons par ailleurs. Stay tuned !
Alimenter directement sur la broche 5V engendre plusieurs problèmes :
1 - vous ne pouvez pas in-situ alimenter et charger un nouveau soft par l’USB sauf si vous avez inséré une diode de protection ...
J’ai grillé quelques Arduino, souvent dans cette configuration (un Arduino en alimente un autre p.e.) mais ce n’était peut-être pas lié.
D’où la question, y a t il des précautions à prendre dans cette configuration où potentiellement on alimente les capteurs par l’Arduino ?
En tout cas au moins une, qui est de ne pas dépasser la limite thermique du régulateur intégré à la carte de l’Arduino si on l’alimente via le VIN.
Sur le shield, il y a un pont PWR_SEL qui permet de séparer l’alimentation des capteurs de celle de l’Arduino, solution certainement à recommander si on a un grand nombre de capteurs.
J’ai constaté par mesure ohmmètre que si le shield entièrement enfoncé sur ses broches, les points de soudure des picots d’alimentation du shield touchent le connecteur métallique USB. cela crée un court circuit qui grille les résistances derrière le connecteur. Je mets depuis soit une cale plastique soit un gros scotch épais double face pour éviter ce problème.
Sur un site anglais ou américain le défaut est d’ailleurs signalé.
Je n’ai pas trouvé le schéma électrique de ce shield. Mais la sérigraphie VCC - GND du bornier d’alimentation semble effectivement indiquer que l’Arduino est alimenté via le 5V. Évidemment il serait préférable que ce sensor shield embarque un régulateur 5V et prenne sont entrée d’alimentation sur VIN. Je recommanderais effectivement d’enlever le jumper situé à côté du bornier d’alimentation.
Concernant la traduction française de JMRI, qui est effectivement incomplète, je rappelle que JMRI est un logiciel libre (aux sens ’Open Source’) et gratuit dont les développeurs sont tous bénévoles. S’il y a un noyau dur de bénévoles qui poussent du code de façon quotidienne, il y a également quelques occasionnels comme moi-même qui apportent des contributions de temps en temps.
J’ai ainsi complété la traduction française sur plusieurs fonctionnalités ces derniers jours (ce sera pour la prochaine version), mais il reste encore pas mal de travail. Tout le monde peut contribuer ; pour la traduction, ce n’est pas très compliqué, mais il faut installer l’environnement de développement sur son ordinateur - tout est expliqué sur le site.
Avis aux amateurs !
Il est également possible de faire part de vos commentaires, questions et requêtes (de traduction ou fonctionnalités) sur la liste de discussion des utilisateurs JMRI (en anglais cependant).
Pour réagir à la première remarque sur cet article, il me semble que l’objectif de ce site n’est pas de parler de JMRI mais bien de l’utilisation de l’Arduino. L’article renvoie aux bonnes références sur JMRI dans l’introduction. C’est peut-être avancé par rapport à d’autres d’article du site, mais il en faut pour tous.
Excellente initiative d’avoir traduit les articles de Geoff Bunza. Pour ceux que l’anglais ne rebute pas, il a publié énormément d’articles et de programmes Arduino pour notre loisir. A découvrir sur MRH.
je suis en train d’essayer les solutions de communication entre arduino et jmri, je patine un peu mais je devrais pouvoir m’en sortir même à 68 ans. Concernant JMRi je rejoint Alain, j’ai assuré un grosse partie de la traduction, c’est un travail énorme que je continue, s’il y a d’autres volontaire pas de problème
Bonsoir,
Vous pouvez passer JMRI en français.
j’ai trouvé dans décodeur pro / préférence/ Display/ Locale affichage un menu langue avec le choix du français.
cela marche bien.
La version 4.17.4 est une version test. Est-elle traduite ?
La version de production est la 4.16.
Ayant JMRI 4.10 en français, sans me souvenir l’avoir configuré (pas trouvé dans les préférences), je me demande si c’est lié à la version de Java. Elle est indiquée dans la fenêtre de PanelPro.
Dominique, bonjour,
J’ai réalisé une centrale en utilisant votre article et ceux rattachés à l’utilisation de JMRI / DCC++ etc.
Je me suis appuyé sur vos scripts Python et sketch auduino
un module pour gérer le retour de la présence des trains via une Arduino Mega et des détecteurs de consommation de courant via des optocoupleurs
Le sketck Arduino intègre un filtre numérique
un module pour piloter 8 aiguillages via une Arduino Uno avec le pilotage des aiguillages construit sur des ULN2803A
Comme vous l’indiquiez dans votre article, je souhaiterais gérer les feux de signalisation en utilisant un processus identique à la gestion des aiguillages, soit lire le tableau "feux de signalisation"
J’aurais besoin de votre aide ou des pistes sur la modification du programme correspondant en python
En parallèle, ne sachant pas mettre des pièces jointes dans ce texte, je les ajoute à un article que j’ai ouvert dans le forum
merci
luc
Luc, cet article est un point de départ pour communiquer entre JMRI et Arduino.
Votre question va plus loin et sort du cadre de cet article. Rejoignez le forum où un dossier est consacré à JMRI. J’y ai déplacé votre question. Les experts JMRI (que je ne suis pas encore) vous répondront probablement.
Bonjour, je suis conquis par le projet DCC Arduino pour piloter mon réseau. Je rencontre un petit soucis pour faire fonctionner ma carte Mega : elle se connecte bien au soft JMRI, il m’indique qu’elle est connectée sur le port com4. J’ai bien modifié le port(dans Notepad++) avant de lancer le script dans JMRI mais mes capteur reste ’inconnu’ ? J’ai essayé dans l’autre sens (aiguillage), çà fait pareil.Je sèche un peu, j’ai essayé via un autre port et même un autre pc. Merci de m’éclairer SVP.
Bonjour Dominique. Merci pour cet excellent article. Je suis membre de l’AMFL et nous sommes en train de moderniser notre réseau N. Comme ce réseau est modulaire, la spécialisation des arduinos pour les entrées et sorties ne sera pas applicable. Nous souhaiterions plutôt avoir sous chaque module un arduino multi-fonctions qui gère à la fois les entrées et les sorties et intègre la logique de traitement des commandes (sorties). Est-ce faisable ? Merci de votre attention.
Merci de votre réponse Dominique. J’avais déjà pris connaissance de cet article, mais à mon avis cette solution ne peut être mise entre les mains d’un club dont 95 % des membres maîtrisent à peine les notions d’électricité. Son architecture est parfaite mais il faut une mise en œuvre plus simple.
Nous voulons simplement faire ce que vous avez décrit dans votre réponse ci-dessus commençant par ’Homme de peu de foi !’. Donc, dans mon esprit, il s’agit seulement d’intégrer les deux sketches de Geoff Bunza dans un même Arduino en limitant les tableaux d’aiguillages et de capteurs aux tricts besoins locaux... Comme je ne suis pas un expert programmation Arduino, ma question était : peut-on le faire ?
Bonne fin de journée.
Je vous donne la même réponse que j’ai donnée précédemment : Le forum de l’article n’est pas le meilleur endroit pour entrer dans les détails de JMRI. Merci de poser votre question sur le forum http://forum.locoduino.org/index.ph.... Il y a des utilisateurs expérimentés de JMRI !
J’hésitais à vous relancer Dominique, je ne voulais pas abuser, mais ma question (je me suis peut-être mal exprimé) ne concernait pas JMRI que je connais sur le bout des doigts, l’utilisant depuis près de dix ans avec CMRI, mais bien Arduino... Vais-je devoir utiliser deux arduinos par module, un pour les entrées et un pour les sorties avec deux ports USB et deux réseaux Can, où puis-je fusionner la recette de Geoff Bunza dans un arduino pour les entrées et sorties de chaque module sur un réseau unifié ? Je cherche à faire de façon plus économique ce que l’on pourrait faire très facilement avec des Smini CMRI distribués reliés par un réseau RS485...
Bonjour à vous,
Novice dans JMRI je m’essaye à sa mise en oeuvre à partir de votre excellent article "Communications entre JMRI et Arduino", section Aiguillage. Tout marche très bien pour la création du tableau d’aiguillages, mais le script TurnoutDataTransfer.py ne s’exécute pas correctement : je retrouve dans le log session de JMRI l’information suivante :
"
Caused by : Traceback (most recent call last) :
File "
<script>", line 22, in <module>
NameError : global name ’extportin’ is not defined
"
La ligne 22 correspond bien au source du script TurnoutDataTransfer.py
J’utilise les dernières versions de JMRI et de java à savoir : PanelPro 4.18+R37ad3d0
et Java version 1.8.0_231(en).
<p>Pourriez vous m’aider !</p>
Le forum de l’article n’est pas le meilleur endroit pour entrer dans les détails de JMRI. Merci de poser votre question sur le forum http://forum.locoduino.org/index.ph...
Cela fait deux mois que je galère avec les routines en Jython à partir de celles de Geoff Bunza, puis, en revenant sur le site de JMRI, sous la rubrique Connexion avec Arduino, j’ai trouvé la possibilité de simuler une connexion CMRI à travars un lien USB. Il s’agit seulement de charger un simulateur CMRI dans l’Arduino de commande ou de tête de réseau ! Le principe de CMRI est simple : on envoie une adresse à partir de la table des lumières avec un bit on ou off et on reçoit une adresse de la table des censeurs avec un bit on ou off. En simulant une Susic on a accès à 2048 adresses (et beaucoup plus si on utilise plusieurs nœuds)... C’est simple, c’est direct ! Sur le réseau N de l’AMFL, on a besoin d’environ 500 adresses pour les occupations, la rétro des aiguillages, la commande des aiguillages, la commande des relais pour les sources d’alimentation (Dcc + trois sources analogiques), la signalisation et l’info sur les manettes de commande des trains en analogique.
Relaxez, ça marche...
Merci Jean-Pierre,
Voilà un exemple concret de réalisation qui serait le bienvenu sur le Forum Locoduino (un sujet à créer comme : "Le réseau N de l’AMFL, un exemple de gestion de réseau avec JMRI et C/MRI sur Arduino" dans la rubrique JMRI et Arduino. Ce serait une manière de présenter les nombreux éléments du réseau N de l’AMFL et surtout comment les ingrédients sont asociés dans l’Arduino, les périphériques et les communications. Pour finir : quelques écrans de pilotage sur JMRI pour voir ce que ça donne (et envie d’aller voir ce réseau à Lyon (voir lien). Promis, j’y passerai à l’un de mes prochains passages à Lyon.
Quelle bibliothèque as-tu utilisé ?
La connexion avec l’Arduino passe-t-elle par du RS485 ?
N’hésites pas à me demander de l’aide pour ce fil du forum ;).
Merci Dominque. Tu seras certainement le bienvenu à l’AMFL lors de ton prochain passage à Lyon. Préviens-moi quelques jours d’avance pour que je m’assure que les principaux animateurs de notre solution soient présents.
La communication entre l’ordinateur et le réseau (CAN) d’arduinos se fait le plus simplement du monde à l’aide du connecteur USB de l’arduino de tête de réseau. Cet arduino utilise un simulateur CMRI créé par Michael D K Adams et que l’on peut télécharger, avec des exemples d’utilisation à l’adresse https://github.com/madleech/Arduino...
Nous avons encore un peu de travail à faire avant de publier nos résultats, mais nous pourrons faire cela au début de l’automne, je pense.
Bon été à tous les arduinistes...
Bonjour ;
Encore un article passionnant !
L’article annoncé à la fin (déport des cartes arduino sur un bus CAN) est-il paru ? Je ne le trouve pas...
Je l’attends avec impatience ! La boucle sera bouclée (JMRI -> DCC -> CAN -> signalisation -> rétro-signalisation -> CAN -> JMRI)
Cordialement
Claude
Certes, la carte satellite V1 permet de connecter SAM aux satellites via le bus CAN. Cependant, l’interface avec JMRI n’est pas abordé...
J’espérais avoir ce lien lorsque vous écriviez : "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 !"
Aujourd’hui, nous avons un lien entre JMRI et une carte Arduino (votre article), un lien entre des satellites et SAM via le bus CAN (article satellite V1), mais pas la chaine totale entre JMRI, SAM et des satellites.
Ceci dit, vos articles sont passionnants !
Merci pour vos compliments. Mais auriez-vous quelque chose à proposer, à partager et à discuter entre nous ?
Voir le forum : http://forum.locoduino.org/index.ph...
après avoir suivi les explications
cela ne fonctionne pas
dans le moniteur série j’ai bien s2rie de A
je suis sur le port 5
j’ai bien mes 68 capteur je lance le script scan
et rien ce passe
j’ ai rèinstaler jmri
et toujours rien
une idée ? par avance merci
Je crains que vous n’ayez pas été très loin dans le détail ... qui renvoie vers le forum, meilleur endroit pour bénéficier d’un dépannage. Voir sur le forum
il faut saisir "AR :" (je suis sous Windows), en ouvrant la console JMRI (Aide / Console système) j’obtenais des erreurs "AR:n NotAvailable" qui m’ont mis sur la voie...
Les coquilles :
1) Dans l’espace Nom d’utilisateur, mettez simplement AR ; // => AR :
2) Supprimez maintenant les entrées IS0 et IS1 AR:0 et AR:1, car nous ne les utiliserons pas. Vous devez maintenant avoir 68 capteurs dans le tableau avec les noms d’utilisateur IS2 à IS68 AR:2 à AR:68.
si ca peut aider a d’autres pour ne pas chercher d’ou vient un potentiel problème...sur un article que je trouve très utile, merci !
Bonsoir,
Je poursuis, grâce à vous,mon apprentissage sur JMRI et ma première centrale DCC. Je suis sur Macbook Pro OS Mojave.
Avec DecodeurPro pas de soucis les locomotives avancent.
Avec Panel pro, je dessine un réseau, avec aiguillages et capteurs et je crée des itinéraires.
Je voudrai maintenant rendre actifs les capteurs et envoyer des ordres depuis JMRI
Pour la partie deux de ce projet, cela fonctionne, mais je me heurte à un os sur la partie une.
J’ai recommencé une bonne dizaine de fois en désinstallant et réinstallant JMRI par sureté mais toujours le même résultat.
Dans les fichiers Sensor_Scan.py et SensorSerialClose.py je rentre l’adresse /dev/cu.wchusbserial1410 comme dans le fichier TurnoutDataTransfer.py
Je suis scrupuleusement l’ordre des commandes comme indiqué dans le mode opératoire
Mais quand le lance le script les capteurs restent à l’état inconnu.
Alors que dans le cas des aiguilles (deuxième partie) elles s’initialisent bien. J’arrive donc bien à lancer un script.
La console système semble pourtant dire que tout se passe bien à l’ouverture de panel pro, au chargement de la table, l’arduino et son shield clignote lorsque je lance le script ce qui semble confirmer qu’il y a bien communication entre JMRI et l’arduino.
Voici les dernières lignes de la console :
19:57:25,116 apps.PanelPro.PanelPro INFO - Main initialization done [main]
19:59:24,322 jmri.configurexml.LoadXmlConfigAction INFO - Loading selected file : /Users/Pierre/Library/Preferences/JMRI/Mon_Réseau_JMRI.jmri/Essai_Capteurs.xml [AWT-EventQueue-0]
19:59:34,524 jmri.jmrit.audio.JoalAudioFactory INFO - Initialised JOAL using OpenAL : vendor - OpenAL Community version - 1.1 ALSOFT 1.23.1 [Listed Table Generation]
Et voici les premières lignes quand le lance le script de cloture :
