Cursillo en C18 para PICS DESDE CERO

[manex_1987]

Buenas

Yo tambien me he pasado al c18. Visto lo efectivo de las librerias de c18 (ni xlcd.h ni adc.h acaban de convencerme), os pongo una modificacion de xlcd.h, basandome en otras libs: 

**No olvideis definir en el programa principal las funciones de retardo, que segun la frecuencia, pueden variar:
 void Delay1u();
 void Delayms(char n);
**

Código: [Seleccionar]

#define lcd_type 2
#define lcd_line_two 0x40
#define tris_write 0x00
#define tris_read 0xF0
//Interfaz 4 bits, datos en nibble superior.
#define LCD_E PORTDbits.RD0
#define LCD_RS PORTDbits.RD1
#define LCD_RW PORTDbits.RD2
#define LCD_TRIS TRISD
#define LCD_PORT PORTD

char const INIT[4]={0x20|(lcd_type<<2),0x0c,1,6};
extern void Delay1u();
extern void Delayms(char n);

char lcd_read_byte();
void lcd_send_nibble(char n);
void lcd_CmdData(char opt,char n);
void lcd_init();
void lcd_gotoxy(char x,char y);
void lcd_putc(char c);

char lcd_read_byte()
{
char lo,hi;
LCD_TRIS=tris_read;
LCD_RW=1;
Nop();
LCD_E=1;
Nop();
hi=LCD_PORT&0xF0;
LCD_E=0;
Nop();
LCD_E=1;
Delay1u();
Delay1u();
lo=(LCD_PORT>>4)&0x0F;
LCD_E=0;
LCD_TRIS=tris_write;
return(hi|lo);
}

void lcd_send_nibble(char n)
{
LCD_PORT&=0x0F;
LCD_PORT|=((n&0x0F)<<4);
Nop();
Delay1u();
LCD_E=1;
Delay1u();
LCD_E=0;
}

void lcd_CmdData(char opt,char n)
{
LCD_RS=0;
while((lcd_read_byte()|0x7F)==0xFF);
LCD_RS=opt;
Nop();
LCD_RW=0;
Delay1u();
LCD_E=0;
lcd_send_nibble(n>>4);
lcd_send_nibble(n);
}

void lcd_init()
{
char i;
LCD_TRIS=tris_write;
LCD_RS=0;
LCD_RW=0;
LCD_E=0;
Delayms(5);
for(i=1;i<=3;++i)
{
lcd_send_nibble(3);
Delayms(5);
}
lcd_send_nibble(2);
for(i=0;i<=3;++i)
lcd_CmdData(0,INIT[i]);
}

void lcd_gotoxy(char x,char y)
{
char addr;
if(y==1)
{
addr=0x00;
}
else
{
addr=0x40;
}
addr+=x-1;
lcd_CmdData(0,0x80|addr);
}

void lcd_putc(char c)
{
switch (c){
case '\f' :lcd_CmdData(0,1);
Delayms(2);
break;
case '\n' :lcd_gotoxy(1,2);
break;
case '\b' :lcd_CmdData(0,0x10);
break;
default :lcd_CmdData(1,c);
}
}

Recordar tambien, que mediante la funcion fprintf (stdio.h) podemos printefear un string con formato.

Para ello, definiremos una funcion

Código: [Seleccionar]

void _user_putc(char c)
{
    lcd_putc(c);
}

y luego invocaremos fprintf, de la forma  fprintf(_H_USER,"Mi texto %d %d",num1,num2);


Espero que sirva de algo el aporte.

[micro_cadaver]

excelente aporte manex 

[PalitroqueZ]

una duda micro, ¿el barrido del dibujo se hace por filas o por columnas?

...dibujando por las columnas y habilitando por las filas
...

tendrá el mismo efecto dibujando al contrario, es decir, dibujando por filas y habilitando por columnas

[micro_cadaver]

claro que si, son caminos distintos de hacer lo mismo.

[caldono]

Hola, soy nuevo en este foro me interesa este cuento de la programacion en C quiero saber si es posible con el C18 ó el C30 programar micros de la serie 16F

[micro_cadaver]

hola amigo, el C30 solo sirve para la gama dspic, el C18 para la gama 18FXXXX, y nada mas.

Para la gama 16FXXX hay otros compiladores por ejemplo CCS (muy usado en el foro), HITECH PICC, MIkroC, y.. algunos más que ignoro.

[micro_cadaver]

seguimos...

Lo primero es definir los pines que se va a utilizar en la aplicación.

Código: C

1. #define reloj   PORTBbits.RB0
2. //pin de entrada que recibira los pulsos del ds1307
3. //con lo cual actualizara el panel cada 2 segundos (segun el proteus)
4.  
5. #define datos_4094              LATCbits.LATC0
6. #define reloj_4094              LATCbits.LATC1
7. #define habilita_4094           LATCbits.LATC2
8. //estos son los pines de control de los 4094
9.  
10. #define fila_1  LATBbits.LATB1
11. #define fila_2  LATBbits.LATB2
12. #define fila_3  LATBbits.LATB3
13. #define fila_4  LATBbits.LATB4
14. #define fila_5  LATBbits.LATB5
15. #define fila_6  LATBbits.LATB6
16. #define fila_7  LATBbits.LATB7
17. //estos son los disparos de las 7 filas del panel

Como se puede apreciar quedan muchos pines libres, lo cual permite usar un PIC de menor tamaño o sino agregarle más características.

Y que va a hacer esto?
Primero configuraremos el ds1307 con la hora deseada y setearemos el disparo de pulsos a 4.096Khz (en el proteus esto me mide 2.048..KHz), luego esta salida la conectaremos al pin de entrada RB0 y utilizaremos su interrupcion por flanco para determinar el momento en que llega a 1 segundo y con un banderin actualizamos el panel leyendo el contenido del DS1307 (en el proteus esto lo hace cada 2 segundos). Entonces el panel estará partido en 2 mitades, en los primeros 32 estará el reloj y en los otros 32 estará un mensaje predeterminado. Ahora veamos el codigo por partes, asi entenderemos mejor el uso y aplicación de todas las instrucciones del C18.

[micro_cadaver]

Encabezado Principal
Todo programa comienza con su encabezado, en esta parte se tiene que mencionar las librerias que vamos a utilizar, los bits de configuración (fuses) y las definiciones de los pines que se utilizará (opcional).

Código: C

1. #include <p18f2525.h>
2. //libreria para el pic18f2525
3. #include <delays.h>
4. //libreria para los retardos
5. #include <i2c.h>
6. //libreria para uso y configuracion del modulo I2C
7. #include "C:\PIC\18F\RELOJ PANEL\ds1307.h"
8. //libreria del reloj digital DS1307 se puede poner tambien solo #include "ds1307.h"
9. pero decidi dejarlo asi para que se entienda de donde viene esta libreria
10.  
11. //bits de configuracion, hay otras maneras de hacerlo, esta es una de las tantas
12. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
13. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
14. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
15. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
16. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
17. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
18. #pragma config CPB = ON,CPD = ON//CONFIG5H
19. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
20. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
21. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
22. #pragma config EBTRB = ON//CONFIG7H
23.  
24. //definicion de los pines de la aplicacion
25. #define reloj   PORTBbits.RB0
26. #define datos_4094              LATCbits.LATC0
27. #define reloj_4094              LATCbits.LATC1
28. #define habilita_4094   LATCbits.LATC2
29.  
30. #define fila_1  LATBbits.LATB1
31. #define fila_2  LATBbits.LATB2
32. #define fila_3  LATBbits.LATB3
33. #define fila_4  LATBbits.LATB4
34. #define fila_5  LATBbits.LATB5
35. #define fila_6  LATBbits.LATB6
36. #define fila_7  LATBbits.LATB7

Configuracion de Puertos
Utilizaremos la siguiente configuracion:

Código: C

1. void main(void)
2. {
3.         //inicializar puertoA todos los pines seran digitales
4.         PORTA = 0X00;ADCON0 = 0X00;
5.         ADCON1 = 0X0F;CMCON = 0X07;
6.  
7.         TRISA = 0X00;TRISB = 0X01;TRISC = 0X18;
8.         LATA = 0X00;LATB = 0X00;LATC = 0X00;   
9.         //PORTA como salida
10.         //PORTB como salida a excepion del RB0 que sera entrada
11.         //PORTC salida menos los pines del modulo I2C que los pondremos como entrada
12.  
13.         Delay10KTCYx(250);     
14.         //retardo= 250 * 10 000 * (4/fosc)  = 25 * 10^5 * (4/(4*10^6)) = 2.5 segundos

Configuración del Módulo I2C
Vamos a configurar el DS1307, pero antes se inicializa el módulo I2C del PIC.

Código: C

1. //*******************************************************
2. //      configuracion del modulo i2c
3. //*******************************************************
4.         OpenI2C(MASTER,SLEW_OFF);//inicializo modulo
5.         SSPADD = 9;//100KHz para 4MHz
6. //*******************************************************
7. //      configuracion del reloj y calendario
8. //*******************************************************
9.         Inicializa_ds1307( 0X00, //segundos + ch
10.                            0X03, //minutos
11.                            0X52, //horas + configuracion AM/PM
12.                            0X07, //dia
13.                            0X01, //fecha
14.                            0X07, //mes
15.                            0X07, //year
16.                            0X11); //control

La Interrupción del RB0
La característica de interrupción del pin RB0 tendrá un flanco de subida para la activación de la interrupción, en su respectiva zona de interrupción habrá un registro que permitirá conocer cuando llega a 1 segundo gracias a los pulsos de 4.096Khz que vienen de la salida del ds1307.
El contador efectuará la siguiente ecuación: (1/f reloj) * 4096 = (1/4096Hz)(4096) = 1 segundo

Código: C

1. void interrupciones(void);//prototipo de la funcion "interrupciones"
2.  
3. //
4. //******************************************************//
5. //      Vector de Interrupcion
6. //******************************************************//
7. //
8. #pragma code prioridad_nomal = 0X0008
9. //vector para las interrupciones en modo compatible con las 16Fxxx
10. //o mejor dicho, interrupciones sin prioridades
11.  
12. void interrupcion_normal (void)
13. {
14.         _asm goto interrupciones _endasm
15. }
16. #pragma code
17. //fin de la interrupcion (retfie en el ASM)
18.  
19. //
20. //******************************************************//
21. //      Rutina de Interrupcion
22. //******************************************************//
23. //
24. #pragma interrupt interrupciones
25. //funcion "interrupciones"
26. void interrupciones(void)
27. {
28.         if(INTCONbits.INT0IF) //pregunta por bandera de interrupcion
29.         {
30.                 ct_reloj--;
31.                 if(ct_reloj==0)
32.                 {
33.                         ct_reloj=0x1000; //0x1000 = D'4096'
34.                         marcador=0;
35.                 }
36.                 INTCONbits.INT0IF = 0;  //limpia bandera y salimos
37.         }
38. }

Luego se coloca los bits que configuran a la interrupcion

Código: C

1. //*******************************************************
2. //      inrterrupcion del pin RB0
3. //*******************************************************
4.         RCON = 0X00; //IPEN = 0 interrupciones sin prioridades
5.         INTCON = 0X90; //configuramos la interrupcion externa del RB0
6.         INTCON2 = 0X40; //configuramos el flanco de subida para la interrupcion

[micro_cadaver]

Datos en la Memoria RAM
Muchos de los procesos para el manejo del panel tienen su apoyo en registros de propósito general ubicados en esta memoria del PIC, vamos a detallar los registros, tablas y matrices que usamos en el C18. Se puede definir su tipo y también si poseen un valor inicial.

Código: C

1. unsigned int temp,marcador=0xff;
2. //tipo: entero sin signo, registros de 16bits
3.  
4. unsigned char cadena[8],numeros,i,j,k;
5. //tipo: caracter sin signo, registros de 8 bits
6. //cadena[8]: arreglo de 8 registros tipo unsigned char
7. //se lee: array "cadena" tiene 8 elementos de 8 bits cada uno
8.  
9. volatile unsigned int ct_reloj=0x1000,ct_panel=41,caracter=0;
10. //tipo: volatil entero sin signo, registros de 16bits utilizados dentro y fuera
11. //de las interrupciones, de preferencia solo usarse dentro de las interrupciones

Hemos implementado unas tablas de valores que poseen la codificación de cada numero en el panel, del 0 al 9, y están ubicados desde la posicion de memoria 0x100 de la RAM. Tienen un orden tipo matriz de 7 filas por 2 columnas de tal manera que sea fácil su adquisición durante el proceso de actualizar el panel al leer el ds1307.

Como pueden notar, estamos usando la directiva #pragma para ubicar el contenido de la RAM en una posicion definida por nosotros de la siguiente manera:

#pragma idata tablas = 0X100
           //
           //registros inicializados
           //
#pragma idata

Código: C

1. //
2. //******************************************************//
3. //      Ubicacion de tabla inicializada en RAM 0X100
4. //******************************************************//
5. //
6. #pragma idata tablas = 0X100
7. unsigned char numero_0[7][2] = {0X00,0X00,
8.                                 0XE0,0X0E,
9.                                 0XA0,0X0A,
10.                                 0XA0,0X0A,
11.                                 0XA0,0X0A,
12.                                 0XE0,0X0E,
13.                                 0X00,0X00};    
14.  
15. unsigned char numero_9[7][2] = {0X00,0X00,
16.                                 0XE0,0X0E,
17.                                 0XA0,0X0A,
18.                                 0XE0,0X0E,
19.                                 0X20,0X02,
20.                                 0X20,0X02,
21.                                 0X00,0X00};    
22. #pragma idata

De la misma forma tendremos la organización en la RAM de los valores que se imprimiran en el panel de leds, observen las matrices "fila_reloj" y "fila_mensaje", ambos están ordenados en 7 filas por 4 columnas, si las juntamos llenarian el panel 7 x 32 bits, donde cada columna de las matrices incluye a 8 bits. También esta definida a partir de la posición 0x400.

Código: C

1. #pragma idata panel = 0X400
2. unsigned char fila_reloj[7][4] = {0X00,0X00,0X00,0X00,
3.                                   0X4E,0XAE,0XEE,0X00,
4.                                   0XC2,0XA2,0X8A,0X44,
5.                                   0X4E,0XEE,0XEE,0X00,
6.                                   0X48,0X22,0X22,0X44,
7.                                   0X4E,0X2E,0XE2,0X00,
8.                                   0X00,0X00,0X00,0X00};
9.  
10. unsigned char fila_mensaje[7][4] = {0X00,0X00,0X00,0X00,
11.                                     0XEE,0XEA,0XEE,0X4E,
12.                                     0XA8,0XAA,0X2A,0XCA,
13.                                     0XEE,0XEA,0XEA,0X4A,
14.                                     0X88,0XCA,0X8A,0X4A,
15.                                     0X8E,0XAE,0XEE,0X4E,
16.                                     0X00,0X00,0X00,0X00};
17. #pragma idata

Lo cual permite vislumbrar la manera en que cargaremos los valores en el panel de leds.

[micro_cadaver]

Estructura Principal
Este es el proceso que está dentro del main desde la cual se llamarán a las distintas funciones que hemos programado para el manejo del panel. Observen que un bucle infinito while(1) domina a todo el proceso, dentro de él estan el manejo de panel encargado por la función " cargar_filas(); " , y la actualización del reloj leyendo cada 1 seg (en el proteus me sale cada 2seg) el chip ds1307.

Código: C

1. while(1)
2.         //bucle infinito que domina todo el proceso.
3.         {
4.                 cargar_filas();
5.                 //funcion que escribe la matriz de registros sobre el panel
6.                 //cada fila tiene un retardo de 5mseg, entonces como son
7.                 //7 filas esta funcion se toma 35mseg pero más los procesos
8.                 //de desplzamiento y busqueda, se toma 54mseg.
9.  
10.                 if(marcador==0)
11.                 //registro bandera que indica el momento de actualizar
12.                 //cada 1 seg (en proteus 2seg), es puesto a cero desde la
13.                 //interrupcion en RB0.
14.                 {
15.                         marcador=0xff;
16.                         //volvemos a cargar el registro para una posterior espera.
17.  
18.                         LeeDatos_ds1307(0x00,cadena,3);
19.                         //lectura de los registros de ds1307 que corresponden a los
20.                         //segundos, minutos, hora, y los guarda en "cadena".
21.  
22.                         numeros=cadena[0];j=2;//apunta al valor segundos
23.                         actualiza_filas();//carga en matriz panel
24.  
25.                         numeros=cadena[1];j=1;//apunta al valor minutos
26.                         actualiza_filas();//carga en matriz panel
27.  
28.                         numeros=(cadena[2] & 0x1F);j=0;//apunta al valor hora
29.                         actualiza_filas();//carga en matriz panel
30.                 }
31.         }

Función cargar_filas
Esta es la función que permite visualizar el contenido de la matriz panel sobre los leds del panel, haciendo todo el proceso de desplzamiento serial a través de los CD4094, habilitando su correspondiente fila por el portB, y también incluido está el mensaje previamente definido en su respectiva matriz.

Código: C

1. //
2. //******************************************************//
3. //      Funcion cargar filas
4. //******************************************************//
5. //
6. void cargar_filas(void)
7. {
8.         for(i=0;i<=6;i++) //i : indice para las filas del panel
9.         {
10.                 j=3; //j : columnas del panel
11.                 for(k=0;k<=3;k++) //k : indice para el bucle for
12.                 {
13.                         desplaza_filas(fila_mensaje[i][j]); //funcion de desplazamiento
14.                         j--;
15.                 }
16.  
17.                 j=3; //j : columnas del panel
18.                 for(k=0;k<=3;k++) //k : indice para el bucle for
19.                 {
20.                         desplaza_filas(fila_reloj[i][j]); //funcion de desplazamiento
21.                         j--;
22.                 }
23.  
24.                 //deshabilitamos las filas del panel
25.                 //y cargamos el desplazamiento en las
26.                //salidas de los CD4094
27.                 LATB=0XFF;
28.                 Nop();
29.                 Nop();
30.                 habilita_4094=1;
31.                 Nop();
32.                 Nop();
33.                 habilita_4094=0;
34.                 Nop();
35.                 Nop();
36.  
37.                 //ahora buscamos la fila que corresponde habilitar
38.                 switch(i)
39.                 {
40.                         case 0:
41.                         fila_1=0;break;
42.                         case 1:
43.                         fila_2=0;break;
44.                         case 2:
45.                         fila_3=0;break;
46.                         case 3:
47.                         fila_4=0;break;
48.                         case 4:
49.                         fila_5=0;break;
50.                         case 5:
51.                         fila_6=0;break;
52.                         case 6:
53.                         fila_7=0;break;
54.                         default:
55.                         Nop();
56.                 }
57.                 Delay1KTCYx(5); //retardo 5mseg
58.         }
59. }

Función desplaza_filas
Esta función se encarga del desplazamiento serial sobre los 8 CD4094, y requiere un valor de entrada tipo char, una vez guardado este valor en registro " fila " comenzamos la cargar por el bit de menor peso, le damos un puklso de reloj y hacemos esto 8 veces para que se desplazen los 8 bits del registro fila tipo char.

Código: C

1. //
2. //******************************************************//
3. //       funcion desplaza filas
4. //******************************************************//
5. //
6. void desplaza_filas(unsigned char fila)
7. {
8.         for(temp=8;temp>=1;temp--) //indice para repetir 8 veces
9.         {
10.                 datos_4094=0;
11.                 if((fila & 0X01)== 1) //preguntamos por el bit de menor peso
12.                         datos_4094=1;
13.  
14.                 //le damos un pulso de reloj
15.                 Nop();
16.                 Nop();
17.                 reloj_4094=1;
18.                 Nop();
19.                 Nop();
20.                 reloj_4094=0;
21.                 Nop();
22.                 Nop();
23.  
24.                 //desplazamiento a la derecha para analizar
25.                 //el siguiente bit a desplazar del registro fila
26.                 fila >>= 1;
27.         }
28. }

[micro_cadaver]

Funcion actualiza filas
Esta si que me salio muy larga  , como recordarán antes de invocar la función "desplaza_filas" se carga un registro "numeros" con el valor de la cadena[ ]  correspendiente a la característica que corresponde, ya sea segundo o minutos u hora. Se le acompaña de un indice " j " que sirve para ubicarlo dentro la matriz en el lugar que le corresponde:

• j=0 corresponde a las horas
• j=1 corresponde a los minutos
• j=2 corresponde a los segundos

Entonces una vez cargado este registro "numeros" pasamos a analizar la funcion "actualiza_filas"

Código: C

1. numeros=cadena[0];j=2;
2.         actualiza_filas();
3.  
4.         numeros=cadena[1];j=1;
5.         actualiza_filas();
6.  
7.         numeros=(cadena[2] & 0x1F);j=0;
8.         actualiza_filas();

Esta función se encarga de colocar las matrices de caracteres numéricos correspondientes al valor del registro "numero",

como pueden ver cada dos digitos ocupan 8 bits y estan separados por un caracter que representan al famoso ":", entonces primero es detectar el caracter numérico que corresponde y luego escrbiirlo sobre la matriz del panel.

Código: C

1. //
2. //******************************************************//
3. //******************************************************//
4. //
5. //      Actualiza Filas
6. //
7. //******************************************************//
8. //******************************************************//
9. //
10. void actualiza_filas(void)
11. {
12.         //vamos a buscar el caracter correspondiente a las decenas
13.         k=numeros>>4;
14.         switch(k)
15.         {
16.                 case 0:
17.                 for(i=0;i<=6;i++)
18.                 {
19.                         fila_reloj[i][j] = numero_0[i][0];
20.                 }      
21.                 break;
22.  
23.                 case 1:
24.                 for(i=0;i<=6;i++)
25.                 {
26.                         fila_reloj[i][j] = numero_1[i][0];
27.                 }      
28.                 break;
29.  
30.                 case 2:
31.                 for(i=0;i<=6;i++)
32.                 {
33.                         fila_reloj[i][j] = numero_2[i][0];
34.                 }      
35.                 break;
36.  
37.                 case 3:
38.                 for(i=0;i<=6;i++)
39.                 {
40.                         fila_reloj[i][j] = numero_3[i][0];
41.                 }      
42.                 break;
43.  
44.                 case 4:
45.                 for(i=0;i<=6;i++)
46.                 {
47.                         fila_reloj[i][j] = numero_4[i][0];
48.                 }      
49.                 break;
50.  
51.                 case 5:
52.                 for(i=0;i<=6;i++)
53.                 {
54.                         fila_reloj[i][j] = numero_5[i][0];
55.                 }      
56.                 break;
57.  
58.                 case 6:
59.                 for(i=0;i<=6;i++)
60.                 {
61.                         fila_reloj[i][j] = numero_6[i][0];
62.                 }      
63.                 break;
64.  
65.                 case 7:
66.                 for(i=0;i<=6;i++)
67.                 {
68.                         fila_reloj[i][j] = numero_7[i][0];
69.                 }      
70.                 break;
71.  
72.                 case 8:
73.                 for(i=0;i<=6;i++)
74.                 {
75.                         fila_reloj[i][j] = numero_8[i][0];
76.                 }      
77.                 break;
78.  
79.                 case 9:
80.                 for(i=0;i<=6;i++)
81.                 {
82.                         fila_reloj[i][j] = numero_9[i][0];
83.                 }      
84.                 break;
85.  
86.                 default:
87.                 Nop();
88.         }
89.  
90.         //vamos a buscar el caracter correspondiente a las unidades
91.         k=numeros & 0x0F;                                      
92.         switch(k)
93.         {
94.                 case 0:
95.                 for(i=0;i<=6;i++)
96.                 {
97.                         fila_reloj[i][j] |= numero_0[i][1];
98.                 }      
99.                 break;
100.  
101.                 case 1:
102.                 for(i=0;i<=6;i++)
103.                 {
104.                         fila_reloj[i][j] |= numero_1[i][1];
105.                 }      
106.                 break;
107.  
108.                 case 2:
109.                 for(i=0;i<=6;i++)
110.                 {
111.                         fila_reloj[i][j] |= numero_2[i][1];
112.                 }      
113.                 break;
114.  
115.                 case 3:
116.                 for(i=0;i<=6;i++)
117.                 {
118.                         fila_reloj[i][j] |= numero_3[i][1];
119.                 }      
120.                 break;
121.  
122.                 case 4:
123.                 for(i=0;i<=6;i++)
124.                 {
125.                         fila_reloj[i][j] |= numero_4[i][1];
126.                 }      
127.                 break;
128.  
129.                 case 5:
130.                 for(i=0;i<=6;i++)
131.                 {
132.                         fila_reloj[i][j] |= numero_5[i][1];
133.                 }      
134.                 break;
135.  
136.                 case 6:
137.                 for(i=0;i<=6;i++)
138.                 {
139.                         fila_reloj[i][j] |= numero_6[i][1];
140.                 }      
141.                 break;
142.  
143.                 case 7:
144.                 for(i=0;i<=6;i++)
145.                 {
146.                         fila_reloj[i][j] |= numero_7[i][1];
147.                 }      
148.                 break;
149.  
150.                 case 8:
151.                 for(i=0;i<=6;i++)
152.                 {
153.                         fila_reloj[i][j] |= numero_8[i][1];
154.                 }      
155.                 break;
156.  
157.                 case 9:
158.                 for(i=0;i<=6;i++)
159.                 {
160.                         fila_reloj[i][j] |= numero_9[i][1];
161.                 }      
162.                 break;
163.  
164.                 default:
165.                 Nop();
166.         }
167. }

  y deberia funcionar en la realidad no?

[micro_cadaver]

todos los archivos del ejemplo del panel:
h**p://www.box.net/shared/q90qmopnyl

Luego continuaremos con el resto de perifericos del PIC, como el A/D, mas interrupciones, EEPROM interna, y lo que se nos ocurra por ahi 

PD: si alguien quiere proponer algo, que lo haga!

[PalitroqueZ]

se me ocurre algo loco  un datalogger usando la e2prom como almacenamiento usando las interrupciones para el cad y la memoria.

[micro_cadaver]

ya pes es dificil? que nos falta saber del pic para realizar ese proyecto

[PalitroqueZ]

se puede usar un 16f877 y montarlo en proteus