lunes, 9 de abril de 2018

Resolución de circuitos mediante Python

Python es un leguage interpretado que es muy popular actualmente.

Se usa en un amplio rango de aplicaciones incluyendo las asociadas a cálculos científicos, gracias a las librerias de SciPy.

Esra entrada del blog está ligada a un par de documentos de Google Colaboratory. Los documentos de Colaboratory son Jupyter Notebooks almacenados en una cuenta Google Drive que ejecutan el código en máquinas virtuales propiedad de Google.

De este modo no es necesario tener instalado Python para probar o modificar el código propuesto.

Resolución de circuitos con SymPy

SymPy es una de las librerias de SciPy. Ésta permite realizar cálculo matemáticos simbólicos. Ello es muy útil para resolver circuitos como el que se muestra a continuación:

Para resolver un circuito necesitamos obtener un conjunto de ecuaciones cuya solución es la magnitud que deseamos conocer. En el circuito mostrado, digamos que queremos conocer el valor de Vo en función de Vs, R1, R2 e Is.

Hemos de empezar definiendo simbolos para el circuito. Necesitamos símbolos para los valores de los componentes Vs, R1, R2 e Is y para la solución Vo.Como vamos a resolver el circuito empleando el método nodal que define ecuaciones de corriente en todos los nodos excepto masa, necesitaremos también símbolos para las tensiones nodales  V1 y V2.
Además, usando el método nodal completo, también necesitamos un símbolo, como iVs para la corriente en la fuente de tensión.


# Create the circuit symbols
Vs,iVs,R1,R2,Is,Vo, V1, V2 = sympy.symbols('Vs,iVs,R1,R2,Is,Vo,V1,V2')


Ara definimos las ecuaciones de los nodos 1 y 2. Para hacerlo, inicializamos una lista vacía de ecuaciones y añadimos las dos ecuaciones a la lista. Dado que estamos en el método nodal, esta ecuaciones consisten en aplicar La Ley de Kirchhoff KCL en ambos nodos:


# Create an empty list of equations
equations = []

# Nodal equations
equations.append(iVs-(V1-V2)/R1)       # Node 1
equations.append(Is-(V2-V1)/R1-V2/R2)  # Node 2


En SymPy se asume que todas las ecuacuiones son igual a cero.

En el método nodal también necesitamos añadir una ecuación para cada fuente de tensión que la relacione con las tensiones nodales.
En SymPy, Eq significa igual, por lo que Eq(Vs,V1) significa Vs = V1.

# Voltage source equations
equations.append(sympy.Eq(Vs,V1))


La última ecuación que hemos de añadir es la que contiene la magnitud que deseamos obtener:

# Measurement equations
equations.append(sympy.Eq(Vo,V2))



Con todo ello tenemos ya el conjunto de ecuaciones del circuito:

iVs - (V1 - V2)/R1
Is - V2/R2 - (-V1 + V2)/R1
Eq(Vs, V1)
Eq(Vo, V2)

Estas ecuaciones permiten obtener Vo pero no son necesariamente las mínimas ecuaciones que permiten halla esta solució. En concreto, dado que la primera ecuación contiene una incógnita iVs que no aparece en ninguna otra ecuación, la podemos eliminar de la lista si la única incógnita que deseamos obtener es Vo. En todo caso, no nos hace falta saber esto para resolver el sistema.

En las ecuaciones algunas variables son incógnitas. Haremos una lista de ellas:

unknowns = [V1,V2,iVs,Vo]

A partir de ello podemos resolver el sistema usando la función solve de la libreria SymPy :

# Solve the circuit
solution = sympy.solve(equations,unknowns)


Ello da lugar a la siguiente lista de soluciones para las incógnitas del circuito:

V1 = Vs
V2 = R2*(Is*R1 + Vs)/(R1 + R2)
iVs = (-Is*R2 + Vs)/(R1 + R2)
Vo = R2*(Is*R1 + Vs)/(R1 + R2)

Si deseas más detalles, más soluciones de circuitos o probar el código personalmente, abre este documento colaboratory.


Automatizando la solución

Como se ha visto, hemos seguido la receta del método nodal para resolver el circuito. Ello significa que el método puede ser automatizado. The módulo Python circuit se encarga precisamente de ello. Resuelve un circuito usando la receta del método nodal.

Recordemos otra vez el circuito a resolver:

Lo podemos describir con una lista de componentes y medidas a realizar:

# Circuit 1 definiton
c1 = circuit.circuit()  # New circuit
c1.addV('Vs',1,0,5)     # Vs between 1 and GND with 5 V value
c1.addR('R1',1,2,1000)  # R1 between 1 and 2 with 1000 Ohm value
c1.addR('R2',2,0,1000)  # R2 between 2 and GND with 1000 Ohm value
c1.addI('Is',2,0,0.01)  # Is going from GND to 2 with 10 mA value
c1.addVM('Vo',2,0)      # Measurement Vo between 2 and GND


Una vez definido el circuito podemos resolverlo para la incógnita Vo:

# Symbolic solution
print('Vo =',c1.solution['Vo'],'  (Symbolic)')


Ello da lugar a:

Vo = R2*(Is*R1 + Vs)/(R1 + R2)   (Symbolic)

Obsérvese que esta es exactamente la  misma solución que obtuvimos previamente usando el módulo SymPy aislado.


Dado que hemos indicado los valores de los componentes, podemos obtener también una solución numérica:

# Numeric solution
print('Vo =',c1.particular['Vo'],'V   (Particular)')


Ello da lugar a:

Vo = 7.5 V   (Particular)

Si deseas saber más sobre el módulo circuit, ver otras soluciones o probar tu propio código, abre este documento de google colaboratory.

domingo, 4 de marzo de 2018

Google colaboratory

Esta es una entrada diseñada para incluir enlaces a documentos de Google Colaboratory.

Google colaboratory permite ejecutar código Python en máquinas virtuales de manera que es posible ejecutar y compartir código sin necesidad de tener ningún entorno de ejecución propio. Basta con tener un navegador.

Los documentos de Colaboratory son notebooks Python Jupyter que permiten incluir no sólo código sino texto e imágenes.

Estos documentos pueden ser descargados como ficheros Jupyter  .ipynb y ser ejecutados offline en un entorno Python local.

Para acceder a colaboratory es necesario tener cuenta de Google. Ello basta para ver los documentos, pero si se quiere ejecutar su contenido hay que guardar una copia en la cuenta propia de Google Drive.
 
A continuación muestro los vínculos a documentos creados en Colaboratory. Todos ellos importan un módulo Python calc que incluye funciones de soporte como, por ejemplo, plot11, plot1n y plotnn que asisten en el dibujo de gráficas. El módulo es accesible desde GitHub.

La lista de mis  documentos en Colaboratory va aumentando con el tiempo. La versión actualizada de esta lista se halla en mi Lista de Documentos en Colaboratory.

Sin más, estos son los documentos  actuales, a fecha de la realización de esta entrada, organizados por categorías. De momento todos ellos están en inglés.

Control

Documentos relativos a temas mecánicos y de control

Pendulum
Documento que explica el comportamiento físico de un péndulo y que permite simular su comportamiento.
https://colab.research.google.com/drive/1GAjq-R4cTyVu90KjOd9P0_r4L1dNJNx9



DC Motor
Documento que explica el funcionamiento físico de un motor de contínua y que también permite simular su comportamiento dinámico.
https://colab.research.google.com/drive/1uOeXitZxeUZZdZlmT8d5pZNUr0QXrb5E#scrollTo=t6-DFI-JwoZr



Inverted pendulum
Documento que trata sobre el control de un péndulo invertido, que es intrínsecamente inestable, y que explica como se puede estabilizar usando un controlador PID y un motor eléctrico.
https://colab.research.google.com/drive/1Jpje3UWRr-ZvVKR1SlcwoM-KI1OGBNYA#scrollTo=fmPgBsrTlnvd


Electrónica analógica

Documentos relativos a electrónica analógica

Common Emitter
Documento sobre el funcionamiento de un amplificador sencillo basado en un BJT en configuración de emisor común.
https://colab.research.google.com/drive/1o57vd-1jAhsuXuMI_HxixXEJiKh7cqGU




jueves, 1 de marzo de 2018

SLab actualizado a la version 1.3

Acabo de actualizar el proyecto SLab en Github.

La nueva versión 1.3 afecta a tres ficheros fuente:
slab.py, slab_meas.py, slab_fft.py

Con los cambios incluidos SLab debería funcionar correctamente en Python 2.7 y 3.x

He añadido también un nuevo fichero slabTest.py en el directorio de código principal.  Este fichero permite verificar la funcionalidad básica de SLab de manera que se pueda comprobar que se tiene un entorno SLab funcional.

La versión actual de SLab ha sido probada en Windows (Anaconda) con Python 2.7.10 y 3.5.1.
La funcionalidad básica de SLab se ha probado también en Linux con Python 2.7.

martes, 20 de febrero de 2018

Respecto de las calibraciones de SLab

Este es un breve artículo sobre cuánto se puede confiar en las calibraciones de los DAC en el sistema SLab.

Observando el comando CurveVV de trazado de curvas entrada salida de tensión del módulo DC, se observa que se puede usar la configuración básica que usa DAC1 y ADC1:

 

O también se puede usar una configuración alternativa que usa DAC1, ADC1 y ADC2:


Si la operación DAC1 se ha calibrado adecuadamente, uno puede preguntarse por qué es necesario tomar medidas en Vi usando ADC2.

Bien, la verdad es que no siempre se puede confiar en las calibraciones de los DAC porque pueden depender de la carga aplicada a sus nodos. Los circuitos de los drivers de los DAC, se basan en amplificadores operacionales seguidores o amplificadores no inversores:



  
Los operacionales están limitados en las corrientes que pueden entregar. Ello no afecta a los ADC porque no toman corriente en los nodos que miden, pero si afecta a los DAC que ven la carga asociada a los nodos en los que fuerzan una tensión.

La siguiente figura muestra un circuito de prueba para las capacidades de carga de salida de los DAC. DAC 1 está conectado a ADC1 y a una resistencia R con conexión a tierra.

La siguiente figura muestra las lecturas de ADC en función de los valores de DAC establecidos, para diferentes valores de la resistencia R. Puede se puede ver, el valor programado en el DAC proporciona la tensión adecuada al nodo para resistencias de 10k o más. Para cargas más bajas hay una degradación que aumenta a voltajes más altos. Para una carga de 100 ohmios, el voltaje solo alcanza aproximadamente 1.5 voltios con cierta degradación antes de llegar a este punto.

¿Era de esperar este comportamiento? Bien, la hoja de datos del opamp MCP6002 muestra las siguientes corrientes máximas de cortocircuito:



A 3.3V y 25ºC, la corriente de cortocircuito es de aproximadamente 15 mA. Para una carga de 100 ohmios, por tanto, la tensión máxima será de 1.5 V. Este es el resultado que se muestra en las curvas obtenidas.
Para una resistencia de 1k, el límite de voltaje debe ser de 15 V, pero vemos cierta degradación antes de alcanzar el límite de 3.3V. ¿Porqué es así?

El límite en este caso es el margen de tensión a las alimentaciones. El MCP6002 es un opamp full rail. Ello significa que deben poder alcanzar ambos raíles de alimentación en el voltage de salida. En la práctica, sin embargo, ningún opamp puede ser realmente full rail. Es siempre necesario disponer de alguna diferencia de voltaje entre la salida y las alimentaciones para mantener la corriente de salida. Esta diferencia mínima de voltaje a las alimentaciones se define como voltage headroom. La siguiente figura, tomada de la hoja de datos de opamp, muestra este parámetro para nuestro opamp.


En nuestro caso, para alcanzar 3.3V usando una resistencia de 1k, necesitamos proporcionar 3.3mA. De la curva anterior, podemos ver que necesitamos un margen de aproximadamente 100 mV para mantener esta corriente. Por tanto, no podemos alcanzar los 3.2V y eso es lo que estamos viendo en nuestras mediciones.

El mismo experimento se puede realizar para cargas conectadas a Vdd.

Como es posible imaginar, la degradación será, en este caso, en los voltajes bajos, cuando el opamp necesita drenar más corriente.


Para una corriente de cortocircuito especificada de 15 mA, la caída máxima de voltaje a Vcc será de 1.5 V con una carga de 100 Ohm. Como Vdd es 3.3 V, se obtiene un voltaje mínimo de 1.8 V respecto a la refencia. Más o menos lo que estamos midiendo.
El margen de voltaje también explica por qué no podemos alcanzar el límite de 0V con una carga de 1k.

Eso es todo de momento. Cuando se fuerzan voltajes utilizando SLab o cualquier otro instrumento como una fuente de alimentación o un generador de funciones, siempre hay límites para la carga se puede sorpotar.
Si no se está seguro de que no habrá problemas de carga, es una buena idea medir el valor de voltaje REAL en el nodo en lugar de confiar en el voltaje seleccionado en el instrumento.

En el caso particular del comando CurveVV, el uso de ADC 2 en el nodo forzado por DAC 1 garantiza que las curvas finales obtenidas relacionan la entrada de voltaje REAL con la tensión de salida en el circuito.


lunes, 12 de febrero de 2018

Primera version de SLab

Esta es la primera versión de Small Lab (SLab), un proyecto en el que he estado trabajando durante bastante tiempo.


SLab es un proyecto para desarrollar una herramienta de aprendizaje práctico de electrónica bajo un presupuesto mínimo. La idea es proporcionar, a cualquiera que lo desee, un sistema capaz de inyectar excitaciones en un circuito y obtener mediciones de maner que se a fácil entender, de manera práctica, como operan los circuitos.

Bajo costo significa un costo realmente bajo, menos de 40 € según mis cálculos aproximados para un sistema completo con instrumentación y los componentes para construir los circuitos.

El sistema completo (y algunos avisos)

El sistema Slab está compuesto de la cadena de elementos mostrada en la figura siguiente:


Primero tenemos nuestro circuito bajo prueba. Este es un circuito que nos permite aprender algo sobre electrónica. Luego tenemos una placa de hardware que puede inyectar señales en el circuito y medir el voltaje en algunos de sus nodos. La placa se conecta a un PC donde algunos módulos en lenguaje Python interactúan con la placa enviando comandos a través de una conexión COM serie implementada en USB. El usuario final se halla en el extremo derecho de la cadena enviando comandos de alto nivel para que se ejecuten en el sistema SLab. Esos comandos, si es necesario, se pueden escribir en scripts Python para facilitar las tareas repetitivas. También es posible crear bibliotecas propias que se conecten con las de SLab para ampliar las capacidades del sistema.

Obsérvese la zona de aislamiento roja en el dibujo anterior. Se supone que solo se debe conectar el circuito bajo prueba a la placa de hardware. Ninguna conexión eléctrica, excepto el cable USB, deberá salir de la zona de protección. El circuito también será alimentado solo por la placa de hardware. Operando de esta manera el sistema es bastante seguro.

Si se desea una capa adicional de protección, o no se está seguro de las propias acciones, es posible utilizar un cable USB aislado junto con un HUB con alimentación para conectarse a la placa de harware como en la figura siguiente. De esa forma, es todavía posible podría dañar la placa de hardware o el HUB, pero el PC estará bastante más seguro.

En cualquier caso, siempre se aplica el siguiente descargo de responsabilidad:

El autor de este documento no se hace responsable por ningún daño a usted, sus propiedades o equipos debido al uso del sistema SLab. Esto es cierto tanto si se están siguiendo los procedimientos indicados como si no.
 

El hardware

Para mantener los costes lo más bajos posible, el principal elemento de hardware del sistema es una placa de demostración de un microcontrolador. La placa elegida para esta primera versión es la placa STM32 Nucleo64 F303RE.

Placa Nucleo64 F303RE

¿Por qué esta placa? Bueno, es barata, a dia de hoy solo 9 € en Farnell y es bastante capaz. Incluye el microcontrolador STM32F303RE que tiene dos DACs de 12 bits, cuatro ADCs de 12 bits, 512 KB de flash y 80 KB de SRAM. También soporta MBED. Ello significa que instalar un firmware binario es tan simplemente arrastrarlo sobre la unidad de almacenamiento que aparece en el PC cuando se conecta la placa. Además, la comunicación USB incluye un enlace Serie sobre USB que instala el controlador tan pronto como se conecta la placa a un PC. Finalmente, como MBED es tan fácil de usar, y la placa es mucho más potente que la mayoría de los Arduinos, tener esta placa también te permite jugar con el desarrollo de firmware en tu tiempo libre si así lo deseas.

Usando el software adecuado en la placa, se le puede hacer que envíe señales desde los DAC y lea voltages con las entradas ADC. El problema es que generalmente es necesario añadir algo de buffering para evitar los efectos de carga cuando se conectan ADCs y DACs a un circuito bajo test (CUT).
La siguiente figura muestra una solución adecuada basada en seguidores de tensión, basados en amplificadores operacionales, para todas las salidas DAC y entradas ADC. Observese que también se agrega un LED y una resistencia para poder ver que el CUT está correctamente alimentado.

Drivers para los ADC y DAC
Obsérvese que DAC2, asociado al pin D13, tiene un amplificador no inversor en lugar de un seguidor. Esto es necesario porque, en la placa F303RE, el pin D13 también está conectada a un LED, lo que nos impide utilizar todo el rango de la DAC y estamos limitados a la mitad inferior del rango completo. Esto no es problema, sin embargo, como veremos más adelante.

Es posible implementar el circuito con los drivers en una placa protoboard, sin soldadura, y queda suficiente espacio para un circuito a medir. La siguiente figura muestra la placa F303RE, los drivers y un circuito de prueba compuesto por una resistencia y un diodo.


Si tienes la capacidad de soldar, puedes implementar el circuito de los drivers en un shield. La siguiente figura muestra los controladores en una placa diseñada para Arduino. Esta es un abuena solución porque la placa F303RE tiene conectores compatibles con Arduino.

Driver shield
Si tienes la opción de construir tus propios PCB, se puede crear un shield mejor. La siguiente figura muestra la "Long Board". Incluye la placa F303RE, un shield basado en un PCB fresado que incluye los drivers, una placa de protoboard para el circuito de prueba y un a lámina de aluminio para unirlo todo. Un pequeño laboratorio de electrónica en un sólo 28 x 8 cm. Los detalles están en la documentación de SLab.
 
Long Board

Respecto a la documentación del proyecto. Actualmente está toda en inglés. Ello es debido a que mi tiempo es limitado e intento llegar al máximo de gente. Si tengo tiempo miraré de generarla también en castellano.

La siguiente imagen muestra el diagrama del shield con sus 17 pines macho. Incluye dos pines de masa (GND), un pin de alimentación Vdd de 3,3 V, las dos salidas DAC con búfer, las cuatro entradas ADC con búfer y ocho líneas de E/S digitales. Todo ello se puede controlar desde código escrito en Python.

Dependiendo de los recursos y capacidades disponibles, se puede usar cualquiera de las opciones de hardware para unir la placa MCU de demostración, los controladores y el espacio para montar un circuito a prueba. En cualquier caso, al final, tendrás los elementos que se muestran en la siguiente figura: Una alimentación Vdd, dos salidas DAC y cuatro entradas ADC. También se puede agregar la E/S digital, pero esta no es necesaria para la mayoría de los circuitos analógicos.

Elementos de SLab
Usando los integrados amplificadore operacionales MCP6002 y MCP6004 propuestos, se obtiene una impedancia de entrada muy alta en los ADC, y una operación full rail casi completa dentro del rango de 3,3V de la placa. Las capacidad de suministrar corriente del los amplificadores operacionales no son es muy grande grandes, pero, como estamos alimentando el sistema desde el puerto USB, de todos modos estamos bastante limitados en la corriente disponible.

Sería posible diseñar un circuito de interfaz con más rango de voltaje y corriente. Y se hará en el futuro, pero, por ahora, la idea es mantener el sistema lo más barato y simple posible. Hacer un mejor circuito de interfaz no es difícil en absoluto, el problema es que esté disponible, a bajo costo, para todos.

El software

Un mal software puede hacer que un dispositivo de instrumentación de bajo presupuesto sea una pesadilla de usar, y desarrollar un buen software es difícil y lleva mucho tiempo. Para este proyecto, he aprovechado la gran biblioteca de Python y, en particular, de algunas bibliotecas de SciPy (NumPy y Matplotlib).

Pero Python no es fácil de usar en la placa F303RE y, además, sería muy ineficiente para realizar mediciones temporizadas. Por lo tanto, el sistema completo necesita un elemento adicional: el firmware de la placa que es el elemento intermedio entre los ADCs y DACs de la placa y el código de Python en el PC. Este firmware actúa como un servidor para comandos enviados desde un PC cliente.

Sistema SLab completo
La estructura del software se asemeja un tanto al protocolo firmata con un servidor en la placa de hardware y un cliente en el PC. Pero no es firmata. La diferencia principal, aparte del hecho de que la comunicación no es MIDI, es que los comandos pueden incluir la generación de formas de onda y la lectura de secuencias de valores de voltaje a velocidades  de muestreo constantes (hasta aproximadamente 80 kHz con el firmware actual). Algunas funcionalidades, como las de contínua, se podrían realizar agregando una capa de Python a la firmata, pero no a todas, especialmente para las transitorias y de alterna. En general, el sistema SLab está más orientado a las señales analógicas que a las digitales.

El firmware de la placa

Como la placa F303RE está habilitada para MBED, la primera versión del firmware se ha desarrollado en el compilador en la nube de MBED. Planeo diseñar una versión futura del firmware, probablemente sin MBED, para optimizar el código tan cerca como sea posible de los límites de la placa. En la siguiente tabla, puede ver que, cuando se usa un solo canal, el tiempo de muestreo en mediciones transitorias puede ser tan bajo como 13 microsegundos. Esto no es malo del todo para una placa de microcontrolador, pero está lejos de las capacidades de la placa F303RE que pueden obtener frecuencias de muestreo en el rango de MHz. La mayoría de los problemas asociados a usar más de un canal se deben al hecho de que MBED usa sólo un ADC para todas las entradas analógicas. Los cuatro canales no se pueden leer, por tanto, al mismo tiempo. Siempre hay margen de mejora, y seguramente el firmware mejorará. Cuando tengo tiempo, claro.

Capacidades de muestreo
El firmware de la placa se comunica con el PC y básicamente recibe comandos, interactua con el circuito a través de los DAC y ADC, y responde al PC. Algunos ejemplos de comandos son:

  •     Establecer un voltaje en un DAC
  •     Lee el voltaje en una entrada ADC
  •     Leer una secuencia de valores de ADC con una determinada frecuencia de muestre
  •     Almacenar formas de onda que se generarán más adelante en los DAC
  •     Generar formas de onda y leer  la respuesta del circuito a ellas

Lo más complejo que puede hacer el firmware de la placa es generar dos formas de onda arbitrarias diferentes en las dos salidas DAC y leer simultáneamente las cuatro entradas ADC. Después de generar las ondas y leer los ADCs durante un tiempo, los datos se envían al PC para su procesamiento.El protocolo de comunicación entre la placa y la PC está completamente documentado, de modo que si tienes una placa con al menos dos DAC y cuatro entradas ADC y sabes sobre desarrollo de firmwares, puedes crear tu propio firmware para interactuar con el sistema SLab. El enlace de comunicación implementa verificación CRC, pero, como la comunicación USB es bastante fiable a cortas distancias, el objetivo principal del CRC es detectar errores de software.Las capacidades de la placa se leen en el momento en que ésta se conecta al PC, por lo que no es necesario realizar modificaciones en el código del PC si se desarrolla firmware para una nueva placa.

El firmware actual de la placa ocupa aproximadamente 2500 líneas de código "C". Éste se puede obtener en el proyecto SLab en Github. Pero, si sólo quieres usarlo, basta descargar el archivo binario y arrástrarlo en la unidad masiva asociada a la placa que aparece en el PC cuando ésta se conecta.

El firmwar también está disponible en MBED.


El código Python

El firmware de la placa interactua con el circuito por lo que debe estar lo más optimizado posible ya que es quien establece los límites del sistema completo. No obstante, una parte importante del software, es el código Python. Actualmente el proyecto SLab tiene cerca de 6000 líneas de código Python. Realmente no es tanto debido a los comentarios y las líneas en blanco. Aunque los comentarios también son importantes porque generan el subsistema de ayuda SLab. No exactamente doxygen pero es la misma idea.

Para trabajar con un circuito, se abre un intérprete de Python, se importa el módulo SLab, y luego se llama a las funciones de SLab que se comunican con la placa, realizan excitaciones y/o mediciones y devuelven los resultados. Gracias a Matplotlib, los resultados se pueden mostrar en la pantalla y, gracias a NumPy, los resultados se pueden manipular tanto como quieras.
Todo el código SLab Python está incluido en el mismo proyecto Github que el código de firmware.

La primera capa del código Python es el código de calibración. ¿Cómo se obtienen buenas mediciones de los instrumentos? Usando una calibración adecuada, evidentemente. Antes de usar la placa, debe ser calibrada. A partir del procedimiento de calibración, se obtiene un conjunto de curvas, una para cada DAC y ADC que describen cómo se relacionan los valores reales con las entradas o salidas de esos dispositivos. A modo de ejemplo, la siguiente figura muestra las curvas de calibración ratiométricas del DAC que incluyen los drivers indicados en el esquema anterior. Observese cómo el DAC2 tiene una pendiente de dos debido al amplificador no inversor con dos resistencias iguales. Pero no hay problema ya que la calibración se encarga de todo. Una vez que se completa la calibración, puedes olvidarte de ella, SLab se ocupa de los detalles internamente en cada medición.

Curvas de calibración de los DACs

La última capa del código SLab son las funciones que el usuario puede llamar. Esas funciones indican que la placa debe hacer algo y devolver un resultado, si está disponible. Puede ser tan simple como establecer un DAC a valor de voltaje dado o tan complejo como medir la distorsión que un circuito induce en una onda sinusoidal o obtener un diagrama de bode obteniendo la respuesta a varias ondas sinusoidales. Los comandos simples se envían directamente a la placa después de la calibración. Los comandos más complejos requieren más trabajo del código Python.

Algunos ejemplos

Ahora, demos paso a algunos ejemplos de lo que se puede hacer SLab. Puede consultarse la documentación de referencia para obtener más ejemplos. Comencemos jugando con un simple filtro paso bajo:
Filtro paso bajo
Se conecta la salida del DAC1, después del búfer, a la entrada del filtro y la entrada del ADC1, antes del búfer, a la salida del filtro. Luego, se ejecuta el siguiente código de Python. No es necesario usar el modo interactivo, pero siempre es posible usarlo si se desea.



Las primeras seis líneas calculan la respuesta ideal de un filtro paso bajo utilizando NumPy. La sexta línea mide la respuesta frecuencial real del circuito conectado entre DAC1 y ADC1 para el mismo conjunto de frecuencias utilizadas en los cálculos anteriores. Se obtiene el siguiente gráfico que compara las respuestas ideales y las medias justo después del último comando.

Diagramas de Bode

Como el sistema SLab, para mantener bajo el coste, no contiene etapas de amplificación, el rango dinámico no es muy bueno y los diagramas de Bode comienzan a ponerse feos, especialmente en el gráfico de fase, después de niveles de atenuación de unos 30 dB.
Los circuitos pueden ser mucho más complicados. El siguiente circuito usa DAC1 para generar una onda sinusoidal y DAC2 para generar una señal de ruido aleatorio. A partir de esas señales, se generan dos señales diferenciales con ruido común inyectado en V1 y V2. Luego, se usa un amplificador diferencial para rechazar el ruido y recuperar la señal original. En la imagen, los amplificadores de ganancia unitaria son seguidores con operacionales y el amplificador inversor es un amplificador inversor basado en operacional.

Circuito de medida diferencial

El circuito se ha montado en una placa de prueba y se ha probado utilizando el siguiente código que genera las señales, realiza la medición y muestra los resultados. En este caso, aunque SLab incluye la generación de ruido gaussiano y uniforme, usamos llamadas NumPy para generar el ruido.

El siguiente gráfico muestra la señal diferencial, con ruido común, en ADC1 y ADC2. También muestra el ruido en ADC4 y cómo se recupera la señal sin ruido en ADC3. Parece una simulación, pero son medidas reales.

Gráficas del amplificador diferencial
No es necesario proporcionar siempre entradas al circuito. El siguiente ejemplo es un circuito astable, basado en un comparador con histéresis que genera una onda cuadrada.

Circuito Astable
 Las medidas de algunos nodos de circuito se muestran a continuación. El código está aquí.

 
Medidas para el Astable
No siempre es necesario operar con señales variables en el tiempo. También se puede realizar medias de continua. La siguiente figura muestra la corriente del colector para varias corrientes de base en un transistor bipolar BC547. Cada punto de la curva es una lectura de continua independiente con un cierto tiempo entre la configuración de la entrada y la lectura de la salida. El código asociado está aquí.

Curvas características de un transistor bipolar

En el sistema SLab actual estamos limitado al rango de 3.3V de la placa Nucleo. Pero el uso de los dos DAC en configuración de puente puede dar un rango de -3.3V a + 3.3V en algunos circuitos. Este es el caso del rectificador en puente de diodos:

Rectificador en puente de diodos
La resistencia de 100k, R2, proporciona la polarización de las salidas cuando ningún diodo está conduciendo. Puede no tenerse en cuenta para facilitar la comprensión del circuito. La respuesta entrada-salida medida para el circuito se muestra en la siguiente figura:

 
Curva del rectificador en puente de diodos
El código asociado puede encontrarse aquí.


La documentación

Tenemos una placa de hardware. Tenemos el firmware en la placa y el código de Python en el PC. Si sabes lo suficiente sobre electrónica y quieres usar el sistema SLab, solo necesitas agregar la documentación de referencia de SLab y estás listo para jugar con los circuitos.

La documentación actual para configurar el hardware y el software y para la referencia a todas las funciones de SLab (hay unas cuantas) es de 239 páginas en varios archivos PDF. La carpeta de código de Python también incluye una carpeta con 31 ejemplos en archivos de código de Python independientes.

Pero uno de los objetivos del proyecto SLab era aprender electrónica. Es por eso que el proyecto SLab también contiene 222 páginas de tutoriales sobre varios dispositivos y circuitos. Actualmente los temas son:
  
  • Circuitos con amplificadores operacionales en modo lineal (7 archivos) 
  • Circuitos de diodos (4 archivos)
  • Circuitos con BJTs (2 archivos)

Seguiré agregando archivos cuando tenga tiempo. Quizás también agregue algunos experimentos asociados a SLab en el blog.


Ya para acabar

SLab es un proyecto en curso. El abeto de la junta se mejorará en el futuro y se agregarán más tutoriales sobre circuitos. Ahora estamos en la primera versión de lanzamiento 1.2. Todos los archivos se pueden obtener en Github o en un archivo Zip, también en Github.

Quiero terminar esta entrada de blog simplemente mostrando una forma de onda arbitraria, a doble onda, generada con el sistema SLab básicamente como entretenimiento.

Formas de onda arbitrarias

¿Quieres ver el código?  Está aquí.

Este artículo está disponible también, en inglés, en el blog R6500.


Actualizaciones

20/2/2018
Actualizado el código del filtro RC ya que actualmente las funciones AC se hallan contenidas en el módulo slab_ac y no en el módulo principal slab.
Actualizada la descripción del sistema.