// from ScanEngineConfigDAQmxTask(ScanStruct& scanEngine, bool bTriggered, bool bContinuous);
int ScanEngine::configDAQmxTask(bool bTriggered, bool bContinuous)
{
int error;
//extern Trig_Channel;
//_____DAQmx Configure Code________________________________________________________________
if (!scanTaskHandle)
DAQmxErrChk (DAQmxCreateTask("Scan",&(scanTaskHandle)));
DAQmxErrChk (DAQmxCreateAOVoltageChan(scanTaskHandle,xChan,"",xMinVOScan,xMaxVOScan,DAQmx_Val_Volts, NULL));
DAQmxErrChk (DAQmxCreateAOVoltageChan(scanTaskHandle,yChan,"",yMinVOScan,yMaxVOScan, DAQmx_Val_Volts, NULL));
if(!bParkBeam)
{
if (bContinuous)
{
if (bLineScan)
DAQmxErrChk (DAQmxCfgSampClkTiming(scanTaskHandle,"/Dev1/PFI13",Samp_Rate, DAQmx_Val_Rising,DAQmx_Val_ContSamps,numSampsPerFrame_LS))
else
DAQmxErrChk (DAQmxCfgSampClkTiming(scanTaskHandle,"/Dev1/PFI13",Samp_Rate, DAQmx_Val_Rising,DAQmx_Val_ContSamps,numSampsPerFrame));
}
else
{
if (bLineScan)
DAQmxErrChk (DAQmxCfgSampClkTiming(scanTaskHandle,"/Dev1/PFI13",Samp_Rate, DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,numSampsTotal_LS))
else
DAQmxErrChk (DAQmxCfgSampClkTiming(scanTaskHandle,"/Dev1/PFI13",Samp_Rate, DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,numSampsTotal));
}
if (bTrigger)
{
//DAQmxErrChk (DAQmxCfgAnlgEdgeStartTrig (scanTaskHandle, trigChan, DAQmx_Val_RisingSlope , 2.0));
DAQmxErrChk (DAQmxCfgDigEdgeStartTrig(scanTaskHandle, trigChan, DAQmx_Val_Rising));
}
}
int microStep(int in)
{
uInt8 MS1Sig[2];
uInt8 MS2Sig[2];
// Pull to zero for active in current controller mode
switch (in){
case 1 : // no mirostep
MS1Sig[0] = 0; MS1Sig[1] = 0;
MS2Sig[0] = 0; MS2Sig[1] = 0;
break;
case 2 : // half step
MS1Sig[0] = 1; MS1Sig[1] = 1;
MS2Sig[0] = 0; MS2Sig[1] = 0;
break;
case 4: // quarter step
MS1Sig[0] = 0; MS1Sig[1] = 0;
MS2Sig[0] = 1; MS2Sig[1] = 1;
break;
case 8: // eighth step
MS1Sig[0] = 1; MS1Sig[1] = 1;
MS2Sig[0] = 1; MS2Sig[1] = 1;
break;
default :
return -1;
}
TaskHandle microStep = 0;
DAQmxCreateTask("MS1", µStep);
DAQmxCreateDOChan(microStep, "Dev1/port0/line6", "MS1", DAQmx_Val_ChanForAllLines); // MS1
DAQmxCfgSampClkTiming(microStep, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
DAQmxWriteDigitalLines(microStep, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, MS1Sig, NULL, NULL); // MS1 out
DAQmxStartTask(microStep);
DAQmxWaitUntilTaskDone(microStep, 1.0); // Wait for action to be completed
DAQmxStopTask(microStep);
DAQmxClearTask(microStep);
microStep = 0;
DAQmxCreateTask("MS2", µStep);
DAQmxCreateDOChan(microStep, "Dev1/port0/line7", "MS2", DAQmx_Val_ChanForAllLines); // MS1
DAQmxCfgSampClkTiming(microStep, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
DAQmxWriteDigitalLines(microStep, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, MS2Sig, NULL, NULL); // MS1 out
DAQmxStartTask(microStep);
DAQmxWaitUntilTaskDone(microStep, 1.0); // Wait for action to be completed
DAQmxStopTask(microStep);
DAQmxClearTask(microStep);
return 0;
}
int32 Tweezers::CurrentRun(float64* curr, float64* indata, void* lpParam)
{
threadinfo* t = (threadinfo*)lpParam;
// config and start analog tast
DAQmxErrRtn(DAQmxCfgSampClkTiming(AOtaskHandle,"",10*float64(1/(*t->delta*1E-3)),DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,(*t->cycles*10*t->nofFrames)));
DAQmxErrRtn(DAQmxCfgOutputBuffer(AOtaskHandle, t->nofFrames*10));
DAQmxErrRtn(DAQmxCfgDigEdgeStartTrig(AOtaskHandle, "PFI0", DAQmx_Val_Rising));
DAQmxErrRtn(DAQmxWriteAnalogF64(AOtaskHandle,t->nofFrames*10,0,10.0,DAQmx_Val_GroupByChannel,curr,&written,NULL));
DAQmxErrRtn(DAQmxStartTask(AOtaskHandle));
cerr << "\nTrying to allocate buffer for " << (*t->cycles * t->nofFrames) << " frames\n";
// config and start pulse channel with parameters set by user
//DAQmxErrRtn(DAQmxCfgImplicitTiming(DOtaskHandle, DAQmx_Val_FiniteSamps,*t->cycles * t->nofFrames));
DAQmxErrRtn(DAQmxCfgImplicitTiming(DOtaskHandle, DAQmx_Val_ContSamps,1));
DAQmxErrRtn(DAQmxCfgDigEdgeStartTrig(DOtaskHandle, "PFI0", DAQmx_Val_Rising));
DAQmxErrRtn(DAQmxStartTask(DOtaskHandle));
// config analog in task
DAQmxErrRtn(DAQmxCfgSampClkTiming(AItaskHandle,"Ctr0Out",100,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,*t->cycles * t->nofFrames));
DAQmxErrRtn(DAQmxStartTask(AItaskHandle));
// set trigger line to 1 - GO!
DAQmxWriteDigitalLines(TRtaskHandle,1,1,10,DAQmx_Val_GroupByChannel,trigdata[1],&written,NULL);
// wait until cam trigger task is done
DAQmxWaitUntilTaskDone(AOtaskHandle,-1);
// reset trigger line
DAQmxWriteDigitalLines(TRtaskHandle,1,1,10,DAQmx_Val_GroupByChannel,trigdata[0],&written,NULL);
// read protocol samples
DAQmxReadAnalogF64(AItaskHandle,*t->cycles * t->nofFrames,5.0,DAQmx_Val_GroupByChannel,indata,*t->cycles * t->nofFrames*2,&read,NULL);
//read indeed current
ofstream strom;
strom.open("newcurrent.txt", ofstream::app);
for(int i=0;i<t->nofFrames;i++)
strom<<i*(*t->delta*1E-3)<<"\t"<<indata[i]<<endl;
strom.close();
// stop tasks, disable trigger
DAQmxStopTask(AOtaskHandle);
DAQmxStopTask(DOtaskHandle);
DAQmxStopTask(AItaskHandle);
DAQmxDisableStartTrig(AOtaskHandle);
DAQmxDisableStartTrig(DOtaskHandle);
}
TaskHandle EXPORT_API EOGSetCallback(UnityCallback uCallback)
{
int32 error = 0;
char errBuff[2048] = { '\0' };
//int32 read;
//float64 data[1];
if (uCallback)
{
DAQmxErrChk(DAQmxCfgSampClkTiming(taskHandle, "", 240.0, DAQmx_Val_Rising, DAQmx_Val_ContSamps, numSamples));
DAQmxErrChk(DAQmxRegisterEveryNSamplesEvent(taskHandle, DAQmx_Val_Acquired_Into_Buffer, 1, 0, uCallback, NULL));
// DAQmxErrChk(DAQmxRegisterEveryNSamplesEvent(taskHandle, DAQmx_Val_Acquired_Into_Buffer, 1000, 0, EveryNSamplesCallback, NULL));
DAQmxErrChk(DAQmxRegisterDoneEvent(taskHandle, 0, DoneCallback, NULL));
/*********************************************/
// DAQmx Start Code
/*********************************************/
DAQmxErrChk(DAQmxStartTask(taskHandle));
return taskHandle;
}
Error:
if (DAQmxFailed(error))
{
DAQmxGetExtendedErrorInfo(errBuff, 2048);
Cleanup();
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
void QxrdNIDAQPlugin::setAnalogWaveform(QString chan, double rate, double wfm[], int size)
{
QMutexLocker lock(&m_Mutex);
// printf("setAnalogWaveform(%g,%g...,%d)\n", rate, wfm[0], size);
int error;
int32 nsampwrt;
if (m_AOTaskHandle) {
DAQmxStopTask(m_AOTaskHandle);
DAQmxClearTask(m_AOTaskHandle);
m_AOTaskHandle = 0;
}
if (chan >= 0) {
DAQmxErrChk(DAQmxCreateTask("qxrd-output", &m_AOTaskHandle));
DAQmxErrChk(DAQmxCreateAOVoltageChan (m_AOTaskHandle,
qPrintable(chan), NULL, -10.0, 10.0, DAQmx_Val_Volts, NULL));
if (m_AOTaskHandle) {
DAQmxErrChk(
DAQmxCfgSampClkTiming(m_AOTaskHandle, NULL, rate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, size)
);
DAQmxErrChk(
DAQmxWriteAnalogF64(m_AOTaskHandle, size, false, -1, DAQmx_Val_GroupByChannel, wfm, &nsampwrt, NULL)
);
}
}
// printf("%d samples written\n", nsampwrt);
Error:
return;
}
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
}
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::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;
}
void YON(int in)
{
TaskHandle YOn = 0;
uInt8 onSig[2] = { in, in };
DAQmxCreateTask("YON", &YOn);
DAQmxCreateDOChan(YOn, "Dev1/port0/line5", "YON", DAQmx_Val_ChanForAllLines); // Yon
DAQmxCfgSampClkTiming(YOn, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
DAQmxWriteDigitalLines(YOn, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, onSig, NULL, NULL); // turn Off
DAQmxStartTask(YOn);
DAQmxWaitUntilTaskDone(YOn, 1.0); // Wait for action to be completed
DAQmxStopTask(YOn);
DAQmxClearTask(YOn);
}
void YDIR(int in)
{
TaskHandle YDir = 0;
uInt8 dirSig[2] = { in, in };
DAQmxCreateTask("YDir", &YDir);
DAQmxCreateDOChan(YDir, "Dev1/port0/line3", "YDir", DAQmx_Val_ChanForAllLines); // Ydirection
DAQmxCfgSampClkTiming(YDir, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Int. Trig
DAQmxWriteDigitalLines(YDir, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, dirSig, NULL, NULL); // turn Off
DAQmxStartTask(YDir);
DAQmxWaitUntilTaskDone(YDir, 1.0); // Wait for action to be completed
DAQmxStopTask(YDir);
DAQmxClearTask(YDir);
}
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;
}
void NationalInstrumentsDAQ::setupAOChannels( float64 nrecords,
float64 record_frequency_Hz,
float64 vmin,
float64 vmax,
IDAQPhysicalChannel **channels,
int nchannels )
{ TaskHandle ao = 0;
int32 N = _config->ao_samples_per_waveform();
char terms[MAX_CHAN_STRING]= {0};
const char *dev = _config->name().c_str(),
*trig = _config->trigger().c_str();
char clk[MAX_CHAN_STRING] = {0};
float64 hz = computeSampleFrequency(nrecords,record_frequency_Hz),
lvl = _config->level_volts();
strcat(clk,_config->ctr().c_str());
strcat(clk,"InternalOutput");
// terminal names
TRY(nchannels<countof(terms));
{ const char* names[8]={0};
for(int i=0;i<nchannels;++i)
names[i]=channels[i]->name();
cat_terminal_names(terms,sizeof(terms),dev,names,nchannels);
}
// voltage range
{ f64 v[4];
DAQERR(DAQmxGetDevAOVoltageRngs(_config->name().c_str(),v,4));
vmin = MAX(vmin,v[2]);
vmax = MIN(vmax,v[3]);
}
ao=_ao.daqtask;
DAQERR(DAQmxCreateAOVoltageChan (ao,terms,NULL,vmin,vmax,DAQmx_Val_Volts,NULL));
DAQERR(DAQmxCfgSampClkTiming (ao,clk,hz,DAQmx_Val_Rising,DAQmx_Val_ContSamps,N));
DAQERR(DAQmxCfgOutputBuffer (ao,10*N));
DAQERR(DAQmxSetWriteRegenMode (ao,DAQmx_Val_DoNotAllowRegen));
DAQERR(DAQmxSetWriteRelativeTo (ao,DAQmx_Val_CurrWritePos));
DAQERR(DAQmxSetAODataXferMech (ao,terms,DAQmx_Val_DMA));
DAQERR(DAQmxSetAODataXferReqCond(ao,terms,DAQmx_Val_OnBrdMemNotFull));
DAQERR(DAQmxCfgAnlgEdgeStartTrig(ao,trig,DAQmx_Val_Rising,lvl));
return;
Error:
UNREACHABLE;
}
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;
}
int32 Tweezers::Degauss(float U, float duration)
{
clock_t startTime;
float freq = 100;
int bufferSize = (int)(5000 * duration);
float64 *data = new float64[bufferSize];
// fill buffer with data
for(int i=0;i<bufferSize;i++)
{
float64 amp = U * (1 - (double)i/(double)(bufferSize-1));
data[i] = amp * cos( 2.0 * PI * freq * (double)i/5000.0); // degauss Srate must be independent of run!!
}
DAQmxErrRtn(DAQmxClearTask(AOtaskHandle));
// create and setup analog task
DAQmxErrRtn(DAQmxCreateTask("AO",&AOtaskHandle));
DAQmxErrRtn(DAQmxCreateAOVoltageChan(AOtaskHandle,"Dev1/ao0","",-10.0,10.0,DAQmx_Val_Volts,NULL));
// configure sample clock for buffered write
DAQmxErrRtn(DAQmxCfgSampClkTiming(AOtaskHandle,"",5000,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,(int)(duration*5000)));
// write data and start task
DAQmxErrRtn(DAQmxWriteAnalogF64(AOtaskHandle,bufferSize,0,10.0,DAQmx_Val_GroupByChannel,data,&written,NULL));
startTime = clock();
DAQmxErrRtn(DAQmxStartTask(AOtaskHandle));
while(!done) {
DAQmxErrRtn(DAQmxIsTaskDone(AOtaskHandle,&done));
if (!done) Sleep(100);
}
done = false;
DAQmxErrRtn(DAQmxStopTask(AOtaskHandle));
residual = 0.0;
delete data;
}
int
ConfigStartle(void)
{
int i;
for(i = 0;i<250;i++)
{
gStartleData[i] = 5.0 ;//* sin(i / 5000.0 * 1400.0 * 2.0 * PI);//(i / 1000 * 400 * 2 * PI);
// printf("%lf, ", gStartleData[i]);
}
for (i = 250; i < 400; i++)
gStartleData[i] = 0.0;
/*********************************************/
// DAQmx Configure Code
/*********************************************/
DAQmxErrChk (DAQmxCreateTask("",&startleDaqHandle));
DAQmxErrChk (DAQmxCreateAOVoltageChan(startleDaqHandle,"Dev1/ao0","",-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk (DAQmxCfgSampClkTiming(startleDaqHandle,"",5000.0,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,400));
Error:
return 0;
}
int32 Tweezers::SetCurrent(float current)
{
// init output data array
float64 out_data[1];
out_data[0] = current;
// setup HTSP timing and deactivate onboard memory
DAQmxErrRtn(DAQmxCfgSampClkTiming(AOtaskHandle,"",Srate_HTSP,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,1));
// start task
DAQmxErrRtn(DAQmxStartTask(AOtaskHandle));
// write single sample
DAQmxErrRtn(DAQmxWriteAnalogF64(AOtaskHandle,1,true,-1,DAQmx_Val_GroupByChannel,out_data,&written,NULL));
// stop task
DAQmxErrRtn(DAQmxStopTask(AOtaskHandle));
residual = (abs(current) > abs(residual) ? current : residual);
}
void moveXStage(int steps, uInt8 clockSig[])
{
int bits = steps * 2;
TaskHandle XClockOut = 0;
uInt8 *signal = new uInt8[bits];
for (int i = 0; i < bits; i += 2) {
signal[i] = clockSig[0];
signal[i + 1] = clockSig[1];
}
DAQmxCreateTask("X", &XClockOut);
DAQmxCreateDOChan(XClockOut, "Dev1/port0/line0", "X", DAQmx_Val_ChanForAllLines); // Xmotor
DAQmxCfgSampClkTiming(XClockOut, NULL, motorSpeed, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, bits); // Ext. Trig
DAQmxWriteDigitalLines(XClockOut, bits, 0, 1000.0, DAQmx_Val_GroupByChannel, signal, NULL, NULL); // X Motor signal
DAQmxStartTask(XClockOut); // Pulse motor
DAQmxWaitUntilTaskDone(XClockOut, 1000.0); // Wait for action to be completed
DAQmxStopTask(XClockOut);
DAQmxClearTask(XClockOut);
delete signal;
}
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 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;
}
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;
}
void ScanThreadLinear::InitializeSyncAndScan(void)
{
//CLEAR TASKS
DAQmxClearTask(taskClock);
DAQmxClearTask(taskTrig);
DAQmxClearTask(taskTrA);
DAQmxClearTask(taskAnalog);
Samps = globalOptions->IMAGEHEIGHT+NumPtsDw;
LineRate = Samps*FrameRate;
//CREATE TASKS
DAQmxCreateTask("",&taskAnalog);
DAQmxCreateTask("",&taskTrig);
DAQmxCreateTask("",&taskTrA);
DAQmxCreateTask("",&taskClock);
/*************************
CLOCK SOURCE
*************************/
//CREATE INTERNAL CLOCK SOURCE
DAQmxCreateCOPulseChanFreq(taskClock, "Dev1/ctr0", "", DAQmx_Val_Hz,
DAQmx_Val_Low, __DDELAY, FrameRate, .2);
/*************************
DIGITAL PULSE TRAIN
*************************/
//CREATE DIGITAL LINE
DAQmxCreateDOChan(taskTrig,"Dev1/port0/line0","",DAQmx_Val_ChanPerLine);
//SET TIMING AND STATE CLOCK SOURCE
//Clock source is based off the analog sample clock
DAQmxCfgSampClkTiming(taskTrig,"ao/SampleClock",FrameRate*Samps,
DAQmx_Val_Rising,DAQmx_Val_ContSamps,Samps);
/*************************
ANALOG SAW TOOTH
*************************/
//CREATE ANALOG CHANNEL
DAQmxCreateAOVoltageChan(taskAnalog,"Dev1/ao0",
"",-10,10.0,DAQmx_Val_Volts,NULL);
DAQmxCreateAOVoltageChan(taskAnalog,"Dev1/ao1",
"",-10,10.0,DAQmx_Val_Volts,NULL);
//SET TIMING
DAQmxCfgSampClkTiming(taskAnalog,"",FrameRate*Samps,
DAQmx_Val_Rising,DAQmx_Val_ContSamps,Samps);
//GET TERMINAL NAME OF THE TRIGGER SOURCE
GetTerminalNameWithDevPrefix(taskTrig, "Ctr0InternalOutput",trigName);
//TRIGGER THE ANALOG DATA BASED OFF INTERNAL TRIGGER (CLOCK SOURCE)
DAQmxCfgDigEdgeStartTrig(taskAnalog,trigName,DAQmx_Val_Rising);
if (globalOptions->bVolumeScan == false)
{
GenSawTooth(Samps,XScanVolts_mV,XScanOffset_mV,ScanBuff);
for (int i = 0; i< Samps; i++)
VolBuff[i] = ScanBuff[i];
for (int i = Samps; i < 2*Samps; i++)
VolBuff[i] = YScanOffset_mV/1000;
DAQmxWriteAnalogF64(taskAnalog, Samps, false ,10 ,DAQmx_Val_GroupByChannel, VolBuff,NULL,NULL);
//GENERATE PULSE TRAIN TO TRIGGER CAMERA
GenPulseTrain(Samps,digiBuff);
DAQmxWriteDigitalLines(taskTrig,Samps,false,10.0,DAQmx_Val_GroupByChannel,digiBuff,NULL,NULL);
}
else
{
int frameCount;
GenSawTooth(Samps,XScanVolts_mV,XScanOffset_mV,ScanBuff);
for (frameCount = 0; frameCount < globalOptions->NumFramesPerVol; frameCount++)
{
for (int i = 0; i< Samps; i++)
VolumeBuff[i+frameCount*Samps] = ScanBuff[i];
}
GenStairCase(Samps,globalOptions->NumFramesPerVol,YScanVolts_mV, YScanOffset_mV, tempBuff);
for (int i = 0; i < Samps*globalOptions->NumFramesPerVol; i++)
VolumeBuff[i + Samps*globalOptions->NumFramesPerVol] = tempBuff[i];
DAQmxWriteAnalogF64(taskAnalog, Samps*globalOptions->NumFramesPerVol, false ,10 ,DAQmx_Val_GroupByChannel, VolumeBuff,NULL,NULL);
//GENERATE PULSE TRAIN TO TRIGGER CAMERA
for (int frameCount = 0; frameCount < globalOptions->NumFramesPerVol; frameCount++)
{
GenPulseTrain(Samps,digiBuff);
for (int i = 0; i< Samps; i++)
digiVolBuff[i+frameCount*Samps] = digiBuff[i];
}
DAQmxWriteDigitalLines(taskTrig,Samps*globalOptions->NumFramesPerVol,false,10.0,DAQmx_Val_GroupByChannel,digiVolBuff,NULL,NULL);
}
//GENERATE PULSE TRAIN TO TRIGGER CAMERA
DAQmxCreateCOPulseChanFreq(taskTrA,"Dev1/ctr1","",DAQmx_Val_Hz,DAQmx_Val_Low,0.0,LineRate,0.2);
DAQmxCfgImplicitTiming(taskTrA,DAQmx_Val_FiniteSamps,globalOptions->IMAGEHEIGHT);
DAQmxCfgDigEdgeStartTrig(taskTrA,"/Dev1/PFI4",DAQmx_Val_Rising);
DAQmxSetStartTrigRetriggerable(taskTrA, 1);
DAQmxConnectTerms ("/Dev1/Ctr1InternalOutput", "/Dev1/RTSI0", DAQmx_Val_DoNotInvertPolarity);
//START TASKS
//IMPORTANT - Need to arm analog task first to make sure that the digital and analog waveforms are in sync
DAQmxStartTask(taskAnalog);
DAQmxStartTask(taskTrA);
DAQmxStartTask(taskTrig);
DAQmxStartTask(taskClock);
}
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 _tmain(int argc, _TCHAR* argv[])
{
TaskHandle task;
int acqTime = 6;
float64 sampleRate = 500000.0;
float64 linePeriod = .002;
int lineSamples = (int)(linePeriod * sampleRate);
int numLines = (int) (acqTime / (lineSamples/sampleRate));
int acqSamples = numLines * lineSamples;
int32 sampsWritten;
bool32 taskDone;
//Create the task
DAQmxCreateTask("a task", &task);
//Add AO channels
DAQmxCreateAOVoltageChan(task, "Dev1/ao0", "", -10, 10, DAQmx_Val_Volts, NULL);
//Configure timing
DAQmxCfgSampClkTiming(task, NULL, sampleRate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, acqSamples);
//Write output data
float64 *outputData = (float64*) calloc(acqSamples, sizeof(float64));
for (int i=0;i<numLines;i++)
{
for (int j=0;j<lineSamples;j++)
{
outputData[i*lineSamples + j] = ((float64) j/(float64)lineSamples) * 10.0;
}
}
DAQmxWriteAnalogF64(task, acqSamples, false, 10.0, DAQmx_Val_GroupByChannel, outputData, &sampsWritten, NULL);
printf("Wrote %d samples of data!\n", sampsWritten);
printf("Sample #33: %g\n", outputData[32]);
printf("Sample #121: %g\n", outputData[120]);
printf("Sample #6032: %g\n", outputData[6031]);
//Start Task
DAQmxStartTask(task);
printf("Started task...\n");
while (true)
{
DAQmxIsTaskDone(task,&taskDone);
if (taskDone)
break;
else
Sleep(1000);
}
//Clear Task
DAQmxClearTask(task);
return 0;
}
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;
}
// 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;
}
int32 Tweezers::Run(float64* force, float64* indata, void* lpParam)
{
threadinfo* t = (threadinfo*)lpParam;
// init output data array
float64 out_data[1];
out_data[0] = 0.0;
register int i = 0,j = 0;
// # of samples to be generated per cycle
register int nofSamples = (int)(t->nofFrames/(*t->cycles)) * (*t->delta)*1E-3 * Srate_HTSP;
//cerr<<nofSamples<<" samples\n";
// setup HTSP timing and deactivate onboard memory
DAQmxErrRtn(DAQmxCfgSampClkTiming(AOtaskHandle,"OnboardClock",Srate_HTSP,DAQmx_Val_Rising,DAQmx_Val_HWTimedSinglePoint,nofSamples));
DAQmxSetRealTimeConvLateErrorsToWarnings(AOtaskHandle, TRUE);
// setup start trigger
DAQmxErrRtn(DAQmxCfgDigEdgeStartTrig(AOtaskHandle, "PFI0", DAQmx_Val_Rising));
// setup counter task and start trigger
// maybe change trigger to digital line? need to use ContSamps, otherwise limited frame #
//DAQmxErrRtn(DAQmxCreateCOPulseChanTime(DOtaskHandle,"Dev1/Ctr0","",DAQmx_Val_Seconds,DAQmx_Val_Low,0,1E-3*(*t->delta)/2,1E-3*(*t->delta/2)));
DAQmxErrRtn(DAQmxCfgImplicitTiming(DOtaskHandle, DAQmx_Val_ContSamps, 1));
// setup start trigger
DAQmxErrRtn(DAQmxCfgDigEdgeStartTrig(DOtaskHandle, "PFI0", DAQmx_Val_Rising));
// setup analog in task
DAQmxErrRtn(DAQmxCfgSampClkTiming(AItaskHandle,"Ctr0Out",100,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,*t->cycles * t->nofFrames));
//DAQmxErrRtn(DAQmxCfgDigEdgeStartTrig(AItaskHandle, "PFI0", DAQmx_Val_Rising));
// start tasks (still waiting for edge trigger from TRtask)
DAQmxErrRtn(DAQmxStartTask(DOtaskHandle));
DAQmxErrRtn(DAQmxStartTask(AOtaskHandle));
DAQmxErrRtn(DAQmxStartTask(AItaskHandle));
// precalulate number of loop runs to speed up loop
int samps = (nofSamples * (*t->cycles) - 1);
// write first sample outside loop, so there is enough time to send the TR start trigger
out_data[0] = current(force[0],t->dist);
DAQmxErrRtn(DAQmxWriteAnalogF64(AOtaskHandle,1,true,-1,DAQmx_Val_GroupByChannel,out_data,&written,NULL));
// GO!
DAQmxErrRtn(DAQmxWriteDigitalLines(TRtaskHandle,1,1,10,DAQmx_Val_GroupByChannel,trigdata[1],&written,NULL));
// 1 kHz sample generation loop
while(!(*t->bead_lost &&
// [email protected]: 05/10/2012 16:16 - dont stop recording if bead is lost in Creep-noint protocol
*t->protocol != "Creep-noint"
// end of change
) && i < samps)
{
j = (++i % nofSamples);
//cerr<<j<<"\r";
out_data[0] = current(force[j],t->dist);
DAQmxErrRtn(DAQmxWaitForNextSampleClock(AOtaskHandle, 1.0, &islate));
DAQmxErrRtn(DAQmxWriteAnalogF64(AOtaskHandle,1,true,-1,DAQmx_Val_GroupByChannel,out_data,&written,NULL));
if(islate)
{
cerr<<i++<<"\n****** late write - out of sync! *******\n";
*t->bead_lost = TRUE;
t->syncerror = TRUE;
}
}
printf("DEBUG: bead_lost(%d) protocol(%s) i(%d) samps(%d)\n",
*t->bead_lost, *t->protocol, i, samps);
// wait for last sample to be generated
DAQmxErrRtn(DAQmxWaitForNextSampleClock(AOtaskHandle, 1.0, &islate));
// make sure enough trigger pulses are generated
Sleep(*t->delta * 5);
// stop tasks
DAQmxErrRtn(DAQmxStopTask(DOtaskHandle));
DAQmxErrRtn(DAQmxStopTask(AOtaskHandle));
// number of frames actually taken
t->FramesTaken = 1 + floor(t->nofFrames * (double)i/(double)(nofSamples * (*t->cycles)));
// read protocol samples
DAQmxReadAnalogF64(AItaskHandle,t->FramesTaken,5.0,DAQmx_Val_GroupByChannel,indata,t->FramesTaken*2,&read,NULL);
DAQmxErrRtn(DAQmxStopTask(AItaskHandle));
// disable start triggers
DAQmxErrRtn(DAQmxDisableStartTrig(DOtaskHandle));
DAQmxErrRtn(DAQmxDisableStartTrig(AOtaskHandle));
// reset trigger line
DAQmxErrRtn(DAQmxWriteDigitalLines(TRtaskHandle,1,1,10,DAQmx_Val_GroupByChannel,trigdata[0],&written,NULL));
}
