Manipulation pointeurs

Bonjour,

un appel à l'aide
pour déchiffrer un bout de code...

Moi et le C avec les pointeurs, ça fait au moins 312000
je m'en remets à une âme charitable du forum qui voudra bien m'éclairer...

Voici donc le code en question :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#define NBP_BUFFER 810 #define N_FRAME 71   unsigned char huge *ACQ_POINTER; long far ENTRY_POINT = 0xdc000000;   Init_Sample_Array(tab) int huge *tab; { ACQ_POINTER = tab; }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

acquisition(tab) int huge *tab; { Init_Sample_Array(tab);   pseudo_int(0);   for (int i = 0 ; i<25 ; i++) { pseudo_int(0); //... } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

pseudo_int() { register char far *pointer; register int time;   pointer = ENTRY_POINT; LINK_FAIL = 0;   *ACQ_POINTER++ = pointer[0xc0]; /*Get Lower byte */ time = pointer[0xc1]&0x0f; if ((time & 0x08) != 0) /* If negate */ time |= 0xf0; /* 4 upper bit extend to sign */ *ACQ_POINTER++ = time;   }

---

après, j'ai ça :

Code:

---

1 2	short int huge signal[NBP_BUFFER*N_FRAME]; acquisition(signal);

---

je cherche donc à savoir comment est constitué "signal"
c'est la partie dans "pseudo_int" qui me pose problème

déjà, j'ai du mal à saisir ce qui est fait...
est-ce que le contenu de "pointeur" est mis bout à bout dans "signal"??
ou bien est-ce que c'est cumulé à chaque passage dans "pseudo_int"??

après, c'est quoi exactement ces manip avec la variable "time"??

Merci d'avance

Bon,
c'est bon, j'ai réussi à déchiffrer en partie mon code pour ce qui est des boucles et des pointeurs...


par contre, je ne vois pas trop le but de cette manip :

Code:

---

1 2 3 4 5

*ACQ_POINTER++ = pointer[0xc0]; /*Get Lower byte */ time = pointer[0xc1]&0x0f; if ((time & 0x08) != 0) /* If negate */ time |= 0xf0; /* 4 upper bit extend to sign */ *ACQ_POINTER++ = time;

---

j'ai décomposé,
si pointer[0xc1] = xxxxxxxx (en binaire)
alors ça nous donne

Code:

---

time = pointer[0xc1]&0x0f;

---

>> time = 0000xxxx

Code:

---

1 2	if ((time & 0x08) != 0) time |= 0xf0;

---

>> time = 1111xxxx

quel est le but de changer les 4 bits de poids forts en '1' si le 4ème bit de poids faible est à '1' ??

Bonjour,

A la vue du commentaire dans le code, je pense que ce code transformation un entier signé 4 bits en entier signé 8 bits.

En gros si l'entier 4 bits est de la forme 1xyz, l'entier 8 bits sera de la forme 11111xyz.

oui, c'est ce que j'ai compris...

mais sachant que cette variable correspond à l'octet de poids fort d'un entier 16 bits
cela donne quoi concrètement sur la valeur entière??


comment s'écrit un entier 16 bits (short int) en binaire??

par exemple
0000 1001 1101 1000 >> cela donne quoi comme valeur décimale?

et son homologue
1111 1001 1101 1000 >> cela donne quoi comme valeur décimale?

Un entier signé écrit en complément à 2 sur n bits comme bn-1 bn-2 ..... b2 b1 b0 (bi = 0 ou 1) a pour valeur :

Citation:

---

V = -bn-1 2^(n-1) + bn-2 2^(n-2)+ ... + b1 2^1 + b0 2^0
(remarquer le signe - pour le bit de poids fort)

---

Ce qui donne :
0000 1001 1101 1000 -> -0*32768+0*16384+0*8192+0*4096+1*2048+0*1024+0*512+1*256+1*128+1*64+0*32+1*16+1*8+0*4+0*2+0*1 = 2520
1111 1001 1101 1000
-1*32768+1*16384+1*8192+1*4096+1*2048+0*1024+0*512+1*256+1*128+1*64+0*32+1*16+1*8+0*4+0*2+0*1 = -1576

Si l'entier est écrit en binaire pur (comme c'est toujours le cas en C pour les entiers non signés) on a :

Citation:

---

V = +bn-1 2^(n-1) + bn-2 2^(n-2)+ ... + b1 2^1 + b0 2^0
(remarquer le signe + pour le bit de poids fort)

---

Alors, dans ce cas :
0000 1001 1101 1000 -> 2520
1111 1001 1101 1000 ->63960 (= 2^16-1576)

Ayé, j'ai compris...

Code:

---

1 2 3 4

time = pointer[0xc1]&0x0f; if ((time & 0x08) != 0) /* If negate */ time |= 0xf0; /* 4 upper bit extend to sign */ *ACQ_POINTER++ = time;

---

ce traduit par :

Code:

---

1 2	si (time >= 8) time = time - 16

---

alors time est forcément négatif à cause du "&0x0f" de départ

maintenant, pourquoi ça??
va falloir retrouver un cahier des charges vieux de 20 ans,
c'est pas gagné...

Cette "traduction" rend le code encore plus incompréhensible qu'il l'était sans.

Les manipulations de bits illustrent bien l'extension de signe, ta soustraction non.