Las señales PWM nos permite tener salidas analógicos a partir de pines digitales, y se usan en aplicaciones como el control de motores de corriente continúa o modulación de la intesidad de brillo de los LEDs, entre otras cosas. En este cuaderno técnico aprenderemos cómo hacer nuestros propias unidades de PWM y cómo usarlas en nuestras aplicaciones

• 2019-Enero-02: Version inicial del cuaderno técnico
• 2023-Junio-23: Añadida versión PDF, maquetada por Carlos Venegas (@cavearr)
• 2024-Abril-03: Ejemplos adaptados a la nueva toolchain: apio-0.9.3. Eliminado el error en la verificación. Probados con icestudio 0.11.3wip

• Descarga la versión en PDF: C1-PWM-FPGA-PLIEGOS-V2-opt-1.pdf. ¡Muchísimas gracias a Carlos Venegas (@cavearr)! 😀️

Colection-Jedi-v1.1.0.zip: Colección para este cuaderno técnico. Descargar e instalar

• Todos los ejemplos de este cuaderno técnico están en este repositorio: Ejemplos CT1: Unidad de PWM de frecuencia aproximada. También encontrarás una selección de ellos en el menú Archivo/Ejemplos/PWM de Icestudio, una vez instalada y seleccionada la colección Jedi

• Introducción
  • Parámetros del PWM
• Frecuencia
  • Experimento 1: Parpadeo de un led a 10Hz
  • Experimento 2: Encontrar la frecuencia a la que no hay parpadeo
  • Criterio de selección de frecuencia
• Contadores: Divisores de frecuencia
  • Experimento 3: Midiendo un contador del sistema de 3 bits
  • Tabla de frecuencias
  • Resumen criterio de selección de frecuencias
• Estructura de la unidad PWM
  • Parámetro anchura del pulso
• Aplicación: control del brillo de un LED
  • Ejemplo 4: Cuatro niveles de brillo en el LED
  • Ejemplo 5: 4+1 niveles de brillo en el LED
  • Ejemplo 6: 4+1 niveles de brillo con prescalado de 15 bits
  • Ejemplo 7: 16 niveles de brillo sin prescalado
• Bloque de PWM
  • Funcionamiento interno, por bloques
  • Código verilog
• Ejemplos de uso del bloque PWM
  • Ejemplo 1: Cuatro niveles de brillo en LED, con pulsador
  • Ejemplo 2: 16 niveles de brillo en LED, con prescalado
  • Ejemplo 3: 256 niveles de Brillo en LEDs, con potenciómetro
  • Ejemplo 4: Servidor hardware de 256 niveles de brillo en los LEDs
    • Cliente 1: Script Communicator
    • Cliente 2: Python script
    • Cliente 3: Python-notebook-jupyter
• Autor
• Licencia
• Enlaces

En los sistemas digitales sólo tenemos dos niveles de tensión: 0 y 1. Si lo aplicamos a un LED, en principio sólo podríamos hacer que el LED esté apagado (0) o luciendo a su máxima intensidad (1)

La Modulación por anchura de pulsos (PWM) nos permite generar salidas analógicas facilmente en sistemas digitales. Por ejemplo, para mover un motor de corriente contínua a diferentes velocidades o modificar el brillo de un LED

En este cuaderno técnico veremos cómo implementar un PWM sencillo, de frecuencia aproximada. Nos servirá para generar una salida analógica en sistemas donde la frecuencia no es un parámetro crítico. Existen otros sistemas donde la frecuencia tiene que tener un valor exacto, como el control de un servo. Eso lo veremos en otro cuaderno

Las señales PWM son periódicas, y tienen dos parámetros: la frecuencia y la anchura del pulso

El periodo lo denotamos por T (el inverso de la frecuencia) y la anchura del pulso por W. La frecuencia (periodo) es un parámetro fijo: siempre es el mismo durante toda el funcionamiento del circuito, mientras que la anchura es variable: en cada ciclo puede tener un valor diferente

En esta figura vemos tres ciclos. Todos con el mismo periodo T, pero la anchura cambia en cada uno de ellos: W1, W2, W3...

Según la aplicación, necesitamos seleccionar la frecuencia del PWM. Así, por ejemplo, para cambiar la intesidad de brillo de un LED basta con usar cualquier frecuencia mayor de 30Hz aproximadamente. A partir de ahí el ojo no nota el parpadeo. Si usamos 10Hz, notaremos cómo el LED parpadea. Pero si usamos 60Hz NO. La frontera depende del ojo de cada uno, y del tipo de LED. Haremos algunos experimentos para entender esto mejor y practicar

Cargar este circuito en la placa Alhambra: Ej-01-LED-10Hz.ice

El escenario está compuesto sólo por la placa Alhambra conectada al PC. Nada más

Veremos cómo el LED7 parpadea, de una forma perfectamente apreciable

Partimos el ejemplo anterior, y aumentamos la frecuencia hasta que NO apreciemos el parpadeo. Probar con 20Hz, 25Hz, 30Hz, 40Hz... En mi caso, al llegar a 40Hz soy incapaz de apreciarlo (Bueno, en realidad a partir de 35Hz me es casi imposible apreciarlo)

Sólo queda un cabo suelto. Asegurarnos que efectivamente la frecuencia de parpadeo del LED es la que le estamos indicando. Os lo podéis creer, o lo podéis medir. Para ello sólo hay que sacar la señal del parpadeo hacia el exterior (por el pin D0 por ejemplo) y usar el analizador compatible Saleae para medir

Este es el circuito que estoy usando:

Y este es el nuevo escenario, con el analizador conectado al canal 1 para realizar la medición

Tomamos las medidas con el PulseView. Este es el resultado obtenido:

Comprobamos que efectivamente la señal que llega al LED es de 40Hz

A esta frecuencia mínima, a partir de la cual ya no se aprecia parpadeo la denominaremos Fmin. El criterio para elegir la frecuencia de la señal PWM aplicada a un LED será:

• La frecuencia F del PWM para modificar la intensidad de un LED sin apreciar parpadeo debe cumplir que F > Fmin

En nuestro caso Fmin = 40Hz, así que cualquier frecuencia superior a 40Hz nos servirá

Los sistemas digitales están gobernados por un reloj, que llamamos el reloj del sistema, que tiene una frecuencia S. En las placas Alhambra esta frecuencia es de 12Mhz. La forma más sencilla de obtener señales de menor frecuencia es usando contadores del sistema de N bits: son aquellos que se incrementan en una unidad con cada flanco de subida del reloj del sistema. Por el bit menos significativo del contador, c0, se obtiene una señal de frecuencia S/2, por c1 de S/4, por c2 de S/8, etc.

Así, si tenemos un contador del sistema de 3 bits, las frecuencias que obtendremos serán S/2, S/4 y S/8. Como S es de 12MHz, las frecuencias serán de 6Mhz, 3Mhz y 1.5Mhz

Comprobaremos lo dicho anteriormente experimentalmente: Colocamos un contador del sistema de 3 bits con sus salidas conectadas al analizador lógico

En el montaje colocamos el analizador, con cuatro canales conectados

Y realizamos la medición. comprobamos empíricamente que las señales del contador efetivamente son divisores de la señal de reloj del sistema. En F_C2 podemos ver las medidas de la señal C2, que coincide con la frecuencia S/8, de 1.5Mhz

En esta tabla se muestran todas las frecuencias que se pueden conseguir usando un contador de N bits conectado a un reloj del sistema de 12MHz

Hay dos valores fronteras. Para contadores con 9 ó menos bits se obtiene frecuencias mayores a 20KHz, que es el máximo audible por el oído humano. Cuando se controlan sistemas mecánicos, si se usan para el PWM frecuencias menores de 20Khz se podrían oir pitidos o zumbidos

Para contadores con 18 o menos bits, se tienen frecuencias mayores a 46Hz, por lo que si se aplican para el control del brillo de LEDs NO se apreciará el parpadeo

La tabla se genera fácilmente (en HZ) con este programa en python: frec_list.py

# Definir la unidad MHZ
MHZ = 1_000_000

# Reloj del sistema
S = 12 * MHZ

#-- Imprimir la lista de frecuencias
for i in range(24):
    F = round(S / (2 ** i))
    print(i,F)

La regla es muy sencilla:

• Señales PWM para control de motores: Frecuencias superiores a 20KHz. Usar contadores de 9 ó menos bits
• Señales PWM para control del brillo de LEDs: Frecuencias superiores a 40Hz. Usar contadores de 18 o menos bits

La estructura básica de la unidad PWM consta de 3 elementos:

• Contador de N bits, donde N determina la frecuencia, y se elige en función de la tabla mostrada en apartado anterior
• Registro de anchura, de W bits: Contiene el valor de la anchura del pulso
• Comparador de W bits: Compara el registro de anchura con el contador principal, para determinar si la señal de salida debe estar a 1 ó 0

La comparación se realiza entre el registro de anchura y los W bits más significativos del contador principal. Si representamos un único ciclo de PWM, observamos estas dos zonas: una donde el contador es menor al registro de anchura, y por tanto la salida está a 1, y otra donde el contador es mayor, cuya salida debe ser 0

En esta figura se representan dos ciclos del PWM, con anchuras de pulsos distintas: W1 y W2. El contador está constantemente incrementándose, desde 0 (comienzo del ciclo) hasta su máximo valor (T). En el primer ciclo, cuando el contador es menor que W1, la señal está a 1. En El segundo ciclo es igual pero con otro valor: W2. Esto hace que el periodo sea el mismo para ambos ciclos (T), pero que las anchuras sean diferentes

El parámetro W es el número de bits del registro de anchura. Este valor lo establecemos según los niveles que queramos para el PWM. Así por ejemplo, para el control de brillo de un LED podríamos establecer 256 niveles, o sólo 4. Es un valor que depende de la aplicación y lo determina el diseñador. Cuantos más niveles usemos, mayor será la resolución

Así, el contador principal está dividido en dos partes: la de mayor peso de W bits que determina el número de niveles, y la de menor peso, de N-W bits, que hace un preescalado. Nos permite tener el PWM con los mismos niveles pero a una frecuencia menor. En la mayoría de las veces tendremos que N = W, por lo que no se usa la parte de preescalado

En general, en las aplicaciones de FPGA cuanto mayores sean las frecuencias, menos recursos se gastarán. Así que, si no hay otras restricciones, intentaremos siempre usar la máxima frecuencia, y que N = W (sin prescalado)

Como ejemplo de diseño de nuestra unidad de PWM, realizaremos una para controlar el brillo de un LED. Sabemos que la frecuencia deberá ser mayor de 40Hz para eliminar el parpadeo

Empezaremos por el ejemplo más básico: implementar 4 niveles de brillo en el LED. Como queremos 4 niveles, tenemos que W = 2. Y como no hay restricciones adicionales, haremos que N = W = 2. Por tanto, según la tabla de frecuencias, tendremos una señal de PWM de 4 niveles a la máxima frecuencia: 3 MHZ

El circuito consta del contador del sistema de 2 bits. Se incrementa en una unidad por cada ciclo de reloj del sistema (12MHZ). Para establecer el valor de la anchura utilizaremos otro contador de 2 bits, que se modificaremos con un pulsador externo. Cada vez que apretemos el pulsador incrementaremos el brillo del LED en un nivel. La señal de PWM se obtiene a la salida del comparador de 2 bits. Por un lado lo sacamos al LED7, que es el que queremos controlar su brillo. Por otro lado lo llevamos al pin D0 para medir la señal con el analizador lógico

En el montaje tenemos el pulsador exerno y el analizador lógico, con el canal 1 conectado

Lo cargamos y lo probamos. Al apretar el pulsador cambiamos la luminosidad del LED. En este vídeo se muestra en funcionamiento

En este pantallazo se muestran las medidas tomadas. Se han tomado de forma individual: una medida para cada nivel y se ha agrupado en una única igura. La medida del nivel 0 no se ha tomado, ya que la señal está siempre a 0. La captura de la señal está a al derecha de la linea vertical azul. Comprobamos cómo el ancho es 0, 25%, 50% y 75%, para los niveles 0, 1, 2 y 3. También comprobamos que la frecuencia es fija: 3MHz

En el ejemplo anterior, el caso del brillo máximo, el 100%, NO está contemplado. Si lo queremos incluir, tenemos que añadir ese caso por separado. Es el caso en el la señal de pwm está siempre a 1. Hay que usar un contador módulo 5, y usar el bit de mayor peso para conmutar un multiplexor entre la señal PWM y la señal constante 1. Este es el circuito:

Lo cargamos y lo probamos. Ahora hay 4 niveles donde el LED está iluminado (25%, 50%, 75%, 100%) y uno en el que está apagado

En el ejemplo 5, la frecuencia del PWM es de 3 MHz. ¿Cómo podemos modificarlo para que funcione a otra frecuencia? Elegimos de la tabla de frecuencia la nueva frecuencia. Por ejemplo 92Hz. Tenemos que ampliar el contador principal para que ahora tenga 17 bits: los dos bits más significativos son para determinar el nivel de brillo, y los 15 restantes para el prescalado. El circuito es el siguiente:

El escenario es el mismo, pero ahora usando un LED externo. Lo cargamos y lo probamos

Al realizar la medición, comprobamos que la frecuencia es de 91.53Hz (En la tabla de frecuencias es 92Hz, porque se ha redondeado al hz). El circuito hace lo mismo que en el ejemplo anterior, pero a una frecuencia menor

Para aumentar el número de niveles, basta con usar un contador principal de mayor número de bits. Así, para tener 16 niveles de brillo, usamos un contador de 4 bits. No usaremos bits adicionales de prescalado, por lo que la frecuencia de este PWM será de 750Khz, según la tabla de frecuencias

Usamos dos pulsadores, uno para incrementar el brillo y otro para disminuirlo. Se usa un contador con incremento/decremento, que NO permite rebasar los límites: cuando se llega al valor máximo (15) no se puede seguir incrementándolo. Y al llegar al valor mínimo (0) no se puede decrementar más

El escenario es el siguiente:

Y este es el circuito

Lo cargamos y lo probamos. Con el pulsador izquierdo incrementamos el nivel en una unidad, y con el derecho lo decrementamos. En el vídeo no se aprecian bien los 16 niveles, pero en real sí se ve la diferencia, especialmente en los niveles bajos. El nivel actual se muestra en binario en los LEDs de menor peso

En este pantallazo se muestran las medidas tomadas para los niveles 4 (25%), 10 (62.5%) y 15 (93.75%). Se han tomado por separado y se han unido en la figura. Se comprueba que la frecuencia es de 750Khz en todos los casos

Las unidades de PWM se encuentra en la colección Jedi, en el menú Varios/PWM. Como parámetro se especifica el número bits de prescalado, que por defecto es de 0 (sin prescalado, máxima frecuencia)

Este bloque funciona como un registro: Se le introduce el valor de la anchura del pulso en el bus de entrada y se emite un tic de escritura en write para que lo capture. Por la salida se obtiene la señal PWM. Existen diferntes unidades de pwm según el número de niveles. El que se muestra en la figura es de 8bits: 256 niveles

La frecuencia de funcionamiento es la máxima por defecto. Para calcular la frecuencia que tiene basta con sumar los bits de prescalado y los bits de la anchura, y acudir a la tabla de frecuencias. Cambiando los bits de prescalado podemos bajar la frecuencia

Como ejemplo de funcionamiento veremos cómo está hecho el bloque pwm de 8 bits y frecuencia de 92Hz. Este bloque, compuesto por otros bloques, se encuentra en el menú Varios/PWM/08-bits/blocks/pwm-92Hz

Veremos su funcionamiento detenidamente. Como es una unidad de 92Hz, necesitamos un contador principal de 17 bits. El esquema es como el general que ya conocemos: el contador principal, el registro de anchura w, de 8 bits y el comparador de 8 bits. Los 8 bits más significativos del contador los extraemos (usando el bloque extractor) y los comparamos con los 8 bits del registro w:

El valor de la anchura se debe introducir en el registro w, sin embargo, NO se puede hacer en cualquier momento. Si queremos tener una señal PWM correcta, en la que la frecuencia se mantiene fija, el registro w sólo se puede actualizar al comienzo de cada ciclo pwm. Si el usuario puede escribir en cualquier momento la nueva anchura, aparecerán pulsos indeseados

Este efecto se muestra en la siguiente figura. Partimos de una anchura W1 que es estable (ciclo 1). Queremos escribir uan nueva anchura, w2, como la que aparece en el ciclo 3, que es estable. La transición se realiza en mitad del ciclo 2. Como el valor que estaba escrito era el w1, el ciclo comienza igual que el ciclo anterio: con un pulso de anchura w1

Sin embargo, al escribirse el nuevo valor w2, se cumple que el contador en ese instante es menor que w2, por lo que la señal de pwm se pone a 1: aparece un segundo pulso NO deseado. La frecuencia en el ciclo 2 ha cambiado. En el ciclo 3 la situación vuelve a la normalidad

La manera de solucionarlo es haciendo que el registro w sólo se pueda actualizar al comienzo de cada ciclo. La señal load del registro w la controla nuestra unidad pwm, y no el usuario:

Para detectar cuando empieza un ciclo nuevo, extraemos el bit de mayor peso del contador (bit 16) y emitimos un tic en el flanco de bajada: al pasar de 1 a 0. Eso sólo ocurre cuando ha transcurrido un periodo completo. Ese tic es el que usamos para capturar el nuevo valor del registro w. Y así garantizamos que no aparezcan pulsos no deseados

¿Y cómo hacemos ahora para que el usuario pueda escribir valores en el registo w? Usamos un registro buffer. Es un registro temporal en el que el usuario escribe el valor de la anchura cuando quiera. Este valor del buffer se transfiere al registro w en el comienzo de cada ciclo

Para terminar nuestra unidad, sólo necesitamos registrar la salida del pwm, usando un biestable del sistema, para cumplir con las normas del diseño síncrono. Al colocar un registro, eliminamos los glitches que pudiesen aparecen en la señal, antes de sacarla por el pin:

Las unidades PWM que está fuera del directorio blocks están implementadas en Verilog, e incluyen el parámetro del prescalado. En los bloques de icestudio la entrada de la anchura es fija, pero en Verilog es genérica. El diseño es el mismo mostrado en el apartado anterior, pero descrito en verilog:

//-- Parámetro P: Número de bits del prescaler
//-- (P = 0 para no usar prescaler)

//-- Bits para el nivel
localparam N = 8;

//-- Contador principal
//-- Tamaño: Bits anchura + Prescaler (P)
localparam C = N + P;

reg [C-1:0] counter = 0;
always @(posedge clk)
  counter <= counter + 1;

//-- Detectar el comienzo de un ciclo nuevo:
//-- cuando hay un flanco de bajada en el bit de  
//-- mayor peso (C-1)

reg q = 0;
always @(posedge clk)
  q <= counter[C-1];
 
//-- Cuando cycle_begin es 1, indica que comienza
//-- un nuevo ciclo
wire cycle_begin = q & ~counter[C-1];
  
//-- Registro W: Almacena la anchura actual
reg [N-1:0] reg_w = 0;

always @(posedge clk)
  //-- Se carga en cada nuevo ciclo de pwm
  if (cycle_begin)
    reg_w <= reg_buf;

//-- Registro buffer. Es donde se almacena la anchura
//-- introducida por el usuario mientras llega un  
//-- nuevo ciclo de pwm, y se pueda cargar en el  
//-- registro w
reg [N-1:0] reg_buf = 0;

always @(posedge clk)
  //-- Se actualiza cuando llega un dato nuevo
  if (write)
    reg_buf <= w;

//-- Salida del pwm: comparador
wire pwm_t = (counter[C-1:C-N] < w);

reg pwm = 0;
//-- Registrar la salida del pwm
always @(posedge clk)
  pwm <= pwm_t;

Ya hemos usado el PWM en varios ejemplo, pero aquí haremos ejemplos usando el bloque PWM. Todos estos ejemplos se encuentran en la colección Jedi

Señal PWM de 4 niveles: 0, 25%, 50% y 75% y frecuencia de 3 MHz para controlar el brillo de un LED con el pulsador. El nivel de brillo actual se muestra en los LEDs 1 y 2 (2 bits). El LED controlado es el LED 7

• Fichero: 01-Brillo-LED-pulsador-2bits.ice

• Elementos: Pulsador externo y analizador lógico para las mediciones

• Medición del nivel 1 (PWM 25%): 100 muestras. Frecuencia muestreo: 24MHz

• Medición de los 4 niveles: Se han tomado por separado y juntado en esta figura

• Resultados: Se comprueba que la frecuencia del PWM es de 3 MHz y que los niveles son el 0%, 25%, 50% y 75%

Señal PWM de 16 niveles: 0, 6.2% ... 93.75% y frecuencia de 91.5 Hz (Prescalado de 13 bits) para controlar el brillo de un LED con dos pulsadores, uno para incrementar el brillo y otro para disminuirlo. El nivel de brillo actual se muestra en los LEDs 3-0 (4 bits). El LED controlado es el LED 7

• Fichero: 02-Brillo-LED-pulsadores-4bits.ice

• Elementos: Dos pulsadores externos y el analizador lógico para medir

• Medición nivel 1: (PWM 6.25%): 2M muestras. Frecuencia muestreo: 24MHz

• Medición niveles 4, 10 y 15: Se han tomado por separado y juntado en esta figura

• Resultados: Se comprueba que la frecuencia del PWM es de 92.5 Hz y que los niveles medidos efectivamente representan el 6.25%, 25%, 62.5% y 93.75%

Señal PWM de 256 niveles: 0, 0.39%, ..., %99.8 y frecuencia de 46.87 KHz (No hay prescalado) para controlar el brillo de los 8 LEDs con un potenciómetro. Al girar el potenciómetro a un extremo todos LEDs se apagarán. En el extremo contrario los LEDs brillarán a su máxima intensidad. Variando el potenciómetro ajustamos la intensidad de todos los LEDs. El potenciómetro se lee a una frecuencia de 20Hz

• Fichero: 03-Brillo-LEDs-pot-8bits.ice

• Elementos: Potenciómetro y analizador lógico para hacer las medicicones

• Medición nivel 1: (PWM 0.39%): 5K muestras. Frecuencia muestreo: 24MHz

• Medición de tres anchuras: Se han medido por separado y juntado en esta figura

• Resultados: Se comprueba que la frecuencia del PWM es de 46.87 Khz y que los niveles medidos efectivamente van desde el 0.39% hasta el 99.85

Misma señal PWM del ejemplo anterior: Señal PWM de 256 niveles: 0, 0.39%, ..., %99.8 y frecuencia de 46.87 KHz (No hay prescalado) para controlar el brillo de los 8 LEDs. El nivel de brillo (0-255) se envía desde el PC a través del puerto serie. El circuito, por tanto, es un Servidor Hardware que ofrece el servicio de establecimiento del brillo de los LEDs. Lo probaremos desde 3 clientes diferentes: El script Communicator, un programa en python, y un Cuaderno interactivo de Jupyter

• Fichero: 04-Brillo-LEDs-serial-8bits.ice

Desde el script Communicator podemos enviar directamente los niveles (0-255) a los que queremos que estén los LEDs. Hay que configurar el envío para que sea de tipo uint8. Se introduce el valor decimal en el recuadro inferior y se aprieta el botón de send

En este vídeo lo vemos en acción

Este es un ejemplo de cliente escrito en python, que recorre todas las instensidades, primero desde 0 a 255 y luego al revés, haciendo que los LEDs lleguen a su máximo brillo y luego lo bajen hasta que se apaguen. El patrón se repite varios haciendo

• Programa ejemplo: pulse-LEDs.py

import time
import serial

#-- Poner el nombre del puerto serie aquí
#-- En windows será COMx
SERIAL_PORT = "/dev/ttyUSB2"

#-- Periodo del pulso en segundos (apagado - maximo - apagado)
T = 0.5

#-- Numero de repeticiones
REPETICIONES = 10

#-- Abrir el puerto serie
with serial.Serial(SERIAL_PORT, 115200) as sp:

    #-- Imprimir la información del pueto serie
    print("Puerto serie: {}".format(sp.portstr))

    #-- Relizar dos iteraciones
    for i in range(REPETICIONES):
        #-- Aumentar brillo de 0 a 255
        for brillo in range(255):
            sp.write(bytes([brillo]))
            time.sleep(T/256)

        #-- Disminuir el brillo
        for brillo in reversed(range(255)):
            sp.write(bytes([brillo]))
            time.sleep(T/256)

        #-- Tiempo de espera hasta el siguiente pulso
        time.sleep(1)

Y en este vídeo lo vemos en acción. El programa se interrumpe pulsando control-c (o bien esperando a que se terminen todos los ciclos)

En el tercer cliente usaremos una barra deslizante en un cuaderno de Jupyter, en Python, para establecer el brillo de los LEDs

• brillo-fpga.ipynb

En este vídeo se muestra en acción

• Juan González-Gómez (Obijuan)

• Tutoriales: Electrónica digital para makers con FPGAs Libres
• VideoBlog 26: Probando el analizador lógico compatible Salee, con la FPGA
• Tutoriales Verilog: Diseño Digital para FPGAs, con herramientas libres