Accès de Jython
Author: Bob Jacobsen
Keywords: JMRI technical code CVS FAQ

# Accès de Jython aux outils JMRI

Cette page parle de l'accès depuis Jython aux librairies JMRI, une version Java de Python. L'accent est mis sur l'utilisation des capacités de JMRI depuis une ligne de commmande d'un interprêteur Jython. cette page n'est pas sur les scripts avec Jython à l'intérieur de JMRI. Voir les pages de script Si vous êtes plus intéresser par les scripts Jython au sein de JMRI.

Notez que cette page est quelque peu dépassée; les numéro de version, etc peuvent ne plus être actuels

## Introduction

Python est un langage script couramment utilisé qui est disponible sur de nombreux types d'ordinateurs. Une version basée Java, appelée Jython, a été intégrée avec JMRI pour rendre la commande d'un réseau de chemin de fer aisée depuis les lignes de commandes de l'ordinateur.

Pour utiliser la bibliothèque JMRI à partir de Jython, vous devez vous assurer que Jython recherchera les fichiers jar corrects quand il démarre. Nous fournissons un script "jmrithon" de démarrage qui le fera pour vous. `% ./jmrithon execFileJython 2.1 on java1.4.1_01 (JIT: null) (Taper "copyright", "credits" ou "license" pour plus d'informations. >>>` Une fois obtenu l'invite Jython ">>>", vous pouvez taper des instructions Python.

Nous avons fourni quelques fichiers de commandes Python pour rendre plus facile le démarrage.

Par exemple, vous pouvez démarrer les applications PanelPro depuis des lignes de commandes Jython, qui sont ensuite disponibles pour la manipulation des objets comme les aiguillages et les capteurs:

    execfile("PanelPro.py")
         0 PanelPro.PanelPro                     INFO  - programme démarre [principal]
     11109 PanelPro.PanelPro                     INFO  - initialisation principale terminée [principal]

    >>> turnouts.newTurnout("LT1", "")
    jmri.jmrix.loconet.LnTurnout@1a8f49

    >>> turnouts.getTurnout("LT1").getCommandedState()
    1

    >>> lt1 = turnouts.getTurnout("LT1")

    >>> lt1.setCommandedState(CLOSED)

    >>> lt1.commandedState
    2

    >>> lt1.commandedState = CLOSED

    >>> lt1.commandedState
    4

    >>>

Notez que ceci exécute une version complète de l'application PanelPro; toutes les fenêtres et les menus sont présentés de la même façon, la configuration se fait par le panneau de préférences, etc. Ce que la connexion Jython ajoute est une ligne de commande à partir de laquelle vous pouvez manipuler directement les choses.
Cela montre aussi certaines des simplifications que Jython et le langage Python apportent à l'utilisation du code JMRI. La fonction de membre de Java:

    	turnout.setCommandedState(jmri.Turnout.CLOSED);

peut aussi être exprimée en Jython comme:

    	turnout.commandedState = CLOSED (Droit)

Ce résultats est dans un code plus facile à lire.

Il y beaucoup de livres Python utiles ainsi que des tutoriels en ligne. Pour plus d'informations sur le langage Jython et ces relations avec Java, la meilleure référence est le Jython Essentials livre publié par O'Reilly. Le site web jython.org est aussi très utile

## Installation

Le support Jython n'est pas (encore) standard dans JMRI. Pour utiliser ceci:

1. Vous devez avoir une installation JMRI utilisable. En particulier, démarrez l'application JMRI et la configurer pour se connecter à votre matériel de DCC, puis enregistrer, quitter et redémarrer le programme. Assurez-vous que le connexion fonctionne pour les menus basés sur les outils avant d'essayer d'utiliser Jython.
2. Télécharger et installer Jython depuis http://www.jython.org. Le développement utilise la version 2.1, donc vous pouvez commencer avec ceci. Sur Mac OS X, l'installateur ne s'exécute pas, vous devez donc appeler manuellement le fichier jython_21.class; voir la note Mac OS X sur le site web de Jython. Assurez-vous que l'installation est terminée en appelant Jython depuis la ligne de commande:

          % jython
          Jython 2.1 on java1.4.1_01 (JIT: null)
          Taper "copyright", "credits" ou "license" pour plus d'information".
          >>> ^D

   Si celui ci travaille, votre installation est OK. Si non, vous devez corriger votre système avant de pouvoir passer à l'étape suivante.

   Si l'installateur ne fonctionne pas, Téléchargez le fichier jython_21.class depuis SourceForge, et entrez à une invite de commande:

         java -cp . jython_21

   puis suivre les invites à travers l'installateur.

   Si le programme d'installation ne fonctionne pas, mais la commande jython n'est pas trouvée:

   - Windows: Trouver le fichier jython.bat que l'installateur a créé, et copiez-le dans votre répertoire C: \WINDOWS .
   - Linux: Assurez-vous que le répertoire d'installation de Jython est sur votre chemin.
3. Maintenant vous avez juste à avoir les classes nécessaires dans le CLASSPATH utilisé lorsque jython démarre. La liste imposée dans la syntaxe Unix est:

         setenv CLASSPATH .:jmri.jar:lib/log4j.jar:lib/collections.jar:lib/crimson.jar:lib/jdom-jdk11.jar

   Pour enregistrer la saisie, le script "jmrithon" est disponible pour une utilisation sur les systèmes Linux et Mac OS X:

         % ./jmrithon
         Jython 2.1 on java1.4.1_01 (JIT: null)
         Taper "copyright", "credits" ou "license" pour plus d'information
         >>> ^D

   La première fois que vous exécutez ceci, vous obtiendrez un certain nombre de messages sur "les traitement modifiées jar"; ceux-ci peuvent être ignorés, car ils sont normaux.

## Utilisation directe de Jython

Cette section de la page est un tas d'informations utiles sur le contrôle de JMRI depuis Jython directement.

Notez que vous n'avez pas plus besoin de ceci lors de l'exécution des scripts PanelPro.py ou similaire, car ils gèrent le démarrage d'une application complète.

### Initialisation

JMRI utilise largement le système LogJ pour des informations de rapport pendant l'exécution du programme. Pour configurer, lors de l'exécution avec Jython, vous devez faire:

      import org.apache.logging.log4j.core.config.Configurator
      Configurator.initialize(null, "default_lcf.xml");

avant de commencer l'une des classes JMRI. Le "default_lcf.xml" est le nom du fichier de contrôle connecté qui sera utilisé, il peut être omis.

Pour rendre les classes JMRI disponible, vous avez à faire:

      import jmri

Tel qu'il est actuellement configuré, celui-ci n'exécute pas n'importe quel code d'initialisation pour commencer les connexions matérielles, etc. Une façon de faire est de charger un fichier de configuration, peut-être un que vous avez créé précédemment via le panneau de préférences PanelPro:

      import java.io
      configfile = java.io.File(jmri.util.FileUtil.getPreferencesPath()+"PanelProConfig2.xml")
      jmri.InstanceManager.setConfigureManager(jmri.configurexml.ConfigXmlManager())
      jmri.InstanceManager.getDefault(jmri.ConfigureManager).load(configfile)

pour activer les classes JMRI et vous connecter à votre réseau. PanelProConfig2.xml "est le nom du fichier de configuration depuis le programme PanelPro; vous pouvez utiliser un autre nom si vous le souhaitez. Le fichier de configuration contrôle la connexion au réseau, et toute autre option qui peut avoir été mise quand il a été créé.

Alternativement, si vous voulez démarrer l'application PanelPro complète, y compris la barre de menu, l'écran d'accueil, etc, vous pouvez faire::

     import apps
     apps.PanelPro.PanelPro.main([])

Cela va démarrer le programme, y compris sa configuration de démarrage, etc

Pour simplifier ce démarrage encore plus, vous pouvez faire:

     execfile("PanelPro.py")

pour appeler ces commandes .

### Accès à JMRI

JMRI utilise beaucoup le modèle-usine pour obtenir l'accès aux objets. En Java il en résulte du code verbeux comme

       Turnout t2 = InstanceManager.turnoutManagerInstance().newTurnout("LT2", "turnout 2");
       t2.setCommandedState(Turnout.THROWN)(aiguillage DÉVIÉ)

Jython simplifie ceci, en nous permettant de fournir des variables utiles, et par le raccourcissement des appels à certaines méthodes.

Pour avoir accès à des gestionnaires de feux de signalisation, capteur et aiguillage et l'objet CommandStation, les variables de plusieurs raccourcis sont définies dans les scripts .py énumérés ci-dessus

- sensors
- signals
- turnouts
- lights
- reporters
- memories
- dcc
- audio

Celles-ci peuvent ensuite être référencées directement dans Jython comme

       t2 = turnouts.provideTurnout("12");

       dcc.

Notez que la variable t2 n'a pas besoin d'être déclarée.

Jython fournit un raccourci pour les paramètres qui ont été définis avec Java-Bean-like les méthodes get et set:

       t2.setCommandedState(Turnout.THROWN)(Dévié)

peuvent être écrites

       t2.commandedState = THROWN(Dévié)

ou l'affectation est en fait l'appel de la méthode définie.. Notez également que THROWN(Dévié) a été défini lors de l'exécution du script Python au démarrage; CLOSED(Direct), ACTIVE(Actif, INACTIVE(Inactif), RED, YELLOW et GREENVERT sont également défini.

Un mécanisme similaire peut être utilisé pour vérifier l'état de chose:

    >>> print sensors.provideSensor("3").knownState == ACTIVE
    1
    >>> print sensors.provideSensor("3").knownState == INACTIVE
    0

Notez que Jython utilise "1" pour indiquer vrai, et "0" pour indiquer faux, de sorte que le capteur 3 est actuellement actif dans cet exemple

Vous pouvez aussi appeler directement les méthodes, par exemple d'envoyer un paquet DCC vers les rails, vous tapez:

       dcc.sendPacket([0x01, 0x03, 0xbb], 4)

Cela envoie ce paquet de trois octets quatre fois, puis retourne à la ligne de commande.

Pour quitter, soit ^ C à partir de la ligne de commande ou utilisez la commande sortie dans le menu.

## Utilisation de Python pour signal logique et automatisation

Les classes "Automate" existantes de JMRI fournissent des crochets pour l'automatisation du réseau utilisateur, y compris la signalisation. Mais ils exigent que vous écriviez du code Java et de le compiler en fichiers .class.

## Etapes suivantes

Nous sommes seulement à apprendre comment intégrer au mieux JMRI et Python, donc il y a encore quelques mystères fondamentaux.

### Initialisation et modules

L'idée de "modules" Python n'est pas encore clairement compris. Il y a trois façons de démarrer le programme via un fichier .py:

1.           % ./jmrithon
             Jython 2.1 on java1.4.1_01 (JIT: null)
             Taper "copyright", "credits" ou "license" pour plus d'informations
             >>> import PanelPro

   Cela fonctionne, en ce sens que le programme démarre. Mais les méthodes commodes sont toutes dans le namespace PanelPro:

             >>> turnouts.newTurnout("LT1","")
             Traceback (innermost last):
               File "<console>", line 1, in ?
             NameError: turnouts

             >>> PanelPro.turnouts.newTurnout("LT1","")
             jmri.jmrix.loconet.LnTurnout@36b91b

   ce qui fait nettement plus à taper plus tard. Et il est déroutant, car selon que vous ayez commencé PanelPro, DecoderPro ou une autre application, les noms seront différents.

2.           % ./jmrithon
             >>>  execfile("PanelPro.py")

           % ./jmrithon -PanelPro.py

   Cela semble un peu moche, car ce n'est pas en utilisant les modules techniques normaux de Python. Mais les méthodes commodes sont dans le namespace de niveau supérieur:

             turnouts.newTurnout("LT1", "")

   Nous avons besoin de comprendre si c'est un vrai problème. La plupart des programmes Python n'utilisent pas cet namespace de haut niveau, et il y a probablement une bonne raison!

Nous avons besoin de comprendre comment les développeurs de Jython ont prévu de faire ceci.

### Résiliation

Une fois que la tâche principale JMRI (ou tâche Swing GUI ?) a commencée, ^ D ne suffit pas pour faire quitter le programme. Vous devez sélectionner "Quit" dans le menu fichier actuel, ou ^ C du programme.

Il serait bon de comprendre ce qui empêcher le programme d'arrêter quand il obtient l'^D.