GGA wird nicht mitgespeichert

[Gandy (Gast)]

Hallo Community,

Ich speichere GPS (RMC,GGA) und Messdaten(Beschleunigungen) auf die 
SD-Karte.
Jedoch enthält meine SD-Karte anschließend nur RMC und Beschleunigungen. 
GGA entfällt!(siehe Bild)
(RMC,GGA und Beschleunigungen sind ziemlich am Ende vom Skript)

#include <SPI.h>
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>
#include <SD.h>
#include <avr/sleep.h>


// these constants describe the pins. They won't change:
const int xpin = A1;                  // x-axis of the accelerometer
const int ypin = A2;                  // y-axis
const int zpin = A3;                  // z-axis (only on 3-axis models)
int sampleDelay = 1000; 


SoftwareSerial mySerial(8, 7);
Adafruit_GPS GPS(&mySerial);

// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences
#define GPSECHO  true
/* set to true to only log to SD when GPS has a fix, for debugging, keep it false */
#define LOG_FIXONLY false  

// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;
void useInterrupt(boolean); // Func prototype keeps Arduino 0023 happy

// Set the pins used
#define chipSelect 10
#define ledPin 13

File logfile;

// read a Hex value and return the decimal equivalent
uint8_t parseHex(char c) {
  if (c < '0')
    return 0;
  if (c <= '9')
    return c - '0';
  if (c < 'A')
    return 0;
  if (c <= 'F')
    return (c - 'A')+10;
}

// blink out an error code
void error(uint8_t errno) {

  while(1) {
    uint8_t i;
    for (i=0; i<errno; i++) {
      digitalWrite(ledPin, HIGH);
      delay(100);
      digitalWrite(ledPin, LOW);
      delay(100);
    }
    for (i=errno; i<10; i++) {
      delay(200);
    }
  }
}

void setup() {

  Serial.begin(115200);
  Serial.println("\r\nUltimate GPSlogger Shield");
  pinMode(ledPin, OUTPUT);

  pinMode(10, OUTPUT);

  analogReference(EXTERNAL);

  pinMode(xpin, INPUT);
  pinMode(ypin, INPUT);
  pinMode(zpin, INPUT);

 
  if (!SD.begin(chipSelect, 11, 12, 13)) {
    
    Serial.println("Card init. failed!");
    error(2);
  }
  char filename[15];
  strcpy(filename, "GPSLOG00.TXT");
  for (uint8_t i = 0; i < 100; i++) {
    filename[6] = '0' + i/10;
    filename[7] = '0' + i%10;
    
    if (! SD.exists(filename)) {
      break;
    }
  }

  logfile = SD.open(filename, FILE_WRITE);
  if( ! logfile ) {
    Serial.print("Couldnt create "); 
    Serial.println(filename);
    error(3);
  }
  Serial.print("Writing to "); 
  Serial.println(filename);

  GPS.begin(9600);

  // uncomment this line to turn on RMC (recommended minimum) and GGA (fix data) including altitude
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
  // uncomment this line to turn on only the "minimum recommended" data
  //GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
  // For logging data, we don't suggest using anything but either RMC only or RMC+GGA
  // to keep the log files at a reasonable size
  // Set the update rate
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ);   // 100 millihertz (once every 10 seconds), 1Hz or 5Hz update rate

  // Turn off updates on antenna status, if the firmware permits it
  GPS.sendCommand(PGCMD_NOANTENNA);

  useInterrupt(true);

  Serial.println("Ready!");
}


// Interrupt is called once a millisecond, looks for any new GPS data, and stores it
SIGNAL(TIMER0_COMPA_vect) {
  char c = GPS.read();
  // if you want to debug, this is a good time to do it!
  #ifdef UDR0
      if (GPSECHO)
        if (c) UDR0 = c;  
      // writing direct to UDR0 is much much faster than Serial.print 
      // but only one character can be written at a time. 
  #endif
}

void useInterrupt(boolean v) {
  if (v) {
    // Timer0 is already used for millis() - we'll just interrupt somewhere
    // in the middle and call the "Compare A" function above
    OCR0A = 0xAF;
    TIMSK0 |= _BV(OCIE0A);
    usingInterrupt = true;
  } 
  else {
    // do not call the interrupt function COMPA anymore
    TIMSK0 &= ~_BV(OCIE0A);
    usingInterrupt = false;
  }
}

void loop() {

  int x = analogRead(xpin);

    delay(1); 

  int y = analogRead(ypin);

    delay(1); 

  int z = analogRead(zpin);

  float zero_G = 512.0; 

  float scale = 102.3;

  float x_real = (((float)x - zero_G)/scale);
  float y_real = (((float)x - zero_G)/scale);
  float z_real = (((float)z - zero_G)/scale);
  String trennen = " ; ";
  String beschleunigungen = x_real + trennen + y_real + trennen + z_real;
  Serial.println(beschleunigungen);
  delay(sampleDelay);
  
  
  if (! usingInterrupt) {
    // read data from the GPS in the 'main loop'
    char c = GPS.read();
    // if you want to debug, this is a good time to do it!
    if (GPSECHO)
      if (c) Serial.print(c);
  }
  
  // if a sentence is received, we can check the checksum, parse it...
  if (GPS.newNMEAreceived()) {

    char *stringptr = GPS.lastNMEA();
        
    if (!GPS.parse(stringptr))   // this also sets the newNMEAreceived() flag to false
      return;  // we can fail to parse a sentence in which case we should just wait for another

    // Sentence parsed! 
    Serial.println("OK");
    if (LOG_FIXONLY && !GPS.fix) {
      Serial.print("No Fix");
      return;
    }

    // Rad. lets log it!
    Serial.println("Log");

    uint8_t stringsize = strlen(stringptr);
    if (stringsize != logfile.write((uint8_t *)stringptr, stringsize))    //write the string to the SD file
        error(4);
      
    if (strstr(stringptr, "RMC") || strstr(stringptr, "GGA"))
    logfile.print(" ; ");  
    logfile.println(beschleunigungen);
    logfile.flush();
    
    Serial.println();
     }
  }

Vielen Dank

Gandy

[holger (Gast)]

Gibt dein GPS auch GGA Messages aus?

[Gandy (Gast)]

Ja gibt er.
Wenn ich die Beschleunigung auskommentiere bekomm ich RMC & GGA

[Jim M. (turboj)]

Es könnte sein, dass Deine delay() zu lang sind und deshalb der GGA 
kaputt geht. Der kommt IIRC zuerst.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

Gandy schrieb:
> char *stringptr = GPS.lastNMEA();

Reservierst du dafür irgendwo Platz? Ansonsten würde ich es wie bei 
Adafruit machen, also direkt

GPS.parse(GPS.lastNMEA());

Und dann wie im Artikel beschrieben, auf z.B. 'GPS.Longitude' zugreifen 
und den String fürs SD daraus zusammensetzen.
https://learn.adafruit.com/adafruit-ultimate-gps-logger-shield/parsing-data