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 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 handle_event(int fd, int revents, void *cb_data)
{
const struct sr_dev_inst *sdi;
struct sr_datafeed_packet packet;
struct timeval tv;
struct dev_context *devc;
struct drv_context *drvc = di->priv;
int num_probes;
uint32_t trigger_offset;
uint8_t capturestate;
(void)fd;
(void)revents;
sdi = cb_data;
devc = sdi->priv;
if (devc->dev_state == STOPPING) {
/* We've been told to wind up the acquisition. */
sr_dbg("Stopping acquisition.");
/*
* TODO: Doesn't really cancel pending transfers so they might
* come in after SR_DF_END is sent.
*/
usb_source_remove(drvc->sr_ctx);
packet.type = SR_DF_END;
sr_session_send(sdi, &packet);
devc->dev_state = IDLE;
return TRUE;
}
/* Always handle pending libusb events. */
tv.tv_sec = tv.tv_usec = 0;
libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
/* TODO: ugh */
if (devc->dev_state == NEW_CAPTURE) {
if (dso_capture_start(sdi) != SR_OK)
return TRUE;
if (dso_enable_trigger(sdi) != SR_OK)
return TRUE;
// if (dso_force_trigger(sdi) != SR_OK)
// return TRUE;
sr_dbg("Successfully requested next chunk.");
devc->dev_state = CAPTURE;
return TRUE;
}
if (devc->dev_state != CAPTURE)
return TRUE;
if ((dso_get_capturestate(sdi, &capturestate, &trigger_offset)) != SR_OK)
return TRUE;
sr_dbg("Capturestate %d.", capturestate);
sr_dbg("Trigger offset 0x%.6x.", trigger_offset);
switch (capturestate) {
case CAPTURE_EMPTY:
if (++devc->capture_empty_count >= MAX_CAPTURE_EMPTY) {
devc->capture_empty_count = 0;
if (dso_capture_start(sdi) != SR_OK)
break;
if (dso_enable_trigger(sdi) != SR_OK)
break;
// if (dso_force_trigger(sdi) != SR_OK)
// break;
sr_dbg("Successfully requested next chunk.");
}
break;
case CAPTURE_FILLING:
/* No data yet. */
break;
case CAPTURE_READY_8BIT:
/* Remember where in the captured frame the trigger is. */
devc->trigger_offset = trigger_offset;
num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
/* TODO: Check malloc return value. */
devc->framebuf = g_try_malloc(devc->framesize * num_probes * 2);
devc->samp_buffered = devc->samp_received = 0;
/* Tell the scope to send us the first frame. */
if (dso_get_channeldata(sdi, receive_transfer) != SR_OK)
break;
/*
* Don't hit the state machine again until we're done fetching
* the data we just told the scope to send.
*/
devc->dev_state = FETCH_DATA;
/* Tell the frontend a new frame is on the way. */
packet.type = SR_DF_FRAME_BEGIN;
sr_session_send(sdi, &packet);
break;
case CAPTURE_READY_9BIT:
/* TODO */
sr_err("Not yet supported.");
break;
case CAPTURE_TIMEOUT:
/* Doesn't matter, we'll try again next time. */
break;
default:
sr_dbg("Unknown capture state: %d.", capturestate);
break;
}
return TRUE;
}
static
void *dso_thread(void *ptr)
{
DMSG("DSO thread started\n");
while(!fl_terminate) {
if(!fl_running) {
pthread_mutex_lock(&thread_mutex); // wait on signal
pthread_mutex_unlock(&thread_mutex);
if(fl_terminate)
return 0;
}
//DMSG("period = %d\n", dso_period_usec);
if(my_cb) {
my_cb();
my_cb = 0;
}
dso_capture_start();
myusleep(dso_period_usec);
dso_trigger_enabled();
int fl_complete = 0;
int trPoint = 0;
int nr_empty = 0;
while(!fl_complete) {
int cs = dso_get_capture_state(&trPoint);
if (cs < 0) {
DMSG("dso_get_capture_state io error\n");
continue;
}
switch(cs) {
case 0: // empty
if(nr_empty == 3) {
dso_capture_start();
nr_empty = 0;
}
nr_empty++;
dso_trigger_enabled();
dso_force_trigger();
myusleep(dso_period_usec);
break;
case 1: // in progress
myusleep(dso_period_usec >> 1);
myusleep(dso_period_usec >> 1);
break;
case 2: // full
pthread_mutex_lock(&buffer_mutex);
if (dso_get_channel_data(dso_buffer, dso_buffer_size) < 0) {
DMSG("Error in command GetChannelData\n");
}
dso_buffer_dirty = 1;
dso_trigger_point = trPoint;
pthread_mutex_unlock(&buffer_mutex);
/*FORMERLEY UPDATE_GUI */
fl_complete = 1;
break;
default:
DMSG("unknown capture state %i\n", cs);
break;
}
}
}
return 0;
}
