scpi-pps: Add a missing "break" in config_get().
[libsigrok.git] / src / hardware / uni-t-dmm / api.c
1 /*
2  * This file is part of the libsigrok project.
3  *
4  * Copyright (C) 2012-2013 Uwe Hermann <uwe@hermann-uwe.de>
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 2 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
20 #include <config.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <libsigrok/libsigrok.h>
24 #include "libsigrok-internal.h"
25 #include "protocol.h"
26
27 static const uint32_t scanopts[] = {
28         SR_CONF_CONN,
29 };
30
31 static const uint32_t drvopts[] = {
32         SR_CONF_MULTIMETER,
33 };
34
35 static const uint32_t devopts[] = {
36         SR_CONF_CONTINUOUS,
37         SR_CONF_LIMIT_SAMPLES | SR_CONF_SET | SR_CONF_GET,
38         SR_CONF_LIMIT_MSEC | SR_CONF_SET | SR_CONF_GET,
39 };
40
41 /*
42  * Note 1: The actual baudrate of the Cyrustek ES519xx chip used in this DMM
43  * is 19230. However, the WCH CH9325 chip (UART to USB/HID) used in (some
44  * versions of) the UNI-T UT-D04 cable doesn't support 19230 baud. It only
45  * supports 19200, and setting an unsupported baudrate will result in the
46  * default of 2400 being used (which will not work with this DMM, of course).
47  */
48
49 static GSList *scan(struct sr_dev_driver *di, GSList *options)
50 {
51         GSList *usb_devices, *devices, *l;
52         struct sr_dev_inst *sdi;
53         struct dev_context *devc;
54         struct drv_context *drvc;
55         struct dmm_info *dmm;
56         struct sr_usb_dev_inst *usb;
57         struct sr_config *src;
58         const char *conn;
59
60         drvc = di->context;
61         dmm = (struct dmm_info *)di;
62
63         conn = NULL;
64         for (l = options; l; l = l->next) {
65                 src = l->data;
66                 switch (src->key) {
67                 case SR_CONF_CONN:
68                         conn = g_variant_get_string(src->data, NULL);
69                         break;
70                 }
71         }
72         if (!conn)
73                 return NULL;
74
75         devices = NULL;
76         if (!(usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) {
77                 g_slist_free_full(usb_devices, g_free);
78                 return NULL;
79         }
80
81         for (l = usb_devices; l; l = l->next) {
82                 usb = l->data;
83                 devc = g_malloc0(sizeof(struct dev_context));
84                 devc->first_run = TRUE;
85                 sdi = g_malloc0(sizeof(struct sr_dev_inst));
86                 sdi->status = SR_ST_INACTIVE;
87                 sdi->vendor = g_strdup(dmm->vendor);
88                 sdi->model = g_strdup(dmm->device);
89                 sdi->priv = devc;
90                 sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P1");
91                 sdi->inst_type = SR_INST_USB;
92                 sdi->conn = usb;
93                 devices = g_slist_append(devices, sdi);
94         }
95
96         return std_scan_complete(di, devices);
97 }
98
99 static int dev_open(struct sr_dev_inst *sdi)
100 {
101         struct sr_dev_driver *di;
102         struct drv_context *drvc;
103         struct sr_usb_dev_inst *usb;
104
105         di = sdi->driver;
106         drvc = di->context;
107         usb = sdi->conn;
108
109         return sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
110 }
111
112 static int config_set(uint32_t key, GVariant *data,
113         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
114 {
115         struct dev_context *devc;
116
117         (void)cg;
118
119         devc = sdi->priv;
120
121         return sr_sw_limits_config_set(&devc->limits, key, data);
122 }
123
124 static int config_list(uint32_t key, GVariant **data,
125         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
126 {
127         return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
128 }
129
130 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
131 {
132         struct dev_context *devc;
133
134         devc = sdi->priv;
135
136         sr_sw_limits_acquisition_start(&devc->limits);
137
138         std_session_send_df_header(sdi);
139
140         sr_session_source_add(sdi->session, -1, 0, 10,
141                         uni_t_dmm_receive_data, (void *)sdi);
142
143         return SR_OK;
144 }
145
146 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
147 {
148         std_session_send_df_end(sdi);
149         sr_session_source_remove(sdi->session, -1);
150
151         return SR_OK;
152 }
153
154 #define DMM(ID, CHIPSET, VENDOR, MODEL, BAUDRATE, PACKETSIZE, \
155                         VALID, PARSE, DETAILS) \
156         &((struct dmm_info) { \
157                 { \
158                         .name = ID, \
159                         .longname = VENDOR " " MODEL, \
160                         .api_version = 1, \
161                         .init = std_init, \
162                         .cleanup = std_cleanup, \
163                         .scan = scan, \
164                         .dev_list = std_dev_list, \
165                         .dev_clear = std_dev_clear, \
166                         .config_get = NULL, \
167                         .config_set = config_set, \
168                         .config_list = config_list, \
169                         .dev_open = dev_open, \
170                         .dev_close = std_dummy_dev_close /* TODO */, \
171                         .dev_acquisition_start = dev_acquisition_start, \
172                         .dev_acquisition_stop = dev_acquisition_stop, \
173                         .context = NULL, \
174                 }, \
175                 VENDOR, MODEL, BAUDRATE, PACKETSIZE, \
176                 VALID, PARSE, DETAILS, sizeof(struct CHIPSET##_info) \
177         }).di
178
179 SR_REGISTER_DEV_DRIVER_LIST(uni_t_dmm_drivers,
180         DMM(
181                 "tecpel-dmm-8061", fs9721,
182                 "Tecpel", "DMM-8061", 2400,
183                 FS9721_PACKET_SIZE,
184                 sr_fs9721_packet_valid, sr_fs9721_parse,
185                 sr_fs9721_00_temp_c
186         ),
187         DMM(
188                 "uni-t-ut372", ut372,
189                 "UNI-T", "UT372", 2400,
190                 UT372_PACKET_SIZE,
191                 sr_ut372_packet_valid, sr_ut372_parse,
192                 NULL
193         ),
194         DMM(
195                 "uni-t-ut60a", fs9721,
196                 "UNI-T", "UT60A", 2400,
197                 FS9721_PACKET_SIZE,
198                 sr_fs9721_packet_valid, sr_fs9721_parse,
199                 NULL
200         ),
201         DMM(
202                 "uni-t-ut60e", fs9721,
203                 "UNI-T", "UT60E", 2400,
204                 FS9721_PACKET_SIZE,
205                 sr_fs9721_packet_valid, sr_fs9721_parse,
206                 sr_fs9721_00_temp_c
207         ),
208         DMM(
209                 "uni-t-ut60g", es519xx,
210                 /* The baudrate is actually 19230, see "Note 1" below. */
211                 "UNI-T", "UT60G", 19200,
212                 ES519XX_11B_PACKET_SIZE,
213                 sr_es519xx_19200_11b_packet_valid, sr_es519xx_19200_11b_parse,
214                 NULL
215         ),
216         DMM(
217                 "uni-t-ut61b", fs9922,
218                 "UNI-T", "UT61B", 2400,
219                 FS9922_PACKET_SIZE,
220                 sr_fs9922_packet_valid, sr_fs9922_parse,
221                 NULL
222         ),
223         DMM(
224                 "uni-t-ut61c", fs9922,
225                 "UNI-T", "UT61C", 2400,
226                 FS9922_PACKET_SIZE,
227                 sr_fs9922_packet_valid, sr_fs9922_parse,
228                 NULL
229         ),
230         DMM(
231                 "uni-t-ut61d", fs9922,
232                 "UNI-T", "UT61D", 2400,
233                 FS9922_PACKET_SIZE,
234                 sr_fs9922_packet_valid, sr_fs9922_parse,
235                 NULL
236         ),
237         DMM(
238                 "uni-t-ut61e", es519xx,
239                 /* The baudrate is actually 19230, see "Note 1" below. */
240                 "UNI-T", "UT61E", 19200,
241                 ES519XX_14B_PACKET_SIZE,
242                 sr_es519xx_19200_14b_packet_valid, sr_es519xx_19200_14b_parse,
243                 NULL
244         ),
245         DMM(
246                 "uni-t-ut71a", ut71x,
247                 "UNI-T", "UT71A", 2400, UT71X_PACKET_SIZE,
248                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
249         ),
250         DMM(
251                 "uni-t-ut71b", ut71x,
252                 "UNI-T", "UT71B", 2400, UT71X_PACKET_SIZE,
253                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
254         ),
255         DMM(
256                 "uni-t-ut71c", ut71x,
257                 "UNI-T", "UT71C", 2400, UT71X_PACKET_SIZE,
258                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
259         ),
260         DMM(
261                 "uni-t-ut71d", ut71x,
262                 "UNI-T", "UT71D", 2400, UT71X_PACKET_SIZE,
263                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
264         ),
265         DMM(
266                 "uni-t-ut71e", ut71x,
267                 "UNI-T", "UT71E", 2400, UT71X_PACKET_SIZE,
268                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
269         ),
270         DMM(
271                 "voltcraft-vc820", fs9721,
272                 "Voltcraft", "VC-820", 2400,
273                 FS9721_PACKET_SIZE,
274                 sr_fs9721_packet_valid, sr_fs9721_parse,
275                 NULL
276         ),
277         DMM(
278                 "voltcraft-vc830", fs9922,
279                 /*
280                  * Note: The VC830 doesn't set the 'volt' and 'diode' bits of
281                  * the FS9922 protocol. Instead, it only sets the user-defined
282                  * bit "z1" to indicate "diode mode" and "voltage".
283                  */
284                 "Voltcraft", "VC-830", 2400,
285                 FS9922_PACKET_SIZE,
286                 sr_fs9922_packet_valid, sr_fs9922_parse,
287                 &sr_fs9922_z1_diode
288         ),
289         DMM(
290                 "voltcraft-vc840", fs9721,
291                 "Voltcraft", "VC-840", 2400,
292                 FS9721_PACKET_SIZE,
293                 sr_fs9721_packet_valid, sr_fs9721_parse,
294                 sr_fs9721_00_temp_c
295         ),
296         DMM(
297                 "voltcraft-vc870", vc870,
298                 "Voltcraft", "VC-870", 9600, VC870_PACKET_SIZE,
299                 sr_vc870_packet_valid, sr_vc870_parse, NULL
300         ),
301         DMM(
302                 "voltcraft-vc920", ut71x,
303                 "Voltcraft", "VC-920", 2400, UT71X_PACKET_SIZE,
304                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
305         ),
306         DMM(
307                 "voltcraft-vc940", ut71x,
308                 "Voltcraft", "VC-940", 2400, UT71X_PACKET_SIZE,
309                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
310         ),
311         DMM(
312                 "voltcraft-vc960", ut71x,
313                 "Voltcraft", "VC-960", 2400, UT71X_PACKET_SIZE,
314                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
315         ),
316         DMM(
317                 "tenma-72-7730", ut71x,
318                 "Tenma", "72-7730", 2400,
319                 UT71X_PACKET_SIZE,
320                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
321         ),
322         DMM(
323                 "tenma-72-7732", ut71x,
324                 "Tenma", "72-7732", 2400,
325                 UT71X_PACKET_SIZE,
326                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
327         ),
328         DMM(
329                 "tenma-72-9380a", ut71x,
330                 "Tenma", "72-9380A", 2400,
331                 UT71X_PACKET_SIZE,
332                 sr_ut71x_packet_valid, sr_ut71x_parse, NULL
333         ),
334         DMM(
335                 "tenma-72-7745", fs9721,
336                 "Tenma", "72-7745", 2400,
337                 FS9721_PACKET_SIZE,
338                 sr_fs9721_packet_valid, sr_fs9721_parse,
339                 sr_fs9721_00_temp_c
340         ),
341         DMM(
342                 "tenma-72-7750", es519xx,
343                 /* The baudrate is actually 19230, see "Note 1" below. */
344                 "Tenma", "72-7750", 19200,
345                 ES519XX_11B_PACKET_SIZE,
346                 sr_es519xx_19200_11b_packet_valid, sr_es519xx_19200_11b_parse,
347                 NULL
348         ),
349 );