//***************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;
}
///////////////////////////////////////////////////////////////////////////////
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.
(http://img121.imageshack.us/img121/5545/sdc10468n.jpg)
(http://img121.imageshack.us/img121/5545/sdc10468n.jpg/img]
[/quote]
entonces hacia el puente entre un anodo y otro de los led (conectados en filas)...
[img]http://img33.imageshack.us/img33/3536/asdasdqwe.jpg)
creo que no hice una buena explicación, si hay dudas consulta de vuelta jeje
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
Mas o menos no veo muy nítido..pero ya me voy dando una idea tienes tantos cables como filas y columnas no? o sea q para encender un led debes sacar un 0 por su columna y un 1 por su fila o como lo haces?..Te habras gastado 500 pesos o estoy lejos?..gracias por tu molestia...ahh no me parece importante que no entiendas el código lo importante que te hayas lanzado a hacerlo lo demas vendrá..saludos y suerte cuando sepa más del tema te sigo preguntando
Sabes como funciona el programa?, estuve viendo el código y vi que en la función que pide los caracteres al usuario dice (máx 5 letras), pero en el video observo que despliegas más, hasta cuantas letras se pueden mostrar?.saber como funciona si, al 100%... donde dices tu sobre los caracteres es asi...
Hola amigo Korpaztk, te felicito por todo el entusiasmo que le estas imprimiendo a tu proyecto, de verdad que te está quedando barbaro!, solo te recomendaría que diseñaras tus circuitos en PCB's con pistas, asi te ahorras muuuuuucho tiempo, te quedan más prolijos, ahorras $ en soldadura y eliminas posibles errores en el hardware; de allí en fuera todo está excelente!
También te quería decir que yo ya he usado el teclado conectado al PIC directamente, con ayuda de un código que me encontre (la verdad no recuerdo donde jejeje), pero funciona de perlas!, y es muy útil en estos casos, si lo quieres, te lo paso ya funcionando con el 16F877A.
capaz, que el del teclado es el que yo hice mension es 2 o 3 post mas atras, de como conectar el teclado ps/2 a un pic, lo intente hacer, pero me quedaban muchas dudas, entonces lo había dejado en conexión serie, (pero mas adelante si alguien me ayuda se puede hacer en VB y con puerto Usb.
si, la verdad que era bastante obvio la parte del PCB, no se de donde eres tu, pero yo soy de santa fe, argentina y yo por experiencia personal soy muy malo haciendo los pcb (mi pulso es malisimo), he probado con impresora láser, pero 2 o 3 veces nomas (cuando iba a la escuela) porque acá en mi casa no tengo, y mandarlas a hacer las placas, tuviera que revisar el circuito y ver si le tengo que agregar cosas para seguridad y demás, mi intensión es esa, la de armar bien el esquema y mandarla a hacer, así me ahorro espacio (aunque la primera vez duele pagar los pcb) después ya salen mucho mas barato si haces la copia.
dale si puedes compartirlo bienvenido sea, pero creo ques del siguiente link el codigo
http://picmania.garcia-cuervo.net/proyectos_teclado_ps2.htm
de un grande dentro y fuera del foro (son solo alabanzas por sus proyectos, no lo conozco personalmente)
// Title: KEYBOARD_PC_To_RS232.c
// Description: Interfase entre un teclado convencional tipo AT y un puerto RS232C
// Date: Abr-2005
// Ver.Rev.: V01
// Author: XP8100 (xp8100@gmail.com)
//
// #Based on the AN AVR313: Interfacing the PC AT Keyboard from ATMEL#
// #Adaptado para 16F628A por Redraven
//
//-----------------------------------------------------------------------------
//
// init_kb() Inicializa rutina y contadores
// decode (char) Decodifica la pulsación realizada, convirtiendola a un caracter de la tabla
// int_ext_isr Rutina de gestión de interrupciones. Captura los diferentes bit"s
//-----------------------------------------------------------------------------
// RB0 - Señal de reloj
// RB3 - Tren de impulsos (11 bit) Start+10101010+Paridad+Stop
//-----------------------------------------------------------------------------
// Commment : Permite conectar un teclado convencional de PC a un entorno
// gestionado por un PIC 16F877.
// El actual sistema se define como un primer prototipo, en el que no se realizan
// acciones concretas asociadas a teclas establecidas.
// Tampoco se actua sobre los indicadores luminosos del teclado, repetición de teclas, ...
//
// THIS DOCUMENT IS PROVIDED TO THE USER "AS IS"
//-----------------------------------------------------------------------------
#include <16F877A.h>
#fuses HS, NOWDT, NOPROTECT, BROWNOUT, PUT, NOLVP
#use delay(clock=20MHz)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,bits=8,parity=N) // Definición del RS232
#zero_ram
//#include <LCD.h>
#include <LCD420.h>
//-----------------------------------------------------------------------------
// Definiciones globales
//-----------------------------------------------------------------------------
unsigned char bitcount;
char got_interrupt;
char interrupt_count;
char status_b3;
#bit INTF_BIT = 0x0B.1 // INTCON BIT 1 = INTF RB0/INT External Interrupt Flag Bit
//-------- Tabla de caracteres correspondientes a la pulsación de la tecla
//-------- en modalidad normal (sin pulsar SHIFT)
unsigned char const unshifted[68][2] =
{
0x0d,9,
0x0e,'º', 0x15,'q', 0x16,'1', 0x1a,'z', 0x1b,'s', 0x1c,'a', 0x1d,'w',
0x1e,'2', 0x21,'c', 0x22,'x', 0x23,'d', 0x24,'e', 0x25,'4', 0x26,'3',
0x29,' ', 0x2a,'v', 0x2b,'f', 0x2c,'t', 0x2d,'r', 0x2e,'5', 0x31,'n',
0x32,'b', 0x33,'h', 0x34,'g', 0x35,'y', 0x36,'6', 0x39,',', 0x3a,'m',
0x3b,'j', 0x3c,'u', 0x3d,'7', 0x3e,'8', 0x41,',', 0x42,'k', 0x43,'i',
0x44,'o', 0x45,'0', 0x46,'9', 0x49,'.', 0x4a,'-', 0x4b,'l', 0x4c,'ñ',
0x4d,'p', 0x4e,'"', 0x52,'´', 0x54,'`', 0x55,'¡', 0x5a,13, 0x5b,'+',
0x5d,'ç', 0x61,'<', 0x66,8, 0x69,'1', 0x6b,'4', 0x6c,'7', 0x70,'0',
0x71,'.', 0x72,'2', 0x73,'5', 0x74,'6', 0x75,'8', 0x79,'+', 0x7a,'3',
0x7b,'-', 0x7c,'*', 0x7d,'9',
0,0
};
//-------- Tabla de caracteres correspondientes a la pulsación de la tecla
//-------- en modalidad desplazamiento (pulsando SHIFT)
unsigned char const shifted[68][2] = {
0x0d,9,
0x0e,'ª', 0x15,'Q', 0x16,'!', 0x1a,'Z', 0x1b,'S', 0x1c,'A', 0x1d,'W',
0x1e,'"', 0x21,'C', 0x22,'X', 0x23,'D', 0x24,'E', 0x25,'$', 0x26,'·',
0x29,' ', 0x2a,'V', 0x2b,'F', 0x2c,'T', 0x2d,'R', 0x2e,'%', 0x31,'N',
0x32,'B', 0x33,'H', 0x34,'G', 0x35,'Y', 0x36,'&', 0x39,'L', 0x3a,'M',
0x3b,'J', 0x3c,'U', 0x3d,'/', 0x3e,'(', 0x41,';', 0x42,'K', 0x43,'I',
0x44,'O', 0x45,'=', 0x46,')', 0x49,':', 0x4a,'_', 0x4b,'L', 0x4c,'Ñ',
0x4d,'P', 0x4e,'?', 0x52,'¨', 0x54,'^', 0x55,'¿', 0x5a,13, 0x5b,'*',
0x5d,'Ç', 0x61,'>', 0x66,8, 0x69,'1', 0x6b,'4', 0x6c,'7', 0x70,'0',
0x71,'.', 0x72,'2', 0x73,'5', 0x74,'6', 0x75,'8', 0x79,'+', 0x7a,'3',
0x7b,'-', 0x7c,'*', 0x7d,'9',
0,0
};
//-----------------------------------------------------------------------------
// Definición de protipos
//-----------------------------------------------------------------------------
void init_kb(void);
void decode(unsigned char sc);
//-----------------------------------------------------------------------------
// Rutina de gestión de interrupciones
//-----------------------------------------------------------------------------
#int_ext
void int_ext_isr(void)
{
unsigned char data;
//-------- Los bit 3 a 10 se considerran datos. Paridad, start y stop
//-------- son ignorados
if(bitcount<11&&bitcount>2)
{
data=(data>>1);
status_b3=input(PIN_B3);
if((status_b3)==1) data=data|0x80;
}
//-------- Todos los bits se han recibido
if(--bitcount==0)
{
decode(data);
data=0;
bitcount=11;
got_interrupt=TRUE;
}
got_interrupt=TRUE;
interrupt_count++;
disable_interrupts(INT_EXT);
}
//-----------------------------------------------------------------------------
// Main
//-----------------------------------------------------------------------------
void main(void)
{
delay_ms(100);
//-------- se inicializa el LCD
lcd_init();
init_kb();
//-------- Los pins indicados (B0 y B3) son configurados como entradas.
output_float(PIN_B0);
output_float(PIN_B3);
//-------- Activa pullups sobre todos los pins del puerto B.
port_b_pullups(TRUE);
//-------- Espera a que se activen.
delay_us(5);
//-------- Inicializa las variables usadas por la rutina de interrupción
//-------- antes de activar las interrupciones
interrupt_count = 0;
got_interrupt=FALSE;
status_b3=0;
//-------- Desde que se activó el modo PULLUPS del puerto B, el estado
//-------- normal del pin B0 es ALTO. La gestión de la interrupción externa
//-------- se gestiona cuando se produce un cambio de nivel ALTO a BAJO.
ext_int_edge(H_TO_L);
//-------- Asegurarse de que el el bit de flag de la interrupción externa
//-------- es borrado antes de activar la gestión de dicha interrupción
//-------- externa.
INTF_BIT=0;
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
//-------- Bucle principal.
//-------- Chequear si se produce alguna interrupción (got_interrupt). Si es así, contar, borrar
//-------- el flag y esperar 50 ms, reactivando la gestión de las interrupciones
while(TRUE)
{
//-------- Chequear si se produce alguna interrupción (got_interrupt).
if(got_interrupt == TRUE)
{
//-------- Borrar el flag global que se inicio en la rutina de servicio
//-------- de interrupciones externas.
got_interrupt = FALSE;
//-------- Esperar 50 ms para evitar rebotes en los contactos de las teclas.
//delay_ms(50);
//-------- Borrar cualquier interrupción producida durante el periodo de espera.
INTF_BIT = 0;
//-------- Reactivar interrupciones
enable_interrupts(INT_EXT);
}
}
}
//-----------------------------------------------------------------------------
// Funciones
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Inicialización de teclado.
//-----------------------------------------------------------------------------
void init_kb(void)
{
//-------- Longitud de la trama para cada pulsación y mensaje de bienvenida
bitcount = 11;
printf("PC AT Keyboard Interface Ver 1.0 by XP8100");
printf("Adpapted for 16F628A by Redpic");
printf("Decoder and Monitoring for 16F628A connected ..." );
lcd_putc("\fInterfaz teclado PS2\n");
lcd_putc(" con mayusculas\n");
lcd_putc("y minusculas usando\n");
lcd_putc(" la funcion SHIFT");
delay_ms(2000);
lcd_putc("\f");
}
//-----------------------------------------------------------------------------
// Decodificación de pulsaciones
//-----------------------------------------------------------------------------
void decode(unsigned char sc)
{
static unsigned char is_up=0, shift=0;
unsigned char i;
//printf("[%c]",sc); // Monitor de código de rastreo
//printf(lcd_putc,"%c",sc);
//-------- El último dato recibido fue el identificador de Up-Key
if(!is_up)
{
switch (sc)
{
//-------- Identificador de Up-Key
case 0xF0 : is_up=1; break;
//-------- SHIFT Izquierdo
case 0x12 : shift=1; break;
//-------- SHIFT Derecho
case 0x59 : shift=1; break;
//-------- ENTER
case 0x5A : shift=0; printf(" "); lcd_putc(" "); break;
//-------- Si no es ninguno de los identificadores especiales, procesar
//-------- pulsación, localizando caracter en tabla de caracteres.
default:
//-------- Pulsación normal
if(!shift)
{
for(i=0;unshifted[i][0]!=sc&&unshifted[i][0];i++);
if(unshifted[i][0]==sc)
{
printf("%c",unshifted[i][1]);
printf(lcd_putc,"%c",unshifted[i][1]);
}
}
else
//-------- Pulsación + SHIFT presionado
{
for(i=0;shifted[i][0]!=sc&&shifted[i][0];i++);
if(shifted[i][0]==sc)
{
printf("%c",shifted[i][1]);
printf(lcd_putc,"%c",shifted[i][1]);
}
}
break;
} // --- End Switch
}
else
{
//-------- No se permiten 2 0xF0 en una fila
is_up=0;
switch (sc)
{
//-------- SHIFT Izquierdo
case 0x12 :
shift=0;
break;
//-------- SHIFT Derecho
case 0x59 :
shift=0;
break;
} // --- End Switch
}
}
Hola Korpaztk (uhh que dificil de escribir je je) te felicito por el empeño puesto en tu trabajo!
El acrilico (supongo para el frente) puedes usar rojo translucido, y el pegamento empleado es cloroformo (que ahora en casi todos los lugares esta prohibido) :5]
Saludos!
Norberto
#use rs232(baud=19200, xmit=pin_c6,rcv=pin_c7)El PIC inicia la recepción de datos con caracter 13, mensaje, caracter 27, esta debe ser la trama#use rs232(baud=19200,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8)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);
}
}Deben ser led potentes para poner 150 ohm en serie a 12V. Los leds utra-brillantes normales de 5mm se le pone 820 ohm aproximadamente para 12V.con 820 veo muy poca corriente :S
A simple vista parece que lo tengas bien, si donde pone PIN ULN hay realmente 0V.los transistores estan bien conectados (como he puesto en el dibujo anterior) he repasado las soldaduras por si las moscas y aparenta estar todo bien. voy a comprobar el tema de los uln haber si me tiran a masa correctamente.
¿Qué ULN es y como lo tienes conectado físicamente? ¿El transistor TIP está bien conectado físicamente?
Hola Korpa!con respecto al link, pude entrar, pero la pagina no me realiza el calculo cuando hago click... e intentado actualizar y escribir también datos erróneos haber si tiraba algún error pero nada... :(
aqui te pongo un link donde se calcular el valor de la resistencia de acuerdo al LED que use, cuidado con los LED, siempre debe saber cual es su voltage y consumos claro.
http://personal.telefonica.terra.es/web/mamelytote/CalculaRes/calcula.html
A simple vista parece que lo tengas bien, si donde pone PIN ULN hay realmente 0V.
PD. El link de stk500 funciona bien y realiza bien el cálculo (conforme a tus valores)ahi lo comprobe esta mañana y ahora me funciona el link.
Una pregunta. ¿Usas el conjunto de los dos transistores con las resistencias para cada diodo LED?ese conjunto es para manejar los led de las filas, osea tengo hecho 7 pares de transistores con sus resistencias, pero de todas formas es como que cada conjunto esta suministrando corriente para un solo led, y como con los 5 v no obtenia suficiente brillo aun cambiandole la resistencia opte por acoplarle otro tip y usar el bc548 como driver para manejarlo entonces de ahi le suministraba los 12v digamos que con su debida resistencia.
Con el PIC controlando los registros de desplazamiento y luego estos atacando directamente a los ULN cuyas salidas estarian conectadas a los LEDs ¿no seria suficiente? ¿Cual es la misión del conjunto transistores-resistencias? ... no lo veo.
Cuando le alimentaste con una R=150ohm ya esos leds ya están alterados ya su brillo bajo aun cuando le pones su resistencia correcta por que internamente disminuyo su impedancia.
Yo tengo varios alterados por querer aumentar mas su brillo, su resistencia interna normal de los leds son de varios mega ohm
y los alterados tienen 1.5K o menos o un poco mas, ya esa resistencia consume corriente y actuá como divisor de tensión.
Hola amigo, la intensidad de los led en esta aplicación creo que depende más del los tiempos de barrido que de la corriente misma de los led, hay que actualizar 37 columnas, permanecen mucho tiempo apagadas, yo te recomiendo dividir la matriz en dos de 18, las columnas van en paralelo y las filas se dividen en dos puertos del PIC, así, el primer puerto entrega los datos de las primeras 18 columnas y el puerto 2 entrega el dato de las siguientes, esto lo hice alguna vez y me solucionó el problema.
hola korpaztk, hace tiempo hice una matriz como la tuya, los leds que se ven encendidos fuera del caracter se deben a que haces cambio en el barrido si apagar todos los leds, mejor dicho apaga las columnas y filas y haz el cambio, eso elimino esa columna que se encendia con baja intensidad.
saludos.
vuelvo a retomar una idea que puse en post anteriores, es de hacer el barrido por filas, pero es solo una idea y hasta lo puedo hacer mas rapido y puedo lograr que este encendido mas tiempo.
void display(void) //rutina general que refresca las columnas de la matriz
{
int i; //inicio variable local
char columna; //otra variable local
mof=0x00; //es para que despues vuelva a la rutina anterior
output_high(PIN_D0); //habilito el registro
for(xcol=1;xcol<8;xcol++) //bucle para seleccionar el bit que quiero cargar
{
for (i=37;i>0;i--) //bucle para seleccionar la fila que quiero cargar
{
Columna=Columnas[i-1]; //tomo el valor de la fila y lo cargo en columna
Registro(bit_test (Columna, xcol)); //chequeo que estado tiene el bit xcol y lo envio
}
switch(xcol) //depende de la fila que este luego habilito el pin
{
case 1: output_high(PIN_B1);delay_ms(1);output_low(PIN_B1);delay_us(1);break;
case 2: output_high(PIN_B2);delay_ms(1);output_low(PIN_B2);delay_us(1);break;
case 3: output_high(PIN_B3);delay_ms(1);output_low(PIN_B3);delay_us(1);break;
case 4: output_high(PIN_B4);delay_ms(1);output_low(PIN_B4);delay_us(1);break;
case 5: output_high(PIN_B5);delay_ms(1);output_low(PIN_B5);delay_us(1);break;
case 6: output_high(PIN_B6);delay_ms(1);output_low(PIN_B6);delay_us(1);break;
case 7: output_high(PIN_B7);delay_ms(1);output_low(PIN_B7);delay_us(1);break;
}
}
}void Registro(int1 bt)
{
if (bt==0) //si el bit es 0
output_low(PIN_D1); //cargo 0 al registro
else //si el bit es 1
output_high(PIN_D1); //cargo 1 al registro
delay_us(1); //espero
output_low(PIN_C3); //cargo dato al registro
delay_us(1); //espero
output_high(PIN_C3); //dejo a la espera el registro para cargar nuevo dato
delay_us(1); //espero
}Hola amigo, la intensidad de los led en esta aplicación creo que depende más del los tiempos de barrido que de la corriente misma de los led, hay que actualizar 37 columnas, permanecen mucho tiempo apagadas, yo te recomiendo dividir la matriz en dos de 18, las columnas van en paralelo y las filas se dividen en dos puertos del PIC, así, el primer puerto entrega los datos de las primeras 18 columnas y el puerto 2 entrega el dato de las siguientes, esto lo hice alguna vez y me solucionó el problema.
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.
//***************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;
}
///////////////////////////////////////////////////////////////////////////////
Amigo porfavor digame el nombre del programa en el que programaste el microcontrolador en C
hoy monte en proteus tu circuito e intento ingresar texto en virtual terminal y no me deja y despues de unos segundos aparece la palabra BAR en los displays.
que puede ser?
o mas bien como hago para ingresar el texto y que me lo muestre en los displays?
for(xcol=0x01;xcol<0x08;xcol++) //con este bucle estamos viendo que fila vamos a encender.
{
for (i=37;i>0;i--) //con este otro veremos que columna estamos analizando.
{
col=columnas[i-1]; //aqui cargamos en esta variable el valor de la columna que querramos usar
delay_us(2);
bt=bit_test (col, xcol); //aqui testeamos el estado de un bit de la variable col que se cargo con los datos de la variable columna, y de ahi decimos que bit de los 8 queremos ver su estado, si es la primera vez testearemos el primer bit y lo almacenamos en la variable bt
delay_us(2);
portb=0x00; //aqui apagamos el puerto b
switch(bt) //luego dependiendo de ese estado en bt entramos a este switch y lo unico que hara es cargar en el registro de desplazamiento el correspondiente uno o cero
{
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) //por ultimo entramos en este otro switch y consultamos que fila debe encenderse (lo se lo se, tuviera que decir xfil y no xcol es confuso)
{
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;
}buen trabajo te quedo exlente no podrias subir el diagrama de potencia de la matriz ps hay una parte que no entiendo muy bien yo no se mucho de electronica pero esto de las matrices de led me gusta y no se como haces en la parte donde tienes los 7404 los sutistuyes por los uln2803 o van conectados unos de tras del otro y luego a los led disculpa mi ignorancialos 7404 y los uln2803 están conectados en cascada, osea la salida de un 7404 esta conectada a una entrada del uln2803 y su salida al katodo de un led.
tu utilizaste don pares de transistores para cada fila pero los conectaste a 12 o a 5v porue en un pos que subiste salia conectado a 12 y en otro a 5 y las resistencia de 74R las conectaste al colector del tip32 verdad esa es la unic duda q tengoahora recordé como era, antes utilizaba 12 y 5 v pero como me traían problemas deje toda la circuiteria a 5V únicamente.
disculpa que te moleste tanto pero tu en tu circuito conectas los 7404 en cascada con los uln? pues yo tengo entendido que los uln en un drive para manejar corrientes grandes con corrientes pequeñas pero tambien invierte la señal osea si tengo un 1 en la entrada del uln tendria un 0 en la salida i viceversa
entonces si eso es cierto para que utilizarias los 7404??? si el uln estaria haciendo el trabajo de el y controlaria la corriente de los led si me pudieras explicar te lo agradeceria
gracias
el pin nº 10 va a a 5v...
Saludos.-
yo le puse un trafo de 2 A (era el que tenia :D) pero el lm7805 soporta hasta 1.5A pero igual no llegue a consumir mucho.... con decirte que el lm7805 sin disipador comenzaba a entibiar, va un poquito mas de tibio pero iba bien, pero de todas formas le coloque un disipador ya que iba a estar en una caja cerrada y para evitar problemas por calentamiento interno/externo.
Saludos... cuando entres a armarlo subi algunas imagenes si quieres :)
bueno te cuento q ya me funciono pero la unica forma de hacerlo fue programandolo en el jdm serial que tenia por ahi guardado y dañado. toco arreglarlo e intentar hacerlo funcionar. bueno en finales me funciono pero me gustaria hacerlo funcionar con el pickit 2. ¿como hago para poner config con un valor de 3e72 que es con el valor que me funciona con el otro programador? pues cuando lo hago con el pickit 2 me pone config con un valor de 3f72 y no lo deja funcionar pues no se tampoco hacerlo por el lado de los fuses pues no se como colocar el WRT me saca error.
bueno te agradezco cualquier colaboracion feliz noche
ok gracias suky por responder pero estamos usando un 16f877a y en ccs y ahi lo utilizo con fuses
ok entonces si no coloco el max232 entonces no hay comunicacion entre el pc y el pic?
en muchos sitios hay información sobre eso. http://picrobot.blogspot.com/2010/09/max232_20.html
Saludos.-
hago el aporte, gracias a Diego E. para el programa en VB.
aqui una imagen
(http://img121.imageshack.us/img121/1441/carnc.png)
ahora se me ocurre una sugerencia pero voy a tratar de digerirla sobre el programa de la matriz
yo hago el barrido de la matriz por columnas...
osea:
tengo 36 columnas
esta es la sub-rutina donde hago el muestreo.Código: [Seleccionar]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);
}
}
demoro en hacer esto... aproximadamente: 19ms de los cuales se soluciona el parpadeo si disminuyo los 500 ms del penúltimo delay, ahora mi intención seria hacer el barrida pero por filas, ya que leí en algunos otros post, que aumenta el brillo del led y lo hago en menos tiempo... ahora esa es la cuestión...
ahora estoy solo, asi que puedo analizar tranquilo la situación, ya en un rato subo mas detalles :)
Gracias Korpaz muy buen aporte.. una pregunta.. como podria hacer para yo mismo agregarle un texto (en el programa) y que este me aparezca siempre....y luego aparezca la frase que yo escriba a travéz de la PC...algo asi como un parpadeo... la frase, termina la frase y vuelve al texto en el programa...deberías investigar un poco el código, yo en este momento no me acuerdo de mucho, pero deberías crear dos array, uno que sea el mensaje que siempre quieres ver y el otro que sea dinámico, como el que uso para poder escribir los mensajes.-
como hacen para controlar el cartel con el teclado de la PC? porque dice que esta hecho con el PIC16f628a.
hola korpaz que barbara te quedo tu matriz, tengo unas dudas sobre como se controla.
1. como haces que por medio de tu soft se mueva o se quede quieto???
2. tendras el archivo fuente de tu soft???
gracias :)
lo que trato es de poder poner varios mensajes de 5, que aparezcan 5 letras y luego otras 5 diferentes etc.. pero no se si es por medio del soft publik o del codigo .hex en el micro
Bueno amigos este tema es muy interesante, no se si seria tan amables de indicar al programar el pic 16f877A y al probar en la matriz, al inicio muestra algo en el panel .No entiendo tu planteo hercules, que es lo que quieres hacer?
Resulta que hice el panel de led, después de programar el microprocesador 16f877A monte en la placa y nada se ven en la matriz de led , por esa razón quería saber si después de programar se ve algo en la matriz o primero hay que enviar por puerto com para que aparezca el mensaje. Le agradeceré por su comentario.Si me mente no falla hercules, la primera vez que se inicia el cartel, no deberia aparecer nada, luego de que le agregues información entonces ahi si la próxima vez que lo enciendas aparecera el mensaje.
perdon por la pregunta, pero todo este proyecto se puede hacer en asm ?? tambien me parece bueno poder agregarle una memoria externa para poder hacer mas columnas y mas largos los mensajes, que opinan ? lo del asm es porque quienes tenemos poco conocimiento y ensima en asm estamos al horno , jajaa.
Gracias a todos , feliz año 2013 a todos, dejo mi mail por si alguien quiere contactarse.
rudafi@yahoo.com.ar
Atte.
Ruben