Cursillo en C18 para PICS DESDE CERO

[micro_cadaver]

Estructura de Control SWITCH CASE
Recuerdan que con el IF ELSE IF se puede seleccionar hasta mas de dos decisiones o alternativas?, que tal si tuvieramos multiples alternativas, el codigo se haria engorroso y el compilador la pasaria mal también, para estos casos existe la estructura SWITCH la cual permite de manera ordenada y práctica la elaboración de múltiples alternativas frente a una variable.

La variable es contrastada con cada constante de los CASEs, cuando se ubica una coincidencia, el bloque de sentencias definido dentro de dicho case es ejecutado hasta que se encuentra al break y termina la busqueda de coincidencias y también la estructura misma. Si no se encontrara ninguna opcion que satisfaga la variable se seleccionará por defecto la opcion DEFAULT, cuya presencia en un SWITCH CASE es opcional.

switch (variable)
{
        case constante1:
               sentencia1;
               break;
        case constante2:
               sentencia2;
               break;
        case constante3:
               sentencia3;
               break;
        case constante4:
               sentencia4;
               break;
           .
           .
           .

        default:
               sentenciaX;
}

pueden ir dentro de cada CASE mas de una sentencia; segun el ANSI standard dice que el C soporta hasta 257 CASEs, eso es bastante 

APLICACION DEL SWITCH CASE
OSC XT: 4MHz

Código: C#

1. //micro_cadaver
2. //hlaredo@gmail.com
3. #include <p18f2525.h>
4. #include <stdio.h>
5. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
6. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
7. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
8. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
9. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
10. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
11. #pragma config CPB = ON,CPD = ON//CONFIG5H
12. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
13. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
14. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
15. #pragma config EBTRB = ON//CONFIG7H
16.  
17. unsigned int a,b;
18.  
19. void main(void){
20.         //inicializar puertoA
21.         //todos los pines
22.         //seran digitales
23.         PORTA = 0X00;
24.         LATA = 0X00;
25.         ADCON0 = 0X00;
26.         ADCON1 = 0X0F;
27.         CMCON = 0X07;
28.         //*******************
29.         TRISA = 0XFF;
30.         TRISB = 0X00;
31.         TRISC = 0X00;
32.         LATB = 0X00;
33.         LATC = 0X00;
34. //*******************************************************
35. //*******************************************************
36.         while(1)
37.         {
38.                 switch (PORTA)
39.                 {
40.                         case 0:
41.                         LATB=0X00;
42.                         break;
43.                         case 2:
44.                         LATB=0X02;
45.                         break;
46.                         case 4:
47.                         LATB=0X04;
48.                         break;
49.                         case 6:
50.                         LATB=0X06;
51.                         break;
52.                         case 8:
53.                         LATB=0X08;
54.                         break;
55.                         case 10:
56.                         LATB=0X0A;
57.                         break;
58.                         case 12:
59.                         LATB=0X0C;
60.                         break;
61.                         default:
62.                         LATB=0XFF;
63.                 }
64.         }
65. //*******************************************************
66. //*******************************************************
67. }

todos los archivos:h**p://www.box.net/shared/f8cr8n7n03

[micro_cadaver]

ESTRUCTURA DE CONTROL FOR

Es un bucle que el lenguaje C nos proporciona para obtener repeticiones de bloques de codigo de manera clara y precisa. su sintaxis es la siguiente:

for ( inicializacion;condicional;incremento)
{
    sentencia1;
    sentencia2;
    sentencia3;
    .
    .
    .
}

La inicializacion es usada para dar un valor inicial al contador (que es una variable ya declarada) del bucle for; el condicional es evaluado antes de ejecutar el codigo dentro del bucle y su valor al ser evaluado puede ser TRUE o FALSE, si es TRUE entonces el codigo dentro del bucle for es ejecutado, sin embargo si es FALSE se termina con el bucle for; el incremento es el que se encarga de incrementar la variable contador dentro del bucle for.

Ejem:
   for(a=0;a<=30;a++)
   {
      LATB++;
      LATC--;
      Nop();
   }


ESTRUCTURA DE CONTROL WHILE
Otro bucle del C. Mientras la expresión sea TRUE se repetira una porción de codigo que esté dentro del bucle while, cuando la espresión evaluada sea FALSE se terminara el bubcle while. Siempre sera evaluada la expresió nantes de seguir ejecutando la porción de código.

while  (expresion)
{
         sentencia1;
         sentencia2;
         sentencia3;
         .
         .
         .
}

Ejm:
   while(PORTA==0X00)
   {
      a++;
      b--;
   }


ESTRUCTURA DE CONTROL DO WHILE
En este caso se combinan el DO con el WHILE, realizando un bucle en el cual se ejecuta primero las sentencias o codigo y luego se evalua la expresión o condicional, de la misma forma que el while y el for, si la expresión evaluada resulta TRUE se continúa con el bucle, de lo contrario, si resulta FALSE se termina con el bucle.

do
{
         sentencia1;
         sentencia2;
         sentencia3;
         .
         .
         .
}
while  (expresion);

Ejm:
   do
   {
      LATC=0XAA;
      LATB=0X55;   
   }
   while(PORTA==0X00);

CODIGO DE APLICACION

Código: C#

1. //micro_cadaver
2. //hlaredo@gmail.com
3. #include <p18f2525.h>
4. #include <stdio.h>
5. #include <delays.h>
6. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
7. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
8. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
9. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
10. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
11. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
12. #pragma config CPB = ON,CPD = ON//CONFIG5H
13. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
14. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
15. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
16. #pragma config EBTRB = ON//CONFIG7H
17.  
18. unsigned int a,b;
19.  
20. void main(void){
21.         //inicializar puertoA
22.         //todos los pines
23.         //seran digitales
24.         PORTA = 0X00;
25.         LATA = 0X00;
26.         ADCON0 = 0X00;
27.         ADCON1 = 0X0F;
28.         CMCON = 0X07;
29.         //*******************
30.         TRISA = 0XFF;
31.         TRISB = 0X00;
32.         TRISC = 0X00;
33.         LATB = 0X00;
34.         LATC = 0X00;
35. //*******************************************************
36. //*******************************************************
37.         for(a=0;a<=30;a++)
38.         {
39.                 LATB++;
40.                 LATC--;
41.                 Delay1KTCYx(100);
42.         }
43.         //*****************
44.         for(b=60;b>=40;b--)
45.         {
46.                 LATB=~LATB;
47.                 Nop();
48.                 Delay1KTCYx(200);
49.         }
50.         //*****************
51.         while(PORTA!=0X05);
52.         //*****************
53.         while(PORTA!=0X00)
54.         {
55.                 a++;
56.                 b--;
57.         }
58.         //*****************
59.         do
60.         {
61.                 LATC=0XAA;
62.                 LATB=0X55;     
63.         }
64.         while(PORTA==0X00);
65.         //*****************
66.         LATB=0;
67.         LATC=0;
68.         while(1);
69. //*******************************************************
70. //*******************************************************
71. }

todos los archivos:h**p://www.box.net/shared/70r3lbe0fy

Código: C#

1. bonus:  :-/
2. bucle infinito con while:
3. while(1);
4.  
5. bucle infinito con for:
6. for(;;);

[micro_cadaver]

BIFURCACIONES DE CONTROL BREAK
Esta instrucción nos permite salir de cualquier bucle ya sea WHILE , DO WHILE, FOR. Cuando el programa encuentra a esat instrucción simplemente salta a la siguiente instruccion fuera del bucle donde se hallaba contenido.

Ejm:
   for(a=0;a<=200;a++)
   {
      Delay1KTCYx(200);
      if (PORTA==0X05)
         break;
      LATB=~LATB;
   }

En esta situación, tenemos un bucle FOR que contara hasta 200 con la variable " a " para satisfacer la expresión del bucle, sin embargo existe un break el cual depende de la estructura condicional IF que inidica si PORTA is igual a 5 entonces ejecuta break, de lo contrario finaliza el IF y continua con el bucle. Cuando PORTA sea igual a 5 el programa se topara con el BREAK y como consecuencia terminara con el bucle FOR y continuará con la siguiente instrucción fuera del bucle.


BIFURCACIONES DE CONTROL CONTINUE
Digamos que dentro de nuestro bucle existe una instrucción al final del bloque de codigo que queremos saltarla o no ejecutarla dependiendo de alguna condición extra, la instruccion CONTINUE permite saltar todas las instrucciones posteriores a su aparición dentro del bloque de codigo escrito en el bucle.

Ejm:
   for(b=0;b<=200;b++)
   {
      Delay1KTCYx(200);
      if (PORTA==0X0A)
         continue;
      LATC=~LATC;
   }

En este caso, el bucle FOR contara hasta 200 con la variable " b " y ejecutará la ultima instruccion LATC=~LATC dependiendo del estado del PORTA, siempre y cuando sea igual a 0X0A, de esta manera se utiliza el CONTINUE.

EJEMPLO PARA EL PIC18

Código: C#

1. //micro_cadaver
2. //hlaredo@gmail.com
3. #include <p18f2525.h>
4. #include <stdio.h>
5. #include <delays.h>
6. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
7. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
8. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
9. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
10. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
11. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
12. #pragma config CPB = ON,CPD = ON//CONFIG5H
13. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
14. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
15. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
16. #pragma config EBTRB = ON//CONFIG7H
17.  
18. unsigned int a,b;
19.  
20. void main(void){
21.         //inicializar puertoA
22.         //todos los pines
23.         //seran digitales
24.         PORTA = 0X00;
25.         LATA = 0X00;
26.         ADCON0 = 0X00;
27.         ADCON1 = 0X0F;
28.         CMCON = 0X07;
29.         //*******************
30.         TRISA = 0XFF;
31.         TRISB = 0X00;
32.         TRISC = 0X00;
33.         LATB = 0X00;
34.         LATC = 0X00;
35. //*******************************************************
36. //*******************************************************
37.         for(a=0;a<=200;a++)
38.         {
39.                 Delay1KTCYx(200);
40.                 if (PORTA==0X05)
41.                         break;
42.                 LATB=~LATB;
43.         }
44. //*******************************************************
45. //*******************************************************
46.         for(b=0;b<=200;b++)
47.         {
48.                 Delay1KTCYx(200);
49.                 if (PORTA==0X0A)
50.                         continue;
51.                 LATC=~LATC;
52.         }
53. //*******************************************************
54. //*******************************************************
55.         for(;;);
56. }

todos los archivos:h**p://www.box.net/shared/6pxn2zqir8

[micro_cadaver]

bueno bueno bueno, a ver m.... que se cocina por aca....  antes de pasar a las interrupciones en C18 vamos a darle una repasada a los FUNCTIONS y a los tipos de VARIABLES pues las interrupciones en el C18 tienen una sintaxis similar a la de los functions y se declaran como volatiles que es un tipo de variable.

[Kedutpic]

  hola henry , te felicito por tu trabajo esta muy bueno, por mi parte ya pude probar algunos de tus programas con el pic18F2550,me funcionaron sin ningun error,  claro que la palabra de configuracion es diferente, por lo que solo le hice una leve modificacion al encabezado de todos tus programas, sigue asi amigo del planeta VULCANO , desde aqui el planeta TIERRA , cambio y fuera ,      .

[barg]

Hola a todos.

Excelente trabajo del amigo micro_cadaver para los que estamos empezando en este mundo del C18.Yo tengo algunos problemas y no soy capaz de compilar bien ningun ejemplo.Creo que es porque no añado las librerias oportunas o algo asi.

Antes de seguir con tus explicaciones, ¿podrias dar unas nociones para que se compile bien un ejemplo de los que has expuesto aqui?Te lo agradeceria mucho porque no consigo avanzar.Los errores que me ponen son:

Error [1027] unable to locate 'p18cxxx.h'
Error [1099] "osc not defined"

Gracias

[micro_cadaver]

  ups !
bueno no hay problema pero... me parece que ya alguien habia hablado del tema de configurar el C18 dentro del MPLAB ademas en los pdfs que te vienen con el c18 (en la capreta docs) revisa el gettind started . pdf ahi especifican bastante sobre el asunto, si encuentro el hilo lo coloco para simplificar ese problemilla  y gracias me gustaria hacerlo mejor pero el tiempo me tiene cogido de los huev....s 

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

[micro_cadaver]

Antes de continuar con las Funciones para el C18 hagamos un repaso a las variables en el compilador C18.

VARIABLES:
Es la forma en que se almacenan datos en el compilador C18.

TIPOS DE DATOS:
La siguiente tabla nos muestra los tipos de datos existentes en el compilador C18.

       Tipo                Tamaño      Mínimo                   Máximo           
char                          8bits          -80                        +7F               
unsigned char            8bits           00                          FF                 
int                            16bits       -8000                     +7FFF               
unsigned int              16bits        0000                       FFFF                       
short long                 24bits      -800000                 +7FFFFF             
unsigned short long   24bits       000000                   FFFFFF               
long                         32bits    -80000000              +7FFFFFFF             
unsigned long           32bits     00000000                FFFFFFFF             
float                         32bits     2^(-126)      2^(+128) * (2 - 2^(-15))

Para mayor información consultar el documento: MPLAB C18 compiler user's guide , capitulo 2. 

DECLARACIONES:
El formato de declaración de una variable es la siguiente:
tipo_de_variable    nombre_de_la_variable;
Ejm:
int    micro_cadaver;

Las variables que son declaradas dentro de una función se llaman Variables Locales; y las que son declaradas fuera de todas las funciones se llaman Variables Globales.

Las Variables Locales solo pueden ser utilizadas dentro de la función donde fueron declaradas. Se permite que en diferentes funciones existan variables que tengan el mismo nombre.

Ejm:

Código: C#

1. #include <p18f2525.h>
2. #include <stdio.h>
3. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
4. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
5. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
6. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
7. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
8. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
9. #pragma config CPB = ON,CPD = ON//CONFIG5H
10. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
11. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
12. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
13. #pragma config EBTRB = ON//CONFIG7H
14.  
15. void funcion1(void){
16.         char todopic;//variable local
17.         unsigned char megapic;//variable local
18.         todopic ++;
19.         megapic --;
20. }
21. //*******************
22. void funcion2(void){
23.         int todopic;//variable local
24.         unsigned int megapic;//variable local
25.         todopic --;
26.         megapic --;
27. }
28. //*******************
29. void funcion3(void){
30.         float a,b,c;//variable local
31.         a=-0.17;
32.         b=5.355;
33.         c=0.93;
34. }
35. //*******************
36. void funcion4(void){
37.         short long kedutpic;//variable local
38.         unsigned short long manuelroin;//variable local
39.         kedutpic = 0x0F;
40.         manuelroin = 0x08;
41. }
42. //********************************************
43. //********************************************
44. //
45. //      funcion principal
46. //
47. //********************************************
48. //********************************************
49. void main(void){
50.         unsigned long macro_cadaver;//variable local
51.         long micro_cadaver;//variable local
52.         TRISA = 0X00;
53.         TRISB = 0X00;
54.         TRISC = 0X00;
55.  
56.         macro_cadaver = 0XFFFFFFFF;
57.  
58.         micro_cadaver = +26556;
59.         micro_cadaver = -26556;
60.  
61.         funcion1();
62.         funcion2();
63.         funcion3();
64.         funcion4();
65.         while (1);
66. //*******************************************************
67. //*******************************************************
68. }

Por otro lado, las variables globales pueden ser usadas en distintas funciones.

Código: C#

1. #include <p18f2525.h>
2. #include <stdio.h>
3. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
4. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
5. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
6. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
7. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
8. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
9. #pragma config CPB = ON,CPD = ON//CONFIG5H
10. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
11. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
12. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
13. #pragma config EBTRB = ON//CONFIG7H
14.  
15. char todopic='A';//variable global
16. unsigned char megapic='h';//variable global
17. float a,b,c;//variable global
18. short long kedutpic;//variable global
19. unsigned short long manuelroin=0;//variable global
20. unsigned long macro_cadaver=15;//variable global
21. long micro_cadaver;//variable global
22.  
23. void funcion1(void){
24.         todopic ++;
25.         c=0.93;
26.         megapic --;
27. }
28. //*******************
29. void funcion2(void){
30.         todopic --;
31.         c=0.93;
32.         megapic --;
33. }
34. //*******************
35. void funcion3(void){
36.         a=-0.17;
37.         c=0.93;
38.         kedutpic = 0x0F;
39. }
40. //*******************
41. void funcion4(void){
42.         a=-0.17;
43.         b=5.355;
44.         kedutpic = 0x0F;
45.         manuelroin = 0x08;
46. }
47. //********************************************
48. //********************************************
49. //
50. //      funcion principal
51. //
52. //********************************************
53. //********************************************
54. void main(void){
55.         TRISA = 0X00;
56.         TRISB = 0X00;
57.         TRISC = 0X00;
58.  
59.         macro_cadaver = 0XFFFFFFFF;
60.  
61.         micro_cadaver = +26556;
62.  
63.         kedutpic = 0x0F;
64.         a=-0.17;
65.  
66.         funcion1();
67.         funcion2();
68.         funcion3();
69.         funcion4();
70.         while (1);
71. //*******************************************************
72. //*******************************************************
73. }

[micro_cadaver]

FUNCIONES
Son un conjunto de sentencias que realizan una determinada tarea, pueden tomar valores de entrada y proporcionar un valor de retorno. Una función que siempre estará presente en un programa es la función " main ". Se puede hacer una analogía con las rutinas en el assembler.

COMO DECLARAR UNA FUNCIÓN?
Una función debe ser declarada y definida antes de ser invocada, así como sucede con las variables.

Una manera de declarar las funciones es presentándola antes de la función principal main:

Código: C#

1. #include <p18f2525.h>
2. #include <stdio.h>
3. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
4. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
5. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
6. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
7. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
8. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
9. #pragma config CPB = ON,CPD = ON//CONFIG5H
10. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
11. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
12. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
13. #pragma config EBTRB = ON//CONFIG7H
14.  
15. unsigned int a,b,c;//variables globales
16.  
17. void funcion1(void){
18.         a=234;
19.         b--;
20.         c>>=2;
21. }
22. //*******************
23. void funcion2(void){
24.         a=68;
25.         b++;
26.         c<<=5;
27. }
28.  
29. //********************************************
30. //********************************************
31. //
32. //      funcion principal
33. //
34. //********************************************
35. //********************************************
36. void main(void){
37.         TRISA = 0X00;
38.         TRISB = 0X00;
39.         TRISC = 0X00;
40.                
41.         a=15;
42.         b++;
43.         c=~c;
44.  
45.         funcion1();//se invoca a la funcion
46.         funcion2();//se invoca a la funcion
47.  
48.         while (1);
49. //*******************************************************
50. //*******************************************************
51. }

La otra forma es utilizando los prototipos:

Código: C#

1. #include <p18f2525.h>
2. #include <stdio.h>
3. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
4. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
5. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
6. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
7. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
8. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
9. #pragma config CPB = ON,CPD = ON//CONFIG5H
10. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
11. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
12. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
13. #pragma config EBTRB = ON//CONFIG7H
14.  
15. unsigned int a,b,c;//variables globales
16.  
17. void funcion1(void);//prototipo
18. void funcion2(void);//prototipo
19.  
20. //********************************************
21. //********************************************
22. //
23. //      funcion principal
24. //
25. //********************************************
26. //********************************************
27. void main(void){
28.         TRISA = 0X00;
29.         TRISB = 0X00;
30.         TRISC = 0X00;
31.                
32.         a=15;
33.         b++;
34.         c=~c;
35.  
36.         funcion1();//se invoca a la funcion
37.         funcion2();//se invoca a la funcion
38.  
39.         while (1);
40. //*******************************************************
41. //*******************************************************
42. }
43. void funcion1(void){
44.         a=234;
45.         b--;
46.         c>>=2;
47. }
48. //*******************
49. void funcion2(void){
50.         a=68;
51.         b++;
52.         c<<=5;
53. }

su importancia no es aparente en programas pequeños, sin embargo su utilidad se hace necesaria en la depuración de errores en programas grandes con mas de 1000 sentencias.

CÓMO Y PARA QUÉ DEFINIMOS UNA FUNCIÓN?
La definición de una función sirve para informarle al compilador sobre las instrucciones con las que va a trabajar la función declarada. Además la defnición es la que contiene el cuerpo o bloque de sentencias de la función. El formato general para la definición de funciones es la siguiente:

Tipo_de_retorno  Nombre_de_función (tipo_entrada1,tipo_entrada2,tipo_entrada3,...);

Donde: " Tipo_de_retorno " es el tipo de valor que la función puede devolver.
            " Nombre_de_función " es el nombre de la función declarada.
            " tipo_entradaX " es el tipo de valor que ingresa a la función y se declara como una variable.

En el ejemplo siguiente se va a mostrar los tipos de funciones más comunes que podemos elaborar dentro del C18:

Código: C#

1. #include <p18f2525.h>
2. #include <stdio.h>
3. #pragma config OSC = XT,FCMEN = OFF,IESO = OFF //CONFIG1H
4. #pragma config PWRT = ON,BOREN = OFF,BORV = 0 //CONFIG2L
5. #pragma config WDT = OFF,WDTPS = 32768 //CONFIG2H
6. #pragma config MCLRE = ON,LPT1OSC = OFF,PBADEN = OFF,CCP2MX = PORTC//CONFIG3H
7. #pragma config STVREN = OFF,LVP = OFF,XINST = OFF,DEBUG = OFF//CONFIG4L
8. #pragma config CP0 = ON,CP1 = ON,CP2 = ON//CONFIG5L
9. #pragma config CPB = ON,CPD = ON//CONFIG5H
10. #pragma config WRT0 = ON,WRT1 = ON,WRT2 = ON//CONFIG6L
11. #pragma config WRTB = ON,WRTC = ON,WRTD = ON//CONFIG6H
12. #pragma config EBTR0 = ON,EBTR1 = ON,EBTR2 = ON//CONFIG7L
13. #pragma config EBTRB = ON//CONFIG7H
14.  
15. int a,c,z;//variables globales
16. long b,temp;//variables globales
17.  
18. //Esta funcion va a retornar un valor tipo " int "
19. //y tiene como valores de entrada 2 variables tipo "int".
20. int funcion1(int x,int y)
21. {
22.         PORTA = 0x05;
23.         PORTB = 0x08;
24.         return x+y;//retorna valor tipo "int"
25. }
26. //Esta funcion va a retornar un valor tipo " long "
27. //y tiene como valor de entrada una variables tipo "int".
28. long funcion2(int x)
29. {
30.         temp=x;
31.         temp<<=3;
32.         temp*=10;
33.         return temp;//retorna valor tipo "long"
34. }
35.  
36. //Esta funcion va a retornar un valor tipo "int"
37. //y no tiene valor de entrada.
38. int funcion3(void)
39. {
40.         if(PORTC == 0X88)
41.                 return 1;
42.         z++;
43.         return z;
44. }
45.  
46. //Esta funcion no tiene valor a retornar
47. //ni tiene valor de entrada.
48. void funcion4(void)
49. {
50.         z--;
51.         temp = 0x12167;
52. }
53.  
54. //********************************************
55. //********************************************
56. //
57. //      funcion principal
58. //
59. //********************************************
60. //********************************************
61. void main(void){
62.         TRISA = 0X00;
63.         TRISB = 0X00;
64.         TRISC = 0XFF;
65.        
66.         //funcion1 se carga con valores tipo "int"
67.         //y espera retorno de variable tipo "int"
68.         a = funcion1(10,20);
69.  
70.         //funcion2 se carga con un valor tipo "int"
71.         //y espera retorno de variable tipo "long"
72.         b = funcion2(30);
73.  
74.         //funcion3 no tiene valor de carga
75.         //y espera retorno de variable tipo "int"
76.         c = funcion3();
77.  
78.         //funcion4 no tiene valor de carga
79.         //ni espera retorno
80.         funcion4();
81.  
82.         while (1);
83. //*******************************************************
84. //*******************************************************
85. }

[Kedutpic]

  hola henry tengo 1 dudas con respecto a tus programas :

Que pasaria si yo tuviera un dato < de 16 bits y lo defino como un short long  que es de  24bits segun lo que has escrito ,  tendra algun efecto en la memoria del PIC  , al momento de compilarlo y grabarlo ??.

   
void funcion4(void){
a=-0.17;
b=5.355;
kedutpic = 0x0F;
manuelroin = 0x08;

  Otra cosa , me gustan el nombre de tus variables son originales jajajjaja 

[micro_cadaver]

habla tio  , no pasaria nada, el compilador simplemente llenaria con ceros el resto de bits, es mas si el dato fuera > de 24 bits y lo defines como un short long, el compilador solo ingresa los 24bits que corresponden a la definicion de la variable y perderías el resto de bits, tampoco te aparece ningun error en el compilado.

PD: ya se vienen las interrupciones!!! 

[barg]

Muchas gracias por tu ayuda micro_cadaver.Lo he mirado y tenia mal configuradas las opciones del compilado.Ahora creo que ya me va bien y empezare a probar todos tus programas y a seguir aprendiendo.Espero con entusiasmo la nueva entraga de interrupciones 

[micro_cadaver]

ah que bien tio!!! jjejej  yo tambien sufri al inicio para hacerlo arrancar me lei como 10 veces el datasheet del C18 el user's guide son varios detalles no? cada vez que creo un proyecto tengo que poner el linker, adjuntar el codigo fuente, luego tengo que ir a projects y rutear unas carpetas H y LIB que se me borran no se porque cada vez que hago un proyecto nuevo  jeje pero ya me acostumbre 

[maunix]

ah que bien tio!!! jjejej  yo tambien sufri al inicio para hacerlo arrancar me lei como 10 veces el datasheet del C18 el user's guide son varios detalles no? cada vez que creo un proyecto tengo que poner el linker, adjuntar el codigo fuente, luego tengo que ir a projects y rutear unas carpetas H y LIB que se me borran no se porque cada vez que hago un proyecto nuevo  jeje pero ya me acostumbre 

Jeje, yo hacía eso hasta que me acostumbré a usar templates. 

Templates hechos por mi, por supuesto, no hay tal cosa en C18. 

Es decir un proyecto con código base , con todo lo necesario, linker file, archivos .h, archivos .c, paths.  Lo copio y lo pego en mi nueva ubicación y voilá!!

[micro_cadaver]

hola maunix, seria algo asi:
#include <c:\archivosdeprograma\microchip\c18\h>