Imprimir Página - [SOLUCIONADO]¿Se le puede pasar un pin del micro a un función?

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Thulsa Doom en 09 de Mayo de 2018, 05:45:43

Título: [SOLUCIONADO]¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 09 de Mayo de 2018, 05:45:43

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 09 de Mayo de 2018, 07:57:02

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.

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 09 de Mayo de 2018, 08:09:02

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 09 de Mayo de 2018, 09:25:06

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.. :D

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 09 de Mayo de 2018, 13:50:52

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: electroipod en 09 de Mayo de 2018, 14:37:47

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 09 de Mayo de 2018, 15:03:34

main.c

Código: C

#include <xc.h>
#include "driver.h"
 
myEncoder_t encoder1;
myEncoder_t encoder2;
myEncoder_t encoder3;
 
 
void main(void) {
 
    encoder1 = vIniciarEncoder(&PORTB,0);
    encoder2 = vIniciarEncoder(&PORTB,1);
    encoder3 = vIniciarEncoder(&PORTB,2);
    
    uAgregarPasos(encoder1,10);
    uAgregarPasos(encoder2,5);
    uAgregarPasos(encoder3,-50);
 
    int8_t test;
    
    test = iPasosEncoder(encoder1);
    test = iPasosEncoder(encoder2);
    test = iPasosEncoder(encoder3);
        
    while(1){
    }
}

driver.c

Código: C

#include "driverinternal.h"
 
static struct myEncoder aEncoderList[MAX_NUMBER_ENCODERS];
static uint8_t gTotalEncoders = 0;
 
myEncoder_t vIniciarEncoder(volatile unsigned char * pPort, uint8_t uPin)
{
    /* // Protecciones
    ASSERT(pPort);
    ASSERT(uPin);
    */
    
    // Se superaron la cantidad de Encoders establecidos
    if(gTotalEncoders >= MAX_NUMBER_ENCODERS )
        return 0;
    
    uint8_t indexActual = gTotalEncoders;
    gTotalEncoders++;
    
    aEncoderList[indexActual].puerto = pPort;
    aEncoderList[indexActual].mask = (uint8_t)(1 << uPin); //Cast para quitar lo molesto del warning del compilador
    aEncoderList[indexActual].pasos = 0;
 
    return &aEncoderList[indexActual];
}
 
int8_t iPasosEncoder(myEncoder_t pEncoder)
{
    // Proteccion
    //ASSERT(pEncoder);
 
    
    int8_t aux = pEncoder->pasos;
    // En caso de que al querer tomar los pasos y que se reinicie el contador
    // pEncoder->pasos = 0;
    return aux;
}
 
uint8_t uAgregarPasos(myEncoder_t pEncoder, int8_t iPasos)
{
    //Proteccion
    //ASSERT(pEncoder);
    
    //posiblemente llamado desde la interrupcion como te comentaba, proteger contra overflow
    pEncoder->pasos += iPasos;
    return 0;
}

driver.h

Código: C

#ifndef DRIVER_H
#define DRIVER_H
 
#include <stdint.h>
 
typedef struct myEncoder * myEncoder_t;
myEncoder_t vIniciarEncoder(volatile unsigned char * b , uint8_t c);
int8_t iPasosEncoder( myEncoder_t a);
uint8_t uAgregarPasos( myEncoder_t a , int8_t b);
 
#define  MAX_NUMBER_ENCODERS    (3)
 
 
#endif  /* DRIVER_H */

driverinternal.h

Código: C

#ifndef DRIVERINTERNAL_H
#define DRIVERINTERNAL_H
 
 
#include "driver.h"
 
struct myEncoder
{
    volatile uint8_t *  puerto;
    uint8_t             mask;
    int8_t              pasos;
};
 
 
#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.

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 13 de Mayo de 2018, 16:16:23

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.

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 13 de Mayo de 2018, 20:17:32

Citar

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.

Citar

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

void vActivarSalida(myEncoder_t pEncoder)
{
    *pEncoder->puerto |= pEncoder->mask;
}
 
void vToggleSalida(myEncoder_t pEncoder)
{
    *pEncoder->puerto ^= pEncoder->mask;
}
 
void vApagarSalida(myEncoder_t pEncoder)
{
    *pEncoder->puerto &= ~pEncoder->mask;
}
 
uint8_t uValorEntrada(myEncoder_t pEncoder)
{
    return (*pEncoder->puerto & pEncoder->mask);
}

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.

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 15 de Mayo de 2018, 04:53:14

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
(https://i.imgur.com/OjD9Km6.png)
segundo if
(https://i.imgur.com/IDyUByk.png)

(https://i.imgur.com/XZa5SmE.png)

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 15 de Mayo de 2018, 08:19:54

El problema esta en la condicion

Citar

*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

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

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 15 de Mayo de 2018, 08:44:42

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 15 de Mayo de 2018, 08:58:24

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

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

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

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 15 de Mayo de 2018, 10:04:09

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

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 15 de Mayo de 2018, 11:19:19

Código: C

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

//A es 1, y B es 0
if((*data->canal_A & data->mask_A) && !(*data->canal_B & data->mask_B))
//A es 0, y B es 1
if(!(*data->canal_A & data->mask_A) && (*data->canal_B & data->mask_B))
//A es 1, y B es 1
if((*data->canal_A & data->mask_A) && (*data->canal_B & data->mask_B))
//A es 0, y B es 0
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

uint8_t tmp;
if(*data->canal_A & data->mask_A) tmp |= (1<<0);
if(*data->canal_B & data->mask_B) tmp |= (1<<1);
 
switch(tmp)
{
   case 0b00:
         break;
   case 0b01:
         break;
   case 0b10:
         break;
   case 0b11:
         break;
   default:
         // No deberia entrar nunca aca
         break;
}

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

Código: C

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

Como dije es igual que esto:

Código: C

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)

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 15 de Mayo de 2018, 13:22:55

Efectivamente, así funciona.
También creo que se podrá crear unas máscaras en función de los pines seleccionados y aplicar esa mascara como igualdad al condicional if, ejemplo

Código: [Seleccionar]

pin1 = 0b00000001;
pin2 = 0b00000010;
pin3 = 0b00000100;

if((*data->canal_A & mask_A) == pin1); //si queremos usar el pin 0
if((*data->canal_B & mask_B) == pin2); //si queremos usar el pin 1
if((*data->canal_C & mask_C) == pin3); //si queremos usar el pin 3

lo he hecho a groso modo, si se quiere hacer bien se tendrá que implementar un bucle switch como el que has puesto pero que compare el pin que elija y le de la mascara que le corresponda, pero si queremos eficiencia de código lo mejor es de la manera que has puesto, eso es lo que creo.
Entonces por lo que veo, ¿el tratamiento de los pines del puerto no se hacen de igual manera cuando usas un puntero a como cuando lo lees del registro, ósea cuando usas PORTBbits.RX?

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: KILLERJC en 15 de Mayo de 2018, 13:44:56

PORTBbits.RX

Es realidad una estructura donde se define los 8bits y un entero de 8bits puesto sobre la direccion del PORTB, XC8 tiene un operador especial para eso y es lo que usa en su .h que es el @

En esa estructura define cada bit... PORTB no es un puntero como esta definido en el .h de XC8, sino que es como una variable que tiene una direccion fija y vos dices: "Lo que hay en la direccion 0x06 le correspondo a esta estructura", dentro de la estructura estan definidos todos los bits.

Lo mismo podes hacer con una variable copio la definicion de un .h

Código: C

// Register: PORTB
#define PORTB PORTB
extern volatile unsigned char           PORTB               @ 0x006;      //Aca dice que tenes una variable de 8bits sin signo llamada PORTB en la direccion 0x006
#ifndef _LIB_BUILD
asm("PORTB equ 06h");
#endif
// bitfield definitions
typedef union {
    struct {
        unsigned RB0                    :1;
        unsigned RB1                    :1;
        unsigned RB2                    :1;
        unsigned RB3                    :1;
        unsigned RB4                    :1;
        unsigned RB5                    :1;
        unsigned RB6                    :1;
        unsigned RB7                    :1;
    };
} PORTBbits_t;
extern volatile PORTBbits_t PORTBbits @ 0x006; // Aca tenes que define la estructura como PORTBbits y dice que esta ubicada tambien en la direccion 0x006

Esto se resuelve en tiempo de compilacion pero no en run-time.
Si tenemos que guardar algo del puerto, lo unico que nos queda guardar es la direccion y el pin, ya que el pin solo no posee direccion propia. Por eso debemos tener guardado ambas cosas. Y por eso usamos un puntero al puerto.

Citar

pin1 = 0b00000001;
pin2 = 0b00000010;
pin3 = 0b00000100;

if((*data->canal_A & mask_A) == pin1); //si queremos usar el pin 0
if((*data->canal_B & mask_B) == pin2); //si queremos usar el pin 1
if((*data->canal_C & mask_C) == pin3); //si queremos usar el pin 3

Hacer eso quita toda ventaja de hacer el codigo como te pase.. intenta cargar cualquier puerto y pin, esto requiere que cada estructura posea minimo 8 punteros a puerto y 8 enteros de 8 bits. Ademas cuando lo inicializas tenes que cargar la mascara exacta.. termina siendo un exceso que no tiene sentido por achicar un poco mas los ifs.

Título: Re:¿Se le puede pasar un pin del micro a un función?
Publicado por: Thulsa Doom en 15 de Mayo de 2018, 14:12:36

Pues gracias por la explicación, ahora mismo ya me funciona el driver con varios encoders.
Se me ha puesto la cabeza como un tambor y echando humo pero ha merecido la pena, me acabas de ayudar a subir un nivel jajaja ((:-)) ((:-)) ((:-)) ((:-))
Saludos

TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: Thulsa Doom en 09 de Mayo de 2018, 05:45:43