Bitpacked Record Bit-Abfrage

[HobbyProgrammer]

Hallo zusammen,

ich habe hier ein Problem bei dem ich mit meinem Latein an Ende bin.
Ich schreibe gerade an einer Emulation einer Zilog Z180 MPU. Der Befehlssatz funktioniert schon prima und ich kann auch schon Progamme darauf laufen lassen.
Das ganze soll später soweit funktionieren das ein CP/M drauf läuft. Die zu emulierende Hardware existiert in echt, habe ich vor ca. 15Jahren selbst designt und zusammengelötet.
Bei der emulation der OnChip Componenten gibt es aber nun ein Problem:

Ich habe folgendes Record:

Code: Alles auswählen

TioSTAT0 = bitpacked record  // ASCI-Channel 0 Status
            case byte of
                0: (STAT0: byte);       // 8Bit Register Data
                1: (bitTIE: boolean;    // Transmit Interrupt Enable
                    bitTDRE: boolean;   // Transmit Data Register Empty
                    bitDCD0: boolean;   // Data Carrier Detect
                    bitRIE: boolean;    // Receive Interrupt Enable
                    bitFE: boolean;     // Framing Error
                    bitPE: boolean;     // Parity Error
                    bitOVRN: boolean;   // Overrun Error
                    bitRDRF: boolean);  // Receive Data Register Full
        end;
..
..
ioSTAT0: TioSTAT0;     // ASCI-Channel 0 Status

aus diesem sollen per 'if' Abfrage entsprechende Aktionen geschehen:

Code: Alles auswählen

if ((not ioSTAT0.bitRDRF) and asciRSR0F) then begin // ist RDR leer und liegen neue Daten im RSR

nur wird das Bit 'ioSTAT0.bitRDRF' nicht ausgewertet.
Auch folgender Test:

Code: Alles auswählen

test1, test2, test3, test4: boolean;
..
..
test1 := False;
test2 := True;
test3 := False;
test4 := True;
..
..
test1 := not ioSTAT0.bitRDRF;
test2 := not ioSTAT0.bitRDRF;
test3 := ioSTAT0.bitRDRF;
test4 := ioSTAT0.bitRDRF;
 

ergibt in allen 4 test-Variablen immer false, egal was in diesem Bit wirklich drin steht.
Seltsamerweise wird im Debug-Modus das Bit richtig ausgewertet.

Bei weiteren Test habe ich herausgefunden das die Bits 'TIE, TDRE, DCD0 und RIE' funktionieren, der Rest dann nicht.

Allerdings funktioniert dieses Record komplett fehlerfrei:

Code: Alles auswählen

TregAF = bitpacked record
            case byte of
                0: (value: word);     // 16Bit Register-Paar AF
                1: (F: byte;          // 8Bit Register F (lower 8Bit)
                    A: byte);         // 8Bit Register A (upper 8Bit)
                2: (Flag_C: boolean;  // 'Carry' Flag
                    Flag_N: boolean;  // 'Negative' Flag
                    Flag_PV: boolean; // 'Parity/Overflow' Flag
                    nv1: boolean;
                    Flag_H: boolean;  // 'Half-Carry' Flag
                    nv2: boolean;
                    Flag_Z: boolean;  // 'Zero' Flag
                    Flag_S: boolean); // 'Sign' Flag
        end;

Die Unit an sich ist recht groß, ca. 6750 Zeilen.

Vielleicht hat jemand von euch eine Idee woran der Fehler liegt.
Falls Ihr weitere Infos braucht, einfach kurz schreiben.

Vielen Dank und schöne Ostern,

HobbyProgrammer

[sstvmaster]

Hallo HobbyProgrammer,

Ich habe zwar keine Ahnung davon aber vielleicht nützt dir das was. Bithelpers von Avra aus dem englischen Forum.
https://bitbucket.org/avra/bithelpers/src/master/

Schöne Ostern, Maik

[af0815]

bitpacking ist aktivuert bei dir ? Nur zur Sicherheit.

https://wiki.freepascal.org/Bit_manipulation/de

[HobbyProgrammer]

Ja, ist aktiviert.
Der bitpacked Record 'regAF' funktioniert ja einwandfrei...

[Mathias]

Die Unit an sich ist recht groß, ca. 6750 Zeilen.

Hast du mal versucht, die Unit auf ein minimum abzuspecken ?
Ist dann der Fehler immer noch nachvollziehbar ?

[sstvmaster]

Kann man dein Problem mit dem Testprogramm nach vollziehen?

Code: Alles auswählen

 
program project1;
 
{$BITPACKING ON}
 
type
  TioSTAT0 = bitpacked record  // ASCI-Channel 0 Status
                case byte of
                0: (STAT0: byte);       // 8Bit Register Data
                1: (bitTIE: boolean;    // Transmit Interrupt Enable
                    bitTDRE: boolean;   // Transmit Data Register Empty
                    bitDCD0: boolean;   // Data Carrier Detect
                    bitRIE: boolean;    // Receive Interrupt Enable
                    bitFE: boolean;     // Framing Error
                    bitPE: boolean;     // Parity Error
                    bitOVRN: boolean;   // Overrun Error
                    bitRDRF: boolean);  // Receive Data Register Full
              end;
var
  ioSTAT0: TioSTAT0;     // ASCI-Channel 0 Status
  test1, test2, test3, test4: boolean;
 
begin
  ioSTAT0.STAT0 := %00000001;
 
  test1 := false;
  test2 := true;
  test3 := false;
  test4 := true;
 
  test1 := not ioSTAT0.bitRDRF;
  test2 := not ioSTAT0.bitRDRF;
  test3 := ioSTAT0.bitRDRF;
  test4 := ioSTAT0.bitRDRF;
 
  WriteLn('Test1: ', test1);
  WriteLn('Test2: ', test2);
  WriteLn('Test3: ', test3);
  WriteLn('Test4: ', test4);
 
  // Laz 2.0.6 / fpc 3.0.4 (stable) = false, false, false, false
 
  // Laz 2.0.7 / fpc 3.2   (fixes)  = true, true, false, false
 
  // Laz 2.1.0 / fpc 3.3.1 (trunk)  = true, true, false, false
 
  ReadLn();
end. 
 

[HobbyProgrammer]

Guten Morgen,

vielen Dank für Deine Mühe.
Da ich so wie installiert Laz 2.0.6 und Fpc 3.0.4 verwende gibt es für mich derzeit 2 Möglichkeiten. Entweder irgendwie der Compiler updaten oder einen Workaround schreiben.
Ich werd da später heute mal dran gehen und überlegen was ich mache.
Komisch nur das das 'regAF' Record einwandfrei funktioniert. Denn der emulierte Befehlssatz läuft perfekt.

[af0815]

Da ich so wie installiert Laz 2.0.6 und Fpc 3.0.4 verwende gibt es für mich derzeit 2 Möglichkeiten. Entweder irgendwie der Compiler updaten oder einen Workaround schreiben.
Ich werd da später heute mal dran gehen und überlegen was ich mache.

Mit fpcupdeluxe kannst du mehere FPC/Lazarus Seite an Seite installieren. Das würde ich in deinem Fall mal machen, damit kannst du auch Testen ob Dein Programm irgendwelche anderen Seiteneffekte mit dem neuen Compiler hat. Fixes von Lazarus und Fixes vom FPC würde ich bereits als ausreichend stabil erachten. Ich verwende genau diese Umgebung auch im professionellen Umfeld in der Firma.

Der einzige Nachteil der Installation mit fpcupdeluxe ist, das man dann im Explorer unter Windows nicht einfach ein Projekt öffnen kann. Nachdem ich mir das schon vor Jahren abgewöhnt habe, ist es für mich keine Einschränkung mehr.

[Timm Thaler]

Der einzige Nachteil der Installation mit fpcupdeluxe ist, das man dann im Explorer unter Windows nicht einfach ein Projekt öffnen kann.

Durch "Öffnen mit" und entsprechende Einträge sollte das möglich sein.

[HobbyProgrammer]

So, habs nun mal bei mir selbst nochmals als Testprojekt nachvollzogen:

Code: Alles auswählen

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
    Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
 
    { TForm1 }
 
    TForm1 = class(TForm)
        Button1: TButton;
        CheckBox1: TCheckBox;
        CheckBox2: TCheckBox;
        CheckBox3: TCheckBox;
        CheckBox4: TCheckBox;
        CheckBox5: TCheckBox;
        CheckBox6: TCheckBox;
        CheckBox7: TCheckBox;
        CheckBox8: TCheckBox;
        Label1: TLabel;
        procedure Button1Click(Sender: TObject);
        procedure FormShow(Sender: TObject);
    private
        type
        TioSTAT0 = bitpacked record  // ASCI-Channel 0 Status
            case byte of
                0: (STAT0: byte);       // 8Bit Register Data
                1: (bitTIE: boolean;    // Transmit Interrupt Enable
                    bitTDRE: boolean;   // Transmit Data Register Empty
                    bitDCD0: boolean;   // Data Carrier Detect
                    bitRIE: boolean;    // Receive Interrupt Enable
                    bitFE: boolean;     // Framing Error
                    bitPE: boolean;     // Parity Error
                    bitOVRN: boolean;   // Overrun Error
                    bitRDRF: boolean);  // Receive Data Register Full
        end;
 
    var
        ioSTAT0: TioSTAT0;     // ASCI-Channel 0 Status
 
    public
 
    end;
 
var
    Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
var
    test1, test2, test3, test4, test5, test6, test7, test8: boolean;
begin
    ioSTAT0.STAT0 := ((ioSTAT0.STAT0 + 1) and $FF);
    label1.Caption := IntToHex(ioSTAT0.STAT0, 2);
 
    test1 := ioSTAT0.bitTIE;
    test2 := ioSTAT0.bitTDRE;
    test3 := ioSTAT0.bitDCD0;
    test4 := ioSTAT0.bitRIE;
    test5 := ioSTAT0.bitFE;
    test6 := ioSTAT0.bitPE;
    test7 := ioSTAT0.bitOVRN;
    test8 := ioSTAT0.bitRDRF;
 
    CheckBox1.Checked := test1;
    CheckBox2.Checked := test2;
    CheckBox3.Checked := test3;
    CheckBox4.Checked := test4;
    CheckBox5.Checked := test5;
    CheckBox6.Checked := test6;
    CheckBox7.Checked := test7;
    CheckBox8.Checked := test8;
end;
 
procedure TForm1.FormShow(Sender: TObject);
begin
    ioSTAT0.STAT0 := $FF; 
end;
 
end.

und da funktioniert es so wie es soll...

Wenn ich allerdings mit 'not' versuche die Bits zu invertieren funktionert es nichtmehr:

Code: Alles auswählen

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
    Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
 
    { TForm1 }
 
    TForm1 = class(TForm)
        Button1: TButton;
        CheckBox1: TCheckBox;
        CheckBox2: TCheckBox;
        CheckBox3: TCheckBox;
        CheckBox4: TCheckBox;
        CheckBox5: TCheckBox;
        CheckBox6: TCheckBox;
        CheckBox7: TCheckBox;
        CheckBox8: TCheckBox;
        Label1: TLabel;
        procedure Button1Click(Sender: TObject);
        procedure FormShow(Sender: TObject);
    private
        type
        TioSTAT0 = bitpacked record  // ASCI-Channel 0 Status
            case byte of
                0: (STAT0: byte);       // 8Bit Register Data
                1: (bitTIE: boolean;    // Transmit Interrupt Enable
                    bitTDRE: boolean;   // Transmit Data Register Empty
                    bitDCD0: boolean;   // Data Carrier Detect
                    bitRIE: boolean;    // Receive Interrupt Enable
                    bitFE: boolean;     // Framing Error
                    bitPE: boolean;     // Parity Error
                    bitOVRN: boolean;   // Overrun Error
                    bitRDRF: boolean);  // Receive Data Register Full
        end;
 
    var
        ioSTAT0: TioSTAT0;     // ASCI-Channel 0 Status
 
    public
 
    end;
 
var
    Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
var
    test1, test2, test3, test4, test5, test6, test7, test8: boolean;
begin
    ioSTAT0.STAT0 := ((ioSTAT0.STAT0 + 1) and $FF);
    label1.Caption := IntToHex(ioSTAT0.STAT0, 2);
 
    test1 := not ioSTAT0.bitTIE;
    test2 := not ioSTAT0.bitTDRE;
    test3 := not ioSTAT0.bitDCD0;
    test4 := not ioSTAT0.bitRIE;
    test5 := not ioSTAT0.bitFE;
    test6 := not ioSTAT0.bitPE;
    test7 := not ioSTAT0.bitOVRN;
    test8 := not ioSTAT0.bitRDRF;
 
    CheckBox1.Checked := test1;
    CheckBox2.Checked := test2;
    CheckBox3.Checked := test3;
    CheckBox4.Checked := test4;
    CheckBox5.Checked := test5;
    CheckBox6.Checked := test6;
    CheckBox7.Checked := test7;
    CheckBox8.Checked := test8;
end;
 
procedure TForm1.FormShow(Sender: TObject);
begin
    ioSTAT0.STAT0 := $FF;
end;
 
end.   

[HobbyProgrammer]

Ich habe nun noch eine dritte Version einzeln getestet, mit dem 'regAF' Record. Und der funktioniert bei der invertierung auch nicht...

Code: Alles auswählen

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
    Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
 
    { TForm1 }
 
    TForm1 = class(TForm)
        Button1: TButton;
        CheckBox1: TCheckBox;
        CheckBox2: TCheckBox;
        CheckBox3: TCheckBox;
        CheckBox4: TCheckBox;
        CheckBox5: TCheckBox;
        CheckBox6: TCheckBox;
        CheckBox7: TCheckBox;
        CheckBox8: TCheckBox;
        Label1: TLabel;
        procedure Button1Click(Sender: TObject);
        procedure FormShow(Sender: TObject);
    private
        type
 
        TregAF = bitpacked record
            case byte of
                0: (Value: word);     // 16Bit Register-Paar AF
                1: (F: byte;          // 8Bit Register F (lower 8Bit)
                    A: byte);         // 8Bit Register A (upper 8Bit)
                2: (Flag_C: boolean;  // 'Carry' Flag
                    Flag_N: boolean;  // 'Negative' Flag
                    Flag_PV: boolean; // 'Parity/Overflow' Flag
                    nv1: boolean;
                    Flag_H: boolean;  // 'Half-Carry' Flag
                    nv2: boolean;
                    Flag_Z: boolean;  // 'Zero' Flag
                    Flag_S: boolean); // 'Sign' Flag
        end;
 
    var
        regAF: TregAF;
 
    public
 
    end;
 
var
    Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
var
    test1, test2, test3, test4, test5, test6, test7, test8: boolean;
begin
    regAF.F := ((regAF.F + 1) and $FF);
    label1.Caption := IntToHex(regAF.F, 2);
 
    test1 := regAF.Flag_C;
    test2 := regAF.Flag_N;
    test3 := regAF.Flag_PV;
    test4 := regAF.nv1;
    test5 := regAF.Flag_H;
    test6 := regAF.nv2;
    test7 := regAF.Flag_Z;
    test8 := regAF.Flag_S;
 
    //test1 := not regAF.Flag_C;
    //test2 := not regAF.Flag_N;
    //test3 := not regAF.Flag_PV;
    //test4 := not regAF.nv1;
    //test5 := not regAF.Flag_H;
    //test6 := not regAF.nv2;
    //test7 := not regAF.Flag_Z;
    //test8 := not regAF.Flag_S;
 
 
    CheckBox1.Checked := test1;
    CheckBox2.Checked := test2;
    CheckBox3.Checked := test3;
    CheckBox4.Checked := test4;
    CheckBox5.Checked := test5;
    CheckBox6.Checked := test6;
    CheckBox7.Checked := test7;
    CheckBox8.Checked := test8;
end;
 
procedure TForm1.FormShow(Sender: TObject);
begin
    regAF.F := $FF;
end;
 
end.  

Dann scheint es mir gerade so, das es purer Zufall ist, das die Emulaion in meinem Projekt läuft, und diese bitpacked Records eine sehr wackelige
Angelegenheit sind? Dann wäre es aus Sicht der Funktionalen Sicherheit angebracht das ganze umzuprogrammieren?
War eben so sehr schön bequem zu schreiben...

[siro]

Windows 10 64 Bit
Lazarus 1.8.4
FPC 3.0.4

sorry, hab mich grad geirrt, es läuft nicht mit NOT
Siro

[Mathias]

Ich habe es mal auf ein Minimum runtergespeckt:
Dabei habe ich den Umweg über Test gespart.

Code: Alles auswählen

type
  TioSTAT0 = bitpacked record
    case byte of
      0: (STAT0: byte);
      1: (bit0: boolean;
        bit1: boolean;
        bit2: boolean;
        bit3: boolean;
        bit4: boolean;
        bit5: boolean;
        bit6: boolean;
        bit7: boolean);
  end;
var
  ioSTAT0: TioSTAT0;
 
begin
  ioSTAT0.STAT0 := %00000001;
  WriteLn(not ioSTAT0.bit1);     // False  Was passiert da ?
  WriteLn(ioSTAT0.bit1);         // False
  WriteLn();
  ioSTAT0.STAT0 := %00000000;
  WriteLn(not ioSTAT0.bit1);     // True
  WriteLn(ioSTAT0.bit1);         // False
end.

[Mathias]

Nimmt man ein Array anstelle des Records, geht's.

Code: Alles auswählen

type
  TioSTAT0 = bitpacked record
    case byte of
      0: (STAT0: byte);
      1: (bit: bitpacked array [0..7] of boolean);
  end;
var
  ioSTAT0: TioSTAT0;
 
begin
  ioSTAT0.STAT0 := %00000001;
  WriteLn(not ioSTAT0.bit[1]);     // True
  WriteLn(ioSTAT0.bit[1]);         // False
  WriteLn();
  ioSTAT0.STAT0 := %00000000;
  WriteLn(not ioSTAT0.bit[1]);     // True
  WriteLn(ioSTAT0.bit[1]);         // False
  WriteLn(SizeOf(ioSTAT0));        // 1
end.    

[af0815]

Der einzige Nachteil der Installation mit fpcupdeluxe ist, das man dann im Explorer unter Windows nicht einfach ein Projekt öffnen kann.

Durch "Öffnen mit" und entsprechende Einträge sollte das möglich sein.

Dann muss man sicher die erstellte Verknüpfung verwenden lassen. Es muss ganz einfach sichergestellt sein, das der richtige Parameter pcp mit übergeben wird.