X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Frigol-ds%2Fprotocol.c;h=1d2302f60c4bb949a99b7d9e0ea6b27e855fc7db;hb=904fd29b7255958f499719f4b7f8f653596e33c6;hp=e8bfb93fc66ba895266154a1ff346d6ec5adf1ed;hpb=355de5a1101076d29c8d1c223c1b07b2bb6b06b3;p=libsigrok.git diff --git a/hardware/rigol-ds/protocol.c b/hardware/rigol-ds/protocol.c index e8bfb93f..1d2302f6 100644 --- a/hardware/rigol-ds/protocol.c +++ b/hardware/rigol-ds/protocol.c @@ -91,12 +91,21 @@ static int parse_int(const char *str, int *ret) return SR_OK; } +/* Set the next event to wait for in rigol_ds_receive */ +static void rigol_ds_set_wait_event(struct dev_context *devc, enum wait_events event) +{ + if (event == WAIT_STOP) + devc->wait_status = 2; + else + devc->wait_status = 1; + devc->wait_event = event; +} + /* - * Waiting for a trigger event will return a timeout after 2, 3 seconds in - * order to not block the application. + * Waiting for a event will return a timeout after 2 to 3 seconds in order + * to not block the application. */ - -static int rigol_ds2xx2_trigger_wait(const struct sr_dev_inst *sdi) +static int rigol_ds_event_wait(const struct sr_dev_inst *sdi, char status1, char status2) { char buf[20]; struct dev_context *devc; @@ -109,14 +118,14 @@ static int rigol_ds2xx2_trigger_wait(const struct sr_dev_inst *sdi) /* * Trigger status may return: - * "TD" - triggered - * "AUTO" - autotriggered - * "RUN" - running - * "WAIT" - waiting for trigger - * "STOP" - stopped + * "TD" or "T'D" - triggered + * "AUTO" - autotriggered + * "RUN" - running + * "WAIT" - waiting for trigger + * "STOP" - stopped */ - if (devc->trigger_wait_status == 1) { + if (devc->wait_status == 1) { do { if (time(NULL) - start >= 3) { sr_dbg("Timeout waiting for trigger"); @@ -125,11 +134,11 @@ static int rigol_ds2xx2_trigger_wait(const struct sr_dev_inst *sdi) if (get_cfg(sdi, ":TRIG:STAT?", buf, sizeof(buf)) != SR_OK) return SR_ERR; - } while (buf[0] == 'T' || buf[0] == 'A'); + } while (buf[0] == status1 || buf[0] == status2); - devc->trigger_wait_status = 2; + devc->wait_status = 2; } - if (devc->trigger_wait_status == 2) { + if (devc->wait_status == 2) { do { if (time(NULL) - start >= 3) { sr_dbg("Timeout waiting for trigger"); @@ -138,92 +147,246 @@ static int rigol_ds2xx2_trigger_wait(const struct sr_dev_inst *sdi) if (get_cfg(sdi, ":TRIG:STAT?", buf, sizeof(buf)) != SR_OK) return SR_ERR; - } while (buf[0] != 'T' && buf[0] != 'A'); + } while (buf[0] != status1 && buf[0] != status2); - devc->trigger_wait_status = 0; + rigol_ds_set_wait_event(devc, WAIT_NONE); } return SR_OK; } /* - * This needs to wait for a new trigger event to ensure that sample data is - * not returned twice. + * For live capture we need to wait for a new trigger event to ensure that + * sample data is not returned twice. * * Unfortunately this will never really work because for sufficiently fast - * timebases it just can't catch the status changes. + * timebases and trigger rates it just can't catch the status changes. * * What would be needed is a trigger event register with autoreset like the * Agilents have. The Rigols don't seem to have anything like this. * * The workaround is to only wait for the trigger when the timebase is slow * enough. Of course this means that for faster timebases sample data can be - * returned multiple times. + * returned multiple times, this effect is mitigated somewhat by sleeping + * for about one sweep time in that case. */ +static int rigol_ds_trigger_wait(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + long s; + + if (!(devc = sdi->priv)) + return SR_ERR; + + /* + * If timebase < 50 msecs/DIV just sleep about one sweep time except + * for really fast sweeps. + */ + if (devc->timebase < 0.0499) { + if (devc->timebase > 0.99e-6) { + /* + * Timebase * num hor. divs * 85(%) * 1e6(usecs) / 100 + * -> 85 percent of sweep time + */ + s = (devc->timebase * devc->model->num_horizontal_divs + * 85e6) / 100L; + sr_spew("Sleeping for %ld usecs instead of trigger-wait", s); + g_usleep(s); + } + rigol_ds_set_wait_event(devc, WAIT_NONE); + return SR_OK; + } else { + return rigol_ds_event_wait(sdi, 'T', 'A'); + } +} -SR_PRIV int rigol_ds2xx2_acquisition_start(const struct sr_dev_inst *sdi, - gboolean wait_for_trigger) +/* Wait for scope to got to "Stop" in single shot mode */ +static int rigol_ds_stop_wait(const struct sr_dev_inst *sdi) +{ + return rigol_ds_event_wait(sdi, 'S', 'S'); +} + +/* Check that a single shot acquisition actually succeeded on the DS2000 */ +static int rigol_ds_check_stop(const struct sr_dev_inst *sdi) { struct dev_context *devc; + struct sr_probe *probe; + int tmp; if (!(devc = sdi->priv)) return SR_ERR; - sr_dbg("Starting acquisition on channel %d", - devc->channel_frame->index + 1); + probe = devc->channel_entry->data; - if (rigol_ds_send(sdi, ":WAV:FORM BYTE") != SR_OK) + if (sr_scpi_send(sdi->conn, ":WAV:SOUR CHAN%d", + probe->index + 1) != SR_OK) return SR_ERR; - if (rigol_ds_send(sdi, ":WAV:SOUR CHAN%d", - devc->channel_frame->index + 1) != SR_OK) + /* Check that the number of samples will be accepted */ + if (sr_scpi_send(sdi->conn, ":WAV:POIN %d;*OPC", devc->analog_frame_size) != SR_OK) return SR_ERR; - if (rigol_ds_send(sdi, ":WAV:MODE NORM") != SR_OK) + if (get_cfg_int(sdi, "*ESR?", &tmp) != SR_OK) return SR_ERR; + /* + * If we get an "Execution error" the scope went from "Single" to + * "Stop" without actually triggering. There is no waveform + * displayed and trying to download one will fail - the scope thinks + * it has 1400 samples (like display memory) and the driver thinks + * it has a different number of samples. + * + * In that case just try to capture something again. Might still + * fail in interesting ways. + * + * Ain't firmware fun? + */ + if (tmp & 0x10) { + sr_warn("Single shot acquisition failed, retrying..."); + /* Sleep a bit, otherwise the single shot will often fail */ + g_usleep(500000); + sr_scpi_send(sdi->conn, ":SING"); + rigol_ds_set_wait_event(devc, WAIT_STOP); + return SR_ERR; + } - devc->num_frame_bytes = 0; - devc->num_block_bytes = 0; + return SR_OK; +} + +/* Wait for enough data becoming available in scope output buffer */ +static int rigol_ds_block_wait(const struct sr_dev_inst *sdi) +{ + char buf[30]; + struct dev_context *devc; + time_t start; + int len; + + if (!(devc = sdi->priv)) + return SR_ERR; + + start = time(NULL); + + do { + if (time(NULL) - start >= 3) { + sr_dbg("Timeout waiting for data block"); + return SR_ERR_TIMEOUT; + } - /* only wait for trigger if timbase 50 msecs/DIV or slower */ - if (wait_for_trigger && devc->timebase > 0.0499) - { - devc->trigger_wait_status = 1; + /* + * The scope copies data really slowly from sample + * memory to its output buffer, so try not to bother + * it too much with SCPI requests but don't wait too + * long for short sample frame sizes. + */ + g_usleep(devc->analog_frame_size < 15000 ? 100000 : 1000000); + + /* "READ,nnnn" (still working) or "IDLE,nnnn" (finished) */ + if (get_cfg(sdi, ":WAV:STAT?", buf, sizeof(buf)) != SR_OK) + return SR_ERR; + + if (parse_int(buf + 5, &len) != SR_OK) + return SR_ERR; + } while (buf[0] == 'R' && len < 1000000); + + rigol_ds_set_wait_event(devc, WAIT_NONE); + + return SR_OK; +} + +/* Start capturing a new frameset */ +SR_PRIV int rigol_ds_capture_start(const struct sr_dev_inst *sdi) +{ + struct dev_context *devc; + + if (!(devc = sdi->priv)) + return SR_ERR; + + sr_dbg("Starting data capture for frameset %lu of %lu", + devc->num_frames + 1, devc->limit_frames); + + if (sr_scpi_send(sdi->conn, ":WAV:FORM BYTE") != SR_OK) + return SR_ERR; + if (devc->data_source == DATA_SOURCE_LIVE) { + if (sr_scpi_send(sdi->conn, ":WAV:MODE NORM") != SR_OK) + return SR_ERR; + rigol_ds_set_wait_event(devc, WAIT_TRIGGER); + } else { + if (sr_scpi_send(sdi->conn, ":WAV:MODE RAW") != SR_OK) + return SR_ERR; + if (sr_scpi_send(sdi->conn, ":SING", devc->analog_frame_size) != SR_OK) + return SR_ERR; + rigol_ds_set_wait_event(devc, WAIT_STOP); + } + + return SR_OK; +} + +/* 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_probe *probe; + + if (!(devc = sdi->priv)) + return SR_ERR; + + probe = devc->channel_entry->data; + + sr_dbg("Starting reading data from channel %d", probe->index + 1); + + if (devc->model->protocol == PROTOCOL_LEGACY) { + if (probe->type == SR_PROBE_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", + probe->index + 1) != SR_OK) + return SR_ERR; + } } else { - devc->trigger_wait_status = 0; + if (sr_scpi_send(sdi->conn, ":WAV:SOUR CHAN%d", + probe->index + 1) != SR_OK) + return SR_ERR; + if (devc->data_source != DATA_SOURCE_LIVE) { + if (sr_scpi_send(sdi->conn, ":WAV:RES") != SR_OK) + return SR_ERR; + if (sr_scpi_send(sdi->conn, ":WAV:BEG") != SR_OK) + return SR_ERR; + rigol_ds_set_wait_event(devc, WAIT_BLOCK); + } else + rigol_ds_set_wait_event(devc, WAIT_NONE); } + devc->num_frame_samples = 0; + devc->num_block_bytes = 0; + return SR_OK; } -static int rigol_ds2xx2_read_header(struct sr_serial_dev_inst *serial) +/* Read the header of a data block */ +static int rigol_ds_read_header(struct sr_scpi_dev_inst *scpi) { char start[3], length[10]; int len, tmp; /* Read the hashsign and length digit. */ - tmp = serial_read(serial, start, 2); + tmp = sr_scpi_read_data(scpi, start, 2); start[2] = '\0'; - if (tmp != 2) - { + if (tmp != 2) { sr_err("Failed to read first two bytes of data block header."); return -1; } - if (start[0] != '#' || !isdigit(start[1]) || start[1] == '0') - { + if (start[0] != '#' || !isdigit(start[1]) || start[1] == '0') { sr_err("Received invalid data block header start '%s'.", start); return -1; } len = atoi(start + 1); /* Read the data length. */ - tmp = serial_read(serial, length, len); + tmp = sr_scpi_read_data(scpi, length, len); length[len] = '\0'; - if (tmp != len) - { + if (tmp != len) { sr_err("Failed to read %d bytes of data block length.", len); return -1; } - if (parse_int(length, &len) != SR_OK) - { + if (parse_int(length, &len) != SR_OK) { sr_err("Received invalid data block length '%s'.", length); return -1; } @@ -236,15 +399,13 @@ static int rigol_ds2xx2_read_header(struct sr_serial_dev_inst *serial) SR_PRIV int rigol_ds_receive(int fd, int revents, void *cb_data) { struct sr_dev_inst *sdi; - struct sr_serial_dev_inst *serial; + struct sr_scpi_dev_inst *scpi; struct dev_context *devc; struct sr_datafeed_packet packet; struct sr_datafeed_analog analog; struct sr_datafeed_logic logic; - unsigned char buf[DS2000_ANALOG_WAVEFORM_SIZE]; double vdiv, offset; - float data[DS2000_ANALOG_WAVEFORM_SIZE]; - int len, i, waveform_size, vref; + int len, i, vref; struct sr_probe *probe; (void)fd; @@ -255,70 +416,104 @@ SR_PRIV int rigol_ds_receive(int fd, int revents, void *cb_data) if (!(devc = sdi->priv)) return TRUE; - serial = sdi->conn; + scpi = sdi->conn; - if (revents == G_IO_IN) { - if (devc->trigger_wait_status > 0) { - if (rigol_ds2xx2_trigger_wait(sdi) != SR_OK) + if (revents == G_IO_IN || revents == 0) { + if (devc->model->protocol == PROTOCOL_IEEE488_2) { + 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; + break; + 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"); + } } - if (devc->model->series == 2 && devc->num_block_bytes == 0) { - sr_dbg("New block header expected"); - if (rigol_ds_send(sdi, ":WAV:DATA?") != SR_OK) - return TRUE; - len = rigol_ds2xx2_read_header(serial); - if (len == -1) - return TRUE; - /* At slow timebases the scope 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 (len < DS2000_ANALOG_WAVEFORM_SIZE) { - sr_dbg("Discarding short data block"); - serial_read(serial, buf, len + 1); + probe = devc->channel_entry->data; + + if (devc->num_block_bytes == 0 && + devc->model->protocol == PROTOCOL_IEEE488_2) { + if (sr_scpi_send(sdi->conn, ":WAV:DATA?") != SR_OK) + return TRUE; + } + + if (devc->num_block_bytes == 0) { + if (sr_scpi_read_begin(scpi) != SR_OK) return TRUE; + if (devc->model->protocol == PROTOCOL_IEEE488_2) { + sr_dbg("New block header expected"); + len = rigol_ds_read_header(scpi); + if (len == -1) + 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 < devc->num_frame_samples) { + 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 = probe->type == SR_PROBE_ANALOG ? + (devc->model->series == RIGOL_VS5000 ? + VS5000_ANALOG_LIVE_WAVEFORM_SIZE : + DS1000_ANALOG_LIVE_WAVEFORM_SIZE) : + DIGITAL_WAVEFORM_SIZE; } - devc->num_block_bytes = len; devc->num_block_read = 0; } - probe = devc->channel_frame; - if (devc->model->series == 2) { - len = devc->num_block_bytes - devc->num_block_read; - len = serial_read(serial, buf, - len < DS2000_ANALOG_WAVEFORM_SIZE ? len : DS2000_ANALOG_WAVEFORM_SIZE); - } else { - waveform_size = probe->type == SR_PROBE_ANALOG ? - DS1000_ANALOG_WAVEFORM_SIZE : DIGITAL_WAVEFORM_SIZE; - len = serial_read(serial, buf, waveform_size - devc->num_frame_bytes); - } + len = devc->num_block_bytes - devc->num_block_read; + len = sr_scpi_read_data(scpi, (char *)devc->buffer, + len < ACQ_BUFFER_SIZE ? len : ACQ_BUFFER_SIZE); + sr_dbg("Received %d bytes.", len); if (len == -1) return TRUE; - if (devc->num_frame_bytes == 0) { + devc->num_block_read += len; + + if (devc->num_frame_samples == 0) { /* Start of a new frame. */ packet.type = SR_DF_FRAME_BEGIN; sr_session_send(sdi, &packet); } if (probe->type == SR_PROBE_ANALOG) { - if (devc->model->series == 2) - devc->num_block_read += len; vref = devc->vert_reference[probe->index]; vdiv = devc->vdiv[probe->index] / 25.6; offset = devc->vert_offset[probe->index]; - if (devc->model->series == 2) + if (devc->model->protocol == PROTOCOL_IEEE488_2) for (i = 0; i < len; i++) - data[i] = ((int)buf[i] - vref) * vdiv - offset; + devc->data[i] = ((int)devc->buffer[i] - vref) * vdiv - offset; else for (i = 0; i < len; i++) - data[i] = (128 - buf[i]) * vdiv - offset; + devc->data[i] = (128 - devc->buffer[i]) * vdiv - offset; analog.probes = g_slist_append(NULL, probe); analog.num_samples = len; - analog.data = data; + analog.data = devc->data; analog.mq = SR_MQ_VOLTAGE; analog.unit = SR_UNIT_VOLT; analog.mqflags = 0; @@ -326,84 +521,78 @@ SR_PRIV int rigol_ds_receive(int fd, int revents, void *cb_data) packet.payload = &analog; sr_session_send(cb_data, &packet); g_slist_free(analog.probes); - - if (devc->model->series == 2) { - devc->num_frame_bytes += len; - - if (devc->num_frame_bytes < DS2000_ANALOG_WAVEFORM_SIZE) - /* Don't have the whole frame yet. */ - return TRUE; - - sr_dbg("Frame completed, %d samples", devc->num_frame_bytes); - } else { - if (len != DS1000_ANALOG_WAVEFORM_SIZE) - /* Don't have the whole frame yet. */ - return TRUE; - } } else { logic.length = len - 10; logic.unitsize = 2; - logic.data = buf + 10; + logic.data = devc->buffer + 10; packet.type = SR_DF_LOGIC; packet.payload = &logic; sr_session_send(cb_data, &packet); + } - if (len != DIGITAL_WAVEFORM_SIZE) - /* Don't have the whole frame yet. */ - return TRUE; + if (devc->num_block_read == devc->num_block_bytes) { + sr_dbg("Block has been completed"); + if (devc->model->protocol == PROTOCOL_IEEE488_2) { + /* Discard the terminating linefeed and prepare for + possible next block */ + sr_scpi_read_data(scpi, (char *)devc->buffer, 1); + devc->num_block_bytes = 0; + if (devc->data_source != DATA_SOURCE_LIVE) + rigol_ds_set_wait_event(devc, WAIT_BLOCK); + } + devc->num_block_read = 0; + } else { + sr_dbg("%d of %d block bytes read", devc->num_block_read, devc->num_block_bytes); } + devc->num_frame_samples += len; + + if (devc->num_frame_samples < (probe->type == SR_PROBE_ANALOG ? + devc->analog_frame_size : DIGITAL_WAVEFORM_SIZE)) + /* Don't have the whole frame yet. */ + return TRUE; + /* End of the frame. */ + sr_dbg("Frame completed, %d samples", devc->num_frame_samples); packet.type = SR_DF_FRAME_END; sr_session_send(sdi, &packet); - if (devc->model->series == 1) - devc->num_frame_bytes = 0; - - if (devc->enabled_analog_probes - && devc->channel_frame == devc->enabled_analog_probes->data - && devc->enabled_analog_probes->next != NULL) { - /* We got the frame for the first analog channel, but - * there's a second analog channel. */ - devc->channel_frame = devc->enabled_analog_probes->next->data; - if (devc->model->series == 2) { - /* Do not wait for trigger to try and keep channel data related. */ - rigol_ds2xx2_acquisition_start(sdi, FALSE); - } else { - rigol_ds_send(sdi, ":WAV:DATA? CHAN%c", - devc->channel_frame->name[2]); - } + if (devc->model->protocol == PROTOCOL_IEEE488_2) { + /* 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... + */ + sr_scpi_send(sdi->conn, ":WAV:END"); + } + + if (probe->type == SR_PROBE_ANALOG + && devc->channel_entry->next != NULL) { + /* We got the frame for this analog channel, but + * there's another analog channel. */ + devc->channel_entry = devc->channel_entry->next; + rigol_ds_channel_start(sdi); } else { - /* Done with both analog channels in this frame. */ + /* Done with all analog channels in this frame. */ if (devc->enabled_digital_probes - && devc->channel_frame != devc->enabled_digital_probes->data) { + && devc->channel_entry != devc->enabled_digital_probes) { /* Now we need to get the digital data. */ - devc->channel_frame = devc->enabled_digital_probes->data; - rigol_ds_send(sdi, ":WAV:DATA? DIG"); + devc->channel_entry = devc->enabled_digital_probes; + rigol_ds_channel_start(sdi); } else if (++devc->num_frames == devc->limit_frames) { - /* End of last frame. */ - packet.type = SR_DF_END; - sr_session_send(sdi, &packet); sdi->driver->dev_acquisition_stop(sdi, cb_data); } else { /* Get the next frame, starting with the first analog channel. */ - if (devc->model->series == 2) { - if (devc->enabled_analog_probes) { - devc->channel_frame = devc->enabled_analog_probes->data; - /* Must wait for trigger because at - * slow timebases the scope will - * return old data otherwise. */ - rigol_ds2xx2_acquisition_start(sdi, TRUE); - } - } else { - if (devc->enabled_analog_probes) { - devc->channel_frame = devc->enabled_analog_probes->data; - rigol_ds_send(sdi, ":WAV:DATA? CHAN%c", - devc->channel_frame->name[2]); - } else { - devc->channel_frame = devc->enabled_digital_probes->data; - rigol_ds_send(sdi, ":WAV:DATA? DIG"); - } - } + if (devc->enabled_analog_probes) + devc->channel_entry = devc->enabled_analog_probes; + else + devc->channel_entry = devc->enabled_digital_probes; + + if (devc->model->protocol == PROTOCOL_LEGACY) + rigol_ds_channel_start(sdi); + else + rigol_ds_capture_start(sdi); } } } @@ -411,43 +600,21 @@ SR_PRIV int rigol_ds_receive(int fd, int revents, void *cb_data) return TRUE; } -SR_PRIV int rigol_ds_send(const struct sr_dev_inst *sdi, const char *format, ...) -{ - va_list args; - char buf[256]; - int len, out, ret; - - va_start(args, format); - len = vsnprintf(buf, 255, format, args); - va_end(args); - strcat(buf, "\n"); - len++; - out = serial_write(sdi->conn, buf, len); - buf[len - 1] = '\0'; - if (out != len) { - sr_dbg("Only sent %d/%d bytes of '%s'.", out, len, buf); - ret = SR_ERR; - } else { - sr_spew("Sent '%s'.", buf); - ret = SR_OK; - } - - return ret; -} - static int get_cfg(const struct sr_dev_inst *sdi, char *cmd, char *reply, size_t maxlen) { int len; struct dev_context *devc = sdi->priv; + struct sr_scpi_dev_inst *scpi = sdi->conn; + char *response; - if (rigol_ds_send(sdi, cmd) != SR_OK) + if (sr_scpi_get_string(scpi, cmd, &response) != SR_OK) return SR_ERR; - if ((len = serial_read(sdi->conn, reply, maxlen - 1)) < 0) - return SR_ERR; - reply[len] = '\0'; + g_strlcpy(reply, response, maxlen); + g_free(response); + len = strlen(reply); - if (devc->model->series == 2) { + if (devc->model->protocol == PROTOCOL_IEEE488_2) { /* get rid of trailing linefeed */ if (len >= 1 && reply[len-1] == '\n') reply[len-1] = '\0'; @@ -501,26 +668,31 @@ SR_PRIV int rigol_ds_get_dev_cfg(const struct sr_dev_inst *sdi) { struct dev_context *devc; char *t_s, *cmd; - int i, res; + unsigned int i; + int res; devc = sdi->priv; /* Analog channel state. */ - if (get_cfg_string(sdi, ":CHAN1:DISP?", &t_s) != SR_OK) - return SR_ERR; - devc->analog_channels[0] = !strcmp(t_s, "ON") || !strcmp(t_s, "1"); - g_free(t_s); - if (get_cfg_string(sdi, ":CHAN2:DISP?", &t_s) != SR_OK) - return SR_ERR; - devc->analog_channels[1] = !strcmp(t_s, "ON") || !strcmp(t_s, "1"); - g_free(t_s); - sr_dbg("Current analog channel state CH1 %s CH2 %s", - devc->analog_channels[0] ? "on" : "off", - devc->analog_channels[1] ? "on" : "off"); + for (i = 0; i < devc->model->analog_channels; i++) { + cmd = g_strdup_printf(":CHAN%d:DISP?", i + 1); + res = get_cfg_string(sdi, cmd, &t_s); + g_free(cmd); + if (res != SR_OK) + return SR_ERR; + devc->analog_channels[i] = !strcmp(t_s, "ON") || !strcmp(t_s, "1"); + } + sr_dbg("Current analog channel state:"); + for (i = 0; i < devc->model->analog_channels; i++) + sr_dbg("CH%d %s", i + 1, devc->analog_channels[i] ? "on" : "off"); /* Digital channel state. */ if (devc->model->has_digital) { - sr_dbg("Current digital channel state:"); + if (get_cfg_string(sdi, ":LA:DISP?", &t_s) != SR_OK) + return SR_ERR; + devc->la_enabled = !strcmp(t_s, "ON") ? TRUE : FALSE; + sr_dbg("Logic analyzer %s, current digital channel state:", + devc->la_enabled ? "enabled" : "disabled"); for (i = 0; i < 16; i++) { cmd = g_strdup_printf(":DIG%d:TURN?", i); res = get_cfg_string(sdi, cmd, &t_s); @@ -539,41 +711,52 @@ SR_PRIV int rigol_ds_get_dev_cfg(const struct sr_dev_inst *sdi) sr_dbg("Current timebase %g", devc->timebase); /* Vertical gain. */ - if (get_cfg_float(sdi, ":CHAN1:SCAL?", &devc->vdiv[0]) != SR_OK) - return SR_ERR; - if (get_cfg_float(sdi, ":CHAN2:SCAL?", &devc->vdiv[1]) != SR_OK) - return SR_ERR; - sr_dbg("Current vertical gain CH1 %g CH2 %g", devc->vdiv[0], devc->vdiv[1]); + for (i = 0; i < devc->model->analog_channels; i++) { + cmd = g_strdup_printf(":CHAN%d:SCAL?", i + 1); + res = get_cfg_float(sdi, cmd, &devc->vdiv[i]); + g_free(cmd); + if (res != SR_OK) + return SR_ERR; + } + sr_dbg("Current vertical gain:"); + for (i = 0; i < devc->model->analog_channels; i++) + sr_dbg("CH%d %g", i + 1, devc->vdiv[i]); - if (devc->model->series == 2) { + sr_dbg("Current vertical reference:"); + if (devc->model->protocol == PROTOCOL_IEEE488_2) { /* Vertical reference - not certain if this is the place to read it. */ - if (rigol_ds_send(sdi, ":WAV:SOUR CHAN1") != SR_OK) - return SR_ERR; - if (get_cfg_int(sdi, ":WAV:YREF?", &devc->vert_reference[0]) != SR_OK) - return SR_ERR; - if (rigol_ds_send(sdi, ":WAV:SOUR CHAN2") != SR_OK) - return SR_ERR; - if (get_cfg_int(sdi, ":WAV:YREF?", &devc->vert_reference[1]) != SR_OK) - return SR_ERR; - sr_dbg("Current vertical reference CH1 %d CH2 %d", - devc->vert_reference[0], devc->vert_reference[1]); + for (i = 0; i < devc->model->analog_channels; i++) { + if (sr_scpi_send(sdi->conn, ":WAV:SOUR CHAN%d", i + 1) != SR_OK) + return SR_ERR; + if (get_cfg_int(sdi, ":WAV:YREF?", &devc->vert_reference[i]) != SR_OK) + return SR_ERR; + sr_dbg("CH%d %d", i + 1, devc->vert_reference[i]); + } } /* Vertical offset. */ - if (get_cfg_float(sdi, ":CHAN1:OFFS?", &devc->vert_offset[0]) != SR_OK) - return SR_ERR; - if (get_cfg_float(sdi, ":CHAN2:OFFS?", &devc->vert_offset[1]) != SR_OK) - return SR_ERR; - sr_dbg("Current vertical offset CH1 %g CH2 %g", devc->vert_offset[0], - devc->vert_offset[1]); + for (i = 0; i < devc->model->analog_channels; i++) { + cmd = g_strdup_printf(":CHAN%d:OFFS?", i + 1); + res = get_cfg_float(sdi, cmd, &devc->vert_offset[i]); + g_free(cmd); + if (res != SR_OK) + return SR_ERR; + } + sr_dbg("Current vertical offset:"); + for (i = 0; i < devc->model->analog_channels; i++) + sr_dbg("CH%d %g", i + 1, devc->vert_offset[i]); /* Coupling. */ - if (get_cfg_string(sdi, ":CHAN1:COUP?", &devc->coupling[0]) != SR_OK) - return SR_ERR; - if (get_cfg_string(sdi, ":CHAN2:COUP?", &devc->coupling[1]) != SR_OK) - return SR_ERR; - sr_dbg("Current coupling CH1 %s CH2 %s", devc->coupling[0], - devc->coupling[1]); + for (i = 0; i < devc->model->analog_channels; i++) { + cmd = g_strdup_printf(":CHAN%d:COUP?", i + 1); + res = get_cfg_string(sdi, cmd, &devc->coupling[i]); + g_free(cmd); + if (res != SR_OK) + return SR_ERR; + } + sr_dbg("Current coupling:"); + for (i = 0; i < devc->model->analog_channels; i++) + sr_dbg("CH%d %s", i + 1, devc->coupling[i]); /* Trigger source. */ if (get_cfg_string(sdi, ":TRIG:EDGE:SOUR?", &devc->trigger_source) != SR_OK)