Introducción.
Últimamente estoy en este blog casi en exclusiva con los
FPGAs, pero lo cierto es que también he estado siempre muy interesado en los
microcontroladores (y probablemente sepa más de microcontroladores que de
FPGAs). Para que esto no se convierta en el blog del tipo obsesionado con las
FPGAs, voy a introducir esta entrada basándome en un un ejercicio sencillito
que hice ya hace tiempo. En esta ocasión –además- es una nueva oportunidad de
mostrar un posible uso más de Simulink para trabajar con la electrónica.
Normalmente los dispositivos electrónicos trabajan dentro de
otros sistemas dónde también se incorporan dispositivos, mecánicos,
hidráulicos, sensores… etc.
Es por eso que desde hace mucho tiempo que estoy interesado
en software que permita simular sistemas electrónicos trabajando con otro tipo
de sistemas. Matlab y su interfaz gráfica Simulink es una de las soluciones
óptimas (no la única). Una de las opciones que baraje en su día y que vi
bastante ventajosa y asequible es mediante lo que se muestra en este link.
Lo que voy a mostrar a continuación es un ejercicio que me
hice ya hace tiempo y que afortunadamente documenté y no se perdió en el
recuerdo. Espero que ayude un poco a introducirse en este software, o al menos a motivar a investigar lo.
Descripción ejercicio.
Simulación mediante SIMULINK de un sistema sencillo basado
en un microcontrolador de 32 bits de arquitectura ARM7 y posterior prueba
hardware.
- Descripción del
sistema:
• Inputs (entradas o fuentes):
Hice pruebas con dos tipos de entradas:
1 - Tren de pulsos de periodo 2 sg y pulso de 1 sg
(50% del periodo).
- - Interruptor o pulsador.
• Microntrolador:
Microcontrolador de 32 bits de arquitectura ARM7 (más
concretamente el STM32F407VGT) que controla 4 leds mediante la entrada (Input)
por un pin digital (pin PA0):
• Outputs (salidas):
- Led1 (salida
pin PD12) -> Encendido si Input =estado alto o 1 lógico (normalmente del
orden de 3,3 o 5 voltios). Apagado si
input 0 (normalmente GND o tierra).
Input= 1,0 -> Output = 1,0
(reproduce entrada)
- Led2 (salida
pin PD13) -> Encendido si Input =estado alto o 1 lógico (normalmente del
orden de 3,3 o 5 voltios). Es decir lo mismo que el anterior.
Input= 1,0 -> Output = 1,0 (reproduce entrada)
- Led3 (salida
pin PD14) -> Apagado siempre (entrada constante 0 lógico).
Input= 1,0 -> Output = 0
siempre.
- Led14 (salida
pin PD15) -> Encendido si entrada en 0 lógico, apagado si entrada 1
(implementado mediante puerta lógica NOT).
Input= 1,0 -> Output = 0,1 (NOT Input).
--------------------------------------------------------------------------------------------------------------------------
Nota importante: como en las librerías de mi
Matlab-Simulink no hay bloques para simular leds, yo usé bloques para displays
y los configuré para que manejaran información de tipo boolean, si marcan un 1
simula un led encendido, si marca un 0
es led apagado.
Los bloque Scope son para analizar las señales en el tiempo,
especialmente en el caso del tren de pulsos como input o fuente.
--------------------------------------------------------------------------------------------------------------------------
Por cuestiones de tiempo y para no cansar al lector en lo
sucesivo haré uso del “una imagen vale más que mil palabras”, y trataré de
introducir poco texto. Lo he dividido en los siguientes apartados:
Parte1:
Implementación del microcontrolador mediante SIMULINK.
Parte2:
Implementación del sistema completo mediante SIMULINK.
Parte3: Simulaciones.
Parte4: Grabación y
prueba hardware.
Observaciones
finales.
Parte1: Implementación del
microcontrolador mediante SIMULINK.
Implementación en SIMULINK del microcontrolador:
Para crear un subsistema (Subsystem en SIMULINK) con lo
anterior y poder simular con el modelo completo, se introducen 3 cosas:
1 1-
Una puerta OR, para hacer posible la simulación
de la fuente. Si no fuera así la entrada (pin PA0 del microcontrolador de 32
bits, sería por defecto siempre cero).
2 2-
Puertos de entrada.
3 3-
Puertos de salida.
Ahora ya podemos crear el modelo completo con un subsistema
llamado microcontrolador de una entrada y cuatro salidas. Dicho subsistema
aparece en las siguientes figuras recuadrado en amarillo, mis disculpas si no
se resalta bien con el fondo blanco.
Parte2: Implementación del sistema
completo mediante SIMULINK.
- Con una entrada de tren de pulsos (como dije uso displays
para simular leds):
Haciendo
clic en el subsistema microcontrolados (que aunque no se aprecie con claridad
está recuadrado de amarillo), se obtiene algo como esto:
------------------------------------------------------------------------------------------------------------------------------
Parte3: Simulaciones.
- Con tren de pulsos:
Simulación subsistema:
- Con interruptor o pulsador:
1- Pulsador sin oprimir, o
interruptor abierto.
Se observa que
- Display_PD12 (LED1)
y Display_PD13 (LED2) están a 0 (apagados),
- Display_PD14 (LED3)
a 0 apagado también (siempre lo
estará),
- Display_PD15 (LED4)
encendido (NOT input) o a 1 lógico,
lo contrario de la entrada.
Todo tal y como pretendíamos.
2- Pulsador oprimido, o interruptor
cerrado.
Se observa que:
- Display_PD12 (LED1) y Display_PD13 (LED2) están a 1 (encendidos), el pulsador los enciende.
- Display_PD14 (LED3) a 0 apagado (siempre estará apagado, la idea era sólo introducir una constante, dentro del subsistema aunque
en la práctica esto no tenga mucho sentido),
- Display_PD15 (LED4)
apagado (NOT input) o a 0 lógico lo contrario de la entrada.
De nuevo todo tal y como pretendíamos.
La simulación funciona.
Parte4: Grabación y prueba hardware.
Grabación del micro:
Nota: Para los
que empezamos hace años programando microprocesadores (como el 8086) y micros
(como por ejemplo el 8051) en ensamblador, y luego pasamos a C y
C++ como vulgarmente se dice “picando código a mano”, esto no sé si es una
buena noticia que se pueda generar código de forma tan fácil, aunque en honor a
la verdad en determinadas circunstancias puede ser útil.
No obstante trataré de publicar más adelante algún proyecto dónde ahí si
hago el código tecleando en el Keil µVision 5 “a mano”.
Si el micro está de alguna manera conectado al PC (en mi
caso mediante la placa STM32-Discovery que yo uso para pruebas hardware y como
grabadora de otros micros), debe salir algo como:
Prueba hardware:
Para probarlo usé una placa STM32-Discover que funciona con
un micro STM32f407VG.
Antes de mostrar las fotos haré algunas aclaraciones:
- Los dos LEds rojos
cerca de la conexión micro-USB no cuentan, sólo están señalando que
hay alimentación (PWR) y que hay conexión con el puerto COM.
- LED verde ->
LED1 conectado al pin PD12 del micro.
- LED naranja
-> LED2 conectado al pin PD13 del micro.
- LED que no se
enciende del rombo -> LED3
conectado al pin PD14 del micro.
- LED azul -> LED2 conectado al pin PD15 del micro.
1- Pulsador sin oprimir, o
interruptor abierto.
LED1 apagado (0 lógico) -> se
activa con el pulsador
LED2 apagado (0 lógico) -> se
activa con el pulsador
LED3 apagado (0 lógico) -> lo
hemos programado para que esté siempre apagado.
LED4 encendido (1 lógico) -> se
activa con el pulsador no oprimido
y se desactiva con el pulsador
oprimido (NOT Input). Siempre lo contrario que los LED1 Y LED2.
2- Pulsador oprimido, o interruptor cerrado.
LED1 apagado (1 lógico) -> se
activa con el pulsador
LED2 apagado (1 lógico) -> se
activa con el pulsador
LED3 apagado (0 lógico) -> lo
hemos programado para que esté siempre apagado.
LED4 encendido (0 lógico) se
desactiva con el pulsador oprimido y se activa con el pulsador no
oprimido (NOT Input). Siempre lo contrario que los LED1 Y LED2.
Se pueden hacer cosas más complejas, pero hubiera necesitado
más hardware. Con este ejercicio basta
con la placa.
Dejo un clip demostrativo de lo que acabo de explicar.
Observaciones finales:
Matlab+SIMULINK, no es la única herramienta para simular
sistemas electrónicos (también se puede sistemas basados en FPGAs), existen
otras diseñadas para técnicos del sector de la electrónica como son Altium,
Proteus, Eagleconectado + LT Spice, Pspice, Orcad, Workbench… Especialmente si los tienes completos y
debidamente registrados… Muchos de estos tienen la ventaja de que puedes
simular en el esquemático y casi inmediatamente al layout para hacer el diseño
del PCB y la obtención de los archivos gerber para la fabricación.
Ni siquiera es la única forma fácil de generar código, de
hecho no hace mucho descubrí el STM32CubeMX, que no sólo te puede generar
código sino que junto STMStudio se puede llegar a incluso hacer simulaciones.
Una última cosica que no quería dejar pasar, hace muy poco descubrí que también se puede programar micros y hasta FPGAs con MicroPython. MicroPython se basa en un lenguaje de programación llamado Python que es bastante "amigable" en comparación con otros lenguajes.
A decir verdad mi nivel de Python hoy por hoy es tan bajo (oí hablar de él hace tiempo pero me he empezado a enterar de sus bondades y sus aplicaciones en la electrónica hace poco), que hoy por hoy no me puedo considerar ni siquiera con nivel de iniciado.
Para el que le interese esto tan interesante del Python y del MicroPython dejaré por el momento un enlace de un congreso que se celebra en España cada año (en otros países me consta que se celebran congresos y hay comunidades similares y muy interesantes):
http://2016.es.pycon.org/es/
También he descubierto con regocijo sin igual que empieza a haber hardware y software libre (tipo Arduino) para FPGAs también. Pero todo esto mencionado ya ocuparía otra entrada más elaborada.
Una última cosica que no quería dejar pasar, hace muy poco descubrí que también se puede programar micros y hasta FPGAs con MicroPython. MicroPython se basa en un lenguaje de programación llamado Python que es bastante "amigable" en comparación con otros lenguajes.
A decir verdad mi nivel de Python hoy por hoy es tan bajo (oí hablar de él hace tiempo pero me he empezado a enterar de sus bondades y sus aplicaciones en la electrónica hace poco), que hoy por hoy no me puedo considerar ni siquiera con nivel de iniciado.
Para el que le interese esto tan interesante del Python y del MicroPython dejaré por el momento un enlace de un congreso que se celebra en España cada año (en otros países me consta que se celebran congresos y hay comunidades similares y muy interesantes):
http://2016.es.pycon.org/es/
También he descubierto con regocijo sin igual que empieza a haber hardware y software libre (tipo Arduino) para FPGAs también. Pero todo esto mencionado ya ocuparía otra entrada más elaborada.
0 comentarios: