pic, comment faire un btfss en C ?

[invitebd358db9]

bonjour,

je programme sous maplab V8.4 et compilateur high tech tools

j'aimerais tester la valeur d'un bite d'une variable et même modifier un bit (RB0) directement selon un bit d'une variable.
comme un btfss ou btfsc en assembleur

exemple:

#define clock  RB0
unsigned char buffer;

clock = buffer.2;

et la j'ai une erreur de compilation pour le buffer.2

je travaillais avant sur le compilateur ce de BKunke (CCS) et cela fonctionnais sans probleme.

je suppose que c'est une question de syntax mais je trouve rien dans le manuel du compilateur high tech.

le code suivant ne fonctionne bien sur par non plus.

unsigned char buffer;
buffer = 0b11111111;

if (buffer.2 == 1) {
  buffer = 10;
}

merci pour votre aide et vos explication.
-----

[invite860936ec]

bonjour,
essai de déclarer les bits à tester dans une structure:

extern volatile near unsigned char       PORTA;
extern volatile near union {
  struct {
    unsigned RA0:1;
    unsigned RA1:1;
    unsigned RA2:1;
    unsigned RA3:1;
    unsigned RA4:1;
    unsigned RA5:1;
    unsigned RA6:1;
    unsigned RA7:1;
  };
  struct {
    unsigned AN0:1;
    unsigned AN1:1;
    unsigned AN2:1;
    unsigned AN3:1;
    unsigned :1;
    unsigned AN4:1;
  };
  struct {
    unsigned C12IN0M:1;
    unsigned C12IN1M:1;
    unsigned C2INP:1;
    unsigned C1INP:1;
    unsigned C1OUT:1;
    unsigned C2OUT:1;
  };
  struct {
    unsigned C12IN0N:1;
    unsigned C12IN1N:1;
    unsigned VREFM:1;
    unsigned VREFP:1;
    unsigned T0CKI:1;
    unsigned SS:1;
  };
  struct {
    unsigned :2;
    unsigned VREFN:1;
    unsigned :2;
    unsigned NOT_SS:1;
  };
  struct {
    unsigned :2;
    unsigned CVREF:1;
    unsigned :2;
    unsigned LVDIN:1;
  };
  struct {
    unsigned :5;
    unsigned HLVDIN:1;
  };
} PORTAbits;

[invite3c35244f]

Bonjour,

à mon avis, il faut que tu vois du coté des structures.
Tu commences par déclarer une structure pour ton mot, par exemple:

#define CLOCK RB0

typedef struct {
    unsigned Buffer_bit0:1; 
    unsigned Buffer_bit1:1;
    unsigned Buffer_bit2:1;
    unsigned Buffer_bit3:1;
    unsigned Buffer_bit4:1; 
    unsigned Buffer_bit5:1;
    unsigned Buffer_bit6:1;
    unsigned Buffer_bit7:1;
  }BUFFER;

ensuite, dans ton code, tu utilises ça comme cela:

BUFFER.Buffer_bit2 = 1;
BUFFER.Buffer_bit3 = 0;
...

Par contre, je sais pas si tu peux faire cela:

BUFFER = 0x55;

Et après pour l'affectation a ton bit:

CLOCK = BUFFER.Buffer_bit2;

Voila, a mon a vis c'est une bonne piste... il y a peut etre plus facile, mais mes connaissances sont un peu limité dans de genre de manip.

Bonne continuation

[invite7a49d0d5]

Bonjour,

moi, ça me ferait mal de devoir déclarer un octet
en structure pour pouvoir accéder individuellement
à ses bits ;O]

c'est sûrement un problème de syntaxe, ou
bien ce compilo inclut une "fonction" spéciale,
style "testbit(octet, nbit)"...

vede
;O]

ps :
t'as tenté la virgule?
clock = buffer,2;

[A voir en vidéo sur Futura]

[invitebd358db9]

merci pour votre aide,

en chechant sur le forum de microchip, j'ai recus une reponse comme vous le proposer, c'est a dire l'emploi d'une structure. avec une union pour pouvoir donner directement une valeur à buffer.

exemple:

#define clock RB0;

union v8bit {
     struct {
         unsigned bit0:1;
         unsigned bit1:1;
         unsigned bit2:1;
         unsigned bit3:1;
         unsigned bit4:1;
         unsigned bit5:1;
         unsigned bit6:1;
         unsigned bit7:1;
     };
     unsigned char ALL;
};

union v8bit buffer;
buffer.ALL = 0b11111111;
clock = buffer.bit2;

cette solution est alors tres lisible mais prend pas mal de place en memoire flash.

alors voici la deuxime solution proposée

#define clock RB0;
buffer = 0b11111111;
clock = ((buffer & 0b00000100)>>2);

celle ci prend moins de place mais bien sur est moins lisible.

par contre la 2eme solution me donne un warning du compilateur C de high tech (constante utilisée avec || ou &&) PQ?

encore merci de votre aide

[invitec1cd705e]

Salut,

Ca serai pas plus simple de faire des masque avec des ET/OU pour tester juste l'état d'un bit?

[invitec1cd705e]

En gros au lieu de

#define clock  RB0
unsigned char buffer;

clock = buffer.2;

plutot ça:

#define clock  RB0
unsigned char buffer;

if ((buffer & 0b00000100)==0)
  clock = 0;
else
  clock = 1;

[invitebd358db9]

Merci pour votre aide,

oui ca peut marcher mais toujours pas tres lisible

j'ai recus sur le forum de microchip une autre ide qui vient du manuel de high tech, je l'avais vu mais pas bien compris.

il faut definir des macro comme ceci.

#define bitset(var,bitno)   ((var) |= 1UL << (bitno))
#define bitclr(var,bitno)    ((var) &= ~(1UL << (bitno)))
et
#define bittest(var,bitno)  (((var) & 1UL << (bitno))>>bitno)

et l'utiliser comme ceci:

#define clock  RB0
unsigned char buffer;

bitset (buffer,4);
clock = testbit (buffer,4);

cela prend la même place en rom que :

clock = ((buffer & 0b00000100)>>2);

mais plus lisible et comprehensible.

le seul petit probleme encore est que je ne comprend pas tres bien les macro decrite.

que veux dire le 1UL ?

de plus j'ai toujours un warning du compilateur, faut il y faire attention?

[Seb.26]

moi, ça me ferait mal de devoir déclarer un octet
en structure pour pouvoir accéder individuellement
à ses bits ;O]

Et pourtant c'est bien ce qu'il faut faire ...

En général, je fais un union d'un byte (unsigned char) et d'un champ de 8 bit (b0 à b7) ...

[Seb.26]

cette solution est alors tres lisible mais prend pas mal de place en memoire flash.

Ah bon ??? ... d'où vient cette info ???

Si ton compilo ne remplace pas par un "toto.b0=1" par un "BSF" ... change de compilo !

[Seb.26]

clock = ((buffer & 0b00000100)>>2);

ce code est pas bon : il faut le OU/ET après le décalage ...

leurs macros font un OU/ET de 0x01 décalé à gauche ... ce qui oblige à charger la valeur dans un registre avant de faire le ET/OU ... tu gaspille une instruction ... le BSF & co est là pour ça ...