Aprendizaje FPGA y Verilog Una guía para

principiantes
Parte 1 - Introducción

Introducción
Aprender electrónica puede ser un poco desafiante a veces, pero es realmente divertido si tienes un
poco de paciencia para leer, comprender y experimentar. Los FPGA no necesitan ser diferentes.
Vamos a probarlo y ver qué tan rápido y fácil podemos aprender un poco sobre los FPGA y crear un
proyecto de prueba de trabajo simple con este sencillo tutorial de FPGA. Para obtener lo mejor de
esta serie de tutoriales, le recomiendo descargar las herramientas que figuran al final de este
documento e intente seguir cada paso a medida que lo lea.

Hace algún tiempo, quería aprender sobre la programación de FPGA. Comencé a buscar en Google
solo para encontrar que no hay un tutorial de FPGA en la web (ese es el caso cuando este tutorial se
escribió originalmente. ¡Pero debería haber más tutoriales de FPGA disponibles en línea ahora!) Que
pueden ayudarlo a comenzar a aprender un poco HDL y lo llevará a través del diseño, la simulación
y la implementación. Hay muchos tutoriales en línea que lo ayudarán a aprender HDL, algunos
tutoriales le dicen cómo hacer la simulación, algunos pueden informarle sobre la implementación,
pero no hay un tutorial único que lo guíe paso a paso desde lo básico hasta la implementación.

Decidí escribir este tutorial con la esperanza de que pueda ayudar a nuestros lectores a aprender
un poco de Verilog (El HDL que elegí aprender primero debido a su similitud de sintaxis con C),
simular su código e implementarlo en hardware real. Este tutorial espera que tenga conocimientos
básicos en electrónica digital, familiaridad con algún lenguaje de programación (preferiblemente
C). Este tutorial no pretende ser un estudio en profundidad sobre Verilog o FPGAs o cualquier cosa,
sino solo una guía para guiarlo a través de diferentes cosas básicas que necesita saber para diseñar
un circuito digital simple en Verilog, simularlo e implementarlo en hardware.

Usaremos Xilinx ISE para simulación y síntesis. Se prefiere ISE Webpack versión 14.7, que es la
última versión disponible (y la última desde que Xilinx pasó a Vivado). Si se le pregunta durante la
instalación, instale "System Edition" porque también incluirá Xilinx EDK. Tenga en cuenta que las
licencias ISE Webpack y EDK son independientes. Necesitará la licencia ISE instalada para seguir las
siguientes partes de este tutorial. Tenga en cuenta que la licencia de evaluación EDK solo es válida
por 30 días, pero la licencia ISE Webpack es perpetua. El diseño final se programará en una placa de
desarrollo FPGA Elbert - Spartan 3A para asegurarse de que nuestro código también funcione en
hardware real.

También puede seguir una versión alternativa de esta guía utilizando una placa Mimas A7 - Artix 7
FPGA en el siguiente enlace.

¿Qué es la FPGA?
FPGA significa "Field Programmable Gate Array". Como ya sabrás, FPGA es esencialmente una gran
variedad de compuertas que se pueden programar y reconfigurar en cualquier momento en
cualquier lugar. "Gran variedad de compuertas" es una descripción demasiado simplificada de
FPGA. FPGA es de hecho mucho más complejo que una simple matriz de compuertas. Algunos FPGA
tienen bloques duros incorporados, como controladores de memoria, interfaces de comunicación
de alta velocidad, puntos finales PCIe, etc. Pero el punto es que hay muchas compuertas dentro del
FPGA que pueden conectarse arbitrariamente para hacer un circuito de su elección. Más o menos
como conectar circuitos integrados de compuertas lógicas individuales (nuevamente simplificado
en exceso, pero una buena imagen mental, no obstante). Los FPGA son fabricados por compañías
como Xilinx, Altera, Microsemi, etc. Los FPGA son fundamentalmente similares a los CPLD, pero los
CPLD son muy pequeños en tamaño y capacidad en comparación con los FPGA.

¿Cuáles son las aplicaciones de FPGA?

Arquitectónicamente, los FPGA son esencialmente un mar de compuertas que se pueden
reconfigurar para construir casi cualquier circuito digital que uno pueda imaginar. Esta gran
flexibilidad junto con la capacidad de reconfigurar el dispositivo con diferentes diseños a voluntad
hace que FPGA sea una mejor opción en comparación con los ASIC (Circuito Integrado Específico de
Aplicación) para muchas aplicaciones. Por ejemplo, el sistema de aprendizaje profundo, IA o
aceleración de aplicaciones puede reprogramar un solo FPGA con diferentes algoritmos en
diferentes momentos para lograr el mejor rendimiento. Un ASIC no sería tan flexible en tales
situaciones. En ciertas aplicaciones, el número de unidades individuales fabricadas sería muy
pequeño. Diseñar y fabricar ASIC para estas aplicaciones puede ser prohibitivamente costoso. En
tales situaciones, FPGA puede ofrecer soluciones muy rentables pero robustas. Las placas de factor
de forma del módulo, como el Módulo FPGA Narvi Spartan 7, hacen que sea más fácil implementar
las aplicaciones sin requerir que los diseñadores de productos finales se encarguen de detalles
complejos como fuentes de alimentación FPGA, enrutamiento DDR3, etc. aplicaciones de FPGA en
ningún orden en particular.

• Criptografía
• Creación de prototipos ASIC
• Instrumentos industriales, médicos y científicos.
• Procesamiento y transmisión de audio / video e imagen
• Computación de alto rendimiento, inteligencia artificial y aprendizaje profundo
• Aplicaciones militares y espaciales
• Redes, procesamiento de paquetes y otras comunicaciones.

¿Qué es la programación FPGA?

La programación de FPGA o proceso de desarrollo de FPGA es el proceso de planificación, diseño e
implementación de una solución en FPGA. La cantidad y el tipo de planificación varían de una
aplicación a otra. Pero crear un documento de requisitos que capture todos los requisitos
específicos y crear un documento de diseño que explique cómo se implementaría la solución
propuesta puede ser muy útil para enumerar posibles problemas y planificar en torno a ellos. Un
poco de tiempo dedicado a crear un documento de diseño de calidad ahorrará toneladas de tiempo
en la refactorización, depuración y corrección de errores más adelante. La implementación de una
solución en FPGA incluye la construcción del diseño utilizando uno de los métodos de entrada de
diseño, como esquemas o código HDL como Verilog o VHDL, sintetizar el diseño (síntesis,
generación de listas de red, lugar y ruta, etc.) en los archivos de salida que los FPGA puede
comprender y programar el archivo de salida en el dispositivo físico FPGA utilizando herramientas
de programación. Entrar en el diseño usando esquemas ya no se usa ampliamente en la industria.
Por lo tanto, mantendremos la discusión limitada a la entrada de diseño usando HDL (Lenguaje de
descripción de hardware), específicamente Verilog en esta serie de artículos. La síntesis y la
programación se ocupan casi por completo de las herramientas del proveedor, como las
herramientas de configuración ISE y Vivado y Numato Lab. Todos los pasos necesarios que debe
tomar el usuario como parte de la entrada de diseño, síntesis y programación se explicarán en
secciones posteriores.
¿Qué es el RTL?
RTL significa registro de transferencia de nivel. También puede encontrar los términos Registrar la
lógica de transferencia o Registrar el lenguaje de transferencia, todos significan lo mismo en el
contexto del diseño de hardware. RTL es una abstracción de nivel superior para su diseño de
hardware digital y se ubica entre el modelado estrictamente conductual en un extremo y el
modelado estructural puramente de nivel de compuerta en otros extremos. El modelado conductual
se explica en los siguientes artículos de esta serie, así que no se desanime con este término. El
modelado de compuertas significa describir hardware usando compuertas básicas que es bastante
tedioso. RTL también puede considerarse análogo al término "pseudocódigo" utilizado en la
programación de software. Es posible describir el diseño del hardware como secuencias de pasos
(o flujo) de datos de un conjunto de registros al siguiente en cada ciclo de reloj. Por lo tanto, RTL
también se conoce comúnmente como diseño de "flujo de datos". Una vez que el diseño RTL está
listo, es más fácil convertirlo en código HDL real usando lenguajes como Verilog, VHDL,
SystemVerilog o cualquier otro lenguaje de descripción de hardware. HDL y Verilog se explican en
la siguiente sección. Consulte la página de Wikipedia en RTL para obtener más información
(https://en.wikipedia.org/wiki/Register-transfer_level)

¿Qué es Verilog?
En los párrafos anteriores, mencioné la palabra "simplificado en exceso" dos veces. La razón es que
los FPGA son mucho más que un simple grupo de compuertas. Si bien es posible construir circuitos
lógicos de cualquier complejidad simplemente organizando y conectando compuertas lógicas,
simplemente no es práctico ni eficiente. Por lo tanto, necesitamos una forma de expresar la lógica
en un formato fácil de usar que eventualmente se pueda convertir en una matriz de compuertas.
Dos formas populares de lograr esto son la entrada esquemática y las HDL (lenguaje de descripción
de hardware). Antes de que las HDL fueran populares, los ingenieros solían diseñar todo con
esquemas. Los esquemas son maravillosamente fáciles para diseños pequeños, pero son
dolorosamente inmanejables para un diseño grande (¡piense en los ingenieros de Intel que dibujan
esquemas para Pentium, que tiene millones de compuertas! Es inaceptablemente complejo). Si tiene
experiencia en electrónica, su tendencia inicial será usar esquemas para realizar su diseño en lugar
de aprender un nuevo idioma (esto me sucedió, sinceramente). Por las razones antes mencionadas,
nos quedaremos con HDL a lo largo de este tutorial.

Verilog es un lenguaje de descripción de hardware (HDL) que se puede utilizar para describir
circuitos digitales de manera textual. Escribiremos nuestro diseño para FPGA usando Verilog (como
si escribiera programas de microcontroladores en C y Ensamblaje). Aprender Verilog no es tan
difícil si tienes experiencia en programación. VHDL es también otro HDL popular utilizado en la
industria ampliamente. Verilog y VHDL comparten más o menos la misma popularidad en el
mercado, pero elegí Verilog porque es fácil de aprender y su similitud sintáctica con el lenguaje C.
Una vez que se sienta cómodo con Verilog, también debería ser fácil aprender VHDL. ¿Quieres leer
más sobre Verilog? Consulte esta página wiki (http://en.wikipedia.org/wiki/Verilog ) o consulte
este tutorial (http://www.asic-world.com/verilog/index.html).
Parte 2 - Módulos
Aprender Verilog en sí no es una tarea difícil, pero crear un buen diseño puede serlo. Pero aquí nos
centramos en diseños simples y haré todo lo posible para explicar las cosas de la manera más simple
posible. Si hubiera estado programando con lenguajes de procedimiento como C, C ++, tendrá que
decidirse a comprender que no todas las cosas suceden secuencialmente en el mundo digital.
Muchas cosas suceden paralelas también. Cuando comencé a aprender Verilog, solía escribir código
secuencialmente como si estuviera escribiendo un programa en C. Los programas C se ejecutan en
microprocesadores, que ejecutan una instrucción a la vez secuencialmente. Por lo tanto, es fácil
escribir un programa de la forma en que desea que las cosas sucedan paso a paso. Y si nos fijamos
bien, este es el punto débil de los microprocesadores / microcontroladores. Solo pueden hacer una
cosa a la vez, una y solo una cosa (¡por supuesto, estoy hablando de dispositivos de un solo núcleo!).
Pero a diferencia de los microprocesadores, los circuitos digitales (FPGA, CPLD y ASIC) pueden
hacer muchas cosas al mismo tiempo. Y necesita aprender a visualizar muchas cosas que suceden
al mismo tiempo en contraste con muchas cosas que suceden en diferentes momentos, una cosa a
la vez, en un lenguaje de procedimiento.

Módulos Verilog
Un módulo Verilog es una unidad de diseño similar a una caja negra, con un propósito específico
diseñado por el diseñador RTL. Tiene entradas, salidas y funciona según su diseño previsto. Un
módulo Verilog más simple podría ser una simple compuerta NOT, como se muestra en la segunda
imagen a continuación, cuyo único trabajo es invertir la señal de entrada entrante. No hay límite
superior en la complejidad de los módulos Verilog, ¡incluso pueden describir núcleos de procesador
completos! Verilog trata con circuitos digitales. En el reino de Verilog, los módulos pueden
considerarse equivalentes a los componentes de un circuito digital, tan simples como una
compuerta o una entidad compleja como ALU, contador, etc. Los módulos son análogos a las clases
en C ++ de forma autónoma y dar un número finito de métodos (puertos) para interactuar con el
mundo externo. Los módulos se pueden instanciar como las clases también se instancian en C ++.
Pero cuidado; Los módulos no son 100% similares a las clases cuando se implementan. Para una
fácil comprensión, un módulo puede representarse simplemente gráficamente como una caja con
varios puertos. Los puertos pueden ser entradas, salidas o bidireccionales. Los puertos pueden
tener un solo bit o varios bits de ancho. La imagen a continuación representa un módulo con algunas
entradas y salidas. El número de entradas y salidas, su ancho y dirección dependerán únicamente
de la funcionalidad del módulo.
Básicamente, Verilog (o la mayoría de las HDL) se trata de crear módulos, interconectarlos y
administrar el tiempo de las interacciones.
Basta de hablar, ni siquiera escribimos un programa "Hola Mundo" todavía. Entonces, ¿cómo nos
ensuciamos las manos con Verilog? Diseñemos una compuerta NOT en Verilog, simulemos y
probémosla en hardware real. Una compuerta NOT (también conocida como un inversor) sería la
más simple de todas. La salida de un inversor es siempre la negación de la entrada. es decir; B =! A,
donde A es la entrada y B es la salida. La siguiente tabla resume el comportamiento de NOT gate
como una tabla de verdad.

La puerta NOT puede considerarse como un módulo con una entrada y una salida con un
comportamiento interno de B =! A. Consulte la representación gráfica del módulo inversor a
continuación.
Veamos cómo representaríamos esto en Verilog.

module myModule(A, B);

input wire A;
output wire B;
assign B = !A;
endmodule

Muy simple, ¿no es así? repasemos todas y cada una de las líneas e intentemos comprender lo que
sucede en este código.

El nombre del módulo es "myModule" y se declara usando la palabra clave "module". El módulo de
palabras clave en Verilog define nuestro módulo (llamado myModule) y le asigna dos puertos.
Todo lo que entra en este módulo se coloca entre las palabras clave " module " y "endmodule".
"MyModule" tiene dos puertos. El tamaño o la dirección de los puertos aún no se conoce.

En las dos líneas siguientes, el puerto A y el puerto B se declaran como entrada y salida,
respectivamente. ¡Estoy seguro de que tiene curiosidad acerca de lo que la palabra clave "wire"
está haciendo allí! Bueno, en Verilog hay dos tipos de datos fundamentales, “wire” y “reg”. Hay
muchos otros tipos de datos como int, real, etc.… Pero “wire” y “reg” juegan roles muy importantes
en Verilog, que sin aprenderlos no podemos progresar mucho.

Como mencioné antes, conocer un poco de electrónica digital será útil aquí. “wire” es como un
cable físico que usamos para conectar dos cosas diferentes eléctricamente. Si se aplica un
potencial en un extremo del cable de cobre, aparecerá en el otro extremo del cable siempre y
cuando continúe aplicando el potencial. Tan pronto como elimine la entrada, el potencial
desaparecerá. Esto también es cierto para un tipo de datos 'cableados' en Verilog. Un cable tendrá
un estado lógico particular siempre que sea conducido por alguna otra entidad. Si nadie conduce
el cable, estará en un estado desconocido. En Verilog, “wire” puede usarse para conectar cosas
dentro de un módulo o entre dos módulos.

Por otro lado, “reg” puede almacenar un estado lógico y mantenerlo hasta que alguien lo cambie
(piense en un registro en un microcontrolador). Esto es similar a un flip-flop. Si coloca flip-flop en
un estado, permanecerá en ese estado hasta que alguien lo cambie.
Por lo tanto, puede usar el cable como entrada o salida para un módulo y “reg” puede usarse como
la salida de un módulo. Cuando se usa un cable como salida, debe haber un “reg” que impulse el
cable desde el módulo para que el 'cable' tenga información significativa sobre él. Si se usa “reg”
como salida, no se necesita ningún otro mecanismo, ya que puede contener datos por sí mismo.

Entonces, ¿por qué "myModule" tiene entradas y salidas declaradas como cables? Buena pregunta,
la respuesta es, porque el módulo representa una compuerta NOT. Las compuertas nunca
almacenan ningún estado. Las compuertas son puramente combinacionales; es decir, su salida
siempre depende de la entrada actual. Si se aplica algún estado lógico a su entrada, habrá una
salida correspondiente (B =! A en este caso). Si no se aplica ningún estado lógico a la entrada, se
considera un estado desconocido y el estado de salida también será desconocido. Y esto también
implica que, para tener cualquier salida útil de este módulo, alguna otra entidad debería conducir
su entrada desde otro lugar (tenga esto en cuenta, tocaremos este tema más adelante cuando
hablemos sobre el banco de pruebas).

Una cosa más importante sobre el código anterior es la palabra clave " assign". La palabra clave de
asignación se utiliza para crear circuitos combinacionales. Lo que esté escrito en el lado derecho
del signo igual en el enunciado se evaluará y el resultado se asignará a la entidad en el lado
izquierdo y esto sucede de forma asincrónica. Tan pronto como ocurran cambios en el lado
derecho, el resultado se reflejará en el lado izquierdo. Si le resulta difícil entender esto, es posible
que desee leer un poco sobre los circuitos digitales combinacionales.

Ahora que tenemos un fragmento de código, es posible que queramos simular el código para ver si
funciona como se esperaba. La simulación, en un sentido amplio, es el proceso de dar alguna
entrada conocida y generar la salida correspondiente. Se espera que la salida dependa tanto de la
entrada como del comportamiento del módulo bajo prueba. Cuando la salida se verifica contra la
salida esperada, se llama verificación. Hay muchas herramientas disponibles para simulación y
verificación. Aquí usaremos iSim (parte de Xilinx ISE Webpack) para simulación e inspección de
formas de onda.
Parte 3 - Simulación
Ok, tenemos un módulo y herramientas listas ahora, intentemos ejecutar una simulación en el
módulo y ver si funciona como se esperaba. Para simular el módulo, necesitamos dar alguna entrada
al módulo, ¿cómo lo hacemos? La respuesta es que necesitamos crear un test bench (banco de
pruebas). test bench generará las entradas necesarias para el módulo bajo análisis (Aquí
"myModule"). Un test bench no es más que otro módulo Verilog que genera algunas señales y las
alimenta al módulo bajo prueba. Durante la simulación, el test bench debe ser un " top module"
(módulo de nivel superior) sin puertos de I/O. Pero cuando se trata de implementación en FPGA
real, el "módulo superior" puede tener puertos de I/O y los bancos de prueba no serán los módulos
principales allí (hablaremos de esto en detalle más adelante). Así que aquí va el código del banco de
pruebas.
module myModule_tb();
wire out;
reg clock;

always begin
#1 clock =!clock;
end

initial begin
//Initialize clock
clock = 0;

//End simulation
#10
$finish;
end

myModule notGate(clock, out);

endmodule

Deja que te explique esto.

El test bench es solo otro módulo, sin puertos de I/O como mencioné anteriormente. He creado un
cable llamado "out" y un registro llamado "clock". Crearemos un reloj en el "reloj" reg invirtiéndolo
periódicamente y lo alimentaremos a la entrada (puerto A) de myModule. El cable "out" está
conectado al puerto de salida (puerto B) de myModule. El resultado debería aparecer en el cable
"fuera" en la simulación.
El bloque "siempre" es algo que merece una mención especial aquí. Como su nombre lo indica, el
bloque "siempre" se seguirá ejecutando mientras se ejecuta la simulación. En los diseños del mundo
real, los bloques "siempre" son un poco más complicados con las listas de sensibilidad, etc. Pero
para esta simulación, la forma más simple de "siempre" debería ser suficiente. Discutiré esto en
detalle en capítulos posteriores.
En el bloque "siempre", el "reloj" reg se invierte después de cada retraso de la unidad de una sola
vez. El símbolo # es una forma de especificar un retraso en Verilog. Por lo tanto, el bloque always se
ejecuta siempre, y dentro del bloque, el "reloj" se invierte continuamente para que la forma de onda
en el reloj se vea como una onda cuadrada. Recuerde que el símbolo # no es un elemento
sintetizable. Tenemos que encontrar otra forma si el retraso es necesario en nuestro diseño cuando
sintetizamos el código. Pero funciona bien para la simulación.
El siguiente bloque es un bloque inicial. Como su nombre lo indica, este bloque se ejecutará solo una
vez en el tiempo t = 0. Por lo tanto, cualquier cosa que necesitemos inicializar debería ir aquí. El
bloqueo inicial también se usa generalmente solo en bancos de prueba. Los bloques iniciales rara
vez se usan en un código sintetizable, en su lugar, se crea la lógica de reinicio si se requiere
inicialización. Inicializamos el reg "reloj" a cero. Esto es muy importante. Si no inicializamos un
registro, su valor se considera desconocido y no importa cuántas veces se invierta un desconocido,
el resultado siempre será desconocido. Es decir, si dejamos "reloj" sin inicializar, no se generará
"reloj". La última parte del bloque inicial es la directiva $ finish. La directiva $ finish se coloca
después de un retraso de 10 unidades de tiempo, esto significa que después de simular el diseño
para unidades de 10 veces, el estimulador dejará de funcionar. Todas las funciones comienzan con
el símbolo $ se llama tareas. Las tareas son simplemente comandos para el simulador, no alteran el
comportamiento del circuito.
Por último, pero no menos importante, la creación de instancias del módulo. La declaración
"myModule notGate (clock, out)" crea una instancia del módulo "myModule" con el nombre
"notGate". Puede crear tantas instancias como desee desde un módulo. Una cosa realmente
importante aquí es el cableado. Si observa el código, puede ver el "reloj" de registro colocado como
el primer parámetro y el cable "fuera" se coloca como el segundo parámetro. Esto literalmente
significa que el "reloj" de registro está conectado al puerto A de la instancia del módulo y la "salida"
del cable está conectada al puerto B de la instancia del módulo.
Ahora es el momento de ejecutar la simulación. Siga los pasos a continuación para ejecutar la
simulación en Xilinx ISE Webpack (las imágenes se basan en Xilinx ISE Webpack 14.7).
1. Ejecuta el navegador de proyectos ISE desde el menú del programa de Windows. Seleccione
la versión de 32 bits o 64 bits de ISE dependiendo de su sistema operativo.
2. En el menú Archivo, seleccione "Nuevo proyecto"
3. Asigne un nombre a su proyecto, seleccione un directorio para guardar el proyecto y haga
clic en Siguiente (consulte la imagen a continuación).

4. Cambie la configuración del proyecto según sea necesario. Puede seleccionar la familia y el
dispositivo FPGA según la placa que utilice. Para la placa de desarrollo Mimas V2 Spartan 6
FPGA , debe configurarse como en la imagen a continuación. Para la placa de desarrollo FPGA
Elbert V2 Spartan 3A , la familia de dispositivos será “Spartan 3A y Spartan 3AN”, el
dispositivo será “XC3S50A”, el paquete será TQ144 y la velocidad será -4. Una vez que se
complete la información, haga clic en Siguiente y luego termine.
5. Hemos creado un proyecto vacío en Xilinx ISE Webpack. Ahora haga clic derecho en el
proyecto y seleccione "Nueva fuente" en el menú emergente.

6. Seleccione "Módulo Verilog" como el tipo de fuente y escriba el nombre del archivo como se
muestra en la imagen a continuación.
 7. Reemplace la plantilla del módulo autogenerado (o el contenido del archivo completo) con
el código a continuación.
module myModule_tb();
wire out;
reg clock;

always begin
#1 clock =!clock;
end

initial begin
//Initialize clock
clock = 0;

//End simulation
#10
$finish;
end

myModule notGate(clock, out);

endmodule

module myModule(A, B);

input wire A;
output wire B;
assign B = !A;
endmodule
 8. Ahora asegúrese de que estamos en el modo de simulación seleccionando "Simulación" en la
vista de diseño

9. Inicie la simulación haciendo clic con el botón derecho en el proceso "Sim" en la vista de
proceso y seleccionando "Ejecutar" (El archivo Verilog myModule_sim.v debe seleccionarse
en la Vista de diseño para que esta opción sea visible).

10. Ahora se iniciará el simulador ISim y se le presentará una forma de onda de simulación como
la siguiente (a veces puede que tenga que acercar / alejar un poco para ver la forma de onda
correctamente).

Inspeccione la forma de onda y asegúrese de que nuestro módulo Verilog funcione como se
esperaba. Como puede ver en la imagen de arriba, la salida es la forma invertida del reloj de entrada.
Esto es exactamente lo que esperamos de una compuerta NOT. En la parte 4 de este tutorial,
implementaremos este módulo en hardware real.
Parte 4 – Síntesis
Hasta ahora aprendimos algunas cosas sobre Verilog y cómo crear un módulo en Verilog y ejecutar
una simulación. Si bien la simulación puede decirnos muchas cosas sobre la corrección de nuestro
módulo, no hay nada como ponerlo en un hardware y verlo funcionar. En esta parte del tutorial, lo
guiaremos a través de los pasos para sintetizar el módulo e implementarlo en el hardware de la
placa de desarrollo FPGA Mimas V2 Spartan 6 (o de la placa de desarrollo FPGA Elbert V2 Spartan
3A ).
Como se menciona en la parte 3 de este tutorial, el código del test bench se usa solo para simulación.
Para sintetizar nuestro módulo, tenemos que eliminar el código del banco de pruebas. Para aquellos
que no saben, HDL Synthesis es el paso donde se interpreta el HDL (Verilog / VHDL o cualquier otro
HDL) y se genera una topología de hardware equivalente. Esta topología de hardware será muy
específica para el objetivo FPGA seleccionado. La síntesis es un proceso muy complejo y no
necesitamos conocer las partes internas para poner en funcionamiento nuestro módulo simple.
Utilizaremos la placa de desarrollo FPGA Mimas V2 Spartan 6 para implementar nuestro módulo y
los pasos son muy similares para la placa de desarrollo FPGA Elbert V2 Spartan 3A también. La placa
Mimas V2 tiene una FPGA Xilinx Spartan 6, una SDRAM DDR y algunos otros periféricos a bordo. El
número de pieza de FPGA exacto utilizado en esta placa es XC6SLX9-CSG324. Este es un chip BGA
CSG324 de 324 pines con celdas lógicas de 9K. La imagen a continuación muestra la parte de los
esquemas donde se conectan las I/O FPGA para LED e interruptores de botón. Usaremos un
interruptor de botón y un LED para implementar nuestra lógica.

Volvamos a nuestro módulo y pensemos cómo podemos implementar lo mismo en el hardware. El

módulo en cuestión es una compuerta NOT. Como sabemos, la salida de una compuerta NOT es
siempre la negación de la entrada. Podemos tener muchas configuraciones de hardware posibles
para probar este módulo. Lo más fácil sería con un interruptor y un LED. Consulte la configuración
de hardware propuesta en la imagen a continuación.

En el diagrama anterior, un interruptor está conectado a una entrada que se eleva a VCC utilizando
una resistencia. La salida está conectada a un LED. Tomemos un momento para entender cómo se
comportará este circuito. Cuando el interruptor está en posición abierta, habrá un voltaje positivo,
es decir; un 1 lógico en la entrada (A) de la compuerta NOT. Eso significa que la salida (B) estará en
la lógica 0. Por lo tanto, el LED estará apagado. Cuando el interruptor está cerrado, la entrada de la
compuerta NOT se convertirá en lógica 0 y la salida cambiará al estado lógico 1. Y el LED brillará.
Ahora conocemos los requisitos básicos de hardware. Necesitamos lo siguiente en nuestro posible
hardware.
1. Una entrada IO capaz con una resistencia pull-up y un interruptor conectado.
2. Una salida capaz de IO con un LED conectado.
Echemos un vistazo más de cerca a la placa de desarrollo Mimas V2 Spartan 6 FPGA. La siguiente
imagen muestra el LED y el interruptor que planeamos usar en Mimas V2. Elbert V2 también tiene
interruptores integrados y LED que se pueden usar para este propósito. Si está utilizando Elbert V2,
LED8 y Switch SW5 serían buenas opciones (el proyecto adjunto en el tutorial para Elbert V2 usa
SW5 y LED8).
Como vemos en la imagen de arriba, Mimas V2 tiene seis interruptores de botón de propósito
general y ocho LED para la conveniencia del usuario. Ahora podemos echar un vistazo a los
esquemas de Mimas V2 y aprender un poco más sobre dónde están conectados los interruptores y
los LED. Elija nuestro interruptor de botón SW3 y LED8 para nuestro propósito. Mirando en los
esquemas revela que SW3 está conectado a IO M16 y LED8 está conectado a T18 del FPGA
respectivamente (M16 y T18 no son los nombres de IO, sino que son los nombres de las bolas de
BGA a las que están conectados los IO).

Ahora tenemos un módulo Verilog que queremos implementar y hemos seleccionado una
plataforma de hardware y hemos decidido qué IO usar para la implementación. Volvamos a visitar
nuestro módulo. Volveré a publicar el código del módulo aquí.

module myModule(A, B);

input wire A;
output wire B;
assign B = !A;
endmodule

Nuestro módulo tiene dos puertos. Puerto A, que es la entrada y Puerto B, que es la salida. Un lector
atento estaría preguntando ahora, ¿cómo vamos a conectar el Puerto A a M16 del hardware y el
Puerto B a T18 del hardware? Haremos esto definiendo las restricciones del usuario. Las
restricciones del usuario le indican al enrutador y a la lógica de ubicación (que es parte del
sintetizador HDL) en qué pines físicos se deben conectar las señales del módulo. Hacemos una lista
de restricciones y la colocamos en un archivo e incluimos ese archivo en el proyecto. Este archivo
se llama un archivo de restricciones de usuario. Para las herramientas Xilinx, es un archivo de texto
con extensión .ucf. Afortunadamente, el archivo de restricciones de usuario para Mimas V2 ya está
disponible para descargar en la página del producto. Este archivo tiene definiciones para todas las
I/O disponibles en Mimas V2. Pero no los necesitamos a todos. Así que eliminaré la parte no utilizada
y publicaré el contenido del archivo requerido aquí.

# User Constraint File for NOT gate implementation on Mimas V2

# Onboard LEDs
NET “LED” LOC = T18;

# Push Button Switches.

# Internal pull-ups need to be enabled since
# there is no pull-up resistor available on board
NET “SW” PULLUP;

NET “SW” LOC = M16;

El contenido de este archivo se explica por sí mismo. En la línea No.4 dice que la Red(NET) del LED
(la red es equivalente al cable / conexión en el circuito físico) está conectado al pin físico T18. Es
posible que haya notado la parte NET "SW" PULLUP. Esto significa que el SW neto se elevará a VCC.
Muchos de los IO de FPGA tienen resistencias pull-up incorporadas disponibles. Estas resistencias
se pueden activar al mencionarlas adecuadamente en el archivo de restricciones del usuario. Eso es
exactamente lo que hace esta línea en particular. La línea No. 11 conecta el SW neto al IO físico M16.
Bueno, esto todavía no responde cómo se van a conectar los puertos de nuestro módulo al
conmutador y al LED. Como he mencionado antes, los puertos de un módulo son equivalentes a los
cables que entran y salen del módulo. Eso, a su vez, es equivalente a una red. Entonces podemos
usar los nombres de puerto como nombres de red en el archivo de restricciones de usuario.
Entonces, si modificamos el código de restricciones de usuario anterior para nuestro módulo de
compuerta NOT, se verá más o menos así.

# User Constraint File for NOT gate implementation on Mimas V2

# Onboard LEDs
NET “B” LOC = T18;

# Push Button Switches.

# Internal pull-ups need to be enabled since
# there is no pull-up resistor available on board
NET “A” PULLUP;

NET “A” LOC = M16;

Puede descargar proyectos completos de Xilinx ISE para Mimas V2 y Elbert V2 al final de este
capítulo. Los proyectos contienen archivos .ucf en funcionamiento.
Ahora tenemos casi todo lo que necesitamos para sintetizar el diseño y probarlo. Abra nuestro
proyecto de simulación en Xilinx ISE Webpack y cambie el modo a Implementación y agregue el
archivo de restricciones de usuario en el proyecto como se muestra en la imagen a continuación. No
olvide eliminar el código del banco de pruebas del archivo fuente de Verilog y volver al modo de
"implementación" en la vista de diseño.

Guarde el proyecto y haga clic derecho en el módulo y seleccione "Implementar módulo superior"
en el menú emergente. La síntesis puede tomar de unos segundos a un minuto. Y si todo va bien,
verá muchos círculos verdes con una marca de verificación en la vista Proceso justo debajo de la
vista Jerarquía (consulte la imagen a continuación).

Si algún elemento se vuelve amarillo, significa que hay algún tipo de advertencia. Las advertencias
están bien por el momento. Si algún elemento se vuelve rojo, hay algo que salió mal. Regrese y
verifique todos los pasos.
Hemos sintetizado con éxito el diseño. Ahora es el momento de programar la salida en el hardware.
Nuestra plataforma de hardware Mimas V2 (y Elbert v2) requiere un flujo de bits (el resultado final
del proceso de síntesis) en formato binario sin formato. Pero ISE no genera un archivo de bits
binarios sin formato por defecto. Podemos hacer esto siguiendo los pasos a continuación.
1. Haga clic derecho en la opción "Generar archivo de programación" en la ventana "Procesos".

2. Seleccione "Propiedades del proceso" en el menú emergente. En el cuadro de diálogo,

marque la casilla de verificación "Crear archivo de configuración binaria" y haga clic en
"Aplicar".
 3. Haga clic en "Aceptar" para cerrar el cuadro de diálogo. Haga clic derecho en la opción
"Generar archivo de programación" en la vista de proceso a la izquierda y seleccione
"Ejecutar". Ahora podrá ver un archivo .bin en el directorio del proyecto y ese archivo se
puede usar directamente para la configuración de Mimas V2.
Ahora descargue myModule.bin (debe estar en el directorio del proyecto si todo va bien) a la placa
de desarrollo Mimas V2 FPGA. Consulte el manual del usuario de Mimas v2 para obtener más
información sobre la descarga del archivo binario de salida a Mimas V2. Una vez que se complete la
descarga, presione el interruptor SW3 y verá que se enciende el LED8.
Descargue el proyecto completo de implementación Xilinx ISE para mimas V2
Descargue el proyecto completo de implementación Xilinx ISE para Elbert V2
Parte 5 – Sistema Integrado
Para muchos de nosotros, aprender FPGA fue el siguiente paso natural del mundo de los
microcontroladores y el Sistema Embebido. Aprende los conceptos básicos de Embedded System,
realiza algunos proyectos utilizando microcontroladores y microprocesadores y un día se da cuenta
de que esos dispositivos pueden no ser la mejor opción para un problema en particular que desea
resolver. Un poco de investigación podría llevarlo a FPGA. Pero el mundo FPGA es muy diferente del
mundo de los microcontroladores que has visto hasta ahora. Si bien la experiencia con el
microcontrolador y el sistema incorporado es muy útil, no puede ayudarlo a comenzar con FPGA
sin una curva de aprendizaje algo pronunciada. Las herramientas son diferentes, los lenguajes son
diferentes e incluso el paradigma de programación es diferente.

Pero hay esperanza. Por definición (en términos sueltos), FPGA es un conjunto de elementos lógicos
que se pueden configurar para hacer cualquier circuito lógico. Si eso es cierto, ¿por qué no hacer un
microprocesador a partir de esas celdas lógicas y programas utilizando lenguajes y herramientas
amigables tradicionales de Embedded System? Sí, es posible. Pero hay una pregunta sobre por qué
este método de hacer un microprocesador o microcontrolador con lógica FPGA es mejor en
comparación con los microprocesadores disponibles. Hay muchas razones por las que fabricar un
microprocesador / controlador en un tejido FPGA es mejor (o peor) en comparación con un micro
estándar. La razón más importante es que tiene acceso a la estructura FPGA desde el
microcontrolador (a través de buses y periféricos creados dentro de la estructura, por supuesto) y
puede implementar periféricos desde una amplia gama de IP periféricas disponibles de forma
gratuita de Xilinx o crear su IP (o comprar IP de terceros). Es posible hacer prácticamente cualquier
periférico que desee dentro de la capacidad del FPGA con el que ha elegido trabajar. Sin embargo,
hay algunos inconvenientes importantes en este esquema. El costo total del hardware generalmente
será más alto en comparación con un micro disponible para la misma cantidad de potencia de
procesamiento sin procesar. Si no puede encontrar la IP periférica que está buscando, terminará
teniendo que escribir una usando Verilog o VHDL y volverá al punto de partida (recuerde, lo que
queríamos era no lidiar con el flujo de trabajo HDL o FPGA en absoluto). Es posible comprar IP de
terceros, pero dependiendo de la IP específica, puede ser muy costoso. Además, vale la pena
mencionar que las herramientas necesarias para construir un sistema integrado a partir de un FPGA
podrían retrasarlo en unos pocos cientos de dólares.

Echemos un vistazo a cómo se vería un sistema integrado basado en procesador integrado en un

FPGA en su forma más simple. Como puede ver en el diagrama a continuación, un sistema integrado
construido en tejido FPGA no es realmente diferente de cualquier otro sistema integrado. Tiene un
procesador, memoria, buses, periféricos, etc., todo lo que esperaría en una configuración normal de
sistema integrado. Es solo que el procesador, los buses y los periféricos se fabrican utilizando celdas
lógicas que están disponibles dentro de la FPGA.
Como puede ver aquí, puede usar una variedad de periféricos de una variedad de fuentes. Los
periféricos pueden ser periféricos de comunicación como I2C, SPI, USART o núcleos de
procesamiento de señales como FFT, filtros o cualquier cosa que pueda imaginar e implementar en
el tejido FPGA. Esta flexibilidad le da a los sistemas integrados basados en FPGA una ventaja en
algunas situaciones en comparación con los microcontroladores tradicionales donde las opciones
periféricas son a menudo menos flexibles.

Infraestructura integrada por Xilinx

Xilinx es posiblemente el líder mundial en FPGA y otra lógica programable. Proporcionan
herramientas para construir sistemas embebidos alrededor de muchos de sus FPGA. Xilinx ofrece
dos tipos de opciones fundamentales a la hora de implementar un sistema integrado.
1. Procesador instanciado en tela FPGA o los llamados procesadores suaves (Microblaze,
Picoblaze)
2. Procesador duro en el dado que tiene conectividad dedicada al tejido FPGA
Como puede imaginar, los procesadores blandos utilizarán parte del tejido FPGA para funcionar y
usted debe estar contento con lo que queda para implementar sus propios periféricos. Pero con los
núcleos de procesador duro, la estructura FPGA no se usa para implementar el procesador y tendrá
el 100% de la estructura FPGA (o cerca del 100%) para implementar sus propios periféricos. Los
núcleos de procesador duro suelen ser también más potentes. Pero al escribir este artículo, el precio
de los FPGA con núcleos de procesador duro integrados tiende a ser más alto.
Durante este tutorial nos quedaremos con los procesadores Soft, Microblaze para ser específicos.
Esto se debe a que Microblaze se puede implementar en hardware relativamente económico como
Mimas V2 . Tenga en cuenta que el procesador suave Microblaze no es compatible con dispositivos
Spartan 3. Por lo tanto, la información de este tutorial (Parte 5) no es aplicable a la placa de
desarrollo FPGA Elbert V2 .
En términos simples, el desarrollo de un sistema integrado con FPGA Xilinx consta de los siguientes
pasos.
1. Crear un proyecto de sistema integrado basado en Microblaze
2. Agregue periféricos adicionales según sea necesario
3. Configurar el procesador y otros subsistemas
4. Cree el núcleo del procesador y todos los subsistemas para generar un archivo de bits que se
pueda programar en FPGA
5. Cree un proyecto de software que pueda ejecutarse en la infraestructura de hardware ya
creada
6. Escribe tu propio programa en C y construye
7. Descargue todo al FPGA y ejecute
Si bien suena un poco complicado, las poderosas herramientas de Xilinx hacen que sea muy fácil
implementar esos pasos en la práctica. De hecho, implementaremos un sistema integrado que
funcione con menos de 10 líneas de código. Ahora parece que es el momento adecuado para
presentar las herramientas de Xilinx que utilizaremos para llevar a cabo los pasos anteriores.
Usaremos las siguientes herramientas en el resto de este tutorial.
1. Xilinx ISE Webpack 14.7 ( http://www.xilinx.com/products/design-tools/ise-design-
suite/ise-webpack.html )
2. Xilinx Platform Studio
3. Xilinx SDK
ISE es la principal herramienta de diseño de FPGA ofrecida por Xilinx. Este software incluye un IDE
y herramientas asociadas para implementar HDL y realizarlo en hardware. Consulte las partes
anteriores de este tutorial para ver algunos ejemplos de cómo crear y construir proyectos con ISE.
Aunque es importante tener ISE instalado en su sistema para que Platform Studio y SDK funcionen,
no utilizaremos ISE IDE en este tutorial.
Xilinx Platform Studio y SDK juntos a menudo se denominan EDK (Embedded Development Kit).
Xilinx Platform Studio es la herramienta que utilizará para diseñar la parte de hardware del sistema
integrado (procesador, periféricos, buses, etc.). Xilinx SDK es un entorno de desarrollo de software
basado en Eclipse IDE. Muchas personas encontrarán la herramienta SDK visualmente muy familiar
debido a esto. Con el SDK, puede crear proyectos de software y escribir código C que se ejecute en
el Sistema integrado diseñado con Platform Studio. ¿Confuso? no se preocupe, todo se volverá
mucho más claro cuando pasemos por el proceso paso a paso.
Xilinx ISE, Platform Studio y SDK se pueden descargar e instalar desde el sitio web de Xilinx como
un paquete único. Pero tienen licencia por separado. Necesitará una licencia para ISE Webpack
(licencia ilimitada pero dispositivo limitado, lo suficientemente bueno para estos tutoriales) y otra
licencia para EDK (se puede comprar aquí . Xilinx solía ofrecer una licencia de evaluación de 30 días.
Póngase en contacto con Xilinx para obtener más información ) Cómo descargar, instalar y licenciar
estas herramientas está más allá del alcance de este tutorial. Visite xilinx.com para obtener más
ayuda sobre esto.

Vamos a ensuciarnos las manos

Para mantener este tutorial conciso y fácil de seguir, implementaremos un sistema integrado Hello
World simple. Una vez implementado, imprimirá "Hello World" a través del puerto serie.
Utilizaremos la placa de desarrollo Mimas V2 FPGA como plataforma de hardware para
implementar este proyecto. Mimas V2 tiene un FPGA Spartan 6 LX9 y un convertidor serie USB
incorporado que nos ayudaría a imprimir datos en la PC.

Paso 1, Configuración y construcción de

procesadores y periféricos blandos
Microblaze
Hasta ahora hemos analizado algunos conceptos básicos y seleccionado una plataforma de
hardware. Ahora crearemos un proyecto utilizando Xilinx Platform Studio y configuraremos el
procesador de software basado en Microblaze y algunos periféricos. Antes de que podamos crear
un proyecto, debemos copiar algunos archivos de soporte en el directorio de instalación de EDK.
Estos archivos nos ayudarán a crear y configurar el proyecto con unos simples clics del mouse.
Descargue el Asistente de Base System Builder para Mimas V2 y extraiga el contenido en el
directorio "placa" dentro de la instalación de Xilinx EDK. Si ha instalado ISE / EDK 14.7 en la unidad
C: \, la ruta completa a estos archivos será C: \ Xilinx \ 14.7 \ ISE_DS \ EDK \ board \ NumatoLab \
ipxact \ MimasV2 \ data.
Ahora inicie Xilinx Platform Studio desde el menú de inicio.

Después de cargar Platform Studio GUI, haga clic en Archivo> Nuevo proyecto BSB. En la ventana
del asistente del proyecto que aparece, ingrese una ruta y un nombre para el nuevo proyecto. En la
imagen a continuación, "C: \ embedded \ HelloWorld \ edk" es la ruta y "HelloWorld" es el nombre
del proyecto.
Haga clic en Aceptar para continuar. En la siguiente ventana, seleccione Nuamto Lab Mimas V2 como
la placa de desarrollo. Deje todas las demás configuraciones por defecto. Consulte la imagen a
continuación para ver configuraciones de muestra.

Presione siguiente para continuar. En la siguiente ventana, asegúrese de que solo UART esté
seleccionado como periférico como se muestra en la imagen a continuación. Deje todas las demás
configuraciones por defecto.
Haga clic en "Finalizar" para finalizar el asistente y generar el proyecto. Si todo salió bien, se le
presentará una ventana similar a la imagen a continuación.
Todas las IP que se incluyen en el proyecto son configurables para satisfacer sus necesidades. Pero
el único cambio que necesitamos hacer aquí para que esta demostración funcione es la velocidad de
transmisión UART. Haga clic derecho en la IP de UART y seleccione "Configurar IP" en el menú
emergente. En la ventana de configuración de IP, seleccione 19200 baudios y haga clic en Aceptar.
Las imágenes a continuación muestran estos pasos.
Un cambio más que debemos hacer al proyecto es cambiar el reloj de inicio. Por defecto, XPS
configurará el reloj JTAG como reloj de inicio FPGA. Esto está perfectamente bien cuando usamos
un adaptador JTAG como Xilinx Platform Cable - USB para programar FPGA. Pero para cargar la
configuración FPGA desde la memoria flash SPI, necesitamos configurar el reloj de inicio en Cclk en
lugar de JTAGCLK. Para hacer esto, vaya a la pestaña "Proyecto" justo al lado de la pestaña "Catálogo
IP" en XPS y abra el archivo de Opciones de Bitgen "etc / bitgen.ut". Cambie la línea "-g StartUpClk:
JTAGCLK" a "-g StartUpClk: CCLK". Guarde el archivo y reconstruya el proyecto haciendo clic en el
botón "Generar archivo de bits" en el panel izquierdo. XPS puede tardar unos minutos en construir
el proyecto. Una vez que la compilación se complete con éxito, verá el mensaje "La generación de
Bitstream se ha completado. ¡Hecho!". Si aparecen errores (idealmente no debería), corríjalos y
reconstruya. Hemos terminado con la creación de nuestro hardware de sistema integrado, ¡así de
fácil!
Ahora podemos exportar los archivos de salida y crear un proyecto SDK. SDK es la herramienta que
usaremos para crear una aplicación de compilación que se ejecutará en el microprocesador
Microblaze. Haga clic en el botón "Exportar diseño" en la caja de herramientas del lado izquierdo en
XPS. En la ventana emergente, haga clic en "Exportar solo". XPS exportará todos los archivos
necesarios para crear un proyecto SDK.
Ahora inicie SDK seleccionando "Xilinx Software Development Kit" en el menú de inicio. Seleccione
una carpeta conveniente como espacio de trabajo y haga clic en Aceptar. Para crear un nuevo
proyecto, haga clic en Archivo> Nuevo proyecto> Proyecto de aplicación. Aparecerá la aplicación
Project Wizard y le pedirá que ingrese un nombre de proyecto y un nombre de proyecto.
Llamaremos a este proyecto "HelloWorld". En la misma ventana, en la sección "Hardware de
destino", haga clic en el cuadro combinado "Plataforma de hardware" y seleccione "Crear nuevo". El
asistente "Nuevo proyecto de hardware" que aparece. Complete el nombre del proyecto y haga clic
en el botón "Examinar" y navegue hasta nuestro proyecto XPS y busque la carpeta SDK y seleccione
HelloWorld.xml (la ruta completa es SDK \ SDK_Export \ hw \ HelloWorld.xml). Luego haga clic en
Finalizar. Vea la imagen a continuación para ver un ejemplo.
Una vez que se crea un nuevo proyecto de plataforma de hardware, se lo enviará nuevamente al
asistente de proyectos de la aplicación SDK. La nueva plataforma de hardware creada se
seleccionará automáticamente en el asistente de aplicaciones. Al asistente debería gustarle como en
la imagen a continuación cuando todo esté configurado correctamente.
Haga clic en "siguiente" y seleccione la plantilla de proyecto "Mundo Hellow" y luego haga clic en
"Finalizar". Xilinx SDK creará el proyecto y lo compilará automáticamente. Si todo salió bien, debería
ver el mensaje "Build Finished" en la consola de compilación.
Hay una modificación menor que debemos hacer al código en este momento. La aplicación generada
usando SDK imprimirá "Hello World" una vez y saldrá. Queremos cambiar el código de la aplicación
para que el código siga imprimiendo los datos indefinidamente. Busque la declaración de impresión
en el código (HelloWorld.c) y reemplácela con el siguiente código.
while(1)
{
print("Hello World\n\r");
}
Todo lo que estamos haciendo aquí es rodear la declaración de impresión en un ciclo while para que
la impresión nunca se detenga. Guarda el proyecto y construye.

Paso 2, Generando el archivo bin para

descargar a Mimas V2
En este punto, hemos terminado un paso importante. Es decir, crear y construir un nuevo proyecto.
El siguiente paso es generar un único archivo binario que se pueda actualizar a la memoria flash SPI
en Mimas V2 utilizando la herramienta de configuración Mimas V2. Lo lograremos con algunas
herramientas de línea de comandos que se instalan con Xilinx ISE. Para continuar, necesitamos
encontrar los siguientes archivos generados por XPS / SDK.
1. El archivo de bits (el nombre del archivo debe ser HelloWorld.bit si utilizó el nombre del
proyecto como en este tutorial. Este archivo se encuentra en la carpeta SDK \ SDK_Export \
hw dentro de la carpeta del proyecto XPS)
2. El archivo ejecutable (el nombre del archivo debe ser HelloWorld.elf si utilizó el nombre del
proyecto como en este tutorial. Este archivo se encuentra en la carpeta SaturnV3test \ Debug
dentro de la carpeta del espacio de trabajo del SDK)
3. El archivo .bmm (El nombre del archivo debe ser HelloWorld_bd.bmm si usó el nombre del
proyecto como en este tutorial. Este archivo se encuentra en la carpeta SDK \ SDK_Export \
hw dentro de la carpeta del proyecto XPS)
Una vez que estos tres archivos se copien en una carpeta común, abra la línea de comandos y
muévase a esa carpeta. Siga los dos pasos a continuación para generar el archivo bin final.

Paso i
cmd> c:\Xilinx\xx.x\ISE_DS\settings64.bat

cmd> data2mem -bm HelloWorld_bd.bmm -bd HelloWorld.elf -bt HelloWorld.bit

Asegúrese de reemplazar xx.x en el primer comando con su versión ISE para formar una ruta
correcta y use los nombres de archivo correctos en el segundo comando (si los nombres de su
proyecto XPS / SDK eran diferentes). Si los comandos se ejecutaron correctamente, debería ver un
nuevo archivo de bits generado en la carpeta (HelloWorld_rp.bit en mi caso).

Paso ii
Ahora necesitamos generar un archivo bin. Ejecute el siguiente comando en la misma ventana de
comandos.
cmd> promgen -w -p bin -u 0x0 HelloWorld_rp.bit -spi -o download_me
Si el comando fue exitoso, verá algunos archivos nuevos generados en la carpeta. Uno de los archivos
será download_me.bin. Utilizaremos este archivo para configurar el módulo Saturn Spartan 6 FPGA.
Ejecute la herramienta de configuración flash Mimas v2, seleccione download_me.bin y haga clic en
el botón "programa" como en la imagen a continuación (asegúrese de configurar el interruptor SW7
adecuadamente para permitir la descarga flash).

Coloque el interruptor SW7 en Mimas V2 en modo de monitor en serie y conéctese al puerto

utilizando un software de terminal en serie (19200 baudios). Debería ver el mensaje "Hola mundo"
que se imprime continuamente.
Parte 6 – DDR SDRAM
La disponibilidad de suficiente almacenamiento de datos es un factor muy importante al seleccionar
una placa de desarrollo FPGA. Varias placas ofrecen diferentes opciones de memoria como SRAM,
QDR, SDRAM, FLASH, etc. DDR SDRAM es el más popular de todos, ya que ofrece una cantidad
razonablemente grande de almacenamiento volátil al que se puede acceder a una velocidad
razonable. Una memoria volátil integrada es clave para muchas aplicaciones, como el
procesamiento de imágenes, el registro de datos, etc., ya que la RAM de bloque disponible en la
estructura lógica FPGA es muy limitada.
Este artículo no tiene la intención de visitar los conceptos básicos y la arquitectura de SDRAM, sino
enfocarse en cómo crear un proyecto muy pequeño para mostrar cómo trabajar con DDR SDRAM
conectado a un FPGA, específicamente Xilinx Spartan 6. Hay muchos artículos informativos sobre el
Internet donde un lector curioso puede aprender sobre el funcionamiento interno de SDRAM.
Encontramos esta serie de tutoriales muy informativa. Sin embargo, tenga en cuenta que una
comprensión profunda de la teoría detrás de cómo funciona SDRAM no es necesaria para seguir este
tutorial.
Utilizaremos la placa de desarrollo Mimas V2 FPGA de Numato Lab para este tutorial. Pero estos
pasos se pueden aplicar a la mayoría de las otras placas con cambios mínimos.
Para que SDRAM funcione con un FPGA, necesitaremos algunos componentes esenciales.
1. Controlador de memoria
2. Lógica de envoltura
3. Lógica de usuario
El controlador de memoria es el componente que habla directamente con la DRAM. Este
componente genera las señales necesarias (Dirección / Datos / Control) para establecer
comunicación con la memoria. El controlador de memoria puede implementarse en código o podría
ser un bloque de IP integrado en el silicio. Es posible que algunos FPGA no tengan un controlador
de memoria física en el interior y la única forma de interactuar con DDR es escribir código
manualmente que use recursos lógicos FPGA. Esto ocupa un espacio valioso en la lógica FPGA que
de otro modo podría usarse para otros fines y también el rendimiento generalmente no es tan bueno
en comparación con los controladores de memoria IP rígida. Un gran número de FPGA tiene
controladores de memoria IP incorporados. Por lo general, estos FPGA son más caros, pero el
controlador de memoria incorporado ofrece un mejor rendimiento y un menor uso de lógica FPGA.
En la mayoría de los casos donde los controladores de memoria están disponibles en silicio, la
interfaz del usuario puede no ser fácilmente utilizable por la lógica del usuario. En tales casos, es
necesario tener un código contenedor que pueda interactuar con el núcleo del controlador de
memoria en un extremo y presentar una interfaz simple y coherente para la lógica del usuario. Por
lo general, los contenedores ofrecen una interfaz que consta de varios puertos que la lógica del
usuario puede leer / escribir.
La lógica del usuario es la pieza final del rompecabezas. El código de usuario es la pieza que genera,
consume datos. Mientras trabaja con los datos, la lógica del usuario puede almacenar los datos
temporalmente en SDRAM (o cualquier otro dispositivo de memoria). Por ejemplo, una aplicación
de registro de datos que se ejecuta en FPGA puede adquirir muestras de un ADC y almacenarlas en
SDRAM. Estos datos se volverán a leer desde la SDRAM y se enviarán a una PC más adelante.
Puede parecer muy complicado hacer todo esto. Pero no se preocupe, hay herramientas que pueden
ayudar. Xilinx ha hecho un excelente trabajo al crear algunas buenas herramientas que pueden
ayudarnos a generar todos los componentes anteriores y hacer que nuestra aplicación de prueba se
ejecute con una codificación manual mínima o nula. Por lo tanto, puede olvidarse de las cosas
anteriores por ahora, pero este conocimiento es útil más adelante cuando planea usar Memory
Controller en un proyecto del mundo real.
Echemos un vistazo rápido al tablero que vamos a utilizar. Mimas V2 tiene un FPGA Xilinx Spartan
6 LX9 en el paquete CSG324 (tiene dos controladores de memoria incorporados) y una SDRAM
LPDDR de 512Mbit (LP significa Low Power y DDR significa Double Data Rate). El paquete CSG324
de FPGA es importante aquí porque Xilinx Spartan 6 LX9 está disponible en algunos otros paquetes
que no tienen un controlador de memoria incorporado. De los dos controladores de memoria
disponibles en el FPGA, uno está conectado a la SDRAM LPDDR de 512Mbit y el otro no se usa. Todas
las conexiones y otros detalles específicos se tienen en cuenta en la placa, por lo que no se necesitan
hardware ni accesorios especiales para implementar los proyectos que vamos a hacer. Para aquellos
que quieran aprender un poco más, recomendamos consultar los esquemas de Mimas V2
(disponibles al final del manual del usuario) y la Guía del usuario de soluciones de interfaz de
memoria Xilinx . Estos documentos son muy valiosos si uno quisiera aprender más allá de lo que
ofrece este artículo.
Xilinx ofrece dos herramientas diferentes para implementar diseños en FPGA Spartan 6
dependiendo de su elección de flujo de trabajo. Ofrecen ISE para el flujo de trabajo convencional y
EDK para el flujo de trabajo del sistema integrado. En el primer caso, todo el código se implementará
en código RTL como Verilog / VHDL. En el último caso, un microprocesador y periféricos
relacionados, incluidos los buses, se construyen sobre la lógica FPGA (implementada usando VHDL
pero la mayoría, si no todo, es generado automáticamente por Xilinx XPS) y el desarrollador
escribirá el código en C que se ejecuta en el microprocesador. En este tutorial, visitaremos ambos
casos y veremos cómo generar, construir y probar programas de muestra en entornos ISE y EDK.

Compatibilidad de versión de herramienta y

ayuda
Este artículo utiliza Xilinx ISE y EDK versión 14.7. Por lo tanto, las capturas de pantalla y las
instrucciones / comandos pueden ser diferentes en su sistema si está utilizando una versión
diferente. Adapte los pasos mencionados en este artículo para que funcione con su versión de
herramienta específica. El mejor lugar para hacer preguntas sobre ISE, EDK (XPS / SDK), Microblaze
y Spartan 6 FPGA es en los foros comunitarios de Xilinx en http://forums.xilinx.com/.
Opcionalmente, puede abrir un caso web en
http://www.xilinx.com/support/clearexpress/websupport.htm. Las preguntas específicas para la
Junta de Desarrollo FPGA Mimas V2 Spartan 6 se pueden hacer en nuestro foro o crear un ticket si
es necesario en la página Contáctenos .
Creación, configuración y construcción del núcleo del controlador de memoria y programa de
prueba en Xilinx ISE
Necesitará las siguientes herramientas para implementar este proyecto.
1. Xilinx ISE Webpack ( Descargar aquí )
2. Junta de desarrollo Mimas V2 FPGA
3. Un cable USB
4. Herramienta de configuración Mimas V2 ( Descargar desde la página del producto )
Inicie Xilinx ISE y seleccione un nuevo proyecto en el menú Archivo. El asistente del proyecto
aparecerá. Escriba el nombre del proyecto y la ruta en la primera página. Seleccione el dispositivo
FPGA apropiado en la segunda página. Mimas V2 tiene un dispositivo Spartan 6 LX9 (XC6SLX9). La
configuración, como se muestra en la imagen a continuación, debería funcionar bien.
Haga clic en siguiente y termine el asistente. Sorprendentemente, no vamos a crear ni agregar
ningún archivo fuente al proyecto y nuestro uso de la interfaz gráfica de usuario de ISE termina una
vez que generamos la IP requerida y otros archivos usando la herramienta Coregen. Para iniciar la
herramienta Coregen, vaya al menú Herramientas y seleccione "Core Generator".

Si Core Generator no crea un proyecto automáticamente, cree un proyecto seleccionando Archivo>

Nuevo proyecto. Deberá seleccionar el FPGA y su paquete al crear el proyecto. Seleccione Verilog
como método de entrada de diseño. Esto es para asegurarse de que Core Generator genera código
en Verilog. En la ventana del catálogo de IP, busque MIG en la categoría "Elementos de memoria y
almacenamiento".

Haga doble clic para ejecutar el asistente del generador de interfaz de memoria. En la primera
pantalla, asegúrese de que el dispositivo FPGA seleccionado y otras configuraciones sean correctas.
La configuración debería verse como en la imagen a continuación.
Haga clic en Siguiente para pasar a la siguiente pantalla y escriba el nombre de un componente si es
necesario. Dejar el nombre predeterminado también debería funcionar bien. En aras de la claridad,
llamaremos a nuestro componente "s6_lpddr". Reemplace esto con el nombre del componente que
eligió cuando aparezca "s6_lpddr" más adelante en este tutorial.

Haga clic en Siguiente para ir a la pantalla tres del asistente. Deje todas las opciones sin cambios y
continúe con la pantalla 4. Esta pantalla es donde seleccionamos el tipo de memoria DDR y le
decimos al asistente MIG dónde está conectada. El dispositivo Spartan 6 LX9 tiene dos controladores
de memoria disponibles. En la placa de desarrollo Mimas V2 FPGA, el dispositivo LPDDR está
conectado al Banco 3 del FPGA. Seleccione LPDDR en el cuadro combinado correspondiente al
Banco 3. Deje la configuración del Banco 1 sin cambios. La configuración en esta página debe verse
como en la imagen a continuación.

Haga clic en Siguiente para ir a la siguiente pantalla. Este es el lugar donde seleccionamos el
dispositivo de memoria DDR y su frecuencia de funcionamiento. Mimas V2 tiene memoria LPDDR
integrada que es Micron MT46H32M16 o equivalente. Este dispositivo admite reloj DDR de hasta
166MHz. Seleccione el dispositivo de memoria MT46H32M16 y configure el período de reloj en
10,000. El período de reloj 10,000 corresponde a la frecuencia de reloj DDR de 100MHz. Aunque el
dispositivo DDR admite hasta 166MHz de reloj, usaremos 100MHz para evitar la complicación de
jugar con la configuración PLL más adelante. Mimas V2 tiene una fuente de reloj de 100MHz y al
usar la misma frecuencia para el reloj DDR, podemos dejar la configuración PLL generada por MIG
tal como está. A continuación se muestra la imagen con la parte de memoria correcta y la frecuencia
seleccionada.
Haga clic en Siguiente para pasar a la siguiente pantalla y dejar todos los ajustes a sus valores
predeterminados. Haga clic en Siguiente nuevamente para pasar a la pantalla de configuración del
puerto. Seleccione el Puerto 0 y deje el resto de los puertos sin marcar como se muestra a
continuación.
Haga clic en Siguiente para pasar a la página de configuración de arbitraje. Como estamos usando
un solo puerto, no hay parámetros para cambiar en esta pantalla. Haga clic en Siguiente nuevamente
para pasar a la pantalla Opciones de FPGA. Seleccione N4 como ubicación de pin RZQ y seleccione
Single Ended como entrada de reloj del sistema. Vea la imagen a continuación con la configuración
correcta.

Haga clic en el siguiente botón unas cuantas veces más y termine. Core Generator generará un
montón de archivos. Estos archivos se pueden encontrar en el directorio \ ipcore_dir \ s6_lpddr
(suponiendo que haya utilizado el nombre "s6_lpddr" para el componente generado
automáticamente). Verá tres carpetas aquí, docs, example_design y user_design. La carpeta docs
tiene documentación muy importante que se puede utilizar para obtener más información sobre
Spartan 6 Memory Controller y la IP generada por MIG. Guárdelos para una lectura posterior.

Edición de restricciones de usuario

En este momento vamos a utilizar el diseño de ejemplo generado por MIG. El diseño de ejemplo se
puede encontrar (como era de esperar) en la carpeta example_design. Hay algunas carpetas y
archivos dentro de la carpeta example_design. La carpeta rtl tiene todos los archivos Verilog
generados por MIG. La carpeta par contiene algunos archivos por lotes y scripts para construir el
diseño de ejemplo. Las restricciones del usuario parecen generarse automáticamente para que
coincidan con las propias placas de desarrollo de Xilinx. Algunos cambios son necesarios para que
el código generado automáticamente funcione con Mimas V2. Antes de construir el proyecto,
debemos hacer lo siguiente.
1. Edite el archivo ucf para poder usarlo con Mimas V2
2. Configure el entorno de compilación para generar un archivo de configuración binario
Vaya a la carpeta par y busque example_top.ucf. Abra example_top.ucf usando cualquier editor de
texto de su elección. Haz los siguientes cambios.
 1. Cambie la línea CONFIG VCCAUX=2.5; por CONFIG VCCAUX=3.3; . Este cambio es
necesario porque Mimas V2 usa 3.3V para VCCAUX.

2. Cambiar las siguientes lineas

NET “error” IOSTANDARD = LVCMOS18;
NET “calib_done” IOSTANDARD = LVCMOS18;
NET “calib_done” LOC = “B2” ;
NET “error” LOC = “A2” ;ToNET “error” IOSTANDARD = LVCMOS33;
NET “calib_done” IOSTANDARD = LVCMOS33;
NET “calib_done” LOC = “T18” ; #LED1
NET “error” LOC = “T17” ; #LED2

Los cambios anteriores harán que los pines "error" y "calib_done" funcionen con el estándar
LVCMOS33 IO y asignen las redes a T18 y T17 de FPGA donde están conectados el LED1 y el LED2.
Esto hará que el LED1 se encienda cuando se complete la calibración y el LED2 se encienda si la
prueba de memoria falla
3. Cambie las líneas NET “c3_sys_clk” IOSTANDARD = LVCMOS25;
NET “c3_sys_rst_n” IOSTANDARD = LVCMOS18;ToNET “c3_sys_clk” IOSTANDARD =
LVCMOS33;
NET “c3_sys_rst_n” IOSTANDARD = LVCMOS33;
El cambio anterior establecerá los estándares de E / S para la entrada del reloj y restablecerá la
entrada a LVCMOS33. Esto se debe nuevamente a que el banco al que pertenecen estos IO está
alimentado por un riel de 3.3V.
4. Agregue una línea NET “c3_sys_rst_n” PULLDOWN;
Esto permitirá desplegar el pin de reinicio y mantendrá el controlador de memoria sin reinicio sin
tener que usar ningún componente externo. A pesar del nombre "c3_sys_rst_n", MIG parece estar
configurando la entrada de reinicio como alta activa.
5. Cambie las asignaciones de pin "c3_sys_clk" y "c3_sys_rst_n" como se muestra a
continuación.
NET “c3_sys_clk” LOC = “V10”;
NET “c3_sys_rst_n” LOC = “M16”;
Esto asignará los pads IO correctos para la entrada del reloj y asignará el interruptor SW3 como
entrada de reinicio.
Ya hemos terminado con los cambios en el archivo ucf. Esto puede parecer difícil pero lo
suficientemente fácil si se hace con cuidado. Es una buena idea hacer una copia de seguridad de su
archivo ucf original antes de guardar los cambios por si acaso desea volver y reiniciar nuevamente.
Construyendo el código
El siguiente paso es modificar el entorno de compilación para generar un archivo de configuración
binario. Este es un paso muy fácil de hacer. Busque el archivo mem_interface_top.ut y ábralo en un
editor de texto. Busque la línea "-g Binary: no" y cámbiela a "-g Binary: yes" y guárdela.
Ahora estamos listos para construir el proyecto. Antes de compilar el proyecto, asegúrese de
agregar la ruta a las herramientas de compilación Xilinx a la variable de entorno PATH. Por lo
general, la ruta es C:\Xilinx\\ISE_DS\ISE\bin\nt suponiendo que ISE esté instalado en la unidad C:.
Ahora ejecute el archivo por lotes ise_flow.bat haciendo doble clic en el archivo o utilizando el
símbolo del sistema. Si todo salió bien hasta ahora, el archivo por lotes ejecutará las herramientas
necesarias para compilar el proyecto y terminará con un mensaje "Listo" y un montón de archivos
nuevos en la carpeta par. El mensaje debería verse en la imagen a continuación.

Si el proceso de compilación falla, consulte ise_flow_results.txt para obtener más detalles sobre las
causas de la falla. Debería ver el archivo "example_top.bin" en la carpeta par si la compilación se
realizó correctamente. Este es el archivo con el que vamos a programar la placa de desarrollo Mimas
V2 Spartan 6 FPGA.

Configurar Mimas V2 y probar

La programación de la placa de desarrollo Mimas V2 Spartan 6 FPGA es muy fácil. Descargue la
última versión de la aplicación Configuration Downloader desde la página del producto. Ejecute el
ejecutable, no requiere instalación. Cargue el archivo binario y programe el flash como se ilustra en
la imagen a continuación.
Observe la ventana de registro y confirme que el archivo binario de configuración se descargó
correctamente. Ahora estamos listos para probar si la interfaz de memoria funciona.
Probar si el programa de ejemplo que creamos es muy fácil de hacer. Puede recordar que
cambiamos algunas líneas en el archivo ucf. Debajo hay dos de esas líneas.
NET "calib_done" LOC = "T18"; # LED1
NET "error" LOC = "T17"; # LED2
La primera línea asigna el pin FPGA T18 a la red "calib_done" de red y la segunda línea asigna el pin
T17 de FPGA a la red "error". Estos pines FPGA están conectados a LED1 y LED2 respectivamente.
Para verificar el correcto funcionamiento del programa de ejemplo, todo lo que necesitamos hacer
es verificar y asegurarnos de que el LED conectado a "calib_done" (LED1) se encienda después del
encendido, lo que indica que se completó con éxito la calibración inicial y el LED conectado a
"error”(LED2) permanece apagado.
Si ha observado que calib_done se está elevando y el error permanece bajo durante un tiempo,
felicidades, tiene su proyecto de prueba Spartan 6 DDR SDRAM funcionando. Gracias a Xilinx
Memory Interface Generator por generar código completo y listo para usar.
Creación, configuración y construcción del núcleo del controlador de memoria y programa de
prueba en Xilinx EDK
Es bastante fácil generar y construir un programa de muestra simple que pueda probar la SDRAM
DDR usando ISE y ciertamente es emocionante. Sería más emocionante si pudiéramos probar toda
la memoria e imprimir la salida a través de UART. Sí, es posible hacerlo usando Xilinx EDK. Y
también podría escribir código C simple para acceder a la SDRAM DDR. Le mostraremos cómo!
Necesitará las siguientes herramientas para implementar este proyecto.
1. Xilinx EDK ( Más información aquí )
2. Junta de desarrollo Mimas V2 FPGA
3. Un cable USB
4. Herramienta de configuración Mimas V2 ( Descargar desde la página del producto )

¿Qué es el microblaze?
Microblaze es un procesador de software suave de 32 bits desarrollado por Xilinx para sus
dispositivos FPGA de gama media y alta. Microblaze es compatible con sus dispositivos Spartan 6,
Virtex y Zynq. Puede encontrar más recursos, incluida la hoja de datos para Microblaze en la página
de Microblaze de Xilinx. Afortunadamente, no necesitamos descargar Microblaze IP por separado,
ya que está incluido con la herramienta Xilinx EDK. El diseño integrado basado en Microblaze puede
usar PLB o AXI como sistema de bus. Dado que Xilinx está planeando eliminar PLB y mantener solo
AXI en el futuro, nos quedaremos con AXI para nuestros diseños. No necesita un conocimiento
profundo de Microblaze o AXI para seguir este artículo y construir un sistema de trabajo con éxito.

¿Qué es el AXI?
AXI significa Interfaz avanzada extensible. AXI es una interconexión de bus basada en la popular
arquitectura de bus AMBA de ARM. En un sistema integrado basado en Microblaze, AXI conecta el
microprocesador a todos los periféricos disponibles. La única excepción es Block RAM, que está
conectado al procesador a través de LMB (bus de memoria local). AXILite está disponible para
conectar periféricos de bajo rendimiento al sistema como UART, GPIO, etc. AXILite utiliza menos
recursos lógicos en FPGA en comparación con AXI. Por lo general, AXI se usa para conectar
periféricos de alto rendimiento como memoria DDR, Ethernet, etc. Una vez más, no se requiere una
comprensión detallada de AXI para seguir este artículo. Pero para los lectores curiosos, la Guía de
referencia de AXI está disponible aquí .

¿Qué es el EDK?
EDK es un conjunto de herramientas de desarrollo proporcionadas por Xilinx para ayudar a crear
un sistema embebido basado en Microblaze y desarrollar software para el sistema. Xilinx EDK tiene
dos componentes principales.
Xilinx Platform Studio (XPS)
Kit de desarrollo de software Xilinx (SDK)
Estas son las dos herramientas de software separadas que utilizaremos para diseñar e implementar
nuestro sistema. XPS es la herramienta utilizada para diseñar y generar el sistema de hardware.
Creará y configurará el procesador Microblaze y los periféricos necesarios utilizando XPS y generará
un archivo de bits a partir del diseño. Este archivo de bits se programará en el FPGA para completar
el diseño del hardware. SDK es la herramienta donde el software está escrito para el procesador
Microblaze. El software se puede escribir usando C o C ++. SDK y XPS juntos generarán todos los
archivos de encabezado necesarios y los scripts de enlazador necesarios para construir con éxito el
software para su sistema. Analizaremos detalladamente estas herramientas a medida que
avancemos. Más detalles sobre estas herramientas se pueden encontrar aquí .

Creación de una plataforma de hardware

integrada basada en Microblaze
En esta sección, veremos cómo crear una Plataforma Embebida básica basada en Microblaze usando
Xilinx Platform Studio (XPS). Utilizaremos el asistente básico de System Builder (BSB) para generar
el sistema. Para utilizar BSB para generar un sistema para Mimas V2, deberá descargar los archivos
del asistente del sistema BSB de la página del producto y extraerlos a la carpeta "C: \ Xilinx \ xx.xx
\ ISE_DS \ EDK \ board". Una vez extraída, la ruta completa al archivo debería verse como "C: \
Xilinx \ xx.xx \ ISE_DS \ EDK \ board \ NumatoLab \ ipxact \ MimasV2 \ data". Una vez que los
archivos se extrajeron correctamente, vaya a Todos los programas> Herramientas de diseño de
Xilinx> EDK y haga clic en el icono de Xilinx Platform Studio. Una vez que se carga XPS, haga clic en
"Nuevo proyecto BSB" en el menú Archivo o presione Ctrl + Shift + B para invocar al asistente BSB.
Si todo salió bien, la ventana del asistente BSB aparecerá como se muestra a continuación.
Ingrese la ruta a la carpeta donde desea almacenar el proyecto y escriba el nombre del proyecto.
Seleccione Sistema AXI en la sección "Tipo de interconexión" y haga clic en Aceptar. En la página
siguiente del asistente, seleccione "Numato Lab" en el cuadro combinado Proveedor del tablero
(esta opción debería estar disponible si ha colocado correctamente los archivos de soporte del
asistente BSB para Mimas V2 como se mencionó anteriormente). Seleccione Mimas y 2.0 de los
cuadros combinados Nombre de la placa y Versión de la placa respectivamente y haga clic en el
botón "Siguiente".
Puede establecer la estrategia de optimización en Área o Rendimiento. Lo dejaremos en la opción
predeterminada "Área" para este ejemplo. Haga clic en Siguiente para pasar a la siguiente página
del asistente. En la página siguiente, tendrá la opción de seleccionar periféricos como se muestra en
la imagen a continuación.
Deje todo en esta página a sus valores predeterminados y haga clic en Finalizar. En este punto, XPS
generará el sistema para usted y se le presentará una ventana como la siguiente.
Esta ventana muestra todas las IP disponibles, las IP utilizadas en el diseño y las conexiones de bus
entre las IP utilizadas. Aquí puede observar que la memoria DDR está conectada al procesador
Microblaze a través del bus AXI, ya que DDR requiere un mejor rendimiento. Pero todos los demás
periféricos están conectados a AXI Lite. Para que este sistema funcione con Mimas V2, es necesario
personalizarlo.

Cambiar velocidad de transmisión

El primer cambio que necesitamos hacer es la velocidad de transmisión UART. Haga clic derecho en
la IP de UART en la vista "Interfaces de bus" y seleccione "Configurar IP". En la ventana de
configuración de IP que aparece, seleccione la velocidad en baudios "19200" y deje todos los demás
valores predeterminados. Consulte la imagen a continuación para conocer la configuración exacta.
Conecte RESET a un interruptor externo
Lo siguiente que debemos hacer es asignar un interruptor a la red "RESET" del procesador
Microblaze para que podamos restablecer todo el sistema cuando sea necesario. Para hacer esto,
abra el archivo "ddrdemo.ucf" en la vista del proyecto y reemplace la línea
PULLUP NETO "RESET";
con
NET "RESET" LOC = M16 | IOSTANDARD = LVCMOS33 | DRIVE = 8 | GIRAR = RÁPIDO | LEVANTAR;
Esto conectará el interruptor momentáneo SW3 en Mimas V2 a la línea RESET del procesador. Esto
nos permitirá restablecer el procesador en cualquier momento presionando el interruptor SW3.
Seleccione CCLK como reloj de configuración
Por defecto, XPS configurará el reloj JTAG como reloj de inicio FPGA. Esto está perfectamente bien
si estamos utilizando un adaptador JTAG como Xilinx Platform Cable - USB para programar el FPGA.
Pero para usar la utilidad de configuración Mimas V2, necesitamos configurar el reloj de inicio en
CCLK en lugar de JTAGCLK. Para hacer esto, vaya a la pestaña "Proyecto" justo al lado de la pestaña
"Catálogo IP" en XPS y abra el archivo de Opciones de Bitgen "etc / bitgen.ut". Cambie la línea "-g
StartUpClk: JTAGCLK" a "-g StartUpClk: CCLK". Guarde el archivo, haga clic en el botón "Generar
flujo de bits" a la izquierda para compilar el sistema y construir el flujo de bits. Este paso puede
llevar de unos minutos a unas pocas decenas de minutos, dependiendo de la velocidad de su
computadora.
Una vez que el archivo de bits se genera correctamente, haga clic en el botón "Exportar diseño" en
la barra de herramientas a la izquierda. Haga clic en el botón "Exportar solo" en la ventana que
aparece. Este paso exportará todos los archivos necesarios para crear un proyecto SDK en un
directorio conveniente (generalmente dentro de SDK \ SDK_Export \ hw bajo el directorio actual
del proyecto). En este punto, tenemos el sistema de hardware listo. Esto es más o menos equivalente
a tener una placa de microprocesador / microcontrolador sin un código escrito para ello. Entonces,
nuestro próximo paso es escribir un código y construirlo.

Crear un programa de aplicación para

Microblaze
Usaremos Xilinx SDK para escribir y compilar código para la plataforma de hardware que acabamos
de construir. Xilinx SDK es un IDE basado en Eclipse que puede crear, construir, depurar y mantener
proyectos para plataformas basadas en Xilinx Microblaze. Para iniciar SDK, vaya a Todos los
programas> Herramientas de diseño de Xilinx> EDK y seleccione "Kit de desarrollo de software de
Xilinx". Cuando se le solicite elegir un espacio de trabajo, ingrese un directorio conveniente donde
desee que se almacenen los archivos de proyectos. Para crear un nuevo proyecto de SDK, seleccione
"Nuevo proyecto de aplicación" en el menú Archivo. Se le presentará una ventana como se muestra
a continuación.
Seleccione crear nuevo en el cuadro combinado Plataforma de hardware. Aparecerá una nueva
ventana donde necesitamos crear un nuevo proyecto de hardware.
Haga clic en el botón Examinar y busque el directorio donde se guardó el proyecto XPS
anteriormente. Y vaya a SDK \ SDK_Export \ hw y seleccione ddrdemo.xml. Este asistente
completará automáticamente el nombre de un proyecto, lo dejaremos sin cambios. Haga clic en el
botón Finalizar para volver al Asistente de proyecto de aplicación. De vuelta en el asistente de
proyecto de la aplicación, ingrese un nombre de proyecto y deje todas las demás configuraciones
predeterminadas como se muestra en la imagen a continuación.
Haga clic en Siguiente para ir a la última página del asistente de proyecto de la aplicación. Seleccione
la plantilla "Prueba de memoria" de la lista de plantillas y haga clic en Finalizar. SDK creará un
espacio de trabajo y le agregará tres proyectos. Todos los proyectos se pueden ver en Eclipse Project
Explorer como se muestra a continuación.
En la imagen de abajo, puedes ver tres proyectos. Proyecto en la parte superior es la plataforma de
hardware. Estos archivos se copian directamente desde el directorio donde XPS exportó el sistema
de hardware. El siguiente es el proyecto de aplicación en el que estaremos trabajando. Y el que está
hasta el final es el proyecto BSP que SDK generó automáticamente. Las bibliotecas y los archivos de
inclusión necesarios para que nuestra aplicación funcione se almacenan en este proyecto.
Para construir el proyecto, seleccione "Construir todo" en el menú Proyecto. Si todo salió bien hasta
ahora, el proyecto debería construirse sin errores. Nuevamente, este es un proyecto que puede
descargarse y probarse en hardware sin modificaciones. Si desea ver el código, vaya a la carpeta src
debajo del proyecto ddrdemoapp y abra los archivos de origen que se enumeran allí. memorytest.c
tiene la función main ().

Construyendo y probando el programa

Una vez que el proyecto se haya creado con éxito, SDK construirá el programa por sí solo. Puede
forzar otra compilación seleccionando "Compilar todo" en el menú "Proyecto" o presionando Ctrl +
B.
Ahora que hemos creado y construido los proyectos en XPS y SDK, podemos crear la imagen binaria
final. La idea es utilizar la herramienta Xilinx data2mem para fusionar el archivo de bits FPGA
generado por XPS para el sistema Microblaze y el ejecutable generado por SDK.
Necesitamos encontrar los siguientes archivos de los proyectos XPS y SDK que hemos creado.
1. El archivo de bits (el nombre del archivo debe ser ddrdemo.bit si utilizó el mismo nombre de
proyecto que el mío. Este archivo se encuentra en la carpeta SDK \ SDK_Export \ hw dentro
de la carpeta del proyecto XPS)
2. El archivo ejecutable (El nombre del archivo debe ser ddrdemoapp.elf si utilizó el mismo
nombre de proyecto que el mío. Este archivo se encuentra en la carpeta ddrdemoapp \ Debug
dentro de la carpeta del espacio de trabajo del SDK)
 3. El archivo .bmm (el nombre del archivo debe ser ddrdemo_bd.bmm si utilizó el mismo
nombre de proyecto que el mío. Este archivo se encuentra en la carpeta SDK \ SDK_Export \
hw dentro de la carpeta del proyecto XPS)
Una vez que estos tres archivos se copien en una carpeta común, abra la línea de comandos y
muévase a esa carpeta. Siga los dos pasos a continuación para generar el archivo bin final.

Paso 1
cmd> c: \ Xilinx \ xx.x \ ISE_DS \ settings64.bat
cmd> data2mem -bm ddrdemo_bd.bmm -bd ddrdemoapp.elf -bt ddrdemo.bit
Asegúrese de reemplazar xx.x en el primer comando con su versión ISE para formar una ruta
correcta y use los nombres de archivo correctos en el segundo comando (si los nombres de su
proyecto XPS / SDK eran diferentes). Si los comandos se ejecutaron correctamente, debería ver un
nuevo archivo de bits generado en la carpeta (ddrdemo_rp.bit en mi caso).

Paso 2
Ahora necesitamos generar un archivo bin. Ejecute el siguiente comando en la misma ventana de
comandos.
cmd> promgen -w -p bin -u 0x0 ddrdemo_rp.bit -spi -o download_me
Si el comando fue exitoso, verá algunos archivos nuevos generados en la carpeta. Uno de los archivos
será download_me.bin. Utilizaremos este archivo para configurar Mimas V2. Ejecute la herramienta
de configuración flash Mimas V2 (asegúrese de configurar el interruptor deslizante de Mimas V2 en
el modo de programación, consulte los detalles en el manual del usuario), seleccione
download_me.bin y haga clic en el botón "programa" como en la imagen a continuación.
Una vez que la placa está programada, coloque el interruptor deslizante de Mimas V2 en modo
normal y conéctese al puerto COM correspondiente a la placa utilizando cualquier software de
emulación de terminal en serie como Hyperterminal o TeraTerm. Luego presione el interruptor
SW3 para reiniciar el procesador. Si todo ha ido bien hasta ahora, debería ver los siguientes
resultados de la prueba impresos en el terminal.

Este tutorial muestra lo fácil que es generar y crear aplicaciones de prueba simples para ejercitar la
SDRAM DDR disponible en la placa de desarrollo Mimas V2 FPGA (o cualquier otra placa basada en
Spartan 6 para el caso).