1er paso: enlazar XILINX con Matlab.
Sobre esto no me explayaré mucho pues creo que se puede entender fácilmente y en cualquier caso hay abundante información en Internet sobre el tema.
Lo primero es -dentro del paquete de software de XILINX - encontrar la aplicación con un nombre tal como "System Generator Matlab Configurator", con un icono como el siguiente:
Se hace doble clic en él y tenemos:
Tal y como se ve en la figura activamos la versión de Matlab que queremos enlazar con XILINX, y luego ya según la versión del paquete de software de XILINX, o bien a "OK", a "Apply" o a las dos opciones en la ventana emergente.
Una vez se ha añadido con éxito la versión gratuita de Matlab (con las versiones gratuitas de las dos compañías no suele haber problemas), tenemos que buscar otro icono muy similar, el "System Generator".
Si no tienes el acceso directo en el escritorio ya depende del sistema operativo que uses el encontrarlo, pero raro es que no esté en el paquete que hayas instalado de XILINX.
Ahora se haría doble clic sobre él y ya tenemos el Matlab abriéndose (a mi me suele tardar en abrirse, si te pasa lo mismo no te preocupes, no hay problema).
Pero de momento no lo vamos a abrir, antes nos vamos a la versión ISE de XILINX que uses o alguna más moderna de Vivado (yo en este tutorial usaré Vivado).
2ndo paso: Crear un nuevo proyecto en XILINX.
Hacemos doble clic sobre el icono del ISE o de Vivado, en este caso yo uso Vivado.
Tenemos:
Si has manejado otras versiones, habrás comprobado que la interfaz varía apreciablemente, no te preocupes, parece todo mucho más diferente de lo que realmente es, la metodología de uso es muy similar y no tendrás problemas para manejarte con rapidez, y sino puedes ayudarte de alguno de los tutoriales de Internet tipo "Quick Start" o "Introducción para principiantes"... etc.
No voy a hacer mucho hincapié en el manejo de la interfaz para que no salga una entrada aún más kilométrica de lo que va a salir. Iré más a lo que yo puedo aportar que a lo que otros ya hayan aportado antes.
3er paso: Modificaciones convenientes del código VHDL.
Primero las explico y luego dejaré el código completamente modificado en un recuadro de dónde puedas copiar y pegar tranquilamente.
Vamos a hacer dos grupos de modificaciones, las primeras dejan el funcionamiento del programa exactamente igual que como estaba. ¿Entonces porqué las hacemos?, se preguntará usted muy razonablemente, pues porque gracias a esas modificaciones en SIMULINK veremos algo más semejante a lo que vimos en el hardware que expliqué en las doce primeras entradas de este blog.
Si no te apetece, no tienes tiempo, no te da la gana... etc de echarles un vistazo no hay problema, el hardware es el que se ve en el clip que aparece al principio del anterior post, no tienes que desplazarte mucho por el blog.
Y si ni por esas, tampoco hay problema, daré una breve explicación a continuación.
Básicamente cuatro leds que se van encendiendo y apagando secuencialmente (como la del coche/auto/carro de la serie televisiva de hace unos años conocida en España como "El Coche Fantástico").
El esquema sería algo así:
Las primeras las vamos a hacer en lo que circulo en verde en el código que muestro a continuación.
En la entidad modificamos:
Tal que:
Además, también pasamos a comentario las deñales declaradas LCD_N y LCD_P que ya vimos en pasados tutoriales que realmente no hacen nada.
Por tanto:
Observese que tan solo hemos pasado el vector led1, a sus cuatro escalares: led1_0, led1_1, led1_2, led1_3.
---------------------------------------------------------------------------------
Nota:
Hay también un cambio de tipografía y espaciado de las letras, esto es debido al cambio en la interfaz de un ISE a un Vivado, en realidad cambia incluso el código de colores, pero eso no lo he querido reflejar para no confundir mucho.
---------------------------------------------------------------------------------
En la arquitectura es simplemente pasar a comentario las asignaciones a las señales LCD_N y LCD_P .
---------------------------------------------------------------------------------
Nota:
Si no estás familiarizado con la terminología de VHDL que no te asuste lo de señal, es un concepto parecido a variable en otros lenguajes (no exactamente igual), a estos conceptos les dediqué una entrada por si interesa.
---------------------------------------------------------------------------------
Hasta ahora, si volviéramos a implementar el programa en el hardware este volvería a funcionar exactamente igual que antes (quién quiera puede probarlo).
Ahora es cuando vienen los cambios necesarios para que se pueda simular de una forma razonable.
Si se analiza el código expuesto, se ve que hay tres procesos presentados de abajo a arriba como: P1, P3 y P2 (si, lo he escrito bien, P3 va detrás de P1, caprichos del programador supongo).
P1 y P3 en realidad lo "único" que hacen es convertir la señal de reloj de entrada clk (de periodo de 20 nanosegundos), a unas fracciones de tiempo de aproximadamente 0,4 segundos. Digamos que temporizan.
Los 0,4 segundos es el tiempo que transcurre entre que se enciende un led, se apaga y se enciende el siguiente.
P2 es el que realmente maneja las salidas a los leds, es el que produce el efecto de una "parpadeo" luminoso de izquierda a derecha. Por tanto es el que gestiona la salida.
Como lo que nos ralentiza de forma exagerada la simulación es el proceso realizado de conversión de nanosegundos a segundos, - es decir de lo que se encargan P1 y P3 -, lo que hacemos es.
Si, en efecto, los eliminamos. Y además también eliminamos la declaración de las señales clk1 y clk2 al principio de la arquitectura.
Pero si no hacemos una modificación más, al hacer un chequeo del código que quede de la "purga" dará error. Eso se evitará modificando en el proceso P2 la lista de señales (que en este caso es clk2).
De forma que:
Es decir, la "lista de señales" (entre parentesis tras la palabra reservada PROCESS) era clk2, y ahora es clk que recordemos era la señal de entrada declarada en la entidad (en el modelo veremos que esa señal de reloj es modificable).
library IEEE; use IEEE.STD_LOGIC_1164.ALL; -- Uncomment the following library declaration if using -- arithmetic functions with Signed or Unsigned values --use IEEE.NUMERIC_STD.ALL; -- Uncomment the following library declaration if instantiating -- any Xilinx primitives in this code. --library UNISIM; --use UNISIM.VComponents.all; entity LEDA_blogVSK is Port ( clk : in STD_LOGIC; led1_0 : out STD_LOGIC:= '1'; led1_1 : out STD_LOGIC:= '1'; led1_2 : out STD_LOGIC:= '1'; led1_3 : out STD_LOGIC:= '1'); --LCD_N : out STD_LOGIC; --LCD_P : out STD_LOGIC); end LEDA_blogVSK; architecture light_blogVSK of LEDA_blogVSK is begin --LCD_N<='0'; --LCD_P<='0'; P2:PROCESS(clk) variable count1:INTEGER RANGE 0 TO 16; --???????????? BEGIN -- IF clk'event AND clk='1'THEN --????????????????? if count1<=4 then --?COUNT1<=9??????? if count1=4 then --?COUNT1=8??COUNT1?? count1:=0; -- end if; -- CASE count1 IS --CASE?????LED1?? WHEN 0=> led1_0<='0'; led1_1<='1'; led1_2<='1'; led1_3<='1'; WHEN 1=> led1_0<='1'; led1_1<='0'; led1_2<='1'; led1_3<='1'; WHEN 2=> led1_0<='1'; led1_1<='1'; led1_2<='0'; led1_3<='1'; WHEN 3=> led1_0<='1'; led1_1<='1'; led1_2<='1'; led1_3<='0'; WHEN OTHERS=> led1_0<='1'; led1_1<='1'; led1_2<='1'; led1_3<='1'; END CASE; count1:=count1+1; end if; end if; end process; end light_blogVSK;
4rto paso: Crear el modelo en SIMULINK.
Ahora ya es el momento de hacer clic en el icono del "System Generator" tal y como explicamos.
Tras lo cual se abrirá el Matlab, que por cierto a mi me tarda en ponerse en marcha, así que si te pasa lo mismo no te preocupes, no se ha quedado "colgado".
Vemos que como tiene la interfaz típica de este tipo de aplicaciones para PC, en la que podemos encontrar en el centro un editor. En este editor está la "traducción" que hace el Matlab del código VHDL a su propio lenguaje.
Pero dónde vamos a simular es en su aplicación gráfica, en SIMULINK, para lo cual buscamos en la pestaña correspondiente y luego hacemos clic en su icono:
En versiones más antiguas al abrir la ventana de SIMULINK realmente abriamos su librería y de ahí de una forma muy intuitiva se abría lo que en SIMULINK se llama un Model o Modelo. En las últimas versiones cambia el aspecto al abrirse SIMULINK, surgiendo una ventana como la de la siguiente figura dónde hay que pulsar con le ratón en "Blank Model" (también indicado en la siguiente figura).
Una vez que se han activado se pueden desplegar, empecemos por la superior (Xilinx Blockset), en la cual haremos clic en "Basic Elements":
Entre los bloques que encontramos en "Basic Elements", tenemos uno que destaca especialmente por su color rojo y característica forma de E (logotipo de XILINX).
Pinchamos sobre él y lo arrastramos sobre nuestro Modelo aún en blanco.
Esa e roja es el bloque "System Generator", en dicho "System Generator" se hace doble clic y se abre una ventana emergente con tres pestañas que vamos a cumplimentar como muestro a continuación:
Vemos que en el apartado "Part" no tenemos nuestra FPGA Spartan-3E, si abrimos el desplegable veremos que simplemente no aparece, esto es porque es ya un modelo relativamente antiguo, y en las librerías que suministra XILINX está descatalogada. No obstante esto no nos va a producir ningún perjuicio, dado que lo que vamos a simular es el algoritmo que implementa el código VHDL, no la FPGA que estemos usando. Seguimos cumplimentando:
Apply y OK.
Antes de seguir es momento de guardar y dar nombre al modelo.
El siguiente paso también merece señalarse. En la misma sub-biblioteca "Basics Elements", hay un bloque llamado "Black Box" que va ser clave para implementar nuestro código VHDL.
Conforme lo arrastremos a nuestro modelo, veremos que surge en el monitor un navegador de Windows (o del sistema operativo que uses).
Haciendo uso de esa ventana navegamos hasta el archivo con el código VHDL (extensión .vhd) que queremos simular, en mi caso -por ejemplo- al código modificado le he llamado LEDA_blogVSK (V de Vivado y SK de SIMULINK). Así que el buscador -que sólo reconoce carpetas y ficheros .vhd - me reconoció el archivo leda_blogvsk.vhd.
En cuanto se le ha asignado un fichero, cambia la forma y toma las entradas y salidas de la entidad en el código VHDL (por eso quería que tuviera cuatro salidas escalares en lugar de una vectorial). Luego aparte con el el "Black Box" activado y el puntero del ratón se le puede aumentar el tamaño o cambiar la forma de cuadrado a rectangular.
Tras esto es importante que hagas clic de nuevo en el "Black Box" (ya transformado) y que te asegures de lo que se muestra en la siguiente figura:
Con los bloques de las librerías de xilinx podremos construir lo siguiente:
Cada uno de los bloques se le hace doble clic encima tras lo cual se tiene una ventana de diálogo desde la que se configura. Veamos la configuración del "Gateway In" y de los "Gatewat Out".
Observamos que la entrada la definimos de tipo booleana y que el periodo es el mismo que hemos puesto anteriormente al bloque "System Generation", 0,5 segundos.
Para completar el modelo ya hacemos uso de bloques de otras librerías, en realidad en este caso he tomado las restantes de la más básica de Simulink, la librería definida sencillamente como "Simulink". Teniendo:
Especial mención vamos a hacer de la fuente "Repeating Sequence", que te da pares de valores y tiempo en secuencia. En realidad podía haber tomado otras fuentes, pero probé con esta y me gustó.
Osea,
Times values:
[0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 21000 22000 23000 24000]
Output values:
[1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
Para terminar volvemos al bloque "System Genrator" y pulsamos el botón "Generate".
Se visualiza un icono en una ventanita que va tomando distintas formas acompañado de textos que nos indican que se está compilando y generando hasta que se queda estático esperando a que pulses en OK. Si no hay mensajes de error es que todo está correcto, al menos en el aspecto formal.
Y salvo que algún detalle que se me pueda haber escapado el modelo ya está listo para ser simulado.
5nto paso: Simulación.
Para simular vamos a la barra de herramientas del modelo abierto, especialmente en la zona superior derecha:
En pasadas entradas vimos que una salida a 1 lógico correspondía a led apagado, y un 0 lógico a led encendido, incluso aunque la intuición indique lo contrario es así. Tiene su explicación - como ya expliqué en una pasada entrada - en el hecho de que las salidas de la FPGA van al cátodo, no al ánodo del led, y no olvidemos que en esencia un led es un diodo. Si todo lo que he dicho te suena a marciano, reset, no leiste nada. Creete que una salida a 1 apaga el led, y una salida a cero lo enciende.
Ahora iniciamos definitivamente el objeto de este tutorial: simular. Para ello me serviré de una grabación hecha de mi modelo en plena simulación:
Hola buena tarde. Oye cada vez que voy a crear un nuevo proyecto, ¿debo hacer esta configuración en Vivado?
ResponderEliminar