CT.7: Display SPI de 4 dígitos de 7 segmentos
Manejo del display de 4 dígitos de 7 segmentos de Sparkfun, que se conecta por el SPI. Se pone en marcha usando el puerto serie primero, y luego se desarrollan controladores propios para manejarlo desde nuestros circuitos de aplicación
- 2019-Julio-20: Version inicial del cuaderno técnico
- 2024-Abril-11: Ejemplos adaptados a la nueva toolchain: apio-0.9.3. Eliminado el error en la verificación. Probados con icestudio 0.11.3wip (futura versión 0.12). Los pantallazos de los ejemplos no se han actualizado todavía
- Fecha: 2019/Julio/22
Haz click en la imagen para ver el vídeo en Youtube
Haz click en la imagen para ver el vídeo en Youtube
- Colection-Jedi-v1.8.0.zip: Colección para este cuaderno técnico. Descargar e instalar esta versión o superior (>= 1.8.0)
Todos los ejemplos de este cuaderno técnico están en este repositorio. También encontrarás una selección de ellos en el menú Archivo/Ejemplos/Displays/COM-1129-SparkFun/SPI/ de Icestudio, una vez instalada y seleccionada la colección Jedi
- Introducción
- Funcionamiento
- Puesta en marcha
- Control desde la FPGA
- Diseñando nuestros controladores
- Conclusiones
- Descargas
- Autor
- Licencia
- Créditos y agradecimientos
- Enlaces
El display COM-1129 de SparkFun permite representar números de 4 dígitos mediante cuatro displays de 7 segmentos que se controlan a través del bus SPI (también por I2C y serie asíncrono)
El mío lo he comprado en Bricogeek. Es un componente ideal para aprender a hacer controladores maestros SPI, por su sencillez de uso. Además es Hardware libre. Sus esquemas están diponibles en el repositorio de github
La documentación es muy buena, está disponible en esta wiki de su repo github (en Inglés). El acceso por SPI usa el modo 0 y una frecuencia máxima de reloj (SCLK) de 250Khz (SPI communication)
El funcionamiento del display es muy sencillo. Cuando se le envía un número, justo después del arranque, lo muestra en el dígito de la posición 0, que es el que está más a la izquierda. Al recibir otro número lo muestra en la posición 1, que es el dígito que está a su derecha
Y así sucesivamente. La posición activa es donde se mostrará el siguiente carácter. Recibe el nombre de Cursor. Cuando se envía el carácter de la posición 3 (el de más a la derecha) el cursor se actualiza para apuntar de nuevo a la posición 0, de forma que el siguiente carácter recibido aparecerá en ella
En esta animación se muestra el funcionamiento. Después del arranque el cursor está en la posición 0 (el cursor es invisible). Se le envían consecutivamente los dígitos 0-1-2-3-4-5-6 y 7. Al recibir el 3 el cursor salta a la posición 0, que es donde se sitúa el dígito 4
Cada display muestra dígitos decimales o hexadecimales. El valor se envía bien en binario (0-15) o bien como caracteres ascii: '0'-'9', 'a'-'f'. También se permiten caracteres alfanuméricos, lo que nos permite sacar mensajes simples de 4 caracteres
Además del envío de caracteres y números, el display admite commandos especiales que incluyen un parámetro adicional, salvo CLS que es un comando de un byte. Para ejecutarlos hay que activar SS, enviar los dos bytes y desactivar SS
| Comando | Código | Parámetro | Descripción |
|---|---|---|---|
| CLS | 0x76 | Ninguno | Borrar el display y colocar el cursos en el display de la izquierda (posición 0) |
| POINT | 0x77 | 0-63 | Activar los puntos. El parámetro usa 6 bits. Cada uno se corresponde con un punto |
| LOCATE | 0x79 | 0-3 | Colocar el cursor en la posición indicada. 0 es el dígito de más a la izquierda y 3 el de más a la derecha |
| BRIGHT | 0x7A | 0 - 255 | Nivel de brillo |
| CONTROL-0 | 0x7B | 0-127 | Activar los segmentos indicados del dígito 0 (Más de la izquierda). El parámetro usa 7 bits, uno por segmento |
| CONTROL-1 | 0x7C | 0-127 | Idem para el dígito 1 |
| CONTROL-2 | 0x7D | 0-127 | Idem para el dígito 2 |
| CONTROL-3 | 0x7E | 0-127 | Idem para el dígito 3 |
El comando CLS apaga todos los segmentos y puntos de los displays y sitúa el cursor en la posición 0. El código de comando es el 0x76, que se corresponde con el caracter 'v'. No hay que añadir ningún parámetro adicional
El comando LOCATE sitúa el cursor en la posición pasa como argumento. Este argumento debe estar en el rango 0-3. El siguiente carácter/número enviado se escribirá en esta nueva posición
El comando bright permite cambiar el nivel de luminosidad del display. Se le pasa como argumento el nivel de brillo, entre 0 y 255. Un nivel de 0 NO es apagado, sino que significa brillo mínimo (que es visible). Para tener el brillo máximo enviamos 0x7A y 0xFF
El display incluye 6 elementos de puntuación: 4 puntos en la parte inferior, uno en la parte superior del dígito 3 y un punto doble entre los dígitos 2 y 3. Se utilizan 6 bits para su visualización, un bit para cada uno de los elementos
El estado de estos elementos se asigna con el comando POINT (0x77) seguido de un argumento que indica qué bits están encendidos (1) y cuáles no (0). En este ejemplo se encienden los dos puntos centrales, enviando los bytes 0x77 0x10
Este comando permite activar los segmentos de cada dígito, de manera independiente. Cada segmentos está controlado por un bit del parámetro usado al invocar el comando de control
Existen un total de 4 comandos de control, uno para cada dígito. Los códigos son 0x7B, 0x7C, 0x7D Y 0x7E. En este ejemplo se encienden los segmentos 0 y 3 de los dígitos inicial y final respectivamente
Este display SPI sólo permite el envío de datos desde el maestro, pero no su lectura. Por ello sólo se usan 3 cables para el SPI: SCK, MOSI y SS. Además hay que conectar alimentarlo con VCC (+5v) y GND. En la Alhambra II usamos los mismos pines que Arduino
Este es el escenario real que usaremos en los ejemplos:
Para poner en marcha el display y comprobar que el conexionado y todo funciona correctamente, usaremos la pasarela Serie-spi, que además nos permitirá probar los diferentes comandos. En la segunda parte implementaremos controladores específicos
El display SPI funciona a una frecuencia máxima de reloj de 250Khz. Los componentes que tenemos hechos para el SPI funcionan a 2Mhz, por ello necesitamos añadir un divisor de frecuencia para bajar de 2Mhz a 250Khz (División entre 8). Se ha añadido como parámetro a los bloques SPI que ya teníamos
Si no damos ningún valor parámetro DIV por defecto se toma 1, y la señal del relog será de 2Mhz. En esta tabla se muestran los valores para el divisor, y la frecuencia del reloj SPI que se consigue. En todos los ejemplos usaremos DIV=8 (250Khz)
| Valor del divisor (DIV) | Frecuencia reloj SPI (SCLK) |
|---|---|
| 1 | 2Mhz |
| 2 | 1Mhz |
| 4 | 500Khz |
| 8 | 250Khz |
| 16 | 125Khz |
| 32 | 62.5Khz |
En la FPGA cargamos el circuito pasarela serie-SPI, usando un divisor de 8 para cumplir con las especificaciones del fabricante del display (250Khz). No conectamos el MISO ya que no leeremos nada del display. Tampoco conectamos el pin TX de la pasarela porque no hay que enviar ningún dato de vuelta al PC
Desde el script communicator enviamos caracteres y números. Se verán en el display
En este vídeo se muestra el funcionamiento. Desde el terminal serie se teclean los dígitos 01234567 (ASCII) y también se envían los números directamente en binario
Una vez que nos funciona desde la consola serie, vamos a probar el resto de comandos desde programas en python que se ejecuten en el ordenador
Comenzamos con un ejemplo que usa las funciones display_cls() y display() para borrar el display y mostrar una cadena o una lista de números en el display. Este es el código de las funciones en python
import time
import serial
#-- Comandos del LCD
CMD_CLS = 0x76
#-- Poner el nombre del puerto serie aquí
#-- En windows será COMx
SERIAL_PORT = "/dev/ttyUSB1"
#-- Borrar lo que haya en el Display
def display_cls(sp):
sp.write(bytes([CMD_CLS]))
#-- Esperar a que la señal ss se ponga a 1
time.sleep(0.0002)
#-- Sacar por el display una cadena o una lista de digitos
def display(sp, cad):
for dig in cad:
try:
#-- Es una lista
sp.write(bytes([dig]))
#-- Es una cadena
except TypeError:
sp.write(bytes([ord(dig)]))
#-- Esperar a que la señal ss se ponga a 1
time.sleep(0.0002)Desde el programa principal sacamos la lista de dígitos 0,1,2,3 y transcurridos dos segundos el mensaje "HOLA"
#----- Programa principal
#-- 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))
#-- Enviar mensaje al display
msg = [0, 1, 2, 3]
display_cls(sp)
display(sp, msg)
print("Enviado: {}".format(msg))
#-- Esperar unos segundos
time.sleep(2)
#-- Enviar una cadena
cad = "HOLA"
display(sp, cad)
print("Enviado: {}".format(cad))En este vídeo lo vemos en funcionamiento
Para probar el resto de comandos ampliamos las funciones. Utilizamos la función genérica display_cmd() que envía un comando y su valor, y a partir de ella implementamos las demás, cada una usando su própio código de comando:
#-- Comandos del LCD
CMD_CLS = 0x76
CMD_BRIGHT = 0x7A
CMD_LOCATE = 0x79
CMD_POINT = 0x77
CMD_CONTROL = 0x7B
#--Enviar un comando con un argumento
def display_cmd(sp, cod, val):
#-- Construir el comando
cmd = [cod, val]
#-- Enviar el comando
sp.write(bytes(cmd))
#-- Esperar a que la señal ss se ponga a 1
sp.flush()
time.sleep(0.001)
#-- Establecer la intensidad del display
def display_bright(sp, level):
display_cmd(sp, CMD_BRIGHT, level)
#-- Visualizacion de los puntos
def display_point(sp, state):
display_cmd(sp, CMD_POINT, state)
#-- Acceso a segmentos individuales
def display_control(sp, pos, state):
display_cmd(sp, CMD_CONTROL + pos, state)
#-- Posicionar el cursor
def display_locate(sp, pos):
display_cmd(sp, CMD_LOCATE, pos)Hacemos unas funciones de test que prueben el brillo, la posición del cursos, los puntos y el acceso a los segmentos individuales. El programa completo está disponible en el repositorio: 01-2-test-cmds.py
Y en este vídeo se muestra la prueba en acción. ¡El display ya no tiene secretos!
Vamos a hacer ejemplos de circuitos para utilizar el display spi directamente desde la FPGA, sin usar un ordenador externo por puerto serie. Comenzaremos usando el módulo spi maestro para enviar caracteres directamente
Este es un circuito que envía el número 3 al display con cada pulsación del botón SW1. El número se introduce por la entrada data del módulo SPI maestro y el pulsador se conecta a start
En este vídeo lo vemos en funcionamiento. Se parte del display inicializado (nada más alimentarlo). Al apretar 4 veces el pulsador habrá 4 números 3 en el display. Como siempre se envía el mismo número, no se notarán cambios si se aprieta más veces
Ahora en vez de introducir un número constante por data, conectamos un contador módulo 10 a la frecuencia de 1Mhz. Cada vez que se aprieta el pulsador se muestra el número de ese contador por el display. No es aleatorio, pero sí nos dará esa sensación
El contador es de 4 bits, y cuenta desde 0 hasta 9. Los datos que se envían por el spi son de 8 bits, por lo que los 4 bits de mayor peso los ponemos a 0 explícitamente. Al apretarse el pulsador se hace la captura del número del contador
Cargamos el circuito y lo probamos. Cada vez sale un resultado diferente. En este vídeo se ven mis pruebas
Ampliamos el ejemplo anterior para incluir la orden de CLS de forma que al apretar SW2 se realiza un borrado del display y el cursos se posiciona en home. Al apretar SW1 se muestra en la posición del cursor el valor del contador de 1Mhz
Un multiplexor de 2 a 1 de 8 bits selecciona el byte a enviar por el SPI: bien el comando CLS o bien el dato del contador. Esta selección depende del pulsador apretado. Mediante un codificador de 2 a 1 obtenemos una señal a 1 cuando se aprieta CLS y 0 en el resto de casos
La transacción en el SPI comienzo cuando se haya apretado cualquiera de los dos pulsadores, por eso usamos una puerta OR conectada a start. Si se aprietan los dos pulsadores a la vez, el codificador da prioridad al CLS
Cargamos el circuito y lo probamos. En este vídeo se ven las pruebas. Con SW1 aparecen números "aleatorios". En cuanto se pulsa SW2 se borra el display y el cursos se inicializa en la posición 0 (extermo izquierdo)
Un controlador es un circuito electrónico que hace de intermediario entre un dispositivo y el circuito de aplicación. En nuestro caso el dispositivo es el display SPI. El controlador ofrece una interfaz para que otros circuitos muestren información en este display. Un ejemplo de circuito de aplicación podría ser un reloj, o un cronómetro
Hemos visto que el display SPI se controla mediante comandos. Por tanto, una de las operaciones fundamentales que debe hacer nuestro controlador es enviar bytes secuencialmente al SPI. Así, por ejemplo, para llevar el cursor a la posición inicial hay que enviar dos bytes: 0x79 y 0x00
Por el SPI sólo podemos hacer envíos de byte en byte. Por lo que para ejecutar el comando LOCATE 0 hay que hacer dos envíos. Nuestro controlador deberá gestionar eso: secuenciar el envío de los bytes para que se envíen uno tras otro
En hardware todo funciona en paralelo. Es lo natural. Pero para realizar tareas secuenciales hay que crear mecanismos específicos. En el sofware es al revés: funciona secuencialmente de manera natural. Para tener paralelismo hay que usar mecanismos adicionales
Para realizar esta secuencialización en nuestro controlador hardware usaremos máquinas, que son circuitos que realizan varias acciones, una detrás de otra. Las máquinas inicialmente están apagadas. Al arrancar realizan las acciones y luego terminan
La máquina más básica es la de contar. Tiene un parámetro N que indica el número de pasos secuenciales a realizar. Por cada paso se envía su número n (empezando por cero) y un tic por exec para indicar la ejecución de ese paso
La máquina NO ejecuta los n pasos de golpe, sino de uno en uno. Al arrancan ejecuta el paso 0 y se queda esperando que llegue un tic por su entrada next. Cuando llega, ejecuta el paso 1 y espera de nuevo. Así con los N pasos. Tras ejecutar el paso N-1, la máquina termina y emite un tic por done
Para entender el funcionamiento empezaremos haciendo un circuito que envíe tres veces el número 4, por ejemplo. Hay que usar una máquina de 3 pasos y en cada paso se envía el dígito 4 por el SPI. La salida exec la conectamos a la entrada start del bloque del SPI
Al apretar el pulsador, la máquina arranca. Emite un tic por exec para realizar el primer envío del dígito 4. Cuando se ha terminado de enviar, el bloque SPI emite un tic por done, que llega a la máquina por next, con lo cual se pasa al siguiente paso
En total, la máquina emite 3 tics por exec, que hacen que el spi haga 3 envíos del dato constante (dígito 4). Luego termina y se apaga. Si apretamos el botón de nuevo, se envían de nuevo los dígitos. En este vídeo lo vemos en acción
La segunda vez que apretamos, aparece el último 4 y dos más al comienzo que se sobreescriben sobre las que ya había. Si volvemos a apretar no notamos cambio, pero se están sobreescribiendo los dígitos 4
Para enviar números diferentes cada vez sólo hay que añadir un multiplexor de 4 a 1, de 4 bits y usar la salida n de la máquina de contar para seleccionar en cada paso cuál es el número a enviar por el SPI. En este ejemplo enviamos 3 números: el 5, 6 y 7
Cargamos el circuito y lo probamos. En este vídeo se muestra el funcionamiento. Cada vez que se aprieta el pulsador, se muestran los dígitos 5,6 y 7 a partir de la posición del cursor. Primero vemos 567. Si apretamos la segunda vez vemos 6775, ya que el 5 se pone en última posición y el 6 y 7 en las dos primeras
Al multiplexor hemos conectado números constantes, pero se podrían sustituir por registros o contadores, lo que nos permite sacar por el display números varibles.
Para mostrar números en los 4 dígitos sólo hay que asegurarse de llevar el cursor a la posición 0. Esto se puede hacer enviando el comando LOCATE 0 (2 bytes) o bien el comando CLS antes del envío de los números. Si usamos CLS, en total habrá que enviar 5 bytes
En este ejemplo implementamos un contador de 0 a 99 en los dígitos de menor peso del display, dejando el resto a 0. Se incrementa con cada pulsación del botón SW1. Con el pulsador SW2 se pone a cero. Como hay que enviar 5 bytes, usamos un multiplexor de 8 a 1
La máquina de contar (N=5) hace que se seleccionen secuencialmente los 5 bytes, para su envío por el SPI, empezando por el CLS (0x76), después los dos dígitos 0 y por último los dos dígitos del contador. El pulsador SW1 incrementa el dígito de menos peso del contador módulo 10
Cuando llega al máximo emite un tic de overflow y se incrementa el contador de las decenas. La máquina hay que arrancarla cada vez que queremos que se actualice el display: en el inicio (tras el encendido), cuando hay un incremento (SW1) y cuando se pone a 0 (SW2). Se usa una OR de 3 entradas
Lo cargamos y lo probamos. En este vídeo lo vemos en funcionamiento. ¡¡Nuestro contador manual funciona perfectamente!!
El controlador más básico es el Digitos-4, que nos permite mostrar 4 dígitos independientes. El bloque se encuentra en el menú Perif/Displays/COM-1129-SparkFun/digitos-4. Al reciber un tic por la entrada view, se capturan los dígitos de sus entradas y se muestran en el display
Está diseñado a partir de los bloques que ya conocemos: una máquina de contar, un multiplexor 8-1 y el SPI maestro. Al llegar el tic de view, los dígitos se almacenan en 4 registros de 4 bits y se activa la máquina de contar, para secuencializar los comandos
Primero se envía el comando de CLS y luego el contenido de los 4 regitros: 5 bytes en total. La señal de selección del esclavo (ss) se activa (0) con view, al comenzar, y se desactiva (1) al terminar, con done. Por busy se saca el estado del controlador y se emite un tic por done al finalizar
En este ejemplo mostramos en los dos dígitos de menor peso un contador de décimas de segundo, de 0 a 99. Es casi igual que el del ejemplo 7, pero usando el nuevo bloque digitos-4 e incrementando el contador automáticamente cada décima de segundo (100ms)
Este controlador del display nos permite usar los 4 dígitos muy fácilmente, sin tener que preocuparnos de los detalles de bajo nivel del SPI. Lo cargamos y lo probamos. En el vídeo lo vemos en acción.
Para mostrar tiempo en el display usaremos los dos puntos ":" como separador entre los dos dígitos de la izquierda y los de la derecha. Esto nos permite serparar entre horas:minutos ó minutos:segundos. El controlador Time-4 es igual a Digitos-4, con una entrada adicional para mostrar los dos puntos
El estado para los dos puntos se introduce por colon. Cuando se envía un tic por view, además de actualizarse los dígitos se mostrarán los dos puntos si colon está a 1 y se apagarán si está a 0. Nuestro controlador deberá enviar el comando POINT con el argumento adecuado
La ampliación del controlador a esta nueva función es muy fácil. Sólo hay que cambiar el parámetro N de la máquina de contar para ejecutar 7 pasos: los 5 anteriores más 2 para el envío del comando POINT con su argumento
En las entradas 5 y 6 del multiplexor 8-1 conectamos los dos nuevos bytes a enviar al display: el código del comando Point, que es un valor fijo, y su argumento que tiene todos los bits a 0 salvo el 4 que indica el estado de los dos puntos
Por la entrada colon llega el estado de los dos puntos y lo inyectamos por el bit 4 de un bus de 8 bits usando el bloque inject. Esto crea una dato de 8 bits donde todos los bits están a 0 salvo el 4 que tiene el estado. Es el argumento del comando POINT
Las modificaciones al controlador han sido mínimas, pero ya podemos mostrar tiempo :-) Este es el circuito completo del nuevo controlador, que se encuentra en el menú Perif/Displays/COM-1129-SparkFun
Como ejemplo de uso de este nuevo bloque vamos a hacer un minutero y segundero. Empieza en 00:00 y llega hasta 59:59. Para mostrar la actividad, los dos puntos parpadean a un ritmo de medio segundo. Usamos 4 contadores de 4 bits para representar los 4 dígitos
El circuito ya lo conocemos de los tutoriales de FPGAs libres. Para las unidades de segundo y de minuto, se usan contadores módulo 10. Para las decenas de segundo y de minuto los contadores son módulo 6, ya que sólo muestran los dígitos del 0 al 5
Lo cargamos y lo probamos. En este vídeo lo vemos en acción. Lo he empezado a grabar cuando estaba por 55:38. Si hacemos reset, la cuenta vuelve a empezar desde 00:00. Ya podemos medir el tiempo y visualizarlo correctamente en nuestra FPGA :-)
Este controlador nos permite visualizar dígitos decimales (0-9) y hexadecimales (0-9, A-F), igual que los anteriores, pero además podemos activar cualquiera de los puntos (comando POINT) y establecer el nivel de brillo (comando BRIGHT)
Este controlador tiene que enviar 9 bytes al display en cada actualización: CLS (1 byte), el valor de los 4 dígitos, el comando LOCATE (2 bytes) y el comando BRIGHT (2 bytes). Hay que actualizar el parámetro N de la máquina de contar para que ahora valga 9 en vez de 7
También hay que sustituir el multiplexor 8 a 1 por uno de 16 a 1. Sólo usaremos 9 de las 16 entradas, por lo que nos sobran 7, que dejamos sin conectar
Es es el circuito completo del nuevo controlador. Es prácticamente igual que los anteriores, pero con un multiplexor mayor y una máquina de contar que ejecuta más pasos.
En este ejemplo se implementa un contador hexadecimal desde 0000 a FFFF. Se incrementa cada décima de segundo. Además se realiza una animación en los puntos, mediante el desplazamiento de un bit a la izquierda de la entrada pts, comenzando con el valor inicial 1
Mediante dos pulsadores se cambia el nivel del brillo del display, usándose el bloque control-brillo. En este vídeo lo vemos en acción. Fijarse primero en el contador, después en la animación de los puntos y luego en el cambio de brillo con los pulsadores
El Controlador Char-4 es igual a Digitos-4++, pero las entradas de datos son de 8 bits para poder representar caracteres ASCII. No se pueden mostrar todos, por la limitación de tener 7 segmentos, pero nos permite mostrar textos simples, además de dígitos
En este ejemplo se muestra el texto "HOLA FPGA" animado, moviéndose de derecha a izquierda. Se usa una memoria de 16 direcciones y 32 bits para almacenar los 4 bytes que se muestran en cada momento de la animación. Un contador recorre esta memoria, mostrando el mensaje en el display
Lo cargamos y lo probamos. En este vídeo se muestra en funcionamiento. La animación se ve muchísimo mejor al natural. A través de la cámara se ve un poco extraña, pero te puedes hacer una idea del funcionamiento. Lo mejor es que lo pruebes en directo ;-)
El último controlador es el Segment-4 que nos permite tener el control de TODOS los segmentos individuales. Las entradas de datos son de 7 bits, un bit para cada segmento. Para mostrar dígitos tendremos que usar nuestro propio decodificador
En su implementación no hay nada nuevo. Ahora hay que enviar 13 bytes: 4 comandos CONTROL (2 bytes cada uno. Total 8 bytes) para enviar el estado de los segmentos a los 4 displays. El comando CLS (1 byte), el comando POINT (2 bytes) y el comando BRIGHT (2 bytes)
Como ejemplo del controlador segment-4 usaremos 4 registros de desplazamiento de 6 bits para generar una animación en cada display. Cada registro tiene un valor inicial diferente, con sólo 1 segmento encendido. Cada 100ms se hacen los desplazamientos y se actualiza el display
Lo cargamos y lo probamos. En este vídeo lo vemos en acción. Con nuestro display ya podemos hacer cosas más creativas, no sólo mostrar información :-)
- Ya podemos mostrar información en el display SPI COM-1129 de Sparkfun, desde nuestros circuitos de aplicación en la FPGA. Con esto podemos hacer relojes, alarmas, contadores... y sobre todo, nos será muy útil para depurar
- Tenemos disponibles 5 controladores para usar el Display, y para modificarlos para desarrollar los nuestros propios
- Estos controladores reciben la información por entradas en paralelo y envían comandos al display, de forma secuencial. Para hacer fácil esta secuencialización hemos usado la máquina de contar
- Con sólo cambiar el número de pasos de la máquina de contar y las conexiones con el multiplexor, hemos sido capaces de implementar 5 controladores diferentes. Lo ideal es hacernos el controlador que necesitamos exactamente para nuestra aplicación. Así ahorramos recursos
- Este display soporta comunicación por el bus I2C además del SPI. Esto nos será muy útil en el futuro para aprender a hacer circuitos por el I2C, usando este mismo display que ya tenemos dominado
Todos los ejemplos se pueden descargar de este repositorio
- Juan González-Gómez (Obijuan)
- Logo de SParkFun: By SparkFun Electronics from Boulder, USA - SparkFun Electronics Logo, CC BY 2.0, https://commons.wikimedia.org/w/index.php?curid=67316131
- Display de 7 segmentos serie. COM-11629. Sparkfun
- Documentación técnica del Display SPI (En inglés)
- Display SPI en Bricogeek
- Icestudio, Nigthly builds
- Tutorial de Electrónica digital para makers con FPGAs libres
- VideoBlog: Píldoras de conocimiento
- Jedi Collection
- SPI Transfer Modes
- Arduino SPI Library