3 * Copyright (C) 2015 Nicolas JOURDEN
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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.
24 * Nicolas JOURDEN <nicolas.jourden at laposte.net>
25 * Florian octo Forster <octo at collectd.org>
26 * Marc Fournier <marc.fournier at camptocamp.com>
32 #include "utils_time.h"
33 #include "configfile.h"
37 #define CGPS_DEFAULT_HOST "localhost"
38 #define CGPS_DEFAULT_PORT "2947" /* DEFAULT_GPSD_PORT */
39 #define CGPS_DEFAULT_TIMEOUT MS_TO_CDTIME_T (15)
40 #define CGPS_DEFAULT_PAUSE_CONNECT TIME_T_TO_CDTIME_T (5)
41 #define CGPS_MAX_ERROR 100
42 #define CGPS_CONFIG "?WATCH={\"enable\":true,\"json\":true,\"nmea\":false}\r\n"
51 cdtime_t pause_connect;
61 static cgps_config_t cgps_config_data;
63 static cgps_data_t cgps_data = {NAN, NAN, NAN, NAN};
65 static pthread_t cgps_thread_id;
66 static pthread_mutex_t cgps_data_lock = PTHREAD_MUTEX_INITIALIZER;
67 static pthread_mutex_t cgps_thread_lock = PTHREAD_MUTEX_INITIALIZER;
68 static int cgps_thread_shutdown = CGPS_FALSE;
69 static int cgps_thread_running = CGPS_FALSE;
72 * Non blocking pause for the thread.
74 static int cgps_thread_pause(cdtime_t pTime)
78 struct timespec pause_th;
79 CDTIME_T_TO_TIMESPEC (MS_TO_CDTIME_T(10), &pause_th);
82 if ( (cdtime () - now) > pTime )
87 pthread_mutex_lock (&cgps_thread_lock);
88 if (cgps_thread_shutdown == CGPS_TRUE)
92 pthread_mutex_unlock (&cgps_thread_lock);
93 nanosleep (&pause_th, NULL);
100 * Thread reading from gpsd.
102 static void * cgps_thread (void * pData)
104 struct gps_data_t gpsd_conn;
105 unsigned int err_count;
106 cgps_thread_running = CGPS_TRUE;
110 pthread_mutex_lock (&cgps_thread_lock);
111 if (cgps_thread_shutdown == CGPS_TRUE)
115 pthread_mutex_unlock (&cgps_thread_lock);
119 #if GPSD_API_MAJOR_VERSION > 4
120 int status = gps_open (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
122 int status = gps_open_r (cgps_config_data.host, cgps_config_data.port, &gpsd_conn);
126 WARNING ("gps plugin: connecting to %s:%s failed: %s",
127 cgps_config_data.host, cgps_config_data.port, gps_errstr (status));
129 // Here we make a pause until a new tentative to connect, we check also if
130 // the thread does not need to stop.
131 if (cgps_thread_pause(cgps_config_data.pause_connect) == CGPS_FALSE)
139 gps_stream (&gpsd_conn, WATCH_ENABLE | WATCH_JSON | WATCH_NEWSTYLE, NULL);
140 gps_send (&gpsd_conn, CGPS_CONFIG);
144 pthread_mutex_lock (&cgps_thread_lock);
145 if (cgps_thread_shutdown == CGPS_TRUE)
149 pthread_mutex_unlock (&cgps_thread_lock);
151 #if GPSD_API_MAJOR_VERSION > 4
152 long timeout_us = CDTIME_T_TO_US (cgps_config_data.timeout);
153 if (!gps_waiting (&gpsd_conn, (int) timeout_us ))
155 if (!gps_waiting (&gpsd_conn))
161 if (gps_read (&gpsd_conn) == -1)
163 WARNING ("gps plugin: incorrect data! (err_count: %d)", err_count);
166 if (err_count > CGPS_MAX_ERROR)
168 // Server is not responding ...
169 if (gps_send (&gpsd_conn, CGPS_CONFIG) == -1)
171 WARNING ("gps plugin: gpsd seems to be down, reconnecting");
172 gps_close (&gpsd_conn);
175 // Server is responding ...
185 pthread_mutex_lock (&cgps_data_lock);
187 // Number of sats in view:
188 cgps_data.sats_used = (gauge_t) gpsd_conn.satellites_used;
189 cgps_data.sats_visible = (gauge_t) gpsd_conn.satellites_visible;
191 // dilution of precision:
192 cgps_data.vdop = NAN;
193 cgps_data.hdop = NAN;
194 if (cgps_data.sats_used > 0)
196 cgps_data.hdop = gpsd_conn.dop.hdop;
197 cgps_data.vdop = gpsd_conn.dop.vdop;
200 DEBUG ("gps plugin: %.0f sats used (of %.0f visible), hdop = %.3f, vdop = %.3f",
201 cgps_data.sats_used, cgps_data.sats_visible, cgps_data.hdop, cgps_data.vdop);
203 pthread_mutex_unlock (&cgps_data_lock);
208 DEBUG ("gps plugin: thread closing gpsd connection ... ");
209 gps_stream (&gpsd_conn, WATCH_DISABLE, NULL);
210 gps_close (&gpsd_conn);
212 DEBUG ("gps plugin: thread shutting down ... ");
213 cgps_thread_running = CGPS_FALSE;
214 pthread_mutex_unlock (&cgps_thread_lock);
220 * Submit a piece of the data.
222 static void cgps_submit (const char *type, gauge_t value, const char *type_instance)
225 value_list_t vl = VALUE_LIST_INIT;
227 values[0].gauge = value;
231 sstrncpy (vl.host, hostname_g, sizeof (vl.host));
232 sstrncpy (vl.plugin, "gps", sizeof (vl.plugin));
233 sstrncpy (vl.type, type, sizeof (vl.type));
234 sstrncpy (vl.type_instance, type_instance, sizeof (vl.type_instance));
236 plugin_dispatch_values (&vl);
240 * Read the data and submit by piece.
242 static int cgps_read (void)
244 cgps_data_t data_copy;
246 pthread_mutex_lock (&cgps_data_lock);
247 data_copy = cgps_data;
248 pthread_mutex_unlock (&cgps_data_lock);
250 cgps_submit ("dilution_of_precision", data_copy.hdop, "horizontal");
251 cgps_submit ("dilution_of_precision", data_copy.vdop, "vertical");
252 cgps_submit ("satellites", data_copy.sats_used, "used");
253 cgps_submit ("satellites", data_copy.sats_visible, "visible");
259 * Read configuration.
261 static int cgps_config (oconfig_item_t *ci)
265 for (i = 0; i < ci->children_num; i++)
267 oconfig_item_t *child = ci->children + i;
269 if (strcasecmp ("Host", child->key) == 0)
270 cf_util_get_string (child, &cgps_config_data.host);
271 else if (strcasecmp ("Port", child->key) == 0)
272 cf_util_get_service (child, &cgps_config_data.port);
273 else if (strcasecmp ("Timeout", child->key) == 0)
274 cf_util_get_cdtime (child, &cgps_config_data.timeout);
275 else if (strcasecmp ("PauseConnect", child->key) == 0)
276 cf_util_get_cdtime (child, &cgps_config_data.pause_connect);
278 WARNING ("gps plugin: Ignoring unknown config option \"%s\".", child->key);
281 // Controlling the value for timeout:
282 // If set too high it blocks the reading (> 5 s), too low it gets not reading (< 500 us).
283 // To avoid any issues we replace "out of range" value by the default value.
285 cgps_config_data.timeout > TIME_T_TO_CDTIME_T(5)
287 cgps_config_data.timeout < US_TO_CDTIME_T(500)
290 WARNING ("gps plugin: timeout set to %.6f sec. setting to default (%.6f).",
291 CDTIME_T_TO_DOUBLE(cgps_config_data.timeout),
292 CDTIME_T_TO_DOUBLE(CGPS_DEFAULT_TIMEOUT)
294 cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
303 static int cgps_init (void)
307 if (cgps_thread_running == CGPS_TRUE)
309 DEBUG ("gps plugin: error gps thread already running ... ");
313 DEBUG ("gps plugin: config{host: \"%s\", port: \"%s\", timeout: %.6f sec., pause connect: %.3f sec.}",
314 cgps_config_data.host, cgps_config_data.port,
315 CDTIME_T_TO_DOUBLE (cgps_config_data.timeout),
316 CDTIME_T_TO_DOUBLE (cgps_config_data.pause_connect));
318 status = plugin_thread_create (&cgps_thread_id, NULL, cgps_thread, NULL);
321 ERROR ("gps plugin: pthread_create() failed.");
331 static int cgps_shutdown (void)
335 pthread_mutex_lock (&cgps_thread_lock);
336 cgps_thread_shutdown = CGPS_TRUE;
337 pthread_mutex_unlock (&cgps_thread_lock);
339 pthread_join(cgps_thread_id, &res);
343 pthread_mutex_unlock(&cgps_thread_lock);
344 pthread_mutex_destroy(&cgps_thread_lock);
345 pthread_mutex_unlock(&cgps_data_lock);
346 pthread_mutex_destroy(&cgps_data_lock);
348 sfree (cgps_config_data.port);
349 sfree (cgps_config_data.host);
355 * Register the module.
357 void module_register (void)
359 cgps_config_data.host = sstrdup (CGPS_DEFAULT_HOST);
360 cgps_config_data.port = sstrdup (CGPS_DEFAULT_PORT);
361 cgps_config_data.timeout = CGPS_DEFAULT_TIMEOUT;
362 cgps_config_data.pause_connect = CGPS_DEFAULT_PAUSE_CONNECT;
364 plugin_register_complex_config ("gps", cgps_config);
365 plugin_register_init ("gps", cgps_init);
366 plugin_register_read ("gps", cgps_read);
367 plugin_register_shutdown ("gps", cgps_shutdown);