Algorithme de conversion BCD

[Résolu]
Signaler
Messages postés
13
Date d'inscription
dimanche 10 février 2008
Statut
Membre
Dernière intervention
10 octobre 2008
-
Messages postés
4202
Date d'inscription
samedi 16 octobre 2004
Statut
Modérateur
Dernière intervention
13 juin 2020
-
Bonjour tt le monde, j besoin d'un algorithme qui montre le fonctionnement de  l'instruction DAA, cette instruction se base sur la conversion BCD du nombre hexadécimale concerné comme expliqué ci-dessous :
Exemples : on veut faire l’addition en BCD de 73 + 88

On remarque que ni 1111 ni 1011 est un nombre BCD donc on va ajouter 6

au premier octet d’ou l’opération devient :

L’octet le plus haut :

d’ou les résultat 163

merci!

5 réponses

Messages postés
4202
Date d'inscription
samedi 16 octobre 2004
Statut
Modérateur
Dernière intervention
13 juin 2020
37
Type
  TBCD4  = array[0..1] of byte; // for Byte
  TBCD6  = array[0..2] of byte; // for Word
  TBCD10 = array[0..4] of byte; // for LongWord

function BCDToSTR(const BCD: TBCD4): string; overload;
begin
  SetLength(result, 3);
  result[1] := char((BCD[0] and $F) or $30);
  result[2] := char((BCD[1] shr 4) or $30);
  result[3] := char((BCD[1] and $F) or $30);
end;

function BCDToSTR(const BCD: TBCD6): string; overload;
begin
  SetLength(result, 5);
  result[1] := char((BCD[0] and $F) or $30);
  result[2] := char((BCD[1] shr 4) or $30);
  result[3] := char((BCD[1] and $F) or $30);
  result[4] := char((BCD[2] shr 4) or $30);
  result[5] := char((BCD[2] and $F) or $30);
end;

function BCDToSTR(const BCD: TBCD10): string; overload;
begin
  SetLength(result, 10);
  result[1] := char((BCD[0] shr 4) or $30);
  result[2] := char((BCD[0] and $F) or $30);
  result[3] := char((BCD[1] shr 4) or $30);
  result[4] := char((BCD[1] and $F) or $30);
  result[5] := char((BCD[2] shr 4) or $30);
  result[6] := char((BCD[2] and $F) or $30);
  result[7] := char((BCD[3] shr 4) or $30);
  result[8] := char((BCD[3] and $F) or $30);
  result[9] := char((BCD[4] shr 4) or $30);
  result[10]:= char((BCD[4] and $F) or $30);
end;

function StrCropZero(const S: string): string;
var C,I,L: integer;
begin
  result := S;
  C := 0;
  I := 1;
  L := Length(result);
  while (result[I] = #48) and (I < L) do
  begin
    inc(C);
    inc(I);
  end;
  if C > 0 then
    Delete(result, 1, C);
end;

function ByteToBCD(const Num: Byte): TBCD4;
begin
  result[1] :=  (Num mod 10) or
               ((Num div 10 mod 10) shl 4);
  result[0] :=   Num div 100 mod 10;
end;

function WordToBCD(const Num: Word): TBCD6;
begin
  result[2] :=  (Num mod 10) or
               ((Num div 10 mod 10) shl 4);
  result[1] :=  (Num div 100 mod 10) or
               ((Num div 1000 mod 10) shl 4);
  result[0] :=   Num div 10000 mod 10;
end;

function LongWordToBCD(const Num: LongWord): TBCD10;
begin
  result[4] :=  (Num mod 10) or
               ((Num div 10 mod 10) shl 4);
  result[3] :=  (Num div 100 mod 10) or
               ((Num div 1000 mod 10) shl 4);
  result[2] :=  (Num div 10000 mod 10) or
               ((Num div 100000 mod 10) shl 4);
  result[1] :=  (Num div 1000000 mod 10) or
               ((Num div 10000000 mod 10) shl 4);
  result[0] :=  (Num div 100000000 mod 10) or
               ((Num div 1000000000 mod 10) shl 4);
end;

function BCDToByte(const BCD: TBCD4): byte;
begin
  result :=    (BCD[1] and $F)
            + ((BCD[1] shr 4)*10)
            + ((BCD[0] and $F)*100);
end;

function BCDToWord(const BCD: TBCD6): Word;
begin
  result :=    (BCD[2] and $F)
            + ((BCD[2] shr 4) *10)
            + ((BCD[1] and $F)*100)
            + ((BCD[1] shr 4) *1000)
            + ((BCD[0] and $F)*10000);
end;

function BCDToLongWord(const BCD: TBCD10): LongWord;
begin
  result :=    (BCD[4] and $F)
            + ((BCD[4] shr 4) *10)
            + ((BCD[3] and $F)*100)
            + ((BCD[3] shr 4) *1000)
            + ((BCD[2] and $F)*10000)
            + ((BCD[2] shr 4) *100000)
            + ((BCD[1] and $F)*1000000)
            + ((BCD[1] shr 4) *10000000)
            + ((BCD[0] and $F)*100000000)
            + ((BCD[0] shr 4) *1000000000);
end;






<hr size="2" width="100%" />
Messages postés
4202
Date d'inscription
samedi 16 octobre 2004
Statut
Modérateur
Dernière intervention
13 juin 2020
37
BCDToSTR permet d'afficher le BCD dans un label par exemple.
il est vrai que je n'ai pas fait de fonction STRToBCD...
mais tu peu probablement en faire une facilement a partir de mon code. c'est même surrement la fonction la plus simple a faire ...

pour convertir les BCD utilise BCDTo* vers le format de ton choix.
inversement, pour convertir un truc, utilise les *ToBCD ...

exemple, si tu a un longword = a 5124567

tu fait :

MonBCD10 := LongWordToBCD(maVariable);

et pour l'afficher :

Label1.caption := StrCropZero(BCDToSTR(MonBCD10));

ou si tu recupere un BCD d'une source quelconque :

tu le place dans une variable type TBCD4, 6 ou 10 selon la taille désiré, avec move ou copymemory.
ou en transtypant directement si la source est compatible :

MonBCD := TBCD10( VariableCardinal ); // par exemple

<hr size="2" width="100%" />
Messages postés
4202
Date d'inscription
samedi 16 octobre 2004
Statut
Modérateur
Dernière intervention
13 juin 2020
37
Je viens de voir en cherchant un truc dans l'aide Delphi,
tu as une unité qui s'appel : FMTBcd.pas

qui permet de convertir les valeurs en BCD et inversement qui est apparement trés complete.

a telecharger ici, si tu ne l'as pas :

http://deefaze.ovh.org/FMTBcd.rar

<hr size="2" width="100%" />
Messages postés
13
Date d'inscription
dimanche 10 février 2008
Statut
Membre
Dernière intervention
10 octobre 2008

Bjr! merci d'avoir répondu à mon appelle, ton algo est très instructif (top génial), le problème c : où je dois insérer la donnée hexa que je veux la convertir en BCD  (j'ai pas pu trouver  le lien directe entre str et word, longword, byte!!type incompatible). MERCI!
Messages postés
13
Date d'inscription
dimanche 10 février 2008
Statut
Membre
Dernière intervention
10 octobre 2008

Merci!!! c'était formidable :)