El MAX7219 y el MAX7221 son drivers para controlar un display de LED de 8 dígitos de 7 segmentos con punto decimal. Comunican con el MCU por medio de un bus SPI en el caso del MAX7221 y un bus serie genérico, aunque muy compatible a nivel hardware y software, por lo que, para la finalidad de este texto, puede equiparase al mismo.
Ofrecen varias ventajas frente a gestionar directamente desde el microcontrolador el uso de una pantalla de módulos LED de 7 segmentos
- Al separar del µC el trabajo de redibujar el display LED, pueden utilizarse con microcontroladores pequeños sin problemas de rendimiento como parpadeo o redibujado desigual.
- Como el bus serie que utilizan es suficientemente rápido (el MAX7219 y el MAX7221 funcionan a 10 MHz), el valor mostrado en el display LED puede refrescarse a buena frecuencia, sin esfuerzo para el MCU, e incluso mostrar fácilmente movimiento.
- Ya que trabajan con comunicaciones serie, solamente se necesitan 3 hilos (no se usa el pin MISO, ya que no devuelve información) más la alimentación, y no 16, para manejar 8 dígitos de 7 segmentos (más el punto decimal) por lo que ahorra patillas GPIO del microcontroladores.
- Al estar diseñados para gestionar pantallas numéricas, son capaces de interpretar la información BCD, pero también pueden utilizarse de forma genérica para manejar cada segmento por separado. Esto abre la posibilidad de usar distribuciones LED alternativas, que no representen números, por ejemplo, barras de progreso (como las de carga de batería) o matrices hasta de 8×8 LED.
- El MAX7219 y el MAX7221 están concebidos de forma que se pueden encadenar varios dispositivos al estilo daisy chain conectando el pin DIN de los MAX7219 y MAX7221 con el pin DOUT del anterior (que en el primero de la cadena no es necesario conectar y puede quedar al aire). Cuando se forma una cadena de drivers es necesario, por tanto, utilizar un cuarto hilo en el bus de comunicaciones.
Como el MAX7219 y el MAX7221 son equiparables en funcionamiento y el MAX7219 está más presente en la mayoría de los dispositivos y sobre todo en los módulos para pruebas, en el resto del texto se hace referencia a ambos usando solamente el nombre del primero, MAX7219. La única diferencia hardware reseñable es que el pin 12 es (nominalmente) CS en el MAX7221 y LOAD en el MAX7219 con una función similar. De la misma forma, se usa para ambos el mismo nombre ya que es el que habitualmente se encuentra rotulado en las conexiones serie.
Con lo dicho hasta ahora ya se puede suponer que la configuración hardware es muy sencilla. En primer lugar, se alimenta a 5 V (funciona entre 4 V y 5,5 V), por lo que es compatible con la mayoría de los microcontroladores de las series pequeñas, como Arduino Uno.
Para establecer el nivel de iluminación de los LED, se dispone una resistencia (RSET) que determina la corriente que llega a la conexión ISET. La corriente que llega a los segmentos LED es 100 veces mayor que la que se establezca en ISET con RSET. El valor de esta resistencia puede ser variable (lo que permite disponer un potenciómetro en el montaje). Debe de ser de 10 Ω como mínimo.
Al diagrama de arriba se suele añadir un diodo Zener (típicamente un 1N5524B) para bajar el nivel de tensión en el LED del punto decimal. El MAX7219 es muy estable frente a interferencias, en cualquier caso, cuando las circunstancias de alimentación lo requieran, se pueden añadir los clásicos condensadores de filtro de 10 µF y 100 nF a la alimentación.
En el anterior esquema se incluye el encadenamiento entre dos MAX7219 usando DOUT (anterior en la cadena) y DIN (siguiente en la cadena) y la activación desde el microcontrolador, pero además, como es lógico, hay que conectar todos los MAX7219 de la cadena al bus SPI, también con CS (LOAD) y la señal de reloj, que en la hoja de datos del MAX7219 aparece como CLK )pero que muchas veces se llama SCK o SCLK en la nomenclatura del bus SPI).
Como existe una gran variedad de display de LED de 7 segmentos o de matrices LED, también es posible que sea necesario añadir una batería de transistores a modo de driver para controlar determinado hardware que funcione a un voltaje o a un amperaje mayor que el entregado por el MAX7219. En tales casos, la función del MAX7219 sería activar (saturar) esos transistores que alimentarían los LED.
Para poder realizar pruebas existen multitud de módulos que usan el MAX7219 y que incluyen algún tipo de display de LED de 7 segmentos o de matriz LED, normalmente preparados para enlazarse entre ellos. Aunque a nivel lógico no exista límite al encadenar drivers, sí que se presenta a nivel de hardware, especialmente cuando se usan cables y en función, principalmente, de su longitud.
Utilizar el MAX7219 y el MAX7221 desde Arduino
Para explotar el MAX7219 o el MAX7221 desde un programa para Arduino se utiliza la librería SPI. En primer lugar es necesario inicializarla con SPI.begin(); y establecer con digitalWrite() un nivel bajo en la patilla CS (LOAD) a cada acceso al driver.
La forma de enviar un valor a un registro del MAX7219 o del MAX7221 es usando SPI.transfer(). En primer lugar se envía el código del registro al que se accede y en segundo lugar el valor que se transfiere. Como ejemplo, la siguiente podría ser una función que transfiriera un valor a un registro de un MAX7219.
|
1 2 3 4 5 6 7 |
void enviar_MAX7219(byte registro, byte valor) { digitalWrite(PIN_CS,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(PIN_CS,HIGH); } |
Lógicamente, necesita que se defina PIN_CS, con algo como #define PIN_CS 10 y se establezca previamente como pin de salida con pinMode(PIN_CS,OUTPUT);.
Antes de enviar los valores de los dígitos que se mostrarán en el MAX7219 suele configurarse. Alguno de los registros (direcciones) de las opciones de configuración más relevantes son:
-
0x0FCuando el valor del registro es 1 se habilita un modo de prueba con el que verificar el funcionamiento del MAX7219. -
0x0CActivar o desactivar. La razón de desactivar el MAX7219 es utilizar el modo de bajo consumo así como apagar el display de LED de 7 segmentos. El valor 1 activa el driver y el 0 lo desactiva. -
0x0BNúmero máximo de dígitos representados por el MAX7219 en el display. Se expresa como un límite, es decir, el valor que se almacena en el registro es el número de dígitos mostrados menos uno. -
0x0ABrillo de la pantalla (el máximo es el establecido con RSET en el pin ISET). Puede ser un valor entre 0, el brillo menor, y 15, el brillo mayor. -
0x09Interpretar los valores mostrados en el display LED de 7 segmentos como decimal codificado en binario (BCD) (almacenando 0xFF en el registro) o con códigos para cada segmento. Usando el segundo método se puede explotar el MAX7219 con todo tipo de matrices LED, no solo en pantallas con módulos LED de 7 segmentos. Además de no codificar en absoluto en BCD almacenando cero en el registro, existen dos modos intermedios que consisten en poner a cero los bits que corresponden con el dígito que se gestiona de forma genérica.
En el siguiente esquema de un módulo LED se muestra el código binario de cada segmento. Con una operación OR entre ellos se obtiene el valor que se envía al MAX7219 para el dígito correspondiente.
Los registros 0x01 a 0x08 sirven para hacer referencia a los dígitos de relevancia correspondiente. No empieza a contar en el cero porque el registro 0x00 es el que se utiliza para encadenar drivers MAX7219.
Con lo que ya se ha explicado sería posible elaborar una nueva función que, usando la anterior, represente un valor display LED de 7 segmentos. El código supone que no hay un segmento especial para el signo menos y se usa el segmento central del primer dígito de la cifra. Cuando se usa un segmento especial suele ser el que, de otra forma, correspondería al punto decimal del último dígito del display LED
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
void mostrar_cifra_MAX7219(long valor, bool rellenar_ceros) { unsigned char contador_digito=0; // Número del dígito que se está procesando unsigned char digito; // Valor del dígito que se va a representar bool negativo=valor<0; // True cuando el valor que se representa es negativo y false cuando sea positivo if(valor==0) // Representar el valor cero (sin procesar) o iterar los valores dividiendo entre 10 y mostrando el resto { enviar_MAX7219(++contador_digito,0); // Mostrar un cero en el primer dígito } else { if(negativo) // El valor que se representa es positivo y posteriormente (si procede) se dibuja el signo { valor=abs(valor); } while(valor>0) { digito=valor%10; // Dígito que toque (resto de 10) enviar_MAX7219(++contador_digito,digito); // Mostrar el dígito en la siguiente posición (empieza digito=0 y el primer dígito en el MAX7219 es 1) valor/=10; // Preparar el valor para representar el próximo dígito dividiéndolo entre 10 } if(negativo&&!rellenar_ceros) // Si el valor era negativo y no hay que rellenar con ceros { enviar_MAX7219(++contador_digito,SIGNO_MENOS); // Mostrar el signo menos el el digito que toque (el siguiente a la cifra) } } while(contador_digito<NUMERO_DIGITOS-rellenar_ceros*negativo) // Mientras queden espacios hay que apagar el dígito o rellenar con ceros salvo que el valor fuera negativo { enviar_MAX7219(++contador_digito,rellenar_ceros?0:BORRAR_SEGMENTOS); // Mostrar un cero o apagar el dígito } if(negativo&&rellenar_ceros) // Si el valor era negativo y había que rellenar con ceros el primer dígito es el signo { enviar_MAX7219(++contador_digito,SIGNO_MENOS); // Mostrar el signo menos en el dígito que toque (que debe ser igual al número total de dígitos) } } |
Como puede verse en la línea resaltada del ejemplo (y en las líneas 8, 24, 29 y 33), para mostrar un valor en un dígito se envía (se almacena) en el registro que corresponde al dígito, de 1 a 8, el valor, en este caso expresado en BCD.
En el código de la función anterior se utilizan las constantes SIGNO_MENOS y BORRAR_SEGMENTOS que corresponden con los códigos que se usan para representar el guión (el signo menos) y el módulo LED con todos los segmentos apagados al enviarlos a un dígito.
|
1 2 |
#define SIGNO_MENOS 0x0A #define BORRAR_SEGMENTOS 0x0F |
Utilizando el modo BCD del MAX7219 aún se pueden representar 4 valores más, que se pueden incluir a las definiciones del código anterior:
|
1 2 3 4 |
#define LETRA_H 0x0C #define LETRA_E 0x0B #define LETRA_L 0x0D #define LETRA_P 0x0E |
Usando la misma codificación que para los dígitos en BCD, estos 4 últimos signos permiten escribir algunos mensajes. En el siguiente código de ejemplo se muestra cómo escribir HELP en mitad del display.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
#define MODO_BCD_MAX7219 0x09 #define BRILLO_MAX7219 0x0A #define LIMITE_MAX7219 0x0B #define ACTIVAR_MAX7219 0x0C #define MODO_TEST_MAX7219 0x0F #define LETRA_E 0x0B #define LETRA_H 0x0C #define LETRA_L 0x0D #define LETRA_P 0x0E #define BORRAR_SEGMENTOS 0x0F #define NUMERO_DIGITOS 8 #define PIN_CS 10 #include <SPI.h> void setup() { SPI.begin(); pinMode(PIN_CS,OUTPUT); digitalWrite(PIN_CS,LOW); enviar_MAX7219(ACTIVAR_MAX7219,0); // Desactivar MAX7219 enviar_MAX7219(MODO_TEST_MAX7219,0); // Desactivar el modo de prueba enviar_MAX7219(BRILLO_MAX7219,0); // El brillo más bajo posible (de 0 a 15) enviar_MAX7219(LIMITE_MAX7219,NUMERO_DIGITOS-1); // Límite de escaneo de dígitos (último dígito empezando en cero) enviar_MAX7219(MODO_BCD_MAX7219,255); // Modo BCD (dígitos de 7 segmentos) enviar_MAX7219(ACTIVAR_MAX7219,1); // Activar MAX7219 enviar_MAX7219(8,BORRAR_SEGMENTOS); enviar_MAX7219(7,BORRAR_SEGMENTOS); enviar_MAX7219(6,LETRA_H); enviar_MAX7219(5,LETRA_E); enviar_MAX7219(4,LETRA_L); enviar_MAX7219(3,LETRA_P); enviar_MAX7219(2,BORRAR_SEGMENTOS); enviar_MAX7219(1,BORRAR_SEGMENTOS); } void loop() { } void enviar_MAX7219(byte registro, byte valor) { digitalWrite(PIN_CS,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(PIN_CS,HIGH); } |
Si en lugar de una posición fija, como en el ejemplo anterior, se utiliza un dígito de inicio, y en lugar de representar cada carácter se muestra el que corresponda de un vector que contiene la palabra, es muy sencillo hacer una versión animada del código de arriba.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
#define MODO_BCD_MAX7219 0x09 #define BRILLO_MAX7219 0x0A #define LIMITE_MAX7219 0x0B #define ACTIVAR_MAX7219 0x0C #define MODO_TEST_MAX7219 0x0F #define LETRA_E 0x0B #define LETRA_H 0x0C #define LETRA_L 0x0D #define LETRA_P 0x0E #define BORRAR_SEGMENTOS 0x0F #define NUMERO_DIGITOS 8 #define DIGITOS_SIN_TEXTO 4 #define VALORES_TEXTO_HELP {BORRAR_SEGMENTOS,BORRAR_SEGMENTOS,BORRAR_SEGMENTOS,BORRAR_SEGMENTOS,LETRA_H,LETRA_E,LETRA_L,LETRA_P} #define PIN_CS 10 #include <SPI.h> byte desplazamiento=0; byte contador; byte texto[NUMERO_DIGITOS]=VALORES_TEXTO_HELP; boolean direccion=true; void setup() { SPI.begin(); pinMode(PIN_CS,OUTPUT); digitalWrite(PIN_CS,LOW); enviar_MAX7219(ACTIVAR_MAX7219,0); // Desactivar MAX7219 enviar_MAX7219(MODO_TEST_MAX7219,0); // Desactivar el modo de prueba enviar_MAX7219(BRILLO_MAX7219,0); // El brillo más bajo posible (de 0 a 15) enviar_MAX7219(LIMITE_MAX7219,NUMERO_DIGITOS-1); // Límite de escaneo de dígitos (último dígito empezando en cero) enviar_MAX7219(MODO_BCD_MAX7219,255); // Modo BCD (dígitos de 7 segmentos) enviar_MAX7219(ACTIVAR_MAX7219,1); // Activar MAX7219 } void loop() { for(contador=0;contador<NUMERO_DIGITOS;contador++) { enviar_MAX7219(NUMERO_DIGITOS-contador,texto[(contador+desplazamiento)%NUMERO_DIGITOS]); } desplazamiento+=direccion?1:-1; direccion=(desplazamiento==DIGITOS_SIN_TEXTO||desplazamiento==0)?!direccion:direccion; delay(150); } void enviar_MAX7219(byte registro, byte valor) { digitalWrite(PIN_CS,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(PIN_CS,HIGH); } |
Con 7 segmentos no es posible representar muchos signos, la razón por la cual el MAX7219 es capaz de usar de forma arbitraria cada segmento es para usar matrices LED con la disposición correspondiente. En cualquier caso, y a falta de explicar un uso más genérico en otro artículo, para activar cada segmento es necesario:
- Desactivar el modo BCD en los dígitos en los que se va a mostrar una disposición arbitraria
- Componer el signo que se quiere representar estableciendo a nivel alto (uno) el bit del segmento que se enciende y a nivel bajo (cero) el bit del segmento que se apaga.
- Enviar el código que se ha compuesto al registro que corresponde a la posición del dígito en el que se representa
Por ejemplo, para escribir la palabra «Error» habría que definir los valores de los signos E, r y o, para luego enviarlos a las posiciones correspondientes entre la 1 y la 5.
Para definir la letra E se encenderían los segmentos A, D, E, F y G lo que corresponde, según la tabla que se incluía más arriba al valor 0b01001111. La letra o se dibujaría encendiendo los segmentos C, D, E y G con el valor 0b00011101. Por último, la letra r se compone con los segmentos E y G que corresponden al valor 0b00000101. Como es lógico, para apagar todos los segmentos de un dígito se establece a nivel bajo todos los bits, es decir, se envía un cero al registro que almacena su posición.
En el siguiente ejemplo se usa la información anterior para escribir la palabra «Error» en la parte derecha (dígitos uno a cinco) del display LED
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 |
#define MODO_BCD_MAX7219 0x09 #define BRILLO_MAX7219 0x0A #define LIMITE_MAX7219 0x0B #define ACTIVAR_MAX7219 0x0C #define MODO_TEST_MAX7219 0x0F #define SEGMENTOS_APAGADOS 0B00000000 // Todos los segmentos apagados #define SEGMENTOS_LETRA_E 0B01001111 // Segmentos ADEFG #define SEGMENTOS_LETRA_R 0B00000101 // Segmentos EG #define SEGMENTOS_LETRA_O 0B00011101 // Segmentos CDEG #define NUMERO_DIGITOS 8 // Número de dígitos de 7 segmentos conectados al MAX7219 #define PIN_CS 10 #include <SPI.h> byte contador_digito; void setup() { SPI.begin(); pinMode(PIN_CS,OUTPUT); digitalWrite(PIN_CS,LOW); delay(500); enviar_MAX7219(ACTIVAR_MAX7219,0); // Desactivar MAX7219 enviar_MAX7219(MODO_TEST_MAX7219,0); // Desactivar el modo de prueba enviar_MAX7219(BRILLO_MAX7219,15); // El brillo más alto posible (de 0 a 15), que se vea que es un error enviar_MAX7219(LIMITE_MAX7219,NUMERO_DIGITOS-1); // Límite de escaneo de dígitos (último dígito empezando en cero) enviar_MAX7219(MODO_BCD_MAX7219,0); // Desactivar el modo BCD enviar_MAX7219(ACTIVAR_MAX7219,1); // Activar MAX7219 contador_digito=1; enviar_MAX7219(contador_digito++,SEGMENTOS_LETRA_R); enviar_MAX7219(contador_digito++,SEGMENTOS_LETRA_O); enviar_MAX7219(contador_digito++,SEGMENTOS_LETRA_R); enviar_MAX7219(contador_digito++,SEGMENTOS_LETRA_R); enviar_MAX7219(contador_digito++,SEGMENTOS_LETRA_E); while(contador_digito<=NUMERO_DIGITOS) { enviar_MAX7219(contador_digito++,SEGMENTOS_APAGADOS); } } void loop() { } void enviar_MAX7219(byte registro, byte valor) { digitalWrite(PIN_CS,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(PIN_CS,HIGH); } |
Para usar el driver MAX7219 con un display de LED de 7 segmentos en el que activar segmentos de manera arbitraría no merece la pena implementar más funcionalidades pero para presentar valores numéricos sí puede ser interesante implementar la presentación de valores con decimales.
Inicialmente puede parecer interesante crear una nueva función para números decimales o modificar la que se ha descrito antes para que los acepte. En realidad lo único relevante es implementar la activación del punto decimal ya que, al ser un número de dígitos fijo (y no muy alto), la gestión que hace el programa debe controlar los valores que se representarán.
La solución por la que he optado consiste en pasar como argumento a la función la posición del punto decimal (coma). Desde el programa que hace la llamada se multiplica el número decimal (float) por el número de posiciones de la coma y se pasa como un entero a la función.
Con los cambios anteriores, una función que mostrara el punto decimal en el dígito de una posición determinada sería como el código de abajo. Es interesante resaltar que, en la mayoría de los módulos de 7 segmentos, el decimal está a la derecha, por lo que debe activarse en el dígito siguiente a la posición que se desea, a la izquierda de los valores menores que uno.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
#define MODO_BCD_MAX7219 0x09 #define BRILLO_MAX7219 0x0A #define LIMITE_MAX7219 0x0B #define ACTIVAR_MAX7219 0x0C #define MODO_TEST_MAX7219 0x0F #define BORRAR_SEGMENTOS 0x0F #define SIGNO_MENOS 0x0A #define COMA 0B10000000 // Para hacer OR con el dígito que tiene el punto decimal encendido #define NUMERO_DIGITOS 8 // Número de dígitos de 7 segmentos conectados al MAX7219 #define NUMERO_DECIMALES 2 #define PIN_CS 10 #include <SPI.h> byte digito; byte caracter; float valor=0.0; float coeficiente_entero=pow(10,NUMERO_DECIMALES); void setup() { SPI.begin(); //SPI.setBitOrder(MSBFIRST); pinMode(PIN_CS,OUTPUT); digitalWrite(PIN_CS,LOW); delay(500); enviar_MAX7219(ACTIVAR_MAX7219,0); // Desactivar MAX7219 enviar_MAX7219(MODO_TEST_MAX7219,0); // Desactivar el modo de prueba enviar_MAX7219(BRILLO_MAX7219,0); // El brillo más bajo posible (de 0 a 15) enviar_MAX7219(LIMITE_MAX7219,NUMERO_DIGITOS-1); // Límite de escaneo de dígitos (último dígito empezando en cero) enviar_MAX7219(MODO_BCD_MAX7219,255); // Modo BCD (dígitos de 7 segmentos) enviar_MAX7219(ACTIVAR_MAX7219,1); // Activar MAX7219 } void loop() { mostrar_cifra_MAX7219((long)(valor*coeficiente_entero),NUMERO_DECIMALES,false); valor-=0.01; delay(150); } void enviar_MAX7219(byte registro, byte valor) { digitalWrite(PIN_CS,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(PIN_CS,HIGH); } void mostrar_cifra_MAX7219(long valor, char posicion_coma, bool rellenar_ceros) // No verifica que el valor sea mayo o menor que el representable { unsigned char contador_digito=0; unsigned char digito; bool negativo=valor<0; posicion_coma=posicion_coma*(posicion_coma>0&&posicion_coma<NUMERO_DIGITOS-negativo); // Corregir posiciones de coma incorrectas if(valor==0) { while(contador_digito<=posicion_coma) { digito=COMA*(contador_digito==posicion_coma&&posicion_coma>0); // El dígito es cero y si la posición de la coma es mayor que cero y se ha llegado al dígito en el que representarla añadírsela enviar_MAX7219(++contador_digito,digito); } } else { if(negativo) { valor=abs(valor); } while(valor>0) { digito=(valor%10)|(contador_digito==posicion_coma&&posicion_coma>0)*COMA; // Dígito que toque (resto de 10) con coma si es su posición y es mayor que cero enviar_MAX7219(++contador_digito,digito); // Mostrar el dígito y la coma si corresponde. Como el primer dígito es 1, cuando la posición de la coma es cero (o un valor mayor que los dígitos) no se muestra valor/=10; } while(contador_digito<=posicion_coma) { digito=(contador_digito==posicion_coma)*COMA; enviar_MAX7219(++contador_digito,digito); } if(negativo&&!rellenar_ceros) { enviar_MAX7219(++contador_digito,SIGNO_MENOS); } } while(contador_digito<NUMERO_DIGITOS-rellenar_ceros*negativo) { enviar_MAX7219(++contador_digito,rellenar_ceros?0:BORRAR_SEGMENTOS); } if(negativo&&rellenar_ceros) { enviar_MAX7219(++contador_digito,SIGNO_MENOS); } } |
Librería para controlar el MAX7219 y el MAX7221 desde Arduino
El siguiente es el código de una pequeña librería para controlar con el MAX7219 o el MAX7221 un display LED de 8 dígitos de 7 segmentos desarrollada utilizando la información que se ha explicado hasta ahora. Se ha añadido la presentación del texto «Error» como ejemplo de activación de LED arbitrarios además de la presentación de una cifra con signo y punto decimal arbitrarios.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
// MAX7219.h #if defined(ARDUINO) && ARDUINO>=100 #include "Arduino.h" #else #include "WProgram.h" #endif #define MODO_BCD_MAX7219 0x09 #define BRILLO_MAX7219 0x0A #define LIMITE_MAX7219 0x0B #define ACTIVAR_MAX7219 0x0C #define MODO_TEST_MAX7219 0x0F #define SIGNO_MENOS 0x0A #define LETRA_E 0x0B #define LETRA_H 0x0C #define LETRA_L 0x0D #define LETRA_P 0x0E #define BORRAR_SEGMENTOS 0x0F #define COMA 0B10000000 #define SEGMENTOS_APAGADOS 0B00000000 // Todos los segmentos apagados #define SEGMENTOS_LETRA_E 0B01001111 // Segmentos ADEFG #define SEGMENTOS_LETRA_R 0B00000101 // Segmentos EG #define SEGMENTOS_LETRA_O 0B00011101 // Segmentos CDEG #define PIN_CS 10 #define NUMERO_DIGITOS 8 // Número de dígitos de 7 segmentos conectados al MAX7219 por defecto class MAX7219 { private: unsigned char pin_cs; unsigned char numero_digitos; long minimo; long maximo; void digitos_BCD(); protected: public: MAX7219(); // Constructor sin parámetros MAX7219(unsigned char pin_cs); // El número de dígitos de los módulos suele ser 8 MAX7219(unsigned char pin_cs, unsigned char numero_digitos); ~MAX7219(); // Destructor void inicializar(); void enviar(unsigned char registro, unsigned char valor); void brillo(unsigned char nivel); void encender(); void apagar(); void activar_modo_prueba(); void desactivar_modo_prueba(); void digitos_BCD(unsigned char digitos); void cantidad_digitos(); bool mostrar_cifra(long valor); bool mostrar_cifra(long valor, char posicion_coma); bool mostrar_cifra(long valor, char posicion_coma, bool rellenar_ceros); void borrar(); void mostrar_error(); }; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 |
// MAX7219.cpp #include <SPI.h> // La librería MAX7219 necesita que la librería SPI esté operativa y para no interferir con otros usos NO la inicializa #include "MAX7219.h" MAX7219::MAX7219() // Constructor sin parámetros (en Arduino suele usarse CS=10, PIN_CS, y el número de dígitos de los módulos suele ser 8, NUMERO_DIGITOS) { pin_cs=PIN_CS; numero_digitos=NUMERO_DIGITOS; // inicializar(PIN_CS,NUMERO_DIGITOS); // Como utiliza SPI debe inicializarse cuando SPI ya esté inicializado } MAX7219::MAX7219(unsigned char numero_pin_cs) // El número de dígitos de los módulos suele ser 8 (NUMERO_DIGITOS) { pin_cs=numero_pin_cs; numero_digitos=NUMERO_DIGITOS; //inicializar(pin_cs,NUMERO_DIGITOS); // Como utiliza SPI debe inicializarse cuando SPI ya esté inicializado } MAX7219::MAX7219(unsigned char numero_pin_cs, unsigned char maximo_digitos) { pin_cs=numero_pin_cs; numero_digitos=maximo_digitos; //inicializar(pin_cs,numero_digitos); // Como utiliza SPI debe inicializarse cuando SPI ya esté inicializado } MAX7219::~MAX7219() // Destructor { } void MAX7219::inicializar() { // SPI.begin(); // Para no interferir con otro código que utilice SPI, hay que gestionarlo desde el programa pinMode(pin_cs,OUTPUT); // El pin al que se conecta CS/SS del MAX7219 debe ser de salida para activarlo/desactivarlo a nivel bajo/alto digitalWrite(pin_cs,HIGH); // Desactivar el driver /* // Descomentar este bloque si hay problemas con CS/SS en SPI. Si persisten, usar el pin 10 para CS/SS de SPI. En algunas versiones, SPI el pin 10 (por defecto) ser de salida no se conecte a CS/SS del dispositivo (y no debe utilizarse para otra cosa pinMode(10,OUTPUT); */ cantidad_digitos(); minimo=-(long)pow(10,numero_digitos-1)+1; // Hay que renunciar a un dígito para el signo (en este tipo de pantalla) maximo=(long)pow(10,numero_digitos)-1; digitos_BCD(0B11111111); // Todos los dígitos (8) en formato BCD } void MAX7219::enviar(unsigned char registro, unsigned char valor) { digitalWrite(pin_cs,LOW); SPI.transfer(registro); SPI.transfer(valor); digitalWrite(pin_cs,HIGH); } void MAX7219::brillo(unsigned char nivel) { enviar(BRILLO_MAX7219,nivel); } void MAX7219::encender() { enviar(ACTIVAR_MAX7219,1); } void MAX7219::apagar() { enviar(ACTIVAR_MAX7219,0); } void MAX7219::activar_modo_prueba() { enviar(MODO_TEST_MAX7219,1); } void MAX7219::desactivar_modo_prueba() { enviar(MODO_TEST_MAX7219,0); } void MAX7219::digitos_BCD() { enviar(MODO_BCD_MAX7219,0B11111111); } void MAX7219::digitos_BCD(unsigned char digitos) { enviar(MODO_BCD_MAX7219,digitos); } void MAX7219::cantidad_digitos() { enviar(LIMITE_MAX7219,numero_digitos-1); } bool MAX7219::mostrar_cifra(long valor) { return mostrar_cifra(valor,0,false); // Por defecto no tiene coma ni se rellena con ceros } bool MAX7219::mostrar_cifra(long valor, char posicion_coma) { return mostrar_cifra(valor,posicion_coma,false); // Por defecto no rellena con ceros } bool MAX7219::mostrar_cifra(long valor, char posicion_coma, bool rellenar_ceros) { if(valor>maximo||valor<minimo) { mostrar_error(); return false; } else { digitos_BCD(); posicion_coma=posicion_coma*(posicion_coma>0&&posicion_coma<numero_digitos-negativo); // Corregir posiciones de coma incorrectas unsigned char contador_digito=0; unsigned char digito; bool negativo=valor<0; if(valor==0) { while(contador_digito<=posicion_coma) { digito=COMA*(contador_digito==posicion_coma&&posicion_coma>0); // El dígito es cero y si la posición de la coma es mayor que cero y se ha llegado al dígito en el que representarla añadírsela enviar(++contador_digito,digito); } } else { if(negativo) { valor=abs(valor); } while(valor>0) { digito=(valor%10)|(contador_digito==posicion_coma&&posicion_coma>0)*COMA; // Dígito que toque (resto de 10) con coma si es su posición y es mayor que cero enviar(++contador_digito,digito); // Mostrar el dígito y la coma si corresponde. Como el primer dígito es 1, cuando la posición de la coma es cero (o un valor mayor que los dígitos) no se muestra valor/=10; } while(contador_digito<=posicion_coma) { digito=(contador_digito==posicion_coma)*COMA; enviar(++contador_digito,digito); } if(negativo&&!rellenar_ceros) { enviar(++contador_digito,SIGNO_MENOS); } } while(contador_digito<NUMERO_DIGITOS-rellenar_ceros*negativo) { enviar(++contador_digito,rellenar_ceros?0:BORRAR_SEGMENTOS); } if(negativo&&rellenar_ceros) { enviar(++contador_digito,SIGNO_MENOS); } return true; } } void MAX7219::borrar() // Borra toda la pantalla sin apagarla { for(char contador=0;contador<NUMERO_DIGITOS;contador++) { enviar(contador+1,BORRAR_SEGMENTOS); } } void MAX7219::mostrar_error() { digitos_BCD(0B00000000); char contador_digito=1; enviar(contador_digito++,SEGMENTOS_LETRA_R); enviar(contador_digito++,SEGMENTOS_LETRA_O); enviar(contador_digito++,SEGMENTOS_LETRA_R); enviar(contador_digito++,SEGMENTOS_LETRA_R); enviar(contador_digito++,SEGMENTOS_LETRA_E); while(contador_digito<=numero_digitos) { enviar(contador_digito++,SEGMENTOS_APAGADOS); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// Ejemplo de uso de la librería MAX7219 para mostrar un valor numérico #define PIN_CS_MAX7219 10 // Pin de Arduino al que se ha conectado el pin CS/SS del MAX7219 #define DIGITOS_DISPLAY_LED 8 // El display LED que se ha usado tiene 8 dígitos #include <SPI.h> // La librería MAX7219 necesita que la librería SPI esté operativa y para no interferir con otros usos NO la inicializa #include "MAX7219.h" // Como ahora la librería se usa para pruebas se carga de la misma carpeta, cuando se instala debe cargarse con <MAX7219.h> MAX7219 pantalla(PIN_CS_MAX7219,DIGITOS_DISPLAY_LED); float valor_decimal=0.0; void setup() { SPI.begin(); // Para no interferir con otro código que utilice SPI, la librería MAX7219 no inicializa SPI y hay que hacerlo desde el programa pantalla.inicializar(); // SPI debe estar inicializado antes de inicializar el MAX7219 (que usa SPI) pantalla.apagar(); pantalla.desactivar_modo_prueba(); pantalla.brillo(7); // Brillo medio (va desde cero hasta 15) pantalla.borrar(); pantalla.encender(); } void loop() { pantalla.mostrar_cifra((long)((valor_decimal)*100),0,false); // Mostrar el valor sin coma (cero) y sin rellenar con ceros (false) valor_decimal-=1; delay(150); // Una pausa para que dé (un poco de) tiempo a ver el valor en la pantalla } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// Ejemplo de uso de la librería MAX7219 para mostrar un valor numérico #define PIN_CS_MAX7219 10 // Pin de Arduino al que se ha conectado el pin CS/SS del MAX7219 #define DIGITOS_DISPLAY_LED 8 // El display LED que se ha usado tiene 8 dígitos #include <SPI.h> // La librería MAX7219 necesita que la librería SPI esté operativa y para no interferir con otros usos NO la inicializa #include "MAX7219.h" // Como ahora la librería se usa para pruebas se carga de la misma carpeta, cuando se instala debe cargarse con <MAX7219.h> MAX7219 pantalla(PIN_CS_MAX7219,DIGITOS_DISPLAY_LED); long valor_entero=0; void setup() { SPI.begin(); // Para no interferir con otro código que utilice SPI, la librería MAX7219 no inicializa SPI y hay que hacerlo desde el programa pantalla.inicializar(); // SPI debe estar inicializado antes de inicializar el MAX7219 (que usa SPI) pantalla.apagar(); pantalla.desactivar_modo_prueba(); pantalla.brillo(7); // Brillo medio (va desde cero hasta 15) pantalla.borrar(); pantalla.encender(); } void loop() { pantalla.mostrar_cifra(valor_entero--,0,false); // Mostrar el valor sin coma (cero) y sin rellenar con ceros (false) delay(150); // Una pausa para que dé (un poco de) tiempo a ver el valor en la pantalla } |
Víctor Ventura
Desarrollando aplicaciones para la web conocí el potencial de internet de las cosas, encontré la excusa perfecta para satisfacer la inquietud de aprender electrónica que había tenido desde siempre. Ahora puedo darme el gusto de programar las cosas que yo mismo diseño y fabrico.
Sígueme:
Luciano
Hola, muy interesante lo que explicas! Yo uso el max7219 en un módulo llamado Led matrix 8×8, me surgió la inquietud de que función cumplía este driver y termine en este interesante y completo tutorial!
Quería consultarte algo respecto ala integrado max7219, usar este integrado es como hacer de forma manual multiplexado? o sea. Me encargaron un display de 4 digitos de leds de 5mm de series de 6 leds de 7 segmentos, entonces me preguntaba si este chip solucionaría gran parte de mi código y evitar tanto cable río para multiplexado y demás. Te agradezco de antemano! saludos
Víctor Ventura
Hola, Luciano.
Sí, este integrado te ahorra el «multiplexado» y también ahorrarás cables desde el microcontrolador hasta el MAX7219, que tendrás que conectar al display LED, aunque entiendo que van a estar juntos en tu montaje y separados del MCU y por eso representa otra mejora ¿Acierto?
Suerte con tu proyecto y gracias por participar en el blog 🙂
BRYAN
Hola, muy interesante y extenso tu blog. Actualmente estoy en un proyecto y estoy usando el max7219 porque a primera instancia lo vi mas facil de usar; mi proyecto consiste en contar pulsos que entra al arduino y mostrar los pulsos en los display de 7 segmentos. Tengo entendido que los display tienen que ser catodos, la cantidad total son 6 digitos, (4 enteros y 2 decimales separadas por un punto decimal) , mi consulta es, como puedo hacer la logica del programa para contar pulsos? ademas como activo el punto decimal solamente en un digito? Gracias por tu respuesta.
Víctor Ventura
Hola, Bryan.
Gracias, me alegro de que te guste el blog; espero que también te resulte útil.
Sí, en el artículo se supone que se usan display LED de 7 segmentos de cátodo común (todos los segmentos de cada dígito están conectados a masa).
Si repasas los ejemplos de código del artículo verás que se explica cómo activar el punto decimal en cierto dígito. Concretamente tendrás que hacer una operación
ORcon el valor0B10000000sobre el valor del dígito para activar el MSB (bit más significativo).Ir contando los pulsos que se muestran en el display LED no tiene relación con el MAX7219. Por ejemplo, puedes usar una variable que se inicialice a cero (por ejemplo al declararla con
unsigned long pulsos=0;) y que se vaya incrementando a cada pulso conpulsos++;dentro de una función que sea llamada por una interrupción y que puedes establecer conattachInterrupt, que usará como parámetros el número de interrupción que elijas (que dependerá del pin al que conectes la entrada del pulso y que puedes determinar condigitalPinToInterrupt), el nombre de la función que incrementa el contador y el cambio en la señal (flanco) que dispara la interrupción.En el blog tienes algunos ejemplos de uso de las interrupciones para tareas similares a la que planteas, por ejemplo en el artículo sobre el almacenamiento de datos en una tarjeta SD.
No termina de quedarme muy claro para qué usarías el punto decimal: si vas a contar pulsos resultará un número entero. Quizá con más información podríamos orientarte con el problema.
Saludos y mucha suerte con tu proyecto.
BRYAN
Gracias por responder.
Cuando dices «Ir contando los pulsos que se muestran en el display LED no tiene relación con el MAX7219» , que quieres decir con eso?
acaso con el max7219 no se puede realizar un contador de pulsos??
* anteriormente si realize un contador de pulsoscon arduino, transistores y display 7 segmentos pero era muchos cables, por eso opte el max7219 que con 3 cables era posible mostrar numeros en el display. Solo que no me queda muy claro como seria posible el contador con el max7219 ya que mandas los registros y valores.
* el punto decimal lo requiero para separar los enteros (4 digitos) y 2 decimales, si bien es cierto no se necesita eso porq al contar es todo entero; pero en mi caso lo requiero, porque cada 100 pulsos es un galon de combustible ( topico de mi proyecto) y lo que muestro en el display son los «galones de combustible» cuando realmente son los pulsos que muestra, pero para que se pueda ver que son los galones con el punto decimal cumplo el objetivo..
por ejemplo.
cont pulsos = 350 pulsos 3.5 galones —> mostrando en el display seria 0003.50 galones.
Víctor Ventura
Hola, Bryan.
Ahora veo lo del punto decimal. Puedes implementarlo como hago en la función
mostrar_cifra_MAX7219que usa el parámetroposicion_comapasando el valor (fijo) de la posición que necesitas.Con el MAX7219 sí se puede hacer un contador de pulsos, pero necesitarás más componentes. Si te fijas en el pinout del MAX7219 verás que no tiene una entrada de pulsos sino una entrada SPI que en el artículo se supone que conectas a una placa Arduino, aunque funcionaría con otros MCU.
Gracias por participar en polaridad.es
Gitmel
Muchas gracias por compartir la información! Todo bien detallado, me ha sido muy útil!.
Víctor Ventura
Gracias a ti por visitar polaridad.es 🙂
Gustavo
Hola, Victor.
Estoy haciendo un simulador de vuelo casero, y arranque con el MCP piloto automatico, con una placa usb que compre logre hacer funcionar botones y rotary encoder, pero se complica con los indicadores de velocidad altitud rumbo y vertical y eso se puede lograr con arduino. Vos me podrias ayudar
con este proyecto? Gracias.
Víctor Ventura
Hola, Gustavo.
Seguro que en polaridad.es podríamos ayudarte pero tendrás que hacer alguna pregunta concreta sobre algún tema concreto ¿No?
Entiendo por lo de «casero» que no es el caso pero, si fuera algo profesional, seguro que algún lector, o yo mismo, podríamos dirigir el proyecto como un trabajo remunerado.
Siempre estoy encantado de responder cualquier cuestión concreta que me plantean en este blog (incluso si no tiene que ver con el tema del artículo) o en otros foros, aunque no siempre soy capaz de acertar con el problema 🙁 (espero que sea por la distancia) Tema muy diferente es que yo me encargue de gestionar el proyecto personal de un tercero: tengo muchos de los míos esperando 🙂 Seguro que lo comprendes.
Saludos y suerte con tu proyecto.
gustavo
Si Victor entiendo Gracias igual. Como no se programar arduino
siempre pregunto para tratar de llegar a alguien que tenga hecho
un proyecto como el que quiero hacer y lograr realizarlo porque yo solo
no podria. Abrazo.
Iker Rour
Buenos dias,
Muy interesante tanto el post como el módulo MAX7219.
Me surge un par de preguntas:
¿Cuantos módulos MAX7219 puedo controlar con un solo arduino uno?
¿Cuantos módulos puedo conectar en cascada?
Víctor Ventura
Hola, Iker.
En principio no hay un límite para el número de dispositivos que puedes conectar a un bus SPI siempre que la alimentación y la señal sean correctas (lo que seguramente limitará la longitud de los cables, pero supongo que eso no representa un problema).
En el caso de un Arduino Uno el límite será el número de salidas digitales disponibles para activar y desactivar cada dispositivo SPI. Lógicamente, dependerá de cómo sea tu proyecto pero seguramente podrás conectar 10 dispositivos sin demasiados problemas.
Gracias por participar en polaridad.es
Iker Rour
Eso es lo que pensaba,
Muchas gracias por el post y la ayuda Victor!
Víctor Ventura
🙂
Luis G
Hola, muy buen y completo post, sólo que me queso la duda de como deberían conectarse los transistores para tener una mayor corriente en una matriz d leds, he intentado exitando la base con la salida del max y conduciendo la corriente hacia el les de colector a emisor pero sin resultados, ojala pudiera ayudarme ya que me gustaría q mi matriz pusiera utilizar el máximo brillo de los les que usé. Y por último otro comentario, en la hoja de datos del max se muestra que la Rset debe de ir a VCC y no a tierra como usted menciona, lo comento por que tal vez cometió un error en eso. Bueno me despido y ojala pudiera responderme, gracias.
Víctor Ventura
Hola, Luis.
El MAX7219 y el MAX7221 son bastante generosos a la hora de iluminar los LED que gestionan por lo que, en principio, es raro que no te baste con la configuración del circuito típico.
La solución que propones para conseguir aumentar la iluminación me parece la correcta: establecer un driver entre las salidas del MAX7219 o del MAX7221 y la alimentación de los LED (de cátodo común). Supongo que estarás utilizando unos displays de LED de 7 segmentos muy grandes y necesitarás utilizar los transistores correspondientes ¿No los sugiere el fabricante? pero, si es que eso es lo que produce el problema de la baja iluminación, tu propuesta me parece la adecuada.
Con respecto a la conexión de RSET, tienes razón. Lógicamente, para que le llegue corriente a a ISET, debe estar conectado +V. Un error absurdo, como tantos otros que habré cometido 😀 Ya lo he cambiado ¡Muchas gracias por avisar! Así no confundo a más lectores.
Espero que resuelvas tu problema y sería fenomenal si nos contaras cómo lo consigues finalmente ¡Te espero pronto por polaridad.es!
Francisco gallardo
Hola Victor,
Muchas gracias por publicar este buen trabajo.
Funciona todo para 1 modulo de 8 dígitos pero ¿como puedo programar en Arduino manejar 3 módulos de 8 digitos interconectados ?
Gracias
claudio
hola me tira un error .error compilando para la tarjeta arduino / genuino uno
Manuel Mena
Buenas tardes, tengo una gran pregunta, así como se puede anexar columnas para aumentar el número de la matriz ¿se puedo pero incrementando el número de filas? Quiero desarrollar una matriz de 16×64.
Wilmer Guarnizo
hola victor, muchas gracias por tu dedicación y aporte, es justo lo que estaba buscando, pero la verdad ando algo perdido con respecto a la conexión del DIN, CS y clk del max7219 a que pines del arduino, entiendo que el cs va en el pin 10 como lo menciona en los ejemplos pero y el resto no veo, disculpa si no caigo en cuenta si en alguna parte de tu tutorial lo dice, te agradecería mucho me respondas.
Víctor Ventura
Hola, Wilmer.
No sé si entiendo tu pregunta. La conexión es, tal como está descrita en el segundo esquema, una conexión SPI convencional pero sin utilizar MISO; es decir: DIN con MOSI, SCK con SCK y CS con algún GPIO (típicamente con SS de Arduino)
Ojalá que eso te ayude un poco.
Saludos.
Rasfael
Ola, nao consegui encontrar o download ZIP desse arquivo, voce pode me ajudar?
preciso de 3 livrarias, consegui baixar 2 apenas essa aqui nao estou achando…
Víctor Ventura
Hola, Rasfael.
Puedes descargar del siguiente enlace la librería para controlar con el MAX7219 o el MAX7221 un display LED de 8 dígitos de 7 segmentos que está formada por tres documentos: la cabecera (MAX7219.h) el código (MAX7219.cpp) y las palabras clave (keywords.txt)
Espero que esto te ayude 🙂
Gracias por visitar el blog y un saludo.
Wilmer Guarnizo
buenas noches víctor, de nuevo yo, que pena incomodar, la respuesta que me diste me sirvió y aclaro mi duda, y de antemano te agradezco muchísimo, pero ahora me surgió un problema, me llevo todo el día probando y haciendo diferentes conexiones incluso cambie librerias debido a que todos los displays me encendian, el caso es que llegue a la conclusion comprobada de que mis displays son de andodo comun, y todos los ejemplos estan destinados para displays de catodo comun, mi pregunta es si hay alguna forma de modificar el codigo tal que me invierta esta cuestion, te agradeceria mucho tu aporte y muchisimas gracias.
Ernesto Aides
Victor, primero felcitaciones por tu blog, y ahora la consulta:
Quiero hacer un panel de radio para conectar al simulador de vuelo, y la idea es usar varios modulos de 8 digitos (7 segmentos). Estoy usando un arduino mega y testeando con la libreria ledControl que permite manejar hasta 8 modulos conectados en cascada, el tema es que todo funciona bien si pongo hasta 3 modulos, ahora si ya pongo un cuarto algunos digitos ya no prenden. Soy muy pero que muy poco experto en electroica/electricidad, asi que solo supongo que es un problema de corriente; por ahora los alimento a los modulos desde el pin 5v y gnd del arduino mega (el mismo se aliemnta por el usb del computador).
Es este el problema ? cuantos modulos se pueden alimentar? (ni que hablar que todavia me faltan varios encoders y botones mas algunos leds indicadores).
Se puede alientar el arduino desde el jack conector de energia y aun mantener la conecccion a la computadora por USB o en ese caso quemaria la placa y/o la computadora ? Hasta ahora encontre info que habla de alimentar por la fuente externa cuando es un proyecto autonomo; pero yo necesito mantener la conecccion usb a la compu.
Gracias por la paciencia para con un novato. Saludos!
José Luis Marrero
Hola Víctor.
Necesito hacer un cronometro de 6 digitos de 7 seg. (mm: SS,00) minutos, segundos, y décimas. Es para una pista de equitación para niños autistas que compiten. Pensé en utilizar el módulo de 8 dígitos puesto que el de 6 no existe. Intento hacer todo con un arduino uno o mega (dispongo de ambos) sin agregar ningún otro controlador. Además debo utilizar cada dígito para ampliarlo a un display mucho más potente destinado al publico lo que haría a través de transistores apropiados y potencia externa. También debo transmitir la info del modulo pequeño al grande de forma inalámbrica con los módulos nrf24l01. La pregunta es: ¿puedes desarrollar el/los códigos y el circuito electrónico comprensible para un neófito? Obviamente sería un trabajo rentado y nos pondríamos de acuerdo en el costo si tu respuesta es afirmativa.
PD: También debería poder programar el crono para 45 seg. descendentes concluidos los cuales comenzaría el crono normal de forma automática al recibir la señal de un sensor que ya tengo instalado en la pista. Si el jinete no cruza ese sensor al los 45 seg. suena una alarma que lo deja fuera de competencia. Si cruza el sensor el crono normal comienza a contar hasta que otro sensor lo detiene al final de la pista.Todos los conteos deberían poder iniciarse, detenerse, pausarse y resetearse de manera manual con botones desde la consola central de control que ya tengo en construcción.
Muy bueno su blog y lo felicito por proporcional tanta ayuda.
Espero su respuesta.
Sebastian Ezequiel Scardigno
Hola Víctor.
Muy interesante y didáctico el articulo.
Yo hace años comencé a jugar con una matriz de 8×8, multiplexores y un arduino. En el caso de controlar una matriz 8×8 RGB se necesitarían 3 MAX7219 (uno por cada color)? O es que se puede usar uno para controlar cada color?
Nicola Bernardelli
Hola Víctor,
Muy bueno el artículo, muy útil el «mapa» de los bits que permiten prender cada segmento o el punto decimal. Tendrías un disegno con las medidas precisas, que incluya posición y diámetro de los agujeros en el PCB? (Y si lo tenés, estaría buenísimo agregarlo a la página que quedaría definitivamente sobresaliendo con respecto a otras publicaciones sobre este componente.)