I spent one whole day today working on the programming code. I got the “easy” part done. The challenging part, however, did seem a bit too much for me. Additionally, unpredictable gaps between successive sweeps are not desirable in the small project that I want to implement. So I probably shall change the way that the user interacts with the program. So, I will simply let the user press any key on the keyboard to initiate both the AO and AI tasks; the program will then deliver a stimulus signal via AO and record data via AI concurrently. When the user is satisfactory with the amount of data collected, the user can then press any key on the keyboard to stop the AI and AO tasks.
To implement this alternative approach, I have written another small program today. Please see my codes posted below.
In order to ensure that AI starts at sample 0 of AO, I created a Digital Edge Start Trigger and associated this trigger with AI task. Also, I make the buffer size the same length as the number of data points of the stimulus signal. So, both the AO and AI buffer sizes are 10000 data points now. Although this program ran through on my computer without showing any error message. I am unsure if everything has been setup correctly. Particularly, I am not sure if I have setup the Digital Edge Start Trigger properly. Also, I am not sure if the 10000 data points will be too much a burden for both the AO and AI buffers.
Because this is my first time trying to use C/C++ language to control a DAQ device, I don’t want to assume. Instead, I want to make sure that I did not make any silly mistakes and the program I wrote is legit. If anyone could go over the codes posted here and give me comments, I would greatly appreciate it.
Thank you!
#include <stdio.h>
#include <NIDAQmx.h> // DAQmx 9.3
#include <iostream> // std::cout, std::cin, std::endl
#define DAQmxErrChk(functionCall) if( DAQmxFailed(error=(functionCall)) ) goto Error; else
#define PI 3.141592653589793238
int32 CVICALLBACK EveryNCallback(TaskHandle taskHandleAI, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData);
const unsigned int N = 10000; // number of data points (This number refers to the number of data points per sweep, which include the stimulus duration and silent interval data points)
const unsigned int BUFFER_SIZE = N; // buffer size in data points, [default 1000]. In this special case, I purposely make the BUFFER_SIAZE equals N so that a recording of one buffer is worth one sweep of data. The buffer size is kind of huge, though.
int main(void)
{
// prepare a sine wave that will be delivered via an AO channel
double frequency = 100; // frequency in Hz
double amplitude = 1.0; // baseline-to-peak amplitude of a sine wave (roughly in volts). Should be between +- 10 volts.
double samplingRateWav = 40000.0; // sampling rate of the sine wave
float64 stimulus[N]; // stores N data points of float64
for(int i = 0; i < N; i++) // generate a sine wave with N data points
stimulus[i] = amplitude * sin(2.0 * PI * frequency * (double)(i) / samplingRateWav);
// declare and initialize an error code and error buffer. This will be used for both the AO and AI tasks
int32 error = 0;
char errBuff[2048] = {'\0'};
// create and initialize AO and AI task handles
TaskHandle taskHandleAO = 0;
TaskHandle taskHandleAI = 0;
/* --- Step 1 Create AO and AI tasks --- */
DAQmxErrChk(DAQmxCreateTask("taskAO", &taskHandleAO));
DAQmxErrChk(DAQmxCreateTask("taskAI", &taskHandleAI));
/* --- Step 2 Create and configure an Analog Output Voltage channel and an Analog Input Voltage channel --- */
DAQmxErrChk(DAQmxCreateAOVoltageChan(taskHandleAO, "Dev1/ao0", "", -10.0, 10.0, DAQmx_Val_Volts, NULL));
DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandleAI, "Dev1/ai0", "", DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL));
/* --- Step 3 Define sampling rate and related parameters for the AO task and the AI task ---*/
DAQmxErrChk(DAQmxCfgSampClkTiming(taskHandleAO, "", 40000.0, DAQmx_Val_Rising, DAQmx_Val_ContSamps, N));
DAQmxErrChk(DAQmxCfgSampClkTiming(taskHandleAI, "", 20000.0, DAQmx_Val_Rising, DAQmx_Val_ContSamps, BUFFER_SIZE));
/* --- Step 4 setup a Digital Edge, Start Trigger --- */
DAQmxErrChk(DAQmxCfgDigEdgeStartTrig(taskHandleAO, "/Dev1/ai/StartTrigger", DAQmx_Val_Rising));
/* --- Step 5 setup parameters for AI buffer ---*/
DAQmxErrChk(DAQmxRegisterEveryNSamplesEvent(taskHandleAI, DAQmx_Val_Acquired_Into_Buffer, BUFFER_SIZE, 0, EveryNCallback, NULL));
/* ---- Step 6 write signal via AO ---- */
DAQmxErrChk (DAQmxWriteAnalogF64(taskHandleAO, N, 0, 10.0, DAQmx_Val_GroupByChannel, stimulus, NULL, NULL));
/* ---- Step 7 User press any key to start AO and AI tasks ----*/
std::cout << "Press any key to start AO and AI tasks";
getchar();
DAQmxErrChk (DAQmxStartTask(taskHandleAO));
std::cout<< "Generating voltage continuously..." << std::endl;
DAQmxErrChk (DAQmxStartTask(taskHandleAI));
/* --- Step 8 read data via AI ----*/
// This step is executed through the EveryNCallback() function ---
/*--- Step 9 User press any key to stop the AO and AI tasks --- */
std::cout << "Press any key to stop AO and AI tasks " << std::endl;
getchar();
DAQmxErrChk(DAQmxStopTask(taskHandleAO));
DAQmxErrChk(DAQmxStopTask(taskHandleAI));
/* --- Step 10 clear AI and AO tasks --- */
DAQmxErrChk(DAQmxClearTask(taskHandleAO));
DAQmxErrChk(DAQmxClearTask(taskHandleAI));
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff, 2048);
if( taskHandleAI!=0 ) {
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask(taskHandleAI);
DAQmxClearTask(taskHandleAI);
}
if( DAQmxFailed(error) )
printf("DAQmx Error: %s\n", errBuff);
std::cout << "End of program, press Enter key to quit" << std::endl;
getchar();
return 0;
}
int32 CVICALLBACK EveryNCallback(TaskHandle taskHandleAI, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData)
{
int32 error = 0;
char errBuff[2048] = {'\0'};
static int totalRead = 0;
int32 read = 0;
float64 data[BUFFER_SIZE]; // N
/*********************************************/
// DAQmx Read Code
/*********************************************/
DAQmxErrChk(DAQmxReadAnalogF64(taskHandleAI, BUFFER_SIZE, 10.0, DAQmx_Val_GroupByScanNumber, data, BUFFER_SIZE, &read, NULL)); // N, N
if( read > 0 )
{
printf("Acquired %d samples. Total %d\r", read, totalRead += read);
fflush(stdout);
}
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff, 2048);
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask(taskHandleAI);
DAQmxClearTask(taskHandleAI);
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
