HAL est basé sur le même principe que celui utilisé pour l'étude des circuits et des systèmes techniques, il va donc être utile d’examiner d’abord ces principes.

N’importe quel système, y compris les machines CNC, est fait de composants interconnectés. Pour les machines CNC, ces composants pourraient être le contrôleur principal, les amplis de servomoteurs, les amplis ou les commandes de puissance des moteurs pas à pas, les moteurs, les codeurs, les interrupteurs de fin de course, les panneaux de boutons de commande, les manivelles, peut être aussi un variateur de fréquence pour le moteur de broche, un automate programmable pour gérer le changeur d’outils, etc. Le constructeur de machine doit choisir les éléments, les monter et les câbler entre eux pour obtenir un système complet et fonctionnel.

Ce document est destiné aux personnes déjà capables de concevoir ce type de réalisation matérielle, mais qui ne savent pas comment connecter le matériel à EMC.

La conception de matériel, telle que décrite précédemment, s’arrête à l’interface de contrôle. Au delà, il y a un tas de boîtes noires, relativement simples, reliées entre elles pour faire ce qui est demandé. À l’intérieur, un grand mystère, c’est juste une grande boîte noire qui fonctionne, nous osons l’espérer.

HAL étend cette méthode traditionnelle de conception de matériel à l’intérieur de la grande boîte noire. Il transforme les pilotes de matériels et même certaines parties internes du matériel, en petites boîtes noires pouvant être interconnectées, elles peuvent alors remplacer le matériel externe. Il permet au “plan de câblage” de faire voir une partie du contrôleur interne et non plus, juste une grosse boîte noire. Plus important encore, il permet à l’intégrateur de tester et de modifier le contrôleur en utilisant les mêmes méthodes que celles utilisées pour le reste du matériel.

Les termes tels que moteurs, amplis et codeurs sont familiers aux intégrateurs de machines. Quand nous parlons d’utiliser un câble extra souple à huit conducteurs blindés pour raccorder un codeur de position à sa carte d’entrées placée dans l’ordinateur. Le lecteur comprend immédiatement de quoi il s’agit et se pose la question, “quel type de connecteurs vais-je devoir monter de chaque côté de ce câble ?” Le même genre de réflexion est indipensable pour HAL mais le cheminement de la pensée est différent. Au début les mots utilisés par HAL pourront sembler un peu étranges, mais ils sont identiques au concept de travail évoluant d’une connection à la suivante.

HAL repose sur une seule idée, l’idée d'étendre le plan de câblage à l’intérieur du contrôleur. Si vous êtes à l’aise avec l’idée d’interconnecter des boîtes noires matérielles, vous n’aurez sans doute aucune difficulté à utiliser HAL pour interconnecter des boites noires logicielles.

Chacun de ces modules est décrit en détail dans les chapitres suivants.

 Je regardais mon fils et sa petite fille de six ans construire une
tour à partir d'une boîte pleine de blocs de différentes tailles, de
barres et de pièces rondes, des sortes de couvercles. L'objectif était
de voir jusqu'où la tour pouvait monter. Plus la base était étroite
plus il restait de pièces pour monter. Mais plus la base était étroite,
moins la tour était stable. Je les voyais étudier combien de blocs ils
pouvaient poser et où ils devaient les poser pour conserver l'équilibre
avec le reste de la tour.

La notion d’empilage de cartes pour voir jusqu’où on peut monter est une très vieille et honorable manière de passer le temps. En première lecture, l’intégrateur pourra avoir l’impression que construire un HAL est un peu comme ça. C’est possible avec une bonne planification, mais l’intégrateur peut avoir à construire un système stable aussi complexe qu’une machine actuelle l’exige.

C'était une grande série de boites de construction en métal, des tôles perforées, plates ou en cornières, toutes avaient des trous régulierements espacés. Vous pouviez concevoir des tas de choses et les monter avec ces éléments maintenus entre eux par des petits boulons.

 J'ai eu ma première boîte Erector pour mon quatrième anniversaire. Je
sais que la boîte était prévue pour des enfants beaucoup plus agés que
moi. Peut être que mon père se faisait vraiment un cadeau à lui même.
J'ai eu une période difficile avec les petites vis et les petits
écrous. J'ai vraiment eu envie d'avoir quatre bras, un pour visser avec
le tournevis, un pour tenir la vis, les pièces et l'écrou. En
persévérant, de même qu'en agaçant mon père, j'ai fini par avoir fait
tous les montages du livret. Bientôt, je lorgnais vers les plus grandes
boîtes qui étaient imprimées sur ce livret. Travailler avec ces pièces
de taille standard m'a ouvert le monde de la construction et j'ai
bientôt été au delà des projets illustrés.

Les composants Hal ne sont pas tous de même taille ni de même forme mais ils permettent d'être regroupés en larges unités qui feront bien du travail. C’est dans ce sens qu’ils sont comme les pièces d’un jeu Erector. Certains composants sont longs et minces. Ils connectent essentiellement les commandes de niveau supérieur aux “physical pins”. D’autres composants sont plus comme les plateformes rectangulaires sur lesquelles des machines entières pourraient être construites. Un intégrateur parviendra rapidement au delà des brefs exemples et commencera à assembler des composants entre eux d’une manière qui lui sera propre.

 Le jouet en bois Tinkertoys est plus humain que l'acier froid de
l'Erector. Le coeur de la construction avec TinkerToys est un
connecteur rond avec huit trous équidistants sur la circonférence. Il a
aussi un trou au centre, perpendiculaire aux autres trous répartis
autour du moyeu.

 Les moyeux pouvaient être connectés avec des tiges rondes de
différentes longueurs. Le constructeur pouvait faire une grosse roue à
l'aide de rayons qui partaient du centre.

 Mon projet favori était une station spaciale rotative. De courtes
tiges rayonnaient depuis les trous du moyeu central et étaient
connectées avec d'autres moyeux aux extrémités des rayons. Ces moyeux
extérieurs étaient raccordés entre eux avec d'autres rayons. Je passais
des heures à rêver de vivre dans un tel dispositif, marchant de moyeu
en moyeu et sur la passerelle extérieure qui tournait lentement à cause
de la gravité dans l'espace en état d'apesanteur. Les provisions
circulaient par les rayons et les ascenceurs qui les transféraient dans
la fusée arrimée sur le rayon central pendant qu'on déchargeait sa
précieuse cargaison.

L’idée qu’une “pin” ou qu’un “component” est la plaque centrale pour de nombreuses connections est aussi une notion facile avec le HAL. Les exemples deux à quatre (voir section [cha:Tutoriel-HAL]) connectent le multimètre et l’oscilloscope aux signaux qui sont prévus pour aller ailleurs. Moins facile, la notion d’un moyeu pour plusieurs signaux entrants. Mais, c’est également possible avec l’utilisation appropriée des fonctions dans ce composant de moyeu qui manipulent les signaux quand ils arrivent, venant d’autres composants.

Une autre réflexion qui vient à partir de ce jouet mécanique est une représentation de “HAL threads”. Un “thread” pourrait ressembler un peu à un chilopode, une chenille, ou un perce-oreille. Une épine dorsale, des “HAL components”, raccordés entre eux par des tiges, les “HAL signals”. Chaque composant prend dans ses propres paramètres et selon l'état de ses broches d’entrée, les passe sur ses broches de sortie à l’intention du composant suivant. Les signaux voyagent ainsi de bout en bout, le long de l'épine dorsale où ils sont ajoutés ou modifiés par chaque composant son tour venu.

Les “Threads” sont tous synchronisés et exécutent une série de tâches de bout en bout. Une représentation mécanique est possible avec Thinkertoys si on pense à la longueur du jouet comme étant la mesure du temps mis pour aller d’un bout à l’autre. Un thread, ou épine dorsale, très différent est créé en connectant le même ensemble de modules avec des tiges de longueur différente. La longueur totale de l'épine dorsale peut aussi être changée en jouant sur la longueur des tiges pour connecter les modules. L’ordre des opérations est le même mais le temps mis pour aller d’un bout à l’autre est très différent.

Lorsque les blocs de Lego sont arrivés dans nos magasins, ils étaient à peu près tous de la même taille et de la même forme. Bien sûr il y avait les demi taille et quelques uns en quart de taille mais tous rectangulaires. Les blocs de Lego se relient ensembles en enfonçant les broches mâles d’une pièce dans les trous femelles de l’autre. En superposant les couches, les jonctions peuvent être rendues très solides, même aux coins et aux tés.

 J'ai vu mes enfants et mes petits-enfants construire avec des pièces
Lego (les mêmes Lego). Il y en a encore quelques milliers dans une
vieille et lourde boîte en carton qui dort dans un coin de la salle de
jeux. Ils sont stockés dans cette boîte car c'était trop long de les
ranger et de les ressortir à chacune de leur visite et ils étaient
utilisés à chaque fois. Il doit bien y avoir les pièces de deux
douzaines de boîtes différentes de Lego. Les petits livrets qui les
accompagnaient ont été perdus depuis longtemps, mais la magie de la
construction avec l'imbrication de ces pièces toutes de la même taille
est quelque chose à observer.

Les exemples en ligne de commande sont représentés en police bold typewriter. Les réponses de l’ordinateur sont en police typewriter. Le texte optionnel est entre crochets [comme ça]. Le texte <comme ça> représente un champ qui peut prendre différentes valeurs, le paragraphe adjacent explique quelles sont les valeurs appropriées. Les élements textuels séparés par des barres verticales indiquent qu’une valeur ou l’autre mais pas les deux, doit être présente. Toutes les lignes de commandes considèrent que vous êtes dans le répertoire emc2/ , les chemins sont affichés en accord avec ce principe.

Votre version de halcmd peut inclure la complétion avec la touche tab. Au lieu de compléter les noms de fichiers comme le fait un shell, il complète les commandes avec les identifiants HAL. Essayez de presser la touche tab après le début d’une commande HAL:

halcmd: *loa<TAB>* +
halcmd: *load* +
halcmd: *loadrt* +
halcmd: *loadrt deb<TAB>* +
halcmd: *loadrt debounce*

RTAPI est le sigle de Real Time Application Programming Interface. De nombreux composants HAL travaillent en temps réel et tous les composants de HAL stockent leurs données dans la mémoire partagée, de sorte que les composants temps réel puissent y accéder. Normalement, Linux ne prend pas en charge les programmes temps réel ni le type de mémoire partagée dont HAL a besoin. Heureusement, il existe des systèmes d’exploitation temps réel RTOS qui fournissent les extensions nécessaires à Linux. Malheureusement, chaque RTOS fait les choses différemment des autres.

Pour remédier à ces différences, l'équipe d’EMC a proposé RTAPI, qui fournit une manière cohérente aux programmes de parler au RTOS. Si vous êtes un programmeur qui veut travailler à l’intérieur d’EMC, vous pouvez étudier emc2/src/rtapi/rtapi.h pour comprendre l’API. Mais si vous êtes une personne normale, tout ce que vous avez besoin de savoir à propos de RTAPI est qu’il doit être (avec le RTOS) chargé dans la mémoire de votre ordinateur avant de pouvoir faire n’importe quoi avec HAL.

Pour ce tutoriel, nous allons supposer que vous avez installé avec succés le CD-Live ou que vous avez compilé correctement l’arborescence emc2/src. Si nécessaire, invoquez le script «emc-environment» pour préparer votre shell. Dans ce cas, tout ce que vous avez à faire est de charger le RTOS requis et les modules RTAPI dans la mémoire. Tapez juste les commandes suivantes dans une console:

~$ *cd emc2* +
~/emc2$ *halrun +*halcmd:

Avec l’OS temps réel et RTAPI chargés, vous pouvez passer au premier exemple. Notez que le prompt a changé, il est passé de “$” à “halcmd:”. La raison en est que les commandes ultérieures seront interprétées comme des commandes HAL et non plus comme des commandes shell.

Pour le premier exemple, nous allons utiliser un composant HAL appelé siggen , qui est un simple générateur de signal. Une description complète du composant siggen reste disponible à la section ??? de ce document. Il s’agit d’un composant temps réel, mis en oeuvre comme un module du noyau Linux. Pour charger siggen utiliser la commande de HAL, loadrt:

halcmd: *loadrt siggen*

Maintenant que le module est chargé, il faut introduire halcmd , l’outil en ligne de commande utilisé pour configurer le HAL. Pour une description plus complète essayez: man halcmd, ou consultez la section halcmd à la section [sec:Halcmd] de ce document. La première commande de halcmd et show, qui affichera les informations concernant l'état actuel du HAL. Pour afficher tout ce qui est installé tapez:

halcmd:* show comp* +
Loaded HAL Components: +
ID     Type  Name                  PID       State +
3       RT     siggen                             ready  +
2       User  halcmd10190    10190 ready

Puisque halcmd lui même est un composant HAL, il sera toujours présent dans la liste. Le nombre après halcmd dans la liste des composants est le “process ID”. Il est toujours possible de lancer plus d’une instance de halcmd en même temps (dans différentes fenêtres par exemple), Le numéro PID est ajouté à la fin du nom pour rendre celui-ci unique. La liste montre aussi le composant siggen que nous avions installé à l'étape précédente. Le “RT” sous “Type” indique que siggen est un composant temps réel.

Ensuite, voyons quelles pins siggen rend disponibles:

halcmd:* show pin* +
Component Pins: +
Owner  Type    Dir    Value      Name  +
         3  float    IN             1  siggen.0.amplitude  +
         3  float    OUT          0  siggen.0.cosine  +
         3  float    IN             1  siggen.0.frequency  +
         3  float    IN             0  siggen.0.offset  +
         3  float    OUT          0  siggen.0.sawtooth +
         3  float    OUT          0  siggen.0.sine +
         3  float    OUT          0  siggen.0.square +
         3  float    OUT          0  siggen.0.triangle

Cette commande affiche toutes les pins présentes dans le HAL. Un système complexe peut avoir plusieurs dizaines ou centaines de pins. Mais pour le moment il y a seulement huit pins. Toutes ces huit pins sont des flottants, elles transportent toutes des données en provenance du composant siggen . Puisque nous n’avons pas encore exécuté le code contenu dans le composant, certaines pins ont une valeur de zéro.

L'étape suivante consiste à examiner les paramètres:

halcmd:* show param* +
Parameters: +
Owner  Type  Dir    Value      Name +
         3    s32    RO            0   siggen.0.update.time +
         3    s32   RW            0   siggen.0.update.tmax

La commande “show param” affiche tous les paramètres de HAL. Pour le moment chaque paramètre à la valeur par défaut attribuée quand le composant a été chargé. Notez dans la colonne Dir, les paramètres marqués -W sont en écriture possible, pour ceux qui ne sont jamais modifiés par le composant lui-même, mais qui sont modifiables par l’utilisateur pour contrôler le composant. Nous verrons comment plus tard. Les paramètres marqués R- sont en lecture seule. Il ne peuvent être modifiés que par le composant. Finalement, les paramètres marqués RW sont en lecture/écriture. Ils peuvent être modifiés par le composant et aussi par l’utilisateur. Nota: les paramètres siggen.0.update.time et siggen.0.update.tmax existent dans un but de déboguage, ils ne sont pas couverts par cette documentation. Les paramètres thread.time et thread.tmax sont associés avec le thread créé quand le composant a été chargé. Quand la réécriture de HAL sera terminée, le thread ne sera plus créé à ce stade, de sorte que ces paramètres ne seront plus visibles.

Il n’y a pas de thread créé ici, mais il y a quand même les paramètres siggen.0.update.{time,tmax}.

Les paramètres de thread sont ceux du composant 02, le module siggen. C’est incorrect, ils devraient être ceux du module hal_lib, parce que le thread lui même n’est plus la propriété de siggen, et en fait, si siggen est retiré, les paramètres devraient rester.

Et bien en fait, “fixer” les paramètres de thread aura pris plus de temps que je ne pensais. Donc, je les ai éliminés pour l’instant. Quand la réécriture de HAL sera terminée, je les remettrai.

La plupart des composants temps réel exportent une ou plusieurs fonctions pour que le code qu’elles contiennent soit exécuté en temps réel. Voyons ce que la fonction siggen exporte:

halcmd: *show funct* +
Exported Functions: +
Owner    CodeAddr   Arg    FP   Users  Name +
 32769   b7f74ac5 b7d0c0b4 YES    0   siggen.0.update

Le composant siggen exporte une seule fonction. Il nécessite un flottant (Floating Point). Il n’est lié à aucun thread, puisque “users” est à zero^[5].

Pour faire tourner le code actuellement contenu dans la fonction siggen.0.update, nous avons besoin d’un thread temps réel. C’est le composant appelé threads qui est utilisé pour créer le nouveau thread. Créons un thread appelé test-thread avec une période de 1ms (1000000ns):

halcmd: *loadrt threads name1=test-thread period1=1000000*

Voyons si il fonctionne:

halcmd: *show thread +*Realtime Threads: +
   Period   FP   Name    (Time, Max-Time) +
     999849 YES  test-thread    ( 0, 0 )

Il fonctionne. La période n’est pas exactement de 1000000ns à cause des limitations dues au matériel, mais nous avons bien un thread qui tourne à une période approximativement correcte et qui peut manipuler des fonctions en virgule flottante. La prochaine étape sera de connecter la fonction au thread:

halcmd: *addf siggen.0.update test-thread*

Pour le moment nous avions utilisé halcmd seulement pour regarder le HAL. Mais cette fois-ci, nous avons utilisé la commande addf (add function) pour changer quelque chose dans le HAL. Nous avons dit à halcmd d’ajouter la fonction siggen.0.update au thread test-thread et la commande suivante indique qu’il a réussi:

halcmd: *show thread +*Realtime Threads: +
   Period   FP   Name    (Time, Max-Time) +
     999849 YES  test-thread    ( 0, 0 ) +
                 1 siggen.0.update

Il y a une étape de plus avant que le composant siggen ne commence à générer des signaux. Quand le HAL est démarré pour la première fois, les threads ne sont pas en marche. C’est pour vous permettre de compléter la configuration du système avant que le code temps réel ne démarre. Une fois que vous êtes satisfait de la configuration, vous pouvez lancer le code temps réel comme ceci:

halcmd: *start*

Maintenant le générateur de signal est en marche. Regardons ses pins de sortie:

halcmd: *show pin* +
Component Pins: +
Owner    Type     Dir                Value   Name +
           3    float     IN                        1
siggen.0.amplitude +
          3    float     OUT   -0.9406941   siggen.0.cosine +
           3    float     IN                        1
siggen.0.frequency +
          3    float     IN                        0   siggen.0.offset +
          3    float     OUT   -0.1164055   siggen.0.sawtooth +
          3    float     OUT      0.379820   siggen.0.sine +
          3    float     OUT                   -1   siggen.0.square +
          3    float     OUT   -0.7728110  siggen.0.triangle

halcmd: *show pin* +
Component Pins: +
Owner    Type     Dir                 Value   Name +
           3    float     IN                         1
siggen.0.amplitude +
          3    float     OUT     0.9958036   siggen.0.cosine +
           3    float     IN                         1
siggen.0.frequency +
           3    float     IN                         0
siggen.0.offset +
          3    float     OUT     0.9708287   siggen.0.sawtooth +
          3    float     OUT -0.09151597   siggen.0.sine +
          3    float     OUT                     1   siggen.0.square +
          3    float     OUT     0.9416574  siggen.0.triangle

Nous avons fait, très rapidement, deux commandes show pin et vous pouvez voir que les sorties ne sont plus à zéro. Les sorties sinus, cosinus, dents de scie et triangle changent constamment. La sortie carrée fonctionne également, mais elle passe simplement de +1.0 à -1.0 à chaque cycle.

La réelle puissance de HAL est de permettre de modifier les choses. Par exemple, on peut utiliser la commande setp pour ajuster la valeur d’un paramètre. Modifions l’amplitude du signal de sortie du générateur de 1.0 à 5.0:

halcmd: *setp siggen.0.amplitude 5* +
emc2$

Voyons encore une fois les paramètres et les pins:

halcmd: *show param* +
Parameters: +
Owner    Type  Dir           Value      Name +
         3    s32    RO               397   siggen.0.update.time +
         3    s32    RW       109100   siggen.0.update.tmax

halcmd: *show pin* +
Component Pins: +
Owner    Type     Dir                 Value   Name +
           3    float     IN                         5
siggen.0.amplitude +
          3    float     OUT      -4.179375   siggen.0.cosine +
           3    float     IN                         1
siggen.0.frequency +
           3    float     IN                         0
siggen.0.offset +
          3    float     OUT     0.9248036   siggen.0.sawtooth +
          3    float     OUT      -2.744599   siggen.0.sine +
          3    float     OUT                      5   siggen.0.square +
          3    float     OUT      -3.150393  siggen.0.triangle

Notez que la valeur du paramètre siggen.0.amplitude est bien passée à 5.000 et que les pins ont maintenant des valeurs plus grandes.

La plupart de ce que nous avons fait jusqu’ici avec halcmd a été de simplement regarder les choses avec la commande show . Toutefois, deux commandes ont rééllement modifié des valeurs. Au fur et à mesure que nous concevons des systèmes plus complexes avec HAL, nous allons utiliser de nombreuses commandes pour le configurer comme nous le souhaitons. HAL a une mémoire d'éléphant et peut retenir sa configuration jusqu'à ce qu’il s’arrête. Mais qu’en est-il de la prochaine fois ? Nous ne voulons pas entrer une série de commande à chaque fois que l’on veut utiliser le système. Nous pouvons enregistrer la configuration de l’ensemble de HAL en une seule commande:

halcmd:* save* +
# components +
loadrt threads name1=test-thread period1=1000000 +
loadrt siggen +
# pin aliases +
# signals +
# nets +
# parameter values +
setp siggen.0.update.tmax 14687 +
# realtime thread/function links +
addf siggen.0.update test-thread

La sortie de la commande save est une séquence de commandes HAL. Si vous commencez par un HAL “vide” et que vous tapez toute la séquence de commandes HAL, vous aurez la configuration qui existait lors de l’exécution de la commande save . Pour sauver ces commandes pour une utilisation ultérieure, nous allons simplement rediriger la sortie vers un fichier:

halcmd: *save all saved.hal +*halcmd: *exit +*~/emc2$

Pour restaurer la configuration de HAL stockée dans saved.hal , nous avons besoin d’exécuter toutes ces commandes HAL. Pour ce faire, nous utiliserons la commande -f <filename> qui lit les commandes à partir d’un fichier, le -I qui affichera le prompt halcmd après l’exécution des commandes:

~/emc2$ *halrun -I -f saved.hal*

Notez qu’il n’y a pas de commande start dans le fichier saved.hal. Il est nécessaire de la retaper (ou d'éditer saved.hal pour l’ajouter):

halcmd: *start +*halcmd: *exit +*~/emc2$

À ce stade, nous avons chargé le composant siggen qui est en cours d’exécution. Nous pouvons lancer halmeter. Puisque halmeter est une application graphique, X doit être actif.

halcmd: *loadusr halmeter*

Dans le même temps, une fenêtre s’ouvre sur votre écran, demandant de sélectionner le signal à observer [cap:HAL-Meter-Fenetre-selection].

Fenêtre de sélection de HAL Meter. Ce dialogue contient trois onglets. Le premier onglet affiche toutes les HAL pins du système. La seconde affiche tous les signaux et le troisième affiche tous les paramètres. Si nous voulons analyser la pin siggen.0. cosine en premier, il suffit de cliquer sur elle puis sur le bouton Close. Le dialogue de sélection se ferme et la mesure s’affiche, quelque chose comme sur la figure [cap:Halmeter].

Figure 2.1. Halmeter

Pour modifier ce qui est affiché sur Hal meter pressez le bouton "Select" qui vous raménera à la fenêtre de sélection précédente.

Vous devriez voir la valeur évoluer puisque siggen génére une onde cosinusoïdale. Halmeter raffraîchi son affichage environ 5 fois par seconde.

Pour éteindre halmeter, cliquer sur le bouton exit.

Pour visualiser plusieurs pins, signaux ou paramètres en même temps, il est possible d’ouvrir plusieurs halmeters. La fenêtre de halmeter est intentionnellement petite justement pour permettre d’en ouvrir un grand nombre sur le même écran.

Maintenant, nous allons charger le composant générateur d’impulsions. Pour l’instant, nous pouvons nous passer des détails et exécuter les commandes suivantes:^[6]

Dans cet exemple nous utiliserons le type de contrôle "velocity" du composant stepgen.

 halrun: *loadrt stepgen step_type=0,0 ctrl_type=v,v +*halcmd: *loadrt
siggen +*halcmd: *loadrt threads name1=fast fp1=0 period1=50000
name2=slow period2=1000000*

La première commande charge deux générateurs d’impulsions, configurés pour générer des impulsions de type 0. La seconde commande charge notre vieil ami siggen et la troisième crée deux threads, un rapide (fast) avec une période de 50 us et un lent avec une période de 1ms. Le thread rapide ne prend pas en charge les fonctions à virgule flottante (fp1=0).

Comme précédemment, on peut utiliser halcmd show pour jeter un coup d’oeil à HAL. Cette fois, nous aurons beaucoup plus de pins et de paramètres que précédemment:

halcmd:* show pin +*Component Pins: +
Owner   Type    Dir         Value           Name +
     3       float    IN              1        siggen.0.amplitude +
     3       float    OUT           0        siggen.0.cosine +
     3       float   IN              1        siggen.0.frequency +
     3       float    IN              0        siggen.0.offset +
     3       float    OUT          0         siggen.0.sawtooth +
     3       float    OUT         0         siggen.0.sine +
     3       float    OUT          0         siggen.0.square +
     3       float    OUT          0         siggen.0.triangle +
     3       float    OUT          0         stepgen.0.counts +
     2       bit       OUT       FALSE    stepgen.0.dir +
     2       bit       IN          FALSE    stepgen.0.enable +
     2       float    IN             0         stepgen.0.position-fb +
     2       float    OUT          0         stepgen.0.step +
     2       bit       OUT       FALSE    stepgen.0.velocity-cmd +
     2       s32      OUT          0         stepgen.1.counts +
     2       bit       OUT       FALSE    stepgen.1.dir +
     2       bit       IN          FALSE    stepgen.1.enable +
     2       float    IN             0         stepgen.1.position-fb +
     2      float    OUT         0         stepgen.1.step +
     2       bit       OUT       FALSE   stepgen.1.velocity-cmd

halcmd:* show param +*Parameters: +
Owner   Type  Dir               Value                  Name +
      3       s32   RO                        0
siggen.0.update.time +
      3       s32   RW                       0
siggen.0.update.tmax +
     2       u32   RW       00000001           stepgen.0.dirhold +
     2       u32   RW       00000001           stepgen.0.dirsetup +
      2       float  RO                       0
stepgen.0.frequency +
      2       float  RW                      0
stepgen.0.maxaccel +
      2       float  RW                      0
stepgen.0.maxvel +
      2       float  RW                      1
stepgen.0.position-scale +
      2       s32   RO                        0
stepgen.0.rawcounts +
     2       u32   RW       00000001           stepgen.0.steplen +
     2       u32   RW       00000001           stepgen.0.stepspace +
     2       u32   RW       00000001           stepgen.1.dirhold +
     2       u32   RW       00000001           stepgen.1.dirsetup +
      2       float  RO                       0
stepgen.1.frequency +
      2       float  RW                      0
stepgen.1.maxaccel +
      2       float  RW                      0
stepgen.1.maxvel +
      2       float  RW                      1
stepgen.1.position-scale +
      2       s32   RO                        0
stepgen.1.rawcounts +
     2       u32   RW       00000001           stepgen.1.steplen +
     2       u32   RW       00000001           stepgen.1.stepspace +
      2       s32   RO                        0
stepgen.capture-position.time +
      2       s32   RW                       0
stepgen.capture-position.tmax +
      2       s32   RO                        0
stepgen.make-pulses.time +
      2       s32   RW                       0
stepgen.make-pulses.tmax +
      2       s32   RO                        0
stepgen.update-freq.time +
      2       s32   RW                       0
stepgen.update-freq.tmax

Nous avons donc deux générateurs d’impulsions de pas et un générateur de signaux. Maintenant, nous allons créer des signaux HAL pour connecter ces trois composants. Nous allons faire comme si nous pilotions les axes X et Y d’une machine avec nos générateurs d’impulsions de pas. Nous voulons déplacer la table en ronds. Pour ce faire, nous allons envoyer un signal cosinusoïdal à l’axe des X et un signal sinusoïdal à l’axe des Y. Le module siggen créera le sinus et le cosinus, mais nous aurons besoin de “fils” pour connecter les modules ensemble. Dans le HAL, les “fils” sont appelés signaux. Nous devons en créer deux. Nous pouvons les appeler comme on veut, pour cet exemple il y aura X-vel et Y-vel. Le signal X-vel partira de la sortie cosinus du générateur de signal et arrivera sur l’entrée “velocity” du premier générateur d’impulsions de pas. La première étape consiste à connecter le signal à la sortie du générateur de signaux. Pour connecter un signal à une pin, nous utilisons la commande net:

halcmd: *net X-vel <= siggen.0.cosine*

Pour voir l’effet de la commande net, regardons les signaux:

halcmd: *show sig* +
ignals: +
Type      Value      Name +
float   0.00000e+00  X_vel +
                         <== siggen.0.cosine

Quand un signal est connecté à une ou plusieurs pins, la commande «show» liste les pins immédiatement suivies par le nom du signal. Les flèches donnent la direction du flux de données, dans ce cas, le flux va de la pin siggen.0.cosine vers le signal X-vel. Maintenant, connectons X-vel à l’entrée “velocity” du générateur d’impulsions de pas:

halcmd: *net X-vel => stepgen.0.velocity-cmd*

On peut aussi connecter l’axe Y au signal Y-vel . Il doit partir de la sortie sinus du générateur de signal pour arriver sur l’entrée du second générateur d’impulsions de pas. La commande suivante fait en une ligne, la même chose que les deux commandes net précédentes ont fait pour X-vel:

halcmd: *net Y-vel siggen.0.sine => stepgen.1.velocity-cmd*

Pour voir l’effet de la commande net, regardons encore les signaux et les pins:

halcmd:* show sig* +
Signals: +
Type      Value      Name            (linked to) +
float              0     X-vel +
                                                   <== siggen.0.cosine +
                                                    ==>
stepgen.0.velocity-cmd +
float              0     Y-vel +
                                                  <== siggen.0.sine +
                                                   ==>
stepgen.1.velocity-cmd

La commande «show sig» montre clairement comment les flux de données circulent dans HAL. Par exemple, le signal` X-vel` provient de la pin siggen.0.cosine et va vers la pin stepgen.0.velocity-cmd.

Penser à ce qui circule dans les “fils” rend les pins et les signaux assez faciles à comprendre. Les threads et les fonctions sont un peu plus difficiles. Les fonctions contiennent des instructions pour l’ordinateur. Les threads sont les méthodes utilisées pour faire exécuter ces instructions quand c’est nécessaire. Premièrement, regardons les fonctions dont nous disposons:

halcmd: *show funct +*Exported Functions: +
Owner   CodeAddr  Arg               FP   Users  Name +
 00004  d8a3a120  d8bd322c  YES      0     siggen.0.update +
 00003  d8bf45b0  d8bd30b4   YES      0     stepgen.capture-position +
 00003  d8bf42c0  d8bd30b4    NO       0     stepgen.make-pulses +
 00003  d8bf46b0  d8bd30b4   YES      0     stepgen.update-freq

En règle générale, vous devez vous référer à la documentation de chaque composant pour voir ce que font ses fonctions. Dans notre exemple, la fonction siggen.0.update est utilisée pour mettre à jour les sorties du générateur de signaux. Chaque fois qu’elle est exécutée, le générateur recalcule les valeurs de ses sorties sinus, cosinus, triangle, carrée. Pour générer un signal régulier, il doit fonctionner à des intervalles bien spécifiques.

Les trois autres fonctions sont relatives au générateur d’impulsions de pas:

La première, stepgen.capture-position , est utilisée pour un retour de position. Elle capture la valeur d’un compteur interne qui compte les impulsions qui sont générées. S’il n’y a pas de perte de pas, ce compteur indique la position du moteur.

La fonction principale du générateur d’impulsions est stepgen.make-pulses. Chaque fois que make-pulses démarre elle décide qu’il est temps de faire un pas, si oui il fixe les sorties en conséquence. Pour des pas plus doux, il doit fonctionner le plus souvent possible. Parce qu’il a besoin de fonctionner de manière rapide, make-pulses est hautement optimisé et n’effectue que quelques calculs. Contrairement aux autres, il n’a pas besoin de virgule flottante pour ses calculs.

La dernière fonction, stepgen.update-freq , est responsable de l'échelle et de quelques autres calculs qui ne doivent être effectués que lors d’une commande de changement de fréquence.

Pour notre exemple nous voulons faire tourner siggen.0.update avec une vitesse de calcul des valeurs sinus et cosinus modérée. Immédiatement après, nous lançons stepgen.0.update. Nous voulons lancer freqgen.update-freq pour charger les nouvelles valeurs dans le générateur d’impulsions. Finalement nous lancerons` stepgen.make-pulses` aussi vite que possible pour des pas plus doux. Comme nous n’utilisons pas de retour de position, nous n’avons pas besoin de lancer stepgen.capture-position.

Nous lançons les fonctions en les ajoutant aux threads. Chaque thread va à une vitesse spécifique. Regardons de quels threads nous disposons:

halcmd: *show thread* +
Realtime Threads: +
   Period   FP   Name +
    1005720 YES  slow    ( 0, 0 ) +
      50286 NO   fast    ( 0, 0 )

Les deux threads ont été créés lorsque nous les avons chargés. Le premier, slow , tourne toutes les millisecondes, il est capable d’exécuter des fonctions en virgule flottante (FP). Nous l’utilisons pour s`iggen.0.update` et stepgen.update-freq. Le deuxième thread est fast , il tourne toutes les 50 microsecondes, il ne prend pas en charge les calculs en virgule flottante. Nous l’utilisons pour stepgen.make-pulses . Pour connecter des fonctions au bon thread, nous utilisons la commande addf. Nous spécifions la fonction en premier suivie par le thread:

halcmd: *addf siggen.0.update slow* +
halcmd: *addf stepgen.update-freq slow* +
halcmd: *addf stepgen.make-pulses fast*

Après avoir lancé ces commandes, nous pouvons lancer la commande show thread une nouvelle fois pour voir ce qui ce passe:

halcmd: *show thread +*Realtime Threads: +
    Period       FP       Name                            (Time,
Max-Time) +
     988960   YES                          slow         (       0,
        0 ) +
                              1 siggen.0.update +
                              2 stepgen.update-freq +
       49448   NO                             fast         (       0,
           0 ) +
                             1 stepgen.make-pulses

Maintenant, chaque thread est suivi par les noms des fonctions, dans l’ordre dans lequel les fonctions seront exécutées.

Nous sommes presque prêts à démarrer notre système HAL. Mais il faut auparavant régler quelques paramètres. Par défaut le composant siggen génère des signaux qui varient entre +1 et -1. Pour notre exemple, c’est très bien, nous voulons que la vitesse de la table varie de +1 à -1 pouce par seconde. Toutefois, l'échelle du générateur d’impulsions de pas n’est pas bonne. Par défaut, il génère une fréquence de sortie de 1 pas par seconde avec une capacité de 1000. Il est fort improbable qu’un pas par seconde nous donne une vitesse de déplacement de la table d’un pouce par seconde. Supposons que notre vis fasse 5 tours par pouce, couplée à un moteur pas à pas de 200 pas par tour et une interface qui fournit 10 micropas par pas. Il faut donc 2000 pas pour faire un tour de vis et 5 tours pour faire un pouce. Ce qui signifie que notre montage utilisera 10000 pas par pouce. Nous avons besoin de multiplier la vitesse d’entrée à l'étape générateur d’impulsions par 10000 pour obtenir la bonne valeur. C’est exactement pour cela qu’existe le paramètre stepgen.n.velocity-scale . Dans notre cas, les axes X et Y ont la même échelle et nous pouvons passer les deux paramètres à 10000:

 halcmd:* setp stepgen.0.position-scale 10000 +*halcmd:* setp
stepgen.1.position-scale 10000 +*halcmd: *setp stepgen.0.enable 1* +
halcmd: *setp stepgen.1.enable 1*

Cela signifie que, avec la pin stepgen.0.velocity-cmd à 1.000 et le générateur réglé pour 10000 impulsions par seconde (10kHz), avec le moteur et la vis décrits précédemment, nos axes auront une vitesse de déplacement de exactement 1.000 pouce par seconde. Cela illustre une notion clé du concept de HAL, des éléments comme les échelles étant au plus bas niveau possible, dans notre exemple le générateur d’impulsions de pas, le signal interne X_vel est celui de la vitesse de déplacement de la table en pouces par seconde. Les autres composants comme siggen ne savent rien du tout à propos de l'échelle des autres. Si on change de vis, ou de moteur, il n’y a qu’un seul paramètre à changer, l'échelle du générateur d’impulsions de pas.

Nous avons maintenant tout configuré et sommes prêts à démarrer. Tout comme dans le premier exemple, nous utilisons la commande start:

halcmd: *start*

Bien que rien ne semble se produire, à l’intérieur de l’ordinateur les impulsions de pas sont présentes sur la sortie du générateur, variant entre 10kHz dans un sens et 10kHz dans l’autre à chaque seconde. Dans la suite de ce tutoriel, nous allons voir comment convertir ces signaux internes des moteurs dans le monde réel, mais nous allons d’abord les examiner pour voir ce qui se passe.

Halscope comporte deux parties, une partie en temps réel qui est chargée comme un module de noyau et une partie utilisateur qui fournit l’interface graphique et l’affichage. Cependant, vous n’avez pas à vous inquiéter à ce sujet car l’interface demandera automatiquement que la partie temps réel soit chargée:

halcmd: *loadusr halscope*

La fenêtre graphique du scope s’ouvre, immédiatement suivie par un dialogue “Realtime function not linked” visible sur la figure [fig:function-not-linked].

Dialogue“Realtime function not linked”. Ce dialogue est l’endroit où vous définissez le taux d'échantillonnage de l’oscilloscope. Pour le moment nous voulons un échantillon par milliseconde, alors cliquez sur le thread “slow” et laissez le multiplicateur à 1. Nous allons aussi passer la longueur d’enregistrement à 4000 samples (échantillons), de sorte que nous puissions utiliser jusqu'à 4 voies simultanément. Quand vous sélectionnez un thread puis que vous cliquez sur le bouton “OK”, le dialogue disparaît et la fenêtre du scope affiche quelque chose comme sur la figure [fig:Fenetre-initiale-Halscope].

Fenêtre initiale du scope. À ce stade, Halscope est prêt à l’emploi. Nous avons déjà choisi le taux d'échantillonnage et la longueur d’enregistrement, de sorte que la prochaine étape consiste à décider de ce qu’il faut mesurer. C’est équivalent à brancher les “sondes virtuelles du scope” à HAL. Halscope dispose de 16 voies, mais le nombre de voies utilisables à un moment donné dépend de la longueur d’enregistrement, plus il y a de voies, plus les enregistrements doivent être courts, car la mémoire disponible pour l’enregistrement est fixée à environ 16000 échantillons.

Les boutons des voies se situent en dessous de l'écran du scope. Cliquez le boutton “1” et vous verrez apparaître le dialogue de sélection “Select Channel Source”, pour sélectionner le signal à afficher sur la voie 1, comme sur la figure [fig:Selection-sources-Halscope]. Ce dialogue est très similaire à celui utilisé par Halmeter.

Dialogue de sélection des sources. Nous aimerions bien regarder les signaux que nous avons défini précédemment, pour cela, cliquons sur l’onglet “Signals” et le dialogue affichera tous les signaux existants dans le HAL (seulement deux dans notre exemple). [cap:Select-Signal]

Pour choisir un signal, il suffit de cliquer dessus. Dans notre cas, nous voulons utiliser la voie 1 pour afficher le signal ‘` X-vel''. Lorsque l'on clique sur `` X-vel’', la fenêtre se ferme et le canal a été sélectionné.

Figure 2.2. Sélection du signal

Le bouton de la voie 1 est pressé, le numéro de la voie 1 et le nom ‘` X-vel’' apparaissent sous la rangée de boutons. L’affichage indique toujours la voie sélectionnée, vous pouvez avoir beaucoup de voies sur l'écran, mais celle qui est active sera en surbrillance.

Figure 2.3. Halscope

Les différents contrôles comme la position verticale et l’amplitude sont toujours relatifs à la voie 1. Pour ajouter un signal sur la voie 2, cliquer sur le bouton "2'. Dans la fenêtre de dialogue, cliquer sur l’onglet "Signals', puis cliquer sur ‘` Y-vel’'.

Nous voulons aussi voir les signaux carrés et triangles produits. Il n’existe pas de signaux connectés à ces pins, nous utilisons donc l’onglet ‘`Pins”. Pour le canal 3, sélectionnez `` siggen.0.triangle’' et pour le canal 4, choisissez ‘` siggen.0.square’'.

Maintenant que nous avons plusieurs sondes branchées sur HAL, il est temps de capturer quelques formes d’ondes. Pour démarrer le scope, cochez la case "Normal'' du groupe ‘`run mode'' (en haut à droite). Puisque nous avons une longueur d'enregistrement de 4000 échantillons et une acquisition de 1000 échantillons par seconde, il faudra à halscope environ 2 secondes pour remplir la moitié de son tampon. Pendant ce temps, une barre de progression juste au-dessus de l'écran principal affichera le remplissage du tampon. Une fois que le tampon est à moitié plein, scope attend un déclencheur. Puisque nous n'en avons pas encore configuré, il attendra toujours. Pour déclencher manuellement, cliquez sur le bouton "Force'' du groupe `` Trigger’' en haut à droite. Vous devriez voir le reste de la zone tampon se remplir, puis l'écran afficher les ondes capturées. Le résultat ressemble à la figure [fig:Capture-onde-Halscope].

Capture d’ondes. Le grand bouton “Selected Channel” en bas, indique que la voie 4 est actuellement sélectionnée, donc, qu’elle correspond à la pin “siggen.0.square”. Essayez de cliquer sur les autres voies pour mettre leurs traces en évidence.

Les traces sont assez difficiles à distinguer car toutes les quatre sont les unes sur les autres. Pour résoudre ce problème, nous utilisons le curseur “Vertical” situé à droite de l'écran. Ces contrôles agissent sur la voie actuellement sélectionnée. En ajustant le gain, notez qu’il couvre une large échelle (contrairement aux scopes réels), celle-ci permet d’afficher des signaux très petits (pico unités) à très grands (Tera - unités). Le curseur “position” déplace la trace affichée de haut en bas sur toute la hauteur de l'écran. Pour de plus grands ajustements le bouton Offset doit être utilisé (voir les références de halscope dans la section [sec:Halscope] pour plus de détails).

Figure 2.4. Ajustement vertical

L’utilisation du bouton “Force” n’est parfois pas satisfaisante pour déclencher le scope. Pour régler un déclenchement (triggering) réel, cliquer sur le bouton “Source” situé en bas à droite. Il ouvre alors le dialogue “Trigger Source”, qui est simplement la liste de toutes les sondes actuellement branchées (Figure [fig:Halscope-demo-5] ). Sélectionner la sonde à utiliser pour déclencher en cliquant dessus. Pour notre exemple nous utilisons 3 canaux, essayons l’onde triangle.

Dialogue des sources de déclenchement. Après avoir défini les sources de déclenchement, il est possible d’ajuster le niveau de déclenchement avec les curseurs dans la boîte ‘` Trigger’' le long du bord droit. Le niveau peut être modifié à partir du haut vers le bas de l'écran, et est affiché sous les curseurs. La position est l’emplacement du point de déclenchement dans l’enregistrement complet. Avec le curseur tout en bas, le point de déclenchement est à la fin de l’enregistrement, et halscope affiche ce qui s’est passé avant le point de déclenchement. Lorsque le curseur est tout en haut, le point de déclenchement est au début de l’enregistrement, l’affichage représente ce qui s’est passé après le point de déclenchement. Le point de déclenchement est visible comme une ligne verticale dans la barre de progression située juste au dessus de l'écran. La polarité du signal de déclenchement peut être inversée en cliquant sur le bouton situé juste sous l’affichage du niveau de déclenchement. Notez que la modification de la position de déclenchement arrête le scope une fois la position ajustée, vous relancez le scope en cliquant sur le bouton “Normal” du groupe “Run Mode”.

Maintenant que nous avons réglé la position verticale et le déclenchement, l'écran doit ressembler à la figure [fig:Halscope-demo-6].

Formes d’ondes avec déclenchement. Pour examiner de près une partie d’une forme d’onde, vous pouvez utiliser le zoom au dessus de l'écran pour étendre la trace horizontalement et le curseur de position pour déterminer quelle partie de l’onde zoomée est visible. Parfois simplement élargir l’onde n’est pas suffisant et il faut augmenter la fréquence d'échantillonnage. Par exemple, nous aimerions voir les impulsions de pas qui sont générés dans notre exemple. Mais les impulsions de pas font seulement 50 us de long, l'échantillonnage à 1kHz n’est pas assez rapide. Pour changer le taux d'échantillonnage, cliquer sur le bouton qui affiche la longueur de l’enregistrement et l'échantillonnage pour avoir le dialogue “Select Sample Rate”, figure [fig:Halscope-demo-7]. Pour notre exemple, nous cliquerons sur le thread “fast”, qui fournira un échantillonnage à environ 20KHz. Maintenant au lieu d’afficher environ 4 secondes de données, un enregistrement est de 4000 échantillons à 20KHz, soit environ 0.20 seconde.

Dialogue de choix d'échantillonnage. Maintenant regardons les impulsions de pas. Halscope dispose de 16 voies, mais pour cet exemple, nous en utilisons seulement 4 à la fois. Avant de sélectionner toute autre voie, nous avons besoin d’en éteindre certaines. Cliquer sur la voie 2, puis sur le bouton "Off'' sous le groupe ‘` vertical''. Ensuite, cliquez sur la voie 3, la mettre off et faire de même pour la voie 4. Même si les circuits sont éteints, ils ont encore en mémoire ce à quoi ils sont connectés et en fait, nous continuerons d'utiliser la voie 3 comme source de déclenchement. Pour ajouter de nouvelles voies, sélectionner la voie 5, choisir la pin `` stepgen.1.dir’, puis la voie 6 et sélectionner "stepgen.1.step'. Ensuite, cliquer sur "mode Normal'' pour lancer le scope, ajustez le zoom horizontal à 5ms par division. Vous devriez voir les impulsions de pas ralentir à la vitesse commandée (voie 1) approcher de zéro, puis la pin de direction changer d'état et les impulsions de pas reprendre de nouveau de la vitesse. Vous aurez peut être besoin d’augmenter le gain sur la voie 1 à environ 20ms par division afin de mieux voir l'évolution de la vitesse de commande. Le résultat devrait être proche de celui de la figure [fig:Halscope-demo-8].

Observer les impulsions de pas. Si vous souhaitez enregistrer plus d'échantillons à la fois, redémarrez le temps réel et chargez halscope avec un argument numérique qui indique le nombre d'échantillons que vous voulez capturer, comme:

halcmd: *loadusr halscope 80000*

Si le composant scope_rt n’est pas déjà chargé, halscope va le charger et lui demander un total de 80000 échantillons, de sorte que lorsque l'échantillonnage se fera sur 4 voies à la fois, il y aura 20000 échantillons par voie. (Si scope_rt est déjà chargé, l’argument numérique passé à halscope sera sans effet)

Les lignes de commandes sont représentées en police bold typewriter. Les réponses de l’ordinateur sont en police typewriter . Depuis début 2006, plus aucune commande ne nécessite les privilèges du root, de sorte que tous les exemples seront précédés par le prompt utilisateur normal, $. Le texte entre crochets est un texte optionnel [comme-cela]. Le texte entre crochets <comme-cela> représente un champ qui peut prendre différentes valeurs, le paragraphe suivant explique les valeurs appropriées. Les items de texte séparés par une barre verticale signifie que l’un ou l’autre, mais pas plus, doit être présent. Toutes les lignes de commandes des exemples supposent que vous êtes dans le répertoire d'emc2/ ou vous avez configuré ou compilé emc2 avec l’option --run-in-place. Les chemins seront par conséquent, affichés en accord avec cet emplacement.

Toutes les entités de HAL sont accessibles et manipulées par leurs noms, donc, documenter les noms des pins, signaux, paramètres, etc, est très important. Les noms dans HAL ont un maximum de 41 caractères de long (comme défini par HAL_NAME_LEN dans hal.h). De nombreux noms seront présentés dans la forme générale, avec un texte entre crochets <comme-cela> représentant les champs de valeurs diverses.

Quand les pins, signaux, ou paramètres sont décrits pour la première fois, leur nom sera précédé par leur type en (PETITES CAPITALES ) et suivi par une brève description. Les définitions typiques de pins ressemblent à ces exemples:

De temps en temps, une version abrégée du nom peut être utilisée, par exemple la deuxième pin ci-dessus pourrait être appelée simplement avec .output quand cela peut être fait sans prêter à confusion.

Les pilotes matériels devraient utiliser cinq champs (sur trois niveaux) pour obtenir un nom de pin ou de paramètre, comme le suivant:

Les champs individuels sont:

Les pilotes matériels ont généralement seulement deux types de fonctions HAL, une qui lit l'état du matériel et met à jour les pins HAL, l’autre qui écrit sur le matériel en utilisant les données fournies sur les pins HAL. Ce qui devrait être nommé de la façon suivante:

(funct) write  — Ecrit la valeur calculée sur la sortie matérielle. Si enable est fausse, la sortie passera à 0, indépendamment des valeurs de value, scale et offset . La signification de “0” dépend du matériel. Par exemple, un convertisseur A/D 12 bits peut vouloir écrire 0x1FF (milieu d'échelle) alors que le convertisseur D/A reçoit 0 Volt de la broche matérielle. Si enable est vraie, l'échelle, l’offset et la valeur sont traités et (scale * value) + offset sont envoyés en sortie de l’adc . Si enable est faux, la sortie passe à 0.

La pin “index-enable” est bi-directionnelle, elle exige un peu plus d’explications. Si “index-enable” est faux, le canal d’index du codeur sera ignoré et le compteur comptera normalement. Le pilote du codeur ne passera jamais “index-enable” sur vrai. Cependant, un autre composant peut le faire. Si “index-enable” est vrai, alors quand la prochaine impulsion d’index arrivera, le compteur du codeur sera remis à zéro et le pilote passera “index-enable” sur faux. Ce qui permettra à l’autre composant de savoir qu’une impulsion d’index est arrivée. C’est une forme de poignée de main, l’autre composant passe “index-enable” sur vrai pour requérir une remise à zéro du comptage d’impulsion d’index et le pilote le repasse sur faux quand la requête à été satisfaite.

Il n’y a qu’une fonction pour lire les codeurs.

Ce composant fonctionne comme dans blocks, y compris la valeur par défaut à 1.0. La déclaration «function _» crée les fonctions nommées constant.0, etc.

component constant;

Ce composant calcule le sinus et le cosinus d’un angle entré en radians. Il a différentes possibilités comme les sorties sinus et cosinus de siggen, parceque l’entrée est un angle au lieu d'être librement basé sur un paramètre frequency.

Les pins sont déclarées avec les noms sin_ et cos_ dans le code source pour que ça n’interfère pas avec les fonctions sin() et cos(). Les pins de HAL sont toujours appelées sincos.<num>.sin.

component sincos;

Ce composant est un pilote pour une carte imaginaire appelée «out8», qui a 8 pins de sortie digitales qui sont traitées comme une simple valeur sur 8 bits. Il peut y avoir un nombre quelconque de ces cartes dans le système et elles peuvent avoir des adresses variées. La pin est appelée out_ parceque out est un identifiant utilisé dans <asm/io.h>. Il illustre l’utilisation de EXTRA_SETUP et de EXTRA_CLEANUP pour sa requête de région d’entrées/sorties et libère cette région en cas d’erreur ou quand le module est déchargé.

component out8;
pin out unsigned out_ "Output value; only low 8 bits are used";
param r unsigned ioaddr;

function _;

option count_function;
option extra_setup;
option extra_cleanup;
option constructable no;

license "GPL";
;;
#include <asm/io.h>

#define MAX 8
int io[MAX] = {0,};
RTAPI_MP_ARRAY_INT(io, MAX, "I/O addresses of out8 boards");

int get_count(void) {
    int i = 0;
    for(i=0; i<MAX && io[i]; i++) { /* Nothing */ }
    return i;
}

EXTRA_SETUP() {
    if(!rtapi_request_region(io[extra_arg], 1, "out8")) {
        // set this I/O port to 0 so that EXTRA_CLEANUP does not release the IO
        // ports that were never requested.
        io[extra_arg] = 0;
        return -EBUSY;
    }
    ioaddr = io[extra_arg];
    return 0;
}

EXTRA_CLEANUP() {
    int i;
    for(i=0; i < MAX && io[i]; i++) {
        rtapi_release_region(io[i], 1);
    }
}

FUNCTION(_) { outb(out_, ioaddr); }

component hal_loop;

Ce fragment de composant illustre l’utilisation du préfixe hal_ dans un nom de composant. loop est le nom d’un module standard du kernel Linux, donc un composant loop ne pourrait pas être chargé si le module loop de Linux est également présent.

Quand il le charge, halcmd montre un composant appelé hal_loop. Cependant, les pins affichées par halcmd sont loop.0.example et non hal-loop.0.example.

Ce composant temps réel illustre l’utilisation d’un tableau de taille fixe:

component arraydemo "Registre à décalage 4-bits";

Ce composant de l’espace utilisateur modifie la valeur de ses pins de sortie vers une nouvelle valeur aléatoire dans l'étendue à chaque ms.

component rand;
option userspace;

pin out float out;
license "GPL";
;;
#include <unistd.h>

void user_mainloop(void) {
    while(1) {
        usleep(1000);
        FOR_ALL_INSTS() out = drand48();
    }
}

component logic "EMC2 HAL component providing experimental logic functions";
pin in bit in-##[16 : personality & 0xff];
pin out bit and if personality & 0x100;
pin out bit or if personality & 0x200;
pin out bit xor if personality & 0x400;
function _ nofp;
description """
Experimental general `logic function' component.  Can perform `and', `or'
and `xor' of up to 16 inputs.  Determine the proper value for `personality'
by adding:
.IP \\(bu 4
The number of input pins, usually from 2 to 16
.IP \\(bu
256 (0x100)  if the `and' output is desired
.IP \\(bu
512 (0x200)  if the `or' output is desired
.IP \\(bu
1024 (0x400)  if the `xor' (exclusive or) output is desired""";
license "GPL";
;;
FUNCTION(_) {
    int i, a=1, o=0, x=0;
    for(i=0; i < (personality & 0xff); i++) {
        if(in(i)) { o = 1; x = !x; }
        else { a = 0; }
    }
    if(personality & 0x100) and = a;
    if(personality & 0x200) or = o;
    if(personality & 0x400) xor = x;
}

loadrt logic count=3 personality=0x102,0x305,0x503

Le préfixe peut être changé en appelant la méthode .setprefix(). Le préfixe courant peut être retrouvé en appelant la méthode .getprefix().

Périodiquement, habituellement dans le temps de réponse de l’horloge, toutes les pins HAL_OUT doivent être «pilotées» en leur assignant une nouvelle valeur. Ceci doit être fait que la valeur soit différente ou non de la valeur précédemment assignée. Quand la pin est connectée au signal, l’ancienne valeur de sortie n’est pas copiée vers le signal, la valeur correcte n’apparaîtra donc sur le signal qu’une fois que le composant lui aura assigné une nouvelle valeur.

La règle mentionnée ci-dessus ne s’applique pas aux pins bidirectionnelles. Au lieux de celà, une pin bidirectionnelle doit seulement être pilotée par le composant et quand le composant souhaîte changer sa valeur. Par exemple, dans l’interface codeur, le composant codeur positionne seulement la pin index-enable à FALSE quand une impulsion d’index est vue et que l’ancienne valeur est TRUE, mais ne la positionne jamais à TRUE. Piloter répétitivement la pin à FALSE pourrait faire qu’un autre composant connecté agisse comme si une nouvelle impulsion d’index avait été vue.