De matriz de leds, a letrero electronico

[MLO__]

Hola.

La forma en que diseñe el código es para no depender de algún software adicional para programar el cartel, yo lo hacia con el hyperterminal. Pero, se puede hacer de otra manera: por medio de un software en el PC; el cual se encargaría de decodificar bit a bit lo que quieres hacer, luego guardaría esa info en la memoria y listo, el PIC del cartel solo se encargaría de volcar la información del memoria al cartel de LED. La ventaja de este último método es que se puede desplegar lo que quieras de una forma mucho mas sencilla  (animaciones) por ejemplo y podrías tener una infinidad de fuentes. Desventajas (para mi sobre todo) que hay que realizar un soft para PC que se encargue de hacer todo lo debido para enviar bytes a la memoria para que despliegue todo, además que si quieres animaciones y demás, la memoria externa debe ser grande, pero bueno, para eso están las SD Card.

Saludos

[Suky]

Muy buena MLO_!!! Yo estoy en pleno proceso, pero soldar leds me está dando mucha vagancia  Hice el soft con varias animaciones, la idea es usar USB para la conexión con la PC, cargar la cantidad de mensajes que se quieran en el soft con sus configuraciones, velocidad desplazamiento, animaciones, además de otros comandos especiales, como medir temperatura, hora, fecha, ect... Otra que tengo en mente es usar un 18F67J60 y trabajarlo por una pagina web    Pero todo eso lleva tiempo   


Saludos!

[fgaretto]

Muchas gracias MLO, Cryn y Suky, voy a seguir trabajando y seguramente les volveré a consultar.
Saludos.

[fgaretto]

Cryn, antes de seguir trabajando.....
Tu dijiste: "Todas las letras del abecedario tanto mayúsculas como minúsculas, y algunos signos los debes definir bit a bit de preferencia en la flash como constantes y tu string se encarga de cargar las letras correspondientes."
Estas definiciones(mayusculas, minusculas y signos) las puedo hacer en una EEprom externa (por ej 24lc256)? Y luego dependiendo del string que quiera (ya sea este declarado en la EEprom o ingresado por RS232) ir leyendo la EEprom para así después realizar el efecto que quiera?
Nuevamente gracias y buen fin de semana.
Fernando.

[Suky]

Revisa la librería graphics.c, ahí hay definida una fuente almacenada en la memoria de programa...


Saludos!

[Cryn]

Estas definiciones(mayusculas, minusculas y signos) las puedo hacer en una EEprom externa (por ej 24lc256)? Y luego dependiendo del string que quiera (ya sea este declarado en la EEprom o ingresado por RS232) ir leyendo la EEprom para así después realizar el efecto que quiera?
Nuevamente gracias y buen fin de semana.
Fernando.

Seguro que lo puedes hacer, pero perderás algún tiempo precioso quizá. Pienso que al leer constantemente las letras, cargar byte a byte cada letra (ya que una letra tendrá entre 5 a 8 bytes) de una memoria externa se perderá mucho más tiempo que leerlo de una memoria del micro como la flash.

Me parece que programas en C, tienes que declarar tus datos del abecedario como const en un arreglo y ya lo tienes en la flash.

De todas maneras dale una mirada a lo que te sugiere suky, puede que tengas una mejor respuesta.

saludos.

[bigluis]

Hola amigos.

He estado trabajando en una libreria que manda a imprimir los datos al letrero, pero en mi caso si utilizo los punteros.

A continuación escribo el código correspondiente a las letras.

Código: C++

1. //Font Generated by GLCD Font Creator 1.1.0 - mikroElektronika Edition
2. //Copyright 2009 Pocket MicroTechnics
3. //http://www.pocketmt.com
4.  
5. //FontName : matriz
6. //FontSize : 7 x 5
7.  
8. const unsigned short matriz[] = {
9.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char
10.         0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04,  // Code for char !
11.         0x0A, 0x0A, 0x0A, 0x00, 0x00, 0x00, 0x00,  // Code for char "
12.         0x0A, 0x0A, 0x1F, 0x0A, 0x1F, 0x0A, 0x0A,  // Code for char #
13.         0x0E, 0x14, 0x14, 0x0E, 0x05, 0x05, 0x1E,  // Code for char $
14.         0x19, 0x1A, 0x02, 0x04, 0x04, 0x0B, 0x0B,  // Code for char %
15.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char &
16.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char '
17.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char (
18.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char )
19.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char *
20.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char +
21.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char ,
22.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char -
23.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char .
24.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // Code for char /
25.         0x0E, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0E,  // Code for char 0
26.         0x04, 0x0C, 0x04, 0x04, 0x04, 0x04, 0x0E,  // Code for char 1
27.         0x06, 0x09, 0x01, 0x02, 0x04, 0x08, 0x1F,  // Code for char 2
28.         0x0E, 0x11, 0x01, 0x06, 0x01, 0x11, 0x0E,  // Code for char 3
29.         0x02, 0x06, 0x0A, 0x1F, 0x02, 0x02, 0x07,  // Code for char 4
30.         0x1F, 0x10, 0x1E, 0x01, 0x01, 0x11, 0x0E,  // Code for char 5
31.         0x0E, 0x10, 0x10, 0x1E, 0x11, 0x11, 0x0E,  // Code for char 6
32.         0x1F, 0x11, 0x01, 0x02, 0x02, 0x04, 0x04,  // Code for char 7
33.         0x0E, 0x11, 0x11, 0x0E, 0x11, 0x11, 0x0E,  // Code for char 8
34.         0x0E, 0x11, 0x11, 0x0F, 0x01, 0x01, 0x0E,  // Code for char 9
35.         0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00,  // Code for char :
36.         0x00, 0x04, 0x00, 0x04, 0x04, 0x08, 0x00,  // Code for char ;
37.         0x00, 0x03, 0x0C, 0x10, 0x0C, 0x03, 0x00,  // Code for char <
38.         0x00, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x00,  // Code for char =
39.         0x00, 0x18, 0x06, 0x01, 0x06, 0x18, 0x00,  // Code for char >
40.         0x0E, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04,  // Code for char ?
41.         0x0C, 0x12, 0x11, 0x05, 0x0B, 0x09, 0x06,  // Code for char @
42.         0x0E, 0x11, 0x11, 0x1F, 0x11, 0x11, 0x11,  // Code for char A
43.         0x1E, 0x11, 0x11, 0x1E, 0x11, 0x11, 0x1E,  // Code for char B
44.         0x0E, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0E,  // Code for char C
45.         0x1E, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1E,  // Code for char D
46.         0x1F, 0x10, 0x10, 0x1E, 0x10, 0x10, 0x1F,  // Code for char E
47.         0x1F, 0x10, 0x10, 0x1E, 0x10, 0x10, 0x10,  // Code for char F
48.         0x1F, 0x11, 0x10, 0x17, 0x15, 0x11, 0x1F,  // Code for char G
49.         0x11, 0x11, 0x11, 0x1F, 0x11, 0x11, 0x11,  // Code for char H
50.         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,  // Code for char I
51.         0x01, 0x01, 0x01, 0x01, 0x11, 0x11, 0x1F,  // Code for char J
52.         0x11, 0x12, 0x14, 0x18, 0x14, 0x14, 0x12,  // Code for char K
53.         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F,  // Code for char L
54.         0x11, 0x1B, 0x15, 0x11, 0x11, 0x11, 0x11   // Code for char M
55.         //Aqui puedes segir escribiendo el codigo correspondiente a los demas caracteres.
56.         };

A continuación escribo el código de las funciones que se encargan de hacer esto, y también un ejemplo de como utilizarlo.

Código: C++

1. #include "letras.c"
2.  
3. #define firstCLK PORTD.F3
4. #define secondCLK PORTD.F5
5. #define Enable  PORTD.F7
6. #define Reset   PORTD.F6
7. #define Data    PORTD.F4
8.  
9. //La siguiente funcion se encarga de transmitir los datos hacia los registros de desplazamiento
10.  
11. transmitir_registros(char DATO){
12.         short k=5;          //Declaramos k, quien controla las 5 columnas de los display
13.         do{                 //comenzamos el ciclo de transmision.
14.                 firstCLK = 0;     //ponemos el pin firstCLK a cero.
15.                 Data = DATO.F0;   //hacemos que el pin DATA sea igual al bit 0 de DATO (la letra a transmitir)
16.                 firstCLK = 1;     //ponemos el pin firstCLK a uno para almacenar el dato.
17.                 DATO >>= 1;       //Desplazamos hacia la derecha un bit la variable dato.
18.         }while(--k);        //predecrementamos el valor de k, y preguntamos si es cero para salir del ciclo.
19.         }
20.        
21. //La siguiente funcion se encarga de decodificar los datos correspondientes a cada letra, para luego
22. //transmitirlos a los registros que manejan las 5 columnas de cada display.
23.  
24. print_matriz5x7(const char *letras){
25.   char l,i=0,j=0;                       //l=letra a decodificar en ASCII, i=indice del display,
26.                                         //j=indice de la fila de la matriz de 5*7.
27.   char display[20];                     //display a los que se les transmitiran los datos
28.   do{                                   //Comienzo del ciclo de decodificacion y transmision
29.         while(l=*letras++)                    //almacenamos en l la letra a decodificar a partir del puntero
30.                                               //letras y luego lo posincrementamos
31.     display[i++]=matriz[(l- ' ')*7+j];  //Almacenamos el dato de cada letra en el arreglo display.
32.                                         //a l se le resta el valor ASCII del espacio, ya que es el primer
33.                                         //simbolo en la matriz de letras, a eso lo multiplicamos por 7 (# de filas)
34.                                         //y le sumamos j.
35.   letras-=i+1;                          //regresamos el puntero letras a la direccion inicial del string
36.         secondCLK=0;                          //ponemos a cero el pin secondCLK
37.         Reset=1;                              //ponemos a uno el pin Reset, para borrar el dato en los registros.
38.   while(i)                              //Mientras i sea distinto de cero
39.     transmitir_registros(display[--i]); //predecrementamos i, y transmitimos el valor de display[i].
40.   if(j) PORTB=(PORTB<<1)+1;             //Si j es distinto de cero, desplazamos 1 bit el PORTB.
41.   else PORTB=254;                       //de lo contrario PORTB=254
42.         secondCLK=1;                          //ponemos a uno el pin secondCLK
43.         Reset=0;                              //ponemos a cero el pin Reset, para almacenar los nuevos datos en los registros.
44.   }while(++j<8);                        //predecrementamos j, y mientras sea menor que 8 continuamos el ciclo.
45.   }
46.  
47. //Funcion Primcipal***************************************************************************************8
48.  
49. main(){  
50.         CMCON=7;                  //Apagamos los comparadores Analogicos
51.         TRISB=0;                  //Todo el puerto B como salida
52.         TRISC=0;                  //Todo el puerto C como salida
53.         TRISD=0;                  //Todo el puerto D como salida
54.   PORTC=6;                  //PORTC sera igual a 6.
55.   Enable=0;                 //ponemos a cero el pin Enable, para habilitar los registros.
56.   while(1)                  //inicio del ciclo infinito.
57.           print_matriz5x7("0123456789ABCDEFGHIK"); //Mandamos a imprimir la cadena a los display de 5x7.
58. }

El código fue hecho en MikroC v3.2, tambien adjunto los archivos correspondientes a la simulación y el código fuente

[Cryn]

buen aporte bigluis, muchas gracias

 

[marturetjulio]

hola saludos a todos los amigos del foro..queria solicitarles su ayuda en un codigo es acerca de una matriz de led 8x8 que estoy tratando de entender, ya lei los tutoriales del amigo ariel en ucontrol y pude avanzar un poco pero ahora tengo un problema y es que quisiera desplazar una letra atravez de la matriz ya logre escribirla pero no se como desplazarla...he visto los codigos de cryn y son realmente sorprendentes pero desafortunadamente son un poco complejos para mi por eso es que les coloco mi codigo para ver si este se puede adaptar para rotar la letra de izquierda a derecha o no se entender como hacerla porque he leido los codigos y no encuentro como adaptarlos al que yo hice...bueno espero no molestar mucho y de ante mano gracias por su ayuda les adjunto la simulacion y el codigo.


#include <18f452.h>
#fuses xt,nolvp,nowdt,noprotect
#use delay(clock=4000000)
#BYTE PORTB = 0x06
#BYTE PORTD = 0x08

int8 LETRA_A[8]={0X00, 0XFE, 0X11, 0X11, 0X11, 0X11, 0XFE, 0X00};   //la letra A
int1 columnas[16]={1,0,0,0,0,0,0,0};
int8 i=0;
int8 x=0;
int8 y;
//--------------------------------------------------
//Main----------------------------------------------
//--------------------------------------------------
void main(){
  set_tris_b(0);   
  set_tris_d(0);
  output_low(PIN_D0);
while (TRUE){
 for(x=0;x<=20;x++){
 for(i=0;i<=7;i++){
  delay_ms(1);
  output_bit(PIN_D1,columnas);
  delay_us(2);
  output_low(PIN_D0);
  delay_us(2);
  output_high(PIN_D0);
  output_b(~LETRA_A); 
  delay_ms(1);
}

}
 // shift_left(&LETRA_A,8,0);   
 rotate_left(&LETRA_A,8);
delay_ms(10);
}
}

[marturetjulio]

hola cryn no se si leiste mi post pero alguna vez intentaste rotar la letra en la matrix de led empleando la instrucion rotate_left, estoy intentando usar esa instruccion y ella se desplaza solo en 8 posiciones como podria hacer para que se siguiera desplazando

[Cryn]

Hola marturetjulio,

Si acabo de leer tu post y vi tu simulación. Esa forma de realizarlo no está mal, ya que es la que más o menos plantie con mi código, se debe considerar un buffer, es decir unas variables temporales (o arreglos de preferencia) donde iras haciendo la rotación de tu letra y posteriormente enviar tu buffer al registro de desplazamiento, y no enviar los datos tal como son rotados, ya que lo veo muy confuso y difícil al momento de manejar en código, por eso que tus datos se pierden y ya solo envías ceros al registro por eso no puedes ver más nada.

saludos.

[marturetjulio]

HOLA CRYN GRACIAS POR TU EXPLICACION PERO POR MAS QUE TRATE NO ME DABA ASI...ENTONCES BUSQUE ESTA EXPLICACION DEL AMIGO PALMER SOBRE COMO HACER EL DESPLAZAMIENTO, ES ESTA.

bueno te voy a explicar mas o menos espero darme a entender lo hago en c (ccs) pero creo que la teoria seria la misma para asm

1° lo que la matriz debe hacer es un barrido en todas las columnas n columnas (en mi caso es por columnas) yo utilizo un for,
    dentro del for va el encendido de las columnas, ya sea con 1 o 0 de acuerdo a tu conexion, tambien dentro de ese mismo for
    le doy un valor al puertob que encenderia las filas (seria el dato), para probar le damos el mismo valor de i y tendrias lo que tu mencionas
    un mensaje fijo puede que salga al reves o algo asi pero no te preocupes ya lo cmpondremos

2° un segundo for lo utilizo para repetir n veces una misma posicion para el valor del puertob (filas), o sea repetir n veces el for anterior,

3° aqui esta el meollo del asunto, para poder desplazar el mensaje necesitas tener una referencia de donde empezar o terminar,
    y utilizo un tercer for que es un contador.... podria llamarlo contador general, entonces, este contador le dara el valor de desplazamiento
    a la matriz.

en lenguaje ccs quedaria algo asi:

3er for(cont=0;cont<capacidad de memoria;cont++)
      {
       dir_de_mem=cont; esto te dara el desplazamiento
       2° for(j=0;j<numero de repeticiones por posicion;j++)
           {
            1er for(i=;i<;i++)
                  {
                   porta=i;
                   portb=origen_de_datos(dir_de_mem--);
                   retardo(de unos 25 ms);
                   }
            }
       }

en resumen: el barrido, el numero de repeticiones por posición y el desplazamiento.


Y  TRATE DE ENTENDERLA Y PUDE HACER EL CODIGO, AHORA SI SE DESPLAZA HACIA LA IZQUIERDA PERO NO SE PORQUE SALE COMO UN SUCIO QUE AFECTA LA DATA QUE SALE Y QUE SE VA DEZPLAZANDO...ME PREGUNTABA SI ALGUNO DE LOS AMIGOS PODIA HECHARLE UNA MIRADA Y VER EL PORQUE  ESTE ES EL CODIGO Y LA SIMULACION..GRACIAS DE ANTEMANO A TODOS POR POSTEAR SUS PROYECTOS Y GRACIAS A DIOS POR CREAR PERSONAS TAN AMABLES COMO LO SON LA MAYORIA DE LOS QUE AYUDAN EN EL FORO..SALUDOS


#include <18f452.h>
#fuses xt,nolvp,nowdt,noprotect
#use delay(clock=4000000)
#BYTE PORTB = 0x06
#BYTE PORTD = 0x08


int LETRA_J[8]={0X40, 0X80, 0X81, 0X81, 0X7F, 0X01, 0X01, 0X00};   //la letra J
int LETRA_U[8]={0X00, 0X7F, 0X80, 0X80, 0X80, 0X80, 0X7F, 0X00};   //la letra U
int LETRA_L[8]={0X00, 0XFF, 0X80, 0X80, 0X80, 0X80, 0X80, 0X00};   //la letra L
int LETRA_I[8]={0X00, 0X81, 0X81, 0XFF, 0X81, 0X81, 0X00, 0X00};   //la letra I
int LETRA_O[8]={0X00, 0X3C, 0X42, 0X81, 0X81, 0X81, 0X42, 0X3C};   //la letra O
int LETRA_M[8]={0X00, 0XFF, 0X02, 0X04, 0X04, 0X02, 0XFF, 0X00};   //la letra M
int1 columnas[49]={1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int8 i=0;
int8 x=0,z;
int8 y;
//--------------------------------------------------
//Main----------------------------------------------
//--------------------------------------------------
void main(){
  set_tris_b(0);   
  set_tris_d(0);
  output_low(PIN_D0);
  output_b(0);
while (TRUE){
 for(y=49;y>0;y--){
 z=y;
 for(x=0;x<=1;x++){
 output_b(0);
 for(i=0;i<=49;i++){
  delay_ms(1);
  output_bit(PIN_D1,columnas);
  delay_us(2);
  output_low(PIN_D0);
  delay_us(2);
  output_high(PIN_D0);   
  output_b(~LETRA_J[z++]);
}

}
}
}
}

[Cryn]

Hola marturetjulio,

Bueno es difícil saber porque sucede ese paso de la basurita, pero al menos ya haz logrado un muy buen avance.

Me parece que estás refrescando por columnas, y eso no está mal, pero no es lo adecuado al menos para este cartel de más columnas que filas, lo mejor es enviar el dato de las columnas a los registros de desplazamiento fila por fila y mediante un puerto completo y transistores encender solamente una fila a la vez, se debe a muy alta velocidad ver más o menos algo así

Te recomiendo que veas ese hilo completo hay muy buenos conceptos y sugerencias para un mejor manejo de un cartel. Ya que la idea es lo principal y de ahí se pasa al lenguaje que más gustes.

Y para un mejor manejo de los mensajes, teniendo almacenado todo el abecedario de preferencia en la memoria flash del micro y guardar el mensaje que se va a pasar por el cartel directamente como cadena ASCII, te recomiendo ver y tratar de entender el código que deje en este tema.

saludos.

[marturetjulio]

hola amigo pero como podría hacer esto...

"Me parece que estás refrescando por columnas, y eso no está mal, pero no es lo adecuado al menos para este cartel de más columnas que filas, lo mejor es enviar el dato de las columnas a los registros de desplazamiento fila por fila y mediante un puerto completo y transistores encender solamente una fila a la vez"

fijate yo entiendo que debo enviar bit a bit al registro de desplazamiento...corrigeme si me equivoco..y si es asi como podria enviar el dato de 8 bits que antes enviaba por las filas por el registro de desplazamiento...disculpame tanta molestia es solo que me gusta aprender bien las cosas..leí los codigos y el que tu me colocaste tambien pero hay instrucciones que no se como trabajan por ejemplo esta load_letra(mensaje[msj][letra]);   se supone que load_letra(int caracter) es una funcion que debe llevar dentro un caracter pero en ves de eso esta mensaje[msj][letra]    osea 2 arreglos naguara alli me perdi y claro en muchas otras cosas jeje pero eso nunca lo habia visto disculpa mi ignorancia pero en ese caso se multiplican o se suman los valores de los arreglos o que ocurre en esos casos porque eso no lo habia visto yo antes...voy a tratar de buscarlo

[Cryn]

Lo que deberías hacer es enviar los datos de todas las columnas correspondientes a una fila primeramente a los registros de desplazamiento, después las columnas de toda la otra fila y así sucesivamente...

fijate yo entiendo que debo enviar bit a bit al registro de desplazamiento...corrigeme si me equivoco..y si es asi como podria enviar el dato de 8 bits que antes enviaba por las filas por el registro de desplazamiento...

Tendrías que hacer precisamente eso, coger bit a bit y enviarlo al registro de desplazamiento, para ello te puede ayudar la función output_bit dentro de un ciclo for e ir desplazando bit a bit cada byte, más o menos como hice en mi función void cargar(int datob) en el código.

hay instrucciones que no se como trabajan por ejemplo esta load_letra(mensaje[msj][letra]);   se supone que load_letra(int caracter) es una funcion que debe llevar dentro un caracter pero en ves de eso esta mensaje[msj][letra]    osea 2 arreglos

Efectivamente load_letra es una función que recibe un byte como parámetro y por tanto mensaje[msj][letra] hace referencia a un byte, mensaje[ x ][ y ] es un arreglo bidimensional de bytes o también casualmente conocida como matriz.

Una matriz tiene 2 indices, va más o menos así:

matriz[3][3]= 1   2   3
                   4   5   6
                   7   8   9

el ejemplo que te puse es una matriz 3x3 en CCS la declaras así:

int8 matriz[3][3]={{1,4,7},{2,5,8},{3,6,9}};
y para llamar/usar a los datos/bytes de la matriz usas 2 indices, como un 'x' y 'y' del sistema cartesiano, para nuestro ejemplo:
matriz[1][1]=1
matriz[1][2]=4
matriz[1][3]=7
....
matriz[3][2]=6
matriz[3][3]=9

Para que complicarme la vida si podría usar un arreglo unidimensional? y hacer:
int array[9]={1,2,3,4,5,6,7,8,9};
simplemente yo escogí usar la bidimensional, ya que al usar los 2 índices me era más fácil desplazarme con todos los datos que el cartel necesitaba.


Es un poco complicado para mi explicar estás ideas, pues al inicio es también un mundo algo complicado esto de los carteles, cuando comprendas algunas ideas de su funcionamiento te será más fácil programarlas.

Lo que te recomiendo es que leas más detenidamente los consejos y sugerencias que hay en el primer link que te deje en mi anterior post, y quizá las imágenes que dejé en ese mismo link, en la respuesta #50 que publiqué en ese hilo puse unas imágenes que explican a grandes rasgos más o menos como va el asunto.

La idea del arreglo bidimensional que usé para el código de mi cartel quizá no sea la correcta, pero al menos me sirvió de mucho para empezar y comprender la idea de los carteles.

saludos.