src/gps.c

   1 /**
   2  * collectd - src/gps.c
   3  * Copyright (C) 2015  Nicolas JOURDEN
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *   Nicolas JOURDEN <nicolas.jourden at laposte.net>
  25  *   Florian octo Forster <octo at collectd.org>
  26  *   Marc Fournier <marc.fournier at camptocamp.com>
  27  **/
  28
  29 #include "common.h"
  30 #include "plugin.h"
  31 #include "utils_time.h"
  32 #include "collectd.h"
  33
  34 #define CGPS_TRUE 1
  35 #define CGPS_FALSE 0
  36 #define CGPS_DEFAULT_HOST "localhost"
  37 #define CGPS_DEFAULT_PORT "2947" /* DEFAULT_GPSD_PORT */
  38 #define CGPS_DEFAULT_TIMEOUT MS_TO_CDTIME_T(15)
  39 #define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T(5)
  40 #define CGPS_MAX_ERROR 100
  41 #define CGPS_CONFIG "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
  42
  43 #include <gps.h>
  44 #include <pthread.h>
  45
  46 typedef struct {
  47   char *host;
  48   char *port;
  49   cdtime_t timeout;
  50   cdtime_t pause_connect;
  51 } cgps_config_t;
  52
  53 typedef struct {
  54   gauge_t sats_used;
  55   gauge_t sats_visible;
  56   gauge_t hdop;
  57   gauge_t vdop;
  58 } cgps_data_t;
  59
  60 static cgps_config_t cgps_config_data;
  61
  62 static cgps_data_t cgps_data = {NAN, NAN, NAN, NAN};
  63
  64 static pthread_t cgps_thread_id;
  65 static pthread_mutex_t cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
  66 static pthread_mutex_t cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
  67 static int cgps_thread_shutdown = CGPS_FALSE;
  68 static int cgps_thread_running = CGPS_FALSE;
  69
  70 /**
  71  * Non blocking pause for the thread.
  72  */
  73 static int cgps_thread_pause(cdtime_t pTime) {
  74   cdtime_t now;
  75   now = cdtime();
  76   struct timespec pause_th;
  77   CDTIME_T_TO_TIMESPEC(MS_TO_CDTIME_T(10), &pause_th);
  78   while (CGPS_TRUE) {
  79     if ((cdtime() - now) > pTime) {
  80       break;
  81     }
  82
  83     pthread_mutex_lock(&cgps_thread_lock);
  84     if (cgps_thread_shutdown == CGPS_TRUE) {
  85       return CGPS_FALSE;
  86     }
  87     pthread_mutex_unlock(&cgps_thread_lock);
  88     nanosleep(&pause_th, NULL);
  89   }
  90
  91   return CGPS_TRUE;
  92 }
  93
  94 /**
  95  * Thread reading from gpsd.
  96  */
  97 static void *cgps_thread(void *pData) {
  98   struct gps_data_t gpsd_conn;
  99   unsigned int err_count;
 100   cgps_thread_running = CGPS_TRUE;
 101
 102   while (CGPS_TRUE) {
 103     pthread_mutex_lock(&cgps_thread_lock);
 104     if (cgps_thread_shutdown == CGPS_TRUE) {
 105       goto quit;
 106     }
 107     pthread_mutex_unlock(&cgps_thread_lock);
 108
 109     err_count = 0;
 110
 111 #if GPSD_API_MAJOR_VERSION > 4
 112     int status =
 113         gps_open(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
 114 #else
 115     int status =
 116         gps_open_r(cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
 117 #endif
 118     if (status < 0) {
 119       WARNING("gps plugin: connecting to %s:%s failed: %s",
 120               cgps_config_data.host, cgps_config_data.port, gps_errstr(status));
 121
 122       // Here we make a pause until a new tentative to connect, we check also if
 123       // the thread does not need to stop.
 124       if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE) {
 125         goto quit;
 126       }
 127
 128       continue;
 129     }
 130
 131     gps_stream(&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
 132     gps_send(&gpsd_conn, CGPS_CONFIG);
 133
 134     while (CGPS_TRUE) {
 135       pthread_mutex_lock(&cgps_thread_lock);
 136       if (cgps_thread_shutdown == CGPS_TRUE) {
 137         goto stop;
 138       }
 139       pthread_mutex_unlock(&cgps_thread_lock);
 140
 141 #if GPSD_API_MAJOR_VERSION > 4
 142       long timeout_us = CDTIME_T_TO_US(cgps_config_data.timeout);
 143       if (!gps_waiting(&gpsd_conn, (int)timeout_us))
 144 #else
 145       if (!gps_waiting(&gpsd_conn))
 146 #endif
 147       {
 148         continue;
 149       }
 150
 151       if (gps_read(&gpsd_conn) == -1) {
 152         WARNING("gps plugin: incorrect data! (err_count: %d)", err_count);
 153         err_count++;
 154
 155         if (err_count > CGPS_MAX_ERROR) {
 156           // Server is not responding ...
 157           if (gps_send(&gpsd_conn, CGPS_CONFIG) == -1) {
 158             WARNING("gps plugin: gpsd seems to be down, reconnecting");
 159             gps_close(&gpsd_conn);
 160             break;
 161           }
 162           // Server is responding ...
 163           else {
 164             err_count = 0;
 165           }
 166         }
 167
 168         continue;
 169       }
 170
 171       pthread_mutex_lock(&cgps_data_lock);
 172
 173       // Number of sats in view:
 174       cgps_data.sats_used = (gauge_t)gpsd_conn.satellites_used;
 175       cgps_data.sats_visible = (gauge_t)gpsd_conn.satellites_visible;
 176
 177       // dilution of precision:
 178       cgps_data.vdop = NAN;
 179       cgps_data.hdop = NAN;
 180       if (cgps_data.sats_used > 0) {
 181         cgps_data.hdop = gpsd_conn.dop.hdop;
 182         cgps_data.vdop = gpsd_conn.dop.vdop;
 183       }
 184
 185       DEBUG("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = "
 186             "%.3f",
 187             cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop,
 188             cgps_data.vdop);
 189
 190       pthread_mutex_unlock(&cgps_data_lock);
 191     }
 192   }
 193
 194 stop:
 195   DEBUG("gps plugin: thread closing gpsd connection ... ");
 196   gps_stream(&gpsd_conn, WATCH_DISABLE, NULL);
 197   gps_close(&gpsd_conn);
 198 quit:
 199   DEBUG("gps plugin: thread shutting down ... ");
 200   cgps_thread_running = CGPS_FALSE;
 201   pthread_mutex_unlock(&cgps_thread_lock);
 202   pthread_exit(NULL);
 203 }
 204
 205 /**
 206  * Submit a piece of the data.
 207  */
 208 static void cgps_submit(const char *type, gauge_t value,
 209                         const char *type_instance) {
 210   value_t values[1];
 211   value_list_t vl = VALUE_LIST_INIT;
 212
 213   values[0].gauge = value;
 214
 215   vl.values = values;
 216   vl.values_len = 1;
 217   sstrncpy(vl.host, hostname_g, sizeof(vl.host));
 218   sstrncpy(vl.plugin, "gps", sizeof(vl.plugin));
 219   sstrncpy(vl.type, type, sizeof(vl.type));
 220   sstrncpy(vl.type_instance, type_instance, sizeof(vl.type_instance));
 221
 222   plugin_dispatch_values(&vl);
 223 }
 224
 225 /**
 226  * Read the data and submit by piece.
 227  */
 228 static int cgps_read(void) {
 229   cgps_data_t data_copy;
 230
 231   pthread_mutex_lock(&cgps_data_lock);
 232   data_copy = cgps_data;
 233   pthread_mutex_unlock(&cgps_data_lock);
 234
 235   cgps_submit("dilution_of_precision", data_copy.hdop, "horizontal");
 236   cgps_submit("dilution_of_precision", data_copy.vdop, "vertical");
 237   cgps_submit("satellites", data_copy.sats_used, "used");
 238   cgps_submit("satellites", data_copy.sats_visible, "visible");
 239
 240   return (0);
 241 }
 242
 243 /**
 244  * Read configuration.
 245  */
 246 static int cgps_config(oconfig_item_t *ci) {
 247   int i;
 248
 249   for (i = 0; i < ci->children_num; i++) {
 250     oconfig_item_t *child = ci->children + i;
 251
 252     if (strcasecmp("Host", child->key) == 0)
 253       cf_util_get_string(child, &cgps_config_data.host);
 254     else if (strcasecmp("Port", child->key) == 0)
 255       cf_util_get_service(child, &cgps_config_data.port);
 256     else if (strcasecmp("Timeout", child->key) == 0)
 257       cf_util_get_cdtime(child, &cgps_config_data.timeout);
 258     else if (strcasecmp("PauseConnect", child->key) == 0)
 259       cf_util_get_cdtime(child, &cgps_config_data.pause_connect);
 260     else
 261       WARNING("gps plugin: Ignoring unknown config option \"%s\".", child->key);
 262   }
 263
 264   // Controlling the value for timeout:
 265   // If set too high it blocks the reading (> 5 s), too low it gets not reading
 266   // (< 500 us).
 267   // To avoid any issues we replace "out of range" value by the default value.
 268   if (cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5) ||
 269       cgps_config_data.timeout < US_TO_CDTIME_T(500)) {
 270     WARNING("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
 271             CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
 272             CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT));
 273     cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
 274   }
 275
 276   return (0);
 277 }
 278
 279 /**
 280  * Init.
 281  */
 282 static int cgps_init(void) {
 283   int status;
 284
 285   if (cgps_thread_running == CGPS_TRUE) {
 286     DEBUG("gps plugin: error gps thread already running ... ");
 287     return 0;
 288   }
 289
 290   DEBUG("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., "
 291         "pause connect: %.3f sec.}",
 292         cgps_config_data.host, cgps_config_data.port,
 293         CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
 294         CDTIME_T_TO_DOUBLE(cgps_config_data.pause_connect));
 295
 296   status = plugin_thread_create(&cgps_thread_id, NULL, cgps_thread, NULL);
 297   if (status != 0) {
 298     ERROR("gps plugin: pthread_create() failed.");
 299     return (-1);
 300   }
 301
 302   return (0);
 303 }
 304
 305 /**
 306  * Shutdown.
 307  */
 308 static int cgps_shutdown(void) {
 309   void *res;
 310
 311   pthread_mutex_lock(&cgps_thread_lock);
 312   cgps_thread_shutdown = CGPS_TRUE;
 313   pthread_mutex_unlock(&cgps_thread_lock);
 314
 315   pthread_join(cgps_thread_id, &res);
 316   free(res);
 317
 318   // Clean mutex:
 319   pthread_mutex_unlock(&cgps_thread_lock);
 320   pthread_mutex_destroy(&cgps_thread_lock);
 321   pthread_mutex_unlock(&cgps_data_lock);
 322   pthread_mutex_destroy(&cgps_data_lock);
 323
 324   sfree(cgps_config_data.port);
 325   sfree(cgps_config_data.host);
 326
 327   return (0);
 328 }
 329
 330 /**
 331  * Register the module.
 332  */
 333 void module_register(void) {
 334   cgps_config_data.host = sstrdup(CGPS_DEFAULT_HOST);
 335   cgps_config_data.port = sstrdup(CGPS_DEFAULT_PORT);
 336   cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
 337   cgps_config_data.pause_connect = CGPS_DEFAULT_PAUSE_CONNECT;
 338
 339   plugin_register_complex_config("gps", cgps_config);
 340   plugin_register_init("gps", cgps_init);
 341   plugin_register_read("gps", cgps_read);
 342   plugin_register_shutdown("gps", cgps_shutdown);
 343 }