// 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
}
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;
}
// 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));
}
}
void QxrdNIDAQPlugin::setAnalogOutput(int chan, double value)
{
QMutexLocker lock(&m_Mutex);
int error;
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(tr("Dev1/ao%1").arg(chan)), NULL, -10.0, 10.0, DAQmx_Val_Volts, NULL));
if (m_AOTaskHandle) {
DAQmxErrChk(DAQmxWriteAnalogScalarF64(m_AOTaskHandle, true, 10.0, value, NULL));
}
}
Error:
return;
}
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;
}
double QxrdNIDAQPlugin::count(int /* chan */, double /* time */)
{
QMutexLocker lock(&m_Mutex);
static TaskHandle counterTask = 0;
int error;
float64 res = 0;
if (counterTask == 0) {
DAQmxErrChk(DAQmxCreateTask("counter", &counterTask));
DAQmxErrChk(DAQmxCreateCICountEdgesChan(counterTask,"Dev1/ctr2", "", DAQmx_Val_Rising, 0, DAQmx_Val_CountUp));
DAQmxErrChk(DAQmxSetCICountEdgesTerm(counterTask, "/Dev1/ctr2", "/Dev1/100MHzTimebase"));
DAQmxErrChk(DAQmxStartTask(counterTask));
}
if (counterTask) {
DAQmxErrChk(DAQmxReadCounterScalarF64(counterTask, 0, &res, NULL));
}
return res;
Error:
DAQmxClearTask(counterTask);
return res;
}
//************************************
// Method: setupCLK
// FullName: fetch::device::NationalInstrumentsDAQ::setupCLK
// Access: public
// Returns: void
// Qualifier:
//
// set up counter for sample clock
// - A finite pulse sequence is generated by a pair of on-board counters.
// In testing, it appears that after the device is reset, initializing
// the counter task doesn't work quite right. First, I have to start the
// task with the paired counter once. Then, I can set things up normally.
// After initializing with the paired counter once, things work fine until
// the device (or computer) is reset. My guess is this is a fault of the
// board or driver software.
// - below, we just cycle the counters when config gets called. This ensures
// everything configures correctly the first time, even after a device
// reset or cold start.
//************************************
void NationalInstrumentsDAQ::setupCLK(float64 nrecords, float64 record_frequency_Hz)
{
TaskHandle clk = 0;
int32 N = _config->ao_samples_per_waveform();
float64 hz = computeSampleFrequency(nrecords, record_frequency_Hz);
const char *dev =_config->name().c_str(),
*ctr =_config->ctr().c_str(),
*armstart_in =_config->armstart().c_str(),
*gate_out =_config->frame_trigger_out().c_str(),
*trig =_config->trigger().c_str();
float64 lvl =_config->level_volts();
char term_ctr[1024]={0},
term_gate[1024]={0},
term_arm_out[1024]={0};
make_terminal_name(term_ctr ,sizeof(term_ctr) ,dev,ctr);
make_terminal_name(term_gate ,sizeof(term_gate) ,dev,ctr);
strcat(term_gate,"Gate");
make_terminal_name(term_arm_out,sizeof(term_arm_out),dev,gate_out);
DAQERR( DAQmxClearTask(_clk.daqtask) ); // Once a DAQ task is started, it needs to be cleared before restarting
DAQERR( DAQmxCreateTask("fetch_CLK",&_clk.daqtask));
clk = _clk.daqtask;
DAQERR(DAQmxCreateCOPulseChanFreq (clk,term_ctr,NULL,DAQmx_Val_Hz,DAQmx_Val_Low,0.0,hz,0.5));
DAQERR(DAQmxCfgImplicitTiming (clk,DAQmx_Val_FiniteSamps,N));
DAQERR(DAQmxCfgDigEdgeStartTrig (clk,"AnalogComparisonEvent",DAQmx_Val_Rising));
DAQERR(DAQmxSetArmStartTrigType (clk,DAQmx_Val_DigEdge)); // Arm trigger has to be through clk
DAQERR(DAQmxSetDigEdgeArmStartTrigSrc (clk,armstart_in));
DAQERR(DAQmxSetDigEdgeArmStartTrigEdge(clk,DAQmx_Val_Rising));
DAQERR(DAQmxSetStartTrigRetriggerable (clk,1));
DAQERR(DAQmxConnectTerms(term_gate,term_arm_out,DAQmx_Val_DoNotInvertPolarity));
}
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;
}
void NationalInstrumentsDAQ::setupAO( float64 nrecords, float64 record_frequency_Hz )
{
float64 freq = computeSampleFrequency(nrecords, record_frequency_Hz);
DAQERR( DAQmxClearTask(_ao.daqtask) );
DAQERR( DAQmxCreateTask( "fetch_AO", &_ao.daqtask));
registerDoneEvent();
}
//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);
}
void DaqMagControl::set_volts(double this_volts)
{
DAQmxCreateTask("",&taskHandle);
DAQmxCreateAOVoltageChan (taskHandle, chan_char, "", -10.0, 10.0, DAQmx_Val_Volts , NULL);
DAQmxStartTask(taskHandle);
double volts=this_volts;
DAQmxWriteAnalogF64(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,&volts,NULL,NULL);
if( taskHandle!=0 )
{
DAQmxStopTask(taskHandle);
DAQmxClearTask(taskHandle);
}
}
int NI6211::startCapot()
{
int error;
taskCapot = new TaskHandle;
/*------ DAQmx Configure Code Reading Task ------*/
DAQmxErrChk (DAQmxCreateTask("",taskCapot));
DAQmxErrChk (DAQmxCreateDIChan(*taskCapot,"Equilibreuse/port0/line3","",DAQmx_Val_ChanPerLine));
DAQmxErrChk (DAQmxStartTask(*taskCapot));
Erreur:
checkError(error);
return error;
}
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 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);
}
/******************************************************************************
**
** Démarage de la tache d'acquisition de la vitesse.
**
******************************************************************************/
int NI6211::startSpeed()
{
int error;
taskFreq = new TaskHandle;
/*------ DAQmx Configure Code Reading Task ------*/
DAQmxErrChk (DAQmxCreateTask("",taskFreq));
DAQmxErrChk (DAQmxCreateCIFreqChan(*taskFreq,"/Equilibreuse/ctr0","",1,200000,DAQmx_Val_Hz,DAQmx_Val_Rising,DAQmx_Val_LowFreq1Ctr,1,1,""));
DAQmxErrChk (DAQmxSetCIFreqTerm(*taskFreq,"","/Equilibreuse/PFI2"))
DAQmxErrChk (DAQmxStartTask(*taskFreq));
Erreur:
checkError(error);
return error;
}
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);
}
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 create_DO_channel(uInt32 port)
{
#ifdef _USE_REAL_KIT_
char taskName[100];
char portName[100];
TaskHandle task_handle;
sprintf(taskName,"task_di__%d",port);
sprintf(portName,"Dev3/port%d",port);
DAQmxCreateTask(taskName,&task_handle);
DAQmxCreateDOChan(task_handle,portName,"",DAQmx_Val_ChanForAllLines);
DAQmxStartTask(task_handle);
tasks[port]=task_handle;
#else
return sim_create_DO_channel(port);
#endif
return(true);
}
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;
}
/******************************************************************************
**
** Fonction de démarage du comptage de la voie A du compteur incrémentale.
**
******************************************************************************/
bool NI6211::startCounter()
{
int32 error=0;
taskCounter = new TaskHandle;
/*------ DAQmx Configure Code Reading Task ------*/
DAQmxErrChk (DAQmxCreateTask("",taskCounter));
DAQmxErrChk (DAQmxCreateCIAngEncoderChan(*taskCounter,"Equilibreuse/ctr0","",DAQmx_Val_X1,TRUE,999,DAQmx_Val_AHighBLow,DAQmx_Val_Ticks,1000,0,NULL));
DAQmxErrChk (DAQmxSetArmStartTrigType(*taskCounter,DAQmx_Val_DigEdge));
DAQmxErrChk (DAQmxSetDigEdgeArmStartTrigSrc(*taskCounter,"/Equilibreuse/PFI2"));
/*------ DAQmx Start Code ------*/
DAQmxErrChk (DAQmxStartTask(*taskCounter));
Erreur:
checkError(error);
return 0;
}
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;
}
/******************************************************************************
**
** 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;
}
void TriggerFrames(unsigned int nr, double extime)
{
char errBuff[2048];
// int32 error;
TaskHandle DOtaskHandle;
DAQmxCreateTask("DO",&DOtaskHandle);
//cerr<<"sending trigger pulse: "<<extime*1E-3<<" secs!\n";
DAQmxCreateCOPulseChanTime(DOtaskHandle,"Dev1/Ctr0","",DAQmx_Val_Seconds,DAQmx_Val_Low,0.0,extime*1E-3,extime*1E-3);
//DAQmxCfgImplicitTiming(DOtaskHandle, DAQmx_Val_ContSamps, 1);
DAQmxCfgImplicitTiming(DOtaskHandle, DAQmx_Val_FiniteSamps, 1);
DAQmxStartTask(DOtaskHandle);
DAQmxWaitUntilTaskDone(DOtaskHandle,-1);
DAQmxStopTask(DOtaskHandle);
DAQmxClearTask(DOtaskHandle);
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
}
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;
}
TaskHandle EXPORT_API EOGStartTask()
{
int32 error = 0;
char errBuff[2048] = { '\0' };
/*********************************************/
// DAQmx Configure Code
/*********************************************/
DAQmxErrChk(DAQmxCreateTask("", &taskHandle));
return taskHandle;
//return 1;
Error:
if (DAQmxFailed(error))
{
DAQmxGetExtendedErrorInfo(errBuff, 2048);
Cleanup();
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
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;
}
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;
}
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;
}
/******************************************************************************
**
** Fonction de démarage de la tache d'alimentation du moteur
** La vitesse du moteur est défini à 50%
**
******************************************************************************/
int NI6211::startMotor()
{
int error=0;
taskVOut = new TaskHandle;
float64 data[1] = {0};
/*------ DAQmx Configure Code ------*/
DAQmxErrChk (DAQmxCreateTask("",taskVOut));
DAQmxErrChk (DAQmxCreateAOVoltageChan(*taskVOut,"/Equilibreuse/ao0","",-10.0,10.0,DAQmx_Val_Volts,""));
/*------ DAQmx Start Code ------*/
DAQmxErrChk (DAQmxStartTask(*taskVOut));
/*------ DAQmx Write Code ------*/
DAQmxErrChk (DAQmxWriteAnalogF64(*taskVOut,1,1,-1,DAQmx_Val_GroupByChannel,data,NULL,NULL));
Erreur:
checkError(error);
return 0;
}
