bclose

Scrolling con MAX7219

Desplazamiento lateral de mensajes en el display

Objetivos

 

 

    • Continuar jugando con los displays MAX7219.
    • Montar un grupo de displays que nos permita mostrar líneas de texto.
    • Desplazar esos textos por la pantalla (Scrolling).
 

Material requerido.

 

 Tienda EspañaTienda Mexico
Imagen de Arduino UNO Arduino UNO o equivalente. Arduino UNO o equivalente.
Protoboardconexiones

Una Protoboard larga más cables.

Vais a necesitar cables macho / macho  y al menos 4 macho/hembra

Una Protoboard larga más cables.

Vais a necesitar cables macho / macho  y al menos 4 macho/hembra

Array LED 8x8

Varias matrices LEDs 8×8, con un MAX7219. Aquí vamos a usar 4

Varias matrices LEDs 8×8, con un MAX7219. Aquí vamos a usar 4

 

Agrupando matrices LED 8×8

 

Cuando montamos el primer tutorial de estas pequeñas matrices LED 8×8 estábamos centrados en montar una colección de tutoriales que pudiera usar, quien tuviera interés, para iniciarse en Arduino y no íbamos sobrados de tiempo para otros menesteres.

Por eso, esperamos que nos disculpéis si se nos fueran quedando cosas en el tintero y nos olvidásemos de tocar algunos temas que sin duda podrían ser de interés, pero que quizás, aquel no era el momento, y así, algunas ideas se fueron quedando fuera.

Pero recientemente un amable lector, nos animó a escribir una sesión en la que usáramos una colección de estas matrices 8×8 basadas en el MAX7219, para mostrar la forma de mover mensajes por la pantalla, haciendo ese desplazamiento (Scrolling) tan típico de displays de LEDs de mayores dimensiones, para informar o anunciar cosas.

Y entonces recordé que esta era una de las aplicaciones más simpáticas de estos displays, y que montar un grupo de ellos en fila podía ser de una cierta utilidad para más de uno de nuestros lectores, y que en su día se quedó fuera, más por falta de oportunidad  que de ganas.

Y por eso, queridos amigos, en esta sesión vamos a intentar reparar tan desafortunada omisión, montando un pequeño ejemplo de cómo podemos usar estos displays con MAX7219 para mostrar mensajes fijos por un lado, y de cómo desplazarlos por la pantalla cuando lo deseéis.

Vamos a montar los ejemplos sencillos de ambos casos y luego, seguro que los seguidores más osados podrán hacer mezclas de ambos a su gusto.

 

Esquema de conexiones

 

Antes de que empecéis a cablear este ejemplo tenéis que entender que os vais a hartar a colocar cablecitos en la protoboard, y además este es uno de esos encantadores casos de que un único cable mal puesto arruinará el circuito, volviéndolo prácticamente inútil. Así que ánimo. Tomaros un tranquilizante y empecemos con calma.

En primer lugar os conviene usar una protoboard larga que os permita acomodar los displays que vais a usar, ( En mi caso 4) y por eso me las he traído al frontal de la protoboard, porque no sobran sitios donde pinchar los cables.

MAX7219

Vamos a empezar colocando la alimentación de las matrices. Tened en cuenta que como vamos a mover el texto hacia la izquierda (Al revés, seria problemático de leer) el display número 1, es el que está más a la derecha (Sorpresa).

Por eso conviene que empecéis cableando desde allí para evitar errores de interpretación. Los displays MAX7219 tienen rotulado en la parte inferior la función de cada pin. Empecemos conectando los pines de Vcc y GND.

El cableado de esta sesión no es complicado, pero si un tanto confuso de presentar en una protoboard con Fritzing, y nada de lo que he visto me ha convencido, así que vamos a usar una representación simbólica de las conexiones, que creo que será más fácil de seguir.

Vamos a empezar uniendo el pin  VCC de cada display al siguiente, y cuando acabéis haced lo mismo con GND ordenadamente.

 
  • Este es uno de esos casos en que es imprescindible ser medio ordenado, porque de lo contrario, es muy improbable que consigáis conectar todos los pines correctamente.
  • Os recomiendo muy seriamente, que uséis cables de colores y os ciñáis a que cada color corresponda a un pin de señal, porque cuando tengáis que revisar porque no funciona (Uy sí. Os va a pasar casi con seguridad) tener un criterio de colores es lo único que nos salvará del desastre.  

Yo he usado los colores habituales, rojos para Vcc y negros para GND. Elegid otro color cualquiera para la señal de CS, en mi caso Azul, unid todos los pines inferiores desde la protoboard de esta señal.

Matriz MAX7219

Ahora hagamos lo mismo con todos los pines de Clock (Amarillo en mi caso) y CS Azul.

Pines Clock + CS

Recordad que estamos usando unos displays que usan el bus SPI, por lo que al unir los CS, que son Chip Select, todos los displays se activarán o apagarán a la vez. Pero también queremos que la información fluya de cada display al siguiente, y para eso los displays tienen otro conector en la parte superior, además del inferior.

La función de estos pines superiores son exactamente los mismos que los de la parte inferior con una excepción, el pin inferior central está rotulado como DIN o Data In, es decir entrada de datos, mientras que el superior hace las funciones de DOUT o Data Out salida.

Por eso hay que usar ahora los cables macho/Hembra para conectar la salida del primer display DOUT1 a la entrada de datos del display 2 DIN2.

 
  • Recordad que el primero es el mas a la derecha según miráis a los displays.
  • Si conectáis empezando desde el de la izquierda no va a funcionar así que ojo.  
Conectando los Data out a los data in

Ya solo falta conectar la cascada a nuestro Arduino. Para ello

Conexion con Arduino

Llevamos los pines de control DIN, CLOCK, CS a los pines 12, 11 y 10 respectivamente, además claro está, de unir VCC y GND. Y con eso dejamos listo el hardware.

 

El Programa de control.

 

Andaba yo pensando en que librería usar para manejar los displays y mira por donde, ya se nos habían adelantado con una librería que hace exactamente lo que queremos y sin complicaciones, así que vamos a tirar de ella directamente (Simplemente por eficiencia y eficacia, no por vagancia, No señor)

Esta Liberia se llama Arduino MaxMatrix library y tiene su propia página en GoogleCode que podéis encontrar en cuanto la busquéis, e incluye un par de  ejemplos de cómo mostrar mensajes estáticos y con desplazamiento lateral que usaremos directamente como base para nuestros programa.

El primer programa mostrará como sacar un mensaje estatico en el conjunto: Prog_39B_1

Lo primero es instalar la librería siguiendo el procedimiento habitual y después podemos empezar nuestro programa con un include, para cargar la librería:

#include <MaxMatrix.h>

Lo siguiente es que como la librería no incluye ningún Font, tenemos que proporcionar el nuestro, algo que ya dominamos y que por si acaso, nos viene dado.

No voy a incluir aquí el array de caracteres (Que veréis en cuanto carguéis el programa) pero si hacer un comentario. Los ejemplos originales incluyen la definición del array de Font como:

PROGMEM prog_uchar CH[] = {…… }

Que aquí hemos cambiado por

const byte CH[] = {…… }

Porque la versión 1.6.4 de Arduino me daba error de compilación y a priori no hay diferencia practica entre ambas expresiones.

 
  • Hay una diferencia importante. PROGMEM es una directiva que indica al compilador almacenar el array de caracteres en la memoria FLASH de Arduino y no en la SRAM más escasa y fácil de agotarse, especialmente si hacéis un programa mayor.
  • Como no me daba problemas he preferido usar la memoria RAM normal para evitar complicaciones, pero nunca se sabe.  

Después tenemos unos valores importantes, las definiciones de los pines de control, y el número de displays que vamos a usar,  y por último creamos una instancia de MaxMatrix para gobernar el conjunto de displays:

int data = 12;
int load = 10;
int clock = 11;

int maxInUse = 4;    //Numero de displays a usar
MaxMatrix m(data, load, clock, maxInUse);

Usaremos un array de char, para contener el mensaje estático que queremos mostrar

char msg[] = "Arduino";

void setup()
   { m.init();                                  // Iniciar el conjunto
     m.setIntensity(15);             // Brillo de los displays. Entre 0 y 15
     printString(msg);                 // Mostrar el mensaje
   }

Aquí tenéis una foto con el resultado:

Array de matrices

No ha estado mal para abrir el apetito, pero aquí el plato principal es hacer desplazarse las letras lateralmente, así que vamos con ello:

Contenido solo disponible para suscriptores. ¡Accede al contenido!

        

Reconoceréis que os esperabais algo mas difícil, pero no. Es la ventaja de usar librerías Adhoc. Cuando hay algo disponible en la puerta serie, lo leemos char a char, y llamamos a la función printCharWithShift () a la que le pasamos el carácter a mostrar y el delay en el desplazamiento de este primer carácter.

Después shiftLeft() desplaza todo el mensaje a la izquierda, al que le pasamos dos bool.

 
  • El primero indica si queremos o no que el mensaje se repita (Aunque funciona fatal) y el segundo es si queremos rellenar de 0s, sea esto lo que sea). No he notado la diferencia.
  • También disponemos de estas otras funciones:

    FuncionParametrosDescripcion
    shiftLeftBool Rotar, RellenoDesplaza a la izquierda
    shiftRightBool Rotar, RellenoDesplaza a la derecha
    shiftUpBool RotarDesplaza arriba
    shiftDownBool RotarDesplaza abajo
 

El programa incluye también un par de funciones de utilidad printCharWithShift()  y printStringWithShift(), a las que no vale la pena dedicar tiempo por ahora, y que podéis usar como cualquier otra función disponible en la librería.

Y esto es todo por ahora. Aquí tenéis un video con el resultado:

 

Resumen de la sesión

 

 

    • Hemos visto, como conectar múltiples MAX7219 en casa cada para montar un display de varios caracteres.
    • Hemos visto , también, como usar estos grupos para hacer scrolling lateral de los mensajes a través del conjunto.
    • Vimos cómo usar la librería MaxMatrix de Arduino para sacar mensajes estáticos.
 

 

 

 

 

 

Para porder realizar consultas a nuestros expertos, tienes que ser suscriptor. Suscribiendote nos ayudas a mantener este proyecto en marcha.

¡ Quiero Suscribirme !

Si ya eres premium y no puedes comentar haz login. Hacer login

(149) Comments

  • El código no me funciona me hace extraños; por ejemplo le introduzco algo por el monitor serial y no pasa nada pero lo hago una segunda vez seguida ya funciona la matriz pero imprime caracteres extraños alguien sabe por que pasa eso (probé el código con 2 matrices y con una y de ambas formas paso lo siguiente)

    • ya logre solucionar el problema solo que me he encontrado con un problema parece ser que la función shiftRight no funciona, no se por que y parece que es un problema algo añejo

    • alguien sabe como se resuelve este problema?

    • Kai

    Como haría si quiero que las letras se muevan de izquerda a derecha

      • Ivan

      Hola Kai, tendrías que usar la función shiftright. Está explicado hacia el final de la sesión. Un saludote.

    • Ferb

    Hola, soy un poco nueva en cuestiones de programación con arduino. Tengo un problema con el printStrig pues me lo marca como una variable no declarada, descargue el primer ejemplo y lo intente cargar tal cual pero me sigue marcando el mismo error. ¿Qué puedo hacer?

      • Ivan

      Hola Ferb, me he descargado por si acaso el ejemplo y compila bien. Has instalado bien la librería Arduino MaxMatrix?

  • Hola, tengo un problema, no tengo estas matrices unidas con el chip en físico, pero estoy tratando de simularlo en proteus, pero no me sale. Será que no se puede simular o será que se tiene que tener en sí la matriz unida con el chip y no tenerlos separados ¿?
    Y otra pregunta, si yo compro el MAX7219 y las matrices por separado, me funcionará igual ¿?

      • Ivan

      Hola Jose, yo no he utilizado proteus pero por lo que veo por ahí sí deberías poder hacerlo. Y sí podrías hacer funcionar la matriz con un chip MAX7219 que no esté integrado con la matriz.

    • Omar Alvarez

    Hola cordial saludo

    Gracias por tu trabajo. Subí el Prog_39B_2, pero no se visualiza el mansaje en las matrices. Si reseteo el arduino algunos led aleatorios encienden y las matrices vuelven a quedar completamente apagadas. Espero me puedas ayudar.

      • Ivan

      Hola Omar, yo comprobaría bien todas las conexiones, porque seguramente venga por ahí el problema.

  • Hola!! he probado los dos programas.mas cambiar los efectos de movimiento y va todo perfecto.
    Tengo una duda,he mirado la hoja de datos del Max7219 y no lo entiendo bien.
    Quiero hacer una matriz pero con leds de 5mm verdes para que sea mas vistoso,y no se si el chip soportara el voltaje para alimentar los led,el amperaje si he visto que soporta hasta 500ma.¿Me podeis aclarar eso?
    Gracias.

      • Admin

      David, el MAX7219 es un chip TTL de 5V, si necesitas mas tension para los led deberias usar algun divisor de tension o mejor aun un step down o buck converter (Tienes un par de sesiones al respecto en la seccion electronica)

    • Alberto

    Gracias Iván, así lo haré.

    Saludos,

    • Alberto

    Buenas tades,
    Antes de nada agradecerte que compartas tus conocimientos con nosotros.
    He seguido tu tuto y he conseguido hacer un letrero que muestra los mensajes en scroll. Pero parece que las cadenas de texto se almacenan en la Ram de arduino y se queda pronto sin memoria. ¿Es posible pasar los String a la memoria Flash del arduino?
    He mirado en internet pero no me ha funcionado nada (o no lo he sabido implementar corectamente).
    Gradezco tu ayuda de antemano.

      • Ivan

      Hola Alberto, lo primero para guardar una variable en la memoria FLASH deberías incluir la librería avr/pgmspace.h en tu programa y después utilizar la instrucción PROGMEM para definir y guardar en la memoria flash las strings que quieras y establecer una tabla con las strings (todo ello como variables globales):

      const char string_0[] PROGMEM = “Saludos”;
      const char string_1[] PROGMEM = “desde”;
      const char string_2[] PROGMEM = “Prometec”;

      const char* const string_table[] PROGMEM = {string_0, string_1, string_2};

      A la hora de recuperar esos datos de la memoria flash tienes que crear una array con la longitud que creas que pueda tener tu cadena más larga, por ejemplo char buffer [10], para volver a sacar las string a la memoria RAM. Finalmente tienes que utilizar la instrucción strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); dentro de un bucle for que vaya recorriendo la tabla que has creado con las strings y te vaya guardando las strings en el buffer que has definido.

      Espero que te ayude. Un saludote!

        • Alberto

        Muchas gracias Iván.
        He intentado implementarlo en el sketch del tuto pero me da conflicto con la variable byte buffer y no compila.

        Te estaría muy agradecido si me pudieses aclarar que pasa. Mi nivel en programción es muy bajo.

        Un saludo.

        /*
        Conexiones del Arduino al Modulo MAX7219:
        ARDUINIO MAX7219
        10 CLK
        9 CS
        8 DIN
        GND GND
        5V VCC

        Conexion de la cascada de MAX7219(1) al MAX7219(2)
        MAX7219(1) MAX7219(2)
        CLK CLK
        CS CS
        DOUT DIN
        GND GND
        VCC VCC
        La cascada se hace conectano de los pines Superiores a los inferiores del modulo MAX7219
        y los modulos se instalan de derecha a izquierda
        */

        #include
        #include

        PROGMEM unsigned char const CH[] = {
        3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
        1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
        3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // ”
        5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
        4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
        5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
        5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
        1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // ‘
        3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
        3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
        5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
        5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
        2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
        4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // –
        2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
        4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
        4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
        3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
        4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
        4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
        4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
        4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
        4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
        4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
        4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
        4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
        2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
        2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
        3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, //
        4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
        5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
        4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
        4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
        4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
        4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
        4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
        4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
        4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
        4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
        3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
        4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
        4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
        4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
        5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
        5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
        4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
        4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
        4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
        4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
        4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
        5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
        4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
        5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
        5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
        5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
        5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
        4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
        2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
        4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
        2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
        3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
        4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
        2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
        4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
        4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
        4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
        4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
        4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
        3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
        4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
        4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
        3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
        4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
        4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
        3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
        5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
        4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
        4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
        4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
        4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
        4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
        4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
        3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
        4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
        5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
        5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
        5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
        4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
        3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
        3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
        1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
        3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
        4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
        };

        //…………………………………………………………//
        const char string_0[] PROGMEM = “String 0”; // “String 0” etc are strings to store – change to suit.
        const char string_1[] PROGMEM = “String 1”;
        const char string_2[] PROGMEM = “String 2”;
        const char string_3[] PROGMEM = “String 3”;
        const char string_4[] PROGMEM = “String 4”;
        const char string_5[] PROGMEM = “String 5″;

        // Then set up a table to refer to your strings.

        const char* const string_table[] PROGMEM = {string_0, string_1, string_2, string_3, string_4, string_5};

        char buffer[30]; // make sure this is large enough for the largest string it must hold

        //………………………………………………………………….//

        int data = 8; // DIN pin del modulo MAX7219
        int load = 9; // CS pin del modulo MAX7219
        int clock = 10; // CLK pin del modulo MAX7219

        int maxInUse = 5; //Cambie este valor dependiendo del numero de matrices que use

        MaxMatrix m(data, load, clock, maxInUse); // Define el modulo

        byte buffer[10];

        char mensaje1[] = ” Dinastia Tecnologica “; //Escriba el mensaje a desplegar
        char mensaje2[] = “Componentes Electronicos para Robotica, Automatizacion, Domotica..”;

        void setup(){
        /………………………………./
        Serial.begin(9600);
        while(!Serial);
        Serial.println(“OK”);
        /………………………………./

        pinMode(8,OUTPUT); //Conexion a DIN
        pinMode(9,OUTPUT); //Conexion a CS
        pinMode(10,OUTPUT); //Conexion a CLK
        m.init(); // inicializa el modulo
        m.setIntensity(1); // intencidad de los puntos de la matriz, entre 1-5
        Serial.begin(9600); // inicializa el puerto serial
        }

        void loop(){
        byte c;
        // Lee el mensaje que llega por el puerto serial
        while (Serial.available() > 0){
        byte c = Serial.read();
        Serial.println(c, DEC);
        printCharWithShift(c, 100);
        }
        delay(100); // Tiempo de inicio de un nuevo Ciclo de mensajes
        m.shiftLeft(false, true);

        // Despliega los mensajes almacenados en las variables

        printStringWithShift(mensaje1, 40); // El ultimo termino se usa para la velocidad del mensaje
        printStringWithShift(mensaje2, 40);

        //……………………………………………..//
        for (int i = 0; i < 6; i++)
        {
        strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Necessary casts and dereferencing, just copy.
        Serial.println(buffer);
        delay( 500 );
        }
        //………………………………………………//
        }

        }

        void printCharWithShift(char c, int shift_speed){ // Imprime caracteres
        if (c < 32) return;
        c -= 32;
        memcpy_P(buffer, CH + 7*c, 7);
        m.writeSprite(maxInUse*8, 0, buffer);
        m.setColumn(maxInUse*8 + buffer[0], 0);

        for (int i=0; i<buffer[0]+1; i++)
        {
        delay(shift_speed);
        m.shiftLeft(false, false);
        }
        }

        void printStringWithShift(char* s, int shift_speed){ // Imprime cadena de caracteres
        while (*s != 0){
        printCharWithShift(*s, shift_speed);
        s++;
        }
        }

        void printString(char* s) // Imprime cadena
        {
        int col = 0;
        while (*s != 0)
        {
        if (*s < 32) continue;
        char c = *s – 32;
        memcpy_P(buffer, CH + 7*c, 7);
        m.writeSprite(col, 0, buffer);
        m.setColumn(col + buffer[0], 0);
        col += buffer[0] + 1;
        s++;
        }
        }

          • Ivan

          Hola Alberto, como veo que el tema tiene su complicación yo creo que lo mejor es que pases el tema a la sección proyectos del foro y nos expliques un poco lo que quieres hacer y te intentamos echar una mano entre todos. Un saludote.

  • descarge el ejemplo del tuto … instale la libreria antes … el mensaje estatico lo logro sin problemas pero cuando descargo el ejemplo 2 hay una linea que no se por que aparece
    #include

    no tengo esa carpeta avr ni el archivo que menciona ?? de que me perdi ese include que hace ??

      • Ivan

      Hola Jorge, el #include sirve para luego poder usar PROGMEM y grabar el array en la memoria FLASH en vez de en la SRAM, que tiene menos capacidad. Un saludote.

      • Admin

      Hola Jorge, no he visto el problema pero el include deberia ser:
      #include

  • hola muy bueno el tuto, pero tengo un error y no creo que mis matrices estan dañadas. lo que pasa es que tengo una matriz de 8×32 con el MAX7219
    pero a todos y todos los que e visto se muestra la palabra a lo largo, mis palabras se pueden leer colocando las matices como columnas. de que manera soluciono ese problema??? saludos y muchas gracias.

      • Admin

      Hola Jonathan, no puede ayudarte mucho porque no he probado tu matriz y seria muy osado opinar en esas condiciones. Me imagino que a pesar de todo se puede toquetear la libreria para invertir filas por columnas o asi

  • Oigan Agregen este caracter

    5, 8, B11101100, B00001010, B00001010, B11101100, B00000000, // =D

    Porfa

      • Admin

      Hola Daniel, te ayuaremos encantados, pero ¿Que es exactamente lo que necesitas?

    • Diana

    Hola admin,

    Excelentes tus explicaciones, gracias a ello he podido llevar a cabo varios proyectos, en este momento quisiera implementar un tetris usando dos matrices, pero no he podido implementar como detener las figuras en la ultima fila, que se apilen.

    agradezco si me puedes ayudar con alguna recomendación.

    gracias

      • Admin

      hola DIana, que proyecta tan interesante. NO se cual es el problema supongo que d eprogramacion del tetris?

    • Nacho

    Buenas,

    En primer lugar muchas gracias por tus tutoriales, vienen de perlas y más para iniciarse como es mi caso,son muy completos. Mi problema es que tengo una matriz 8×32, en realidad son 4 módulos como el tuyo pero unidos horizontalmente. El problema está en que al probar tu código para escribir en estático, pone “Arduino” pero en vertical,es decir, necesitaría rotar todos los caracteres 90º para poder verlo como sale en tu vídeo. Hay alguna manera de hacerlo “fácil”? He pensado en reescribir los códigos para cada carácter,pero tampoco se como hacerlo para que me ilumine el primer led que en código que tu has puesto va marcado con la letra B.

    Cualquier ayuda es bienvenida!Gracias

    • Alex

    Hola admin,
    tengo que usar matrices de dos colores (rojo y verde) con un arduino mega 2560 para programar el juego hundir la flota.
    El problema que tengo es que no consigo por ningun medio que cada matriz me muestre un campo. Lo que me pasa todo el rato es que lo que represento en la matriz 3, me sale reflejado en la 1… 🙁
    Estoy usando 4 martrices bicolor con 2 MAX7219 cada una (1 para cada color).
    He intentado concatenar las 4 y comunicar por SPI, pero no me sale… Tambien he intentado comunicar con 2 y 2 matrices, con la libreria LedControl.

    Me puedes ayudar?
    Muchas gracias.
    Alex

      • Admin

      Hola Alex, me planteas un tema que no e sfacil de responder sin montar un ejemplo y me temo que voy fatal de tiempo. De todos modos, procura montar el ejemplo de los tutoriales porque deberia funcionarte, y si no lo has conseguido te recomiendo que insistas porque esta comprobado

    • Rodrigo Castro Arce

    Hola, agradecemos tus aportes, tiempo y paciencia, para enseñar. quiero resolver una duda que he tratado de solucionar por todos lados y nada. Tengo Arduino Uno R3, y le agregué una placa (shield) FC-16 con 4 Max 7219 EWG, para 4 módulos 8X8. Es decir quiero hacer lo mismo que hiciste, pero sin cascada, para desplazar un mensaje o dos, pero no lo hace de forma horizontal al igual que el tuyo, sino que se ven en los 4 módulos pero verticalmente. Me podrías ayudar por favor. Muchas gracias.

      • Admin

      Hola Rodrigo, te ayudare con gusto en lo que pueda, pero sin tener un shield de esos para probar va a ser dificil.
      ¿Que libreria usas?

  • Hola crack, buenos tutoriales y muy bien explicados, gracias a ti he puesto en marcha un proyecto muy ambicioso con el controlador bluetooth 05 para que se conecte a mi movil y sincronize datos de un reloj-calendario-termometro con leds rgb.

    Es mi primer arduino y me ido a lo complicado, tengo 22 displays de 7 (8) segmentos y ya he preparado la logica del programa probando con unos kingbright rojos de alta luminosidad, el problema es que como lo quiero hacer recomplicado y vistoso no voy a usar displays de 7 (8) segmentos si no que los voy a construir yo gigantes en RGB con acrilico (los segmentos), entonces hechando cuentas si aplico el mismo sistema de multiplexado de 8 pines x numero de digitos me voy a Nmil cables que mi arduino no tiene (2 o 3 leds RGB por segmento), asi que buscando un poco por internet he visto varios tutoriales de como hacen cubos de hasta 10x10x10 leds RGB usando controladores de tipo MAX7219 (lo que me ha llevado hasta aqui), asi que despues de ponerte en contexto me gustaria saber si puedes ayudarme a elegir el IC apropiado para tan ingente cantidad de leds por que veo que para pintar los 22 digitos que quiero pintar por 7 segmentos que tiene cada uno por 2 o 3 leds RGB que tendra cada segmento quiza el MAX del tutorial se quede un poco pequeño (necesitaria como unos 8) por que aparte de iluminar los digitos en si hay mas leds para indicar los dias y nombre de la semana.

    Cualquier otra sugerencia sera muy bien recibida, muchas gracias y felicidades por la web.

      • Admin

      !!Aupa ahi¡¡, asi me gusta, sin miedo. No estoy seguro si quieres usar los RGBs de forma analogica para conseguir cualquier tono de color o mas bien para conseguir combinacione digitales de los tonos, es decir pasando valores de 0 o 1 a los pines de color

  • Hola muy buena información, tengo un problema, tengo una baquela con estos mismos componentes pero vienen unidos verticalmente entonces cambie los datos del array para hacer que las letras queden bien, pero al hacer el scroll no logro hacer que se desplaza horizontalmente osea para el ejemplo del tutorial seria como un desplazamiento vertical. no se si me hice entender, agradezco su ayuda

      • Admin

      Hola Yelsson, no tengo claro si esta libreria permite el scroll vertical o solo el horizontal me temo pero seguro que habra alguna otra corriendo por internet que valga

      • me he dado cuenta que el scroll vertical no me sirve porque no va tomar los 4 display en vertical, parece mas facil hacer la libreria, pero el verdadero problema radica en que tengo que pintar por fila en vez de columna. voy a ver como puedo crear arrays para cada fila a partir de los arrays de cada columna que hay, si alguien tiene alguna sugerencia o ayuda, lo agradeceria

      • Ferb

      Hola, creo que tengo el mismo problema con los datos del array, pero no sé cómo hacer para que no se vean de costado. ¿Cómo lo solucionaste?

    • Jose

    Para Jaume:
    Prueba con este código y comentas si se repite indefinidamente.

    #include
    #include

    const char CH[] PROGMEM= {
    3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
    1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
    3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // ”
    5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
    4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
    5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
    5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
    1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // ‘
    3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
    3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
    5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
    5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
    2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
    4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // –
    2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
    4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
    3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
    4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
    4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
    4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
    4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
    4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
    4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
    4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
    4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
    2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
    2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
    3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, //
    4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
    5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
    4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
    4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
    4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
    4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
    4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
    4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
    4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
    4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
    3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
    4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
    4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
    4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
    5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
    5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
    4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
    4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
    4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
    4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
    4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
    5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
    4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
    5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
    5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
    5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
    5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
    4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
    2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
    4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
    2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
    3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
    4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
    2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
    4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
    4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
    4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
    4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
    4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
    3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
    4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
    4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
    3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
    4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
    4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
    3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
    5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
    4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
    4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
    4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
    4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
    4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
    4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
    3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
    4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
    5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
    5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
    5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
    4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
    3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
    3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
    1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
    3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
    4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
    };

    int data = 11; // 8, DIN pin of MAX7219 module
    int load = 10; // 9, CS pin of MAX7219 module
    int clock = 13; // 10, CLK pin of MAX7219 module

    int maxInUse = 5; //change this variable to set how many MAX7219’s you’ll use

    MaxMatrix m(data, load, clock, maxInUse); // define module

    byte buffer[10];

    // active sentenses
    char string1[] = ” Hello, my name is Marcelo Moraes and… “;
    char string2[] = ” I am glad to show you my Arduino scrolling dot Matrix “;
    char string3[] = ” using MAX7219 IC “;
    char string4[] = ” Visit my blog at: http://arduinobymyself.blogspot.com.br “;
    char string5[] = ” There you will find a lot of projects with Arduino. “;
    char string6[] = ” Thanks for watching =) “;

    // just for tests
    char string7[] = ” A B C D E F G H I J K L M N O P Q R S T U V X W Y Z “;
    char string8[] = ” a b c d e f g h i j k l m n o p q r s t u v x w y z “;
    char string9[] = ” 1 2 3 4 5 6 7 8 9 0 – = “;
    char string10[] = ” ! @ # $ % ¨ & * ( ) _ + “;
    char string11[] = ” ‘ , . ; ~ ] ´ [ | : ^ } ` { / ? “;

    char string12[] = ” Hello ! “;

    void setup(){
    m.init(); // module initialize
    m.setIntensity(0); // dot matix intensity 0-15
    Serial.begin(9600); // serial communication initialize
    }

    void loop(){
    byte c;
    // this is the code if you want to entering a message via serial console
    while (Serial.available() > 0){
    byte c = Serial.read();
    Serial.println(c, DEC);
    printCharWithShift(c, 100);
    }
    delay(100);
    m.shiftLeft(false, true);

    // 1st block – print the active sentences
    // comment this block when using the 2nd messages block

    printStringWithShift(string1, 100);
    //printStringWithShift(string2, 100);
    //printStringWithShift(string3, 100);
    //printStringWithShift(string4, 100);
    //printStringWithShift(string5, 100);
    //printStringWithShift(string6, 100);

    // 2nd block – print sentences just for tests
    // uncomment this block to use it
    /*
    printStringWithShift(string7, 100);
    printStringWithShift(string8, 100);
    printStringWithShift(string9, 100);
    printStringWithShift(string10, 100);
    printStringWithShift(string11, 100);
    */
    }

    void printCharWithShift(char c, int shift_speed){
    if (c < 32) return;
    c -= 32;
    memcpy_P(buffer, CH + 7*c, 7);
    m.writeSprite(maxInUse*8, 0, buffer);
    m.setColumn(maxInUse*8 + buffer[0], 0);

    for (int i=0; i<buffer[0]+1; i++)
    {
    delay(shift_speed);
    m.shiftLeft(false, false);
    }
    }

    void printStringWithShift(char* s, int shift_speed){
    while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
    }
    }

    void printString(char* s)
    {
    int col = 0;
    while (*s != 0)
    {
    if (*s < 32) continue;
    char c = *s – 32;
    memcpy_P(buffer, CH + 7*c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
    }
    }

    • Jaume

    Hola de nuevo, admin, parece mentira, pero sigo peleándome con la matrix, bueno, con la matriz no, porque funciona perfectamente, pero con el programa… A ver, un par de cosas:

    1.- Quería que el mismo texto que se escribe una vez, se repitiera indefinidamente. Comentando el tema con Jesús, me apuntó que para que se repitiera el mensaje, bastaba con cambiar, en m.shiftLeft(false, true); por m.shiftLeft(true, true);, pero en el tuto indicas que funciona fatal. Lo probé, y ciertamente lo repite, pero el mensaje sale íntegro la primera vuelta, y solo una parte del final en la segunda y sucesivas.
    Por ejemplo, escribo “Esto es lo que hay”, en la primera vuelta sale correcto y, a partir de la segunda, solo sale ” Ie hay, Ie hay, Ie hay…” (el “Ie” es el último palo de la u, de “que”).
    He probado de ponerle un texto moderadamente más largo, y lo muestra bien, pero repite el mismo error (solo salen las últimas palabras del texto), a partir de la segunda vuelta.
    Te referías a este error cuando dices que funciona fatal? Parece que el problema podría estar en que no “recuerda”, no almacena el texto, y se limita a repetir lo último (problema de buffer?)?

    2.- Como he leído más arriba (y después de pelearme con la construcción de las letras, y con la ayuda de San Jesús), sustituyendo los códigos de un símbolo por los de la letra que quiero incluir, funciona, pero solo si clico el símbolo original, es decir, si el código es para la letra “Ç” y lo he sustituido por el de “$”, por ejemplo, para que escriba la “Ç”, debo clicar sobre “$”
    Me indica Jesús que se debe a los códigos ASCII, pero no se localizar cómo se debería modificar para que aparezca la letra que quiero, clicando sobre la auténtica.

    Ya imagino que tal vez en este espacio es pedir demasiado que lo expliques, pero puedes indicarme alguna pista sobre que debería buscar en San Google que explicara cómo incluir/eliminar símbolos y/o letras del array del programa en cuestión? El array tiene un número limitado de caracteres, y por eso no permite añadir nuevos códigos? Estos caracteres, que vienen del ASCII, como se gestionan para localizarlos, descifrarlos e incluirlos en el array?

    Solo que me indicaras por donde buscar estos dos temas, ya me daría por satisfecho.

    Gracias, Admin, no sabes como aprendo con tus magníficos tutos…

    salu2

      • Admin

      Hola Jaume, SI vas a documentos\arduino libraries y vas al directorio correspondiente a la libreria que estas usando, la definicion de los caraecteres esta en alguno d esos ficheros con extension .c .cpp o .h

      Hay que editarlos y revisar a ver donde estan las definicones de las matrices de caracteres y cambiar ahi

    • Jair

    hola que tal, me gustaria crear un mensaje con 3 arduino, que el mensaje se desplace solo, (mensaje ya insertado en el programa), y he intentado de varias formas incluso reciclando programas pero aun no puedo, me podrias ayudar porfavor

      • Admin

      Jair, te ayudaré con gusto si me das algun detalle mas preciso

Para porder realizar consultas a nuestros expertos, tienes que ser suscriptor. Suscribiendote nos ayudas a mantener este proyecto en marcha.

¡ Quiero Suscribirme !

Si ya eres premium y no puedes comentar haz login. Hacer login