Unbekanntes Dateiformat einlesen

[nahpets]

Hallo,

Zitat:

Das Konvertierungsprogramm macht einen CRC Check. Wenn man nun ein Zeichen hinzufügt bzw löscht kommt der CRC Fehler.
Wenn aber nur zwei Zeichen vertauscht geht es ohne Probleme.

läßt auf eine feste Satzlänge schließen, der Inhalt scheint aber (in gewisser Weise) wursch zu sein.

[ryLIX]

Code:

07 00 01 00 01 00 01 01 01 63 65 01 
00 02

02 01 0C 00 03 0000 DATEINAME            00 55 02 00 04 S                  00 55 05 00 05 NAME
00 07 13 00 03 0100 SGID_CODIERINDEX     00 1F 05 00 04 B(B)               00 00 0B 00 05 WERT,WERT2
00 10 16 00 03 0200 SGID_HARDWARENUMMER  00 43 05 00 04 S(S)               00 00 0B 00 05 WERT,WERT2
00 10 10 00 03 0300 SGID_SWNUMMER        00 5E 05 00 04 S(S)               00 00 0B 00 05 WERT,WERT2
00 10 0E 00 03 0400 SPEICHERORG          00 40 03 00 04 SS                 00 07 0D 00 05 STRUKTUR,TYP
00 61 12 00 03 0500 ANLIEFERZUSTAND      00 49 04 00 04 (B)                00 43 05 00 05 WERT
00 14 13 00 03 0600 CODIERDATENBLOCK     00 13 07 00 04 {L}LWS             00 01 24 00 05 BLOCKNR,WORTADR,BYTEADR,BEZEICHNUNG
00 04 17 00 03 0700 HERSTELLERDATENBLOCK 00 0A 07 00 04 {L}LWS             00 01 24 00 05 BLOCKNR,WORTADR,BYTEADR,BEZEICHNUNG
00 04 17 00 03 0800 RESERVIERTDATENBLOCK 00 00 07 00 04 {L}LWS             00 01 24 00 05 BLOCKNR,WORTADR,BYTEADR,BEZEICHNUNG
00 04 0C 00 03 0900 UNBELEGT1            00 31 0C 00 04 {L}LW{B}(B)        00 5E 24 00 05 BLOCKNR,WORTADR,BYTEADR,INDEX,MASKE
00 6F 0C 00 03 0A00 UNBELEGT2            00 31 04 00 04 (B)                00 43 05 00 05 WERT
00 14 0C 00 03 0B00 KENNUNG_K            00 42 06 00 04 SS(S)              00 50 12 00 05 IDENT,WERT1,WERTN
00 3A 0C 00 03 0C00 KENNUNG_D            00 4A 07 00 04 WW(WW)             00 02 26 00 05 HEXWERT1,HEXWERT2,HEXWERTN1,HEXWERTN2
00 0F 0C 00 03 0D00 KENNUNG_X            00 57 07 00 04 WW(WW)             00 02 26 00 05 HEXWERT1,HEXWERT2,HEXWERTN1,HEXWERTN2
00 0F 0E 00 03 0E00 KENNUNG_ALL          00 4F 06 00 04 SW(W)              00 50 1A 00 05 KENNUNG,HEXWERT1,HEXWERTN
00 32 14 00 03 0F00 PARZUWEISUNG_PSW2    00 39 04 00 04 (B)                00 43 06 00 05 DATUM
00 4A 14 00 03 1000 PARZUWEISUNG_PSW1    00 25 05 00 04 W(B)               00 15 0A 00 05 PSW,DATUM
00 3E 13 00 03 1100 PARZUWEISUNG_DIR     00 19 11 00 04 {L}LWW{B}(B)(A)B   00 16 3A 00 05 BLOCKNR,WORTADR,BYTEADR,FSW,INDEX,MASKE,OPERATION,EINHEIT
00 18 13 00 03 1200 PARZUWEISUNG_FSW     00 07 13 00 04 {L}LWW{B}(B){B}{B} 00 16 38 00 05 BLOCKNR,WORTADR,BYTEADR,FSW,INDEX,MASKE,EINHEIT,INDIVID

00 1E 00 00 FF FF

Hab hatte mal wieder etwas Zeit und hab mich noch mal dem Header gewidmet und habe es so sortiert wie nicodex es forgeschlagen hat.
Noch ein wenig einrückung dazu und schon siehts schick aus :)
Nun habe ich mir das ganze in Ruhe angeschaut und folgende Theorie entwickelt:
Da man im Moment von einer festen Satzlänge ausgehen kann (durch den CRC Check) kommt folgende aufteilung als schlüssig vor:
03 -> Start ID und Bezeichner
04 -> Start Variablentyp
05 -> Start Variablenname
Also wie nicodex es auch schon meinte.
Was mich immer noch etas verwirrt ist die erste Zeile der Datei und warum startet die Zeile für 'DATEINAME' nicht mit 00

Zu dem Header habe ich mir heute auch mal den Databereich näher angeschaut.
Auch hier feste Satzlänge. Anfang und Ende von gleichen Zeilen (PSW1 z.B.) fangen immer gleich an und Enden gleich.

Code:

DATEINAME : ALC_DS2.C04
0C 0000 ALC_DS2.C04 00 51

SGID_CODIERINDEX : 04,(00)
03 0100 04 00 00 06

SPEICHERORG : BYTE,BLOCK
0B 0400 BYTE 00 BLOCK 00 4C

ANLIEFERZUSTAND : (00 00)
03 0500 01 00 00 07

CODIERDATENBLOCK : {00003000},00000000,0010,Grundkonfiguration_ALC-SG
25 0600 01003000 00000000 0010 00 Grundkonfiguration_ALC-SG 00 18

PARZUWEISUNG_FSW : {00003000},00000000,0001,02D6,{},(00 01),{68},{}
14 1200 01003000 00000000 0001 00 D602 000100 0101 68 00 8B

PARZUWEISUNG_PSW1 : 0002,(00 00)
05 1000 0200 01 00 00 16

PARZUWEISUNG_PSW1 : 0001,(00 01)
05 1000 0100 01 00 01 14

PARZUWEISUNG_FSW : {00003000},00000000,0001,02D4,{},(00 02),{68},{}
14 1200 01003000 00000000 0001 00 D402 000100 0201 68 00 8A

PARZUWEISUNG_PSW1 : 0002,(00 00)
05 1000 0200 01 00 00 16


PARZUWEISUNG_PSW1 : 0001,(00 01)
05 1000 0100 01 00 01 14

PARZUWEISUNG_FSW : {00003000},00000000,0001,0647,{},(00 04),{68},{}
14 1200 01003000 00000000 0001 00 4706 000100 0401 68 00 1B


PARZUWEISUNG_PSW1 : 0002,(00 00)
05 1000 0200 0100 00 16


PARZUWEISUNG_PSW1 : 0001,(00 01)
05 1000 0100 01 00 01 14

UNBELEGT1 : {00003013},0000000F,0001,{},(00 FF)
0F 0900 01 13300000 0F000000 0100 0001 00FF D4

UNBELEGT2 : (00 00)
03 0A00 0100 00 08

[ryLIX]

Zitat:

Zitat von Externes Forum

So, das mit dem CRC oder Checksumme ist geklärt :wink:
Der Code wird in Blöcke geteilt und von jedem Block eine Xor-Checksumme gebildet! Habe mir den Spaß erlaubt und eine kurze Datei als Test geschrieben, die man mit dem Datentool öffnen kann.

Code:

00000000 07 00 01 00 01 00 01 17 07 68 7E 01 00 02 02 01 .........h~.....
00000010 0A 00 03 00 00 4D 41 4C 49 42 4F 4F 00 42 02 00 .....MALIBOO.B..
00000020 04 53 00 55 07 00 05 46 4F 52 55 4D 20 00 61 00 .S.U...FORUM .a.
00000030 00 FF FF 04 00 00 52 41 44 00 53                .ÿÿ...RAD.S

Hier die Blöcke:

07 00 01 00 01 00 01 17 07 68 => 7E
01 00 02 02 01 0A 00 03 00 00 4D 41 4C 49 42 4F 4F 00 => 42
02 00 04 53 00 => 55
07 00 05 46 4F 52 55 4D 20 00 => 61
00 00 FF FF 04 00 00 52 41 44 00 => 53


...war doch ganz einfach :mrgreen:

:wall: :wall:

Naja nun ist die Lösung wahrscheinlich ganz nahe ;)
Ich glaube ich sollte mal schauen wie man das mit dem XOR mit Delphi macht...

Aso das Ergebnis der Testdatei sieht im Konverter so aus:

Code:

-definitions--------------------------------------------------------------------
[ id - name - data_format - data_names ]
0000 - MALIBOO - S - FORUM 
-daten--------------------------------------------------------------------------
MALIBOO : RAD
-eof----------------------------------------------------------------------------

[nicodex]

Zitat:

Zitat von ryLIX

Ich weiß leider nicht wie ich das Programm noch etwas mehr ausnutzen kann.
Asambler hab ich garkeine Ahnung von und mit Debugging hab ich auch nicht die große Erfahrung.

Nun, es gibt im Forum schon einige Leute, die mit einem Disassembler umgehen können :)

Offensichtlich wird das Format auch in einem anderen Forum analysiert - nur, dass dort das Datentool zur Verfügung steht...
(hättest du erwähnt, dass es eine CRC-Fehlermeldung gibt, hätte man auch danach suchen können)

[ryLIX]

Zitat:

Zitat von ryLIX

Was mir noch aufgefallen ist ist folgendes:
Das Konvertierungsprogramm macht einen CRC Check. Wenn man nun ein Zeichen hinzufügt bzw löscht kommt der CRC Fehler.
Wenn aber nur zwei Zeichen vertauscht geht es ohne Probleme.

Hab ich doch ;)
Schau dir mal den Ahang an vielleicht kannst du damit was Anfangen.

[nicodex]

Zitat:

Zitat von ryLIX

Schau dir mal den Ahang an vielleicht kannst du damit was Anfangen.

Jupp, kann ich - siehe Anhang.
(ist einfach nur nachprogrammiert, ich hätte diversen Typen/Funktionen/Variablen andere Namen gegeben und anstatt Assign/Reset/Read/Close mit Sicherheit TMemoryStream verwendet (auch für die Analyse der Datenblöcke)).

Kurzer Überblick:

Code:

while (!eof)
{
  uint8_t  Size;
  uint16_t ID;
  uint8_t  Data[Size];
  uint8_t  Checksum;  // xor Size,ID,Data[...]
};

Die Interpretation von Data[] hängt von der ID ab:

Code:

// ID(0x0100): // definition block start
// ID(0x0200): // definition block header
// ID(0x0300): // definition name
//      uint16_t ID;
//      uint8_t  Name[Size - sizeof(ID)];  // includes '\0'
// ID(0x0400): // definition data_format
//      uint8_t  DataFormat[Size];  // includes '\0'
// ID(0x0500): // definition data_names
//      uint8_t  DataNames[Size];  // includes '\0'
// ID(0xFF00): // data block start
// ID(<else>): // ID == Definition[x].ID
//      uint8_t  Data[Size];  // parse with Definition[x].DataFormat

Für die Implementation von ParseData() bin ich zu faul - viel Spaß ;)

[ryLIX]

Öhm ja
Erstmal danke nicodex :hello:

Dann werde ich mich mal über das ganze her machen und versuchen zu verstehen was da abgeht.
Einen kleinen Überblick habe ich mir gerade verschafft.
Ich hoffe das du mir noch in wenig zur Seite stehst wenn ich Fragen zu ParseData habe ;)

Aber ich will versuchen so viel wie möglich allein zu schaffen sonst war ja noch nicht mal ein lern Effekt dabei :D

:dp:

[ryLIX]

So nach dem ich nun einige Zeit damit verbracht habe zu verstehen was dort passiert :D sind noch ein paar Fragen offen.

Delphi-Quellcode:

GDefinitons[Index].ID := (ABlock.Data[1] shl 8) + ABlock.Data[0];

Hier ist mir der Sinn noch nicht ganz klar. Wie muss ich mir den Inhalt von ABlock.Data vorstellen?

Delphi-Quellcode:

ParseData(ABlock.Size, @ABlock.Data[0], GDefinitons[Index].DataFormat);

Hier wird nun Size übergeben. Aber von was? Von Data?

Bei der Implementation von ParseData() fehlt mir irgendwie noch der richtige Lösungsansatz.
Eine Fall Entscheidung mit case durch das mitgelieferte DataFormat ist nicht möglich da ein String nicht Ordinal ist.
Ich hab irgendwie das Gefühl ich seh den Wald vor lauter Bäumen nicht...
:wiejetzt:

[nicodex]

Zitat:

Zitat von ryLIX

Wie muss ich mir den Inhalt von ABlock.Data vorstellen?

Als Folge von Bytes, deren Interpretation von der ID des Datensatzes abhängt.
(in diesem Fall ein little-endian Word, welches aus zwei Bytes zusammengesetzt wird)

Zitat:

Zitat von ryLIX

Hier wird nun Size übergeben. Aber von was? Von Data?

Ja.

Zitat:

Zitat von ryLIX

Bei der Implementation von ParseData() fehlt mir irgendwie noch der richtige Lösungsansatz.
Eine Fall Entscheidung mit case durch das mitgelieferte DataFormat ist nicht möglich da ein String nicht Ordinal ist.

case AFormat[x] of würde funktionieren.

Welche Delphi-Version verwendest du? Und in welchem Kontext sind die Dateien zu betrachten (nur für BMW oder auch andere Fahrzeuge, sind es allgemeine Datensätze oder gehören sie nur zu einer einzigen Software, ...)?

[ryLIX]

Zitat:

Zitat von nicodex

case AFormat[x] of würde funktionieren.

:wiejetzt:
Dann müsste ich AFormat als neues Arry erstellen richtig?
Bin gerade etwas verwirrt da ich heut als ablenkung Angefangen hab die Oberfläche der Software zu designen (es wird noch mehr gemacht als nur das Parsen).

Zitat:

Zitat von nicodex

Welche Delphi-Version verwendest du?

Turbo Delphi Explorer 2006

Zitat:

Zitat von nicodex

Und in welchem Kontext sind die Dateien zu betrachten (nur für BMW oder auch andere Fahrzeuge, sind es allgemeine Datensätze oder gehören sie nur zu einer einzigen Software, ...)?

Nur BMW, nur eine Software.

Es ist ein komplettes Softwarepaket von BMW.
Bei den hier verwendeten Daten geht es nur um die Codierdaten die in den Beispieldateien abgelegt sind die im ersten Beitrag angehängt sind.

Diese Teilen sich in eine feste Ordnerstruktur auf Sortiert nach Baureihe.

Code:

Hauptordner
-Data
--E* // Baureihe 'E'+ zwei Zahlen
---Codierdaten_Datei.C* // Die Dateiendung gibt den Codierindex vor also quasi die Softwareversion des Steuergerätes

Kurz noch was zur Funktion des Programms:
Sinn ist es erst einmal aus den Codierdateien die Möglichen Funktionen des Steuergerätes mit den dazugehörenden Parametern auszulesen und sortiert in Klartext darzustellen.
Speichern kann man alle zwischen Schritte des Parsens also Funktionsschlüsselwort Datei, Parameter Datei, Steuergeräte Datei und die Klartextanzeige.

Performance ist erst einmal Nebensache die Funktion steht im Vordergrund. Obwohl ich wohl das einlesen der Rohdaten auf TMemoryStream umstellen werde weil es auch so geplant war. Aber du hast da was fertiges geliefert also verwende ich das vorerst.

So genug geschrieben 8)
Wenn noch mehr Fragen sind nich zurück halten... mach ich ja auch nich :D