SR_PRIV int hmo_request_data(const struct sr_dev_inst *sdi) { char command[MAX_COMMAND_SIZE]; struct sr_channel *ch; struct dev_context *devc; const struct scope_config *model; devc = sdi->priv; model = devc->model_config; ch = devc->current_channel->data; switch (ch->type) { case SR_CHANNEL_ANALOG: g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_GET_ANALOG_DATA], #ifdef WORDS_BIGENDIAN "MSBF", #else "LSBF", #endif ch->index + 1); break; case SR_CHANNEL_LOGIC: g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_GET_DIG_DATA], ch->index < 8 ? 1 : 2); break; default: sr_err("Invalid channel type."); break; } return sr_scpi_send(sdi->conn, command); }
/** * Send a SCPI command, receive the reply and store the reply in scpi_response. * * @param scpi Previously initialised SCPI device structure. * @param command The SCPI command to send to the device (can be NULL). * @param scpi_response Pointer where to store the SCPI response. * * @return SR_OK on success, SR_ERR on failure. */ SR_PRIV int sr_scpi_get_string(struct sr_scpi_dev_inst *scpi, const char *command, char **scpi_response) { char buf[256]; int len; GString *response; if (command) if (sr_scpi_send(scpi, command) != SR_OK) return SR_ERR; if (sr_scpi_read_begin(scpi) != SR_OK) return SR_ERR; response = g_string_new(""); *scpi_response = NULL; while (!sr_scpi_read_complete(scpi)) { len = sr_scpi_read_data(scpi, buf, sizeof(buf)); if (len < 0) { g_string_free(response, TRUE); return SR_ERR; } g_string_append_len(response, buf, len); } *scpi_response = response->str; g_string_free(response, FALSE); return SR_OK; }
/** * Send a SCPI command, receive the reply and store the reply in scpi_response. * * @param scpi Previously initialised SCPI device structure. * @param command The SCPI command to send to the device (can be NULL). * @param scpi_response Pointer where to store the SCPI response. * * @return SR_OK on success, SR_ERR* on failure. */ SR_PRIV int sr_scpi_get_string(struct sr_scpi_dev_inst *scpi, const char *command, char **scpi_response) { char buf[256]; int len; GString *response; gint64 laststart; unsigned int elapsed_ms; if (command) if (sr_scpi_send(scpi, command) != SR_OK) return SR_ERR; if (sr_scpi_read_begin(scpi) != SR_OK) return SR_ERR; laststart = g_get_monotonic_time(); response = g_string_new(""); *scpi_response = NULL; while (!sr_scpi_read_complete(scpi)) { len = sr_scpi_read_data(scpi, buf, sizeof(buf)); if (len < 0) { sr_err("Incompletely read SCPI response."); g_string_free(response, TRUE); return SR_ERR; } else if (len > 0) { laststart = g_get_monotonic_time(); } g_string_append_len(response, buf, len); elapsed_ms = (g_get_monotonic_time() - laststart) / 1000; if (elapsed_ms >= scpi->read_timeout_ms) { sr_err("Timed out waiting for SCPI response."); g_string_free(response, TRUE); return SR_ERR; } } /* Get rid of trailing linefeed if present */ if (response->len >= 1 && response->str[response->len - 1] == '\n') g_string_truncate(response, response->len - 1); /* Get rid of trailing carriage return if present */ if (response->len >= 1 && response->str[response->len - 1] == '\r') g_string_truncate(response, response->len - 1); sr_spew("Got response: '%.70s', length %" G_GSIZE_FORMAT ".", response->str, response->len); *scpi_response = g_string_free(response, FALSE); return SR_OK; }
SR_PRIV int rigol_ds_receive(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; struct sr_scpi_dev_inst *scpi; struct dev_context *devc; struct sr_datafeed_packet packet; struct sr_datafeed_analog_old analog; struct sr_datafeed_logic logic; double vdiv, offset; int len, i, vref; struct sr_channel *ch; gsize expected_data_bytes; (void)fd; if (!(sdi = cb_data)) return TRUE; if (!(devc = sdi->priv)) return TRUE; scpi = sdi->conn; if (!(revents == G_IO_IN || revents == 0)) return TRUE; switch (devc->wait_event) { case WAIT_NONE: break; case WAIT_TRIGGER: if (rigol_ds_trigger_wait(sdi) != SR_OK) return TRUE; if (rigol_ds_channel_start(sdi) != SR_OK) return TRUE; return TRUE; case WAIT_BLOCK: if (rigol_ds_block_wait(sdi) != SR_OK) return TRUE; break; case WAIT_STOP: if (rigol_ds_stop_wait(sdi) != SR_OK) return TRUE; if (rigol_ds_check_stop(sdi) != SR_OK) return TRUE; if (rigol_ds_channel_start(sdi) != SR_OK) return TRUE; return TRUE; default: sr_err("BUG: Unknown event target encountered"); break; } ch = devc->channel_entry->data; expected_data_bytes = ch->type == SR_CHANNEL_ANALOG ? devc->analog_frame_size : devc->digital_frame_size; if (devc->num_block_bytes == 0) { if (devc->model->series->protocol >= PROTOCOL_V4) { if (sr_scpi_send(sdi->conn, ":WAV:START %d", devc->num_channel_bytes + 1) != SR_OK) return TRUE; if (sr_scpi_send(sdi->conn, ":WAV:STOP %d", MIN(devc->num_channel_bytes + ACQ_BLOCK_SIZE, devc->analog_frame_size)) != SR_OK) return TRUE; } if (devc->model->series->protocol >= PROTOCOL_V3) if (sr_scpi_send(sdi->conn, ":WAV:DATA?") != SR_OK) return TRUE; if (sr_scpi_read_begin(scpi) != SR_OK) return TRUE; if (devc->format == FORMAT_IEEE488_2) { sr_dbg("New block header expected"); len = rigol_ds_read_header(sdi); if (len == 0) /* Still reading the header. */ return TRUE; if (len == -1) { sr_err("Read error, aborting capture."); packet.type = SR_DF_FRAME_END; sr_session_send(cb_data, &packet); sdi->driver->dev_acquisition_stop(sdi, cb_data); return TRUE; } /* At slow timebases in live capture the DS2072 * sometimes returns "short" data blocks, with * apparently no way to get the rest of the data. * Discard these, the complete data block will * appear eventually. */ if (devc->data_source == DATA_SOURCE_LIVE && (unsigned)len < expected_data_bytes) { sr_dbg("Discarding short data block"); sr_scpi_read_data(scpi, (char *)devc->buffer, len + 1); return TRUE; } devc->num_block_bytes = len; } else { devc->num_block_bytes = expected_data_bytes; } devc->num_block_read = 0; } len = devc->num_block_bytes - devc->num_block_read; if (len > ACQ_BUFFER_SIZE) len = ACQ_BUFFER_SIZE; sr_dbg("Requesting read of %d bytes", len); len = sr_scpi_read_data(scpi, (char *)devc->buffer, len); if (len == -1) { sr_err("Read error, aborting capture."); packet.type = SR_DF_FRAME_END; sr_session_send(cb_data, &packet); sdi->driver->dev_acquisition_stop(sdi, cb_data); return TRUE; } sr_dbg("Received %d bytes.", len); devc->num_block_read += len; if (ch->type == SR_CHANNEL_ANALOG) { vref = devc->vert_reference[ch->index]; vdiv = devc->vdiv[ch->index] / 25.6; offset = devc->vert_offset[ch->index]; if (devc->model->series->protocol >= PROTOCOL_V3) for (i = 0; i < len; i++) devc->data[i] = ((int)devc->buffer[i] - vref) * vdiv - offset; else for (i = 0; i < len; i++) devc->data[i] = (128 - devc->buffer[i]) * vdiv - offset; analog.channels = g_slist_append(NULL, ch); analog.num_samples = len; analog.data = devc->data; analog.mq = SR_MQ_VOLTAGE; analog.unit = SR_UNIT_VOLT; analog.mqflags = 0; packet.type = SR_DF_ANALOG_OLD; packet.payload = &analog; sr_session_send(cb_data, &packet); g_slist_free(analog.channels); } else { logic.length = len; // TODO: For the MSO1000Z series, we need a way to express that // this data is in fact just for a single channel, with the valid // data for that channel in the LSB of each byte. logic.unitsize = devc->model->series->protocol == PROTOCOL_V4 ? 1 : 2; logic.data = devc->buffer; packet.type = SR_DF_LOGIC; packet.payload = &logic; sr_session_send(cb_data, &packet); } if (devc->num_block_read == devc->num_block_bytes) { sr_dbg("Block has been completed"); if (devc->model->series->protocol >= PROTOCOL_V3) { /* Discard the terminating linefeed */ sr_scpi_read_data(scpi, (char *)devc->buffer, 1); } if (devc->format == FORMAT_IEEE488_2) { /* Prepare for possible next block */ devc->num_header_bytes = 0; devc->num_block_bytes = 0; if (devc->data_source != DATA_SOURCE_LIVE) rigol_ds_set_wait_event(devc, WAIT_BLOCK); } if (!sr_scpi_read_complete(scpi)) { sr_err("Read should have been completed"); packet.type = SR_DF_FRAME_END; sr_session_send(cb_data, &packet); sdi->driver->dev_acquisition_stop(sdi, cb_data); return TRUE; } devc->num_block_read = 0; } else { sr_dbg("%" PRIu64 " of %" PRIu64 " block bytes read", devc->num_block_read, devc->num_block_bytes); } devc->num_channel_bytes += len; if (devc->num_channel_bytes < expected_data_bytes) /* Don't have the full data for this channel yet, re-run. */ return TRUE; /* End of data for this channel. */ if (devc->model->series->protocol == PROTOCOL_V3) { /* Signal end of data download to scope */ if (devc->data_source != DATA_SOURCE_LIVE) /* * This causes a query error, without it switching * to the next channel causes an error. Fun with * firmware... */ rigol_ds_config_set(sdi, ":WAV:END"); } if (devc->channel_entry->next) { /* We got the frame for this channel, now get the next channel. */ devc->channel_entry = devc->channel_entry->next; rigol_ds_channel_start(sdi); } else { /* Done with this frame. */ packet.type = SR_DF_FRAME_END; sr_session_send(cb_data, &packet); if (++devc->num_frames == devc->limit_frames) { /* Last frame, stop capture. */ sdi->driver->dev_acquisition_stop(sdi, cb_data); } else { /* Get the next frame, starting with the first channel. */ devc->channel_entry = devc->enabled_channels; rigol_ds_capture_start(sdi); /* Start of next frame. */ packet.type = SR_DF_FRAME_BEGIN; sr_session_send(cb_data, &packet); } } return TRUE; }
/* Start reading data from the current channel */ SR_PRIV int rigol_ds_channel_start(const struct sr_dev_inst *sdi) { struct dev_context *devc; struct sr_channel *ch; if (!(devc = sdi->priv)) return SR_ERR; ch = devc->channel_entry->data; sr_dbg("Starting reading data from channel %d", ch->index + 1); switch (devc->model->series->protocol) { case PROTOCOL_V1: case PROTOCOL_V2: if (ch->type == SR_CHANNEL_LOGIC) { if (sr_scpi_send(sdi->conn, ":WAV:DATA? DIG") != SR_OK) return SR_ERR; } else { if (sr_scpi_send(sdi->conn, ":WAV:DATA? CHAN%d", ch->index + 1) != SR_OK) return SR_ERR; } rigol_ds_set_wait_event(devc, WAIT_NONE); break; case PROTOCOL_V3: if (rigol_ds_config_set(sdi, ":WAV:SOUR CHAN%d", ch->index + 1) != SR_OK) return SR_ERR; if (devc->data_source != DATA_SOURCE_LIVE) { if (rigol_ds_config_set(sdi, ":WAV:RES") != SR_OK) return SR_ERR; if (rigol_ds_config_set(sdi, ":WAV:BEG") != SR_OK) return SR_ERR; } break; case PROTOCOL_V4: if (ch->type == SR_CHANNEL_ANALOG) { if (rigol_ds_config_set(sdi, ":WAV:SOUR CHAN%d", ch->index + 1) != SR_OK) return SR_ERR; } else { if (rigol_ds_config_set(sdi, ":WAV:SOUR D%d", ch->index) != SR_OK) return SR_ERR; } if (rigol_ds_config_set(sdi, devc->data_source == DATA_SOURCE_LIVE ? ":WAV:MODE NORM" :":WAV:MODE RAW") != SR_OK) return SR_ERR; break; } if (devc->model->series->protocol >= PROTOCOL_V3 && ch->type == SR_CHANNEL_ANALOG) { /* Vertical reference. */ if (sr_scpi_get_int(sdi->conn, ":WAV:YREF?", &devc->vert_reference[ch->index]) != SR_OK) return SR_ERR; } rigol_ds_set_wait_event(devc, WAIT_BLOCK); devc->num_channel_bytes = 0; devc->num_header_bytes = 0; devc->num_block_bytes = 0; return SR_OK; }
SR_PRIV int gwinstek_gds_800_receive_data(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; struct sr_scpi_dev_inst *scpi; struct dev_context *devc; struct sr_datafeed_packet packet; struct sr_datafeed_analog_old analog; char command[32]; char *response; float volts_per_division; int num_samples, i; float samples[MAX_SAMPLES]; uint32_t sample_rate; char *end_ptr; (void)fd; if (!(sdi = cb_data)) return TRUE; if (!(devc = sdi->priv)) return TRUE; scpi = sdi->conn; if (!(revents == G_IO_IN || revents == 0)) return TRUE; switch (devc->state) { case START_ACQUISITION: if (sr_scpi_send(scpi, ":TRIG:MOD 3") != SR_OK) { sr_err("Failed to set trigger mode to SINGLE."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } if (sr_scpi_send(scpi, ":STOP") != SR_OK) { sr_err("Failed to put the trigger system into STOP state."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } if (sr_scpi_send(scpi, ":RUN") != SR_OK) { sr_err("Failed to put the trigger system into RUN state."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } devc->cur_acq_channel = 0; devc->state = START_TRANSFER_OF_CHANNEL_DATA; break; case START_TRANSFER_OF_CHANNEL_DATA: if (((struct sr_channel *)g_slist_nth_data(sdi->channels, devc->cur_acq_channel))->enabled) { if (sr_scpi_send(scpi, ":ACQ%d:MEM?", devc->cur_acq_channel+1) != SR_OK) { sr_err("Failed to acquire memory."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } if (sr_scpi_read_begin(scpi) != SR_OK) { sr_err("Could not begin reading SCPI response."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } devc->state = WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE; devc->cur_rcv_buffer_position = 0; } else { /* All channels acquired. */ if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) { sr_spew("All channels acquired."); if (devc->cur_acq_frame == devc->frame_limit - 1) { /* All frames accquired. */ sr_spew("All frames acquired."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } else { /* Start acquiring next frame. */ if (devc->df_started) { packet.type = SR_DF_FRAME_END; sr_session_send(sdi, &packet); packet.type = SR_DF_FRAME_BEGIN; sr_session_send(sdi, &packet); } devc->cur_acq_frame++; devc->state = START_ACQUISITION; } } else { /* Start acquiring next channel. */ devc->cur_acq_channel++; } } break; case WAIT_FOR_TRANSFER_OF_BEGIN_TRANSMISSION_COMPLETE: if (read_data(sdi, scpi, devc, 1) == SR_OK) { if (devc->rcv_buffer[0] == '#') devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE; } break; case WAIT_FOR_TRANSFER_OF_DATA_SIZE_DIGIT_COMPLETE: if (read_data(sdi, scpi, devc, 1) == SR_OK) { if (devc->rcv_buffer[0] != '4' && devc->rcv_buffer[0] != '5' && devc->rcv_buffer[0] != '6') { sr_err("Data size digits is not 4, 5 or 6 but " "'%c'.", devc->rcv_buffer[0]); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } else { devc->data_size_digits = devc->rcv_buffer[0] - '0'; devc->state = WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE; } } break; case WAIT_FOR_TRANSFER_OF_DATA_SIZE_COMPLETE: if (read_data(sdi, scpi, devc, devc->data_size_digits) == SR_OK) { devc->rcv_buffer[devc->data_size_digits] = 0; if (sr_atoi(devc->rcv_buffer, &devc->data_size) != SR_OK) { sr_err("Could not parse data size '%s'", devc->rcv_buffer); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } else devc->state = WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE; } break; case WAIT_FOR_TRANSFER_OF_SAMPLE_RATE_COMPLETE: if (read_data(sdi, scpi, devc, sizeof(float)) == SR_OK) { /* * Contrary to the documentation, this field is * transfered with most significant byte first! */ sample_rate = RB32(devc->rcv_buffer); memcpy(&devc->sample_rate, &sample_rate, sizeof(float)); devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE; if (!devc->df_started) { std_session_send_df_header(sdi); packet.type = SR_DF_FRAME_BEGIN; sr_session_send(sdi, &packet); devc->df_started = TRUE; } } break; case WAIT_FOR_TRANSFER_OF_CHANNEL_INDICATOR_COMPLETE: if (read_data(sdi, scpi, devc, 1) == SR_OK) devc->state = WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE; break; case WAIT_FOR_TRANSFER_OF_RESERVED_DATA_COMPLETE: if (read_data(sdi, scpi, devc, 3) == SR_OK) devc->state = WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE; break; case WAIT_FOR_TRANSFER_OF_CHANNEL_DATA_COMPLETE: if (read_data(sdi, scpi, devc, devc->data_size - 8) == SR_OK) { /* Fetch data needed for conversion from device. */ snprintf(command, sizeof(command), ":CHAN%d:SCAL?", devc->cur_acq_channel + 1); if (sr_scpi_get_string(scpi, command, &response) != SR_OK) { sr_err("Failed to get volts per division."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } volts_per_division = g_ascii_strtod(response, &end_ptr); if (!strcmp(end_ptr, "mV")) volts_per_division *= 1.e-3; g_free(response); num_samples = (devc->data_size - 8) / 2; sr_spew("Received %d number of samples from channel " "%d.", num_samples, devc->cur_acq_channel + 1); /* Convert data. */ for (i = 0; i < num_samples; i++) samples[i] = ((float) ((int16_t) (RB16(&devc->rcv_buffer[i*2])))) / 256. * VERTICAL_DIVISIONS * volts_per_division; /* Fill frame. */ analog.channels = g_slist_append(NULL, g_slist_nth_data(sdi->channels, devc->cur_acq_channel)); analog.num_samples = num_samples; analog.data = samples; analog.mq = SR_MQ_VOLTAGE; analog.unit = SR_UNIT_VOLT; analog.mqflags = 0; packet.type = SR_DF_ANALOG_OLD; packet.payload = &analog; sr_session_send(sdi, &packet); g_slist_free(analog.channels); /* All channels acquired. */ if (devc->cur_acq_channel == ANALOG_CHANNELS - 1) { sr_spew("All channels acquired."); if (devc->cur_acq_frame == devc->frame_limit - 1) { /* All frames acquired. */ sr_spew("All frames acquired."); sdi->driver->dev_acquisition_stop(sdi); return TRUE; } else { /* Start acquiring next frame. */ if (devc->df_started) { packet.type = SR_DF_FRAME_END; sr_session_send(sdi, &packet); packet.type = SR_DF_FRAME_BEGIN; sr_session_send(sdi, &packet); } devc->cur_acq_frame++; devc->state = START_ACQUISITION; } } else { /* Start acquiring next channel. */ devc->state = START_TRANSFER_OF_CHANNEL_DATA; devc->cur_acq_channel++; return TRUE; } } break; } return TRUE; }
static int hmo_setup_channels(const struct sr_dev_inst *sdi) { GSList *l; unsigned int i; gboolean *pod_enabled, setup_changed; char command[MAX_COMMAND_SIZE]; struct scope_state *state; const struct scope_config *model; struct sr_channel *ch; struct dev_context *devc; struct sr_scpi_dev_inst *scpi; int ret; devc = sdi->priv; scpi = sdi->conn; state = devc->model_state; model = devc->model_config; setup_changed = FALSE; pod_enabled = g_try_malloc0(sizeof(gboolean) * model->digital_pods); for (l = sdi->channels; l; l = l->next) { ch = l->data; switch (ch->type) { case SR_CHANNEL_ANALOG: if (ch->enabled == state->analog_channels[ch->index].state) break; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE], ch->index + 1, ch->enabled); if (sr_scpi_send(scpi, command) != SR_OK) { g_free(pod_enabled); return SR_ERR; } state->analog_channels[ch->index].state = ch->enabled; setup_changed = TRUE; break; case SR_CHANNEL_LOGIC: /* * A digital POD needs to be enabled for every group of * 8 channels. */ if (ch->enabled) pod_enabled[ch->index < 8 ? 0 : 1] = TRUE; if (ch->enabled == state->digital_channels[ch->index]) break; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE], ch->index, ch->enabled); if (sr_scpi_send(scpi, command) != SR_OK) { g_free(pod_enabled); return SR_ERR; } state->digital_channels[ch->index] = ch->enabled; setup_changed = TRUE; break; default: g_free(pod_enabled); return SR_ERR; } } ret = SR_OK; for (i = 0; i < model->digital_pods; i++) { if (state->digital_pods[i] == pod_enabled[i]) continue; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_DIG_POD_STATE], i + 1, pod_enabled[i]); if (sr_scpi_send(scpi, command) != SR_OK) { ret = SR_ERR; break; } state->digital_pods[i] = pod_enabled[i]; setup_changed = TRUE; } g_free(pod_enabled); if (ret != SR_OK) return ret; if (setup_changed && hmo_update_sample_rate(sdi) != SR_OK) return SR_ERR; return SR_OK; }
static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { int ret, cg_type, idx, j; char command[MAX_COMMAND_SIZE], float_str[30]; struct dev_context *devc; const struct scope_config *model; struct scope_state *state; double tmp_d; gboolean update_sample_rate; if (!sdi) return SR_ERR_ARG; devc = sdi->priv; if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; model = devc->model_config; state = devc->model_state; update_sample_rate = FALSE; switch (key) { case SR_CONF_LIMIT_FRAMES: devc->frame_limit = g_variant_get_uint64(data); ret = SR_OK; break; case SR_CONF_TRIGGER_SOURCE: if ((idx = std_str_idx(data, *model->trigger_sources, model->num_trigger_sources)) < 0) return SR_ERR_ARG; state->trigger_source = idx; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE], (*model->trigger_sources)[idx]); ret = sr_scpi_send(sdi->conn, command); break; case SR_CONF_VDIV: if (!cg) return SR_ERR_CHANNEL_GROUP; if ((idx = std_u64_tuple_idx(data, *model->vdivs, model->num_vdivs)) < 0) return SR_ERR_ARG; if ((j = std_cg_idx(cg, devc->analog_groups, model->analog_channels)) < 0) return SR_ERR_ARG; state->analog_channels[j].vdiv = idx; g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) (*model->vdivs)[idx][0] / (*model->vdivs)[idx][1]); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV], j + 1, float_str); if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK) return SR_ERR; ret = SR_OK; break; case SR_CONF_TIMEBASE: if ((idx = std_u64_tuple_idx(data, *model->timebases, model->num_timebases)) < 0) return SR_ERR_ARG; state->timebase = idx; g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) (*model->timebases)[idx][0] / (*model->timebases)[idx][1]); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE], float_str); ret = sr_scpi_send(sdi->conn, command); update_sample_rate = TRUE; break; case SR_CONF_HORIZ_TRIGGERPOS: tmp_d = g_variant_get_double(data); if (tmp_d < 0.0 || tmp_d > 1.0) return SR_ERR; state->horiz_triggerpos = tmp_d; tmp_d = -(tmp_d - 0.5) * ((double) (*model->timebases)[state->timebase][0] / (*model->timebases)[state->timebase][1]) * model->num_xdivs; g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_HORIZ_TRIGGERPOS], float_str); ret = sr_scpi_send(sdi->conn, command); break; case SR_CONF_TRIGGER_SLOPE: if ((idx = std_str_idx(data, *model->trigger_slopes, model->num_trigger_slopes)) < 0) return SR_ERR_ARG; state->trigger_slope = idx; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SLOPE], (*model->trigger_slopes)[idx]); ret = sr_scpi_send(sdi->conn, command); break; case SR_CONF_COUPLING: if (!cg) return SR_ERR_CHANNEL_GROUP; if ((idx = std_str_idx(data, *model->coupling_options, model->num_coupling_options)) < 0) return SR_ERR_ARG; if ((j = std_cg_idx(cg, devc->analog_groups, model->analog_channels)) < 0) return SR_ERR_ARG; state->analog_channels[j].coupling = idx; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING], j + 1, (*model->coupling_options)[idx]); if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK) return SR_ERR; ret = SR_OK; break; default: ret = SR_ERR_NA; break; } if (ret == SR_OK) ret = sr_scpi_get_opc(sdi->conn); if (ret == SR_OK && update_sample_rate) ret = hmo_update_sample_rate(sdi); return ret; }
static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { int ret, cg_type; unsigned int i, j; char command[MAX_COMMAND_SIZE], float_str[30]; struct dev_context *devc; const struct scope_config *model; struct scope_state *state; const char *tmp; uint64_t p, q; double tmp_d; gboolean update_sample_rate; if (!sdi || !(devc = sdi->priv)) return SR_ERR_ARG; if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; model = devc->model_config; state = devc->model_state; update_sample_rate = FALSE; ret = SR_ERR_NA; switch (key) { case SR_CONF_LIMIT_FRAMES: devc->frame_limit = g_variant_get_uint64(data); ret = SR_OK; break; case SR_CONF_TRIGGER_SOURCE: tmp = g_variant_get_string(data, NULL); for (i = 0; (*model->trigger_sources)[i]; i++) { if (g_strcmp0(tmp, (*model->trigger_sources)[i]) != 0) continue; state->trigger_source = i; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE], (*model->trigger_sources)[i]); ret = sr_scpi_send(sdi->conn, command); break; } break; case SR_CONF_VDIV: if (cg_type == CG_NONE) { sr_err("No channel group specified."); return SR_ERR_CHANNEL_GROUP; } g_variant_get(data, "(tt)", &p, &q); for (i = 0; i < model->num_vdivs; i++) { if (p != (*model->vdivs)[i][0] || q != (*model->vdivs)[i][1]) continue; for (j = 1; j <= model->analog_channels; ++j) { if (cg != devc->analog_groups[j - 1]) continue; state->analog_channels[j - 1].vdiv = i; g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) p / q); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV], j, float_str); if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK) return SR_ERR; break; } ret = SR_OK; break; } break; case SR_CONF_TIMEBASE: g_variant_get(data, "(tt)", &p, &q); for (i = 0; i < model->num_timebases; i++) { if (p != (*model->timebases)[i][0] || q != (*model->timebases)[i][1]) continue; state->timebase = i; g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) p / q); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE], float_str); ret = sr_scpi_send(sdi->conn, command); update_sample_rate = TRUE; break; } break; case SR_CONF_HORIZ_TRIGGERPOS: tmp_d = g_variant_get_double(data); if (tmp_d < 0.0 || tmp_d > 1.0) return SR_ERR; state->horiz_triggerpos = tmp_d; tmp_d = -(tmp_d - 0.5) * ((double) (*model->timebases)[state->timebase][0] / (*model->timebases)[state->timebase][1]) * model->num_xdivs; g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_HORIZ_TRIGGERPOS], float_str); ret = sr_scpi_send(sdi->conn, command); break; case SR_CONF_TRIGGER_SLOPE: tmp = g_variant_get_string(data, NULL); if (!tmp || !(tmp[0] == 'f' || tmp[0] == 'r')) return SR_ERR_ARG; state->trigger_slope = (tmp[0] == 'r') ? 0 : 1; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SLOPE], (state->trigger_slope == 0) ? "POS" : "NEG"); ret = sr_scpi_send(sdi->conn, command); break; case SR_CONF_COUPLING: if (cg_type == CG_NONE) { sr_err("No channel group specified."); return SR_ERR_CHANNEL_GROUP; } tmp = g_variant_get_string(data, NULL); for (i = 0; (*model->coupling_options)[i]; i++) { if (strcmp(tmp, (*model->coupling_options)[i]) != 0) continue; for (j = 1; j <= model->analog_channels; ++j) { if (cg != devc->analog_groups[j - 1]) continue; state->analog_channels[j-1].coupling = i; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING], j, tmp); if (sr_scpi_send(sdi->conn, command) != SR_OK || sr_scpi_get_opc(sdi->conn) != SR_OK) return SR_ERR; break; } ret = SR_OK; break; } break; default: ret = SR_ERR_NA; break; } if (ret == SR_OK) ret = sr_scpi_get_opc(sdi->conn); if (ret == SR_OK && update_sample_rate) ret = hmo_update_sample_rate(sdi); return ret; }