3.0 Volt - 3.3 Volt Bauteile an Arduino Uno

Ich habe das jetzt so verbunden


und den Beispielcode verwendet
Siehe: https://raw.github.com/adafruit/Adafruit-MTK3329-GPS-Module-Test-Sketch/master/Adafruit_MTK3329_GPS_Test.pde

Aber leider bekomme ich nur eine folge von ? und ÄÜ's woran kann das liegen? :astonished:

Sieht auf den ersten Blick wie ein Baudraten-Fehler aus. Allerdings ist die Standardeinstellung des GPS-Moduls 9600 und auch dein Programmschnipsel "spricht" 9600 bps. Hattest du versucht, das zu ändern, dass nun die Geschwindigkeiten nicht mehr passen?

BigInteger:
Ah und noch eine zweite Frage, ich habe einen Sensor, der mit einer Spannung von 3.0 bis 5.5 Volt betrieben werden kann,
wenn ich dieses Bauteil mit 3.3 Volt betreibe, bedeutet es doch auch, dass der Sensor länger über Batterie betrieben werden kann, als wenn ich diesen an 5 Volt klemme, oder liege ich da falsch?

Nein. Singt die Spannung, setigt der Strom. Steigt die Spannung, sinkt der Strom. Viele meinen auch, das wenn man eine Lampe dimmt, verbraucht die weniger Strom. Dies ist ebenfalls falsch. Hättest Du nach der Nennleistung gefragt, die bleibt in beiden fällen gkeich.

Ein einfaches Beispiel: Eine Nennleistung von 20 KW an einer Spannung von 230 volt soll über eine längere Strecke übertragen werden.
I=P/U => 20000W/230V => 87A

Erhöt mann die Spannung auf 10 KV, ergibt sich ein Strom von 2 Amper.
I=P/U => 20Kw (20000W)/10 KV (10000V) => 2A

Ergo Dein Modul braucht mit 3.3 volt genausoviel leistung wie mit 5 volt.

Singt die Spannung, setigt der Strom. Steigt die Spannung, sinkt der Strom. Viele meinen auch, das wenn man eine Lampe dimmt, verbraucht die weniger Strom. Dies ist ebenfalls falsch. Hättest Du nach der Nennleistung gefragt, die bleibt in beiden fällen gkeich.

:~

Und wieso wird eine gedimmte Lampe nicht nur dunkler, sondern auch weniger heiss ?

Ob der Sensor immer die gleiche Leistung braucht, und daher mehr Strom zieht, müsste man ihn auch erstmal fragen.

Ich glaube ich lese nicht richtig :fearful: :fearful:

Rene_Merten:
Nein. Singt die Spannung, setigt der Strom. Steigt die Spannung, sinkt der Strom.

Sorry, aber das ist SO komplett aus dem Zusammenhang gerissen!
Dieses Verhalten kann man z.B. bei einem DC/DC Wandler oder einer Stromquelle beobachten. Also einem aktiven Schaltkreis, der versucht, eine sekundäre Bedingung einzuhalten.

Rene_Merten:
Viele meinen auch, das wenn man eine Lampe dimmt, verbraucht die weniger Strom. Dies ist ebenfalls falsch. Hättest Du nach der Nennleistung gefragt, die bleibt in beiden fällen gkeich.

Und da haben die vielen mit ihrer Meinung recht. Das von dir ist einfach nur FALSCH. Bei einem ohmschen Verbraucher (Halogen-Lampe) ist die verbrauchte Leistung geringer wenn sie gedimmt ist/wird!

Rene_Merten:
Ein einfaches Beispiel: Eine Nennleistung von 20 KW an einer Spannung von 230 volt soll über eine längere Strecke übertragen werden.
I=P/U => 20000W/230V => 87A

Erhöt mann die Spannung auf 10 KV, ergibt sich ein Strom von 2 Amper.
I=P/U => 20Kw (20000W)/10 KV (10000V) => 2A

Sorry, aber das ist SO komplett aus dem Zusammenhang gerissen!
Siehe oben!

Rene_Merten:
Ergo Dein Modul braucht mit 3.3 volt genausoviel leistung wie mit 5 volt.

Diese Aussage ist nicht richtig begründet. Eine pauschale Aussage ist hier sowieso nicht möglich!
Und wie verhält sich das bei einer LED? Braucht die auch gleich viel Leistung bei 3,3V und 5,0V wenn der Rv für 5V mit 20mA berechnet wurde?

michael_x:
Ob der Sensor immer die gleiche Leistung braucht, und daher mehr Strom zieht, müsste man ihn auch erstmal fragen.

Jeder Fernseher, Radio, Arduino etc, hat eine schwankende Stromaufnahme. Es wird immer die maximale Stromaufnahme angegeben.

michael_x:
Und wieso wird eine gedimmte Lampe nicht nur dunkler, sondern auch weniger heiss ?

Weist Du, was ein Dimmer überhaupt macht?

Mit einem Dimmer können wir die Helligkeit einer Glühlampe stufenlos bis zu einem ganz schwachen Glimmen herunterregeln.

Das funktioniert so: Der Strom geht in jeder Sekunde fünfzig Mal an und aus. Ein Dimmer verzögert dieses Einschalten jedes Mal ein kleines bisschen. Soll das Licht nur wenig gedimmt werden, verzögert der Dimmer das Einschalten nur kurz. Möchten wir stark gedimmtes Licht, verzögert der Dimmer das Einschalten länger. In beiden Fällen reduziert sich also die Zeit, in der Strom durch die Lampe fließt.

Und was hat der Glühfaden nun? Mer zeit zum abkühlen.

Probiers doch mal selber aus.! Benötigst ein Ampermeter und Voltmeter. Das Ohmsche Gesetz wirste ja wohl kennen. Und vergiss die Verlustleistung des Wiederstandes an deiner LED net :smiley:

Für weitere Fragen kannste dich an mein Dad wenden, der hat Elektrotechnik Studiert.

Und ganz nebenbei, es war die Frage, ob es an 3.3 volt gegenüber 5 volt Strom spart. Und genau das tut man nicht. Und vergiss net, das kein Gerät der Welt eine Konstante bStromaufnahme hat. Es wir immer die Maximale Stromaufnahme angegeben. Betreib deine LED mit der angegebenen Nennspannung, rechne, und dann mit Vorwiederstand und eine höhere Spannung, inklusive der Verlustleitung des Wiederstandes. Dann vergleich mal beide Ergebnisse.

Rene_Merten:
...In beiden Fällen reduziert sich also die Zeit, in der Strom durch die Lampe fließt...

Da haben wir es, weniger Arbeit. Weil Arbeit = Leistung(Spannung * Strom) * Zeit.
Weniger Zeit = Weniger Arbeit

Rene_Merten:
Probiers doch mal selber aus.! Benötigst ein Ampermeter und Voltmeter. Das Ohmsche Gesetz wirste ja wohl kennen. Und vergiss die Verlustleistung des Wiederstandes an deiner LED net :smiley:

Ich glaube du hast dich da etwas verbrannt, Rene. Der Griff zum Multimeter solltest du machen und den Zusammenhang von Spannung und Strom an einem Widerstand beobachten. Dann wirst du erkennen, dass diese proportional sind. Ja genau, ohmsches Gesetz: R=U/I. R bleibt konstant, wenn U sinkt sinkt in gleichem Maße auch I. Wie gesagt, gilt für ohmsche Lasten. Ob es sich bei dem GPS-Modul zumindest in nächster Nähe um eine solche Last handelt, können nur entsprechende Messungen ergeben.

Rene_Merten:
...Und ganz nebenbei, es war die Frage, ob es an 3.3 volt gegenüber 5 volt Strom spart. Und genau das tut man nicht. Und vergiss net, das kein Gerät der Welt eine Konstante bStromaufnahme hat. Es wir immer die Maximale Stromaufnahme angegeben. Betreib deine LED mit der angegebenen Nennspannung, rechne, und dann mit Vorwiederstand und eine höhere Spannung, inklusive der Verlustleitung des Wiederstandes. Dann vergleich mal beide Ergebnisse.

Habe aufgebaut, und verglichen. Sorry ist leider kein PSpice geworden. Siehe Ergebnisse im Anhang. Jetzt bist du dran!

Rene_Merten:
Das funktioniert so: Der Strom geht in jeder Sekunde fünfzig Mal an und aus. Ein Dimmer verzögert dieses Einschalten jedes Mal ein kleines bisschen. Soll das Licht nur wenig gedimmt werden, verzögert der Dimmer das Einschalten nur kurz. Möchten wir stark gedimmtes Licht, verzögert der Dimmer das Einschalten länger. In beiden Fällen reduziert sich also die Zeit, in der Strom durch die Lampe fließt.

Und was hat der Glühfaden nun? Mer zeit zum abkühlen.

Rene. Ja, Du mußt aufpassen Dich nicht zu verbrennen.

Bei 50Hz Wechselstrom wird der Strom 100ma Null (nach jeder Halbwelle). Phasenanschnittsteuerung kennen wir alle. Die Leistung ist in diesem Fall das Integral des quadratischen Mittelwerts der Produkte der Momentalwerte des Stroms und der Spannung wobei diese bei einer Lampe beide einen sinusförmigen Verlauf haben. Während einer Halbwelle änder sich sowohl der Strom als auch die Spannung.

Das Verhältnis P= U*I = konstant ist nur bei einem Trafo gegeben wenn man die Verluste nicht berücksichtigt.

Alle anderen 2-Pole haben mehr oder weniger den Zusammenhang I ist proportional U. Einzige Ausnahme sind Motore. Da hängt der Strom von der Spannung und von der an der Welle abgegebenen mechanischen Leistung ab.

Glaub mir auch, daß der Glühfaden einer Lampe während einer teilweise fehlenden Halbwelle nicht merklich abkühlt sondern dur weniger eingebrachte Leistung weniger heiß wird.

Grüße Uwe

So hab es jetzt mit diesem code hier versucht:

// tested on an Arduino Mega 2560 using pins 11 for RXd & 12 for TXd
// Connect the GPS Power pin to 3.3V
// Connect the GPS Ground pin to ground
// Connect the GPS VBAT pin to 3.3V if no battery is used
// Connect the GPS TX (transmit) pin to Digital 11
// Connect the GPS RX (receive) pin to Digital 12
// For 3.3V only modules such as the UP501, connect a 10K
// resistor between digital 12 and GPS RX and a 10K resistor
// from GPS RX to ground. (Must divide voltage into module as it only takes 3.3V)

#include <SoftwareSerial.h>;

#define PMTK_SET_NMEA_UPDATE_1HZ "$PMTK220,10001F"
#define PMTK_SET_NMEA_UPDATE_5HZ "$PMTK220,200
2C"
#define PMTK_SET_NMEA_UPDATE_10HZ "$PMTK220,1002F"
#define PMTK_SET_NMEA_OUTPUT_RMCONLY "$PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
29"
#define PMTK_SET_NMEA_OUTPUT_ALLDATA "$PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0*28"

int rxPin = 2;
int txPin = 3;

SoftwareSerial mySerial = SoftwareSerial(rxPin, txPin);

void setup()
{
Serial.begin(57600);
Serial.println("UP501 NMEA test!");

pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);

mySerial.begin(9600);

// uncomment this line to turn on only the "minimum recommended" data for high update rates!
//mySerial.println(PMTK_SET_NMEA_OUTPUT_RMCONLY);

// uncomment this line to turn on all the available data - for 9600 baud you'll want 1 Hz rate
mySerial.println(PMTK_SET_NMEA_OUTPUT_ALLDATA);

// Set the update rate
// 1 Hz update rate
mySerial.println(PMTK_SET_NMEA_UPDATE_1HZ);

// 5 Hz update rate- for 9600 baud you'll have to set the output to RMC only (see above)
//mySerial.println(PMTK_SET_NMEA_UPDATE_5HZ);

//10 Hz update rate - for 9600 baud you'll have to set the output to RMC only (see above)
//mySerial.println(PMTK_SET_NMEA_UPDATE_10HZ);

}

void loop()
{

if (mySerial.available())
Serial.print((char)mySerial.read());

if (Serial.available())
mySerial.print((char)Serial.read());
}

und bekomme bei einer boundrate von 57600 nur "UP501 NMEA test!" mehr nicht :frowning:

und bei diesem Code:

#include <SoftwareSerial.h>

#include <TinyGPS.h>

/* This sample code demonstrates the normal use of a TinyGPS object.
   It requires the use of SoftwareSerial, and assumes that you have a
   4800-baud serial GPS device hooked up on pins 3(rx) and 4(tx).
*/

TinyGPS gps;
SoftwareSerial nss(2, 3);

static void gpsdump(TinyGPS &gps);
static bool feedgps();
static void print_float(float val, float invalid, int len, int prec);
static void print_int(unsigned long val, unsigned long invalid, int len);
static void print_date(TinyGPS &gps);
static void print_str(const char *str, int len);

void setup()
{
  Serial.begin(115200);
  nss.begin(4800);
  
  Serial.print("Testing TinyGPS library v. "); Serial.println(TinyGPS::library_version());
  Serial.println("by Mikal Hart");
  Serial.println();
  Serial.print("Sizeof(gpsobject) = "); Serial.println(sizeof(TinyGPS));
  Serial.println();
  Serial.println("Sats HDOP Latitude Longitude Fix  Date       Time       Date Alt     Course Speed Card  Distance Course Card  Chars Sentences Checksum");
  Serial.println("          (deg)    (deg)     Age                        Age  (m)     --- from GPS ----  ---- to London  ----  RX    RX        Fail");
  Serial.println("--------------------------------------------------------------------------------------------------------------------------------------");
}

void loop()
{
  bool newdata = false;
  unsigned long start = millis();
  
  // Every second we print an update
  while (millis() - start < 1000)
  {
    if (feedgps())
      newdata = true;
  }
  
  gpsdump(gps);
}

static void gpsdump(TinyGPS &gps)
{
  float flat, flon;
  unsigned long age, date, time, chars = 0;
  unsigned short sentences = 0, failed = 0;
  static const float LONDON_LAT = 51.508131, LONDON_LON = -0.128002;
  
  print_int(gps.satellites(), TinyGPS::GPS_INVALID_SATELLITES, 5);
  print_int(gps.hdop(), TinyGPS::GPS_INVALID_HDOP, 5);
  gps.f_get_position(&flat, &flon, &age);
  print_float(flat, TinyGPS::GPS_INVALID_F_ANGLE, 9, 5);
  print_float(flon, TinyGPS::GPS_INVALID_F_ANGLE, 10, 5);
  print_int(age, TinyGPS::GPS_INVALID_AGE, 5);

  print_date(gps);

  print_float(gps.f_altitude(), TinyGPS::GPS_INVALID_F_ALTITUDE, 8, 2);
  print_float(gps.f_course(), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
  print_float(gps.f_speed_kmph(), TinyGPS::GPS_INVALID_F_SPEED, 6, 2);
  print_str(gps.f_course() == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(gps.f_course()), 6);
  print_int(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0UL : (unsigned long)TinyGPS::distance_between(flat, flon, LONDON_LAT, LONDON_LON) / 1000, 0xFFFFFFFF, 9);
  print_float(flat == TinyGPS::GPS_INVALID_F_ANGLE ? 0.0 : TinyGPS::course_to(flat, flon, 51.508131, -0.128002), TinyGPS::GPS_INVALID_F_ANGLE, 7, 2);
  print_str(flat == TinyGPS::GPS_INVALID_F_ANGLE ? "*** " : TinyGPS::cardinal(TinyGPS::course_to(flat, flon, LONDON_LAT, LONDON_LON)), 6);

  gps.stats(&chars, &sentences, &failed);
  print_int(chars, 0xFFFFFFFF, 6);
  print_int(sentences, 0xFFFFFFFF, 10);
  print_int(failed, 0xFFFFFFFF, 9);
  Serial.println();
}

static void print_int(unsigned long val, unsigned long invalid, int len)
{
  char sz[32];
  if (val == invalid)
    strcpy(sz, "*******");
  else
    sprintf(sz, "%ld", val);
  sz[len] = 0;
  for (int i=strlen(sz); i<len; ++i)
    sz[i] = ' ';
  if (len > 0) 
    sz[len-1] = ' ';
  Serial.print(sz);
  feedgps();
}

static void print_float(float val, float invalid, int len, int prec)
{
  char sz[32];
  if (val == invalid)
  {
    strcpy(sz, "*******");
    sz[len] = 0;
        if (len > 0) 
          sz[len-1] = ' ';
    for (int i=7; i<len; ++i)
        sz[i] = ' ';
    Serial.print(sz);
  }
  else
  {
    Serial.print(val, prec);
    int vi = abs((int)val);
    int flen = prec + (val < 0.0 ? 2 : 1);
    flen += vi >= 1000 ? 4 : vi >= 100 ? 3 : vi >= 10 ? 2 : 1;
    for (int i=flen; i<len; ++i)
      Serial.print(" ");
  }
  feedgps();
}

static void print_date(TinyGPS &gps)
{
  int year;
  byte month, day, hour, minute, second, hundredths;
  unsigned long age;
  gps.crack_datetime(&year, &month, &day, &hour, &minute, &second, &hundredths, &age);
  if (age == TinyGPS::GPS_INVALID_AGE)
    Serial.print("*******    *******    ");
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d %02d:%02d:%02d   ",
        month, day, year, hour, minute, second);
    Serial.print(sz);
  }
  print_int(age, TinyGPS::GPS_INVALID_AGE, 5);
  feedgps();
}

static void print_str(const char *str, int len)
{
  int slen = strlen(str);
  for (int i=0; i<len; ++i)
    Serial.print(i<slen ? str[i] : ' ');
  feedgps();
}

static bool feedgps()
{
  while (nss.available())
  {
    if (gps.encode(nss.read()))
      return true;
  }
  return false;
}

bekomme ich das hier:

BigInteger:
und bekomme bei einer boundrate von 57600 nur "UP501 NMEA test!" mehr nicht :frowning:

Wenn hier nichts kommt, wird auch nichts vom Modul empfangen.
Das "UP501 NMEA test!" kommt vom Setup.
In der Loop wird nur weitergeleitet, was vom GPS Modul empfangen wird. Wenn hier nichts kommt, wird mit den anderen Libs auch nicht viel mehr passieren können.

Ich kenne mich mit dem Modul nicht aus, nur generell mit der GPS Technik. GPS hat einen cold-start der bis zu 10 Minuten brauchen kann. Probiere vielleicht mal das Modul mind. 10min unter freiem Himmel zu positionieren und dann den Monitor dran hängen. Nach der Zeit müsste er seinen fix haben.
Jurs hatte geschrieben, dass das Modul in der Standard- Konfig das NMEA sendet, außer du hast es mit irgendeiner Lib umprogrammiert.

Hast du einen USB-RS232 Adapter?
Könntest du am GPS Modul PIN 2 mal die AC-Spannung beobachten/messen?

leider habe ich keinen USB-RS232 Adapter :frowning:

Okay SCHOCK!!!!!!
Ich habe grade die anliegende Spannung gemessen und die betrug 4,78 - 5,1 Volt schwankende...
Und mein Modul verträgt aber nur von 3,0 bis 4,2 Volt!!!!
Ich denke, dass ich den teuren GPS Empfänger getötet habe....

Komischer weise schmeisst er aber nach ca 3 Minuten (Kaltstart) folgendes aus:

$GPRMC,000302.037,V,,,,,0.00,0.00,060180,,,N*47
$GPRMC,210646.337,V,,,,,0.00,0.00,080180,,,N*4C
$GPRMC,210647.337,V,,,,,0.00,0.00,080180,,,N*4D
$GPRMC,210648.337,V,,,,,0.00,0.00,080180,,,N*42
$GPRMC,210649.337,V,,,,,0.00,0.00,080180,,,N*43
$GPRMC,210650.337,V,,,,,0.00,0.00,080180,,,N*4B
$GPRMC,210651.337,V,,,,,0.00,0.00,080180,,,N*4A
$GPRMC,210652.337,V,,,,,0.00,0.00,080180,,,N*49
$GPRMC,210653.337,V,,,,,0.00,0.00,080180,,,N*48
$GPRMC,210654.337,V,,,,,0.00,0.00,080180,,,N*4F
$GPRMC,210655.337,V,,,,,0.00,0.00,080180,,,N*4E
$GPRMC,210656.337,V,,,,,0.00,0.00,080180,,,N*4D
$GPRMC,210657.337,V,,,,,0.00,0.00,080180,,,N*4C
$GPRMC,210658.337,V,,,,,0.00,0.00,080180,,,N*43
$GPRMC,210659.337,V,,,,,0.00,0.00,080180,,,N*42
$GPRMC,210700.337,V,,,,,0.00,0.00,080180,,,N*4F
$GPRMC,210701.337,V,,,,,0.00,0.00,080180,,,N*4E
$GPRMC,210702.337,V,,,,,0.00,0.00,080180,,,N*4D
$GPRMC,210703.337,V,,,,,0.00,0.00,080180,,,N*4C
$GPRMC,210704.337,V,,,,,0.00,0.00,080180,,,N*4B
$GPRMC,210705.337,V,,,,,0.00,0.00,080180,,,N*4A
$GPRMC,210706.337,V,,,,,0.00,0.00,080180,,,N*49
$GPRMC,210707.337,V,,,,,0.00,0.00,080180,,,N*48

Sie Vorne ist die Uhrzeit aber Hinten sind keine richtigen werwedbaren Koordinaten... :frowning:
Aber wie gesagt, ich glaube dass ich den Chip durchgebrannt habe.... :disappointed_relieved: =( =( =(

BigInteger:
Ich habe grade die anliegende Spannung gemessen und die betrug 4,78 - 5,1 Volt schwankende...

WO hast du die Spannung WIE gemessen? Also AC oder DC? Bitte immer ausführlich beschreiben.
Das sollten wir klären vor weiteren Tests! (Auf deinen Bildern weist nichts auf ein vorhandensein von 5V DC hin.)
Mit der AC-Messung wollte ich nur sehen, ob Daten drauf sind. Die AC Werte sind nicht wichtig, nur ob eine AC Spannung angezeigt wird. Ein Oszi wirst du vermutlich nicht haben.

Hast du jetzt aufgrund meines Tipps das Modul länger beobachtet?
Ist es richtig, dass am Anfang noch wie vor keine Daten kommen und er erst später anfängt zu senden?
3min sind noch kein Kaltstart. Wie gesagt 10min sollten es auf dem Balkon mit freier sich zum Himmel schon sein.

Ob er abgeschossen ist wissen wir noch nicht. Hoffen wir mal dass er noch lebt ;). Den Daten nach zu urteilen lebt er noch und ist Gesund.

Nochmal zu den Bildern. Ich empfehle ich dir an Pin2 vom GPS Modul immer noch einen 1k Widerstand zum Schutz.
Dann kommen ganz sicher keine 5V irgendwo her. Wie gesgt, wenn du einmal nicht aufpasst, und den Arduino Pin als Ausgang definierst und den auf 1 setzt schützt der Wid immernoch. Wer weiß wie tolerant der GPS dinger ist...

mde110:
Nochmal zu den Bildern. Ich empfehle ich dir an Pin2 vom GPS Modul immer noch einen 1k Widerstand zum Schutz.
Dann kommen ganz sicher keine 5V irgendwo her. Wie gesgt, wenn du einmal nicht aufpasst, und den Arduino Pin als Ausgang definierst und den auf 1 setzt schützt der Wid immernoch. Wer weiß wie tolerant der GPS dinger ist...

Danke für deinen Tipp! Habst mir sehr geholfen, hab jetzt einen 1K Widerstand drangehängt und wie aus dem nichts kamen kurz darauf die Daten mit den PASSENDEN Koordinaten. Gott sein Dank ist mein Modul doch nicht hinüber, hab anscheind Glück gehabt, oder es gibt einen Überspannungsschutz.

Hab jetzt viel gelernt, vorallem immer sehr vorsichtig zu sein und bevor ich nächstens ein teures Modul dranhänge werde ich messen und auf Nummer sicher gehen. 8)

Aus deinem GPRMC-Datensatz bekommst du vor allem die Information "V", diese steht für "void" als ungültigen Wert. Sieht danach aus, als hättest du noch keinen Satellitenfix. Dass der GPS-Empfänger defekt ist schließe ich erst mal aus, immerhin wirft er die übertragene Uhrzeit aus.

[edit] Für mehr Informationen zu den Datensätzen: http://www.kowoma.de/gps/zusatzerklaerungen/NMEA.htm

Cool, danke für den Link, der ist sehr Hilfreich.

Werde jetzt meinen langen String den ich von meinem Modul bekomme mit einem Stringtokenizer zurechtstutzen und dann in die für mich relevanten Daten extrahieren. ]:smiley: