SR_CONF_SERIALCOMM
};
-static const uint32_t devopts[] = {
+static const uint32_t drvopts[] = {
SR_CONF_OSCILLOSCOPE,
+};
+
+static const uint32_t devopts[] = {
SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
+ SR_CONF_SAMPLERATE | SR_CONF_GET,
SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
+ SR_CONF_NUM_HDIV | SR_CONF_GET,
+ SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
- SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
- SR_CONF_NUM_HDIV | SR_CONF_GET,
- SR_CONF_SAMPLERATE | SR_CONF_GET,
+ SR_CONF_TRIGGER_LEVEL | SR_CONF_GET | SR_CONF_SET,
SR_CONF_DATA_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
};
SR_CONF_NUM_VDIV | SR_CONF_GET,
SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
+ SR_CONF_PROBE_FACTOR | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
};
static const uint64_t timebases[][2] = {
"GND",
};
+static const uint64_t probe_factor[] = {
+ 1,
+ 2,
+ 5,
+ 10,
+ 20,
+ 50,
+ 100,
+ 200,
+ 500,
+ 1000,
+};
+
/* Do not change the order of entries */
static const char *data_sources[] = {
"Live",
{SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
{SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
{SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
+ {SERIES(DS2000A), "MSO2072A", {5, 1000000000}, 2, true},
+ {SERIES(DS2000A), "MSO2102A", {5, 1000000000}, 2, true},
+ {SERIES(DS2000A), "MSO2202A", {2, 1000000000}, 2, true},
+ {SERIES(DS2000A), "MSO2302A", {1, 1000000000}, 2, true},
{SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
{SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
{SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
{SERIES(DS1000Z), "DS1104Z", {5, 1000000000}, 4, false},
{SERIES(DS1000Z), "DS1074Z-S", {5, 1000000000}, 4, false},
{SERIES(DS1000Z), "DS1104Z-S", {5, 1000000000}, 4, false},
+ {SERIES(DS1000Z), "DS1074Z Plus", {5, 1000000000}, 4, false},
+ {SERIES(DS1000Z), "DS1104Z Plus", {5, 1000000000}, 4, false},
{SERIES(DS1000Z), "MSO1074Z", {5, 1000000000}, 4, true},
{SERIES(DS1000Z), "MSO1104Z", {5, 1000000000}, 4, true},
{SERIES(DS1000Z), "MSO1074Z-S", {5, 1000000000}, 4, true},
{SERIES(DS1000Z), "MSO1104Z-S", {5, 1000000000}, 4, true},
};
-SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
+static struct sr_dev_driver rigol_ds_driver_info;
static void clear_helper(void *priv)
{
return std_dev_clear(di, clear_helper);
}
-static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
-{
- return std_init(di, sr_ctx);
-}
-
static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
{
struct dev_context *devc;
int idx = -1;
unsigned i;
- if (!sdi || !(devc = sdi->priv))
+ if (!sdi)
return SR_ERR_ARG;
+ devc = sdi->priv;
+
/* If a channel group is specified, it must be a valid one. */
if (cg && !g_slist_find(sdi->channel_groups, cg)) {
sr_err("Invalid channel group specified.");
}
*data = g_variant_new_string(tmp_str);
break;
+ case SR_CONF_TRIGGER_LEVEL:
+ *data = g_variant_new_double(devc->trigger_level);
+ break;
case SR_CONF_TIMEBASE:
for (i = 0; i < devc->num_timebases; i++) {
float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
}
*data = g_variant_new_string(devc->coupling[analog_channel]);
break;
+ case SR_CONF_PROBE_FACTOR:
+ if (analog_channel < 0) {
+ sr_dbg("Negative analog channel: %d.", analog_channel);
+ return SR_ERR_NA;
+ }
+ *data = g_variant_new_uint64(devc->attenuation[analog_channel]);
+ break;
default:
return SR_ERR_NA;
}
const char *tmp_str;
char buffer[16];
- if (!(devc = sdi->priv))
- return SR_ERR_ARG;
+ devc = sdi->priv;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
break;
+ case SR_CONF_TRIGGER_LEVEL:
+ t_dbl = g_variant_get_double(data);
+ g_ascii_formatd(buffer, sizeof(buffer), "%.3f", t_dbl);
+ ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:LEV %s", buffer);
+ if (ret == SR_OK)
+ devc->trigger_level = t_dbl;
+ break;
case SR_CONF_TIMEBASE:
g_variant_get(data, "(tt)", &p, &q);
for (i = 0; i < devc->num_timebases; i++) {
}
sr_dbg("Didn't set coupling, unknown channel(group).");
return SR_ERR_NA;
+ case SR_CONF_PROBE_FACTOR:
+ if (!cg) {
+ sr_err("No channel group specified.");
+ return SR_ERR_CHANNEL_GROUP;
+ }
+ p = g_variant_get_uint64(data);
+ for (i = 0; i < devc->model->analog_channels; i++) {
+ if (cg == devc->analog_groups[i]) {
+ for (j = 0; j < ARRAY_SIZE(probe_factor); j++) {
+ if (p == probe_factor[j]) {
+ devc->attenuation[i] = p;
+ ret = rigol_ds_config_set(sdi, ":CHAN%d:PROB %"PRIu64,
+ i + 1, p);
+ if (ret == SR_OK)
+ rigol_ds_get_dev_cfg_vertical(sdi);
+ return ret;
+ }
+ }
+ sr_err("Invalid probe factor: %"PRIu64".", p);
+ return SR_ERR_ARG;
+ }
+ }
+ sr_dbg("Didn't set probe factor, unknown channel(group).");
+ return SR_ERR_NA;
case SR_CONF_DATA_SOURCE:
tmp_str = g_variant_get_string(data, NULL);
if (!strcmp(tmp_str, "Live"))
unsigned int i;
struct dev_context *devc = NULL;
+ /* SR_CONF_SCAN_OPTIONS is always valid, regardless of sdi or channel group. */
if (key == SR_CONF_SCAN_OPTIONS) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
- } else if (key == SR_CONF_DEVICE_OPTIONS && !cg) {
+ }
+
+ /* If sdi is NULL, nothing except SR_CONF_DEVICE_OPTIONS can be provided. */
+ if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
- devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
+ drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
return SR_OK;
}
/* Every other option requires a valid device instance. */
- if (!sdi || !(devc = sdi->priv))
+ if (!sdi)
return SR_ERR_ARG;
+ devc = sdi->priv;
/* If a channel group is specified, it must be a valid one. */
if (cg && !g_slist_find(sdi->channel_groups, cg)) {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
if (!cg) {
- sr_err("No channel group specified.");
- return SR_ERR_CHANNEL_GROUP;
+ /* If cg is NULL, only the SR_CONF_DEVICE_OPTIONS that are not
+ * specific to a channel group must be returned. */
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
+ devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
+ return SR_OK;
}
if (cg == devc->digital_group) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
}
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
+ case SR_CONF_PROBE_FACTOR:
+ if (!cg) {
+ sr_err("No channel group specified.");
+ return SR_ERR_CHANNEL_GROUP;
+ }
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT64,
+ probe_factor, ARRAY_SIZE(probe_factor), sizeof(uint64_t));
+ break;
case SR_CONF_VDIV:
if (!devc)
/* Can't know this until we have the exact model. */
devc->analog_channels[ch->index] = ch->enabled;
}
} else if (ch->type == SR_CHANNEL_LOGIC) {
- /* Only one list entry for DS1000D series. All channels are retrieved
- * together when this entry is processed. */
+ /* Only one list entry for older protocols. All channels are
+ * retrieved together when this entry is processed. */
if (ch->enabled && (
- devc->model->series->protocol > PROTOCOL_V2 ||
+ devc->model->series->protocol > PROTOCOL_V3 ||
!some_digital))
devc->enabled_channels = g_slist_append(
devc->enabled_channels, ch);
/* Turn on LA module if currently off. */
if (!devc->la_enabled) {
if (rigol_ds_config_set(sdi,
- devc->model->series->protocol >= PROTOCOL_V4 ?
+ devc->model->series->protocol >= PROTOCOL_V3 ?
":LA:STAT ON" : ":LA:DISP ON") != SR_OK)
return SR_ERR;
devc->la_enabled = TRUE;
if (ch->enabled != devc->digital_channels[ch->index]) {
/* Enabled channel is currently disabled, or vice versa. */
if (rigol_ds_config_set(sdi,
- devc->model->series->protocol >= PROTOCOL_V4 ?
+ devc->model->series->protocol >= PROTOCOL_V3 ?
":LA:DIG%d:DISP %s" : ":DIG%d:TURN %s", ch->index,
ch->enabled ? "ON" : "OFF") != SR_OK)
return SR_ERR;
/* Turn off LA module if on and no digital channels selected. */
if (devc->la_enabled && !some_digital)
if (rigol_ds_config_set(sdi,
- devc->model->series->protocol >= PROTOCOL_V4 ?
+ devc->model->series->protocol >= PROTOCOL_V3 ?
":LA:STAT OFF" : ":LA:DISP OFF") != SR_OK)
return SR_ERR;
sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
rigol_ds_receive, (void *)sdi);
- std_session_send_df_header(sdi, LOG_PREFIX);
+ std_session_send_df_header(sdi);
devc->channel_entry = devc->enabled_channels;
return SR_ERR;
}
- std_session_send_df_end(sdi, LOG_PREFIX);
+ std_session_send_df_end(sdi);
g_slist_free(devc->enabled_channels);
devc->enabled_channels = NULL;
return SR_OK;
}
-SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
+static struct sr_dev_driver rigol_ds_driver_info = {
.name = "rigol-ds",
.longname = "Rigol DS",
.api_version = 1,
- .init = init,
+ .init = std_init,
.cleanup = std_cleanup,
.scan = scan,
.dev_list = std_dev_list,
.dev_acquisition_stop = dev_acquisition_stop,
.context = NULL,
};
+SR_REGISTER_DEV_DRIVER(rigol_ds_driver_info);