static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_header header;
struct dev_context *devc;
devc = sdi->priv;
sr_dbg("Starting acquisition.");
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
sr_dbg("Sending SR_DF_HEADER.");
packet.type = SR_DF_HEADER;
packet.payload = (uint8_t *)&header;
header.feed_version = 1;
gettimeofday(&header.starttime, NULL);
sr_session_send(devc->cb_data, &packet);
if (!strcmp(di->name, "uni-t-ut61d")) {
sr_source_add(0, 0, 10 /* poll_timeout */,
uni_t_ut61d_receive_data, (void *)sdi);
} else if (!strcmp(di->name, "voltcraft-vc820")) {
sr_source_add(0, 0, 10 /* poll_timeout */,
voltcraft_vc820_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;
/*
* 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 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;
sr_source_add(serial->fd, G_IO_IN, 150, colead_slm_receive_data,
(void *)sdi);
return SR_OK;
}
SR_PRIV int usb_source_add(struct sr_context *ctx, int timeout,
sr_receive_data_callback cb, void *cb_data)
{
if (ctx->usb_source_present) {
sr_err("A USB event source is already present.");
return SR_ERR;
}
#ifdef _WIN32
ctx->usb_event = CreateEvent(NULL, TRUE, FALSE, NULL);
g_mutex_init(&ctx->usb_mutex);
ctx->usb_thread_running = TRUE;
ctx->usb_thread = g_thread_new("usb", usb_thread, ctx);
ctx->usb_pollfd.fd = ctx->usb_event;
ctx->usb_pollfd.events = G_IO_IN;
ctx->usb_cb = cb;
ctx->usb_cb_data = cb_data;
sr_session_source_add_pollfd(&ctx->usb_pollfd, timeout, usb_callback, ctx);
#else
const struct libusb_pollfd **lupfd;
unsigned int i;
lupfd = libusb_get_pollfds(ctx->libusb_ctx);
for (i = 0; lupfd[i]; i++)
sr_source_add(lupfd[i]->fd, lupfd[i]->events, timeout, cb, cb_data);
free(lupfd);
#endif
ctx->usb_source_present = TRUE;
return SR_OK;
}
static int scpi_vxi_source_add(void *priv, int events, int timeout,
sr_receive_data_callback cb, void *cb_data)
{
(void)priv;
/* Hook up a dummy handler to receive data from the device. */
return sr_source_add(-1, events, timeout, cb, cb_data);
}
SR_PRIV int scpi_usbtmc_source_add(void *priv, int events, int timeout,
sr_receive_data_callback_t cb, void *cb_data)
{
struct usbtmc_scpi *uscpi = priv;
struct sr_usbtmc_dev_inst *usbtmc = uscpi->usbtmc;
return sr_source_add(usbtmc->fd, events, timeout, cb, cb_data);
}
static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct dev_context *devc;
devc = sdi->priv;
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
if (!strcmp(di->name, "uni-t-ut61d")) {
sr_source_add(0, 0, 10 /* poll_timeout */,
uni_t_ut61d_receive_data, (void *)sdi);
} else if (!strcmp(di->name, "voltcraft-vc820")) {
sr_source_add(0, 0, 10 /* poll_timeout */,
voltcraft_vc820_receive_data, (void *)sdi);
}
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data, int dmm)
{
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(cb_data, LOG_PREFIX);
sr_source_add(0, 0, 10 /* poll_timeout */,
udmms[dmm].receive_data, (void *)sdi);
return SR_OK;
}
static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
const struct libusb_pollfd **lupfd;
struct sr_datafeed_packet packet;
struct sr_datafeed_header header;
struct dev_context *devc;
struct drv_context *drvc = di->priv;
int i;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR;
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(devc) != SR_OK)
return SR_ERR;
if (dso_capture_start(devc) != SR_OK)
return SR_ERR;
devc->dev_state = CAPTURE;
lupfd = libusb_get_pollfds(drvc->sr_ctx->libusb_ctx);
for (i = 0; lupfd[i]; i++)
sr_source_add(lupfd[i]->fd, lupfd[i]->events, TICK,
handle_event, (void *)sdi);
free(lupfd);
/* Send header packet to the session bus. */
packet.type = SR_DF_HEADER;
packet.payload = (unsigned char *)&header;
header.feed_version = 1;
gettimeofday(&header.starttime, NULL);
sr_session_send(cb_data, &packet);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data, int idx)
{
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;
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 100ms, or whenever some data comes in. */
serial = sdi->conn;
sr_source_add(serial->fd, G_IO_IN, 100,
mic_devs[idx].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;
int ret = SR_ERR;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
if (mso_configure_probes(sdi) != SR_OK) {
sr_err("Failed to configure probes.");
return SR_ERR;
}
/* FIXME: No need to do full reconfigure every time */
// ret = mso_reset_fsm(sdi);
// if (ret != SR_OK)
// return ret;
/* FIXME: ACDC Mode */
devc->ctlbase1 &= 0x7f;
// devc->ctlbase1 |= devc->acdcmode;
ret = mso_configure_rate(sdi, devc->cur_rate);
if (ret != SR_OK)
return ret;
/* set dac offset */
ret = mso_dac_out(sdi, devc->dac_offset);
if (ret != SR_OK)
return ret;
ret = mso_configure_threshold_level(sdi);
if (ret != SR_OK)
return ret;
ret = mso_configure_trigger(sdi);
if (ret != SR_OK)
return ret;
/* END of config hardware part */
ret = mso_arm(sdi);
if (ret != SR_OK)
return ret;
/* Start acquisition on the device. */
mso_check_trigger(devc->serial, &devc->trigger_state);
ret = mso_check_trigger(devc->serial, NULL);
if (ret != SR_OK)
return ret;
/* Reset trigger state. */
devc->trigger_state = 0x00;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Our first probe is analog, the other 8 are of type 'logic'. */
/* TODO. */
sr_source_add(devc->serial->fd, G_IO_IN, -1, mso_receive_data, cb_data);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
uint8_t buf[4];
int bytes_written;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (!(devc = sdi->priv)) {
sr_err("%s: sdi->priv was NULL.", __func__);
return SR_ERR_BUG;
}
if (!devc->ftdic) {
sr_err("%s: devc->ftdic was NULL.", __func__);
return SR_ERR_BUG;
}
devc->divcount = samplerate_to_divcount(devc->cur_samplerate);
if (devc->divcount == 0xff) {
sr_err("%s: Invalid divcount/samplerate.", __func__);
return SR_ERR;
}
if (configure_probes(sdi) != SR_OK) {
sr_err("Failed to configure probes.");
return SR_ERR;
}
/* Fill acquisition parameters into buf[]. */
buf[0] = devc->divcount;
buf[1] = 0xff; /* This byte must always be 0xff. */
buf[2] = devc->trigger_pattern;
buf[3] = devc->trigger_mask;
/* Start acquisition. */
bytes_written = la8_write(devc, buf, 4);
if (bytes_written < 0) {
sr_err("Acquisition failed to start: %d.", bytes_written);
return SR_ERR;
} else if (bytes_written != 4) {
sr_err("Acquisition failed to start: %d.", bytes_written);
return SR_ERR;
}
sr_dbg("Hardware acquisition started successfully.");
devc->cb_data = cb_data;
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Time when we should be done (for detecting trigger timeouts). */
devc->done = (devc->divcount + 1) * 0.08388608 + time(NULL)
+ devc->trigger_timeout;
devc->block_counter = 0;
devc->trigger_found = 0;
/* Hook up a dummy handler to receive data from the LA8. */
sr_source_add(-1, G_IO_IN, 0, receive_data, (void *)sdi);
return SR_OK;
}
static int hw_start_acquisition(int device_index, gpointer session_data)
{
struct sr_device_instance *sdi;
struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header;
struct fx2_device *fx2;
struct libusb_transfer *transfer;
const struct libusb_pollfd **lupfd;
int size, i;
unsigned char *buf;
if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR;
fx2 = sdi->priv;
fx2->session_data = session_data;
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("saleae: %s: packet malloc failed", __func__);
return SR_ERR_MALLOC;
}
if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
sr_err("saleae: %s: header malloc failed", __func__);
return SR_ERR_MALLOC;
}
/* Start with 2K transfer, subsequently increased to 4K. */
size = 2048;
for (i = 0; i < NUM_SIMUL_TRANSFERS; i++) {
if (!(buf = g_try_malloc(size))) {
sr_err("saleae: %s: buf malloc failed", __func__);
return SR_ERR_MALLOC;
}
transfer = libusb_alloc_transfer(0);
libusb_fill_bulk_transfer(transfer, sdi->usb->devhdl,
2 | LIBUSB_ENDPOINT_IN, buf, size,
receive_transfer, fx2, 40);
if (libusb_submit_transfer(transfer) != 0) {
/* TODO: Free them all. */
libusb_free_transfer(transfer);
g_free(buf);
return SR_ERR;
}
size = 4096;
}
lupfd = libusb_get_pollfds(usb_context);
for (i = 0; lupfd[i]; i++)
sr_source_add(lupfd[i]->fd, lupfd[i]->events, 40, receive_data,
NULL);
free(lupfd);
packet->type = SR_DF_HEADER;
packet->payload = header;
header->feed_version = 1;
gettimeofday(&header->starttime, NULL);
header->samplerate = fx2->cur_samplerate;
header->num_logic_probes = fx2->profile->num_probes;
header->num_analog_probes = 0;
sr_session_bus(session_data, packet);
g_free(header);
g_free(packet);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct sr_serial_dev_inst *serial;
struct dev_context *devc;
struct sr_probe *probe;
GSList *l;
char cmd[256];
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
serial = sdi->conn;
devc = sdi->priv;
for (l = sdi->probes; l; l = l->next) {
probe = l->data;
sr_dbg("handling probe %s", probe->name);
if (probe->type == SR_PROBE_ANALOG) {
if (probe->enabled)
devc->enabled_analog_probes = g_slist_append(
devc->enabled_analog_probes, probe);
if (probe->enabled != devc->analog_channels[probe->index]) {
/* Enabled channel is currently disabled, or vice versa. */
sprintf(cmd, ":CHAN%d:DISP %s", probe->index + 1,
probe->enabled ? "ON" : "OFF");
if (rigol_ds1xx2_send(sdi, cmd) != SR_OK)
return SR_ERR;
}
} else if (probe->type == SR_PROBE_LOGIC) {
if (probe->enabled)
devc->enabled_digital_probes = g_slist_append(
devc->enabled_digital_probes, probe);
if (probe->enabled != devc->digital_channels[probe->index]) {
/* Enabled channel is currently disabled, or vice versa. */
sprintf(cmd, ":DIG%d:TURN %s", probe->index,
probe->enabled ? "ON" : "OFF");
if (rigol_ds1xx2_send(sdi, cmd) != SR_OK)
return SR_ERR;
}
}
}
if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
return SR_ERR;
sr_source_add(serial->fd, G_IO_IN, 50, rigol_ds1xx2_receive, (void *)sdi);
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* Fetch the first frame. */
if (devc->enabled_analog_probes) {
devc->channel_frame = devc->enabled_analog_probes->data;
if (rigol_ds1xx2_send(sdi, ":WAV:DATA? CHAN%d",
devc->channel_frame->index + 1) != SR_OK)
return SR_ERR;
} else {
devc->channel_frame = devc->enabled_digital_probes->data;
if (rigol_ds1xx2_send(sdi, ":WAV:DATA? DIG") != SR_OK)
return SR_ERR;
}
devc->num_frame_bytes = 0;
return SR_OK;
}
static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
void *cb_data)
{
struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header;
struct dev_context *devc;
int ret = SR_ERR;
devc = sdi->priv;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR;
if (mso_configure_probes(sdi) != SR_OK) {
sr_err("Failed to configure probes.");
return SR_ERR;
}
/* FIXME: No need to do full reconfigure every time */
// ret = mso_reset_fsm(sdi);
// if (ret != SR_OK)
// return ret;
/* FIXME: ACDC Mode */
devc->ctlbase1 &= 0x7f;
// devc->ctlbase1 |= devc->acdcmode;
ret = mso_configure_rate(sdi, devc->cur_rate);
if (ret != SR_OK)
return ret;
/* set dac offset */
ret = mso_dac_out(sdi, devc->dac_offset);
if (ret != SR_OK)
return ret;
ret = mso_configure_threshold_level(sdi);
if (ret != SR_OK)
return ret;
ret = mso_configure_trigger(sdi);
if (ret != SR_OK)
return ret;
/* END of config hardware part */
ret = mso_arm(sdi);
if (ret != SR_OK)
return ret;
/* Start acquisition on the device. */
mso_check_trigger(devc->serial, &devc->trigger_state);
ret = mso_check_trigger(devc->serial, NULL);
if (ret != SR_OK)
return ret;
sr_source_add(devc->serial->fd, G_IO_IN, -1, mso_receive_data, cb_data);
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("Datafeed packet malloc failed.");
return SR_ERR_MALLOC;
}
if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
sr_err("Datafeed header malloc failed.");
g_free(packet);
return SR_ERR_MALLOC;
}
packet->type = SR_DF_HEADER;
packet->payload = (unsigned char *)header;
header->feed_version = 1;
gettimeofday(&header->starttime, NULL);
sr_session_send(cb_data, packet);
g_free(header);
g_free(packet);
return SR_OK;
}
static int hw_start_acquisition(int device_index, gpointer session_data)
{
struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header;
struct databag *mydata;
/* TODO: 'mydata' is never g_free()'d? */
if (!(mydata = g_try_malloc(sizeof(struct databag)))) {
sr_err("demo: %s: mydata malloc failed", __func__);
return SR_ERR_MALLOC;
}
mydata->sample_generator = default_pattern;
mydata->session_data = session_data;
mydata->device_index = device_index;
mydata->samples_counter = 0;
if (pipe(mydata->pipe_fds)) {
/* TODO: Better error message. */
sr_err("demo: %s: pipe() failed", __func__);
return SR_ERR;
}
channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
/* Set channel encoding to binary (default is UTF-8). */
g_io_channel_set_encoding(channels[0], NULL, NULL);
g_io_channel_set_encoding(channels[1], NULL, NULL);
/* Make channels to unbuffered. */
g_io_channel_set_buffered(channels[0], FALSE);
g_io_channel_set_buffered(channels[1], FALSE);
sr_source_add(mydata->pipe_fds[0], G_IO_IN | G_IO_ERR, 40,
receive_data, session_data);
/* Run the demo thread. */
g_thread_init(NULL);
/* This must to be done between g_thread_init() & g_thread_create(). */
mydata->timer = g_timer_new();
thread_running = 1;
my_thread =
g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
if (!my_thread) {
sr_err("demo: %s: g_thread_create failed", __func__);
return SR_ERR; /* TODO */
}
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("demo: %s: packet malloc failed", __func__);
return SR_ERR_MALLOC;
}
if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
sr_err("demo: %s: header malloc failed", __func__);
return SR_ERR_MALLOC;
}
packet->type = SR_DF_HEADER;
packet->payload = header;
packet->timeoffset = 0;
packet->duration = 0;
header->feed_version = 1;
gettimeofday(&header->starttime, NULL);
header->samplerate = cur_samplerate;
header->num_logic_probes = NUM_PROBES;
header->num_analog_probes = 0;
sr_session_bus(session_data, packet);
g_free(header);
g_free(packet);
return SR_OK;
}
