Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

23/03/2011 #1


Cómo Construir Un Letrero Matricial De LEDs
Cómo Construir Un Letrero Matricial De LEDs

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.

El hardware

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.

Los barridos

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.

Los caracteres

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í:
Código:
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.

Generación automática de matrix

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:
  1. 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.


  2. 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.


  3. 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.


  4. 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".


  5. 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.

El código fuente

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.

Código PHP:
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=0bad<LENbad++)  // Bucle para LEN "frames"
63          {
64              for(i=0i<8i++)      // Bucle de 8 barridos por "frame"
65              {
66                  for(row=1rowrow<<=1)    // Cada barrido pasa por las 8 filas  (23288 ciclos)
67                  {
68                      for(col=WIDTHcolcol--)  // 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 
Descripción del programa
  • 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.

La simulación

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.


Descargas

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.
24/03/2011 #2

Avatar de snakewather

MUY buena informacion para hacer uno para mi puerta jejeje.

el Programa que te genera el letrero es libre?
25/03/2011 #3


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

Avatar de SERGIOD

Genial se ve interesante voy a descargar los archivos adjuntos y le doy una leida
25/03/2011 #5


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.
25/03/2011 #6


Se ve muy bueno.

Muchas gracias !


Adiosín...!
25/03/2011 #7


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...
26/03/2011 #8


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
26/03/2011 #9

Avatar de arias887

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...
27/03/2011 #10

Avatar de arias887

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...
Imágenes Adjuntas
Tipo de Archivo: bmp ensayo.bmp (286 Bytes, 252 visitas)
29/03/2011 #11


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á.
Archivos Adjuntos
Tipo de Archivo: rar panccs.rar (24,7 KB (Kilobytes), 354 visitas)
29/03/2011 #12


saludos colegas, muy buen trabajo, de inmediato me pongo a investigar y desarrollar los trabajos...
gracias por el buen aporte Shawn.
29/03/2011 #13


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
30/03/2011 #14

Avatar de arias887

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...
04/04/2011 #15


Muy buen aporte Shawn, voy a tratar de hacerlo en ASEMBLER
16/04/2011 #16


esta genial este proyecto tambien hare mi matriz de led's espero contar con su ayuda si me trabo
25/04/2011 #17


miguel angel ayuda, porfa
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,.
27/04/2011 #18

Avatar de SERGIOD

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...
Archivos Adjuntos
Tipo de Archivo: rar SERGIO INTERNET.rar (1,6 KB (Kilobytes), 279 visitas)
28/04/2011 #19

Avatar de Moyano Jonathan

Está exelente el aporte, me suscribo al hilo !!
05/06/2011 #20


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
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.