double QxrdNIDAQPlugin::getAnalogInput(int chan)
{
QMutexLocker lock(&m_Mutex);
int error;
float64 res = 0;
if (m_AITaskHandle) {
DAQmxStopTask(m_AITaskHandle);
DAQmxClearTask(m_AITaskHandle);
m_AITaskHandle = 0;
}
if (chan >= 0) {
DAQmxErrChk(DAQmxCreateTask("qxrd-input", &m_AITaskHandle));
DAQmxErrChk(DAQmxCreateAIVoltageChan (m_AITaskHandle,
qPrintable(tr("Dev1/ai%1").arg(chan)), NULL, DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL));
if (m_AITaskHandle) {
DAQmxErrChk(DAQmxReadAnalogScalarF64(m_AITaskHandle, 10.0, &res, NULL));
}
}
Error:
return res;
}
// constructor
Tweezers::Tweezers(double iF0,double id0,double ic1,double ic2,double ic3,double Anti_Voltage, void* lpParam)
{
threadinfo* t = (threadinfo*)lpParam;
// set calibration parameters
F0 = iF0;
d0 = id0;
c1 = ic1;
c2 = ic2;
c3 = ic3;
AV = Anti_Voltage;
x4 = *t->x4;
x3 = *t->x3;
x2 = *t->x2;
x1 = *t->x1;
x0 = *t->x0;
done = false;
islate = false;
residual = AV;
tmp_residual = AV;
trigdata[0][0] = 0;
trigdata[1][0] = 1;
// initialize device
DAQmxResetDevice("Dev1");
// create and setup analog task
DAQmxCreateTask("AO",&AOtaskHandle);
DAQmxCreateAOVoltageChan(AOtaskHandle,"Dev1/ao0","",-10.0,10.0,DAQmx_Val_Volts,NULL);
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
// create and reset start trigger
// implicit timing => no start task... (?)
DAQmxCreateTask("TR",&TRtaskHandle);
DAQmxCreateDOChan(TRtaskHandle,"Dev1/port0/line7","TR",DAQmx_Val_ChanForAllLines);
DAQmxWriteDigitalLines(TRtaskHandle,1,1,10,DAQmx_Val_GroupByChannel,trigdata[0],&written,NULL);
// create pulse channel for trigger
DAQmxCreateTask("DO",&DOtaskHandle);
DAQmxCreateCOPulseChanTime(DOtaskHandle,"Dev1/Ctr0","",DAQmx_Val_Seconds,DAQmx_Val_Low,1E-3*(*t->wait),1E-3*(*t->delta)/2.0,1E-3*(*t->delta/2.0));
DAQmxCreateTask("AI",&AItaskHandle);
DAQmxCreateAIVoltageChan(AItaskHandle,"Dev1/ai0,Dev1/ai2","",DAQmx_Val_RSE,-10,+10,DAQmx_Val_Volts,NULL);
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
// set to zero force
Reset();
}
DAQManager::DAQManager()
{
stateCount = 8;
states = new uInt32[stateCount];
states[0] = 0x8;
states[1] = 0xC;
states[2] = 0x4;
states[3] = 0x6;
states[4] = 0x2;
states[5] = 0x3;
states[6] = 0x1;
states[7] = 0x9;
stateNum = 0;
dataAcquired = 0;
voltageData = new float64[SAMPLE_COUNT];
#ifdef _WIN32
DAQmxCreateTask("", &motorTaskHandle);
DAQmxCreateTask("", &adcTaskHandle);
DAQmxCreateTask("", &triggerTaskHandle);
DAQmxCreateDOChan(motorTaskHandle, "Dev1/port0", "", DAQmx_Val_ChanForAllLines);
DAQmxCreateDOChan(triggerTaskHandle, "Dev1/port1", "", DAQmx_Val_ChanForAllLines);
DAQmxCreateAIVoltageChan(adcTaskHandle, "Dev1/ai0", "", DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL);
DAQmxCfgSampClkTiming(adcTaskHandle, "", SAMPLE_FREQ, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, SAMPLE_COUNT);
DAQmxCfgDigEdgeStartTrig(adcTaskHandle, "/Dev1/PFI0", DAQmx_Val_Rising);
DAQmxRegisterEveryNSamplesEvent(adcTaskHandle, DAQmx_Val_Acquired_Into_Buffer, 1000, 0, EveryNCallbackWrapper, this);
DAQmxStartTask(motorTaskHandle);
DAQmxStartTask(triggerTaskHandle);
uInt32 data;
int32 written;
data = states[0];
DAQmxWriteDigitalU32(motorTaskHandle, 1, 1, 10.0, DAQmx_Val_GroupByChannel, &data, &written, NULL);
data=0x0;
DAQmxWriteDigitalU32(triggerTaskHandle, 1, 1, 10.0, DAQmx_Val_GroupByChannel, &data, &written, NULL);
#elif __APPLE__
DAQmxBaseCreateTask("motorTask", &motorTaskHandle);
DAQmxBaseCreateDOChan(motorTaskHandle, "Dev1/port0", "", DAQmx_Val_ChanForAllLines);
DAQmxBaseStartTask(motorTaskHandle);
DAQmxBaseCreateTask("adcTask", &adcTaskHandle);
DAQmxBaseCreateAIVoltageChan(adcTaskHandle, "Dev1/ai0", "", DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL);
DAQmxBaseCfgSampClkTiming(adcTaskHandle,"OnboardClock", SAMPLE_FREQ, DAQmx_Val_Rising, DAQmx_Val_ContSamps, SAMPLE_COUNT);
DAQmxBaseCfgInputBuffer(adcTaskHandle,0);
DAQmxBaseStartTask(adcTaskHandle);
uInt32 data;
int32 written;
data = states[0];
DAQmxBaseWriteDigitalU32(motorTaskHandle, 1, 1, 10.0, DAQmx_Val_GroupByChannel, &data, &written, NULL);
#endif
}
int32 ATIDAQHardwareInterface::ConfigSingleSampleTask( float64 sampleRate,
int averaging,
const std::string & deviceName,
int firstChannel,
int numChannels,
int minVoltage,
int maxVoltage )
{
int32 retVal; /*the return value*/
/*we have to use unmanaged c-style strings in here because that's what the NI-DAQmx
C Library uses*/
char channelString[WHOLE_LOTTA_CHARACTERS]; /*the channel string, of format "Dev1/ai0:5"*/
/*set up member data*/
m_f64SamplingFrequency = sampleRate;
m_uiAveragingSize = ( averaging > 0 )? averaging : 1; /*averaging must be at least 1*/
m_sDeviceName = deviceName;
m_uiFirstChannel = firstChannel;
m_uiNumChannels = numChannels;
m_iMinVoltage = minVoltage;
m_iMaxVoltage = maxVoltage;
unsigned int numSamplesPerChannel = m_uiAveragingSize; /*the number of samples per channel that
daqmx is configured with*/
/*in a perfect world, NI-DAQmx would allow us to set up single scan acquisitions, but they don't.
even if we were to make the single sample task a finite sample task, they still require you to use
at least 2 samples per channel. Therefore, we pass daqmx a number of samples per channel that it
will accept, and then set up our task to only read the most recent samples*/
if ( MIN_SAMPLES_PER_CHANNEL > numSamplesPerChannel ) numSamplesPerChannel = MIN_SAMPLES_PER_CHANNEL;
ati_Channel_Name_Format( channelString, m_sDeviceName ); /* Format the channel name for niDAQmx */
/*if the following confuses you, I suggest you read the NI-DAQmx C Reference Help, included
with NI-DAQmx*/
StopCollection(); /*stop currently running task*/
/*if any function fails (returns non-zero), don't execute any more daqmx functions*/
/*create the daqmx task*/
if( !( retVal = DAQmxCreateTask( "", m_thDAQTask ) ) )
/*add the analog input channels to the task - july.22.2005 - ss - now uses m_iConnectionMode*/
if( !( retVal = DAQmxCreateAIVoltageChan( *m_thDAQTask, channelString, "", m_iConnectionMode,
m_iMinVoltage, m_iMaxVoltage, DAQmx_Val_Volts, NULL ) ) )
/*set up timing for the task*/
if( !( retVal = DAQmxCfgSampClkTiming( *m_thDAQTask, NULL, m_f64SamplingFrequency,
DAQmx_Val_Rising, DAQmx_Val_ContSamps, numSamplesPerChannel ) ) )
/*set read position relative to next sample to be read*/
if( !( retVal = DAQmxSetReadRelativeTo( *m_thDAQTask, DAQmx_Val_MostRecentSamp ) ) )
/*offset of -1 from the next sample, meaning we read the most recent sample*/
if( !( retVal = DAQmxSetReadOffset( *m_thDAQTask, 0 ) ) )
/*start the task*/
retVal = DAQmxStartTask( *m_thDAQTask );
return retVal;
}
// when I tried to set the channels from c#, first channel set fine, but second one gets error. no freaking idea, so hardcoded it.
//int EXPORT_API EOGSetChannel(const char *channel)
TaskHandle EXPORT_API EOGSetChannel()
{
int32 error = 0;
char errBuff[2048] = { '\0' };
/*********************************************/
// DAQmx Configure Code
/*********************************************/
DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, "Dev1/ai3", "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, "Dev1/ai4", "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
// DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, channel, "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
return taskHandle;
//return 1;
Error:
if (DAQmxFailed(error))
{
DAQmxGetExtendedErrorInfo(errBuff, 2048);
Cleanup();
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
int main(void)
{
int32 error=0;
TaskHandle taskHandle=0;
int32 read;
float64 data[1000];
char errBuff[2048]={'\0'};
int i;
/*********************************************/
// DAQmx Configure Code
/*********************************************/
DAQmxErrChk (DAQmxCreateTask("",&taskHandle));
DAQmxErrChk (DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0","",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(taskHandle,"",10000.0,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,1000));
/*********************************************/
// DAQmx Start Code
/*********************************************/
DAQmxErrChk (DAQmxStartTask(taskHandle));
/*********************************************/
// DAQmx Read Code
/*********************************************/
DAQmxErrChk (DAQmxReadAnalogF64(taskHandle,1000,10.0,DAQmx_Val_GroupByChannel,data,1000,&read,NULL));
printf("Acquired %d points\n",read);
for (i = 0; i < 1000; i++) {
printf ("data[%d] = %f\n", i, data[i]);
}
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
if( taskHandle!=0 ) {
/*********************************************/
// DAQmx Stop Code
/*********************************************/
DAQmxStopTask(taskHandle);
DAQmxClearTask(taskHandle);
}
if( DAQmxFailed(error) )
printf("DAQmx Error: %s\n",errBuff);
printf("End of program, press Enter key to quit\n");
getchar();
return 0;
}
BOOL CForceChartDlg::DAQ(CString changeDeviceName, short changeFirstChannel)
{
TaskHandle taskHandle = 0;
int32 read;
CString cstrChannelList;
cstrChannelList.Format( _T("/ai%d"), changeFirstChannel );
DAQmxCreateTask("AAencoderTask", &taskHandle);
DAQmxCreateAIVoltageChan(taskHandle, changeDeviceName+cstrChannelList, "AAencoderChannel", DAQmx_Val_RSE, 0, 5, DAQmx_Val_Volts, NULL);
//UpdateData(TRUE);
DAQmxCfgSampClkTiming(taskHandle, "OnboardClock", 100, DAQmx_Val_Rising, DAQmx_Val_ContSamps, 20);
//UpdateData(TRUE);
DAQmxStartTask(taskHandle);
DAQmxReadAnalogF64(taskHandle, 10, 0.2, DAQmx_Val_GroupByChannel, G0, 10, &read, NULL);
DAQmxStopTask(taskHandle);
DAQmxClearTask(taskHandle);
return TRUE;
}
/******************************************************************************
**
** Démarage de la tache d'acquisition sur la voie passé en paramètre.
**
******************************************************************************/
int NI6211::startAquisition(char* _Voie)
{
int32 error=0;
taskRead = new TaskHandle;
/*------ DAQmx Configure Code Reading Task ------*/
DAQmxErrChk (DAQmxCreateTask("",taskRead));
DAQmxErrChk (DAQmxCreateAIVoltageChan(*taskRead,_Voie,"",DAQmx_Val_Diff,-0.2,0.2,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(*taskRead,_VoieO,"",DAQmx_Val_Diff,-0.2,0.2,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(*taskRead,"/Equilibreuse/PFI0",1000,DAQmx_Val_Rising,DAQmx_Val_ContSamps,1000));
DAQmxErrChk (DAQmxCfgDigEdgeStartTrig(*taskRead,"/Equilibreuse/PFI2",DAQmx_Val_Rising));
/*------ DAQmx Start Code ------*/
DAQmxErrChk (DAQmxStartTask(*taskRead));
Erreur:
checkError(error);
return error;
}
int NiPci6220Config()
{
int32 error = 0;
char errBuff[2048];
daq6220pvt.sampsPerChan = (uInt64)((daq6220pvt.t1 - daq6220pvt.t0) * daq6220pvt.rate);
epicsPrintf("**** Initialize Task 6220 ****\n");
epicsPrintf("**** 6220 : sampsPerChan = %d****\n", daq6220pvt.sampsPerChan);
DAQmxErrChk(DAQmxCreateTask("", &daq6220pvt.taskHandle));
DAQmxErrChk(DAQmxCreateAIVoltageChan(daq6220pvt.taskHandle, "Dev3/ai0:15","", daq6220pvt.terminalConfig, -10.0, 10.0, DAQmx_Val_Volts, NULL));
if(daq6220pvt.extMode == 1) {
DAQmxErrChk(DAQmxCfgSampClkTiming(daq6220pvt.taskHandle, "/Dev3/PFI7", daq6220pvt.rate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, daq6220pvt.sampsPerChan));
}
else {
DAQmxErrChk(DAQmxCfgSampClkTiming(daq6220pvt.taskHandle, "", daq6220pvt.rate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, daq6220pvt.sampsPerChan));
}
if(daq6220pvt.trigMode == 1) {
DAQmxErrChk (DAQmxCfgDigEdgeStartTrig(daq6220pvt.taskHandle,"/Dev3/PFI0",DAQmx_Val_Rising));
DAQmxErrChk (DAQmxRegisterEveryNSamplesEvent(daq6220pvt.taskHandle,DAQmx_Val_Acquired_Into_Buffer,daq6220pvt.sampsPerChan,0,EveryNCallback,NULL));
DAQmxErrChk (DAQmxRegisterDoneEvent(daq6220pvt.taskHandle,0,DoneCallback,NULL));
}
return 0;
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
if( daq6220pvt.taskHandle!=0 ) {
DAQmxStopTask(daq6220pvt.taskHandle);
DAQmxClearTask(daq6220pvt.taskHandle);
}
if( DAQmxFailed(error) )
epicsPrintf("DAQmx Error(6220): %s\n",errBuff);
return -1;
}
//Gateway routine
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
TaskHandle task,task2;
float64 sampleRate = 100000;
float64 acqTime = 5;
uInt64 numSamples = (uInt64) sampleRate * acqTime;
char chanName[128];
int32 sampsWritten;
//Create the task
DAQmxCreateTask("",&task);
DAQmxCreateTask("",&task2);
//Add AI channels to task
DAQmxCreateAIVoltageChan(task, "Dev1/ai0:2", "ScanImageAcq", -1, -1, 1, DAQmx_Val_Volts, NULL);
DAQmxCreateAOVoltageChan(task2, "Dev1/ao0:2", "ScanImageControl", -1, 1, DAQmx_Val_Volts, NULL);
//Configure task timing
DAQmxCfgSampClkTiming(task, NULL, 100000, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, numSamples);
DAQmxCfgSampClkTiming(task2, NULL, 100000, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, numSamples);
//Configure some task properties
for (int i=0; i<2; i++)
{
sprintf_s(chanName, "Dev1/ai%d", i);
DAQmxSetAIMax(task, chanName, 10);
DAQmxSetAIMax(task, chanName, -10);
}
//Write some data
DAQmxWriteAnalogF64(task, (int32) numSamples, false, -1, DAQmx_Val_GroupByChannel, outputData, &sampsWritten, NULL);
//Screw it
DAQmxClearTask(task);
}
int32 ATIDAQHardwareInterface::ConfigBufferTask( float64 sampleRate, int averaging,const std::string &deviceName, int firstChannel,
int numChannels, int minVoltage, int maxVoltage, int bufferSize )
{
int32 retVal; /*the return value*/
/*we have to use unmanaged c-style strings in here because that's what the NI-DAQmx
C Library uses*/
char channelString[1024]; /*the channel string, of format "Dev1/ai0:5"*/
/*set up member data*/
m_f64SamplingFrequency = sampleRate;
m_uiAveragingSize = ( averaging > 0 )? averaging : 1; /*averaging must be at least 1*/
m_sDeviceName = deviceName;
m_uiFirstChannel = firstChannel;
m_uiNumChannels = numChannels;
m_iMinVoltage = minVoltage;
m_iMaxVoltage = maxVoltage;
m_ulBufferedSize = bufferSize;
unsigned int numSamplesPerChannel = m_uiAveragingSize * m_ulBufferedSize; /*the number of samples per channel that
daqmx is configured with*/
/*NI-DAQmx requires a minimum number of samples per channel*/
if ( MIN_SAMPLES_PER_CHANNEL > numSamplesPerChannel ) numSamplesPerChannel = MIN_SAMPLES_PER_CHANNEL;
ati_Channel_Name_Format( channelString, m_sDeviceName ); /* Format the channel name for niDAQmx */
/*if the following confuses you, I suggest you read the NI-DAQmx C Reference Help, included
with NI-DAQmx*/
StopCollection(); /*stop any currently running task*/
/*if any function fails (returns non-zero), don't execute any more daqmx functions*/
/*create the daqmx task*/
if( !( retVal = DAQmxCreateTask( "", m_thDAQTask ) ) )
/*add the analog input channels to the task - july.22.2005 - ss - now uses m_iConnectionMode*/
if( !( retVal = DAQmxCreateAIVoltageChan( *m_thDAQTask, channelString, "", m_iConnectionMode,
m_iMinVoltage, m_iMaxVoltage, DAQmx_Val_Volts, NULL ) ) )
/*set up timing for the task*/
if( !( retVal = DAQmxCfgSampClkTiming( *m_thDAQTask, NULL, m_f64SamplingFrequency,
DAQmx_Val_Rising, DAQmx_Val_ContSamps, numSamplesPerChannel ) ) )
/*start the task*/
retVal = DAQmxStartTask( *m_thDAQTask );
return retVal;
}
int start_daq (void)
{
int32 error=0;
char errBuff[2048]={'\0'};
char str1[256],str2[256],trigName[256];
char devName[256];
float64 clkRate;
int i;
for (i = 0; i < DEV_NUM; i++) {
sprintf (devName, "Dev%d/ai0", i+1);
DAQmxErrChk2 ("CreateTask", DAQmxCreateTask("",&gTaskHandle[i]));
DAQmxErrChk2 ("CreateAIVoltageChan" , DAQmxCreateAIVoltageChan(gTaskHandle[i],devName,"",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk2 ("CfgSampClkTiming", DAQmxCfgSampClkTiming(gTaskHandle[i],"",10000.0,DAQmx_Val_Rising,DAQmx_Val_ContSamps,1000));
DAQmxErrChk2 ("CfgDigEdgeStartTrig", DAQmxCfgDigEdgeStartTrig(gTaskHandle[i],TRIG_NAME,DAQmx_Val_Rising));
DAQmxErrChk2 ("RegisterEveryNSamplesEvent", DAQmxRegisterEveryNSamplesEvent(gTaskHandle[i],DAQmx_Val_Acquired_Into_Buffer,1000,0,EveryNCallback,NULL));
DAQmxErrChk2 ("RegisterDoneEvent", DAQmxRegisterDoneEvent(gTaskHandle[i],0,DoneCallback,NULL));
printf ("Dev(%s) : Task(%u) was created \n", devName, gTaskHandle[i]);
}
for (i = 0; i < DEV_NUM; i++) {
gReadTotal[i] = 0;
printf ("start task%d(%u) ...\n", i+1, gTaskHandle[i]);
DAQmxErrChk2 ("StartTask", DAQmxStartTask(gTaskHandle[i]));
}
printf("Acquiring samples continuously. Press Enter to interrupt\n");
printf("\nHandle:\tTotal:\tDev1\tDev2\tDev3\n");
getchar();
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
/*********************************************/
// DAQmx Stop Code
/*********************************************/
for (i = 0; i < DEV_NUM; i++) {
if( gTaskHandle[i] ) {
printf ("stop task%d (%u) ...\n", i+1, gTaskHandle[i]);
DAQmxStopTask(gTaskHandle[i]);
DAQmxClearTask(gTaskHandle[i]);
gTaskHandle[i] = 0;
}
}
if( DAQmxFailed(error) ) {
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
printf("End of program. Press enter to restart ... \n");
getchar();
return 0;
}
motorControl::motorControl(double offset1, double offset2)
{
encoderBias[0] = encoderBias[1] = 0;
encoderGain[0] = encoderGain[1] = 0;
I = 4;
cortexVoluntaryAmp = 10000;
cortexVoluntaryFreq = 0.25;
char errBuff[2048]={'\0'};
int32 error=0;
angle = 0;
velocity = 0;
trialTrigger = 0;
gammaStatic1 = 0;
gammaDynamic1 = 0;
gammaStatic2 = 0;
gammaDynamic2 = 0;
cortexDrive[0] = 0;
cortexDrive[1] = 0;
spindleIa[0] = 0;
spindleII[0] = 0;
spindleIa[1] = 0;
spindleII[1] = 0;
isEnable = FALSE;
isWindUp = FALSE;
isControlling = FALSE;
live = FALSE;
loadCellOffset1 = offset1;
loadCellOffset2 = offset2;
loadCellData[0] = 0;
loadCellData[1] = 0;
motorRef[0] = 4;
motorRef[1] = 4;
encoderData1[0] = 0;
encoderData2[0] = 0;
resetMuscleLength = TRUE;
muscleLengthPreviousTick[0] = 1;
muscleLengthPreviousTick[1] = 1;
muscleLengthOffset [0] = 0;
muscleLengthOffset [1] = 0;
strcpy(header,"Time, Exp Prot, Len1, Len2, ForcMeas1, ForcMeas2,");
if (dataAcquisitionFlag[0]){
strcat (header, ", ForceDes1, ForceDes2");
}
if (dataAcquisitionFlag[1]){
strcat (header, ", EMG1, EMG2");
}
if (dataAcquisitionFlag[2]){
strcat (header, ", Ia1, Ia2");
}
if (dataAcquisitionFlag[3]){
strcat (header, ", II1, II2");
}
if (dataAcquisitionFlag[4]){
strcat (header, ", Spike Count1, Spike Count2");
}
if (dataAcquisitionFlag[5]){
strcat (header, ", Raster 1-1, Raster 2-1");
}
if (dataAcquisitionFlag[6]){
strcat (header, ", Raster 1-2, Raster 2-2");
}
if (dataAcquisitionFlag[7]){
strcat (header, ", Raster 1-3, Raster 2-3");
}
if (dataAcquisitionFlag[8]){
strcat (header, ", Raster 1-4, Raster 2-4");
}
if (dataAcquisitionFlag[9]){
strcat (header, ", Raster 1-5, Raster 2-5");
}
if (dataAcquisitionFlag[10]){
strcat (header, ", Raster 1-6, Raster 2-6");
}
char dataTemp[100]="";
strcat(header,"\n");
sprintf(dataTemp,"%d,%d,%d,%d,",dataAcquisitionFlag[0],dataAcquisitionFlag[1],dataAcquisitionFlag[2],dataAcquisitionFlag[3]);
strcat(header,dataTemp);
sprintf(dataTemp,"%d,%d,%d,%d,",dataAcquisitionFlag[4],dataAcquisitionFlag[5],dataAcquisitionFlag[6],dataAcquisitionFlag[7]);
strcat(header,dataTemp);
sprintf(dataTemp,"%d,%d,%d,%d\n",dataAcquisitionFlag[8],dataAcquisitionFlag[9],dataAcquisitionFlag[10],dataAcquisitionFlag[11]);
strcat(header,dataTemp);
DAQmxErrChk (DAQmxCreateTask("",&loadCelltaskHandle));
DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai8","loadCell1",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai9","loadCell2",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai16","ACC z",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai17","ACC y",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai18","ACC x",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai19","Side LoadCell1",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
//DAQmxErrChk (DAQmxCreateAIVoltageChan(loadCelltaskHandle,"PXI1Slot5/ai20","Side LoadCell2",DAQmx_Val_RSE,loadCellMinVoltage,loadCellMaxVoltage,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(loadCelltaskHandle,"",controlFreq,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,NULL));
DAQmxErrChk (DAQmxSetRealTimeConvLateErrorsToWarnings(loadCelltaskHandle,1));
DAQmxErrChk (DAQmxCreateTask("",&motorTaskHandle));
DAQmxErrChk (DAQmxCreateAOVoltageChan(motorTaskHandle,"PXI1Slot2/ao9","motor1",motorMinVoltage,motorMaxVoltage,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCreateAOVoltageChan(motorTaskHandle,"PXI1Slot2/ao11","motor2",motorMinVoltage,motorMaxVoltage,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCreateAOVoltageChan(motorTaskHandle,"PXI1Slot2/ao31","speaker",motorMinVoltage,motorMaxVoltage,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(motorTaskHandle,"",controlFreq,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,1));
DAQmxErrChk (DAQmxCreateTask("",&motorEnableHandle));
DAQmxErrChk (DAQmxCreateDOChan(motorEnableHandle,"PXI1Slot2/port0","motorEnable",DAQmx_Val_ChanForAllLines));
DAQmxErrChk (DAQmxCreateTask("",&encodertaskHandle[0]));
DAQmxErrChk (DAQmxCreateCIAngEncoderChan(encodertaskHandle[0],"PXI1Slot3/ctr7","Enoder 1",DAQmx_Val_X4,0,0.0,DAQmx_Val_AHighBHigh,DAQmx_Val_Degrees,encoderPulsesPerRev,0.0,""));
DAQmxErrChk (DAQmxCfgSampClkTiming(encodertaskHandle[0],"/PXI1Slot5/ai/SampleClock",controlFreq,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,1));
DAQmxErrChk (DAQmxCreateTask("",&encodertaskHandle[1]));
DAQmxErrChk (DAQmxCreateCIAngEncoderChan(encodertaskHandle[1],"PXI1Slot3/ctr3","Enoder 2",DAQmx_Val_X4,0,0.0,DAQmx_Val_AHighBHigh,DAQmx_Val_Degrees,encoderPulsesPerRev,0.0,""));
DAQmxErrChk (DAQmxCfgSampClkTiming(encodertaskHandle[1],"/PXI1Slot5/ai/SampleClock",controlFreq,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,1));
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
DAQmxClearTask(motorTaskHandle);
DAQmxClearTask(loadCelltaskHandle);
DAQmxClearTask(motorEnableHandle);
printf("DAQmx Error: %s\n",errBuff);
printf("Motor, load cell or encoder initialization error\n");
}
}
int start_daq (void)
{
int32 error=0;
char errBuff[2048]={'\0'};
int i;
for (i = 0; i < getNumOfDev(); i++) {
printf ("\n------------------------------------------------------------\n");
printf ("Create Task for Dev(%s)\n", gTaskInfoList[i].devName);
DAQmxErrChk2 ("CreateTask", DAQmxCreateTask("",&gTaskInfoList[i].nTaskHandle));
DAQmxErrChk2 ("CreateAIVoltageChan" , DAQmxCreateAIVoltageChan(gTaskInfoList[i].nTaskHandle,
gTaskInfoList[i].chName,"",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk2 ("CfgSampClkTiming", DAQmxCfgSampClkTiming(gTaskInfoList[i].nTaskHandle,"",10000.0,DAQmx_Val_Rising,DAQmx_Val_ContSamps,1000));
//DAQmxErrChk2 ("SetRefClkSrc", DAQmxSetRefClkSrc(gTaskInfoList[i].nTaskHandle,"PXI_Clk1"));
//DAQmxErrChk2 ("SetRefClkRate", DAQmxSetRefClkRate(gTaskInfoList[i].nTaskHandle,10000000.0));
DAQmxErrChk2 ("CfgDigEdgeStartTrig", DAQmxCfgDigEdgeStartTrig(gTaskInfoList[i].nTaskHandle,gTaskInfoList[i].trigName,DAQmx_Val_Rising));
DAQmxErrChk2 ("RegisterEveryNSamplesEvent", DAQmxRegisterEveryNSamplesEvent(gTaskInfoList[i].nTaskHandle,DAQmx_Val_Acquired_Into_Buffer,1000,0,EveryNCallback,NULL));
DAQmxErrChk2 ("RegisterDoneEvent", DAQmxRegisterDoneEvent(gTaskInfoList[i].nTaskHandle,0,DoneCallback,NULL));
printf ("Dev(%s) : Task(%u) was created \n", gTaskInfoList[i].devName, gTaskInfoList[i].nTaskHandle);
}
printf ("\n------------------------------------------------------------\n");
for (i = 0; i < getNumOfDev(); i++) {
gTaskInfoList[i].nReadTotal = 0;
DAQmxErrChk2 ("StartTask", DAQmxStartTask(gTaskInfoList[i].nTaskHandle));
}
printf ("\n------------------------------------------------------------\n");
printf("Acquiring samples continuously. Press Enter to interrupt\n");
printf("\nHandle:\tTotal:\tDev1\tDev2\tDev3\n");
getchar();
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
/*********************************************/
// DAQmx Stop Code
/*********************************************/
for (i = 0; i < getNumOfDev(); i++) {
if( gTaskInfoList[i].nTaskHandle ) {
printf ("stop task%d (%u) ...\n", i+1, gTaskInfoList[i].nTaskHandle);
DAQmxStopTask(gTaskInfoList[i].nTaskHandle);
DAQmxClearTask(gTaskInfoList[i].nTaskHandle);
gTaskInfoList[i].nTaskHandle = 0;
}
}
if( DAQmxFailed(error) ) {
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
printf("End of program. Press enter to restart ... \n");
getchar();
return 0;
}
int main(int argc, char *argv[]){
int sampletime = 1; // in s
int numSamples;
int32 error = 0;
TaskHandle taskHandle = 0;
int32 read;
float64 *data;
char filename[2048] = {'\0'};
char errBuff[2048] = {'\0'};
int recording = 1;
float64 state = -10; // used to detect edge
FILE *pFile; // file id for output twophoton times file
if(argc<2){
customerror("Not enough arguments given.");
}
sampletime = atoi( argv[1]);
if(sampletime<1){
customerror("Sampletime given is incorrect.");
}
strncpy(filename,argv[2],2048);
// calculate number of samples needed
numSamples = sampletime *(int) (SAMPLE_FREQUENCY+1);
// allocating buffer
data = (float64*)malloc( numSamples *sizeof( float64 ));
// open file
pFile = fopen(filename,"w");
if (pFile==NULL){
customerror("Failed to open %s", filename);
}
/*
char curdir[FILENAME_MAX];
memset(curdir, 0, sizeof(curdir));
if (!GetCurrentDir(curdir, sizeof(curdir))) {
customerror("Couldn't get current directory!");
}
printf("Current directory: %s\n", curdir);
*/
printf("Filename: %s\n", filename);
// DAQmx Configure Code
printf("DAQmx Configure Code\n");
DAQmxErrChk (DAQmxCreateTask("",&taskHandle));
DAQmxErrChk (DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0","",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(taskHandle,"",SAMPLE_FREQUENCY,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,numSamples));
//DAQmxErrChk (DAQmxCfgDigEdgeStartTrig(taskHandle,"/Dev1/PFI0",DAQmx_Val_Rising));
//DAQmxErrChk (DAQmxCfgDigEdgeRefTrig(taskHandle,"/Dev1/PFI0",DAQmx_Val_Rising,100));
// DAQmx Start Code
printf("DAQmx Start Code\n");
DAQmxErrChk (DAQmxStartTask(taskHandle));
printf("Acquiring for %d seconds a total of %d samples at %f Hz\n", sampletime, numSamples, SAMPLE_FREQUENCY);
// DAQmx Read Code
printf("DAQmx Read Code\n");
DAQmxErrChk (DAQmxReadAnalogF64(taskHandle,-1,sampletime+1,0,data,numSamples,&read,NULL));
printf("read = %d\n",read);
parse_times(data, read, &state, pFile);
if( read<numSamples ){
customerror("Error occurred. Acquired fewer than the requested number of samples. ");
}
printf("Acquired %d points\n",read);
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
if( taskHandle!=0 ) {
// DAQmx Stop Code
DAQmxStopTask(taskHandle);
DAQmxClearTask(taskHandle);
}
if( DAQmxFailed(error) )
printf("DAQmx Error: %s\n",errBuff);
free(data);
fclose(pFile);
//printf("End of program, press Enter key to quit\n");
//getchar();
return 0;
}
// from ConfigDAQmxTasks(float xVolts, float yVolts, ScanStructure scanStructure);
int LifetimeAcq::configDAQmxTasks(float xVolts, float yVolts, ScanEngine* scanStruct)
{
int error;
int retVal;
char errBuff[2048];
double voltagePair[2];
//extern Trig_Channel;
voltagePair[0] = (double)xVolts;
voltagePair[1] = (double)yVolts;
//_____DAQmx Configure Code________________________________________________________________
//_____Setup analog output task_____
DAQmxErrChk (DAQmxCreateTask("AnalogOuput",&aoTaskHandle));
DAQmxErrChk (DAQmxCreateAOVoltageChan (aoTaskHandle, scanStruct->getXChan(), "xChan",
-2.0, 2.0, DAQmx_Val_Volts, NULL));
DAQmxErrChk (DAQmxCreateAOVoltageChan (aoTaskHandle, scanStruct->getYChan(), "yChan",
-2.0, 2.0, DAQmx_Val_Volts, NULL));
DAQmxErrChk (DAQmxWriteAnalogF64 (aoTaskHandle, 1, 1, 10, DAQmx_Val_GroupByChannel,
voltagePair, DAQmx_Val_GroupByChannel, NULL));
//_____Setup Analog input task_____
DAQmxErrChk (DAQmxCreateTask("TrigAcq",&acqTaskHandle));
/*Add analog input channel to acqtask*/
DAQmxErrChk (DAQmxCreateAIVoltageChan(acqTaskHandle, ACQ_CHANNEL, "PMT",
DAQmx_Val_RSE,ACQMIN, ACQMAX, DAQmx_Val_Volts,NULL));
/*config analog input to use counter output as sample clock and continuous samps*/
DAQmxErrChk (DAQmxCfgSampClkTiming (acqTaskHandle, SAMPCLK_CHANNEL, SAMP_RATE,
DAQmx_Val_Rising, DAQmx_Val_ContSamps, totSamps));
/*Make buffer size slightly larger than default*/
DAQmxErrChk (DAQmxSetBufferAttribute (acqTaskHandle, DAQmx_Buf_Input_BufSize, totSamps+1000));
//_____Setup counter task_____
DAQmxErrChk (DAQmxCreateTask ("couterOutTask", &ctrTaskHandle));
/*Add counter clock to counter task*/
DAQmxErrChk (DAQmxCreateCOPulseChanFreq (ctrTaskHandle, COUNTER_CHANNEL, "coChannel",
DAQmx_Val_Hz,DAQmx_Val_Low, 0, SAMP_RATE, 0.5));
/*config clock for counter output task to generate correct numSamps*/
DAQmxErrChk (DAQmxCfgImplicitTiming (ctrTaskHandle, DAQmx_Val_FiniteSamps, numSamps));
/*Config triggering of counter task*/
DAQmxErrChk (DAQmxCfgDigEdgeStartTrig (ctrTaskHandle, TRIG_CHANNEL, DAQmx_Val_Rising));
DAQmxErrChk (DAQmxSetTrigAttribute (ctrTaskHandle, DAQmx_StartTrig_Retriggerable, TRUE));
return 1;
Error:
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
retVal = this->stopTasks();
//if( DAQmxFailed(error) )
// MessagePopup("DAQmx Error",errBuff);
return 0;
}
