]> sigrok.org Git - libsigrok.git/blame - src/hardware/gmc-mh-1x-2x/api.c
Introduce standard cleanup helper
[libsigrok.git] / src / hardware / gmc-mh-1x-2x / api.c
CommitLineData
7b4edcb6
MH
1/*
2 * This file is part of the libsigrok project.
3 *
c90beca7 4 * Copyright (C) 2013, 2014 Matthias Heidbrink <m-sigrok@heidbrink.biz>
7b4edcb6
MH
5 *
6 * This program 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 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
6392d599
MH
20/** @file
21 * Gossen Metrawatt Metrahit 1x/2x drivers
c90beca7 22 * @internal
6392d599
MH
23 */
24
6ec6c43b 25#include <config.h>
f5792417 26#include <string.h>
7b4edcb6
MH
27#include "protocol.h"
28
f5792417
MH
29/* Serial communication parameters for Metrahit 1x/2x with 'RS232' adaptor */
30#define SERIALCOMM_1X_RS232 "8228/6n1/dtr=1/rts=1/flow=0" /* =8192, closer with divider */
31#define SERIALCOMM_2X_RS232 "9600/6n1/dtr=1/rts=1/flow=0"
6392d599 32#define SERIALCOMM_2X "9600/8n1/dtr=1/rts=1/flow=0"
f5792417
MH
33#define VENDOR_GMC "Gossen Metrawatt"
34
7b4edcb6 35SR_PRIV struct sr_dev_driver gmc_mh_1x_2x_rs232_driver_info;
c90beca7 36SR_PRIV struct sr_dev_driver gmc_mh_2x_bd232_driver_info;
7b4edcb6 37
a0e0bb41 38static const uint32_t scanopts[] = {
f5792417
MH
39 SR_CONF_CONN,
40 SR_CONF_SERIALCOMM,
41};
42
c90beca7 43/** Hardware capabilities for Metrahit 1x/2x devices in send mode. */
f254bc4b 44static const uint32_t devopts_sm[] = {
f5792417 45 SR_CONF_MULTIMETER,
6392d599 46 SR_CONF_THERMOMETER, /**< All GMC 1x/2x multimeters seem to support this */
f5792417 47 SR_CONF_CONTINUOUS,
5827f61b
BV
48 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
49 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
f5792417
MH
50};
51
c90beca7 52/** Hardware capabilities for Metrahit 2x devices in bidirectional Mode. */
f254bc4b 53static const uint32_t devopts_bd[] = {
c90beca7
MH
54 SR_CONF_MULTIMETER,
55 SR_CONF_THERMOMETER, /**< All GMC 1x/2x multimeters seem to support this */
c90beca7 56 SR_CONF_CONTINUOUS,
5827f61b
BV
57 SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
58 SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
59 SR_CONF_POWER_OFF | SR_CONF_GET | SR_CONF_SET,
c90beca7
MH
60};
61
6392d599
MH
62/* TODO:
63 * - For the 29S SR_CONF_ENERGYMETER, too.
64 * - SR_CONF_PATTERN_MODE for some 2x devices
65 * - SR_CONF_DATALOG for 22M, 26M, 29S and storage adaptors.
66 * Need to implement device-specific lists.
67 */
68
4f840ce9 69static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
c90beca7 70{
4f840ce9 71 return std_init(sr_ctx, di, LOG_PREFIX);
7b4edcb6
MH
72}
73
fc348b77
UH
74/**
75 * Read single byte from serial port.
76 *
77 * @retval -1 Timeout or error.
78 * @retval other Byte.
f5792417
MH
79 */
80static int read_byte(struct sr_serial_dev_inst *serial, gint64 timeout)
7b4edcb6 81{
fc348b77 82 uint8_t result = 0;
f5792417
MH
83 int rc = 0;
84
85 for (;;) {
0714a010 86 rc = serial_read_nonblocking(serial, &result, 1);
f5792417
MH
87 if (rc == 1) {
88 sr_spew("read: 0x%02x/%d", result, result);
89 return result;
90 }
91 if (g_get_monotonic_time() > timeout)
92 return -1;
93 g_usleep(2000);
94 }
95}
96
fc348b77
UH
97/**
98 * Try to detect GMC 1x/2x multimeter model in send mode for max. 1 second.
f5792417 99 *
fc348b77
UH
100 * @param serial Configured, open serial port.
101 *
102 * @retval NULL Detection failed.
103 * @retval other Model code.
f5792417
MH
104 */
105static enum model scan_model_sm(struct sr_serial_dev_inst *serial)
106{
107 int byte, bytecnt, cnt;
108 enum model model;
109 gint64 timeout_us;
110
873e0c12 111 model = METRAHIT_NONE;
1a46cc62 112 timeout_us = g_get_monotonic_time() + (1 * 1000 * 1000);
f5792417 113
fc348b77
UH
114 /*
115 * Try to find message consisting of device code and several
116 * (at least 4) data bytes.
117 */
f5792417
MH
118 for (bytecnt = 0; bytecnt < 100; bytecnt++) {
119 byte = read_byte(serial, timeout_us);
120 if ((byte == -1) || (timeout_us < g_get_monotonic_time()))
121 break;
122 if ((byte & MSGID_MASK) == MSGID_INF) {
873e0c12 123 if (!(model = gmc_decode_model_sm(byte & MSGC_MASK)))
f5792417 124 break;
fc348b77 125 /* Now expect (at least) 4 data bytes. */
f5792417
MH
126 for (cnt = 0; cnt < 4; cnt++) {
127 byte = read_byte(serial, timeout_us);
128 if ((byte == -1) ||
c90beca7 129 ((byte & MSGID_MASK) != MSGID_DATA))
f5792417 130 {
873e0c12 131 model = METRAHIT_NONE;
f5792417
MH
132 bytecnt = 100;
133 break;
134 }
135 }
136 break;
137 }
138 }
7b4edcb6 139
f5792417
MH
140 return model;
141}
142
fc348b77
UH
143/**
144 * Scan for Metrahit 1x and Metrahit 2x in send mode using Gossen Metrawatt
145 * 'RS232' interface.
146 *
147 * The older 1x models use 8192 baud and the newer 2x 9600 baud.
148 * The DMM usually sends up to about 20 messages per second. However, depending
149 * on configuration and measurement mode the intervals can be much larger and
150 * then the detection might not work.
f5792417 151 */
4f840ce9 152static GSList *scan_1x_2x_rs232(struct sr_dev_driver *di, GSList *options)
f5792417
MH
153{
154 struct sr_dev_inst *sdi;
155 struct drv_context *drvc;
156 struct dev_context *devc;
157 struct sr_config *src;
f5792417
MH
158 struct sr_serial_dev_inst *serial;
159 GSList *l, *devices;
160 const char *conn, *serialcomm;
161 enum model model;
162 gboolean serialcomm_given;
7b4edcb6
MH
163
164 devices = NULL;
41812aca 165 drvc = di->context;
7b4edcb6 166 drvc->instances = NULL;
f5792417 167 conn = serialcomm = NULL;
f5792417
MH
168 serialcomm_given = FALSE;
169
c90beca7 170 sr_spew("scan_1x_2x_rs232() called!");
f5792417
MH
171
172 for (l = options; l; l = l->next) {
173 src = l->data;
174 switch (src->key) {
175 case SR_CONF_CONN:
176 conn = g_variant_get_string(src->data, NULL);
177 break;
178 case SR_CONF_SERIALCOMM:
179 serialcomm = g_variant_get_string(src->data, NULL);
180 serialcomm_given = TRUE;
181 break;
182 }
183 }
184 if (!conn)
185 return NULL;
186 if (!serialcomm)
187 serialcomm = SERIALCOMM_2X_RS232;
188
91219afc 189 serial = sr_serial_dev_inst_new(conn, serialcomm);
f5792417 190
e13e354f 191 if (serial_open(serial, SERIAL_RDWR) != SR_OK) {
f5792417
MH
192 sr_serial_dev_inst_free(serial);
193 return NULL;
194 }
7b4edcb6 195
f5792417
MH
196 serial_flush(serial);
197
198 model = scan_model_sm(serial);
199
fc348b77
UH
200 /*
201 * If detection failed and no user-supplied parameters,
202 * try second baud rate.
203 */
873e0c12 204 if ((model == METRAHIT_NONE) && !serialcomm_given) {
f5792417
MH
205 serialcomm = SERIALCOMM_1X_RS232;
206 g_free(serial->serialcomm);
207 serial->serialcomm = g_strdup(serialcomm);
208 if (serial_set_paramstr(serial, serialcomm) == SR_OK) {
209 serial_flush(serial);
210 model = scan_model_sm(serial);
211 }
212 }
213
873e0c12
UH
214 if (model != METRAHIT_NONE) {
215 sr_spew("%s %s detected!", VENDOR_GMC, gmc_model_str(model));
aac29cc1 216 sdi = g_malloc0(sizeof(struct sr_dev_inst));
0af636be
UH
217 sdi->status = SR_ST_INACTIVE;
218 sdi->vendor = g_strdup(VENDOR_GMC);
219 sdi->model = g_strdup(gmc_model_str(model));
f57d8ffe 220 devc = g_malloc0(sizeof(struct dev_context));
f5792417
MH
221 devc->model = model;
222 devc->limit_samples = 0;
223 devc->limit_msec = 0;
224 devc->num_samples = 0;
225 devc->elapsed_msec = g_timer_new();
226 devc->settings_ok = FALSE;
f5792417
MH
227 sdi->conn = serial;
228 sdi->priv = devc;
4f840ce9 229 sdi->driver = di;
5e23fcab 230 sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P1");
f5792417
MH
231 drvc->instances = g_slist_append(drvc->instances, sdi);
232 devices = g_slist_append(devices, sdi);
233 }
7b4edcb6
MH
234
235 return devices;
236}
237
1a863916
UH
238/**
239 * Scan for Metrahit 2x in a bidirectional mode using Gossen Metrawatt
240 * 'BD 232' interface.
c90beca7 241 */
4f840ce9 242static GSList *scan_2x_bd232(struct sr_dev_driver *di, GSList *options)
c90beca7
MH
243{
244 struct sr_dev_inst *sdi;
245 struct drv_context *drvc;
246 struct dev_context *devc;
247 struct sr_config *src;
c90beca7
MH
248 struct sr_serial_dev_inst *serial;
249 GSList *l, *devices;
250 const char *conn, *serialcomm;
251 int cnt, byte;
252 gint64 timeout_us;
253
254 sdi = NULL;
255 devc = NULL;
256 conn = serialcomm = NULL;
257 devices = NULL;
258
41812aca 259 drvc = di->context;
c90beca7
MH
260 drvc->instances = NULL;
261
262 sr_spew("scan_2x_bd232() called!");
263
264 for (l = options; l; l = l->next) {
265 src = l->data;
266 switch (src->key) {
267 case SR_CONF_CONN:
268 conn = g_variant_get_string(src->data, NULL);
269 break;
270 case SR_CONF_SERIALCOMM:
271 serialcomm = g_variant_get_string(src->data, NULL);
272 break;
273 }
274 }
275 if (!conn)
276 return NULL;
277 if (!serialcomm)
278 serialcomm = SERIALCOMM_2X;
279
91219afc 280 serial = sr_serial_dev_inst_new(conn, serialcomm);
c90beca7 281
e13e354f 282 if (serial_open(serial, SERIAL_RDWR) != SR_OK)
c90beca7
MH
283 goto exit_err;
284
f57d8ffe 285 devc = g_malloc0(sizeof(struct dev_context));
c90beca7 286
aac29cc1 287 sdi = g_malloc0(sizeof(struct sr_dev_inst));
0af636be
UH
288 sdi->status = SR_ST_INACTIVE;
289 sdi->vendor = g_strdup(VENDOR_GMC);
c90beca7
MH
290 sdi->priv = devc;
291
292 /* Send message 03 "Query multimeter version and status" */
293 sdi->conn = serial;
c90beca7
MH
294 if (req_stat14(sdi, TRUE) != SR_OK)
295 goto exit_err;
296
297 /* Wait for reply from device(s) for up to 2s. */
1a46cc62 298 timeout_us = g_get_monotonic_time() + (2 * 1000 * 1000);
c90beca7
MH
299
300 while (timeout_us > g_get_monotonic_time()) {
301 /* Receive reply (14 bytes) */
302 devc->buflen = 0;
07ffa5b3 303 for (cnt = 0; cnt < GMC_REPLY_SIZE; cnt++) {
c90beca7
MH
304 byte = read_byte(serial, timeout_us);
305 if (byte != -1)
306 devc->buf[devc->buflen++] = (byte & MASK_6BITS);
307 }
308
07ffa5b3 309 if (devc->buflen != GMC_REPLY_SIZE)
c90beca7
MH
310 continue;
311
312 devc->addr = devc->buf[0];
313 process_msg14(sdi);
314 devc->buflen = 0;
315
316 if (devc->model != METRAHIT_NONE) {
317 sr_spew("%s %s detected!", VENDOR_GMC, gmc_model_str(devc->model));
c90beca7 318 devc->elapsed_msec = g_timer_new();
c90beca7
MH
319 sdi->model = g_strdup(gmc_model_str(devc->model));
320 sdi->version = g_strdup_printf("Firmware %d.%d", devc->fw_ver_maj, devc->fw_ver_min);
321 sdi->conn = serial;
322 sdi->priv = devc;
4f840ce9 323 sdi->driver = di;
5e23fcab 324 sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P1");
c90beca7
MH
325 drvc->instances = g_slist_append(drvc->instances, sdi);
326 devices = g_slist_append(devices, sdi);
f57d8ffe 327 devc = g_malloc0(sizeof(struct dev_context));
aac29cc1 328 sdi = g_malloc0(sizeof(struct sr_dev_inst));
0af636be
UH
329 sdi->status = SR_ST_INACTIVE;
330 sdi->vendor = g_strdup(VENDOR_GMC);
c90beca7
MH
331 }
332 };
333
334 /* Free last alloc if no device found */
335 if (devc->model == METRAHIT_NONE) {
336 g_free(devc);
337 sr_dev_inst_free(sdi);
338 }
339
340 return devices;
341
342exit_err:
343 sr_info("scan_2x_bd232(): Error!");
344
345 if (serial)
346 sr_serial_dev_inst_free(serial);
b1f83103 347 g_free(devc);
c90beca7
MH
348 if (sdi)
349 sr_dev_inst_free(sdi);
350
351 return NULL;
352}
353
4f840ce9 354static GSList *dev_list(const struct sr_dev_driver *di)
7b4edcb6 355{
41812aca 356 return ((struct drv_context *)(di->context))->instances;
7b4edcb6
MH
357}
358
7b4edcb6
MH
359static int dev_close(struct sr_dev_inst *sdi)
360{
f5792417 361 struct dev_context *devc;
7b4edcb6 362
bf2c987f 363 std_serial_dev_close(sdi);
7b4edcb6
MH
364
365 sdi->status = SR_ST_INACTIVE;
366
f5792417
MH
367 /* Free dynamically allocated resources. */
368 if ((devc = sdi->priv) && devc->elapsed_msec) {
369 g_timer_destroy(devc->elapsed_msec);
370 devc->elapsed_msec = NULL;
873e0c12 371 devc->model = METRAHIT_NONE;
f5792417
MH
372 }
373
7b4edcb6
MH
374 return SR_OK;
375}
376
584560f1
BV
377static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
378 const struct sr_channel_group *cg)
7b4edcb6
MH
379{
380 int ret;
fadd0707 381 struct dev_context *devc;
c90beca7 382
53b4680f 383 (void)cg;
c90beca7 384
6392d599
MH
385 if (!sdi || !(devc = sdi->priv))
386 return SR_ERR_ARG;
387
7b4edcb6
MH
388 ret = SR_OK;
389 switch (key) {
6392d599
MH
390 case SR_CONF_LIMIT_SAMPLES:
391 *data = g_variant_new_uint64(devc->limit_samples);
392 break;
393 case SR_CONF_LIMIT_MSEC:
394 *data = g_variant_new_uint64(devc->limit_msec);
395 break;
c90beca7
MH
396 case SR_CONF_POWER_OFF:
397 *data = g_variant_new_boolean(FALSE);
398 break;
7b4edcb6
MH
399 default:
400 return SR_ERR_NA;
401 }
402
403 return ret;
404}
405
1a863916 406/** Implementation of config_list, auxiliary function for common parts. */
584560f1
BV
407static int config_list_common(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
408 const struct sr_channel_group *cg)
7b4edcb6 409{
c90beca7 410 (void)sdi;
53b4680f 411 (void)cg;
7b4edcb6 412
7b4edcb6 413 switch (key) {
c90beca7 414 case SR_CONF_SCAN_OPTIONS:
584560f1 415 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
5827f61b 416 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
f5792417 417 break;
7b4edcb6 418 default:
f5792417 419 return SR_ERR_NA;
7b4edcb6
MH
420 }
421
f5792417 422 return SR_OK;
7b4edcb6
MH
423}
424
c90beca7 425/** Implementation of config_list for Metrahit 1x/2x send mode */
584560f1 426static int config_list_sm(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
53b4680f 427 const struct sr_channel_group *cg)
7b4edcb6 428{
7b4edcb6 429 switch (key) {
c90beca7 430 case SR_CONF_DEVICE_OPTIONS:
584560f1 431 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
5827f61b 432 devopts_sm, ARRAY_SIZE(devopts_sm), sizeof(uint32_t));
f5792417 433 break;
c90beca7 434 default:
53b4680f 435 return config_list_common(key, data, sdi, cg);
c90beca7
MH
436 }
437
438 return SR_OK;
439}
440
441/** Implementation of config_list for Metrahit 2x bidirectional mode */
584560f1 442static int config_list_bd(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
53b4680f 443 const struct sr_channel_group *cg)
c90beca7 444{
c90beca7 445 switch (key) {
f5792417 446 case SR_CONF_DEVICE_OPTIONS:
584560f1 447 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
5827f61b 448 devopts_bd, ARRAY_SIZE(devopts_bd), sizeof(uint32_t));
f5792417 449 break;
7b4edcb6 450 default:
53b4680f 451 return config_list_common(key, data, sdi, cg);
7b4edcb6
MH
452 }
453
f5792417 454 return SR_OK;
7b4edcb6
MH
455}
456
695dc859 457static int dev_acquisition_start_1x_2x_rs232(const struct sr_dev_inst *sdi)
7b4edcb6 458{
f5792417
MH
459 struct dev_context *devc;
460 struct sr_serial_dev_inst *serial;
461
7b4edcb6
MH
462 if (sdi->status != SR_ST_ACTIVE)
463 return SR_ERR_DEV_CLOSED;
464
208c1d35 465 devc = sdi->priv;
f5792417
MH
466 devc->settings_ok = FALSE;
467 devc->buflen = 0;
468
695dc859 469 std_session_send_df_header(sdi, LOG_PREFIX);
f5792417
MH
470
471 /* Start timer, if required. */
472 if (devc->limit_msec)
473 g_timer_start(devc->elapsed_msec);
474
475 /* Poll every 40ms, or whenever some data comes in. */
476 serial = sdi->conn;
102f1239
BV
477 serial_source_add(sdi->session, serial, G_IO_IN, 40,
478 gmc_mh_1x_2x_receive_data, (void *)sdi);
7b4edcb6
MH
479
480 return SR_OK;
481}
482
695dc859 483static int dev_acquisition_start_2x_bd232(const struct sr_dev_inst *sdi)
c90beca7
MH
484{
485 struct dev_context *devc;
486 struct sr_serial_dev_inst *serial;
487
c90beca7
MH
488 if (sdi->status != SR_ST_ACTIVE)
489 return SR_ERR_DEV_CLOSED;
490
208c1d35 491 devc = sdi->priv;
c90beca7
MH
492 devc->settings_ok = FALSE;
493 devc->buflen = 0;
494
695dc859 495 std_session_send_df_header(sdi, LOG_PREFIX);
c90beca7
MH
496
497 /* Start timer, if required. */
498 if (devc->limit_msec)
499 g_timer_start(devc->elapsed_msec);
500
501 /* Poll every 40ms, or whenever some data comes in. */
502 serial = sdi->conn;
102f1239
BV
503 serial_source_add(sdi->session, serial, G_IO_IN, 40,
504 gmc_mh_2x_receive_data, (void *)sdi);
c90beca7
MH
505
506 /* Send start message */
507 return req_meas14(sdi);
508}
509
695dc859 510static int dev_acquisition_stop(struct sr_dev_inst *sdi)
7b4edcb6 511{
f5792417 512 struct dev_context *devc;
7b4edcb6 513
f5792417
MH
514 /* Stop timer, if required. */
515 if (sdi && (devc = sdi->priv) && devc->limit_msec)
516 g_timer_stop(devc->elapsed_msec);
7b4edcb6 517
6525d819 518 return std_serial_dev_acquisition_stop(sdi, dev_close,
f5792417 519 sdi->conn, LOG_PREFIX);
7b4edcb6
MH
520}
521
522SR_PRIV struct sr_dev_driver gmc_mh_1x_2x_rs232_driver_info = {
523 .name = "gmc-mh-1x-2x-rs232",
a90061e5 524 .longname = "Gossen Metrawatt Metrahit 1x/2x, RS232 interface",
7b4edcb6 525 .api_version = 1,
4f840ce9 526 .init = init,
700d6b64 527 .cleanup = std_cleanup,
c90beca7 528 .scan = scan_1x_2x_rs232,
4f840ce9 529 .dev_list = dev_list,
a6630742 530 .dev_clear = NULL,
c90beca7
MH
531 .config_get = config_get,
532 .config_set = config_set,
533 .config_list = config_list_sm,
534 .dev_open = std_serial_dev_open,
535 .dev_close = dev_close,
536 .dev_acquisition_start = dev_acquisition_start_1x_2x_rs232,
537 .dev_acquisition_stop = dev_acquisition_stop,
41812aca 538 .context = NULL,
c90beca7
MH
539};
540
541SR_PRIV struct sr_dev_driver gmc_mh_2x_bd232_driver_info = {
542 .name = "gmc-mh-2x-bd232",
a90061e5 543 .longname = "Gossen Metrawatt Metrahit 2x, BD232/SI232-II interface",
c90beca7 544 .api_version = 1,
4f840ce9 545 .init = init,
700d6b64 546 .cleanup = std_cleanup,
c90beca7 547 .scan = scan_2x_bd232,
4f840ce9 548 .dev_list = dev_list,
a6630742 549 .dev_clear = NULL,
7b4edcb6
MH
550 .config_get = config_get,
551 .config_set = config_set,
c90beca7 552 .config_list = config_list_bd,
854434de 553 .dev_open = std_serial_dev_open,
7b4edcb6 554 .dev_close = dev_close,
c90beca7 555 .dev_acquisition_start = dev_acquisition_start_2x_bd232,
27fd2eaa 556 .dev_acquisition_stop = dev_acquisition_stop,
41812aca 557 .context = NULL,
7b4edcb6 558};