kostenloser Webspace werbefrei: lima-city


Aus GPS Koordinaten Kurs berechnen

lima-cityForumProgrammiersprachenC/C++ und D

  1. Autor dieses Themas

    christian1603

    Kostenloser Webspace von christian1603

    christian1603 hat kostenlosen Webspace.

    Hallo LC,
    ich habe ein kleines Projekt vor mir wo ich den Kurs berechnen muss denn ich gehen muss damit ich an einer bestimmten
    GPS Position ankomme.

    Mir bekannt ist meine Aktuelle GPS Position und die Ziel Position.
    Noch dazu soll das ganze in C ablaufen.

    //Start
     char lon1 = "52.011144"; (Format is veränderbar)
     char lat1= "11.68632";
      //ziel
     char lon2 = "51.983611";
     char lat2= "11.6922";
     //Winkel
     char Winkel;


    Ich habe bei Wiki eine rechnung gefunden. Klick
    Weiß aber nicht wie ich das in C umsetzen kann :(


    Wäre cool wenn ihr mir dabei helfen könntet...
  2. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

  3. ich behaupte, du unterliegst dem irrglauben, dass du späisch rechnen musst...


    du hast deine Position, die ist koordinatenursprung für dich.


    du hast dein ziel, da ziehst du die differenz ab:


    x_vektor = lon1 - lon2
    y_vektor= lat1 - lat2

    und dann bekommst du einen vektor raus und mit dem kannst du rechnen


    hoffe der denkanstoß hilft dir weiter
  4. Hallo christian1603,

    eigentlich kannst Du die Beispielrechnung aus Wikipedia einfach abschreiben:
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #ifndef M_PI
    static const double M_PI = 3.1415926535897932384626433832795;
    #endif
    
    static const double R_EARTH=6371000.785;
    
    /* define structure for geographic coordinates: */
    typedef struct
    {
      double latitude;
      double longitude;
    } geographic_t;
    
    /* compute the angular distance between two locations.
     *   coord1 -- pointer to coordinates of first location
     *   coord2 -- pointer to coordinates of second location
     *
     *   returns angular distance in radians
     */
    double angular_distance(geographic_t * coord1, geographic_t * coord2)
    {
      double phi_1, phi_2, lambda_1, lambda_2, zeta;
    
      /* convert degrees to radians: */
      phi_1 = coord1->latitude * M_PI / 180.0;
      lambda_1 = coord1->longitude * M_PI / 180.0;
    
      phi_2 = coord2->latitude * M_PI / 180.0;
      lambda_2 = coord2->longitude * M_PI / 180.0;
    
      /* do what Wiki told you: */
      zeta = acos(sin(phi_1)*sin(phi_2)+ cos(phi_1)*cos(phi_2)*cos(lambda_2 - lambda_1));
    
      return zeta;
    }
    
    /* compute the geographic distance between two locations.
     *   coord1 -- pointer to coordinates of first location
     *   coord2 -- pointer to coordinates of second location
     *
     *   returns distance in meters
     */
    double distance(geographic_t * coord1, geographic_t * coord2)
    {
      /* again, do what Wiki told you: */
      return R_EARTH * angular_distance(coord1, coord2);
    }
    
    int main(int argc, char ** argv)
    {
      /* first posibility: */
      geographic_t g1 = {52.011144, 11.68632};
      geographic_t g2 = {51.983611, 11.6922};
    
      printf("Winkel: %.2lf Grad\n", angular_distance(&g1, &g2)*180.0/M_PI);
      printf("Abstand: %.2lf km\n", distance(&g1, &g2)/1000.0);
      
      /* second possibility: */
      g1.latitude = atof("52.011144");
      g1.longitude = atof("11.68632");
    
      g2.latitude = atof("51.983611");
      g2.longitude = atof("11.6922");
    
      printf("Winkel: %.2lf Grad\n", angular_distance(&g1, &g2)*180.0/M_PI);
      printf("Abstand: %.2lf km\n", distance(&g1, &g2)/1000.0);
      
      getchar();
      return 0;
    }
    Allerdings ist das vermutlich nicht das, was Du eigentlich willst.
    Die Formeln geben Dir entweder den Winkelabstand oder den Abstand der zwei Punkte in Metern. Was Du aber nicht bekommst ist die Richtung in die Du gehen musst.
    Idealerweise sollte der Kurs vermutlich als Kompass-Richtung angegeben werden. Dazu sind Großkreise (Orthodrome) nicht geeignet, da sich die Kompassrichtung ständig ändert. Also solltest Du Dir vermutlich das hier anschauen:
    http://de.wikipedia.org/wiki/Loxodrome
  5. Autor dieses Themas

    christian1603

    Kostenloser Webspace von christian1603

    christian1603 hat kostenlosen Webspace.

    darkpandemic schrieb:
    Hallo christian1603,

    eigentlich kannst Du die Beispielrechnung aus Wikipedia einfach abschreiben:
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    #ifndef M_PI
    static const double M_PI = 3.1415926535897932384626433832795;
    #endif
    
    static const double R_EARTH=6371000.785;
    
    /* define structure for geographic coordinates: */
    typedef struct
    {
      double latitude;
      double longitude;
    } geographic_t;
    
    /* compute the angular distance between two locations.
     *   coord1 -- pointer to coordinates of first location
     *   coord2 -- pointer to coordinates of second location
     *
     *   returns angular distance in radians
     */
    double angular_distance(geographic_t * coord1, geographic_t * coord2)
    {
      double phi_1, phi_2, lambda_1, lambda_2, zeta;
    
      /* convert degrees to radians: */
      phi_1 = coord1->latitude * M_PI / 180.0;
      lambda_1 = coord1->longitude * M_PI / 180.0;
    
      phi_2 = coord2->latitude * M_PI / 180.0;
      lambda_2 = coord2->longitude * M_PI / 180.0;
    
      /* do what Wiki told you: */
      zeta = acos(sin(phi_1)*sin(phi_2)+ cos(phi_1)*cos(phi_2)*cos(lambda_2 - lambda_1));
    
      return zeta;
    }
    
    /* compute the geographic distance between two locations.
     *   coord1 -- pointer to coordinates of first location
     *   coord2 -- pointer to coordinates of second location
     *
     *   returns distance in meters
     */
    double distance(geographic_t * coord1, geographic_t * coord2)
    {
      /* again, do what Wiki told you: */
      return R_EARTH * angular_distance(coord1, coord2);
    }
    
    int main(int argc, char ** argv)
    {
      /* first posibility: */
      geographic_t g1 = {52.011144, 11.68632};
      geographic_t g2 = {51.983611, 11.6922};
    
      printf("Winkel: %.2lf Grad\n", angular_distance(&g1, &g2)*180.0/M_PI);
      printf("Abstand: %.2lf km\n", distance(&g1, &g2)/1000.0);
      
      /* second possibility: */
      g1.latitude = atof("52.011144");
      g1.longitude = atof("11.68632");
    
      g2.latitude = atof("51.983611");
      g2.longitude = atof("11.6922");
    
      printf("Winkel: %.2lf Grad\n", angular_distance(&g1, &g2)*180.0/M_PI);
      printf("Abstand: %.2lf km\n", distance(&g1, &g2)/1000.0);
      
      getchar();
      return 0;
    }
    Allerdings ist das vermutlich nicht das, was Du eigentlich willst.
    Die Formeln geben Dir entweder den Winkelabstand oder den Abstand der zwei Punkte in Metern. Was Du aber nicht bekommst ist die Richtung in die Du gehen musst.
    Idealerweise sollte der Kurs vermutlich als Kompass-Richtung angegeben werden. Dazu sind Großkreise (Orthodrome) nicht geeignet, da sich die Kompassrichtung ständig ändert. Also solltest Du Dir vermutlich das hier anschauen:
    http://de.wikipedia.org/wiki/Loxodrome






    #include <math.h>
    #include "RP6ControlLib.h" 		// The RP6 Control Library. 
    								// Always needs to be included!
    
    /*****************************************************************************/
    // Main function - The program starts here:
    
    
    
    void writeDoubleLCD(double number, uint8_t width, uint8_t prec)
    {char buffer[width + 1];
     dtostrf(number, width, prec, &buffer[0]);
     writeStringLCD(&buffer[0]);
    }
    
    
    int main(void)
    {
     initRP6Control(); // Always call this first! The Processor will not work
           // correctly otherwise. 
     initLCD(); // Initialize the LC-Display (LCD)
      
    	 double pos_breite_A = 52.00137* M_PI / 180.0, pos_laenge_A=11.621475* M_PI /180;  //Koordinaten Punkt A mit Umwandlung in Bogenmaß
    double pos_breite_B = 52.552976* M_PI /180, pos_laenge_B=10.014038* M_PI /180; //Koordinaten Punkt B mit Umwandlung in Bogenmaß
     // 52.552976,10.014038
       
       double zentriw, distance, kurswinkel;
           
     
          zentriw = 2.0*asin(sqrt(square(sin((pos_breite_A-pos_breite_B)/2.0)) + cos(pos_breite_A)*cos(pos_breite_B)*square(sin((pos_laenge_B-pos_laenge_A)/2.0))));
          distance = zentriw*6370; // in km
           
    
          kurswinkel = acos((sin(pos_breite_B)-sin(pos_breite_A)*cos(zentriw))/(cos(pos_breite_A)*sin(zentriw)));
        
    	setCursorPosLCD(0, 0);  // line 1
        writeStringLCD("Entf. ");  writeDoubleLCD(distance, 1, 1);  writeStringLCD(" km");
      setCursorPosLCD(1, 0);  // line 1
     if(pos_laenge_A <= pos_laenge_B && (pos_laenge_B-pos_laenge_A <= M_PI)){    
        
    	 writeStringLCD("Kurs ");  writeDoubleLCD(kurswinkel, 1, 1);  writeStringLCD(" Grad");
      }else if(pos_laenge_A > pos_laenge_B && (pos_laenge_A-pos_laenge_B <= M_PI)){ 
          
    	    writeStringLCD("Kurs ");  writeDoubleLCD(360 - kurswinkel, 1, 1);  writeStringLCD(" Grad");
          }else if(pos_laenge_A < pos_laenge_B && (pos_laenge_B-pos_laenge_A > M_PI)){   
        
      writeStringLCD("Kurs ");  writeDoubleLCD(360 - kurswinkel*180/M_PI, 1, 1);  writeStringLCD(" Grad"); 
      }else if(pos_laenge_A > pos_laenge_B && (pos_laenge_A-pos_laenge_B > M_PI)){     
      
     writeStringLCD("Kurs ");  writeDoubleLCD(kurswinkel*180/M_PI, 1, 1);  writeStringLCD(" Grad"); 
        
      }
     
          
       
       
         mSleep(2000);
       
    
    	return 0;
    }





    So hab ich es jetzt... die entfernung stimmt aber es kommt irgentwie immer 360 Grad raus... hat jemand eine idee woran das liegt?
  6. Diskutiere mit und stelle Fragen: Jetzt kostenlos anmelden!

    lima-city: Gratis werbefreier Webspace für deine eigene Homepage

Dir gefällt dieses Thema?

Über lima-city

Login zum Webhosting ohne Werbung!