Intelhex-File mit C einlesen

[Markus (Gast)]

Hallo zusammen,

ich möchte ein Intelhex-File Zeile für Zeile einlesen. Das klappt auch 
soweit, aber er liest jedes Zeichen als char. Wie kann ich denn die 
Datenbytes gleich als Hexzahlen einlesen?

Ich habe versucht jedes Char-Paar über eine switch-Anweisung wieder 
zurück zu wandeln. Geht auch. Aber das muss doch auch einfacher gehen - 
oder?

Gruß
Markus

[Klaus W. (mfgkw)]

Mit scanf() bzw. sscanf()

[Markus (Gast)]

Das habe ich bisher verbrochen:

    FILE *fil;
    char buffer[16];
    fil = fopen("test.hex", "r");

    if (fil == NULL) {
        printf("\nDatei test.txt kann nicht geöffent werden\n");
        exit(-1);
    }

    while(!feof(fil)) {

    fgets (zeichen, LINE_LENGTH, fil);
    if (!feof(fil)) printf("%.*s",LINE_LENGTH, zeichen);
    }

    fclose (fil);


Ziel soll sein, dass ich aus jeder Zeile die 16 Datenbytes herausziehe 
und in einen Array (buffer) schreibe.

[Karl H. (kbuchegg)]

Markus schrieb:
> Das habe ich bisher verbrochen:
>
>     FILE *fil;
>     char buffer[16];

nicht char.
char benutzt du ausscchliesslich für Buffer die reinen Text enthalten. 
Du willst letztendlich Bytes formen. Also nimmst du unsigned char.

>     fil = fopen("test.hex", "r");
>
>     if (fil == NULL) {
>         printf("\nDatei test.txt kann nicht geöffent werden\n");
>         exit(-1);
>     }
>
>     while(!feof(fil)) {

Falsch.
feof ist ein Test mit dem man hinterher feststellt, warum eine 
Leseoperation schief gelaufen ist. Die zentrale Einleseschleife wird 
niemals von feof abhängig gemacht. In C liefert jede Lesefunktion einen 
Returnwert, aus dem sich ablesen lässt, ob die Operation gut gegangen 
ist oder nicht.

Achtung: Eine Leseoperation kann aus vielen Gründen schief gehen, nicht 
nur EOF. NIcht zuletzt deshalb ist es auch unlogisch, die while Schleife 
auf feof basieren zu lassen.


>
>     fgets (zeichen, LINE_LENGTH, fil);

ist schon mal ein guter Anfang.

> Ziel soll sein, dass ich aus jeder Zeile die 16 Datenbytes herausziehe
> und in einen Array (buffer) schreibe.

Bleib bei der Strategie erst mal eine Zeile komplett einzulesen. Hast du 
sie erst mal als String im Speicher, kannst du sie in aller Ruhe 
zerlegen und analysieren. Vor allen Dingen in Fehlerfällen ist das 
einfacher, als wenn man gleich beim Einlesen die Zeile zerlegen lassen 
will

    FILE *fil;
    unsigned char buffer[16];
    fil = fopen("test.hex", "r");

    if (fil == NULL) {
        printf("\nDatei test.txt kann nicht geöffent werden\n");
        exit(-1);
    }

    while( fgets (zeichen, LINE_LENGTH, fil) ) {
      printf("%.*s",LINE_LENGTH, zeichen);
    }

    if( !feof(fil) )
      printf( "Fehler beim Einlesen der Datei!\n" );

    fclose (fil);

So sieht die klassische Leseschleife in C aus.

Als nächstes siehst du dir den Aufbau einer Zeile an.
Und du liest über sscanf (bzw.) scanf in deinem C-Buch nach, ob und wie 
du mit dem Formatstring sscanf dazu bringen kannst, die ganze Arbeit für 
dich zu machen.

> Ich habe versucht jedes Char-Paar über eine switch-Anweisung wieder
> zurück zu wandeln.

Das ist ein bischen aufwändig. Das geht auch deutlich einfacher.
Wenn du mit sscanf nicht klar kommst, dann schreib dir eine Funktion, 
die 2 Zeichen übernimmt, diese als ASCII Repräsentierung von Hex-Digits 
interpretiert und daraus das Byte zusammensetzt.
Es gibt einen Zusammenhang zwischen dem ASCII Code von Ziffern und 
Zeichen und dem was man binär daraus generieren will.

Das ASCII Zeichen für '0' hat den ASSCII Code 0x30
Das Zeichen '1' hat den ASCII Code 0x31, etc. für alle Ziffern.

Zieht man daher von einem Zeichen den ASCII Code von '0' ab, dann hat 
man unmittelbar die Zahl die diesem Zeichen entspricht. Bei den 
Buchstaben 'A' bis 'F' ist es ähnlich.
Dein erstes Ziel: SChreib eine Funktion, der du 1 Zeichen vorgibst, 
welches entweder '0'..'9' oder 'A'..'F' sein kann, und welches dir 
daraus eine Zahl 0..15 errechnet, je nach Zeichen.

[Klaus W. (mfgkw)]

Auch wenn es KHB sauer aufstößt, daß ich nicht erst eine Zeile
einlese (was sicher auch nicht falsch wäre), hier ein Beispiel
mit allen nötigen scanf-Formaten:

/* Time-stamp: "09.09.10 22:08 intelhex.c klaus?wachtler.de"
 *
 * Lesen einer Intel-Hex-Datei
 *
 * [1] http://de.wikipedia.org/wiki/Intel_HEX
 *
 */

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>


int main( int nargs, char **args )
{
  FILE            *f      = fopen( "a.hex", "r" );
  unsigned long    iZeile = 0;
  uint8_t          data[128];    // Platz für Daten aus einer Zeile

  if( f )
  {
    while( "mehr daten" )
    {
      unsigned int    bytecount, address, recordtype, checksum;

      iZeile++;
      if( fscanf( f, " :%2x%4x%2x", &bytecount, &address, &recordtype )!=3 )
      {
        fprintf( stderr, "Zeilenstart nicht lesbar in Zeile %lu\n", iZeile );
        return 1;
      }
      else if( bytecount>sizeof(data) )
      {
        fprintf( stderr, "Zeile zu lang\n" );
        return 1;
      }
      else if( recordtype==1 )
      {
        fprintf( stderr, "End of file erreicht\n" );
        break;
      }
      else if( recordtype!=0 )
      {
        fprintf( stderr, "Recordtyp unbekannt, ignoriert\n" );
        continue;
      }
      else
      {
        unsigned int    own_checksum = 0;
        own_checksum -= bytecount;
        own_checksum -= ( address & 0xFF ) + (address >> 8);
        own_checksum -= recordtype;
        unsigned int iDatabyte;
        for( iDatabyte=0; iDatabyte<bytecount; ++iDatabyte )
        {
          unsigned int    c;
          if( fscanf( f, "%2x", &c )!=1 )
          {
            fprintf( stderr, "Zeichen %d in Zeile %lu nicht lesbar\n",
                     iDatabyte,
                     iZeile
                     );
            return 1;
          }
          else
          {
            // ok, Zeichen gelesen
            data[iDatabyte] = c;
            own_checksum -= data[iDatabyte];
          }
        }
        if( fscanf( f, "%2x", &checksum )!=1 )
        {
          fprintf( stderr, "Lesefehler bei Checksumme in Zeile %lu\n", iZeile );
          return 1;
        }
        else
        {
          // Checksumme vergleichen:
          fprintf( stderr, "Checksumme %02x %02x\n", own_checksum&0xFF, checksum );
        }

        // Kontrollausgabe:
        unsigned int iZeichen;
        printf( "adr=%04x ", address );
        for( iZeichen=0; iZeichen<bytecount; ++iZeichen )
        {
          printf( " 0x%02x", data[iZeichen] );
        }
        printf( "\n" );

      }
    }
  }
  else
  {
    fprintf( stderr, "Datei nicht zu oeffnen\n" );
  }


  return 0;
}

Die Datei wird nicht geschlossen, aber das ist mir für das Beispiel 
egal.
Außerdem könnte man noch die Adressen kontrollieren.

Meine Beispieldatei:

:100000000C94B9000C94D6000C94D6000C94D60035
:100010000C94D6000C94D6000C94D6000C94D60008
:100020000C94D6000C94D6000C94D6000C94D600F8
...
:101668006E76616C6964005769647468546F6F536F
:081678006D616C6C003F000085
:00000001FF

Die Ausgabe:

Checksumme 35 35
adr=0000  0x0c 0x94 0xb9 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00
Checksumme 08 08
adr=0010  0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00
Checksumme f8 f8
adr=0020  0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00 0x0c 0x94 0xd6 0x00
...
Checksumme 6f 6f
adr=1668  0x6e 0x76 0x61 0x6c 0x69 0x64 0x00 0x57 0x69 0x64 0x74 0x68 0x54 0x6f 0x6f 0x53
Checksumme 85 85
adr=1678  0x6d 0x61 0x6c 0x6c 0x00 0x3f 0x00 0x00
End of file erreicht

[Markus (Gast)]

Vielen Dank euch beiden!

Da habe ich erstmal genügend Stoff, mit dem ich mich beschäftigen kann. 
:-)

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Auch wenn es KHB sauer aufstößt, daß ich nicht erst eine Zeile
> einlese

LOL
Stösst mir überhaupt nicht sauer auf.

Dein Programm wird sich nur hier

      else if( recordtype!=0 )
      {
        fprintf( stderr, "Recordtyp unbekannt, ignoriert\n" );
        continue;
      }

schwer tun, sich wieder auf den nächsten Datensatz zu synchronisieren.
(Ich weiß, man kann das beheben)

[Klaus W. (mfgkw)]

wohl war.
Du willst bestimmt drauf raus, daß man erst die ganze Zeile liest?

Wobei ich gar nicht weiß, ob es Sinn macht, bei anderen
Typen einfach stillschweigend weiter zu machen.
Wenn die vorkommen (?), müssen sie auch vrmtl. behandelt werden

[Markus (Gast)]

Alles was bei mir momentan rauskommt ist folgendes:

Recordtyp unbekannt, ignoriert
Zeilenstart nicht lesbar in Zeile 2


Da werde ich wohl noch etwas anpassen müssen. ;-)

Der Start von meinem Hexfile sieht übrigens so aus:

:020000040000FA
:10000000EA00FF32EA0067FEEA006ECEEA0067E02F
:10001000EA0067C3EAFFFFFEEA006293EA006C4071
:1000200047D4AB7B000213380400002000106B059E
:10003000000000030003FFE0BDFA1FF77F352265D3
...

[Klaus W. (mfgkw)]

Schau doch mal den Link am Anfang von meinem Quelltext an!
Da ist das Format beschrieben.

Ich habe in meinem Beispiel nur die Typen 0 (Daten) und 1 (EOF).
Deshalb habe ich mein Beispielprogramm nur darauf abgestellt.

Bei dir ist die erste Zeile etwas ganz anderes: Typ 2
(Extended Segment Address Record/Real Mode-Adressierung).

Das heißt, du musst diesen Fall im if...else if... auch abfangen
und mehr oder weniger sinnvoll darauf reagieren.
Das kannst du bestimmt selber...

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> wohl war.
> Du willst bestimmt drauf raus, daß man erst die ganze Zeile liest?

Ich denke für jemanden (den TO) der das erste mal ein File einliest, ist 
das gut genug. Das passt schon.

Für mich persönlich würde ich eine Kombi machen.
Ist doch simpel die Zeile zunächst mittels fgets einzulesen und dann im 
Prinzip deinen Code zu nehmen, die fprintf durch sscanf ersetzen, noch 
einen char-Pointer als 'File-Pointer' und läuft schon.

Aber das ist für den TO sicherlich jetzt noch nicht notwendig. 
File-einlesen absolut abzusichern, so dass nichts passieren kann, ist 
für uns Profis eine Notwendigkeit (egal was ein Kunde dieser Funktion 
vorsetzt, sie darf Fehlermeldungen werfen so viele sie will, nur 
abstürzen darf sie auf keinen Fall) für den Heimgebrauch kann man ruhig 
die Ansprüche runterschrauben.

>
> Wobei ich gar nicht weiß, ob es Sinn macht, bei anderen
> Typen einfach stillschweigend weiter zu machen.

Kann ich nicht sagen.
Gibts im Intel-Hex Format überhaupt noch andere Codes?

Fass den Einwand, den ich da vorgebracht habe bloss nicht als Kritik um 
der Kritik willen auf. So war das ganz sicher nicht gedacht.

[Klaus W. (mfgkw)]

Klaus Wachtler schrieb:
> Bei dir ist die erste Zeile etwas ganz anderes: Typ 2
> (Extended Segment Address Record/Real Mode-Adressierung).

Korrektur: du hast hier Typ 4 (Extended Linear Address
Record/32Bit-Adressierung).

[Klaus W. (mfgkw)]

Karl heinz Buchegger schrieb:
> Kann ich nicht sagen.
> Gibts im Intel-Hex Format überhaupt noch andere Codes?

Angeblich 6 Stück.
http://de.wikipedia.org/wiki/Intel_HEX


> Fass den Einwand, den ich da vorgebracht habe bloss nicht als Kritik um
> der Kritik willen auf. So war das ganz sicher nicht gedacht.
:-)

So sensibel bin ich nicht. Als Maschinenbauer eher gefühl- und 
regungslos.

[Markus (Gast)]

Karl heinz Buchegger schrieb:
> ein Programm wird sich nur hier      else if( recordtype!=0 )
>       {
>         fprintf( stderr, "Recordtyp unbekannt, ignoriert\n" );
>         continue;
>       }
> schwer tun, sich wieder auf den nächsten Datensatz zu synchronisieren.
> (Ich weiß, man kann das beheben)

Genau dieses Problem habe ich gerade noch... ;-)

den Typ 4 fange ich bereits ab... aber hier fehlt es mir noch.

[Karl H. (kbuchegg)]

Markus schrieb:

>> schwer tun, sich wieder auf den nächsten Datensatz zu synchronisieren.
>> (Ich weiß, man kann das beheben)
>
> Genau dieses Problem habe ich gerade noch... ;-)
>
> den Typ 4 fange ich bereits ab... aber hier fehlt es mir noch.

Und genau deswegen hab ich in letzter Zeit immer mehr Bauchweh, wenn 
fertige Lösungen präsentiert werden.
Hand aufs Herz: Du hast noch nicht nachgelesen wie die Einzelteile, die 
du noch nicht verstehst eigentlich funktionieren.

[holger (Gast)]

>den Typ 4 fange ich bereits ab... aber hier fehlt es mir noch.

Schmeiß die Zeile weg, der Offset ist Null;)

[Markus (Gast)]

nein habe ich nicht... ich bin gerade dabei den Code Stück für Stück 
auseinanderzunehmen. Und "fertige" Lösungen nehme ich trotzdem 
auseinander - so viel Ehrgeiz habe ich, dass ich mir das anschaue und 
verstehen möchte. Man lernt dabei unheimlich viel!

[Klaus W. (mfgkw)]

Eben, hast ja noch viel Zeit bis morgen früh.

[Karl H. (kbuchegg)]

holger schrieb:
>>den Typ 4 fange ich bereits ab... aber hier fehlt es mir noch.
>
> Schmeiß die Zeile weg, der Offset ist Null;)

Kann er nicht.
Er muss sie schon lesen, sonst geht die Synchronisierung verloren und er 
findet den nächsten Zeilenanfang nicht.
Liest er sie aber, dann kann er auch gleich die Zahlenwerte rausholen. 
Ob er damit was macht, ist eine andere Geschicht. Aber der einfachste 
Weg ist es in diesem Fall tatsächlich, die Zeile zu ende zu lesen. Ist 
ja nur noch eine 2 Byte Zahl und die Checksumme. Wenn er mit 
Formatstrings umgehen kann (und sich bei den anderen Daten ansieht wie 
Klaus ihm das vorgemacht hat), ist das nicht weiter schwer.

[Klaus W. (mfgkw)]

Mit scanf kann man auch überlesen, ohne etwas zu nutzen (mit einem *).
Da kann man jetzt streiten, ob es "wegwerfen" ist oder "lesen".

[Karl H. (kbuchegg)]

Klaus Wachtler schrieb:
> Mit scanf kann man auch überlesen, ohne etwas zu nutzen (mit einem *).
> Da kann man jetzt streiten, ob es "wegwerfen" ist oder "lesen".

Lass ihn mal die Standardsachen im Formatstring erlernen, ehe du mit den 
Spezialitäten kommst :-)
Die 2 zusätzlichen Variablen, die er dann noch braucht, bringen ihn auch 
nicht um :-) und der Rest ist Kontrolle, ob er den Aufbau eines 
Formatstrings verstanden hat.

[Markus (Gast)]

hab den Code recht schnell kapiert und das Problem mit folgender Zeile 
gelöst:

fscanf( f, "%4x%2x", &storage_address, &checksum);


wie kann man mit "*" die 6 Zeichen überlesen? neugier

[Klaus W. (mfgkw)]

fscanf( f, "%*4x%*2x" );

Siehe die Doku zu scanf....

http://www.wachtler.de/ck/19_4_Liste_Funktionen.html#SECTION0002049200000000000000

[Markus (Gast)]

Vielen Dank nochmals für die super Hilfe und die ganzen Tips.

[Oliver (Gast)]

Hallo Ihr Lieben,

vor vielen, vielen Jahren habe ich mich ganz passabel in GFA-Basic 
ausgekannt und damit so einiges programmiert. Nun mache ich meine ersten 
Schritte in C++, trotz einiger Ähnlichkeiten sehe ich mich zwangsläufig 
also darin noch als Anfänger.

Nun möchte ich für ein opensource Projekt www.opcar.de ein ganz 
einfaches Tool entwickeln, mehrere in einer eep Datei gespeichertes CVs 
ändern zu können, diese geänderten CVs anschließend wieder in eine eep 
Datei zurück zuschreiben um diese dann mit dem AVRootloader in die 
Fahrzeuge zu schreiben.  Auf jegliche Grafik soll bewusst verzichtet 
werden, ein reines Zweckwerkzeug.

Bei meinen Recherchen bin ich auf diesen Beitrag hier gestoßen und habe 
den veröffentlichten Code an meine Bedürfnisse angepasst. Damit lassen 
sich die CVs einlesen und bearbeiten. Für diejenigen, die damit 
"spielen" wollen, ist eine erforderliche eep angehängt.

Nun möchte das Rückschreiben in die eep Datei schreiben, stoße dabei 
aber an meine Grenzen. Wenn ich es richtig verstanden habe, muss ich

1) immer 15 CVs in einem String zusammenfassen
2) Zeilennummer ergänzen
3) Prüfsumme neu berechnen
4) Zeilenweise in Datei schreiben

Aber wie ? Könnt Ihr bitte helfen. Vielen Dank.

#include <iostream>
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <iomanip>

using namespace std;

int main(void)
{
int cv = 0;
int max_cv;
int cv_wert [255];
int cv_auswahl;
int cv_wert_neu; // Variablen für Datenübernahme einrichten
char pruefung;
        
//Den folgenden Code habe ich dem Beitrag von Klaus Wachtler auf der Seite http://www.mikrocontroller.net/topic/189911
//entnommen und in Teilen angepasst    
    
  FILE            *f      = fopen( "open_car.eep", "r" );
  unsigned long    iZeile = 0;
  uint8_t          data[128];    // Platz für Daten aus einer Zeile

  if( f )
  {
    while( "mehr daten" )
    {
      unsigned int    bytecount, address, recordtype, checksum;

      iZeile++;
      if( fscanf( f, " :%2x%4x%2x", &bytecount, &address, &recordtype )!=3 )
      {
        fprintf( stderr, "Zeilenstart nicht lesbar in Zeile %lu\n", iZeile );
        //return 1;
      }
      else if( bytecount>sizeof(data) )
      {
        fprintf( stderr, "Zeile zu lang\n" );
        //return 1;
      }
      else if( recordtype==1 )
      {
        fprintf( stderr, "Ende der Datei erreicht\n" );
        cout <<"Insgesamt ";
        max_cv = cv-1;
        cout << max_cv;
        cout <<" CVs gelesen\n";
        cout << "\n";
        break;
      }
      else if( recordtype!=0 )
      {
        fprintf( stderr, "Recordtyp unbekannt, ignoriert\n" );
        continue;
      }
      else
      {
        unsigned int    own_checksum = 0;
        own_checksum -= bytecount;
        own_checksum -= ( address & 0xFF ) + (address >> 8);
        own_checksum -= recordtype;
        unsigned int iDatabyte;
        for( iDatabyte=0; iDatabyte<bytecount; ++iDatabyte )
        {
          unsigned int    c;
          if( fscanf( f, "%2x", &c )!=1 )
          {
            fprintf( stderr, "Zeichen %d in Zeile %lu nicht lesbar\n",
                     iDatabyte,
                     iZeile
                     );
            //return 1;
          }
          else
          {
            // ok, Zeichen gelesen
            data[iDatabyte] = c;
            own_checksum -= data[iDatabyte];
          }
        }
        if( fscanf( f, "%2x", &checksum )!=1 )
        {
          fprintf( stderr, "Lesefehler bei Checksumme in Zeile %lu\n", iZeile );
          //return 1;
        }
        else
        {
          // Checksumme vergleichen:
          //fprintf( stderr, "Checksumme %02x %02x\n", own_checksum&0xFF, checksum );
        }

        // Kontrollausgabe:
    unsigned int iZeichen;
        //printf( "adr=%04x \n", address );
        
        for( iZeichen=0; iZeichen<bytecount; ++iZeichen )
        {
          cv_wert[cv] = data[iZeichen];
      ++cv;
          }
        }
    }
  }
  else
  {
    fprintf( stderr, "Datei nicht zu oeffnen\n" );
  }

// Ab hier geht jetzt selber weiter   
// Jetzt Daten anzeigen ********************************************************
cout << "Um die Daten anzuzeigen Taste druecken  \n";
cin.get();

while (cv_auswahl != 0)
{
  for( cv=1; cv<=max_cv; ++cv )
  {
    cout << "CV [" << setw(3) << cv <<"]: " << setw (3) << cv_wert [cv] << " \t";
  }
  cout << "\n";
  
// Und jetzt ändern ************************************************************
    cout << "Welche CV moechtest Du aendern ? [0=Exit]";
    cin >> cv_auswahl;
    
    if (cv_auswahl != 0)
       {
     cout << "Ok. CV [" << cv_auswahl << "] hat momentan den Wert " << cv_wert [cv_auswahl] << "\n" << "Neuer Wert ?";
       cin >> cv_wert_neu;
    
// Nochmal prüfen **************************************************************
       cout << "Ok. CV [" << cv_auswahl << "] hat noch den Wert "  << cv_wert [cv_auswahl] <<  ". Neuer Wert " << cv_wert_neu <<".\n";
       cout << "Wirklich aendern [j/n] ? ";
       cin >> pruefung;
     if (pruefung == 'j')
     {
      cv_wert [cv_auswahl] = cv_wert_neu;
      }
  }
}
cout << "\n";
cout << "CV-Werte nach Aenderung \n";
for( cv=1; cv<=max_cv; ++cv ) //nochmal zur Prüfung anzeigen
  {
    cout << "CV [" << setw(3) << cv <<"]: " << setw(3) << cv_wert [cv] << " \t";
  }
  cout <<"\n";
  cout <<"Diese Werte speichern [j/n]?\n";
  cin >> pruefung;
  
//Und jetzt Daten zurückschreiben
  if (pruefung == 'j')
     {
    
    }
          
      
  
  cin.get();
  return 0;    
}