Mi nueva matriz de led

[korpaztk]

Bueno... por donde comenzar...
el año pasado, empece con este asunto de las matrices de led basicamente con una pequeña de 8 x 8, de la cual habia visto en la pagina de ucontrol, estuve meses dando vuelta para construirla (ya que en programacion en la escuela dabamos muy poco por distintos motivos), el costo aqui en mi zona por los led era demasiado caro lo q me llevo a pedirlos a otro lado, lo cual empece a seguir dando vueltas y buscando mucha informacion en internet, al principio me costo muchisimo entender como se formaba una letra ( ahora no jeje)
[
este fue el primero que hice, con imagenes ya precargadas, ya q tampoco sabia utilizar el puerto serie.

ahora estoy en mi nueva matriz que tiene 36 columnas y 7 filas.

el chip esta programado en lenguaje c, pero no esta hecho por mi sino por

http://www.todopic.com.ar/foros/index.php?topic=28409.20

que la verdad muy bueno el codigo yo lo habia montado en el pic que puso en su programa (uno prestado) y me funciono perfecto, luego al codigo le hice unas pequeñas modifiaciones ya que el pic que utilizo yo es otro, nada mas ni nada menos que el conocido pic16f877a ( el disponible aqui en la zona tambien),

todavia no alcance a terminarlo, porque estoy viendo que tengo algunos problemitas, (porque el micro tiene ya algunos problemas en algunas patitas de sus puertos asiq tuve q arreglar temporariamente el programa del micro para q funcione...
pero ahi es donde llego mi nuevo problema, no me muestra bien los caracteres.
EJ:

Letra A:

00100                        00100
01010                        01010
10001                        01001
10001    Y me sale ==> 10001
11111                        11011
10001                        10001
10001                        10000

nose puede apreciar bien, pero los muestra a veces con led encendidos de mas,
pero buenooo ya con mi nuevo pic y volviendo el programa al estado anterior creeria que se solucionara.

aqui unas imagenes de como va el proyecto


y aqui otra


algunas ya muestro cuando esta funcionando con una parte nomas del cartel, ya que las placa las consegui de 20 x 10 solamente para poder armar 7 filas por 18 columnas,





mas adelante cuando apenas consiga el nuevo pic procedere a continuarlo y poder terminarlo
mientras tanto continuare posteando mis avance...

por ahora me despido, y muchas gracias a todos los que me han ayudado y a los que no tambien, porque he aprendido que no todo viene de arriba.-

[korpaztk]

la verdad que me esta llevando meses hacerlo, no por tema de tiempos sino por $$$, y bue tengo recien 19 y el año pasado me recibi de tecnico electronico, y ya tengo muchas ideas en mente pero buee, como muchos de aqui de este foro dicen, lo agrego en mi lista, y ojala los pueda ahcer a la gran mayoria, y obviamente dejarlos acentados aqui para q muchos lo puedan ver y hacer.

[korpaztk]

el video que prometi  


bueno lo dejo asi con el enlace porque no se como hacer para que el video aparezca en el foro si despues alguien me da una mano para se vea le agradezco un monton =)

[Miquel_S]

Hola korpaztk, el enlace no funca.

Saludos.

[korpaztk]

gracias por avisar, ni me habia dado cuenta, ahora si funciona =)

[stk500]

En Hora buenas Korpaytk , da alegria  ver acabado tu proyecto.

Saludos

[korpaztk]

ya mas adelante cuando tnga un poco mas de $$ jeje comprare un gabinete para hacerlo quedar mas elegante, ahora es la hora de empezar a insertarle efectos que es dond viene la parte dificil jeje, como hacer q aparezcan de arriba o q aparezcan mitad y mitad de las palabras por los costados y se peguen y demas pero buee...

[korpaztk]

Código: [Seleccionar]

//***************E N C A B E Z A D O  P R I N C I P A L
#include <16f877A.h>
#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
#byte porta = 0x05
#byte portb = 0x06
#byte portc = 0x07
#byte portd = 0x08
#byte t1con = 0x0fcd
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#priority rda,timer1
//******************************************************************
#define uno PIN_B0
#define dos PIN_D2
//V A R I A B L E S
int1 ban_recibir;
int1 ban_tmr1;
int1 ban_espacio;
int con_recibir;
int con_columnas;
int fin_columnas;
int con_caracter;
int con_espacio;
char cadena[96];
int columnas[36];
int mof=0x00;
int yu;
int fijo1;

//******************************

//S U B R U T I N A S************
void display(void);
void display_1(void);
void display_2 (void);
void rotar_mensaje(void);
//void rotar_mensaje_1(void);
//void rotar_columnas(void);
//void rotar_columnas_1(void);
//*******************************


//V A R I A B L E S  D E  C A R A C T E R E S

int const tab_espacio[] = {
0b00000000,
0b00000000,
0b00000000,
};

int const tab_admiracion[] = {
0b11110110,
0b11110110,
};

int const tab_comilla[] = {
0b11100000,
0b11100000,
0b00000000,
0b11100000,
0b11100000,
};

int const tab_numero[] = {
0b00101000,
0b11111110,
0b00101000,
0b11111110,
0b00101000,
};

int const tab_moneda[] = {
0b00100100,
0b01010100,
0b11111110,
0b01010100,
0b01001000,
};

int const tab_porcentaje[] = {
0b01100100,//0x32
0b01101000,//0x34
0b00010000,//0x08
0b00101100,//0x16
0b01001100,//0x26
};

int const tab_and[] = {
0b01101100,
0b11111110,
0b10010010,
0b10101010,
0b01000110,
0b00111010,
};

int const tab_apostrofo[] = {
0b11010000,
0b11100000,
};

int const tab_parent_a[] = {
0b00111000,
0b01000100,
0b10000010,
};

int const tab_parent_b[] = {
0b10000010,
0b01000100,
0b00111000,
};

int const tab_asterisco[] = {
0b00101000,
0b00010000,
0b01111100,
0b00010000,
0b00101000,
};

int const tab_mas[] = {
0b00010000,
0b00010000,
0b01111100,
0b00010000,
0b00010000,
};

int const tab_coma[] = {
0b00011010,
0b00011100,
};

int const tab_menos[] = {
0b00010000,
0b00010000,
0b00010000,
0b00010000,
0b00010000,
};

int const tab_punto[] = {
0b00000110,
0b00000110,
};

int const tab_slash[] = {
0b00000100,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
};

int const tab_0[] = {
0b01111100,
0b11111110,
0b10010010,
0b10100010,
0b01111100,
};

int const tab_1[] = {
0b01000010,
0b11111110,
0b11111110,
0b00000010,
};

int const tab_2[] = {
0b01100110,
0b10001110,
0b10011010,
0b11110010,
0b01100010,
};

int const tab_3[] = {
0b11000100,
0b10010010,
0b10110010,
0b11111110,
0b11001100,
};

int const tab_4[] = {
0b00011000,
0b00101000,
0b01001000,
0b11111110,
0b11111110,
0b00001000,
};

int const tab_5[] = {
0b11100100,
0b11100010,
0b10100010,
0b10111110,
0b10011100,
};

int const tab_6[] = {
0b01111100,
0b11111110,
0b10100010,
0b10100010,
0b00011100,
};

int const tab_7[] = {
0b11000110,
0b10001110,
0b10011000,
0b11110000,
0b11100000,
};

int const tab_8[] = {
0b01101100,
0b11111110,
0b10010010,
0b10010010,
0b01101100,
};

int const tab_9[] = {
0b01110000,
0b10001010,
0b10001010,
0b11111110,
0b01111100,
};

int const tab_dos_puntos[] = {
0b01101100,
0b01101100,
};

int const tab_punto_coma[] = {
0b01101010,
0b01101100,
};

int const tab_menor[] = {
0b00010000,
0b00101000,
0b01000100,
0b10000010,
};

int const tab_igual[] = {
0b00101000,
0b00101000,
0b00101000,
0b00101000,
};

int const tab_mayor[] = {
0b10000010,
0b01000100,
0b00101000,
0b00010000,
};

int const tab_interrogante[] = {
0b01000000,
0b10001010,
0b10011010,
0b11110000,
0b01100000,
};

int const tab_arroba[] = {
0b01001100,
0b10010010,
0b10011110,
0b10000010,
0b01111100,
};
//////////////////////////////////////////////////////////////
int const tab_A[] = {
0b01111110,
0b11111110,
0b10001000,
0b10001000,
0b01111110,
};

int const tab_B[] = {
0b11111110,
0b11111110,
0b10010010,
0b10010010,
0b01101100,
};

int const tab_C[] = {
0b01111100,
0b11111110,
0b10000010,
0b10000010,
0b01000100,
};

int const tab_D[] = {
0b11111110,
0b11111110,
0b10000010,
0b10000010,
0b01111100,
};

int const tab_E[] = {
0b11111110,
0b11111110,
0b10010010,
0b10010010,
0b10000010,
};

int const tab_F[] = {
0b11111110,
0b11111110,
0b10010000,
0b10010000,
0b10000000,
};

int const tab_G[] = {
0b01111100,
0b11111110,
0b10010010,
0b10010010,
0b10011110,
};
////////////////////////////////////////////////////////
int const tab_H[] = {
0b11111110,
0b11111110,
0b00010000,
0b00010000,
0b11111110,
};

int const tab_I[] = {
0b10000010,
0b11111110,
0b11111110,
0b10000010,
};

int const tab_J[] = {
0b00001100,
0b10000010,
0b11111110,
0b11111100,
0b10000000,
};

int const tab_K[] = {
0b11111110,
0b11111110,
0b00110000,
0b01001000,
0b10000110,
};

int const tab_L[] = {
0b11111110,
0b11111110,
0b00000110,
0b00000110,
0b00000110,
};

int const tab_M[] = {
0b11111110,
0b11111110,
0b01000000,
0b00100000,
0b01000000,
0b11111110,
};

int const tab_N[] = {
0b11111110,
0b11111110,
0b00010000,
0b00001000,
0b11111110,
};

int const tab_enie_1 [] = {
0b00111110,
0b10111110,
0b01001000,
0b10000100,
0b10111110,
};

int const tab_O[] = {
0b01111100,
0b11111110,
0b10000010,
0b10000010,
0b01111100,
};

int const tab_P[] = {
0b11111110,
0b11111110,
0b10010000,
0b10010000,
0b01100000,
};

int const tab_Q[] = {
0b01111100,
0b11111110,
0b10000010,
0b10000110,
0b01111110,
};

int const tab_R[] = {
0b11111110,
0b11111110,
0b10010000,
0b10011000,
0b01100110,
};

int const tab_S[] = {
0b01100100,
0b11110010,
0b10010010,
0b10011110,
0b01001100,
};

int const tab_T[] = {
0b10000000,
0b11111110,
0b11111110,
0b10000000,
};

int const tab_U[] = {
0b11111100,
0b11111110,
0b00000010,
0b00000010,
0b11111100,
};

int const tab_V[] = {
0b11111000,
0b11111100,
0b00000010,
0b00000100,
0b11111000,
};

int const tab_W[] = {
0b11111100,
0b11111110,
0b00000100,
0b00001000,
0b00000100,
0b11111110,
};

int const tab_X[] = {
0b11000110,
0b11101000,
0b00010000,
0b00101110,
0b11001110,
};

int const tab_Y[] = {
0b11000000,
0b00100010,
0b00111110,
0b00111100,
0b11000000,
};

int const tab_Z[] = {
0b10001110,
0b10011110,
0b10110010,
0b11100010,
0b11000010,
};

int const tab_lla_a[] = {
0b11111110,
0b10000010,
0b10000010,
};

int const tab_sim1[] = {
0b1010100,
0b0110100,
0b0011111,
0b0110100,
0b1010100,
};

int const tab_lla_b[] = {
0b10000010,
0b10000010,
0b11111110,
};

int const tab_sim2[] = {
0b00100000,
0b01000000,
0b10000000,
0b01000000,
0b00100000,
};

int const tab_ul[] = {
0b00000010,
0b00000010,
0b00000010,
0b00000010,
0b00000010,
};


int const tab_dia[] = {
0b10000000,
0b01000000,
0b00100000,
};

int const tab_aa[] = {
0b00000100,
0b00101010,
0b00101010,
0b00111110,
0b00011110,
};

int const tab_bb[] = {
0b11111110,
0b11111110,
0b00100010,
0b00100010,
0b00011100,
};

int const tab_cc[] = {
0b00011100,
0b00111110,
0b00100010,
0b00100010,
0b00000100,
};

int const tab_dd[] = {
0b00011100,
0b00100010,
0b00100010,
0b11111110,
0b11111110,
};

int const tab_ee[] = {
0b00011100,
0b00111110,
0b00101010,
0b00101010,
0b00010000,
};

int const tab_ff[] = {
0b00010000,
0b01111110,
0b11111110,
0b10010000,
0b01000000,
};

int const tab_gg[] = {
0b00110010,
0b01001010,
0b01111110,
0b00111100,
};

int const tab_hh[] = {
0b11111110,
0b11111110,
0b00100000,
0b00100000,
0b00011110,
};

int const tab_ii[] = {
0b00100010,
0b10111110,
0b10111110,
0b00000010,
};

int const tab_jj[] = {
0b00000100,
0b00100010,
0b10111110,
0b10111100,
};

int const tab_kk[] = {
0b11111110,
0b01111110,
0b00001000,
0b00010100,
0b00100010,
};

int const tab_ll[] = {
0b00000010,
0b11111110,
0b11111110,
0b10000010,
};

int const tab_mm[] = {
0b00111110,
0b00011110,
0b00100000,
0b00011110,
0b00100000,
0b00011110,
};

int const tab_nn[] = {
0b00111110,
0b00011110,
0b00100000,
0b00100000,
0b00011110,
};

int const tab_enie_2[] = {
0b10111110,
0b00011110,
0b00100000,
0b10100000,
0b10011110,
};

int const tab_oo[] = {
0b00011100,
0b00111110,
0b00100010,
0b00100010,
0b00011100,
};

int const tab_pp[] = {
0b01111110,
0b01111110,
0b01001000,
0b01001000,
0b00110000,
};

int const tab_qq[] = {
0b00110000,
0b01001000,
0b01001000,
0b01111110,
0b01111110,
};

int const tab_rr[] = {
0b00111110,
0b00011110,
0b00100000,
0b00100000,
0b00010000,
};

int const tab_ss[] = {
0b00010010,
0b00111010,
0b00101110,
0b00100100,
};

int const tab_tt[] = {
0b00100000,
0b11111100,
0b11111110,
0b00100010,
0b00000100,
};

int const tab_uu[] = {
0b00111100,
0b00000010,
0b00000010,
0b00111100,
0b00111110,
};

int const tab_vv[] = {
0b00111000,
0b00111100,
0b00000010,
0b00000100,
0b00111000,
};

int const tab_ww[] = {
0b00111110,
0b00111100,
0b00000010,
0b00001100,
0b00000010,
0b00111100,
};

int const tab_xx[] = {
0b00100010,
0b00010100,
0b00001000,
0b00010100,
0b00100010,
};

int const tab_yy[] = {
0b00110000,
0b00001010,
0b00001010,
0b00111110,
0b00111100,
};

int const tab_zz[] = {
0b00100010,
0b00100110,
0b00101110,
0b00111010,
0b00110010,
};

int const tab_cor1[] = {
0b00010000,
0b01101100,
0b10000010,
0b10000010,
};

int const tab_sim3[] = {
0b11111110,
};

int const tab_cor2[] = {
0b10000010,
0b10000010,
0b01101100,
0b00010000,
};

int const tab_fle1[] = {
0b00010000,
0b00010000,
0b01010100,
0b00111000,
0b00010000,
};

int const tab_fle2[] = {
0b00010000,
0b00111000,
0b01010100,
0b00010000,
0b00010000,
};

///////////////////////////////////////////////////////////////////////////////
#int_timer1 //Vector de interrupcion por desbordamiento del
//timer 1
void interrupcion_tmr1(void)
{
delay_us(2); //tiempo de 250 ms
set_timer1(3048);
ban_tmr1 = 0x01;
}

///////////////////////////////////////////////////////////////////////////////
#int_rda     //Vector de interrupcion de la recepcion de datos
void interrupcion_rx(void) //por el usart
{
char respaldo;

respaldo = getc(); //Se lee el dato recibido con el código 13 (enter) se da inicio a la
//escritura de datos en la matriz y con el código 27 (escape) se finaliza
//la recepcion de datos
if(ban_recibir == 0x01)
{
cadena[con_recibir] = respaldo;
delay_us(10);
con_recibir++;
delay_us(10);
putc(respaldo);
delay_us(10);


}

if(respaldo == 0x0D)
{
ban_recibir = 0x01;
delay_us(10);
con_recibir = 0x00;
delay_us(10);
memset(columnas,0,sizeof(columnas));
delay_us(2);
mof = 0x01;
delay_us(10);
fijo1=0x00;
}



if(respaldo == 0x1B)
{
ban_recibir = 0x00;
delay_us(10);
con_caracter = 0x00;
delay_us(10);
con_columnas = 0x00;
delay_us(10);
yu=0x00;
}

}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

#zero_ram //Borrado de la memoria ram

void main(void) //Rutina principal
{
set_tris_a(0X00);
set_tris_b(0X00);
set_tris_c(0X80);
set_tris_d(0X00);
port_b_pullups(false);
setup_timer_1(t1_internal | t1_div_by_4);
setup_adc_ports(no_analogs);
set_timer1(0);


//se carga en la matriz todos los caracteres ascii

for(con_recibir = 32; con_recibir <=128; con_recibir++)
{
cadena[con_recibir-32] = con_recibir;
}

cadena[95] = 27;

enable_interrupts(global); //habilitación de todas las interrupciones
enable_interrupts(int_rda); //habilitación de la interrupción de la recepcion de datos
enable_interrupts(int_timer1); //habilitación de la interrupción del Tmr1
disable_interrupts(int_ext);
disable_interrupts(int_rtcc);
disable_interrupts(int_timer2);
disable_interrupts(int_rb);
mof=0x00;
portb=0;
portd=0;
while(true)
{
///////////////////////////////////////////////////////////////////////////////
while(mof == 0x00) //Rutina general
{
mof=0x00;
delay_us(10);
display();

if(ban_tmr1 == 0x01)
{
ban_tmr1 = 0x00;
delay_us(10);
rotar_mensaje();
mof=0x00;
}
}
///////////////////////////////////////////////////////////////////////////////
while(mof == 0x01)
{
char key=0x00;
disable_interrupts(global);
PUTS("Presione 1 para texto fijo");
delay_ms(100);
PUTS("Presione 2 para texto movil");
delay_ms(100);
PUTS("Presione 3 para texto movil (acelerado)");
delay_ms(100);
do
{
key=getc();

}while (key != 49 && key != 50 && key != 51);

 
if(key == 49)
{
mof= 0x02;
PUTS("Ingrese su texto acontinuacion (Permitido Solo 5 Caracteres)");
delay_ms(2000);
PUTS("\f");
enable_interrupts(global);
mof=0x02;
delay_us(20);
ban_recibir = 0x01;
delay_us(10);
con_recibir = 0x00;
delay_us(10);
}
if(key == 50)
{
mof=0x00;
PUTS("Ingrese su texto acontinuacion");
delay_ms(2000);
PUTS("\f");
enable_interrupts(global);
mof=0x00;
ban_recibir = 0x01;
delay_us(10);
con_recibir = 0x00;
delay_us(10);

}

if(key == 51)
{
mof=0x03;
PUTS("Ingrese su texto acontinuacion");
delay_ms(2000);
PUTS("\f");
enable_interrupts(global);
mof=0x03;
ban_recibir = 0x01;
delay_us(10);
con_recibir = 0x00;
delay_us(10);

}


}

///////////////////////////////////////////////////////////////////////////////
while(mof == 0x02)

{

int fijo;
fijo=yu;
delay_us(10);
display_1();
if(ban_recibir == 0x00)
{
if(fijo <= 0x24)
{
if(ban_tmr1 == 0x01)
{
ban_tmr1 = 0x00;
delay_us(10);

rotar_mensaje();
mof=0x02;
fijo = fijo+0x01;
fijo1=fijo1+0x01;
}
yu = fijo;
}
}




///////////////////////////////////////////////////////////////////////////////////



}
while(mof == 0x03) //Rutina general
{
mof=0x03;
delay_us(10);
display_2();
rotar_mensaje();
if(ban_tmr1 == 0x01)
{
ban_tmr1 = 0x00;
delay_us(10);
rotar_mensaje();
mof=0x03;
}

}

}
}
///////////////////////////////////////////////////////////////////////////////

void display(void) //rutina general que refresca las columnas de la matriz
{

int i;
mof=0x00;
output_low(PIN_D0); //Desactivo Registro
delay_us(2);
output_high(PIN_D0); //Activo Registro
delay_us(2);
output_high(PIN_D1); //Dato en uno
delay_us(2);


for(i=0;i<36;i++)
{
portb = 0;
delay_us(2);
output_high(PIN_C3); //Activo el clock
delay_us(2);
output_low(PIN_C3); //Desactivo el clock
delay_us(2);
portb = columnas[i]; //Cargo en el puerto b el valor que alla en la cadena COLUMNAS
delay_us(500);
output_low(PIN_D1); //Dato en cero
delay_us(2);

}


}


void display_1(void)
{
int i;
mof=0x02;
output_low(PIN_D0); //Desactivo Registro
delay_us(2);
output_high(PIN_D0); //Activo Registro
delay_us(2);
output_high(PIN_D1); //Dato en uno
delay_us(2);

for(i=0;i<36;i++)
{
portb = 0;
delay_us(2);
output_high(PIN_C3); //Activo el clock
delay_us(2);
output_low(PIN_C3); //Desactivo el clock
delay_us(2);
portb = columnas[i];     //Cargo en el puerto b el valor que alla en la cadena COLUMNAS
delay_us(450);
output_low(PIN_D1); //Dato en cero
delay_us(2);

}
}
////////////////////////////////////////////////////////////////////////////////
void display_2(void) //rutina general que refresca las columnas de la matriz
{

int i;
mof=0x03;
output_low(PIN_D0); //Desactivo Registro
delay_us(2);
output_high(PIN_D0); //Activo Registro
delay_us(2);
output_high(PIN_D1); //Dato en uno
delay_us(2);

for(i=0;i<36;i++)
{
portb = 0;
delay_us(2);
output_high(PIN_C3); //Activo el clock
delay_us(2);
output_low(PIN_C3); //Desactivo el clock
delay_us(2);
portb = columnas[i];     //Cargo en el puerto b el valor que alla en la cadena COLUMNAS
delay_us(100);
output_low(PIN_D1); //Dato en cero
delay_us(2);

}


}


///////////////////////////////////////////////////////////////////////////////
void rotar_mensaje(void) //rutina general que recorre la matriz cadena y descompone los carateres
{ //en columnas
int respaldo;
int i;
if(ban_recibir == 0x01) //Consulta si se presiono Enter
{
return;
}

if(ban_espacio == 0x01)
{

for(i=0x27; i>0x00; i--)
{
columnas[i] = columnas[i-1];
}

columnas[0] = 0x00;
con_espacio++;

if(con_espacio == 0x02)
{
ban_espacio = 0x00;
con_espacio = 0x00;
}
return;


}
///////////////////////////////////////////////////////////////////////////////////
//cuando encuatra el codigo 27 (escape) reinicia el mensaje
if(cadena[con_caracter] == 27)
{
con_caracter = 0;
con_columnas = 0;
return;
}
///////////////////////////////////////////////////////////////////////////////////


switch(cadena[con_caracter])
{
case 32: respaldo = tab_espacio[con_columnas]; fin_columnas = sizeof(tab_espacio); break;
case 33: respaldo = tab_admiracion[con_columnas]; fin_columnas = sizeof(tab_admiracion); break;
case 34: respaldo = tab_comilla[con_columnas]; fin_columnas = sizeof(tab_comilla); break;
case 35: respaldo = tab_numero[con_columnas]; fin_columnas = sizeof(tab_numero); break;
case 36: respaldo = tab_moneda[con_columnas]; fin_columnas = sizeof(tab_moneda); break;
case 37: respaldo = tab_porcentaje[con_columnas]; fin_columnas = sizeof(tab_porcentaje); break;
case 38: respaldo = tab_and[con_columnas]; fin_columnas = sizeof(tab_and); break;
case 39: respaldo = tab_apostrofo[con_columnas]; fin_columnas = sizeof(tab_apostrofo); break;
case 40: respaldo = tab_parent_a[con_columnas]; fin_columnas = sizeof(tab_parent_a); break;
case 41: respaldo = tab_parent_b[con_columnas]; fin_columnas = sizeof(tab_parent_b); break;
case 42: respaldo = tab_asterisco[con_columnas]; fin_columnas = sizeof(tab_asterisco); break;
case 43: respaldo = tab_mas[con_columnas]; fin_columnas = sizeof(tab_mas); break;
case 44: respaldo = tab_coma[con_columnas]; fin_columnas = sizeof(tab_coma); break;
case 45: respaldo = tab_menos[con_columnas]; fin_columnas = sizeof(tab_menos); break;
case 46: respaldo = tab_punto[con_columnas]; fin_columnas = sizeof(tab_punto); break;
case 47: respaldo = tab_slash[con_columnas]; fin_columnas = sizeof(tab_slash); break;

case 48: respaldo = tab_0[con_columnas]; fin_columnas = sizeof(tab_0); break;
case 49: respaldo = tab_1[con_columnas]; fin_columnas = sizeof(tab_1); break;
case 50: respaldo = tab_2[con_columnas]; fin_columnas = sizeof(tab_2); break;
case 51: respaldo = tab_3[con_columnas]; fin_columnas = sizeof(tab_3); break;
case 52: respaldo = tab_4[con_columnas]; fin_columnas = sizeof(tab_4); break;
case 53: respaldo = tab_5[con_columnas]; fin_columnas = sizeof(tab_5); break;
case 54: respaldo = tab_6[con_columnas]; fin_columnas = sizeof(tab_6); break;
case 55: respaldo = tab_7[con_columnas]; fin_columnas = sizeof(tab_7); break;
case 56: respaldo = tab_8[con_columnas]; fin_columnas = sizeof(tab_8); break;
case 57: respaldo = tab_9[con_columnas]; fin_columnas = sizeof(tab_9); break;
case 58: respaldo = tab_dos_puntos[con_columnas]; fin_columnas = sizeof(tab_dos_puntos); break;
case 59: respaldo = tab_punto_coma[con_columnas]; fin_columnas = sizeof(tab_punto_coma); break;
case 60: respaldo = tab_menor[con_columnas]; fin_columnas = sizeof(tab_menor); break;
case 61: respaldo = tab_igual[con_columnas]; fin_columnas = sizeof(tab_igual); break;
case 62: respaldo = tab_mayor[con_columnas]; fin_columnas = sizeof(tab_mayor); break;
case 63: respaldo = tab_interrogante[con_columnas]; fin_columnas = sizeof(tab_interrogante); break;

case 64: respaldo = tab_arroba[con_columnas]; fin_columnas = sizeof(tab_arroba); break;
case 65: respaldo = tab_A[con_columnas]; fin_columnas = sizeof(tab_A); break;
case 66: respaldo = tab_B[con_columnas]; fin_columnas = sizeof(tab_B); break;
case 67: respaldo = tab_C[con_columnas]; fin_columnas = sizeof(tab_C); break;
case 68: respaldo = tab_D[con_columnas]; fin_columnas = sizeof(tab_D); break;
case 69: respaldo = tab_E[con_columnas]; fin_columnas = sizeof(tab_E); break;
case 70: respaldo = tab_F[con_columnas]; fin_columnas = sizeof(tab_F); break;
case 71: respaldo = tab_G[con_columnas]; fin_columnas = sizeof(tab_G); break;
case 72: respaldo = tab_H[con_columnas]; fin_columnas = sizeof(tab_H); break;
case 73: respaldo = tab_I[con_columnas]; fin_columnas = sizeof(tab_I); break;
case 74: respaldo = tab_J[con_columnas]; fin_columnas = sizeof(tab_J); break;
case 75: respaldo = tab_K[con_columnas]; fin_columnas = sizeof(tab_K); break;
case 76: respaldo = tab_L[con_columnas]; fin_columnas = sizeof(tab_L); break;
case 77: respaldo = tab_M[con_columnas]; fin_columnas = sizeof(tab_M); break;
case 78: respaldo = tab_N[con_columnas]; fin_columnas = sizeof(tab_N); break;
case 209: respaldo = tab_enie_1[con_columnas]; fin_columnas = sizeof(tab_enie_1); break;
case 79: respaldo = tab_O[con_columnas]; fin_columnas = sizeof(tab_O); break;
case 80: respaldo = tab_P[con_columnas]; fin_columnas = sizeof(tab_P); break;
case 81: respaldo = tab_Q[con_columnas]; fin_columnas = sizeof(tab_Q); break;
case 82: respaldo = tab_R[con_columnas]; fin_columnas = sizeof(tab_R); break;
case 83: respaldo = tab_S[con_columnas]; fin_columnas = sizeof(tab_S); break;
case 84: respaldo = tab_T[con_columnas]; fin_columnas = sizeof(tab_T); break;
case 85: respaldo = tab_U[con_columnas]; fin_columnas = sizeof(tab_U); break;
case 86: respaldo = tab_V[con_columnas]; fin_columnas = sizeof(tab_V); break;
case 87: respaldo = tab_W[con_columnas]; fin_columnas = sizeof(tab_W); break;
case 88: respaldo = tab_X[con_columnas]; fin_columnas = sizeof(tab_X); break;
case 89: respaldo = tab_Y[con_columnas]; fin_columnas = sizeof(tab_Y); break;
case 90: respaldo = tab_Z[con_columnas]; fin_columnas = sizeof(tab_Z); break;

case 91: respaldo = tab_lla_a[con_columnas]; fin_columnas = sizeof(tab_lla_a); break;
case 92: respaldo = tab_sim1[con_columnas]; fin_columnas = sizeof(tab_sim1); break;
case 93: respaldo = tab_lla_b[con_columnas]; fin_columnas = sizeof(tab_lla_b); break;
case 94: respaldo = tab_sim2[con_columnas]; fin_columnas = sizeof(tab_sim2); break;
case 95: respaldo = tab_ul[con_columnas]; fin_columnas = sizeof(tab_ul); break;
case 96: respaldo = tab_dia[con_columnas]; fin_columnas = sizeof(tab_dia); break;

case 97: respaldo = tab_aa[con_columnas]; fin_columnas = sizeof(tab_aa); break;
case 98: respaldo = tab_bb[con_columnas]; fin_columnas = sizeof(tab_bb); break;
case 99: respaldo = tab_cc[con_columnas]; fin_columnas = sizeof(tab_cc); break;
case 100: respaldo = tab_dd[con_columnas]; fin_columnas = sizeof(tab_dd); break;
case 101: respaldo = tab_ee[con_columnas]; fin_columnas = sizeof(tab_ee); break;
case 102: respaldo = tab_ff[con_columnas]; fin_columnas = sizeof(tab_ff); break;
case 103: respaldo = tab_gg[con_columnas]; fin_columnas = sizeof(tab_gg); break;
case 104: respaldo = tab_hh[con_columnas]; fin_columnas = sizeof(tab_hh); break;
case 105: respaldo = tab_ii[con_columnas]; fin_columnas = sizeof(tab_ii); break;
case 106: respaldo = tab_jj[con_columnas]; fin_columnas = sizeof(tab_jj); break;
case 107: respaldo = tab_kk[con_columnas]; fin_columnas = sizeof(tab_kk); break;
case 108: respaldo = tab_ll[con_columnas]; fin_columnas = sizeof(tab_ll); break;
case 109: respaldo = tab_mm[con_columnas]; fin_columnas = sizeof(tab_mm); break;
case 110: respaldo = tab_nn[con_columnas]; fin_columnas = sizeof(tab_nn); break;
case 241: respaldo = tab_enie_2[con_columnas]; fin_columnas = sizeof(tab_enie_2); break;
case 111: respaldo = tab_oo[con_columnas]; fin_columnas = sizeof(tab_oo); break;
case 112: respaldo = tab_pp[con_columnas]; fin_columnas = sizeof(tab_pp); break;
case 113: respaldo = tab_qq[con_columnas]; fin_columnas = sizeof(tab_qq); break;
case 114: respaldo = tab_rr[con_columnas]; fin_columnas = sizeof(tab_rr); break;
case 115: respaldo = tab_ss[con_columnas]; fin_columnas = sizeof(tab_ss); break;
case 116: respaldo = tab_tt[con_columnas]; fin_columnas = sizeof(tab_tt); break;
case 117: respaldo = tab_uu[con_columnas]; fin_columnas = sizeof(tab_uu); break;
case 118: respaldo = tab_vv[con_columnas]; fin_columnas = sizeof(tab_vv); break;
case 119: respaldo = tab_ww[con_columnas]; fin_columnas = sizeof(tab_ww); break;
case 120: respaldo = tab_xx[con_columnas]; fin_columnas = sizeof(tab_xx); break;
case 121: respaldo = tab_yy[con_columnas]; fin_columnas = sizeof(tab_yy); break;
case 122: respaldo = tab_zz[con_columnas]; fin_columnas = sizeof(tab_zz); break;

case 123: respaldo = tab_cor1[con_columnas]; fin_columnas = sizeof(tab_cor1); break;
case 124: respaldo = tab_sim3[con_columnas]; fin_columnas = sizeof(tab_sim3); break;
case 125: respaldo = tab_cor2[con_columnas]; fin_columnas = sizeof(tab_cor2); break;
case 126: respaldo = tab_fle1[con_columnas]; fin_columnas = sizeof(tab_fle1); break;
case 127: respaldo = tab_fle2[con_columnas]; fin_columnas = sizeof(tab_fle2); break;
}

///////////////////
con_columnas++;

if(con_columnas == fin_columnas)
{
con_columnas = 0x00;
con_caracter++;
ban_espacio = 0x01;
}




for(i=0x27; i>0x00; i--)
{
columnas[i] = columnas[i-1];
}

columnas[0] = respaldo;
}
///////////////////////////////////////////////////////////////////////////////




aqui dejo el codigoo para q lo vean, y si quieren hacer criticas pueden hacerlas (mientras sean constructivas), y si hay alguna sugerencia mejora o ayuda para mis letras bienvenidos sean.

gracias

[CarloS_32]

Hola..te ha quedado de lujo  ..me gustaria ver mejor la parte de atras de las placas para ver como soldaste..gracias por compartir el código me serivá para iniciarme en el tema..cuanta plata mas o menos haz gastado para tener una idea

PD: De casualidad tenemos el mismo tester y el mismo programador JDM..jeje casualidades

[korpaztk]

estuve horas y horas soldando, ya que son las placas paso integrado (todas agujereadas) e hice todas sus pistas de apoco con estaño jeje ( un laburo de horasssss)

aqui cargo lo que me pediste..

si no entendes mucho de como va, decime y yo explico un poco haber si lo agarran.







cualquier cosa subo mas fotos, hay miles y miles jejeje ya que me emocione cuando termine de armarlo jaja  

[CarloS_32]

estuve horas y horas soldando, ya que son las placas paso integrado (todas agujereadas) e hice todas sus pistas de apoco con estaño jeje ( un laburo de horasssss)

aqui cargo lo que me pediste..

si no entendes mucho de como va, decime y yo explico un poco haber si lo agarran.

Hola si que laburito jeje..pero no me da verguenza decirte que no lo entiendo me podrias explicar un poco como hiciste las conexiones en la placa? quiero saber eso nada mas por ahora por que ahora estoy en otro tema..si tienes un esquema del circuito mejor..usaste leds comunes o de alto brillo..se nota que no se nada del tema jeje

[korpaztk]

si podes observar


las columnas estan conectados los katodos de los led (-), luego se ve como una ¨L¨ hecha atras tambien, eso es para conectar los anodos de los led en filas, pero como no podia conectarlos directamente con estaño como hice con los katodos, tuve q hacer puentes con lo que me sobraban de las patillas de los led,

creo que no hice una buena explicación, si hay dudas consulta de vuelta jeje

[darck_khronos]

Jeje bien se dice que cada quien programa a como entiende, yo te recomendaria que todas tus letras las metieras un una matriz de nxn asi tambien podrias buscarlas mas rapido

[korpaztk]

Jeje bien se dice que cada quien programa a como entiende, yo te recomendaria que todas tus letras las metieras un una matriz de nxn asi tambien podrias buscarlas mas rapido

disculpa darck_khronos, no entendí tu sugerencia, como es eso de matriz de nxn, recuerda que el código no lo hice yo, lo único que hice fue hacerle unas modificas pequeñas, para adaptarla a mi matriz, pero si puedes explicarte con eso que has dicho te agradecería

[darck_khronos]

Te dejo un ejemplo ahorita aqui aun me faltan algunas del ascii pero puedes darte una idea.

aqui facilito la mayoria de los simbolos

Código: C

1. char const  letras [127][8]={ /*       */{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
2. /*carita */{0xE,0x11,0x1B,0x11,0x1B,0x15,0x11,0xE},
3. /*bcarita*/{0x11,0xE,0x4,0xE,0x4,0xA,0xE,0x11},
4. /*corazon*/{0x00,0x00,0xA,0x15,0x11,0x11,0xA,0x4},
5. /*diamante*/{0x00,0x4,0xE,0x1F,0xE,0x4,0x00,0x00},
6. /*trebol*/{0x00,0x4,0xE,0x1B,0x1B,0xE,0x4,0xE},
7. /*espada*/{0x00,0x4,0xA,0x11,0x15,0xE,0x4,0xE},
8. /*bola*/{0x00,0x00,0x4,0xE,0x4,0x00,0x00,0x00},
9. /*bbola*/{0x1F,0x1F,0x1B,0x11,0x1B,0x1F,0x1F,0x1F},
10. /*bolita*/{0x00,0x4,0xA,0x11,0xA,0x4,0x00,0x00},
11. /*bbolita*/{0x1F,0x1B,0x15,0xE,0x15,0x1B,0x1F,0x1F},
12. /*mujer*/{0x1C,0x18,0x14,0xE,0x11,0x11,0x11,0xE},
13. /*hombre*/{0xE,0x11,0x11,0x11,0xE,0x4,0xE,0x4},
14. /*nota*/{0x8,0x18,0x8,0x8,0x8,0xA,0x7,0x2},
15. /*acorde*/{0x1C,0x1F,0x1F,0x17,0x12,0x1A,0x1B,0x3},
16. /*sol*/{0x4,0x15,0x4,0x1B,0x4,0x15,0x4,0x00},
17. /*Flecha D*/{0x1,0x3,0x7,0xF,0xF,0x7,0x3,0x1},
18. /*Flecha I*/{0x10,0x18,0x1C,0x1E,0x1E,0x1C,0x8,0x10},
19. /*Flecha-A-A*/{0x4,0xE,0x1F,0xE,0xE,0x1F,0xE,0x4},
20. /*!!*/{0xA,0xA,0xA,0xA,0xA,0xA,0x00,0xA},
21. /*P-rara*/{0x1E,0x15,0x15,0x16,0x14,0x14,0x14,0x14},
22. /*doble-s*/{0x00,0xE,0x1,0xE,0x11,0xE,0x10,0xE},
23. /*guion*/{0x00,0x00,0x00,0x1F,0x1F,0x00,0x00,0x00},
24. /*Flecha-a-a_*/{0x4,0xE,0x1F,0x4,0x1F,0xE,0x4,0x1F},
25. /*Flecha Arriba*/{0x4,0xE,0x1F,0xE,0xE,0xE,0xE,0xE},
26. /*Flecha Abajo*/{0xE,0xE,0xE,0xE,0xE,0x1F,0xE,0x4},
27. /*Derecha*/{0x00,0x00,0x4,0x8,0x1F,0x8,0x4,0x00},
28. /*Izquierda*/{0x00,0x00,0x4,0x2,0x1F,0x2,0x4,0x00},
29. /*Eskina*/{0x00,0x00,0x00,0x1,0x1,0x1F,0x00,0x00},
30. /*Flechita*/{0x00,0x00,0x00,0xA,0x1F,0xA,0x00,0x00},
31. /*Arriba*/{0x00,0x4,0xE,0x1F,0x1F,0x00,0x00,0x00},
32. /*Abajo*/{0x00,0x00,0x1F,0x1F,0xE,0x4,0x00,0x00},
33. /*   ¡   */{0x4,0x00,0x4,0x4,0x4,0xE,0xE,0x4},
34. /*   !   */{0x4,0xE,0xE,0x4,0x4,0x4,0x00,0x4},
35. /*   "   */{0x1B,0x1B,0x9,0x00,0x00,0x00,0x00,0x00},
36. /*   #   */{0x00,0xA,0x2,0x1F,0xA,0x1F,0xA,0xA},
37. /*   $   */{0x00,0x4,0xE,0x5,0xE,0x14,0xE,0x4},
38. /*   %   */{0x00,0x3,0x13,0x8,0x4,0x2,0x19,0x18},
39. /*   &   */{0x00,0x6,0x9,0x9,0x6,0x16,0x9,0x16},
40. /*   '   */{0x8,0x8,0x8,0x00,0x00,0x00,0x00,0x00},
41. /*   (   */{0xC,0x2,0x1,0x1,0x1,0x2,0xC,0x00},
42. /*   )   */{0x6,0x8,0x10,0x10,0x10,0x8,0x6,0x00},
43. /*   *   */{0x00,0x4,0x15,0xE,0x1F,0xE,0x15,0x4},
44. /*   +   */{0x00,0x00,0x4,0x4,0x1F,0x4,0x4,0x00},
45. /*   ,   */{0x00,0x00,0x00,0x00,0x00,0x6,0x4,0x2},
46. /*   -   */{0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0x00},
47. /*   .   */{0x00,0x00,0x00,0x00,0x00,0x00,0x3,0x3},
48. /*   /   */{0x00,0x00,0x10,0x8,0x4,0x2,0x1,0x00},
49. /*   0   */{0x00,0xE,0x11,0x19,0x15,0x13,0x11,0xE},
50. /*   1   */{0x00,0x4,0x6,0x5,0x4,0x4,0x4,0x1F},
51. /*   2   */{0x00,0xE,0x11,0x11,0x8,0x4,0x2,0x1F},
52. /*   3   */{0x00,0x1F,0x10,0x8,0x4,0x8,0x11,0xE},
53. /*   4   */{0x00,0x8,0xC,0xA,0x1F,0x8,0x8,0x8},
54. /*   5   */{0x00,0x1F,0x1,0x1,0xF,0x10,0x11,0xE},
55. /*   6   */{0x00,0xE,0x11,0x1,0xF,0x11,0x11,0xE},
56. /*   7   */{0x00,0x1F,0x10,0x10,0x8,0x4,0x4,0x4},
57. /*   8   */{0x00,0xE,0x11,0x11,0xE,0x11,0x11,0xE},
58. /*   9   */{0x00,0xE,0x11,0x11,0x1E,0x10,0x11,0xE},
59. /*   :   */{0xE,0xE,0xE,0x00,0xE,0xE,0xE,0x00},
60. /*   ;   */{0xE,0xE,0xE,0x00,0xE,0xE,0xE,0x3},
61. /*   <   */{0x00,0x8,0x4,0x2,0x1,0x2,0x4,0x8},
62. /*   =   */{0x00,0x00,0x00,0x1F,0x00,0x1F,0x00,0x00},
63. /*   >   */{0x00,0x1,0x2,0x4,0x8,0x4,0x2,0x1},
64. /*   ?   */{0xE,0x11,0x11,0x10,0x8,0x4,0x00,0x4},
65. /*   @   */{0x00,0xE,0x11,0x15,0x1B,0x5,0x11,0xE},