static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (!(devc = sdi->priv)) {
sr_err("sdi->priv was NULL.");
return SR_ERR_BUG;
}
devc->cb_data = cb_data;
/*
* Reset the number of samples to take. If we've already collected our
* quota, but we start a new session, and don't reset this, we'll just
* quit without acquiring any new samples.
*/
devc->num_samples = 0;
devc->starttime = g_get_monotonic_time();
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Poll every 50ms, or whenever some data comes in. */
serial = sdi->conn;
sr_source_add(serial->fd, G_IO_IN, 50,
brymen_dmm_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
uint8_t packet[PACKET_SIZE];
(void)cb_data;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
memset(devc->packet, 0x44, PACKET_SIZE);
devc->packet_size = 0;
devc->acquisition_running = TRUE;
serial = sdi->conn;
serial_source_add(serial, G_IO_IN, 50, atten_pps3xxx_receive_data, (void *)sdi);
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Send a "channel" configuration packet now. */
memset(packet, 0, PACKET_SIZE);
packet[0] = 0xaa;
packet[1] = 0xaa;
send_packet(sdi, packet);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (!(devc = sdi->priv)) {
sr_err("sdi->priv was NULL.");
return SR_ERR_BUG;
}
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Poll every 100ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 50,
fluke_receive_data, (void *)sdi);
if (serial_write_blocking(serial, "QM\r", 3, SERIAL_WRITE_TIMEOUT_MS) < 0) {
sr_err("Unable to send QM.");
return SR_ERR;
}
devc->cmd_sent_at = g_get_monotonic_time() / 1000;
devc->expect_response = TRUE;
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_dev_driver *di = sdi->driver;
struct drv_context *drvc = di->context;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
if (configure_channels(sdi) != SR_OK) {
sr_err("Failed to configure channels.");
return SR_ERR;
}
if (hantek_6xxx_init(sdi) != SR_OK)
return SR_ERR;
std_session_send_df_header(sdi);
devc->samp_received = 0;
devc->dev_state = FLUSH;
usb_source_add(sdi->session, drvc->sr_ctx, TICK,
handle_event, (void *)sdi);
hantek_6xxx_start_data_collecting(sdi);
read_channel(sdi, FLUSH_PACKET_SIZE);
return SR_OK;
}
static int dev_acquisition_start_2x_bd232(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
devc->settings_ok = FALSE;
devc->buflen = 0;
std_session_send_df_header(sdi, LOG_PREFIX);
/* Start timer, if required. */
if (devc->limit_msec)
g_timer_start(devc->elapsed_msec);
/* Poll every 40ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 40,
gmc_mh_2x_receive_data, (void *)sdi);
/* Send start message */
return req_meas14(sdi);
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
int ret;
struct dev_context *devc;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
if (!devc->ftdic)
return SR_ERR_BUG;
/* TODO: Configure channels later (thresholds etc.). */
/* Properly reset internal variables before every new acquisition. */
devc->compressed_bytes_ignored = 0;
devc->samples_sent = 0;
devc->bytes_received = 0;
if ((ret = scanaplus_init(devc)) < 0)
return ret;
if ((ret = scanaplus_start_acquisition(devc)) < 0)
return ret;
std_session_send_df_header(sdi);
/* Hook up a dummy handler to receive data from the device. */
sr_session_source_add(sdi->session, -1, 0, 0, scanaplus_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
struct drv_context *drvc = di->priv;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
devc->cb_data = cb_data;
if (configure_probes(sdi) != SR_OK) {
sr_err("Failed to configure probes.");
return SR_ERR;
}
if (dso_init(sdi) != SR_OK)
return SR_ERR;
if (dso_capture_start(sdi) != SR_OK)
return SR_ERR;
devc->dev_state = CAPTURE;
usb_source_add(drvc->sr_ctx, TICK, handle_event, (void *)sdi);
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct dev_context *devc = sdi->priv;
int ret;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (devc->channel) {
static const float res_array[] = {0.5, 1, 2, 5};
static const uint8_t relays[] = {100, 10, 10, 1};
devc->factor = devc->probe[devc->channel - 1] / 32.0;
devc->factor *= res_array[devc->cctl[devc->channel - 1] & 0x03];
devc->factor /= relays[(devc->cctl[devc->channel - 1] >> 4) & 0x03];
}
devc->frame = 0;
devc->cb_data = cb_data;
devc->state_known = TRUE;
devc->step = 0;
devc->adc2 = FALSE;
devc->retries = MAX_RETRIES;
ret = hung_chang_dso_2100_move_to(sdi, 0x21);
if (ret != SR_OK)
return ret;
std_session_send_df_header(cb_data, LOG_PREFIX);
sr_session_source_add(sdi->session, 0, 0, 8,
hung_chang_dso_2100_poll, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
devc->starttime = g_get_monotonic_time();
devc->num_samples = 0;
devc->reply_pending = FALSE;
devc->req_sent_at = 0;
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN,
KDXXXXP_POLL_INTERVAL_MS,
korad_kdxxxxp_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct session_vdev *vdev;
int ret;
vdev = sdi->priv;
vdev->bytes_read = 0;
vdev->cur_chunk = 0;
vdev->finished = FALSE;
sr_info("Opening archive %s file %s", vdev->sessionfile,
vdev->capturefile);
if (!(vdev->archive = zip_open(vdev->sessionfile, 0, &ret))) {
sr_err("Failed to open session file '%s': "
"zip error %d.", vdev->sessionfile, ret);
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* freewheeling source */
sr_session_source_add(-1, 0, 0, receive_data, cb_data);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
serial = sdi->conn;
sr_spew("Set O1 mode (continuous values, stable and unstable ones).");
if (serial_write_nonblocking(serial, "O1\r\n", 4) != 4)
return SR_ERR;
/* Device replies with "A00\r\n" (OK) or "E01\r\n" (Error). Ignore. */
sr_sw_limits_acquisition_start(&devc->limits);
std_session_send_df_header(sdi);
/* Poll every 50ms, or whenever some data comes in. */
serial_source_add(sdi->session, serial, G_IO_IN, 50,
kern_scale_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
GHashTableIter iter;
void *value;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
devc->sent_samples = 0;
g_hash_table_iter_init(&iter, devc->ch_ag);
while (g_hash_table_iter_next(&iter, NULL, &value))
demo_generate_analog_pattern(value, devc->cur_samplerate);
sr_session_source_add(sdi->session, -1, 0, 100,
demo_prepare_data, (struct sr_dev_inst *)sdi);
std_session_send_df_header(sdi);
/* We use this timestamp to decide how many more samples to send. */
devc->start_us = g_get_monotonic_time();
devc->spent_us = 0;
return SR_OK;
}
static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data, int dmm)
{
struct dev_context *devc;
if (!(devc = sdi->priv)) {
sr_err("sdi->priv was NULL.");
return SR_ERR_BUG;
}
devc->cb_data = cb_data;
/*
* Reset the number of samples to take. If we've already collected our
* quota, but we start a new session, and don't reset this, we'll just
* quit without acquiring any new samples.
*/
devc->num_samples = 0;
devc->starttime = g_get_monotonic_time();
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
/* Poll every 50ms, or whenever some data comes in. */
sr_source_add(devc->serial->fd, G_IO_IN, 50,
dmms[dmm].receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (!(devc = sdi->priv)) {
sr_err("sdi->priv was NULL.");
return SR_ERR_BUG;
}
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Poll every 150ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(serial, G_IO_IN, 150, colead_slm_receive_data,
(void *)sdi);
return SR_OK;
}
static int dev_acquisition_start_1x_2x_rs232(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
if (!sdi || !cb_data || !(devc = sdi->priv))
return SR_ERR_BUG;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc->cb_data = cb_data;
devc->settings_ok = FALSE;
devc->buflen = 0;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Start timer, if required. */
if (devc->limit_msec)
g_timer_start(devc->elapsed_msec);
/* Poll every 40ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 40,
gmc_mh_1x_2x_receive_data, (void *)sdi);
return SR_OK;
}
static int process_buffer(struct sr_input *in)
{
struct context *inc;
struct sr_datafeed_meta meta;
struct sr_datafeed_packet packet;
struct sr_config *src;
unsigned int offset, chunk_size;
inc = in->priv;
if (!inc->started) {
std_session_send_df_header(in->sdi, LOG_PREFIX);
if (inc->samplerate) {
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(inc->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
g_slist_free(meta.config);
sr_config_free(src);
}
inc->started = TRUE;
}
/* Round down to the last channels * unitsize boundary. */
inc->analog.num_samples = CHUNK_SIZE / inc->samplesize;
chunk_size = inc->analog.num_samples * inc->samplesize;
offset = 0;
while ((offset + chunk_size) < in->buf->len) {
inc->analog.data = in->buf->str + offset;
sr_session_send(in->sdi, &inc->packet);
offset += chunk_size;
}
inc->analog.num_samples = (in->buf->len - offset) / inc->samplesize;
chunk_size = inc->analog.num_samples * inc->samplesize;
if (chunk_size > 0) {
inc->analog.data = in->buf->str + offset;
sr_session_send(in->sdi, &inc->packet);
offset += chunk_size;
}
if ((unsigned int)offset < in->buf->len) {
/*
* The incoming buffer wasn't processed completely. Stash
* the leftover data for next time.
*/
g_string_erase(in->buf, 0, offset);
} else {
g_string_truncate(in->buf, 0);
}
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct drv_context *drvc;
struct dev_context *devc;
struct acquisition_state *acq;
int ret;
(void)cb_data;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
drvc = di->priv;
if (devc->acquisition) {
sr_err("Acquisition still in progress?");
return SR_ERR;
}
acq = lwla_alloc_acquisition_state();
if (!acq)
return SR_ERR_MALLOC;
devc->stopping_in_progress = FALSE;
devc->transfer_error = FALSE;
sr_info("Starting acquisition.");
devc->acquisition = acq;
lwla_convert_trigger(sdi);
ret = lwla_setup_acquisition(sdi);
if (ret != SR_OK) {
sr_err("Failed to set up acquisition.");
devc->acquisition = NULL;
lwla_free_acquisition_state(acq);
return ret;
}
ret = lwla_start_acquisition(sdi);
if (ret != SR_OK) {
sr_err("Failed to start acquisition.");
devc->acquisition = NULL;
lwla_free_acquisition_state(acq);
return ret;
}
usb_source_add(sdi->session, drvc->sr_ctx, 100, &lwla_receive_data,
(struct sr_dev_inst *)sdi);
sr_info("Waiting for data.");
/* Send header packet to the session bus. */
std_session_send_df_header(sdi, LOG_PREFIX);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
GSList *l;
gboolean digital_added;
struct sr_channel *ch;
struct dev_context *devc;
struct sr_scpi_dev_inst *scpi;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
scpi = sdi->conn;
devc = sdi->priv;
digital_added = FALSE;
g_slist_free(devc->enabled_channels);
devc->enabled_channels = NULL;
for (l = sdi->channels; l; l = l->next) {
ch = l->data;
if (!ch->enabled)
continue;
/* Only add a single digital channel. */
if (ch->type != SR_CHANNEL_LOGIC || !digital_added) {
devc->enabled_channels = g_slist_append(
devc->enabled_channels, ch);
if (ch->type == SR_CHANNEL_LOGIC)
digital_added = TRUE;
}
}
if (!devc->enabled_channels)
return SR_ERR;
if (hmo_check_channels(devc->enabled_channels) != SR_OK) {
sr_err("Invalid channel configuration specified!");
return SR_ERR_NA;
}
if (hmo_setup_channels(sdi) != SR_OK) {
sr_err("Failed to setup channel configuration!");
return SR_ERR;
}
sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
hmo_receive_data, (void *)sdi);
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
devc->current_channel = devc->enabled_channels;
return hmo_request_data(sdi);
}
static int process_buffer(struct sr_input *in)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_datafeed_logic logic;
struct sr_config *src;
struct context *inc;
gsize chunk_size, i;
gsize chunk;
uint16_t unitsize;
inc = in->priv;
unitsize = (g_slist_length(in->sdi->channels) + 7) / 8;
if (!inc->started) {
std_session_send_df_header(in->sdi);
if (inc->samplerate) {
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(inc->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
g_slist_free(meta.config);
sr_config_free(src);
}
inc->samples_remain = CHRONOVU_LA8_DATASIZE;
inc->samples_remain /= unitsize;
inc->started = TRUE;
}
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.unitsize = unitsize;
/* Cut off at multiple of unitsize. Avoid sending the "header". */
chunk_size = in->buf->len / logic.unitsize * logic.unitsize;
chunk_size = MIN(chunk_size, inc->samples_remain * unitsize);
for (i = 0; i < chunk_size; i += chunk) {
logic.data = in->buf->str + i;
chunk = MIN(CHUNK_SIZE, chunk_size - i);
if (chunk) {
logic.length = chunk;
sr_session_send(in->sdi, &packet);
inc->samples_remain -= chunk / unitsize;
}
}
g_string_erase(in->buf, 0, chunk_size);
return SR_OK;
}
static int loadfile(struct sr_input *in, const char *filename)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_datafeed_logic logic;
struct sr_config *src;
unsigned char buffer[CHUNKSIZE];
int fd, size, num_probes;
struct context *ctx;
ctx = in->internal;
packet.status = SR_PKT_OK;
if ((fd = open(filename, O_RDONLY)) == -1)
return SR_ERR;
num_probes = g_slist_length(in->sdi->channels);
/* Send header packet to the session bus. */
std_session_send_df_header(in->sdi, LOG_PREFIX);
if (ctx->samplerate) {
packet.type = SR_DF_META;
packet.payload = &meta;
src = sr_config_new(SR_CONF_SAMPLERATE,
g_variant_new_uint64(ctx->samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
sr_config_free(src);
}
/* Chop up the input file into chunks & send it to the session bus. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.unitsize = (num_probes + 7) / 8;
logic.data = buffer;
while ((size = read(fd, buffer, CHUNKSIZE)) > 0) {
logic.length = size;
sr_session_send(in->sdi, &packet);
}
close(fd);
/* Send end packet to the session bus. */
packet.type = SR_DF_END;
sr_session_send(in->sdi, &packet);
g_free(ctx);
in->internal = NULL;
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
GSList *l;
struct dev_context *devc;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
if (devc->limit_samples == 0)
return SR_ERR;
devc->logic_counter = devc->analog_counter = 0;
/*
* Setting two channels connected by a pipe is a remnant from when the
* demo driver generated data in a thread, and collected and sent the
* data in the main program loop.
* They are kept here because it provides a convenient way of setting
* up a timeout-based polling mechanism.
*/
if (pipe(devc->pipe_fds)) {
sr_err("%s: pipe() failed", __func__);
return SR_ERR;
}
for (l = devc->analog_channel_groups; l; l = l->next) {
generate_analog_pattern(l->data, devc->cur_samplerate);
}
devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
/* Set channel encoding to binary (default is UTF-8). */
g_io_channel_set_encoding(devc->channel, NULL, NULL);
/* Make channels to unbuffered. */
g_io_channel_set_buffered(devc->channel, FALSE);
sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
40, prepare_data, (void *)sdi);
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* We use this timestamp to decide how many more samples to send. */
devc->starttime = g_get_monotonic_time();
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
std_session_send_df_header(sdi, LOG_PREFIX);
/* Poll every 100ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 100,
agdmm_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
devc = sdi->priv;
sr_sw_limits_acquisition_start(&devc->limits);
std_session_send_df_header(sdi);
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 50,
receive_data, (void *)sdi);
return SR_OK;
}
SR_PRIV int lwla_start_acquisition(const struct sr_dev_inst *sdi)
{
struct drv_context *drvc;
struct dev_context *devc;
int ret;
const int poll_interval_ms = 100;
drvc = sdi->driver->context;
devc = sdi->priv;
if (devc->state != STATE_IDLE) {
sr_err("Not in idle state, cannot start acquisition.");
return SR_ERR;
}
devc->cancel_requested = FALSE;
devc->transfer_error = FALSE;
ret = init_acquisition_state(sdi);
if (ret != SR_OK)
return ret;
ret = (*devc->model->setup_acquisition)(sdi);
if (ret != SR_OK) {
sr_err("Failed to set up device for acquisition.");
clear_acquisition_state(sdi);
return ret;
}
/* Register event source for asynchronous USB I/O. */
ret = usb_source_add(sdi->session, drvc->sr_ctx, poll_interval_ms,
&transfer_event, (struct sr_dev_inst *)sdi);
if (ret != SR_OK) {
clear_acquisition_state(sdi);
return ret;
}
ret = submit_request(sdi, STATE_START_CAPTURE);
if (ret == SR_OK)
ret = std_session_send_df_header(sdi, LOG_PREFIX);
if (ret != SR_OK) {
usb_source_remove(sdi->session, drvc->sr_ctx);
clear_acquisition_state(sdi);
}
return ret;
}
static int loadfile(struct sr_input *in, const char *filename)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_meta meta;
struct sr_config *src;
FILE *file;
struct context *ctx;
uint64_t samplerate;
ctx = in->internal;
if ((file = fopen(filename, "r")) == NULL)
return SR_ERR;
if (!parse_header(file, ctx))
{
sr_err("VCD parsing failed");
fclose(file);
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(in->sdi, LOG_PREFIX);
/* Send metadata about the SR_DF_LOGIC packets to come. */
packet.type = SR_DF_META;
packet.payload = &meta;
samplerate = ctx->samplerate / ctx->downsample;
src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate));
meta.config = g_slist_append(NULL, src);
sr_session_send(in->sdi, &packet);
sr_config_free(src);
/* Parse the contents of the VCD file */
parse_contents(file, in->sdi, ctx);
/* Send end packet to the session bus. */
packet.type = SR_DF_END;
sr_session_send(in->sdi, &packet);
fclose(file);
release_context(ctx);
in->internal = NULL;
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
devc = sdi->priv;
devc->buffer_len = 0;
devc->memory_state = MEM_STATE_REQUEST_MEMORY_USAGE;
std_session_send_df_header(sdi);
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 150,
pce_322a_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc = sdi->priv;
struct sr_serial_dev_inst *serial;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
sr_sw_limits_acquisition_start(&devc->limits);
std_session_send_df_header(sdi);
/* Poll every 150ms, or whenever some data comes in. */
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 150,
colead_slm_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct drv_context *drvc;
int ret;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
drvc = sdi->driver->context;
if ((ret = lls_start_acquisition(sdi)) < 0)
return ret;
std_session_send_df_header(sdi);
return usb_source_add(sdi->session, drvc->sr_ctx, 100,
receive_usb_data, drvc);
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
devc = sdi->priv;
devc->cb_data = cb_data;
devc->starttime = g_get_monotonic_time();
/* Send header packet to the session bus. */
std_session_send_df_header(sdi, LOG_PREFIX);
sr_session_source_add(sdi->session, -1, 0, 10 /* poll_timeout */,
uni_t_dmm_receive_data, (void *)sdi);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
devc = sdi->priv;
devc->state = ST_INIT;
devc->num_samples = 0;
devc->buf_len = 0;
std_session_send_df_header(sdi);
serial = sdi->conn;
serial_source_add(sdi->session, serial, G_IO_IN, 150,
cem_dt_885x_receive_data, (void *)sdi);
return SR_OK;
}
