Discussion :

[axel20012]

Bonjour,

j'ai un problème : je veux un programme en Pascal qui convertit un nombre décimal vers le DCB (décimal codé en binaire) sur 4 bits. J'ai réfléchi mais je n'ai pas pu.

[Roland Chastain]

Bonjour !

Tu peux regarder cette discussion.

Sauf erreur de ma part, le plus grand nombre représentable avec 4 chiffres binaires est 15 (1111). La méthode de conversion consiste à rechercher les puissances de deux contenues dans le nombre.

[M.Dlb]

Tu peux jeter un oeil ici aussi:
http://fr.wikipedia.org/wiki/Binary_coded_decimal

Je trouve néanmoins ce codage extrêmement débile, car on ne stocke que 100 nombres dans 8 bits, alors qu'on peut en mettre "naturellement" 256, d'où une énorme perte de place.
Et ca ne facilite pas forcément les algorithmes et la lecture/écriture de données... Mais comme cette méthode est encore enseignée......

[Alcatîz]

Bonjour,

Pour décomposer un nombre entier en chiffres décimaux, il faut le diviser successivement par 10 et récupérer les restes successifs dans un octet. Forcément, les 4 bits de poids faible de cet octet contiendront le chiffre extrait.

S'il s'agit de conversion en packed BCD (2 chiffres par octet), il faut appliquer un décalage de 4 bits pour un chiffre sur deux (les puissances impaires de 10).

Exemple : la conversion de 94 en packed BCD (à généraliser pour des nombres supérieurs à 99 ) :

• Le résultat est mis à zéro ;
• Division de 94 par 10 : quotient = 9 et reste = 4 --> le reste est additionné au résultat ;
• Division du quotient (9) par 10 : quotient = 0 et reste = 9 --> le reste est décalé de 4 bits vers la gauche et additionné au résultat.

Il reste à transformer en pseudocode cette résolution faite sur papier puis à généraliser le principe dans une boucle. Des tests sur papier permettront de valider la solution ou d'en trouver une meilleure.
Pour terminer : on traduit le pseudocode en Pascal.

[Roland Chastain]

le reste est décalé de 4 bits vers la gauche et additionné au résultat

N'est-ce pas plutôt : le résultat est décalé de 4 bits et le reste est additionné au résultat ?

Autrement, voici une procédure qui peut aider à comprendre et à mettre en œuvre la solution expliquée par Alcatîz.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
{ Ecrire en chiffres binaires la valeur d'une variable de type LongInt. }
 
program test;
 
procedure WriteBinaryDigits(li: longInt);
var
  i: integer;
  s: string;
begin
  s := '0000';
  s := s + s;
  s := s + s;
  s := s + s;
 
  {$Define Version1}
  for i := 32 downTo 1 do
  begin
    {$IfDef Version1}
    if li mod 2 = 1 then s[i] := '1';
    li := li div 2;
    {$Else}
    if li and 1 = 1 then s[i] := '1';
    li := li shr 1;
    {$EndIf}
  end;
 
  for i := 0 to 3 do
  begin
    Write(Copy(s, 8 * i + 1, 8));
    if i < 3 then Write(' ');
  end;
end;
 
begin
  WriteBinaryDigits(255);
  ReadLn;
end.

00000000 00000000 00000000 11111111

[Alcatîz]

N'est-ce pas plutôt : le résultat est décalé de 4 bits et le reste est additionné au résultat ?

Non, puisque les digits sont déterminés de la droite vers la gauche : le premier digit trouvé est stocké dans les 4 bits de poids faible et le second dans les 4 bits de poids fort.

[Roland Chastain]

Non, puisque les digits sont déterminés de la droite vers la gauche : le premier digit trouvé est stocké dans les 4 bits de poids faible et le second dans les 4 bits de poids fort.

Merci Alcatîz. Je ne sais pas à quoi je pensais.

L'auteur de la discussion ne s'étant plus manifesté, je me permets de poster ce que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
65
66
program essaiDCB;
 
uses
  Crt;
 
procedure WriteLnBinaryDigits(l: longInt);
const
  s1 = '00000000000000000000000000000000';
var
  i: integer;
  s2: string;
begin
  s2 := s1;
  for i := 32 downto 1 do
  begin
    if l and 1 = 1 then s2[i] := '1';
    l := l shr 1;
  end;
  for i := 1 to 8 do
    Write(Copy(s2, 4*i-3, 4), ' ');
  WriteLn;
end;
 
function DCB(l: longInt; pckd: boolean): longInt;
var
  i: longInt; { résultat }
  r: longInt; { reste de la division }
  m: longInt; { plus grande valeur représentable }
  j: integer; { compteur }
  n: integer; { nombre de chiffres décimaux traités }
begin
  if pckd then
  begin
    n := 8;
    m := 99999999;
  end else
  begin
    n := 4;
    m := 9999;
  end;
  if l > m then l := m;
  i := 0;
  for j := 0 to n - 1 do begin
    r := l mod 10;
    l := l div 10;
    r := r shl ((32 div n) * j);
    i := i or r;
  end;
  DCB := i;
end;
 
var
  i: longInt;
 
begin
  ClrScr;
  Write('Veuillez saisir un nombre entier : ');
  ReadLn(i);
  WriteLn;
  WriteLnBinaryDigits(i);
  WriteLnBinaryDigits(DCB(i, false));
  WriteLnBinaryDigits(DCB(i, true));
  WriteLn;
  WriteLn('Appuyez sur une touche...');
  ReadKey;
end.

En suivant le lien donné plus haut par wormful_sickfoot j'ai appris comment fonctionnait un afficheur à 7 segments : ça ferait un beau sujet d'exercice. Quelqu'un du forum s'y est-il déjà essayé ?

Ce serait intéressant de refaire avec FlashPascal cette animation.