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ña Tienda 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:

    Funcion Parametros Descripcion
    shiftLeft Bool Rotar, Relleno Desplaza a la izquierda
    shiftRight Bool Rotar, Relleno Desplaza a la derecha
    shiftUp Bool Rotar Desplaza arriba
    shiftDown Bool Rotar Desplaza 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

  • Avatar for Charly

    Oigan Agregen este caracter

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

    Porfa

  • Avatar for Charly
    • Admin

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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • 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?

  • Avatar for Charly
    • 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.

  • Avatar for Charly
    • 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

  • Avatar for Charly

    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.

  • Avatar for Charly

    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

  • Avatar for Charly
    • 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

  • Avatar for Charly

    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

  • Avatar for Charly
    • 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++;
    }
    }

  • Avatar for Charly
    • Admin

    Pues no se decirte que es este error. Parece algun problema de referencias. ¿Que version del IDE usas, jair?

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • Admin

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

  • Avatar for Charly
    • 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

  • Avatar for Charly
    • Jair

    hola que tal, tengo un problema con este error
    exit status 1
    ‘printCharWithShift’ was not declared in this scope

    me podrian yudar porfavor

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