Gerer les bits d'une variable avec C18

[invite958adb57]

Salut à tous, depuis peu je me suis mis au C pour programmer les PIC de la série 18 (grâce au compilateur C18 fourni sur le site de microchip).
Un problème se pose: je n'arrive pas à gérer les bits d'une variable.

En assembleur, c'est facile:

bsf variable_X,2 ; forcer bit 2 de la variable_X
btfss variable_X,2 ; tester bit 2 de la variable_X
xxxxx
xxxxx etc...

Mais sur C18, j'ai trouvé comment manipuler les bits des registres mais pas des variables:
pour placer RA1 à 1 il faut faire:

PORTAbits.RA1 = 1; // Placer RA1 à l'état haut
if (PORTAbits.RA1 == 1) goto suivant; // Si RA1 = 1 on saute
xxxxx

mais comment faire pour les bits d'une variable ??? J'ai éssayé:

variable_X.1 = 1; // forcer bit 1 à l'état haut de la variable_X
variable_X,1 = 1;
variable_X.bit.1 = 1;
variable_X.bit,1 = 1;
variable_X.bits.1 = 1;
variable_X.bits,1 = 1;
bit.variable_X,1 = 1;
bit.variable_X.1 = 1;
bits.variable_X,1 = 1;
bits.variable_X.1 = 1;

Rien n'y fait j'ai systématiquement une erreur lors de la compilation.
Si quelqu'un pouvait me dépanner ça serait sympa.

@++
Louis
-----

[invite4c7a167b]

Salut Louis !
Passage d'un bit à 1 dans une variable

variable |= 0x01 /* bit 1 à 1 */
variable |= 0x02 /* bit 2 à 1 */
variable |= 0x04 /* bit 3 à 1 */
variable |= 0x08 /* bit 4 à 1 */
variable |= 0x10 /* bit 5 à 1 */
variable |= 0x20 /* bit 6 à 1 */
variable |= 0x40 /* bit 7 à 1 */
variable |= 0x80 /* bit 8 à 1 */

Passage d'un bit à 0 dans une variable

variable &= 0x01 /* bit 1 à 0 */
variable &= 0x02 /* bit 2 à 0 */
variable &= 0x04 /* bit 3 à 0 */
variable &= 0x08 /* bit 4 à 0 */
variable &= 0x10 /* bit 5 à 0 */
variable &= 0x20 /* bit 6 à 0 */
variable &= 0x40 /* bit 7 à 0 */
variable &= 0x80 /* bit 8 à 0 */

PORTAbits.RA1 = 1; // Placer RA1 à l'état haut

Regarde dans le fichier .h de ton pic tu verras que PORTAbits est une strcuture composé de champs de bit et c'est pour cette raison que ça fonctionne avec les registres.

[invite958adb57]

Merci beaucoup.
Est-ce que je peux t'embêter encore en te demandant comment tester un ou plusieurs bits d'une variable ?

J'ai trouvé cette méthode:

variable_1 = 0b00000001; // Bit1 à 1
variable_2 = 0b00010000; // Bit5 à 1
if ((variable_1 & 0x01 == 1) && ((variable_2 & 0x10) >> 4 == 1)) //si bit1 de
goto saut1 //variable_1 et bit 5 de variable_2 sont à 1, on saute
xxxxx

@++
Louis

[invite4c7a167b]

Bonjour,
Excuse moi pour le retard, j'ai beaucoup de travail. Alors si c'est toujours d'actualité tu peux faire comme ça (tu n'étais pas loin) mais on peut faire plus simple.

variable_1 = 0b00000001; // Bit1 à 1
variable_2 = 0b00010000; // Bit5 à 1

     //si bit1 de variable_1 et bit 5 de variable_2 sont à 1, on saute
     if ((variable_1 & 0x01) && (variable_2 & 0x10))           
          goto saut1 
...

La méthode que tu as posté marche mais fait perdre du temps en faisant ((variable_2 & 0x10) >> 4 == 1)). Pour un simple test c'est inutile même si ça parâit une démarche logique de faire ce décalage à droite.

Mon code résonne comme suit :

Si le bit1 de variable_1 et bit 5 de variable_2 valent autres choses que 0 (1, 16, 4, 32... peut importe) alors on saute.

En C un "vrai" est tout sauf 0. C'est à dire :
0 = faux
1 = vrai
12 = vrai
2 = vrai
65535 = vrai
...

Je ne sais pas si j'ai été clair ? Sinon dit le je te posterai un nouveau post très détailé.
A bientôt,
Vincent

[A voir en vidéo sur Futura]

[invite958adb57]

Merci bien pour ces réponses, tu a été très clair et tu me sors d'une petite galère (au pire je serais passé par de l'assembleur pour tester les bits mais c'est plus marrant de savoir le faire en C).

@++
Louis