PRIMER TUTORIAL HOLA MUNDO

Para este primer tutorial, la meta ser la de crear un microprocesador de 32 bits el cual contar como corazn el procesador Nios II de altera, adems de un puerto de salida digital de 8 puertos, un puerto de comunicaciones UART y un modulo externo SRAM controlado desde la Nios. Las metas a lograr sern desde obtener prender un simple LED, hasta manejar un puerto de comunicaciones serial de manera bidireccional. Para esto contaremos con 3 herramientas informaticas: System Builder de Tersic Quartus II de altera. Nios IDE de Eclipse.

CREANDO EL HARDWARE BASICO La idea del System Builder de Terasic es la de facilitarnos la vida al momento de comenzar un proyecto en Quartus II, generndonos las configuraciones bsicas de los pines y la creacin de un mdulo top level desing en Verilog con los puertos bsicos que seleccionamos desde su interfaz.

Como se puede observar en la imagen anterior al arrancar el system builder nos presenta una amigable interfaz en la cual podemos agregar el nombre de nuestro proyecto y los perifricos que deseamos incluir en nuestro proyecto. En este primer tutorial los elementos necesarios para lograr nuestra meta sern: Clock (imprescindible). SDRAM: memoria voltil en la cual se alojar nuestro cdigo C++. LEDx8: un puerto de salida de 8 bits conectado a los LEDs de la placa.

Dado que esta placa no posee un puerto serial nativamente, deberemos incluirla manualmente nosotros mismos, tanto en el cdigo verilog y el la asignacin de pines. Una vez que hemos elegido nuestros componentes, simplemente presionamos el botn Generate y guardamos.

En la imagen anterior observamos los archivos generados automticamente por el system builder, ahora solo nos basta hacer doble click en el icono azul de la carpeta y estamos en el entorno Quartus dos de nuestro proyecto. Si presionamos el botn Pin planner de nuestro proyecto vemos que todos los pines han sido configurados automticamente.

Adems observamos en la imagen inferior que se ha generado un mdulo verilog con los puertos que solicitamos en el system builder.

El siguiente paso es generar nuestro procesador NiosII, para esto Quartus II nos provee de una til herramienta llamada SOPC Builder, en realidad esta herramienta est siendo reemplazada por otra llamada Qsys pero para efectos de este tutorial usaremos el que posee mayor documentacin en internet. Para acceder al SOPC Builder, nos vamos a nuestra barra de herramientas en Quartus II y presionamos en Tools y bajamos hasta la pestaa SOPC Builder, tal como se muestra en la imagen a continuacin.

Una vez terminada la pantalla de carga de esta aplicacin, nos piden que creemos un nuevo sistema, le damos un nombre significativo y que podamos recordar, en nuestro caso Nios_SOPC y seleccionamos la casilla Verilog. Esto es necesario para asegurar la compatibilidad al momento de instanciar el Nios II en nuestro top level design.

Ahora buscamos los dispositivos que integrarn nuestro sistema, los componentes de nuestra configuracin bsica sern: Procesador Nios II Jtag Uart: Este dispositivo nos permitir una comunicacin directa desde la FPGA y nuestra consola en la IDE Eclipse. Uart: este ser nuestro modulo de comunicacin serial entre una terminal en Windows y nuestra FPGA On chip memory: Si bien nuestro proyecto ser cargado en la FPGA, se necesita una memoria interna que maneje el stack de instrucciones y otras cosas que no profundizaremos en este tutorial. Sdram: Memoria del tipo voltil donde se almacenar el cdigo generado en C++ y ser ejecutado por el Nios II. (no confundir con el cdigo generado en Verilog) Pio: Acrnimo de Parallel input/output, es decir, entrada y salida paralela, en este caso solo lo usaremos un puerto de 8 bits de salida apuntando hacia los LEDs de la placa.

Nuestro primer paso ser agregar el corazn de nuestro sistema, en este caso es el procesador de 32 bits que provee Quartus II, buscamos en la librera de componentes en Processors -> Nios II Processor, con lo cual nos aparece la siguiente ventana.

Seleccionamos la opcin Nios ll/e dado que es la nica gratuita en el sistema, si bien es la mas bsica de las tres, para nuestro cometido ser ms que suficiente. Luego le damos a Aceptar dejando todo en el modo default (por el momento). Si al volver a la pantalla del SOPC Builder aparecen mensajes de error en la consola inferior no se preocupen, esto se solucionar antes de compilar.

Nuestro siguiente componente ser el Jtag Uart, lo encontramos en la librera de componentes en Interface Protocols -> Serial. Lo agregamos a nuestro sistema dejndolo con los valores por defecto, tal como se aprecia en la imagen a continuacin.

Nuestro siguiente elemento ser el puerto serial RS-232, en este caso solo modificamos el Baud rate a 115200 y el resto lo dejamos tal como est.

El siguiente componente ser la controladora SDRAM, si bien nuestra SDRAM es un componente externo a la FPGA, debemos manejar los tiempos de latencia y gestionar la transferencia de datos, SOPC Builder nos facilita esto mediante el SDRAM Controller. Este componente lo encontramos en Memories and Memory Controllers -> SDRAM Interfaces.

Modificamos el preset a la opcin Custom, el ancho de datos Data width a 16 bits y el ancho de direcciones Address width cambiando las filas a 13 y las columnas 9, tal como lo muestra la imagen anterior, el resto lo dejamos por defecto y le damos a Finish. Finalmente agregamos el puerto que prender los LEDs en nuestra placa, el componente PIO lo encontramos en Peripherals -> Microcontroller Peripherals. Configuramos el PIO tal como aparece en la imagen mostrada a continuacin.

Una vez que hemos incorporado todos los elementos de nuestro sistema, modificamos los nombres para que estos sean ms significativos al momento de instanciar en el modulo Verilog. Esto se hace simplemente dndole al botn derecho de nuestro Mouse y seleccionando la opcin rename tal como se muestra a continuacin.

En este caso los nombres deberan quedar de la siguiente manera: cpu jtag_uart uart onchip_memory sdram pio_LED

Nuestro siguiente paso ser decirle al Nios II donde debe buscar la informacin al ejecutarse los programas. Hacemos doble click sobre nuestro componente Nios II ahora llamado cpu y cambiamos la informacin tal como se muestra en la siguiente imagen.

Aceptamos este cambio en la configuracin y vemos que algunas banderas de error desaparecen pero no en su totalidad, el SOPC Builder nos dice que existen inconsistencias en el direccionamiento de los dispositivos en la memoria.

Para solucionar esto, nos vamos a nuestra barra de tareas y en System presionamos Assingn Base Addresses y luego Assign Interrupt Numbers tal como lo muestra la imagen a continuacin.

Asi vemos que todas las banderas de error han desaparecido, dado que se han direccionado automticamente los dispositivos en el mapa de la memoria.

Finalmente nuestra ventana SOPC Builder debera verse como la siguiente imagen.

Si estamos seguros de que hemos hecho todo correctamente, le damos al botn Generate, con lo cual nos solicitar guardar el proyecto bajo la extensin sopc, nuevamente le damos un nombre significativo, puesto que este archivo ser imprescindible al momento de crear nuestros proyectos en la IDE Eclipse.

Si todo ha salido bien, despus de unos minutos de compilacin, la consola del SOPC Builder nos dir que la generacin del sistema fue exitosa.

Ahora podemos cerrar el SOPC Builder y volver a nuestra pantalla en Quartus II. Nuestro siguiente paso ser el de instanciar el sistema que creamos anteriormente en nuestro mdulo Verilog. Para esto buscamos el archivo Verilog que contiene el modulo del sistema creado, recuerdan el nombre significativo que le dimos? Pues a buscarlo!! Nos vamos a la pestaa Open.

Lo encontramos bajo el nombre previamente dado Nios_SOPC y lo abrimos.

Luego debemos buscar el modulo llamado como el archivo, es decir NIOS_SOPC, podemos hacerlo manualmente o ejecutar una bsqueda con los botones Ctrl+f, tal como aparece en la siguiente imagen.

Una vez encontrado el modulo lo copiamos ntegramente y lo pegamos en nuestro cdigo Verilog principal bajo el titulo Structural coding

Nuestro siguiente paso es instanciarlo apropiadamente, se supone que al momento de leer este tutorial se tienen conocimientos bsicos en Verilog, de todas maneras las siguientes imgenes muestran una manera de instanciar un modulo en Verilog. Modificamos el mdulo que copiamos desde el Nios_SOPC.v tal como lo muestra la siguiente imagen.

Luego debemos incluir todos los puertos creados en el modulo top level desing en muestro mdulo instanciado.

Si han sido observadores, se darn cuenta que hay cuatro elementos que no hemos podido instanciar hasta el momento, dos de ellos son el puerto UART, para instanciarlos correctamente, debemos crearlos en nuestro cdigo Verilog tal como lo muestran las imgenes a continuacin. Primero creamos estos dos componentes en nuestro mdulo principal.

Luego declaramos nuestros dos componentes e indicamos si pertenecen a un puerto de entrada o salida.

Finalmente podemos incluirlos en nuestra instancia del Nios_sopc.

El tercer elemento que no hemos instanciado correctamente, es el reloj de nuestra SDRAM, dado que el SOPC Builder no declara este puerto por defecto, para solucionar esto simplemente le asignamos la entrada de nuestro reloj al reloj de la SRAM, tal como se muestra a continuacin.

Y por ltimo instanciamos al reset del Nios un uno lgico dado que esta entrada de reset es de lgica negada, un uno significa que jams ser reseteado.

Ahora que hemos instanciado el Nios_SOPC correctamente, procedemos a compilar (sintetizar) por primera vez nuestro proyecto.

Luego de unos minutos y todo ha salido bien nos dirigimos al Pin Planner y completamos los campos que el System Builder de Terasic no incluy.

Los dos pines no configurados corresponden justamente a los creados por nosotros, es decir los del mdulo UART.

En este caso los asignaremos a dos pines conectados al GPIO expansin headers los cuales corresponden a los pines A8 para la recepcin y D3 para la transimision. (vase el manual del DE0 Nano, pags.18 y 19) Rx => GPIO_0_IN0 => A8 => D3

TX => GPIO_00

Una vez agregados estos dos pines, cerramos el Pin Planner y compilamos nuevamente.

Ahora estamos listos para grabar nuestro diseo en la FPGA, para esto nos vamos a la herramienta Programmer tal como se indica en la siguiente imagen.

Una vez dentro, nos aseguramos que el programador est correctamente activado, para esto presionamos el botn Hardware Setup y nos debera aparecer el USB-Blaster, si es as cerramos esta ventana y simplemtente le damos a Start.

Luego de unos segundos la barra de progreso nos dir que la grabacin fue exitosa, nuestro hardware est dentro de la FPGA!!!

Con esto termina la primera parte del tutorial Nios_SDRAM, lo siguiente ser compilar un cdigo en C++ y ejecutarlo en el procesador recin sintetizado.

PRIMERA APLICACIN SOFTWARE HOLA NIOS II

Abrimos nuestra IDE Eclipe Nios II y la primera pantalla nos solicitar una direccin para el workspace, buscamos la carpeta donde hemos creado nuestro proyecto Quartus II y aceptamos.

Una vez hecho esto, aparece nuestro entorno de trabajo vacio.

Para crear un nuevo proyecto vamos a File -> New -> Nios II Aplication and BSP from Template. Tal como lo muestra la siguiente imagen.

Nos aparece una ventana pidindonos la informacin necesaria para generar las libreras del procesador Nios II.

Primero buscamos el archivo SOPC que generamos en el Quartus II. Este estar en la carpeta del proyecto Nios_SDRAM que creamos anteriormete.

Si el proyecto fue generado en una carpeta que tenga espacios en su nombre no nos permitir ingresar nuestro archivo SOPC. Si este es nuestro caso, copiamos la carpeta del proyecto ntegramente y lo copiamos a una direccin que no posea espacios, por ejemplo: C:

En este caso la direccin donde pegamos la carpeta con los archivos fue C:\altera_trn\Nios_proy pero puede ser cualquier otra direccin siempre y cuando no posea espacios.

Repetimos la operacin anterior y

esta vez no nos da ningn error al generar los archivos.

Luego nombramos al proyecto Hola_mundo_jtag.

Finalmente elegimos como plantilla al proyecto Hello World y presionamos finish

Luego de un par de segundos de compilacin, se generan todas las libreras necesarias del procesador.

Hacemos un doble click en el archivo hello_world.c y nos aparece el cdigo de la plantilla elegida.

Finalmente compilamos nuestro cdigo en la barra de tareas -> Project -> Build Project, luego de unos segundos de compilacin si todo ha salido bien, la consola nos dir que nuestra compilacin est completa.

Es hora de probar nuestro cdigo en el FPGA, para esto nos posamos sobre la carpeta Hola_mundo_jtag en el Project Explorer, presionamos el botn secundario del mouse y nos vamos a la opcin Run As -> 3 Nios II Hardware, tal como lo muestra la siguiente imagen.

Luego de unos segundos, la carga terminar y en la consola del Nios II aparecer el mensaje Hello from Nios II

Felicitaciones, has hecho andar tu primer programa en el Nios II !!! SEGUNDA APLICACIN BLINKING LEDs

Nuestro siguiente proyecto ser prender un LED en un intervalo de tiempo regular, para esto usaremos la misma configuracin de hardware aprovechando el puerto de LEDs que incorporamos al sistema SOPC. Para esto creamos un nuevo proyecto en nuestro workspace actual, una vez ac repetimos los pasos de la experiencia anterior, es decir, le indicamos al programa donde est nuestro archivo Nios_SOPC, nombramos nuestro nuevo proyecto Hola_mundo_LED, con la diferencia que esta vez no usaremos una plantilla, sino que elegiremos un proyecto en blanco, tal como lo muestra la siguiente imagen.

Hacemos click con el botn derecho de nuestro mouse en el proyecto recin creado y nos vamos a New-> Source File.

Nombramos nuestro nuevo cdigo fuente teniendo presente incluir la extensin .c ya que si no lo hacemos el cdigo se guardara como un archivo genrico y no un archivo c++.

Hacemos doble click en nuestro archivo recin creado y escribimos el siguiente cdigo.

Si bien este nuevo cdigo es muy parecido al anterior, vemos un par de nuevos elementos. Hemos incluido la librera altera_avalon_pio_regs.h la cual maneja los registros de escritura y lectura de nuestros puertos IO creados en el SOPC Builder, en nuestro caso el pio_LED. Para poder acceder y escribir valores lgicos en nuestro puerto usaremos la funcin: IOWR_ALTERA_AVALON_PIO_DATA(BASE, DATA);

Esta funcin y el resto de funciones que acceden a los registros funcionales de nuestro procesador, tales como escritura, lectura, manejo de interrupciones, etc. Estas funciones las podemos encontrar en la carpeta del proyecto con la extensin _bsp->drivers->inc

Al dar con la funcin de escritura del PIO, vemos que esta funcin requiere de 2 campos para funcionar: Base: el cual debe apuntar a la direccin en el mapa de memoria del procesador. Data: es el valor binario que activar el registro., poniendo en alto o bajo sus bits (es decir lo que prender a nuestros LEDs.

Si bien darle un valor al campo Data es trivial, encontrar la base es algo ms complicado, pero si nos vamos al archivo system.h podemos encontrar la direccin base de todos nuestros componentes del sistema.

En este caso encontramos la base bajo el nombre de PIO_LED_BASE.

Con la direccin hexadecimal 0x4011020, dado que este nmero est definido bajo el nombre PIO_LED_BASE solo necesitamos reemplazar en nuestra funcin de escritura el campo BASE del puerto por este nombre.

Ahora nos resta compilar el cdigo y correr el proyecto en la placa tal como lo hicimos en la experiencia anterior. Veremos que en esta oportunidad adems de ver nuestro saludo en la consola nuestro LED nmero uno se flashear continuamente.

TERCERA APLICACIN COMUNICACIN SERIAL

Nuestro siguiente proyecto ser aprovechar el modulo serial (UART) que incluimos en el sistema. Para esto repetimos los pasos hechos en las experiencias anteriores.

Abre un fichero cuyo nombre es la cadena apuntada por nombre, y adjudica un stream a ello. El argumento modo apunta a una cadena empezando con una serie de caracteres. En el primer campo, indicamos la direccin del registro uart.

La direccin del registro la encontramos tal como en la experiencia anterior, en el archivo de cabecera system.h bajo el nombre de UART_NAME

Hacemos doble click sobre este ttulo y nos aparece el nombre del registro que debemos incluir en el primer campo de nuestra funcin FOPEN, en este caso ser /dev/uart.

El segundo campo ser r+ lo que indica que nuestro fichero ser utilizado para la actualizacin (lectura y escritura). Una vez declarada nuestra funcin de lectura y escritura que apunta al mdulo uart, simplemente enviamos y recibimos datos con las funciones fprint(), fgetc(), fscan(), etc. Compilamos nuestro cdigo y lo corremos en nuestra placa, para observar los resultados podemos usar un software tal como el putty ingresando la siguiente configuracin:

Para saber el puerto habilitado para la comunicacin se puede encontrar en el administrador de dispositivos de Windows. Si todo ha salido bien, apretamos cualquier tecla de nuestro computador y debera comenzar la cuenta de tecleos, tal como se muestra en la siguiente imagen.

SEGUNDO TUTORIAL CONTADOR CONCURRENTE

La misin de este segundo tutorial ser la de utilizar un sistema diseado en el SOPC Builder que maneje a un sistema externo creado en VHDL mediante seales de control.

DISEO DEL HARDWARE

La siguiente imagen muestra el sistema que se deber construir para lograr nuestro cometido, las nicas diferencias con respecto al tutorial anterior est en la configuracin de los puertos I/O, en este caso usaremos el puerto de 8 bits como entrada y un puerto de 2 bits de salida usadas para el control de nuestro contador concurrente.

Configuramos el puerto de control tal como se indic anteriormente, en este caso ser un puerto de salida de dos bits.

El segundo puerto, ser el encargado de registrar el conteo del dispositivo externo, este ser un puerto de entrada de 8 bits. Adems debemos habilitar la interrupcin cuando exista un pulso de bajo a alto. Tal como lo muestra la siguiente imagen.

El resto del sistema se construye del mismo modo que en el tutorial anterior. Nuevamente asignamos la base de direcciones pero adems asignamos el nmero de interrupciones, el cual ordenar las prioridades al momento de efectuarse dichas interrupciones.

Una vez finalizado el trabajo en el SOPC, volvemos a nuestra pantalla principal en Quartus II, y tal como en el tutorial anterior instanciamos el modulo nios en nuestro cdigo Verilog. Debemos agregar manualmente los dos puertos de control declarados en el SOPC en nuestro modulo instanciado, tal como se muestra a continuacin en las siguientes imagenes. Adems la imagen muestra un cambio en el titulo de nuestro mdulo, ya que en esta oportunidad la instancia del NIOS no ser nuestro Top Level Desing.

Una vez instanciado correctamente el mdulo NIOS, lo convertimos en un archivo del tipo smbolo, tal como se muestra en la siguiente imagen.

Una vez que la generacin del smbolo ha sido exitosa, creamos un nuevo diseo el cual ser nuestro Top Level Design , para esto le damos a File -> New -> Block Diagram Symbol.

Lo nombramos de la misma forma que nuestro poryecto para convertirlo en nuestro Top Level Desing.

Una vez creado nuestro archivo Top Level Desing del tipo esquemtico, vamos a la herramienta agregar smbolo marcado en la imagen a continuacin y seleccionamos al bloque instanciado por nosotros en el paso anterior.

Una vez integrado en nuestro diseo, nos vamos a propiedades y le damos un nombre a la instancia, dado que por defecto todos los mdulos agregados reciben el nombre de inst es necesario cambiarlos para as evitar errores en la posterior compilacin.

Una vez integrado nuestro ncleo NIOS al Top Level Desing debemos crear nuestro contador concurrente en el lenguaje VHDL. Para esto creamos un nuevo archivo del tipo VHDL tal como se muestra en la imagen a continuacin.

Luego creamos nuestro mdulo VHDL, el cdigo se puede encontrar en los archivos marcados como Tutorial Concurrente.

Una vez creado nuestro cdigo en VHDL, repetimos el proceso para la creacin de smbolo tal como lo hicimos para la instancia del ncleo NIOS y lo integramos en nuestro Top Level Desing.

Ahora tenemos los dos componentes centrales de nuestro proyecto, nuestro siguiente reto ser el de entregarle frecuencias de reloj diferenciadas para cada uno de nuestros componentes.

Para esto ingresamos a la herramienta MegaWizard y creamos una nueva variacin de una Megafuncin.

Buscamos el componente llamado ALTPLL, lo nombramos PPL_NIOS y aceptamos.

Una vez dentro de los parmetros de nuestro nuevo componente, le indicamos que la frecuencia de entrada ser de 50 Mhz.

En la siguiente ventana desmarcamos las opciones de entradas y salidas auxiliares.

Luego nos vamos a la tercera pestaa titulada Output Clocks y configuramos el reloj cero clk c0 para que entregue 50 Mhz y el clk c1 lo configuramos a 100 Mhz.

Finalizamos la configuracin y Quartus II nos mostrar el diseo final del bloque creado.

Lo incluimos en nuestro diseo y cambiamos su nombre de intancia a inst_PLL.

Nuestro siguiente paso ser crear las conexiones entre nuestros componentes, si bien podemos conectar anlogamente nuestras lneas y buses, podemos crear un pequeo segmento y nombrar nuestros buses para conectarlos implcitamente tal como lo muestra la siguiente imagen.

Observamos que el bus contiene dos lneas y fue nombrado como CTRL_BUS desde ahora todos los buses nombrados del mismo modo estarn implcitamente conectados entre s.

Hacemos las conexiones apropiadas tal como se muestra a continuacin, adems hemos agregado deos salidas conectadas directamente desde nuestro puerto de control Nios a dos LEDs para saber como se est comportando nuestro proyecto.

Una vez hechas todas las conexiones necesarias, debemos conectar los pines del FPGA a las salidas de nuestros mdulos, para ahorrarnos la tediosa tarea de hacerlo uno por uno, nos posamos sobre cada uno de los componentes y haciendo click con el botn derecho del mouse, seleccionamos la opcin Generate Pins for System Symbols, tal como lo muestra la

imagen a continuacin.

El resultado se puede ver en la siguiente imagen.

Nos vamos al Pin Planner para corroborar la conexin de todos nuestros pines y observamos que la nica entrada no configurada es la que se cre en el mdulo PLL_NIOS dado que por defecto el System Builder de Terasic configura como entrada de reloj directamente al relol del mdulo Nios. Simplemente eliminamos este pin y modificamos apropiadamente la entrada de nuestro PLL_NIOS.

Finalmente compilamos y si todo ha salido bien, grabamos el proyecto en nuestra FPGA y abrimos nuestra IDE de eclipse indicndole el Workspace apropiado.

APLICACIN SOFTWARE

En esta seccin no se profundizar en la configuracin del IDE dado que los pasos son los mismos que se usaron para las aplicaciones del primer tutorial, apuntando a la carpeta del proyecto actual.

Creamos un proyecto para nuestro sistema concurrente, en este caso llamado Hola_concurrencia y elegimos la plantilla Hello World.

Aceptamos y cambiamos el cdigo original por el mostrado a continuacin, la idea de este programa es modificar el Bus de control que va hacia el contador mediante instrucciones desde el terminal serial y as cambiar el comportamiento de nuestro contador VHDL.

Compilamos el proyecto y lo cargamos en el hardware del Nios, si todo ha sido exitoso el terminal serial nos mostrar el men tal como en la siguiente imagen.

Podemos presionar las distintas teclas indicadas y ver como el comportamiento de nuestro contador VHDL cambia fsicamente, en horabuena!!.

TERCER TUTORIAL DISEO STAND ALONE

Hasta ahora todos nuestros proyectos por muy complejos que sean, solo quedan guardados en el FPGA y la SDRAM mientras la placa est energizada, dado que estos dos dispositivos solo contienen memoria voltil. Si bien esto es provechoso en etapas de desarrollo, cuando tenemos un diseo eficiente y final queremos que este se mantenga. Para esto haremos uso de un componente llamado EPCS, el cual es una memoria de configuracin en la cual podemos cargar tanto nuestro diseo FPGA como nuestro cdigo C++ los cuales quedarn permanentemente grabados hasta que deseemos borrarlos.

DISEO DEL HARDWARE

Para esto, agregamos en el System Builder de Terasic adicionalmente el mdulo EPCS adems de los usados en el resto de los tutoriales.

Una vez generado el proyecto, en nuestro Quartus II, vamos a Assignments-> Device->Dual Purposse Pins.

Y modificamos la tabla tal como se indica a continuacin.

Aceptamos y vamos a nuestra herramienta SOPC, introducimos un nuevo componente llamado EPCS serial Flash Controller el cual lo encontramos en Memories and Memory controllers-

>Flash interfaces. Una vez en la ventana de configuracin, deseleccionamos los dos check boxes y aceptamos, tal como se muestra en la imagen a continuacin.

El resto del sistema se crea de la misma manera que en el primer tutorial (o simplemente modificamos nuestro primer tutorial).

Luego, debemos entrar a la configuracin de nuestro componente Nios II y cambiamos el Reset Vector apuntando a nuestro nuevo componente EPCS tal como se indica a continuacin.

Generamos el proyecto e instanciamos el sistema Nios en el Top Level Desing tal como en los tutoriales anteriores agregando nuestro nuevo componente EPCS, tal como se muestra a continuacin.

DISEO DE APLICACIN SOFTWARE

Una vez instanciado y compilado, entramos a nuestra IDE Ecplise y generamos un nuevo proyecto y repetimos los pasos y el ejemplo usado en el primer tutorial.

Compilamos nuestro proyecto tal como en las experiencias anteriores, pero esta vez no utilizaremos la opcin Run As Nios sino que nos vamos a la pestaa Nios II -> Flash Programmer.

Una vez dentro de la ventana del Flash Programmer refrescamos la conexin y elegimos las opciones de ignorar el System ID y el System timestamp.

Luego creamos un nuevo proyecto Flash programmer en File -> New.

Ingresamos el archivo SOPC creado para nuestro proyecto.

Luego en agregamos al Flash programmer el archivo de nuestro proyecto con la extensin sof presionando el botn add.

Una vez ingresado volvemos a presionar el botn Add y buscamos el archivo con extensin elf, este se encuentra dentro de la carpeta Software de nuestro proyecto.

Finalmente, una vez ingresados estos dos archivos aceptamos y comenzar la grabacin en la EPCS de nuestra placa, si todo ha salido bien, el siguiente mensaje aparecer en la consola de nuestros Flash Programmer.

Nuestra placa a quedado pausada, para volver a activarla simplemente desconectamos el cable USB y volvemos a conectarlo. Nuestro LED comienza a prenderse, felicitaciones!!.