GPS-String zerlegen mit C für AVR

[Jürgen (Gast)]

Hallo,
als blutiger Anfänger in Sachen 'C' mit AVR versuche ich den String 
einer GPS-Maus zu lesen.
Das klappt eigentlich schon gut, nun will ich ihn in seine Bestandteile 
zerlegen.
Ich habe ein paar Beispiele mittels der Suche gefunden, fast alles ist 
aber mit Bascom gemacht.
Auch habe ich ein paar wenige Beispiele mit der C-Funktion strtok 
gesehen, die gibt es aber beim AVR nicht (heißt wohl strtok_r).

Kann mir bitte jemand ein einfaches, nachvollziehbares  Beispiel geben,
mit dem ich einen empfangenen String der GPS-Maus in seine Bestandteile 
zerlegen kann,
so dass jeder Teilstring in einem eigenen String gespeichert wird?

Vielen Dank,
Jürgen

[Nils (Gast)]

Hallo Jürgen,

das kann man so pauschal nicht sagen. Es kommt immer darauf an, was du 
mit den einzelnen Teilstrings machen möchtest. Die Zeichen die du 
empfängst sind ja ascii Zeichen. Wenn du also was mit ...,1234,... 
empängst, kannst du zum beispiel einer Variable nicht einfach den String 
zuweisen, sondern musst ihn erst mal konvertieren.

Sag uns doch einfach mal, was du so vor hast mit den Informationen von 
der GPS Maus. Willst du sie nur wieder irgendwo anzeigen oder verwerten?

Gruss
Nils

[gast (Gast)]

da es ein langer string ist der meist mit ',' getrennt ist kann man 
danach suchen

char *temp;

temp = strchr( ****string , ',' );
temp is dann ein zeiger auf das erste komma

wenn man nun das ganze wiederholt aber anstatt dem string den zeiger+1 
übergibt
sucht man weiter im string das nächste komma

zB geht das so .. gibt aber noch andere möglichkeiten

[Klaus W. (mfgkw)]

sscanf() ist die nächste Möglichkeit.

Wenn er mal so einen String zeigen würde....

[Jürgen (Gast)]

Hi,
also, ich empfange zum Beispiel den String

$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,E,A*19

Den möchte ich zerlegen, so dass ich nachher neue Strings habe:
Zeit = "191410"
Breitengrad = "4735.5634"
Laengengrad = "00739.3538" usw.

Vielen Dank,
Jürgen

[Klaus W. (mfgkw)]

Und du brauchst die wirklich als Strings, nicht als Zahlen?
Ist das Format immer das gleiche (13 Strings, mit Komma getrennt)?

[Klaus W. (mfgkw)]

  char gpsstring[] = "$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,E,A*19";

  char puffer_cmd[10];
  char puffer_a[10];
  char puffer_b[10];
  char puffer_c[10];
  char puffer_d[10];
  char puffer_e[10];
  char puffer_f[10];
  char puffer_g[10];
  char puffer_h[10];
  char puffer_i[10];
  char puffer_j[10];
  char puffer_k[10];
  char puffer_l[10];

  if( sscanf( gpsstring,
          "%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,],%[^,]",
          puffer_cmd,
          puffer_a,
          puffer_b,
          puffer_c,
          puffer_d,
          puffer_e,
          puffer_f,
          puffer_g,
          puffer_h,
          puffer_i,
          puffer_j,
          puffer_k,
          puffer_l
          )
      ==13
      )
  {
    printf( "letzter ist %s\n", puffer_l );
  }

Die Namen sind natürlich verbesserungswürdig, z.B. Breitengrad statt 
puffer_c...

[Klaus W. (mfgkw)]

ach ja: falls du einzelne nicht brauchst, kann man statt

%[^,]

auch

%*[^,]

schreiben und den entsprechenden Puffer weglassen.

[Jürgen (Gast)]

jepp, ich hätte das gerne als Strings.
@Klaus: Ich werde das morgen mal ausprobieren.


Danke,
Jürgen

[gast (Gast)]

ich wäre für eine elegante strchr  lösung ^^

hatte einmal sprint und so genutzt ..
allein das einbinden der lib stört mit seinen >500byte doch etwas

bei 500bate bekommt man locker das mit den normalen stringfunktionen hin
inkl umwandlung mit atoi und CO

[Klaus W. (mfgkw)]

Die 10 ist übrigens an mindestens einer Stelle zu knapp....

Man kann das testen lassen, indem man statt

%[^,]

besser:

%9[^,]

angibt; dann werden maximal 9 Zeichen verwendet (und damit ist
noch Platz für die abschließende 0 im Puffer bei 10 Zeichen).
Reicht das nicht, bricht sscanf() ab und liefert dann nicht 13
zurück, sondern entsprechend weniger.

[Klaus W. (mfgkw)]

gast schrieb:
> ich wäre für eine elegante strchr  lösung ^^
>
> hatte einmal sprint und so genutzt ..
> allein das einbinden der lib stört mit seinen >500byte doch etwas
>
> bei 500bate bekommt man locker das mit den normalen stringfunktionen hin
> inkl umwandlung mit atoi und CO

Das ist wahr; dann ist aber strtok() einfacher und braucht auch
nicht viel Platz. Letztlich macht sie ja auch nichts anderes,
als nach dem Trennzeichen zu suchen und mit einer terminierenden
0 zu überschreiben.

#include <string.h>

...
  char gpsstring[] = "$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,E,A*19";

  char *puffer_cmd;
  char *puffer_a;
  char *puffer_b;
  char *puffer_c;
  char *puffer_d;
  char *puffer_e;
  char *puffer_f;
  char *puffer_g;
  char *puffer_h;
  char *puffer_i;
  char *puffer_j;
  char *puffer_k;
  char *puffer_l;

  char *saveptr = NULL;

  if( ( puffer_cmd = strtok_r( gpsstring, ",", &saveptr ) )
      &&
      ( puffer_a = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_b = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_c = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_d = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_e = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_f = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_g = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_h = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_i = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_j = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_k = strtok_r( NULL, ",", &saveptr ) )
      &&
      ( puffer_l = strtok_r( NULL, ",", &saveptr ) )
      )
  {
    printf( "letzter: %s\n", puffer_l );
  }
  else
  {
    printf( "oioioi!\n" );
  }

Dabei wird der gpsstring an den Trennzeichen von strok_r()
überschrieben!
Dafür hat man kein Problem mit Pufferlängen mehr.

[spess53 (Gast)]

Hi

Nur als Hinweis: Die Funktionen sollten auch mit 'leeren Strings' 
zwischen zwei Kommas zurechtkommen.

MfG Spess

[Klaus W. (mfgkw)]

strtok_r kann man dann auch verwenden; allerdings muß man das if
davor ändern. strtok_r() liefert dann nämlich NULL (was in meinem
Beispiel als Fehler interptetiert wird).

[STK500-Besitzer (Gast)]

Ich würde sowas mit einer Statemachine machen...

[Klaus W. (mfgkw)]

nur zu!

[Michael K. (Gast)]

Schau mal, ob der der GPS Empfänger auch UBX spricht ... dann erübrigt 
sich die ganze "Parserei" ...

Grüße,
Michael

[Manuel E. (defi)]

Klaus Wachtler schrieb:
> strtok_r kann man dann auch verwenden; allerdings muß man das if
> davor ändern. strtok_r() liefert dann nämlich NULL (was in meinem
> Beispiel als Fehler interptetiert wird).


Hallo,

ich grab den Beitrag mal wieder aus.
bin ein ziemlicher Fan von strtok(), obwohl dieser bei NMEA-Strings den 
ersten token überspringt und destruktiv arbeitet, ist er sehr schnell.

habe aber das Problem, dass strtok() nicht mit 'leeren Strings' zwischen 
zwei Kommas zurechtkommt.

Kann mir jemand helfen und sagen wie man den Code von Klaus Wachtler 
umändern muss, dass strtok_r() den Bereich zwischen 2 Kommas (",,") 
nicht überspringt?

gruss,
defi

[Martin G. (mager)]

STK500-Besitzer schrieb:
> Ich würde sowas mit einer Statemachine machen...

http://arduiniana.org/libraries/tinygps/

[Manuel E. (defi)]

Danke für den link.

Bei der Statemaschine sind aber nur wenige NMEA Variablen integriert, um 
alle Variablen aus den verschiedenen NMEA-Sätzen auszulesen dauert es 
sehr lange.

Ich denke, dass strtok immer noch die beste Methode wäre, wenn das 
Problem mit den 2 Kommas nicht wäre.

[Karl H. (kbuchegg)]

Na ja, so einen "strtok Ersatz" hat man aber auch schnell selber 
gemacht.

ungetestet:

char * part;
char * pLoop;
char String[] = "a,b,,c,d";
uint8_t finished = false;


  pLoop = String;

  while( !finished ) {

    // pLoop zeigt auf den Anfang des nächsten Eintrags
    // wenn es keinen mehr gibt, dann ist *pLoop == 0

    if( *pLoop ) {
      // hier beginnt der Teilstring
      part = pLoop;

      // weiter bis zum Trennzeichen
      while( *pLoop && *pLoop != ',' )
        pLoop++;

      // am Ende angelangt ?
      if( *pLoop == '\0' )
        finished = true;
      else
        // den String dort unterteilen, so dass part einen gültigen
        // Teilstring ergibt
        *pLoop = '\0';

      // mach was mit part
      printf( "%s\n", part );

      // und die Voraussetzung für den nächsten Schleifendurchlauf
      // schaffen: pLoop zeigt auf den Anfang des nächsten Teilstrings
      pLoop++;
    }
  }

letzten Endes hast du keine grossen Anforderungen an den strtok Ersatz. 
Das ist einfach nur eine while-Schleife, bis das nächste Trennzeichen 
auftaucht. Pointer auf Anfang des Teilstrings, while-Schleife bis zum 
Trennzeichen, dort eine '\0' rein und man hat den Teilstring. Ein 
bischen aufpassen muss man noch, dass es zu keinen Komplikationen kommt, 
wenn kein Trennzeichen mehr gefunden wird und das wars dann auch schon.

[Klaus W. (mfgkw)]

So, jetzt wärme ich die Geschichte nochmal auf.

Ich hatte vor etlichen Tagen eine PM dazu bekommen wg. Leertoken
und strtok().
Leider kam ich erst nicht dazu und habe inzwischen versehentlich
die Mail gelöscht; sie war wohl von defi, sorry.

Meine Behauptung, daß strtok* mit leeren Token sinnvoll umgehen
würde, war voreilig.
Als Friedensangebot hier eine eigene Variante (viel kompakter
dürfte es nicht gehen; Ring frei!):

/* Time-stamp: "17.04.10 13:15 strtok_r_empty.c klaus?wachtler.de"
 *
 * Variante von strtok_r(), die auch mit leeren token umgehen kann.
 *
 * Lizenz MDWDW: Macht damit, was du willst.
 */

#include <stddef.h>
#include <string.h>

// variant of strtok_r() which finds empty tokens as well (sequences
// of delimiter characters will not be considered to be a single
// delimiter).
// If the start string contains too few tokens for the
// strtok_r_empty()-calls the excessive calls return empty strings.
char *strtok_r_empty( char *p_str, const char *p_delim, char **pp_save )
{
  // *pp_save will save the pointer to the start of the next
  // unprocessed token or NULL if there are no more tokens

  char *p_start = ( p_str ? p_str : *pp_save );
  if( p_start )
  {
    // look for start of next token, or NULL
    *pp_save = strpbrk( p_start, p_delim );

    if( *pp_save )
    {
      // delimiter found
      **pp_save = '\0'; // terminate current token
      ++*pp_save;       // skip delimiter on next call
    }
  }
  // return current token or NULL
  return p_start;
}

#include <stdio.h>

int main( int nargs, char **args )
{
  char gpsstring[] = "$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,,A*19";

  char *puffer_cmd;
  char *puffer_a;
  char *puffer_b;
  char *puffer_c;
  char *puffer_d;
  char *puffer_e;
  char *puffer_f;
  char *puffer_g;
  char *puffer_h;
  char *puffer_i;
  char *puffer_j;
  char *puffer_k;
  char *puffer_l;

  char *saveptr = NULL;

  if( ( puffer_cmd = strtok_r_empty( gpsstring, ",", &saveptr ) )
      &&
      ( puffer_a = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_b = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_c = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_d = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_e = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_f = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_g = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( puffer_h = strtok_r_empty( NULL, ",", &saveptr ) )
      &&
      ( ( puffer_i = strtok_r_empty( NULL, ",", &saveptr ) )||( puffer_i = "" ) )
      &&
      ( ( puffer_j = strtok_r_empty( NULL, ",", &saveptr ) )||( puffer_j = "" ) )
      &&
      ( ( puffer_k = strtok_r_empty( NULL, ",", &saveptr ) )||( puffer_k = "" ) )
      &&
      ( ( puffer_l = strtok_r_empty( NULL, ",", &saveptr ) )||( puffer_l = "" ) )
      )
  {
    printf( "erster:        <%s>\n", puffer_cmd );
    printf( "zweiter:       <%s>\n", puffer_a );
    printf( "vorvorletzter: <%s>\n", puffer_j );
    printf( "vorletzter:    <%s>\n", puffer_k );
    printf( "letzter:       <%s>\n", puffer_l );
  }
  else
  {
    printf( "oioioi!\n" );
  }

  return 0;
}

Es klappt mit leeren Token am Anfang, am Ende ebenso wie mittendrin.

[Klaus W. (mfgkw)]

Zum Thema kompakt: man könnte natürlich noch mind. zweimal je zwei
Zeilen zu einer zusammenfassen; das würde aber doch die Lesbarkeit
reduzieren...

[Andreas S. (andreas) (Admin)]

Noch eine einfache Alternative:

#include <stdio.h>

int str_split(char *s, char *parts[], char delimiter)
{
  int part_index = 0;
  parts[part_index++] = s;
  while (*s) {
    if (*s == delimiter) {
      *s = '\0';
      parts[part_index++] = s + 1;
    }
    s++;
  }
  return part_index;
}

int main( int nargs, char **args )
{
  char gpsstring[] = "$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,,A*19";
  char *parts[20];
  int i, num_parts;

  num_parts = str_split(gpsstring, parts, ',');
  for(i = 0; i < num_parts; i++) {
    puts(parts[i]);
  }

  return 0;
}

EDIT: verbessert

[Klaus W. (mfgkw)]

Wenn ich das richtig sehe, wird aber ein leeres Token am Ende damit 
nicht geliefert ("t1,t2,t3,")?

Dazu müsste man das if entfernen und dessen Rumpf aber stehen lassen.
Dann wird es sogar noch einfacher...

[Andreas S. (andreas) (Admin)]

Ja, stimmt. Hab es oben geändert.

[Jürgen (Gast)]

Sehr schön. Aber wie übergebe ich nun einen Teilstring an eine int- 
Variable?

[Karl H. (kbuchegg)]

Jürgen schrieb:
> Sehr schön. Aber wie übergebe ich nun einen Teilstring an eine int-
> Variable?

Gar nicht.
Wozu soll das denn gut sein?

Ein Teilstring ist erst mal ein String. Er enthält eine Zeichenkette, zb 
"Hermann Müller".

Eine int Variable ist eine Variable die Zahlen aufnehmen kann, zb 42

Das passt aber nicht zusammen. Ein String ist nicht etwas, was in einer 
int Variablen gespeichert werden könnte.

Es kann natürlich sein, dass dein Teilstring die Textrepräsentierung 
einer Zahl enthält. Das zb der String anstelle von "Hermann Müller" den 
Text "126" enthält. Auch das ist erst mal nur ein Text. Aber es ist ein 
Text aus dem man sinnvoll eine Zahl bilden kann, nämlich die Zahl 126

Und genau das macht zb die Funktion atoi. (zu lesen als "A to I", also 
ASCII to Integer)

Man übergibt ihr einen Pointer auf den Start eines Strings und die 
Funktion versucht da eine Zahl 'herauszuholen', sofern der String mit 
einem Zeichen beginnt, das das erste Zeichen einer Zahl sein könnte.

[Karl H. (kbuchegg)]

Vielleicht tu ich dir aber auch unrecht und du bist gar nicht der 
Jürgen, der den Thread eröffnet hat. Auf der anderen Seite ist es aber 
auch ziemlich unwahrscheinlich, dass sich ausgerechnet ein anderer 
Jürgen diesen Thread wieder ausgegraben hat.

Der springende Punkt ist aber: Seit Juli letzten Jahres war es dir nicht 
möglich ein C-Buch zu kaufen und zumindest das erste Drittel 
durchzuarbeiten?

Na dann Prost!

[Jürgen (Gast)]

Da dieser Threat sich um die Werte eines Positions-Protokolls einer GPS- 
Maus dreht, liegt doch nahe, wozu das gut sein soll.

Trotzdem vielen Dank, Karl-Heinz

[Karl H. (kbuchegg)]

Jürgen schrieb:
> Da dieser Threat sich um die Werte eines Positions-Protokolls einer GPS-
> Maus dreht, liegt doch nahe, wozu das gut sein soll.

Darum geht es nicht.
Es geht darum wozu es gut sein soll "einen String in einer Int Variablen 
abzulegen".

Das ist ungefähr so, wie die Fragestellung: Wie mache ich meine 45 Meter 
Segleyacht in meiner 3 Meter PKW-Garage fest.

Es geht nicht darum, warum du ausgerechnet deine Yacht in die Garage 
haben willst (weil du sie vor Wind und Wetter schützen willst), sondern 
es geht darum, dass es keinen sinnvollen Grund gibt ein 45 Meter Objekt 
in eine 3 Meter "Schachtel" quetschen zu wollen, die noch nicht mal dazu 
gedacht ist etwas anderes als einen PKW aufzunehmen. Jeder, der den 
Unterschied zwischen einer Segelyacht und einem PKW kennt, leuchtet 
unmittelbar ein, dass die ursprüngliche Fragestellung eine sinnlose ist. 
Im Umkehrschluss kann man dann folgern, dass dem Fragesteller daher 
nicht klar ist, dass eine Segelyacht (noch dazu eine große) etwas andres 
ist als ein Fiat Panda. Entweder das oder die Fragestellung wurde extrem 
unglücklich formuliert.

Mit ist schon klar, was du eigentlich fragen wolltest. Daher habe ich 
dann auch die Frage beantwortet, die du eigentlich stellen wolltest, 
aber in Unkentnis der Situation nicht gestellt hast. Und angesichts der 
Zeiträume konnte ich mir dann auch einen kleinen Seitenhieb nicht 
verkneifen.

[Jürgen (Gast)]

Die Lösung (atoi) ist ja zum Glück da.



Karl heinz Buchegger schrieb:
> Es geht darum wozu es gut sein soll "einen String in einer Int Variablen
>
> abzulegen".

Die Funktion (atoi) tut doch genau das, was ist denn daran unsinnvoll?


Übertragen: ich falte meine Dreimastbark auf handliche Garagengröße, 
sodass sie immernoch ein Segelschiff ist, aber in meine Garage passt, 
schließlich hab ich keine Pier im Garten.

[Jürgen (Gast)]

Mit ganz viel Phantasie könnte ich mir vorstellen, man könne meine Frage 
so interpretieren, dass ich versuche, $GPRMC in eine Int-Variable zu 
konvertieren.
Da gehört schon viel negatives Denken zu.

[Läubi .. (laeubi)]

Na dann übergib atoi doch mal den String 
"124395856743635342648583624274957465" und lass den in 'ner int 
Variablen "ablegen"...
Es geht einfach darum das atoi eben nicht den String in einer Int 
Variablen ablegt, sonder ihn hernimmt, und versucht eine konvertierung 
durchzuführen.
Also nimmst du einen Teilstring und "übergibst" den an atoi, und kriegst 
dan (hoffentlich) die gewünschte Zahl.

[Karl H. (kbuchegg)]

Jürgen schrieb:
> Die Lösung (atoi) ist ja zum Glück da.
>
>
>
> Karl heinz Buchegger schrieb:
>> Es geht darum wozu es gut sein soll "einen String in einer Int Variablen
>>
>> abzulegen".
>
> Die Funktion (atoi) tut doch genau das, was ist denn daran unsinnvoll?

Du verstehst es immer noch nicht, oder?

Wenn man sich an den Buchstaben des geschriebenen Wortes hält, dann ist 
die Fragestellung
"Aber wie übergebe ich nun einen Teilstring an eine int-Variable?"
lediglich mit einem simplen "Gar nicht" zu beantworten.

Auch atoi vollbringt keine Wunder und quetscht einen Teilstring in eine 
int-Variable.

Was aoti macht ist: Es sieht sich den Teilstring an und versucht ihn als 
Textrepräsentierung einer Zahl aufzufassen. atoi liefert dir die Zahl, 
deren Textrepräsentierung im String steht (sofern da überhaupt eine Zahl 
drinnen steht).

aoti kovertiert die Textrepräsentierung einer Zahl in die Zahl selber. 
Und diese Zahl kannst du dann in deiner int-Variablen ablegen, oder was 
weiß ich alles damit machen, was man eben mit Zahlen so machen kann.

Das Zauberwort ist: Da ist eine Konvertierung beteiligt!

Das ganze ist ein mehrstufiger Prozess

              Konvertierung             Abspeichern in
              in eine int-Zahl          der int-Variablen
   Text -----------------------> int ----------------------> int

           wird von atoi                 wird durch die
             erledigt                  Zuweisung erledigt


Es geht im weitesten Sinne darum, dass du dich korrekt ausdrückst, wenn 
du nach etwas fragst. Ansonsten bringt dir jemand einen 
Schraubenschlüssel, wenn du nach einem Werkzeug aus Stahl frägst, mit 
dem man Nägel in die Wand schlagen kann. Denn ein Hammer hat einen Stiel 
aus Holz und den hast du mit deiner Frage nach einem Werkzeug aus Stahl 
ausgeschlossen. Selbst dann, wenn deine ursprüngliche Überlegung war, 
keinen Gummihammer zu bekommen.

Und wenn du denkst, das das ja wohl egal ist ob du dich korrekt 
ausdrückst oder nicht, dann wirst du in der Programmierung Schiffbruch 
erleiden. Denn ein Computer ist ein Gerät, dass deine Befehle 
wortwörtlich befolgt. Für einen Computer gilt "Do what I write" und 
nicht "Do what I mean"

[Jürgen (Gast)]

Ach von daher weht der Wind.

"Natürlich" weiss ich vorher, welchen Teil des Strings ich einsammeln 
und zur int machen möchte (nämlich die Geschwindigkeit), und dass dieser 
Teil in eine int reinpasst..

[Jürgen (Gast)]

Karl Heinz, ich bewundere dich.

Bist Du eigentlich Lehrer?
Oder hauptberuflich www.mikrocontroller.net- Moderator?