Rutinas XC8, dudas

[Pinolillo16]

Que tal colegas, tengo una serie de dudas respecto a como generar una función o rutina en XC8. Uso regularmente ASM pero estoy haciendo algunos códigos para aprender XC8.

En ASM uso esto:

Código: ASM

1. CALL RUTINA1
2.  
3. RUTINA1
4.      Opcion1
5.      Instruccion 1
6.      Instruccion 2
7.      Return
8.      Opcion2
9.      Instruccion 3
10.       Instruccion 4
11.      Return

Asi suelo hacerlo en ASM. En una rutina puedo tener multiples opciones de retorno, en XC8 como se puede hacer?

Saludos

[remi04]

Código: C

1. uint8_t rutina (uint8_t opcion) {
2.    uint8_t valor = 0;
3.  
4.         if (opcion == 1){
5.         valor = 10;      //instruccion1;
6.         valor = 10 * opción; // Instruccion2;
7.         return valor;    // fin de función . Devuelve el valor de ‘valor’
8.         }
9.  
10.         if (opcion == 2){
11.         valor = 20;  // instruccion1;
12.         valor = 10 * opción;     // instrucción 2;
13.         return valor;  // fin de función, devuelve valor de ‘valor’
14.       }
15.      
16.     return 0;    // si no se cumple ninguna termina devolviendo cero.
17. }

Para llamar a la función desde main o desde otra funcion:

Código: C

1. rutina(10);     // ve a la función “rutina” con valor 10;
2.  
3. uint8_t variable = rutina(20);   // Crea una variable, va a la función rutina y asigna a esta variable el valor que devuelve la función rutina.
4.  
5. printf(“El valor es %u”,rutina(20)); // otra forma de llamar a la rutina y que devuelva el valor a printf para que lo saque por (stdout).

   Este es uno de los muchos planteamientos que se pueden hacer.

[KILLERJC]

Si tenes muchas mas "opciones" lo que podes hacer es lo mismo que haces con una tabla:

Código: C

1. uint8_t rutina (uint8_t opcion) {
2.    uint8_t valor = 0;
3.  
4.         switch(opcion){
5.         case 1:
6.                   valor = 10;      //instruccion1;
7.                   valor = 10 * opción; // Instruccion2;
8.                   break;
9.         case 2:
10.                   valor = 20;  // instruccion1;
11.                   valor = 10 * opción;     // instrucción 2;
12.                   break;
13.         default:
14.                   valor = 0; // Para cualquier valor de opcion que no este en los casos superiores
15.                   break;
16.        }
17.      
18.     return valor;
19. }

Por supuesto tiene sus limitaciones. Solo en opciones pueden existir numeros o un caracter (recorda que un caracter es un ASCII y tiene su valor hexadecimal)

Y estoy tomando las instrucciones dadas como relleno.

[Pinolillo16]

Muchas gracias por las respuestas, trate de implementarlo pero sigo con dudas ya que me tira un error, el código es:

Código: C

1. void Lee_Teclado4x4(uint8_t val)
2. {
3.     C1_SetLow();
4.     C2_SetHigh();
5.     C3_SetHigh();
6.     C4_SetHigh();
7.     if(F1_GetValue()==0)
8.     {
9.         key=7;
10.         return key;
11.     }
12.  
13. }

El error: main.c:45:9: error: void function 'Lee_Teclado4x4' should not return a value [-Wreturn-type]

Aca trato de leer un teclado matricial, y hago un puleo con los pines para regresar el pin presionado. El caso es que no logro comprender como implementar esta funcion de leer teclado ya que en ensamblador me queda mas claro como podeis implementar la lectura?

Saludos y muchas gracias por sus consejos

[Eduardo2]

Declaraste que la función no devuelve nada, por eso te da error  ( void Lee_teclado4x4(uint8_t val)  )

Debe ser:

Código: C

1. uint8_t  Lee_Teclado4x4(uint8_t val)
2.     {
3.         C1_SetLow();
4.         C2_SetHigh();
5.         C3_SetHigh();
6.         C4_SetHigh();
7.         if(F1_GetValue()==0)
8.         {
9.             key=7;
10.             return key;
11.         }
12.     return 0 ;
13.     }

[Pinolillo16]

Eduardo, Killer. Gracias por sus respuestas. Funciono....

El código:

Código: C

1. #include "mcc_generated_files/mcc.h"
2. #include <stdio.h>
3. #include <stdlib.h>
4.  
5.  
6. uint8_t Lee_Teclado4x4(uint8_t);
7.  
8.  
9. uint8_t key;
10.  
11.  
12. void main(void)
13. {
14.  
15.     SYSTEM_Initialize();
16.  
17.     //INTERRUPT_GlobalInterruptEnable();
18.     //INTERRUPT_GlobalInterruptDisable();
19.     //INTERRUPT_PeripheralInterruptEnable();
20.  
21.     //INTERRUPT_PeripheralInterruptDisable();
22.  
23.     C1_SetLow();
24.     C2_SetLow();
25.     C3_SetLow();
26.     C4_SetLow();
27.  
28.     while (1)
29.     {
30.      Lee_Teclado4x4(key);
31.      LATC=key;
32. //     __delay_ms(300);
33.     }
34. }
35.  
36. uint8_t  Lee_Teclado4x4(uint8_t val)
37.     {
38.         C1_SetLow();
39.         C2_SetHigh();
40.         C3_SetHigh();
41.         C4_SetHigh();
42.         __delay_ms(1);
43.         if(F1_GetValue()==0)
44.         {
45.             key=0X07;
46.             return key;
47.         }
48.         if(F2_GetValue()==0)
49.         {
50.             key=0X04;
51.             return key;
52.         }
53.         if(F3_GetValue()==0)
54.         {
55.             key=0X01;
56.             return key;
57.         }
58.         if(F4_GetValue()==0)
59.         {
60.             key=0X0A;
61.             return key;
62.         }
63.         C1_SetHigh();
64.         C2_SetLow();
65.         C3_SetHigh();
66.         C4_SetHigh();
67.         __delay_ms(1);
68.         if(F1_GetValue()==0)
69.         {
70.             key=0X08;
71.             return key;
72.         }
73.         if(F2_GetValue()==0)
74.         {
75.             key=0X05;
76.             return key;
77.         }
78.         if(F3_GetValue()==0)
79.         {
80.             key=0X02;
81.             return key;
82.         }
83.         if(F4_GetValue()==0)
84.         {
85.             key=0X00;
86.             return key;
87.         }
88.         C1_SetHigh();
89.         C2_SetHigh();
90.         C3_SetLow();
91.         C4_SetHigh();
92.         __delay_ms(1);
93.         if(F1_GetValue()==0)
94.         {
95.             key=0X09;
96.             return key;
97.         }
98.         if(F2_GetValue()==0)
99.         {
100.             key=0X06;
101.             return key;
102.         }
103.         if(F3_GetValue()==0)
104.         {
105.             key=0X03;
106.             return key;
107.         }
108.         if(F4_GetValue()==0)
109.         {
110.             key=0X0B;
111.             return key;
112.         }
113.         C1_SetHigh();
114.         C2_SetHigh();
115.         C3_SetHigh();
116.         C4_SetLow();
117.         __delay_ms(1);
118.         if(F1_GetValue()==0)
119.         {
120.             key=0X0C;
121.             return key;
122.         }
123.         if(F2_GetValue()==0)
124.         {
125.             key=0X0D;
126.             return key;
127.         }
128.         if(F3_GetValue()==0)
129.         {
130.             key=0X0E;
131.             return key;
132.         }
133.         if(F4_GetValue()==0)
134.         {
135.             key=0X0F;
136.             return key;
137.         }
138.  
139.     return 0xFF ;
140.     }

Me queda claro el funcionamiento. Ahora la pregunta seria, las funciones no necesariamente tienen que ser void???

No conocia esto, gracias por su asesoramiento.

Saludos desde Mexico

[remi04]

Las funciones se componen de un tipo, un nombre y un campo de argumentos.

  El tipo puede ser void, o un tipo cualquiera idéntico a las variables.

  Que una función sea de tipo void significa que esa función hará lo que sea pero no va a devolver ningún valor “salvo por referencia” que sería otro tema.

  Si es de tipo entero, float, booleana , etc significa que la función puede devolver un valor de ese tipo que puede ser asignado a una variable desde donde se llame. 

 Los argumentos son “variables” que se crean de forma privada dentro de la función para que puedas pasarle valores para operar.

  Ejemplo función que hace algo pero no devuelve nada.

 

Código: C

1. void sumar(uint8_t numero1,uint8_t numero2) {
2. resultado = numero1 + numero2;
3. }   // no hace falta poner return.
4.  
5.  void main() {
6. uint8_t resultado =  sumar(4,6);
7. Printf(“El resultado es: %u”,resultado);
8. while(1) ;
9. }

Mismo caso pero con una función que devuelve el valor:

Código: C

1. uint8_t sumar(uint8_t numero1,uint8_t numero2) {
2. return numero1 + numero2;
3. }    
4.  
5.  void main() {
6.  
7. Printf(“El resultado es: %u”,suma(4,6));
8. while(1) ;
9. }