Debian Codegraph @

eyes17/helpFiles/fr/_sources/9.0.rst

raw
1 Programmer ExpEYES à l'aide de Python
2 =====================================
3
4 Les programmes à interface graphique décrit dans les chapitres
5 précédents sont prévus pour un ensemble fini d'expériences. Pour
6 développer de nouvelles expériences, on doit savoir comment accéder
7 aux fonctionnalités d'expEYES par logiciel. Les appels de fonctions
8 importants pour communiquer avec l'appareil sont donnés ci-dessous.
9
10 Établir la Connexion
11 """"""""""""""""""""
12
13 Pour accéder au matériel de EYES17, les modules Python pour ``eyes17``
14 doivent être installés. Il sont censés se trouver dans un répertoire
15 nommé ``eyes17``, qui pourrait être dans votre répertoire personnel
16 ou sur le « Python PATH ».
17
18 **Tout programme doit commencer par les deux lignes suivantes :**
19
20 .. code-block:: python
21
22 import eyes17.eyes
23 p = eyes17.eyes.open()
24
25 La variable ``p`` est l'objet logiciel qui représente le matériel.
26
27 Les sections suivantes expliquent les appels de fonctions Python pour
28 accéder au matériel EYES17. Chaque appel de fonction est expliquer
29 avec un exemple d'utilisation.
30
31 set_pv1(v), set_pv2(v)
32 """"""""""""""""""""""
33
34 Règle la tension continue en PV1 et PV2. L'intervalle pour PV1 est
35 de -5 à 5. L'intervalle pour PV2 est de -3,3 à 3,3.
36
37 .. code-block:: python
38
39 print p.set_pv1(4)
40 print p.set_pv2(2.1)
41
42 La valeur assignée à la sortie est affichée. Mesurer les tensions
43 avec un voltmètre.
44
45 get_voltage(entree)
46 """""""""""""""""""
47
48 Renvoie la tension de l'entrée spécifiée.
49
50 .. code-block:: python
51
52 print p.get_voltage('A1')
53 print p.get_voltage('A2')
54 print p.get_voltage('A3')
55 print p.get_voltage('MIC')
56 print p.get_voltage('SEN')
57
58 Connecter PV1 à A1, et utiliser ``set_pv1()`` et ``get_voltage('A1')``
59 ensemble. Cette fonction ajuste le calibre d'entrée par essais et
60 erreurs, selon la valeur du signal d'entrée.
61
62 get_voltage_time(entree)
63 """"""""""""""""""""""""
64
65 Renvoie un tuple, qui contient le timbre à date de l'ordinateur et
66 la tension à l'entrée spécifiée.
67
68 .. code-block:: python
69
70 print p.get_voltage_time('A1')
71
72
73 get_resistance()
74 """"""""""""""""
75
76 Renvoie la valeur de la résistance connectée à SEN, qui devrait être
77 entre :math:`100~\Omega` et :math:`100~k\Omega` pour une précision raisonnable.
78
79 ..code-block:: python
80
81 print p.get_resistance()
82
83
84 get_capacitance()
85 """""""""""""""""
86
87 Renvoie la valeur de la capacité connectée en IN1 (fonctionne bien
88 dans le domaine du :math:`pF`)
89
90 .. code-block:: python
91
92 print p.get_capacitance()
93
94
95 get_version()
96 """""""""""""
97
98 Renvoie la version du firmware.
99
100 .. code-block:: python
101
102 print p.get_version()
103
104 get_temperature()
105 """""""""""""""""
106
107 Renvoie la température du processeur à l'intérieur de EYES17
108
109 .. code-block:: python
110
111 print p.get_temperature()
112
113
114 set_state(SORTIE=valeur)
115 """"""""""""""""""""""""
116
117 Règle l'état logique de la sortie OD1, SQ1, etc. Connecter OD1 à A1
118 et lancer :
119
120 .. code-block:: python
121
122 p.set_state(OD1=1)
123 print p.get_voltage('A1')
124
125
126 set_sine(frequence)
127 """""""""""""""""""
128
129 Génère le signal sinusoïdal de la fréquence demandée sur WG (intervalle
130 de :math:`5~Hz` à :math:`5000~Hz`). Toutes les valeurs intermédiaires ne sont
131 pas possibles, la fonction renvoie la valeur effectivement adoptée.
132
133 .. code-block:: python
134
135 print p.set_sine(502)
136
137 ``502.00803``
138
139 set_sine_amp(amplitude)
140 """""""""""""""""""""""
141
142 L'amplitude peut être réglée à trois valeurs prédéfinies de tension
143 crête(0 pour avoir :math:`80~mV`, 1 pour avoir :math:`1~V`, 3 pour avoir :math:`3~V`).
144
145 .. code-block:: python
146
147 p.set_sine_amp(2)
148
149 Règle l'amplitude à :math:`3~V` crête.
150
151 set_sqr1(frequence)
152 """""""""""""""""""
153
154 Règle la fréquence de la sortie SQ1 (intervalle de :math:`4~Hz` à :math:`1~MHz`).
155 Toutes les valeurs intermédiaires ne sont pas possibles, la fonction
156 renvoie la valeur effectivement adoptée.
157
158 .. code-block:: python
159
160 print p.set_sqr1(15030)
161
162 ``15030.53``
163
164 set_sqr1_slow(frequence)
165 """"""""""""""""""""""""
166
167 Règle la fréquence de la sortie SQ1 (intervalle de :math:`0,1~Hz` à :math:`1~MHz`).
168 Toutes les valeurs intermédiaires ne sont pas possibles, la fonction
169 renvoie la valeur effectivement adoptée. La résolution est fine mais
170 WG est désactivé quand on commande SQ1 de cette façon.
171
172 .. code-block:: python
173
174 print p.set_sqr1_slow(0.5)
175
176
177 set_sqr2(frequence)
178 """""""""""""""""""
179
180 Similaire à set_sqr1() mais SQ2 n'est pas disponible en même temps
181 que WG, une seule des deux sorties est utilisable à la fois.
182
183 set_sqr1(frequence, rapportCyclique)
184 """"""""""""""""""""""""""""""""""""
185
186 Règle la fréquence de la sortie SQ1 (intervalle de :math:`0,1~Hz` à :math:`1~MHz`).
187 Toutes les valeurs intermédiaires ne sont pas possibles, la fonction
188 renvoie la valeur effectivement adoptée.
189
190 .. code-block:: python
191
192 print p.set_sqr1(1000, 30) #1000 ~Hz, rapport cyclique 30%
193
194
195 get_freq(entree)
196 """"""""""""""""
197
198 Mesure la fréquence d'un signal carré sur l'entrée, IN2 ou SEN. Connecter
199 SQ1 à IN2 et lancer le code :
200
201 .. code-block:: python
202
203 p.set_sqr1(1000)
204 print p.get_freq('IN2')
205
206
207 duty_cycle(entree)
208 """"""""""""""""""
209
210 Mesure le rapport cyclique d'un signal carré , IN2 ou SEN. Connecter
211 SQ1 à IN2 et lancer le code :
212
213 .. code-block:: python
214
215 p.set_sqr1(1000, 30)
216 print p.duty_cycle('IN2')
217
218
219 r2ftime(entree1, entree2)
220 """""""""""""""""""""""""
221
222 Mesure l'intervalle de temps entre un front montant sur input1 jusqu'à
223 un front descendant sur input2, les entrées peuvent éventuellement
224 être les mêmes. On peut l'utiliser pour tester un signal carré.
225
226 Connecter SQ1 à IN2 et lancer le code :
227
228 .. code-block:: python
229
230 p.set_sqr1(1000, 30)
231 print p.r2ftime('IN2', 'IN2')
232
233 ``0.0003``
234
235 Le signal carré à :math:`1~kHz` avec un rapport cyclique de 30% a une
236 période de :math:`1~ms` et reste à l'état HAUT durant :math:`0,3~ms`.
237
238 multi_r2rtime(entree, nbCycles)
239 """"""""""""""""""""""""""""""""
240
241 Mesure l'intervalle de temps entre deux fronts montants de l'entrée
242 ``entree``. La durée entre deux fronts montants est un cycle.
243 On peut spécifier le nombre cycles à mesurer, la valeur par défaut
244 étant 1. Les valeurs autorisées sont 1,2,4,8,12,16,32 et 48. On peut
245 tester ça avec un signal carré.
246
247 Connecter SQ1 à IN2 et lancer le code :
248
249 .. code-block:: python
250
251 p.set_sqr1(1000)
252 print p.multi_r2rtime('IN2', 8)
253
254 ``0.008``
255
256 select_range(canal, calibre)
257 """"""""""""""""""""""""""""
258
259 Les calibres pour A1 et A2 peuvent être réglés depuis :math:`\pm0.5~V`
260 jusqu'à :math:`\pm16~V`, à l'aide d'amplificateurs à gain programmable.
261
262 .. code-block:: python
263
264 p.select_range('A1', 4) # 4 volt maximum
265 p.select_range('A1', 8) # 8 volt maximum
266
267
268 capture1(entree, nbEchantillons, intervalleTemps)
269 """""""""""""""""""""""""""""""""""""""""""""""""
270
271 Numérise l'entrée spécifiée. Le nombre d'échantillons peut aller jusqu'à
272 10000. La durée entre deux échantillons consécutifs est donnée en
273 microseconde (intervalle de :math:`2` à :math:`1000~\mu s`).
274
275 .. code-block:: python
276
277 print p.capture1('A1', 5, 5)
278
279 affichera deux tableaux de dates et de tensions.
280
281 Quand on a besoin de créer un graphique de la tension de sortie pour
282 une meilleure compréhension, on peut le faire à l'aide du module ``matplotlib``,
283 importé grâce à l'interface ``pylab``. Connecter WG à A1 à l'aide
284 d'un fil et lancer :
285
286 .. code-block:: python
287
288 from pylab import *
289 p.set_sine_amp(2)
290 p.set_sine(1000)
291 p.select_range('A1', 4)
292 t,v = p.capture1('A1', 300, 10)
293 plot(t,v)
294 show()
295
296 Le résultat de ce code est donné ci-dessous.
297
298 .. image:: pics/sine-mpl-screen.png
299 :width: 400px
300
301
302 capture2(nbEchantillons, intervalleTemps)
303 """""""""""""""""""""""""""""""""""""""""
304
305 Numérise les entrées A1 et A2 simultanément. Le nombre d'échantillons
306 peut aller jusqu'à 10000. La durée entre deux échantillons consécutifs
307 est donnée en microseconde (intervalle de :math:`2` à :math:`1000~\mu s`).
308
309 Connecter WG à A1, et une diode entre A1 et A2. Lancer le code ci-dessous :
310
311 .. code-block:: python
312
313 from pylab import *
314 p.set_sine_amp(2)
315 p.set_sine(1000)
316 p.select_range('A1', 4)
317 t,v,tt,vv = p.capture2(300, 10)
318 plot(t,v)
319 plot(tt,vv)
320 show()
321
322 Le résultat de ce code est donné ci-dessous.
323
324 .. image:: pics/halfwave-mpl-screen.png
325 :width: 400px
326
327 capture4(nbEchantillons, intervalleTemps)
328 """""""""""""""""""""""""""""""""""""""""
329
330 Numérise les entrées A1, A2, A3 et MIC simultanément. Le nombre d'échantillons
331 peut aller jusqu'à 10000. La durée entre deux échantillons consécutifs
332 est donnée en microseconde (intervalle de :math:`2` à :math:`1000~\mu s`).
333
334 Connecter WG à A3 et lancer le code donné ci-dessous. Le résultat
335 est montré ci-dessus.
336
337 .. code-block:: python
338
339 from pylab import *
340 p.set_sine_amp(2)
341 p.set_sine(1000)
342 p.select_range('A1', 4)
343 res = p.capture4(300, 10)
344 plot(res{[}4{]},res{[}5{]}) # A3
345 plot(res{[}6{]},res{[}7{]}) # MIC
346 show()
347
348
349 .. image:: pics/capture4-mpl-screen.png
350 :width: 400px
351
352 set_wave(frequence, typeDeSignal)
353 """""""""""""""""""""""""""""""""
354
355 Si le paramètre ``typeDeSignal`` n'est pas spécifié, cela génère
356 un signal en utilisant la table d'onde existante. Si ``typeDeSignal``
357 est spécifié ``'sine'`` ou ``'tria'``, la table d'onde
358 correspondante est chargée.
359
360 .. code-block:: python
361
362 from pylab import *
363 p.set_wave(1000, 'sine')
364 p.set_wave(100) # fréq. 100Hz avec la table existante
365 x,y = p.capture1('A1', 500,50)
366 plot(x,y)
367 p.set_wave(100, 'tria') # table d'onde triangulaire et 100 Hz
368 x,y = p.capture1('A1', 500,50)
369 plot(x,y)
370 show()
371
372
373 load_equation(fonction, intervalle)
374 """""""""""""""""""""""""""""""""""
375
376 Crée la table d'onde en utilisant l'équation. Connecter WG à A1 et
377 lancer le code ci-dessous. Le résultat est montré plus bas.
378
379 .. code-block:: python
380
381 from pylab import *
382
383 def f1(x):
384 return sin(x) + sin(3*x)/3
385
386 p.load_equation(f1, [-pi,pi])
387 p.set_wave(400)
388 x,y = p.capture1('A1', 500,10)
389 plot(x,y)
390 show()
391
392
393 load_table(table)
394 """""""""""""""""
395
396 On peut aussi charger la table d'onde avec un tableau de 512 éléments.
397 Connecter WG à A1 et lancer le code ci-dessous. Après l'opération
398 de valeur absolue, la table commence par 256, puis descend jusqu'à
399 0 et enfin remonte jusqu'à 255, ce qui trace un signal triangulaire.
400 Le résultat dû à ce tableau est montré ci-dessus.
401
402 .. code-block:: python
403
404 from pylab import *
405 x = arange(-256, 256)
406 x = abs(x)
407 p.load_table(x)
408 p.set_wave(400)
409 x,y = p.capture1('A1', 500, 10)
410 plot(x,y)
411 show()
412
413
414 .. image:: pics/load-equation-mpl-screen.png
415 :width: 400px
416
417 .. image:: pics/load-table-mpl-screen.png
418 :width: 400px
419