自学教程：C++ std_session_send_df_header函数代码示例

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;    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_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 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 = 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, 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;}