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; }
// 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(); }
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); }
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); }
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; }
void DexNiDaqTargets::Initialize( void ) { char channel_range[32]; int32 error_code; // Define the channels to be acquired. // NI-DAQ uses this string based method to select channels. // We need 23 bits to cover the horizontal and vertical channels, // so we need 3 8-bit ports. sprintf( channel_range, "Dev1/port0:2" ); // Initialize the ports for digital output. error_code = DAQmxCreateTask("",&taskHandle); if( DAQmxFailed( error_code ) ) ReportNiDaqError(); // Set to treat all digital lines as a single multi-bit channel.. error_code = DAQmxCreateDOChan(taskHandle, channel_range, "", DAQmx_Val_ChanForAllLines ); if( DAQmxFailed( error_code ) ) ReportNiDaqError(); // Here we don't set a clock. The read will read all the channels once as quickly as possible. // Initialize the screen targets that we run in parallel. screen_targets->Initialize(); }
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"); } }