trunk/src/gps.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of GPXView.
 *
 * GPXView is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <string.h>
#include <math.h>

#include "gpxview.h"


#ifdef USE_MAEMO
#ifdef ENABLE_GPSBT
#include <gpsbt.h>
#include <gpsmgr.h>
#endif
#include <errno.h>
#endif

#ifndef ENABLE_LIBLOCATION

/* maybe user configurable later on ... */
#define GPSD_HOST "127.0.0.1"
#define GPSD_PORT 2947

gps_sat_t *gps_get_sats(appdata_t *appdata) {
  gps_sat_t *retval = NULL;

  g_mutex_lock(appdata->gps_state->mutex);
  if(appdata->gps_state->gpsdata.set & SATELLITE_SET) {
    int i;
    retval = malloc(sizeof(gps_sat_t));
    retval->num = appdata->gps_state->gpsdata.satellites;

    retval->PRN  = malloc(sizeof(int)*retval->num);
    retval->used = malloc(sizeof(int)*retval->num);
    retval->ss   = malloc(sizeof(int)*retval->num);

    if(retval->num) {
      for(i=0;i<retval->num;i++) {
        retval->PRN[i]  = appdata->gps_state->gpsdata.PRN[i];
        retval->ss[i]   = appdata->gps_state->gpsdata.ss[i];
        retval->used[i] = appdata->gps_state->gpsdata.used[i];
      }
    }
  }

  g_mutex_unlock(appdata->gps_state->mutex);

  return retval;
}

pos_t *gps_get_pos(appdata_t *appdata) {
  static pos_t retval;

  retval.lat = NAN;

  g_mutex_lock(appdata->gps_state->mutex);
  if(appdata->gps_state->gpsdata.set & STATUS_SET)
    if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX)
      if(appdata->gps_state->gpsdata.set & LATLON_SET) 
        retval = appdata->gps_state->gpsdata.fix.pos;

  g_mutex_unlock(appdata->gps_state->mutex);

  if(isnan(retval.lat))
    return NULL;

  return &retval;
}

float gps_get_heading(appdata_t *appdata) {
  float retval = NAN;

  g_mutex_lock(appdata->gps_state->mutex);
  if(appdata->gps_state->gpsdata.set & STATUS_SET)
    if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX) 
      if(appdata->gps_state->gpsdata.set & TRACK_SET) 
        retval = appdata->gps_state->gpsdata.fix.track;

  g_mutex_unlock(appdata->gps_state->mutex);
  return retval;
}

float gps_get_epe(appdata_t *appdata) {
  float retval = NAN;

  g_mutex_lock(appdata->gps_state->mutex);
  if(appdata->gps_state->gpsdata.set & STATUS_SET)
    if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX) 
      retval = appdata->gps_state->gpsdata.fix.eph;

  g_mutex_unlock(appdata->gps_state->mutex);
  return retval;
}

static int gps_connect(gps_state_t *gps_state) {
  GnomeVFSResult vfs_result;
#ifdef USE_MAEMO
  char errstr[256] = "";

  /* We need to start gpsd (via gpsbt) first. */
  memset(&gps_state->context, 0, sizeof(gpsbt_t));
  errno = 0;

  if(gpsbt_start(NULL, 0, 0, 0, errstr, sizeof(errstr),
                 0, &gps_state->context) < 0) {
    printf("Error connecting to GPS receiver: (%d) %s (%s)\n",
           errno, strerror(errno), errstr);
  }
#endif

  /************** from here down pure gnome/gtk/gpsd ********************/

  /* try to connect to gpsd */
  /* Create a socket to interact with GPSD. */

  int retries = 5;
  while(retries && 
        (GNOME_VFS_OK != (vfs_result = gnome_vfs_inet_connection_create(
                &gps_state->iconn, GPSD_HOST, GPSD_PORT, NULL)))) {
    printf("Error creating connection to GPSD, retrying ...\n");

    retries--;
    sleep(1);
  }

  if(!retries) {
    printf("Finally failed ...\n");
    return -1;
  }

  retries = 5;
  while(retries && ((gps_state->socket = 
     gnome_vfs_inet_connection_to_socket(gps_state->iconn)) == NULL)) {
    printf("Error creating connecting GPSD socket, retrying ...\n");

    retries--;
    sleep(1);
  }

  if(!retries) {
    printf("Finally failed ...\n");
    return -1;
  }

  GTimeVal timeout = { 10, 0 };
  if(GNOME_VFS_OK != (vfs_result = gnome_vfs_socket_set_timeout(
        gps_state->socket, &timeout, NULL))) {
    printf("Error setting GPSD timeout\n");
    return -1;
  } 

  printf("GPSD connected ...\n");

  return 0;
}       

void gps_clear_fix(struct gps_fix_t *fixp) {
  fixp->mode = MODE_NOT_SEEN;
  fixp->pos.lat = fixp->pos.lon = NAN;
  fixp->track = NAN;
  fixp->speed = NAN;
  fixp->climb = NAN;
  fixp->altitude = NAN;
  fixp->ept = NAN;
  fixp->eph = NAN;
  fixp->epv = NAN;
  fixp->epd = NAN;
  fixp->eps = NAN;
  fixp->epc = NAN;
}

/* unpack a daemon response into a status structure */
static void gps_unpack(char *buf, struct gps_data_t *gpsdata) {
  char *ns, *sp, *tp;

  for(ns = buf; ns; ns = strstr(ns+1, "GPSD")) {
    if(strncmp(ns, "GPSD", 4) == 0) {
      /* the following should execute each time we have a good next sp */
      for (sp = ns + 5; *sp != '\0'; sp = tp+1) {
        tp = sp + strcspn(sp, ",\r\n");
        if (*tp == '\0') tp--;
        else *tp = '\0';
        
        switch (*sp) {
        case 'A':
          if (sp[2] == '?') {
            gpsdata->fix.altitude = NAN;
          } else {
            (void)sscanf(sp, "A=%lf", &gpsdata->fix.altitude);
            gpsdata->set |= ALTITUDE_SET;
          }
          break;
          /* B - baudrate isn't supported by gpxview */
          /* C - cycle isn't supported by gpxview */
          /* D - utc time isn't supported by gpxview */
        case 'E':
          gpsdata->epe = gpsdata->fix.eph = gpsdata->fix.epv = NAN;
          /* epe should always be present if eph or epv is */
          if (sp[2] != '?') {
            char epe[20], eph[20], epv[20];
            (void)sscanf(sp, "E=%s %s %s", epe, eph, epv);
#define DEFAULT(val) (val[0] == '?') ? NAN : g_ascii_strtod(val, NULL)
            gpsdata->epe = DEFAULT(epe);
            gpsdata->fix.eph = DEFAULT(eph);
            gpsdata->fix.epv = DEFAULT(epv);
#undef DEFAULT
          }
          break;
          /* F - device name isn't supported by gpxview */
          /* I - gps id isn't supported by gpxview */
          /* K - known devices list isn't supported by gpxview */
        case 'M':
          if (sp[2] == '?') {
            gpsdata->fix.mode = MODE_NOT_SEEN;
          } else {
            gpsdata->fix.mode = atoi(sp+2);
            gpsdata->set |= MODE_SET;
          }
          break;
          /* N - driver mode reporting isn't supported by gpxview */
        case 'O':
          if (sp[2] == '?') {
            gpsdata->set = 
              (gpsdata->set & SATELLITE_SET) | // fix for below
              MODE_SET | STATUS_SET;  // this clears sat info??
            gpsdata->status = STATUS_NO_FIX;
            gps_clear_fix(&gpsdata->fix);
          } else {
            struct gps_fix_t nf;
            char tag[MAXTAGLEN+1], alt[20];
            char eph[20], epv[20], track[20],speed[20], climb[20];
            char epd[20], eps[20], epc[20], mode[2];
            char timestr[20], ept[20], lat[20], lon[20];
            int st = sscanf(sp+2, 
                            "%8s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %1s",
                            tag, timestr, ept, lat, lon,
                            alt, eph, epv, track, speed, climb,
                            epd, eps, epc, mode);
            if (st >= 14) {
#define DEFAULT(val) (val[0] == '?') ? NAN : g_ascii_strtod(val, NULL)
              nf.pos.lat = DEFAULT(lat);
              nf.pos.lon = DEFAULT(lon);
              nf.ept = DEFAULT(ept);
              nf.altitude = DEFAULT(alt);
              nf.eph = DEFAULT(eph);
              nf.epv = DEFAULT(epv);
              nf.track = DEFAULT(track);
              nf.speed = DEFAULT(speed);
              nf.climb = DEFAULT(climb);
              nf.epd = DEFAULT(epd);
              nf.eps = DEFAULT(eps);
              nf.epc = DEFAULT(epc);
#undef DEFAULT
              if (st >= 15)
                nf.mode = (mode[0] == '?') ? MODE_NOT_SEEN : atoi(mode);
              else
                nf.mode = (alt[0] == '?') ? MODE_2D : MODE_3D;
              if (alt[0] != '?')
                gpsdata->set |= ALTITUDE_SET | CLIMB_SET;
              if (isnan(nf.eph)==0)
                gpsdata->set |= HERR_SET;
              if (isnan(nf.epv)==0)
                gpsdata->set |= VERR_SET;
              if (isnan(nf.track)==0)
                gpsdata->set |= TRACK_SET | SPEED_SET;
              if (isnan(nf.eps)==0)
                gpsdata->set |= SPEEDERR_SET;
              if (isnan(nf.epc)==0)
                gpsdata->set |= CLIMBERR_SET;
              gpsdata->fix = nf;
              gpsdata->set |= TIME_SET|TIMERR_SET|LATLON_SET|MODE_SET;
              gpsdata->status = STATUS_FIX;
              gpsdata->set |= STATUS_SET;
            }
          }
          break;
        case 'P':
          if (sp[2] == '?') {
            gpsdata->fix.pos.lat = NAN;
            gpsdata->fix.pos.lon = NAN;
          } else {
            char lat[20], lon[20];
            (void)sscanf(sp, "P=%19s %19s", lat, lon);
            gpsdata->fix.pos.lat = g_ascii_strtod(lat, NULL);
            gpsdata->fix.pos.lon = g_ascii_strtod(lon, NULL);
            gpsdata->set |= LATLON_SET;
          }
          break;
        case 'Q':
          if (sp[2] == '?') {
            gpsdata->satellites_used = 0;
            gpsdata->pdop = 0;
            gpsdata->hdop = 0;
            gpsdata->vdop = 0;
          } else {
            (void)sscanf(sp, "Q=%d %lf %lf %lf %lf %lf",
                         &gpsdata->satellites_used,
                         &gpsdata->pdop,
                         &gpsdata->hdop,
                         &gpsdata->vdop,
                         &gpsdata->tdop,
                         &gpsdata->gdop);
            gpsdata->set |= HDOP_SET | VDOP_SET | PDOP_SET;
          }
          break;
        case 'S':
          if (sp[2] == '?') {
            gpsdata->status = -1;
          } else {
            gpsdata->status = atoi(sp+2);
            gpsdata->set |= STATUS_SET;
          }
          break;
        case 'T':
          if (sp[2] == '?') {
            gpsdata->fix.track = NAN;
          } else {
            (void)sscanf(sp, "T=%lf", &gpsdata->fix.track);
            gpsdata->set |= TRACK_SET;
          }
          break;
        case 'U':
          if (sp[2] == '?') {
            gpsdata->fix.climb = NAN;
          } else {
            (void)sscanf(sp, "U=%lf", &gpsdata->fix.climb);
            gpsdata->set |= CLIMB_SET;
          }
          break;
        case 'V':
          if (sp[2] == '?') {
            gpsdata->fix.speed = NAN;
          } else {
            (void)sscanf(sp, "V=%lf", &gpsdata->fix.speed);
            /* V reply is in kt, fix.speed is in metres/sec */
            gpsdata->fix.speed = gpsdata->fix.speed / MPS_TO_KNOTS;
            gpsdata->set |= SPEED_SET;
          }
          break;
        case 'X':
          if (sp[2] == '?') 
            gpsdata->online = -1;
          else {
            (void)sscanf(sp, "X=%lf", &gpsdata->online);
            gpsdata->set |= ONLINE_SET;
          }
          break;
        case 'Y':
          if (sp[2] == '?') {
            gpsdata->satellites = 0;
          } else {
            int j, i1, i2, i3, i4, i5;
            int PRN[MAXCHANNELS];
            int elevation[MAXCHANNELS], azimuth[MAXCHANNELS];
            int ss[MAXCHANNELS], used[MAXCHANNELS];
            char tag[MAXTAGLEN+1], timestamp[21];
            
            (void)sscanf(sp, "Y=%8s %20s %d ", 
                         tag, timestamp, &gpsdata->satellites);
            for (j = 0; j < gpsdata->satellites; j++) {
              PRN[j]=elevation[j]=azimuth[j]=ss[j]=used[j]=0;
            }
            //      printf("sats = %d\n", gpsdata->satellites);
            for (j = 0, gpsdata->satellites_used = 0; j < gpsdata->satellites; j++) {
              if ((sp != NULL) && ((sp = strchr(sp, ':')) != NULL)) {
                sp++;
                (void)sscanf(sp, "%d %d %d %d %d", &i1, &i2, &i3, &i4, &i5);
                PRN[j] = i1;
                elevation[j] = i2; azimuth[j] = i3;
                ss[j] = i4; used[j] = i5;
                if (i5 == 1)
                  gpsdata->satellites_used++;
              }
            }
            memcpy(gpsdata->PRN, PRN, sizeof(PRN));
            memcpy(gpsdata->elevation, elevation, sizeof(elevation));
            memcpy(gpsdata->azimuth, azimuth,sizeof(azimuth));
                        memcpy(gpsdata->ss, ss, sizeof(ss));
                        memcpy(gpsdata->used, used, sizeof(used));
                        /*@ +compdef @*/
          }
          gpsdata->set |= SATELLITE_SET;
          break;
          /* Z and $ - profiling isn't supported by gpxview */
        }
      }
    }
  }
}

gpointer gps_thread(gpointer data) {
  GnomeVFSFileSize bytes_read;
  GnomeVFSResult vfs_result;
  char str[512];
  appdata_t *appdata = (appdata_t*)data;
  int cnt=1000;

  const char *msg_pos = "o\r\n";   /* pos request */
  const char *msg_sat = "y\r\n";   /* sat request */

  appdata->gps_state->gpsdata.set = 0;

  gboolean connected = FALSE;

  while(1) {
    if(appdata->use_gps) {
      if(!connected) {
        printf("trying to connect\n");

        if(gps_connect(appdata->gps_state) < 0)
          sleep(10);
        else 
          connected = TRUE;
      } else {
        const char *msg;
        if(!cnt) msg = msg_sat;
        else     msg = msg_pos;
      
        if(GNOME_VFS_OK == 
           (vfs_result = gnome_vfs_socket_write(appdata->gps_state->socket,
                      msg, strlen(msg)+1, &bytes_read, NULL))) {

          /* update every second, wait here to make sure a complete */
          /* reply is received */
          if(cnt <= 1) usleep(500000);
          else         sleep(1);
          
          if(bytes_read == (strlen(msg)+1)) {
            vfs_result = gnome_vfs_socket_read(appdata->gps_state->socket,
                               str, sizeof(str)-1, &bytes_read, NULL);
            if(vfs_result == GNOME_VFS_OK) {
              str[bytes_read] = 0; 
            
              //          printf("msg: %s (%d)\n", str, strlen(str));
              
              g_mutex_lock(appdata->gps_state->mutex);
              
              if(!cnt) appdata->gps_state->gpsdata.set &= ~SATELLITE_SET;
              else     appdata->gps_state->gpsdata.set &= 
                         ~(TIME_SET|TIMERR_SET|LATLON_SET|MODE_SET|STATUS_SET);
            
              gps_unpack(str, &appdata->gps_state->gpsdata);
              g_mutex_unlock(appdata->gps_state->mutex);
            }
          }
        }
        if(cnt++ >= 5) cnt = 0;
      }
    } else {
      if(connected) {
        printf("stopping GPS connection due to user request\n");
        gnome_vfs_inet_connection_destroy(appdata->gps_state->iconn, NULL);

#ifdef USE_MAEMO
        gpsbt_stop(&appdata->gps_state->context);
#endif
        connected = FALSE;
      } else
        sleep(1);
    }
  }

  printf("GPS thread ended???\n");
  return NULL;
}

void gps_init(appdata_t *appdata) {
  appdata->gps_state = g_new0(gps_state_t, 1);

  /* start a new thread to listen to gpsd */
  appdata->gps_state->mutex = g_mutex_new();
  appdata->gps_state->thread_p = 
    g_thread_create(gps_thread, appdata, FALSE, NULL);
}

void gps_release(appdata_t *appdata) { 
#ifdef USE_MAEMO
  gpsbt_stop(&appdata->gps_state->context);
#endif
  g_free(appdata->gps_state);
}

#else

static void
location_changed(LocationGPSDevice *device, gps_state_t *gps_state) {

  gps_state->fields = device->fix->fields;

  if(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET) { 
    gps_state->latitude = device->fix->latitude;
    gps_state->longitude = device->fix->longitude;
    gps_state->epe = device->fix->eph;
  }

  if(gps_state->fields & LOCATION_GPS_DEVICE_TRACK_SET)
    gps_state->heading = device->fix->track;
  
  /* update list of sattelites */

  /* free old list */
  if(gps_state->sats.num) {
    g_free(gps_state->sats.PRN);
    g_free(gps_state->sats.used);
    g_free(gps_state->sats.ss);
    gps_state->sats.num = 0;
  }

  /* build new one */
  if(device->satellites_in_view) {
    gps_state->sats.PRN  = g_new0(int, device->satellites_in_view);
    gps_state->sats.used = g_new0(int, device->satellites_in_view);
    gps_state->sats.ss   = g_new0(int, device->satellites_in_view);

    int i;
    for(i=0;i<device->satellites_in_view;i++) {
      LocationGPSDeviceSatellite *sat = 
        g_ptr_array_index(device->satellites, i);

      gps_state->sats.PRN[i]  = sat->prn;
      gps_state->sats.used[i] = sat->in_use;
      gps_state->sats.ss[i]   = sat->signal_strength;
    }

    gps_state->sats.num  = device->satellites_in_view;
  }
}

void gps_init(appdata_t *appdata) {
  gps_state_t *gps_state = appdata->gps_state = g_new0(gps_state_t, 1);

  printf("GPS init: Using liblocation\n");

  gps_state->device = g_object_new(LOCATION_TYPE_GPS_DEVICE, NULL);  
  if(!gps_state->device) {
    printf("Unable to connect to liblocation\n");
    return;
  }

  gps_state->idd_changed = 
    g_signal_connect(gps_state->device, "changed", 
                     G_CALLBACK(location_changed), gps_state);

  gps_state->control = location_gpsd_control_get_default();

  if(gps_state->control
#if MAEMO_VERSION_MAJOR < 5
     && gps_state->control->can_control
#endif
     ) {

    printf("Having control over GPSD and GPS is to be enabled, starting it\n");
    location_gpsd_control_start(gps_state->control);
  }
}

void gps_release(appdata_t *appdata) {
  gps_state_t *gps_state = appdata->gps_state;
  
  if(!gps_state->device) return;

  if(gps_state->control
#if MAEMO_VERSION_MAJOR < 5
     && gps_state->control->can_control
#endif     
     ) {
    printf("Having control over GPSD, stopping it\n");
    location_gpsd_control_stop(gps_state->control);
  }
  
  /* Disconnect signal */
  g_signal_handler_disconnect(gps_state->device, gps_state->idd_changed);
  
  g_free(appdata->gps_state);
  appdata->gps_state = NULL;
}

pos_t *gps_get_pos(appdata_t *appdata) {   
  static pos_t pos;

  if(!appdata->use_gps)
    return NULL;

  gps_state_t *gps_state = appdata->gps_state;

  if(!(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET))
    return NULL;

  pos.lat = gps_state->latitude;
  pos.lon = gps_state->longitude;

  return &pos; 
}

float gps_get_heading(appdata_t *appdata) { 
  gps_state_t *gps_state = appdata->gps_state;
 
  if(!(gps_state->fields & LOCATION_GPS_DEVICE_TRACK_SET))
    return NAN;

  return gps_state->heading; 
}

float gps_get_epe(appdata_t *appdata) { 
  gps_state_t *gps_state = appdata->gps_state;
 
  if(!(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET))
    return NAN;

  return gps_state->epe; 
}

gps_sat_t *gps_get_sats(appdata_t *appdata) { 
  gps_sat_t *retval = NULL;
  gps_state_t *gps_state = appdata->gps_state;

  if(gps_state->sats.num) {
    retval = g_new0(gps_sat_t, 1);
    retval->num = gps_state->sats.num;
  
    retval->PRN  = g_memdup(gps_state->sats.PRN, 
                            sizeof(int)*gps_state->sats.num);
    retval->used = g_memdup(gps_state->sats.used, 
                            sizeof(int)*gps_state->sats.num);
    retval->ss   = g_memdup(gps_state->sats.ss, 
                            sizeof(int)*gps_state->sats.num);
  }

  return retval;
}


#endif
1	/*
2	* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3	*
4	* This file is part of GPXView.
5	*
6	* GPXView is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* GPXView is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with GPXView. If not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include <stdio.h>
21	#include <string.h>
22	#include <math.h>
23
24	#include "gpxview.h"
25
26
27	#ifdef USE_MAEMO
28	#ifdef ENABLE_GPSBT
29	#include <gpsbt.h>
30	#include <gpsmgr.h>
31	#endif
32	#include <errno.h>
33	#endif
34
35	#ifndef ENABLE_LIBLOCATION
36
37	/* maybe user configurable later on ... */
38	#define GPSD_HOST "127.0.0.1"
39	#define GPSD_PORT 2947
40
41	gps_sat_t gps_get_sats(appdata_t appdata) {
42	gps_sat_t *retval = NULL;
43
44	g_mutex_lock(appdata->gps_state->mutex);
45	if(appdata->gps_state->gpsdata.set & SATELLITE_SET) {
46	int i;
47	retval = malloc(sizeof(gps_sat_t));
48	retval->num = appdata->gps_state->gpsdata.satellites;
49
50	retval->PRN = malloc(sizeof(int)*retval->num);
51	retval->used = malloc(sizeof(int)*retval->num);
52	retval->ss = malloc(sizeof(int)*retval->num);
53
54	if(retval->num) {
55	for(i=0;i<retval->num;i++) {
56	retval->PRN[i] = appdata->gps_state->gpsdata.PRN[i];
57	retval->ss[i] = appdata->gps_state->gpsdata.ss[i];
58	retval->used[i] = appdata->gps_state->gpsdata.used[i];
59	}
60	}
61	}
62
63	g_mutex_unlock(appdata->gps_state->mutex);
64
65	return retval;
66	}
67
68	pos_t gps_get_pos(appdata_t appdata) {
69	static pos_t retval;
70
71	retval.lat = NAN;
72
73	g_mutex_lock(appdata->gps_state->mutex);
74	if(appdata->gps_state->gpsdata.set & STATUS_SET)
75	if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX)
76	if(appdata->gps_state->gpsdata.set & LATLON_SET)
77	retval = appdata->gps_state->gpsdata.fix.pos;
78
79	g_mutex_unlock(appdata->gps_state->mutex);
80
81	if(isnan(retval.lat))
82	return NULL;
83
84	return &retval;
85	}
86
87	float gps_get_heading(appdata_t *appdata) {
88	float retval = NAN;
89
90	g_mutex_lock(appdata->gps_state->mutex);
91	if(appdata->gps_state->gpsdata.set & STATUS_SET)
92	if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX)
93	if(appdata->gps_state->gpsdata.set & TRACK_SET)
94	retval = appdata->gps_state->gpsdata.fix.track;
95
96	g_mutex_unlock(appdata->gps_state->mutex);
97	return retval;
98	}
99
100	float gps_get_epe(appdata_t *appdata) {
101	float retval = NAN;
102
103	g_mutex_lock(appdata->gps_state->mutex);
104	if(appdata->gps_state->gpsdata.set & STATUS_SET)
105	if(appdata->gps_state->gpsdata.status != STATUS_NO_FIX)
106	retval = appdata->gps_state->gpsdata.fix.eph;
107
108	g_mutex_unlock(appdata->gps_state->mutex);
109	return retval;
110	}
111
112	static int gps_connect(gps_state_t *gps_state) {
113	GnomeVFSResult vfs_result;
114	#ifdef USE_MAEMO
115	char errstr[256] = "";
116
117	/* We need to start gpsd (via gpsbt) first. */
118	memset(&gps_state->context, 0, sizeof(gpsbt_t));
119	errno = 0;
120
121	if(gpsbt_start(NULL, 0, 0, 0, errstr, sizeof(errstr),
122	0, &gps_state->context) < 0) {
123	printf("Error connecting to GPS receiver: (%d) %s (%s)\n",
124	errno, strerror(errno), errstr);
125	}
126	#endif
127
128	/************ from here down pure gnome/gtk/gpsd ******************/
129
130	/* try to connect to gpsd */
131	/* Create a socket to interact with GPSD. */
132
133	int retries = 5;
134	while(retries &&
135	(GNOME_VFS_OK != (vfs_result = gnome_vfs_inet_connection_create(
136	&gps_state->iconn, GPSD_HOST, GPSD_PORT, NULL)))) {
137	printf("Error creating connection to GPSD, retrying ...\n");
138
139	retries--;
140	sleep(1);
141	}
142
143	if(!retries) {
144	printf("Finally failed ...\n");
145	return -1;
146	}
147
148	retries = 5;
149	while(retries && ((gps_state->socket =
150	gnome_vfs_inet_connection_to_socket(gps_state->iconn)) == NULL)) {
151	printf("Error creating connecting GPSD socket, retrying ...\n");
152
153	retries--;
154	sleep(1);
155	}
156
157	if(!retries) {
158	printf("Finally failed ...\n");
159	return -1;
160	}
161
162	GTimeVal timeout = { 10, 0 };
163	if(GNOME_VFS_OK != (vfs_result = gnome_vfs_socket_set_timeout(
164	gps_state->socket, &timeout, NULL))) {
165	printf("Error setting GPSD timeout\n");
166	return -1;
167	}
168
169	printf("GPSD connected ...\n");
170
171	return 0;
172	}
173
174	void gps_clear_fix(struct gps_fix_t *fixp) {
175	fixp->mode = MODE_NOT_SEEN;
176	fixp->pos.lat = fixp->pos.lon = NAN;
177	fixp->track = NAN;
178	fixp->speed = NAN;
179	fixp->climb = NAN;
180	fixp->altitude = NAN;
181	fixp->ept = NAN;
182	fixp->eph = NAN;
183	fixp->epv = NAN;
184	fixp->epd = NAN;
185	fixp->eps = NAN;
186	fixp->epc = NAN;
187	}
188
189	/* unpack a daemon response into a status structure */
190	static void gps_unpack(char buf, struct gps_data_t gpsdata) {
191	char ns, sp, *tp;
192
193	for(ns = buf; ns; ns = strstr(ns+1, "GPSD")) {
194	if(strncmp(ns, "GPSD", 4) == 0) {
195	/* the following should execute each time we have a good next sp */
196	for (sp = ns + 5; *sp != '\0'; sp = tp+1) {
197	tp = sp + strcspn(sp, ",\r\n");
198	if (*tp == '\0') tp--;
199	else *tp = '\0';
200
201	switch (*sp) {
202	case 'A':
203	if (sp[2] == '?') {
204	gpsdata->fix.altitude = NAN;
205	} else {
206	(void)sscanf(sp, "A=%lf", &gpsdata->fix.altitude);
207	gpsdata->set \|= ALTITUDE_SET;
208	}
209	break;
210	/* B - baudrate isn't supported by gpxview */
211	/* C - cycle isn't supported by gpxview */
212	/* D - utc time isn't supported by gpxview */
213	case 'E':
214	gpsdata->epe = gpsdata->fix.eph = gpsdata->fix.epv = NAN;
215	/* epe should always be present if eph or epv is */
216	if (sp[2] != '?') {
217	char epe[20], eph[20], epv[20];
218	(void)sscanf(sp, "E=%s %s %s", epe, eph, epv);
219	#define DEFAULT(val) (val[0] == '?') ? NAN : g_ascii_strtod(val, NULL)
220	gpsdata->epe = DEFAULT(epe);
221	gpsdata->fix.eph = DEFAULT(eph);
222	gpsdata->fix.epv = DEFAULT(epv);
223	#undef DEFAULT
224	}
225	break;
226	/* F - device name isn't supported by gpxview */
227	/* I - gps id isn't supported by gpxview */
228	/* K - known devices list isn't supported by gpxview */
229	case 'M':
230	if (sp[2] == '?') {
231	gpsdata->fix.mode = MODE_NOT_SEEN;
232	} else {
233	gpsdata->fix.mode = atoi(sp+2);
234	gpsdata->set \|= MODE_SET;
235	}
236	break;
237	/* N - driver mode reporting isn't supported by gpxview */
238	case 'O':
239	if (sp[2] == '?') {
240	gpsdata->set =
241	(gpsdata->set & SATELLITE_SET) \| // fix for below
242	MODE_SET \| STATUS_SET; // this clears sat info??
243	gpsdata->status = STATUS_NO_FIX;
244	gps_clear_fix(&gpsdata->fix);
245	} else {
246	struct gps_fix_t nf;
247	char tag[MAXTAGLEN+1], alt[20];
248	char eph[20], epv[20], track[20],speed[20], climb[20];
249	char epd[20], eps[20], epc[20], mode[2];
250	char timestr[20], ept[20], lat[20], lon[20];
251	int st = sscanf(sp+2,
252	"%8s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %19s %1s",
253	tag, timestr, ept, lat, lon,
254	alt, eph, epv, track, speed, climb,
255	epd, eps, epc, mode);
256	if (st >= 14) {
257	#define DEFAULT(val) (val[0] == '?') ? NAN : g_ascii_strtod(val, NULL)
258	nf.pos.lat = DEFAULT(lat);
259	nf.pos.lon = DEFAULT(lon);
260	nf.ept = DEFAULT(ept);
261	nf.altitude = DEFAULT(alt);
262	nf.eph = DEFAULT(eph);
263	nf.epv = DEFAULT(epv);
264	nf.track = DEFAULT(track);
265	nf.speed = DEFAULT(speed);
266	nf.climb = DEFAULT(climb);
267	nf.epd = DEFAULT(epd);
268	nf.eps = DEFAULT(eps);
269	nf.epc = DEFAULT(epc);
270	#undef DEFAULT
271	if (st >= 15)
272	nf.mode = (mode[0] == '?') ? MODE_NOT_SEEN : atoi(mode);
273	else
274	nf.mode = (alt[0] == '?') ? MODE_2D : MODE_3D;
275	if (alt[0] != '?')
276	gpsdata->set \|= ALTITUDE_SET \| CLIMB_SET;
277	if (isnan(nf.eph)==0)
278	gpsdata->set \|= HERR_SET;
279	if (isnan(nf.epv)==0)
280	gpsdata->set \|= VERR_SET;
281	if (isnan(nf.track)==0)
282	gpsdata->set \|= TRACK_SET \| SPEED_SET;
283	if (isnan(nf.eps)==0)
284	gpsdata->set \|= SPEEDERR_SET;
285	if (isnan(nf.epc)==0)
286	gpsdata->set \|= CLIMBERR_SET;
287	gpsdata->fix = nf;
288	gpsdata->set \|= TIME_SET\|TIMERR_SET\|LATLON_SET\|MODE_SET;
289	gpsdata->status = STATUS_FIX;
290	gpsdata->set \|= STATUS_SET;
291	}
292	}
293	break;
294	case 'P':
295	if (sp[2] == '?') {
296	gpsdata->fix.pos.lat = NAN;
297	gpsdata->fix.pos.lon = NAN;
298	} else {
299	char lat[20], lon[20];
300	(void)sscanf(sp, "P=%19s %19s", lat, lon);
301	gpsdata->fix.pos.lat = g_ascii_strtod(lat, NULL);
302	gpsdata->fix.pos.lon = g_ascii_strtod(lon, NULL);
303	gpsdata->set \|= LATLON_SET;
304	}
305	break;
306	case 'Q':
307	if (sp[2] == '?') {
308	gpsdata->satellites_used = 0;
309	gpsdata->pdop = 0;
310	gpsdata->hdop = 0;
311	gpsdata->vdop = 0;
312	} else {
313	(void)sscanf(sp, "Q=%d %lf %lf %lf %lf %lf",
314	&gpsdata->satellites_used,
315	&gpsdata->pdop,
316	&gpsdata->hdop,
317	&gpsdata->vdop,
318	&gpsdata->tdop,
319	&gpsdata->gdop);
320	gpsdata->set \|= HDOP_SET \| VDOP_SET \| PDOP_SET;
321	}
322	break;
323	case 'S':
324	if (sp[2] == '?') {
325	gpsdata->status = -1;
326	} else {
327	gpsdata->status = atoi(sp+2);
328	gpsdata->set \|= STATUS_SET;
329	}
330	break;
331	case 'T':
332	if (sp[2] == '?') {
333	gpsdata->fix.track = NAN;
334	} else {
335	(void)sscanf(sp, "T=%lf", &gpsdata->fix.track);
336	gpsdata->set \|= TRACK_SET;
337	}
338	break;
339	case 'U':
340	if (sp[2] == '?') {
341	gpsdata->fix.climb = NAN;
342	} else {
343	(void)sscanf(sp, "U=%lf", &gpsdata->fix.climb);
344	gpsdata->set \|= CLIMB_SET;
345	}
346	break;
347	case 'V':
348	if (sp[2] == '?') {
349	gpsdata->fix.speed = NAN;
350	} else {
351	(void)sscanf(sp, "V=%lf", &gpsdata->fix.speed);
352	/* V reply is in kt, fix.speed is in metres/sec */
353	gpsdata->fix.speed = gpsdata->fix.speed / MPS_TO_KNOTS;
354	gpsdata->set \|= SPEED_SET;
355	}
356	break;
357	case 'X':
358	if (sp[2] == '?')
359	gpsdata->online = -1;
360	else {
361	(void)sscanf(sp, "X=%lf", &gpsdata->online);
362	gpsdata->set \|= ONLINE_SET;
363	}
364	break;
365	case 'Y':
366	if (sp[2] == '?') {
367	gpsdata->satellites = 0;
368	} else {
369	int j, i1, i2, i3, i4, i5;
370	int PRN[MAXCHANNELS];
371	int elevation[MAXCHANNELS], azimuth[MAXCHANNELS];
372	int ss[MAXCHANNELS], used[MAXCHANNELS];
373	char tag[MAXTAGLEN+1], timestamp[21];
374
375	(void)sscanf(sp, "Y=%8s %20s %d ",
376	tag, timestamp, &gpsdata->satellites);
377	for (j = 0; j < gpsdata->satellites; j++) {
378	PRN[j]=elevation[j]=azimuth[j]=ss[j]=used[j]=0;
379	}
380	// printf("sats = %d\n", gpsdata->satellites);
381	for (j = 0, gpsdata->satellites_used = 0; j < gpsdata->satellites; j++) {
382	if ((sp != NULL) && ((sp = strchr(sp, ':')) != NULL)) {
383	sp++;
384	(void)sscanf(sp, "%d %d %d %d %d", &i1, &i2, &i3, &i4, &i5);
385	PRN[j] = i1;
386	elevation[j] = i2; azimuth[j] = i3;
387	ss[j] = i4; used[j] = i5;
388	if (i5 == 1)
389	gpsdata->satellites_used++;
390	}
391	}
392	memcpy(gpsdata->PRN, PRN, sizeof(PRN));
393	memcpy(gpsdata->elevation, elevation, sizeof(elevation));
394	memcpy(gpsdata->azimuth, azimuth,sizeof(azimuth));
395	memcpy(gpsdata->ss, ss, sizeof(ss));
396	memcpy(gpsdata->used, used, sizeof(used));
397	/@ +compdef @/
398	}
399	gpsdata->set \|= SATELLITE_SET;
400	break;
401	/* Z and $ - profiling isn't supported by gpxview */
402	}
403	}
404	}
405	}
406	}
407
408	gpointer gps_thread(gpointer data) {
409	GnomeVFSFileSize bytes_read;
410	GnomeVFSResult vfs_result;
411	char str[512];
412	appdata_t appdata = (appdata_t)data;
413	int cnt=1000;
414
415	const char msg_pos = "o\r\n"; / pos request */
416	const char msg_sat = "y\r\n"; / sat request */
417
418	appdata->gps_state->gpsdata.set = 0;
419
420	gboolean connected = FALSE;
421
422	while(1) {
423	if(appdata->use_gps) {
424	if(!connected) {
425	printf("trying to connect\n");
426
427	if(gps_connect(appdata->gps_state) < 0)
428	sleep(10);
429	else
430	connected = TRUE;
431	} else {
432	const char *msg;
433	if(!cnt) msg = msg_sat;
434	else msg = msg_pos;
435
436	if(GNOME_VFS_OK ==
437	(vfs_result = gnome_vfs_socket_write(appdata->gps_state->socket,
438	msg, strlen(msg)+1, &bytes_read, NULL))) {
439
440	/* update every second, wait here to make sure a complete */
441	/* reply is received */
442	if(cnt <= 1) usleep(500000);
443	else sleep(1);
444
445	if(bytes_read == (strlen(msg)+1)) {
446	vfs_result = gnome_vfs_socket_read(appdata->gps_state->socket,
447	str, sizeof(str)-1, &bytes_read, NULL);
448	if(vfs_result == GNOME_VFS_OK) {
449	str[bytes_read] = 0;
450
451	// printf("msg: %s (%d)\n", str, strlen(str));
452
453	g_mutex_lock(appdata->gps_state->mutex);
454
455	if(!cnt) appdata->gps_state->gpsdata.set &= ~SATELLITE_SET;
456	else appdata->gps_state->gpsdata.set &=
457	~(TIME_SET\|TIMERR_SET\|LATLON_SET\|MODE_SET\|STATUS_SET);
458
459	gps_unpack(str, &appdata->gps_state->gpsdata);
460	g_mutex_unlock(appdata->gps_state->mutex);
461	}
462	}
463	}
464	if(cnt++ >= 5) cnt = 0;
465	}
466	} else {
467	if(connected) {
468	printf("stopping GPS connection due to user request\n");
469	gnome_vfs_inet_connection_destroy(appdata->gps_state->iconn, NULL);
470
471	#ifdef USE_MAEMO
472	gpsbt_stop(&appdata->gps_state->context);
473	#endif
474	connected = FALSE;
475	} else
476	sleep(1);
477	}
478	}
479
480	printf("GPS thread ended???\n");
481	return NULL;
482	}
483
484	void gps_init(appdata_t *appdata) {
485	appdata->gps_state = g_new0(gps_state_t, 1);
486
487	/* start a new thread to listen to gpsd */
488	appdata->gps_state->mutex = g_mutex_new();
489	appdata->gps_state->thread_p =
490	g_thread_create(gps_thread, appdata, FALSE, NULL);
491	}
492
493	void gps_release(appdata_t *appdata) {
494	#ifdef USE_MAEMO
495	gpsbt_stop(&appdata->gps_state->context);
496	#endif
497	g_free(appdata->gps_state);
498	}
499
500	#else
501
502	static void
503	location_changed(LocationGPSDevice device, gps_state_t gps_state) {
504
505	gps_state->fields = device->fix->fields;
506
507	if(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET) {
508	gps_state->latitude = device->fix->latitude;
509	gps_state->longitude = device->fix->longitude;
510	gps_state->epe = device->fix->eph;
511	}
512
513	if(gps_state->fields & LOCATION_GPS_DEVICE_TRACK_SET)
514	gps_state->heading = device->fix->track;
515
516	/* update list of sattelites */
517
518	/* free old list */
519	if(gps_state->sats.num) {
520	g_free(gps_state->sats.PRN);
521	g_free(gps_state->sats.used);
522	g_free(gps_state->sats.ss);
523	gps_state->sats.num = 0;
524	}
525
526	/* build new one */
527	if(device->satellites_in_view) {
528	gps_state->sats.PRN = g_new0(int, device->satellites_in_view);
529	gps_state->sats.used = g_new0(int, device->satellites_in_view);
530	gps_state->sats.ss = g_new0(int, device->satellites_in_view);
531
532	int i;
533	for(i=0;i<device->satellites_in_view;i++) {
534	LocationGPSDeviceSatellite *sat =
535	g_ptr_array_index(device->satellites, i);
536
537	gps_state->sats.PRN[i] = sat->prn;
538	gps_state->sats.used[i] = sat->in_use;
539	gps_state->sats.ss[i] = sat->signal_strength;
540	}
541
542	gps_state->sats.num = device->satellites_in_view;
543	}
544	}
545
546	void gps_init(appdata_t *appdata) {
547	gps_state_t *gps_state = appdata->gps_state = g_new0(gps_state_t, 1);
548
549	printf("GPS init: Using liblocation\n");
550
551	gps_state->device = g_object_new(LOCATION_TYPE_GPS_DEVICE, NULL);
552	if(!gps_state->device) {
553	printf("Unable to connect to liblocation\n");
554	return;
555	}
556
557	gps_state->idd_changed =
558	g_signal_connect(gps_state->device, "changed",
559	G_CALLBACK(location_changed), gps_state);
560
561	gps_state->control = location_gpsd_control_get_default();
562
563	if(gps_state->control
564	#if MAEMO_VERSION_MAJOR < 5
565	&& gps_state->control->can_control
566	#endif
567	) {
568
569	printf("Having control over GPSD and GPS is to be enabled, starting it\n");
570	location_gpsd_control_start(gps_state->control);
571	}
572	}
573
574	void gps_release(appdata_t *appdata) {
575	gps_state_t *gps_state = appdata->gps_state;
576
577	if(!gps_state->device) return;
578
579	if(gps_state->control
580	#if MAEMO_VERSION_MAJOR < 5
581	&& gps_state->control->can_control
582	#endif
583	) {
584	printf("Having control over GPSD, stopping it\n");
585	location_gpsd_control_stop(gps_state->control);
586	}
587
588	/* Disconnect signal */
589	g_signal_handler_disconnect(gps_state->device, gps_state->idd_changed);
590
591	g_free(appdata->gps_state);
592	appdata->gps_state = NULL;
593	}
594
595	pos_t gps_get_pos(appdata_t appdata) {
596	static pos_t pos;
597
598	if(!appdata->use_gps)
599	return NULL;
600
601	gps_state_t *gps_state = appdata->gps_state;
602
603	if(!(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET))
604	return NULL;
605
606	pos.lat = gps_state->latitude;
607	pos.lon = gps_state->longitude;
608
609	return &pos;
610	}
611
612	float gps_get_heading(appdata_t *appdata) {
613	gps_state_t *gps_state = appdata->gps_state;
614
615	if(!(gps_state->fields & LOCATION_GPS_DEVICE_TRACK_SET))
616	return NAN;
617
618	return gps_state->heading;
619	}
620
621	float gps_get_epe(appdata_t *appdata) {
622	gps_state_t *gps_state = appdata->gps_state;
623
624	if(!(gps_state->fields & LOCATION_GPS_DEVICE_LATLONG_SET))
625	return NAN;
626
627	return gps_state->epe;
628	}
629
630	gps_sat_t gps_get_sats(appdata_t appdata) {
631	gps_sat_t *retval = NULL;
632	gps_state_t *gps_state = appdata->gps_state;
633
634	if(gps_state->sats.num) {
635	retval = g_new0(gps_sat_t, 1);
636	retval->num = gps_state->sats.num;
637
638	retval->PRN = g_memdup(gps_state->sats.PRN,
639	sizeof(int)*gps_state->sats.num);
640	retval->used = g_memdup(gps_state->sats.used,
641	sizeof(int)*gps_state->sats.num);
642	retval->ss = g_memdup(gps_state->sats.ss,
643	sizeof(int)*gps_state->sats.num);
644	}
645
646	return retval;
647	}
648
649
650	#endif