]> sigrok.org Git - libsigrok.git/blobdiff - src/hardware/rigol-ds/api.c
projects / libsigrok.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
rigol-ds: Add DS1074Z Plus and DS1104Z Plus.
[libsigrok.git] / src / hardware / rigol-ds / api.c
diff --git a/src/hardware/rigol-ds/api.c b/src/hardware/rigol-ds/api.c
index c380c330db11d835164dfd24f382d6d368c178f4..c7a8937690e796917d3a65707dd4dff2af3cb5e9 100644 (file)
--- a/src/hardware/rigol-ds/api.c
+++ b/src/hardware/rigol-ds/api.c
@@ -43,6 +43,7 @@ static const uint32_t devopts[] = {
        SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
        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_TRIGGER_LEVEL | SR_CONF_GET | SR_CONF_SET,
        SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
        SR_CONF_NUM_HDIV | SR_CONF_GET,
        SR_CONF_SAMPLERATE | SR_CONF_GET,
@@ -53,6 +54,7 @@ static const uint32_t analog_devopts[] = {
        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] = {
@@ -160,6 +162,19 @@ static const char *coupling[] = {
        "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",
@@ -243,13 +258,15 @@ static const struct rigol_ds_model supported_models[] = {
        {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)
 {
@@ -501,9 +518,11 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s
        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.");
@@ -572,6 +591,9 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s
                }
                *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];
@@ -614,6 +636,13 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s
                }
                *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;
        }
@@ -674,6 +703,13 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd
                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++) {
@@ -762,6 +798,30 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd
                }
                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"))
@@ -803,8 +863,9 @@ static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *
        }
 
        /* 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)) {
@@ -840,6 +901,14 @@ static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *
                }
                *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. */
@@ -1015,7 +1084,7 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi)
        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;
 
@@ -1041,7 +1110,7 @@ static int dev_acquisition_stop(struct sr_dev_inst *sdi)
                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;
@@ -1051,7 +1120,7 @@ static int dev_acquisition_stop(struct sr_dev_inst *sdi)
        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,
@@ -1069,3 +1138,4 @@ SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
        .dev_acquisition_stop = dev_acquisition_stop,
        .context = NULL,
 };
+SR_REGISTER_DEV_DRIVER(rigol_ds_driver_info);
Hardware access and backend lib