added configure options for disabling python and ruby bindings

[comedilib.git] / doc / other.sgml

<!-- <!DOCTYPE section PUBLIC "-//OASIS//DTD DocBook V3.1//EN"> -->


<section id="acquisitionfunctions">
<title>
Acquisition and configuration functions
</title>

<para>
This Section gives an overview of all &comedi; functions with which 
application programmers can implement their data acquisition. (With
<quote>acquisition</quote> we mean all possible kinds of interfacing
with the cards: input, output, configuration, streaming, etc.)
<xref linkend="comedireference"> explains the function calls in full
detail.
</para>

<section id="singleacquisition">
<title>
Functions for single acquisition
</title>

<para>
The simplest form of using &comedi; is to get one single sample to or
from an interface card. This sections explains how to do such simple
<link linkend="dio">digital</link> and
<link linkend="singleanalog">analog</link> acquisitions.
</para>

<section id="dio">
<title>
Single digital acquisition
</title>

<para>
Many boards supported by &comedi; have digital input and output
channels; i.e., channels that can only produce a <literal>0</literal>
or a <literal>1</literal>.
Some boards allow the <emphasis>direction</emphasis> (input or output)
of each channel to be specified independently in software.
</para>

<para>
&comedi; groups digital channels into a
<emphasis>subdevice</emphasis>, which is a group of digital channels
that have the same characteristics.  For example, digital output lines
will be grouped into a digital
output subdevice, bidirectional digital lines will be grouped
into a digital I/O subdevice.  Thus, there can be multiple
digital subdevices on a particular board.
</para>

<para>
Individual bits on a digital I/O device can be read and written using
the functions
<programlisting>
  int <link linkend="func-ref-comedi-dio-read">comedi_dio_read</link>(device,subdevice,channel,unsigned int *bit);
  int <link linkend="func-ref-comedi-dio-write">comedi_dio_write</link>(device,subdevice,channel,unsigned int bit);
</programlisting>
The <parameter class=function>device</parameter> parameter is a
<link linkend="ref-type-comedi-t">pointer</link>
to a successfully opened &comedi; device.
The <parameter class=function>subdevice</parameter> and
<parameter class=function>channel</parameter> parameters are positive
integers that indicate which subdevice and channel is used in the
acquisition. The integer <parameter class=function>bit</parameter>
contains the value of the acquired bit.
</para>
<para>
The direction of bidirectional lines can be configured using
the function
<programlisting>
  <link linkend="func-ref-comedi-dio-config">comedi_dio_config</link>(device,subdevice,channel,unsigned int dir);
</programlisting>
The parameter <parameter class=function>dir</parameter> should be
either <literal>COMEDI_INPUT</literal> or 
<literal>COMEDI_OUTPUT</literal>.
Many digital I/O subdevices group channels into blocks for
configuring direction.  Changing one channel in a block changes
the entire block.
</para>

<para>
Multiple channels can be read and written simultaneously using the
function
<programlisting>
  <link linkend="func-ref-comedi-dio-bitfield">comedi_dio_bitfield</link>(device,subdevice,unsigned int write_mask,unsigned int *bits);
</programlisting>
Each channel is assigned to a bit in the
<parameter class=function>write_mask</parameter> and
<parameter class=function>bits</parameter>
bitfield.  If a bit in
<parameter class=function>write_mask</parameter> is set, the
corresponding bit in <parameter class=function>*bits</parameter> will
be written to the corresponding digital output line.
Each digital line is then read and placed into 
<parameter class=function>*bits</parameter>.  The value
of bits in <parameter class=function>*bits</parameter> corresponding
to digital output lines is undefined and device-specific.  Channel
<literal>0</literal> is the least significant bit in the bitfield;
channel <literal>31</literal> is the most significant bit.  Channels
higher than <literal>31</literal> cannot be accessed using this method.
</para>

<para>
The digital acquisition functions seem to be very simple, but, behind
the implementation screens of the &comedi; kernel module, they are
executed as special cases of the general
<link linkend="instructions">instruction</link> command.
</para>


</section>


<section id="singleanalog">
<title>
Single analog acquisition
</title>
<para>
Analog &comedi; channels can produce data values that are
<emphasis>samples</emphasis> from continuous analog signals.
These samples are integers with a significant content in
the range of, typically, <literal>8</literal>, <literal>10</literal>,
<literal>12</literal>, or <literal>16</literal> bits.
</para>
<para>
The 
<programlisting>
 int <link linkend="func-ref-comedi-data-read">comedi_data_read</link>(<link linkend="ref-type-comedi-t">comedi_t</link> * device, unsigned int subdevice, unsigned int channel, 
                    unsigned int range, unsigned int aref, <link linkend="ref-type-lsampl-t">lsampl_t</link> * data);
</programlisting>
function reads one such data value from a &comedi; channel, and puts it in
the user-specified <parameter>data</parameter> buffer. The
<programlisting>
 int <link linkend="func-ref-comedi-data-write">comedi_data_write</link>(<link linkend="ref-type-comedi-t">comedi_t</link> * device, unsigned int subdevice, unsigned int channel, 
                       unsigned int range, unsigned int aref, <link linkend="ref-type-lsampl-t">lsampl_t</link> data);
</programlisting>
works in the opposite direction. Data values returned by this function
are unsigned integers less than, or equal to, the maximum sample value
of the channel, which can be determined using the function
<programlisting>
 <link linkend="ref-type-lsampl-t">lsampl_t</link> <link linkend="func-ref-comedi-get-maxdata">comedi_get_maxdata</link>(<link linkend="ref-type-comedi-t">comedi_t</link> * device, unsigned int subdevice, unsigned int channel);
</programlisting>
Conversion of data values to physical units can be performed by the
function
<programlisting>
 double <link linkend="func-ref-comedi-to-phys">comedi_to_phys</link>(<link linkend="ref-type-lsampl-t">lsampl_t</link> data, comedi_range * range,  <link linkend="ref-type-lsampl-t">lsampl_t</link> maxdata);
</programlisting>
There are two data structures in these commands that are not fully
self-explanatory:
<itemizedlist>

<listitem>
<para>
<link linkend="ref-type-comedi-t">comedi_t</link>: this data structure
contains all information that a user program has to know about an
<emphasis>open</emphasis> &comedi; device. The programmer doesn't have
to fill in this data structure manually: it gets filled in by opening
the device.
</para>
</listitem>

<listitem>
<para>
<link linkend="ref-type-lsampl-t">lsampl_t</link>: this 
<quote>data structure</quote> represents one single sample. On most
architectures, it's nothing more than a 32 bits value. Internally,
&comedi; does some conversion from raw sample data to
<quote>correct</quote> integers. This is called <quote>data
munging</quote>.
</para>
</listitem>

</itemizedlist>
</para>
<para>
Each single acquisition by, for example,
<function>
 <link linkend="func-ref-comedi-data-read">comedi_data_read()</link>
</function>
requires quite some overhead, because all the arguments of the
function call are checked. If multiple acquisitions must be done on
the same channel, this overhead can be avoided by using a function
that can read more than one sample:
<programlisting>
  int <link linkend="func-ref-comedi-dio-read">comedi_data_read_n</link>(<link linkend="ref-type-comedi-t">comedi_t</link> *it, unsigned int subdev, unsigned int chan, unsigned int range, 
      unsigned int aref, <link linkend="ref-type-lsampl-t">lsampl_t</link> *data, unsigned int n)
</programlisting>
The number of samples, <parameter class=function>n</parameter>, is
limited by the &comedi; implementation (to a maximum of 100 samples),
because the call is blocking.
</para>
<para>
The start of the data acquisition can also be delayed by a specified
number of nano-seconds:
<programlisting>
int <link linkend="func-ref-comedi-data-read-delayed">comedi_data_read_delayed</link>(<link linkend="ref-type-comedi-t">comedi_t</link> *it, unsigned int subdev, unsigned int chan, unsigned int range, 
    unsigned int aref, <link linkend="ref-type-lsampl-t">lsampl_t</link> *data, unsigned int nano_sec)
</programlisting>
All these read and write acquisition functions are implemented on top
of the generic <link linkend="instructions">instruction</link>
command.
</para>

</section>

</section>


<section id="instructions">
<title>
Instructions for multiple acquisitions 
</title>
<para>
The <emphasis>instruction</emphasis> is one of the most generic,
overloaden and flexible functions in the &comedi; API. It is used to
execute a multiple of identical acquisitions on the same channel, but
also to perform a
<link linkend="instructionsconfiguration">configuration</link> of a
channel.
<anchor id="anchor.instruction.list">
An <emphasis>instruction list</emphasis> is a list of instructions,
possibly on different channels. Both instructions and instructions
lists are executed <emphasis>synchronously</emphasis>, i.e., while
<emphasis role="strong">blocking</emphasis> the calling process.
This is one of the limitations of instructions; the other one is that
they cannot code an acquisition involving timers or external events.
These limits are eliminated by the
<link linkend="commandsstreaming">command</link> acquisition
primitive.
</para>


<section id="comediinsnstructure">
<title>
The instruction data structure
</title>
<para>
All the information needed to execute an instruction is stored in the
<link linkend="ref-type-comedi-insn">comedi_insn</link>
data structure:
<programlisting>
struct <anchor id="insn-data-structure">comedi_insn_struct{
  <anchor id="insn-data-structure-insn">unsigned int insn;      // integer encoding the type of acquisition
                          // (or configuration)
  unsigned int n;         // number of samples
  <link linkend="ref-type-lsampl-t">lsampl_t</link> <anchor id="insn-data-structure-data">*data;         // pointer to data buffer
  unsigned int subdev;    // subdevice
  unsigned int <anchor id="insn-data-structure-chanspec"><link linkend="ref-macro-CR-PACK">chanspec</link>; // encoded channel specification
  unsigned int unused[3];
} comedi_insn;
</programlisting>
Because of the large flexibility of the instruction function, many
types of instruction do not need to fill in all fields, or attach
different meanings to the same field. But the current implementation
of &comedi; requires the 
<link linkend="insn-data-structure-data">data</link> field to be at
least one byte long.
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> flag of the 
<link linkend="insn-data-structure">instruction data structure</link> 
determines the type of acquisition executed in the corresponding
instruction:
<itemizedlist>

<listitem>
<para>
INSN_READ: the instruction executes a read on an analog channel.
</para>
</listitem>

<listitem>
<para>
INSN_WRITE: the instruction executes a write on an analog channel. 
</para>
</listitem>
                                                                                
<listitem>
<para>
INSN_BITS: indicates that the instruction must
read or write values on multiple digital I/O channels.
</para>
</listitem>

<listitem>
<para>
INSN_GTOD: the instruction performs a <quote>Get Time Of Day</quote>
acquisition.
</para>
</listitem>

<listitem>
<para>
INSN_WAIT: the instruction blocks for a specified number of
nanoseconds.
</para>
</listitem>

</itemizedlist>
</para>

</section>


<section id="instructionexecution">
<title>
Instruction execution
</title>
<para>
Once an instruction data structure has been filled in, the
corresponding instruction is executed as follows:
<programlisting>
 int <link linkend="func-ref-comedi-do-insn">comedi_do_insn</link>(<link linkend="ref-type-comedi-t">comedi_t</link> *it, <link linkend="ref-type-comedi-insn">comedi_insn</link> * instruction);
</programlisting>
Many &comedi; instructions are shortcuts that relieve the programmer
from explicitly filling in the data structure and calling the
<link linkend="func-ref-comedi-do-insn">comedi_do_insn</link>
function.
</para>
<para>
The
<programlisting>
 int <link linkend="func-ref-comedi-do-insnlist">comedi_do_insnlist</link><link linkend="ref-type-comedi-t">comedi_t</link> *it, <link linkend="ref-type-comedi-insnlist">comedi_insnlist</link> * list)
</programlisting>
instruction allows to perform a list of instructions in one function
call. The number of instructions in the list is limited in the
implementation, because instructions are executed
<emphasis>synchronously</emphasis>, i.e., the call blocks until the
whole instruction (list) has finished.
</para>

</section>
 
</section>


<section id="instructionsconfiguration">
<title>
Instructions for configuration
</title>
<para>
<xref linkend="instructions"> explains how instructions are used to do
<emphasis>acquisition</emphasis> on channels. This section explains
how they are used to <emphasis>configure</emphasis> a device.
There are various sorts of configurations, and the
specific information for each different configuration possibility is
to be specified via the
<link linkend="insn-data-structure-data">data</link> buffer of the
<link linkend="insn-data-structure">instruction data structure</link>.
(So, the pointer to a
<link linkend="ref-type-lsampl-t">lsampl_t</link>
is misused as a pointer to an array with board-specific information.)
</para>

<para>
Using INSN_CONFIG as the
<link linkend="insn-data-structure-insn">insn</link> flag in an
<link linkend="insn-data-structure">instruction data structure</link>
indicates that the instruction will
<emphasis>not perform acquisition</emphasis> on a
channel, but will <emphasis>configure</emphasis> that channel.
For example, the configuration of digital I/O channels is done as
follows.  The
<link linkend="ref-macro-CR-PACK">chanspec</link> field in the
<link linkend="insn-data-structure-chanspec">comedi_insn</link> 
data structure, contains the channel to be configured. And
<link linkend="insn-data-structure-data">data</link>[0] contains
either COMEDI_INPUT or COMEDI_OUTPUT, depending on the desired
direction of the digital I/O lines.
On typical devices, multiple channels are grouped together in blocks
for determining their direction.  And configuring one channel in a
block configures the entire block.
</para>

<para>
Another example of an INSN_CONFIG instruction is the configuration of
the <link linkend="trigother-event">TRIG_OTHER</link> event source.
</para>

</section>


<section id="inttrigconfiguration">
<title>
Instruction for internal triggering
</title>
<para>
This special instruction has 
<anchor id="insn-inttrig">INSN_INTTRIG as the
<link linkend="insn-data-structure-insn">insn</link> flag in its
<link linkend="insn-data-structure">instruction data structure</link>.
Its execution causes an
<link linkend="trig-int-start-src">internal triggering event</link>. This
event can, for example, cause the device driver to start a conversion,
or to stop an ongoing acquisition. The exact meaning of the triggering
depends on the card and its particular driver.
</para>
<para>
The 
<link linkend="insn-data-structure-data">data</link>[0] field of the
INSN_INTTRIG instruction is reserved for future use, and should be set
to <quote>0</quote>.
</para>

</section>


<section id="commandsstreaming">
<title>
Commands for streaming acquisition
</title>

<para>
The most powerful &comedi; acquisition primitive is the
<emphasis>command</emphasis>. It's powerful because, with one single
command, the programmer launches:
<itemizedlist>

<listitem>
<para>
a possibly infinite <emphasis>sequence of acquisitions</emphasis>,
</para>
</listitem>

<listitem>
<para>
accompanied with various <emphasis>callback</emphasis> functionalities
(DMA, interrupts, driver-specific callback functions), 
</para>
</listitem>

<listitem>
<para>
for <emphasis>any number of channels</emphasis>, 
</para>
</listitem>

<listitem>
<para>
with an <emphasis>arbitrary order</emphasis> of channels in each scan
(possibly even with repeated channels per scan), 
</para>
</listitem>

<listitem>
<para>
and with various scan <emphasis>triggering sources</emphasis>,
external (i.e., hardware pulses) as well as internal (i.e., pulses
generated on the DAQ card itself, or generated by a 
<link linkend="inttrigconfiguration">software trigger instruction</link>).
</para>
</listitem>

</itemizedlist>
This command functionality exists in the &comedi; API, because various
data acquisition devices have the capability to perform this kind of
complex acquisition, driven by either on-board or
off-board timers and triggers.
</para>

<para>
A command specifies a particular data 
<link linkend="fig-acq-seq">acquisition sequence</link>, which
consists of a number of <emphasis>scans</emphasis>, and each scan is
comprised of a number of <emphasis>conversions</emphasis>, which
usually corresponds to a single A/D or D/A conversion. So, for
example, a scan could consist of sampling channels 1, 2 and 3 of a
particular device, and this scan should be repeated 1000 times, at
intervals of 1 millisecond apart.
</para>
<para>
The command function is complementary to the
<link linkend="instructionsconfiguration">configuration instruction</link>
function: each channel in the command's 
<link linkend="command-data-struct-chanlist">chanlist</link>
should first be configured by an appropriate instruction.
</para>


<section id="executingcommand">
<title>
Executing a command
</title>

<para>
A commands is executed by the following &comedi; function:
<programlisting>
 int <link linkend="func-ref-comedi-command">comedi_command</link>(<link linkend="ref-type-comedi-t">comedi_t</link> * device,  <link linkend="ref-type-comedi-cmd">comedi_cmd</link> * command);
</programlisting>
The following sections explain the meaning of the
<link linkend="ref-type-comedi-cmd">comedi_cmd</link> data structure.
Filling in this structure can be quite complicated, and
requires good knowledge about the exact functionalities of the DAQ
card.  So, before launching a command, the application programmer is
adviced to check whether this complex command data structure can be
successfully parsed. So, the typical sequence for executing a command is
to first send the command through
<link linkend="func-ref-comedi-command-test">comedi_command_test()</link>
once or twice.  The test will check that the command is valid for the
particular device, and often makes some adjustments to the command
arguments, which can then be read back by the user to see the actual
values used.
</para>
<para>
A &comedi; program can find out on-line what the command capabilities
of a specific device are, by means of the
<link linkend="func-ref-comedi-get-cmd-src-mask">comedi_get_cmd_src_mask()</link>
function.
</para>
 
</section>


<section id="comedicmdstructure">
<title>
The command data structure
</title>
<para>
The command executes according to the information about the requested
acquisition, which is stored in the
<link linkend="ref-type-comedi-cmd">comedi_cmd</link> 
<anchor id="command-data-struct">data structure:
<programlisting>
typedef struct comedi_cmd_struct comedi_cmd;

struct comedi_cmd_struct{
  unsigned int subdev;         // which subdevice to sample
  unsigned int <anchor id="command-data-struct-flags">flags;          // encode some configuration possibilities 
                               // of the command execution; e.g.,
                               // whether a callback routine is to be
                               // called at the end of the command

  unsigned int <anchor id="command-data-struct-start-src">start_src;      // event to make the acquisition start
  unsigned int <anchor id="command-data-struct-start-arg">start_arg;      // parameters that influence this start

  unsigned int <anchor id="command-data-struct-scan-begin-src">scan_begin_src; // event to make a particular scan start
  unsigned int <anchor id="command-data-struct-scan-begin-arg">scan_begin_arg; // parameters that influence this start`

  unsigned int <anchor id="command-data-struct-convert-src">convert_src;    // event to make a particular conversion start
  unsigned int <anchor id="command-data-struct-convert-arg">convert_arg;    // parameters that influence this start

  unsigned int <anchor id="command-data-struct-scan-end-src">scan_end_src;   // event to make a particular scan terminate
  unsigned int <anchor id="command-data-struct-scan-end-arg">scan_end_arg;   // parameters that influence this termination

  unsigned int <anchor id="command-data-struct-stop-src">stop_src;       // what make the acquisition terminate
  unsigned int <anchor id="command-data-struct-stop-arg">stop_arg;       // parameters that influence this termination

  unsigned int <anchor id="command-data-struct-chanlist">*chanlist;      // pointer to list of channels to be sampled
  unsigned int <anchor id="command-data-struct-chanlist-len">chanlist_len;   // number of channels to be sampled

  sampl_t *<anchor id="command-data-struct-data">data;               // address of buffer
  unsigned int <anchor id="command-data-struct-data-len">data_len;       // number of samples to acquire
};
</programlisting>
The start and end of the whole command acquisition sequence, and the
start and end of each scan and of each conversion, is triggered by a
so-called <emphasis>event</emphasis>. More on these in
<xref linkend="comedicmdsources">.
</para>

<para>
The <parameter class=function>subdev</parameter> member of the
<link linkend="ref-type-comedi-cmd">comedi_cmd()</link> structure is
the index of the subdevice the command is intended for.  The
<link linkend="func-ref-comedi-find-subdevice-by-type">comedi_find_subdevice_by_type()</link>
function can be useful in discovering the index of your desired subdevice.
</para>

<para>
The <link linkend="command-data-struct-chanlist">chanlist</link>
member of the
<link linkend="ref-type-comedi-cmd">comedi_cmd</link> data
structure should point to an array whose number of elements is
specificed by
<link linkend="command-data-struct-chanlist-len">chanlist_len</link>
(this will generally be the same as the
<link linkend="command-data-struct-scan-end-arg">scan_end_arg</link>).
The
<link linkend="command-data-struct-chanlist">chanlist</link>
specifies the sequence of channels and gains (and analog references)
that should be stepped through for each scan.  The elements of the
<link linkend="command-data-struct-chanlist">chanlist</link> array should be
initialized by <quote>packing</quote> the channel, range and reference
information together with the
<parameter class=function>
 <link linkend="ref-macro-CR-PACK">CR_PACK()</link>
</parameter>
macro.
</para>

<para>
The <link linkend="command-data-struct-data">data</link> and
<link linkend="command-data-struct-data-len">data_len</link>
members can be safely ignored when issueing commands from a user-space
program.  They only have meaning when a command is sent from a
<emphasis role="strong">kernel</emphasis> module using the
<function>kcomedilib</function> interface, in which case they specify
the buffer where the driver should write/read its data to/from.
</para>

<para>
The final member of the
<link linkend="command-data-struct">comedi_cmd</link> structure is the
<link linkend="command-data-struct-flags">flags</link> field,
i.e., bits in a word that can be bitwise-or'd together. The meaning of
these bits are explained in a 
<link linkend="source.flags.anchor">later section</link>.
</para>

</section>


<section id="comedicmdsources">
<title>
The command trigger events
<anchor id="source.trigger.anchor">
</title>
<para>
A command is a very versatile acquisition instruction, in the sense
that it offers lots of possibilities to let different hardware and
software sources determine when acquisitions are started, performed,
and stopped. More specifically, the command
<link linkend="command-data-struct">data structure</link>
has <emphasis>five</emphasis> types of events: start the 
<link linkend="acquisitionterminology">acquisition</link>,
start a <link linkend="scan">scan</link>, start a 
<link linkend="conversion">conversion</link>, stop a scan, and stop
the acquisition.  Each event can be given its own
<emphasis><link linkend="source.trigger.anchor">source</link></emphasis>
(the <parameter class=function>*_src</parameter> members in the
<link linkend="ref-type-comedi-cmd">comedi_cmd</link> data
structure). And each event source can have a corresponding
argument (the <parameter class=function>*_arg</parameter> members of
the <link linkend="ref-type-comedi-cmd">comedi_cmd</link> data
structure) whose meaning depends on the type of source trigger. 
For example, to specify an external digital line <quote>3</quote> as a
source (in general, <emphasis>any</emphasis> of the five event
sources), you would use
<parameter>src</parameter>=<link linkend="trig-ext">TRIG_EXT</link> and
<parameter>arg</parameter>=3.
</para>
<para>
The following paragraphs discuss in somewhat more detail the trigger
event sources(<parameter class=function>*_src</parameter>), and the
corresponding arguments (<parameter class=function>*_arg</parameter>).
</para>
<para>
The start of an acquisition is controlled by the
<link linkend="command-data-struct-start-src">start_src</link> events.
The available options are:
<itemizedlist>

<listitem>
<para>
<anchor id="trig-now-start-src">
TRIG_NOW: the
<link linkend="command-data-struct-start-src">start_src</link> 
event occurs 
<link linkend="command-data-struct-start-arg">start_arg</link> 
nanoseconds after the
<link linkend="ref-type-comedi-cmd">comedi_cmd</link> 
is called. Currently, only 
<link linkend="command-data-struct-start-arg">start_arg</link>=0 is
supported.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-follow-start-src">
TRIG_FOLLOW:  (For an output device.) The 
<link linkend="command-data-struct-start-src">start_src</link>
event occurs when data is written to the buffer.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-ext-start-src">
TRIG_EXT: the start event occurs when an external trigger signal
occurs; e.g., a rising edge of a digital line.  
<link linkend="command-data-struct-start-arg">start_arg</link>
chooses the particular digital line.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-int-start-src">
TRIG_INT: the start event occurs on a &comedi; internal signal, which
is typically caused by an 
<link linkend="insn-inttrig">INSN_INTTRIG instruction</link>.
</para>
</listitem>

</itemizedlist>
The start of the beginning of each
<link linkend="scan">scan</link> is controlled by the
<link linkend="command-data-struct-scan-begin-src">scan_begin</link> events.
The available options are:
<itemizedlist>

<listitem>
<para>
<anchor id="trig-timer-start-scan">
TRIG_TIMER: 
<link linkend="command-data-struct-scan-begin-src">scan_begin</link> 
events occur periodically.  The time between
<link linkend="command-data-struct-scan-begin-src">scan_begin</link> 
events is
<link linkend="command-data-struct-convert-arg">convert_arg</link> 
nanoseconds.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-follow-start-scan">
TRIG_FOLLOW:  The
<link linkend="command-data-struct-scan-begin-src">scan_begin</link>
event occurs immediately after a
<link linkend="command-data-struct-scan-end-src">scan_end</link>
event occurs.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-ext-start-scan">
TRIG_EXT: the 
<link linkend="command-data-struct-scan-begin-src">scan_begin</link>
event occurs when an external trigger signal
occurs; e.g., a rising edge of a digital line.  
<link linkend="command-data-struct-scan-begin-arg">scan_begin_arg</link>
chooses the particular digital line.
</para>
</listitem>

</itemizedlist>
The 
<link linkend="command-data-struct-scan-begin-arg">scan_begin_arg</link>
used here may not be supported exactly by the device, but it
will be adjusted to the nearest supported value by 
<link linkend="func-ref-comedi-command-test">comedi_command_test()</link>.
</para>
<para>
The timing between each sample in a 
<link linkend="scan">scan</link> is controlled by the
<link linkend="command-data-struct-convert-src">convert_*</link>
fields:
<itemizedlist>

<listitem>
<para>
<anchor id="convert-trig-timer">
<anchor id="trig-timer">
TRIG_TIMER: the conversion events occur periodically.  The time
between convert events is 
<link linkend="command-data-struct-convert-arg">convert_arg</link>
nanoseconds.
</para>
</listitem>

<listitem>
<para>
<anchor id="convert-trig-ext">
<anchor id="trig-ext">
TRIG_EXT: the conversion events occur when an external trigger signal
occurs, e.g., a rising edge of a digital line. 
<link linkend="command-data-struct-convert-arg">convert_arg</link>
chooses the particular digital line.
</para>
</listitem>

<listitem>
<para>
<anchor id="convert-trig-now">
<anchor id="trig-now">
TRIG_NOW: All conversion events in a 
<link linkend="scan">scan</link> occur simultaneously.
</para>
</listitem>

</itemizedlist>
The <emphasis>end</emphasis> of each scan is almost always specified
using 
<link linkend="trig-count">TRIG_COUNT</link>, with the argument being
the same as the number of channels in the
<link linkend="command-data-struct-chanlist">chanlist</link>.  You
could probably find a device that allows something else, but it would
be strange. 
</para>
<para>
The end of an
<link linkend="acquisitionterminology">acquisition</link> is
controlled by
<link linkend="command-data-struct-stop-src">stop_src</link>
and <link linkend="command-data-struct-stop-arg">stop_arg</link>:
<itemizedlist>

<listitem>
<para>
<anchor id="acquisition-end-trig-count">
<anchor id="trig-count">
TRIG_COUNT:  stop the acquisition after 
<link linkend="command-data-struct-stop-arg">stop_arg</link>
scans.
</para>
</listitem>

<listitem>
<para>
<anchor id="acquisition-end-trig-none">
<anchor id="trig-none">
TRIG_NONE: perform continuous acquisition, until stopped using
<link linkend="func-ref-comedi-cancel">comedi_cancel()</link>.
</para>
<para>
Its argument is reserved and should be set to 0.
(<quote>Reserved</quote>
means that unspecified things could happen if it is set to something
else but 0.)
</para>
</listitem>

</itemizedlist>
There are a couple of less usual or not yet implemented events:
<itemizedlist>

<listitem>
<para>
<anchor id="trig-time">
TRIG_TIME:
cause an event to occur at a particular time.
</para>
<para>
(This event source is reserved for future use.)
</para>
</listitem>

<listitem>
<para>
<anchor id="trigother-event">
TRIG_OTHER: driver specific event trigger.
</para>
<para>
This event can be useful as any of the trigger sources.  Its exact
meaning is driver specific, because it implements a feature that
otherwise does not fit into the generic &comedi; command interface.
Configuration of TRIG_OTHER features are done by
<link linkend="instructionsconfiguration">INSN_CONFIG</link>
instructions.
</para>
<para>
The argument is reserved and should be set to 0.
</para>
</listitem>

</itemizedlist>
Not all event sources are applicable to all events.  Supported
trigger sources for specific events depend significantly on your
particular device, and even more on the current state of its device
driver. The 
<link linkend="func-ref-comedi-get-cmd-src-mask">comedi_get_cmd_src_mask()</link>
function is useful for determining what trigger sources a subdevice
supports.
</para>

</section>


<section id="comedicmdflags">
<title>
The command flags
<anchor id="source.flags.anchor">
</title>

<para>
The
<link linkend="command-data-struct-flags">flags</link> field in the
<link linkend="ref-type-comedi-cmd">command data structure</link>
is used to specify some <quote>behaviour</quote> of the acquisitions in
a command.
The meaning of the field is as follows:
<itemizedlist>

<listitem>
<para>
<anchor id="trig-rt">
TRIG_RT: ask the driver to use a
<emphasis role="strong">hard real-time</emphasis> interrupt handler.
This will reduce latency in handling interrupts from your data
aquisition
hardware.  It can be useful if you are sampling at high frequency, or
if your hardware has a small onboard data buffer.  You must have a
real-time kernel (<ulink url="http://www.rtai.org">RTAI</ulink> or
<ulink url="http://fsmlabs.com/community/">RTLinux/Free</ulink>)
and must compile &comedi; with real-time support, or this flag will do
nothing.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-wake-eos">
TRIG_WAKE_EOS:
where <quote>EOS</quote> stands for <quote>End of Scan</quote>. Some
drivers will change their behaviour when this flag is set, trying to
transfer data at the end of every scan (instead of, for example,
passing data in chunks whenever the board's hardware data buffer is
half full).  This flag may degrade a driver's performance at high
frequencies, because the end of a scan is, in general, a much more
frequent event than the filling up of the data buffer.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-round-nearest">
TRIG_ROUND_NEAREST:
round to nearest supported timing period, the default.
This flag (as well as the following three), indicates how timing
arguments should be rounded if the hardware cannot achieve the exact
timing requested.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-round-down">
TRIG_ROUND_DOWN: round period down.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-round-up">
TRIG_ROUND_UP: round period up.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-round-up-next">
TRIG_ROUND_UP_NEXT:
this one doesn't do anything, and I don't know what it was intended
to do&hellip;?
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-dither">
TRIG_DITHER: enable dithering? Dithering is a software technique to
smooth the influence of discretization <quote>noise</quote>.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-deglitch">
TRIG_DEGLITCH: enable deglitching? Another <quote>noise</quote>
smoothing technique.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-write">
TRIG_WRITE:
write to bidirectional devices.  Could be useful, in principle, if
someone wrote a driver that supported commands for a digital I/O
device that could do either input or output.
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-bogus">
TRIG_BOGUS: do the motions?
</para>
</listitem>

<listitem>
<para>
<anchor id="trig-other">
TRIG_CONFIG: perform configuration, not triggering.  This is a legacy
of the deprecated
<link linkend="ref-type-comedi-cmd">comedi_trig_struct</link>
data structure, and has no function at present.
</para>
</listitem>

</itemizedlist>
</para>

</section>

<section>
<title>
Anti-aliasing
</title>
<para>
If you wish to aquire accurate waveforms, it is vital that you use an
anti-alias filter.  An anti-alias filter is a low-pass filter used to
remove all    frequencies higher than the Nyquist frequency (half your sampling rate)
from your analog input signal
before you convert it to digital.  If you fail to filter your input signal,
any high frequency components in the original analog signal will create
artifacts in your recorded    digital waveform that cannot be corrected.
</para>
<para>
For example, suppose you are sampling an analog input channel at a rate of
1000 Hz.  If you were to apply a 900 Hz sine wave to the input, you
would find that your
sampling rate is not high enough to faithfully record the 900 Hz input,
since it is above your Nyquist frequency of 500 Hz.  Instead, what you
will see in your recorded digital waveform is a 100 Hz sine wave!  If you
don't use an anti-alias filter, it is impossible to tell whether the 100
Hz sine wave you see in your digital signal was really produced by a
100 Hz input signal, or a 900 Hz signal aliased to 100 Hz, or a 1100 Hz
signal, etc.
</para>
<para>
In practice, the cutoff frequency for the anti-alias filter is usually
set 10% to 20% below the Nyquist frequency due to fact that real filters
do not have infinitely sharp cutoffs.
</para>
</section>
</section>


<section id="slowlyvarying">
<title>
Slowly-varying inputs
</title>

<para>
Sometimes, your input channels change slowly enough that
you are able to average many successive input values to get a
more accurate measurement of the actual value.  In general,
the more samples you average, the better your estimate
gets, roughly by a factor of sqrt(number_of_samples).
Obviously, there are limitations to this:
</para>

<itemizedlist>

<listitem>
<para>
you are ultimately limited by <quote>Spurious Free Dynamic
Range</quote>. This SFDR is one of the popular measures to quantify how
much noise a signal carries. If you take a Fourier transform of your
signal, you will see several <quote>peaks</quote> in the transform: one
or more of the fundamental harmonics of the measured signal, and lots
of little <quote>peaks</quote> (called <quote>spurs</quote>) caused by
noise. The SFDR is then the difference between the amplitude of the
fundamental harmonic and of the largest spur (at frequencies below
half of the Nyquist frequency of the DAQ sampler!).
</para>
</listitem>

<listitem>
<para>
you need to have <emphasis>some</emphasis> noise on the input channel,
otherwise you will be averaging the same number <literal>N</literal>
times. (Of course, this only holds if the noise is large enough to
cause at least a one-bit discretization.)
</para>
</listitem>

<listitem>
<para>
the more noise you have, the greater your SFDR, but it
takes many more samples to compensate for the increased
noise.
</para>
</listitem>

<listitem>
<para>
if you feel the need to average samples for, for example, two seconds,
your signal will need to be <emphasis>very</emphasis> slowly-varying,
i.e., not varying more than your target uncertainty for the entire two
seconds.
</para>
</listitem>

</itemizedlist>

<para>
As you might have guessed, the &comedi; library has functions
to help you in your quest to accurately measure slowly varying
inputs:
<programlisting>
  int <link linkend="func-ref-comedi-sv-init">comedi_sv_init</link>(<link linkend="ref-type-comedi-sv-t">comedi_sv_t</link> * sv, <link linkend="ref-type-comedi-t">comedi_t</link> * device, unsigned int subdevice, unsigned int channel);
</programlisting>
This function initializes the
<link linkend="ref-type-comedi-sv-t">comedi_sv_t</link> data structure, used
to do the averaging acquisition:
<programlisting>
struct comedi_sv_struct{
  <link linkend="ref-type-comedi-t">comedi_t</link> *dev;
  unsigned int subdevice;
  unsigned int chan;

  /* range policy */
  int range;
  int aref;

  /* number of measurements to average (for analog inputs) */
  int n;

  lsampl_t maxdata;
};
</programlisting>
The actual acquisition is done with:
<programlisting>
  int <link linkend="func-ref-comedi-sv-measure">comedi_sv_measure</link>(<link linkend="ref-type-comedi-sv-t">comedi_sv_t</link> * sv, double * data);
</programlisting>
The number of samples over which the
<function>comedi_sv_measure()</function> averages is limited by the
implementation (currently the limit is 100 samples). 
</para>

<para>
One typical use for this function is the measurement of thermocouple
voltages.
And the &comedi; self-calibration utility also uses these functions.
On some hardware, it is possible to tell it to measure an
internal stable voltage reference, which is typically going
to be very slowly varying; on the kilosecond time scale
or more.  So, it is reasonable to measure millions of samples,
to get a very accurate measurement of the A/D converter output
value that corresponds to the voltage reference.  Sometimes,
however, this is overkill, since there is no need to
perform a part-per-million calibration to a standard that
is only accurate to a part-per-thousand.
</para>

</section>

<section id="experimentalfunctionality">
<title>
Experimental functionality
</title>

<para>
The following subsections document functionality that has not yet
matured. Most of this functionality has even not been implemented yet
in any single device driver. This information is included here, in
order to stimulate discussion about their API, and to encourage
pioneering implementations.
</para>

<section id="digitalinputcombining">
<title>
Digital input combining machines
</title>

<para>
(<emphasis role="strong">Status: experimental (i.e., no driver implements
this yet)</emphasis>)
</para>
<para>
When one or several digital inputs are used to modify an output
value, either an accumulator or a single digital line or bit,
a bitfield structure is typically used in the &comedi; interface.
The digital inputs have two properties, <quote>sensitive</quote> inputs
and <quote>modifier</quote> inputs.  Edge transitions on sensitive
inputs cause changes in the output signal, whereas modifier inputs
change the effect of edge transitions on sensitive inputs.  Note that
inputs can be both modifier inputs and sensitive inputs.
</para>

<para>
For simplification purposes, it is assumed that multiple digital
inputs do not change simultaneously.
</para>

<para>
The combined state of the modifier inputs determine a modifier
state.  For each combination of modifier state and sensitive
input, there is a set of bits that determine the effect on the
output value due to positive or negative transitions of the
sensitive input.  For each transition direction, there are two
bits defined as follows:
<simplelist>

<member>
00: transition is ignored.
</member>

<member>
01: accumulator is incremented, or output is set.
</member>

<member>
10: accumulator is decremented, or output is cleared.
</member>
                                                                                
<member>
11: reserved.
</member>

</simplelist>
For example, a simple digital follower is specified by the bit
pattern 01 10, because it sets the output on positive transitions
of the input, and clears the output on negative transitions.  A
digital inverter is similarily 10 01.  These systems have only
one sensitive input.
</para>

<para>
As another example, a simple up counter, which increments on
positive transitions of one input, is specified by 01 00.  This
system has only one sensitive input.
</para>

<para>
When multiple digital inputs are used, the inputs are divided
into two types, inputs which cause changes in the accumulator, and
those that only modify the meaning of transitions on other inputs.
Modifier inputs do not require bitfields, but there needs to be
a bitfield of length 4*(2^(N-1)) for each edge sensitive input,
where N is the total number of inputs.  Since N is usually 2 or
3, with only one edge sensitive input, the scaling issues are
not significant.
</para>

</section>


<section id="analogconversion">
<title>
Analog filtering configuration
</title>

<para>
<emphasis role="strong">(Status: design (i.e., no driver implements
this yet).)</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is ignored.
</para>

<para>
Some devices have the capability to add white noise (dithering) to
analog input measurement.  This additional noise can then be averaged
out, to get a more accurate measurement of the input signal.  It
should not be assumed that channels can be separately configured.
A simple design can use 1 bit to turn this feature on/off.
</para>

<para>
Some devices have the capability of changing the glitch characteristics
of analog output subsytems.  The default (off) case should be where
the average settling time is lowest.  A simple design can use 1 bit
to turn this feature on/off.
</para>

<para>
Some devices have a configurable analog filters as part of the analog
input stage.  A simple design can use 1 bit to enable/disable the
filter.  Default is disabled, i.e., the filter being bypassed, or if
the choice is between two filters, the filter with the largest
bandwidth.
</para>
</section>

<section id="waveformgeneration">
<title>
Analog Output Waveform Generation
</title>

<para>
<emphasis role="strong">(Status: design (i.e., no driver implements
this yet).)</emphasis>
</para>
<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is ignored.
</para>

<para>
Some devices have the ability to cyclicly loop through samples kept in
an on-board analog output FIFO.  This config should allow the user to
enable/disable this mode.
</para>

<para>
This config should allow the user to configure the number of samples
to loop through.  It may be necessary to configure the channels used.
</para>

</section>

<section id="extendedtriggering">
<title>
Extended Triggering
</title>
<para>
<emphasis role="strong">(Status: alpha.)</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is ignored.
</para>

<para>
This section covers common information for all extended
triggering configuration, and doesn't describe a particular
type of extended trigger.
</para>

<para>
Extended triggering is used to configure triggering engines that
do not fit into commands.  In a typical programming sequence, the
application will use
<link linkend="instructionsconfiguration">configuration instructions</link>
to configure an extended trigger, and a
<link linkend="commandsstreaming">command</link>,
specifying 
<link linkend="trig-other">TRIG_OTHER</link> as one of the trigger
sources.
</para>

<para>
Extended trigger configuration should be designed in such a way
that the user can probe for valid parameters, similar to how
command testing works.  An extended trigger configuration instruction
should not configure the hardware directly, rather, the configuration
should be saved until the subsequent command is issued.  This
allows more flexibility for future interface changes.
</para>

<para>
It has not been decided whether the configuration stage should return a
token that is then used as the trigger argument in the command.
Using tokens is one method to satisfy the problem that extended
trigger configurations may have subtle compatiblity issues with
other trigger sources/arguments that can only be determined at
command test time.  Passing all stages of a command test should
only be allowed with a properly configured extended trigger.
</para>

<para>
Extended triggers must use 
<link linkend="insn-data-structure-data">data[1]</link> as flags.  The
upper 16 bits are reserved and used only for flags that are common to
all extended triggers.  The lower 16 bits may be defined by the
particular type of extended trigger.
</para>

<para>
Various types of extended triggers must use 
<link linkend="insn-data-structure-data">data[1]</link> to know which
event the extended trigger will be assigned to in the command
structure.  The possible values are an OR'd mask of the following:
</para>

<itemizedlist>
  <listitem>
    <para>
COMEDI_EV_START
    </para>
  </listitem>
  <listitem>
    <para>
COMEDI_EV_SCAN_BEGIN
    </para>
  </listitem>
  <listitem>
    <para>
COMEDI_EV_CONVERT
    </para>
  </listitem>
  <listitem>
    <para>
COMEDI_EV_SCAN_END
    </para>
  </listitem>
  <listitem>
    <para>
COMEDI_EV_STOP
    </para>
  </listitem>
</itemizedlist>

</section>

<section id="analogtriggering">
<title>
Analog Triggering
</title>
<para>
<emphasis role="strong">
(Status: alpha. The <function>ni_mio_common.c</function> driver
implements this feature.)
</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is ignored.
</para>

<para>
The <link linkend="insn-data-structure-data">data</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used as follows:
<simplelist>
  <member>
data[1]:  trigger and combining machine configuration.
  </member>
  <member>
data[2]: analog triggering signal chanspec.
  </member>
  <member>
data[3]: primary analog level.
  </member>
  <member>
data[4]: secondary analog level.
  </member>
</simplelist>
</para>
<para>
Analog triggering is described by a digital combining machine that
has two sensitive digital inputs.  The sensitive digital inputs are
generated by configurable analog comparators.  The analog comparators
generate a digital 1 when the analog triggering signal is greater
than the comparator level.  The digital inputs are not modifier
inputs.  Note, however, there is an effective modifier due to the
restriction that the primary analog comparator level must be less
than the secondary analog comparator level.
</para>

<para>
If only one analog comparator signal is used, the combining machine
for the secondary input should be set to ignored, and the secondary
analog level should be set to 0.
</para>

<para>
The interpretation of the chanspec and voltage levels is device
dependent, but should correspond to similar values of the analog
input subdevice, if possible.
</para>

<para>
Notes:  Reading range information is not addressed.  This makes it
difficult to convert comparator voltages to data values.
</para>

<para>
Possible extensions: A parameter that specifies the necessary time
that the set condition has to be true before the trigger is generated.
A parameter that specifies the necessary time that the reset condition
has to be true before the state machine is reset.
</para>

</section>

<section id="bitfieldmatching">
<title>
Bitfield Pattern Matching Extended Trigger
</title>
<para>
<emphasis role="strong">
(Status: design. No driver implements this feature yet.)
</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is ignored.
</para>

<para>
The <link linkend="insn-data-structure-data">data</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used as follows:
</para>
<simplelist>
  <member>
data[1]: trigger flags.
  </member>
  <member>
data[2]: mask.
  </member>
  <member>
data[3]: pattern.
  </member>
</simplelist>

<para>
The pattern matching trigger issues a trigger when all of a specifed 
set of input lines match a specified pattern.  If the device allows,
the input lines should correspond to the input lines of a digital input
subdevice, however, this will necessarily be device dependent.  Each
possible digital line that can be matched is assigned a bit in the
mask and pattern.  A bit set in the mask indicates that the
input line must match the corresponding bit in the pattern.
A bit cleared in the mask indicates that the input line is ignored.
</para>

<para>
Notes: This only allows 32 bits in the pattern/mask, which may be
too few.  Devices may support selecting different sets of lines from
which to match a pattern.
</para>

<para>
Discovery: The number of bits can be discovered by setting the mask
to all 1's.  The driver must modify this value and return -EAGAIN.
</para>

</section>

<section id="countertimer">
<title>
Counter configuration
</title>
<para>
<emphasis role="strong">
(Status: design. No driver implements this feature yet.)
</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used to specify which counter to use. (I.e., the
counter is a &comedi; channel.)
</para>

<para>
The <link linkend="insn-data-structure-data">data</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used as follows:
</para>
<simplelist>
  <member>
data[1]: trigger configuration.
  </member>
  <member>
data[2]: primary input chanspec.
  </member>
  <member>
data[3]: primary combining machine configuration.
  </member>
  <member>
data[4]: secondary input chanspec.
  </member>
  <member>
data[5]: secondary combining machine configuration.
  </member>
  <member>
data[6]: latch configuration.
  </member>
</simplelist>

<para>
Note that this configuration is only useful if the counting has to be
done in <emphasis>software</emphasis>. Many cards offer configurable
counters in hardware; e.g., general purpose timer cards can be
configured to act as pulse generators, frequency counters, timers,
encoders, etc.
</para>
<para>
Counters can be operated either in synchronous mode (using
<link linkend="comediinsnstructure">INSN_READ</link>)
or asynchronous mode (using 
<link linkend="commandsstreaming">commands</link>), similar to analog
input subdevices. 
The input signal for both modes is the accumulator.
Commands on counter subdevices are almost always specified using
<link linkend="command-data-struct-scan-begin-src">scan_begin_src</link>
= <link linkend="trigother-event">TRIG_OTHER</link>, with the
counter configuration also serving as the extended configuration for
the scan begin source.
</para>

<para>
Counters are made up of an accumulator and a combining machine that
determines when the accumulator should be incremented or decremented
based on the values of the input signals.  The combining machine
optionally determines when the accumulator should be latched and
put into a buffer.  This feature is used in asynchronous mode.
</para>

<para>
Note: How to access multiple pieces of data acquired at each event?
</para>

</section>

<section id="auxcounter">
<title>
One source plus auxiliary counter configuration
</title>
<para>
<emphasis role="strong">
(Status: design. No driver implements this feature yet.)
</emphasis>
</para>

<para>
The <link linkend="insn-data-structure-insn">insn</link> field of the 
<link linkend="insn-data-structure">instruction data structure</link>
has not been assigned yet.
</para>
<para>
The <link linkend="insn-data-structure-chanspec">chanspec</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used to &hellip;
</para>

<para>
The <link linkend="insn-data-structure-data">data</link> field
of the <link linkend="insn-data-structure">instruction data
structure</link> is used as follows:
</para>

<para>
<simplelist>
 <member>
data[1]: is flags, including the flags for the command triggering
configuration.  If a command is not subsequently issued on the
subdevice, the command triggering portion of the flags are ignored.
 </member>
 <member>
data[2]: determines the mode of operation.  The mode of operation
is actually a bitfield that encodes what to do for various
transitions of the source signals.
</member>

<member>
data[3], data[4]: determine the primary source for the counter,
similar to the 
<link linkend="command-data-struct-scan-begin-src">_src</link> and the 
<link linkend="command-data-struct-scan-begin-arg">_arg</link> fields
used in the
<link linkend="command-data-struct">command data structure</link>.
</member>

</simplelist>
</para>

<para>
Notes: How to specify which events cause a latch and push, and what
should get latched?
</para>

</section>

</section>

</section>