~ubuntu-branches/ubuntu/utopic/xoscope/utopic

/*

 * @(#)$Id: comedi.c,v 2.4 2009/01/17 06:44:55 baccala Exp $

 *

 * Author: Brent Baccala <baccala@freesoft.org>

 *

 * Public domain.

 *

 * This file implements the COMEDI interface for xoscope

 *

 * The capturing occurs in what a normal oscilloscope would call "chop

 * mode" - samples are alternated between the various channels being

 * captured.  This has the effect of reducing the overall sampling

 * rate by a factor equal to the number of channels being captured.

 * You could also (but we don't) implement an "alt mode" - an entire

 * sweep is taken from one channel, then the entire next sweep is

 * taken from the next channel, etc.  Triggering would be a problem.

 *

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <ctype.h>

#include <fcntl.h>

#include <errno.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#include <sys/poll.h>

#include <asm/page.h>

#include <comedilib.h>

#include "oscope.h"		/* program defaults */

#include "func.h"

#define COMEDI_RANGE 0		/* XXX user should set this */

/* Some of these variables aren't defined static because we need to

 * get at them from our GTK dialog callbacks.  None of them are set

 * from there, that's done via set_option(), but there are read, and

 * for that reason need to be global.

 */

comedi_t *comedi_dev = NULL;

gchar *comedi_board_name = NULL;

static int comedi_opened = 0;	/* t if open has at least been _attempted_ */

static int comedi_running = 0;

static int comedi_error = 0;

/* device_name[] is an array we write the COMEDI device into if it is

 * set by an option (then point device at device_name).  If there's

 * no option, device stays pointing to the default - /dev/comedi0

 */

static char device_name[256];

char *comedi_devname = "/dev/comedi0";

int comedi_subdevice = 0;

int comedi_rate = 50000;	/* XXX set this to max valid upon open */

/* Size of COMEDI's kernel buffer.  -1 means leave it at the default.

 * Slight bug - if you change it, then change it back to -1, the

 * default setting won't return until you close and re-open the

 * device.  Actually, that might not be good enough - you might

 * need to re-configure the device.

 */

int comedi_bufsize = -1;

#define BUFSZ 1024

static sampl_t buf[BUFSZ];

static int bufvalid=0;

// has to be set later

int zero_value = -1;

static int lag = 0;			/* lag - see get_data() */

static int subdevice_flags = 0;

static int subdevice_type = COMEDI_SUBD_UNUSED;

int comedi_aref = AREF_GROUND;		/* Global voltage reference setting */

/* This structure associates xoscope Signal structures with the COMEDI

 * channel they are receiving on.  capture_list gets emptied by

 * close_comedi(), added to by enable_chan(), deleted from by

 * disable_chan(), used by start_comedi_running() to build a channel

 * list, and used by get_data() to figure out in which Signal(s) to

 * put the data.

 */

#define NCHANS 8

struct capture {

  struct capture * next;

  int chan;

  Signal * signal;

};

static struct capture *capture_list = NULL;

static int active_channels=0;

static Signal comedi_chans[NCHANS];

/* Triggering information - the (one) channel we're triggering on, the

 * sample level, the type of trigger (0 - freerun, 1 - ascending,

 * 2 - descending), and the index of the trigger channel in the

 * capture list

 */

static int trig_chan = 0;

static int trig_level = 0;

static int trig_mode = 0;

static int trig_index = -1;

/* This function is defined as do-nothing and weak, meaning it can be

 * overridden by the linker without error.  It's used to start the X

 * Windows GTK options dialog for COMEDI, and is defined in this way

 * so that this object file can be used either with or without GTK.

 * If this causes compiler problems, just comment out the attribute

 * line and leave the do-nothing function.  You will then need to

 * comment out both lines to generate an object file that can be used

 * with GTK.

 */

void comedi_gtk_options() __attribute__ ((weak));

void comedi_gtk_options() {}

/* This function gets called at various points that we need to stop

 * and restart COMEDI, like a rate change, or a change to the list

 * of channels we're capturing for.  start_comedi_running() gets

 * called automatically by get_data(), so we can use stop_comedi_running()

 * pretty liberally.

 */

static void stop_comedi_running(void)

{

  if (comedi_running) {

    comedi_cancel(comedi_dev, 0);

    comedi_running = 0;

  }

  bufvalid = 0;

}

/* XXX This function should make sure the Signal arrays are reset to sane

 * values.  Right now, it just sets their volt and rate values.

 */

static int start_comedi_running(void)

{

  int try;

  int ret = -1;

  comedi_cmd cmd;

  unsigned int chanlist[NCHANS];

  struct capture *capture;

  comedi_range *comedi_rng;

  int maxdata;

  if (!comedi_dev) return 0;

  /* There might have been an error condition that was cleared (like

   * switching from an unsupported subdevice to a supported one), so

   * clear comedi_error here and set it if there's a problem later.

   * If we're not capturing anything, make sure we set subdevice_type

   * before we return, because nchans() depends on this variable to

   * figure out how to interpret comedi_get_n_channels()

   */

  comedi_error = 0;

  subdevice_flags = comedi_get_subdevice_flags(comedi_dev, comedi_subdevice);

  subdevice_type = comedi_get_subdevice_type(comedi_dev, comedi_subdevice);

  if (active_channels == 0) return 0;

  if (comedi_bufsize > 0) {

    /* comedi 0.7.66 has a bug in its buffer size handling.  Not only

     * does it fail to round up to a multiple of PAGE_SIZE correctly,

     * but if you attempt to set a buffer smaller than PAGE_SIZE, it

     * will deallocate the buffer and you'll never get it back without

     * re-configuring the device.  We round up to PAGE_SIZE here to

     * avoid the bug.  This is the only reason we need <asm/page.h> in

     * our include list.

     */

    comedi_bufsize = (comedi_bufsize + PAGE_SIZE - 1) & PAGE_MASK;

    ret = comedi_set_buffer_size(comedi_dev, comedi_subdevice, comedi_bufsize);

    if (ret < 0) {

      comedi_error = comedi_errno();

      return ret;

    }

  }

  /* Now we build a COMEDI command structure */

  bzero(&cmd, sizeof(cmd));

  cmd.subdev = comedi_subdevice;

  /* Start with a channel list based on capture_list

   *

   * This code matches up with get_data(), which assumes that the captured

   * data is in the same order as the channels in the capture_list

   */

  cmd.chanlist = chanlist;

  cmd.chanlist_len = 0;

  for (capture = capture_list; capture != NULL; capture = capture->next) {

    chanlist[cmd.chanlist_len++] = CR_PACK(capture->chan,0,comedi_aref);

  }

  if (cmd.chanlist_len == 0) {

    return 0;

  }

  /* comedilib has a comedi_get_cmd_generic_timed() function, but it's

   * set up for sampling a single channel, so I don't use it.

   * Instead, I try several different varients on comedi command

   * structures in the hopes of finding one that works.

   */

  try = 0;

  do {

    switch (try) {

      /* The first thing we try is to simultaneously sample (that's

       * the convert_src of TRIG_NOW) all the channels at the

       * requested rate.

       */

    case 0:

      cmd.start_src = TRIG_NOW;

      cmd.start_arg = 0;

      cmd.scan_begin_src = TRIG_TIMER;

      cmd.scan_begin_arg = 1e9 / comedi_rate;

      cmd.convert_src = TRIG_NOW;

      cmd.convert_arg = 0;

      cmd.scan_end_src = TRIG_COUNT;

      cmd.scan_end_arg = cmd.chanlist_len;

      cmd.stop_src = TRIG_NONE;

      cmd.stop_arg = 0;

      break;

      /* There's a good chance that won't work (not many cards support it).

       * So now try sampling each channel at a staggered interval of

       * the requested rate times the number of channels.

       */

    case 1:

      cmd.start_src = TRIG_NOW;

      cmd.start_arg = 0;

      cmd.scan_begin_src = TRIG_FOLLOW;

      cmd.scan_begin_arg = 0;

      cmd.convert_src = TRIG_TIMER;

      cmd.convert_arg = 1e9 / (comedi_rate * active_channels);

      cmd.scan_end_src = TRIG_COUNT;

      cmd.scan_end_arg = cmd.chanlist_len;

      cmd.stop_src = TRIG_NONE;

      cmd.stop_arg = 0;

      break;

      /* OK, that didn't work.  Maybe the card wants timers on

       * both the scan and conversion?

       */

    case 2:

      cmd.start_src = TRIG_NOW;

      cmd.start_arg = 0;

      cmd.scan_begin_src = TRIG_TIMER;

      cmd.scan_begin_arg = 1e9 / comedi_rate;

      cmd.convert_src = TRIG_TIMER;

      cmd.convert_arg = 1e9 / (comedi_rate * active_channels);

      cmd.scan_end_src = TRIG_COUNT;

      cmd.scan_end_arg = cmd.chanlist_len;

      cmd.stop_src = TRIG_NONE;

      cmd.stop_arg = 0;

      break;

      /* Nothing we tried worked!  There are other possibilities, but

       * none are currently supported by this code.  Complain and

       * return the error code from the last thing we tried.

       */

    default:

      comedi_error = comedi_errno();

      return ret;

    }

    /* COMEDI command testing can be a little funky.  We get a return

     * code indicating which phase of test failed.  Basically, if

     * phase 1 or 2 failed, we're screwed.  If phase 3 failed, it

     * might be because we've pushed the limits of the timing past

     * where it can go, and if phase 4 failed, it's just because the

     * device can't support exactly the timings we asked for.  In

     * either of the last two cases, the driver adjusts the offending

     * parameters.  That's why we call this function three times.

     */

    ret = comedi_command_test(comedi_dev,&cmd);

    ret = comedi_command_test(comedi_dev,&cmd);

    ret = comedi_command_test(comedi_dev,&cmd);

    try ++;

  } while (ret != 0);

  /* Now we adjust our global rate to whatever we got the card to do. */

  if (cmd.scan_begin_src == TRIG_TIMER) {

    comedi_rate = 1e9 / cmd.scan_begin_arg;

  } else if (cmd.convert_src == TRIG_TIMER) {

    comedi_rate = 1e9 / cmd.convert_arg;

    comedi_rate /= active_channels;

  } else {

    fprintf(stderr, "neither convert_src nor start_src is TRIG_TIMER!?!\n");

  }

  /* Voltage range is currently a global setting.  Find it, and save

   * it into all the Signal(s) we're collecting data into (if we're

   * capturing an analog input subdevice; digital subdevs don't do

   * this).  Signal->volts should be in milivolts per 320 sample

   * values, so take the voltage range given by COMEDI, multiply by

   * 1000 (volts -> millivolts), divide by 2^(sampl_t bits) (sample

   * values in an sampl_t), to get millivolts per sample value, and

   * multiply by 320 to get millivolts per 320 sample values.  320 is

   * the size of the vertical display area, in case you wondered.

   *

   * Also, set the rate (samples/sec) at which we'll capture data

   */

  for (capture = capture_list; capture != NULL; capture = capture->next) {

    if (subdevice_type == COMEDI_SUBD_AI) {

      comedi_rng = comedi_get_range(comedi_dev,

				    comedi_subdevice,

				    capture->chan, COMEDI_RANGE);

      maxdata=comedi_get_maxdata(comedi_dev,

				 comedi_subdevice,

				 0);

      capture->signal->volts

	= (comedi_rng->max - comedi_rng->min)

	* 1000 * 320 / maxdata;

      if (zero_value<0) {

	      // we have to set zero value

	      if ((comedi_rng->min<0)&&(comedi_rng->max>0)) {

		      // we are bipolar

		      zero_value=maxdata/2;

	      } else {

		      // we are unipolar

		      zero_value=0;

	      }

      }

      capture->signal->bits = 0;

#if 0

      printf(" [%g,%g] %s\n",comedi_rng->min,comedi_rng->max,

	     comedi_rng->unit == UNIT_volt ? "V" : "");

#endif

    } else {

      capture->signal->bits = comedi_get_n_channels(comedi_dev, comedi_subdevice);

      capture->signal->volts = 0;

    }

    capture->signal->rate = comedi_rate;

  }

#if 0

  fprintf(stderr, "Sampling every %d(%d) ns(Hz)\n",

	  cmd.convert_arg, comedi_rate);

#endif

  ret = comedi_command(comedi_dev,&cmd);

  if (ret >= 0) {

    fcntl(comedi_fileno(comedi_dev), F_SETFL, O_NONBLOCK);

    comedi_running = 1;

  } else {

    comedi_error = comedi_errno();

  }

  return ret;

}

static void

close_comedi()

{

#if 0

  struct capture *capture;

#endif

  if (comedi_dev) comedi_close(comedi_dev);

  comedi_dev = NULL;

  if (comedi_board_name) g_free(comedi_board_name);

  comedi_board_name = NULL;

  comedi_running = 0;

  comedi_opened = 0;

  /* Leave active channels alone here in case we're closing

   * a device because of an error and want to re-open later.

   */

#if 0

  while (capture_list != NULL) {

    capture = capture_list->next;

    free(capture_list);

    capture_list = capture;

  }

  active_channels = 0;

#endif

}

static int

open_comedi(void)

{

  int i;

  static int once=0;

  close_comedi();

  comedi_error = 0;

  comedi_opened = 1;

  subdevice_flags = 0;

  subdevice_type = COMEDI_SUBD_UNUSED;

  if (!once) {

    /* XXX once is a kludge */

    /* Setup the Signal structures.  Note that the name is set to 'a',

     * 'b', 'c', etc, to conform with xoscope usage and to avoid

     * confusing the user with the display channels.  COMEDI, of

     * course, numbers its channels 0, 1, 2, etc

     */

    for (i = 0 ; i < NCHANS ; i++) {		/* XXX hardwired at 8 */

      comedi_chans[i].data = NULL;

      comedi_chans[i].num = comedi_chans[i].frame = comedi_chans[i].volts = 0;

      comedi_chans[i].listeners = 0;

      //sprintf(comedi_chans[i].name, "Channel %d", i);

      sprintf(comedi_chans[i].name, "Channel %c", 'a' + i);

      comedi_chans[i].savestr[0] = 'a' + i;

      comedi_chans[i].savestr[1] = '\0';

    }

    once = 1;

  }

  comedi_dev = comedi_open(comedi_devname);

  if (! comedi_dev) {

    comedi_error = comedi_errno();

    return 0;

  }

  /* All the GTK stuff uses UTF8, and complains to stderr if it

   * doesn't get it.

   */

  comedi_board_name = g_locale_to_utf8(comedi_get_board_name(comedi_dev),

				       -1, NULL, NULL, NULL);

  /* XXX I'd kinda like to do this here, but then the read() loop

   * below (to get offset correction for the DAQP) returns errors

   * (-EAGAIN).  If do this later, and start_comedi_running() has

   * problems, then it might hang in get_data(), but I hope I've

   * fixed that now...

   */

  /* fcntl(comedi_fileno(comedi_dev), F_SETFL, O_NONBLOCK); */

  if (comedi_board_name && strncmp(comedi_board_name, "DAQP", 4) == 0) {

    /* Special case for DAQP - unfortunately, COMEDI doesn't (yet) provide

     * a generic interface for boards that can do offset correction,

     * so this special case is designed to handle the Quatech DAQP.

     * We collect a hundred samples from channel 4 in differential

     * mode, a non-existant channel used by the DAQP specifically for

     * offset correction.

     */

    comedi_cmd cmd;

    unsigned int chan;

    int ret;

    ret = comedi_get_cmd_generic_timed(comedi_dev, comedi_subdevice, &cmd, 0);

    if (ret >= 0) {

      chan = CR_PACK(4,0,AREF_DIFF);

      cmd.chanlist = &chan;

      cmd.chanlist_len = 1;

      cmd.start_src = TRIG_NOW;

      cmd.start_arg = 0;

      cmd.stop_src = TRIG_COUNT;

      cmd.stop_arg = 100;

      ret = comedi_command_test(comedi_dev, &cmd);

      if (ret >= 0) {

	ret = comedi_command(comedi_dev, &cmd);

	if (ret >= 0) {

	  int i = 0;

	  while ((i < (100 * sizeof(sampl_t)))

		 && (ret = read(comedi_fileno(comedi_dev), buf,

				100 * sizeof(sampl_t) - i)) > 0) {

	    i += ret;

	  }

	  if (i == (100 * sizeof(sampl_t))) {

	    zero_value = 0;

	    for (i=0; i<100; i++) zero_value += buf[i];

	    zero_value /= 100;

	  }

	}

      }

    }

    if (ret == -1) {

      comedi_error = comedi_errno();

      /* close_comedi(); */

      return 0;

    }

    comedi_cancel(comedi_dev, 0);

  }

  /* XXX Why can't we do this here?  It doesn't seem to "take" */

  /* fcntl(comedi_fileno(comedi_dev), F_SETFL, O_NONBLOCK); */

  if (start_comedi_running() < 0) {

    return 0;

  } else {

    return 1;

  }

}

void

reset_comedi(void)

{

  if (comedi_dev == NULL) {

    open_comedi();

    if (comedi_dev == NULL) {

      return;

    }

  }

  stop_comedi_running();

}

static int nchans(void)

{

  int chans;

  int i;

  if (! comedi_opened) open_comedi();

  /* open_comedi() calls start_comedi_running() just before it

   * returns, so that's how we know subdevice_type has been set

   * correctly when we get here.  However, I really don't know if

   * open_comedi() SHOULD call start_comedi_running() at all, so we

   * may need to revisit this.

   */

  if (comedi_dev == NULL) {

    return 0;

  } else if (subdevice_type == COMEDI_SUBD_AI) {

    /* analog subdevice - mark all channels analog and return num of chans */

    chans = comedi_get_n_channels(comedi_dev, comedi_subdevice);

    for (i = 0; i < chans; i ++) comedi_chans[i].bits = 0;

    return chans;

  } else {

    /* digital subdevice - n_channels returns number of bits */

    comedi_chans[0].bits = comedi_get_n_channels(comedi_dev, comedi_subdevice);

    return 1;

  }

}

static int fd(void)

{

  return (comedi_running ? comedi_fileno(comedi_dev) : -1);

}

/* reset() - part of the data source API.  Called when we're ready to

 * start capturing.  Clears the old capture_list and builds a new one.

 * capture_ptr is used to make sure we build the list from the top

 * down, not the bottom up, mainly to make sure trig_index counts from

 * the top down.  Finally, we start COMEDI.  We don't really need to

 * start COMEDI, just prep it, but we start it in order to set the

 * rate and volts fields (during start_comedi_running) in the Signal

 * structures.

 */

static void

reset(void)

{

  struct capture *capture;

  struct capture **capture_ptr;

  int i;

  stop_comedi_running();

  for (capture = capture_list; capture != NULL; capture = capture_list) {

    capture_list = capture->next;

    free(capture);

  }

  capture_list = NULL;

  active_channels = 0;

  trig_index = -1;

  capture_ptr = &capture_list;

  for (i = 0; i < NCHANS; i++) {

    if ((comedi_chans[i].listeners) || ((trig_mode > 0) && (trig_chan == i))) {

      capture = malloc(sizeof(struct capture));

      if (capture == NULL) {

	perror("enable_chan() malloc failed");

	exit(1);

      }

      capture->chan = i;

      capture->signal = &comedi_chans[i];

      capture->next = NULL;

      *capture_ptr = capture;

      capture_ptr = &capture->next;

      comedi_chans[i].num = 0;

      comedi_chans[i].frame ++;

      if ((trig_mode > 0) && (trig_chan == i)) trig_index = active_channels;

      active_channels ++;

    }

  }

  start_comedi_running();

}

static Signal * comedi_chan(int chan)

{

  return &comedi_chans[chan];

}

static int set_trigger(int chan, int *levelp, int mode)

{

  trig_chan = chan;

  trig_level = *levelp;

  trig_mode = mode;

  /* XXX check that trig_level is within subdevice's range */

  return 1;

}

static void clear_trigger(void)

{

  trig_mode = 0;

}

/* Current COMEDI rate logic has some bizarre effects.  As we increase

 * the number of channels sampled, the rate goes down (usually), but

 * doesn't go back up when we decrease the number of sampled chans.

 */

/* XXX the rate we calculate might not be the one that actually gets used */

static int change_rate(int dir)

{

  int oldrate = comedi_rate;

  if (dir == 1) {

    comedi_rate *= 2;

  } else {

    comedi_rate /= 2;

  }

  stop_comedi_running();

  return (comedi_rate != oldrate);

}

/* set_width(int)

 *

 * sets the frame width (number of samples captured per sweep) globally

 * for all the channels.

 */

static void set_width(int width)

{

  int i;

  for (i=0; i<NCHANS; i++) {

    comedi_chans[i].width = width;

    if (comedi_chans[i].data != NULL) free(comedi_chans[i].data);

    comedi_chans[i].data = malloc(width * sizeof(short));

  }

}

/* get_data() -

 * read all available data from comedi device, return value is TRUE if we

 * actually put some samples into the sweep buffer (and thus need a redisplay)

 *

 * This function should always return at the end of a sweep

 */

#define convert(sample) (sample - zero_value)

static int get_data(void)

{

  int bytes_read;

  int samples_read;

  int scans_read;

  int samples_per_frame;

  sampl_t *current_scan, *last_scan;

  int i, j;

  int delay;

  int triggered=0;

  int was_in_sweep=in_progress;

  static struct timeval tv1, tv2;

  struct capture *capture;

  /* This code used to try and start COMEDI running if it wasn't running

   * already.  But if fd() already returned -1, the main code doesn't

   * think we're running, so it's best to leave things alone here...

   */

  if (! comedi_dev || ! comedi_running) return 0;

  /* The way the code's written right now, all the channels are

   * sampled at the same rate and for the same width (number of

   * samples per frame), so we just use the width from the first

   * channel in the capture list to figure how many samples we're

   * capturing.

   */

  samples_per_frame = capture_list->signal->width;

  /* It is possible for this loop to be entered with a full buffer of

   * data already (bufvalid == sizeof(buf)).  In that case, the read will

   * be called with a zero byte buffer size, and will return zero.

   * That's why the comparison reads ">=0" and not ">0"

   */

  while ((bytes_read = read(comedi_fileno(comedi_dev),

			    ((char *)buf) + bufvalid, sizeof(buf) - bufvalid))

	 >= 0) {

    // fprintf(stderr, "bytes_read=%d; bufvalid=%d\n", bytes_read, bufvalid);

    bytes_read += bufvalid;

    gettimeofday(&tv1, NULL);

    samples_read = bytes_read / sizeof(sampl_t);

    scans_read = samples_read / active_channels;

    /* This is here to catch the case when there's nothing (or not

     * much) in the buffer, and the read() call returned nothing.

     */

    if (scans_read == 0 && bytes_read == 0) break;

    for (i = 0; i < scans_read; i++) {

      current_scan = buf + i * active_channels;

      if (!in_progress && scope.run && i>0) {

	/* Sweep isn't in_progress, so look for a trigger -

	 * anything (trig_mode==0) or a transition between the last

	 * sample and the current one that crossed the trig_level

	 * threshold, either going positive (trig_mode==1) or going

	 * negative (trig_mode==2).  Since we check the previous sample,

	 * there's an "i>0" case in the above if statement, and that

	 * does mean that we'll miss a trigger if the transition

	 * exactly corresponds with a read buffer boundary.

	 */

	last_scan = buf + (i-1) * active_channels;

	if ((trig_mode == 0) ||

	    ((trig_mode == 1) &&

	     (convert(current_scan[trig_index]) >= trig_level) &&

	     (convert(last_scan[trig_index]) < trig_level)) ||

	    ((trig_mode == 2) &&

	     (convert(current_scan[trig_index]) <= trig_level) &&

	     (convert(last_scan[trig_index]) > trig_level))) {

	  /* found something to trigger on, so compute a delay value

	   * based on extrapolating a straight line between the two

	   * sample values that straddle the triggering point, for

	   * high-frequency signals that change significantly between

	   * the two samples.  Set up all the relevent Signal

	   * structures, then fall through into the triggered case

	   * below

	   */

	  delay = 0;

	  if (trig_mode != 0) {

	    short current = convert(current_scan[trig_index]);

	    short last = convert(last_scan[trig_index]);

	    if (current != last) {

	      delay = abs(10000 * (current - trig_level) / (current - last));

	    }

	  }

	  for (j=0, capture=capture_list;

	       capture != NULL; capture=capture->next, j++) {

	    capture->signal->frame ++;

	    capture->signal->delay = delay;

	    capture->signal->num = 0;

	  }

	  if (j != active_channels) {

	    fprintf(stderr, "ERROR!   j != active_channels in get_data()\n");

	  }

	  in_progress = 1;

	}

      }

      if (in_progress) {

	/* Sweep in progress */

	for (j=0, capture=capture_list;

	     capture != NULL; capture=capture->next, j++) {

	  capture->signal->data[capture->signal->num ++]

	    = convert(current_scan[j]);

	  in_progress = capture->signal->num;

	}

	if (j != active_channels) {

	  fprintf(stderr, "ERROR!   j != active_channels in get_data()\n");

	}

	triggered = 1;

	if (in_progress >= samples_per_frame) {

	  in_progress = 0;

	  /* If we were in the middle of a sweep when we entered this function,

	   * return now.  Otherwise, keep looking for more sweeps.

	   */

	  if (was_in_sweep) {

	    bufvalid = bytes_read - (i * active_channels * sizeof(sampl_t));