Mini curso "Programación en XC8"

[lmtreser]

Hola amigos, a continuación voy a publicar el mini curso que estoy armando de a poco en el foro uControl. Bienvenidas sugerencias, correcciones y aportes aquí mismo, por Twitter o como sea!

Mini curso "Programación de micros en C desde 0"

Introducción

Hola, hoy empiezo este mini curso de programación de microcontroladores PIC en lenguaje C desde 0. La idea es aprender paso a paso, realizar algunos proyectos simples y sumar conocimientos.

Voy a trabajar sobre el sistema operativo Ubuntu, con software libre o gratuito. Para todos aquellos que utilizan Windows no van a tener inconvenientes porque los paquetes de software son multiplataforma. Voy a utilizar como entorno de desarrollo MPLAB X en conjunto con el compilador XC8. No me voy a detener en la instalación y configuración del IDE y del compilador ya que existen muchos tutoriales sobre esto (por ejemplo). El microcontrolador por ahora es un PIC16F648A salvo indicación contraria!

El curso lo voy realizando sobre la marcha, en parte leyendo libros, en parte dudas consultadas a los expertos en el foro y en parte en experiencias propias. Por este motivo lo verán formarse "online" y a medida que el tiempo me lo permita ire sumando contenido. Les recomiendo que lean el tutorial sobre XC8 que escribió Suky que es un buen punto de partida y el "Tutorial MPLAB C18 Desde Cero". También es de mucha utilidad tener a mano los ejemplos de Microchip para consulta: Microchip Code Examples (12F & 16F).

Indice:

1.1. Estructura de un programa en C
1.2. ¡Hola Mundo! en C (o como hacer destellar un LED)
1.3. Leer un pulsador
1.4. Utilizando PWM
1.5. Uso de funciones
1.6. Variables y tipos de datos
1.7. Usando una interrupción por timer0
1.8. Interrupciones de alta y baja prioridad

Ejemplos y rutinas útiles:

2.1. Ejemplo de uso PIC18F4550, delays y USART
2.2. Escribir y leer una memoria EEPROM
2.3. Rutina para generar pausas extensas
2.4. PIC16F819 controlando un modulo LCD 2x16 - 4 bits
2.5. Conversores ADC/PWM (uso de la función ITOA)
2.6. Uso de I2C por software

Bugs, errores, herramientas:

3.1. Corrección del bug "maldita linea roja"
3.2. Dolor de cabeza con el uso de la librería del LCD xlcd.h
3.3. Integrar Proteus VSM para hacer debug en los proyectos de MPLABX con el plugin Proteus VSM viewer
3.4. View Includes Hierarchy
3.5. View macro expansion
3.6. Generador de código para los "Bits de configuración"

[lmtreser]

1.1. Estructura de un programa en C

C es el lenguaje de programación que utilizaremos. Un programa C está compuesto por una o varias funciones, dentro de las cuales tendremos una o más instrucciones. Existe una función llamada "main" donde tendremos nuestro código principal.

Comentarios: Los comentarios son de mucha utilidad para entender lo que escribimos. Para realizar un comentario anteponemos en la línea de código "//" y el compilador la ignorará. También podemos comentar bloques de código utilizando "/*" para abrir y "*/" para cerrar.

Includes: utilizando "#include" incluimos en nuestro programa archivos de funciones o librerías que nos permitirán utilizar características especiales.

Ejemplo:

Código: C

1. /*
2.  * File:   main.c
3.  * Author: lucas
4.  * Created on 1 de abril de 2013, 22:20
5.  *
6.  * ESTO ES UN BLOQUE DE COMENTARIOS
7.  */
8.  
9. #include <xc.h> // Incluimos la librería XC8
10.  
11. // ESTO ES UN COMENTARIO DE UNA LINEA
12.  
13. // Función principal
14. void main ()
15. {
16.     OSCCONbits.IRCF = 0b110; // Instrucción
17.  
18. }

IMPORTANTE:

* Todas las instrucciones deben terminar si o si en ";".
* Los bloques de instrucciones empiezan con "{" y terminan con "}".
* C es case sensitive, es decir que distingue minúsculas de mayúsculas.

[lmtreser]

1.2. ¡Hola mundo! en C (o como hacer destellar un LED)

Hacer destellar un LED es muy sencillo. Tanto como crear un bucle infinito, escribir en un pin, generar una demora y volver a escribir. El ejemplito:

Código: C

1. /*
2.  * File:   main.c
3.  * Author: lucas
4.  * Created on 1 de abril de 2013, 22:20
5.  * Microcontrolador: PIC16F648A
6.  *
7.  * ¡Hola Mundo! en C (o como hacer destellar un LED)
8.  */
9.  
10. #include <stdio.h>
11. #include <stdlib.h>
12. #include <xc.h> // Librería XC8
13.  
14. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
15.  
16. // PIC16F648A Configuration Bit Settings
17. #pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on RA7/OSC1/CLKIN)
18. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
19. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
20. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
21. #pragma config BOREN = ON       // Brown-out Detect Enable bit (BOD enabled)
22. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming)
23. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
24. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
25.  
26. // FUNCION PRINCIPAL
27. void main ()
28. {
29.      TRISB = 0b00000000; // Configuro puerto B como salidas
30.      while (1) // Bucle infinito
31.      {
32.          PORTBbits.RB0 = 0; // Apago pin RB0
33.          __delay_ms(500);
34.          PORTBbits.RB0 = 1; // Enciendo pin RB0
35.          __delay_ms(500);
36.      }
37. }

* Podríamos hacer el cambio de estado del pin RB0 (toggle) utilizando la siguiente instrucción: PORTBbits.RB0 ^= 1;

[lmtreser]

1.3. Leer un pulsador

Utilizando una estructura condicional "if" podemos leer un pulsador conectado en RB0 para encender o apagar un LED en el pin RB4.

Código: C

1. /*
2.  * File:   main.c
3.  * Author: lucas
4.  * Created on 1 de abril de 2013, 22:20
5.  * Microcontrolador: PIC16F648A
6.  *
7.  */
8.  
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <xc.h> // Librería XC8
12.  
13. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
14.  
15. // PIC16F648A Configuration Bit Settings
16. #pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on RA7/OSC1/CLKIN)
17. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
18. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
19. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
20. #pragma config BOREN = ON       // Brown-out Detect Enable bit (BOD enabled)
21. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming)
22. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
23. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
24.  
25. // FUNCION PRINCIPAL
26.  
27. void main() {
28.  
29.     TRISB = 0b00000001; // Configuro puerto B
30.     PORTB = 0b00000000;
31.  
32.     if (PORTBbits.RB0 == 1) {
33.         PORTBbits.RB4 = 1;
34.     } else {
35.         PORTBbits.RB4 = 0;
36.     }
37. }

[lmtreser]

1.4. Utilizando PWM

Vamos a utilizar una señal PWM de 8 bits para controlar el brillo de un LED. Para configurar el módulo CCP1 en modo PWM solo basta con escribir 0x0C en el registro CCP1CON.

Frecuencia PWM: el periodo de la onda PWM lo determina el tiempo que dura el conteo del Timer2 desde 0 hasta el valor cargado en el registro PR2. Y como la frecuencia es la inversa del período podemos deducir:

Donde:

* PR2 es el valor del registro PR2 (entre 0 y 255)
* FOSC es la frecuencia del cristal utilizado
* Prescaler es el prescaler del Timer2 (1, 4 ó 16). Se configura en el registro T2CON.

Ciclo de trabajo (duty cicle): es la cantidad de tiempo que en un periodo la salida PWM permanece en estado alto. El valor es determinado por el contenido del registro CCPR1L. Podemos deducir el tiempo utilizando la formula:

Donde:

* CCPR1L es el valor del registro CCPR1L (entre 0 y 255)
* FOSC es la frecuencia del cristal
* Prescaler   es el prescaler del Timer2 (1, 4 ó 16)

Ejemplo dimerizado de un LED conectado a RB3

Código: C

1. /*
2.  * File:   main.c
3.  * Author: lucas
4.  * Created on 1 de abril de 2013, 22:20
5.  * Microcontrolador: PIC16F648A
6.  *
7.  * Utilizando PWM para dimerizar un LED
8.  */
9.  
10. #include <stdio.h>
11. #include <stdlib.h>
12. #include <xc.h> // Librería XC8
13.  
14. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
15.  
16. // PIC16F648A Configuration Bit Settings
17. #pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on RA7/OSC1/CLKIN)
18. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
19. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
20. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
21. #pragma config BOREN = ON       // Brown-out Detect Enable bit (BOD enabled)
22. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming)
23. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
24. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
25.  
26. // FUNCION PRINCIPAL
27. void main(void) {
28.     TRISB = 0;                  // Puerto B como salidas
29.     PORTB = 0;                  // Limpio el puerto B
30.  
31. // CONFIGURANDO PWM  
32.     CCP1CON = 0b00001100;       // Activamos el modo PWM
33.     PR2 = 250;                  // Frecuencia 250Hz
34.     T2CONbits.T2CKPS = 0b10;    // Prescaler del timer 2 en 1:16
35.     T2CONbits.TMR2ON = 1;       // Arranca el PWM      
36.  
37. // BUCLE INFINITO
38.     unsigned char i;           // Declaramos una variable
39.     while (1){
40.     for(i=0; i=50; i++)
41.     {
42.       CCPR1L = CCPR1L++;        // Seteando el ciclo de trabajo
43.       __delay_ms (100);    
44.     }
45.     i=0;                       // Reiniciamos la variable para comenzar el ciclo de nuevo
46.     }
47.     }

[lmtreser]

1.5. Uso de funciones

Las funciones sirven para modularizar un programa. La idea es dividir nuestro código en distintos bloques, y asignarle una tarea especifica a cada uno. Esto nos ayudará a comprender el funcionamiento de nuestro programa y a hacerlo más ordenado.

Si bien todavía no hablamos para nada de variables, tenemos que tener en cuenta que juega un papel muy importante la forma en que las declaramos. Un poco más adelante lo veremos.

La sintaxis de una función es la siguiente:

tipo_de_datos nombre_de_la_funcion (tipo_y_nombre_de_argumentos) {
    instrucciones
    instrucciones
}
 
donde:

tipo_de_datos: es el tipo de dato que devolverá esa función.
nombre_de_la_funcion: es el identificador que le damos a nuestra función.
tipo_y_nombre_de_argumentos: son los parámetros que recibe la función.

No todas las funciones reciben argumentos. En caso que posean se tratan simplemente de variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función.

Un sencillo ejemplo:

Código: C

1. // FUNCION "EJEMPLO". NO RECIBE ARGUMENTOS
2. void ejemplo (void){
3.     PORTBbits.RB1 = 1;    // High pin RB1
4.     __delay_ms (1700);    // Demora
5.     PORTBbits.RB1 = 0;    // Low pin RB1
6. }
7.  
8. // FUNCION PRINCIPAL
9. void main(void) {
10.     TRISB = 0b00000001;
11.     PORTB = 0;                       // Limpio el puerto B
12.  
13.     while (1){                         // Bucle infinito  
14.     if (PORTBbits.RB0 == 1){    // Chequeo estado de RB0
15.         ejemplo();                    // Llamado a función "ejemplo"
16.     }
17.     }
18. }

[lmtreser]

1.6. Variables y tipos de datos

TIPOS DE DATOS. Siempre que arranquemos a estudiar un nuevo compilador lo primero que debemos analizar, a mi entender, son los tipos de datos disponibles. Ello nos permitirá tener control sobre el dimensionamiento de las variables determinando que tamaños y rangos de datos podremos almacenar en ellas.

Los puntos a tener en cuenta sobre los tipos de datos son los siguientes:

* Nombre del tipo y su correspondiente nombre estandarizado
* Existencia de tipos para almacenar números enteros y reales
* Tamaño en bits
* Tipo aritmético (si es con o sin signo)
* Comportamiento del tipo aritmético por defecto (si no especificamos si el tipo es con o sin signo ¿cual es el comportamiento?)
* Rango de valores que podremos almacenar

En XC8 tenemos los siguientes tipos para almacenar datos numéricos "enteros" (sin decimales), a saber:

En la tabla pueden ver que puse el nombre estandarizado de cada tipo. Ya que es más fácil de visualizar un int16 que un signed int o int32 que signed long (ya veremos como utilizar los nombres estandarizados en nuestro código).

Hay que tener en cuenta que los tipos de datos: bit y short long no son tipos estandar de C. Y el que tipo long long es C99 Standard. El tipo bit tiene ciertas limitaciones que ya veremos.

Tipos con signo o sin signo. Si el signo no se especifica junto al tipo de dato, el tipo de dato por defecto será signado con excepción del tipo char que por defecto es unsigned o sin signo. El tipo bit siempre se lo toma no signado.

Los rangos disponibles nos permitirán elegir eficientemente que tipo debemos utilizar al diseñar nuestro código. Por ejemplo para almacenar los días dentro de un mes (de 1 a 31) con un tipo char (int8) nos alcanzará. Pero si queremos almacenar los días consecutivos dentro de un año (de 1 a 365) ya no nos alcanzará debiendo utilizar un signed int (int16).

Para almacenar el kilometraje de un auto ya no nos alcanzará con un signed int (int16) y deberemos elegir un tipo mayor como ser signed short long (int24). Y si queremos almacenar los habitantes de un país nos quedamos cortos con un short long (int24) debiendo utilizar para ello un unsigned long long (int32) pudiendo almacenar hasta 4.294.967.295 habitantes.

En XC8 también contamos con tipos para almacenar datos numéricos "reales" o flotantes, a saber: 24-bit y 32-bit floating-point types. Por ahora sólo debemos saber que existen además float y double. Más adelante ampliaremos.

Gracias a Jukinch por el excelente aporte a este capítulo!

[lmtreser]

1.7. Usando una interrupción por Timer 0

El PIC16F648A cuenta con un temporizador programable que efectúa una interrupción al desbordar su cuenta. Esto es muy útil para gran cantidad de artilugios.

Para trabajar con el Timer 0 debemos hacer uso de algunos registros y bits de configuraciones. A saber:

Registro TMR0: almacena el valor del contador en tiempo real. Se puede alterar su contenido.
Registro INTCON: configuración de interrupciones. Los siguientes bits están asociados al Timer0:

- T0IF: bandera que se pone a "1" al producirse un desbordamiento del timer.
- T0IE: habilita la interrupción por desbordamiento del timer.
- GIE: habilita las interrupciones globalmente.

Registro OPTION: contiene varios bits de control asociados a nuestro timer:

- PS0, PS1 y PS2: bits de configuración del prescaler (divisor de pulsos).
 

- PSA: bit de asignación de prescaler, si está en "0" se asigna al TMR0.
- T0SE: bit de selección del tipo de flanco para el TMR0. No lo vamos a usar por ahora.
- T0CS: selecciona la entrada de reloj del TMR0, colocar a "0" para incrementar por ciclo de reloj interno.

El próximo paso será saber el tiempo que necesitamos para producir la interrupción por desborde del timer. Para hacer este calculo utilizamos la siguiente fórmula que relaciona las distintas variables:

Veamoslo en un ejemplo. Cada 65 ms desbordará el timer alterando el estado del pin RB0 donde colocamos un LED para hacerlo destellar.

Código: C

1. /*
2.  * File:   main.c
3.  * Author: lucas
4.  * Created on 1 de abril de 2013, 22:20
5.  * Microcontrolador: PIC16F648A
6.  *
7.  * Uso de interrupción por Timer 0
8.  */
9.  
10. #include <stdio.h>
11. #include <stdlib.h>
12. #include <xc.h> // Librería XC8
13.  
14. #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro
15. #define LED PORTBbits.RB0
16.  
17. // PIC16F648A Configuration Bit Settings
18. #pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on RA7/OSC1/CLKIN)
19. #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
20. #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
21. #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
22. #pragma config BOREN = ON       // Brown-out Detect Enable bit (BOD enabled)
23. #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB4/PGM pin has digital I/O function, HV on MCLR must be used for programming)
24. #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
25. #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
26.  
27. unsigned char cuenta = 0;   // Declaro una variable "cuenta"
28.  
29. // FUNCION DE INTERRUPCION
30. void interrupt ISR(void) {
31.     cuenta++;                   // Incremento variable
32.     INTCONbits.TMR0IF = 0;      // Limpiamos bandera de desborde
33. }
34.  
35. // FUNCION PRINCIPAL
36. void main () {
37.     TRISB = 0;                   // Puerto B como salidas
38.     PORTB = 0;
39.  
40.     // Configuración del timer & interrupcion
41.     TMR0 = 0;
42.     INTCONbits.TMR0IE = 1;
43.     INTCONbits.GIE = 1;
44.     OPTION_REGbits.PS0 = 1;
45.     OPTION_REGbits.PS1 = 1;
46.     OPTION_REGbits.PS2 = 1;
47.     OPTION_REGbits.PSA = 0;
48.     OPTION_REGbits.T0CS = 0;
49.  
50.     // Bucle infinito
51.     while (1){
52.         if (cuenta == 10){
53.             LED ^= 1;
54.             cuenta = 0;
55.         }
56.     }
57. }

[electroipod]

Me ha gustado tu tutorial amigo, ojala continues con el tuto, somos muchos los que queremos aprender a programar con el mplabx y el xc8, gracias y sigue asi.

[jeremylf]

Muy bueno, gracias!

[Rseliman]

Muy Bueno el curso ...una pregunta ?? al siguiente codigo lo quiero modificar de la siguiente manera

para un pic 12f683

y con variables led1



    /*
    * File:   main.c
    * Author: lucas
    * Created on 1 de abril de 2013, 22:20
    * Microcontrolador: PIC12f683
    *
    * ¡Hola Mundo! en C (o como hacer destellar un LED)
    */
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <xc.h> // Librería XC8
     
    #define _XTAL_FREQ 4000000 // Indicamos a que frecuencia de reloj esta funcionando el micro

    #define led1 GPIO,GP1 ;
     
    // PIC12f683 Configuration Bit Settings
    #pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSC oscillator: I/O function on RA6/OSC2/CLKOUT pin, I/O function on RA7/OSC1/CLKIN)
    #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
    #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
    #pragma config MCLRE = OFF      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital input, MCLR internally tied to VDD)
    #pragma config BOREN = ON       // Brown-out Detect Enable bit (BOD enabled)
    #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Data memory code protection off)
    #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)
     
    // FUNCION PRINCIPAL
    void main ()
    {
        TRISIO = 0b00000000; // Configuro puerto B como salidas
        while (1) // Bucle infinito
        {
            led1 = 0; // Apago pin RB0
            __delay_ms(500);
           
             led1 = 1; // Enciendo pin RB0
            __delay_ms(500);
        }
    }


esta rutina me da error en led1 .....No entiendo porque ....gracias y disculpen soy nuevo

[lmtreser]

Hola! Buenisimo que se vayan sumando y subiendo ejemplos para avanzar... En el código de Rseliman hay un ; en el define de LED1 que causa el problema. Saludos!

[Rseliman]

Hola! Buenisimo que se vayan sumando y subiendo ejemplos para avanzar... En el código de Rseliman hay un ; en el define de LED1 que causa el problema. Saludos!

MUCHISIMAS GRACIAS ....es muy cierto que cuando uno esta muy cansado no ve cosas que son obias ....lo mire y lo recontra mire ....y no me daba cuenta ....hasta llegue a pensar que andaba mal el c8 jajajajajaj

Seguire compartiendo mis experiencias asi este curso crece !!!!

Gracias IMtreser ....vamos por mas !!!!

Saludos a todos

[Rseliman]

Amigos sigo escribiendo codigo sencillo por ahora , pero creo servira para el cursillo ....

la subrutina no sirve para nada solamente escribe la eeprom , la lee , y blinkea un led


Saludos a todos y Gracias .....ojala esto se agrande

Código: [Seleccionar]

/*
 * File:   main.c
 * Author: Ramiro Seliman
 *
 * Created on 26 de abril de 2013, 18:07
 */
#include <xc.h>
#include <stdio.h>
#include <stdlib.h>
#include <htc.h>


//*************************** funciones grab y lee eeprom ***************************************

void write_eeprom(char address, char data)
{
EEADR = address;
EEDATA = data;
EECON1bits.WREN = 1; // habilito escritura
INTCONbits.GIE = 0; // desabilito las interrupciones
EECON2 = 0x55; // destrabo escritura
EECON2 = 0xAA;  //destrabo escritura
EECON1bits.WR = 1; // habilito escritura
INTCONbits.GIE = 1; // habilito la interrupcion
EECON1bits.WREN = 0; // desabilito escritura
  while (EECON1bits.WR); // espero hasta que WR se haga 0 por hard
}

char read_eeprom(char address)
{
    EEADR = address;
    EECON1bits.RD = 1 ;
    return EEDAT;
 
}
//****************************************************************************************************

#pragma config FOSC = INTOSCIO  // Oscillator Selection bits (INTOSCIO oscillator: I/O function on RA4/OSC2/CLKOUT pin, I/O function on RA5/OSC1/CLKIN)
#pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
#pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
#pragma config MCLRE = OFF      // MCLR Pin Function Select bit (MCLR pin function is digital input, MCLR internally tied to VDD)
#pragma config CP = OFF         // Code Protection bit (Program memory code protection is disabled)
#pragma config CPD = OFF        // Data Code Protection bit (Data memory code protection is disabled)
#pragma config BOREN = OFF      // Brown Out Detect (BOR disabled)
#pragma config IESO = OFF       // Internal External Switchover bit (Internal External Switchover mode is disabled)
#pragma config FCMEN = OFF       // Fail-Safe Clock Monitor Enabled bit (Fail-Safe Clock Monitor is enabled)



char tiempo, address, data ;  // defino variable tiempo para leer eeprom

#define _XTAL_FREQ 4000000      // Indicamos a que frecuencia de reloj esta funcionando el micro

#define ledverde GPIO,GP1
#define ledrojo GPIO,GP4
#define buzzer GPIO,GP0
#define microswitch GPIO,GP2
#define teclado GPIO,GP3
/***********************************************************************************************************/
/*                                   PROGRAMA PRINCIPAL                                                     */
/***********************************************************************************************************/

int main (void)
{


    CMCON0 = 7; // Disable comparators
          TRISIO = 0b00001100;  //  GP3 y GP4 entradas las demas salidas
          ANSEL = 0;  // No ADC

            write_eeprom(0,6); //leo la primer posicion memoria eeprom
            _delay(500);

          tiempo = read_eeprom(0); //la cargo en tiempo

          write_eeprom(2,tiempo); //cargo la 3r posicion de la eeprom con el valor de tiempo

         _delay(500); // espero
         
         write_eeprom(5,tiempo); //cargo la 6ta posicion de la eeprom con la variable tiempo
         _delay(500);

    while(1)     // bucle infiinito
    {
     ledverde = 0;                       // apago led verde en GP1
        _delay(1000);                  // espero 1 seg
     ledverde = 1;                    // prendo led verde en GP1
        _delay(1000);                  // espero 1 seg
       
    }

}

[Rseliman]

Buen dia Muchachos , el codigo Funciona y sigo aprendiendo , la pregunta es , donde coloco las subrutinas de eeprom si quisiera sacarlas del codigo main para no complicarlo , a lo mismo que las demas subrutinas que construya , por ejemplo subrutinas de audio ...pueden ir como librerias ??o tengo que ponerlas en header files o sources files

Gracias Amigos
Un Gran saludo a todos