1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
:lang: fr
:toc:
= Créer des composants de l'espace utilisateur
== Utilisation de base en Python
Un composant de l'espace utilisateur commence par créer ses pins et
ses paramètres, puis il entre dans une boucle dans laquelle il va
positionner périodiquement toutes ses sorties en fonction de ses
entrées. Le composant suivant, un passe-tout, copie la valeur vue sur
ses pins d'entrée (_passe_tout.in_) vers ses pins de sortie
(_passe_tout.out_) approximativement une fois par seconde.
----
#!/usr/bin/python
import hal, time
h = hal.component("passe_tout")
h.newpin("in", hal.HAL_FLOAT, hal.HAL_IN)
h.newpin("out", hal.HAL_FLOAT, hal.HAL_OUT)
h.ready()
try:
while 1:
time.sleep(1)
h['out'] = h['in']
except KeyboardInterrupt:
raise SystemExit
----
Copier le listing précédent dans un fichier nommé _passe_tout_, le
rendre exécutable par un _chmod +x_ et le placer dans son _$PATH_.
On peut alors l'essayer en faisant:
+*halrun*+
+halcmd: *loadusr passe_tout*+
+halcmd: *show pin*+
Component Pins:
Owner Type Dir Value Name
03 float IN 0 passe_tout.in
03 float OUT 0 passe_tout.out
+halcmd: *setp passe_tout.in 3.14*+
+halcmd: *show pin*+
Component Pins:
Owner Type Dir Value Name
03 float IN 3.14 passe_tout.in
03 float OUT 3.14 passe_tout.out
== Composants de l'espace utilisateur et délais
Si vous tapez rapidement _show pin_, vous pourrez voir que
_passe_tout.out_ conserve un moment son ancienne valeur de 0. Ceci
est dû à l'appel de la fonction _time.sleep(1)_, qui fait que les pins
de sortie changent d'état, au plus, une fois par seconde.
Parce-que ce composant appartient à l'espace utilisateur,
ce délai peut apparaître plus long, par exemple si la mémoire utilisée
par le composant pass_tout est échangée avec le disque dur,
le délai peut être allongé jusqu'au rafraîchissement de la mémoire.
Ces composants de l'espace utilisateur conviennent parfaitement pour
des éléments tels que des panneaux de contrôle pour lesquels des délais
de l'ordre de quelques millisecondes sont imperceptibles. Ils ne
conviennent pas, en revanche, pour envoyer des impulsions de pas vers
une carte de pilotage de périphériques pour lesquelles les délais
doivent rester de l'ordre de quelques microsecondes, dans tous les
cas.
== Créer les pins et les paramètres
+h = hal.component("passe_tout")+
Le composant lui-même est créé par l'appel du constructeur
_hal.component_. Les arguments sont le nom du composant HAL et
optionnellement, le préfixe utilisé pour les noms de pin et de paramètre.
Si le préfixe n'est pas spécifié, le nom du composant est utilisé.
+h.newpin("in", hal.HAL_FLOAT, hal.HAL_IN)+
Puis les pins sont créées par appels des méthodes sur l'objet
composant. Les arguments sont: pin nom suffixe, type de pin et
direction de la pin. Pour les paramètres, les arguments sont: paramètre
nom suffixe, type de paramètre et direction du paramètre.
.Noms des options de HAL
[width="95%", options="header"]
|========================================
|*Types de Pin et Paramètre:* | HAL_BIT | HAL_FLOAT | HAL_S32 | HAL_U32
|*Directions des pins:* | HAL_IN | HAL_OUT | HAL_IO |
|*Directions des paramètres:* | HAL_RO | HAL_RW | |
|========================================
Le nom complet d'une pin ou d'un paramètre est formé en joignant le
préfixe avec le suffixe par un *.*, comme dans l'exemple où la pin
créée est appelée _passe_tout.in_.
+h.ready()+
Une fois toutes les pins et les paramètres créés, la méthode _.ready()_
est appelée.
=== Changer le préfixe
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()_.
== Lire et écrire les pins et les paramètres
Pour les pins et les paramètres qui sont aussi des identifiants
Python, la valeur est accessible ou ajustable en utilisant la syntaxe
des attributs suivante:
+h.out = h.in+
Pour les pins et les paramètres qui sont aussi des identifiants
Python, la valeur est accessible ou ajustable en utilisant la syntaxe
de sous-script suivante:
+h['out'] = h['in']+
=== Pilotage des pins de sortie (HAL_OUT)
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.
=== Pilotage des pins bidirectionnelles (HAL_IO)
La règle mentionnée ci-dessus ne s'applique pas aux pins
bidirectionnelles. Au lieux de cela, une pin bidirectionnelle doit
seulement être pilotée par le composant et quand le composant souhaite
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_. Positionner de manière répétitive la
pin à _FALSE_ pourrait faire qu'un autre composant connecté agisse
comme si une nouvelle impulsion d'index avait été vue.
== Quitter
Une requête _halcmd unload_ pour le composant est délivrée comme une
exception _KeyboardInterrupt_ . Quand une requête de déchargement
arrive, le processus doit quitter
dans un court laps de temps ou appeler la méthode _.exit()_ sur le
composant si un travail substantiel, comme la lecture ou
l'écriture de fichiers, doit être fourni pour terminer le processus
d'arrêt.
== Idées de projets
- Créer un panneau de contrôle extérieur avec boutons poussoirs,
interrupteurs et voyants. Connecter le tout à un microcontrôleur et
raccorder le microcontrôleur à un PC en utilisant une liaison série.
Python est vraiment capable d'interfacer une liaison série grâce à son
module http://pyserial.sourceforge.net/[pyserial] (Paquet
_python-serial_, dans les dépôts universe d'Ubuntu)
- Relier un module d'affichage à LCD
http://lcdproc.omnipotent.net/[LCDProc] et l'utiliser pour afficher les
informations de votre choix (Paquet _lcdproc_, dans les dépôts universe
d'Ubuntu)
- Créer un panneau de contrôle virtuel utilisant n'importe quelle
librairie d'interface graphique supportée par Python (gtk, qt,
wxwindows, etc)
|
