GPS-Daten

Das Programm strip_gps.nxc wertet die Daten aus die das Programm von
Antonio Scarfone "gps_master_1_04.nxc" liefert.
Hier das modifizierte Programm von Scarfone.

Der Nxt kommuniziert mit der GPS-Mouse (RoyalTek RBT 1000 XTRACK2) über Bluetooth.

Da es Float bei NXC noch nicht gibt habe ich die GPS-Daten in low und high (vor und nach dem Komma) geteilt.

/* *********************************************************************
Hello, with this little tool you can analyze the GPS-Out-string
I use only the GPPGGA string.

You must the code include in "Antonio Scarfone" "gps_master_1_04.nxc"

copy and paste or

#include "strip_gps.nxc"

after
.....
#include "NXCDefs.h"
.......

start the tool with

.......
       //debug output
       //tmpstr=SubStr(out, 5, 13);
       //TextOut(0,LCD_LINE4,tmpstr);
       //NumOut(0,LCD_LINE5,numsent);
       //write the sentences in a file
       
   strip_gps_data(out);   //----------------this is new
       
       // WriteData(FILENAME,out);
       numsent = 0;
...........

possibly you must comment out TextOUT or NumOUT from gps_master_1_04.nxc

Author: Robokalle
Date:   19.11.2007

************************************************************************** */
#include "NXCDefs.h"

struct GPGGA_struct {
       long clock_high;
       long clock_low;
       unsigned int latitude_high;
       int latitude_low;
       string N_direction;
       unsigned int longitude_high;
       int longitude_low;
       string E_direction;
       byte quality;
       byte Sat_number;
       byte accurateness_high;
       byte accurateness_low;
       int altitude_high;
       int altitude_low;
       string altitude_measure;
};
GPGGA_struct GPGGA;

void  GPGGAtoScreen() {
   ClearScreen();

   NumOut(0,LCD_LINE1,GPGGA.clock_high);
   TextOut(36,LCD_LINE1,".");
   NumOut(42,LCD_LINE1,GPGGA.clock_low);

   NumOut(0,LCD_LINE2,GPGGA.latitude_high);
   TextOut(36,LCD_LINE2,".");
   NumOut(42,LCD_LINE2,GPGGA.latitude_low);

   NumOut(0,LCD_LINE3,GPGGA.longitude_high);
   TextOut(36,LCD_LINE3,".");
   NumOut(42,LCD_LINE3,GPGGA.longitude_low);

   NumOut(0,LCD_LINE4,GPGGA.altitude_high);
   TextOut(36,LCD_LINE4,".");
   NumOut(42,LCD_LINE4,GPGGA.altitude_low);
   TextOut(48,LCD_LINE4,GPGGA.altitude_measure);

   NumOut(0,LCD_LINE5,GPGGA.accurateness_high);
   TextOut(36,LCD_LINE5,".");
   NumOut(42,LCD_LINE5,GPGGA.accurateness_low);

   NumOut(0,LCD_LINE6,GPGGA.quality);
   NumOut(0,LCD_LINE7,GPGGA.Sat_number);

} // GPGGA

void copytostruct(int item,string sdumy){
int len,j;
string dumy, dumy1;
len= StrLen(sdumy);

switch(item){
            case 1:
                 for (j=0; j < len ;j++){
                      if (StrIndex(sdumy,j)== 46){ // nach "." suchen
                          dumy1= SubStr( sdumy,0,j ) ;
                          GPGGA.clock_high = StrToNum(dumy1);
                          dumy1=SubStr( sdumy,j+1, len - j);
                          GPGGA.clock_low =StrToNum(dumy1);
                      }// if str
                   } // for j
            break;
            case 2:
                 for (j=0; j < len ;j++){
                      if (StrIndex(sdumy,j)== 46){ // nach "." suchen
                          dumy1= SubStr( sdumy,0,j ) ;
                          GPGGA.latitude_high = StrToNum(dumy1);
                          dumy1=SubStr( sdumy,j+1, len - j);
                          GPGGA.latitude_low =StrToNum(dumy1);
                      }// if str
                   } // for j
            break;

            case 3:
                 GPGGA.N_direction=sdumy;
            break;
            case 4:
                 for (j=0; j < len ;j++){
                      if (StrIndex(sdumy,j)== 46){ // nach "." suchen
                          dumy1= SubStr( sdumy,0,j ) ;
                          GPGGA.longitude_high = StrToNum(dumy1);
                          dumy1=SubStr( sdumy,j+1, len - j);
                          GPGGA.longitude_low =StrToNum(dumy1);
                      }// if str
                   } // for j
            break;
            case 5:
                 GPGGA.E_direction=sdumy;
            break;
            case 6:
                 GPGGA.quality=StrToNum(sdumy);
            break;
            case 7:
                 GPGGA.Sat_number=StrToNum(sdumy);
            break;
            case 8:
                 for (j=0; j < len ;j++){
                      if (StrIndex(sdumy,j)== 46){ // nach "." suchen
                          dumy1= SubStr( sdumy,0,j ) ;
                          GPGGA.accurateness_high = StrToNum(dumy1);
                          dumy1=SubStr( sdumy,j+1, len - j);
                          GPGGA.accurateness_low =StrToNum(dumy1);
                      }// if str
                   } // for j
            break;
            case 9:
                 for (j=0; j < len ;j++){
                      if (StrIndex(sdumy,j)== 46){ // nach "." suchen
                          dumy1= SubStr( sdumy,0,j ) ;
                          GPGGA.altitude_high = StrToNum(dumy1);
                          dumy1=SubStr( sdumy,j+1, len - j);
                          GPGGA.altitude_low =StrToNum(dumy1);
                      }// if str
                   } // for j
            break;
            case 10:
                 GPGGA.altitude_measure=sdumy;
            break;

               
}// switch


} // ----------------------------------copytostr

void strip_gps_data(string GPS_data){
int lendata, i, begin, last, item ;
string sdumy;
bool GGA;
GGA = false;
i=0;
lendata= StrLen(GPS_data);
begin = -1;
item=0;

while (StrIndex(GPS_data,i) ==36 && i < lendata){// suchen "$"
      i++;
      begin =i;
      } // while
if (begin >-1){
    for (i=begin; i < lendata ;i++) {
        if (StrIndex(GPS_data,i)== 44){
           last=i;
           sdumy=SubStr(GPS_data,begin,last-begin);
           if (sdumy == "GPGGA"){
              GGA = true;
           }

           if (GGA){
           NumOut(0,LCD_LINE6,GGA);
              copytostruct(item,sdumy);
              begin=i+1;
             // NumOut(0,LCD_LINE8,item);
              item++;
              if (item > 10){
                 i=lendata;
               //  Wait(500);
                GPGGAtoScreen();
              }
           }
           
           else
           {
           i=lendata;
           }
        }// if strindex
    }// for begin
} // if
} // ---------------------------------copy


/*
task main (){   // Testing main
string GPS_data = "$GPGGA,123522.798,5016.9430,N,01776.7081,E,1,05,5.0,564.2,M,,,,0000*0F";

 strip_gps_data(GPS_data);


 Wait(1000);
}  //----------------------------------------main
 */

2 GPS Mäuse mit VB6

2 GPS-Empfänger

Dies sind die ersten Tests mit 2 GPS-Empfänger.
1 TomTom Maus am COM-Port über USB
1 Rikaline GPS-6031-X7 Bluetooth
1 Visual Basic 6.0 Programm auf dem Laptop.
Das ganze wurde auf einem Tablett durch den Garten getragen.

Die maximale Abmessungen der Wegpunkte ca. 36m x 26m.
blau Häuser
grün Bäume
Deutlich zu sehen die unterschiedlichen Ausgaben der GPS-Empfänger. Auch unterschiedliche Empfangsleistung bei Abschattungen.

Mit 2 GPS-Mäuse soll es besser werden. Test steht noch aus.

Hier mal ein Tipp von einem Landvermesser
(Danke nochmal an Rico)

wenn Du den eine Empfänger fest irgendwo aufbaust. Er darf sich nie von der Stelle bewegen, das heißt, Du solltest immer die Gleiche Position empfangen. Tust Du aber nicht, wegen schwankende Satelittenbahnen, Luftschichten, Sonneneruptionen etc.
Nun musst Du den wert was sich Dein fester GPS Empfänger angeblich bewegt hat einfach vom sich tatsächlich bewegenden Empfänger abziehen, und bekommst eine korrigierte neue Position.
In Deutschland hat jedes Vermessungsamt einen Empfänger fest auf dem Dach, und liefert permanent Korrekturwerte. Natürlich nicht kostenlostenlos.

Aber dafür hoch genau. Wir können damit auf Arbeit eine Position mit einer Genauigkeit von 1-3 cm bestimmen. Dein Problem wird sein: Die wirkliche Position des Festen Empfängers. Einen guten wert wirst Du bekommen, wenn Du die Position 2 mal 24 Stunden lang protokollierst. Zwischen den 2 Messungen sollten einige Tage Zeit liegen. Wir empfangen bei solchen Dauermessungen alle 15 sec eine vollkommen unabhängig gerechnete neue Position.
Da kommt in 24 Stunden schon was zusammen. Das wird dann alles gemittelt und fertig ist eine 24 Stundenposition. Natürlich sind unsere Empfänger auch besser, da sie eine genauere Antenne besitzen, und vor
allem 2 Frequenzen empfangen.
Ich schätze mit nur einer Frequenz wirst Du eine Genauigkeit von max. 50cm bis 1m bekommen.
Bei Abschattungen (nahe Hauswand oder unter dem Baum) ist nicht einmal das machbar. Da hier die Signale von der Wand reflektiert werden, und dann etwas später im Empfänger eintreffen. Das bedeutet, das jedes Signal unzählig oft im Empfänger an kommt.
Unsere Antennen haben dafür eine Abschirmung, und die Empfänger aufwendige Analysefunktionen eingebaut um das angeblich richtig
Signal auszufiltern. Doch die Praxis zeigt, das auch das seine Grenzen
hat, und die sind noch lange nicht dort, wo man sie sich wünscht.

Home

Lego

Combat DigiQ