Problem mit Records in Datei schreiben

goose · Beiträge: 93

Hallo,

ich hab wiedermal ein schweres Problem damit Records in eine Datei zu schreiben.
Vielleicht sollte ich glaich dazu sagen das ich sowieso ein kleines Problemchen mit den blöden Records schreiben hab. Irgendwie kapier ich das nicht so richtig.
Naja, vielleicht kapier ich's ja nachdem ich das hier endlich hinbekommen habe :-)

Also es geht darum ein File für den FS Navigator zu erstellen, ein Flugplanfile.
Darin stehen verschieden Informationen zu den Wegpunkten usw.
Vom Entwckler des Programms hab ich folgende Textdatei als hilfe bekommen :

markieren

Quelltext

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:

The flight plan have as first the header. Only the header have
a fix position. In this header found you the byte offset for
aircraft data, waypoints and more.



struct tagFlightHeader
{
  UINT  m_uFileSize;
  char  m_cFileSignum1;    // 'F'
  char  m_cFileSignum2;    // 'P'
  WORD  m_wVersion;    // 105
  UINT  m_uUnusedA;    // 0
  UINT  m_uUnusedB;    // 0

  char  m_szDesc[256];    // Name for the plan open dialogue box

  UINT  m_uOffsCraft;    // 0 or byte offset to the aircraft data
  UINT  m_uCountCraft;    // 0 or 1
  UINT  m_uOffsWaypoint;  // byte offset to the first waypoint
  UINT  m_uCountWaypoint;  // count of waypoints

  UINT  m_uOffsOldData;    // 0
  UINT  m_uCountOldData;  // 0
  UINT  m_uOffsCruise;    // 0
  UINT  m_uCountCruise;    // 0

  UINT  m_uOffsManual;    // 0
  UINT  m_uCountManual;    // 0
  UINT  m_uUnused0;    // 0
  UINT  m_uUnused1;    // 0
};

struct tagAircraft
{
  char  m_szName[31];
  BYTE  m_uFlags;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
  int  m_nClimbSpeed;
  int  m_nClimbFuel;
  int  m_nClimbRate;
  int  m_nCruiseSpeed;
  int  m_nCruiseFuel;
  int  m_nCruiseAlt;
  int  m_nTDownSpeed;
  int  m_nDescentFuel;
  int  m_nDescentRate;
};

struct tagWaypoint
{
  WORD  m_wType;
  float  m_fLat;
  float  m_fLon;
};

******** values for tagWaypoint::m_wType *******
#define  POINTTYPE_ISEC      0x0004
#define  POINTTYPE_NDB      0x0008
#define  POINTTYPE_VOR      0x0010
#define  POINTTYPE_ILS      0x0020
#define  POINTTYPE_AIRPORT    0x0040
#define  POINTTYPE_RUNWAY    0x0080
#define  POINTTYPE_FIX      0x8000

auf die Frage hin, welche Struktur die Datei hat.
Nun steht ganz oben das die Datei einen Header hat.
Scheint der Record namens tagFlightHeader zu sein.

Den müsste ich doch jetzt in eine Datei an den Anfang schreiben denke ich oder ?
Dann müssten aber in die gleiche datei die anderen beiden Records auch noch geschrieben werden und von dem letzten Record halt soviele wie Wegpunkte in dem Flugplan sind oder ?

Die Frage ist wie ich das ganze in eine Datei schreiben kann ?

Ich hab erst mal volgendes gemacht :

markieren

Delphi-Quelltext

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:

type _tagFlightHeader = record
       m_uFileSize      : integer;
       m_cFileSignum1   : char;         // 'F'
       m_cFileSignum2   : char;         // 'P'
       m_wVersion       : WORD;         // 105
       m_uUnusedA       : integer;      // 0
       m_uUnusedB       : integer;      // 0

       m_szDesc         : array[0..255] of char;  // Name for the plan open dialogue box

       m_uOffsCraft     : integer;      // 0 or byte offset to the aircraft data
       m_uCountCraft    : integer;      // 0 or 1
       m_uOffsWaypoint  : integer;      // byte offset to the first waypoint
       m_uCountWaypoint : integer;     // count of waypoints

       m_uOffsOldData   : integer;    // 0
       m_uCountOldData  : integer;    // 0
       m_uOffsCruise    : integer;    // 0
       m_uCountCruise   : integer;    // 0

       m_uOffsManual    : integer;    // 0
       m_uCountManual   : integer;    // 0
       m_uUnused0       : integer;    // 0
       m_uUnused1       : integer;    // 0
    end;
type  _tagAircraft = record
        m_szName        : array[0..30] of char;
        m_uFlags        : byte;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
        m_nClimbSpeed   : integer;
        m_nClimbFuel    : integer;
        m_nClimbRate    : integer;
        m_nCruiseSpeed  : integer;
        m_nCruiseFuel   : integer;
        m_nCruiseAlt    : integer;
        m_nTDownSpeed   : integer;
        m_nDescentFuel  : integer;
        m_nDescentRate  : integer;
      end;
type _tagWaypoint = record
        m_wType : word;
        m_fLat  : Extended;
        m_fLon  : Extended;
      end;

Aber jezt muss ich doch dem File einen Type zuweisen oder ?
Also z.B.

markieren

Delphi-Quelltext

1:
2:

type
  _TFplFILE = File of ???;

Also ich hoffe ihr habt so einigermassen verstanden um was es geht ... hmmmmm

Ich häng mal so ne Datei an, vielleicht ist das ja hilfreich

Dank Euch schon mal

Matthias

Einloggen, um Attachments anzusehen!

Narses · Verfasst: Mo 23.05.05 17:31

Moin!

Du kannst dieser Datei keinen Typ in Delphi zuweisen, weil du einer Datei nur einen Typ zuweisen kannst, hier aber mehrere Typen (von Records) verwendet werden.

Du mußt die Datei als Stream (also binär) verarbeiten. Dazu könnte man die entsprechenden Teile der Datei an die Adresse eines entsprechend deklarierten Records in den Speicher laden. Gibt da sicherlich auch andere Variationen, wie man das lösen kann, aber sicher nicht mit einer (einfach) typisierten Datei.

cu
Narses

jasocul · Verfasst: Mo 23.05.05 17:35

Es ginge auch noch mit varianten Records oder mit Kennzeichnungen und untypisierten Dateien.
Aber Stream ist wohl wirklich einfacher.

goose · Beiträge: 93

Hallo,

danke Euch für die Antworten.
Allerdings hab ich das mit den Stream auch schon probiert. ging aber nicht.
Denk mal das ich da irgendwas falsch gemacht habe.

Wie müsste ich das denn machen um z.B. einen Flugplan ganz einfach, nur um
das Prinzip zu verstehen , einzugeben ?

Sagen wir

Departure : EDDP ( Flughafen )
VOR : LEG LAT : 12.345 lon 54.432
NDB : ZIG Lat : 12.567 LON : 54.987
ISEC : LUTER : Lat 12.743 LON 54.934
Destination EDDT ( Flugafen )

Nur so als beispiel

Dank Euch, vielleicht habt ihr ja ein beispiel das mir das Prinzip erklärt ?

Narses · Verfasst: Di 24.05.05 18:23

Moin!

goose hat folgendes geschrieben:

Allerdings hab ich das mit den Stream auch schon probiert. ging aber nicht.
Denk mal das ich da irgendwas falsch gemacht habe.

Zeig doch mal deinen Code, dann kann man vielleicht auch die Fehler beheben.

Andernfalls bedeutet das ja praktisch, dir das Programm zu schreiben... :wink:

cu
Narses

jaenicke · Verfasst: Mi 25.05.05 09:37

goose hat folgendes geschrieben:

Andernfalls bedeutet das ja praktisch, dir das Programm zu schreiben... :wink:

Ja genau. Das hab ich auch nicht vor, aber ich kann ja kurz schreiben, wie du es machen musst...

1. Du erzeugst nen FileStream mit der entsprechenden Datei
2. Du benutzt ReadBuffer fürs lesen vom Header
3. Du nimmst den Offset für die gesuchte Struktur, dieser steht ja in der gerade gelesenen Header-Struktur
4. Du gehst mit Position an die entsprechende Stelle
5. Du liest die entsprechende Struktur wiederum mit ReadBuffer aus

Ich denke, die Vorgehensweise sollte jetzt klar sein, aber jetzt poste mal erstmnal deinen Code, wenn dir das nicht zur Implementierung reicht, damit wir deinen Code korrigieren können...

goose · Beiträge: 93

Hallöchen,

sorry für die verspätete Antwort, aber musste arbeiten..stress ohne Ende

Also das hab ich bis jetzt erst mal :

markieren

Delphi-Quelltext

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:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    btnWriteStream: TButton;
    procedure btnWriteStreamClick(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

type _tagFlightHeader = packed record
       m_uFileSize      : LongWord;
       m_cFileSignum1   : char;         // 'F'
       m_cFileSignum2   : char;         // 'P'
       m_wVersion       : WORD;         // 105
       m_uUnusedA       : LongWord;     // 0
       m_uUnusedB       : LongWord;     // 0

       m_szDesc         : array[0..255] of char;  // Name for the plan open dialogue box

       m_uOffsCraft     : LongWord;      // 0 or byte offset to the aircraft data
       m_uCountCraft    : LongWord;      // 0 or 1
       m_uOffsWaypoint  : LongWord;      // byte offset to the first waypoint
       m_uCountWaypoint : LongWord;     // count of waypoints

       m_uOffsOldData   : LongWord;    // 0
       m_uCountOldData  : LongWord;    // 0
       m_uOffsCruise    : LongWord;    // 0
       m_uCountCruise   : LongWord;    // 0

       m_uOffsManual    : LongWord;    // 0
       m_uCountManual   : LongWord;    // 0
       m_uUnused0       : LongWord;    // 0
       m_uUnused1       : LongWord;    // 0
    end;
type  _tagAircraft = packed record
        m_szName        : array[0..30] of char;
        m_uFlags        : byte;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
        m_nClimbSpeed   : LongWord;
        m_nClimbFuel    : LongWord;
        m_nClimbRate    : LongWord;
        m_nCruiseSpeed  : LongWord;
        m_nCruiseFuel   : LongWord;
        m_nCruiseAlt    : LongWord;
        m_nTDownSpeed   : LongWord;
        m_nDescentFuel  : LongWord;
        m_nDescentRate  : LongWord;
      end;
type _tagWaypoint = packed record
        m_wType : word;
        m_fLat  : real;
        m_fLon  : real;
      end;

var
  Form1: TForm1;

const
  FPLFileName='test_fpl.FSN';

implementation

{$R *.dfm}

procedure TForm1.btnWriteStreamClick(Sender: TObject);
var
  FileStr: TFileStream;
  tagFlightHeader : _tagFlightHeader;
  tagAircraft     : _tagAircraft;
  tagWaypoint     : _tagWaypoint;
begin
  tagFlightHeader.m_uFileSize     := 0;
  tagFlightHeader.m_cFileSignum1  := 'F';
  tagFlightHeader.m_cFileSignum2  := 'P';
  tagFlightHeader.m_wVersion      := 105;
  tagFlightHeader.m_uUnusedA      := 0;
  tagFlightHeader.m_uUnusedB      := 0;

  tagFlightHeader.m_szDesc        := 'Test to Test';

  tagFlightHeader.m_uOffsCraft    := 0;
  tagFlightHeader.m_uCountCraft   := 0;
  tagFlightHeader.m_uOffsWaypoint := 0;
  tagFlightHeader.m_uCountWaypoint:= 0;

  tagFlightHeader.m_uOffsOldData  := 0;
  tagFlightHeader.m_uCountOldData := 0;
  tagFlightHeader.m_uOffsCruise   := 0;
  tagFlightHeader.m_uCountCruise  := 0;

  tagFlightHeader.m_uOffsManual   := 0;
  tagFlightHeader.m_uUnused0      := 0;
  tagFlightHeader.m_uUnused1      := 0;

  tagAircraft.m_szName        := 'Airbus A320';
  tagAircraft.m_uFlags        := 0;
  tagAircraft.m_nClimbSpeed   := 0;
  tagAircraft.m_nClimbFuel    := 0;
  tagAircraft.m_nClimbRate    := 0;
  tagAircraft.m_nCruiseSpeed  := 0;
  tagAircraft.m_nCruiseFuel   := 0;
  tagAircraft.m_nCruiseAlt    := 0;
  tagAircraft.m_nTDownSpeed   := 0;
  tagAircraft.m_nDescentFuel  := 0;
  tagAircraft.m_nDescentFuel  := 0;
  tagAircraft.m_nDescentRate  := 0;

  tagWaypoint.m_wType := $0040;
  tagWaypoint.m_fLat  := 0;
  tagWaypoint.m_fLon  := 0;

  FileStr := TFileStream.Create(FPLFileName, fmCreate);
  FileStr.Write(tagFlightHeader, SizeOf(tagFlightHeader) );
  FileStr.Write(tagAircraft, SizeOf(tagAircraft) );
  FileStr.Write(tagWaypoint, SizeOf(tagWaypoint) );
  FileStr.Free;
end;


end.

Funktioniert leider nicht.
Das File wird zwar erzeugt, aber irgendwie weiss ich nicht wie ich das mit dem Offset machen soll. Ausserdem ist es nur ein Wegpunkt ( letzter Record ). Wenn das mehrere sein sollen müsste ich das ja irgendwie anders machen oder ?
Würde aber schon mal recihen wenn es überhaupt gehen würde :-(

Dank Euch
Matthias

Narses · Verfasst: Do 26.05.05 10:02

Moin!

goose hat folgendes geschrieben:

aber irgendwie weiss ich nicht wie ich das mit dem Offset machen soll.

Naja, wie wäre es mit angeben, bzgl. der Offsets... :wink:

Die Bedeutung der Offsets ist folgende: damit wird die Position (als Anzahl Bytes ab Dateianfang vermutlich) angegeben, ab der eine bestimmte Struktur zu finden ist.

markieren

Delphi-Quelltext

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

  tagFlightHeader.m_uFileSize     := SizeOf(tagFlightHeader)
                                    +SizeOf(tagAircraft)
                                    +SizeOf(tagWaypoint); // * Anzahl Wegpunkte
  tagFlightHeader.m_cFileSignum1  := 'F';
  tagFlightHeader.m_cFileSignum2  := 'P';
  tagFlightHeader.m_wVersion      := 105;
  tagFlightHeader.m_uUnusedA      := 0;
  tagFlightHeader.m_uUnusedB      := 0;

  tagFlightHeader.m_szDesc        := 'Test to Test';

  tagFlightHeader.m_uOffsCraft    := SizeOf(tagFlightHeader); // davor ist der Header
  tagFlightHeader.m_uCountCraft   := 1; // ein Flugzeug ist das wohl, oder... ;)
  tagFlightHeader.m_uOffsWaypoint := SizeOf(tagFlightHeader)
                                    +SizeOf(tagAircraft); // nach Header und Aircraft
  tagFlightHeader.m_uCountWaypoint:= 1; // ebenfalls ein Wegpunkt, eigentlich natürlich richtige Anzahl

[...]

  FileStr := TFileStream.Create(FPLFileName, fmCreate);
  FileStr.Write(tagFlightHeader, SizeOf(tagFlightHeader) );
  FileStr.Write(tagAircraft, SizeOf(tagAircraft) );
  FileStr.Write(tagWaypoint, SizeOf(tagWaypoint) );
  FileStr.Free;

Eigentlich sollte es damit bereits klappen können. Wenn du mehr Wegpunkte ablegen willst, musst du eigentlich nur die Anzahl der Wegpunkte mit in die Offsetberechnung einfließen lassen, dürfte jetzt aber klar sein.

cu
Narses

goose · Beiträge: 93

Hallöchen,

ich danke Euch !!
Natürlich will ich nicht das Ihr die ganze Arbeit für mich macht !

Jetzt funktioniert es erst mal teilweise.
Der FS-Navigator öffnet zumindest erst mal den Flugplan den ich erstellt habe.
Allerdings meckert er jetzt das er einen Wegpunkt nicht gefunden hat.
Das liegt jetzt entweder an dem Format der Daten ( Lat/Lon ) oder
an dem hier ( womit ich wiedermal nicht wirklich was anfangen kann :

Zitat:

Normale Compiler setzen die Mitglieder einer Daten-Structur oder -Record nicht direkt
hintereinander sondern in 4 bzw. 8 Byte Schritten. Es ist also immer Luft zwischen
den Daten Elementen wenn diese nicht zufällig auf einer 4 Byte Grenze enden.
Das darf hier aber nicht sein. Deshalb benutze ich in C++ besonder Anweisungen:

#pragma pack(push, 1) // ab jetzt Daten direkt hintereinander anodnen

struct tagFlightHeader
{
};

#pragma pack(pop) // ab jetzt zurück zum default Schema wechselln

Man kann diese Einstellung auch in den Optionen des Entwicklungs Projektes global machen.

Vielleicht hast Du auch ein Problem mit den Daten Typen.
"float" ist eine Gleitkomma Zahl der Größe 4 Byte. Hat jeder Compiler. Standart ist aber 8 Byte.
"WORD" ist eine vorzeichenlose Ganzzahl mit 2 Byte.
"UINT" ist eine vorzeichenlose Ganzzahl mit 4 Byte.
"char" ist ein Byte.

char m_szDesc[256]; ist ein Text der aber nichts mit dem Üblichen in Pascal/Delfi gemein hat.
Es ist eine Kette von 256 Byte, wobei der enthaltene Textes am Ende mit einer 0 abgeschlossen ist.
0 ist dabei nicht der Buchstabe 0 sonder ein Byte mit allen Bits 0.

Also stimmen denn die Varibalen die ich in den Records verwendet habe wirklich ? Nicht das da eine zu lang ist oder so ?
Das hier ( #pragma pack(push, 1) ) hab ich in der Delphi hilfe nicht gefunden.
Gibts das in Delphi ?

Dank Euch !

Matthias

alzaimar · Verfasst: Do 26.05.05 18:19

In Pascal gibt es das Konstrukt 'Packed record' und 'Packed Array'. Damit soll die Ausrichtung an 2er oder 4er Byte Blöcken ausgehebelt werden. Es ist nicht definiert, wie ein Compiler das Konstrukt 'Record a,b : Byte End;' intern ablegt (und speichert). Aber ein 'Packed Record a,b : Byte End;' wird laut Definition so eng wie möglich, hier also in Byte-Schritten, abgelegt.
Theoretisch sollte ein guter Pascal-Compiler ein Packed Array [0..7] Of Boolean in genau ein Byte ... packen.

Allerdings würde ich für jedes Record eine Klasse schreiben und diesen Klassen jeweils eine "LoadFromStream" und eine "SaveToStream" Methode programmieren. Da kannst Du haargenau jedes einzelne Byte einlesen und solange umfriemeln, bis die Daten genauso geladen/gespeichert werden, wie es der FS verlangt.

Spiel halt mal ein wenig.

retnyg · Verfasst: Do 26.05.05 18:26

markieren

Delphi-Quelltext

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

type _tagFlightHeader = packed record
...
     end;
type  _tagAircraft = packed record
...
     end;
type _tagWaypoint = packed record
...
     end;

type TMyRec = packed record
      tF : _tagFlightHeader;
      tA : _tagAircraft;
      tW : _tagWaypoint
     end;

var
  Form1: TForm1;
  myfile: file of TMyRec;

so auch schon probiert ?

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

goose · Beiträge: 93

Hallöchen,

ja hatte ich schon, habs aber nochmal probiert, und zwar so :

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:

type _TMyRec = packed record
      tF : _tagFlightHeader;  
      tA : _tagAircraft;  
      tW : _tagWaypoint  
     end;

markieren

Delphi-Quelltext

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:

procedure TForm1.btnWriteFileClick(Sender: TObject);
var
  tagFlightHeader : _tagFlightHeader;
  tagAircraft     : _tagAircraft;
  tagWaypoint     : _tagWaypoint;
  MyRec : _TMyRec;
  myfile: file of _TMyRec;
begin
  tagFlightHeader.m_uFileSize     := SizeOf(tagFlightHeader)
                                    +SizeOf(tagAircraft)
                                    +SizeOf(tagWaypoint); // * Anzahl Wegpunkte

  tagFlightHeader.m_cFileSignum1  := 'F';
  tagFlightHeader.m_cFileSignum2  := 'P';
  tagFlightHeader.m_wVersion      := 105;
  tagFlightHeader.m_uUnusedA      := 0;
  tagFlightHeader.m_uUnusedB      := 0;

  tagFlightHeader.m_szDesc        := 'Test to Test';

  tagFlightHeader.m_uOffsCraft    := SizeOf(tagFlightHeader); // davor ist der Header
  tagFlightHeader.m_uCountCraft   := 1; // ein Flugzeug ist das wohl, oder... ;)
  tagFlightHeader.m_uOffsWaypoint := SizeOf(tagFlightHeader)
                                    +SizeOf(tagAircraft); // nach Header und Aircraft
  tagFlightHeader.m_uCountWaypoint:= 1; // ebenfalls ein Wegpunkt, eigentlich natürlich richtige Anzahl

  tagFlightHeader.m_uOffsOldData  := 0;
  tagFlightHeader.m_uCountOldData := 0;
  tagFlightHeader.m_uOffsCruise   := 0;
  tagFlightHeader.m_uCountCruise  := 0;

  tagFlightHeader.m_uOffsManual   := 0;
  tagFlightHeader.m_uUnused0      := 0;
  tagFlightHeader.m_uUnused1      := 0;

  tagAircraft.m_szName        := 'Airbus A320';
  tagAircraft.m_uFlags        := 0;
  tagAircraft.m_nClimbSpeed   := 0;
  tagAircraft.m_nClimbFuel    := 0;
  tagAircraft.m_nClimbRate    := 0;
  tagAircraft.m_nCruiseSpeed  := 0;
  tagAircraft.m_nCruiseFuel   := 0;
  tagAircraft.m_nCruiseAlt    := 0;
  tagAircraft.m_nTDownSpeed   := 0;
  tagAircraft.m_nDescentFuel  := 0;
  tagAircraft.m_nDescentFuel  := 0;
  tagAircraft.m_nDescentRate  := 0;

  tagWaypoint.m_wType := $0040;
  tagWaypoint.m_fLat  := 51.424;
  tagWaypoint.m_fLon  := 12.2364;

  Myrec.tF := tagFlightHeader;
  MyRec.tA := tagAircraft;
  MyRec.tW := tagWaypoint;

  AssignFile(myfile, 'f_fpl.FSN');
  rewrite(myfile);
  write(myfile,MyRec);
  CloseFile(myfile);

end;

Geht aber nicht, da sagt er wieder "Falsches FileFormat". Hmmmm

Matthias

retnyg · Verfasst: Do 26.05.05 18:58

so gehts:

markieren

Delphi-Quelltext

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:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:

procedure TForm1.Button2Click(Sender: TObject);
type _tagFlightHeader = packed record
       m_uFileSize      : LongWord;
       m_cFileSignum1   : char;         // 'F'
       m_cFileSignum2   : char;         // 'P'
       m_wVersion       : WORD;         // 105
       m_uUnusedA       : LongWord;     // 0
       m_uUnusedB       : LongWord;     // 0

       m_szDesc         : array[0..255] of char;  // Name for the plan open dialogue box

       m_uOffsCraft     : LongWord;      // 0 or byte offset to the aircraft data
       m_uCountCraft    : LongWord;      // 0 or 1
       m_uOffsWaypoint  : LongWord;      // byte offset to the first waypoint
       m_uCountWaypoint : LongWord;     // count of waypoints

       m_uOffsOldData   : LongWord;    // 0
       m_uCountOldData  : LongWord;    // 0
       m_uOffsCruise    : LongWord;    // 0
       m_uCountCruise   : LongWord;    // 0

       m_uOffsManual    : LongWord;    // 0
       m_uCountManual   : LongWord;    // 0
       m_uUnused0       : LongWord;    // 0
       m_uUnused1       : LongWord;    // 0
    end;
    _tagAircraft = packed record
        m_szName        : array[0..30] of char;
        m_uFlags        : byte;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
        m_nClimbSpeed   : LongWord;
        m_nClimbFuel    : LongWord;
        m_nClimbRate    : LongWord;
        m_nCruiseSpeed  : LongWord;
        m_nCruiseFuel   : LongWord;
        m_nCruiseAlt    : LongWord;
        m_nTDownSpeed   : LongWord;
        m_nDescentFuel  : LongWord;
        m_nDescentRate  : LongWord;
      end;
     _tagWaypoint = packed record
        m_wType : word;
        m_fLat  : real;
        m_fLon  : real;
      end;

      _TMyRec = packed record
      tF : _tagFlightHeader;
      tA : _tagAircraft;
      tW : _tagWaypoint
     end;
var
  MyRec : _TMyRec;
  myfile: file of _TMyRec;
begin
  myrec.tF.m_uFileSize     := SizeOf(myrec); // * Anzahl Wegpunkte

  myrec.tF.m_cFileSignum1  := 'F';
  myrec.tF.m_cFileSignum2  := 'P';
  myrec.tF.m_wVersion      := 105;
  myrec.tF.m_uUnusedA      := 0;
  myrec.tF.m_uUnusedB      := 0;

  myrec.tF.m_szDesc        := 'Test to Test';

  myrec.tF.m_uOffsCraft    := SizeOf(myrec.tF); // davor ist der Header
  myrec.tF.m_uCountCraft   := 1; // ein Flugzeug ist das wohl, oder... ;)
  myrec.tF.m_uOffsWaypoint := SizeOf(myrec.tF)
                                    +SizeOf(myrec.tA); // nach Header und Aircraft
  myrec.tF.m_uCountWaypoint:= 1; // ebenfalls ein Wegpunkt, eigentlich natürlich richtige Anzahl

  myrec.tF.m_uOffsOldData  := 0;
  myrec.tF.m_uCountOldData := 0;
  myrec.tF.m_uOffsCruise   := 0;
  myrec.tF.m_uCountCruise  := 0;

  myrec.tF.m_uOffsManual   := 0;
  myrec.tF.m_uUnused0      := 0;
  myrec.tF.m_uUnused1      := 0;

  myrec.tA.m_szName        := 'Airbus A320';
  myrec.tA.m_uFlags        := 0;
  myrec.tA.m_nClimbSpeed   := 0;
  myrec.tA.m_nClimbFuel    := 0;
  myrec.tA.m_nClimbRate    := 0;
  myrec.tA.m_nCruiseSpeed  := 0;
  myrec.tA.m_nCruiseFuel   := 0;
  myrec.tA.m_nCruiseAlt    := 0;
  myrec.tA.m_nTDownSpeed   := 0;
  myrec.tA.m_nDescentFuel  := 0;
  myrec.tA.m_nDescentFuel  := 0;
  myrec.tA.m_nDescentRate  := 0;

  myrec.tW.m_wType := $0040;
  myrec.tW.m_fLat  := 51.424;
  myrec.tW.m_fLon  := 12.2364;

  AssignFile(myfile, 'f_fpl.FSN');
  rewrite(myfile);
  write(myfile,MyRec);
  CloseFile(myfile);

end;

falls es damit noch probleme in dem programm gibt, versuche mal das packed wegzulassen.
// edit: sizeOf auch angepasst

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

retnyg · Verfasst: Do 26.05.05 19:12

habe oben noch was geändert, nicht dass du dich mit dem verbuggten code von vorher rumärgerst o0

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

goose · Beiträge: 93

Hallo,

ich hab das jetzt nochmal so versucht, also nicht per FileStrem.
Das scheint so nicht zu gehen, denn da sagt er auch das es ein falsches dateiformat wäre.
Wie ist das eigentlich mit diesem "packed" ist das das was der Autor geschrieben hat wegen diesem hintereinander schreiben ?
Also das hier : #pragma pack(push, 1) ?

Oder muss ich das vielleicht auch noch irgendwo einstellen ?

Matthias

Vergessen :

Ich hab in der Hilfe und auch im Internet nach den genauen grössen der einzelnen Variablen Typen gesucht. Komischerweise hab ich da unterschiedlich angaben gefunden ???

Gibt es irgendwo eine genaue Aufstellung aller in Delphi verfügbaren Variablen inclusive derer möglichen Inhalte und Grössen ( also wieviel byte sie belegen ) ??

retnyg · Verfasst: Do 26.05.05 23:39

häng mal ein funktionierendes file hier rein, dann kann man vergleichen was schiefläuft ^^

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

goose · Beiträge: 93

Hallöchen,

mach ich:

Hab mal einen Flugplan gemacht, der nur einen Airport als Wegpunkt enthält.
Also genau das was ich die ganze Zeit versucht habe zu erstellen.

Wie is das mit den Variablen ? ( vielleicht liegts ja an der länge der Variablen )

Matthias

Einloggen, um Attachments anzusehen!

retnyg · Verfasst: Fr 27.05.05 00:31

markieren

Delphi-Quelltext

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:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:

procedure TForm1.Button2Click(Sender: TObject);
type _tagFlightHeader = packed record
       m_uFileSize      : LongWord;
       m_cFileSignum1   : char;         // 'F'
       m_cFileSignum2   : char;         // 'P'
       m_wVersion       : WORD;         // 105
       m_uUnusedA       : LongWord;     // 0
       m_uUnusedB       : LongWord;     // 0

       m_szDesc         : array[0..255] of char;  // Name for the plan open dialogue box

       m_uOffsCraft     : LongWord;      // 0 or byte offset to the aircraft data
       m_uCountCraft    : LongWord;      // 0 or 1
       m_uOffsWaypoint  : LongWord;      // byte offset to the first waypoint
       m_uCountWaypoint : LongWord;     // count of waypoints

       m_uOffsOldData   : LongWord;    // 0
       m_uCountOldData  : LongWord;    // 0
       m_uOffsCruise    : LongWord;    // 0
       m_uCountCruise   : LongWord;    // 0

       m_uOffsManual    : LongWord;    // 0
       m_uCountManual   : LongWord;    // 0
       m_uUnused0       : LongWord;    // 0
       m_uUnused1       : LongWord;    // 0
    end;
    _tagAircraft = packed record
        m_szName        : array[0..30] of char;
        m_uFlags        : byte;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
        m_nClimbSpeed   : LongWord;
        m_nClimbFuel    : LongWord;
        m_nClimbRate    : LongWord;
        m_nCruiseSpeed  : LongWord;
        m_nCruiseFuel   : LongWord;
        m_nCruiseAlt    : LongWord;
        m_nTDownSpeed   : LongWord;
        m_nDescentFuel  : LongWord;
        m_nDescentRate  : LongWord;
      end;
     _tagWaypoint = packed record
        m_wType : word;
        m_fLat  : single;
        m_fLon  : single;
      end;
      _tagFileEnd = packed record
        dummy : array [0..41] of char;
        something: array[0..11] of char;
      end;

      _TMyRec = packed record
      tF : _tagFlightHeader;
      tA : _tagAircraft;
      tW : _tagWaypoint;
      tE : _tagFileEnd;
     end;
var
  MyRec : _TMyRec;
  myfile: file of _TMyRec;
begin
  myrec.tF.m_uFileSize     := SizeOf(_Tmyrec); // * Anzahl Wegpunkte

  myrec.tF.m_cFileSignum1  := 'F';
  myrec.tF.m_cFileSignum2  := 'P';
  myrec.tF.m_wVersion      := 105;
  myrec.tF.m_uUnusedA      := 0;
  myrec.tF.m_uUnusedB      := 0;

  myrec.tF.m_szDesc        := 'Test to Test';

  myrec.tF.m_uOffsCraft    := SizeOf(_tagFlightHeader); // davor ist der Header
  myrec.tF.m_uCountCraft   := 1; // ein Flugzeug ist das wohl, oder... ;)
  myrec.tF.m_uOffsWaypoint := SizeOf(_tagFlightHeader)
                                    +SizeOf(_tagAircraft); // nach Header und Aircraft
  myrec.tF.m_uCountWaypoint:= 1; // ebenfalls ein Wegpunkt, eigentlich natürlich richtige Anzahl

  myrec.tF.m_uOffsOldData  := 0;
  myrec.tF.m_uCountOldData := 0;
  myrec.tF.m_uOffsCruise   := 0;
  myrec.tF.m_uCountCruise  := 0;

  myrec.tF.m_uOffsManual   := 0;
  myrec.tF.m_uUnused0      := 0;
  myrec.tF.m_uUnused1      := 0;

  myrec.tA.m_szName        := 'Airbus A320';
  myrec.tA.m_uFlags        := 0;
  myrec.tA.m_nClimbSpeed   := 0;
  myrec.tA.m_nClimbFuel    := 0;
  myrec.tA.m_nClimbRate    := 0;
  myrec.tA.m_nCruiseSpeed  := 0;
  myrec.tA.m_nCruiseFuel   := 0;
  myrec.tA.m_nCruiseAlt    := 0;
  myrec.tA.m_nTDownSpeed   := 0;
  myrec.tA.m_nDescentFuel  := 0;
  myrec.tA.m_nDescentFuel  := 0;
  myrec.tA.m_nDescentRate  := 0;

  myrec.tW.m_wType := $0040;
  myrec.tW.m_fLat  := 51.424;
  myrec.tW.m_fLon  := 12.2364;

  fillchar(myrec.tE.dummy,42,0);
  myrec.tE.something := #$22#1#0#0#0#$7d#0#0#0#$7d#0#0;
  // ob das hier sinn macht, und welche variablen dahinter verborgen sind, musst du selbst rauskriegen ;)

  AssignFile(myfile, 'f_fpl.FSN');
  rewrite(myfile);
  write(myfile,MyRec);
  CloseFile(myfile);

end;

float in C++ entspricht Single in delphi, was aber nichts dran ändert dass am ende des files noch 54 byte overhead dranhängen. probiere es mal so, und frag den programmierer wofür die letzten 54 bytes sthen

edit: man könnte übrigens auch die einzelnen (_tag-) records der reihe nach mit blockwrite in ein file schreiben.

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

goose · Beiträge: 93

Hehe,

cool, das funktioniert !
Wie haste das denn rausbekommen ????
Bei sowas sehe ich immer wieviel Wissen mir noch fehlt, hauptsächlich mit den blöden typerisierten dateien mit denen ich mich sowieso gestritten habe :-)

Gut, das geht jetzt erst mal mit einem Wegpunkt.
Wenn ich das jetzt mit mehreren machen will müsste ich dann einen
array of tagWaypoint machen oder ?

Dann müsste aber auch die grösse der Datei anders angegeben werden oder ?
Die stimmt ja dann auch nicht mehr ..... man is das kompliziert.
Ich hab das ganze gerade mit dem Stream ausprobiert, da geht es wieder nicht. Also den tagFileEnd gefüllt und dan die Datei drangehangen.

Kannst mir noch mit mehreren wegpunkten helfen ? ( mit irgendwelchen daten )
Ich glaub ich schnall das nie :-(

Matthias

retnyg · Verfasst: Fr 27.05.05 02:37

wie ich das rausgefunden habe ? ich habe beide dateien mit ultraedit im hexmodus verglichen.
z.b. steht bei adresse 110h das offset von craft, welches 40 01 00 00 (longword sind 4 byte) ist, also 00000140h -> an
adresse 140h beginnt also der record des flugzeugs.
bis zum waypoint hat auch alles gestimmt...der rest war einfach

wie vorhin erwähnt, kannst du das ganze bei mehreren waypoints mit blockwrite machen:

markieren

Delphi-Quelltext

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:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:

procedure TForm1.Button2Click(Sender: TObject);
type _tagFlightHeader = packed record
       m_uFileSize      : LongWord;
       m_cFileSignum1   : char;         // 'F'
       m_cFileSignum2   : char;         // 'P'
       m_wVersion       : WORD;         // 105
       m_uUnusedA       : LongWord;     // 0
       m_uUnusedB       : LongWord;     // 0

       m_szDesc         : array[0..255] of char;  // Name for the plan open dialogue box

       m_uOffsCraft     : LongWord;      // 0 or byte offset to the aircraft data
       m_uCountCraft    : LongWord;      // 0 or 1
       m_uOffsWaypoint  : LongWord;      // byte offset to the first waypoint
       m_uCountWaypoint : LongWord;     // count of waypoints

       m_uOffsOldData   : LongWord;    // 0
       m_uCountOldData  : LongWord;    // 0
       m_uOffsCruise    : LongWord;    // 0
       m_uCountCruise   : LongWord;    // 0

       m_uOffsManual    : LongWord;    // 0
       m_uCountManual   : LongWord;    // 0
       m_uUnused0       : LongWord;    // 0
       m_uUnused1       : LongWord;    // 0
    end;
    _tagAircraft = packed record
        m_szName        : array[0..30] of char;
        m_uFlags        : byte;    // bit 0 and 1 = FuelMeasure type; bit 2 = NotAsh
        m_nClimbSpeed   : LongWord;
        m_nClimbFuel    : LongWord;
        m_nClimbRate    : LongWord;
        m_nCruiseSpeed  : LongWord;
        m_nCruiseFuel   : LongWord;
        m_nCruiseAlt    : LongWord;
        m_nTDownSpeed   : LongWord;
        m_nDescentFuel  : LongWord;
        m_nDescentRate  : LongWord;
      end;
     _tagWaypoint = packed record
        m_wType : word;
        m_fLat  : single;
        m_fLon  : single;
      end;
      _tagFileEnd = packed record
        dummy : array [0..41] of char;
        something: array[0..11] of char;
      end;

      _TMyRec = packed record
      tF : _tagFlightHeader;
      tA : _tagAircraft;
      tW : _tagWaypoint;
      tE : _tagFileEnd;
     end;
var
  //MyRec : _TMyRec;
  tF : _tagFlightHeader;
  tA : _tagAircraft;
  tW : array of _tagWaypoint;
  tE : _tagFileEnd;
  n: dword; // anzahl waypoints
  i: dword;
  p:pchar;
  myfile: file of byte;//of _TMyRec;
begin
  n := 3;
  setlength(tW,n);

  AssignFile(myfile, 'f_fpl.FSN');
  rewrite(myfile);

    tF.m_uFileSize     := SizeOf(_tagFlightHeader) +
                          SizeOf(_tagAirCraft) +
                          (sizeof(_tagwaypoint) * n) +
                          SizeOf(_tagFileEnd);

    tF.m_cFileSignum1  := 'F';
    tF.m_cFileSignum2  := 'P';
    tF.m_wVersion      := 105;
    tF.m_uUnusedA      := 0;
    tF.m_uUnusedB      := 0;

    tF.m_szDesc        := 'Test to Test';

    tF.m_uOffsCraft    := SizeOf(_tagFlightHeader); // davor ist der Header
    tF.m_uCountCraft   := 1; // ein Flugzeug ist das wohl, oder... ;)
    tF.m_uOffsWaypoint := SizeOf(_tagFlightHeader)
                                      +SizeOf(_tagAircraft); // nach Header und Aircraft
    tF.m_uCountWaypoint:= n; // ebenfalls ein Wegpunkt, eigentlich natürlich richtige Anzahl

    tF.m_uOffsOldData  := 0;
    tF.m_uCountOldData := 0;
    tF.m_uOffsCruise   := 0;
    tF.m_uCountCruise  := 0;

    tF.m_uOffsManual   := 0;
    tF.m_uUnused0      := 0;
    tF.m_uUnused1      := 0;

  blockwrite(myfile, tF, sizeof(_TagFlightHeader));

    tA.m_szName        := 'Airbus A320';
    tA.m_uFlags        := 0;
    tA.m_nClimbSpeed   := 0;
    tA.m_nClimbFuel    := 0;
    tA.m_nClimbRate    := 0;
    tA.m_nCruiseSpeed  := 0;
    tA.m_nCruiseFuel   := 0;
    tA.m_nCruiseAlt    := 0;
    tA.m_nTDownSpeed   := 0;
    tA.m_nDescentFuel  := 0;
    tA.m_nDescentFuel  := 0;
    tA.m_nDescentRate  := 0;

  blockwrite(myfile, tA, sizeof(_tagAircraft));

  for i := 0 to n-1 do begin
    tW[i].m_wType := $0040;
    tW[i].m_fLat  := 51.424;
    tW[i].m_fLon  := 12.2364;
    blockwrite(myfile, tW[i], sizeof(_tagWaypoint));
  end;

    fillchar(tE.dummy,42,0);
    tE.something := #$22#1#0#0#0#$7d#0#0#0#$7d#0#0;

  blockwrite(myfile, tE, sizeof(_tagFileEnd));

  // ob das hier sinn macht, und welche variablen dahinter verborgen sind, musst du selbst rauskriegen ;)

  CloseFile(myfile);

end;

//edit: filesize angepasst
//edit: und nochmal

_________________
es gibt leute, die sind genetisch nicht zum programmieren geschaffen.
in der regel haben diese leute die regel...

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme