From: Uwe Hermann Date: Thu, 27 Aug 2015 20:06:26 +0000 (+0200) Subject: kern-scale: Add initial driver contents. X-Git-Tag: libsigrok-0.4.0~382 X-Git-Url: https://sigrok.org/gitaction?a=commitdiff_plain;h=607dcdeae13d04fd5c6d41da46d9c29a04206a86;p=libsigrok.git kern-scale: Add initial driver contents. This currently supports (and is tested on) the KERN EW 6200-2NM, other models will be added later. --- diff --git a/configure.ac b/configure.ac index b5980dbb..47a68349 100644 --- a/configure.ac +++ b/configure.ac @@ -205,7 +205,7 @@ SR_DRIVER([Hantek DSO], [hantek-dso], [libusb]) SR_DRIVER([Ikalogic Scanalogic-2], [ikalogic-scanalogic2], [libusb]) SR_DRIVER([Ikalogic Scanaplus], [ikalogic-scanaplus], [libftdi]) SR_DRIVER([Kecheng KC-330B], [kecheng-kc-330b], [libusb]) -SR_DRIVER([KERN Scale], [kern-scale]) +SR_DRIVER([KERN scale], [kern-scale]) SR_DRIVER([Lascar EL-USB], [lascar-el-usb], [libusb]) SR_DRIVER([Manson HCS-3xxx], [manson-hcs-3xxx], [libserialport]) SR_DRIVER([maynuo-m97], [maynuo-m97]) diff --git a/src/drivers.c b/src/drivers.c index aeb36f86..0dd6f26c 100644 --- a/src/drivers.c +++ b/src/drivers.c @@ -93,7 +93,7 @@ extern SR_PRIV struct sr_dev_driver ikalogic_scanaplus_driver_info; extern SR_PRIV struct sr_dev_driver kecheng_kc_330b_driver_info; #endif #ifdef HAVE_HW_KERN_SCALE -extern SR_PRIV struct sr_dev_driver kern_scale_driver_info; +extern SR_PRIV struct sr_dev_driver *kern_scale_drivers[]; #endif #ifdef HAVE_HW_LASCAR_EL_USB extern SR_PRIV struct sr_dev_driver lascar_el_usb_driver_info; @@ -245,7 +245,7 @@ SR_PRIV struct sr_dev_driver **drivers_lists[] = { (DRVS) {&kecheng_kc_330b_driver_info, NULL}, #endif #ifdef HAVE_HW_KERN_SCALE - (DRVS) {&kern_scale_driver_info, NULL}, + kern_scale_drivers, #endif #ifdef HAVE_HW_LASCAR_EL_USB (DRVS) {&lascar_el_usb_driver_info, NULL}, diff --git a/src/hardware/kern-scale/api.c b/src/hardware/kern-scale/api.c index 2d68fcf6..b0e4feef 100644 --- a/src/hardware/kern-scale/api.c +++ b/src/hardware/kern-scale/api.c @@ -18,9 +18,27 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#include +#include +#include "libsigrok-internal.h" #include "protocol.h" -SR_PRIV struct sr_dev_driver kern_scale_driver_info; +static const uint32_t scanopts[] = { + SR_CONF_CONN, + SR_CONF_SERIALCOMM, +}; + +static const uint32_t devopts[] = { + SR_CONF_SCALE, + SR_CONF_CONTINUOUS, + SR_CONF_LIMIT_SAMPLES | SR_CONF_SET, + SR_CONF_LIMIT_MSEC | SR_CONF_SET, +}; + +static int dev_clear(const struct sr_dev_driver *di) +{ + return std_dev_clear(di, NULL); +} static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx) { @@ -29,145 +47,220 @@ static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx) static GSList *scan(struct sr_dev_driver *di, GSList *options) { + struct scale_info *scale; + struct sr_config *src; + GSList *l, *devices; + const char *conn, *serialcomm; + struct sr_dev_inst *sdi; struct drv_context *drvc; - GSList *devices; + struct dev_context *devc; + struct sr_serial_dev_inst *serial; + int ret; + size_t len; + uint8_t buf[128]; + + scale = (struct scale_info *)di; + + conn = serialcomm = NULL; + for (l = options; l; l = l->next) { + src = l->data; + switch (src->key) { + case SR_CONF_CONN: + conn = g_variant_get_string(src->data, NULL); + break; + case SR_CONF_SERIALCOMM: + serialcomm = g_variant_get_string(src->data, NULL); + break; + } + } + if (!conn) + return NULL; - (void)options; + if (!serialcomm) + serialcomm = scale->conn; - devices = NULL; - drvc = di->context; - drvc->instances = NULL; + serial = sr_serial_dev_inst_new(conn, serialcomm); - return devices; -} + if (serial_open(serial, SERIAL_RDWR) != SR_OK) + return NULL; -static GSList *dev_list(const struct sr_dev_driver *di) -{ - return ((struct drv_context *)(di->context))->instances; -} + sr_info("Probing serial port %s.", conn); -static int dev_clear(const struct sr_dev_driver *di) -{ - return std_dev_clear(di, NULL); -} - -static int dev_open(struct sr_dev_inst *sdi) -{ - (void)sdi; + drvc = di->context; + devices = NULL; + serial_flush(serial); - sdi->status = SR_ST_ACTIVE; + sr_spew("Set O1 mode (continuous values, stable and unstable ones)."); + if (serial_write_nonblocking(serial, "O1\r\n", 4) != 4) + goto scan_cleanup; + /* Device replies with "A00\r\n" (OK) or "E01\r\n" (Error). Ignore. */ - return SR_OK; -} + /* Let's get a bit of data and see if we can find a packet. */ + len = sizeof(buf); + ret = serial_stream_detect(serial, buf, &len, scale->packet_size, + scale->packet_valid, 3000, scale->baudrate); + if (ret != SR_OK) + goto scan_cleanup; -static int dev_close(struct sr_dev_inst *sdi) -{ - (void)sdi; + sr_info("Found device on port %s.", conn); + sdi = g_malloc0(sizeof(struct sr_dev_inst)); sdi->status = SR_ST_INACTIVE; + sdi->vendor = g_strdup(scale->vendor); + sdi->model = g_strdup(scale->device); + devc = g_malloc0(sizeof(struct dev_context)); + sdi->inst_type = SR_INST_SERIAL; + sdi->conn = serial; + sdi->priv = devc; + sdi->driver = di; + sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "Mass"); + drvc->instances = g_slist_append(drvc->instances, sdi); + devices = g_slist_append(devices, sdi); + +scan_cleanup: + serial_close(serial); - return SR_OK; + return devices; } -static int cleanup(const struct sr_dev_driver *di) +static GSList *dev_list(const struct sr_dev_driver *di) { - dev_clear(di); - - return SR_OK; + return ((struct drv_context *)(di->context))->instances; } -static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg) +static int cleanup(const struct sr_dev_driver *di) { - int ret; - - (void)sdi; - (void)data; - (void)cg; - - ret = SR_OK; - switch (key) { - default: - return SR_ERR_NA; - } - - return ret; + return dev_clear(di); } static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { - int ret; + struct dev_context *devc; - (void)data; (void)cg; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; - ret = SR_OK; + if (!(devc = sdi->priv)) + return SR_ERR_BUG; + switch (key) { + case SR_CONF_LIMIT_SAMPLES: + devc->limit_samples = g_variant_get_uint64(data); + break; + case SR_CONF_LIMIT_MSEC: + devc->limit_msec = g_variant_get_uint64(data); + break; default: - ret = SR_ERR_NA; + return SR_ERR_NA; } - return ret; + return SR_OK; } static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { - int ret; - (void)sdi; - (void)data; (void)cg; - ret = SR_OK; switch (key) { + case SR_CONF_SCAN_OPTIONS: + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, + scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t)); + break; + case SR_CONF_DEVICE_OPTIONS: + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, + devopts, ARRAY_SIZE(devopts), sizeof(uint32_t)); + break; default: return SR_ERR_NA; } - return ret; + return SR_OK; } static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { - (void)sdi; - (void)cb_data; + struct dev_context *devc; + struct sr_serial_dev_inst *serial; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; + if (!(devc = sdi->priv)) + return SR_ERR_BUG; + + devc->cb_data = cb_data; + + serial = sdi->conn; + + sr_spew("Set O1 mode (continuous values, stable and unstable ones)."); + if (serial_write_nonblocking(serial, "O1\r\n", 4) != 4) + return SR_ERR; + /* Device replies with "A00\r\n" (OK) or "E01\r\n" (Error). Ignore. */ + + devc->num_samples = 0; + devc->starttime = g_get_monotonic_time(); + + /* Send header packet to the session bus. */ + std_session_send_df_header(cb_data, LOG_PREFIX); + + /* Poll every 50ms, or whenever some data comes in. */ + serial_source_add(sdi->session, serial, G_IO_IN, 50, + kern_scale_receive_data, (void *)sdi); + return SR_OK; } static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data) { - (void)cb_data; + return std_serial_dev_acquisition_stop(sdi, cb_data, std_serial_dev_close, + sdi->conn, LOG_PREFIX); +} - if (sdi->status != SR_ST_ACTIVE) - return SR_ERR_DEV_CLOSED; +#define SCALE(ID, CHIPSET, VENDOR, MODEL, CONN, BAUDRATE, PACKETSIZE, \ + VALID, PARSE) \ + &(struct scale_info) { \ + { \ + .name = ID, \ + .longname = VENDOR " " MODEL, \ + .api_version = 1, \ + .init = init, \ + .cleanup = cleanup, \ + .scan = scan, \ + .dev_list = dev_list, \ + .dev_clear = dev_clear, \ + .config_get = NULL, \ + .config_set = config_set, \ + .config_list = config_list, \ + .dev_open = std_serial_dev_open, \ + .dev_close = std_serial_dev_close, \ + .dev_acquisition_start = dev_acquisition_start, \ + .dev_acquisition_stop = dev_acquisition_stop, \ + .context = NULL, \ + }, \ + VENDOR, MODEL, CONN, BAUDRATE, PACKETSIZE, \ + VALID, PARSE, sizeof(struct CHIPSET##_info) \ + } - return SR_OK; -} +/* + * Some scales have (user-configurable) 14-byte or 15-byte packets. + * We transparently support both variants by specifying the larger value + * below and due to the way the stream parser works. + * + * The scales have a standard baudrate (model dependent) as listed below, + * but serial parameters are user-configurable. We support that by letting + * the user override them via "serialcomm". + */ -SR_PRIV struct sr_dev_driver kern_scale_driver_info = { - .name = "kern-scale", - .longname = "KERN Scale", - .api_version = 1, - .init = init, - .cleanup = cleanup, - .scan = scan, - .dev_list = dev_list, - .dev_clear = dev_clear, - .config_get = config_get, - .config_set = config_set, - .config_list = config_list, - .dev_open = dev_open, - .dev_close = dev_close, - .dev_acquisition_start = dev_acquisition_start, - .dev_acquisition_stop = dev_acquisition_stop, - .context = NULL, +SR_PRIV const struct scale_info *kern_scale_drivers[] = { + SCALE( + "kern-ew-6200-2nm", kern, + "KERN", "EW 6200-2NM", "1200/8n2", 1200, + 15 /* (or 14) */, sr_kern_packet_valid, sr_kern_parse + ), + NULL }; diff --git a/src/hardware/kern-scale/protocol.c b/src/hardware/kern-scale/protocol.c index 51ad9be1..28ebe717 100644 --- a/src/hardware/kern-scale/protocol.c +++ b/src/hardware/kern-scale/protocol.c @@ -18,12 +18,91 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ +#include +#include +#include +#include +#include +#include "libsigrok-internal.h" #include "protocol.h" +static void handle_packet(const uint8_t *buf, struct sr_dev_inst *sdi, + void *info) +{ + struct scale_info *scale; + float floatval; + struct sr_datafeed_packet packet; + struct sr_datafeed_analog analog; + struct dev_context *devc; + + scale = (struct scale_info *)sdi->driver; + + devc = sdi->priv; + + memset(&analog, 0, sizeof(struct sr_datafeed_analog)); + + analog.channels = sdi->channels; + analog.num_samples = 1; + analog.mq = -1; + + scale->packet_parse(buf, &floatval, &analog, info); + analog.data = &floatval; + + if (analog.mq != -1) { + /* Got a measurement. */ + packet.type = SR_DF_ANALOG; + packet.payload = &analog; + sr_session_send(devc->cb_data, &packet); + devc->num_samples++; + } +} + +static void handle_new_data(struct sr_dev_inst *sdi, void *info) +{ + struct scale_info *scale; + struct dev_context *devc; + int len, i, offset = 0; + struct sr_serial_dev_inst *serial; + + scale = (struct scale_info *)sdi->driver; + + devc = sdi->priv; + serial = sdi->conn; + + /* Try to get as much data as the buffer can hold. */ + len = SCALE_BUFSIZE - devc->buflen; + len = serial_read_nonblocking(serial, devc->buf + devc->buflen, len); + if (len == 0) + return; /* No new bytes, nothing to do. */ + if (len < 0) { + sr_err("Serial port read error: %d.", len); + return; + } + devc->buflen += len; + + /* Now look for packets in that data. */ + while ((devc->buflen - offset) >= scale->packet_size) { + if (scale->packet_valid(devc->buf + offset)) { + handle_packet(devc->buf + offset, sdi, info); + offset += scale->packet_size; + } else { + offset++; + } + } + + /* If we have any data left, move it to the beginning of our buffer. */ + for (i = 0; i < devc->buflen - offset; i++) + devc->buf[i] = devc->buf[offset + i]; + devc->buflen -= offset; +} + SR_PRIV int kern_scale_receive_data(int fd, int revents, void *cb_data) { - const struct sr_dev_inst *sdi; + struct sr_dev_inst *sdi; struct dev_context *devc; + struct scale_info *scale; + int64_t time; + void *info; (void)fd; @@ -33,7 +112,28 @@ SR_PRIV int kern_scale_receive_data(int fd, int revents, void *cb_data) if (!(devc = sdi->priv)) return TRUE; + scale = (struct scale_info *)sdi->driver; + if (revents == G_IO_IN) { + /* Serial data arrived. */ + info = g_malloc(scale->info_size); + handle_new_data(sdi, info); + g_free(info); + } + + if (devc->limit_samples && devc->num_samples >= devc->limit_samples) { + sr_info("Requested number of samples reached."); + sdi->driver->dev_acquisition_stop(sdi, cb_data); + return TRUE; + } + + if (devc->limit_msec) { + time = (g_get_monotonic_time() - devc->starttime) / 1000; + if (time > (int64_t)devc->limit_msec) { + sr_info("Requested time limit reached."); + sdi->driver->dev_acquisition_stop(sdi, cb_data); + return TRUE; + } } return TRUE; diff --git a/src/hardware/kern-scale/protocol.h b/src/hardware/kern-scale/protocol.h index 1a7a51a4..a7f11d23 100644 --- a/src/hardware/kern-scale/protocol.h +++ b/src/hardware/kern-scale/protocol.h @@ -21,15 +21,52 @@ #ifndef LIBSIGROK_HARDWARE_KERN_SCALE_PROTOCOL_H #define LIBSIGROK_HARDWARE_KERN_SCALE_PROTOCOL_H -#include -#include -#include -#include "libsigrok-internal.h" - #define LOG_PREFIX "kern-scale" +struct scale_info { + /** libsigrok driver info struct. */ + struct sr_dev_driver di; + /** Manufacturer/brand. */ + char *vendor; + /** Model. */ + char *device; + /** serialconn string. */ + char *conn; + /** Baud rate. */ + uint32_t baudrate; + /** Packet size in bytes. */ + int packet_size; + /** Packet validation function. */ + gboolean (*packet_valid)(const uint8_t *); + /** Packet parsing function. */ + int (*packet_parse)(const uint8_t *, float *, + struct sr_datafeed_analog *, void *); + /** Size of chipset info struct. */ + gsize info_size; +}; + +#define SCALE_BUFSIZE 256 + /** Private, per-device-instance driver context. */ struct dev_context { + /** The current sampling limit (in number of samples). */ + uint64_t limit_samples; + + /** The time limit (in milliseconds). */ + uint64_t limit_msec; + + /** Opaque pointer passed in by the frontend. */ + void *cb_data; + + /** The current number of already received samples. */ + uint64_t num_samples; + + /** The starting time of current sampling run. */ + int64_t starttime; + + uint8_t buf[SCALE_BUFSIZE]; + int bufoffset; + int buflen; }; SR_PRIV int kern_scale_receive_data(int fd, int revents, void *cb_data);