*
* @return SR_OK on success, SR_ERR on failure.
*/
-static int sr_parse_strict_bool(const char *str, gboolean *ret)
+static int parse_strict_bool(const char *str, gboolean *ret)
{
if (!str)
return SR_ERR_ARG;
!g_ascii_strncasecmp(str, "yes", 3) ||
!g_ascii_strncasecmp(str, "true", 4) ||
!g_ascii_strncasecmp(str, "on", 2)) {
-
*ret = TRUE;
return SR_OK;
-
} else if (!g_strcmp0(str, "0") ||
!g_ascii_strncasecmp(str, "n", 1) ||
!g_ascii_strncasecmp(str, "f", 1) ||
!g_ascii_strncasecmp(str, "no", 2) ||
!g_ascii_strncasecmp(str, "false", 5) ||
!g_ascii_strncasecmp(str, "off", 3)) {
-
*ret = FALSE;
return SR_OK;
}
SR_PRIV int sr_scpi_send(struct sr_serial_dev_inst *serial,
const char *command)
{
- int len;
- int out;
+ int len, out;
gchar *terminated_command;
terminated_command = g_strconcat(command, "\n", NULL);
len = strlen(terminated_command);
-
- out = serial_write(serial, terminated_command,
- strlen(terminated_command));
-
+ out = serial_write(serial, terminated_command, len);
g_free(terminated_command);
if (out != len) {
*
* @param serial Previously initialized serial port structure.
* @param command The SCPI command to send to the device (can be NULL).
- * @param scpi_response Pointer where to store the scpi response.
+ * @param scpi_response Pointer where to store the SCPI response.
*
- * @return SR_OK upon fetching a full SCPI response, SR_ERR upon fetching a
- * incomplete or no response. The allocated response must be freed by the caller
- * in the case of a full response as well in the case of an incomplete.
+ * @return SR_OK upon fetching a full SCPI response, SR_ERR upon fetching an
+ * incomplete or no response. The allocated response must be freed by
+ * the caller in the case of a full response as well in the case of
+ * an incomplete.
*/
SR_PRIV int sr_scpi_get_string(struct sr_serial_dev_inst *serial,
- const char *command, char **scpi_response)
+ const char *command, char **scpi_response)
{
- int len;
- int ret;
+ int len, ret;
char buf[256];
unsigned int i;
GString *response;
if (response->len > 0 &&
response->str[response->len-1] == '\n') {
- sr_spew("Fetched full SCPI response");
+ sr_spew("Fetched full SCPI response.");
break;
}
}
if (response->len == 0) {
- sr_dbg("No SCPI response received");
+ sr_dbg("No SCPI response received.");
g_string_free(response, TRUE);
*scpi_response = NULL;
return SR_ERR;
-
- } else if (response->str[response->len-1] == '\n') {
+ } else if (response->str[response->len - 1] == '\n') {
/*
* The SCPI response contains a LF ('\n') at the end and we
* don't need this so replace it with a '\0' and decrement
*/
response->str[--response->len] = '\0';
ret = SR_OK;
-
} else {
sr_warn("Incomplete SCPI response received!");
ret = SR_ERR;
/* Minor optimization: steal the string instead of copying. */
*scpi_response = response->str;
- /* A SCPI response can be quite large, print at most 50 characters */
+ /* A SCPI response can be quite large, print at most 50 characters. */
sr_dbg("SCPI response for command %s received (length %d): '%.50s'",
command, response->len, response->str);
if (!response)
return SR_ERR;
- if (sr_parse_strict_bool(response, scpi_response) == SR_OK)
+ if (parse_strict_bool(response, scpi_response) == SR_OK)
ret = SR_OK;
else
ret = SR_ERR;
* @return SR_OK on success, SR_ERR on failure.
*/
SR_PRIV int sr_scpi_get_int(struct sr_serial_dev_inst *serial,
- const char *command, int *scpi_response)
+ const char *command, int *scpi_response)
{
int ret;
char *response;
* @return SR_OK on success, SR_ERR on failure.
*/
SR_PRIV int sr_scpi_get_double(struct sr_serial_dev_inst *serial,
- const char *command, double *scpi_response)
+ const char *command, double *scpi_response)
{
int ret;
char *response;
for (i = 0; i < SCPI_READ_RETRIES; ++i) {
sr_scpi_get_bool(serial, SCPI_CMD_OPC, &opc);
-
if (opc)
return SR_OK;
-
g_usleep(SCPI_READ_RETRY_TIMEOUT);
}
* @param scpi_response Pointer where to store the parsed result.
*
* @return SR_OK upon successfully parsing all values, SR_ERR upon a parsing
- * error or upon no response. The allocated response must be freed by the caller
- * in the case of an SR_OK as well as in the case of parsing error.
+ * error or upon no response. The allocated response must be freed by
+ * the caller in the case of an SR_OK as well as in the case of
+ * parsing error.
*/
SR_PRIV int sr_scpi_get_floatv(struct sr_serial_dev_inst *serial,
- const char *command, GArray **scpi_response)
+ const char *command, GArray **scpi_response)
{
int ret;
float tmp;
char *response;
-
- gchar **ptr;
- gchar **tokens;
+ gchar **ptr, **tokens;
GArray *response_array;
ret = SR_OK;
response_array = g_array_sized_new(TRUE, FALSE, sizeof(float), 256);
- while(*ptr) {
+ while (*ptr) {
if (sr_atof(*ptr, &tmp) == SR_OK)
response_array = g_array_append_val(response_array,
tmp);
* @param scpi_response Pointer where to store the parsed result.
*
* @return SR_OK upon successfully parsing all values, SR_ERR upon a parsing
- * error or upon no response. The allocated response must be freed by the caller
- * in the case of an SR_OK as well as in the case of parsing error.
+ * error or upon no response. The allocated response must be freed by
+ * the caller in the case of an SR_OK as well as in the case of
+ * parsing error.
*/
SR_PRIV int sr_scpi_get_uint8v(struct sr_serial_dev_inst *serial,
- const char *command, GArray **scpi_response)
+ const char *command, GArray **scpi_response)
{
- int tmp;
- int ret;
+ int tmp, ret;
char *response;
-
- gchar **ptr;
- gchar **tokens;
+ gchar **ptr, **tokens;
GArray *response_array;
ret = SR_OK;
response_array = g_array_sized_new(TRUE, FALSE, sizeof(uint8_t), 256);
- while(*ptr) {
+ while (*ptr) {
if (sr_atoi(*ptr, &tmp) == SR_OK)
response_array = g_array_append_val(response_array,
tmp);
* Send the *IDN? SCPI command, receive the reply, parse it and store the
* reply as a sr_scpi_hw_info structure in the supplied scpi_response pointer.
*
+ * The hw_info structure must be freed by the caller via sr_scpi_hw_info_free().
+ *
* @param serial Previously initialized serial port structure.
* @param scpi_response Pointer where to store the hw_info structure.
*
* @return SR_OK upon success, SR_ERR on failure.
- * The hw_info structure must be freed by the caller with sr_scpi_hw_info_free().
*/
SR_PRIV int sr_scpi_get_hw_id(struct sr_serial_dev_inst *serial,
struct sr_scpi_hw_info **scpi_response)
int num_tokens;
char *response;
gchar **tokens;
-
struct sr_scpi_hw_info *hw_info;
response = NULL;
for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
if (num_tokens != 4) {
- sr_dbg("IDN response not according to spec: %80.s", response);
+ sr_dbg("IDN response not according to spec: %80.s.", response);
g_strfreev(tokens);
g_free(response);
return SR_ERR;
projects / libsigrok.git / commitdiff