Debian Codegraph @

eyes17/helpFiles/es/_sources/9.0.rst

raw
1 .. note::
2
3 Programas con interfaz gráfica descritos en los capítulos
4 anteriores están previstos para un conjunto determinado de
5 experimentos. Para desarrollar nuevas experiencias, uno debe saber
6 cómo acceder a las funcionalidades de expEYES por
7 software. Llamadas de funciones importantes para comunicarse con el
8 dispositivo se dan a continuación.
9
10 Establecer la conexión
11 """"""""""""""""""""""
12
13 Para acceder al hardware EYES17, los módulos Python para ``eyes17``
14 debe estar instalado Se supone que están en un directorio
15 denominado ``eyes17``, que podría estar en su directorio personal
16 o sobre « Python PATH ».
17
18 **Todos los programas deben comenzar con las siguientes dos líneas:**
19
20 .. code-block:: python
21
22 import eyes17.eyes
23 p = eyes17.eyes.open()
24
25 La variable ``p`` es el objeto de software que representa el hardware.
26
27 Las siguientes secciones explican las llamadas a la función Python para
28 acceder al hardware EYES17. Cada llamada a la función se explica
29 con un ejemplo de uso.
30
31 set_pv1(v), set_pv2(v)
32 """"""""""""""""""""""
33
34 Ajusta el voltaje de CC en PV1 y PV2. El intervalo para PV1 es
35 de -5 a 5. El intervalo para PV2 est de -3,3 a 3,3.
36
37 .. code-block:: python
38
39 print p.set_pv1(4)
40 print p.set_pv2(2.1)
41
42 Se muestra el valor asignado a la salida. Medir los voltajes
43 con un voltímetro
44
45 get_voltage(entrada)
46 """"""""""""""""""""
47
48 Devuelve el voltaje de la entrada especificada.
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 Conectar PV1 en A1, y utilizar ``set_pv1()`` y ``get_voltage('A1')``
59 juntos. Esta función ajusta la plantilla de entrada por prueba y
60 error, dependiendo del valor de la señal de entrada..
61
62 get_voltage_time(entrada)
63 """""""""""""""""""""""""
64
65 Devuelve una tupla, que contiene el sello de fecha de la computadora
66 y el voltaje en la entrada especificada..
67
68 .. code-block:: python
69
70 print p.get_voltage_time('A1')
71
72
73 get_resistance()
74 """"""""""""""""
75
76 Devuelve el valor de la resistencia conectada en SEN, que debería ser
77 entre :math:`100~\Omega` y :math:`100~k\Omega` para una precisión razonable.
78
79 ..code-block:: python
80
81 print p.get_resistance()
82
83
84 get_capacitance()
85 """""""""""""""""
86
87 Devuelve el valor de la capacidad conectada en IN1 (funciona bien
88 en el dominio de :math:`pF`)
89
90 .. code-block:: python
91
92 print p.get_capacitance()
93
94
95 get_version()
96 """""""""""""
97
98 Devuelve la versión del firmware.
99
100 .. code-block:: python
101
102 print p.get_version()
103
104 get_temperature()
105 """"""""""""""""""
106
107 Devuelve la temperatura del procesador dentro de EYES17
108
109 .. code-block:: python
110
111 print p.get_temperature()
112
113
114 set_state(SALIDA=valor)
115 """""""""""""""""""""""
116
117 Establece el estado lógico de la salida OD1, SQ1, etc.
118 Conectar OD1 en A1 y lanzar :
119
120 .. code-block:: python
121
122 p.set_state(OD1=1)
123 print p.get_voltage('A1')
124
125
126 set_sine(frecuencia)
127 """"""""""""""""""""
128
129 Genera la señal sinusoidal de la frecuencia solicitada en WG (intervalo
130 de :math:`5~Hz` a :math:`5000~Hz`). Todos los valores intermedios no son
131 posibles, la función devuelve el valor realmente adoptado.
132
133 .. code-block:: python
134
135 print p.set_sine(502)
136
137 ``502.00803``
138
139 set_sine_amp(amplitud)
140 """"""""""""""""""""""
141
142 La amplitud se puede establecer en tres valores de voltaje preestablecidos en las
143 cresta (0 para tener :math:`80~mV`, 1 para tener :math:`1~V`, 3 para tener :math:`3~V`).
144
145 .. code-block:: python
146
147 p.set_sine_amp(2)
148
149 Ajusta la amplitud en :math:`3~V` cresta.
150
151 set_sqr1(frecuencia)
152 """"""""""""""""""""
153
154 Ajusta la frecuencia de la salida SQ1 (intervalo de :math:`4~Hz` en :math:`1~MHz`).
155 Todos los valores intermedios no son posibles, la función devuelve
156 el valor realmente adoptado.
157
158 .. code-block:: python
159
160 print p.set_sqr1(15030)
161
162 ``15030.53``
163
164 set_sqr1_slow(frecuencia)
165 """""""""""""""""""""""""
166
167 Ajusta la frecuencia de la salida SQ1 (intervalo de :math:`0,1~Hz` a :math:`1~MHz`).
168 Todos los valores intermedios no son posibles, la función devuelve
169 el valor realmente adoptado. La resolución está bien, pero
170 WG está deshabilitado cuando se ordena SQ1 de esta manera.
171
172 .. code-block:: python
173
174 print p.set_sqr1_slow(0.5)
175
176
177 set_sqr2(frecuencia)
178 """"""""""""""""""""
179
180 Similar a set_sqr1() pero SQ2 no está disponible al mismo tiempo
181 que WG, sólo se puede usar una de las dos salidas a la vez.
182
183 set_sqr1(frecuencia, cicloDeTrabajo)
184 """"""""""""""""""""""""""""""""""""
185
186 Ajusta la frecuencia de la salida SQ1 (intervalo de :math:`0,1~Hz` a :math:`1~MHz`).
187 Todos los valores intermedios no son posibles, la función
188 devuelve el valor realmente adoptado.
189
190 .. code-block:: python
191
192 print p.set_sqr1(1000, 30) #1000 Hz, ciclo de trabajo 30%
193
194
195 get_freq(entrada)
196 """""""""""""""""
197
198 Mide la frecuencia de una señal cuadrada en la entrada, IN2 o SEN. Conectar
199 SQ1 en IN2 e iniciar el código:
200
201 .. code-block:: python
202
203 p.set_sqr1(1000)
204 print p.get_freq('IN2')
205
206
207 duty_cycle(entrada)
208 """""""""""""""""""
209
210 Mide el ciclo de trabajo de una onda cuadrada, IN2 oo SEN. Conectar
211 SQ1 en IN2 y lanzar el còdigo :
212
213 .. code-block:: python
214
215 p.set_sqr1(1000, 30)
216 print p.duty_cycle('IN2')
217
218
219 r2ftime(entrada1, entrada2)
220 """""""""""""""""""""""""""
221
222 Mide el intervalo de tiempo entre un flanco ascendente en la entrada1
223 hasta un flanco descendente en la entrada2, las entradas pueden ser
224 las mismas. Se puede usar para probar una onda cuadrada.
225
226 Conectar SQ1 en IN2 y lanzar el código :
227
228 .. code-block:: python
229
230 p.set_sqr1(1000, 30)
231 print p.r2ftime('IN2', 'IN2')
232
233 ``0.0003``
234
235 La señal cuadrada en :math:`1~kHz`con una relación cíclica del 30% tiene
236 un período de de :math:`1~ms` y permanece en el estado ALTO durante :math:`0,3~ms`.
237
238 multi_r2rtime(entrada, nCiclos)
239 """""""""""""""""""""""""""""""
240
241 Mide el intervalo de tiempo entre dos bordes ascendentes de la entrada
242 ``entrada``. La duración entre dos bordes ascendentes es un ciclo.
243 Se puede especificar el número de ciclos a medir, el valor predeterminado
244 es 1. Los valores permitidos son 1,2,4,8,12,16,32 y 48. Esto se puede probar con
245 una señal cuadrada.
246
247 Conectar SQ1 en IN2 y lanzar el código :
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 Los calibres para A1 y A2 se pueden ajustar desde :math:`\pm0.5~V`
260 hasta :math:`\pm16~V`, utilizando amplificadores de ganancia programables.
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(entrada, nMuestras, intervaloTiempo)
269 """""""""""""""""""""""""""""""""""""""""""""
270
271 Escanea la entrada especificada. El número de muestras puede subir hasta
272 10000. La duración entre dos muestras consecutivas se da en
273 microsegundos (intervalo de :math:`2` a :math:`1000~\mu s`).
274
275 .. code-block:: python
276
277 print p.capture1('A1', 5, 5)
278
279 mostrará dos tablas de fechas y voltajes.
280
281 Cuando necesite crear un gráfico del voltaje de salida para
282 una mejor comprensión, puede hacerlo utilizando el módulo ``matplotlib``,
283 importado a través de la interfaz ``pylab``. Conectar WG en A1 con la ayuda
284 un hilo y tirar :
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 El resultado de este código se da a continuación.
297
298 .. image:: pics/sine-mpl-screen.png
299 :width: 400px
300
301
302 capture2(nMuestras, intervaloTiempo)
303 """"""""""""""""""""""""""""""""""""
304
305 Escanea las entradas A1 y A2 simultáneamente. El número de muestras
306 puede ser de hasta 10000. La duración entre dos muestras consecutivas
307 se da en microsegundos (intervalo de :math:`2` a :math:`1000~\mu s`).
308
309 Conectar WG en A1, y un diodo entre A1 y A2. Iniciar el siguiente código :
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 El resultado de este código se da a continuación.
323
324 .. image:: pics/halfwave-mpl-screen.png
325 :width: 400px
326
327 capture4(nMuestras, intervaloTiempo)
328 """"""""""""""""""""""""""""""""""""
329
330 Escanea las entradas A1, A2, A3 y MIC simultáneamente. El número de muestras
331 puede ser de hasta 10000. La duración entre dos muestras consecutivas
332 se da en microsegundos (intervalo de :math:`2` a :math:`1000~\mu s`).
333
334 Conectar WG en A3 e inicie el código que figura a continuación. El resultado
335 se muestra a continuación.
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 set_wave(frecuencia, tipoDeSenal)
350 """""""""""""""""""""""""""""""""
351
352 Si el parámetro ``tipoDeSenal`` no está especificado, esto genera
353 una signal señal utilizando la tabla de ondas existente. Si ``tipoDeSenal``
354 está especificada ``'sine'`` ou ``'tria'``, la tabla de onda
355 correspondiente está cargada.
356
357 .. code-block:: python
358
359 from pylab import *
360 p.set_wave(1000, 'sine')
361 p.set_wave(100) # frec. 100Hz con la tabla corriente
362 x,y = p.capture1('A1', 500,50)
363 plot(x,y)
364 p.set_wave(100, 'tria') # tabla de onda triangular y 100 Hz
365 x,y = p.capture1('A1', 500,50)
366 plot(x,y)
367 show()
368
369
370 load_equation(funcion, intervalo)
371 """""""""""""""""""""""""""""""""
372
373 Crea la tabla de ondas usando la ecuación. Conecte WG a A1 e
374 inicia el código siguiente. El resultado se muestra a continuación.
375
376 .. code-block:: python
377
378 from pylab import *
379
380 def f1(x):
381 return sin(x) + sin(3*x)/3
382
383 p.load_equation(f1, [-pi,pi])
384 p.set_wave(400)
385 x,y = p.capture1('A1', 500,10)
386 plot(x,y)
387 show()
388
389
390 load_table(tabla)
391 """""""""""""""""
392
393 También puede cargar la tabla de ondas con una matriz de 512 elementos.
394 Conecte WG a A1 e inicie el código a continuación. Después de la operación
395 de valor absoluto, la tabla comienza con 256, luego baja a 0 y finalmente
396 vuelve a 255, que dibuja una señal triangular.
397 El resultado debido a esta tabla se muestra arriba.
398
399 .. code-block:: python
400
401 from pylab import *
402 x = arange(-256, 256)
403 x = abs(x)
404 p.load_table(x)
405 p.set_wave(400)
406 x,y = p.capture1('A1', 500, 10)
407 plot(x,y)
408 show()
409
410
411 .. image:: pics/load-equation-mpl-screen.png
412 :width: 400px
413
414 .. image:: pics/load-table-mpl-screen.png
415 :width: 400px