static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { 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; devc->cb_data = cb_data; 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; /* Send header packet to the session bus. */ std_session_send_df_header(cb_data, LOG_PREFIX); 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(const struct sr_dev_inst *sdi, void *cb_data) { 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; devc->cb_data = cb_data; if (configure_channels(sdi) != SR_OK) { sr_err("Failed to configure channels."); 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(sdi->session, 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; }
int main(int argc, char *argv[]) { (void) argc; (void) argv; struct xdf *xdf = NULL; int step, retval = EXIT_FAILURE; unsigned int ns, i; size_t strides[NARRAYS] = { NEEG*sizeof(eeg[0]), NSENS*sizeof(sens[0]), sizeof(trigger[0]) }; /************************************************* * File preparation * *************************************************/ step = 0; xdf = xdf_open(filename, XDF_WRITE, XDF_BDF); if (xdf == NULL) goto exit; xdf_set_conf(xdf, XDF_F_SAMPLING_FREQ, FS, XDF_NOF); step++; if (configure_channels(xdf, NEEG, NSENS)) goto exit; step++; if (xdf_define_arrays(xdf, NARRAYS, strides) || xdf_prepare_transfer(xdf) ) goto exit; /************************************************ * Writing loop * *************************************************/ step++; for (i=0; i<TOTAL_NS; i+=NS) { ns = ((TOTAL_NS - i) >= NS) ? NS : (TOTAL_NS - i); generate_signal(NEEG, eeg, NSENS, sens, trigger, FS, ns); if (xdf_write(xdf, ns, eeg, sens, trigger) < 0) goto exit; } retval = EXIT_SUCCESS; exit: if (retval != EXIT_SUCCESS) { fprintf(stderr, "Error while %s : (%i) %s\n", stepmsg[step], errno, strerror(errno)); } xdf_close(xdf); return retval; }
SR_PRIV int fx2lafw_start_acquisition(const struct sr_dev_inst *sdi) { struct sr_dev_driver *di; struct drv_context *drvc; struct dev_context *devc; int timeout, ret; size_t size; di = sdi->driver; drvc = di->context; devc = sdi->priv; devc->ctx = drvc->sr_ctx; devc->sent_samples = 0; devc->empty_transfer_count = 0; devc->acq_aborted = FALSE; if (configure_channels(sdi) != SR_OK) { sr_err("Failed to configure channels."); return SR_ERR; } timeout = get_timeout(devc); usb_source_add(sdi->session, devc->ctx, timeout, receive_data, drvc); size = get_buffer_size(devc); /* Prepare for analog sampling. */ if (g_slist_length(devc->enabled_analog_channels) > 0) { /* We need a buffer half the size of a transfer. */ devc->logic_buffer = g_try_malloc(size / 2); devc->analog_buffer = g_try_malloc( sizeof(float) * size / 2); } start_transfers(sdi); if ((ret = command_start_acquisition(sdi)) != SR_OK) { fx2lafw_abort_acquisition(devc); return ret; } return SR_OK; }
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { struct dev_context *devc; struct sr_usb_dev_inst *usb; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; unsigned int samples_read; int res; unsigned int packet_num, n; unsigned char *buf; unsigned int status; unsigned int stop_address; unsigned int now_address; unsigned int trigger_address; unsigned int trigger_offset; unsigned int triggerbar; unsigned int ramsize_trigger; unsigned int memory_size; unsigned int valid_samples; unsigned int discard; int trigger_now; 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_ARG; } if (configure_channels(sdi) != SR_OK) { sr_err("Failed to configure channels."); return SR_ERR; } usb = sdi->conn; set_triggerbar(devc); /* Push configured settings to device. */ analyzer_configure(usb->devhdl); analyzer_start(usb->devhdl); sr_info("Waiting for data."); analyzer_wait_data(usb->devhdl); status = analyzer_read_status(usb->devhdl); stop_address = analyzer_get_stop_address(usb->devhdl); now_address = analyzer_get_now_address(usb->devhdl); trigger_address = analyzer_get_trigger_address(usb->devhdl); triggerbar = analyzer_get_triggerbar_address(); ramsize_trigger = analyzer_get_ramsize_trigger_address(); n = get_memory_size(devc->memory_size); memory_size = n / 4; sr_info("Status = 0x%x.", status); sr_info("Stop address = 0x%x.", stop_address); sr_info("Now address = 0x%x.", now_address); sr_info("Trigger address = 0x%x.", trigger_address); sr_info("Triggerbar address = 0x%x.", triggerbar); sr_info("Ramsize trigger = 0x%x.", ramsize_trigger); sr_info("Memory size = 0x%x.", memory_size); /* Send header packet to the session bus. */ std_session_send_df_header(cb_data, LOG_PREFIX); /* Check for empty capture */ if ((status & STATUS_READY) && !stop_address) { packet.type = SR_DF_END; sr_session_send(cb_data, &packet); return SR_OK; } if (!(buf = g_try_malloc(PACKET_SIZE))) { sr_err("Packet buffer malloc failed."); return SR_ERR_MALLOC; } /* Check if the trigger is in the samples we are throwing away */ trigger_now = now_address == trigger_address || ((now_address + 1) % memory_size) == trigger_address; /* * STATUS_READY doesn't clear until now_address advances past * addr 0, but for our logic, clear it in that case */ if (!now_address) status &= ~STATUS_READY; analyzer_read_start(usb->devhdl); /* Calculate how much data to discard */ discard = 0; if (status & STATUS_READY) { /* * We haven't wrapped around, we need to throw away data from * our current position to the end of the buffer. * Additionally, the first two samples captured are always * bogus. */ discard += memory_size - now_address + 2; now_address = 2; } /* If we have more samples than we need, discard them */ valid_samples = (stop_address - now_address) % memory_size; if (valid_samples > ramsize_trigger + triggerbar) { discard += valid_samples - (ramsize_trigger + triggerbar); now_address += valid_samples - (ramsize_trigger + triggerbar); } sr_info("Need to discard %d samples.", discard); /* Calculate how far in the trigger is */ if (trigger_now) trigger_offset = 0; else trigger_offset = (trigger_address - now_address) % memory_size; /* Recalculate the number of samples available */ valid_samples = (stop_address - now_address) % memory_size; /* Send the incoming transfer to the session bus. */ samples_read = 0; for (packet_num = 0; packet_num < n / PACKET_SIZE; packet_num++) { unsigned int len; unsigned int buf_offset; res = analyzer_read_data(usb->devhdl, buf, PACKET_SIZE); sr_info("Tried to read %d bytes, actually read %d bytes.", PACKET_SIZE, res); if (discard >= PACKET_SIZE / 4) { discard -= PACKET_SIZE / 4; continue; } len = PACKET_SIZE - discard * 4; buf_offset = discard * 4; discard = 0; /* Check if we've read all the samples */ if (samples_read + len / 4 >= valid_samples) len = (valid_samples - samples_read) * 4; if (!len) break; if (samples_read < trigger_offset && samples_read + len / 4 > trigger_offset) { /* Send out samples remaining before trigger */ packet.type = SR_DF_LOGIC; packet.payload = &logic; logic.length = (trigger_offset - samples_read) * 4; logic.unitsize = 4; logic.data = buf + buf_offset; sr_session_send(cb_data, &packet); len -= logic.length; samples_read += logic.length / 4; buf_offset += logic.length; } if (samples_read == trigger_offset) { /* Send out trigger */ packet.type = SR_DF_TRIGGER; packet.payload = NULL; sr_session_send(cb_data, &packet); } /* Send out data (or data after trigger) */ packet.type = SR_DF_LOGIC; packet.payload = &logic; logic.length = len; logic.unitsize = 4; logic.data = buf + buf_offset; sr_session_send(cb_data, &packet); samples_read += len / 4; } analyzer_read_stop(usb->devhdl); g_free(buf); packet.type = SR_DF_END; sr_session_send(cb_data, &packet); return SR_OK; }
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { struct sr_dev_driver *di = sdi->driver; struct dev_context *devc; struct drv_context *drvc; struct sr_usb_dev_inst *usb; struct sr_trigger *trigger; struct libusb_transfer *transfer; unsigned int i, timeout, num_transfers; int ret; unsigned char *buf; size_t size, convsize; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; drvc = di->priv; devc = sdi->priv; usb = sdi->conn; /* Configures devc->cur_channels. */ if (configure_channels(sdi) != SR_OK) { sr_err("Failed to configure channels."); return SR_ERR; } devc->cb_data = cb_data; devc->sent_samples = 0; devc->empty_transfer_count = 0; devc->cur_channel = 0; memset(devc->channel_data, 0, sizeof(devc->channel_data)); if ((trigger = sr_session_trigger_get(sdi->session))) { int pre_trigger_samples = 0; if (devc->limit_samples > 0) pre_trigger_samples = devc->capture_ratio * devc->limit_samples/100; devc->stl = soft_trigger_logic_new(sdi, trigger, pre_trigger_samples); if (!devc->stl) return SR_ERR_MALLOC; devc->trigger_fired = FALSE; } else devc->trigger_fired = TRUE; timeout = get_timeout(devc); num_transfers = get_number_of_transfers(devc); size = get_buffer_size(devc); convsize = (size / devc->num_channels + 2) * 16; devc->submitted_transfers = 0; devc->convbuffer_size = convsize; if (!(devc->convbuffer = g_try_malloc(convsize))) { sr_err("Conversion buffer malloc failed."); return SR_ERR_MALLOC; } devc->transfers = g_try_malloc0(sizeof(*devc->transfers) * num_transfers); if (!devc->transfers) { sr_err("USB transfers malloc failed."); g_free(devc->convbuffer); return SR_ERR_MALLOC; } if ((ret = logic16_setup_acquisition(sdi, devc->cur_samplerate, devc->cur_channels)) != SR_OK) { g_free(devc->transfers); g_free(devc->convbuffer); return ret; } devc->num_transfers = num_transfers; for (i = 0; i < num_transfers; i++) { if (!(buf = g_try_malloc(size))) { sr_err("USB transfer buffer malloc failed."); if (devc->submitted_transfers) abort_acquisition(devc); else { g_free(devc->transfers); g_free(devc->convbuffer); } return SR_ERR_MALLOC; } transfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(transfer, usb->devhdl, 2 | LIBUSB_ENDPOINT_IN, buf, size, logic16_receive_transfer, (void *)sdi, timeout); if ((ret = libusb_submit_transfer(transfer)) != 0) { sr_err("Failed to submit transfer: %s.", libusb_error_name(ret)); libusb_free_transfer(transfer); g_free(buf); abort_acquisition(devc); return SR_ERR; } devc->transfers[i] = transfer; devc->submitted_transfers++; } devc->ctx = drvc->sr_ctx; usb_source_add(sdi->session, devc->ctx, timeout, receive_data, (void *)sdi); /* Send header packet to the session bus. */ std_session_send_df_header(cb_data, LOG_PREFIX); if ((ret = logic16_start_acquisition(sdi)) != SR_OK) { abort_acquisition(devc); return ret; } return SR_OK; }