output/csv: use intermediate time_t var, silence compiler warning

[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 eb3aabf7624f8ebb9a6712a16e9d2ca1658ba02a..6703d1cea3145a4ccffaf53ef102677662cd8f8b 100644 (file)
--- a/src/hardware/rigol-ds/api.c
+++ b/src/hardware/rigol-ds/api.c
@@ -42,7 +42,7 @@ static const uint32_t drvopts[] = {
 };
 
 static const uint32_t devopts[] = {
-       SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
+       SR_CONF_LIMIT_FRAMES | SR_CONF_GET | 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,
@@ -273,13 +273,15 @@ static const struct rigol_ds_model supported_models[] = {
        {SERIES(DS1000Z), "DS1104Z", {5, 1000000000}, CH_INFO(4, false), std_cmd},
        {SERIES(DS1000Z), "DS1074Z-S", {5, 1000000000}, CH_INFO(4, false), std_cmd},
        {SERIES(DS1000Z), "DS1104Z-S", {5, 1000000000}, CH_INFO(4, false), std_cmd},
-       {SERIES(DS1000Z), "DS1074Z Plus", {5, 1000000000}, CH_INFO(4, false), std_cmd},
-       {SERIES(DS1000Z), "DS1104Z Plus", {5, 1000000000}, CH_INFO(4, false), std_cmd},
+       {SERIES(DS1000Z), "DS1074Z Plus", {5, 1000000000}, CH_INFO(4, true), std_cmd},
+       {SERIES(DS1000Z), "DS1104Z Plus", {5, 1000000000}, CH_INFO(4, true), std_cmd},
+       {SERIES(DS1000Z), "DS1102Z-E", {2, 1000000000}, CH_INFO(2, false), std_cmd},
        {SERIES(DS1000Z), "DS1202Z-E", {2, 1000000000}, CH_INFO(2, false), std_cmd},
        {SERIES(DS1000Z), "MSO1074Z", {5, 1000000000}, CH_INFO(4, true), std_cmd},
        {SERIES(DS1000Z), "MSO1104Z", {5, 1000000000}, CH_INFO(4, true), std_cmd},
        {SERIES(DS1000Z), "MSO1074Z-S", {5, 1000000000}, CH_INFO(4, true), std_cmd},
        {SERIES(DS1000Z), "MSO1104Z-S", {5, 1000000000}, CH_INFO(4, true), std_cmd},
+       {SERIES(DS4000), "DS4014", {1, 1000000000}, CH_INFO(4, false), std_cmd},
        {SERIES(DS4000), "DS4024", {1, 1000000000}, CH_INFO(4, false), std_cmd},
        {SERIES(MSO5000), "MSO5072", {1, 1000000000}, CH_INFO(2, true), std_cmd},
        {SERIES(MSO5000), "MSO5074", {1, 1000000000}, CH_INFO(4, true), std_cmd},
@@ -394,17 +396,13 @@ static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
                channel_name = g_strdup_printf("CH%d", i + 1);
                ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_name);
 
-               devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
-
-               devc->analog_groups[i]->name = channel_name;
+               devc->analog_groups[i] = sr_channel_group_new(sdi,
+                       channel_name, NULL);
                devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
-               sdi->channel_groups = g_slist_append(sdi->channel_groups,
-                               devc->analog_groups[i]);
        }
 
        if (devc->model->has_digital) {
-               devc->digital_group = g_malloc0(sizeof(struct sr_channel_group));
-
+               devc->digital_group = sr_channel_group_new(sdi, "LA", NULL);
                for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
                        channel_name = g_strdup_printf("D%d", i);
                        ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
@@ -412,9 +410,6 @@ static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
                        devc->digital_group->channels = g_slist_append(
                                        devc->digital_group->channels, ch);
                }
-               devc->digital_group->name = g_strdup("LA");
-               sdi->channel_groups = g_slist_append(sdi->channel_groups,
-                               devc->digital_group);
        }
 
        for (i = 0; i < ARRAY_SIZE(timebases); i++) {
@@ -572,6 +567,9 @@ static int config_get(uint32_t key, GVariant **data,
                else
                        *data = g_variant_new_string("Segmented");
                break;
+       case SR_CONF_LIMIT_FRAMES:
+               *data = g_variant_new_uint64(devc->limit_frames);
+               break;
        case SR_CONF_SAMPLERATE:
                *data = g_variant_new_uint64(devc->sample_rate);
                break;
@@ -879,6 +877,7 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi)
        GSList *l;
        char *cmd;
        int protocol;
+       int ret;
 
        scpi = sdi->conn;
        devc = sdi->priv;
@@ -1017,20 +1016,27 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 
        devc->channel_entry = devc->enabled_channels;
 
-       if (devc->data_source == DATA_SOURCE_LIVE)
-               devc->sample_rate = analog_frame_size(sdi) / 
+       if (devc->data_source == DATA_SOURCE_LIVE) {
+               devc->sample_rate = analog_frame_size(sdi) /
                        (devc->timebase * devc->model->series->num_horizontal_divs);
-       else {
+       } else {
                float xinc;
-               if (devc->model->series->protocol >= PROTOCOL_V3 && 
-                               sr_scpi_get_float(sdi->conn, "WAV:XINC?", &xinc) != SR_OK) {
-                       sr_err("Couldn't get sampling rate");
+               if (devc->model->series->protocol < PROTOCOL_V3) {
+                       sr_err("Cannot get samplerate (below V3).");
+                       return SR_ERR;
+               }
+               ret = sr_scpi_get_float(sdi->conn, "WAV:XINC?", &xinc);
+               if (ret != SR_OK) {
+                       sr_err("Cannot get samplerate (WAV:XINC? failed).");
+                       return SR_ERR;
+               }
+               if (!xinc) {
+                       sr_err("Cannot get samplerate (zero XINC value).");
                        return SR_ERR;
                }
                devc->sample_rate = 1. / xinc;
        }
 
-
        if (rigol_ds_capture_start(sdi) != SR_OK)
                return SR_ERR;