X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fhardware%2Fdemo%2Fapi.c;h=1f9b9d2c04892c988a5dbbbd104ec3027ad9d6b4;hp=5ab1f4afdfe9dc213e0d6b1de1d68d7ce30cc1ee;hb=94f364ec11c938934f68cde067ee590218177140;hpb=d2f7c417fdd96a13d8fd86350d2fc13db16f626c diff --git a/src/hardware/demo/api.c b/src/hardware/demo/api.c index 5ab1f4af..1f9b9d2c 100644 --- a/src/hardware/demo/api.c +++ b/src/hardware/demo/api.c @@ -5,6 +5,7 @@ * Copyright (C) 2011 Olivier Fauchon * Copyright (C) 2012 Alexandru Gagniuc * Copyright (C) 2015 Bartosz Golaszewski + * Copyright (C) 2019 Frank Stettner * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -28,11 +29,13 @@ #include "libsigrok-internal.h" #include "protocol.h" -#define DEFAULT_NUM_LOGIC_CHANNELS 8 -#define DEFAULT_LOGIC_PATTERN PATTERN_SIGROK +#define DEFAULT_NUM_LOGIC_CHANNELS 8 +#define DEFAULT_LOGIC_PATTERN PATTERN_SIGROK -#define DEFAULT_NUM_ANALOG_CHANNELS 4 -#define DEFAULT_ANALOG_AMPLITUDE 10 +#define DEFAULT_NUM_ANALOG_CHANNELS 4 +#define DEFAULT_ANALOG_ENCODING_DIGITS 4 +#define DEFAULT_ANALOG_SPEC_DIGITS 4 +#define DEFAULT_ANALOG_AMPLITUDE 10 /* Note: No spaces allowed because of sigrok-cli. */ static const char *logic_pattern_str[] = { @@ -44,6 +47,13 @@ static const char *logic_pattern_str[] = { "all-low", "all-high", "squid", + "graycode", +}; + +static const uint32_t scanopts[] = { + SR_CONF_NUM_LOGIC_CHANNELS, + SR_CONF_NUM_ANALOG_CHANNELS, + SR_CONF_LIMIT_FRAMES, }; static const uint32_t drvopts[] = { @@ -52,18 +62,16 @@ static const uint32_t drvopts[] = { SR_CONF_OSCILLOSCOPE, }; -static const uint32_t scanopts[] = { - SR_CONF_NUM_LOGIC_CHANNELS, - SR_CONF_NUM_ANALOG_CHANNELS, -}; - static const uint32_t devopts[] = { SR_CONF_CONTINUOUS, SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET, SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET, + SR_CONF_LIMIT_FRAMES | SR_CONF_GET | SR_CONF_SET, SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST, SR_CONF_AVERAGING | SR_CONF_GET | SR_CONF_SET, SR_CONF_AVG_SAMPLES | SR_CONF_GET | SR_CONF_SET, + SR_CONF_TRIGGER_MATCH | SR_CONF_LIST, + SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET, }; static const uint32_t devopts_cg_logic[] = { @@ -75,10 +83,19 @@ static const uint32_t devopts_cg_analog_group[] = { }; static const uint32_t devopts_cg_analog_channel[] = { + SR_CONF_MEASURED_QUANTITY | SR_CONF_GET | SR_CONF_SET, SR_CONF_PATTERN_MODE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST, SR_CONF_AMPLITUDE | SR_CONF_GET | SR_CONF_SET, }; +static const int32_t trigger_matches[] = { + SR_TRIGGER_ZERO, + SR_TRIGGER_ONE, + SR_TRIGGER_RISING, + SR_TRIGGER_FALLING, + SR_TRIGGER_EDGE, +}; + static const uint64_t samplerates[] = { SR_HZ(1), SR_GHZ(1), @@ -95,10 +112,12 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) struct analog_gen *ag; GSList *l; int num_logic_channels, num_analog_channels, pattern, i; + uint64_t limit_frames; char channel_name[16]; num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS; num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS; + limit_frames = DEFAULT_LIMIT_FRAMES; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { @@ -108,6 +127,9 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) case SR_CONF_NUM_ANALOG_CHANNELS: num_analog_channels = g_variant_get_int32(src->data); break; + case SR_CONF_LIMIT_FRAMES: + limit_frames = g_variant_get_uint64(src->data); + break; } } @@ -119,8 +141,14 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) devc->cur_samplerate = SR_KHZ(200); devc->num_logic_channels = num_logic_channels; devc->logic_unitsize = (devc->num_logic_channels + 7) / 8; + devc->all_logic_channels_mask = 1UL << 0; + devc->all_logic_channels_mask <<= devc->num_logic_channels; + devc->all_logic_channels_mask--; devc->logic_pattern = DEFAULT_LOGIC_PATTERN; devc->num_analog_channels = num_analog_channels; + devc->limit_frames = limit_frames; + devc->capture_ratio = 20; + devc->stl = NULL; if (num_logic_channels > 0) { /* Logic channels, all in one channel group. */ @@ -158,12 +186,17 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) /* Every channel gets a generator struct. */ ag = g_malloc(sizeof(struct analog_gen)); ag->ch = ch; + ag->mq = SR_MQ_VOLTAGE; + ag->mq_flags = SR_MQFLAG_DC; + ag->unit = SR_UNIT_VOLT; ag->amplitude = DEFAULT_ANALOG_AMPLITUDE; sr_analog_init(&ag->packet, &ag->encoding, &ag->meaning, &ag->spec, 2); ag->packet.meaning->channels = cg->channels; - ag->packet.meaning->mq = 0; - ag->packet.meaning->mqflags = 0; - ag->packet.meaning->unit = SR_UNIT_VOLT; + ag->packet.meaning->mq = ag->mq; + ag->packet.meaning->mqflags = ag->mq_flags; + ag->packet.meaning->unit = ag->unit; + ag->packet.encoding->digits = DEFAULT_ANALOG_ENCODING_DIGITS; + ag->packet.spec->spec_digits = DEFAULT_ANALOG_SPEC_DIGITS; ag->packet.data = ag->pattern_data; ag->pattern = pattern; ag->avg_val = 0.0f; @@ -180,47 +213,30 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options) return std_scan_complete(di, g_slist_append(NULL, sdi)); } -static int dev_open(struct sr_dev_inst *sdi) -{ - sdi->status = SR_ST_ACTIVE; - - return SR_OK; -} - -static int dev_close(struct sr_dev_inst *sdi) -{ - sdi->status = SR_ST_INACTIVE; - - return SR_OK; -} - -static void clear_helper(void *priv) +static void clear_helper(struct dev_context *devc) { - struct dev_context *devc; GHashTableIter iter; void *value; - devc = priv; - /* Analog generators. */ g_hash_table_iter_init(&iter, devc->ch_ag); while (g_hash_table_iter_next(&iter, NULL, &value)) g_free(value); g_hash_table_unref(devc->ch_ag); - g_free(devc); } static int dev_clear(const struct sr_dev_driver *di) { - return std_dev_clear(di, clear_helper); + return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper); } -static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg) +static int config_get(uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; struct sr_channel *ch; struct analog_gen *ag; + GVariant *mq_arr[2]; int pattern; if (!sdi) @@ -237,12 +253,27 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s case SR_CONF_LIMIT_MSEC: *data = g_variant_new_uint64(devc->limit_msec); break; + case SR_CONF_LIMIT_FRAMES: + *data = g_variant_new_uint64(devc->limit_frames); + break; case SR_CONF_AVERAGING: *data = g_variant_new_boolean(devc->avg); break; case SR_CONF_AVG_SAMPLES: *data = g_variant_new_uint64(devc->avg_samples); break; + case SR_CONF_MEASURED_QUANTITY: + if (!cg) + return SR_ERR_CHANNEL_GROUP; + /* Any channel in the group will do. */ + ch = cg->channels->data; + if (ch->type != SR_CHANNEL_ANALOG) + return SR_ERR_ARG; + ag = g_hash_table_lookup(devc->ch_ag, ch); + mq_arr[0] = g_variant_new_uint32(ag->mq); + mq_arr[1] = g_variant_new_uint64(ag->mq_flags); + *data = g_variant_new_tuple(mq_arr, 2); + break; case SR_CONF_PATTERN_MODE: if (!cg) return SR_ERR_CHANNEL_GROUP; @@ -268,6 +299,9 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s ag = g_hash_table_lookup(devc->ch_ag, ch); *data = g_variant_new_double(ag->amplitude); break; + case SR_CONF_CAPTURE_RATIO: + *data = g_variant_new_uint64(devc->capture_ratio); + break; default: return SR_ERR_NA; } @@ -275,23 +309,18 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s return SR_OK; } -static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg) +static int config_set(uint32_t key, GVariant *data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; struct analog_gen *ag; struct sr_channel *ch; + GVariant *mq_tuple_child; GSList *l; - int logic_pattern, analog_pattern, ret; - unsigned int i; - const char *stropt; + int logic_pattern, analog_pattern; devc = sdi->priv; - if (sdi->status != SR_ST_ACTIVE) - return SR_ERR_DEV_CLOSED; - - ret = SR_OK; switch (key) { case SR_CONF_SAMPLERATE: devc->cur_samplerate = g_variant_get_uint64(data); @@ -304,6 +333,9 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd devc->limit_msec = g_variant_get_uint64(data); devc->limit_samples = 0; break; + case SR_CONF_LIMIT_FRAMES: + devc->limit_frames = g_variant_get_uint64(data); + break; case SR_CONF_AVERAGING: devc->avg = g_variant_get_boolean(data); sr_dbg("%s averaging", devc->avg ? "Enabling" : "Disabling"); @@ -312,24 +344,27 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd devc->avg_samples = g_variant_get_uint64(data); sr_dbg("Setting averaging rate to %" PRIu64, devc->avg_samples); break; - case SR_CONF_PATTERN_MODE: + case SR_CONF_MEASURED_QUANTITY: if (!cg) return SR_ERR_CHANNEL_GROUP; - stropt = g_variant_get_string(data, NULL); - logic_pattern = analog_pattern = -1; - for (i = 0; i < ARRAY_SIZE(logic_pattern_str); i++) { - if (!strcmp(stropt, logic_pattern_str[i])) { - logic_pattern = i; - break; - } - } - for (i = 0; i < ARRAY_SIZE(analog_pattern_str); i++) { - if (!strcmp(stropt, analog_pattern_str[i])) { - analog_pattern = i; - break; - } + for (l = cg->channels; l; l = l->next) { + ch = l->data; + if (ch->type != SR_CHANNEL_ANALOG) + return SR_ERR_ARG; + ag = g_hash_table_lookup(devc->ch_ag, ch); + mq_tuple_child = g_variant_get_child_value(data, 0); + ag->mq = g_variant_get_uint32(mq_tuple_child); + mq_tuple_child = g_variant_get_child_value(data, 1); + ag->mq_flags = g_variant_get_uint64(mq_tuple_child); + g_variant_unref(mq_tuple_child); } - if (logic_pattern == -1 && analog_pattern == -1) + break; + case SR_CONF_PATTERN_MODE: + if (!cg) + return SR_ERR_CHANNEL_GROUP; + logic_pattern = std_str_idx(data, ARRAY_AND_SIZE(logic_pattern_str)); + analog_pattern = std_str_idx(data, ARRAY_AND_SIZE(analog_pattern_str)); + if (logic_pattern < 0 && analog_pattern < 0) return SR_ERR_ARG; for (l = cg->channels; l; l = l->next) { ch = l->data; @@ -366,47 +401,31 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd ag->amplitude = g_variant_get_double(data); } break; + case SR_CONF_CAPTURE_RATIO: + devc->capture_ratio = g_variant_get_uint64(data); + break; default: - ret = SR_ERR_NA; + return SR_ERR_NA; } - return ret; + return SR_OK; } -static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, - const struct sr_channel_group *cg) +static int config_list(uint32_t key, GVariant **data, + const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct sr_channel *ch; - GVariant *gvar; - GVariantBuilder gvb; - - 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; - } - - if (key == SR_CONF_DEVICE_OPTIONS && !sdi) { - *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, - drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t)); - return SR_OK; - } - - if (!sdi) - return SR_ERR_ARG; if (!cg) { switch (key) { + case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: - *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, - devopts, ARRAY_SIZE(devopts), sizeof(uint32_t)); - break; + return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); case SR_CONF_SAMPLERATE: - g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}")); - gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates, - ARRAY_SIZE(samplerates), sizeof(uint64_t)); - g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar); - *data = g_variant_builder_end(&gvb); + *data = std_gvar_samplerates_steps(ARRAY_AND_SIZE(samplerates)); + break; + case SR_CONF_TRIGGER_MATCH: + *data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches)); break; default: return SR_ERR_NA; @@ -416,18 +435,12 @@ static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst * switch (key) { case SR_CONF_DEVICE_OPTIONS: if (ch->type == SR_CHANNEL_LOGIC) - *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, - devopts_cg_logic, ARRAY_SIZE(devopts_cg_logic), - sizeof(uint32_t)); + *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_logic)); else if (ch->type == SR_CHANNEL_ANALOG) { if (strcmp(cg->name, "Analog") == 0) - *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, - devopts_cg_analog_group, ARRAY_SIZE(devopts_cg_analog_group), - sizeof(uint32_t)); + *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_analog_group)); else - *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32, - devopts_cg_analog_channel, ARRAY_SIZE(devopts_cg_analog_channel), - sizeof(uint32_t)); + *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_analog_channel)); } else return SR_ERR_BUG; @@ -438,11 +451,9 @@ static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst * return SR_ERR_NA; if (ch->type == SR_CHANNEL_LOGIC) - *data = g_variant_new_strv(logic_pattern_str, - ARRAY_SIZE(logic_pattern_str)); + *data = g_variant_new_strv(ARRAY_AND_SIZE(logic_pattern_str)); else if (ch->type == SR_CHANNEL_ANALOG) - *data = g_variant_new_strv(analog_pattern_str, - ARRAY_SIZE(analog_pattern_str)); + *data = g_variant_new_strv(ARRAY_AND_SIZE(analog_pattern_str)); else return SR_ERR_BUG; break; @@ -463,12 +474,32 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) uint8_t mask; GHashTableIter iter; void *value; - - if (sdi->status != SR_ST_ACTIVE) - return SR_ERR_DEV_CLOSED; + struct sr_trigger *trigger; devc = sdi->priv; devc->sent_samples = 0; + devc->sent_frame_samples = 0; + + /* Setup triggers */ + if ((trigger = sr_session_trigger_get(sdi->session))) { + int pre_trigger_samples = 0; + if (devc->limit_samples > 0) + pre_trigger_samples = (devc->capture_ratio * devc->limit_samples) / 100; + devc->stl = soft_trigger_logic_new(sdi, trigger, pre_trigger_samples); + if (!devc->stl) + return SR_ERR_MALLOC; + + /* Disable all analog channels since using them when there are logic + * triggers set up would require having pre-trigger sample buffers + * for analog sample data. + */ + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + if (ch->type == SR_CHANNEL_ANALOG) + ch->enabled = FALSE; + } + } + devc->trigger_fired = FALSE; /* * Determine the numbers of logic and analog channels that are @@ -503,8 +534,8 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) bitpos = devc->enabled_logic_channels % 8; mask = (1 << bitpos) - 1; devc->first_partial_logic_mask = mask; - sr_dbg("DBG: %s(), num logic %zu, partial off %zu, mask 0x%02x", - __func__, devc->enabled_logic_channels, + sr_dbg("num logic %zu, partial off %zu, mask 0x%02x.", + devc->enabled_logic_channels, devc->first_partial_logic_index, devc->first_partial_logic_mask); @@ -522,6 +553,9 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) std_session_send_df_header(sdi); + if (devc->limit_frames > 0) + std_session_send_frame_begin(sdi); + /* We use this timestamp to decide how many more samples to send. */ devc->start_us = g_get_monotonic_time(); devc->spent_us = 0; @@ -532,9 +566,21 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi) static int dev_acquisition_stop(struct sr_dev_inst *sdi) { + struct dev_context *devc; + sr_session_source_remove(sdi->session, -1); + + devc = sdi->priv; + if (devc->limit_frames > 0) + std_session_send_frame_end(sdi); + std_session_send_df_end(sdi); + if (devc->stl) { + soft_trigger_logic_free(devc->stl); + devc->stl = NULL; + } + return SR_OK; } @@ -550,8 +596,8 @@ static struct sr_dev_driver demo_driver_info = { .config_get = config_get, .config_set = config_set, .config_list = config_list, - .dev_open = dev_open, - .dev_close = dev_close, + .dev_open = std_dummy_dev_open, + .dev_close = std_dummy_dev_close, .dev_acquisition_start = dev_acquisition_start, .dev_acquisition_stop = dev_acquisition_stop, .context = NULL,