Como leer 3 pines dispersos de un micro con CCW

[MasterD]

Soy nuevo en C y mi experiencia ha sido en PicBasic, la pregunta es
En PicBasic o en Basic existen los Alias. Es decir que puedo acceder
A cualquier punto de la variable en cualquier momento por ejemplo
Tengo la siguiente sub-rutina en Basic que puede leer un DipSwitch
Y almacena el contenido en variable < dipswt >, cuando los puertos están
Organizados en grupo de 4, 8, 2 no hay problema. Pero cuando están dispersos
En el puerto o en diferente puertos el caso es diferentes.

Read_sw:
  dipswt=0      ‘ Limpia el contenido de la variable
  dipswt.0=PORTA.2 ‘Almacena el contenido del PORTA.2 en dipswt.0
  dipswt.1=PORTA.1   ‘Almacena el contenido del PORTA.1 en dipswt.1
  dipswt.2=PORTA.4   ‘Almacena el contenido del PORTA.4 en dipswt.2
  debug dipswt    ‘ Imprime el valor total almacenado en < dipswt >
return

En C se me ocurre lo siguiente:

int Read_sw ( ) {
Int   dipswt;
dipswt = 0;

bit_clear(dipswt,0);
if (input(PIN_A2))
   bit_set(dipswt,0);

bit_clear(dipswt,1);
if (input(PIN_A1))
   bit_set(dipswt,1);

bit_clear(dipswt,2);
if (input(PIN_A4))
   bit_set(dipswt,1);

return (dipswt);
}

Sin embargo me resisto a creer en esto debe de existir un mejor método de asignación.

Estoy estudiando las estructuras y las uniones pero aun me cuesta comprender, menos aun los punteros.

[pocher]

Conforme lo tienes puesto, cuando algún bit del PORTA suba a 1, el correspondiente de la variable subirá a 1 y ya no cambiará. Supongo que lo que tú quieres es que los valores individuales de los pines de entrada, sean 0 o 1 los guarde en una variable nada más cambien de valor.

Se puede hacer que sea el compilador quien asigne los bits individuales a las posiciones de memoria que le dé la gana (normalmente las asigna correlativas). Esto es lo más rápido de programar, o bien se puede obligar al compilador a que meta los bits en posiciones fijas de direccciones fijas asignadas por tí.

Yo personalmente te recomiendo la primera opción (que el jefe sea el compilador y te quite faena)

¿Con cual te quedas?

Un saludo

[MasterD]

Si es posible me gustaria ver un ejemplo de:
hacer que sea el compilador quien asigne los bits individuales a las posiciones de memoria que le dé la gana (normalmente las asigna correlativas).

[pocher]

... eh voila!

Codigo://            P1_4_2.C

#include <16f84a.h>

#use fast_io(A)
#use fast_io(B)

#byte port_b = 6

main()
{
  short B,A,R;
   port_b = 0;
   set_tris_a(0x1F);
   set_tris_b(0x00);
   
   while (1)
   {
      B = input(PIN_A0);
      A = input(PIN_A1);
      
      R = (R||!B)&&!A;
      
      output_bit(PIN_B0,R);
   }
}

[El_Coach]

Hola, tengo un problema parecido...

Necesito asignar el valor de un pin del micro a los diferentes bits de una variable cada cierto tiempo. La única forma que se me ocurre es la que a continuación explico, pero espero que haya alguna más efectiva, no puede ser que sea la única manera. Un saludo


#include<18F2550.h>

#fuses HS,NOPROTECT,NOBROWNOUT,NOWDT,NOPUT

#use delay(clock=20000000)    //Oscilador a 20MHz

main()
{

    int    var=0;
    set_tris_a(0xFF);

    while(1)
    {
        delay_ms(1000);

        if (input(PIN_A0))    // <--- Me gustaria abreviar estas dos líneas en una sola,
            bit_set(var,7);    // <--- algo así: var.7=input(PIN_A0);
        delay_ms(1);

        if (input(PIN_A0))
            bit_set(var,6);
        delay_ms(1);

        if (input(PIN_A0))
            bit_set(var,5);
        delay_ms(1);

        if (input(PIN_A0))
            bit_set(var,4);
        delay_ms(1);

        if (input(PIN_A0))
            bit_set(var,3);
        delay_ms(1);

        if (input(PIN_A0))
            bit_set(var,2);
        delay_ms(1);

        if (input(PIN_A0))
           bit_set(var,1);
        delay_ms(1);
 
        if (input(PIN_A0))
            bit_set(var,0);
    }
}

[Nocturno]

Hay una opción distinta que quizas te guste más:

var=0;
for (i=0;i<7;i++)
{
   var=var+input (PIN_A0); // mete el valor de PIN_A0 en el bit menos significativo
   var=var*2; // desplaza un bit a la izquierda la variable var
   delay_ms(1)
}

[El_Coach]

Desde luego que me gusta más!

Como se nota la experiencia...

A veces es bueno pensar en ensamblador, lo hice con tanto código porque con el for y utilizando i como indicador del bit en el que quería escribir, utilizando bit_set(var,i); , no siempre tardaba el mismo tiempo en ejecutar la instrucción. Haciéndolo como indicas debería siempre tardar lo mismo.

Gracias Nocturno