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;
}
