Gps code von 1Hz auf 10Hz aendern.

Moin moin,

ich habe hier ein Programm (nennt sich Ghettoproxy) was auf einem Arduino Pro mini läuft und aus einem GPS Protokoll (NMEA) ein anderes Protokoll (LTM) macht.
Das funktioniert so weit ganz gut, wenn ich das GPS Modul mit 1Hz arbeiten lasse (5V, Minus, Tx) . Leider ist mir aber eine Wiederholungsfrequenz von 10Hz vorgegeben, da ich das GPS Signal noch für einen Closedsource Autopiloten benötige, welche unbedingt 10Hz haben möchte und dem GPS Empfänger auch sofort nach dem anschließen auf 10 Hz umstellt. (Vermutlich über den Rx pin.)
Die Idee einen 2. GPS Empfänger einzubauen habe ich schon gehabt, möchte es aber erst mal auf diesem Wege versuchen.

Da ich mich mit dem Arduino code fast gar nicht auskenne veröffentliche ich jetzt mal diesen “original code”. Vielleicht entdeckt jemand von euch die Stelle, an dem man den Code anpassen kann.

Gruß, Jochen

Es sind mehrere Dateien die in Frage kommen:

/*########################################### BOARD PINOUTS #########################################################
 Pins for Arduino Mini
 *SERIAL TELEMETRY INPUT PINOUT:
 
     Use TX/RX pads
     
 *SERIAL LTM OUTPUT PINOUT ( AltSoftSerial):
 
     TX: D9 on arduino mini/nano 

*/
/*############################################## CONFIGURATION ####################################################
 # Comment/uncomment/edit according to your needs.
 ##################################################################################################################*/

//########## OPTIONS ###############################################################################################
//INPUT PROTOCOL
// Choose only one.

//#define PROTOCOL_UAVTALK                      // OpenPilot / Taulabs protocol
//#define PROTOCOL_MSP                          // MSP from Multiwii / Baseflight
//#define PROTOCOL_MAVLINK                      // Mavlink for Ardupilot / Autoquad / PixHawk / Taulabs (UAVOmavlinkBridge)
#define PROTOCOL_NMEA                         //GPS NMEA ASCII protocol
//#define PROTOCOL_UBLOX                        //GPS UBLOX binary protocol

//!uncomment to use altitude from Baro. Use GPS alt if commented.
//#define BARO_ALT

//INPUT BAUDRATE
 #define INPUT_BAUD 38400

// GhettoProxy just listen & convert in passive mode. If disabled, it will initiate queries packet.
 #define PASSIVEMODE 1

//OUTOPUT BAUDRATE
#define OUTPUT_BAUD 2400


//#define DEBUG
/**
 ******************************************************************************
 *
 * @file       GhettoStation.ino
 * @author     Guillaume S
 * @brief      Arduino based antenna tracker & telemetry display for UAV projects.
 * @project    https://code.google.com/p/ghettostation/
 * 
 *             
 *             
 *
 * @see        The GNU Public License (GPL) Version 3
 *
 *****************************************************************************
*/

#include <FastSerial.h>
#include <avr/pgmspace.h>
#include <Arduino.h>

#include <AP_Math.h>

#include "Config.h"

#include <AltSoftSerial.h>
//#include <SoftwareSerial.h>
#include <Metro.h>
#include "GhettoStation.h"

#include "LightTelemetry.cpp"
#ifdef DEBUG
#include <MemoryFree.h>
#endif
/*
 * BOF preprocessor bug prevent
 */
#define nop() __asm volatile ("nop")
#if 1
nop();
#endif
/*
 * EOF preprocessor bug prevent
*/


#ifdef PROTOCOL_UAVTALK
#include "UAVTalk.cpp"
#endif
#ifdef PROTOCOL_MSP
#include "MSP.cpp"
#endif
#ifdef PROTOCOL_MAVLINK
#include <AP_Common.h>
#include <GCS_MAVLink.h>
#include "Mavlink.cpp"
#endif
#ifdef PROTOCOL_NMEA
#include "GPS_NMEA.cpp"
#endif
#ifdef PROTOCOL_UBLOX
#include "GPS_UBLOX.cpp"
#endif

//################################### SETTING OBJECTS ###############################################

//##### LOOP RATES

Metro loop10hz = Metro(100); //10hz loop
#ifdef DEBUG
Metro loopDebug = Metro(500);
#endif
//#################################### SETUP LOOP ####################################################

void setup() {
    //start serial com  
    init_serial();
    #ifdef PROTOCOL_GPS 
     GPS.Init();
    #endif
    #ifdef PROTOCOL_MAVLINK
    mavlink_comm_0_port = &Serial;
    #endif
}

//######################################## MAIN LOOP #####################################################################
void loop() {
    get_telemetry(); 
 
 #ifdef DEBUG
    if (loopDebug.check()) {
        debug_proxy();
    }
 #endif

    if (loop10hz.check()) {
   
       send_LTM();
       //SerialPort1.println("sendLTM");
     
    }
}
//######################################## TELEMETRY FUNCTIONS #############################################
void init_serial() {
    
    Serial.begin(INPUT_BAUD);
    SerialPort2.begin(OUTPUT_BAUD);
}

//Preparing adding other protocol
void get_telemetry() {
        
#if defined(PROTOCOL_UAVTALK) // OpenPilot / Taulabs 
      uavtalk_read();
#endif

#if defined(PROTOCOL_MSP) // Multiwii
      if (!PASSIVEMODE) { // query MSP packets
          static unsigned long previous_millis_low = 0;
          static unsigned long previous_millis_high = 0;
          static unsigned long previous_millis_onsec = 0;
          static uint8_t queuedMSPRequests = 0;
          unsigned long currentMillis = millis();
          if((currentMillis - previous_millis_low) >= 1000) // 1hz
          {
              setMspRequests(); 
          }
          if((currentMillis - previous_millis_low) >= 100)  // 10 Hz (Executed every 100ms)
          {
              blankserialRequest(MSP_ATTITUDE); 
              previous_millis_low = millis();
          }
          if((currentMillis - previous_millis_high) >= 200) // 20 Hz (Executed every 50ms)
          {
              uint8_t MSPcmdsend;
              if(queuedMSPRequests == 0)
                 queuedMSPRequests = modeMSPRequests;
              uint32_t req = queuedMSPRequests & -queuedMSPRequests;
              queuedMSPRequests &= ~req;
              switch(req) {
                  case REQ_MSP_IDENT:
                    MSPcmdsend = MSP_IDENT;
                    break;
                  case REQ_MSP_STATUS:
                    MSPcmdsend = MSP_STATUS;
                    break;
                  case REQ_MSP_RAW_GPS:
                    MSPcmdsend = MSP_RAW_GPS;
                    break;
                  case REQ_MSP_ALTITUDE:
                    MSPcmdsend = MSP_ALTITUDE;
                    break;
                  case REQ_MSP_ANALOG:
                    MSPcmdsend = MSP_ANALOG;
                    break;
              } 
              previous_millis_high = millis();
          }
      }
      msp_read(); 
#endif


#if defined(PROTOCOL_MAVLINK) // Ardupilot / PixHawk / Taulabs ( mavlink output ) / Other
      if(enable_frame_request == 1){//Request rate control
    enable_frame_request = 0;
        if (!PASSIVEMODE) {
           request_mavlink_rates();
        }
      }
      read_mavlink(); 
#endif

#if defined (PROTOCOL_NMEA) || defined (PROTOCOL_UBLOX)
 gps_read();
#endif
}

#ifdef DEBUG




void debug_proxy() {
//SerialPort1.print("timer ");
//int currenttime = millis();
//SerialPort1.println(currenttime);
Serial.print("mem ");
int freememory = freeMem();
Serial.println(freememory);
Serial.print("uav_alt = ");
Serial.println(uav_alt);
Serial.print("uav_pitch = ");
Serial.println(uav_pitch);
Serial.print("uav_roll = ");
Serial.println(uav_roll);
Serial.print("uav_heading = ");
Serial.println(uav_heading);
Serial.print("uav_lat = ");
Serial.println(uav_lat);
Serial.print("uav_lon = ");
Serial.println(uav_lon);
Serial.print("uav_speed = ");
Serial.println(uav_groundspeed);
Serial.print("uav_fix_type = ");
Serial.println(uav_fix_type);
Serial.print("uav_satellites_visible = ");
Serial.println(uav_satellites_visible);
//SerialPort1.print("softserial_delay = ");
//SerialPort1.println(softserial_delay);
//SerialPort1.print("packet_drops = ");
//SerialPort1.println(packet_drops);
//SerialPort1.print("parse_error = ");
//SerialPort1.println(parse_error);
}
#endif

Und im nächsten post noch, da ich an die Grenze der maximal zulässigen Zeichen gekommen bin.

#if defined (PROTOCOL_NMEA) || defined (PROTOCOL_UBLOX)
void gps_read() {
    GPS.Read();
    if (GPS.NewData)  // New GPS data?
        {
          
         uav_satellites_visible = GPS.NumSats;
         uav_fix_type = GPS.Fix;
         if (uav_fix_type == 1) {
             uav_fix_type = 3; // 3D fix
         }
         else 
             uav_fix_type == 1; // no fix
 uav_lat = GPS.Lattitude;
 uav_lon = GPS.Longitude;
        #if defined (PROTOCOL_NMEA)
 uav_alt = round(GPS.Altitude / 10.0f); //from mm to cm
        #else
        uav_alt = GPS.Altitude; //in cm
        #endif
 uav_groundspeed = round(GPS.Ground_Speed / 100.0f); // in m/s
 uav_heading = round(GPS.Ground_Course / 100.0f);  // in deg
        } 
  
}
#endif

und im nächsten post...... :-/

/*
	GPS_NMEA.cpp - Generic NMEA GPS library for Arduino
	Code by Jordi Muñoz and Jose Julio. DIYDrones.com
	This code works with boards based on ATMega168/328 and ATMega1280 (Serial port 1)

	This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

	GPS configuration : NMEA protocol
	Baud rate : 38400
	NMEA Sentences : 
		$GPGGA : Global Positioning System Fix Data
		$GPVTG : Ttack and Ground Speed
		
	Methods:
		Init() : GPS Initialization
		Read() : Call this funcion as often as you want to ensure you read the incomming gps data
		
	Properties:
		Lattitude : Lattitude * 10000000 (long value)
		Longitude : Longitude * 10000000 (long value)
		Altitude :  Altitude * 1000 (milimeters) (long value)
		Ground_speed : Speed (m/s) * 100 (long value)
		Ground_course : Course (degrees) * 100 (long value)
		Type : 2 (This indicate that we are using the Generic NMEA library)
		NewData : 1 when a new data is received.
		          You need to write a 0 to NewData when you read the data
		Fix : >=1: GPS FIX, 0: No Fix (normal logic)
		Quality : 0 = No Fix
		           1 = Bad (Num sats < 5)
				   2 = Poor
				   3 = Medium
				   4 = Good

   NOTE : This code has been tested on a Locosys 20031 GPS receiver (MTK chipset)
*/

#if defined(PROTOCOL_NMEA)
#include "GPS_NMEA.h"

// Constructors ////////////////////////////////////////////////////////////////
GPS_NMEA_Class::GPS_NMEA_Class()
{
}

// Public Methods //////////////////////////////////////////////////////////////
void GPS_NMEA_Class::Init(void)
{
	Type = 2;
	GPS_checksum_calc = false;
	bufferidx = 0;
	NewData=0;
	Fix=0;
	Quality=0;
	PrintErrors=0;	
}

// This code don´t wait for data, only proccess the data available on serial port
// We can call this function on the main loop (50Hz loop)
// If we get a complete packet this function call parse_nmea_gps() to parse and update the GPS info.
void GPS_NMEA_Class::Read(void)
{
  char c;
  int numc;
  int i;
	numc = Serial.available();
  if (numc > 0)
    for (i=0;i<numc;i++){
	  c = Serial.read();
      if (c == '

Und im nächsten… :confused:){                      // NMEA Start
        bufferidx = 0;
        buffer[bufferidx++] = c;
        GPS_checksum = 0;
        GPS_checksum_calc = true;
        continue;
        }
      if (c == ‘\r’){                    // NMEA End
        buffer[bufferidx++] = 0;
parse_nmea_gps();
        }
      else {
        if (bufferidx < (GPS_BUFFERSIZE-1)){
          if (c == ‘*’)
            GPS_checksum_calc = false;    // Checksum calculation end
          buffer[bufferidx++] = c;
          if (GPS_checksum_calc)
            GPS_checksum ^= c;            // XOR
          }
else
  bufferidx=0;  // Buffer overflow : restart
        }
    } 
}

/****************************************************************
*
****************************************************************/
// Private Methods //////////////////////////////////////////////////////////////
void GPS_NMEA_Class::parse_nmea_gps(void)
{
  byte NMEA_check;
  long aux_deg;
  long aux_min;
  char *parseptr;

if (strncmp(buffer,"$GPGGA",6)==0){        // Check if sentence begins with $GPGGA
    if (buffer[bufferidx-4]==’’){          // Check for the "" character
      NMEA_check = parseHex(buffer[bufferidx-3])16 + parseHex(buffer[bufferidx-2]);    // Read the checksums characters
      if (GPS_checksum == NMEA_check){      // Checksum validation
        //Serial.println(“buffer”);
NewData = 1;  // New GPS Data
        parseptr = strchr(buffer, ‘,’)+1;
        //parseptr = strchr(parseptr, ‘,’)+1;
Time = parsenumber(parseptr,2);          // GPS UTC time hhmmss.ss
parseptr = strchr(parseptr, ‘,’)+1;
//
        aux_deg = parsedecimal(parseptr,2);      // degrees
        aux_min = parsenumber(parseptr+2,4);    // minutes (sexagesimal) => Convert to decimal
        Lattitude = aux_deg
10000000 + (aux_min50)/3;  // degrees + minutes/0.6  (10000000) (0.6 = 3/5)
        parseptr = strchr(parseptr, ‘,’)+1;
//
if (parseptr==‘S’)
  Lattitude = -1
Lattitude;              // South Lattitudes are negative
//
        parseptr = strchr(parseptr, ‘,’)+1;
        // W Longitudes are Negative
        aux_deg = parsedecimal(parseptr,3);      // degrees
        aux_min = parsenumber(parseptr+3,4);    // minutes (sexagesimal)
        Longitude = aux_deg
10000000 + (aux_min
50)/3;  // degrees + minutes/0.6 (10000000)
        //Longitude = -1
Longitude;                  // This Assumes that we are in W longitudes…
        parseptr = strchr(parseptr, ‘,’)+1;
//
if (parseptr==‘W’)
  Longitude = -1
Longitude;              // West Longitudes are negative
//
        parseptr = strchr(parseptr, ‘,’)+1;
        Fix = parsedecimal(parseptr,1);
        parseptr = strchr(parseptr, ‘,’)+1;
        NumSats = parsedecimal(parseptr,2);
        parseptr = strchr(parseptr, ‘,’)+1;
        HDOP = parsenumber(parseptr,1);          // HDOP * 10
        parseptr = strchr(parseptr, ‘,’)+1;
        Altitude = parsenumber(parseptr,1)100;  // Altitude in decimeters100 = milimeters
if (Fix < 1)
  Quality = 0;      // No FIX
else if(NumSats<5)
  Quality = 1;      // Bad (Num sats < 5)
else if(HDOP>30)
  Quality = 2;      // Poor (HDOP > 30)
else if(HDOP>25)
  Quality = 3;      // Medium (HDOP > 25)
else
  Quality = 4;      // Good (HDOP < 25)
        }
  else
    {
if (PrintErrors)
      Serial.println(“GPSERR: Checksum error!!”);
    }
      }
    }
  else if (strncmp(buffer,"$GPVTG",6)==0){        // Check if sentence begins with $GPVTG
    //Serial.println(buffer);
    if (buffer[bufferidx-4]==’’){          // Check for the "" character
      NMEA_check = parseHex(buffer[bufferidx-3])*16 + parseHex(buffer[bufferidx-2]);    // Read the checksums characters
      if (GPS_checksum == NMEA_check){      // Checksum validation
        parseptr = strchr(buffer, ‘,’)+1;
        Ground_Course = parsenumber(parseptr,2) * 10;      // Ground course in degrees * 100
        parseptr = strchr(parseptr, ‘,’)+1;
        parseptr = strchr(parseptr, ‘,’)+1;
        parseptr = strchr(parseptr, ‘,’)+1;
        parseptr = strchr(parseptr, ‘,’)+1;
        parseptr = strchr(parseptr, ‘,’)+1;
        parseptr = strchr(parseptr, ‘,’)+1;
        Ground_Speed = parsenumber(parseptr,2)*10/36; // Convert Km/h to m/s (*100)
        //GPS_line = true;
        }
  else
    {
if (PrintErrors)
      Serial.println(“GPSERR: Checksum error!!”);
    }
    }
  }
  else
    {
bufferidx = 0;
if (PrintErrors)
  Serial.println(“GPSERR: Bad sentence!!”);
    }
}

/****************************************************************
*
****************************************************************/
// Parse hexadecimal numbers
byte GPS_NMEA_Class::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);
}

// Decimal number parser
long GPS_NMEA_Class::parsedecimal(char *str,byte num_car) {
  long d = 0;
  byte i;
 
  i = num_car;
  while ((str[0] != 0)&&(i>0)) {
    if ((str[0] > ‘9’) || (str[0] < ‘0’))
      return d;
    d *= 10;
    d += str[0] - ‘0’;
    str++;
    i–;
    }
  return d;
}

// Function to parse fixed point numbers (numdec=number of decimals)
long GPS_NMEA_Class::parsenumber(char *str,byte numdec) {
  long d = 0;
  byte ndec = 0;
 
  while (str[0] != 0) {
    if (str[0] == ‘.’){
      ndec = 1;
    }
    else {
      if ((str[0] > ‘9’) || (str[0] < ‘0’))
        return d;
      d *= 10;
      d += str[0] - ‘0’;
      if (ndec > 0)
        ndec++;
      if (ndec > numdec)  // we reach the number of decimals…
        return d;
      }
    str++;
    }
  return d;
}

GPS_NMEA_Class GPS;

#endif


Und im nächsten..... :confused:
#ifndef GPS_NMEA_h
#define GPS_NMEA_h

#define GPS_BUFFERSIZE 120 

class GPS_NMEA_Class
{
  private:
    // Internal variables
    uint8_t GPS_checksum;
    uint8_t GPS_checksum_calc;
 char buffer[GPS_BUFFERSIZE];
 int bufferidx;

 void parse_nmea_gps(void);
 uint8_t parseHex(char c);
 long parsedecimal(char *str,uint8_t num_car);
 long parsenumber(char *str,uint8_t numdec);

  public:
    // Methods
 GPS_NMEA_Class();
 void Init();
 void Read();
 // Properties
 long Time;          //GPS Millisecond Time of Week
 long Lattitude;     // Geographic coordinates
 long Longitude;
 long Altitude;
 long Ground_Speed;
 long Speed_3d;      //Speed (3-D)
 long Ground_Course;
 uint8_t Type;       // Type of GPS (library used)
 uint8_t NumSats;    // Number of visible satelites
 uint8_t Fix;        // >=1:GPS FIX   0:No FIX (normal logic)
 uint8_t Quality;    // GPS Signal quality
 uint8_t NewData;    // 1:New GPS Data
 uint8_t PrintErrors; // 1: To Print GPS Errors (for debug)
 int HDOP;            // HDOP
};

extern GPS_NMEA_Class GPS;

#endif

kann Dein GPS Reciver 10 Hz?

Grüße Uwe

Falls es sich um ein Ublox Neo handelt, die konnten glaub ich erst ab dem Modell 7M 10Hz.

Gruß

Welches GPS Modul es genau ist, weis ich nicht. In jeder Beschreibung im Internet steht 10Hz und 5V dran. (FY41ap GPS Modul) Als ich das Modul nur mit 5V, Masse und am Tx das Protokoll mit u-Center rausgefummelt habe, blinkte es sekündlich. Mit angeschlossenem Autopilot blinkt es 10 mal pro Sekunde. Habe ich mit einer Kamera gefilmt und dann langsam abgespielt und gezählt. :)

Gruß

Hallo, ein gültiger "GPS-Satz" wird nur einmal in der Sekunde vom Satelliten geliefert. scheint wohl nicht zu stimmen. Na, ja. Gruß und Spaß Andreas

SkobyMobil: Hallo, ein gültiger "GPS-Satz" wird nur einmal in der Sekunde vom Satelliten geliefert.

Quatsch.

Du solltest dir die Funktionsweise von GPS Systemen noch einmal ansehen. ;)

jochen111: Welches GPS Modul es genau ist, weis ich nicht. In jeder Beschreibung im Internet steht 10Hz und 5V dran. (FY41ap GPS Modul)

Wie jetzt? Du hast das Teil und da steht nichts drauf, Du kannst es nicht knipsen und gekauft hast Du es auch nirgendwo?!

Womöglich ist es gar kein GPS-Modul ;-)

Gruß

Gregor

Ich verstehe nicht ganz welche Relevanz der GPS Chip für die Änderung der Software in meinem speziellen Fall hat?

Für Gregor ein Link zu einem Bild: https://www.globe-flight.de/10Hz-GPS-Empfaenger-fuer-Feiyu-Tech-FY-41-5V

In meinem Fall sind alle Pins im Stecker belegt. (Auf dem Bild ist der Rx nicht belegt)

Das ist wohl inzwischen untergegangen:

da ich das GPS Signal noch für einen Closedsource Autopiloten benötige, welche unbedingt 10Hz haben möchte und dem GPS Empfänger auch sofort nach dem anschließen auf 10 Hz umstellt. (Vermutlich über den Rx pin.)

Dein GPS Modul kann definitiv 10 Hz, du weisst nur nicht, wie der Autopilot es schafft, den Empfänger umzustellen.

Mein Status: Weiss ich auch nicht, Dein Verdacht auf die Rx Leitung liegt nahe.

Versuch mal, da mitzuhören.

Oder umgekehrt, Dein Arduino hört einfach mit, was der GPS Modul dem Autopiloten im 10 Hz Modus erzählt.

jochen111: Ich verstehe nicht ganz welche Relevanz der GPS Chip für die Änderung der Software in meinem speziellen Fall hat?

Mein Interesse daran ist der Tatsache geschuldet, dass ich noch nie mit irgendeinem GPS-Ding zu tun hatte. Und mit einer genauen Bezeichnung ist es häufig verhältnismäßig einfach, Datenblätter zu finden - und in diesem finden sich dann häufig Hinweise auf mögliche Fehlerquellen.

Blöderweise ist auf der von Dir genannten Seite gar kein Datenblatt verlinkt.

jochen111: Für Gregor ein Link zu einem Bild: https://www.globe-flight.de/10Hz-GPS-Empfaenger-fuer-Feiyu-Tech-FY-41-5V In meinem Fall sind alle Pins im Stecker belegt. (Auf dem Bild ist der Rx nicht belegt)

Danke!

Gruß

Gregor

PS: Der Vorschlag von Michael ist gut. Das mit dem Belauschen hast Du ja schon mal hinbekommen.

Nach langem rumgefummel konnte ich nicht feststellen mit welchem Befehl Das GPS Modul überzeugt wird auf 10Hz zu wechseln. wofür das gut sein soll zu wissen wie es geschieht, weis ich nicht. Schließlich möchte ich doch, daß das Ghettoproxy 10Hz lesen kann und nicht die 10Hz ändern. Ich werde jetzt wohl doch ein eigenes GPS Modul verwenden müssen.

Vielen Dank

Hallo, "Welches GPS Modul es genau ist, weis ich nicht."

Läuft es denn mit U-Center? Wenn ja, könnte es ein U-Blox Modul sein. Das kannst Du, wenn Du die Anleitung zu U-Center gelesen hast, auslesen. Wenn Du den Typ bekommen hast, dann das Datenblatt dazu lesen. Das ist alles kein Problem! Du kannst es auch mit einem TerminalProgramm auslesen. Gruß und Spaß Andreas

Es wird kein U-blox sein, denn die Geschwindigkeitsänderung im U-Center findet man auch ohne Datenblatt.

SetRate.png

Die Umstellung des Moduls auf 10Hz ist doch gar nicht das Problem. Er will doch den parallel lauschenden Sketch ändern, dass selbiger 10Hz einlesen kann. Bisher gingen alle Antworten und Tips an der Problemstellung vorbei.
Leider habe ich auch keine Erfahrung in dem Bereich.

Mit der Bibliothek tinygps oder tinygps++ kein Problem, hab ich selbst schon gemacht mit 10Hz auf einem U-blox NEO 6M.

Gruß

Scherheinz: Mit der Bibliothek tinygps oder tinygps++ kein Problem, hab ich selbst schon gemacht mit 10Hz auf einem U-blox NEO 6M.

Gruß

Ich weiß das ist ein alter Thread... aber mit welchem Befehl konnte die Hz umgestellt werden?

Benötige das auch momentan... Wäre sehr wichtig!

Hast Du Dir die Beispiele bzw Funktionen der Bibliothek angeschaut (.h und .cpp file) oder muß ich das für Dich machen?
Grüße Uwe