Table of Contents / Tabla de Contenidos

English

Mojo v2 FPGA Development Board - Development board, FPGA, microcontroller 

Finite State-Machine using Button Toggle - FPGA, verilog

Finite State-Machines changing LED automatically - FPGA, verilog

Clock Frequency Divider - FPGA, verilog

Arduino UNO Development Board - Development board, microcontroller

Special Characters for Engineering Using ALT Key

Interfacing SainSmart 20x4 LCD Module with Arduino Uno - microcontroller

What is Hysteresis and Why Care About It? - theory

Trying to Keep Track of Your Code? Try GitHub - programming

LED Circuit Design - theory

Blinking an LED Using the Tiva C Series LaunchPad and Keil µVision - dev board, microcontroller

Microprocessor vs Microcontroller vs FPGA - theory

How to Make an Ethernet Cable Without a Crimping Tool - DIY, networking

Myths About Electricity - theory

Creating a Project with the Terasic DE0-Nano FPGA Development Board - verilog, FPGA, dev board

Driving Single Digit 7-Segment Display with the Tiva C Series Launchpad - microcontroller

Button Press Counter Using 4-Digit 7-Segment Display and Tiva C Launchpad - microcontroller

Frequency Divider by Odd Numbers with 50% Duty Cycle - theory, verilog


Español

Mojo v2 Placa de Desarrollo de FPGA - Placa de desarrollo, FPGA, microcontrolador

Máquina de Estado Finita - Usando Botón para Cambios - FPGA, verilog

Máquina de Estado Finita - Cambiando LEDs Automáticamente - FPGA, verilog

Divisor de Frecuencia de Reloj - FPGA, verilog

Arduino UNO Placa de Desarrollo - placa de desarrollo, microcontrolador

Interfaz entre Módulo de LCD SainSmart de 20x4 con Arduino Uno - microcontrolador

Caracteres Especiales para Ingeniería Usando Tecla ALT

Qué es la Histéresis? - teoría

Estás Tratando de Organizar tu Código? Prueba GitHub - programación

Diseñando un Circuito con LEDs - teoría

Parpadeando un LED con el Tiva C Series LaunchPad y Keil µVision v4 - microcontrolador, placa de desarrollo

Microprocesadores vs Microcontroladores vs FPGA - teoría

Cómo Hacer un Cable de Ethernet Sin Crimpadora o Pinza de Compresión? - DIY, networking

Mitos e Ideas Erróneas Sobre la Electricidad - theory

Creación de Proyecto con la Placa de Desarrollo de FPGA Terasic DE0-Nano - verilog, FPGA, dev board

Control de Pantalla de Siete Segmentos con el Tiva C Launchpad - microcontrolador

Contador de Presión de Botón con Pantalla de 7 Segmentos y 4 Dígitos y el Tiva C Launchpad - microcontrolador

Divisor de Frecuencia por Número Impar con Ciclo de Trabajo de 50% - verilog, teoría

Mojo v2 Placa de Desarrollo de FPGA

Hace un par de años, ayudé a financiar un proyecto de Embedded Micro para crear Mojo (se pronuncia mou-llo), una placa de desarrollo de FPGA. La placa contiene:

- FPGA Spartan-6 XC6SLX9
- 84 pines de entrada/salida (I/O)
- 8 pines de entrada análoga
- 8 LEDs de uso genérico
- 1 botón de reinicio (reset)
- 1 LED para el estado de configuración del FPGA
- Regulador de voltaje entrante para 4.8V - 12V (5V recomendado)
- Microcontrolador ATmega32U4 para configurar FPGA, interfaz de USB y leer pines análogos
- Memoria flash integrada a la tarjeta para el archivo de configuración del FPGA

El microcontrolador usa una secuencia de arranque compatible con Arduino, para permitir cargar código usando simplemente USB. Embedded Micro también provee un cargador basado en java para cargar el codigo .bin para el Spartan-6 usando simplemente USB.

Esta placa de desarrollo me pareció muy conveniente gracias al potente FPGA Spartan-6. Además, en comparación a la mayoría de placas de desarrollo ofrecidas por Xilinx o Altera, el precio de ~$80 es de fácil acceso para los entusiastas.

Si deseas comprar la placa, o buscar instrucciones para descargar e instalar los programas requeridos por el Mojo, vista la página web de Embedded Micro.

Para la mayoría de mis proyectos de FPGA en este blog, estaré usando el Mojo v2.

Máquina de Estado Finita en Verilog - Usando botón para transiciones

Este código es un ejemplo de una máquina de estado en Verilog y puede ser usado en la placa de FPGA  Mojo.

El código enciende uno de los 8 LEDs a la vez en el Mojo. El LED encendido cambia cada vez que el botón de reinicio (Reset) en el Mojo es presionado.


module LED_state_machine1(

    input   clk,           // reloj de 50MHz   
    input   nRst,          // entrada de botón reset   
    input   cclk,          // reloj del microcontrolador AVR
    output  reg[7:0]led,   // salida a 8 LEDs en tarjeta  
    

  // las siguientes conexiones son para el microcontrolador en el Mojo
    output  spi_miso,          // conexiones SPI para AVR
    input   spi_ss,
    input   spi_mosi,
    input   spi_sck,
    output  [3:0] spi_channel, // AVR selección de canal
    input   avr_tx,            // AVR Tx => FPGA Rx
    output  avr_rx,            // AVR Rx => FPGA Tx
    input   avr_rx_busy        // AVR Rx buffer lleno
    );
// sólo para Mojo. asignar alta impedancia si pines no son usados.
assign  spi_miso = 1'bz;
assign  avr_rx = 1'bz;
assign  spi_channel = 4'bzzzz;

reg       rst;     // crea registro para botón

reg  [3:0]state=0; // crea registros para estados

always@(posedge clk)
 rst <= ~nRst;     // connects reset button to rst register

//beginning of state-machine
// inicio de máquina de estado
always@(posedge rst)  // máquina transiciona si rst es presionado
   begin              // comenzar secuencia de máquina de estado
    case(state)
     3'd0: begin
            led[7:0]<=8'b0000_0001;  // sólo led[1] encendido
            state <= 3'd1;           // saltar a estado 3'd0
           end
     3'd1: begin
            led[7:0]<=8'b0000_0010;  
            state <= 3'd2;           
           end           
     3'd2: begin
            led[7:0]<=8'b0000_0100;
            state <= 3'd3;
           end
     3'd3: begin
            led[7:0]<=8'b0000_1000;
            state <= 3'd4;
           end
     3'd4: begin
            led[7:0]<=8'b0001_0000;
            state <= 3'd5;
           end
     3'd5: begin
            led[7:0]<=8'b0010_0000;
            state <= 3'd6;
           end
     3'd6: begin
            led[7:0]<=8'b0100_0000;
            state <= 3'd7;
           end
     3'd7: begin
            led[7:0]<=8'b1000_0000; // 
            state <= 3'd0;          // volver a estado 0
           end
     default: state <= 3'b0; 
    endcase
   end
  end

endmodule

Máquina de Estado Finita en Verilog - LEDs cambiando automáticamente

Este código es un ejemplo de una máquina de estado en Verilog y puede ser usado en la placa de FPGA  Mojo.

El código enciende uno de los 8 LEDs a la vez en el Mojo. Los LED cambian automáticamente a 1Hz.


module LED_state_machine2(

    input   clk,           // reloj de 50MHz   
    input   rst_n,         // entrada de botón reset   
    input   cclk,          // reloj del microcontrolador AVR
    output  reg[7:0]led,   // salida a 8 LEDs en tarjeta  
    

  // las siguientes conexiones son para el microcontrolador en el Mojo
    output  spi_miso,          // conexiones SPI para AVR
    input   spi_ss,
    input   spi_mosi,
    input   spi_sck,
    output  [3:0] spi_channel, // AVR selección de canal
    input   avr_tx,            // AVR Tx => FPGA Rx
    output  avr_rx,            // AVR Rx => FPGA Tx
    input   avr_rx_busy        // AVR Rx buffer lleno
    );

// sólo para Mojo. asignar alta impedancia si pines no son usados.
assign  spi_miso = 1'bz;
assign  avr_rx = 1'bz;
assign  spi_channel = 4'bzzzz;

reg [25:0] count;      // crea registros para contador 
reg        clk2;
reg  [2:0] state=0;    // crea 8 registros para estados
wire rst = ~rst_n;     // conecta botón de reinicio a registro rst


// divisor de reloj 50MHz a 1Hz
always@(posedge clk)
    begin
        if(count==26'd25000000)  // cuenta 25M ciclos de clk              begin                  // cambia clk2 a alto o bajo
            count<=0;            
            clk2 <= ~clk2;       
          end
        else
          begin
            count<=count+1;
          end
    end    


// inicio de máquina de estado
always@(posedge clk2) // máquina cambia a 1Hz
 begin                // con transición de clk2
  if(rst)             //
   state <= 3'd0;     // volver a estado 0 si rst es presionado
  else                //
   begin              // comenzar secuencia de máquina de estado
    case(state)
     3'd0: begin
            led[7:0]<=8'b0000_0001;  // sólo led[1] encendido 
            state <= 3'd1;           // salta a estado 3'd1
           end
     3'd1: begin
            led[7:0]<=8'b0000_0010;  
            state <= 3'd2;           
           end           
     3'd2: begin
            led[7:0]<=8'b0000_0100;
            state <= 3'd3;
           end
     3'd3: begin
            led[7:0]<=8'b0000_1000;
            state <= 3'd4;
           end
     3'd4: begin
            led[7:0]<=8'b0001_0000;
            state <= 3'd5;
           end
     3'd5: begin
            led[7:0]<=8'b0010_0000;
            state <= 3'd6;
           end
     3'd6: begin
            led[7:0]<=8'b0100_0000;
            state <= 3'd7;
           end
     3'd7: begin
            led[7:0]<=8'b1000_0000; 
            state <= 3'd0;          // volver a estado 0
           end
     default: state <= 3'b0; 
    endcase
   end
  end

endmodule

Divisor de Reloj en Verilog

Este código es un ejemplo de un divisor de reloj de 50MHz a 5MHz en Verilog.

Nota: Este código sólo puede dividir frecuencias por números pares (2, 4, 6, 10, etc).  Para dividir frecuencias de reloj por números impares, visita éste articulo.

Los dispositivos lógicos programables operan a velocidades bastante altas. Por ejemplo, el reloj para el FPGA de la tarjeta Mojo opera a 50MHz. Si designáramos un circuito para encender y apagar un LED,  el LED lo haría a 50 o 25 millones de ciclos por segundo (dependiendo del diseño) y por lo tanto, sería imposible de observar con la vista.

Para solucionar esa situación, podemos usar el reloj del FPGA para crear relojes mas lentos. El concepto es simple. El circuito cuenta un número determinado de ciclos de reloj para cambiar una nueva señal a alta o baja. Esta nueva señal sería nuestro nuevo reloj.

La fórmula para calcular el nuevo reloj es simple:

   contador = (reloj_entrante / reloj_nuevo) / 2

entonces, para crear un reloj de 5MHz usando un reloj de 50MHz, nuestro contador usaría 5 ciclos de reloj entrante:

   contador = (50MHz / 5MHz) / 2 = (10) / 2 = 5

En la figura 1, simulamos el divisor de reloj de 50MHz a 5MHz usando Xilinx ISim para mostrar el comportamiento del reloj entrante (clk), el contador (count) y el nuevo reloj (clk2). Nótese que por cada 5 ciclos de clk, clk2 transiciona. La barra amarilla muestra el vector count cuando llega al valor 5 (3'b101) y es seguida por la transición en clk2.

Fig. 1. Simulación de divisor de reloj de 50MHz a 5MHz.

Ejemplo de código:

module clock_divider(
   input           clk,     // reloj entrante de 50MHz
   output reg      clk2,      // nuevo reloj de 5MHz
    );

reg [3:0] count;

// divisor de reloj 50MHz a 5MHz
always@(posedge clk)
    begin
        if(count==4'd4)      // cuenta 5 ciclos (0-4) de reloj    
            begin
              count<=0;      // reinicia cuenta a 0
              clk2 <= ~clk2; // transiciona clk2 a alto o bajo
            end
        else
            begin
            count<=count+1;  //  aumenta contador
            end                  end     

Clock Divider using Verilog

This is a code sample for a 50MHz to 5MHz clock divider using Verilog.

Note: This code will only work to divide the frequencies by an even number (2,4,10, etc).  For a frequency divider by odd numbers, visit this post.

Programmable logic devices (PLD) operate at relatively fast clock speeds. For instance, the clock in the Mojo FPGA runs at 50MHz. If we designed a circuit to make the on-board LEDs blink, they'd do so 50 or 25 million times per second (depending on the design) and therefore, the human eye wouldn't be able to catch it.

To solve that situation we can use the FPGA's input clock to create slower clock signals. The concept is simple. The circuit counts a certain number of clock cycles before setting the new signal as high or low. This new signal would then become our new slower clock.

The math to calculate the number of clk counts for certain frequencies is pretty straight forward:

   counter = (input_clock / new_clock) / 2

thus, if we want to create a 5MHz clock from 50MHz, our counter would use 5 input clock cycles:

   counter = (50MHz / 5MHz) / 2 = (10) / 2 = 5

In figure 1, we simulated our clock divider using Xilinx ISim to show the behavior of the input clock (clk), the counter (count) and the new clock (clk2). Notice that at every 5 clk cycles, clk2 toggles. The yellow tab shows that the count vector is at 5 (3'b101) and is followed by a clk2 transition.

Fig. 1. Behavioral simulation of 50MHz to 5MHz clock divider.

Code sample:

module clock_divider(
   input           clk,     // 50MHz clock input. reloj de 50MHz
   output reg      clk2,     // new 5MHz clock  
    );

reg [2:0] count;

// clock divider 50MHz to 5MHz
always@(posedge clk)
    begin
        if(count==3'd4)      // counts 5 clk cycles (0 thru 4)
            begin            
              count<=0;        
              clk2 <= ~clk2;   // toggles clk2 to hi or lo
            end
        else
            begin
              count<=count+1; 
            end              
    end     

Finite State-Machine in Verilog - LED changing automatically

This is a code sample for a finite state-machine using Verilog and was tested using the Mojo FPGA board.

The code turns on one of the 8 LED in the Mojo board at a time. The LED transitions automatically at 1Hz.


Code Sample:

module LED_state_machine2(

    input   clk,         // 50MHz clock input   
    input   rst_n,       // input from reset button   
    input   cclk,        // clock input from AVR microcontroller
    output  reg[7:0]led, // output 8 onboard LEDs  
    
   // all connection below are for the microcontroller in Mojo

    output  spi_miso,          // SPI connections for AVR
    input   spi_ss,
    input   spi_mosi,
    input   spi_sck,
    output  [3:0] spi_channel, // AVR ADC channel select   
    input   avr_tx,            // AVR Tx => FPGA Rx
    output  avr_rx,            // AVR Rx => FPGA Tx
    input   avr_rx_busy        // AVR Rx buffer full
    );

// for Mojo only. these signals should be high-z when not used.

assign  spi_miso = 1'bz;
assign  avr_rx = 1'bz;
assign  spi_channel = 4'bzzzz;

wire    rst = ~rst_n; // make reset active high 
reg  [25:0] count;
reg         clk2;
reg   [2:0] state=0;


// clock divider 50MHz to 1Hz
always@(posedge clk)
    begin
        if(count==26'd25_000_000)    // counts 25M clk cycles and
            begin                    // toggles clk2 hi or lo
             count<=0;                
             clk2 <= ~clk2;          
            end
        else
            begin
             count<=count+1;
            end
    end    

// beginning of state-machine
always@(posedge clk2)  // state-machine change at clk2 transition
begin 
  if(rst)              // go to state 0 if rst is pressed
    state <= 3'd0;    
  else                 // otherwise start state-machine sequence
   begin             
    case(state)
     3'd0: begin
            led[7:0]<=8'b0000_0001;  // only led[0] is hi
            state <= 3'd1;           // jump to state 3'd1
           end
     3'd1: begin
            led[7:0]<=8'b0000_0010;  
            state <= 3'd2;           
           end            
     3'd2: begin
            led[7:0]<=8'b0000_0100;
            state <= 3'd3;
           end
     3'd3: begin
            led[7:0]<=8'b0000_1000;
            state <= 3'd4;
           end
     3'd4: begin
            led[7:0]<=8'b0001_0000;
            state <= 3'd5;
           end
     3'd5: begin
            led[7:0]<=8'b0010_0000;
            state <= 3'd6;
           end
     3'd6: begin
            led[7:0]<=8'b0100_0000;
            state <= 3'd7;
           end
     3'd7: begin
            led[7:0]<=8'b1000_0000; // back to state 0
            state <= 3'd0;          // volver a estado 0
           end
     default: state <= 3'b0; 
    endcase
   end
  end

endmodule