1 /*
2 * collectd - src/sigrok.c
3 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
19 #include "collectd.h"
20 #include "common.h"
21 #include "plugin.h"
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <time.h>
27 #include <pthread.h>
29 #include <glib.h>
30 #include <libsigrok/libsigrok.h>
32 /* Minimum interval between dispatches coming from this plugin. The RRD
33 * plugin, at least, complains when written to with sub-second intervals.*/
34 #define DEFAULT_MIN_DISPATCH_INTERVAL TIME_T_TO_CDTIME_T(0)
36 static pthread_t sr_thread;
37 static int sr_thread_running = FALSE;
38 GSList *config_devices;
39 static int num_devices;
40 static int loglevel = SR_LOG_WARN;
41 static struct sr_context *sr_ctx;
43 struct config_device {
44 char *name;
45 char *driver;
46 char *conn;
47 char *serialcomm;
48 struct sr_dev_inst *sdi;
49 cdtime_t min_dispatch_interval;
50 cdtime_t last_dispatch;
51 };
54 static int sigrok_log_callback(void*cb_data __attribute__((unused)),
55 int msg_loglevel, const char *format, va_list args)
56 {
57 char s[512];
59 if (msg_loglevel <= loglevel) {
60 vsnprintf(s, 512, format, args);
61 plugin_log(LOG_INFO, "sigrok plugin: %s", s);
62 }
64 return 0;
65 }
67 static int sigrok_config_device(oconfig_item_t *ci)
68 {
69 struct config_device *cfdev;
70 int i;
72 if (!(cfdev = malloc(sizeof(struct config_device)))) {
73 ERROR("sigrok plugin: malloc() failed.");
74 return -1;
75 }
76 memset(cfdev, 0, sizeof(*cfdev));
77 if (cf_util_get_string(ci, &cfdev->name)) {
78 free(cfdev);
79 WARNING("sigrok plugin: Invalid device name.");
80 return -1;
81 }
82 cfdev->min_dispatch_interval = DEFAULT_MIN_DISPATCH_INTERVAL;
84 for (i = 0; i < ci->children_num; i++) {
85 oconfig_item_t *item = ci->children + i;
86 if (!strcasecmp(item->key, "driver"))
87 cf_util_get_string(item, &cfdev->driver);
88 else if (!strcasecmp(item->key, "conn"))
89 cf_util_get_string(item, &cfdev->conn);
90 else if (!strcasecmp(item->key, "serialcomm"))
91 cf_util_get_string(item, &cfdev->serialcomm);
92 else if (!strcasecmp(item->key, "minimuminterval"))
93 cf_util_get_cdtime(item, &cfdev->min_dispatch_interval);
94 else
95 WARNING("sigrok plugin: Invalid keyword \"%s\".",
96 item->key);
97 }
99 config_devices = g_slist_append(config_devices, cfdev);
101 return 0;
102 }
104 static int sigrok_config(oconfig_item_t *ci)
105 {
106 int i;
108 for (i = 0; i < ci->children_num; i++) {
109 oconfig_item_t *item = ci->children + i;
110 if (strcasecmp("LogLevel", item->key) == 0) {
111 int status;
112 int tmp = -1;
114 status = cf_util_get_int (item, &tmp);
115 if (status != 0)
116 continue;
117 else if ((tmp < 0) || (tmp > 5)) {
118 ERROR ("sigrok plugin: The \"LogLevel\" "
119 "configuration option expects "
120 "an integer between 0 and 5 "
121 "(inclusive); you provided %i.",
122 tmp);
123 continue;
124 }
125 loglevel = tmp;
126 } else if (!strcasecmp(item->key, "Device"))
127 sigrok_config_device(item);
128 else
129 WARNING("sigrok plugin: Invalid keyword \"%s\".",
130 item->key);
131 }
133 return 0;
134 }
136 static char *sigrok_value_type(const struct sr_datafeed_analog *analog)
137 {
138 char *s;
140 if (analog->mq == SR_MQ_VOLTAGE)
141 s = "voltage";
142 else if (analog->mq == SR_MQ_CURRENT)
143 s = "current";
144 else if (analog->mq == SR_MQ_FREQUENCY)
145 s = "frequency";
146 else if (analog->mq == SR_MQ_POWER)
147 s = "power";
148 else if (analog->mq == SR_MQ_TEMPERATURE)
149 s = "temperature";
150 else if (analog->mq == SR_MQ_RELATIVE_HUMIDITY)
151 s = "humidity";
152 else if (analog->mq == SR_MQ_SOUND_PRESSURE_LEVEL)
153 s = "spl";
154 else
155 s = "gauge";
157 return s;
158 }
160 static void sigrok_feed_callback(const struct sr_dev_inst *sdi,
161 const struct sr_datafeed_packet *packet, void *cb_data)
162 {
163 const struct sr_datafeed_analog *analog;
164 struct config_device *cfdev;
165 GSList *l;
166 value_t value;
167 value_list_t vl = VALUE_LIST_INIT;
169 /* Find this device's configuration. */
170 cfdev = NULL;
171 for (l = config_devices; l; l = l->next) {
172 cfdev = l->data;
173 if (cfdev->sdi == sdi) {
174 /* Found it. */
175 break;
176 }
177 cfdev = NULL;
178 }
180 if (!cfdev) {
181 ERROR("sigrok plugin: Received data from driver \"%s\" but "
182 "can't find a configuration / device matching "
183 "it.", sdi->driver->name);
184 return;
185 }
187 if (packet->type == SR_DF_END) {
188 /* TODO: try to restart acquisition after a delay? */
189 WARNING("sigrok plugin: acquisition for \"%s\" ended.",
190 cfdev->name);
191 return;
192 }
194 if (packet->type != SR_DF_ANALOG)
195 return;
197 if ((cfdev->min_dispatch_interval != 0)
198 && ((cdtime() - cfdev->last_dispatch)
199 < cfdev->min_dispatch_interval))
200 return;
202 /* Ignore all but the first sample on the first probe. */
203 analog = packet->payload;
204 value.gauge = analog->data[0];
205 vl.values = &value;
206 vl.values_len = 1;
207 sstrncpy(vl.host, hostname_g, sizeof(vl.host));
208 sstrncpy(vl.plugin, "sigrok", sizeof(vl.plugin));
209 ssnprintf(vl.plugin_instance, sizeof(vl.plugin_instance),
210 "%s", cfdev->name);
211 sstrncpy(vl.type, sigrok_value_type(analog), sizeof(vl.type));
213 plugin_dispatch_values(&vl);
214 cfdev->last_dispatch = cdtime();
215 }
217 static void sigrok_free_drvopts(struct sr_config *src)
218 {
219 g_variant_unref(src->data);
220 g_free(src);
221 }
223 static int sigrok_init_driver(struct config_device *cfdev,
224 struct sr_dev_driver *drv)
225 {
226 struct sr_config *src;
227 GSList *devlist, *drvopts;
228 char hwident[512];
230 if (sr_driver_init(sr_ctx, drv) != SR_OK)
231 /* Error was logged by libsigrok. */
232 return -1;
234 drvopts = NULL;
235 if (cfdev->conn) {
236 if (!(src = malloc(sizeof(struct sr_config))))
237 return -1;
238 src->key = SR_CONF_CONN;
239 src->data = g_variant_new_string(cfdev->conn);
240 drvopts = g_slist_append(drvopts, src);
241 }
242 if (cfdev->serialcomm) {
243 if (!(src = malloc(sizeof(struct sr_config))))
244 return -1;
245 src->key = SR_CONF_SERIALCOMM;
246 src->data = g_variant_new_string(cfdev->serialcomm);
247 drvopts = g_slist_append(drvopts, src);
248 }
249 devlist = sr_driver_scan(drv, drvopts);
250 g_slist_free_full(drvopts, (GDestroyNotify)sigrok_free_drvopts);
251 if (!devlist) {
252 /* Not an error, but the user should know about it. */
253 WARNING("sigrok plugin: No device found for \"%s\".",
254 cfdev->name);
255 return 0;
256 }
258 if (g_slist_length(devlist) > 1) {
259 INFO("sigrok plugin: %d sigrok devices for device entry "
260 "\"%s\": must be 1.",
261 g_slist_length(devlist), cfdev->name);
262 return -1;
263 }
264 cfdev->sdi = devlist->data;
265 g_slist_free(devlist);
266 ssnprintf(hwident, sizeof(hwident), "%s %s %s",
267 cfdev->sdi->vendor ? cfdev->sdi->vendor : "",
268 cfdev->sdi->model ? cfdev->sdi->model : "",
269 cfdev->sdi->version ? cfdev->sdi->version : "");
270 INFO("sigrok plugin: Device \"%s\" is a %s", cfdev->name, hwident);
272 if (sr_dev_open(cfdev->sdi) != SR_OK)
273 return -1;
275 if (sr_session_dev_add(cfdev->sdi) != SR_OK)
276 return -1;
278 return 1;
279 }
281 static void *sigrok_read_thread(void *arg __attribute__((unused)))
282 {
283 struct sr_dev_driver *drv, **drvlist;
284 GSList *l;
285 struct config_device *cfdev;
286 int ret, i;
288 sr_log_callback_set(sigrok_log_callback, NULL);
289 sr_log_loglevel_set(loglevel);
291 if ((ret = sr_init(&sr_ctx)) != SR_OK) {
292 ERROR("sigrok plugin: Failed to initialize libsigrok: %s.",
293 sr_strerror(ret));
294 return NULL;
295 }
297 if (!sr_session_new())
298 return NULL;
300 num_devices = 0;
301 drvlist = sr_driver_list();
302 for (l = config_devices; l; l = l->next) {
303 cfdev = l->data;
304 drv = NULL;
305 for (i = 0; drvlist[i]; i++) {
306 if (!strcmp(drvlist[i]->name, cfdev->driver)) {
307 drv = drvlist[i];
308 break;
309 }
310 }
311 if (!drv) {
312 ERROR("sigrok plugin: Unknown driver \"%s\".",
313 cfdev->driver);
314 return NULL;
315 }
317 if ((ret = sigrok_init_driver(cfdev, drv)) < 0)
318 /* Error was already logged. */
319 return NULL;
321 num_devices += ret;
322 }
324 if (num_devices > 0) {
325 /* Do this only when we're sure there's hardware to talk to. */
326 if (sr_session_datafeed_callback_add(sigrok_feed_callback, NULL)
327 != SR_OK)
328 return NULL;
330 /* Start acquisition on all devices. */
331 if (sr_session_start() != SR_OK)
332 return NULL;
334 /* Main loop, runs forever. */
335 sr_session_run();
337 sr_session_stop();
338 sr_session_dev_remove_all();
339 }
341 sr_session_destroy();
343 sr_exit(sr_ctx);
345 pthread_exit(NULL);
346 sr_thread_running = FALSE;
348 return NULL;
349 }
351 static int sigrok_init(void)
352 {
353 int status;
355 if (sr_thread_running) {
356 ERROR("sigrok plugin: Thread already running.");
357 return -1;
358 }
360 if ((status = plugin_thread_create(&sr_thread, NULL, sigrok_read_thread,
361 NULL)) != 0) {
362 ERROR("sigrok plugin: Failed to create thread: %s.",
363 strerror(status));
364 return -1;
365 }
366 sr_thread_running = TRUE;
368 return 0;
369 }
371 static int sigrok_shutdown(void)
372 {
373 struct config_device *cfdev;
374 GSList *l;
376 if (sr_thread_running) {
377 pthread_cancel(sr_thread);
378 pthread_join(sr_thread, NULL);
379 }
381 for (l = config_devices; l; l = l->next) {
382 cfdev = l->data;
383 free(cfdev->name);
384 free(cfdev->driver);
385 free(cfdev->conn);
386 free(cfdev->serialcomm);
387 free(cfdev);
388 }
389 g_slist_free(config_devices);
391 return 0;
392 }
394 void module_register(void)
395 {
396 plugin_register_complex_config("sigrok", sigrok_config);
397 plugin_register_init("sigrok", sigrok_init);
398 plugin_register_shutdown("sigrok", sigrok_shutdown);
399 }