De matriz de leds, a letrero electronico

[martin 2187]

acá dejo el link de un video donde esta un proyecto como el que quiero... gracias por su tiempo y disculpen las molestias...

feature=related

[martin 2187]

hola.. disculpen las molestias... soy algo nuevo en esto de la programación y ando con la idea de armarme unos de esos carteles para colocar en el negocio de mi vieja... les agradecería si pudieran subir algún cartel de matrices que se pueda escribir el texto sin necesidad de una pc, o indicarme donde puedo bajarlo porque desde hace una semana estoy dando vueltas por todas las paginas y no puedo encontrar nada que me convenza... lo que estoy buscando es alguno de 7x45 o similar....

Desde ya muchas gracias...

creo que la mejor manera sería con un teclado de pc, pero tienes que entrarle al código PS/2
saludos.

y como podría hacer alguno con teclado?? si tenes alguno por ahí a mano me lo podrías pasar?? muchas gracias...

[Suky]

hola.. disculpen las molestias... soy algo nuevo en esto de la programación y ando con la idea de armarme unos de esos carteles para colocar en el negocio de mi vieja... les agradecería si pudieran subir algún cartel de matrices que se pueda escribir el texto sin necesidad de una pc, o indicarme donde puedo bajarlo porque desde hace una semana estoy dando vueltas por todas las paginas y no puedo encontrar nada que me convenza... lo que estoy buscando es alguno de 7x45 o similar....

Desde ya muchas gracias...

creo que la mejor manera sería con un teclado de pc, pero tienes que entrarle al código PS/2
saludos.

y como podría hacer alguno con teclado?? si tenes alguno por ahí a mano me lo podrías pasar?? muchas gracias...

Utiliza el buscador del foro, hay hilos donde se explica como trabajar con el teclado. El proyecto completo de un cartel de leds comandado por un teclado no lo vas a encontrar, pero si las partes, solo queda el esfuerzo propio de entenderlo y combinarlos. 


Saludos!

[martin 2187]

hola.. disculpen las molestias... soy algo nuevo en esto de la programación y ando con la idea de armarme unos de esos carteles para colocar en el negocio de mi vieja... les agradecería si pudieran subir algún cartel de matrices que se pueda escribir el texto sin necesidad de una pc, o indicarme donde puedo bajarlo porque desde hace una semana estoy dando vueltas por todas las paginas y no puedo encontrar nada que me convenza... lo que estoy buscando es alguno de 7x45 o similar....

Desde ya muchas gracias...

creo que la mejor manera sería con un teclado de pc, pero tienes que entrarle al código PS/2
saludos.

y como podría hacer alguno con teclado?? si tenes alguno por ahí a mano me lo podrías pasar?? muchas gracias...

Utiliza el buscador del foro, hay hilos donde se explica como trabajar con el teclado. El proyecto completo de un cartel de leds comandado por un teclado no lo vas a encontrar, pero si las partes, solo queda el esfuerzo propio de entenderlo y combinarlos. 


Saludos!

bueno.. aunque no entiendo nada de programación voy a tratar de orientarme y ver que puedo hacer....

muchas gracias... suerte.

[nediamolbap]

Saludo a todos,

He intentado agregar más matrices al ejemplo de Cryn en la simulación con el pic 16f88, pero al aumentar 1 o 2 matriz el mensaje empieza en dicha matriz.

he cambiado en el código
#define COLUMNAS 48 //para 6 matrices  

Como podría agregar mas matrices al ejemplo de Cryn??

Adjunto la simulación (he cambiado el pic a un 16F628A) Gracias.

[mikele]

hola q tal......... bueno revise el codigo y creo q te falta esta linea.......
int carries[6] le cambias por int carries[7], intentalo ............  suerte.....

[nediamolbap]

Saludo gracias,

Probé cambiando int carries[6] por int carries[7], pero sigue igual, también he intentado cambiar otros valores pero nada. Sera que solo sirve para 5 matrices?? o es problema en la simulación?? 

gracias.

[mikele]

hOLA Q TAL .... PRUEBA CON ESTE CODIGO, CON LA MISMA SIMULACION, ESTA AUMENTADO (EN CODIGO) PARA 8 MATRIZ LEDS..LO AUMENTAS EN LA SIMULACION LAS MATRICES Q FALTAN.... ME AVISAS CUALQUIER COSA............SUERT.........

Código: C++

1. #include <16F628A.h>//cambio de libreria
2. #fuses HS,NOWDT,NOLVP,PUT,NOBROWNOUT
3. #use delay(clock=20M)
4. #use fast_io(a)
5. #use fast_io(b)
6. #include <fonts.h>//fonts
7. #include <string.h>
8. #define clock PIN_A1
9. #define strobe PIN_A2
10. #define dato PIN_A0
11. #define size_matriz_col 8  //cantidad de columnas por matriz
12. #define COLUMNAS 56       //Defino cantidad de columnas a usar
13. #define matriz_num COLUMNAS/size_matriz_col  //numero de matrices usado
14.  
15. #byte portb=6
16.  
17. int matriz[matriz_num+1][size_matriz_col]={"\0"};  //Almacena los datos a mostrar en el cartel
18. int Fila;           //Fila actual a refrescar
19. int VSync;          //Indica si es momento correcto de modificar lo que se esta mostrando...
20. int Inhibit;        //Impide que se produzcan cambios en el cartel.
21.                        
22. int mensaje[1][20/*42*/]={"*** BIENVENIDOS ***"};  //{};
23.                          
24. const int num_msj=1;          
25. const int msj_length[num_msj]={19};//31--33
26. int carries[8]/*6*/,msj,letra,desplazos;
27.  
28.    int i_desplazar_izq=0;
29.    int j_desplazar_izq=0;
30.    int a_desplazar_izq=0;
31.    
32.    int contador_cargar=0;
33.    
34.    int i,j;
35.  
36. void ShowFila(void);
37. void cargar(int datob);
38. void desplazar_izq(void);
39. void load_letra(int caracter);
40.  
41. //Esta interrupcion debe suceder segun la cantidad de filas que tengas, y segun la cantidad de Hz a los que queres que tu cartel refresque...
42. #int_TIMER0
43. void  TIMER0_isr(void){
44. ShowFila();                  //Mostremos la fila actual...
45. Fila++;
46. if(Fila==8){
47.       Fila=0;
48.       VSync=1;
49.       if(Inhibit!=0)
50.       Inhibit--;
51.       else
52.       desplazar_izq();
53.       }  
54.       else     VSync=0;
55.       }
56.      
57. void main(void){
58.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
59.      enable_interrupts(INT_TIMER0);
60.    clear_interrupt(INT_TIMER0);
61.    enable_interrupts(GLOBAL);
62.    //setup_adc(adc_off);
63.    //setup_adc_ports(no_analogs);
64.    set_tris_a(0);
65.    set_tris_b(0);
66.    output_b(0x01);      //Apago cartel
67.    output_low(CLOCK);   //Aseguro inicialmente clock en bajo
68.    output_low(STROBE);
69.    Fila=0;              //Comienzo por la 1er fila
70.    Inhibit=5;
71.    VSync=1;             //Indico que comienzo con sync.
72.    desplazos=0;
73.    msj=0;
74.    while(true){}}
75.    
76.    void cargar(int datob){
77.    //int contador;
78.    output_low(clock);
79.    delay_cycles(2);
80.    output_low(strobe);
81.    for(contador_cargar=0;contador_cargar<8;contador_cargar++){
82.    output_bit(dato,(datob & 0x1));
83.    datob>>=1;
84.    output_high(clock);
85.    delay_cycles(1);
86.    output_low(clock);   }
87.    output_high(strobe);
88.    delay_cycles(1);
89.    output_low(strobe);
90.    }
91.    int i_showfila=0;
92.    void ShowFila(void){
93.    //int i;
94.    output_b(0xFF);//*****0xFF
95.    for(i_showfila=0;i_showfila<7;i_showfila++){//5  6
96.    cargar(matriz[i_showfila][Fila]);
97.    }
98.    bit_clear(portb,fila);//*****clear
99.    }
100.    
101.    void desplazar_izq(void){
102.    //int i,j,a;
103.    if(desplazos==8 || desplazos==0){
104.    load_letra(mensaje[msj][letra]);
105.    desplazos=0;   }
106.    for(i_desplazar_izq=0;i_desplazar_izq<8;i_desplazar_izq++){
107.    for(j_desplazar_izq=0;j_desplazar_izq<=7;j_desplazar_izq++){
108.    a_desplazar_izq=matriz[j_desplazar_izq][i_desplazar_izq];
109.    carries[j_desplazar_izq]=shift_left(&a_desplazar_izq,1,0);
110.    matriz[j_desplazar_izq][i_desplazar_izq]=a_desplazar_izq;      }
111.    for(j_desplazar_izq=0;j_desplazar_izq<=7;j_desplazar_izq++){
112.    if(j_desplazar_izq!=7)//5
113.    matriz[j_desplazar_izq][i_desplazar_izq]|=carries[j_desplazar_izq+1];
114.    else  
115.    matriz[j_desplazar_izq][i_desplazar_izq]|=carries[0];
116.    }  
117.    }  
118.    Inhibit=5;
119.    desplazos++;
120.    if(desplazos==8){
121.    letra++;
122.    if(letra>msj_length[msj])
123.    letra=0;
124.    }
125.    }
126.    
127.  void load_letra(int caracter){
128.  //int i,j;
129.  if(isalnum(caracter)){
130.  if(isalpha(caracter)){
131.  if(isupper(caracter)){
132.  switch(caracter){
133.  case 'A': i=0; break;
134.  case 'B': i=1; break;
135.  case 'C': i=2; break;
136.  case 'D': i=3; break;
137.  case 'E': i=4; break;
138.  case 'F': i=5; break;
139.  case 'G': i=6; break;
140.  case 'H': i=7; break;
141.  case 'I': i=8; break;
142.  case 'J': i=9; break;
143.  case 'K': i=10; break;
144.  case 'L': i=11; break;
145.  case 'M': i=12; break;
146.  case 'N': i=13; break;
147.  case 'O': i=14; break;
148.  case 'P': i=15; break;
149.  case 'Q': i=16; break;
150.  case 'R': i=17; break;
151.  case 'S': i=18; break;
152.  case 'T': i=19; break;
153.  case 'U': i=20; break;
154.  case 'V': i=21; break;
155.  case 'W': i=22; break;
156.  case 'X': i=23; break;
157.  case 'Y': i=24; break;
158.  case 'Z': i=25; break;
159.  }
160.  for(j=0;j<8;j++){
161.  matriz[7][j]=letrasM[i][j];
162.  }
163.  }
164.  else{
165.  switch(caracter){
166.  case 'a': i=0; break;
167.  case 'b': i=1; break;
168.  case 'c': i=2; break;
169.  case 'd': i=3; break;
170.  case 'e': i=4; break;
171.  case 'f': i=5; break;
172.  case 'g': i=6; break;
173.  case 'h': i=7; break;
174.  case 'i': i=8; break;
175.  case 'j': i=9; break;
176.  case 'k': i=10; break;
177.  case 'l': i=11; break;
178.  case 'm': i=12; break;
179.  case 'n': i=13; break;
180.  case 'o': i=14; break;
181.  case 'p': i=15; break;
182.  case 'q': i=16; break;
183.  case 'r': i=17; break;
184.  case 's': i=18; break;
185.  case 't': i=19; break;
186.  case 'u': i=20; break;
187.  case 'v': i=21; break;
188.  case 'w': i=22; break;
189.  case 'x': i=23; break;
190.  case 'y': i=24; break;
191.  case 'z': i=25; break;
192.  }
193.  for(j=0;j<8;j++){
194.  matriz[7/*5*/][j]=letras_m[i][j];
195.  }
196.  }
197.  }
198.  else{
199.  for(j=0;j<8;j++){
200.  matriz[7][j]=numeros[caracter-'0'][j];
201.  }
202.  }
203.  }
204.  else{
205.  switch(caracter){
206.  case ' ': i=0; break;
207.  case '!': i=1; break;
208.  case '"': i=2; break;
209.  case '#': i=3; break;
210.  case '$': i=4; break;
211.  case '%': i=5; break;
212.  case '&': i=6; break;
213.  case '´': i=7; break;//este es el acento
214.  case '(': i=8; break;
215.  case ')': i=9; break;
216.  case '*': i=10; break;
217.  case '+': i=11; break;
218.  case ',': i=12; break;
219.  case '-': i=13; break;
220.  case '.': i=14; break;
221.  case '/': i=15; break;
222.  case ':': i=16; break;
223.  case ';': i=17; break;
224.  case '>': i=18; break;
225.  case '=': i=19; break;
226.  case '<': i=20; break;
227.  case '?': i=21; break;
228.  case '[': i=22; break;
229.  case ']': i=23; break;
230.  case '^': i=24; break;
231.  case '_': i=25; break;
232.  case '{': i=26; break;
233.  case '|': i=27; break;
234.  case '}': i=28; break;
235.  case '@': i=29; break;
236.  case 'ñ': i=30; break;  // esta es la enie
237.  case '\f': i=31; break;
238.  }
239.  for(j=0;j<8;j++){
240.  matriz[7][j]=chars[i][j];
241.  }
242.  }
243.  }

[nediamolbap]

saludo,

Muchas gracias mikele, 

he aumentado las matrices, y funciona bien, solo que el mensaje no empieza en la primera columna??

gracias de nuevo.

[gallo961]

de momento les presento el 1er código que hice para el 16f88, para que talvez pueda servir a alguien, porque de momento, aunque me duele un poco decirlo, tengo que dejarlo pendiente esto del publik, porque se me presento un proyecto urgente para un amigo, aunque en ratos que pueda le dedicaré al publik

acá les dejo el 1er código:

Código: C

1. #include <16f88.h>
2. #fuses HS,NOWDT,NOLVP,PUT,NOBROWNOUT,MCLR
3. #use delay(clock=20000000)
4. #use fast_io(a)
5. #use fast_io(b)
6. #include <fonts.h>
7. #include <string.h>
8.  
9. #define clock PIN_A1
10. #define strobe PIN_A2
11. #define dato PIN_A0
12. #define size_matriz_col 8  //cantidad de columnas por matriz
13. #define COLUMNAS 40       //Defino cantidad de columnas a usar
14. #define matriz_num COLUMNAS/size_matriz_col  //numero de matrices usado
15.  
16. #byte portb=6
17.  
18. int matriz[matriz_num+1][size_matriz_col]={"\0"};  //Almacena los datos a mostrar en el cartel
19. int Fila;           //Fila actual a refrescar
20. int VSync;          //Indica si es momento correcto de modificar lo que se esta mostrando...
21. int Inhibit;        //Impide que se produzcan cambios en el cartel.
22. const int mensaje[1][32]={"Feliz Navidad y Feliz 2009!!..."};
23. const int num_msj=1;
24. const int msj_length[num_msj]={31};
25. int carries[6],msj,letra,desplazos;
26.  
27. void ShowFila(void);
28. void cargar(int datob);
29. void desplazar_izq(void);
30. void load_letra(int caracter);
31.  
32. //Esta interrupcion debe suceder segun la cantidad de filas que tengas, y segun la cantidad de Hz a los que queres que tu cartel refresque...
33. #int_TIMER0
34. void  TIMER0_isr(void){
35.  
36.    ShowFila();                  //Mostremos la fila actual...
37.    Fila++;
38.    if(Fila==8){
39.       Fila=0;
40.       VSync=1;
41.       if(Inhibit!=0)
42.          Inhibit--;
43.       else
44.          desplazar_izq();
45.   }
46.   else
47.      VSync=0;
48. }
49.  
50. void main(void){
51.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);
52.    enable_interrupts(INT_TIMER0);
53.    clear_interrupt(INT_TIMER0);
54.    enable_interrupts(GLOBAL);
55.    setup_adc(adc_off);
56.    setup_adc_ports(no_analogs);
57.    set_tris_a(0);
58.    set_tris_b(0);
59.    output_b(0xFF);      //Apago cartel
60.    output_low(CLOCK);   //Aseguro inicialmente clock en bajo
61.    output_low(STROBE);
62.    Fila=0;              //Comienzo por la 1er fila
63.    Inhibit=5;
64.    VSync=1;             //Indico que comienzo con sync.
65.    desplazos=0;
66.    msj=0;
67.    while(true){}
68. }
69.  
70. void cargar(int datob){
71.    int contador;
72.  
73.    output_low(clock);
74.    delay_cycles(2);
75.    output_low(strobe);
76.    for(contador=0;contador<8;contador++){
77.       output_bit(dato,(datob & 0x1));
78.       datob>>=1;
79.       output_high(clock);
80.       delay_cycles(1);
81.       output_low(clock);
82.    }
83.    output_high(strobe);
84.    delay_cycles(1);
85.    output_low(strobe);
86. }
87.  
88. void ShowFila(void){
89.    int i;
90.  
91.    output_b(0xFF);
92.    for(i=0;i<5;i++){
93.       cargar(matriz[i][Fila]);
94.    }
95.    bit_clear(portb,fila);
96. }
97.  
98. void desplazar_izq(void){
99.    int i,j,a;
100.  
101.    if(desplazos==8 || desplazos==0){
102.       load_letra(mensaje[msj][letra]);
103.       desplazos=0;
104.    }
105.    for(i=0;i<8;i++){
106.       for(j=0;j<6;j++){
107.          a=matriz[j][i];
108.          carries[j]=shift_left(&a,1,0);
109.          matriz[j][i]=a;
110.       }
111.       for(j=0;j<6;j++){
112.          if(j!=5)
113.             matriz[j][i]|=carries[j+1];
114.          else
115.             matriz[j][i]|=carries[0];
116.       }
117.    }
118.    Inhibit=5;
119.    desplazos++;
120.    if(desplazos==8){
121.       letra++;
122.       if(letra>msj_length[msj])
123.          letra=0;
124.    }
125. }
126.  
127. void load_letra(int caracter){
128.    int i,j;
129.  
130.    if(isalnum(caracter)){
131.       if(isalpha(caracter)){
132.          if(isupper(caracter)){
133.             switch(caracter){
134.                case 'A': i=0; break;
135.                case 'B': i=1; break;
136.                case 'C': i=2; break;
137.                case 'D': i=3; break;
138.                case 'E': i=4; break;
139.                case 'F': i=5; break;
140.                case 'G': i=6; break;
141.                case 'H': i=7; break;
142.                case 'I': i=8; break;
143.                case 'J': i=9; break;
144.                case 'K': i=10; break;
145.                case 'L': i=11; break;
146.                case 'M': i=12; break;
147.                case 'N': i=13; break;
148.                case 'O': i=14; break;
149.                case 'P': i=15; break;
150.                case 'Q': i=16; break;
151.                case 'R': i=17; break;
152.                case 'S': i=18; break;
153.                case 'T': i=19; break;
154.                case 'U': i=20; break;
155.                case 'V': i=21; break;
156.                case 'W': i=22; break;
157.                case 'X': i=23; break;
158.                case 'Y': i=24; break;
159.                case 'Z': i=25; break;
160.             }
161.             for(j=0;j<8;j++){
162.                matriz[5][j]=letrasM[i][j];
163.             }
164.          }
165.          else{
166.             switch(caracter){
167.                case 'a': i=0; break;
168.                case 'b': i=1; break;
169.                case 'c': i=2; break;
170.                case 'd': i=3; break;
171.                case 'e': i=4; break;
172.                case 'f': i=5; break;
173.                case 'g': i=6; break;
174.                case 'h': i=7; break;
175.                case 'i': i=8; break;
176.                case 'j': i=9; break;
177.                case 'k': i=10; break;
178.                case 'l': i=11; break;
179.                case 'm': i=12; break;
180.                case 'n': i=13; break;
181.                case 'o': i=14; break;
182.                case 'p': i=15; break;
183.                case 'q': i=16; break;
184.                case 'r': i=17; break;
185.                case 's': i=18; break;
186.                case 't': i=19; break;
187.                case 'u': i=20; break;
188.                case 'v': i=21; break;
189.                case 'w': i=22; break;
190.                case 'x': i=23; break;
191.                case 'y': i=24; break;
192.                case 'z': i=25; break;
193.             }
194.             for(j=0;j<8;j++){
195.                matriz[5][j]=letras_m[i][j];
196.             }
197.          }
198.       }
199.       else{
200.          for(j=0;j<8;j++){
201.             matriz[5][j]=numeros[caracter-'0'][j];
202.          }
203.       }
204.    }
205.    else{
206.       switch(caracter){
207.          case ' ': i=0; break;
208.          case '!': i=1; break;
209.          case '"': i=2; break;
210.          case '#': i=3; break;
211.          case '$': i=4; break;
212.          case '%': i=5; break;
213.          case '&': i=6; break;
214.          case '´': i=7; break; //este es el acento
215.          case '(': i=8; break;
216.          case ')': i=9; break;
217.          case '*': i=10; break;
218.          case '+': i=11; break;
219.          case ',': i=12; break;
220.          case '-': i=13; break;
221.          case '.': i=14; break;
222.          case '/': i=15; break;
223.          case ':': i=16; break;
224.          case ';': i=17; break;
225.          case '>': i=18; break;
226.          case '=': i=19; break;
227.          case '<': i=20; break;
228.          case '?': i=21; break;
229.          case '[': i=22; break;
230.          case ']': i=23; break;
231.          case '^': i=24; break;
232.          case '_': i=25; break;
233.          case '{': i=26; break;
234.          case '|': i=27; break;
235.          case '}': i=28; break;
236.          case '@': i=29; break;
237.          case 'ñ': i=30; break;  // esta es la enie
238.          case '\f': i=31; break;
239.       }
240.       for(j=0;j<8;j++){
241.          matriz[5][j]=chars[i][j];
242.       }
243.    }
244. }

y el fonts.h:

Código: C

1. const int letrasM[26][8]={{48,120,204,204,252,204,204,204},    //A
2.                           {248,204,204,248,248,204,204,248},   //B
3.                           {252,192,192,192,192,192,192,252},   //C
4.                           {240,200,204,204,204,204,200,240},   //D
5.                           {252,192,192,240,240,192,192,252},   //E
6.                           {252,192,192,240,240,192,192,192},   //F
7.                           {60,64,192,192,216,204,204,248},     //G
8.                           {204,204,204,204,252,204,204,204},   //H
9.                           {252,48,48,48,48,48,48,252},         //I
10.                           {252,48,48,48,48,48,176,240},        //J
11.                           {196,200,208,224,208,204,204,204},   //K
12.                           {192,192,192,192,192,192,192,252},   //L
13.                           {238,214,214,198,198,198,198,198},   //M
14.                           {196,228,244,212,212,204,204,196},   //N
15.                           {48,204,204,204,204,204,204,48},     //O
16.                           {248,204,204,204,248,192,192,192},   //P
17.                           {56,196,196,196,196,212,200,52},     //Q
18.                           {248,204,204,204,248,208,200,196},   //R
19.                           {120,204,192,192,120,12,12,248},     //S
20.                           {252,48,48,48,48,48,48,48},          //T
21.                           {204,204,204,204,204,204,204,120},   //U
22.                           {204,204,204,204,204,204,72,48},     //V
23.                           {198,198,198,198,198,214,214,238},   //W
24.                           {132,132,72,48,48,72,132,132},       //X
25.                           {204,204,204,120,48,48,48,48},       //Y
26.                           {252,252,8,16,32,64,252,252}};       //Z
27.  
28. const int letras_m[26][8]={{0,0,112,136,8,120,136,116},        //a
29.                            {0,128,128,128,240,136,136,240},    //b
30.                            {0,0,0,120,128,128,128,120},        //c
31.                            {0,8,8,8,120,136,136,120},          //d
32.                            {0,0,0,120,136,240,128,120},        //e
33.                            {0,96,144,128,128,224,128,128},     //f
34.                            {0,0,112,136,136,112,8,112},        //g
35.                            {0,128,128,128,240,136,136,136},    //h
36.                            {0,0,32,0,32,32,32,32},             //i
37.                            {0,0,16,0,16,16,144,96},            //j
38.                            {0,128,144,160,192,160,144,144},    //k
39.                            {0,32,32,32,32,32,32,32},           //l
40.                            {0,0,0,136,212,164,164,164},        //m
41.                            {0,0,0,176,200,136,136,136},        //n
42.                            {0,0,0,112,136,136,136,112},        //o
43.                            {0,0,240,136,136,240,128,128},      //p
44.                            {0,0,120,136,136,120,8,28},         //q
45.                            {0,0,0,176,192,128,128,128},        //r
46.                            {0,0,112,136,128,112,8,240},        //s
47.                            {0,32,32,112,32,32,32,24},          //t
48.                            {0,0,0,136,136,136,152,104},        //u
49.                            {0,0,0,136,136,136,80,32},          //v
50.                            {0,0,0,136,136,136,168,80},         //w
51.                            {0,0,0,136,80,32,80,136},           //x
52.                            {0,0,0,136,136,112,16,96},          //y
53.                            {0,0,0,248,16,32,64,248}};          //z
54.                            
55. const int numeros[10][8]={{0,120,132,140,148,164,196,120},     //0
56.                           {0,16,48,80,16,16,16,124},           //1
57.                           {0,112,136,8,16,32,64,248},          //2
58.                           {0,112,136,8,48,8,136,112},          //3
59.                           {0,8,24,40,72,252,8,8},              //4
60.                           {0,124,128,128,120,4,4,248},         //5
61.                           {0,120,128,128,248,132,132,120},     //6
62.                           {0,252,132,8,16,32,64,64},           //7
63.                           {0,120,132,132,120,132,132,120},     //8
64.                           {0,120,132,132,124,4,4,120}};        //9
65.  
66. const int chars[31][8]={{0,0,0,0,0,0,0,0},                 //space
67.                         {0,32,32,32,32,32,0,32},           //!
68.                         {0,40,40,40,0,0,0,0},              //"
69.                         {0,36,36,254,40,252,80,80},        //#
70.                         {0,120,148,144,120,20,148,120},    //$
71.                         {0,196,204,24,48,96,204,140},      //%
72.                         {0,96,144,144,96,148,136,116},     //&
73.                         {0,16,16,16,0,0,0,0},              //'
74.                         {0,24,32,64,64,64,32,24},          //(
75.                         {0,96,16,8,8,8,16,96},             //)
76.                         {0,0,146,84,56,56,84,146},         //*
77.                         {0,16,16,16,254,16,16,16},         //+
78.                         {0,0,0,0,0,96,32,64},              //,
79.                         {0,0,0,0,252,0,0,0},               //-
80.                         {0,0,0,0,0,0,96,96},               //.
81.                         {0,4,12,24,48,96,192,128},         //  /
82.                         {0,0,96,96,0,0,96,96},             //:
83.                         {0,0,96,96,0,96,32,64},            //;
84.                         {0,0,192,48,12,48,192,0},          //>
85.                         {0,0,0,252,0,252,0,0},             //=
86.                         {0,0,12,48,192,48,12,0},           //<
87.                         {0,120,132,4,24,16,0,16},          //?
88.                         {0,56,32,32,32,32,32,56},          //[
89.                         {0,56,8,8,8,8,8,56},               //]
90.                         {16,40,68,0,0,0,0,0},              //^
91.                         {0,0,0,0,0,0,0,254},               //_
92.                         {0,24,32,32,64,32,32,24},          //{
93.                         {0,32,32,32,32,32,32,32},          //|
94.                         {0,96,16,16,8,16,16,96},           //}
95.                         {56,68,146,170,170,148,64,60},     //@
96.                         {0,112,0,176,200,136,136,136}};    //ñ

un saludo, espero sirva por ahora

hola q tal......... bueno revise el codigo y creo q te falta esta linea.......
int carries[6] le cambias por int carries[7], intentalo ............  suerte.....

buenos dias
soy nuevo en este foro
quisiera que me guiaran en mi poyecto que es parecido
estoy haciendo un publik de 5x55 con registros de ls164  con un micro de motorola jm60 en programa codewarrios
gracias

[gallo961]

hola a todos
la verdad soy nuevo aca
pero es interesante este foro y creo que aprendere mucho.
estoy haciendo un publik  de 5 filas po56 colomnas con 7 registros ls164  un micro jm60 de motorola on frecalee codewarrios y me carga una letra en todos los registros y corridos de arriba  hacia abajo tengo que dividir las letras en cada registro y correrlas horizontal
gracias agradezco una guia de ustedes que y lo realizaron.

[nediamolbap]

Saludo a todos,

Retomo este proyecto, ya he conseguido las matrices y componentes que me hacían falta. 

He estado intentando hacerlo funcionar, pero lo único que he conseguido es esto:

http://www.youtube.com/v/WGRzwn5dvXE

He probado con varios PIC16F628A, grabándolos desde el pickit2 y el MPLAB (sin errores).Tanto el pic como el registro tienen su correspondiente 104. He seguido algunos concejos dados en este mismo hilo por algunos usuarios, pero sigue igual. 

He probado con diferentes fuentes de 5v, 200mA-500mA. Con el regulador 7805 con fuente de 9 a 15V.

Adjunto el archivo que estoy grabando.
No se que mas hacer estaré atento a sus concejos.

[16f]

hola amigos , requiero la ayuda de ud , para poder hacer una matriz de 7 x72 con 2 filas,
la idea es controlar  el display desde un pc, yo puedo manejar el display con texto pero
no tengo idea como enviar caracteres y luego transformar a  pixel.

PC------------------micro---------------------panel  linea1 y linea 2
ya tengo el programita que envia el texto.,
saludos
 

[bigluis]

  Hola amigos de Todopic.

En esta ocasion traigo un código que sirve para imprimir caracteres y cadenas en una matriz de led de 7x5 (facilmente puede ser adaptada a mas).

A continuacion muestro el código del archivo principal

Código: [Seleccionar]

#include <Matriz.h>

#include <Fonts.c>

#use fast_io(ALL)

main(){
   set_tris_b(0);
   set_tris_a(0);
   output_b(0);
   output_a(0);
   while(1)
//!      Matrix_putc('h');                //Al descomentar esta linea y comentar la siguiente solo se mostrara la letra h
      printf(Matrix_putc,"hola TODOPIC"); //Al descomentar esta linea y comentar la anterior se mostrara hola TODOPIC caracter
}                                         //por caracter en la matriz de 7x5

Y el fichero donde se guardan las funciones y arreglos de caracteres necesarios para el funcionamiento del programa.

Código: [Seleccionar]

//La siguiente matriz almacena los pixeles de cada carecter que sera impreso
const unsigned char Fonts[96][5] = {
        {0x00, 0x00, 0x00, 0x00, 0x00},            // Code for char 
        {0x00, 0x06, 0x5F, 0x06, 0x00},            // Code for char !
        {0x07, 0x03, 0x00, 0x07, 0x03},            // Code for char "
        {0x24, 0x7E, 0x24, 0x7E, 0x24},            // Code for char #
        {0x24, 0x2B, 0x6A, 0x12, 0x00},            // Code for char $
        {0x63, 0x13, 0x08, 0x64, 0x63},            // Code for char %
        {0x36, 0x49, 0x56, 0x20, 0x50},            // Code for char &
        {0x00, 0x07, 0x03, 0x00, 0x00},            // Code for char '
        {0x00, 0x3E, 0x41, 0x00, 0x00},            // Code for char (
        {0x00, 0x41, 0x3E, 0x00, 0x00},            // Code for char )
        {0x08, 0x3E, 0x1C, 0x3E, 0x08},            // Code for char *
        {0x08, 0x08, 0x3E, 0x08, 0x08},            // Code for char +
        {0x00, 0xE0, 0x60, 0x00, 0x00},            // Code for char ,
        {0x08, 0x08, 0x08, 0x08, 0x08},            // Code for char -
        {0x00, 0x60, 0x60, 0x00, 0x00},            // Code for char .
        {0x20, 0x10, 0x08, 0x04, 0x02},            // Code for char /
        {0x3E, 0x51, 0x49, 0x45, 0x3E},            // Code for char 0
        {0x00, 0x42, 0x7F, 0x40, 0x00},            // Code for char 1
        {0x62, 0x51, 0x49, 0x49, 0x46},            // Code for char 2
        {0x22, 0x49, 0x49, 0x49, 0x36},            // Code for char 3
        {0x18, 0x14, 0x12, 0x7F, 0x10},            // Code for char 4
        {0x2F, 0x49, 0x49, 0x49, 0x31},            // Code for char 5
        {0x3C, 0x4A, 0x49, 0x49, 0x30},            // Code for char 6
        {0x01, 0x71, 0x09, 0x05, 0x03},            // Code for char 7
        {0x36, 0x49, 0x49, 0x49, 0x36},            // Code for char 8
        {0x06, 0x49, 0x49, 0x29, 0x1E},            // Code for char 9
        {0x00, 0x6C, 0x6C, 0x00, 0x00},            // Code for char :
        {0x00, 0xEC, 0x6C, 0x00, 0x00},            // Code for char ;
        {0x08, 0x14, 0x22, 0x41, 0x00},            // Code for char <
        {0x24, 0x24, 0x24, 0x24, 0x24},            // Code for char =
        {0x00, 0x41, 0x22, 0x14, 0x08},            // Code for char >
        {0x02, 0x01, 0x59, 0x09, 0x06},            // Code for char ?
        {0x3E, 0x41, 0x5D, 0x55, 0x1E},            // Code for char @
        {0x7E, 0x11, 0x11, 0x11, 0x7E},            // Code for char A
        {0x7F, 0x49, 0x49, 0x49, 0x36},            // Code for char B
        {0x3E, 0x41, 0x41, 0x41, 0x22},            // Code for char C
        {0x7F, 0x41, 0x41, 0x41, 0x3E},            // Code for char D
        {0x7F, 0x49, 0x49, 0x49, 0x41},            // Code for char E
        {0x7F, 0x09, 0x09, 0x09, 0x01},            // Code for char F
        {0x3E, 0x41, 0x49, 0x49, 0x7A},            // Code for char G
        {0x7F, 0x08, 0x08, 0x08, 0x7F},            // Code for char H
        {0x00, 0x41, 0x7F, 0x41, 0x00},            // Code for char I
        {0x30, 0x40, 0x40, 0x40, 0x3F},            // Code for char J
        {0x7F, 0x08, 0x14, 0x22, 0x41},            // Code for char K
        {0x7F, 0x40, 0x40, 0x40, 0x40},            // Code for char L
        {0x7F, 0x02, 0x04, 0x02, 0x7F},            // Code for char M
        {0x7F, 0x02, 0x04, 0x08, 0x7F},            // Code for char N
        {0x3E, 0x41, 0x41, 0x41, 0x3E},            // Code for char O
        {0x7F, 0x09, 0x09, 0x09, 0x06},            // Code for char P
        {0x3E, 0x41, 0x51, 0x21, 0x5E},            // Code for char Q
        {0x7F, 0x09, 0x09, 0x19, 0x66},            // Code for char R
        {0x26, 0x49, 0x49, 0x49, 0x32},            // Code for char S
        {0x01, 0x01, 0x7F, 0x01, 0x01},            // Code for char T
        {0x3F, 0x40, 0x40, 0x40, 0x3F},            // Code for char U
        {0x1F, 0x20, 0x40, 0x20, 0x1F},            // Code for char V
        {0x3F, 0x40, 0x3C, 0x40, 0x3F},            // Code for char W
        {0x63, 0x14, 0x08, 0x14, 0x63},            // Code for char X
        {0x07, 0x08, 0x70, 0x08, 0x07},            // Code for char Y
        {0x71, 0x49, 0x45, 0x43, 0x00},            // Code for char Z
        {0x00, 0x7F, 0x41, 0x41, 0x00},            // Code for char [
        {0x02, 0x04, 0x08, 0x10, 0x20},            // Code for char BackSlash
        {0x00, 0x41, 0x41, 0x7F, 0x00},            // Code for char ]
        {0x04, 0x02, 0x01, 0x02, 0x04},            // Code for char ^
        {0x80, 0x80, 0x80, 0x80, 0x80},            // Code for char _
        {0x00, 0x03, 0x07, 0x00, 0x00},            // Code for char `
        {0x20, 0x54, 0x54, 0x54, 0x78},            // Code for char a
        {0x7F, 0x44, 0x44, 0x44, 0x38},            // Code for char b
        {0x38, 0x44, 0x44, 0x44, 0x28},            // Code for char c
        {0x38, 0x44, 0x44, 0x44, 0x7F},            // Code for char d
        {0x38, 0x54, 0x54, 0x54, 0x08},            // Code for char e
        {0x08, 0x7E, 0x09, 0x09, 0x00},            // Code for char f
        {0x18, 0xA4, 0xA4, 0xA4, 0x7C},            // Code for char g
        {0x7F, 0x04, 0x04, 0x78, 0x00},            // Code for char h
        {0x00, 0x00, 0x7D, 0x40, 0x00},            // Code for char i
        {0x40, 0x80, 0x84, 0x7D, 0x00},            // Code for char j
        {0x7F, 0x10, 0x28, 0x44, 0x00},            // Code for char k
        {0x00, 0x00, 0x7F, 0x40, 0x00},            // Code for char l
        {0x7C, 0x04, 0x18, 0x04, 0x78},            // Code for char m
        {0x7C, 0x04, 0x04, 0x78, 0x00},            // Code for char n
        {0x38, 0x44, 0x44, 0x44, 0x38},            // Code for char o
        {0xFE, 0x22, 0x22, 0x22, 0x1C},            // Code for char p
        {0x1C, 0x22, 0x22, 0x22, 0xFE},            // Code for char q
        {0x44, 0x78, 0x44, 0x04, 0x08},            // Code for char r
        {0x08, 0x54, 0x54, 0x54, 0x20},            // Code for char s
        {0x04, 0x3E, 0x44, 0x24, 0x00},            // Code for char t
        {0x3C, 0x40, 0x20, 0x7C, 0x00},            // Code for char u
        {0x1C, 0x20, 0x40, 0x20, 0x1C},            // Code for char v
        {0x3C, 0x60, 0x30, 0x60, 0x3C},            // Code for char w
        {0x6C, 0x10, 0x10, 0x6C, 0x00},            // Code for char x
        {0x9C, 0xA0, 0x60, 0x3C, 0x00},            // Code for char y
        {0x64, 0x54, 0x54, 0x4C, 0x00},            // Code for char z
        {0x08, 0x3E, 0x41, 0x41, 0x00},            // Code for char {
        {0x00, 0x00, 0x77, 0x00, 0x00},            // Code for char |
        {0x00, 0x41, 0x41, 0x3E, 0x08},            // Code for char }
        {0x02, 0x01, 0x02, 0x01, 0x00},            // Code for char ~
        {0x3C, 0x26, 0x23, 0x26, 0x3C}             // Code for char 
        };

//Esta funcion se encarga de imprimir un caracter en la matriz de led de 7x5
//Si se utiliza en conjunto con la funcion printf se pueden imprimir cadenas
void Matrix_putc(char letter){
   int i,j,l,k=20;                  //declaramos i,j,l y k=20
   letter-=' ';                     //Al valor de letter le restamos el valor ASCII de ' ' que es 32
                                    //dandonos el puntero de la letra que sera impresa
   while(--k){                      //decrementamos k y mientras sea distinto de cero (20 Veces)
      for(i=0,j=1;i<5;i++,j<<=1){   //Para i=0,j=1 mientras isea menor a 5 incrementamos i en 1
                                    //y desplazamos el valor de j hacia la izquierda
         l=Fonts[letter][i];        //l almacenara el arreglo de pixeles de la columna a mostrar
         output_b(~l);              //Negamos el valor de l y lo mostramos por el puerto B
         delay_ms(5);               //Un retraso de 5ms para hacer visible el caracter
         output_a(j);               //PORTA igual a j encendiendo una de las columnas
         delay_us(1);               //Retardo de 1us antes de apagar columnas
         output_a(0);               //Apagamos las columnas
      }
   }
   delay_ms(100);                   //Retardo de 100ms antes de pasar al siguiente caracter.
}
A continuacion mustro el diagrama del circuito


Y finalmente el archivo adjunto con la simulacion y el código

[VOLTIO]

Buen dia  amigos del foro, quisiera saber algo que parece tonto (a lo mejor lo es ajaj) y es la distancia entre leds en un cartel led comercializable, esto es porque quiero hacer un cartel y quisiera que salga lo mas "profesional" posible, quisiera hacer del tamaño que tienen los micros de linea , que he visto son hermosos .
Bueno espero algun comentario al respecto, les envio un saludo cordial.
Atte.Ruben