Mi nueva matriz de led

[jukinch]

Lo importante de este pequeño gran proyecto es que no le has dado el brazo a torcer y pronto podrás decir sueño realizado!!!!
Saludos.
       Jukinch

[korpaztk]

me siguen surgiendo dudas... como la siguiente
como sabrán tengo conectadas los ánodos a las filas y cátodos a las columnas.
las filas están conectadas en con una resistencia de 150ohm, y por unos cálculos básicos seria algo asi

Corriente = (Tension Fuente - Caida del Led) / Resistencia

Corriente = ( 5v - 2.2v ) / 150

Corriente =aprox. 18 mA

pero cuando conecto mi miliamperimetro, y mido la corriente en una fila me da un valor de 2mA, entonces llegue a colocar una resistencia de 8,2 ohm de 1/8 W y ni calientan  y recien veo que fluyen 17 a 18 mA.

mis cálculos están bien? o me estoy olvidando de algún factor importante? con esa resistencia baja los led prenden bien y no se nota sobre-consumo... pero bueno mejor también escuchar la opinión de otros hace bien...

Saludos.-

[stk500]

pero es que tu hace el calculo de uno solo LED y si estan en paralelo el voltage/amperio seran menos, deberia mejor hacer el calculo con la resistencia en paralelo y por cantidades aqui te pongo la pagina que yo uso para mi calculo
http://led.linear1.org/led.wiz, y como te decia ante deberia saber exacto la caracteristica de los led que usa.

[korpaztk]

pero es que tu hace el calculo de uno solo LED y si estan en paralelo el voltage/amperio seran menos, deberia mejor hacer el calculo con la resistencia en paralelo y por cantidades aqui te pongo la pagina que yo uso para mi calculo
http://led.linear1.org/led.wiz, y como te decia ante deberia saber exacto la caracteristica de los led que usa.

claro por ende al aumentar los led en paralelo la corriente disminuye, eso lo entiendo...
mi duda era si: coloco una resistencia baja, cuando prenden varios led la corriente se disminuye por cada led, pero si enciende uno solo, va a pasar toda la corriente por ese led solo y debería encender mas... no se si me doy a entender  
fíjate que la resistencia las conecto en las columnas osea uso 7 nomas, ahora tengo que conectar una resistencia por columna?? no voy a tener problemas,¿ pero debo hacerlo??...

Saludos.-


Modificacion 1: muy bueno el link de todas formas


Saludos.-

[korpaztk]

nuevo avance:  
ahora e cambiado las resistencias de 150 ohm por unas de 20 y logro ahora un brillo bueno, y un consumo razonable entre 15 y 19 mA por filas.

pero (siempre hay un pero) ... no se que sucede, que al encenderlo comienzan a pasar el mensaje y de la nada se resetea :S que podra ser??

Código: [Seleccionar]

//***************E N C A B E Z A D O  P R I N C I P A L
#include <16f877.h>
#use delay(clock=20000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)
#fuses HS,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

//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;
int xcol=0;
int1 guarda=0x00;
int1 guarda1=0X00;
int1 ok=0x00;
int1 ver=0x00;
int act=0x00;
//******************************

//S U B R U T I N A S************
void display(void);
void display_1(void);
void rotar_mensaje(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

if(ban_recibir == 0x01 && respaldo!=0x1f && respaldo!=0x1e)
{
cadena[con_recibir] = respaldo;
delay_us(10);
con_recibir++;
delay_us(10);
act++;
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);
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;
guarda=0x01;
ok=0x01;
ban_recibir = 0x00;
delay_us(10);
}

if(respaldo == 0x1f)
{
mof=0x02;
guarda1=0x01;
ver=0x01;
}

if(respaldo == 0x1e)
{
mof=0x00;
guarda1=0x01;
ver=0x00;
}

}

///////////////////////////////////////////////////////////////////////////////
void escribir_eeprom(void)
{
int k=0x00;

for(k=0x00;k<=0x60;k++)
{
write_eeprom(k,cadena[k]);
delay_ms(100);
}

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

#zero_ram

void main(void)
{
int x;
set_tris_a(0X00);
delay_us(1);
set_tris_b(0X00);
delay_us(1);
portb=0x00;
set_tris_c(0X80);
delay_us(1);
set_tris_d(0X00);
port_b_pullups(false);
delay_ms(5);
portb=0x00;
setup_timer_1(t1_internal | t1_div_by_4);
setup_adc_ports(no_analogs);
set_timer1(0);
output_low(PIN_D0);

//se carga en la matriz todos los caracteres ascii

for(x=0x00; x<=0x60; x++)
{
cadena[x]=read_eeprom(x);
delay_ms(100);
}
mof=read_eeprom(0xff);
delay_ms(100);
ver=read_eeprom(0xfd);
delay_ms(100);
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);
portb=0x00;
portd=0x00;
delay_us(10);

while(true)
{
///////////////////////////////////////////////////////////////////////////////
while(mof == 0x00) //Rutina general
{

delay_us(10);
display();

if(ban_tmr1 == 0x01 && mof == 0x00)
{
ban_tmr1 = 0x00;
delay_us(10);
rotar_mensaje();
if(ver==0x01)
{
mof=0x02;
ver=0x00;
}
else
{
mof=0x00;
}
}

if(guarda==0x01)
{
guarda=0x00;
if(ver==0x01)
{
mof=0x02;
ver=0x01;
}
else
{
mof=0x00;
}
escribir_eeprom();
write_eeprom(0xff,mof);
delay_ms(100);
write_eeprom(0xfd,ver);
delay_ms(100);
}
}
///////////////////////////////////////////////////////////////////////////////
while(mof == 0x02)

{

int fijo;

fijo=yu;
delay_us(10);
display();


if(ban_recibir == 0x00 )
{
if(fijo <= 0x23)
{
if(ban_tmr1 == 0x01 && mof == 0x02 && ver == 0x01)
{
ban_tmr1 = 0x00;
delay_us(10);

rotar_mensaje();
fijo = fijo+0x01;
fijo1=fijo1+0x01;
if(ver==0x00)
{
mof=0x00;
ver=0x00;
}
else
{
mof=0x02;
}
}
yu = fijo;
}
}




if(guarda==0x01)
{
mof=0x02;
guarda=0x00;
if(ver==0x01)
{
mof=0x02;
ver=0x01;
}
else
{
mof=0x00;
}
escribir_eeprom();
write_eeprom(0xff,mof);
delay_ms(50);
write_eeprom(0xfd,ver);
delay_ms(50);
}

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




}
}


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

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

int i;
char col;
int bt=0;
portb=0x00;
delay_us(100);
output_low(PIN_D0);
delay_us(1);
output_high(PIN_D0);
    delay_us(1);

for(xcol=0x01;xcol<0x08;xcol++)
{

for (i=37;i>0;i--)
{
col=columnas[i-1];
delay_us(2);
bt=bit_test (col, xcol);
delay_us(2);
portb=0x00;
 
switch(bt)
{
case 0x00 :output_low(PIN_D1);delay_us(1);output_low(PIN_C3);delay_us(1);output_high(PIN_C3);delay_us(1);output_low(PIN_C3);delay_us(1); break;          
case 0x01 :output_high(PIN_D1);delay_us(1);output_low(PIN_C3);delay_us(1);output_high(PIN_C3);delay_us(1);output_low(PIN_C3);delay_us(1); break;
}
}
      
portb=0x00;
switch(xcol)
{
case 0x01: portb=0x02;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x02: portb=0x04;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x03: portb=0x08;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x04: portb=0x10;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x05: portb=0x20;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x06: portb=0x40;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
case 0x07: portb=0x80;delay_ms(2);portb=0x00;delay_us(100);output_low(PIN_D0);delay_us(1);output_high(PIN_D0);delay_us(1);break;
}

  portb=0x00;


}
}
//***********************************************************************************************
//***********************************************************************************************
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;
}
///////////////////////////////////////////////////////////////////////////////



alguien ve algun inconveniente, yo por lo menos no. :S

Saludos.-



Moficiacion 1:

el problema debe de haber sido electrónico, ya que las resistencias que habia puesto de 20 ohms las he sustituido por unas de 47, y ahora funciona de los mas maravilloso.

Saludos.-

[korpaztk]

hice pruebas en el exterior de mi casa (daba un poco de cosas sacar a la calle el manojo de cables ) e increiblemente me lleve la sorpresa que por lo menos de 10 a 20 mts (dependiendo del angulo que me hubicara) podía leer perfecto lo que estaba pasando  ahora falta nomas el gabinete y doy por terminado todo esto jejeje

Saludos.-

[korpaztk]

esto esta casi cocido del todo  ya me trajeron mi gabinete, hecho en madera porque no habia fondos para hacerlo en metal o aluminio 
aqui unas fotos de como va quedando












ya hoy lo pinto y mañana o esta noche subire un video del resultado final =)


Saludos.-

[stk500]

  pues te ha quedado muy chula, han pensando poner regilla detras o orificio para que tenga ventilacion?
porque me imagino que cerrado completo se te calentaran todos los componente.

[korpaztk]

Si la verdad que fue un detalle que no tuve en cuenta pero no hay nada que no pueda hacer un taladro de banco 
Y bueno, ya dejo terminado mi asunto, con las fotos finales 













y por supuesto ....

un video      

[korpaztk]

Bueno, le pongo punto y final y dar agradecimientos a todos los que me ayudaron, los que dieron consejos, los pequeños tips, y demás que son:

Miquel_S, stk500, CarloS_32, Diego E., falflores, todopic, bmb, jukinch, cristian_elect, pocher, KALLITOS, Chipcon y MLO__

Disculpas a los que no halla nombrado.-

Y dado por final, adjunto mi proyecto con simulacion y programa en VB, lo subo a un servidor ya que pesa un poco mas de lo que permite la pagina.-

http://www.megaupload.com/?d=GRNKKM9S

Saludos.-

[mafig2112]

hola acabo de bajar tu code y al simularlo sale solo BAR
como uso el puerto com segun yo uso el com3, lo pongo en la simulacion pero al tratar de meter letras no cambia solo se queda bar
por cierto te quedo de waooo O.o

[korpaztk]

en ese archivo tienes la simulación del proteus y un programa en VB pero para poder enlazarlos necesitas otro software que te simule la conexión física de dos puertos COM (serie), yo me acuerdo haberlo hecho con el virtual serial com driver algo asi, jeje no recuerdo bien el nombre.

Saludos.-

[jukinch]

korpaztk:
            Si no es molestia o perjuicio podrías subir el código en Vb?
             Saludos.
              Jukinch
                 

[korpaztk]

sii, no hay drama.
no tengo el visual basic en esta maquina, creería que el archivo debe ser alguno de los que subí ahí en el archivo, no creo que te sea dificil encontrarlo, cualquier cosa avisenme y lo busco con mas exactitud

Saludos.

PD: no se porque pero me gustaría que algún admin también opinase que le pareció mi pequeño proyecto, obviamente que ustedes pueden también porque son los que me han ayudado en este y otros post que he hecho.

[jukinch]

korpaztk:
             El proyecto está muy copado. Y como te dije antes, le diste lucha hasta el último rincón. Cuantos proyectos quedan a mitad de camino por una cosa u otra.? Y este si que no es el caso.
                    Saludos desde San Nicolás, Argentina
                                       Jukinch