diff --git a/hardware/agilent-dmm/Makefile.am b/hardware/agilent-dmm/Makefile.am index ca1a7762..9bdf3bb4 100644 --- a/hardware/agilent-dmm/Makefile.am +++ b/hardware/agilent-dmm/Makefile.am @@ -23,7 +23,9 @@ if HW_AGILENT_DMM noinst_LTLIBRARIES = libsigrokhwagilentdmm.la libsigrokhwagilentdmm_la_SOURCES = \ - api.c + api.c \ + agilentdmm.h \ + sched.c libsigrokhwagilentdmm_la_CFLAGS = \ -I$(top_srcdir) diff --git a/hardware/agilent-dmm/agilent-dmm.h b/hardware/agilent-dmm/agilent-dmm.h new file mode 100644 index 00000000..9af01f3e --- /dev/null +++ b/hardware/agilent-dmm/agilent-dmm.h @@ -0,0 +1,79 @@ +/* + * This file is part of the sigrok project. + * + * Copyright (C) 2012 Bert Vermeulen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + + +#ifndef LIBSIGROK_AGILENT_DMM_H +#define LIBSIGROK_AGILENT_DMM_H + +#define AGDMM_BUFSIZE 256 + +/* Supported models */ +enum { + AGILENT_U1232A = 1, +}; + +/* Supported device profiles */ +struct agdmm_profile { + int model; + const char *modelname; + int serial_speed; + const struct agdmm_job *jobs; + const struct agdmm_recv *recvs; +}; + +/* Private driver context. */ +struct drv_context { + GSList *instances; +}; + +/* Private, per-device-instance driver context. */ +struct dev_context { + const struct agdmm_profile *profile; + uint64_t limit_samples; + uint64_t limit_msec; + struct sr_serial_dev_inst *serial; + + /* Opaque pointer passed in by the frontend. */ + void *cb_data; + + /* Runtime. */ + uint64_t num_samples; + int64_t jobqueue[8]; + unsigned char buf[AGDMM_BUFSIZE]; + int buflen; + int cur_mq; + int cur_mq_unit; + int cur_mq_flags; + int cur_divider; + int cur_acdc; +}; + +struct agdmm_job { + int interval; + int (*send) (const struct sr_dev_inst *sdi); +}; + +struct agdmm_recv { + const char *recv_regex; + int (*recv) (const struct sr_dev_inst *sdi, GMatchInfo *match); +}; + +SR_PRIV int agdmm_receive_data(int fd, int revents, void *cb_data); + +#endif /* LIBSIGROK_AGILENT_DMM_H */ diff --git a/hardware/agilent-dmm/api.c b/hardware/agilent-dmm/api.c index e69de29b..a2aab654 100644 --- a/hardware/agilent-dmm/api.c +++ b/hardware/agilent-dmm/api.c @@ -0,0 +1,440 @@ +/* + * This file is part of the sigrok project. + * + * Copyright (C) 2012 Bert Vermeulen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include "libsigrok.h" +#include "libsigrok-internal.h" +#include "config.h" +#include "agilent-dmm.h" +#include +#include +#include +#include +#include + +static const int hwopts[] = { + SR_HWOPT_CONN, + SR_HWOPT_SERIALCOMM, + 0, +}; + +static const int hwcaps[] = { + SR_HWCAP_MULTIMETER, + SR_HWCAP_LIMIT_SAMPLES, + SR_HWCAP_LIMIT_MSEC, + SR_HWCAP_CONTINUOUS, + 0, +}; + +static const char *probe_names[] = { + "Probe", + NULL, +}; + +extern const struct agdmm_job u123x_jobs[]; +extern const struct agdmm_recv u123x_recvs[]; + +static const struct agdmm_profile supported_agdmm[] = { + { AGILENT_U1232A, "U1232A", 9600, u123x_jobs, u123x_recvs }, + { 0, NULL, 0, NULL, NULL } +}; + +SR_PRIV struct sr_dev_driver agdmm_driver_info; +static struct sr_dev_driver *di = &agdmm_driver_info; + +/* Properly close and free all devices. */ +static int clear_instances(void) +{ + struct sr_dev_inst *sdi; + struct drv_context *drvc; + struct dev_context *devc; + GSList *l; + + if (!(drvc = di->priv)) + return SR_OK; + + drvc = di->priv; + for (l = drvc->instances; l; l = l->next) { + if (!(sdi = l->data)) + continue; + if (!(devc = sdi->priv)) + continue; + sr_serial_dev_inst_free(devc->serial); + sr_dev_inst_free(sdi); + } + g_slist_free(drvc->instances); + drvc->instances = NULL; + + return SR_OK; +} + +static int hw_init(void) +{ + struct drv_context *drvc; + + if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) { + sr_err("agilent-dmm: driver context malloc failed."); + return SR_ERR; + } + + di->priv = drvc; + + return SR_OK; +} + +static int serial_readline(int fd, char **buf, int *buflen, uint64_t timeout_ms) +{ + uint64_t start; + int maxlen, len; + + timeout_ms *= 1000; + start = g_get_monotonic_time(); + + maxlen = *buflen; + *buflen = len = 0; + while(1) { + len = maxlen - *buflen - 1; + if (len < 1) + break; + len = serial_read(fd, *buf + *buflen, len); + if (len > 0) { + *buflen += len; + *(*buf + *buflen) = '\0'; + if (*buflen > 0 && *(*buf + *buflen - 1) == '\n') + /* End of line */ + break; + } + if (g_get_monotonic_time() - start > timeout_ms) + /* Timeout */ + break; + g_usleep(2000); + } + + /* Strip CRLF */ + while (*buflen) { + if (*(*buf + *buflen - 1) == '\r' || *(*buf + *buflen - 1) == '\n') + *(*buf + --*buflen) = '\0'; + else + break; + } + if (*buflen) + sr_dbg("agilent-dmm: received '%s'", *buf); + + return SR_OK; +} + +static GSList *hw_scan(GSList *options) +{ + struct sr_dev_inst *sdi; + struct drv_context *drvc; + struct dev_context *devc; + struct sr_hwopt *opt; + struct sr_probe *probe; + GSList *l, *devices; + int len, fd, i; + const char *conn, *serialcomm; + char *buf, **tokens; + + drvc = di->priv; + drvc->instances = NULL; + + devices = NULL; + conn = serialcomm = NULL; + for (l = options; l; l = l->next) { + opt = l->data; + switch (opt->hwopt) { + case SR_HWOPT_CONN: + conn = opt->value; + break; + case SR_HWOPT_SERIALCOMM: + serialcomm = opt->value; + break; + } + } + if (!conn) { + sr_dbg("no serial port provided"); + return NULL; + } + if (!serialcomm) { + sr_dbg("no serial communication parameters provided"); + return NULL; + } + + if ((fd = serial_open(conn, O_RDWR|O_NONBLOCK)) == -1) { + sr_err("agilent-dmm: unable to open %s: %s", conn, strerror(errno)); + return NULL; + } + + if (serial_set_paramstr(fd, serialcomm) != SR_OK) { + sr_err("agilent-dmm: unable to set serial parameters: %s", + strerror(errno)); + return NULL; + } + + serial_flush(fd); + if (serial_write(fd, "*IDN?\r\n", 7) == -1) { + sr_err("agilent-dmm: unable to send identification string: %s", + strerror(errno)); + return NULL; + } + + len = 128; + buf = g_try_malloc(len); + serial_readline(fd, &buf, &len, 150); + if (!len) + return NULL; + + tokens = g_strsplit(buf, ",", 4); + if (!strcmp("Agilent Technologies", tokens[0]) + && tokens[2] && tokens[3]) { + for (i = 0; supported_agdmm[i].model; i++) { + if (strcmp(supported_agdmm[i].modelname, tokens[1])) + continue; + if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, tokens[0], + tokens[1], tokens[3]))) + return NULL; + if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { + sr_dbg("agilent-dmm: failed to malloc devc"); + return NULL; + } + devc->profile = &supported_agdmm[i]; + devc->serial = sr_serial_dev_inst_new(conn, -1); + devc->cur_mq = -1; + sdi->priv = devc; + sdi->driver = di; + if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1"))) + return NULL; + sdi->probes = g_slist_append(sdi->probes, probe); + drvc->instances = g_slist_append(drvc->instances, sdi); + devices = g_slist_append(devices, sdi); + break; + } + } + g_strfreev(tokens); + g_free(buf); + + serial_close(fd); + + return devices; +} + +static GSList *hw_dev_list(void) +{ + struct drv_context *drvc; + + drvc = di->priv; + + return drvc->instances; +} + +static int hw_dev_open(struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + + if (!(devc = sdi->priv)) { + sr_err("agilent-dmm: sdi->priv was NULL."); + return SR_ERR_BUG; + } + + devc->serial->fd = serial_open(devc->serial->port, O_RDWR | O_NONBLOCK); + if (devc->serial->fd == -1) { + sr_err("agilent-dmm: Couldn't open serial port '%s'.", + devc->serial->port); + return SR_ERR; + } + serial_set_params(devc->serial->fd, devc->profile->serial_speed, 8, + SERIAL_PARITY_NONE, 1, 0); + sdi->status = SR_ST_ACTIVE; + + return SR_OK; +} + +static int hw_dev_close(struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + + if (!(devc = sdi->priv)) { + sr_err("agilent-dmm: sdi->priv was NULL."); + return SR_ERR_BUG; + } + + if (devc->serial && devc->serial->fd != -1) { + serial_close(devc->serial->fd); + devc->serial->fd = -1; + sdi->status = SR_ST_INACTIVE; + } + + return SR_OK; +} + +static int hw_cleanup(void) +{ + + clear_instances(); + + return SR_OK; +} + +static int hw_info_get(int info_id, const void **data, + const struct sr_dev_inst *sdi) +{ + + (void)sdi; + + switch (info_id) { + case SR_DI_HWOPTS: + *data = hwopts; + break; + case SR_DI_HWCAPS: + *data = hwcaps; + break; + case SR_DI_NUM_PROBES: + *data = GINT_TO_POINTER(1); + break; + case SR_DI_PROBE_NAMES: + *data = probe_names; + break; + default: + return SR_ERR_ARG; + } + + return SR_OK; +} + +static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap, + const void *value) +{ + struct dev_context *devc; + + if (sdi->status != SR_ST_ACTIVE) + return SR_ERR; + + if (!(devc = sdi->priv)) { + sr_err("agilent-dmm: sdi->priv was NULL."); + return SR_ERR_BUG; + } + + switch (hwcap) { + case SR_HWCAP_LIMIT_MSEC: + /* TODO: not yet implemented */ + if (*(const uint64_t *)value == 0) { + sr_err("agilent-dmm: LIMIT_MSEC can't be 0."); + return SR_ERR; + } + devc->limit_msec = *(const uint64_t *)value; + sr_dbg("agilent-dmm: Setting time limit to %" PRIu64 "ms.", + devc->limit_msec); + break; + case SR_HWCAP_LIMIT_SAMPLES: + devc->limit_samples = *(const uint64_t *)value; + sr_dbg("agilent-dmm: Setting sample limit to %" PRIu64 ".", + devc->limit_samples); + break; + default: + sr_err("agilent-dmm: Unknown capability: %d.", hwcap); + return SR_ERR; + break; + } + + return SR_OK; +} + +static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi, + void *cb_data) +{ + struct sr_datafeed_packet packet; + struct sr_datafeed_header header; + struct sr_datafeed_meta_analog meta; + struct dev_context *devc; + + if (!(devc = sdi->priv)) { + sr_err("agilent-dmm: sdi->priv was NULL."); + return SR_ERR_BUG; + } + + sr_dbg("agilent-dmm: Starting acquisition."); + + devc->cb_data = cb_data; + + /* Send header packet to the session bus. */ + sr_dbg("agilent-dmm: Sending SR_DF_HEADER."); + packet.type = SR_DF_HEADER; + packet.payload = (uint8_t *)&header; + header.feed_version = 1; + gettimeofday(&header.starttime, NULL); + sr_session_send(devc->cb_data, &packet); + + /* Send metadata about the SR_DF_ANALOG packets to come. */ + sr_dbg("agilent-dmm: Sending SR_DF_META_ANALOG."); + packet.type = SR_DF_META_ANALOG; + packet.payload = &meta; + meta.num_probes = 1; + sr_session_send(devc->cb_data, &packet); + + /* Poll every 100ms, or whenever some data comes in. */ + sr_source_add(devc->serial->fd, G_IO_IN, 100, agdmm_receive_data, (void *)sdi); + + return SR_OK; +} + +static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi, + void *cb_data) +{ + struct sr_datafeed_packet packet; + struct dev_context *devc; + + if (sdi->status != SR_ST_ACTIVE) + return SR_ERR; + + if (!(devc = sdi->priv)) { + sr_err("agilent-dmm: sdi->priv was NULL."); + return SR_ERR_BUG; + } + + sr_dbg("agilent-dmm: Stopping acquisition."); + + sr_source_remove(devc->serial->fd); + hw_dev_close((struct sr_dev_inst *)sdi); + + /* Send end packet to the session bus. */ + sr_dbg("agilent-dmm: Sending SR_DF_END."); + packet.type = SR_DF_END; + sr_session_send(cb_data, &packet); + + + return SR_OK; +} + +SR_PRIV struct sr_dev_driver agdmm_driver_info = { + .name = "agilent-dmm", + .longname = "Agilent U12xx series DMMs", + .api_version = 1, + .init = hw_init, + .cleanup = hw_cleanup, + .scan = hw_scan, + .dev_list = hw_dev_list, + .dev_clear = clear_instances, + .dev_open = hw_dev_open, + .dev_close = hw_dev_close, + .info_get = hw_info_get, + .dev_config_set = hw_dev_config_set, + .dev_acquisition_start = hw_dev_acquisition_start, + .dev_acquisition_stop = hw_dev_acquisition_stop, + .priv = NULL, +}; diff --git a/hardware/agilent-dmm/sched.c b/hardware/agilent-dmm/sched.c new file mode 100644 index 00000000..582ad28d --- /dev/null +++ b/hardware/agilent-dmm/sched.c @@ -0,0 +1,335 @@ +/* + * This file is part of the sigrok project. + * + * Copyright (C) 2012 Bert Vermeulen + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include "libsigrok.h" +#include "libsigrok-internal.h" +#include "config.h" +#include "agilent-dmm.h" +#include +#include +#include +#include + + +static void dispatch(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + const struct agdmm_job *jobs; + int64_t now; + int i; + + devc = sdi->priv; + jobs = devc->profile->jobs; + now = g_get_monotonic_time() / 1000; + for (i = 0; (&jobs[i])->interval; i++) { + if (now - devc->jobqueue[i] > (&jobs[i])->interval) { + sr_spew("agilent-dmm: running job %d", i); + (&jobs[i])->send(sdi); + devc->jobqueue[i] = now; + } + } + +} + +static void receive_line(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + const struct agdmm_recv *recvs, *recv; + GRegex *reg; + GMatchInfo *match; + int i; + + devc = sdi->priv; + + /* Strip CRLF */ + while (devc->buflen) { + if (*(devc->buf + devc->buflen - 1) == '\r' + || *(devc->buf + devc->buflen - 1) == '\n') + *(devc->buf + --devc->buflen) = '\0'; + else + break; + } + sr_spew("agilent-dmm: received '%s'", devc->buf); + + recv = NULL; + recvs = devc->profile->recvs; + for (i = 0; (&recvs[i])->recv_regex; i++) { + reg = g_regex_new((&recvs[i])->recv_regex, 0, 0, NULL); + if (g_regex_match(reg, (char *)devc->buf, 0, &match)) { + recv = &recvs[i]; + break; + } + g_match_info_unref(match); + g_regex_unref(reg); + } + if (recv) { + recv->recv(sdi, match); + g_match_info_unref(match); + g_regex_unref(reg); + } + + /* Done with this. */ + devc->buflen = 0; + +} + +SR_PRIV int agdmm_receive_data(int fd, int revents, void *cb_data) +{ + const struct sr_dev_inst *sdi; + struct dev_context *devc; + int len; + + if (!(sdi = cb_data)) + return TRUE; + + if (!(devc = sdi->priv)) + return TRUE; + + if (revents == G_IO_IN) { + /* Serial data arrived. */ + len = AGDMM_BUFSIZE - devc->buflen - 1; + if (len > 0) { + len = serial_read(fd, devc->buf + devc->buflen, len); + if (len > 0) { + devc->buflen += len; + *(devc->buf + devc->buflen) = '\0'; + if (devc->buflen > 0 && *(devc->buf + devc->buflen - 1) == '\n') + /* End of line */ + receive_line(sdi); + } + } + } + + dispatch(sdi); + + if (devc->num_samples >= devc->limit_samples) + sdi->driver->dev_acquisition_stop(sdi, cb_data); + + return TRUE; +} + +static int agdmm_send(const struct sr_dev_inst *sdi, const char *cmd) +{ + struct dev_context *devc; + char buf[32]; + + devc = sdi->priv; + sr_spew("agilent-dmm: sending '%s'", cmd); + strncpy(buf, cmd, 28); + if (!strncmp(buf, "*IDN?", 5)) + strncat(buf, "\r\n", 32); + else + strncat(buf, "\n\r\n", 32); + if (serial_write(devc->serial->fd, buf, strlen(buf)) == -1) { + sr_err("agilent-dmm: failed to send: %s", strerror(errno)); + return SR_ERR; + } + + return SR_OK; +} + +static int agdmm_ident_send(const struct sr_dev_inst *sdi) +{ + + return agdmm_send(sdi, "*IDN?"); +} + +static int agdmm_ident_recv(const struct sr_dev_inst *sdi, GMatchInfo *match) +{ + + (void)sdi; + + sr_spew("got ident '%s'", g_match_info_get_string(match)); + + return SR_OK; +} + +static int agdmm_stat_send(const struct sr_dev_inst *sdi) +{ + + return agdmm_send(sdi, "STAT?"); +} + +static int agdmm_stat_recv(const struct sr_dev_inst *sdi, GMatchInfo *match) +{ + + sr_spew("got stat '%s'", g_match_info_get_string(match)); + + return SR_OK; +} + +SR_PRIV int agdmm_fetc_send(const struct sr_dev_inst *sdi) +{ + + return agdmm_send(sdi, "FETC?"); +} + +SR_PRIV int agdmm_fetc_recv(const struct sr_dev_inst *sdi, GMatchInfo *match) +{ + struct dev_context *devc; + struct sr_datafeed_packet packet; + struct sr_datafeed_analog analog; + float fvalue; + char *mstr, *eptr; + + sr_spew("agilent-dmm: FETC reply '%s'", g_match_info_get_string(match)); + devc = sdi->priv; + + if (devc->cur_mq == -1) + /* Haven't seen configuration yet, so can't know what + * the fetched float means. Not really an error, we'll + * get metadata soon enough. */ + return SR_OK; + + if (!strcmp(g_match_info_get_string(match), "+9.90000000E+37")) { + /* An invalid measurement shows up on the display as "O.L, but + * comes through like this. Since comparing 38-digit floats + * is rather problematic, we'll cut through this here. */ + fvalue = NAN; + } else { + mstr = g_match_info_fetch(match, 1); + fvalue = strtof(mstr, &eptr); + g_free(mstr); + if (fvalue == 0.0 && eptr == mstr) { + sr_err("agilent-dmm: invalid float"); + return SR_ERR; + } + if (devc->cur_divider > 0) + fvalue /= devc->cur_divider; + } + + memset(&analog, 0, sizeof(struct sr_datafeed_analog)); + analog.mq = devc->cur_mq; + analog.unit = devc->cur_mq_unit; + analog.mqflags = devc->cur_mq_flags; + analog.num_samples = 1; + analog.data = &fvalue; + packet.type = SR_DF_ANALOG; + packet.payload = &analog; + sr_session_send(devc->cb_data, &packet); + + devc->num_samples++; + + return SR_OK; +} + +SR_PRIV int agdmm_conf_send(const struct sr_dev_inst *sdi) +{ + + return agdmm_send(sdi, "CONF?"); +} + +SR_PRIV int agdmm_conf_recv(const struct sr_dev_inst *sdi, GMatchInfo *match) +{ + struct dev_context *devc; + char *mstr; + + sr_spew("got conf '%s'", g_match_info_get_string(match)); + devc = sdi->priv; + mstr = g_match_info_fetch(match, 1); + if (!strcmp(mstr, "V")) { + devc->cur_mq = SR_MQ_VOLTAGE; + devc->cur_mq_unit = SR_UNIT_VOLT; + devc->cur_mq_flags = 0; + devc->cur_divider = 0; + } else if(!strcmp(mstr, "MV")) { + devc->cur_mq = SR_MQ_VOLTAGE; + devc->cur_mq_unit = SR_UNIT_VOLT; + devc->cur_mq_flags = 0; + devc->cur_divider = 1000; + } else if(!strcmp(mstr, "A")) { + devc->cur_mq = SR_MQ_CURRENT; + devc->cur_mq_unit = SR_UNIT_AMPERE; + devc->cur_mq_flags = 0; + devc->cur_divider = 0; + } else if(!strcmp(mstr, "UA")) { + devc->cur_mq = SR_MQ_CURRENT; + devc->cur_mq_unit = SR_UNIT_AMPERE; + devc->cur_mq_flags = 0; + devc->cur_divider = 1000000; + } else if(!strcmp(mstr, "FREQ")) { + devc->cur_mq = SR_MQ_FREQUENCY; + devc->cur_mq_unit = SR_UNIT_HERTZ; + devc->cur_mq_flags = 0; + devc->cur_divider = 0; + } else if(!strcmp(mstr, "RES")) { + devc->cur_mq = SR_MQ_RESISTANCE; + devc->cur_mq_unit = SR_UNIT_OHM; + devc->cur_mq_flags = 0; + devc->cur_divider = 0; + } else if(!strcmp(mstr, "CAP")) { + devc->cur_mq = SR_MQ_CAPACITANCE; + devc->cur_mq_unit = SR_UNIT_FARAD; + devc->cur_mq_flags = 0; + devc->cur_divider = 0; + } else if(!strcmp(mstr, "DIOD")) { + devc->cur_mq = SR_MQ_VOLTAGE; + devc->cur_mq_unit = SR_UNIT_VOLT; + devc->cur_mq_flags = SR_MQFLAG_DIODE; + devc->cur_divider = 0; + } else + sr_dbg("agilent-dmm: unknown first argument"); + g_free(mstr); + + if (g_match_info_get_match_count(match) == 3) { + mstr = g_match_info_fetch(match, 1); + /* Third value, if present, is always AC or DC. */ + if (!strcmp(mstr, "AC")) + devc->cur_acdc = 1; + else if (!strcmp(mstr, "DC")) + devc->cur_acdc = 2; + else + sr_dbg("agilent-dmm: unknown third argument"); + g_free(mstr); + } + + return SR_OK; +} + +SR_PRIV int agdmm_switch_recv(const struct sr_dev_inst *sdi, GMatchInfo *match) +{ + + (void)sdi; + + sr_spew("got switch '%s'", g_match_info_get_string(match)); + + return SR_OK; +} + + +SR_PRIV const struct agdmm_job u123x_jobs[] = { + { 1000, agdmm_ident_send }, + { 143, agdmm_stat_send }, + { 1000, agdmm_conf_send }, + { 143, agdmm_fetc_send }, + { 0, NULL } +}; + +SR_PRIV const struct agdmm_recv u123x_recvs[] = { + { "^\"(\\d\\d.{18}\\d)\"$", agdmm_stat_recv }, + { "^\\*([0-9])$", agdmm_switch_recv }, + { "^([-+][0-9]\\.[0-9]{8}E[-+][0-9]{2})$", agdmm_fetc_recv }, + { "^\"(V|MV|A|UA|FREQ),(\\d),(AC|DC)\"$", agdmm_conf_recv }, + { "^\"(RES|CAP),(\\d)\"$", agdmm_conf_recv }, + { "^\"(DIOD)\"$", agdmm_conf_recv }, + { NULL, NULL } +}; + + diff --git a/hwdriver.c b/hwdriver.c index 545fc533..e466575b 100644 --- a/hwdriver.c +++ b/hwdriver.c @@ -83,6 +83,9 @@ extern SR_PRIV struct sr_dev_driver hantek_dso_driver_info; #ifdef HAVE_HW_GENERICDMM extern SR_PRIV struct sr_dev_driver genericdmm_driver_info; #endif +#ifdef HAVE_HW_AGILENT_DMM +extern SR_PRIV struct sr_dev_driver agdmm_driver_info; +#endif static struct sr_dev_driver *drivers_list[] = { #ifdef HAVE_LA_DEMO @@ -114,6 +117,9 @@ static struct sr_dev_driver *drivers_list[] = { #endif #ifdef HAVE_HW_GENERICDMM &genericdmm_driver_info, +#endif +#ifdef HAVE_HW_AGILENT_DMM + &agdmm_driver_info, #endif NULL, };