X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fhardware%2Fserial-dmm%2Fprotocol.c;h=5e8912bf3d21c61906b25b0b21e7bd23b084c8dd;hp=e667ca4955cd84f04953a70ec90066ffaf24c058;hb=HEAD;hpb=4277ac349ced6224e8093fea79b6988315fbb780 diff --git a/src/hardware/serial-dmm/protocol.c b/src/hardware/serial-dmm/protocol.c index e667ca49..4cbec267 100644 --- a/src/hardware/serial-dmm/protocol.c +++ b/src/hardware/serial-dmm/protocol.c @@ -18,136 +18,228 @@ * along with this program. If not, see . */ +#include #include #include #include -#include #include -#include "libsigrok.h" +#include #include "libsigrok-internal.h" #include "protocol.h" -static void log_dmm_packet(const uint8_t *buf) +static void log_dmm_packet(const uint8_t *buf, size_t len) { - sr_dbg("DMM packet: %02x %02x %02x %02x %02x %02x %02x" - " %02x %02x %02x %02x %02x %02x %02x", - buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], - buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13]); + GString *text; + + if (sr_log_loglevel_get() < SR_LOG_DBG) + return; + + text = sr_hexdump_new(buf, len); + sr_dbg("DMM packet: %s", text->str); + sr_hexdump_free(text); } -static void handle_packet(const uint8_t *buf, struct sr_dev_inst *sdi, - int dmm, void *info) +static void handle_packet(struct sr_dev_inst *sdi, + const uint8_t *buf, size_t len, void *info) { + struct dmm_info *dmm; + struct dev_context *devc; float floatval; + double doubleval; struct sr_datafeed_packet packet; struct sr_datafeed_analog analog; - struct dev_context *devc; + struct sr_analog_encoding encoding; + struct sr_analog_meaning meaning; + struct sr_analog_spec spec; + gboolean sent_sample; + struct sr_channel *channel; + size_t ch_idx; - log_dmm_packet(buf); - devc = sdi->priv; + dmm = (struct dmm_info *)sdi->driver; - memset(&analog, 0, sizeof(struct sr_datafeed_analog)); + log_dmm_packet(buf, len); + devc = sdi->priv; - analog.channels = sdi->channels; - analog.num_samples = 1; - analog.mq = -1; + sent_sample = FALSE; + memset(info, 0, dmm->info_size); + for (ch_idx = 0; ch_idx < dmm->channel_count; ch_idx++) { + /* Note: digits/spec_digits will be overridden by the DMM parsers. */ + sr_analog_init(&analog, &encoding, &meaning, &spec, 0); + + channel = g_slist_nth_data(sdi->channels, ch_idx); + analog.meaning->channels = g_slist_append(NULL, channel); + analog.num_samples = 1; + analog.meaning->mq = 0; + + if (dmm->packet_parse) { + dmm->packet_parse(buf, &floatval, &analog, info); + analog.data = &floatval; + analog.encoding->unitsize = sizeof(floatval); + } else if (dmm->packet_parse_len) { + dmm->packet_parse_len(dmm->dmm_state, buf, len, + &doubleval, &analog, info); + analog.data = &doubleval; + analog.encoding->unitsize = sizeof(doubleval); + } - dmms[dmm].packet_parse(buf, &floatval, &analog, info); - analog.data = &floatval; + /* If this DMM needs additional handling, call the resp. function. */ + if (dmm->dmm_details) + dmm->dmm_details(&analog, info); - /* If this DMM needs additional handling, call the resp. function. */ - if (dmms[dmm].dmm_details) - dmms[dmm].dmm_details(&analog, info); + if (analog.meaning->mq != 0 && channel->enabled) { + /* Got a measurement. */ + packet.type = SR_DF_ANALOG; + packet.payload = &analog; + sr_session_send(sdi, &packet); + sent_sample = TRUE; + } + } - 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++; + if (sent_sample) { + sr_sw_limits_update_samples_read(&devc->limits, 1); } } /** Request packet, if required. */ -SR_PRIV int req_packet(struct sr_dev_inst *sdi, int dmm) +SR_PRIV int req_packet(struct sr_dev_inst *sdi) { + struct dmm_info *dmm; struct dev_context *devc; struct sr_serial_dev_inst *serial; + uint64_t now, left, next; int ret; - if (!dmms[dmm].packet_request) + dmm = (struct dmm_info *)sdi->driver; + if (!dmm->packet_request) return SR_OK; devc = sdi->priv; serial = sdi->conn; - if (devc->req_next_at && (devc->req_next_at > g_get_monotonic_time())) { - sr_spew("Not requesting new packet yet, %" PRIi64 " ms left.", - ((devc->req_next_at - g_get_monotonic_time()) / 1000)); + now = g_get_monotonic_time(); + if (devc->req_next_at && now < devc->req_next_at) { + left = (devc->req_next_at - now) / 1000; + sr_spew("Not re-requesting yet, %" PRIu64 "ms left.", left); return SR_OK; } - ret = dmms[dmm].packet_request(serial); + sr_spew("Requesting next packet."); + ret = dmm->packet_request(serial); if (ret < 0) { sr_err("Failed to request packet: %d.", ret); return ret; } - if (dmms[dmm].req_timeout_ms) - devc->req_next_at = g_get_monotonic_time() + (dmms[dmm].req_timeout_ms * 1000); + if (dmm->req_timeout_ms) { + next = now + dmm->req_timeout_ms * 1000; + devc->req_next_at = next; + } return SR_OK; } -static void handle_new_data(struct sr_dev_inst *sdi, int dmm, void *info) +static void handle_new_data(struct sr_dev_inst *sdi, void *info) { + struct dmm_info *dmm; struct dev_context *devc; - int len, i, offset = 0; struct sr_serial_dev_inst *serial; + int ret; + size_t read_len, check_pos, check_len, pkt_size, copy_len; + uint8_t *check_ptr; + uint64_t deadline; + + dmm = (struct dmm_info *)sdi->driver; devc = sdi->priv; serial = sdi->conn; - /* Try to get as much data as the buffer can hold. */ - len = DMM_BUFSIZE - devc->buflen; - len = serial_read_nonblocking(serial, devc->buf + devc->buflen, len); - if (len == 0) + /* Add the maximum available RX data we can get to the local buffer. */ + read_len = DMM_BUFSIZE - devc->buflen; + ret = serial_read_nonblocking(serial, &devc->buf[devc->buflen], read_len); + if (ret == 0) return; /* No new bytes, nothing to do. */ - if (len < 0) { - sr_err("Serial port read error: %d.", len); + if (ret < 0) { + sr_err("Serial port read error: %d.", ret); return; } - devc->buflen += len; - - /* Now look for packets in that data. */ - while ((devc->buflen - offset) >= dmms[dmm].packet_size) { - if (dmms[dmm].packet_valid(devc->buf + offset)) { - handle_packet(devc->buf + offset, sdi, dmm, info); - offset += dmms[dmm].packet_size; - - /* Request next packet, if required. */ - if (!dmms[dmm].packet_request) + devc->buflen += ret; + + /* + * Process packets when their reception has completed, or keep + * trying to synchronize to the stream of input data. + */ + check_pos = 0; + while (check_pos < devc->buflen) { + /* Got the (minimum) amount of receive data for a packet? */ + check_len = devc->buflen - check_pos; + if (check_len < dmm->packet_size) + break; + sr_dbg("Checking: pos %zu, len %zu.", check_pos, check_len); + + /* Is it a valid packet? */ + check_ptr = &devc->buf[check_pos]; + if (dmm->packet_valid_len) { + ret = dmm->packet_valid_len(dmm->dmm_state, + check_ptr, check_len, &pkt_size); + if (ret == SR_PACKET_NEED_RX) { + sr_dbg("Need more RX data."); break; - if (dmms[dmm].req_timeout_ms || dmms[dmm].req_delay_ms) - devc->req_next_at = g_get_monotonic_time() + - dmms[dmm].req_delay_ms * 1000; - req_packet(sdi, dmm); - } else { - offset++; + } + if (ret == SR_PACKET_INVALID) { + sr_dbg("Not a valid packet, searching."); + check_pos++; + continue; + } + } else if (dmm->packet_valid) { + if (!dmm->packet_valid(check_ptr)) { + sr_dbg("Not a valid packet, searching."); + check_pos++; + continue; + } + pkt_size = dmm->packet_size; + } + + /* Process the packet. */ + sr_dbg("Valid packet, size %zu, processing", pkt_size); + handle_packet(sdi, check_ptr, pkt_size, info); + check_pos += pkt_size; + + /* Arrange for the next packet request if needed. */ + if (!dmm->packet_request) + continue; + if (dmm->req_timeout_ms || dmm->req_delay_ms) { + deadline = g_get_monotonic_time(); + deadline += dmm->req_delay_ms * 1000; + devc->req_next_at = deadline; } + req_packet(sdi); + continue; } /* 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; + if (devc->buflen > check_pos) { + copy_len = devc->buflen - check_pos; + memmove(&devc->buf[0], &devc->buf[check_pos], copy_len); + } + devc->buflen -= check_pos; + + /* + * If the complete buffer filled up and none of it got processed, + * discard the unprocessed buffer, re-sync to the stream in later + * calls again. + */ + if (devc->buflen == sizeof(devc->buf)) { + sr_info("Drop unprocessed RX data, try to re-sync to stream."); + devc->buflen = 0; + } } -static int receive_data(int fd, int revents, int dmm, void *info, void *cb_data) +int receive_data(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; struct dev_context *devc; - int64_t time; + struct dmm_info *dmm; + void *info; (void)fd; @@ -157,70 +249,21 @@ static int receive_data(int fd, int revents, int dmm, void *info, void *cb_data) if (!(devc = sdi->priv)) return TRUE; + dmm = (struct dmm_info *)sdi->driver; + if (revents == G_IO_IN) { /* Serial data arrived. */ - handle_new_data(sdi, dmm, info); + info = g_malloc(dmm->info_size); + handle_new_data(sdi, info); + g_free(info); } else { /* Timeout; send another packet request if DMM needs it. */ - if (dmms[dmm].packet_request && (req_packet(sdi, dmm) < 0)) + if (dmm->packet_request && (req_packet(sdi) < 0)) return FALSE; } - 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; - } - } + if (sr_sw_limits_check(&devc->limits)) + sr_dev_acquisition_stop(sdi); return TRUE; } - -#define RECEIVE_DATA(ID_UPPER, DMM_DRIVER) \ -SR_PRIV int receive_data_##ID_UPPER(int fd, int revents, void *cb_data) { \ - struct DMM_DRIVER##_info info; \ - return receive_data(fd, revents, ID_UPPER, &info, cb_data); } - -/* Driver-specific receive_data() wrappers */ -RECEIVE_DATA(BBCGM_M2110, metex14) /* metex14_info used as a dummy. */ -RECEIVE_DATA(DIGITEK_DT4000ZC, fs9721) -RECEIVE_DATA(TEKPOWER_TP4000ZC, fs9721) -RECEIVE_DATA(METEX_ME31, metex14) -RECEIVE_DATA(PEAKTECH_3410, metex14) -RECEIVE_DATA(MASTECH_MAS345, metex14) -RECEIVE_DATA(VA_VA18B, fs9721) -RECEIVE_DATA(VA_VA40B, fs9721) -RECEIVE_DATA(METEX_M3640D, metex14) -RECEIVE_DATA(METEX_M4650CR, metex14) -RECEIVE_DATA(PEAKTECH_4370, metex14) -RECEIVE_DATA(PCE_PCE_DM32, fs9721) -RECEIVE_DATA(RADIOSHACK_22_168, metex14) -RECEIVE_DATA(RADIOSHACK_22_805, metex14) -RECEIVE_DATA(RADIOSHACK_22_812, rs9lcd) -RECEIVE_DATA(TECPEL_DMM_8061_SER, fs9721) -RECEIVE_DATA(VOLTCRAFT_M3650CR, metex14) -RECEIVE_DATA(VOLTCRAFT_M3650D, metex14) -RECEIVE_DATA(VOLTCRAFT_M4650CR, metex14) -RECEIVE_DATA(VOLTCRAFT_ME42, metex14) -RECEIVE_DATA(VOLTCRAFT_VC820_SER, fs9721) -RECEIVE_DATA(VOLTCRAFT_VC830_SER, fs9922) -RECEIVE_DATA(VOLTCRAFT_VC840_SER, fs9721) -RECEIVE_DATA(UNI_T_UT60A_SER, fs9721) -RECEIVE_DATA(UNI_T_UT60E_SER, fs9721) -RECEIVE_DATA(UNI_T_UT60G_SER, es519xx) -RECEIVE_DATA(UNI_T_UT61B_SER, fs9922) -RECEIVE_DATA(UNI_T_UT61C_SER, fs9922) -RECEIVE_DATA(UNI_T_UT61D_SER, fs9922) -RECEIVE_DATA(UNI_T_UT61E_SER, es519xx) -RECEIVE_DATA(ISO_TECH_IDM103N, es519xx) -RECEIVE_DATA(TENMA_72_7745_SER, fs9721) -RECEIVE_DATA(TENMA_72_7750_SER, es519xx) -RECEIVE_DATA(BRYMEN_BM25X_SER, bm25x)