int SetDaqAbort() { int32 error = 0; char errBuff[2048]; epicsPrintf("**** DAQmx Task Abort****\n"); DAQmxErrChk(DAQmxStopTask(daq6220pvt.taskHandle)); DAQmxErrChk(DAQmxClearTask(daq6220pvt.taskHandle)); daq6220pvt.status = DAQ_STATUS_STOP; 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; }
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; }
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; }
int motorControl::motorDisable() { int32 error=0; char errBuff[2048] = {'\0'}; uInt32 dataDisable=0x00000000; int32 written; float64 zeroVoltages[3]={0.0,0.0,0.0}; while(isControlling){ } DAQmxErrChk (DAQmxStartTask(motorEnableHandle)); DAQmxErrChk (DAQmxStartTask(motorTaskHandle)); DAQmxErrChk (DAQmxWriteDigitalU32(motorEnableHandle,1,1,10.0,DAQmx_Val_GroupByChannel,&dataDisable,NULL,NULL)); DAQmxErrChk (DAQmxWriteAnalogF64(motorTaskHandle,1,FALSE,10,DAQmx_Val_GroupByChannel,zeroVoltages,NULL,NULL)); Sleep(500); DAQmxStopTask(motorTaskHandle); DAQmxStopTask(motorEnableHandle); isControlling = FALSE; isWindUp = FALSE; live = FALSE; isEnable = FALSE; Error: if( DAQmxFailed(error) ){ printf("DisableMotor Error: %s\n",errBuff); DAQmxGetExtendedErrorInfo(errBuff,2048); printf("DAQmx Error: %s\n",errBuff); DAQmxStopTask(motorEnableHandle); DAQmxStopTask(motorTaskHandle); DAQmxClearTask(motorEnableHandle); DAQmxClearTask(motorTaskHandle); } return 0; }
int motorControl::motorWindUp() { char errBuff[2048]={'\0'}; int32 error=0; float64 windingUpCmnd[3]={0.5,0.5,0}; if (isEnable){ DAQmxErrChk (DAQmxStartTask(motorTaskHandle)); DAQmxErrChk (DAQmxWriteAnalogF64(motorTaskHandle,1,FALSE,10,DAQmx_Val_GroupByChannel,windingUpCmnd,NULL,NULL)); Sleep(500); isWindUp = TRUE; DAQmxStopTask(motorTaskHandle); printf("Windup Pass.\n"); }else printf("Motors must be first enabled prior to winding up.\n"); Error: if( DAQmxFailed(error) ) { DAQmxGetExtendedErrorInfo(errBuff,2048); DAQmxStopTask(motorTaskHandle); DAQmxClearTask(motorTaskHandle); printf("DAQmx Error: %s\n",errBuff); printf("winding up Error\n"); } return 0; }
int main(int argc, char *argv[]) { int32 error=0; TaskHandle taskHandle=0; uInt8 data[100]; char errBuff[2048]={'\0'}; int32 i; char ch; DAQmxErrChk (Configure_ReadDigChan("Dev1/port0/line0:7",&taskHandle)); DAQmxErrChk (Start_ReadDigChan(taskHandle)); DAQmxErrChk (Read_ReadDigChan(taskHandle,data,100)); Error: if( DAQmxFailed(error) ) DAQmxGetExtendedErrorInfo(errBuff,2048); if( taskHandle!=0 ) Stop_ReadDigChan(taskHandle); if( DAQmxFailed(error) ) printf("DAQmx Error: %s\n",errBuff); else // assuming 8 channels acquired for(i=0;i<8;++i) printf("Data acquired, channel %d: 0x%X\n",i,data[i]); printf("End of program, press any key to quit\n"); while( !_kbhit() ) {} ch = _getch(); return 0; }
int motorControl::motorEnable() { uInt32 dataEnable=0x00000001; char errBuff[2048]={'\0'}; int32 error=0; float64 zeroVoltages[3]={0.0,0.0,0.0},zeroVoltage={0.0}; DAQmxErrChk (DAQmxStartTask(motorEnableHandle)); DAQmxErrChk (DAQmxStartTask(motorTaskHandle)); DAQmxErrChk (DAQmxWriteDigitalU32(motorEnableHandle,1,1,10.0,DAQmx_Val_GroupByChannel,&dataEnable,NULL,NULL)); DAQmxErrChk (DAQmxWriteAnalogF64(motorTaskHandle,1,FALSE,10,DAQmx_Val_GroupByChannel,zeroVoltages,NULL,NULL)); Sleep(500); DAQmxStopTask(motorTaskHandle); DAQmxStopTask(motorEnableHandle); isEnable = TRUE; Error: if( DAQmxFailed(error) ) { DAQmxGetExtendedErrorInfo(errBuff,2048); DAQmxStopTask(motorTaskHandle); DAQmxClearTask(motorTaskHandle); DAQmxStopTask(motorEnableHandle); DAQmxClearTask(motorEnableHandle); printf("DAQmx Error: %s\n",errBuff); printf("Motor enable Error\n"); } 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; }
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; }
float64 readAnalog(char eingangNr = '0'){ //Default Eingang = 0 // Task parameters TaskHandle taskHandle = 0; // Channel parameters char chan[8] = "Dev1/ai"; float64 min = 0.0; float64 max = 5.0; // Timing parameters uInt64 samplesPerChan = 1; // Data read parameters float64 data; int32 pointsToRead = 1; int32 pointsRead; float64 timeout = 10.0; chan[7] = eingangNr; DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateAIVoltageChan(taskHandle,chan,"",DAQmx_Val_RSE,min,max,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); DAQmxErrChk (DAQmxBaseReadAnalogF64(taskHandle,pointsToRead,timeout,DAQmx_Val_GroupByChannel,&data,samplesPerChan,&pointsRead,NULL)); // printf ("Acquired reading: %f\n", data); //Debug DAQmxErrChk (DAQmxBaseStopTask (taskHandle)); return data; }
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; }
uInt32 readDigitalPort(char portNr = '0'){ //Default Port = 0 // Task parameters TaskHandle taskHandle = 0; // Channel parameters char chan[10] = "Dev1/port"; // Read parameters uInt32 r_data [1]; int32 read; // Vervollständige den String mit der Portnummer chan[9] = portNr; // Create Digital Input (DI) Task and Channel DAQmxErrChk (DAQmxBaseCreateTask ("", &taskHandle)); DAQmxErrChk (DAQmxBaseCreateDIChan(taskHandle,chan,"",DAQmx_Val_ChanForAllLines)); // Start Task (configure port) DAQmxErrChk (DAQmxBaseStartTask (taskHandle)); // Read from port DAQmxErrChk (DAQmxBaseReadDigitalU32(taskHandle,1,10.0,DAQmx_Val_GroupByChannel,r_data,1,&read,NULL)); // printf("Data read: 0x%X\n", r_data[0]); //Debug DAQmxErrChk (DAQmxBaseStopTask (taskHandle)); return r_data[0]; }
void writeDigitalPort(uInt8 dig_out_daten, char portNr = '0') { //Default Port = 0 TaskHandle taskHandle = 0; // Channel parameters char chan[10] = "Dev1/port"; // Write parameters uInt8 w_data [1]; int32 written; chan[9] = portNr; // Vervollständige den String mit der Portnummer // Create Digital Output Channel and Task DAQmxErrChk (DAQmxBaseCreateTask ("", &taskHandle)); DAQmxErrChk ( DAQmxBaseCreateDOChan(taskHandle,chan,"",DAQmx_Val_ChanForAllLines) ); // Start Task (configure port) //DAQmxErrChk (DAQmxBaseStartTask (taskHandle)); // Write dig_out_daten to port(s) // Only 1 sample per channel supported for static DIO // Autostart ON w_data[0] = dig_out_daten; // printf("Data to write: 0x%X\n", w_data[0]); // Debug DAQmxErrChk (DAQmxBaseWriteDigitalU8(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,w_data,&written,NULL)); DAQmxErrChk (DAQmxBaseStopTask (taskHandle)); }
void writeAnalog(char ausgangNr = '0', float64 data = 5.0){ //Default Ausgang = 0, Spannung = 5.0 Volt // Task parameters TaskHandle taskHandle = 0; // Channel parameters char chan[8] = "Dev1/ao"; float64 min = 0.0; float64 max = 5.0; // Timing parameters uInt64 samplesPerChan = 1; // Data write parameters int32 pointsWritten; float64 timeout = 10.0; chan[7] = ausgangNr; DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,chan,"",min,max,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,samplesPerChan,0,timeout,DAQmx_Val_GroupByChannel,&data,&pointsWritten,NULL)); DAQmxErrChk (DAQmxBaseStopTask (taskHandle)); }
int main (int argc, char *argv[]) { // Task parameters int32 error = 0; TaskHandle taskHandle = 0; char errBuff[2048]= {'\0'}; int32 i; // Channel parameters char chan[] = "Dev1/ai0"; float64 min = -10.0; float64 max = 10.0; // Timing parameters char source[] = "OnboardClock"; uInt64 samplesPerChan = 100; float64 sampleRate = 1200.0; // Data read parameters #define bufferSize (uInt32)1000 float64 data[bufferSize]; int32 pointsToRead = -1; int32 pointsRead; float64 timeout = 10.0; while(1) { printf("new task\n\n"); DAQmxErrChk (DAQmxBaseCreateTask ("", &taskHandle)); DAQmxErrChk (DAQmxBaseCreateAIVoltageChan (taskHandle, chan, "", DAQmx_Val_NRSE, min, max, DAQmx_Val_Volts, NULL)); DAQmxErrChk (DAQmxBaseCfgSampClkTiming (taskHandle, source, sampleRate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, samplesPerChan)); DAQmxErrChk (DAQmxBaseStartTask (taskHandle)); DAQmxErrChk (DAQmxBaseReadAnalogF64 (taskHandle, pointsToRead, timeout, 0, data, bufferSize, &pointsRead, NULL)); printf("pointsRead: %d\n",pointsRead); // Just print out the first 10 points for (i = 0; i < 8; ++i) { printf ("%f\n", data[i]); } DAQmxBaseStopTask (taskHandle); DAQmxBaseClearTask (taskHandle); } Error: if (DAQmxFailed (error)) DAQmxBaseGetExtendedErrorInfo (errBuff, 2048); if (taskHandle != 0) { DAQmxBaseStopTask (taskHandle); DAQmxBaseClearTask (taskHandle); } if (error) printf ("DAQmxBase Error %d: %s\n", error, errBuff); return 0; }
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; }
/****************************************************************************** ** ** 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; }
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; }
int EXPORT_API EOGStopTask(TaskHandle taskHandle) { int32 error = 0; char errBuff[2048] = { '\0' }; if (taskHandle != 0) { DAQmxErrChk(DAQmxStopTask(taskHandle)); DAQmxClearTask(taskHandle); return 1; } else { return 2; } Error: if (DAQmxFailed(error)) { DAQmxGetExtendedErrorInfo(errBuff, 2048); Cleanup(); printf("DAQmx Error: %s\n", errBuff); } return 0; }
int32 CVICALLBACK EveryNCallback(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData) { int32 error=0; char errBuff[2048]={'\0'}; int32 nRead; float64 data[1000]; int i; DAQmxErrChk (DAQmxReadAnalogF64(taskHandle,1000,10.0,DAQmx_Val_GroupByChannel,data,1000,&nRead,NULL)); printf ("[%10u]", taskHandle); for (i = 0; i < getNumOfDev(); i++) { if(taskHandle == gTaskInfoList[i].nTaskHandle) { gTaskInfoList[i].nReadTotal += nRead; } printf("\t%10d", gTaskInfoList[i].nReadTotal); } printf ("\r"); fflush(stdout); Error: return 0; }
/****************************************************************************** ** ** 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; }
/****************************************************************************** ** ** Acquisition des données des compteur et mise en forme pour ** déterminer l'origine ** ******************************************************************************/ int NI6211::readCounter() { float64 data[1]; int error=0; DAQmxErrChk (DAQmxReadCounterScalarF64(*taskCounter,DAQmx_Val_WaitInfinitely,data,NULL)); Erreur: checkError(error); return data[0]; }
/****************************************************************************** ** ** 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 QxrdNIDAQPlugin::setAnalogOutput(double value) { int error; if (m_AOTaskHandle) { DAQmxErrChk(DAQmxWriteAnalogScalarF64(m_AOTaskHandle, true, 10.0, value, NULL)); } Error: return; }
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; }
/****************************************************************************** ** ** Acquisition des valeur de la tache d'acquisition de la vitesse ** ******************************************************************************/ double NI6211::readSpeed() { int error; double speed[1]; /*------ DAQmx Read Code ------*/ DAQmxErrChk (DAQmxReadCounterScalarF64(*taskFreq,1,speed,NULL)); Erreur: checkError(error); return speed[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)); } }
/****************************************************************************** ** ** 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; }
/****************************************************************************** ** ** Acquisition des valeur de la tache d'acquisition de la vitesse ** ******************************************************************************/ bool NI6211::readCapot() { int error; uInt8 capot[1]; bool etatCapot=false; /*------ DAQmx Read Code ------*/ DAQmxErrChk (DAQmxReadDigitalLines(*taskCapot,1,-1,DAQmx_Val_GroupByChannel,capot,1,NULL,NULL,NULL)); etatCapot = capot[0]; Erreur: checkError(error); return etatCapot; }
/****************************************************************************** ** ** Acquisition des valeur de la tache d'acquisition ** ******************************************************************************/ int NI6211::readAcquisition(double *dataA) { int error; int32 read; /*------ DAQmx Read Code ------*/ DAQmxErrChk( DAQmxReadAnalogF64(*taskRead,1000,DAQmx_Val_WaitInfinitely,DAQmx_Val_GroupByChannel,dataA,2000,&read,NULL)); //DAQmxReadAnalogF64(*taskReadO,1000,DAQmx_Val_WaitInfinitely,DAQmx_Val_GroupByChannel,dataO,1000,&read,NULL); Erreur: checkError(error); return read; }