convertion binaire en hexadecimal "" bintohex ""

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour à toutes et tous, j'essaie de trouver des infos pour réaliser une conversion d'un chiffre binaire en hexadécimal,
objectif de mon petit programme: 4 x edit.text un pour donnée la valeur de départ un second pour recevoir la multiplication de ma valeur par 2048, le troisième pour recevoir ma conversion en binaire et le quatrième pour recevoir ma conversion en hexadécimal, je réussi a convertir en binaire ma valeur de départ mais sans virgule mais en valeur ronde ça fonctionne, je n'arrive pas du tout a convertir en hexadécimal déjà dans un premier temps et après je vais devoir retourner les octets par poids

j'ai déjà fait cela qui mériterait une grosse amélioration bien sur, pouvez vous m'aider svp merci
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 procedure TForm1.SpeedButton2Click(Sender: TObject); var s,t: single; b : integer; begin s:= strtofloat (edit3.Text); t:=(s * 2048); edit5.Text:=floattostr(t) ; // ça fonctionne reçois avec virgule //// peut être un round ? ///////////////////////////////////////////// b:= strtoint (edit5.text); edit6.Text:= DeciToBin (b); // ça fonctionne mai pas avec virgule puffff ? ////////////////////////////////////////////// // convertir edit6 en exadecimal dans edit7 // trouver dechex ou dec2hex Edit7.Text := StrToHexStr (Edit6.Text); //////////////////////////////////////// //retourné hexadécimal par poids ? rien trouvé sur les forums ? end;

06/05/2025, 09h12
SergioMaster
Bonjour,

Citation:

Envoyé par alll1

rien trouvé sur les forums ?

pas beaucoup cherché, à mon avis, car j'ai déjà vu plusieurs fois passer cette question (et même l'ai-je peut-être posée moi-même).

Sans savoir quelle version de Delphi je me demande si, déjà, la fonction format ne suffirait pas.
Code:

1 2 3 // ligne 6 s:= strtofloatdef (edit3.Text,0); // on ne sait jamais ce qui est saisi par l'utilisateur
maintenant, pourquoi un float ?
Code:

1 2 3 // ligne 8 edit5.Text:=t.tostring; // si delphi nouvelle version // sinon edit5.text:=format('%3.5f',[t]);
pour ce qui est de l'hexadécimal, il existe la version historique IntToHex
06/05/2025, 09h27
ShaiLeTroll

A lire Représentation binaire d'un entier.

un nombre floattant en binaire ?
c'est IEEE 754 qu'il faut étudier, à mon avis vous confondez la conversion Entier avec sa représentation binaire 0010010001 ... et la conversion d'un Double qui a une structure plus subtile.

Une possibilité

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
var
  s1: single;
  w1: Pword;
 
begin
  Memo1.Lines.Clear;
  w1 := @s1;
  s1 := 10.1;
  Memo1.Lines.Add(intToHex(w1^,4));
  s1 := 0.1;
  Memo1.Lines.Add(intToHex(w1^,4));
end;

06/05/2025, 12h08
alll1

strtofloat
SergioMaster Bonjour,
pardon pour mes question mais je ne suis pas a votre niveau de programmation juste amateur ,
sur les forum non je n'ai pas trouvé car j'ai chercher strtofloat pas strtofloatdef ?
pour la fonction 'StrToFloat' ai tenté de construire vers une Chaine à virgule ,
je vais déjà essayer avec cet fonction pour voir
merci pour infos je vous tiendrais au courant
Alain

pas beaucoup cherché, à mon avis, car j'ai déjà vu plusieurs fois passer cette question (et même l'ai-je peut-être posée moi-même).

Sans savoir quelle version de Delphi je me demande si, déjà, la fonction format ne suffirait pas.
Code:

1 2 3 // ligne 6 s:= strtofloatdef (edit3.Text,0); // on ne sait jamais ce qui est saisi par l'utilisateur
maintenant, pourquoi un float ?
Code:

1 2 3 // ligne 8 edit5.Text:=t.tostring; // si delphi nouvelle version // sinon edit5.text:=format('%3.5f',[t]);
pour ce qui est de l'hexadécimal, il existe la version historique IntToHex[/QUOTE]
06/05/2025, 12h39
alll1

nombre flotant en binaire

bonjour ShaiLeTroll,
oui pour la norm ieee754

alors oui avec un nombre entier la conversion en binaire fonctionne effectivement
il faudrait que je trouve le moyen d'arrondir mon edit5.text en supérieur ou inferieur mais cela aurait pour conséquence de décalé ma fréquence de travail en utilisation de mon eeprom

comment expliquer pourquoi:

j'ai un fichier en .hex pour programmer un circuit intégré de type eeprom que j'injecte dans ce CI
il contient une information que je doit modifier
cet infos correspond a une fréquence " 410 mhz actuellement
je doit donc changer cet fréquence dans mon fichier
ma nouvelle fréquence est par exemple " 433.800 mhz
je doit convertir en binaire rajouté un bits et le convertir en hexadécimal pour le changer dans mon fichier
car vous l'avez compris les 800 corresponde a 800 khz presque 1 mhz

voila pourquoi j'essais avec cet fonction a virgule

convertir ma fréquence en multipliant par 2048 ex: 432 x 2048 = 884*736 ///// si 432.800 = 67*174,4 , il me faudrait tronquer cet valeur en l'arrondissant a 67 174
convertir en binaire qui donne = 1101 1000 0000 0000 0000
mon binaire je doit lui rajouté 1 bits = 1101 1000 0000 0000 0001
convertir le binaire en hexa = 0x 0D 80 01
inversé les poids 01 80 0D
c'est ce résultat que je doit écrire dans mon fichier

voila
et vous avez raison bien sur d'être étonné sur ma conversion a virgule
cordialement

Citation:

Envoyé par ShaiLeTroll

A lire Représentation binaire d'un entier.

un nombre floattant en binaire ?
c'est IEEE 754 qu'il faut étudier, à mon avis vous confondez la conversion Entier avec sa représentation binaire 0010010001 ... et la conversion d'un Double qui a une structure plus subtile.
06/05/2025, 12h39
foetus

Pour la conversion binaire vers hexadécimal il faut prendre 4 bits par 4 bits et ensuite c'est simple :mrgreen: : 0000=0x0, 0001=0x1, 0010=0x2, 0011=0x3, 0100=0x4, 0101=0x5, 0110=0x6, 0111=0x7, 1000=0x8, 1001=0x9, 1010=0xA, 1011=0xB, 1100=0XC, 1101=0XD, 1110=0XE, 1111=0XF
C'est pour cela d'ailleurs qu'avec 1 octet, la notation hexadécimale est plus parlante que le binaire (tu n'as que 2 chiffres)

La multiplication 432 x 2048 permet de rajouter en binaire 11 zéros à droite (tu décales 432 de 11 par la droite) parce que 2048 = 2^11 :zoubi:

bonjour ALWEBER,

je vais regarder ce que donne cet conversion je n'ai pas du tout chercher dans se sens
merci
cordialement
Citation:
Envoyé par ALWEBER
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 var s1: single; w1: Pword; begin Memo1.Lines.Clear; w1 := @s1; s1 := 10.1; Memo1.Lines.Add(intToHex(w1^,4)); s1 := 0.1; Memo1.Lines.Add(intToHex(w1^,4)); end;

06/05/2025, 14h13
ShaiLeTroll

La conversion en binaire en inutile

+1 en Binaire, en Décimal ou en Hexa, ça c'est la même chose soit +1

Convertir 433.800 en 434 c'est un arrondi, suffit de faire un Round comme évoqué dans votre premier message, c'est la bonne approche
Cependant, vu la multiplication par 2048, il y a peut-être une précision meilleur à obtenir.

Sinon, cela semble du bricolage tout ça, quelle la vraie règle de stockage de la fréquence dans le fichier
Autant donner un lien vers la spécification d'origine
3 octets ? vraiment ?! Curieux on aurait dit 4 car c'est plus standard

Je vais tout calé sur 4 octets car en Delphi c'est 4 octets, faudra éclaircir pourquoi cela n'en gère que 3 dans votre fichier

Partons sur 432,000 * 2048 = 884 736 = 00 0D 80 00 -> BigEndian 00 80 0D 00
Partons sur 432,800 * 2048 = 886 374,4 = 00 0D 86 66 -> BigEndian 66 86 0D 00
Donc cette histoire de +1 c'est très étrange puisqu'il manque le 1 * 2048 (0x800)

Je ne sais pas d'ou viens le "67*174,4"
Code:

1 2 3 4 5 6 7 8 9 10 11 12 procedure TForm1.SpeedButton2Click(Sender: TObject); var FreqD: Double; FreqC: Cardinal; FreqS: string; begin FreqD := StrtToFloat (edit3.Text) * 2048; edit5.Text := FloatToStr(FreqD); FreqC := Round(FreqD); edit6.Text:= IntToHex(FreqC); edit7.Text:= IntToHex(SwapCardinal(FreqC))); end;
SwapCardinal est une reprise de SwapLongword pour la conversion Little Endian -> Big Endian
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 function SwapCardinal(Value: Cardinal): Cardinal; {$IFDEF PUREPASCAL} type TMapCardinal = array[0..3] of Byte; begin TMapCardinal(Result)[0] := TMapCardinal(Value)[3]; TMapCardinal(Result)[1] := TMapCardinal(Value)[2]; TMapCardinal(Result)[2] := TMapCardinal(Value)[1]; TMapCardinal(Result)[3] := TMapCardinal(Value)[0]; {$ELSE} asm BSWAP EAX {$ENDIF} end;
ou encore
Code:

1 2 3 4 function SwapCardinal(const AValue: Cardinal): Cardinal; begin Result := ((AValue and $FF) shl 24) or ((AValue and $FF00) shl 8) or ((AValue and $FF0000) shr 8) or ((AValue and $FF000000) shr 24); end;

UN autre exemple

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
65
66
67
68
69
70
71
72
73
74
75
76
77
 
unit ex01a;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
  System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Math;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
Function IntToBin(IG1: LongWord): string;
var
  st1: string;
  i1: integer;
begin
  st1 := '';
  for i1 := 0 to 31 do
  begin
    if (Round(Power(2, i1)) and IG1) > 0 then
      st1 := '1' + st1
    else
      st1 := '0' + st1;
  end;
  result := copy(st1, 1, 1) + ' ' + copy(st1, 2, 8) + ' ' + copy(st1, 10, 23);
end;
 
procedure TForm1.Button1Click(Sender: TObject);
var
  s1: single;
  i1: integer;
  v1: ^integer;
 
  procedure visu ;
  begin
    Memo1.Lines.Add(format('%2.f', [s1])+'|'+floatToStr(s1));
    Memo1.Lines.Add(IntToHex(v1^,8) );
    Memo1.Lines.Add(IntToBin(v1^) );
  end;
 
begin
  Memo1.Lines.Clear;
  s1 := 0;
  v1 := @s1;
  s1 := 100 ; visu ;
  s1 := 99 ; visu ;
 
end;
{
Un nombre Single sur 4 octets (32 bits) est décomposé en trois champs
1 8 23
s e f
La valeur v du nombre est donnée par la formule :
Si 0 < e < 255, alors v = (1)^s * 2^(e127) * (1.f)
Si e = 0 et f <> 0, alors v = (1)^s * 2^(126) * (0.f)
Si e = 0 et f = 0, alors v = (1)^s * 0
Si e = 255 et f = 0, alors v = (1)^s * Inf
Si e = 255 et f <> 0, alors v est un NaN
}
end.

mon code actuel

bonsoir ShaiLeTroll,
voila les dernière modif que ai réalisé enfin un résultat

mon code source
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 procedure TForm1.SpeedButton2Click(Sender: TObject); var s,t: single; b : integer; BinaryNumber: string; begin s:= strtofloat (edit3.Text); t:=(s * 2048); edit5.Text:=floattostr(t) ; // sa marche ou edit5.Text:= format ('%.5f', [t] ); idem pareille edit5.Text:= inttostr(trunc(t)); /// ici je trunc directement la valut et le résultat et beaucoup plus proche b:= strtoint (edit5.text); edit6.Text:= DeciToBin (b); ////////////////// sa marche maintenant avec virgule mais Tucker ? BinaryNumber := edit6.Text; edit7.Text := IntToHex(StrToInt('$' + IntToHex(StrToInt64def(edit5.Text, 2), 0)), 0); end;
actuel résultat := 432 = 884736 = 11011000000000000000 = D8000
433,8 = 888422= 11011000111001100110 = D8E66

la sa marche avec virgule et plus prêt de la bonne fréquence
reste a trouvé comment retournée mes poids hexadécimal
0x0D8000 = 00 80 D0

pour le 0 du poids c'est 0x0 ------ 0D 80 00

reste a trouver comment retourné l'hexadécimal ?
alors oui j'ai beaucoup navigué sur ce site dans diffèrent mode pour trouvé mes idées de codification et j'ai vu ce type de codage également en html, javascript etc.... il me semble mais a mon niveau sa m'as paru bizarroïde
maintenant mes conversion fonctionne et donne enfin un résultat concordant ou correspondant a mon besoin
cordialement
Citation:
Je vais tout calé sur 4 octets car en Delphi c'est 4 octets, faudra éclaircir pourquoi cela n'en gère que 3 dans votre fichier

Partons sur 432,000 * 2048 = 884 736 = 00 0D 80 00 -> BigEndian 00 80 0D 00
Partons sur 432,800 * 2048 = 886 374,4 = 00 0D 86 66 -> BigEndian 66 86 0D 00
Donc cette histoire de +1 c'est très étrange puisqu'il manque le 1 * 2048 (0x800)

Je ne sais pas d'ou viens le "67*174,4"
Code:

1 2 3 4 5 6 7 8 9 10 11 12 procedure TForm1.SpeedButton2Click(Sender: TObject); var FreqD: Double; FreqC: Cardinal; FreqS: string; begin FreqD := StrtToFloat (edit3.Text) * 2048; edit5.Text := FloatToStr(FreqD); FreqC := Round(FreqD); edit6.Text:= IntToHex(FreqC); edit7.Text:= IntToHex(SwapCardinal(FreqC))); end;
SwapCardinal est une reprise de SwapLongword pour la conversion Little Endian -> Big Endian
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 function SwapCardinal(Value: Cardinal): Cardinal; {$IFDEF PUREPASCAL} type TMapCardinal = array[0..3] of Byte; begin TMapCardinal(Result)[0] := TMapCardinal(Value)[3]; TMapCardinal(Result)[1] := TMapCardinal(Value)[2]; TMapCardinal(Result)[2] := TMapCardinal(Value)[1]; TMapCardinal(Result)[3] := TMapCardinal(Value)[0]; {$ELSE} asm BSWAP EAX {$ENDIF} end;
ou encore
Code:

1 2 3 4 function SwapCardinal(const AValue: Cardinal): Cardinal; begin Result := ((AValue and $FF) shl 24) or ((AValue and $FF00) shl 8) or ((AValue and $FF0000) shr 8) or ((AValue and $FF000000) shr 24); end;

06/05/2025, 18h05
ALWEBER

Citation:

Envoyé par alll1

reste a trouver comment retourner mes poids hexadécimal

regarde l'exemple que je t'ai envoyé qui fonctionne et 32bits et qui est aisément traduisible en 64bits

Citation:

Envoyé par foetus

Pour la conversion binaire vers hexadécimal il faut prendre 4 bits par 4 bits et ensuite c'est simple :mrgreen: : 0000=0x0, 0001=0x1, 0010=0x2, 0011=0x3, 0100=0x4, 0101=0x5, 0110=0x6, 0111=0x7, 1000=0x8, 1001=0x9, 1010=0xA, 1011=0xB, 1100=0XC, 1101=0XD, 1110=0XE, 1111=0XF
C'est pour cela d'ailleurs qu'avec 1 octet, la notation hexadécimale est plus parlante que le binaire (tu n'as que 2 chiffres)

Pour illustrer ce propos même si le passage en binaire est superflu dans l'histoire puis c'est une conversion Double -> Cardinal -> Hexa Big Endian qu'il faudrait plus détaillé (le pourquoi du 2048)

Inspiré du sujet Ouvrir un fichier dans son code binaire et de SwapCardinal pour montrer en code ce que évoque foetus.
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 function CardinalToBin(Value: Cardinal): string; type TMapCardinal = array[0..3] of Byte; const BitStringForHalfByte: array[0..15] of String = ('0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111' ); var PResult: PChar; I, HalfSize: Integer; B, BH, BL: Byte; begin SetLength(Result, 32); PResult := @Result[1]; HalfSize := 4 * SizeOf(Char); for I := 3 downto 0 do begin B := TMapCardinal(Value)[I]; BH := B shr 4; CopyMemory(PResult, @BitStringForHalfByte[BH][1], HalfSize); Inc(PResult, 4); BL := B and $0F; CopyMemory(PResult, @BitStringForHalfByte[BL][1], HalfSize); Inc(PResult, 4); end; end;

06/05/2025, 18h13
alll1

bonsoir foetus,

oui effectivement c'est par 4 bits
j'ai réussi a codé une conversion binaire hexadécimal qui fait le job
apres avoir tronquer la valeur de mon edit5.text

Code:

edit7.Text := IntToHex(StrToInt('$' + IntToHex(StrToInt64def(edit5.Text, 2), 0)), 0);

je retrouve bien en resultat

432 = 884736 = 11011000000000000000 = D8000
433,8 = 888422= 11011000111001100110 = D8E66

la sa marche avec virgule et plus prêt de la bonne fréquence

reste a trouvé comment retournée mes poids hexadécimal
0x0D8000 = 00 80 D0

pour le 0 du poids c'est 0x0 ------ 0D 80 00

reste a trouver comment retourné l'hexadécimal ?
c'est quoi mrgreen ? une fonction

connaissez vous une fonction déjà codé qui saurait ajouté 0x0 a D8000 = 0x0D8000 et séparé les poids et retourné les 3 poids en 0D 80 00 ?

cordialement

Citation:

Pour la conversion binaire vers hexadécimal il faut prendre 4 bits par 4 bits et ensuite c'est simple :mrgreen: : 0000=0x0, 0001=0x1, 0010=0x2, 0011=0x3, 0100=0x4, 0101=0x5, 0110=0x6, 0111=0x7, 1000=0x8, 1001=0x9, 1010=0xA, 1011=0xB, 1100=0XC, 1101=0XD, 1110=0XE, 1111=0XF
C'est pour cela d'ailleurs qu'avec 1 octet, la notation hexadécimale est plus parlante que le binaire (tu n'as que 2 chiffres)

La multiplication 432 x 2048 permet de rajouter en binaire 11 zéros à droite (tu décales 432 de 11 par la droite) parce que 2048 = 2^11 :zoubi:
06/05/2025, 18h16
ShaiLeTroll
Citation:

Envoyé par alll1

actuel résultat := 432 = 884736 = 11011000000000000000 = D8000
433,8 = 888422= 11011000111001100110 = D8E66

la sa marche avec virgule et plus prêt de la bonne fréquence
reste a trouvé comment retournée mes poids hexadécimal
0x0D8000 = 00 80 D0

pour le 0 du poids c'est 0x0 ------ 0D 80 00

C'est sur pour 3 octets seulement dans le fichier ? c'est très curieux que cela ne soit pas 4 !

C'est la même chose que SwapCardinal, au lieu de travail sur les Byte de Cardinal, suffit de bosser sur les Couple de Char de la chaine

Si c'est 3, suffit d'inverser les bouts, faudrait vous documenter sur la notion de Little Endian et Big Endian.

Citation:

Envoyé par alll1

connaissez vous une fonction déjà codé qui saurait ajouté 0x0 a D8000 = 0x0D8000 et séparé les poids et retourné les 3 poids en 0D 80 00 ?

C'est vraiment une question ?
C'est l'exemple même : IntToHex (Delphi)
Code:

1 2 3 4 5 6 7 BL := '0D8000'; BB := '0x00 00 00'; // -> va devenir '0x00 80 D0'; BB[2+1] := BL[5]; BB[2+2] := BL[6]; BB[2+3+3+1] := BL[1]; BB[2+3+3+2] := BL[2];
06/05/2025, 18h19
ShaiLeTroll

Citation:

Envoyé par alll1

c'est quoi mrgreen ? une fonction

:ptdr::ptdr::ptdr::ptdr:

Euh, c'était une proposition d'algorithme que j'ai illustré dans CardinalToBin

Nous avons un gros problème d'échange avec vous !
Ce sujet devient incompréhensible

Et clairement, il manque le B-A-BA

Code:

1
2
3
4
5
6
 
begin
  ShowMessage('432 = ' + IntToHexEx(Round(432 * 2048), 6, ' ', '0x') +
    sLineBreak + '432,8 = ' + IntToHexEx(Round(432.8 * 2048), 6, ' ', '0x') +
    sLineBreak + '433,8 = ' + IntToHexEx(Round(433.8 * 2048), 6, ' ', '0x'));
end;

Code:

1
2
3
4
 
432 = 0x0D 80 00
432,8 = 0x0D 86 66
433,8 = 0x0D 8E 66

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
 
function IntToHexEx(Value: Integer; Digits: Integer; Space: string = ''; Prefix: string = ''): string;
var
  Hex: string;
  I, K: Integer;
  PResult, PHex: PChar;
begin
  if Space <> '' then
  begin
    if Odd(Digits) then
      Inc(Digits);
 
    Hex := IntToHex(Value, Digits);
 
    K := Digits div 2;
    SetLength(Result, Digits + K - 1);
    PResult := @Result[1];
    PHex := @Hex[1];
 
    for I := 1 to K do
    begin
      PResult^ := PHex^;
      Inc(PResult);
      Inc(PHex);
      PResult^ := PHex^;
      Inc(PResult);
      Inc(PHex);
 
      PResult^ := Space[1];
      Inc(PResult);
    end;
  end
  else
    Result := IntToHex(Value, Digits);
 
  Result := Prefix + Result;
end;

06/05/2025, 19h41
alll1

bonsoir ShaiLeTroll,

ok pour la proposition d'illustration
désoler je n'avait pas compris
hélas oui incompréhensible pour moi aussi comme je vous l'ai déjà dit je ne suis pas programmeur juste un ouvrier qui se fait quelque petit prog avec Delphi 7 et je n'ai aucune formation dans se domaine non plus
avec les réponse sophistiquer ai beaucoup de mal a vous suivre car non commenté je suppose les formules que vous me proposé dans vos réponses
je travail depuis mes 14 ans aujourd'hui a 63 ans ai beaucoup de mal évidement je n'ai pas le B-A-ba en programmation

cordialement

;12081401]:ptdr::ptdr::ptdr::ptdr:

Euh, c'était une proposition d'algorithme que j'ai illustré dans CardinalToBin

Nous avons un gros problème d'échange avec vous !
Ce sujet devient incompréhensible

Et clairement, il manque le B-A-BA[/QUOTE]
06/05/2025, 19h56
alll1
bonsoir ShaiLeTroll,

oui oui c'est sur 3 octets
voici un extrait du fichier .hex que je doit corigé

:020000040000FA
:10100000F209F009D60AD50ACD08D20800FF9421CA
:10101000CD900D0C00FFFFFFFFFFFFFFFFFFFFFF65
:1010200035200000008E2001BB00000003003DB20F
:10103000CA5800000000000000000000000000008E
:1010400000000000000000000000000000000000A0
:10105000008E268E2101FFFFFFFFFFFFFFFFFFFF36

en rouge le code hexa a changé et son checksum en fin de ligne

intéressant que sont les BL et BB ?

si je créer une fonction avec comment Pui-je reprendre le texte de mon résultat si je lui dit BL := '0D8000';

ok je vais voir ce type de document Little Endian et Big Endian sa peut etre interessant

cordialement

;12081400]C'est sur pour 3 octets seulement dans le fichier ? c'est très curieux que cela ne soit pas 4 !

C'est la même chose que SwapCardinal, au lieu de travail sur les Byte de Cardinal, suffit de bosser sur les Couple de Char de la chaine

Si c'est 3, suffit d'inverser les bouts, faudrait vous documenter sur la notion de Little Endian et Big Endian.

C'est vraiment une question ?
C'est l'exemple même : IntToHex (Delphi)
Code:

1 2 3 4 5 6 7 BL := '0D8000'; BB := '0x00 00 00'; // -> va devenir '0x00 80 D0'; BB[2+1] := BL[5]; BB[2+2] := BL[6]; BB[2+3+3+1] := BL[1]; BB[2+3+3+2] := BL[2];
[/QUOTE]

Voir 40 message(s) de cette discussion en une page