A/D functions
BYTE SATURNADSetSettings(BoardInfo* bi, SATURNADSETTINGS* settings);
This function configures the A/D input range, channel register, and scan settings. It can optionally recall the A/D calibration settings for the selected input range.
Input parameters:
Gain
int
0-3: 0 = 1, 1 = 2, 2 = 4, 3 = 8
Polarity
int
0-1; 0 = bipolar, 1 = unipolar
Sedi
int
0-1; 0 = single-ended, 1 = differential
Lowch
int
low channel, 0-15
Highch
int
high channel, 0-15
LoadCal
bool
True/False
ScanEnable
int
0 = disable, 1 = enable
ScanInterval
int
0 = 10us, 1 = 5us, 2 = 8us, 3 = programmable
ProgInt
int
100-255, used if Interval = 3 (minimum limit is not enforced in driver)
This function operates as follows:
Set page = 0
Build register 2 value (input channels) from Lowch and Highch parameters
Write value to register 2
Calculate Scansize = Highch – Lowch + 1
Write Sedi to register 3
Build register 4 value (input range) from Gain and Polarity parameters
Write value to register 4
Build register 6 value (scan settings) from ScanEnable and ScanInterval
Write value to register 6
If ScanInterval = 3 then write ProgInt value to register 7
If LoadCal = True:
Recall A/D calibration values for selected input range from EEPROM (4 values)
Write calibration values to TrimDACs
On each write to TrimDAC:
Wait for TDBUSY = 0
Return Timeout error if TDBUSY does not return to 0 within the specified time limit
Wait for ADWAIT = 0 (register 3 bit 6)
Return Timeout error if ADWAIT does not return to 0 within the specified time limit
Exit
BYTE SATURNADSetRange(BoardInfo* bi, SATURNADSETTINGS* settings);
This function configures the A/D input range. All other settings remain as is.
Input parameters:
Gain
int
0-3: 0 = 1, 1 = 2, 2 = 4, 3 = 8
Polarity
int
0-1; 0 = bipolar, 1 = unipolar
Sedi
int
0-1; 0 = single-ended, 1 = differential
This function operates as follows:
Set page = 0
Build register 4 value (input range) from Gain, Polarity, and Sedi parameters
Write value to register 4
Wait for ADWAIT = 0 (register 3 bit 6)
Return Timeout error if ADWAIT does not return to 0 within the specified time limit
Exit
BYTE SATURNADSetChannel(BoardInfo* bi, SATURNADSETTINGS* settings);
This function configures the A/D input channel range. All other settings remain as is.
Input parameters:
Lowch
int
low channel, 0-15
Highch
int
High channel, 0-15
This function operates as follows:
Set page = 0
Build register 2 value (input channels) from Lowch and Highch parameters
Write value to register 2
Calculate Scansize = Highch – Lowch + 1 // wrap around 15 to 0 is allowed
Wait for ADWAIT = 0 (register 3 bit 6)
Return Timeout error if ADWAIT does not return to 0 within the specified time limit
Exit
BYTE SATURNADSetScan(BoardInfo* bi, SATURNADSETTINGS* settings);
This function configures the A/D logic for scan operation. It does not configure any other settings on the board.
Input parameters:
ScanEnable
int
0 = disable, 1 = enable
ScanInterval
int
0 = 10us, 1 = 5us, 2 = 8us, 3 = programmable
ProgInt
int
125-255, used if Interval = 3
This function operates as follows:
Set page = 0
Build register 6 value (scan settings) from ScanEnable and ScanInterval
Write value to register 6
If ScanInterval = 3 then write ProgInt value to register 7
Exit
BYTE SATURNADSetClock(BoardInfo* bi, BYTE ADclk);
This function configures the clock source for A/D conversions.
Input parameters:
ADClk
int
0-3: 0 = software command (ADSample or ADScan function), 1 = falling edge on DIO0, 2 = counter 0 output, 3 = counter 1 output
This function operates as follows:
Set page = 0
value = ADclk
// ADCLKEN is only set when the interrupt function is started.
Write value to register 5
Exit
BYTE SATURNADStartClock(BoardInfo* bi);
This function enables the clock source for A/D conversions.
Input parameters:
None
This function operates as follows:
Set page = 0
Read register 5
Set ADCLKEN bit
Write new value to register 5
Exit
BYTE SATURNADStopClock(BoardInfo* bi);
This function disables the clock source for A/D conversions.
Input parameters:
None
This function operates as follows:
Set page = 0
Read register 5
Clear ADCLKEN bit
Write new value to register 5
Exit
BYTE SATURNADRead(BoardInfo* bi, unsigned* Sample);
This function reads one A/D sample out of the FIFO if the FIFO is not empty. If the FIFO is empty, it returns an error FIFO_EMPTY. The purpose of this function is to enable reading A/D data acquired with counter/timer or external triggering without having to use interrupts.
This function operates as follows:
Set page = 4
Read FIFO depth in registers 4 and 5
If depth = 0, return error FIFO_EMPTY and Sample is set to 0
Set page = 0
Read A/D data in registers 0 and 1
Convert data to 16-bit value and store in Sample
Exit
BYTE SATURNADSample(BoardInfo* bi, unsigned* Sample);
This function executes one A/D conversion using the current board settings. It does not perform any configuration of the board or the FPGA but rather uses the current settings. It assumes that the board is configured for sample mode, not scan mode.
Output parameters:
Sample
unsigned
Return value, 16 bits; may be interpreted as unsigned integer 0 - 65535 or signed integer -32768 – 32767 depending on the A/D configuration and software expectations.
This function operates as follows:
Set page = 0
Write 0x80 to register 0 to start conversion (ADSTART = 1)
Monitor ADBUSY (register 3 bit 7)
Return Timeout error if ADBUSY does not return to 0 within the specified time limit
Read A/D value from registers 0 and 1 and store in Sample
Exit
BYTE SATURNADScan(BoardInfo* bi unsigned* Sample);
This function executes one A/D scan (sample on all channels between Lowch and Highch). It uses all existing A/D settings on the board. It assumes that the board is configured for scan mode, not sample mode.
Output parameters:
Sample
unsigned
pointer to array of return values, 16 bits; may be interpreted as unsigned integer 0 - 65535 or signed integer -32768 – 32767 depending on the A/D configuration and software expectations. The size of this array must be equal to or greater than the maximum number of channels available on the board (16).
This function operates as follows:
Set page = 0
Write 0x80 to register 0 to start scan (ADSTART = 1)
Monitor ADBUSY (register 3 bit 7)
Return Timeout error if ADBUSY does not return to 0 within the specified time limit
When ADBUSY = 0, an entire scan of samples will be stored in the A/D FIFO.
Read all A/D values from registers 0 and 1 and store in array; the number of samples to read is equal to Scansize. This will have been calculated previously during SATURNADSetSettings() or SATURNADSetChannel().
Exit
BYTE SATURNADInt(BoardInfo* bi, SATURNADINT* SATURNadint);
This function enables A/D interrupt operation using the current analog input settings. It configures the FIFO and the clock source on the board.
Input parameters (part of SATURNADINT data structure):
FIFOEnable
int
0 = disable; interrupt occurs after each sample / scan; 1 = enable; interrupt occurs on FIFO threshold flag
FIFOThreshold
int
0-2048, indicates level at which FIFO will generate an interrupt if FIFOEnable = 1
Cycle
int
0 = one shot operation, interrupts will stop when the selected no. of samples / scans are acquired; 1 = continuous operation until terminated
ADClk
int
0-3 selects A/D clock source
NumConversions
int
if Cycle = 0 this is the number of samples / scans to acquire; if Cycle = 1 this is the size of the circular buffer in samples / scans
ADBuffer
unsigned *
pointer to A/D buffer to hold the samples; the buffer must be greater than or equal to NumConversions x 1 if scan is disabled or NumConversions x Scansize if scan is enabled (Scansize is Highch – Lowch + 1)
Procedure:
Disable A/D clock
Reset A/D FIFO
Configure FIFO settings
Install interrupt routine
Set up buffer in kernel
Configure A/D clock source
If counter/timer is used, reset counter so it starts at beginning
Enable A/D interrupts
This function operates as follows:
Set page = 0
Write 0 to register 5 to stop A/D clock
Set page = 4
Write 0x80 to register 13 to reset FIFO
If FIFOEnable = 1 then:
Write FIFO threshold to register 0 and 1
Write 0x01 to register 12 to enable FIFO
Clear SampleCount variable
Store Cycle parameter
Install pointer to A/D interrupt routine
Configure A/D buffer in kernel according to NumConversions and ScanEnable register bit
Store interrupt parameters Cycle and NumConversions for use by interrupt routine
If internal counter/timer 0 or 1 is selected as clock source:
Stop counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0100, CCD0 = 0
Reset counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0000
Set page = 7
Read register 0
Set ADINTEN, retain other bits
Write value to register 0
Set page = 0
If internal counter/timer 0 or 1 is selected as clock source:
Start counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0100, CCD0 = 1
Write ADclk + ADCLKEN = 1 to register 5 // Enable AD clock for A/D conversions only after all other settings are in place
Set page = 0
Exit
SATURNADIntHandler();
This function processes A/D interrupts. It is called by the operating system interrupt handler in Universal Driver when a hardware interrupt occurs on the selected level for the board. It will also run a user interrupt function if user interrupts have been configured. This function is internal to the driver and is never called directly by the user.
Procedure:
Check ADINT status, if 0 then exit: Page 7 register 1 bit 0
If UserInterrupt = 1 and UserInterruptMode = 1 (before) then run user interrupt routine
Read A/D data from board (sample, scan, or FIFO threshold qty)
Store A/D data in buffer mod buffer size; interrupt routine must manage the buffer pointer
Increment SampleCount by 1, ScanSize, or FIFO Threshold
Clear A/D interrupt request on board
Set page = 7
Write 0x01 to register 1
If SampleCount >= NumConversions, then:
If Cycle = 0 stop interrupts
If Cycle = 1 nothing needs to be done
If UserInterrupt = 1 and UserInterruptMode = 2 (after) then run user interrupt routine
Exit
BYTE SATURNADIntStatus(BoardInfo* bi, SATURNADINTSTATUS* intstatus);
This function returns the interrupt routine status including, running / not running, number of conversions completed, cycle mode, FIFO status, and FIFO flags.
Output parameters (part of SATURNADINTSTATUS data structure):
OpStatus
int
0 = not running, 1 = running
NumConversions
int
Number of conversions since interrupts started
Cycle
int
0 = one-shot operation, 1 = continuous operation
FIFODepth
int
Current FIFO depth pointer
UF, OF, FF, TF, EF
int
FIFO flags
This function operates as follows:
Set page = 7
OpStatus = ADINTEN, register 0 bit 0
Set page = 4
FIFODepth = depth value in registers 4 and 5
Flags = values in register 13; Each return value is either 1 or 0
NumConversions = SampleCount managed by interrupt handler
Cycle = Cycle parameter stored by SATURNADInt()
Set page = 0
Exit
BYTE SATURNADIntPause(BoardInfo* bi);
This function pauses A/D interrupts by turning off the interrupt enable and stopping the A/D clock. This holds the A/D channel counter and FIFO at their current positions. Interrupts may be resumed from the point at which they were stopped with the Resume function.
Input parameters:
None
This function operates as follows:
Set page = 0
Read ADCLK1-0 in register 5
Clear ADCLKEN bit
Rewrite register 5
If counter/timer 0 or 1 is selected, then:
Stop counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0100, CCD0 = 0
Clear counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0000
Set page = 7
Set ADINTEN = 0, retain other bits in register 0
Set page = 0
Exit
BYTE SATURNADIntResume(BoardInfo* bi);
This function resumes A/D interrupts from the point at which they were paused. This function cannot be used to initiate interrupt operations because it does not set up the board or the driver to handle interrupts.
Input parameters:
None
This function operates as follows:
Set page = 7
Set ADINTEN = 1, retain other bits in register 0
Set page = 0
Read ADCLK1-0 in register 5
Set ADCLKEN bit = 1
Rewrite register 5
If counter/timer 0 or 1 is selected, then:
Start counter/timer using SATURNCounterFunction(): CtrNo = 0 or 1, CtrCmd = 0100, CCD0 = 1
Set page = 0
Exit
BYTE SATURNADIntCancel(BoardInfo* bi);
Last updated
Was this helpful?