TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Pinolillo16 en 26 de Abril de 2020, 03:15:01

Título: Rutinas XC8, dudas
Publicado por: Pinolillo16 en 26 de Abril de 2020, 03:15:01
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
Título: Re:Rutinas XC8, dudas
Publicado por: remi04 en 26 de Abril de 2020, 05:42:03
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.
Título: Re:Rutinas XC8, dudas
Publicado por: KILLERJC en 26 de Abril de 2020, 09:25:59
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.
Título: Re:Rutinas XC8, dudas
Publicado por: Pinolillo16 en 26 de Abril de 2020, 17:19:23
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





Título: Re:Rutinas XC8, dudas
Publicado por: Eduardo2 en 26 de Abril de 2020, 17:48:40
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.     }
Título: Re:Rutinas XC8, dudas
Publicado por: Pinolillo16 en 28 de Abril de 2020, 03:49:58
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
Título: Re:Rutinas XC8, dudas
Publicado por: remi04 en 28 de Abril de 2020, 06:21:42
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. }