« Code Gray » : différence entre les versions
mAucun résumé des modifications |
mAucun résumé des modifications |
||
Ligne 146 : | Ligne 146 : | ||
=== Exemple de code === | === Exemple de code === | ||
On va utilisera du code en "C".<syntaxhighlight lang="c"> | |||
typedef unsigned int uint; | |||
// This function converts an unsigned binary number to reflected binary Gray code. | |||
uint BinaryToGray(uint num) | |||
{ | |||
return num ^ (num >> 1); // The operator >> is shift right. The operator ^ is exclusive or. | |||
} | |||
// This function converts a reflected binary Gray code number to a binary number. | |||
uint GrayToBinary(uint num) | |||
{ | |||
uint mask = num; | |||
while (mask) { // Each Gray code bit is exclusive-ored with all more significant bits. | |||
mask >>= 1; | |||
num ^= mask; | |||
} | |||
return num; | |||
} | |||
// A more efficient version for Gray codes 32 bits or fewer through the use of SWAR (SIMD within a register) techniques. | |||
// It implements a parallel prefix XOR function. The assignment statements can be in any order. | |||
// | |||
// This function can be adapted for longer Gray codes by adding steps. | |||
uint GrayToBinary32(uint num) | |||
{ | |||
num ^= num >> 16; | |||
num ^= num >> 8; | |||
num ^= num >> 4; | |||
num ^= num >> 2; | |||
num ^= num >> 1; | |||
return num; | |||
} | |||
</syntaxhighlight> |
Version du 21 mars 2025 à 21:10
La théorie
Le code Gray ou code binaire réfléchi est une façon de coder les nombres entiers en binaire en faisant en sorte que, d'un nombre consécutif à un autre il n'y ai jamais qu'un seul bit modifié.
Nombre | Hexa | Binaire | Code Gray |
---|---|---|---|
0
|
0
|
0000
|
0000
|
1
|
1
|
0001
|
0001
|
2
|
2
|
0010
|
0011
|
3
|
3
|
0011
|
0010
|
4
|
4
|
0100
|
0110
|
5
|
5
|
0101
|
0111
|
6
|
6
|
0110
|
0101
|
7
|
7
|
0111
|
0100
|
8
|
8
|
1000
|
1100
|
9
|
9
|
1001
|
1101
|
10
|
A
|
1010
|
1111
|
11
|
B
|
1011
|
1110
|
12
|
C
|
1100
|
1010
|
13
|
D
|
1101
|
1011
|
14
|
E
|
1110
|
1001
|
15
|
F
|
1111
|
1000
|
Quel est l'intérêt d'un tel code me direz vous ?
Cela sert a faire des compteurs numériques de façon mécaniques par exemple. Imaginons que l'on ai un signal binaire qui s'excrément au fur et a mesure d'un process quelconque.
Si les 4 lignes (A,B,D et D) sont parfaitement synchrones et qu'on lise le signe parfaitement au milieu de chaque état cela nous donne:
Jusque là tout va bien. Imaginons que les lignes A,B,C et B ne soient pas bien en phase.
On voit bien que le 7 qui doit être 0100
est 11xx
avec x
où sait pas bien si c'est un 0 ou un 1.
Comment pourrait on faire un système de décompte binaire qui sont insensible a ces problèmes? Avec le code binaire réfléchi ou code Gray!
Si on change le signal binaire par un signal en code gray:
On lit la valeur au début:
Ok on commence à zéro. La "ruse" est qu'il suffit d'attendre que l'un des bits changes de valeur, sachant que jamais deux ne peuvent changer en même temps.
Premier changement c'est la ligne D et on lit 0001
qui en code gray donne 1 . Après 0 on a bien un 1. Jusqu'ici tout va bien!
On attends le prochain changement :
La ligne C a changé et on a donc 0011 qui code un 2 en gray. Apres 1 on a bien 2.... on continue:
Et ca marche!
Mise en oeuvre
On peut réaliser une roue codeuse en code GRAY:
Si on la lit avec 3 photodiodes on a un encodeur d'angle précis à 45°. Et c'est la même méthode, on attends qu'un bit change pour lire la nouvelle valeur.
J'ai même trouvé:
J'ai compté 10 bits donc mieux que 0,35° de précision.
Exemple de code
On va utilisera du code en "C".
typedef unsigned int uint;
// This function converts an unsigned binary number to reflected binary Gray code.
uint BinaryToGray(uint num)
{
return num ^ (num >> 1); // The operator >> is shift right. The operator ^ is exclusive or.
}
// This function converts a reflected binary Gray code number to a binary number.
uint GrayToBinary(uint num)
{
uint mask = num;
while (mask) { // Each Gray code bit is exclusive-ored with all more significant bits.
mask >>= 1;
num ^= mask;
}
return num;
}
// A more efficient version for Gray codes 32 bits or fewer through the use of SWAR (SIMD within a register) techniques.
// It implements a parallel prefix XOR function. The assignment statements can be in any order.
//
// This function can be adapted for longer Gray codes by adding steps.
uint GrayToBinary32(uint num)
{
num ^= num >> 16;
num ^= num >> 8;
num ^= num >> 4;
num ^= num >> 2;
num ^= num >> 1;
return num;
}