Written by Fabio Andres



In this manual you are going to understand how the SNES Controller Works, and how we can acquire through a simple Finite State Machine (FSM), all the buttons states from the SNES controller using the de0-nano SOC (you can use any FPGA borad, and implement this manual).

It is important to make clear that this manual is based on "SNES timing diagram"(Design Methodology) by Thomas D.


Required Materials:

  1. Any FPGA board (Though for this manual we are going to use the DE0-NANO-SOC)
  2. SNES Controller (10 USD on Ebay)


Brief Explanation:

  • Let's start by looking at the SNES Controller Pinout:



As you can see The SNES has two gamepad ports which each have 5 wires. Two are the power supply wires: brown (ground) and white (5v). Two of the three remaining wires are used by the SNES to output clock and timing information: yellow (data latch), and orange (data clock) y el Puerto restante es el rojo (DATA).


  • The SNES sends a 12 us positive impulse on the data latch wire (yellow). This data latch indicates the SNES will start sending 16 data clock periods to the gamepad on the clock wire (orange) which are used by the gamepads to indicate what buttons are pressed. Each of the 16 data clock periods represent a different button, and the SNES will expect the output signal to toggle on those data clock periods which indicates a button on the gamepad is pressed.

There are 12 buttons on the SNES gamepad, but the SNES sends 16 data clocks periods. Only the first 12 data clock periods are used, the following 4 are ignored by the SNES. The protocol was first designed for the NES console which had less buttons. Nintendo added new buttons on the SNES but didn't change the communication protocol as it could support more buttons. Potentially, this protocol could support up to 16 different buttons.



  •  Once the logical procedure is understood, the following step is to put this into a FSM Diagram to make it more understandable.


  • The previous FSM diagram is composed by 5 different states which are necessary to get the buttons status from SNES controller:
    • IDLE: this state set up the delay in 12 microseconds and, if the signal start is high, go to the next state.
    • STATE1: in this state the LATCH  signal is high, and stay in this status as long as the delay is greater than zero, when have passed 12 microseconds, the FSM go to the next state.
    • STATE2: in this state the LATCH signal  goes from high state to low state and the clock signal hold in high state as long as the delay is greater than zero, when have passed 6 microseconds, the FSM go to the next state.
    • STATE3: in this state all the signals hold in low state (the clock signal goes from high state to low state) From now on whenever a flank is down it takes a button and it is stored in the buttons_temp vector [14: 0] (always@ negedge clk_snes) if the module have saved all the 16 buttons state, the FSM go to the next state, else , the FSM returns to the state 2 and save a new botton state.
    • STATE4: in this state the clock signal hold in high state as long as the delay is greather than zero, when have passed 12 microseconds the FSM go to the next state.
    • FINISH: in this state the finish signal hold in high state and the bottons state are sent to the output of the module and the FSM goes to the IDLE state. 


  • The above description can be represented by the following graph through time:


  •  Now it is time to see the Verilog Code, for this logic.
    • Verilog Module pinout:
      module SNES_FSM(
      				input clk_50,
      				input start,
      				input data_in_snes,
      				output reg [11:0]buttons_snes,
      				output finish,
      				output idle,
      				output latch_snes,
      				output clk_snes
    • States and control signal declaration:
      localparam   IDLE  =  10'b0_____________1_________0________1______000001;
      localparam   STATE1=  10'b1_____________1_________0________0______000010;
      localparam   STATE2=  10'b0_____________1_________0________0______000100;
      localparam   STATE3=  10'b0_____________0_________0________0______001000;
      localparam   STATE4=  10'b0_____________1_________0________0______010000;
      localparam   FINISH=  10'b0_____________1_________1________0______100000;
      							//numero de clocks del relog base de 50 Mhz
      localparam   TIME6u	= 10'd300;
      localparam   TIME12u	= 10'd600;
      reg [9:0]state=IDLE;
      reg [9:0]delay=TIME12u;
      reg [3:0]num_clks=4'd0;
      reg [14:0]buttons_temp=15'd0;
      wire pre_finish=(state[9:0]==STATE4)?1'b1:0;
      assign latch_snes=state[9];
      assign clk_snes=state[8];
      assign finish=state[7];
      assign idle=state[6];
    • Main FSM:
      always@(posedge clk_50)
      	IDLE  :begin
    • shift register to save button states:
      always@(negedge clk_snes)
    • When FSM has acquired all the buttons, sends them to the output of the module:
      always@(posedge pre_finish)


  •  Once we have taken a look at the FSM diagram and the Verilog description, we can simulate using ModelSim to verify that the designed FSM works properly, and we meet the timing specifications.





  • ENJOY!







Written by Holguer Andres


  1. DE0-NANO-SOC with and SD-CARD preloaded with the following Linux Image (compiled and customized by Holguer Andres).
  2. Putty


  • Using putty open the Linux Terminal through the UART port at 115200 bps.
  • On the Console type:
    nano /etc/inittab​

  • As you can observe in the next image, and highlighted in red, all the initial system processes init with ":sysinit:" and next to this a command or a script that is going to be run on the initialization of the system.


  • To see how it works, we are going to modify the file rcS by typing the following:

    nano /etc/init.d/rcS
  • once you have typed the previous console line, the nano editor is going to show you on the console the file rcS, and you are going to add the line highlighted in red 'fpgalover.com'

  •  Now save and exit.

  • Type on the console 'reboot' to restart the system

  •  once the system is relaunched, you will see at the beginning a new line message that contains what you just have written on the rcS file.

  • Now it is your time to add your own script to the inittab file and execute what you desire!



  1. https://access.redhat.com/documentation/en-US/Red_Hat_Enterprise_Linux/5/html/Installation_Guide/s1-boot-init-shutdown-sysv.html
  2. http://stackoverflow.com/questions/10408816/how-do-i-use-the-nohup-command-without-getting-nohup-out


Written by Fabio Andres


Nios II is an embed processor of structure of 32 bits specifically designed for FPGAs of the brand Altera (Intel).  Nios II has many improvements with the original architecture niosll/e, therefore is more suitable for a huge kinds of informatics applications such as DSP and control systems, moreover, Nios II processor is the world's most versatile processor, according to Gartner Research, and is the most widely used soft processor in the FPGA industry. The Nios II processor delivers unprecedented flexibility for your cost-sensitive, real-time, safety-critical (DO-254), ASIC-optimized, and applications processing needs. The Nios II processor supports all Intel FPGA and SoC families.



In the previous imagen shows the different modules that conform the Nios II, the modules debug option, fixed and optional are configurable.  




  1. APPLICATION PROCESSING: With a simple configuration, the core of the fast Nios II processor can use an unit of memory management unit (MMU) for run embedded Linux.  Open code and Linux’s compatible versions are available for Nios II processor.
  2. ECONOMY: With only 600 logic elements, the Nios II processor core is ideal for applications of micro-controllers. The embedded Software Tools, Software, and Middleware it can be free.
  3. REAL TIME: A yield without jitter absolutely deterministic in real time with hardware. These are some functions in real time:
  • Vector controller of interruption
  • Memory of rigid structure
  • Nios II processor is the processor in real time ideal for use with the hardware accelerators based on DPS for provide results in real time with high yield.



 These are the steps for the design of this practice.

1. Firstly we create a new quartus project file (.qpf) with system builder tool for de0nano soc boards, in this case the name of the archive is NIOS II PRACTICE.



Finally we click in the GENERATE button and we generate a new quartus project file (.qpf).

2. Save the file that system builder created, for opening the archive is necessary to find a nearest route to main disk, that route must not have spaces or strange symbols.


3. Open the archive and find a .qpf file. open the file with Quartus II, in the upper part where it says TOOLS find theoption QSYS and open it. 

(Right-Click on the image and open image in new tab to Magnify)

4. When you click in the QSYS option, you will see a window like this:

 In the left part will appear the IP CATALOG,in this part, you can find all the compliments or modules that you can add or use for the design. 

5. Save your design as Nios II. The first module that you have to add will be the Nios II embedded processor, for that, go to IP CATALOG and search NIOS there will appear NIOS II and you have to double clicking.

 6. Then appear a window similar like this,  choose NIOS/E option.

Both options of Nios work, however Nios / f has the fastest processor and can execute more instructions per second, in this case we choose the version Nios II / e (free option) , then, you click FINISH.


7. In IP CATALOG you have to write the word CHIP and inside of the options it will appear the ON-CHIP MEMORY option, double-click in this and then, set the memory capacity to 116000, finally click FINISH.



 8. Now, go and search the word PLL,  select the Altera PLL module and double-click. 

 When the new window is opened, configure the module selected with a beginning clock of 50 Mhz and then other of 150 Mhz how the image shows.


 9. For the next module, write JTAG UART and double-click.

When the configure window opens, everything remains the same as the image. Nothing change.  


10. For the next module is necessary add three modules of the same name, but with different functions, go for IP CATALOG and search the word PIO, double-clicking to add each module.


 Below it shows the different configurations of PIO ports which will be inputs and outputs.

 The first one will be an entry of 4 bits as the image shows


The second port will be an 8-bit output.

 And finally one of 32 bits

 11. Now, search the word UART and choose UART SERIAL, double-click and, in the configuration part, do not change anything. 

12. The last module that we added is the INTERVAL TIMER, we choose and double-click, and the same as the previous item, we do not chance anything. 

13. With all the modules ready, is necessary chance the names to differentiate from each other as the image shows.

Change the names as the image shows.


14. To observe how the project is going, go for VIEW and click in schematic

When you double-click, Qsys show you the window with all the modules that you have at the moment with the Inputs and Outputs.




15. Open the module called cpu, and configure vector section as the image shows: 

16. Now it is time to interconnect all the modules that you have added to the qsys design as follows:


17. This step is necessary to result the position mistakes that genereted the modules, therefore you go to button system in the top left and double click in assign addreses and assign interrupt numbers , finally all the mistakes disappear. 



18. Finally you have to generate the HLD file that you can generate in the lower part or in upper part as the imagen shows.


19.You can show the instantiation template in order to instantiate our nios ii system in the main module.



20. Click in CLOSE and return to Quartus II, the next image shows an example about instantiation in the main file.

21. Before compile the project, you have to add a qsys file, as the images show.

22. Now, you can compile the project and check if all is correct



Solution Source: Download.


Written by Juan David



El proyecto FPGArduino consiste en transformar el uso que normalmente se le da a la FPGA y usarlo como un sistema de micro controladores programables usando Arduino. El sistema consiste en construir una “CPU CORE” que ejecuta subgrupos de cualquier RISC-V o MIPS grupo de instrucciones.


¿Qué es softcore?

Es un microprocesador de núcleo que puede ser implementado en su totalidad mediante la síntesis de la lógica. Se puede implementar a través de diferentes dispositivos semiconductores  que contienen la lógica programable (por ejemplo, ASIC, FPGA, CPLD), incluyendo tanto de gama alta y las variaciones de las materias primas.


¿Qué es una CPU CORE?

Un procesador multinúcleo es aquel que combina dos o más microprocesadores independientes en un solo paquete, a menudo un solo circuito integrado. Generalmente, los microprocesadores multinúcleo permiten que un dispositivo computacional exhiba una cierta forma del paralelismo a nivel de thread (thread-level parallelism) (TLP) sin incluir múltiples microprocesadores en paquetes físicos separados. Esta forma de TLP se conoce a menudo como multiprocesamiento a nivel de chip (chip-level multiprocessing) o CMP.


En este caso la CPU CORE que usamos es una F32C. La F32C es un retarguetable (diseñada para generar código para más de una plataforma), escalar (variable), pipelined (grupo de elementos de procesamiento de datos conectado en serie), procesador de 32-bit que es capaz de ejecutar subgrupos de cualquier RISC-V o MIPS grupo de instrucciones. Es implementado en VHDL parametrizada que permite sintetizar con diferentes compensaciones de área o velocidad, e incluye un predictor de saltos, manejo de excepciones de control de bloques, y caches de correlación opcionales. El código RTL además incluye módulos como controladores SDRAM y SRAM de multi-puertos, framebuffers de vídeo con material compuesto ( PAL ) , HDMI , DVI y VGA con aceleración simple 2D para sprites y windows, SPI , UART , audio PCM , GPIO , salidas PWM y un temporizador, así como la lógica de pegamento adaptados para el desarrollo de numerosas tarjetas FPGA de varios fabricantes.

 ¿Cómo funciona?

Una vez configurado, la FPGA se comporta como sistema en un chip de 32 Bit, ejecutando un gestor de arranque que espera una compilación binaria para ser recibida en el puerto serial de la FPGA.

Compilar y subir el programa (sketch) es fácil para todas las plataformas. El proceso funciona incluso con sistemas operativos que algunas herramientas de síntesis de la FPGA no soportan.


Procedimiento para usar un ARDUINO con la FPGA

Lo primero que se debe hacer es abrir el código en QUARTUS que se encuentra al final de la pagina llamado DE0_NANO_SOC_arduino.qar

El montaje para conectar la FPGA con el Conversor Serial USB consiste en conectar el Transmisor (Tx) de la FPGA con el Receptor (Rx) del Conversor Serial USB, además conectar el Receptor de la FPGA con el transmisor del Conversor Serial USB y también conectar las tierras de ambos dispositivos.


Como se observa en el código la FPGA maneja unas entradas que son la del reloj, unos switch, dos botones y un receptor, y tiene unas salidas que son los Led y el transmisor.


Luego de programar la FPGA se puede observar la conexión en RTL de forma detallada de cómo está construido.


En las imágenes se observa que hay un conjunto de memorias y una etapa de pipeline.


Luego, se procede a conectar el Conversor Serial USB  y se abre el archivo Blinked.ino (se encuentra al final de la pagina).

Al abrir el archivo se abre un código en ARDUINO UNO, para  ejecutarlo primero debe asegurarse de que las siguientes configuraciones estén aplicadas:

  1. En la ventana de ARDUINO IDE abrimos el menú archivo y selecciona preferencias

Luego de haber seleccionado aparecerá una ventana como la siguiente y en esta debe buscar la opción que dice “Gestor de URLs adicionales de tarjetas” y en este espacio agregue la siguiente dirección: http://www.nxlab.fer.hr/fpgarduino/package_f32c_core_index.json

    2.    Ahora seleccione el menú herramientas y busque la opción que diga “placa”, luego seleccione “gestor de tarjetas”

Luego de seleccionar esta opción busque en la ventana a la que lo dirige la opción que dice “FPGArduino by FER+RIZ+RADIONA” e instalela.

    3.    Ahora para poder empezar a dar uso al programa que usara con la FPGA y el Conversor Serial USB debe seleccionar las siguientes opciones:

                a.    En el menú de herramientas se debe asegurar de que en la opción de placa este seleccionado “Terasic DEO NANO”

                b.     En el menú herramientas en la opción de CPU Architecture seleccionar “MIPS”
                    c.        En el menú herramientas en la opción de RAM size seleccionar “32 KB BRAM Internal”
                d.        En el menú herramientas en la opción “programador” seleccionar “ujprog (FPGArduino)”
                e.        En el menú de herramientas en la opción de “puerto” seleccionamos “COM4”

        Una vez hecha la conexión de la FPGA y el Conversor Serial USB (que se muestra en la figura)

            Al ejecutarlo lo que se muestra en la pantalla es lo siguiente
        En el siguiente vídeo podrá observar el funcionamiento en la FPGA

Vídeo de YouTube


Vídeo de YouTube

Con el siguiente diseño, genere una secuencia musical
El procedimiento es el siguiente: 
  1. Descargue DE0_NANO_SOC_arduino_2.qar
  2. Abra el archivo en quartus, y abra el archivo Rom_Musical
    Lo que tiene que hacer en la Rom_Musical es añadir las notas que se utilizaran en la secuencia musical que desea hacer añadiendo el numero correspondiente a la frecuencia de cada nota. El numero lo halla con la siguiente formula: En este caso la frecuencia que maneja el reloj es de 50Mhz y la frecuencia de salida es la frecuencia de la nota. Lo único que debe cambiar de la Rom_musical es en el "case" donde dependiendo de la cantidad de notas que va a manejar la secuencia musical es la cantidad de temporales que va a utilizar.

    Una vez haya cambiado las frecuencias de las notas que utilizara, ya se tiene la Rom_Musical, el Div_Freq que se usa en el diseño, y solo falta diseñar el software que mandara la señal a la Rom_Musical mostrando cual es la secuencia musical que debe seguir y la Rom enviara la frecuencia al divisor para que luego se reproduzca en el altavoz.
  3. Ahora para diseñar el software descargue Secuencia_Musical, copielo y peguelo en el archivo "Blinked.ino" que se trabajo anteriormente.
  • Esta parte del código consiste en definir al nombre de las letras que definimos en la Rom_Musical y asignarles un valor. 
  • La siguiente parte del código consiste en un switch el cual se encarga de identificar la nota que sigue en la secuencia y envía una señal a la Rom_Musical para que está pueda enviar la nota al divisor.  En cada "case" se lee la nota dependiendo del valor que le asigno y usd debe formar el numero en binario con varias funciones digitalWrite siendo la 8 bit menos significativo y el 12 el mas significativo.
  • La parte final del código consiste en hacer la secuencia musical deseada en la que pondrá en orden todas las notas que ya asigno con sus respectivos tiempos de duración en el "delay" que se expresa en mili segundos.
En el siguiente video puede observar la secuencia musical desarrollada.

Vídeo de YouTube


Written by Jesus

Basado en la practica de PicoCtrl del Prof. Yair Linn.
    • Aprender como funciona y como programar el microcontrolador PicoCtrl, adquiriendo conocimiento de como funciona un microcontrolador.


    Un microcontrolador es un circuito integrado de alta escala de integración que incorpora la mayor parte de los elementos que configuran un controlador. Un microcontrolador dispone normalmente de los siguientes componentes:
    1. Procesador o UCP (Unidad Central de Proceso).
    2. Memoria RAM para Contener los datos.
    3. Memoria para el programa tipo ROM/PROM/EPROM.
    4. Líneas de E/S para comunicarse con el exterior.
    5. Diversos módulos para el control de periféricos (temporizadores, Puertas Serie y Paralelo, CAD: Conversores Analógico/Digital, CDA: Conversores Digital/Analógico, etc.).
    6. Generador de impulsos de reloj que sincronizan el funcionamiento de todo el sistema.


    El primer microprocesador fue el Intel 4004 de 4 bits, lanzado en 1971, seguido por el Intel 8008 y otros más capaces. Sin embargo, ambos procesadores requieren circuitos adicionales para implementar un sistema de trabajo, elevando el costo del sistema total.El Instituto Smithsoniano dice que los ingenieros de Texas Instruments Gary Boone y Michael Cochran lograron crear el primer microcontrolador, TMS 1000, en 1971; fue comercializado en 1974. Combina memoria ROM, memoria RAM, microprocesador y reloj en un chip y estaba destinada a los sistemas embebidos.Debido en parte a la existencia del TMS 1000, Intel desarrolló un sistema de ordenador en un chip optimizado para aplicaciones de control, el Intel 8048, que comenzó a comercializarse en 1977. Combina memoria RAM y ROM en el mismo chip y puede encontrarse en más de mil millones de teclados de compatible IBM PC, y otras numerosas aplicaciones. El en ese momento presidente de Intel, Luke J. Valenter, declaró que el microcontrolador es uno de los productos más exitosos en la historia.

    1. EL microcontrolador tendrá 6 señales de condición de entrada que controlan la ejecución de microinstrucción, las señales son asíncronas y estarán sincronizados dentro del controlador
    2. El microcontrolador tendrá 32 instrucciones que se pueden ejecutar, si el microprograma se pasa de los 32 este se pondrá en 0
    3. El microcontrolador tendrá 4 puertos de salida de 8 bits controlados por la instrucción de escritura. Cada uno de los puertos tiene su propio registro de salida ( es decir, el valor de salida es estable hasta que se cambie por microprograma ejecutado)
    4. Cada instrucción se ejecuta en dos ciclos de reloj - el primer ciclo es una zona de alcance de un ( FETCH fase) , la segunda ejecución de un ( fase de ejecución)
    5. El microcontrolador ejecutará instrucción de salto ( salto a la dirección almacenada en la instrucción )
      Instrucion NOP ( operación ignorado )
    6. La instrucción WRITE ( escribir al puerto de salida ) .

  4. Procedimiento

    Para empezar vaya a la ubicación donde tenga la carpeta SystemBuilder, esto con el fin de crear un Proyecto a través de dicha aplicación. 

    Al ejecutarlo  se obtiene la interfaz (figura) que genera el proyecto, debe tener en cuenta las partes de la DE0-Nano-SoC que utilizara ya que debe seleccionarlas para que  aparezcan en dicho proyecto, en este caso puede seleccionar todas, no importa, lo importante es no dejar por fuera las que  se necesitan. En Project Name ponemos el nombre de nuestro proyecto, a este proyecto se le llamo DE0_Nano_SoC_picoCtrl

    Luego, damos click en Generate, se nos despliega una ventana de (guardar como), elegimos el destino de nuestro proyecto, preferiblemente una carpeta donde se tengan todos los proyectos de clase.

    Nos dirigimos a la ubicación donde guardamos nuestro proyecto(en este caso, SystemBuilder tiene una carpeta donde guarda los proyectos por default, llamada CodeGenerated) si usted guardo su proyecto en otra ubicación no tiene problema alguno; siga a ejecutar el  archivo de tipo QPF llamado de la misma forma como llamo su proyecto.

    Ahora diríjase a su carpeta de GitHub\ece10243upb2016\Prof_Examples\3-1_PicoCtrl  donde encontrara los archivos de PicoCtrl_rom32_instructions,  picoctrl_Verilog,  opcodes, Pico, README, PicoCtrl-AnFPGAMicrocontrollerDesign (1).

    Si usted no tiene esto haga lo siguiente:
    1. Dirijace al siguiente link https://github.com/Adrizcorp/ece10243upb2016
    2. Abra la carpeta Prof_Examples
    3. Abra la carpeta 3-1_PIcoCtrl donde encontrara los archivos mencionados.

Copie cada uno de los archivos tipo “Archivo v” y péguelos en una nueva carpeta a la cual llamara “Modules” esto con el fin de llevar un orden. La carpeta será creada en la carpeta donde tenemos nuestro proyecto de PicoCtrl

Se preguntara por que el archivo “opcodes” no se encuentra en dicha carpeta, Estos se debe a que “opcodes” contiene una sintaxis que será leida por Quartus para que esto suceda sin generar error alguno, “opcodes” fue copiado en la carpeta principal

También necesitamos los archivos de syncro.v y div_freq.v Estos archivos son de proyectos pasados, en caso tal de no tenerlos diríjase al siguiente link y descárguelos

Divisor de frecuencia (div_freq.v)

Sincronizador (syncro.v)

Estos archivos también deben ir en la carpeta de “modules”

Diríjase a QUARTUS donde tiene abierto su proyecto DE0_Nano_SoC_picoCtrl

En la parte izquierda encontrara “Files” selecciones, aparecerán los “Files” que tenemos, lo que tenemos que hacer es agregar nuevos “Files”, se acuerdan los .que agregamos a la carpeta de Modules? Cada uno de ellos los agregaremos de la siguiente forma.

click derecho en “Files” en al parte superior izquierda y le daremos add/remove files in project

Se desplegara la siguiente ventana

En los tres puntos de la imagen dele click y seleccione todos los  .v que están en la carpeta “modules” incluyendo los “opcodes” que copiamos en la carpeta principal, debe quedar algo asi

click en apply y luego en ok.

Ahora en general debe tener algo así.

Lo siguiente  es crear las instanciaciones de cada uno de los .v, solo es dar click derecho en el archivo y seleccionar “créate verilog Instantiation template files for current file

Así de la misma forma con cada uno de los punto .v

Las instanciaciones se guardaran en la carpeta del proyecto, en la principal  de esta forma.

Abra cada una de las instanciaciones y copie el código, por ejemplo, abriremos  syncro_inst 

Este es el código a copiar, copiara cada uno de los códigos de las instanciaciones en el modulo principal de su proyecto en QUARTUS

El código con instanciaciones debe verse asi

El siguiente paso es borrar cada una de las entradas o salidas por defautl que aparecen en el código de cada instanciación

Luego  identificar las entradas y las salidas,  hay que  saber que entra y que sale para poder hacer las respectivas conexiones.

se tiene una entrada de 5 bits y una salida de 16 bits en la instanciación del PicoCtrl_rom32_instructions por lo tanto para ello se cre buses de datos (wire’s) para conectar dichas entradas y salidas.

Los wire deben tener la misma cantidad de bits.

se pasa a ver la instanciación del Picoctrl ; tenemos una entrada de reloj el cual se utilizara la que nos proporciona la FPGA FPGA_CLK1_50 , tenemos una entrada  reset la cual se colocara en 1 lógico 1’b1 (encendido) , una entrada  cond_1  la cual será un reloj de 1hz tenemos una segunda condición  cond_2  *(~clk_1hz_sync), las condiciones del 3-6 no importa por lo tanto están en 1'b00 (apagadas) , se utilizara el registro 1, esa será nuestra salida a los led’s por ende seran conectados a los LED[7:0] quiere decir que utilizaremos los 8 leds que nos proporciona la FPGA.

Esta parte es importante, fíjese que a la salida de instruction_ROM_Addr se le asigna la entrada  addr (encerrada en rojo) y la entrada de instruction_ROM_data se le asigna la salida del data (encerrada en azul).

*la condición 2 es un reloj de 1hz pero tiene  el signo de negación (~) esto hace que pase ser de 1hz a 0,5 hz, es la forma de hacer un divisor de frecuencia. Ejemplo : si tiene un reloj de 50hz como el que da la FPGA, solo con anteponer (~)  se tendría uno de 25hz.

se pasa a la instanciación de div_freq

se tiene  una entrada de reloj a la cual conectamos FPGA_CLK1_50  que ya sabemos es el reloj de 50 hz que nos proporciona la FPGA, tenemos una entrada de 32 bits a la cual asignamos 32’b24999999 este numero es sacado de la formula y por ultimo tenemos una salida div que seria nuesto reloj de 1hz.

Por ultimo se pasa a la instanciación syncro donde tenemos una entrada async que será nuestro reloj de 1hz, una entrada clock que será nuestro reloj de 50hz y una salida sync que será nuestro otro reloj de 1hz.

Con esto se terminan cada una de las instanciaciones ahora dirígea dar click en  assembler Para iniciar la compilación del programa.

Luego de compilado nuestro proyecto nos dirigimos a programmer  esto desplegara la siguiente ventana

En add device seleccionaremos  Soc Serie V y SOCVHPS y dara click en OK

luego vamos a add files y selecciona el .sof  debe salir algo así

procedemos hacer click en el botón de START

observe  lo que hacen los LEDs, Deben hacer el siguiente recorrido con 0.5 segundos entre cada posición:


Donde   "1" significa encendido y "0" significa apagado.


Ahora bien, lo que hara será hacer la siguiente secuencia, donde ¨X¨ será encendido y ¨0¨ Apagado

0000 000X
0000 00X0
0000 0X00
0000 X000
000X 0000
00X0 0000
0X00 0000
X000 0000
0X00 0000
00X0 0000
000X 0000
0000 X000
0000 0X00
0000 00X0
0000 000X

Bueno, lo que se debe hacer es cambiar la configuracion de la ROM, abra el  .v de PicoCtrl_rom32_instructions  y cambie las condiciones del registro por la secuencia que se dio

Que es lo que quiere decir esto, se esta asignando ala room el data siguiente, si  c0 es igual a 0 escriba (write) en el regitro 1 8'b0000_0001, eso  en cada (write) de la misma forma, por ejemplo en la tercera  línea, si c0 es igual a 0 escriba en el registro 1 8'b0000_0010.

Ahora cada jump (salto), por ejemplo en la cuarta línea si c1 es igual a 0 haga un salto a 8´h3, pero dese cuenta que 8´h3 esta en la misma posición, así que se queda en el mismo lugar , así mismo cada jum.

Después de tener algo similar a la imagen, debemos compilar de nuevo nuestro programa, añadir de nuevo nuestro archivo .v y nuestro archivo .sof

Start (archivo GIF)

You can contribute and make this a better place by supporting it.
if you like this webpage, or if the resources of this webpage are useful for you, please donate.

Paypal(Own Amount)

Donate Rapidly 5 USD:

Donate Rapidly 10 USD: