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