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)
{
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 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 scpi_gpib_source_add(struct sr_session *session, 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_session_source_add(session, -1, events, timeout, cb, cb_data);
}
static int scpi_tcp_source_add(struct sr_session *session, void *priv,
int events, int timeout, sr_receive_data_callback cb, void *cb_data)
{
struct scpi_tcp *tcp = priv;
return sr_session_source_add(session, tcp->socket, events, timeout,
cb, cb_data);
}
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,
void *cb_data)
{
struct zip_stat zs;
struct session_vdev *vdev;
int ret;
vdev = sdi->priv;
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\n", vdev->sessionfile, ret);
return SR_ERR;
}
if (zip_stat(vdev->archive, vdev->capturefile, 0, &zs) == -1) {
sr_err("Failed to check capture file '%s' in "
"session file '%s'.", vdev->capturefile, vdev->sessionfile);
return SR_ERR;
}
if (!(vdev->capfile = zip_fopen(vdev->archive, vdev->capturefile, 0))) {
sr_err("Failed to open capture file '%s' in "
"session file '%s'.", vdev->capturefile, vdev->sessionfile);
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(sdi, LOG_PREFIX);
/* freewheeling source */
sr_session_source_add(-1, 0, 0, receive_data, sdi);
return SR_OK;
}
/* Turn off buffering on stdin. */
void add_anykey(void)
{
#ifdef _WIN32
stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
if (!GetConsoleMode(stdin_handle, &stdin_mode)) {
/* TODO: Error handling. */
}
SetConsoleMode(stdin_handle, 0);
#else
struct termios term;
tcgetattr(STDIN_FILENO, &term);
memcpy(&term_orig, &term, sizeof(struct termios));
term.c_lflag &= ~(ECHO | ICANON | ISIG);
tcsetattr(STDIN_FILENO, TCSADRAIN, &term);
#endif
sr_session_source_add(STDIN_FILENO, G_IO_IN, -1, received_anykey, NULL);
printf("Press any key to stop acquisition.\n");
}
/** @private */
SR_PRIV int sr_source_add(int fd, int events, int timeout,
sr_receive_data_callback_t cb, void *cb_data)
{
return sr_session_source_add(fd, events, timeout, cb, cb_data);
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct dev_context *devc;
uint8_t buf[8];
int bytes_to_write, bytes_written;
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;
}
if (!devc->ftdic) {
sr_err("devc->ftdic was NULL.");
return SR_ERR_BUG;
}
devc->divcount = cv_samplerate_to_divcount(sdi, devc->cur_samplerate);
if (devc->divcount == 0xff) {
sr_err("Invalid divcount/samplerate.");
return SR_ERR;
}
if (cv_convert_trigger(sdi) != SR_OK) {
sr_err("Failed to configure trigger.");
return SR_ERR;
}
/* Fill acquisition parameters into buf[]. */
if (devc->prof->model == CHRONOVU_LA8) {
buf[0] = devc->divcount;
buf[1] = 0xff; /* This byte must always be 0xff. */
buf[2] = devc->trigger_pattern & 0xff;
buf[3] = devc->trigger_mask & 0xff;
bytes_to_write = 4;
} else {
buf[0] = devc->divcount;
buf[1] = 0xff; /* This byte must always be 0xff. */
buf[2] = (devc->trigger_pattern & 0xff00) >> 8; /* LSB */
buf[3] = (devc->trigger_pattern & 0x00ff) >> 0; /* MSB */
buf[4] = (devc->trigger_mask & 0xff00) >> 8; /* LSB */
buf[5] = (devc->trigger_mask & 0x00ff) >> 0; /* MSB */
buf[6] = (devc->trigger_edgemask & 0xff00) >> 8; /* LSB */
buf[7] = (devc->trigger_edgemask & 0x00ff) >> 0; /* MSB */
bytes_to_write = 8;
}
/* Start acquisition. */
bytes_written = cv_write(devc, buf, bytes_to_write);
if (bytes_written < 0 || bytes_written != bytes_to_write) {
sr_err("Acquisition failed to start.");
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(sdi, LOG_PREFIX);
/* Time when we should be done (for detecting trigger timeouts). */
devc->done = (devc->divcount + 1) * devc->prof->trigger_constant +
g_get_monotonic_time() + (10 * G_TIME_SPAN_SECOND);
devc->block_counter = 0;
devc->trigger_found = 0;
/* Hook up a dummy handler to receive data from the device. */
sr_session_source_add(sdi->session, -1, G_IO_IN, 0, receive_data, (void *)sdi);
return SR_OK;
}
static int hw_start_acquisition(int device_index, gpointer session_device_id)
{
struct zip_stat zs;
struct session_vdevice *vdevice;
struct sr_datafeed_header *header;
struct sr_datafeed_packet *packet;
int err;
/* Avoid compiler warnings. */
(void)session_device_id;
if (!(vdevice = get_vdevice_by_index(device_index)))
return SR_ERR;
sr_info("session_driver: opening archive %s file %s", sessionfile,
vdevice->capturefile);
if (!(vdevice->archive = zip_open(sessionfile, 0, &err))) {
sr_warn("Failed to open session file '%s': zip error %d\n",
sessionfile, err);
return SR_ERR;
}
if (zip_stat(vdevice->archive, vdevice->capturefile, 0, &zs) == -1) {
sr_warn("Failed to check capture file '%s' in session file '%s'.",
vdevice->capturefile, sessionfile);
return SR_ERR;
}
if (!(vdevice->capfile = zip_fopen(vdevice->archive, vdevice->capturefile, 0))) {
sr_warn("Failed to open capture file '%s' in session file '%s'.",
vdevice->capturefile, sessionfile);
return SR_ERR;
}
/* freewheeling source */
sr_session_source_add(-1, 0, 0, feed_chunk, session_device_id);
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("session: %s: packet malloc failed", __func__);
return SR_ERR_MALLOC;
}
if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
sr_err("session: %s: header malloc failed", __func__);
return SR_ERR_MALLOC;
}
/* 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);
header->samplerate = vdevice->samplerate;
header->num_logic_probes = vdevice->num_probes;
header->num_analog_probes = 0;
sr_session_bus(session_device_id, packet);
g_free(header);
g_free(packet);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct clockselect_50 clockselect;
int frac, triggerpin, ret;
uint8_t triggerselect = 0;
struct triggerinout triggerinout_conf;
struct triggerlut lut;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
if (sigma_convert_trigger(sdi) != SR_OK) {
sr_err("Failed to configure triggers.");
return SR_ERR;
}
/* If the samplerate has not been set, default to 200 kHz. */
if (devc->cur_firmware == -1) {
if ((ret = sigma_set_samplerate(sdi, SR_KHZ(200))) != SR_OK)
return ret;
}
/* Enter trigger programming mode. */
sigma_set_register(WRITE_TRIGGER_SELECT1, 0x20, devc);
/* 100 and 200 MHz mode. */
if (devc->cur_samplerate >= SR_MHZ(100)) {
sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81, devc);
/* Find which pin to trigger on from mask. */
for (triggerpin = 0; triggerpin < 8; triggerpin++)
if ((devc->trigger.risingmask | devc->trigger.fallingmask) &
(1 << triggerpin))
break;
/* Set trigger pin and light LED on trigger. */
triggerselect = (1 << LEDSEL1) | (triggerpin & 0x7);
/* Default rising edge. */
if (devc->trigger.fallingmask)
triggerselect |= 1 << 3;
/* All other modes. */
} else if (devc->cur_samplerate <= SR_MHZ(50)) {
sigma_build_basic_trigger(&lut, devc);
sigma_write_trigger_lut(&lut, devc);
triggerselect = (1 << LEDSEL1) | (1 << LEDSEL0);
}
/* Setup trigger in and out pins to default values. */
memset(&triggerinout_conf, 0, sizeof(struct triggerinout));
triggerinout_conf.trgout_bytrigger = 1;
triggerinout_conf.trgout_enable = 1;
sigma_write_register(WRITE_TRIGGER_OPTION,
(uint8_t *) &triggerinout_conf,
sizeof(struct triggerinout), devc);
/* Go back to normal mode. */
sigma_set_register(WRITE_TRIGGER_SELECT1, triggerselect, devc);
/* Set clock select register. */
if (devc->cur_samplerate == SR_MHZ(200))
/* Enable 4 channels. */
sigma_set_register(WRITE_CLOCK_SELECT, 0xf0, devc);
else if (devc->cur_samplerate == SR_MHZ(100))
/* Enable 8 channels. */
sigma_set_register(WRITE_CLOCK_SELECT, 0x00, devc);
else {
/*
* 50 MHz mode (or fraction thereof). Any fraction down to
* 50 MHz / 256 can be used, but is not supported by sigrok API.
*/
frac = SR_MHZ(50) / devc->cur_samplerate - 1;
clockselect.async = 0;
clockselect.fraction = frac;
clockselect.disabled_channels = 0;
sigma_write_register(WRITE_CLOCK_SELECT,
(uint8_t *) &clockselect,
sizeof(clockselect), devc);
}
/* Setup maximum post trigger time. */
sigma_set_register(WRITE_POST_TRIGGER,
(devc->capture_ratio * 255) / 100, devc);
/* Start acqusition. */
gettimeofday(&devc->start_tv, 0);
sigma_set_register(WRITE_MODE, 0x0d, devc);
std_session_send_df_header(sdi, LOG_PREFIX);
/* Add capture source. */
sr_session_source_add(sdi->session, -1, 0, 10, sigma_receive_data, (void *)sdi);
devc->state.state = SIGMA_CAPTURE;
return SR_OK;
}
