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

function test(aHexCode: string): string;
var
  HexBH: string;
  DecBH, myPos: integer;
begin
  myPos:=Length(aHexCode)-3;
  HexBH := copy(aHexCode, myPos, 2);        // meine $11 rausholen
  DecBH := StrToInt('$'+HexBH) -$17;        // meine $11 mit $17 subtrahieren
  HexBH := format('%x', [DecBh]);           // meine $11 - $11 = FA in string wandeln wobei hier eigentlich FFFFFFFA rauskommt

  if Length(HexBH) > 2 then                 // wenn die Länge von HexBH größer als 2 ist
  Delete(HexBH, 1, Length(HexBH)-2);        // wird alles, bis auf die letzen 2 Zeichen gelöscht (also hier alles bis auf FA)
  Delete(aHexCode, myPos, 2);               // die stelle wo vorhin meine $11 waren löschen
  insert(HexBH, aHexCode, myPos);           // meine $FA da einfügen wo vorhin $11 war

  result := aHexCode;
end;                    

1:
2:
3:
4:

type
  TMyArray = array[0..Laenge-1] of Byte;
var
  A: TMyArray;                    

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

type
  TMyArray = array of Byte;
var
  A: TMyArray;

procedure InitArray(const ALen: Integer);
begin
  SetLength(A,ALen);
end;

procedure DoneArray;
begin
  Finalize(A);
end;                    

1:

A[0] := 100;                    

1:
2:
3:
4:
5:

s:=''; 
for i:=0 to high(key) do
begin
  s:=s+IntToHex(Key[i],2);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

function ArrayToKey(const A: array[0..3] of Byte): Cardinal; // 4 Byte
var
  I: Integer;  
begin
  Result := 0;
  for I := 0 to 3 do
  begin
    Result := (Result shl 8) or A[I];
  end;
end;                    

1:
2:
3:
4:

  A := A+AByte ; //4.Stelle
  A := A+($100*AByte); //3.Stelle
  A := A+($10000AByte); //2.Stelle
  A := A+($1000000*AByte); //1.Stelle                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

var
  a: array of byte;

implementation

{$R *.dfm}

...

var
  tempStr, Hex: string;
  i, len: integer;
begin
  Hex:='EE01FF44';

  Len := Length(Hex) div 2;
  SetLength(a, Len+1);
  for i := 1 to Len do
  begin
    tempStr:='$'+copy(Hex, i*2-1, 2);
    a[i]:=byte(StrToInt(tempStr));
  end;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  c, i: integer;
  Hex: string;
begin
  for i:=low(a) to high(a) do
  begin
    c:= (c shl 8) or a[i];
  end;
  hex:=IntToHex(c, 8);                    

1:

c:= (c shl 8) or a[i];                    

1:
2:
3:

SHL
Logische Linksverschiebung.
Beide Ausdrücke müssen absolute, direkte Werte sein. Das Ergebnis ist ebenfalls ein absoluter direkter Wert.                    

1:
2:
3:

OR
Bitweises OR.
Beide Ausdrücke müssen absolute, direkte Werte sein. Das Ergebnis ist ebenfalls ein absoluter direkter Wert.                    

1:
2:
3:
4:
5:

 
A := 1;       // A := 0000 0000 0000 0001b = 1
B := A shl 1; // B := 0000 0000 0000 0010b = 2
C := A shl 2; // C := 0000 0000 0000 0100b = 3
D := A shl 8; // D := 0000 0001 0000 0000b = 256                    

1:
2:
3:
4:

A := 2;       // A := 0000 0000 0000 0010b = $002
B := A shl 8; // B := 0000 0010 0000 0000b = $200
C := B or $34;// C := 0000 0010 0011 0100b = $234
D := B + $34; // D := 0000 0010 0011 0100b = $234                    

1:

StrToInt('$'+HexString);                    

1:

IntToHex(Zahl,8);                    

1:
2:
3:
4:
5:
6:
7:

A := 1;       // A := 0000 0000 0000 0001b = 1
B := A shl 1; // B := 0000 0000 0000 0010b = 2
C := A shl 2; // C := 0000 0000 0000 0100b = 3  -> dann müsste das 4 sein oder?
D := A shl 8; // D := 0000 0001 0000 0000b = 256

// mein zusatz
E := A shl 4  // müsste dann 16 sein oder?                    

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:

var
  a: array of byte;
  Dec, Len, j: integer;
  HexBH: string;

...

hex:='0001FA11';

Len := Length(Hex) div 2;
SetLength(a, Len+1);

// Hex in array übertragen
for j:=1 to Len do
begin
  HexBH := '$'+copy(Hex, j*2-1, 2);
  a[j] := byte(StrToInt(HexBH));
end;

// Rechenvorgang in 2er gruppe
a[3] := a[3] + $07;                                                     
                                                                                
// Array in integer umwandeln
for j:= low(a) to high(a) do
begin
  dec := (dec shl 8) or a[j];
end;

// und wieder in Hex umwandeln
hex:=IntToHex(Dec, 2);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

/ Rechenvorgang in 2er gruppe
a[3] := a[3] + $07;                                                     
                                                                                
// Array in integer umwandeln
for j:= low(a) to high(a) do
begin
  dec := (dec shl 8) or a[j];
end;

// und wieder in Hex umwandeln
hex:=IntToHex(Dec, 2);                    

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

var
  Z: Integer;
  hex: String;
// Zweiergruppe in Zahl umwandeln

// und dann :
ResultString := a[0]+a[1]+a[2]+a[3]...
Z:=StrToInt('$'+a[3]);                                                     
                                                                                
// Dazuzählen
Z := Z + DeineZahl;
if Z > 255 then Z := Z - 256;

// und wieder in Hex umwandeln
hex:=IntToHex(Z, 2);
a[3]:=hex;                    

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

var
  Hex, Hex2: string;
  z: integer;
begin
  Hex:='00011111';
  z:=StrToInt('$' + Hex[5] + Hex[6]);

  z := z - $17;
  if z > 255 then z:= z - 256;
  if z < 0 then z:= z + 256;

  Hex2:=IntToHex(z, 2);

  Hex[5]:=Hex2[1];
  Hex[6]:=Hex2[2];
end;