path: root/docs/src/hal/pyvcp_examples_fr.txt

:lang: fr
:toc:

= Exemples d'utilisation de PyVCP

== Panneau PyVCP dans AXIS

Procédure pour créer un panneau PyVCP et l'utiliser, attaché dans la partie 
droite de l'interface AXIS.

 - Créer un fichier .xml contenant la description du panneau et le placer dans
   le répertoire de la configuration.
 - Ajouter une entrée, avec le nom du fichier .xml, dans la section [DISPLAY] 
   du fichier ini.
 - Ajouter une entrée POSTGUI_HALFILE, avec le nom du fichier postgui HAL.
 - Ajouter les liens vers les pins de HAL pour le panneau dans le fichier
   postgui.hal pour "connecter" le panneau PyVCP avec LinuxCNC.

== Panneaux flottants

Pour créer des panneaux flottants PyVCP pouvant être utilisés avec
n'importe quelle interface, suivre les points suivants:

 - Créer un fichier .xml contenant la description du panneau et le placer dans
   le répertoire de configuration.
 - Ajouter les lignes _loadusr_ dans le fichier.hal pour charger chaque panneau.
 - Ajouter les liens vers les pins de HAl du panneau dans le fichier postgui.hal,
   pour "connecter" les panneaux PyVCP à LinuxCNC.

L'exemple suivant montre le chargement de deux panneaux PyVCP.
----
loadusr -Wn btnpanel pyvcp -c btnpanel panel1.xml 
loadusr -Wn sppanel pyvcp -c sppanel panel2.xml
----

Les paramètres -Wn font que HAL **W**ait for **n**ame, attends le composant
nommé _btnpanel_. 

Les paramètres pyvcp -c font que PyVCP nomme le panneau.

Les pins de HAL de panel1.xml seront nommées _btnpanel.<pin name>_

Les pins de HAL de panel2.xml seront nommées _sppanel.<pin name>_

Bien s'assurer qu'aucune ligne _loadusr_ ne fasse déjà appel à une de ces pins
PyVCP.

== Boutons de Jog

Dans cet exemple nous allons créer un panneau PyVCP avec 3 boutons utilisables
pour déplacer en manuel les axes X, Y et Z. Cette configuration sera réalisée
avec l'assistant Stepconf qui générera la configuration de la machine.
Premièrement, nous lançons l'assistant Stepconf et le configurons pour la
machine, ensuite dans la page _Advanced Configuration Options_ nous effectuons
les sélections pour ajouter un panneau PyVCP vierge, comme indiqué sur l'image
suivante. Pour cet exemple nous avons nommé la configuration _pyvcp_xyz_ sur la
page _Basic Machine Information_ de l'assistant Stepconf.

.Assistant de configuration XYZ[[cap:XYZ-Wizard-Configuration]]

image::images/xyz_ACO.png[]

L'assistant Stepconf Wizard va créer plusieurs fichiers et les placer dans le
répertoire _/emc/configs/pyvcp_xyz_. Si la case _Créer un lien_ est cochée,
un lien vers ces fichiers sera créé sur le bureau.

=== Créer les Widgets

Ouvrir le fichier custompanel.xml par un clic droit sur son nom, puis en
sélectionnant _Ouvrir avec l'éditeur de texte_. Entre les balises
_<pyvcp>_ et _</pyvcp>_ nous ajouterons les widgets pour le panneau.

Tous les détails sur chacun des Widgets de PyVCP sont donnés dans la
<<sec:Documentation-des-widgets, documentation des widgets>>.

Dans le fichier custompanel.xml nous ajoutons la description des widgets.

[source,xml]
----
<pyvcp>

    <labelframe text="Boutons de Jog"> 
       <font>("Helvetica",16)</font>

        <!-- le bouton de jog de l'axe X --> 
        <hbox> 
            <relief>RAISED</relief> 
            <bd>3</bd> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"x-plus"</halpin> 
                <text>"X+"</text> 
            </button> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"x-moins"</halpin> 
                <text>"X-"</text> 
            </button> 
        </hbox>

        <!-- le bouton de jog de l'axe Y --> 
        <hbox> 
            <relief>RAISED</relief> 
            <bd>3</bd> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"y-plus"</halpin> 
                <text>"Y+"</text> 
            </button> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"y-moins"</halpin> 
                <text>"Y-"</text> 
            </button> 
        </hbox>

        <!-- le bouton de jog de l'axe Z --> 
        <hbox> 
            <relief>RAISED</relief> 
            <bd>3</bd> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"z-plus"</halpin> 
                <text>"Z+"</text> 
            </button> 
            <button> 
                <font>("Helvetica",20)</font> 
                <width>3</width> 
                <halpin>"z-moins"</halpin> 
                <text>"Z-"</text> 
            </button> 
        </hbox>

        <!-- le curseur de vitesse de jog --> 
        <vbox> 
            <relief>RAISED</relief> 
            <bd>3</bd> 
            <label> 
                <text>"Vitesse de Jog"</text> 
                <font>("Helvetica",16)</font> 
            </label> 
            <scale> 
                <font>("Helvetica",14)</font> 
                <halpin>"jog-speed"</halpin> 
                <resolution>1</resolution> 
                <orient>HORIZONTAL</orient> 
                <min_>0</min_> 
                <max_>80</max_> 
            </scale> 
        </vbox>
    </labelframe>
</pyvcp>
----

Après les ajouts précédents, nous avons un panneau PyVCP tel que celui
de l'image suivante, attaché à droite d'Axis. Il est beau mais ne fait rien tant
que les boutons ne sont pas "connectés" à halui. Si, à ce stade, une erreur se 
produit lors du déplacement de la fenêtre vers le bas, c'est généralement dû à 
une erreur de syntaxe ou d'écriture, elle est donc dans cette partie qu'il 
conviendra tout d'abord de vérifier soigneusement.

.Boutons de Jog[[cap:Jog-Buttons]]

image::images/xyz_buttons.png[]

=== Effectuer les connections

Pour effectuer les connections nécessaires, ouvrir le fichier custom_postgui.hal
et y ajouter le code suivant:

[source,c]
----
# connecte les boutons PyVCP pour X 
net my-jogxmoins halui.jog.0.minus <= pyvcp.x-moins 
net my-jogxplus halui.jog.0.plus <= pyvcp.x-plus

# connecte les boutons PyVCP pour Y
net my-jogymoins halui.jog.1.minus <= pyvcp.y-moins 
net my-jogyplus halui.jog.1.plus <= pyvcp.y-plus

# connecte les boutons PyVCP pour Z 
net my-jogzmoins halui.jog.2.minus <= pyvcp.z-moins 
net my-jogzplus halui.jog.2.plus <= pyvcp.z-plus

# connecte le curseur de vitesse de jog PyVCP  
net my-jogspeed halui.jog-speed <= pyvcp.jog-speed-f
----

Après avoir désactivé l'A/U (E-Stop) et activé la marche machine en mode Jog,
le déplacement du curseur du panneau PyVCP devrait agir dès qu'il est placé au 
delà de zéro et les boutons de jog devraient fonctionner. Il est impossible de 
jogger alors qu'un fichier G-code s'exécute ou pendant qu'il est en pause ni 
quand l'onglet _Données manuelles [F5]_ du (MDI), est ouvert.

== Testeur de port

Cet exemple montre comment faire un simple testeur de port parallèle en utilisant
PyVCP et HAL.

Premièrement, créer le fichier ptest.xml qui contiendra le code suivant pour créer
la description du panneau.

[source,xml]
----
<!-- Panneau de test pour la config. du port parallèle -->
<pyvcp>
  <hbox>
    <relief>RIDGE</relief>
    <bd>2</bd>
    <button>
      <halpin>"btn01"</halpin>
      <text>"Pin 01"</text>
    </button>
    <led>
      <halpin>"led-01"</halpin>
      <size>25</size>
      <on_color>"green"</on_color>
      <off_color>"red"</off_color>
    </led>
  </hbox>
  <hbox>
    <relief>RIDGE</relief>
    <bd>2</bd>
    <button>
      <halpin>"btn02"</halpin>
      <text>"Pin 02"</text>
    </button>
    <led>
      <halpin>"led-02"</halpin>
      <size>25</size>
      <on_color>"green"</on_color>
      <off_color>"red"</off_color>
    </led>
  </hbox>
  <hbox>
    <relief>RIDGE</relief>
    <bd>2</bd>
    <label>
      <text>"Pin 10"</text>
      <font>("Helvetica",14)</font>
    </label>
    <led>
      <halpin>"led-10"</halpin>
      <size>25</size>
      <on_color>"green"</on_color>
      <off_color>"red"</off_color>
    </led>
  </hbox>
  <hbox>
    <relief>RIDGE</relief>
    <bd>2</bd>
    <label>
      <text>"Pin 11"</text>
      <font>("Helvetica",14)</font>
    </label>
    <led>
      <halpin>"led-11"</halpin>
      <size>25</size>
      <on_color>"green"</on_color>
      <off_color>"red"</off_color>
    </led>
  </hbox>
</pyvcp>
----

Le panneau flottant contenant deux pins de HAL d'entrée et deux pins de 
HAL de sortie.

.Panneau flottant testeur de port parallèle[[cap:Port-Tester-Panel]]

image::images/ptest.png[]

Pour lancer les commandes de HAL dont nous avons besoin et démarrer tout ce
qi'il nous faut, nous avons mis le code suivant dans notre fichier ptest.hal.

[source,c]
----
loadrt hal_parport cfg="0x378 out"
loadusr -Wn ptest pyvcp -c ptest ptest.xml
loadrt threads name1=porttest period1=1000000
addf parport.0.read porttest
addf parport.0.write porttest
net pin01 ptest.btn01 parport.0.pin-01-out ptest.led-01
net pin02 ptest.btn02 parport.0.pin-02-out ptest.led-02
net pin10 parport.0.pin-10-in ptest.led-10
net pin11 parport.0.pin-11-in ptest.led-11
start
----

Pour lancer le fichier HAL, nous utilisons, dans un terminal, les commandes 
suivantes:
----
~$ halrun -I -f ptest.hal
----

La figure suivante montre à quoi ressemble le panneau complet.

.Testeur de port parallèle, complet[[cap:Port-Tester-Complete]]

image::images/ptest-final.png[]

Pour ajouter le reste des pins du port parallèle, il suffi de modifier les 
fichiers .xml et .hal.

Pour visualiser les pins après avoir lancé le script HAL, utiliser la
commande suivante au prompt _halcmd:_

----
halcmd: show pin
Component Pins:
Owner Type  Dir Value  Name
    2 bit   IN  FALSE  parport.0.pin-01-out <== pin01
    2 bit   IN  FALSE  parport.0.pin-02-out <== pin02
    2 bit   IN  FALSE  parport.0.pin-03-out
    2 bit   IN  FALSE  parport.0.pin-04-out
    2 bit   IN  FALSE  parport.0.pin-05-out
    2 bit   IN  FALSE  parport.0.pin-06-out
    2 bit   IN  FALSE  parport.0.pin-07-out
    2 bit   IN  FALSE  parport.0.pin-08-out
    2 bit   IN  FALSE  parport.0.pin-09-out
    2 bit   OUT TRUE   parport.0.pin-10-in ==> pin10
    2 bit   OUT FALSE  parport.0.pin-10-in-not
    2 bit   OUT TRUE   parport.0.pin-11-in ==> pin11
    2 bit   OUT FALSE  parport.0.pin-11-in-not
    2 bit   OUT TRUE   parport.0.pin-12-in
    2 bit   OUT FALSE  parport.0.pin-12-in-not
    2 bit   OUT TRUE   parport.0.pin-13-in
    2 bit   OUT FALSE  parport.0.pin-13-in-not
    2 bit   IN  FALSE  parport.0.pin-14-out
    2 bit   OUT TRUE   parport.0.pin-15-in
    2 bit   OUT FALSE  parport.0.pin-15-in-not
    2 bit   IN  FALSE  parport.0.pin-16-out
    2 bit   IN  FALSE  parport.0.pin-17-out
    4 bit   OUT FALSE  ptest.btn01 ==> pin01
    4 bit   OUT FALSE  ptest.btn02 ==> pin02
    4 bit   IN  FALSE  ptest.led-01 <== pin01
    4 bit   IN  FALSE  ptest.led-02 <== pin02
    4 bit   IN  TRUE   ptest.led-10 <== pin10
    4 bit   IN  TRUE   ptest.led-11 <== pin11
------

Cela montre quelles pins sont IN est lesquelles sont OUT, ainsi que toutes les
connections.

== Compte tours pour GS2[[sec:Exemple-Compte-Tours-GS2]]

L'exemple suivant utilise un variateur de fréquence GS2 de la société Automation 
Direct. footnote:[ En Europe on trouve ce type de variateur sous la marque Omron.]
 Il permet le pilotage du moteur, la visualisation de la vitesse ainsi que
d'autres informations dans un panneau PyVCP. Cet exemple est basé sur un autre,
relatif au variateur GS2 et se trouvant dans la section des exemples matériels
de ce manuel.
Ce dernier exemple s'appuie lui même sur la description du composant de 
HAL gs2_vfd.

=== Le panneau

Pour créer le panneau nous ajoutons ce code au fichier .xml.

[source,xml]
----
<pyvcp>

    <!-- Compte tours --> 
    <hbox> 
        <relief>RAISED</relief> 
        <bd>3</bd> 
        <meter> 
            <halpin>"spindle_rpm"</halpin> 
            <text>"Broche"</text> 
            <subtext>"tr/mn"</subtext> 
            <size>200</size> 
            <min_>0</min_> 
            <max_>3000</max_> 
            <majorscale>500</majorscale> 
            <minorscale>100</minorscale> 
            <region1>0,10,"yellow"</region1> 
        </meter> 
    </hbox>

    <!-- La Led On --> 
    <hbox> 
        <relief>RAISED</relief> 
        <bd>3</bd> 
        <vbox> 
            <relief>RAISED</relief> 
            <bd>2</bd> 
            <label> 
                <text>"On"</text> 
                <font>("Helvetica",18)</font> 
            </label> 
            <width>5</width> 
            <hbox> 
                <label width="2"/> <!-- utilisé pour centrer la Led --> 
                <rectled> 
                    <halpin>"on-led"</halpin> 
                    <height>"30"</height> 
                    <width>"30"</width> 
                    <on_color>"green"</on_color> 
                    <off_color>"red"</off_color> 
                </rectled> 
            </hbox> 
        </vbox>

        <!-- La Led Sens horaire --> 
        <vbox> 
            <relief>RAISED</relief> 
            <bd>2</bd> 
            <label> 
                <text>"Sens horaire"</text> 
                <font>("Helvetica",18)</font> 
                <width>5</width> 
            </label> 
            <label width="2"/> 
            <rectled> 
                <halpin>"fwd-led"</halpin> 
                <height>"30"</height> 
                <width>"30"</width> 
                <on_color>"green"</on_color> 
                <off_color>"red"</off_color> 
            </rectled> 
        </vbox>

        <!-- La Led Sens inverse --> 
        <vbox> 
            <relief>RAISED</relief> 
            <bd>2</bd> 
            <label> 
                <text>"Sens inverse"</text> 
                <font>("Helvetica",18)</font> 
                <width>5</width> 
            </label> 
            <label width="2"/> 
            <rectled> 
                <halpin>"rev-led"</halpin> 
                <height>"30"</height> 
                <width>"30"</width> 
                <on_color>"red"</on_color> 
                <off_color>"green"</off_color> 
            </rectled> 
        </vbox> 
    </hbox> 
</pyvcp>
----

L'image ci-dessous montre notre panneau PyVCP en fonctionnement. 

.Panneau pour GS2[[cap:Panneau-GS2]]

image::images/gs2_panel.png[]

=== Les connections

Pour qu'il fonctionne, il est nécessaire d'ajouter le code suivant au fichier
custom_postgui.hal, il réalise les connections entre PyVCP et LinuxCNC.

[source,c]
----
# affiche le compte tours, calcul basé sur freq * rpm par hz 
loadrt mult2 
addf mult2.0 servo-thread 
setp mult2.0.in1 28.75 
net cypher_speed mult2.0.in0 <= spindle-vfd.frequency-out 
net speed_out pyvcp.spindle_rpm <= mult2.0.out 

# la led On 
net gs2-run => pyvcp.on-led

# la led Sens horaire 
net gs2-fwd => pyvcp.fwd-led

# la led Sens anti-horaire
net running-rev spindle-vfd.spindle-rev => pyvcp.rev-led
----

Certaines lignes demandent quelques explications. 

 - La ligne de la led Sens horaire utilise le signal créé dans le fichier 
    custom.hal dans lequel la led Sens inverse doit utiliser le bit _spindle-rev_. 
 - On ne _peut pas_ lier deux fois le bit _spindle-fwd_ pour utiliser le signal 
    auquel il est déjà lié.