[SOLUCIONADO]¿Se le puede pasar un pin del micro a un función?

[Thulsa Doom]

Hola a todos de nuevo, estoy creando una librería para detectar el estado de un pin, sé que se le pueden pasar datos a una función pero no sé si se le podrá pasar que pin voy a usar.
A suponer yo defino un pin del pic de esta manera.

 

Código: [Seleccionar]

#define PIN_RB0  PORTBbits.RB0
¿se le puede pasar ese pin a mi función de esta manera.

 

Código: [Seleccionar]

void mi funcion ( PIN_RB0);
es para poder usar mi función con diferentes pines, ¿o como sería la manera?

Gracias

[KILLERJC]

Que yo sepa asi de simple no. Si tenes mas argumentos podes pasar una mascara, y la direccion del PORT por ejemplo.

void funcion( volatile unsigned char * port, unsigned char mask);


Y lo llamas por ejemplo:
funcion(&PORTB,(1<<0));  //RB0

Es distinto que CCS y otros mas en donde cada pin tiene su "numero" entonces podes pasar el numero este.
De todas formas no se cual es tu objetivo de esto, pero seguramente hay otra forma de hacerlo, y se me ocurren macros como una de las formas.

[Thulsa Doom]

La idea es que me he hecho un driver para manejar un encoder rotatorio, y mi idea es usar varios encoders en un mismo micro y a la hora de manejar el driver es pasarle los pines a usar y los valores a través de la función. así se haría de una forma automática y tan solo definir los pines de cada encoder en el archivo de configuración del micro, sería una forma más clara de ver el código

[KILLERJC]

El problema es "definir"... A esto tampoco lo tomes como que es así y debería serlo, te ofrezco otra forma de verlo. Cada uno programa de la forma que mas le apetece (siempre y cuando programe solo)

Tranquilamente podes tener una estructura que caracterice al encoder.. Y esto seria mas claro al verlo en el codigo.
Ej... tengo un archivo el cual posee algunas funciones y variables especificas del micro. Y tengo otro archivo con el driver del encoder. Voy a suponer nombre de funciones.

#include "port/misvariables.h"
#include "driver/encoder.h"


verificarEncoder(&encoder1);
verificarEncoder(&encoder2);
a = direccionEncoder(&encoder1);


siendo encoder1 una estructura

typedef struct myEncoder myEncoder_t
struct myEncoder
{
    unsigned char *  puerto;
    unsidned char    pin;
}

myEncoder_t encoder1 = {&PORTB,0};
myEncoder_t encoder2 = {&PORTB,3};
myEncoder_t encoder3 = {&PORTC,1};

Personalmente lo encararia de otra forma definiendolo en el comienzo y siendo abstracto (del manejo) al usuario en el main, que pertenezca esa definicion de struct al driver del encoder, y solo le des acceso a myEncoder_t sin que conozca que otras cosas posee la estructura. (tampoco incluirias el archivo con las variables)

Obviamente que la estructura puede tener muchas mas cosas...  Por ejemplo, suponete que a traves de las interrupciones vos sabes si aumento un paso o no, entonces en tu estructura podes tener otro valor que sean "pasos" (con signo asi tenes direccion tambien), de esa forma actualizas la estructura y todo lo contenido en la misma pertenece a ese encoder. En el main cuando te interese pedis si hubo algun cambio y el driver del encoder te devolveria los valores de la estructura.

Si poseo algun error en el codigo es porque todavia sigo dormido..

[Thulsa Doom]

Hola, yo siempre estoy dispuesto a aprender y el que yo programe de una manera no quiere decir que no quiera aprender el hacerlo de una manera más eficiente, lo que me dices me interesa mucho y creo que guarda alguna semejanza con C++ ya que no que me comentas tiene toda la pinta del uso del constructor y de las clases que se usa en C++, y que yo nunca he llegado a entender de una manera clara.

me perdí un poco en tu explicación, si tuvieras un ejemplo que funcionara en mi micro PIC16F4620 y si no cualquier ejemplo para intentar entenderlo.

La verdad que me parece una manera de programar más eficiente que la que uso yo

[electroipod]

Creo que tu buscas una función así como la que tiene mikroc para una función llamada button.
https://download.mikroe.com/documents/compilers/mikroc/pic/help/button_library.htm

[KILLERJC]

main.c

Código: C

1. #include <xc.h>
2. #include "driver.h"
3.  
4. myEncoder_t encoder1;
5. myEncoder_t encoder2;
6. myEncoder_t encoder3;
7.  
8.  
9. void main(void) {
10.  
11.     encoder1 = vIniciarEncoder(&PORTB,0);
12.     encoder2 = vIniciarEncoder(&PORTB,1);
13.     encoder3 = vIniciarEncoder(&PORTB,2);
14.    
15.     uAgregarPasos(encoder1,10);
16.     uAgregarPasos(encoder2,5);
17.     uAgregarPasos(encoder3,-50);
18.  
19.     int8_t test;
20.    
21.     test = iPasosEncoder(encoder1);
22.     test = iPasosEncoder(encoder2);
23.     test = iPasosEncoder(encoder3);
24.        
25.     while(1){
26.     }
27. }

driver.c

Código: C

1. #include "driverinternal.h"
2.  
3. static struct myEncoder aEncoderList[MAX_NUMBER_ENCODERS];
4. static uint8_t gTotalEncoders = 0;
5.  
6. myEncoder_t vIniciarEncoder(volatile unsigned char * pPort, uint8_t uPin)
7. {
8.     /* // Protecciones
9.     ASSERT(pPort);
10.     ASSERT(uPin);
11.     */
12.    
13.     // Se superaron la cantidad de Encoders establecidos
14.     if(gTotalEncoders >= MAX_NUMBER_ENCODERS )
15.         return 0;
16.    
17.     uint8_t indexActual = gTotalEncoders;
18.     gTotalEncoders++;
19.    
20.     aEncoderList[indexActual].puerto = pPort;
21.     aEncoderList[indexActual].mask = (uint8_t)(1 << uPin); //Cast para quitar lo molesto del warning del compilador
22.     aEncoderList[indexActual].pasos = 0;
23.  
24.     return &aEncoderList[indexActual];
25. }
26.  
27. int8_t iPasosEncoder(myEncoder_t pEncoder)
28. {
29.     // Proteccion
30.     //ASSERT(pEncoder);
31.  
32.    
33.     int8_t aux = pEncoder->pasos;
34.     // En caso de que al querer tomar los pasos y que se reinicie el contador
35.     // pEncoder->pasos = 0;
36.     return aux;
37. }
38.  
39. uint8_t uAgregarPasos(myEncoder_t pEncoder, int8_t iPasos)
40. {
41.     //Proteccion
42.     //ASSERT(pEncoder);
43.    
44.     //posiblemente llamado desde la interrupcion como te comentaba, proteger contra overflow
45.     pEncoder->pasos += iPasos;
46.     return 0;
47. }

driver.h

Código: C

1. #ifndef DRIVER_H
2. #define DRIVER_H
3.  
4. #include <stdint.h>
5.  
6. typedef struct myEncoder * myEncoder_t;
7. myEncoder_t vIniciarEncoder(volatile unsigned char * b , uint8_t c);
8. int8_t iPasosEncoder( myEncoder_t a);
9. uint8_t uAgregarPasos( myEncoder_t a , int8_t b);
10.  
11. #define  MAX_NUMBER_ENCODERS    (3)
12.  
13.  
14. #endif  /* DRIVER_H */

driverinternal.h

Código: C

1. #ifndef DRIVERINTERNAL_H
2. #define DRIVERINTERNAL_H
3.  
4.  
5. #include "driver.h"
6.  
7. struct myEncoder
8. {
9.     volatile uint8_t *  puerto;
10.     uint8_t             mask;
11.     int8_t              pasos;
12. };
13.  
14.  
15. #endif  /* DRIVERINTERNAL_H */

Desde el main, vos ves solo lo que te ofrece driver.h. Una mayor abstracción intentando hacer algo parecido a C++, Como ves tampoco el usuario no sabe que tiene el struct del encoder, simplemente lo usa. Esto lleva a que vos podes modificar las funciones, y siempre y cuando mantengas la misma interfaz (parámetros de entrada y salida) no vas a tener problema en agregar lo que quieras, si necesitas un campo mas en el struct o incrementar el tamaño de alguna de las variables, tampoco vas a tener problemas con tu código del main.

Como no hay manejo de memoria dinamico (malloc), de antemano necesitamos saber cuantos encoders van a existir para reservarle el lugar, por eso hay un #define especificando cuantos encoders máximo va a existir y tampoco se agrego un "destructor" aunque debería.

No agregue una funcion que lea el puerto, pero lo vas a poder hacer facilmente.

[Thulsa Doom]

Hola,siento el retraso en contestar pero he estado asimilando lo expuesto, esto está por encima de mis conocimientos, así que esto es una vuelta de tuerca más a lo que sé.
tengo unas dudas, a ver si me se explicar.

Entiendo lo de la estructura y por que se hace, por lo que veo o creo que veo en la estructura recogemos el puerto y el pin con el que vamos a trabajar, quedemos solo con esto por ahora, el manejo de los pines, omitamos el dato de pasos.

Se supone que con

Código: [Seleccionar]

encoder1 = vIniciarEncoder(&PORTB,0);
estamos pasando a la estructura encoder1 el dato del puerto y pin a trabajar por separado, ósea le decimos PORTB por el pin 0.

luego pasamos ese dato a las siguientes funciones ¿no?

Donde me estoy trabando ahora es en cómo puedo unir esos dos datos para que sea PORTBbits.RB0.

He pensado en algo así.

Código: [Seleccionar]

uint8_t puerto = Encoder_t->port |= Encoder_t->mask;pero no me funciona, tampoco sé si el registro PORTB se puede meter en una variable como he hecho, la verdad que se me escapa de mis conocimiento pero me gustaría aprender a manejar esto que lo veo muy útil.

Me podría limitar simplemente ha hacerlo de una manera mas simple como dentro de mi función del encoder a usar el puerto de esta manera.

Código: [Seleccionar]

#define PIN_RB0  PORTBbits.RB0
y poner dentro de mi función cuando leo el canal del encoder PIN_RB0 y ya pero tendría que crear una función por cada encoder y eso sería poco eficiente, tener que estar repitiendo código así que lo de crear un driver a un nivel mas abstracto eso me mola mucho.

El manejo del encoder lo hago con 3 pines, dos son canales A y B que son por donde hago el ciclo de lectura y el pin 3 es el switch que trae el encoder, (al final no hice la lectura por interrupciones si no normal por los puertos, tenía problemas con las interrupciones y ahora funciona genial),

con lo cual me hace falta especificar bien por que pines de que puertos voy a trabajar.

[KILLERJC]

estamos pasando a la estructura encoder1 el dato del puerto y pin a trabajar por separado, ósea le decimos PORTB por el pin 0.

encoder1 es simplemente un puntero. Al usar IniciarEncoder le estamos dando la direccion de una estructura, en esa estructura va a tener guardado lo que le pasamos (es decir la informacion PORTB y el pin 0 ). encoder2 va a apuntar a otra estructura con los mismos campos pero con valores distintos de puerto y pin.

Pero, las funciones van a ser generales sea el pin que tengan.

Donde me estoy trabando ahora es en cómo puedo unir esos dos datos para que sea PORTBbits.RB0.

Eso lo definis en:
encoder1 = vIniciarEncoder(&PORTB,0);

En ves de usar un #define, lo haces ahí... si queres cambiarlo solo tenes que modificar ese único lugar. Así como también lo harías con un #define, si quisiera modificar el pin deberías hacer algo así:

Código: C

1. void vActivarSalida(myEncoder_t pEncoder)
2. {
3.     *pEncoder->puerto |= pEncoder->mask;
4. }
5.  
6. void vToggleSalida(myEncoder_t pEncoder)
7. {
8.     *pEncoder->puerto ^= pEncoder->mask;
9. }
10.  
11. void vApagarSalida(myEncoder_t pEncoder)
12. {
13.     *pEncoder->puerto &= ~pEncoder->mask;
14. }
15.  
16. uint8_t uValorEntrada(myEncoder_t pEncoder)
17. {
18.     return (*pEncoder->puerto & pEncoder->mask);
19. }

Recorda que lo que pasamos es un puntero a la estructura, por lo tanto por eso tenemos el "->" para poder acceder a la estructura.
En la estructura tenemos 2 cosas... un PUNTERO al puerto y la mascara que la generamos sabiendo el numero del pin cuando lo inicializamos.
Entonces:

pEncoder->puerto  = puntero del puerto, en caso de los PIC16 el PORTB es 0x06 (su dirección)
 *(pEncoder->puerto) = contenido del puerto , el operador "->" posee una mayor precedencia que el "*", por eso puedo escribirlo sin paréntesis.
La mascara es un valor de 8bits, que generamos antes, si pusimos que nuestro pin era el 3, mask queda con el valor: 0000 1000

Por lo tanto, si hacemos:
- una OR, lo ponemos a 1 a ese pin nomas
- una XOR, hacemos un toggle de ese pin
- una AND con su negado, apagamos el pin

Y deje ahi una funcion por si tu idea es leerlo.

----------------------------------------------------

si la idea es generar un driver para el encoder, cuando lo "inciializas" tambien podrias modificar los TRIS
Tambien podrias agregar otros campos mas a la estructura en caso de querer agregar los pines A,B, y el 3er pin que es el switch.
Infinitas posibilidades..

----------------------------------------------------

PD: Me acabo de dar cuenta que al simulador del MPLAB no le gusta nada esta forma de programar jeje, no te reconoce ningun valor.

[Thulsa Doom]

Hola, me he estado estrujando el cerebro hasta no poder más, el código me hace cosas raras y ya no sé que puede ser.
Esta es la función de prueba que he creado para  configurara a que puerto quiero leer y pin.

Código: [Seleccionar]

   static struct RotaryEncoder EncoderList[MAX_NUMBER_ENCODERS];
    static uint8_t TotalEncoders = 0;

_RotaryEncoder EncoderInit(int8_t *port1, int8_t *port2, int8_t pin1, int8_t pin2, int8_t limite){
   
      // Se superaron la cantidad de Encoders establecidos
    if(TotalEncoders >= MAX_NUMBER_ENCODERS )
        return 0;
   
    uint8_t indexActual = TotalEncoders;
    TotalEncoders++;
   
    EncoderList[indexActual].canal_A = port1;
    EncoderList[indexActual].canal_B = port1;
    EncoderList[indexActual].mask_A = (1<<pin1);
    EncoderList[indexActual].mask_B = (1<<pin2);
    EncoderList[indexActual].limit = limite;
 
    return &EncoderList[indexActual]; // Retorna el puerto o puertos y pines que vams a usar
   
}
y esta es la función para leer el puerto y actue en consecuencia.

Código: [Seleccionar]

uint8_t Encoder_Scan(_RotaryEncoder data){
   
    static uint8_t encoder_tick = 0;
    static BIT cycle = 0;
    static BIT gd = 0;     //Variable local
    static BIT gi = 0;     //Variable local   
 
   
    if((*data->canal_A & data->mask_A) == 1){
        gd = 1;
    }
   
    if((*data->canal_B & data->mask_B) == 1){
        gd = 0;
    }
     
    return encoder_tick;
}
Pues resulta que el primer if si que funciona pero el segundo no, he invertido los pines a trabajar y se invierte la sentencia que funciona, ósea que ahora funciona el if segundo pero no el primero.
En modo debugger me muestra que el puntero al puerto D funcionan bien y lee el dato del puertos, también se ve la variable mask_X tiene el valor correcto con lo cual ya no sé que puede estar pasando.
Primer if

segundo if

[KILLERJC]

El problema esta en la condicion

*data->canal_X & data->mask_X == 1

En tu ejemplo mask_A es 0000 0001 por lo tanto al hacer una AND queda 0000 0001 lo que es igual a 1, en caso de no detectarse un 1, queda en 0
En el caso de mask_B es 0000 0010 si detecta un 1 quiere decir que el resultado es 0000 0010 lo que es igual a 2, y en caso de no detectarse un 1, queda en 0

Entonces la condicion de que sea 1 no sirve.. Deberias pensarlo en cuando se cumple que NO ES 0
Cambia la condicion por:

Código: C

1. if(*data->canal_A & data->mask_A)
2. if(*data->canal_B & data->mask_B)

Entonces si es 0 no va entrar, si es cualquier otro numero entra al if.

[Thulsa Doom]

Pues así si funciona pero no entiendo el porqué, si lo que estoy preguntando de que si es 1 que se ejecute y el pin está a 1, no lo comprendo

[KILLERJC]

Nuevamente.... voy a ser mas preciso con un ejemplo..

Caso de que el pinB este en 1:

*data->canal_B = 0b0100 1011  (Los demas 1 son aleatorios en este ejemplo)
data->mask_B =   0b0000 0010

El resultado de la AND es:
0100 1011
0000 0010
------------
0000 0010

Lo que es igual a 2, luego te queda:

Código: C

1. if(2 == 1)

Lo cual nunca se cumple... el 2 == 1 da como resultado falso o verdadero, que es lo que recibe el if

Si no tenemos ningun operador comparador como te pido yo

Código: C

1. if(*data->canal_A & data->mask_A)

Esta ves no se compara con nada, entonces tenes una "regla" que:

Cualquier valor distinto de 0 = verdadero
Valor igual a 0 = falso.

cuando te queda if(2), ese 2 se transforma en un "verdadero". if(-100) es verdadero, if(400) es verdadero. Estos todos se cumplen, Observa que es lo mismo que cuando hacemos while(1).

Ahora si hacemos if(0) no entra al if, porque es falso. Por eso te funciona. y el tuyo no.

Si lo negamos,, muchas veces hacemos:

Código: C

1. if(!(*data->canal_A & data->mask_A))

Primero se evalua lo de adentro del parentesis, y queda verdadero o falso, y luego se invierte. En este caso entraria si NO esta presionado. Es decir que la entrada sea 0

[Thulsa Doom]

El problema es que tengo que comparar entre los dos pines de los dos puertos, de la manera que si que me está funcionando es esta:

Código: [Seleccionar]

if(((*data->canal_A & data->mask_A) != 0) && ((*data->canal_B & data->mask_B) != 1){
}

De la manera que me indicas no me funciona

pero a su vez el pin del interruptor del encoder no va de esta manera si no todo lo contrario, tengo que hacerlo así.

Código: [Seleccionar]

if((*data->canal_C & data->mask_C) == 0){
 
    }
Este pin va a siempre uno, y cuando se activa es cuando baja a 0

Si lo niego como lo de arriba no funciona, la verdad que me deja loco

[KILLERJC]

Código: C

1. if(((*data->canal_A & data->mask_A) != 0) && ((*data->canal_B & data->mask_B) != 1){

Queres detectar cuando el pinA es 1 y B es 0?

Código: C

1. //A es 1, y B es 0
2. if((*data->canal_A & data->mask_A) && !(*data->canal_B & data->mask_B))
3. //A es 0, y B es 1
4. if(!(*data->canal_A & data->mask_A) && (*data->canal_B & data->mask_B))
5. //A es 1, y B es 1
6. if((*data->canal_A & data->mask_A) && (*data->canal_B & data->mask_B))
7. //A es 0, y B es 0
8. if(!(*data->canal_A & data->mask_A) && !(*data->canal_B & data->mask_B))

De ultima haces para todas las opciones, ya que puede variar los pines a medida que los vas leyendo:

Código: C

1. uint8_t tmp;
2. if(*data->canal_A & data->mask_A) tmp |= (1<<0);
3. if(*data->canal_B & data->mask_B) tmp |= (1<<1);
4.  
5. switch(tmp)
6. {
7.    case 0b00:
8.          break;
9.    case 0b01:
10.          break;
11.    case 0b10:
12.          break;
13.    case 0b11:
14.          break;
15.    default:
16.          // No deberia entrar nunca aca
17.          break;
18. }

---------------------------------------------------------------------------
Esto:

Código: C

1. if((*data->canal_C & data->mask_C) == 0){

Como dije es igual que esto:

Código: C

1. if(!(*data->canal_C & data->mask_C)){

Deberia funcionar... no veo nada malo en el codigo... pero deberia hacerlo. Aunque es equivalente, y no habria problemas de dejarlo como lo tenes. Es raro que me digas que no funciona de la otra forma (negandolo logicamente)