X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fyokogawa-dlm%2Fprotocol.c;h=e833389c815ef0e2e1aaf8d689f76f18a067b963;hb=c65a021c050b3ef05ccc844cf24ee8e620eb669e;hp=f18e97eabde07a9ce33ca65087267fafdfe0d862;hpb=8ab929d614262dc446ee2e948ca583d31110b14b;p=libsigrok.git diff --git a/src/hardware/yokogawa-dlm/protocol.c b/src/hardware/yokogawa-dlm/protocol.c index f18e97ea..e833389c 100644 --- a/src/hardware/yokogawa-dlm/protocol.c +++ b/src/hardware/yokogawa-dlm/protocol.c @@ -25,22 +25,6 @@ #include "protocol.h" -static const int32_t dlm_hwcaps[] = { - SR_CONF_LOGIC_ANALYZER, - SR_CONF_OSCILLOSCOPE, - SR_CONF_TRIGGER_SLOPE, - SR_CONF_TRIGGER_SOURCE, - SR_CONF_TIMEBASE, - SR_CONF_NUM_TIMEBASE, - SR_CONF_HORIZ_TRIGGERPOS, -}; - -static const int32_t dlm_analog_caps[] = { - SR_CONF_VDIV, - SR_CONF_COUPLING, - SR_CONF_NUM_VDIV, -}; - static const char *dlm_coupling_options[] = { "AC", "DC", @@ -49,13 +33,6 @@ static const char *dlm_coupling_options[] = { NULL, }; -/* Note: Values must correlate to the trigger_slopes values */ -static const char *dlm_trigger_slopes[] = { - "r", - "f", - NULL, -}; - static const char *dlm_2ch_trigger_sources[] = { "1", "2", @@ -83,7 +60,14 @@ static const char *dlm_4ch_trigger_sources[] = { NULL, }; -static const uint64_t dlm_timebases[][2] = { +/* Note: Values must correlate to the trigger_slopes values */ +const char *dlm_trigger_slopes[3] = { + "r", + "f", + NULL, +}; + +const uint64_t dlm_timebases[36][2] = { /* nanoseconds */ { 1, 1000000000 }, { 2, 1000000000 }, @@ -126,7 +110,7 @@ static const uint64_t dlm_timebases[][2] = { { 500, 1 }, }; -static const uint64_t dlm_vdivs[][2] = { +const uint64_t dlm_vdivs[17][2] = { /* millivolts */ { 2, 1000 }, { 5, 1000 }, @@ -155,7 +139,7 @@ static const char *scope_analog_channel_names[] = { "4" }; -static const char *scope_digital_channel_names[] = { +static const char *scope_digital_channel_names_8[] = { "D0", "D1", "D2", @@ -166,7 +150,42 @@ static const char *scope_digital_channel_names[] = { "D7" }; -static struct scope_config scope_models[] = { +static const char *scope_digital_channel_names_32[] = { + "A0", + "A1", + "A2", + "A3", + "A4", + "A5", + "A6", + "A7", + "B0", + "B1", + "B2", + "B3", + "B4", + "B5", + "B6", + "B7", + "C0", + "C1", + "C2", + "C3", + "C4", + "C5", + "C6", + "C7", + "D0", + "D1", + "D2", + "D3", + "D4", + "D5", + "D6", + "D7", +}; + +static const struct scope_config scope_models[] = { { .model_id = {"710105", "710115", "710125", NULL}, .model_name = {"DLM2022", "DLM2032", "DLM2052", NULL}, @@ -175,23 +194,10 @@ static struct scope_config scope_models[] = { .pods = 0, .analog_names = &scope_analog_channel_names, - .digital_names = &scope_digital_channel_names, - - .hw_caps = &dlm_hwcaps, - .num_hwcaps = ARRAY_SIZE(dlm_hwcaps), - - .analog_hwcaps = &dlm_analog_caps, - .num_analog_hwcaps = ARRAY_SIZE(dlm_analog_caps), + .digital_names = &scope_digital_channel_names_8, .coupling_options = &dlm_coupling_options, .trigger_sources = &dlm_2ch_trigger_sources, - .trigger_slopes = &dlm_trigger_slopes, - - .timebases = &dlm_timebases, - .num_timebases = ARRAY_SIZE(dlm_timebases), - - .vdivs = &dlm_vdivs, - .num_vdivs = ARRAY_SIZE(dlm_vdivs), .num_xdivs = 10, .num_ydivs = 8, @@ -204,23 +210,60 @@ static struct scope_config scope_models[] = { .pods = 1, .analog_names = &scope_analog_channel_names, - .digital_names = &scope_digital_channel_names, + .digital_names = &scope_digital_channel_names_8, + + .coupling_options = &dlm_coupling_options, + .trigger_sources = &dlm_4ch_trigger_sources, - .hw_caps = &dlm_hwcaps, - .num_hwcaps = ARRAY_SIZE(dlm_hwcaps), + .num_xdivs = 10, + .num_ydivs = 8, + }, + { + .model_id = {"701307", "701308", "701310", "701311", + "701312", "701313", NULL}, + .model_name = {"DL9040", "DL9040L", "DL9140", "DL9140L", + "DL9240", "DL9240L", NULL}, + .analog_channels = 4, + .digital_channels = 0, + .pods = 0, + + .analog_names = &scope_analog_channel_names, + .digital_names = NULL, + + .coupling_options = &dlm_coupling_options, + .trigger_sources = &dlm_4ch_trigger_sources, + + .num_xdivs = 10, + .num_ydivs = 8, + }, + { + .model_id = {"701320", "701321", NULL}, + .model_name = {"DL9505L", "DL9510L", NULL}, + .analog_channels = 4, + .digital_channels = 16, + .pods = 4, - .analog_hwcaps = &dlm_analog_caps, - .num_analog_hwcaps = ARRAY_SIZE(dlm_analog_caps), + .analog_names = &scope_analog_channel_names, + .digital_names = &scope_digital_channel_names_32, .coupling_options = &dlm_coupling_options, .trigger_sources = &dlm_4ch_trigger_sources, - .trigger_slopes = &dlm_trigger_slopes, - .timebases = &dlm_timebases, - .num_timebases = ARRAY_SIZE(dlm_timebases), + .num_xdivs = 10, + .num_ydivs = 8, + }, + { + .model_id = {"701330", "701331", NULL}, + .model_name = {"DL9705L", "DL9710L", NULL}, + .analog_channels = 4, + .digital_channels = 32, + .pods = 4, - .vdivs = &dlm_vdivs, - .num_vdivs = ARRAY_SIZE(dlm_vdivs), + .analog_names = &scope_analog_channel_names, + .digital_names = &scope_digital_channel_names_32, + + .coupling_options = &dlm_coupling_options, + .trigger_sources = &dlm_4ch_trigger_sources, .num_xdivs = 10, .num_ydivs = 8, @@ -233,33 +276,33 @@ static struct scope_config scope_models[] = { * @param config This is the scope configuration. * @param state The current scope state to print. */ -static void scope_state_dump(struct scope_config *config, +static void scope_state_dump(const struct scope_config *config, struct scope_state *state) { unsigned int i; char *tmp; for (i = 0; i < config->analog_channels; ++i) { - tmp = sr_voltage_string((*config->vdivs)[state->analog_states[i].vdiv][0], - (*config->vdivs)[state->analog_states[i].vdiv][1]); + tmp = sr_voltage_string(dlm_vdivs[state->analog_states[i].vdiv][0], + dlm_vdivs[state->analog_states[i].vdiv][1]); sr_info("State of analog channel %d -> %s : %s (coupling) %s (vdiv) %2.2e (offset)", - i + 1, state->analog_states[i].state ? "On" : "Off", - (*config->coupling_options)[state->analog_states[i].coupling], - tmp, state->analog_states[i].vertical_offset); + i + 1, state->analog_states[i].state ? "On" : "Off", + (*config->coupling_options)[state->analog_states[i].coupling], + tmp, state->analog_states[i].vertical_offset); } for (i = 0; i < config->digital_channels; ++i) { sr_info("State of digital channel %d -> %s", i, - state->digital_states[i] ? "On" : "Off"); + state->digital_states[i] ? "On" : "Off"); } for (i = 0; i < config->pods; ++i) { sr_info("State of digital POD %d -> %s", i, - state->pod_states[i] ? "On" : "Off"); + state->pod_states[i] ? "On" : "Off"); } - tmp = sr_period_string((*config->timebases)[state->timebase][0] * - (*config->timebases)[state->timebase][1]); + tmp = sr_period_string(dlm_timebases[state->timebase][0] * + dlm_timebases[state->timebase][1]); sr_info("Current timebase: %s", tmp); g_free(tmp); @@ -267,10 +310,13 @@ static void scope_state_dump(struct scope_config *config, sr_info("Current samplerate: %s", tmp); g_free(tmp); + sr_info("Current samples per acquisition (i.e. frame): %d", + state->samples_per_frame); + sr_info("Current trigger: %s (source), %s (slope) %.2f (offset)", - (*config->trigger_sources)[state->trigger_source], - (*config->trigger_slopes)[state->trigger_slope], - state->horiz_triggerpos); + (*config->trigger_sources)[state->trigger_source], + dlm_trigger_slopes[state->trigger_slope], + state->horiz_triggerpos); } /** @@ -325,6 +371,7 @@ static int array_float_get(gchar *value, const uint64_t array[][2], int i; uint64_t f; float s; + unsigned int s_int; gchar ss[10], es[10]; memset(ss, 0, sizeof(ss)); @@ -347,10 +394,10 @@ static int array_float_get(gchar *value, const uint64_t array[][2], while ((int)fmod(log10(f), 3) > 0) { s *= 10; f *= 10; } /* Truncate s to circumvent rounding errors. */ - s = (int)s; + s_int = (unsigned int)s; for (i = 0; i < array_len; i++) { - if ( (s == array[i][0]) && (f == array[i][1]) ) { + if ( (s_int == array[i][0]) && (f == array[i][1]) ) { *result = i; return SR_OK; } @@ -363,30 +410,43 @@ static int array_float_get(gchar *value, const uint64_t array[][2], * Obtains information about all analog channels from the oscilloscope. * The internal state information is updated accordingly. * - * @param scpi An open SCPI connection. + * @param sdi The device instance. * @param config The device's device configuration. * @param state The device's state information. * * @return SR_ERR on error, SR_OK otherwise. */ -static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi, - struct scope_config *config, - struct scope_state *state) +static int analog_channel_state_get(const struct sr_dev_inst *sdi, + const struct scope_config *config, + struct scope_state *state) { + struct sr_scpi_dev_inst *scpi; int i, j; + GSList *l; + struct sr_channel *ch; gchar *response; + scpi = sdi->conn; + for (i = 0; i < config->analog_channels; ++i) { if (dlm_analog_chan_state_get(scpi, i + 1, - &state->analog_states[i].state) != SR_OK) + &state->analog_states[i].state) != SR_OK) return SR_ERR; + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + if (ch->index == i) { + ch->enabled = state->analog_states[i].state; + break; + } + } + if (dlm_analog_chan_vdiv_get(scpi, i + 1, &response) != SR_OK) return SR_ERR; - if (array_float_get(response, *config->vdivs, config->num_vdivs, - &j) != SR_OK) { + if (array_float_get(response, dlm_vdivs, ARRAY_SIZE(dlm_vdivs), + &j) != SR_OK) { g_free(response); return SR_ERR; } @@ -395,15 +455,15 @@ static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi, state->analog_states[i].vdiv = j; if (dlm_analog_chan_voffs_get(scpi, i + 1, - &state->analog_states[i].vertical_offset) != SR_OK) + &state->analog_states[i].vertical_offset) != SR_OK) return SR_ERR; if (dlm_analog_chan_wrange_get(scpi, i + 1, - &state->analog_states[i].waveform_range) != SR_OK) + &state->analog_states[i].waveform_range) != SR_OK) return SR_ERR; if (dlm_analog_chan_woffs_get(scpi, i + 1, - &state->analog_states[i].waveform_offset) != SR_OK) + &state->analog_states[i].waveform_offset) != SR_OK) return SR_ERR; if (dlm_analog_chan_coupl_get(scpi, i + 1, &response) != SR_OK) { @@ -412,7 +472,7 @@ static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi, } if (array_option_get(response, config->coupling_options, - &state->analog_states[i].coupling) != SR_OK) { + &state->analog_states[i].coupling) != SR_OK) { g_free(response); return SR_ERR; } @@ -426,22 +486,27 @@ static int analog_channel_state_get(struct sr_scpi_dev_inst *scpi, * Obtains information about all digital channels from the oscilloscope. * The internal state information is updated accordingly. * - * @param scpi An open SCPI connection. + * @param sdi The device instance. * @param config The device's device configuration. * @param state The device's state information. * * @return SR_ERR on error, SR_OK otherwise. */ -static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi, - struct scope_config *config, - struct scope_state *state) +static int digital_channel_state_get(const struct sr_dev_inst *sdi, + const struct scope_config *config, + struct scope_state *state) { - unsigned int i; + struct sr_scpi_dev_inst *scpi; + int i; + GSList *l; + struct sr_channel *ch; + + scpi = sdi->conn; if (!config->digital_channels) { sr_warn("Tried obtaining digital channel states on a " \ - "model without digital inputs."); + "model without digital inputs."); return SR_OK; } @@ -450,6 +515,14 @@ static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi, &state->digital_states[i]) != SR_OK) { return SR_ERR; } + + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + if (ch->index == i + DLM_DIG_CHAN_INDEX_OFFS) { + ch->enabled = state->digital_states[i]; + break; + } + } } if (!config->pods) @@ -467,6 +540,93 @@ static int digital_channel_state_get(struct sr_scpi_dev_inst *scpi, return SR_OK; } +/** + * + */ +SR_PRIV int dlm_channel_state_set(const struct sr_dev_inst *sdi, + const int ch_index, gboolean ch_state) +{ + GSList *l; + struct sr_channel *ch; + struct dev_context *devc = NULL; + struct scope_state *state; + const struct scope_config *model = NULL; + struct sr_scpi_dev_inst *scpi; + gboolean chan_found; + gboolean *pod_enabled; + int i, result; + + result = SR_OK; + + scpi = sdi->conn; + devc = sdi->priv; + state = devc->model_state; + model = devc->model_config; + chan_found = FALSE; + + pod_enabled = g_malloc0(sizeof(gboolean) * model->pods); + + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + + switch (ch->type) { + case SR_CHANNEL_ANALOG: + if (ch->index == ch_index) { + if (dlm_analog_chan_state_set(scpi, ch->index + 1, ch_state) != SR_OK) { + result = SR_ERR; + break; + } + + ch->enabled = ch_state; + state->analog_states[ch->index].state = ch_state; + chan_found = TRUE; + break; + } + break; + case SR_CHANNEL_LOGIC: + i = ch->index - DLM_DIG_CHAN_INDEX_OFFS; + + if (ch->index == ch_index) { + if (dlm_digital_chan_state_set(scpi, i + 1, ch_state) != SR_OK) { + result = SR_ERR; + break; + } + + ch->enabled = ch_state; + state->digital_states[i] = ch_state; + chan_found = TRUE; + + /* The corresponding pod has to be enabled also. */ + pod_enabled[i / 8] |= ch->enabled; + } else + /* Also check all other channels. Maybe we can disable a pod. */ + pod_enabled[i / 8] |= ch->enabled; + break; + default: + result = SR_ERR_NA; + } + } + + for (i = 0; i < model->pods; ++i) { + if (state->pod_states[i] == pod_enabled[i]) + continue; + + if (dlm_digital_pod_state_set(scpi, i + 1, pod_enabled[i]) != SR_OK) { + result = SR_ERR; + break; + } + + state->pod_states[i] = pod_enabled[i]; + } + + g_free(pod_enabled); + + if ((result == SR_OK) && !chan_found) + result = SR_ERR_BUG; + + return result; +} + /** * Obtains information about the sample rate from the oscilloscope. * The internal state information is updated accordingly. @@ -508,7 +668,7 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) { struct dev_context *devc; struct scope_state *state; - struct scope_config *config; + const struct scope_config *config; float tmp_float; gchar *response; int i; @@ -517,17 +677,17 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) config = devc->model_config; state = devc->model_state; - if (analog_channel_state_get(sdi->conn, config, state) != SR_OK) + if (analog_channel_state_get(sdi, config, state) != SR_OK) return SR_ERR; - if (digital_channel_state_get(sdi->conn, config, state) != SR_OK) + if (digital_channel_state_get(sdi, config, state) != SR_OK) return SR_ERR; if (dlm_timebase_get(sdi->conn, &response) != SR_OK) return SR_ERR; - if (array_float_get(response, *config->timebases, - config->num_timebases, &i) != SR_OK) { + if (array_float_get(response, dlm_timebases, + ARRAY_SIZE(dlm_timebases), &i) != SR_OK) { g_free(response); return SR_ERR; } @@ -540,8 +700,8 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) /* TODO: Check if the calculation makes sense for the DLM. */ state->horiz_triggerpos = tmp_float / - (((double)(*config->timebases)[state->timebase][0] / - (*config->timebases)[state->timebase][1]) * config->num_xdivs); + (((double)dlm_timebases[state->timebase][0] / + dlm_timebases[state->timebase][1]) * config->num_xdivs); state->horiz_triggerpos -= 0.5; state->horiz_triggerpos *= -1; @@ -551,7 +711,7 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) } if (array_option_get(response, config->trigger_sources, - &state->trigger_source) != SR_OK) { + &state->trigger_source) != SR_OK) { g_free(response); return SR_ERR; } @@ -563,6 +723,11 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) state->trigger_slope = i; + if (dlm_acq_length_get(sdi->conn, &state->samples_per_frame) != SR_OK) { + sr_err("Failed to query acquisition length."); + return SR_ERR; + } + dlm_sample_rate_query(sdi); scope_state_dump(config, state); @@ -575,20 +740,19 @@ SR_PRIV int dlm_scope_state_query(struct sr_dev_inst *sdi) * * @param config The device configuration to use. * - * @return The newly allocated scope_state struct or NULL on error. + * @return The newly allocated scope_state struct. */ -static struct scope_state *dlm_scope_state_new(struct scope_config *config) +static struct scope_state *dlm_scope_state_new(const struct scope_config *config) { struct scope_state *state; - if (!(state = g_try_malloc0(sizeof(struct scope_state)))) - return NULL; + state = g_malloc0(sizeof(struct scope_state)); state->analog_states = g_malloc0(config->analog_channels * - sizeof(struct analog_channel_state)); + sizeof(struct analog_channel_state)); state->digital_states = g_malloc0(config->digital_channels * - sizeof(gboolean)); + sizeof(gboolean)); state->pod_states = g_malloc0(config->pods * sizeof(gboolean)); @@ -629,7 +793,7 @@ SR_PRIV int dlm_model_get(char *model_id, char **model_name, int *model_index) if (*model_index == -1) { sr_err("Found unsupported DLM device with model identifier %s.", - model_id); + model_id); return SR_ERR_NA; } @@ -652,26 +816,24 @@ SR_PRIV int dlm_device_init(struct sr_dev_inst *sdi, int model_index) devc = sdi->priv; devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) * - scope_models[model_index].analog_channels); + scope_models[model_index].analog_channels); devc->digital_groups = g_malloc0(sizeof(struct sr_channel_group*) * - scope_models[model_index].digital_channels); + scope_models[model_index].pods); - /* Add analog channels. */ + /* Add analog channels, each in its own group. */ for (i = 0; i < scope_models[model_index].analog_channels; i++) { - if (!(ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, - (*scope_models[model_index].analog_names)[i]))) - return SR_ERR_MALLOC; - sdi->channels = g_slist_append(sdi->channels, ch); + ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, + (*scope_models[model_index].analog_names)[i]); devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group)); devc->analog_groups[i]->name = g_strdup( - (char *)(*scope_models[model_index].analog_names)[i]); + (char *)(*scope_models[model_index].analog_names)[i]); devc->analog_groups[i]->channels = g_slist_append(NULL, ch); sdi->channel_groups = g_slist_append(sdi->channel_groups, - devc->analog_groups[i]); + devc->analog_groups[i]); } /* Add digital channel groups. */ @@ -689,13 +851,12 @@ SR_PRIV int dlm_device_init(struct sr_dev_inst *sdi, int model_index) /* Add digital channels. */ for (i = 0; i < scope_models[model_index].digital_channels; i++) { - if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, - (*scope_models[model_index].digital_names)[i]))) - return SR_ERR_MALLOC; - sdi->channels = g_slist_append(sdi->channels, ch); + ch = sr_channel_new(sdi, DLM_DIG_CHAN_INDEX_OFFS + i, + SR_CHANNEL_LOGIC, TRUE, + (*scope_models[model_index].digital_names)[i]); devc->digital_groups[i / 8]->channels = g_slist_append( - devc->digital_groups[i / 8]->channels, ch); + devc->digital_groups[i / 8]->channels, ch); } devc->model_config = &scope_models[model_index]; devc->frame_limit = 0; @@ -710,42 +871,34 @@ SR_PRIV int dlm_device_init(struct sr_dev_inst *sdi, int model_index) return SR_OK; } -/** - * Send an SCPI command, read the reply and store the result in scpi_response - * without performing any processing on it. - * - * @param scpi Previously initialised SCPI device structure. - * @param command The SCPI command to send to the device (can be NULL). - * @param scpi_response Pointer where to store the parsed result. - * - * @return SR_OK on success, SR_ERR on failure. - */ -static int dlm_scpi_get_raw(struct sr_scpi_dev_inst *scpi, - const char *command, GArray **scpi_response) +SR_PRIV int dlm_channel_data_request(const struct sr_dev_inst *sdi) { - char buf[256]; - int len; - - if (command) - if (sr_scpi_send(scpi, command) != SR_OK) - return SR_ERR; - - if (sr_scpi_read_begin(scpi) != SR_OK) - return SR_ERR; + struct dev_context *devc; + struct sr_channel *ch; + int result; - *scpi_response = g_array_new(FALSE, FALSE, sizeof(uint8_t)); + devc = sdi->priv; + ch = devc->current_channel->data; - while (!sr_scpi_read_complete(scpi)) { - len = sr_scpi_read_data(scpi, buf, sizeof(buf)); - if (len < 0) { - g_array_free(*scpi_response, TRUE); - *scpi_response = NULL; - return SR_ERR; - } - g_array_append_vals(*scpi_response, buf, len); + switch (ch->type) { + case SR_CHANNEL_ANALOG: + result = dlm_analog_data_get(sdi->conn, ch->index + 1); + break; + case SR_CHANNEL_LOGIC: + result = dlm_digital_data_get(sdi->conn); + break; + default: + sr_err("Invalid channel type encountered (%d).", + ch->type); + result = SR_ERR; } - return SR_OK; + if (result == SR_OK) + devc->data_pending = TRUE; + else + devc->data_pending = FALSE; + + return result; } /** @@ -783,32 +936,34 @@ static int dlm_block_data_header_process(GArray *data, int *len) * Turns raw sample data into voltages and sends them off to the session bus. * * @param data The raw sample data. - * @samples Number of samples that were acquired. * @ch_state Pointer to the state of the channel whose data we're processing. * @sdi The device instance. * * @return SR_ERR when data is trucated, SR_OK otherwise. */ -static int dlm_analog_samples_send(GArray *data, int samples, - struct analog_channel_state *ch_state, - struct sr_dev_inst *sdi) +static int dlm_analog_samples_send(GArray *data, + struct analog_channel_state *ch_state, + struct sr_dev_inst *sdi) { - int i; + uint32_t i, samples; float voltage, range, offset; GArray *float_data; struct dev_context *devc; + struct scope_state *model_state; struct sr_channel *ch; struct sr_datafeed_analog analog; struct sr_datafeed_packet packet; + devc = sdi->priv; + model_state = devc->model_state; + samples = model_state->samples_per_frame; + ch = devc->current_channel->data; + if (data->len < samples * sizeof(uint8_t)) { sr_err("Truncated waveform data packet received."); return SR_ERR; } - devc = sdi->priv; - ch = devc->current_channel->data; - range = ch_state->waveform_range; offset = ch_state->waveform_offset; @@ -819,7 +974,7 @@ static int dlm_analog_samples_send(GArray *data, int samples, for (i = 0; i < samples; i++) { voltage = (float)g_array_index(data, int8_t, i); voltage = (range * voltage / - DLM_DIVISION_FOR_BYTE_FORMAT) + offset; + DLM_DIVISION_FOR_BYTE_FORMAT) + offset; g_array_append_val(float_data, voltage); } @@ -844,18 +999,24 @@ static int dlm_analog_samples_send(GArray *data, int samples, * Sends logic sample data off to the session bus. * * @param data The raw sample data. - * @samples Number of samples that were acquired. * @ch_state Pointer to the state of the channel whose data we're processing. * @sdi The device instance. * * @return SR_ERR when data is trucated, SR_OK otherwise. */ -static int dlm_digital_samples_send(GArray *data, int samples, - struct sr_dev_inst *sdi) +static int dlm_digital_samples_send(GArray *data, + struct sr_dev_inst *sdi) { + struct dev_context *devc; + struct scope_state *model_state; + uint32_t samples; struct sr_datafeed_logic logic; struct sr_datafeed_packet packet; + devc = sdi->priv; + model_state = devc->model_state; + samples = model_state->samples_per_frame; + if (data->len < samples * sizeof(uint8_t)) { sr_err("Truncated waveform data packet received."); return SR_ERR; @@ -886,13 +1047,13 @@ static int dlm_digital_samples_send(GArray *data, int samples, */ SR_PRIV int dlm_data_receive(int fd, int revents, void *cb_data) { - struct sr_channel *ch; struct sr_dev_inst *sdi; struct scope_state *model_state; struct dev_context *devc; + struct sr_channel *ch; struct sr_datafeed_packet packet; - GArray *data; - int result, num_bytes, samples; + int chunk_len, num_bytes; + static GArray *data = NULL; (void)fd; (void)revents; @@ -906,90 +1067,106 @@ SR_PRIV int dlm_data_receive(int fd, int revents, void *cb_data) if (!(model_state = (struct scope_state*)devc->model_state)) return FALSE; - if (dlm_acq_length_get(sdi->conn, &samples) != SR_OK) { - sr_err("Failed to query acquisition length."); + /* Are we waiting for a response from the device? */ + if (!devc->data_pending) return TRUE; - } - packet.type = SR_DF_FRAME_BEGIN; - sr_session_send(sdi, &packet); + /* Check if a new query response is coming our way. */ + if (!data) { + if (sr_scpi_read_begin(sdi->conn) == SR_OK) + /* The 16 here accounts for the header and EOL. */ + data = g_array_sized_new(FALSE, FALSE, sizeof(uint8_t), + 16 + model_state->samples_per_frame); + else + return TRUE; + } - /* Request data for all active channels. */ - for (devc->current_channel = devc->enabled_channels; - devc->current_channel; - devc->current_channel = devc->current_channel->next) { - ch = devc->current_channel->data; + /* Store incoming data. */ + chunk_len = sr_scpi_read_data(sdi->conn, devc->receive_buffer, + RECEIVE_BUFFER_SIZE); + if (chunk_len < 0) { + sr_err("Error while reading data: %d", chunk_len); + goto fail; + } + g_array_append_vals(data, devc->receive_buffer, chunk_len); - switch (ch->type) { - case SR_CHANNEL_ANALOG: - result = dlm_analog_data_get(sdi->conn, ch->index + 1); - break; - case SR_CHANNEL_LOGIC: - result = dlm_digital_data_get(sdi->conn); - break; - default: - sr_err("Invalid channel type encountered (%d).", - ch->type); - continue; - } + /* Read the entire query response before processing. */ + if (!sr_scpi_read_complete(sdi->conn)) + return TRUE; - if (result != SR_OK) { - sr_err("Failed to query aquisition data."); - goto fail; - } + /* We finished reading and are no longer waiting for data. */ + devc->data_pending = FALSE; - data = NULL; - if (dlm_scpi_get_raw(sdi->conn, NULL, &data) != SR_OK) { - sr_err("Failed to receive waveform data from device."); - goto fail; - } + /* Signal the beginning of a new frame if this is the first channel. */ + if (devc->current_channel == devc->enabled_channels) { + packet.type = SR_DF_FRAME_BEGIN; + sr_session_send(sdi, &packet); + } - if (dlm_block_data_header_process(data, &num_bytes) != SR_OK) { - sr_err("Encountered malformed block data header."); - goto fail; - } + if (dlm_block_data_header_process(data, &num_bytes) != SR_OK) { + sr_err("Encountered malformed block data header."); + goto fail; + } - if (num_bytes == 0) { - sr_warn("Zero-length waveform data packet received. " \ + if (num_bytes == 0) { + sr_warn("Zero-length waveform data packet received. " \ "Live mode not supported yet, stopping " \ "acquisition and retrying."); - /* Don't care about return value here. */ - dlm_acquisition_stop(sdi->conn); - goto fail; - } + /* Don't care about return value here. */ + dlm_acquisition_stop(sdi->conn); + g_array_free(data, TRUE); + dlm_channel_data_request(sdi); + return TRUE; + } - switch (ch->type) { - case SR_CHANNEL_ANALOG: - if (dlm_analog_samples_send(data, samples, - &model_state->analog_states[ch->index], - sdi) != SR_OK) - goto fail; - break; + ch = devc->current_channel->data; + switch (ch->type) { + case SR_CHANNEL_ANALOG: + if (dlm_analog_samples_send(data, + &model_state->analog_states[ch->index], + sdi) != SR_OK) + goto fail; + break; + case SR_CHANNEL_LOGIC: + if (dlm_digital_samples_send(data, sdi) != SR_OK) + goto fail; + break; + default: + sr_err("Invalid channel type encountered."); + break; + } - case SR_CHANNEL_LOGIC: - if (dlm_digital_samples_send(data, samples, - sdi) != SR_OK) - goto fail; - break; + g_array_free(data, TRUE); + data = NULL; - default: - sr_err("Invalid channel type encountered."); - break; - } + /* Signal the end of this frame if this was the last enabled channel + * and set the next enabled channel. Then, request its data. + */ + if (!devc->current_channel->next) { + packet.type = SR_DF_FRAME_END; + sr_session_send(sdi, &packet); + devc->current_channel = devc->enabled_channels; + + /* As of now we only support importing the current acquisition + * data so we're going to stop at this point. + */ + sdi->driver->dev_acquisition_stop(sdi, cb_data); + return TRUE; + } else + devc->current_channel = devc->current_channel->next; - g_array_free(data, TRUE); + if (dlm_channel_data_request(sdi) != SR_OK) { + sr_err("Failed to request acquisition data."); + goto fail; } - packet.type = SR_DF_FRAME_END; - sr_session_send(sdi, &packet); - - sdi->driver->dev_acquisition_stop(sdi, cb_data); - return TRUE; fail: - if (data) + if (data) { g_array_free(data, TRUE); + data = NULL; + } - return TRUE; + return FALSE; }