X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fscpi%2Fscpi.c;h=48e6a48495c9bfaba591147a12f715b67fe0b493;hb=b6be55ce95b8d4d00d64874a05c022846e43cec4;hp=8e7e4d74af6702b7b59ba1cd87f163a7468bee3c;hpb=ad21865fa7bb8bc429615235e90e012541d2b606;p=libsigrok.git diff --git a/src/scpi/scpi.c b/src/scpi/scpi.c index 8e7e4d74..48e6a484 100644 --- a/src/scpi/scpi.c +++ b/src/scpi/scpi.c @@ -190,7 +190,7 @@ SR_PRIV struct sr_scpi_dev_inst *scpi_dev_inst_new(struct drv_context *drvc, scpi = g_malloc(sizeof(*scpi)); *scpi = *scpi_dev; scpi->priv = g_malloc0(scpi->priv_size); - scpi->read_timeout_ms = 1000; + scpi->read_timeout_us = 1000 * 1000; params = g_strsplit(resource, "/", 0); if (scpi->dev_inst_new(scpi->priv, drvc, resource, params, serialcomm) != SR_OK) { @@ -337,6 +337,21 @@ SR_PRIV int sr_scpi_read_data(struct sr_scpi_dev_inst *scpi, return scpi->read_data(scpi->priv, buf, maxlen); } +/** + * Send data to SCPI device. + * + * @param scpi Previously initialised SCPI device structure. + * @param buf Buffer with data to send. + * @param len Number of bytes to send. + * + * @return Number of bytes read, or SR_ERR upon failure. + */ +SR_PRIV int sr_scpi_write_data(struct sr_scpi_dev_inst *scpi, + char *buf, int maxlen) +{ + return scpi->write_data(scpi->priv, buf, maxlen); +} + /** * Check whether a complete SCPI response has been received. * @@ -364,12 +379,14 @@ SR_PRIV int sr_scpi_close(struct sr_scpi_dev_inst *scpi) /** * Free SCPI device. * - * @param scpi Previously initialized SCPI device structure. - * - * @return SR_OK on success, SR_ERR on failure. + * @param scpi Previously initialized SCPI device structure. If NULL, + * this function does nothing. */ SR_PRIV void sr_scpi_free(struct sr_scpi_dev_inst *scpi) { + if (!scpi) + return; + scpi->free(scpi->priv); g_free(scpi->priv); g_free(scpi); @@ -412,15 +429,49 @@ SR_PRIV int sr_scpi_get_string(struct sr_scpi_dev_inst *scpi, return SR_OK; } +/** + * Do a non-blocking read of up to the allocated length, and + * check if a timeout has occured. + * + * @param scpi Previously initialised SCPI device structure. + * @param response Buffer to which the response is appended. + * @param abs_timeout_us Absolute timeout in microseconds + * + * @return read length on success, SR_ERR* on failure. + */ +SR_PRIV int sr_scpi_read_response(struct sr_scpi_dev_inst *scpi, + GString *response, gint64 abs_timeout_us) +{ + int len, space; + + space = response->allocated_len - response->len; + len = sr_scpi_read_data(scpi, &response->str[response->len], space); + + if (len < 0) { + sr_err("Incompletely read SCPI response."); + return SR_ERR; + } + + if (len > 0) { + g_string_set_size(response, response->len + len); + return len; + } + + if (g_get_monotonic_time() > abs_timeout_us) { + sr_err("Timed out waiting for SCPI response."); + return SR_ERR_TIMEOUT; + } + + return 0; +} + SR_PRIV int sr_scpi_get_data(struct sr_scpi_dev_inst *scpi, const char *command, GString **scpi_response) { - int len; + int ret; GString *response; - gint64 laststart; - unsigned int elapsed_ms; - unsigned int offset; int space; + gint64 timeout; /* Optionally send caller provided command. */ if (command) { @@ -433,35 +484,26 @@ SR_PRIV int sr_scpi_get_data(struct sr_scpi_dev_inst *scpi, return SR_ERR; /* Keep reading until completion or until timeout. */ - laststart = g_get_monotonic_time(); + timeout = g_get_monotonic_time() + scpi->read_timeout_us; response = *scpi_response; - offset = response->len; while (!sr_scpi_read_complete(scpi)) { /* Resize the buffer when free space drops below a threshold. */ space = response->allocated_len - response->len; if (space < 128) { - g_string_set_size(response, response->len + 1024); - g_string_set_size(response, offset); - space = response->allocated_len - response->len; + int oldlen = response->len; + g_string_set_size(response, oldlen + 1024); + g_string_set_size(response, oldlen); } + /* Read another chunk of the response. */ - len = sr_scpi_read_data(scpi, &response->str[offset], space); - if (len < 0) { - sr_err("Incompletely read SCPI response."); - return SR_ERR; - } else if (len > 0) { - laststart = g_get_monotonic_time(); - } - offset += len; - g_string_set_size(response, offset); - /* Quit reading after a period of time without receive data. */ - elapsed_ms = (g_get_monotonic_time() - laststart) / 1000; - if (elapsed_ms >= scpi->read_timeout_ms) { - sr_err("Timed out waiting for SCPI response."); - return SR_ERR; - } + ret = sr_scpi_read_response(scpi, response, timeout); + + if (ret < 0) + return ret; + if (ret > 0) + timeout = g_get_monotonic_time() + scpi->read_timeout_us; } return SR_OK; @@ -752,19 +794,32 @@ SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi, char buf[10]; long llen; long datalen; + gint64 timeout; + + if (command) + if (sr_scpi_send(scpi, command) != SR_OK) + return SR_ERR; + + if (sr_scpi_read_begin(scpi) != SR_OK) + return SR_ERR; /* * Assume an initial maximum length, optionally gets adjusted below. * Prepare a NULL return value for when error paths will be taken. */ response = g_string_sized_new(1024); + + timeout = g_get_monotonic_time() + scpi->read_timeout_us; + *scpi_response = NULL; /* Get (the first chunk of) the response. */ - ret = sr_scpi_get_data(scpi, command, &response); - if (ret != SR_OK) { - g_string_free(response, TRUE); - return ret; + while (response->len < 2) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { + g_string_free(response, TRUE); + return ret; + } } /* @@ -789,6 +844,15 @@ SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi, g_string_free(response, TRUE); return ret; } + + while (response->len < (unsigned long)(2 + llen)) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { + g_string_free(response, TRUE); + return ret; + } + } + memcpy(buf, &response->str[2], llen); buf[llen] = '\0'; ret = sr_atol(buf, &datalen); @@ -808,19 +872,22 @@ SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi, g_string_set_size(response, datalen); g_string_set_size(response, oldlen); } + while (response->len < (unsigned long)(datalen)) { - ret = sr_scpi_get_data(scpi, NULL, &response); - if (ret != SR_OK) { + ret = sr_scpi_read_response(scpi, response, timeout); + if (ret < 0) { g_string_free(response, TRUE); return ret; } + if (ret > 0) + timeout = g_get_monotonic_time() + scpi->read_timeout_us; } /* Convert received data to byte array. */ *scpi_response = g_byte_array_new_take( (guint8*)g_string_free(response, FALSE), datalen); - return ret; + return SR_OK; } /** @@ -884,17 +951,17 @@ SR_PRIV int sr_scpi_get_hw_id(struct sr_scpi_dev_inst *scpi, /** * Free a sr_scpi_hw_info struct. * - * @param hw_info Pointer to the struct to free. - * - * This function is safe to call with a NULL pointer. + * @param hw_info Pointer to the struct to free. If NULL, this + * function does nothing. */ SR_PRIV void sr_scpi_hw_info_free(struct sr_scpi_hw_info *hw_info) { - if (hw_info) { - g_free(hw_info->manufacturer); - g_free(hw_info->model); - g_free(hw_info->serial_number); - g_free(hw_info->firmware_version); - g_free(hw_info); - } + if (!hw_info) + return; + + g_free(hw_info->manufacturer); + g_free(hw_info->model); + g_free(hw_info->serial_number); + g_free(hw_info->firmware_version); + g_free(hw_info); }