# Cómo Construir Un Letrero Matricial De LEDs



## Shawn (Mar 23, 2011)

[size=+2]Cómo Construir Un Letrero Matricial De LEDs[/size]

Un panel matricial es uno de los proyectos más atractivos en el mundo de la electrónica. Su elaboración puede ser sencilla por su funcionamiento, aunque algo complicada por la implementación del hardware.




En esta oportunidad aprenderemos a diseñar un panel de 8 filas y de 64 columnas, es decir, de 512 LEDs, pero verás que ampliar o reducir el tamaño será tan simple como añadir o quitar registros en el hardware o cambiar un solo número en el software.

Este es el primer artículo que escribo para forosdeelectronica pero espero publicar otros periódicamente, ya no pensando en los PIC sino en los AVR.

[size=+2]El hardware[/size]

Sabemos que para encender un LED necesitamos de una señal de control, aparte de la alimentación (Vcc o GND), ¿cierto? Con esto en mente deberíamos suponer que para un letrero de 515 LEDs se necesitarían de 512 señales saliendo del microcontrolador, más o menos como en la siguiente figura:




Pero no es así. Podemos resolver parte de este problema multiplicando las señales del microcontrolador con ayuda de dispositivos como multiplexores, decodificadores o registros serie-paralelo como el 74164, 74595 o el CD4094. Los dos últimos son muy parecidos y son a la vez mejores que los primeros porque cuentan con doble buffer. Uno para almacenar internamente los datos seriales que van ingresando al registro y otro que se conecta al exterior. Más adelante veremos los beneficios de esta arquitectura.

Todos estos registros son de 8 bits pero tienen la característica de poder ser montados en cascada para multiplicar sus salidas. Por ejemplo, en la siguiente figura se muestra cómo conectar varios registros 74595 en cascada. Se pueden ir añadiendo tantos registros como salidas paralelas se desee.




Por otro lado, si nos basamos solo en este mecanismo para ampliar nuestras señales, para controlar los 512 LEDs tendríamos que usar 512/8 = 64 registros de 8 bits, lo cual nos llevaría a un circuito muy difícil de implementar además de bastante costoso. La técnica para salvar este segundo inconveniente es un artificio que consiste en encender grupos de LEDs en tiempos diferentes pero con la suficiente frecuencia como para dar la impresión de que estuvieran encendidos todos al mismo tiempo.

Obviamente, en un letrero matricial los LEDs quedan mejor agrupados en filas y/o columnas. En la siguiente figura los ánodos de los LEDs se unen formando las columnas y los cátodos se unen formando las filas (rows). También se puede armar una configuración alternativa invirtiendo la polaridad de todos los LEDs. En ese caso los transistores serán de tipo PNP.




Los valores de las resistencias R1 a R64 dependen de la corriente que tiene que fluir por los LEDs, la cual a su vez depende de los mismos LEDs. Hay que tener en cuenta que los LEDs no estarán prendidos al 100 % sino la octava parte (por las ocho filas) y también que la corriente promedio no siempre es proporcional al brillo del LED prendido, es decir, que un LED esté prendido la octava parte no significa que vaya a brillar ocho veces menos

Por otro lado, los transistores deben tener la capacidad de controlar la corriente proveniente de todos los LEDs de cada fila. En algunos casos bastará con usar el ULN2803.

[size=+2]Los barridos[/size]

Una vez estructurado el hardware de la matriz de LEDs nos damos cuenta de que podemos encender los LEDs que queramos de cualquier fila o de cualquier columna simplemente activando las coordenadas de dichos LEDs. Por ejemplo, si queremos prender los LEDs de las columnas 0, 3, 4, 7 y 63 de la fila 5 se vería así:




Sin embargo, no es posible encender varios LEDs que pertenezcan a diferentes filas y diferentes columnas al mismo tiempo. Es aquí donde entra a jugar el software.

Por ejemplo en la siguiente animación se muestra como para visualizar la letra G se encienden los LEDs correspondientes pero en tiempos diferentes.




La primera figura muestra la secuencia del barrido en cámara lenta pero en la práctica los barridos serán tan rápidos que los LEDs se verán como en la segunda figura.

[size=+2]Los caracteres[/size]

De lo visto anteriormente queda claro que encendiendo los LEDs convenientemente podemos formar en el letrero la figura que deseemos. Será el microcontrolador quien de acuerdo con su programa se encargue de generar los barridos activando las filas y columnas adecuadamente según un patrón establecido. Este patrón corresponde a letras, figuras o números que queramos y se puede estructurar de diversas formas.

Vamos a representar el patrón con una matriz de datos, donde cada dato represente una columna del panel de LEDs. De esta forma, si asignamos un 0 a un LED apagado y un 1 a un LED prendido, podemos establecer a partir de cada columna un byte de dato. Luego podremos agrupar ordenadamente todos estos datos y escribirlos en un formato conocido.




Por ejemplo, para el pequeño texto de arriba la matriz escrita en lenguaje C quedaría algo así:

```
const char matrix[] = {0x00, 0xFF, 0x10, 0x28, 0x44, 0x82, 0x00, 0xFF, 0x11, 0x31, 0x51, 0x8E, 0x00, 0x00, 0x00};
```
Esta matriz puede tener cualquier nombre pero de aquí en adelante me referiré a ella como matrix.

[size=+2]Generación automática de matrix[/size]

Ya vimos que para generar nuestra matrix que se visualizará en el panel de LEDs hace falta conocer el sistema binario y/o hexadecimal. Pero para quienes no tengan la paciencia de componerla manualmente sobre todo si quieren experimentar con textos grandes, les presento una de varias herramientas que encontré en Internet. Se llama LCD font maker y, aunque fue diseñado para componer patrones de caracteres o gráficos para displays LCD o GLCD, también nos servirá para nuestro panel de LEDs. Su uso es bastante fácil de descubrir, así que no entraré en muchos detalles. Los pasos que debemos seguir son:


Presiona el botón *Choose font* y escoge la fuente que desees. Yo escogí Verdana-Negrita-11 porque he visto que produce un tipo de letra que se ajusta bien a la altura del letrero. Puedes probar por tu cuenta para ver otros resultados.





En *Char input* ingresa el texto que mostrará tu letrero; Yo dejé unos espacios al principio para que el texto empiece a aparecer desde el costado derecho. Con "*Offset*" puedes centrar y ajustar vertical y horizontalmente el patrón del texto. Hay que establecer "*Height*" (altura) a 8 y "*Width*" (ancho) lo ajustamos hasta que cubra todo el texto, en mi caso fue de 230.





Ahora presiona el botón "*Step 2: open the fonts dialog parameters*" y en la ventana que se abre escoge los parámetros que indica la siguiente figura.





Presiona el botón "*Step 3: Making a single fonts with the current graphics*" para generar la matriz hexadecimal. El resultado aparecerá como se muestra en la siguiente figura. Puedes seleccionarlo y copiarlo manualmente o mediante el botón "*Copy all*".





Guarda la matriz generada para usarla en el código fuente. Esta matriz está por defecto declarada como "*unsigned char code Bmp001*" pero lo cambiaremos luego.

[size=+2]El código fuente[/size]

La elaboración del código dependerá de varios factores, como el tamaño del panel, la forma cómo se presenta el texto (efecto), la longitud de los mensajes, de si los mensajes son estáticos o si se programan en tiempo de ejecución, etc. En esta práctica el panel solo muestra un mensaje en desplazamiento.

Por tanto el código fuente será muy simple y se podrá adaptar para compilarlo para cualquier microcontrolador. Yo ya estoy harto de usar los PICs pero veo que siguen siendo los más populares, así que lo volveré a hacer. Usaré el PIC16F84A porque es el más fácil de conseguir.
´
El código está hecho en lenguaje C y se compila con BoostC. Una limitación de este compilador es que las matrices constantes (en rom) admiten como máximo 256 bytes.

Si se presentan los suficientes interesados, también podría escribir una versión en lenguaje ensamblador y hasta en Basic, pero confío en la extensa explicación de este código y creo que eso no hará falta.


```
1   
2   // ***************************************************************
3   // ***              Letrero matricial V1.0                     ***
4   // ***             Written By Shawn Johnson                    ***
5   // ***            Website: www.cursomicros.com                 ***
6   // ***        Compiled for PIC16F84A with BoostC compiler      ***
7   // ***************************************************************
8
9   #include <system.h>
10
11  #pragma DATA _CONFIG, _CP_OFF & _PWRTE_ON & _WDT_OFF & _HS_OSC
12  #pragma CLOCK_FREQ 10000000
13
14  #define DS      porta.0     // 74595 serial data input
15  #define SH_CP   porta.1     // 74595 shift register clock input
16  #define ST_CP   porta.2     // 74595 storage register clock input
17
18  #define WIDTH       64      // LED panel width
19
20  rom char * matrix = // El contenido de esta matrix se puede reemplazar
21  {
22  /*------------------------------------------------------------------------------
23  ; Source file / text :               www.cursomicros.com
24  ; Width x Height (pixels) :230X8
25  ------------------------------------------------------------------------------*/
26  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
27  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
28  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
29  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x1F,0xFC,0xE0,
30  0x7C,0x0F,0x0F,0x7C,0xE0,0xFC,0x1F,0x03,0x00,0x03,0x1F,0xFC,0xE0,0x7C,0x0F,0x0F,
31  0x7C,0xE0,0xFC,0x1F,0x03,0x00,0x03,0x1F,0xFC,0xE0,0x7C,0x0F,0x0F,0x7C,0xE0,0xFC,
32  0x1F,0x03,0x00,0x00,0xE0,0xE0,0x00,0x00,0x3C,0x7E,0xC3,0x81,0x81,0x81,0x42,0x00,
33  0x7F,0xFF,0x80,0x80,0x80,0x40,0xFF,0xFF,0x00,0xFF,0xFF,0x02,0x03,0x03,0x03,0x00,
34  0x4E,0x9F,0x99,0x99,0x99,0xF9,0x72,0x00,0x3C,0x7E,0xC3,0x81,0x81,0xC3,0x7E,0x3C,
35  0x00,0xFF,0xFF,0x02,0x01,0x01,0xFF,0xFE,0x02,0x01,0x01,0xFF,0xFE,0x00,0x00,0xFF,
36  0xFF,0x00,0x00,0x3C,0x7E,0xC3,0x81,0x81,0x81,0x42,0x00,0xFF,0xFF,0x02,0x03,0x03,
37  0x03,0x00,0x3C,0x7E,0xC3,0x81,0x81,0xC3,0x7E,0x3C,0x00,0x4E,0x9F,0x99,0x99,0x99,
38  0xF9,0x72,0x00,0x00,0xE0,0xE0,0x00,0x00,0x3C,0x7E,0xC3,0x81,0x81,0x81,0x42,0x00,
39  0x3C,0x7E,0xC3,0x81,0x81,0xC3,0x7E,0x3C,0x00,0xFF,0xFF,0x02,0x01,0x01,0xFF,0xFE,
40  0x02,0x01,0x01,0xFF,0xFE,0x00,
41  };
42
43  const unsigned int LEN = 230;	// sizeof(matrix);
44
45  void main()
46  {
47      unsigned int bad;   // Base index
48      unsigned int idx;   // Index
49      unsigned char dato; // dato
50      unsigned char row;  // Fila
51      unsigned char col;  // Columna
52      unsigned char i;
53
54      trisa = 0x00;       // Configurar puertos A
55      trisb = 0x00;       // y B como salidas
56
57      porta = 0x00;       // Inicializar puertos A
58      portb = 0x00;       // y B a 0x00
59	
60      while(1)            // Bucle infinito
61      {
62          for(bad=0; bad<LEN; bad++)  // Bucle para LEN "frames"
63          {
64              for(i=0; i<8; i++)      // Bucle de 8 barridos por "frame"
65              {
66                  for(row=1; row; row<<=1)    // Cada barrido pasa por las 8 filas  (23288 ciclos)
67                  {
68                      for(col=WIDTH; col; col--)  // Cada fila iene WIDTH columnas (2911 ciclos)
69                      {
70                          idx = bad + col - 1;    // Calcular índice de elemento en matrix
71
72                          if(idx < LEN)           // Si está dentro del rango
73                              dato = matrix[idx]; // Extraer dato
74                          else
75                              dato = 0x00;        // si no, asumir 0x00
76  
77                          if(dato & row)          // Si el bit de row es 1
78                              DS = 1;             // colocar 1 en DS
79                          else
80                              DS = 0;             // o, colocar 0
81
82                          SH_CP = 0;              // 
83                          SH_CP = 1;              // Pulso de reloj para
84                          SH_CP = 0;              // validar el dato colocado
85                      }
86                      portb = 0x00;               // Desactiva todas las filas temporalmente
87
88                      ST_CP = 1;                  // Pulso para sacar todos 
89                      ST_CP = 0;                  // los datos cargados
90  
91                      portb = row;                // Activar la fila actual
92                  }
93              }
94          }
95      }
96  }
97
```

[size=+2]Descripción del programa[/size]


La línea 9 incluye el archivo system.h, propio del compilador BoostC.


La línea 11 establece los fuses o Bits de Configuración. Son 4 para el PIC16F84A  y pueden ser más si se usa otro PIC.


La línea 12 establece la frecuencia a tomar en cuenta para generar las funciones de delay, si se usan.


La línea 14 define con el nombre DS el pin porta.0 (RA0) del PIC. Este será el pin por donde se sacarán los datos serialmente y se depositarán en los registros 74595.


La línea 15 define con SH_CP el pin RA1 del PIC. También debe ir conectado a los pines SH_CP de los registros 74595.


La línea 16 define con ST_CP el pin RA2 del PIC. Debe ir conectado a los pines ST_CP de los 74595.


La línea 18 define la constante WIDHT (ancho) como 64. Este es el ancho del panel y lo puedes cambiar si en tu diseño es mayor o menor.


Las líneas 20 a 41 declaran la matriz llamada matrix que contiene el patrón del mapa de bits que se visualizará en el panel de LEDs. Puedes reemplazar el contenido hexadecimal por los datos de tu mensaje que generaste hace dos apartados.


La línea 43 declara la constante LEN como el tamaño de matrix. Este dato aparece con el nombre Width en los comentarios de la matriz generada automáticamente.


Las líneas 47 a 52 declaran las variables bad, idx, row, col,  i y dato.


Las líneas 54 a 55 configuran los puertos A y B como salidas.


Las líneas 57 a 58 inicializan los puertos a 0x00.


La línea 62 es un bucle for cuyo contenido se ejecutará LEN veces. ¿Para qué?
Un panel matricial puede mostrar contenido de diferentes formas según lo programemos. El efecto que realiza el código presentado es visualizar un texto que se desplaza de derecha a izquierda, el más esperado. Este efecto se consigue visualizando secuencialmente diferentes segmentos  o bloques de datos de matrix.

En la siguiente figura LEN es la longitud de matrix, cuyo contenido completo se mostrará en desplazamiento, y WIDTH es la longitud del panel de LEDs, en mi diseño vale 64 pero ya vimos donde modificarlo.




Si llamamos frame a la visualización en el panel de cada segmento de datos de matrix, ¿cuántos frames tendrá que haber para ver el texto desplazado por completo? La respuesta es LEN porque el contenido se desplaza una columna de LEDs cada vez.
Así que ya sabemos que el primer bucle for sirve para ejecutar LEN frames.


La línea 64 es otro bucle for. Este bucle cuenta 8 ciclos porque cada frame se forma con 8 barridos de filas de LEDs. A mayor cantidad de barridos más lento será el desplazamiento del contenido.


La línea 66 es el bucle for que se encarga de ejecutar los barridos. En cada barrido se activan las 8 filas del panel, una a continuación de otra. Row (fila) empieza en 1 (LSbit) y en cada ciclo se desplaza un bit a la izquierda gracias al operador <<.


La línea 68 es un bucle for para serialmente cargar todos los registros 74595. Todos estos registros juntos y en cascada se comportan como un "mega-registro" serie-paralelo de WIDTH bits, es decir que sacarán en paralelo y al mismo tiempo los WIDTH bits que hayamos cargado serialmente.
Este bucle se ejecuta WIDTH veces pero con la variable col avanzando en modo descendente. Esto es porque los primeros bits en salir deberán ir a los registros que controlan las últimas columnas del panel de LEDs.


La línea 70 calcula la posición del dato de matrix que se extraerá. En cada frame se empieza desde el elemento número bad y se toman los datos subsiguientes según el valor de col. Por eso la suma bad + col. Se resta 1 para compensar que col no llega a 0, sino hasta 1.


La línea 70 empieza una sentencia if-else que evalúa si idx corresponde a un elemento de matrix. De ser así se extrae el dato, de lo contrario se asumirá que el dato es 0x00. Esto servirá para que al finalizar su desplazamiento el texto el texto siga su recorrido mostrando columnas vacías (0x00) en vez de terminar súbitamente.


La línea 77 empieza una sentencia if-else que evalúa si el bit que marca row es 1 ó 0 para colocar dicho bit en el pin DS, el cual está conectado a la entrada serial de datos de nuestro "mega-registro".


La líneas 82 a 84 generan un pulso en el pin SH_CP del PIC. Este debe ir conectado a todos los pines SH_CP de todos los registros 74595. Este pulso de reloj servirá para que el bit de dato presente en las entradas de los registros ingresen en ellos. Los datos se irán almacenando en los buffers internos de los registros, un bit por pulso de reloj.


Las líneas 88 a 89 generan un pulso en el pin ST_CP, que está conectado a todos los pines ST_CP de los registros 74595. Mediante este pulso todos los datos que ingresaron serialmente y que están almacenados en los buffers internos salgan a los pines paralelos externos de los registros 74595 al mismo tiempo.


La línea 91 activa la fila correspondiente del barrido.


Como el bucle más interno se ejecuta en 982us, cada barrido se completa en 7,86 ms (7908 en la práctica) y como cada frame tiene 8 barridos, durará cerca de 60ms. En consecuencia, la imagen del panel se desplaza una columna de LEDs cada 60ms. Para medir estos tiempos puedes utilizar el Stopwatch de MPLAB o el Counter/Timer de Proteus.

[size=+2]La simulación[/size]

Dudo que todos los lectores de este artículo consigan implementar en la práctica real un letrero matricial completo debido a la relativa complejidad del hardware, pero creo que al menos podrán ver su diseño en una buena simulación gracias a Proteus.

Debemos notar que para la simulación en Proteus no es necesario armar el circuito completamente. Para este diseño por ejemplo he ignorado las resistencias y los transistores de las columnas y filas del panel.

Se puede (o debe) editar el parámetro Minimum Trigger Time de las matrices de LEDs para mejorar la visualización de los LEDs sobre todo si se cambia la frecuencia del XTAL.

El realismo de simulación también dependerá de la potencia de ordenador. En ordenadores lentos el contenido del panel se desplaza más lentamente, aunque se puede mejorar la animación modificando algunos parámetros, como la cantidad de barridos por frame en el código fuente, solo para fines de la simulación.




[size=+2]Descargas[/size]

En el siguiente enlace podrás encontrar todos los archivos relacionados con esta práctica: el circuito, el código fuente, el archivo .hex, el archivo .cof, el archivo .dsn para Proteus y hasta un diseño que trabaja con un microcontrolador AVR.
Descargar archivos

Y así, amigos, hemos llegado al final de este artículo. Si tienen comentarios o inquietudes al respecto, no duden en escribirlos. Hasta la próxima.


----------



## snakewather (Mar 24, 2011)

MUY buena informacion para hacer uno para mi puerta jejeje.

el Programa que te genera el letrero es libre?


----------



## Shawn (Mar 25, 2011)

Todos los programas usados en este proyecto son son comerciales, pero las versiones demo son suficientes (excepto Proteus) y para fines no comerciales.


----------



## SERGIOD (Mar 25, 2011)

Genial se ve interesante voy a descargar los archivos adjuntos y le doy una leida


----------



## Shawn (Mar 25, 2011)

Para la versión con el microcontrolador AVR he usado el ATtiny2313, pero parece que olvidé subirla. Lo haré lo más pronto posible. Por ahora tengo que dejar el foro. No olviden dejar sus opiniones. Saludos.


----------



## jreyes (Mar 25, 2011)

Se ve muy bueno.

Muchas gracias !


Adiosín...!


----------



## tecnogat (Mar 25, 2011)

Woow se lee tan facil jajaja, voy intentar mi letrero para mi negocio jajaja. Gracias por el curso intensivo, andaba buscando algo asi desde hace un tiempo...


----------



## Mikepower (Mar 26, 2011)

Hola a todos... soy nuevo en el foro y me ha gustado mucho, en verdad los felicito es muy interesante todo lo que ustedes saben.
Ya tiene tiempo que no veo mucho de electrónica aunque estudie precisamente electrónica, voy a intentar armar un letrero a ver que tal funciona, gracias por toda la información que ustedes proporcionan es muy alentador saber que aqui hay gente muy preparada y dispuesta a compartir sus conocimientos
Saludos desde Queretaro, México


----------



## arias887 (Mar 26, 2011)

Esto esta muy interesante...
Shawn, no te imaginas hace cuanto estaba buscando algo como esto, lo digo por el programa LCD blablabla....

y te lo agradesemos mucho...

Ahora la cosa es que yo tengo el CCS C PIC C, y me puse a hacerlo ay, el mismo ejemplo tuyo, y despues de mucho pelear con el, logre desacerme de los cientos de errores que me salieron XD...
pero sigo con unos cuantos errores y son que no me deja configuar los tris a y b...

En ese programa se ponen asi:

set_tris_a (0x00);     ó (0b00000);
set_tris_b (0x00);     ó (0b00000000);

y me sale el error: 
"error 28= expecting an identifier"
"error 43= expecting an declaration" 
"error 84= expecting a ("
Para ambos

y si le dejo ambos pares de () y le quito los ;, me sales los 2 errores 28...
y si le quito ambos pares de () y le dejo los ;, me salen los 2 errores 43 y 48...
y si le quito ambos pares de () y tambien los ; me salen los 2 errores 48...
X_x...

Ya llevo casi 3 horas dandole a eso y ya son las 5:30a.m. y nada...
Si me puedes ayudar te lo agradeceria mucho...
despues te doy mas detalles si es necesario...


----------



## arias887 (Mar 27, 2011)

Y lo otro que se olvido poner en el mensaje anterior...

Es que cuando finalizo el 3° paso en el LCD front maker, me sale una linea que atraviesa todo el texto, como si lo seleccionara en tachado, cosa que no hago, y no se porque es eso...
adjunto la imagen para que la vean...

y si pueden porfavor ayudenme...


----------



## Shawn (Mar 29, 2011)

Hola muchachos, lamento mucho no haber podido contestar antes. Pero aquí estoy de nuevo.
Bueno:

*jreyes*, me alegro de que te haya gustado el proyecto.

*tecnogat*, no es una mala idea realizar este tipo de letreros como medio publicitario. De hecho, funciona tan bien que muchos se dedican a la fabricación y comercialización de estos letreros.

*Mikepower*, para eso estamos. Si tienes alguna inquietud en tu emprendimiento no dudes en consustar.

*arias887*. Por lo que veo, tú sí que estás avanzando en el proyecto. Luego les envío el proyecto hecho en versión CCS PICC. Y sobre tu segunda pregunta: ya *snakewather* había preguntado antes sobre si los programas usados son libres o no. De inmediato revicé las limitaciones de las versiones demo y vi que en el caso del* LCD Font Maker* la limitación era eso: decía que los patrones generados saldrían tachados en el demo. A mi me pareció raro porque, como habrán visto, a mí me salió todo bien.
Recuerdo que en una de mis tantas pruebas me salió algo como lo que mencionas pero creí que era algún error trivial y cuando lo volví a intentar me salió todo bien.

Sigan comentando muchachos. Solo espero poder disponer del suficiente tiempo para contestar. Y no olviden poner estrellitas 

Programa en CCS Picc.

PD: no lo he probado pero es tan simple que creo que funcionará.


----------



## samigoro (Mar 29, 2011)

saludos colegas, muy buen trabajo, de inmediato me pongo a investigar y desarrollar los trabajos...
gracias por el buen aporte Shawn.


----------



## miborbolla (Mar 29, 2011)

Buen desarrollo, yo habia utilizado desde siempre el arreglo de los 74ls595, como para expander mis microcontroladores ya que puedes poner tantos 74ls595 como se deseen, pero nunca tuve la necesidad como la que se explana en este Post. Ya realice unas pruebas utilizando los Arreglos de leds "GM-12057CSB" que se consigue facilmente en el centro de la ciudad de mexico por unos 3 dolares americanos (35 pesos mexicanos) y que es con Catodo comun por renglon, que es como el arreglo que nos presenta el compañero Shawn.

Gracias por compartir este projecto, que es mas que ilustrativo el poder del lenguaje "C" y la electronica digital bien aplicada.

Saludos


----------



## arias887 (Mar 30, 2011)

Shawn gracias, lo de la raya ya lo solucione, hay que poner en "height" no 8 si no 18 y el tamaño de la letra=8, para que la raya esa salga por  debajo del texto y quedaria asi "arias887" luego en el progama donde al final quedan todo ese pocoton de "0x00", hay que elimiar los tres anteriores a esos para que en la visualizacion no te queden 3 punticos detras del texto asi (arias887°°°) me explico...

este es el codigo que genero para "arias887" con la rraya por de bajo abajo:

-----------------------------------------------------------------------------------------------------------------
{
/*------------------------------------------------------------------------------
; If font display distortion, please check Fonts format of setup.
; Source file / text :                  arias887
; Width x Height (pixels) :129X17
;  Font Format/Size : Monochrome LCD Fonts ,Vertical scan ,  Little endian order/387Byte
;  Font make date  : 30/03/2011 01:44:47
------------------------------------------------------------------------------*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0xF4,0x94,0x94,0xFC,0xF8,0x00,
0x00,0xFC,0xFC,0x08,0x0C,0x0C,0x00,0xFD,0xFD,0x00,0x00,0x60,0xF4,0x94,0x94,0xFC,
0xF8,0x00,0x00,0x98,0xBC,0xB4,0xF4,0x64,0x00,0x00,0x76,0xFF,0x89,0x89,0xFF,0x76,
0x00,0x00,0x76,0xFF,0x89,0x89,0xFF,0x76,0x00,0x00,0x01,0xC1,0xF1,0x3D,0x0F,0x03,
0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01*,0x01,
0x01,0x01*,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,
};

------------------------------------------------------------------------------------------------------------

Esos tres "0x01" son los que generan los tres punticos al fina (arias887°°°) y si se eliminas, ps ya esos punticos desaparecen de la visualización...

Lo malo es que como hay que decile al progroma que height=18, tonces el programa es mas largo y pesado para PIC, pero bueno, por lo menos todo esta saliendo bien...

AHHH!!!
Y otra cosa muchachos, solo tube que modificar en el programa CCS, la parte que les estoy contando y nada mas, por lo tanto, se pueden hacer muchos letreros con el codigo de Shwan...

¡¡¡Seguiremos informando!!!...XD...


----------



## osmantigre (Abr 4, 2011)

Muy buen aporte Shawn, voy a tratar de hacerlo en ASEMBLER


----------



## cesarVS (Abr 16, 2011)

esta genial este proyecto  tambien hare mi matriz de led's  espero contar con su ayuda si me trabo


----------



## miguel2486 (Abr 25, 2011)

hola como estan esta buena la informacion pero tengo un problema yo tengo el registro de desplazamiento 74ls164, y estoy tratando de modificar el programa para hacer que funcione con este registro, pero por mas cosas que hago no puedo , por favor alguien k domine lenguaje en C me puede ayudar,.gracias por la ayuda.... espero su respuesta,.


----------



## SERGIOD (Abr 27, 2011)

Hola como dije me parecio y me parece genial el aporte asi es que yo quiero hacer uno que diga:

* INTERNET SPEEDY*

a ver si me ayudan...


----------



## Moyano Jonathan (Abr 28, 2011)

Está exelente el aporte, me suscribo al hilo !!


----------



## stornipro (Jun 5, 2011)

y alguien sabe alguna forma de que en vez de que sean solo 8 filas ...que sean mas de 20?... nose.. usando otros en paralelo o algo... 

me serviria de mucho que me orienten a ver como puedo hacerlo.. 
muchas gracias


----------



## mettroid2006 (Jun 10, 2011)

Hola Shawn como te va, me parece genial que compartas este gran conocimiento, solo que tengo una duda, espero me puedas ayudar, y esta es:

Que tan largo puede ser el texto a desplegar y como puedo expandirlo? Yo introduje alrededor de 35 letras y 10 espacios iniciales y no se despliega el texto, de hecho, no aparece nada en la simulación de Proteus. Apenas estoy iniciando con CCS y quiero ver que es lo que limita esto, y obviamente como podria solucionarlo porque quisiera meter un texto de alrededor de 100 letras o mas, pero no tengo idea de como hacer eso.

Espeo me puedas ayudar porque si me dieron muchas ganas de construir este "letrero matricial con leds". Gracias por tu tiempo y sigue aportando cosas tan buenas como estas

Saludos!!!


----------



## SERGIOD (Jun 29, 2011)

arias887 dijo:


> Shawn gracias, lo de la raya ya lo solucione, hay que poner en "height" no 8 si no 18 y el tamaño de la letra=8, para que la raya esa salga por  debajo del texto y quedaria asi "arias887" luego en el progama donde al final quedan todo ese pocoton de "0x00", hay que elimiar los tres anteriores a esos para que en la visualizacion no te queden 3 punticos detras del texto asi (arias887°°°) me explico...
> 
> este es el codigo que genero para "arias887" con la rraya por de bajo abajo:
> 
> ...



Hola compañero arias queria saber como te va en el proyecto a ver si nos comunicas sobre tus avances


----------



## norbey (Nov 11, 2011)

ya pudimos meter bastante texto como , " bienvenidos", "foro  electronica ".....  con  ocho  mensajes  diferentes  parecidos a  estos , el problema es  que llena la ram  , !desearia hacer una  pequeña  base de datos para solo direccionar la  frase  qe  deseo   sin necesidad de guardar   los  mensajes  como matrices  sino  al  contario en un variable   tipo  char   !estoy interesado en hacer animaciones  y  un scrool   bainas de ese estilo


----------



## arias887 (Nov 11, 2011)

SERGIOD dijo:


> Hola compañero arias queria saber como te va en el proyecto a ver si nos comunicas sobre tus avances



No ps lo deje hay en "pausa" porque este tipo de cosas salen muy costosas...
Pero seria bueno implementarlo como para un regalo para darselo a la novi@ o algo asi...


----------



## arias887 (Abr 25, 2013)

Holas compañeros...
He estado retomando el proyecto y me gustaria saber como hacer para agregar otras 8 filas para que quede de 16 filas, osea, de 16x64...
Es decir el doble de alto....
He estado intentandolo pero no he conseguido....

Gracias...


----------



## ludwina (Jul 19, 2014)

hola amigos quiero realizar esta matriz pero no me deja mostrar todo el texto pues solo se queda a la mitad


----------



## juanalf (Jul 28, 2014)

Hola buenas,

Me encuentro haciendo un proyecto en el cual, necesito construir una matriz Led que cargue un texto que viene desde la PC.

En principio, sobre lo que tengo que hacer, tengo esto definido.

-El tamaño del panel: Si es pequeño mejor, pero no es algo impresindible.

-La forma cómo se presenta el texto (efecto): Sin efectos, aparece el texto tal cual sin animaciones. Solo tiene que mostrarse por un momento.

-La longitud de los mensajes: Tienen un máximo de 16 caracteres.

-Si los mensajes son estáticos o si se programan en tiempo de ejecución: Los mensajes estan definidos estaticamente pero se decide cual usar en tiempo de ejecucion.

Buscando información al respecto, encuentro este tema que es bastante acertado acerca de lo que necesito hacer:

Cómo Construir Un Letrero Matricial De LEDs

Ahora, alli se menciona que el problema de la implementacion del HW es lo mas complicado. Pero no es lo unico.
Para mi caso es necesario saberlo y como tengo muy pocos conocimientos de electronica. quisiera saber que es lo que necesito para construirlo o si es mejor conseguir ya hecha alguna parte o todo el HW de la matriz led.

Que matriz led me conviene, si uso una microcontroladora (cual?), si el software del enlace me sirve o cual podria ser. Que otro elemento estoy omitiendo que necesito para esto?

Les agradezco de ante mano cualquier respuesta que me den, ya me han ayudado una vez. ...


----------



## yamil2009 (Sep 28, 2015)

Hola amigos ! Me gustaria armar un letrero asi y la verdad me gustaria intentar armarlo, porfavor alguien pudiera pasar los archivos que estan en la parte inicial de este hilo.
se los agradesco por la ayuda.
atentamente
Yamil


----------



## Fogonazo (Sep 28, 2015)

yamil2009 dijo:


> Hola amigos ! Me gustaria armar un letrero asi y la verdad me gustaria intentar armarlo, porfavor alguien pudiera pasar los archivos que estan en la parte inicial de este hilo.
> se los agradesco por la ayuda.
> atentamente
> Yamil



Si los archivos están en la _"Parte inicial del hilo"_ ¿ Para que deseas que te los pasen nuevamente ?


----------



## locodelafonola (Sep 29, 2015)

hola 





Fogonazo dijo:


> Si los archivos están en la _"Parte inicial del hilo"_ ¿ Para que deseas que te los pasen nuevamente ?


 Fogo ., pasa lo que muchas veces ., se cayo el link ., o sea quedo el BLAA,BLAA y BLAA ., del proyecto nada mas .,  lo demas desaparecio ., y  tambien los avances del hilo queda inutil​


----------



## MrCarlos (Sep 29, 2015)

Hola

En El Mensaje #11 Del originador de este tema (Shawn) está el *panccs.rar* el cual contiene todos los archivos necesarios para el proyecto que se trató aquí.

saludos
a sus ordenes


----------



## julian403 (Nov 28, 2015)

Me interesaría saber el tiempo en que los leds quedan emitiendo luego de ser apagados. En el post inicial, el compañero menciona lo siguiente: 



> Sin embargo, no es posible encender varios LEDs que pertenezcan a diferentes filas y diferentes columnas al mismo tiempo. Es aquí donde entra a jugar el software.
> 
> Por ejemplo en la siguiente animación se muestra como para visualizar la letra G se encienden los LEDs correspondientes pero en tiempos diferentes.



Ahora bien, no puedo visualizar las imagenes o los gift. 

Lo que supongo es jugar con el tiempo en que el led sigue emitiendo luz una vez deshabilitado su caida de potencial. Sé que existe un tiempo (tiempo de apaga quizás se llame) pero no me acuerdo cual es la duración temporal promedio pero estaba en el orden de los microsegundo. Si alguien conoce dicho dato agradecería su información. A su vez una exesiva frecuencia puede ocacionar que el led no emita.



> Como el bucle más interno se ejecuta en 982us, cada barrido se completa en 7,86 ms (7908 en la práctica) y como cada frame tiene 8 barridos, durará cerca de 60ms. En consecuencia, la imagen del panel se desplaza una columna de LEDs cada 60ms. Para medir estos tiempos puedes utilizar el Stopwatch de MPLAB o el Counter/Timer de Proteus.


Esa información proporcionó los tiempos que usó pero me interesa saber el tiempo promedio de los leds para poder trabajar sobre esto y no copiar por el simple hecho de copiar un trabajo ajeno. Lamentablemente los dominios de los links que suministra están caidos.

Saludos


----------



## J2C (Nov 28, 2015)

.


Julian403

En las matrices de led's como en los display de 7 Seg multiplexados no se juega con el tiempo:


julian403 dijo:


> Me interesaría saber el tiempo en que los leds quedan emitiendo luego de ser apagados .....


El tema pasa por la *persistencia de la visión* !!!!


El ejemplo mas burdo lo teníamos con las lámparas incandescentes y los 50Hz de la distribución de energía domiciliaria, si bien el filamento posee una persistencia distinta a los led's no llegabamos a apreciar la disminución del brillo en simultaneo con la senoide.

Aquí lo que hace típicamente es barrer cada una de las ocho filas en un tiempo aproximado a los 2 ms de manera que las 8 filas sean barridas en 16 ms y repetir los barridos continuamente, de esa manera habrá realizado unos 60 barridos completos en 1 seg.

Se que se puede usar menor cantidad de barridos completos, pero llega un punto que dependiendo de la iluminación ambiente se llega a notar algún tipo de parpadeo. Tampoco es conveniente sincronizar la cantidad de barridos con la frecuencia de la distribución de energía domiciliaria.


Recuerdo haber visto más temas de Matrices de Led's multiplexadas dentro del foro.




Saludos, JuanKa.-


----------



## Scooter (Nov 28, 2015)

El ejemplo de las lámparas incandescentes no es válido: no se apagan nunca porque no les da tiempo a enfriarse.
Un tubo fluorescente u otra lámpara de descarga si que se apaga y enciende. Por eso cansan más la vista y tienen efecto estroboscópico.


----------

