/** \brief Initialize whatever structures inside the qth_t stucture for later updates. * \param qth the qth data structure to update * *Initial intention of this is to open sockets and ports to gpsd *and other like services to update the qth position. */ gboolean qth_data_update_init(qth_t * qth) { #ifdef HAS_LIBGPS char *port; #endif gboolean retval = FALSE; switch (qth->type) { case QTH_STATIC_TYPE: /* nothing to do. the data never updates */ break; case QTH_GPSD_TYPE: #ifdef HAS_LIBGPS switch (GPSD_API_MAJOR_VERSION) { case 4: #if GPSD_API_MAJOR_VERSION==4 /* open the connection to gpsd and start the stream */ qth->gps_data = g_try_new0(struct gps_data_t, 1); port = g_strdup_printf("%d", qth->gpsd_port); if (gps_open_r(qth->gpsd_server, port, qth->gps_data) == -1) { free(qth->gps_data); qth->gps_data = NULL; sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s: Could not open gpsd at %s:%d"), __FUNCTION__, qth->gpsd_server, qth->gpsd_port); retval = FALSE; } else { (void)gps_stream(qth->gps_data, WATCH_ENABLE, NULL); retval = TRUE; } g_free(port); #endif break; case 5: #if GPSD_API_MAJOR_VERSION==5 /* open the connection to gpsd and start the stream */ qth->gps_data = g_try_new0(struct gps_data_t, 1); port = g_strdup_printf("%d", qth->gpsd_port); if (gps_open(qth->gpsd_server, port, qth->gps_data) == -1) { free(qth->gps_data); qth->gps_data = NULL; sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s: Could not open gpsd at %s:%d"), __FUNCTION__, qth->gpsd_server, qth->gpsd_port); retval = FALSE; } else { (void)gps_stream(qth->gps_data, WATCH_ENABLE, NULL); retval = TRUE; } g_free(port); #endif break; default: sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s: Unsupported gpsd api major version (%d)"), __FUNCTION__, GPSD_API_MAJOR_VERSION); return FALSE; break; } #else return FALSE; #endif break; default: break; } return retval; }
int main(int argc, char** argv) { int ret = 0; if (!parse_args(argc, argv)) return 1; GMainLoop *ml = g_main_loop_new(NULL, FALSE); gpsdata = malloc(sizeof(struct gps_data_t)); printf("Connecting to gpsd server %s, port %s\n", server, port); ret = gps_open(server, port, gpsdata); if (ret != 0) { perror("error connecting to gpsd"); return 1; } gps_stream(gpsdata, WATCH_ENABLE, NULL); IvyInit ("GPSd2Ivy", "GPSd2Ivy READY", NULL, NULL, NULL, NULL); IvyStart(ivy_bus); g_timeout_add(TIMEOUT_PERIOD, gps_periodic, NULL); g_main_loop_run(ml); (void) gps_stream(gpsdata, WATCH_DISABLE, NULL); (void) gps_close (gpsdata); free(gpsdata); return ret; }
int main(int argc, char **argv) { bool res; int rc; /* check the parameters */ if (argc != 4) { fprintf(stderr, "Usage: %s nodeName host port\n", argv[0]); exit(1); } /* Use the parameters */ gpsNodeName = argv[1]; int sockfd = create_udp_socket(argv[2], argv[3]); do { struct gps_data_t gps_data; if ((rc = gps_open("localhost", "2947", &gps_data)) == -1) { printf("code: %d, reason: %s\n", rc, gps_errstr(rc)); return EXIT_FAILURE; } gps_stream(&gps_data, WATCH_ENABLE | WATCH_JSON, NULL); res = mainLoop(&gps_data, sockfd); /* When you are done... */ gps_stream(&gps_data, WATCH_DISABLE, NULL); gps_close (&gps_data); } while (res == false); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { char *server = NULL, *port = DEFAULT_GPSD_PORT; bool running = true; int ret = 0; GMainLoop *ml = g_main_loop_new(NULL, FALSE); gpsdata = malloc(sizeof(struct gps_data_t)); ret = gps_open(NULL, port, gpsdata); if (ret != 0) { perror("error connecting to gpsd"); return 1; } gps_stream(gpsdata, WATCH_ENABLE, NULL); IvyInit ("GPSd2Ivy", "GPSd2Ivy READY", NULL, NULL, NULL, NULL); IvyStart("224.255.255.255:2010"); g_timeout_add(TIMEOUT_PERIOD, gps_periodic, NULL); g_main_loop_run(ml); (void) gps_stream(gpsdata, WATCH_DISABLE, NULL); (void) gps_close (gpsdata); free(gpsdata); return ret; }
int main() { char * hostName = "127.0.0.1"; char * hostPort = "2947"; // initializes a GPS-data structure to hold the data collected by // the GPS, and sets up access to gpsd if( -1 == gps_open(hostName, hostPort, &gpsdata) ) { printf("ERROR: gps_open returned -1"); } gps_stream(&gpsdata, WATCH_ENABLE | WATCH_JSON, NULL); /* Put this in a loop with a call to a high resolution sleep () in it. */ while(1) { /* Used to check whether there is new data from the * daemon. The second argument is the maximum amount of time * to wait (in microseconds) on input before returning */ if( gps_waiting(&gpsdata, 500) ) { if( -1 == gps_read (&gpsdata) ) { printf("ERROR: gps_read returned -1"); } else { /* Display data from the GPS receiver. */ printf("\nSatellites Used:%d\n", gpsdata.satellites_used); /* Error estimates are at 95% confidence. */ printf("Time:%f, Error:%f\n", gpsdata.fix.time, gpsdata.fix.ept); printf("Latitude:%f, Error:%f\n", gpsdata.fix.latitude, gpsdata.fix.epy); printf("Longitude:%f, Error:%f\n", gpsdata.fix.longitude, gpsdata.fix.epx); printf("Altitude:%f, Error:%f\n", gpsdata.fix.altitude, gpsdata.fix.epv); printf("Track:%f, Error:%f\n", gpsdata.fix.track, gpsdata.fix.epd); printf("Speed:%f, Error:%f\n", gpsdata.fix.speed, gpsdata.fix.eps); printf("Climb:%f, Error:%f\n", gpsdata.fix.climb, gpsdata.fix.epc); } } usleep(250000); } /* When you are done... */ (void) gps_stream(&gpsdata, WATCH_DISABLE, NULL); (void) gps_close (&gpsdata); }
static int _connectGPSD(void) // return FALSE if _ais_list is NULL or 10 failed attempt to connect else TRUE { int nWait = 0; g_print("s52ais:_gpsdClientRead(): start looping ..\n"); memset(&_gpsdata, 0, sizeof(_gpsdata)); while (0 != gps_open(GPSD_HOST, GPSD_PORT, &_gpsdata)) { // android (gpsd 2.96) g_print("s52ais:_gpsdClientRead(): no gpsd running or network error, wait 1 sec: %d, %s\n", errno, gps_errstr(errno)); // try to connect to GPSD server, bailout after 10 failed attempt GMUTEXLOCK(&_ais_list_mutex); if ((NULL==_ais_list) || (10 <= ++nWait)) { g_print("s52ais:_gpsdClientRead() no AIS list (main exited) or no GPSD server.. terminate _gpsClientRead thread\n"); GMUTEXUNLOCK(&_ais_list_mutex); return FALSE; } GMUTEXUNLOCK(&_ais_list_mutex); g_usleep(1000 * 1000); // 1.0 sec } if (-1 == gps_stream(&_gpsdata, WATCH_ENABLE|WATCH_NEWSTYLE, NULL)) { g_print("s52ais:_gpsdClientRead():gps_stream() failed .. exiting\n"); return FALSE; } return TRUE; }
/*@-mustfreefresh -compdestroy@*/ static int socket_mainloop(void) { unsigned int flags = WATCH_ENABLE; if (gps_open(source.server, source.port, &gpsdata) != 0) { (void)fprintf(stderr, "%s: no gpsd running or network error: %d, %s\n", progname, errno, gps_errstr(errno)); exit(1); } if (source.device != NULL) flags |= WATCH_DEVICE; (void)gps_stream(&gpsdata, flags, source.device); print_gpx_header(); for (;;) { if (!gps_waiting(&gpsdata, 5000000)) { (void)fprintf(stderr, "%s: error while waiting\n", progname); break; } else { (void)gps_read(&gpsdata); conditionally_log_fix(&gpsdata); } } (void)gps_close(&gpsdata); return 0; }
gpsd_iface_impl(const std::string &addr, uint16_t port) : _detected(false), _bthread(), _timeout_cnt(0) { boost::unique_lock<boost::shared_mutex> l(_d_mutex); if (gps_open(addr.c_str(), str(boost::format("%u") % port).c_str(), &_gps_data) < 0) { throw uhd::runtime_error( str((boost::format("Failed to connect to gpsd: %s") % gps_errstr(errno)))); } // register for updates, we don't specify a specific device, // therefore no WATCH_DEVICE gps_stream(&_gps_data, WATCH_ENABLE, NULL); // create background thread talking to gpsd boost::thread t(boost::bind(&gpsd_iface_impl::_thread_fcn ,this)); _bthread.swap(t); _sensors = boost::assign::list_of<std::string>("gps_locked")("gps_time") \ ("gps_position")("gps_gpgga")("gps_gprmc").to_container(_sensors); }
gps_data_t GPS::get_current_location() { struct gps_data_t gps_data; int rc; if ((rc = gps_open("localhost", this->gpsd_port.c_str(), &gps_data)) == -1) { this->last_error = "GPS_OPEN"; this->all_errors.push_back(this->last_error); return gps_data; } gps_stream(&gps_data, WATCH_ENABLE | WATCH_JSON, NULL); if (gps_waiting(&gps_data, this->timeout)) { if ((rc = gps_read(&gps_data)) == -1) { this->last_error == "GPS_READ"; this->all_errors.push_back(this->last_error); return gps_data; } else { if ((gps_data.status == STATUS_FIX) && (gps_data.fix.mode == MODE_2D || gps_data.fix.mode == MODE_3D) && !std::isnan(gps_data.fix.longitude) && !std::isnan(gps_data.fix.latitude)) { return gps_data; } else { this->last_error == "NO_GPS_DATA"; this->all_errors.push_back(this->last_error); return gps_data; } } } else { this->last_error = "TIMEOUT"; this->all_errors.push_back(this->last_error); return gps_data; } }
int startLocationServices() { if (working) { return 0.0; } gpsdata.status = STATUS_NO_FIX; gpsdata.satellites_used = 0; gps_clear_fix(&(gpsdata.fix)); gps_clear_dop(&(gpsdata.dop)); gpsdata.fix.latitude=0; gpsdata.fix.longitude=0; logfile=stdout; gpsd_source_spec(NULL, &source); unsigned int flags = WATCH_ENABLE; if (gps_open("127.0.0.1" , "2947", &gpsdata) != 0) { fprintf(stderr,"LoacationService : no gpsd running or network error: %d, %s\n", errno, gps_errstr(errno)); return 0; } if (source.device != NULL) flags |= WATCH_DEVICE; gps_stream(&gpsdata, flags, source.device); fprintf(stderr,MAGENTA "Polling location services to determine if they will be used in this run : \n" NORMAL); fprintf(stderr,MAGENTA "If you don't want to wait use `sudo service gpsd stop`\n" NORMAL); unsigned int tries=3; unsigned int success=0; unsigned int i=0; working=1; //lets assume that we are working so that pollLocationServices will work for (i=0; i<tries; i++) { success+=pollLocationServices(); usleep(1000*1000); } if (success==0) { fprintf(stderr,RED "Location services failed to provide gps coordinates beeing switched off\n" NORMAL); working=0; } else if (success<tries) { fprintf(stderr,YELLOW "Location services failed to provide gps coordinates beeing switched off\n" NORMAL); working=1; } else if (success==tries) { fprintf(stderr,GREEN "Location services working fine.. :) \n" NORMAL); working=1; } return working; }
struct gps_data_t* gpsmm::stream(int flags) { if (to_user == NULL) return NULL; else if (gps_stream(gps_state(),flags, NULL)==-1) { return NULL; } else { return backup(); } }
virtual ~gpsd_iface_impl(void) { // interrupt the background thread and wait for it to finish _bthread.interrupt(); _bthread.join(); // clean up ... { boost::unique_lock<boost::shared_mutex> l(_d_mutex); gps_stream(&_gps_data, WATCH_DISABLE, NULL); gps_close(&_gps_data); } }
static int attempt_reconnect(const char *host, const char *port, struct gps_data_t *gpsdata) { int rc; rc = gps_open(host, port, gpsdata); if (rc) return -1; syslog(LOG_INFO, "(re)connected to gpsd\n"); gps_stream(gpsdata, WATCH_ENABLE|WATCH_JSON, NULL); return 0; }
void Gpsd::connectToServer(const QString &h, quint16 p, Gpsd::StreamMode m) { if (isConnected()) { // We're connected disconnectFromServer(); // disconnect first } host = h; port = p; if (gps_open(h.toLatin1().data(), QString().setNum(p).toLatin1().data(), &gpsdata) == 0) { notifier = new QSocketNotifier(gpsdata.gps_fd, QSocketNotifier::Read); notifier->setEnabled(true); connect(notifier, SIGNAL(activated(int)), this, SLOT(handleInput(int))); emit connectionStatus(true); gps_stream(&gpsdata, WATCH_ENABLE|m, NULL); } else {
int main() { struct gps_data_t gps_data; int err; if ((err = gps_open("localhost", DEFAULT_GPSD_PORT, &gps_data)) != 0) { fprintf(stderr, gps_errstr(err)); exit(1); } gps_stream(&gps_data, WATCH_ENABLE, NULL); for (int i = 0; i < NUM_GPS_READS; i++) one_gps_cycle(&gps_data); return 0; }
static gpointer _gpsdClientStart(gpointer dummy) { int ret = -1; while (ret < 0) { if (TRUE == _connectGPSD()) { ret = _gpsdClientReadLoop(); // disconnect GPSD gps_stream(&_gpsdata, WATCH_DISABLE, NULL); gps_close(&_gpsdata); } } return dummy; }
void dwgps_term (void) { #if __WIN32__ #elif ENABLE_GPS if (init_status == INIT_SUCCESS) { #ifndef USE_GPS_SHM gps_stream(&gpsdata, WATCH_DISABLE, NULL); #endif gps_close (&gpsdata); } #else #endif } /* end dwgps_term */
int main (int argc, gchar *argv[]) { GError *error = NULL; GIOChannel *gio_read; ctx.user = "******"; ctx.pass = "******"; ctx.state = APRSIS_DISCONNECTED; // g_thread_init(NULL); g_type_init(); g_message("opening aprs-is"); start_aprsis(&ctx); g_message("opening gpsd"); // Connect to GPS (FIXME move to thread) if (gps_open("localhost", "2947", &gpsdata) != 0) { printf("no gpsd: %d, %s\n", errno, gps_errstr(errno)); exit(2); } printf("%x\n", gpsdata); printf("%x\n", flags); //sleep(1); gps_stream(&gpsdata, flags, NULL); //printf("%s\n", source.device); printf("started stream\n"); gpsd_io_channel = g_io_channel_unix_new(gpsdata.gps_fd); g_io_channel_set_flags(gpsd_io_channel, G_IO_FLAG_NONBLOCK, NULL); sid3 = g_io_add_watch(gpsd_io_channel, G_IO_IN | G_IO_PRI, gpsd_data_cb, NULL); printf("about to start main loop\n"); main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (main_loop); return 0; }
// Open the stream with the GPSd socket int gpsdOpenStream() { // ... to verify what version gpsd_source_spec(NULL, &source); // GPSD_SERVERPORT, &source); // gpsd_source_spec(FCD_GPSD_SERVERPORT, &source); // // Open the stream if (gps_open(source.server, source.port, &gpsdata) != 0) { fcdLogErr("No GPSD daemon running or network !",(char *)gps_errstr(errno)); __recordStringValue("NO LINK", "GPSstatus"); return(false); } // If the device is defined then add a flag if (source.device != NULL) flags |= WATCH_DEVICE; // Finally connect the device to the stream (void)gps_stream(&gpsdata, flags, source.device); __recordStringValue("LINK", "GPSstatus"); return(true); }
static void gpsd_connect_gpsd(struct globals *globals) { unsigned int flags = WATCH_ENABLE | WATCH_JSON; int ret; ret = gps_open(globals->gpsdsource.server, globals->gpsdsource.port, &globals->gpsdata); if (ret) { /* Could not connect to gpsd. Set the fd so we don't try to perform select(2) on it. */ globals->gpsdata.gps_fd = -1; return; } if (globals->gpsdsource.device != NULL) flags |= WATCH_DEVICE; gps_stream(&globals->gpsdata, flags, globals->gpsdsource.device); }
//Will open a gps data stream int openStream(){ static struct fixsource_t source; unsigned int flags = WATCH_ENABLE; if(gps_open(source.server, source.port, gps_data_ptr) == -1){ //print failure return 0; } if(source.device == NULL){ //print failure return 0; } flags |= WATCH_DEVICE; gps_stream(gps_data_ptr, flags, source.device); return 1; }
int main() { static struct fixsource_t source; struct gps_data_t* gpsdata; unsigned int flag = WATCH_ENABLE | WATCH_JSON; // Set watch flags build_curses(); //build GUI gpsdata = (struct gps_data_t*)malloc (sizeof (struct gps_data_t)); // Retrieve a pointer to the structure if (gps_open(source.server , source.port, gpsdata) == -1) { dcgps_error(NO_GPS); return 1; } if(source.device != NULL) flag |= WATCH_DEVICE; gps_stream(gpsdata, flag, source.device); // start data report stream from the sensor read(gpsdata); gps_close(gpsdata); // close gps stream kill_curses(); return 0; }
int main(int argc, char **argv) { char *host = "localhost"; int i, rc; openlog("gpsdate", LOG_PERROR, LOG_CRON); if (argc > 1) host = argv[1]; for (i = 1; i <= NUM_RETRIES; i++) { printf("Attempt #%d to connect to gpsd at %s...\n", i, host); rc = gps_open(host, DEFAULT_GPSD_PORT, &gpsdata); if (!rc) break; sleep(RETRY_SLEEP); } if (rc) { syslog(LOG_ERR, "no gpsd running or network error: %d, %s\n", errno, gps_errstr(errno)); closelog(); exit(EXIT_FAILURE); } osmo_daemonize(); gps_stream(&gpsdata, WATCH_ENABLE|WATCH_JSON, NULL); /* We run in an endless loop. The only reasonable way to exit is after * a correct GPS timestamp has been received in callback() */ while (1) gps_mainloop(&gpsdata, INT_MAX, callback); gps_close(&gpsdata); closelog(); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char *server = NULL, *port = DEFAULT_GPSD_PORT; GMainLoop *ml = g_main_loop_new(NULL, FALSE); gpsdata = gps_open(server, port); if (!gpsdata) perror("error connecting to gpsd"); gps_set_raw_hook(gpsdata, update_gps); gps_stream(gpsdata, WATCH_ENABLE, NULL); IvyInit ("GPSd2Ivy", "GPSd2Ivy READY", NULL, NULL, NULL, NULL); IvyStart("127.255.255.255"); g_timeout_add(TIMEOUT_PERIOD, gps_periodic, NULL); g_main_loop_run(ml); return 0; }
/*@-mustfreefresh -mustfreeonly -branchstate -globstate@*/ int main(int argc, char **argv) { int ch; bool daemonize = false; unsigned int flags = WATCH_ENABLE; struct exportmethod_t *method = NULL; progname = argv[0]; if (export_default() == NULL) { (void)fprintf(stderr, "%s: no export methods.\n", progname); exit(1); } logfile = stdout; while ((ch = getopt(argc, argv, "dD:e:f:hi:lm:V")) != -1) { switch (ch) { case 'd': openlog(basename(progname), LOG_PID | LOG_PERROR, LOG_DAEMON); daemonize = true; break; #ifdef CLIENTDEBUG_ENABLE case 'D': debug = atoi(optarg); gps_enable_debug(debug, logfile); break; #endif /* CLIENTDEBUG_ENABLE */ case 'e': method = export_lookup(optarg); if (method == NULL) { (void)fprintf(stderr, "%s: %s is not a known export method.\n", progname, optarg); exit(1); } break; case 'f': /* Output file name. */ { char fname[PATH_MAX]; time_t t; size_t s; t = time(NULL); s = strftime(fname, sizeof(fname), optarg, localtime(&t)); if (s == 0) { syslog(LOG_ERR, "Bad template \"%s\", logging to stdout.", optarg); break; } logfile = fopen(fname, "w"); if (logfile == NULL) syslog(LOG_ERR, "Failed to open %s: %s, logging to stdout.", fname, strerror(errno)); break; } case 'i': /* set polling interfal */ timeout = (time_t) atoi(optarg); if (timeout < 1) timeout = 1; if (timeout >= 3600) fprintf(stderr, "WARNING: track timeout is an hour or more!\n"); break; case 'l': export_list(stderr); exit(0); case 'm': minmove = (double )atoi(optarg); break; case 'V': (void)fprintf(stderr, "%s revision " REVISION "\n", progname); exit(0); default: usage(); /* NOTREACHED */ } } if (daemonize && logfile == stdout) { syslog(LOG_ERR, "Daemon mode with no valid logfile name - exiting."); exit(1); } if (method != NULL) if (method->magic != NULL) { source.server = (char *)method->magic; source.port = NULL; } if (optind < argc) { gpsd_source_spec(argv[optind], &source); } else gpsd_source_spec(NULL, &source); #if 0 (void)fprintf(logfile,"<!-- server: %s port: %s device: %s -->\n", source.server, source.port, source.device); #endif /* catch all interesting signals */ (void)signal(SIGTERM, quit_handler); (void)signal(SIGQUIT, quit_handler); (void)signal(SIGINT, quit_handler); /*@-unrecog@*/ /* might be time to daemonize */ if (daemonize) { /* not SuS/POSIX portable, but we have our own fallback version */ if (daemon(0, 0) != 0) (void) fprintf(stderr,"demonization failed: %s\n", strerror(errno)); } /*@+unrecog@*/ //syslog (LOG_INFO, "---------- STARTED ----------"); if (gps_open(source.server, source.port, &gpsdata) != 0) { (void)fprintf(stderr, "%s: no gpsd running or network error: %d, %s\n", progname, errno, gps_errstr(errno)); exit(1); } if (source.device != NULL) flags |= WATCH_DEVICE; (void)gps_stream(&gpsdata, flags, source.device); print_gpx_header(); (int)gps_mainloop(&gpsdata, 5000000, conditionally_log_fix); print_gpx_footer(); (void)gps_close(&gpsdata); exit(0); }
int main(int argc, char *argv[]) { int option, rc; struct sockaddr_in localAddr, servAddr; struct hostent *h; int n; for(n=0;n<CLIMB;n++) climb[n]=0.0; switch (gpsd_units()) { case imperial: altfactor = METERS_TO_FEET; altunits = "ft"; speedfactor = MPS_TO_MPH; speedunits = "mph"; break; case nautical: altfactor = METERS_TO_FEET; altunits = "ft"; speedfactor = MPS_TO_KNOTS; speedunits = "knots"; break; case metric: altfactor = 1; altunits = "m"; speedfactor = MPS_TO_KPH; speedunits = "kph"; break; default: /* leave the default alone */ break; } /* Process the options. Print help if requested. */ while ((option = getopt(argc, argv, "Vhl:su:")) != -1) { switch (option) { case 'V': (void)fprintf(stderr, "lcdgs revision " REVISION "\n"); exit(EXIT_SUCCESS); case 'h': default: usage(argv[0]); break; case 'l': switch ( optarg[0] ) { case 'd': deg_type = deg_dd; continue; case 'm': deg_type = deg_ddmm; continue; case 's': deg_type = deg_ddmmss; continue; default: (void)fprintf(stderr, "Unknown -l argument: %s\n", optarg); } break; case 's': sleep(10); continue; case 'u': switch ( optarg[0] ) { case 'i': altfactor = METERS_TO_FEET; altunits = "ft"; speedfactor = MPS_TO_MPH; speedunits = "mph"; continue; case 'n': altfactor = METERS_TO_FEET; altunits = "ft"; speedfactor = MPS_TO_KNOTS; speedunits = "knots"; continue; case 'm': altfactor = 1; altunits = "m"; speedfactor = MPS_TO_KPH; speedunits = "kph"; continue; default: (void)fprintf(stderr, "Unknown -u argument: %s\n", optarg); } } } /* Grok the server, port, and device. */ if (optind < argc) { gpsd_source_spec(argv[optind], &source); } else gpsd_source_spec(NULL, &source); /* Daemonize... */ if (daemon(0, 0) != 0) (void)fprintf(stderr, "lcdgps: demonization failed: %s\n", strerror(errno)); /* Open the stream to gpsd. */ if (gps_open(source.server, source.port, &gpsdata) != 0) { (void)fprintf( stderr, "lcdgps: no gpsd running or network error: %d, %s\n", errno, gps_errstr(errno)); exit(EXIT_FAILURE); } /* Connect to LCDd */ h = gethostbyname(LCDDHOST); if (h==NULL) { printf("%s: unknown host '%s'\n",argv[0],LCDDHOST); exit(EXIT_FAILURE); } servAddr.sin_family = h->h_addrtype; memcpy((char *) &servAddr.sin_addr.s_addr, h->h_addr_list[0], h->h_length); servAddr.sin_port = htons(LCDDPORT); /* create socket */ sd = socket(AF_INET, SOCK_STREAM, 0); if (BAD_SOCKET(sd)) { perror("cannot open socket "); exit(EXIT_FAILURE); } /* bind any port number */ localAddr.sin_family = AF_INET; localAddr.sin_addr.s_addr = htonl(INADDR_ANY); localAddr.sin_port = htons(0); /* coverity[uninit_use_in_call] */ rc = bind(sd, (struct sockaddr *) &localAddr, sizeof(localAddr)); if (rc == -1) { printf("%s: cannot bind port TCP %u\n",argv[0],LCDDPORT); perror("error "); exit(EXIT_FAILURE); } /* connect to server */ /* coverity[uninit_use_in_call] */ rc = connect(sd, (struct sockaddr *) &servAddr, sizeof(servAddr)); if (rc == -1) { perror("cannot connect "); exit(EXIT_FAILURE); } /* Do the initial field label setup. */ reset_lcd(); /* Here's where updates go. */ unsigned int flags = WATCH_ENABLE; if (source.device != NULL) flags |= WATCH_DEVICE; (void)gps_stream(&gpsdata, flags, source.device); for (;;) { /* heart of the client */ if (!gps_waiting(&gpsdata, 50000000)) { fprintf( stderr, "lcdgps: error while waiting\n"); exit(EXIT_FAILURE); } else { (void)gps_read(&gpsdata); update_lcd(&gpsdata); } } }
int main( int argc, char **argv ) { // Enforce proper command line arguments. if( argc != 2 ) { fprintf( stderr, "Usage: %s <hostname>\n", argv[0] ); exit( EXIT_FAILURE ); } // Connect to remote host. int sockfd = createConnection( argv[1], PORT_NUMBER ); if( sockfd < 0 ) { fprintf( stderr, "Couldn't connect to %s.\n", argv[1] ); exit( EXIT_FAILURE ); } else { printf( "Connected to %s\n.", argv[0] ); } // Connect to gpsd. if( gps_open( "localhost", DEFAULT_GPSD_PORT, &gpsData ) != 0 ) { fprintf( stderr, "Couldn't connect to gpsd, errno = %d, %s.\n", errno, gps_errstr( errno ) ); exit( EXIT_FAILURE ); } else { printf( "Connected to gpsd.\n" ); } // Register for updates from gpsd. gps_stream( &gpsData, WATCH_ENABLE | WATCH_JSON, NULL ); printf( "Waiting for gps lock." ); for(;;) { if( !gps_waiting( &gpsData, 5000000 ) ) { fprintf( stderr, "GPS fix timed out.\n" ); exit( EXIT_FAILURE ); } else { if( gps_read( &gpsData ) == -1 ) { fprintf( stderr, "gps_read() error, errno = %d\n", errno ); } else { if( isnan( gpsData.fix.latitude ) || isnan( gpsData.fix.longitude ) ) { fprintf( stderr, "Bad GPS fix.\n" ); } else { printf( "Latitude: %f\n", gpsData.fix.latitude ); printf( "Longitude: %f\n", gpsData.fix.longitude ); } } } } close( sockfd ); return 0; }
int main(){ int gps_recv; struct gps_data_t gps_data; struct timeval tv; struct tm *tm_info; FILE *gps_file_ptr; int millisec; char file_path[] = "/home/odroid/Canon_camera/Canon_gps_log.csv"; /* Open GPS device (GPSD) */ gps_recv = gps_open("localhost", "2947", &gps_data); if (gps_recv == -1) { printf("code: %d, reason %s\n", gps_recv, gps_errstr(gps_recv) ); } /* Start streaming GPS data */ gps_stream(&gps_data, WATCH_ENABLE, NULL); char lat_marker; char lng_marker; double latitude; double longitude; double latitude_min; double longitude_min; gps_file_ptr = fopen (file_path, "a"); int i; for (i=1;i<=50;i++) { if (gps_waiting(&gps_data, GPS_WAIT)) { /* Then GPS data is available, so read the data */ gps_recv = gps_read(&gps_data); /* printf("%d\n", gps_recv); */ /* Check for error in reading data */ if (gps_recv == -1) { printf("Error reading GPS. code: %d, reason %s\n", gps_recv, gps_errstr(gps_recv) ); } else { /* No problems in reading data, check for GPS fix*/ /* printf("No errors %d -- fix: %d\n", MODE_3D, gps_data.fix.mode); */ if ( (gps_data.status == STATUS_FIX) && (gps_data.fix.mode == MODE_2D || gps_data.fix.mode == MODE_3D) && !isnan(gps_data.fix.latitude) && !isnan(gps_data.fix.longitude) ) { latitude = fabs(gps_data.fix.latitude); longitude = fabs(gps_data.fix.longitude); latitude_min = (latitude - (int) latitude)*60; longitude_min = (longitude - (int) longitude)*60; if (gps_data.fix.latitude >= 0 ) { lat_marker = 'N'; } else { lat_marker = 'S'; } if (gps_data.fix.longitude >= 0 ) { lng_marker = 'E'; } else { lng_marker = 'W'; } printf("%f %c, %f %c \n", fabs(gps_data.fix.latitude), lat_marker, fabs(gps_data.fix.longitude), lng_marker); /* Write timestamp in YYYY-MM-DD_HH-MM-SS-sss */ gettimeofday(&tv, NULL); char time_buffer[26]; millisec = (long) (tv.tv_usec/1000.0 + 0.5); // Round to nearest millisec tm_info = localtime(&tv.tv_sec); strftime(time_buffer, 26, "%Y-%m-%d_%H-%M-%S-", tm_info); fprintf(gps_file_ptr, "%s", time_buffer); fprintf(gps_file_ptr, "%03d,", millisec); /* Write latititude and longitude in DD-MM-SS.sss */ fprintf(gps_file_ptr, "%d-%d-%f,%c,", (int) latitude, (int) latitude_min, (latitude_min - (int) latitude_min )*60, lat_marker); fprintf(gps_file_ptr, "%d-%d-%f,%c,", (int) longitude, (int) longitude_min, (longitude_min - (int) longitude_min )*60, lng_marker); /* Write Altitude, Heading */ if (gps_data.fix.mode == MODE_3D) { fprintf(gps_file_ptr, "%f,%f\n", gps_data.fix.altitude, gps_data.fix.track); } else { /* if not 3D fix, altitude is not defined */ fprintf(gps_file_ptr, "%d,%f\n", 0, gps_data.fix.track); } /* fprintf(gps_file_ptr, "%f%c,%f%c\n", fabs(gps_data.fix.latitude), lat_marker, fabs(gps_data.fix.longitude), lng_marker); */ } } } else { printf("-\n"); /* printf("\n ----- Did not wait long enough ----- \n");*/ } } /* Close logging file */ fclose(gps_file_ptr); /* Stop streaming data and close GPS connection */ gps_stream(&gps_data, WATCH_DISABLE, NULL); gps_close(&gps_data); printf("GPS -- %d\n", gps_recv); return 0; }
int main(int argc, char *argv[]) { if (argc<0) { error(" hostname error\n"); } int socket_fd, port_no, i,j,s; uint8_t arr[60]; //buffer to store payload memset(arr, 0, 60); uint8_t msgNum; srand(time(NULL)); msgNum=(uint8_t)(rand()%128); printf("The random value picked is %u\n",msgNum); struct timespec time1,start,stop,diff; int64_t t1,t2; struct BasicSafetyMessage *BSM_head = (struct BasicSafetyMessage *)arr; //pointer to BSM printf("size of BSM is %lu\n", sizeof(struct BasicSafetyMessage)); struct gps_data_t gpsdata; j = gps_open("localhost", "3333", &gpsdata); // can be any port number printf("open status is %d\n", j); (void)gps_stream(&gpsdata, WATCH_ENABLE | WATCH_JSON, NULL); printf("overall status is %d\n", gpsdata.status); socket_fd = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)); //ethernet header automatically constructed if (socket_fd < 0) { error("Error opening socket"); } else { printf("opened socket\n"); } //to determine interface number of the interface to be used struct ifreq ifr; size_t if_name_len = strlen("wlan0"); if (if_name_len<sizeof(ifr.ifr_name)) { memcpy(ifr.ifr_name, "wlan0", if_name_len); ifr.ifr_name[if_name_len] = 0; } else { error("interface name is too long\n"); } if (ioctl(socket_fd, SIOCGIFINDEX, &ifr) == -1) { error("error in ioctl block\n"); } int ifindex = ifr.ifr_ifindex; //store interface number in the variable 'ifindex' const unsigned char ether_broadcast_addr[] = { 0xff,0xff,0xff,0xff,0xff,0xff }; //destination address- broadcast address in this case struct sockaddr_ll addr = { 0 }; addr.sll_family = AF_PACKET; addr.sll_ifindex = ifindex; addr.sll_halen = ETHER_ADDR_LEN; addr.sll_protocol = htons(ETH_P_ALL); memcpy(addr.sll_addr, ether_broadcast_addr, ETHER_ADDR_LEN); int broadcast = 1; if (setsockopt(socket_fd, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) == -1) { //setting the 'broadcast' option on socket error("Error in setting the socket option for broadcast"); } else { printf("set option broadcast\n"); } //fill structure of BSM getFixedData(&BSM_head); int tot_len = sizeof(struct BasicSafetyMessage); FILE *fp; fp = fopen("location.txt","a"); fprintf(fp,"Timestamp(microsecs) SeqNum Latitude Longitude \n"); int c; for (c=0;c<1800;c++) //to keep broadcasting continuously { int num_bytes; if (gps_read(&gpsdata) == -1){ printf("error inside read\n"); } // If we have data, gpsdata.status becomes greater than 0 else if(gpsdata.status > 0){ getGpsSensorData(&BSM_head,&gpsdata,&msgNum); } getAnotherSensorData(); clock_gettime(CLOCK_REALTIME, &time1); //timestamp in microseconds int64_t micros = time1.tv_sec * 1000000; // Adding full microseconds micros += time1.tv_nsec/1000; // rounding up if (time1.tv_nsec % 1000 >= 500) { ++micros; } fprintf(fp,"\t"); fprintf(fp,"%u",micros); fprintf(fp,"\t\t"); fprintf(fp,"%u",BSM_head->blob1.msgCnt); fprintf(fp,"\t\t"); fprintf(fp,"%lf",BSM_head->blob1.lat); fprintf(fp,"\t\t"); fprintf(fp,"%lf",BSM_head->blob1.longi); fprintf(fp,"\n"); if(c!=0){ clock_gettime(CLOCK_REALTIME, &stop); //timestamp in nanoseconds t2 = stop.tv_sec * 1000000000; // Adding full nanoseconds t2 += stop.tv_nsec; printf("\n t2 is %u\n",t2); diff.tv_sec = 0; diff.tv_nsec = (100000000-(t2-t1)); printf("difference is %u in secs and %u nanosecs\n",diff.tv_sec,diff.tv_nsec); nanosleep(&diff,NULL); printf("after sleep\n"); } num_bytes = sendto(socket_fd, BSM_head, tot_len, 0, (struct sockaddr*)&addr, sizeof(addr));//sendto() to broadcast the BSM packet clock_gettime(CLOCK_REALTIME, &start); //timestamp in nanoseconds t1 = start.tv_sec * 1000000000; // Adding full nanoseconds t1 += start.tv_nsec; printf("\n t1 is %u\n",t1); if (num_bytes <0) { error("Error in sending the packet\n"); } else { printf("Sent %d bytes\n", num_bytes); } /* printf("The contents of the buffer are:\n"); for(s=0;s<num_bytes;s=s+2){ printf("%02x %02x\n",arr[s+1],arr[s]); } */ //sleep(1); } fclose(fp); close(socket_fd); (void)gps_stream(&gpsdata, WATCH_DISABLE, NULL); (void)gps_close(&gpsdata); return 0; }
int main(int argc, char **argv) { char buf[4096]; bool timestamp = false; char *format = "%F %T"; char tmstr[200]; bool daemonize = false; bool binary = false; bool sleepy = false; bool new_line = true; bool raw = false; bool watch = false; bool profile = false; int option_u = 0; // option to show uSeconds long count = -1; int option; unsigned int vflag = 0, l = 0; FILE *fp; unsigned int flags; fd_set fds; struct fixsource_t source; char *serialport = NULL; char *outfile = NULL; flags = WATCH_ENABLE; while ((option = getopt(argc, argv, "?dD:lhrRwStT:vVn:s:o:pPu2")) != -1) { switch (option) { case 'D': debug = atoi(optarg); #ifdef CLIENTDEBUG_ENABLE gps_enable_debug(debug, stderr); #endif /* CLIENTDEBUG_ENABLE */ break; case 'n': count = strtol(optarg, 0, 0); break; case 'r': raw = true; /* * Yes, -r invokes NMEA mode rather than proper raw mode. * This emulates the behavior under the old protocol. */ flags |= WATCH_NMEA; break; case 'R': flags |= WATCH_RAW; binary = true; break; case 'd': daemonize = true; break; case 'l': sleepy = true; break; case 't': timestamp = true; break; case 'T': timestamp = true; format = optarg; break; case 'u': timestamp = true; option_u++; break; case 'v': vflag++; break; case 'w': flags |= WATCH_JSON; watch = true; break; case 'S': flags |= WATCH_SCALED; break; case 'p': profile = true; break; case 'P': flags |= WATCH_PPS; break; case 'V': (void)fprintf(stderr, "%s: %s (revision %s)\n", argv[0], VERSION, REVISION); exit(EXIT_SUCCESS); case 's': serialport = optarg; break; case 'o': outfile = optarg; break; case '2': flags |= WATCH_SPLIT24; break; case '?': case 'h': default: usage(); exit(EXIT_FAILURE); } } /* Grok the server, port, and device. */ if (optind < argc) { gpsd_source_spec(argv[optind], &source); } else gpsd_source_spec(NULL, &source); if (serialport != NULL && !raw) { (void)fprintf(stderr, "gpspipe: use of '-s' requires '-r'.\n"); exit(EXIT_FAILURE); } if (outfile == NULL && daemonize) { (void)fprintf(stderr, "gpspipe: use of '-d' requires '-o'.\n"); exit(EXIT_FAILURE); } if (!raw && !watch && !binary) { (void)fprintf(stderr, "gpspipe: one of '-R', '-r', or '-w' is required.\n"); exit(EXIT_FAILURE); } /* Daemonize if the user requested it. */ if (daemonize) if (daemon(0, 0) != 0) (void)fprintf(stderr, "gpspipe: demonization failed: %s\n", strerror(errno)); /* Sleep for ten seconds if the user requested it. */ if (sleepy) (void)sleep(10); /* Open the output file if the user requested it. If the user * requested '-R', we use the 'b' flag in fopen() to "do the right * thing" in non-linux/unix OSes. */ if (outfile == NULL) { fp = stdout; } else { if (binary) fp = fopen(outfile, "wb"); else fp = fopen(outfile, "w"); if (fp == NULL) { (void)fprintf(stderr, "gpspipe: unable to open output file: %s\n", outfile); exit(EXIT_FAILURE); } } /* Open the serial port and set it up. */ if (serialport) open_serial(serialport); if (gps_open(source.server, source.port, &gpsdata) != 0) { (void)fprintf(stderr, "gpspipe: could not connect to gpsd %s:%s, %s(%d)\n", source.server, source.port, gps_errstr(errno), errno); exit(EXIT_FAILURE); } if (profile) flags |= WATCH_TIMING; if (source.device != NULL) flags |= WATCH_DEVICE; (void)gps_stream(&gpsdata, flags, source.device); if ((isatty(STDERR_FILENO) == 0) || daemonize) vflag = 0; for (;;) { int r = 0; struct timeval tv; tv.tv_sec = 0; tv.tv_usec = 100000; FD_ZERO(&fds); FD_SET(gpsdata.gps_fd, &fds); errno = 0; r = select(gpsdata.gps_fd+1, &fds, NULL, NULL, &tv); if (r == -1 && errno != EINTR) { (void)fprintf(stderr, "gpspipe: select error %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } else if (r == 0) continue; if (vflag) spinner(vflag, l++); /* reading directly from the socket avoids decode overhead */ errno = 0; r = (int)read(gpsdata.gps_fd, buf, sizeof(buf)); if (r > 0) { int i = 0; int j = 0; for (i = 0; i < r; i++) { char c = buf[i]; if (j < (int)(sizeof(serbuf) - 1)) { serbuf[j++] = buf[i]; } if (new_line && timestamp) { char tmstr_u[20]; // time with "usec" resolution struct timespec now; struct tm *tmp_now; (void)clock_gettime(CLOCK_REALTIME, &now); tmp_now = localtime((time_t *)&(now.tv_sec)); (void)strftime(tmstr, sizeof(tmstr), format, tmp_now); new_line = 0; switch( option_u ) { case 2: (void)snprintf(tmstr_u, sizeof(tmstr_u), " %ld.%06ld", (long)now.tv_sec, (long)now.tv_nsec/1000); break; case 1: (void)snprintf(tmstr_u, sizeof(tmstr_u), ".%06ld", (long)now.tv_nsec/1000); break; default: *tmstr_u = '\0'; break; } if (fprintf(fp, "%.24s%s: ", tmstr, tmstr_u) <= 0) { (void)fprintf(stderr, "gpspipe: write error, %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } } if (fputc(c, fp) == EOF) { fprintf(stderr, "gpspipe: write error, %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } if (c == '\n') { if (serialport != NULL) { if (write(fd_out, serbuf, (size_t) j) == -1) { fprintf(stderr, "gpspipe: serial port write error, %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } j = 0; } new_line = true; /* flush after every good line */ if (fflush(fp)) { (void)fprintf(stderr, "gpspipe: fflush error, %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } if (count > 0) { if (0 >= --count) { /* completed count */ exit(EXIT_SUCCESS); } } } } } else { if (r == -1) { if (errno == EAGAIN) continue; else (void)fprintf(stderr, "gpspipe: read error %s(%d)\n", strerror(errno), errno); exit(EXIT_FAILURE); } else { exit(EXIT_SUCCESS); } } } #ifdef __UNUSED__ if (serialport != NULL) { /* Restore the old serial port settings. */ if (tcsetattr(fd_out, TCSANOW, &oldtio) != 0) { (void)fprintf(stderr, "gpsipe: error restoring serial port settings\n"); exit(EXIT_FAILURE); } } #endif /* __UNUSED__ */ exit(EXIT_SUCCESS); }