Identification d'un bit sur un octet

Version imprimable

30/11/2013, 14h27
rauch

Identification d'un bit sur un octet

Bonjours à tous.

Donc j'ai décalé dans une structure un
char flag;
donc un octect..
et j'aurais aimé savoir comment je fait pour identifier un bit sur cet octect
ex j'ai b7 b6 b5 b4 b3 b2 b1 b0
et j'aimerais que par exemple

b4 = halt
b5 = halt1
b6 = halt2
b7 = halt3

merci de m'aider svp
30/11/2013, 14h39
Obsidian

Tu utilises les opérations logiques bit-à-bit pour les modifier. Le OU logique pour les mettre un bit donné à 1 :

— flag |= 1 pour mettre à un le bit 0 ;
— flag |= 2 pour mettre à un le bit 1 ;
— flag |= 4 pour mettre à un le bit 2 ;
— flag |= 8 pour mettre à un le bit 3 ;
etc.

… et le ET logique avec le complément des valeurs ci-dessus pour les remettre à zéro :

— flag &= 254 pour mettre à zéro le bit 0 ;
— flag &= 253 pour mettre à zéro le bit 1 ;
— flag &= 251 pour mettre à zéro le bit 2 ;
— flag &= 247 pour mettre à zéro le bit 3 ;
etc.

… enfin, tu utilises le ET avec les masques originaux pour isoler la valeur d'un bit en particulier :

— flag & 1 pour isoler le bit 0 ;
— flag & 2 pour isoler le bit 1 ;
— flag & 4 pour isoler le bit 2 ;
— flag & 8 pour isoler le bit 3 ;
etc.

Alors d'apres ce que j'ai compris tu voudrais "modifier" un bit d'un char. Je vois pas des masses l'interet mais pourquoi pas... Donc voila pour afficher le "stockage binaire" de ta variable.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 char *convertToBinary(char x) { int size = sizeof(x) * 8 - 1; char *ret; int pos = 0; if (!(ret = malloc(sizeof(*ret) * (size + size / 8 + 1))) return 0; while (size >= 0) { ret[pos++] = (char)(((x >> size) & 1) + '0'); if (size-- % 8 == 0 && size >= 0) ret[pos++] = ' '; } ret[pos] = 0; return ret; }
Maintenant si tu veux voir tous les octets de ta structure pour en modifier un, tu n'as qu'a la convertir en char*...
Code:

1 2 3 4 5 6 7 8 ma_struct p; char *ptr = (char*)&p; int i = 0; for (; i < sizeof(p); ++i) { printf("%d ", ptr[i]); } printf("\n");
J'espere avoir repondu a ta question...

30/11/2013, 14h53
rauch

Merci beaucoup, une réponse parfaite

j'ai réussi a isoler le bit que je voulais merci,

Et império tu as répondu a une questions que j'allais sans doute pour la suite de mon projet.
Mais j'ai un problème;

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
 
#include <stdio.h>
#include <stdlib.h>
 
char *convertToBinary(char x);
 
 
int main(int argc, const char * argv[])
 
{
    char nombre = 5;
    convertToBinary(&nombre);
    printf("%d",nombre);
 
}
 
 
char *convertToBinary(char x)
{
    int        size = sizeof(x) * 8 - 1;
    char       *ret;
    int         pos = 0;
 
    if (!(ret = malloc(sizeof(*ret) * (size + size / 8 + 1))))
 
 
        return 0;
 
        while (size >= 0)
        {
            ret[pos++] = (char)(((x >> size) & 1) + '0');
            if (size-- % 8 == 0 && size >= 0)
                ret[pos++] = ' ';
        }
        ret[pos] = 0;
        return ret;
 
}

j'arrive pas trop a saisir l'erreur...

30/11/2013, 16h01
imperio

Tu envoies un char* a une fonction qui attend un char. Tu n'as pas l'air d'avoir compris ce que fait la fonction que j'ai ecrite. Elle renvoie un pointeur alloue en cas de reussite et 0 en cas d'echec. Donc tu dois recuperer la valeur de retour, l'afficher avec printf puis la liberer avec free.

PS: pour afficher une chaine de caractere avec printf on utilise %s.
30/11/2013, 16h14
rauch

ah! ok,
et comment je peux récupérer ton ret et la libérer ?
30/11/2013, 17h04
imperio

... Ca doit etre une blague mais au cas ou :

Citation:

Envoyé par imperio

Elle renvoie un pointeur alloue en cas de reussite et 0 en cas d'echec. Donc tu dois recuperer la valeur de retour, l'afficher avec printf puis la liberer avec free.

PS: pour afficher une chaine de caractere avec printf on utilise %s.
30/11/2013, 17h06
diogene
@imperio :
Pourquoi un code aussi complexifié :

Code:

int size = sizeof(x) * 8 - 1;

x est un char, donc sizeof(x) vaut toujours 1 :

Code:

int size = 7;

----------

Code:

ret = malloc(sizeof(*ret) * (size + size / 8 + 1))

devient (*ret est un char)
Code:

1 2 3 ret = malloc(7 + 7 / 8 + 1) // ou ret = malloc(8)
----------

Code:

ret[pos++] = (char)(((x >> size) & 1) + '0');

Pourquoi ce transtypage ? Il est automatique. L'utilisation de transtypage doit être réservé exclusivement aux cas où il est nécessaire, car cela empêche le compilateur de vérifier la cohérence du code.

Code:

ret[pos++] = ((x >> size) & 1) + '0';

----------

Code:

if (size-- % 8 == 0 && size >= 0)

Comme size est inférieur à 8, size % 8 == size
----------

Code:

ret[pos++] = ' ';

Comme pos augmente de 2 lorsque size diminue de 1, la place précédemment allouée est trop petite

@diogene: j'ai tout simplement adapte une fonction templatee que j'ai fait. Normalement elle ressemble a ca :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 template<class C> std::string convertToBinary(C &x) { int size = sizeof(x) * 8 - 1; std::string ret; while (size >= 0) { ret += (char)(((x >> size) & 1) + '0'); if (size-- % 8 == 0 && size >= 0) ret += ' '; } return ret; }
Le but etant d'afficher le stockage binaire de la variable, quel que soit son type. Donc en passant ce code en C, j'ai essaye de garder cette facilite de conversion, il suffirait juste de change le type de la variable recu sans avoir a changer quoi que ce soit d'autre.

Bonsoir,

Citation:

Envoyé par rauch

Bonjours à tous.

Donc j'ai décalé dans une structure un
char flag;
donc un octect..
et j'aurais aimé savoir comment je fait pour identifier un bit sur cet octect
ex j'ai b7 b6 b5 b4 b3 b2 b1 b0
et j'aimerais que par exemple

b4 = halt
b5 = halt1
b6 = halt2
b7 = halt3

merci de m'aider svp

Voici une proposition :
supposons qu'on a :

Code:

flag = b7 b6 b5 b4 b3 b2 b1 b0;

vous declarez une autre variable de type char, par ex:

Code:

char result;

alors pour modifier n'importe quel bit, utilisez cette expression :

Code:

result=(~(taille_mask)<<offset)& flag) | ((value)<<offset)

exemple :
J'ai développé un petit code ( à vérifier) permettant de modifier le bit b0 du flag par 1 ( vous pouvez changer ces valeurs):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <stdio.h>
 /*La constante 1 représente le bit0*/
#define bit0 1
/*Prototype de la fonction  bit_modif*/
unsigned char bit_modif(unsigned char value_in_bit_number,
                            unsigned char value_in,
                            unsigned char value_insert
                           );
/*Variable valeur de type unsigned char qui occupe un seule bit*/
 
typedef struct bit_s {
 
    unsigned char valeur :1;
 
} bit_t;
 
        int main ()
        {
                /*Variable à modifier*/
                unsigned char flag = 0xCC;
                /*numéro de bit de flag à modifier*/
                bit_t bit;
                /* Résultat de modification*/
                unsigned char result;
 
                bit.valeur=1;
                /* Appel de la fonction bit_modif*/
                result =  bit_modif( bit0 , flag , bit.valeur);
 
            return(0);
        }
 
 
unsigned char bit_modif(    unsigned char value_in_bit_number,
                            unsigned char value_in,
                            unsigned char value_insert
                           )
{
    return ( (~((0x01) << value_in_bit_number) & value_in ) | ((value_insert) << value_in_bit_number ));
}

06/12/2013, 19h52
Sve@r

Citation:

Envoyé par Obsidian

— flag |= 1 pour mettre à un le bit 0 ;
— flag |= 2 pour mettre à un le bit 1 ;
— flag |= 4 pour mettre à un le bit 2 ;
— flag |= 8 pour mettre à un le bit 3 ;
etc.

Salut

Moi je préfère utiliser les notations hexa
— flag |= 0x01 pour mettre à un le bit 0 ;
— flag |= 0x02 pour mettre à un le bit 1 ;
— flag |= 0x04 pour mettre à un le bit 2 ;
— flag |= 0x08 pour mettre à un le bit 3 ;

C'est pas très parlant jusque là mais si on continue, on aura
— flag |= 0x10 pour mettre à un le bit 4 ;
— flag |= 0x20 pour mettre à un le bit 5 ;
— flag |= 0x40 pour mettre à un le bit 6 ;
— flag |= 0x80 pour mettre à un le bit 7 ;
Je préfère cette progression 01; 02; 04; 08; 10; 20; 40; 80 (et qui continue avec 100; 200; 400; 800 si on travaille sur des int) plutôt que des nombres tels que 16; 32; 64; 128; 256; 512; 1024; 2048 identiques certes ; mais qui sont moins représentatifs...

ou la macro (1<<n), exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
 
#define bit(n) (1LL<<n)
 
int main()
{
  int i;
  for(i=0;i<64;i++)
    printf("bit %2d = %016llx %llu\n",i,bit(i),(unsigned long long)bit(i));
  return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
bit  0 = 0000000000000001 1
bit  1 = 0000000000000002 2
bit  2 = 0000000000000004 4
bit  3 = 0000000000000008 8
bit  4 = 0000000000000010 16
bit  5 = 0000000000000020 32
bit  6 = 0000000000000040 64
bit  7 = 0000000000000080 128
bit  8 = 0000000000000100 256
bit  9 = 0000000000000200 512
bit 10 = 0000000000000400 1024
bit 11 = 0000000000000800 2048
bit 12 = 0000000000001000 4096
bit 13 = 0000000000002000 8192
bit 14 = 0000000000004000 16384
bit 15 = 0000000000008000 32768
bit 16 = 0000000000010000 65536
bit 17 = 0000000000020000 131072
bit 18 = 0000000000040000 262144
bit 19 = 0000000000080000 524288
bit 20 = 0000000000100000 1048576
bit 21 = 0000000000200000 2097152
bit 22 = 0000000000400000 4194304
bit 23 = 0000000000800000 8388608
bit 24 = 0000000001000000 16777216
bit 25 = 0000000002000000 33554432
bit 26 = 0000000004000000 67108864
bit 27 = 0000000008000000 134217728
bit 28 = 0000000010000000 268435456
bit 29 = 0000000020000000 536870912
bit 30 = 0000000040000000 1073741824
bit 31 = 0000000080000000 2147483648
bit 32 = 0000000100000000 4294967296
bit 33 = 0000000200000000 8589934592
bit 34 = 0000000400000000 17179869184
bit 35 = 0000000800000000 34359738368
bit 36 = 0000001000000000 68719476736
bit 37 = 0000002000000000 137438953472
bit 38 = 0000004000000000 274877906944
bit 39 = 0000008000000000 549755813888
bit 40 = 0000010000000000 1099511627776
bit 41 = 0000020000000000 2199023255552
bit 42 = 0000040000000000 4398046511104
bit 43 = 0000080000000000 8796093022208
bit 44 = 0000100000000000 17592186044416
bit 45 = 0000200000000000 35184372088832
bit 46 = 0000400000000000 70368744177664
bit 47 = 0000800000000000 140737488355328
bit 48 = 0001000000000000 281474976710656
bit 49 = 0002000000000000 562949953421312
bit 50 = 0004000000000000 1125899906842624
bit 51 = 0008000000000000 2251799813685248
bit 52 = 0010000000000000 4503599627370496
bit 53 = 0020000000000000 9007199254740992
bit 54 = 0040000000000000 18014398509481984
bit 55 = 0080000000000000 36028797018963968
bit 56 = 0100000000000000 72057594037927936
bit 57 = 0200000000000000 144115188075855872
bit 58 = 0400000000000000 288230376151711744
bit 59 = 0800000000000000 576460752303423488
bit 60 = 1000000000000000 1152921504606846976
bit 61 = 2000000000000000 2305843009213693952
bit 62 = 4000000000000000 4611686018427387904
bit 63 = 8000000000000000 9223372036854775808