Note

Programas con interfaz gráfica descritos en los capítulos anteriores están previstos para un conjunto determinado de experimentos. Para desarrollar nuevas experiencias, uno debe saber cómo acceder a las funcionalidades de expEYES por software. Llamadas de funciones importantes para comunicarse con el dispositivo se dan a continuación.

# Establecer la conexión

Para acceder al hardware EYES17, los módulos Python para `eyes17` debe estar instalado Se supone que están en un directorio denominado `eyes17`, que podría estar en su directorio personal o sobre « Python PATH ».

Todos los programas deben comenzar con las siguientes dos líneas:

    import eyes17.eyes
    p = eyes17.eyes.open()

La variable `p` es el objeto de software que representa el hardware.

Las siguientes secciones explican las llamadas a la función Python para acceder al hardware EYES17. Cada llamada a la función se explica con un ejemplo de uso.

# set_pv1(v), set_pv2(v)

Ajusta el voltaje de CC en PV1 y PV2. El intervalo para PV1 es de -5 a 5. El intervalo para PV2 est de -3,3 a 3,3.

    print p.set_pv1(4)
    print p.set_pv2(2.1)

Se muestra el valor asignado a la salida. Medir los voltajes con un voltímetro

# get_voltage(entrada)

Devuelve el voltaje de la entrada especificada.

    print p.get_voltage('A1')
    print p.get_voltage('A2')
    print p.get_voltage('A3')
    print p.get_voltage('MIC')
    print p.get_voltage('SEN')

Conectar PV1 en A1, y utilizar `set_pv1()` y `get_voltage('A1')` juntos. Esta función ajusta la plantilla de entrada por prueba y error, dependiendo del valor de la señal de entrada..

# get_voltage_time(entrada)

Devuelve una tupla, que contiene el sello de fecha de la computadora y el voltaje en la entrada especificada..

    print p.get_voltage_time('A1')

# get_resistance()

Devuelve el valor de la resistencia conectada en SEN, que debería ser entre 100 Ω y 100 kΩ para una precisión razonable.

..code-block:: python

> print p.get_resistance()

# get_capacitance()

Devuelve el valor de la capacidad conectada en IN1 (funciona bien en el dominio de pF)

    print p.get_capacitance()

# get_version()

Devuelve la versión del firmware.

    print p.get_version()

# get_temperature()

Devuelve la temperatura del procesador dentro de EYES17

    print p.get_temperature()

# set_state(SALIDA=valor)

Establece el estado lógico de la salida OD1, SQ1, etc. Conectar OD1 en A1 y lanzar :

    p.set_state(OD1=1)
    print p.get_voltage('A1')

# set_sine(frecuencia)

Genera la señal sinusoidal de la frecuencia solicitada en WG (intervalo de 5 Hz a 5000 Hz). Todos los valores intermedios no son posibles, la función devuelve el valor realmente adoptado.

    print p.set_sine(502)

`502.00803`

# set_sine_amp(amplitud)

La amplitud se puede establecer en tres valores de voltaje preestablecidos en las cresta (0 para tener 80 mV, 1 para tener 1 V, 3 para tener 3 V).

    p.set_sine_amp(2)

Ajusta la amplitud en 3 V cresta.

# set_sqr1(frecuencia)

Ajusta la frecuencia de la salida SQ1 (intervalo de 4 Hz en 1 MHz). Todos los valores intermedios no son posibles, la función devuelve el valor realmente adoptado.

    print p.set_sqr1(15030)

`15030.53`

# set_sqr1_slow(frecuencia)

Ajusta la frecuencia de la salida SQ1 (intervalo de 0, 1 Hz a 1 MHz). Todos los valores intermedios no son posibles, la función devuelve el valor realmente adoptado. La resolución está bien, pero WG está deshabilitado cuando se ordena SQ1 de esta manera.

    print p.set_sqr1_slow(0.5)

# set_sqr2(frecuencia)

Similar a set_sqr1() pero SQ2 no está disponible al mismo tiempo que WG, sólo se puede usar una de las dos salidas a la vez.

# set_sqr1(frecuencia, cicloDeTrabajo)

Ajusta la frecuencia de la salida SQ1 (intervalo de 0, 1 Hz a 1 MHz). Todos los valores intermedios no son posibles, la función devuelve el valor realmente adoptado.

    print p.set_sqr1(1000, 30)          #1000 Hz, ciclo de trabajo 30%

# get_freq(entrada)

Mide la frecuencia de una señal cuadrada en la entrada, IN2 o SEN. Conectar SQ1 en IN2 e iniciar el código:

    p.set_sqr1(1000)
    print p.get_freq('IN2')

# duty_cycle(entrada)

Mide el ciclo de trabajo de una onda cuadrada, IN2 oo SEN. Conectar SQ1 en IN2 y lanzar el còdigo :

    p.set_sqr1(1000, 30)
    print p.duty_cycle('IN2')

# r2ftime(entrada1, entrada2)

Mide el intervalo de tiempo entre un flanco ascendente en la entrada1 hasta un flanco descendente en la entrada2, las entradas pueden ser las mismas. Se puede usar para probar una onda cuadrada.

Conectar SQ1 en IN2 y lanzar el código :

    p.set_sqr1(1000, 30)
    print p.r2ftime('IN2', 'IN2')

`0.0003`

La señal cuadrada en 1 kHz`con una relación cíclica del30un período de de : math : `1 ms y permanece en el estado ALTO durante 0, 3 ms.

# multi_r2rtime(entrada, nCiclos)

Mide el intervalo de tiempo entre dos bordes ascendentes de la entrada `entrada`. La duración entre dos bordes ascendentes es un ciclo. Se puede especificar el número de ciclos a medir, el valor predeterminado es 1. Los valores permitidos son 1,2,4,8,12,16,32 y 48. Esto se puede probar con una señal cuadrada.

Conectar SQ1 en IN2 y lanzar el código :

    p.set_sqr1(1000)
    print p.multi_r2rtime('IN2', 8)

`0.008`

# select_range(canal, calibre)

Los calibres para A1 y A2 se pueden ajustar desde ±0.5 V hasta ±16 V, utilizando amplificadores de ganancia programables.

    p.select_range('A1', 4)         # 4 volt maximum
    p.select_range('A1', 8)         # 8 volt maximum

# capture1(entrada, nMuestras, intervaloTiempo)

Escanea la entrada especificada. El número de muestras puede subir hasta 10000. La duración entre dos muestras consecutivas se da en microsegundos (intervalo de 2 a 1000 μ s).

    print p.capture1('A1', 5, 5)

mostrará dos tablas de fechas y voltajes.

Cuando necesite crear un gráfico del voltaje de salida para una mejor comprensión, puede hacerlo utilizando el módulo `matplotlib`, importado a través de la interfaz `pylab`. Conectar WG en A1 con la ayuda un hilo y tirar :

    from pylab import *
    p.set_sine_amp(2)
    p.set_sine(1000)
    p.select_range('A1', 4)
    t,v = p.capture1('A1', 300, 10)
    plot(t,v)
    show()

El resultado de este código se da a continuación.

# capture2(nMuestras, intervaloTiempo)

Escanea las entradas A1 y A2 simultáneamente. El número de muestras puede ser de hasta 10000. La duración entre dos muestras consecutivas se da en microsegundos (intervalo de 2 a 1000 μ s).

Conectar WG en A1, y un diodo entre A1 y A2. Iniciar el siguiente código :

    from pylab import *
    p.set_sine_amp(2)
    p.set_sine(1000)
    p.select_range('A1', 4)
    t,v,tt,vv = p.capture2(300, 10)
    plot(t,v)
    plot(tt,vv)
    show()

El resultado de este código se da a continuación.

# capture4(nMuestras, intervaloTiempo)

Escanea las entradas A1, A2, A3 y MIC simultáneamente. El número de muestras puede ser de hasta 10000. La duración entre dos muestras consecutivas se da en microsegundos (intervalo de 2 a 1000 μ s).

Conectar WG en A3 e inicie el código que figura a continuación. El resultado se muestra a continuación.

    from pylab import *
    p.set_sine_amp(2)
    p.set_sine(1000)
    p.select_range('A1', 4)
    res = p.capture4(300, 10)
    plot(res{[}4{]},res{[}5{]})        # A3
    plot(res{[}6{]},res{[}7{]})        # MIC
    show()

# set_wave(frecuencia, tipoDeSenal)

Si el parámetro `tipoDeSenal` no está especificado, esto genera una signal señal utilizando la tabla de ondas existente. Si `tipoDeSenal` está especificada `'sine'` ou `'tria'`, la tabla de onda correspondiente está cargada.

    from pylab import *
    p.set_wave(1000, 'sine')
    p.set_wave(100)          # frec. 100Hz con la tabla corriente
    x,y = p.capture1('A1', 500,50)
    plot(x,y)
    p.set_wave(100, 'tria')  # tabla de onda triangular y 100 Hz
    x,y = p.capture1('A1', 500,50)
    plot(x,y)
    show()

# load_equation(funcion, intervalo)

Crea la tabla de ondas usando la ecuación. Conecte WG a A1 e inicia el código siguiente. El resultado se muestra a continuación.

    from pylab import *

    def f1(x):
        return sin(x) + sin(3*x)/3

    p.load_equation(f1, [-pi,pi])
    p.set_wave(400)
    x,y = p.capture1('A1', 500,10)
    plot(x,y)
    show()

# load_table(tabla)

También puede cargar la tabla de ondas con una matriz de 512 elementos. Conecte WG a A1 e inicie el código a continuación. Después de la operación de valor absoluto, la tabla comienza con 256, luego baja a 0 y finalmente vuelve a 255, que dibuja una señal triangular. El resultado debido a esta tabla se muestra arriba.

    from pylab import *
    x = arange(-256, 256)
    x = abs(x)
    p.load_table(x)
    p.set_wave(400)
    x,y = p.capture1('A1', 500, 10)
    plot(x,y)
    show()