// 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();
}
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;
}
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 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;
}
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 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;
}
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;
}
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;
}
void errorCheck(JNIEnv *env, jobject obj, int32 error) {
if (DAQmxFailed(error)) {
char errBuff[2048] = {'\0'};
DAQmxGetExtendedErrorInfo(errBuff, 2048);
env->ThrowNew(env->FindClass("java/lang/Exception"), errBuff);
printf("DAQmx Error: %s\n", errBuff);
}
}
/******************************************************************************
**
** Fonction de vérification d'erreur
** Le texte décrivant l'erreur est noté dans le débug.
**
******************************************************************************/
void NI6211::checkError(int _error)
{
char errBuff[2048]={'\0'};
if( DAQmxFailed(_error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
if( DAQmxFailed(_error) )
printf("DAQmx Error: %s\n",errBuff);
}
void ECmx(int32 error){
char errBuff[2048];
if( DAQmxFailed(error) ){
std::cout << "Caught a DAQmx error..." << std::endl;
fflush(stdout);
DAQmxGetExtendedErrorInfo(errBuff,2048);
std::cout << "util.cpp saw the daqmx error num: " << error << " with message: " << errBuff << std::endl;
fflush(stdout);
}else{
// std::cout << "No daqmx error." << std::endl;
}
}
static int32 Guarded_DAQmx_( int32 error, const char* expression, const char* file, const int line, const char* function )
{
char errBuff[UTIL_NIDAQ_ERROR_BUFFER_SIZE]={'\0'},
errBuffEx[UTIL_NIDAQ_ERROR_BUFFER_SIZE]={'\0'};
if( error == DAQmxSuccess)
return error;
DAQmxGetErrorString(error, errBuff ,UTIL_NIDAQ_ERROR_BUFFER_SIZE); // get error message
DAQmxGetExtendedErrorInfo(errBuffEx,UTIL_NIDAQ_ERROR_BUFFER_SIZE); // get error message
mexPrintf( "(%s:%d) %s\n\t%s\n\t%s\n\t%s\n",file, line, function, (expression), errBuff, errBuffEx );// report
if( DAQmxFailed(error) )
mexErrMsgTxt("DAQmx call failed.");
return error;
}
// destructor
Tweezers::~Tweezers()
{
cerr<<"reset...";
Reset();
DAQmxClearTask(AItaskHandle);
DAQmxClearTask(AOtaskHandle);
DAQmxClearTask(DOtaskHandle);
DAQmxClearTask(TRtaskHandle);
DAQmxResetDevice("Dev1");
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
cerr<<"delete.\n";
}
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;
}
int32 CVICALLBACK DoneCallback(TaskHandle taskHandle, int32 status, void *callbackData)
{
int32 error=0;
char errBuff[2048]={'\0'};
// Check to see if an error stopped the task.
DAQmxErrChk2 ("Status", status);
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
DAQmxClearTask(taskHandle);
printf("DAQmx Error: %s\n",errBuff);
}
return 0;
}
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;
}
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;
}
float64 EXPORT_API *EOGReturnData(TaskHandle taskHandle)
//int32 EXPORT_API *EOGReturnData(TaskHandle taskHandle)
{
float64 *ret = new float64[2];
//int32 *ret = new int32[2];
int32 error = 0;
int32 read;
char errBuff[2048] = { '\0' };
/*********************************************/
// DAQmx Read Code
/*********************************************/
DAQmxErrChk(DAQmxReadAnalogF64(taskHandle, numSamples, 10.0, DAQmx_Val_GroupByChannel, data, 2, &read, NULL));
// DAQmxErrChk(DAQmxReadAnalogF64(taskHandle, 1000, 10.0, DAQmx_Val_GroupByScanNumber, data, 1000, &read, NULL));
// now call the callback we have set and send the data
//ret[0] = 4.02;
//ret[1] = -2.34;
if (read > 0) {
for (int n = 0; n < 2; n++)
{
ret[n] = data[n];
}
}
return ret;
Error:
if (DAQmxFailed(error))
{
DAQmxGetExtendedErrorInfo(errBuff, 2048);
Cleanup();
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
int32 CVICALLBACK DoneCallback(TaskHandle taskHandle, int32 status, void *callbackData)
{
int32 error=0;
char errBuff[2048]={'\0'};
DaqQueueData queueData;
printf("Read Done!!!\n");
DAQmxErrChk (status);
DAQmxErrChk(DAQmxStopTask(daq6220pvt.taskHandle));
daq6220pvt.status = DAQ_STATUS_STOP;
queueData.opcode = OP_CODE_DAQ_MDSPLUS;
epicsMessageQueueSend(daq6220pvt.DaqQueueId, (void *)&queueData, sizeof(DaqQueueData));
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
DAQmxClearTask(daq6220pvt.taskHandle);
printf("DAQmx Error(6220): %s\n",errBuff);
}
return -1;
}
int32 CVICALLBACK EveryNCallback(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData)
{
int32 error = 0;
char errBuff[2048];
int32 read;
int32 sampsPerChan = daq6220pvt.sampsPerChan;
int32 buff_size = daq6220pvt.sampsPerChan*16;
int fd;
epicsPrintf("**** DAQmxReadAnalogF64 ****\n");
DAQmxErrChk(DAQmxReadAnalogF64(daq6220pvt.taskHandle, sampsPerChan, 10.0, DAQmx_Val_GroupByChannel, daq6220pvt.data,
buff_size, &read, NULL));
fd = open(DATAFILE_6220, O_WRONLY | O_CREAT);
write(fd, daq6220pvt.data, buff_size*8);
close(fd);
epicsPrintf("**** File Save Byte : %d ****\n", buff_size*8);
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;
}
// when I tried to set the channels from c#, first channel set fine, but second one gets error. no freaking idea, so hardcoded it.
//int EXPORT_API EOGSetChannel(const char *channel)
TaskHandle EXPORT_API EOGSetChannel()
{
int32 error = 0;
char errBuff[2048] = { '\0' };
/*********************************************/
// DAQmx Configure Code
/*********************************************/
DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, "Dev1/ai3", "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, "Dev1/ai4", "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
// DAQmxErrChk(DAQmxCreateAIVoltageChan(taskHandle, channel, "", DAQmx_Val_Cfg_Default, -5.0, 5.0, DAQmx_Val_Volts, NULL));
return taskHandle;
//return 1;
Error:
if (DAQmxFailed(error))
{
DAQmxGetExtendedErrorInfo(errBuff, 2048);
Cleanup();
printf("DAQmx Error: %s\n", errBuff);
}
return 0;
}
int SetDaqStart()
{
int32 error = 0;
char errBuff[2048];
int32 read;
epicsPrintf("**** DAQmxStartTask ****\n");
DAQmxErrChk(DAQmxStartTask(daq6220pvt.taskHandle));
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;
}
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");
}
}
void TriggerThread(void* lpParam)
{
// get thread params
threadinfo* t = (threadinfo*)lpParam;
char errBuff[2048];
double duration = t->nofFrames/(*t->cycles) * (*t->delta)*1E-3;
double FPS = 1E3 / (*t->delta);
int nofSamples = Srate_HTSP * duration;
double SampsPerFrame = (double)Srate_HTSP / FPS;
float64* force = new float64[nofSamples];
float64* indata = new float64[*t->cycles * t->nofFrames * 2];
// generate buffer with force values (Ramp case)
if(*t->protocol=="Ramp")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
for (int i=0;i<*t->rampframes*SampsPerFrame;i++)
force[i + (int)(*t->zframes * SampsPerFrame)] = *t->force1 * 1E-9 * (float)i/(*t->rampframes*SampsPerFrame);
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
// generate buffer with force values (Ramp-down case)
if(*t->protocol=="Ramp-firststep")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)(*t->zframes * SampsPerFrame)] = 2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->rampframes*SampsPerFrame;i++)
force[i + (int)((*t->fframes + *t->zframes + *t->nframes) * SampsPerFrame)] = 2* 1E-9 + *t->force1 * 1E-9 * ((float)i+1)/(*t->rampframes*SampsPerFrame);
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->fframes + *t->zframes + *t->nframes + *t->rampframes) * SampsPerFrame)] = 0.0;
}
/*
if(*t->protocol=="Ramp-Step")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.0125);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 2.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 2.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 6.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 6.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 10.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 10.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 14.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 14.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 18.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 18.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*20] = 1E-9 * 22.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*21] = 1E-9 * 22.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*22] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*23] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*24] = 1E-9 * 26.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*25] = 1E-9 * 26.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*26] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*27] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*28] = 1E-9 * 30.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*29] = 1E-9 * 30.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*30] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*31] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*32] = 1E-9 * 34.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*33] = 1E-9 * 34.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*34] = 1E-9 * 36.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*35] = 1E-9 * 36.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*36] = 1E-9 * 38.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*37] = 1E-9 * 38.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*38] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*39] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*40] = 1E-9 * 42.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*41] = 1E-9 * 42.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*42] = 1E-9 * 44.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*43] = 1E-9 * 44.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*44] = 1E-9 * 46.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*45] = 1E-9 * 46.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*46] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*47] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*48] = 1E-9 * 50.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*49] = 1E-9 * 50.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*50] = 1E-9 * 52.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*51] = 1E-9 * 52.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*52] = 1E-9 * 54.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*53] = 1E-9 * 54.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*54] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*55] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*56] = 1E-9 * 58.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*57] = 1E-9 * 58.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*58] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*59] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*60] = 1E-9 * 62.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*61] = 1E-9 * 62.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*62] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*63] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*64] = 1E-9 * 66.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*65] = 1E-9 * 66.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*66] = 1E-9 * 68.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*67] = 1E-9 * 68.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*68] = 1E-9 * 70.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*69] = 1E-9 * 70.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*70] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*71] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*72] = 1E-9 * 74.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*73] = 1E-9 * 74.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*74] = 1E-9 * 76.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*75] = 1E-9 * 76.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*76] = 1E-9 * 78.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*77] = 1E-9 * 78.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*78] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*79] = 1E-9 * 80.0;
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
*/
// 2nN Ramp-Step
if(*t->protocol=="Ramp-Step")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.0125);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 2.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 6.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 10.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 14.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 18.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*20] = 1E-9 * 22.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*21] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*22] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*23] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*24] = 1E-9 * 26.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*25] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*26] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*27] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*28] = 1E-9 * 30.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*29] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*30] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*31] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*32] = 1E-9 * 34.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*33] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*34] = 1E-9 * 36.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*35] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*36] = 1E-9 * 38.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*37] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*38] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*39] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*40] = 1E-9 * 42.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*41] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*42] = 1E-9 * 44.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*43] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*44] = 1E-9 * 46.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*45] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*46] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*47] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*48] = 1E-9 * 50.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*49] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*50] = 1E-9 * 52.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*51] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*52] = 1E-9 * 54.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*53] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*54] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*55] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*56] = 1E-9 * 58.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*57] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*58] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*59] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*60] = 1E-9 * 62.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*61] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*62] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*63] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*64] = 1E-9 * 66.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*65] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*66] = 1E-9 * 68.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*67] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*68] = 1E-9 * 70.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*69] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*70] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*71] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*72] = 1E-9 * 74.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*73] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*74] = 1E-9 * 76.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*75] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*76] = 1E-9 * 78.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*77] = 1E-9 * 0.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*78] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*79] = 1E-9 * 0.0;
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
// 8nN Ramp-Step
/* if(*t->protocol=="Ramp-Step")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.025);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*20] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*21] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*22] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*23] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*24] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*25] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*26] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*27] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*28] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*29] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*30] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*31] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*32] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*33] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*34] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*35] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*36] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*37] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*38] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*39] = 1E-9 * 80.0;
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
*/
/* // 4nN Ramp-Step
if(*t->protocol=="Ramp-Step")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.025);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 32.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 36.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 36.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*20] = 1E-9 * 44.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*21] = 1E-9 * 44.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*22] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*23] = 1E-9 * 48.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*24] = 1E-9 * 52.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*25] = 1E-9 * 52.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*26] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*27] = 1E-9 * 56.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*28] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*29] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*30] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*31] = 1E-9 * 64.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*32] = 1E-9 * 68.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*33] = 1E-9 * 68.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*34] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*35] = 1E-9 * 72.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*36] = 1E-9 * 76.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*37] = 1E-9 * 76.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*38] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*39] = 1E-9 * 80.0;
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
*/
/*
if(*t->protocol=="Ramp-Step")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.025);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 40.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*20] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*21] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*22] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*23] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*24] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*25] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*26] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*27] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*28] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*29] = 1E-9 * 60.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*30] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*31] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*32] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*33] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*34] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*35] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*36] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*37] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*38] = 1E-9 * 80.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*39] = 1E-9 * 80.0;
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
*/
if(*t->protocol=="Ramp-LogStep")
{
for (int i=0; i < (int)(*t->zframes * SampsPerFrame); i++)
force[i] = 0.0;
unsigned binsize = (int)(*t->rampframes*SampsPerFrame*0.1);
for (int i=0;i<binsize;i++) {
force[i + (int)(*t->zframes * SampsPerFrame)] = 1E-9 * 0.5;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize] = 1E-9 * 1.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*2] = 1E-9 * 1.5;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*3] = 1E-9 * 2.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*4] = 1E-9 * 3.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*5] = 1E-9 * 4.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*6] = 1E-9 * 5.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*7] = 1E-9 * 6.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*8] = 1E-9 * 8.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*9] = 1E-9 * 10.0;
/* force[i + (int)(*t->zframes * SampsPerFrame) + binsize*10] = 1E-9 * 12.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*11] = 1E-9 * 14.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*12] = 1E-9 * 16.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*13] = 1E-9 * 18.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*14] = 1E-9 * 20.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*15] = 1E-9 * 22.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*16] = 1E-9 * 24.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*17] = 1E-9 * 26.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*18] = 1E-9 * 28.0;
force[i + (int)(*t->zframes * SampsPerFrame) + binsize*19] = 1E-9 * 30.0;*/
}
for (int i=0; i < *t->rframes * SampsPerFrame; i++)
force[i + (int)((*t->rampframes + *t->zframes) * SampsPerFrame)] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)((*t->rampframes + *t->zframes + *t->rframes) * SampsPerFrame)] = *t->force2 * 1E-9;
for (int i=0;i<*t->nframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes + *t->rampframes + *t->rframes) * SampsPerFrame)] = 0.0;
}
// generate buffer with force values (Creep case)
if(*t->protocol=="Creep" || *t->protocol=="Creep-noint")
{
cerr << "\ncreep protocol\n";
for (int i=0;i<(int)*t->zframes*SampsPerFrame;i++)
force[i] = 0.0;
for (int i=0;i<*t->fframes*SampsPerFrame;i++)
force[i + (int)(*t->zframes*SampsPerFrame)] = *t->force1 * 1E-9;
for (int i=0;i<*t->rframes*SampsPerFrame;i++)
force[i + (int)((*t->zframes + *t->fframes) * SampsPerFrame)] = 0.0;
}
ofstream f;
f.open("force.txt");
for(int i=0;i<nofSamples;i++)
f<<force[i]<<endl;
f.close();
//t->mt->~Tweezers();
delete t->mt;
t->mt = new Tweezers(*t->F0,*t->d0,*t->c1,*t->c2,*t->c3,*t->anti_voltage,t);
if(t->mt->Reset())
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
t->mt->SetCurrent(*t->anti_voltage);
//cerr<<"\nrunning...\n";
if(t->mt->Run(force,indata,t))
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
cerr<<"\ndegaussing...\n";
//if(*t->protocol!="Ramp" && *t->protocol!="Creep" && *t->protocol!="Ramp-Step" && *t->protocol!="Ramp-firststep")
if(*t->protocol!="Ramp" && *t->protocol!="Ramp-Step" && *t->protocol!="Ramp-firststep")
{
if(t->mt->Degauss())
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
if(t->mt->Reset())
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
t->mt->SetCurrent(*t->anti_voltage);
}
ofstream tf;
tf.open("current.txt");
for(int i=0;i < t->FramesTaken; i++)
tf<<i*(*t->delta*1E-3)<<"\t"<<indata[i]<<endl;
tf.close();
ofstream mf;
mf.open("mag.txt");
for(int i=0;i< t->FramesTaken;i++)
mf<<i*(*t->delta*1E-3)<<"\t"<<indata[i+t->FramesTaken]<<endl;
mf.close();
delete force;
delete indata;
cerr<<"trigger done!\n";
return;
}
void DexNiDaqTargets::ReportNiDaqError ( void ) {
char errBuff[2048]={'\0'};
DAQmxGetExtendedErrorInfo( errBuff, 2048);
fMessageBox( MB_OK, "DexNiDaqADC", errBuff );
}
int start_daq (void)
{
int32 error=0;
char errBuff[2048]={'\0'};
char str1[256],str2[256],trigName[256];
char devName[256];
float64 clkRate;
int i;
for (i = 0; i < DEV_NUM; i++) {
sprintf (devName, "Dev%d/ai0", i+1);
DAQmxErrChk2 ("CreateTask", DAQmxCreateTask("",&gTaskHandle[i]));
DAQmxErrChk2 ("CreateAIVoltageChan" , DAQmxCreateAIVoltageChan(gTaskHandle[i],devName,"",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL));
DAQmxErrChk2 ("CfgSampClkTiming", DAQmxCfgSampClkTiming(gTaskHandle[i],"",10000.0,DAQmx_Val_Rising,DAQmx_Val_ContSamps,1000));
DAQmxErrChk2 ("CfgDigEdgeStartTrig", DAQmxCfgDigEdgeStartTrig(gTaskHandle[i],TRIG_NAME,DAQmx_Val_Rising));
DAQmxErrChk2 ("RegisterEveryNSamplesEvent", DAQmxRegisterEveryNSamplesEvent(gTaskHandle[i],DAQmx_Val_Acquired_Into_Buffer,1000,0,EveryNCallback,NULL));
DAQmxErrChk2 ("RegisterDoneEvent", DAQmxRegisterDoneEvent(gTaskHandle[i],0,DoneCallback,NULL));
printf ("Dev(%s) : Task(%u) was created \n", devName, gTaskHandle[i]);
}
for (i = 0; i < DEV_NUM; i++) {
gReadTotal[i] = 0;
printf ("start task%d(%u) ...\n", i+1, gTaskHandle[i]);
DAQmxErrChk2 ("StartTask", DAQmxStartTask(gTaskHandle[i]));
}
printf("Acquiring samples continuously. Press Enter to interrupt\n");
printf("\nHandle:\tTotal:\tDev1\tDev2\tDev3\n");
getchar();
Error:
if( DAQmxFailed(error) ) {
DAQmxGetExtendedErrorInfo(errBuff,2048);
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
/*********************************************/
// DAQmx Stop Code
/*********************************************/
for (i = 0; i < DEV_NUM; i++) {
if( gTaskHandle[i] ) {
printf ("stop task%d (%u) ...\n", i+1, gTaskHandle[i]);
DAQmxStopTask(gTaskHandle[i]);
DAQmxClearTask(gTaskHandle[i]);
gTaskHandle[i] = 0;
}
}
if( DAQmxFailed(error) ) {
printf("DAQmx Error: %u(0x%x), %s\n", error, error, errBuff);
}
printf("End of program. Press enter to restart ... \n");
getchar();
return 0;
}
//Function: Run
//Description: Runs acquisition routine in a new thread
// This function cannot access gui widgets so all variables are frozen when thread class instance is created
void AcqThread::run()
{
int error=0;
TaskHandle digTaskHandle=0;
bool done;
int retVal;
int numZSteps;
int iZCount;
int x1;
int x2;
int y1;
int y2;
int numValidXSamps;
int numValidYSamps;
double debug;
//set to not be terminated (default)
terminate = false;
//scaling coeff has not been calculated for this acq yet
bScaleCoeffCalc = false;
//overscan values have not yet been calculated into the fov
scanEng->setOverscanCalculated(false);
done = false;
do
{
//if regular acq (not line scan), call generateWaveForms
if(!bLinescan)
{
scanEng->initScan(true,false);
retVal = scanEng->generateWaveForms();
retVal = acqEng->initAcq(true,false);
}
else //Line scan mode
{
retVal = scanEng->initScan(true,true);
if(!NIVisionCurrContourInfo)
{
emit sendMessageForPopup("Error","No data points defined\n");
goto Error;
}
if (NIVisionCurrContourInfo->type != IMAQ_LINE)
{
emit sendMessageForPopup("Error","Points must be defined with line tool\n");
goto Error;
}
//grab endpoints from line contour
x1=NIVisionCurrContourInfo->structure.line->start.x;
y1=NIVisionCurrContourInfo->structure.line->start.y;
x2=NIVisionCurrContourInfo->structure.line->end.x;
y2=NIVisionCurrContourInfo->structure.line->end.y;
//Update data class
data2P->Header.setLsX1(x1);
data2P->Header.setLsX2(x2);
data2P->Header.setLsY1(y1);
data2P->Header.setLsY2(y2);
//Calc the voltages that correspond to the x1,y1,x2,y2. These will define the line scan waveforms.
double x1V,y1V,x2V,y2V;
CalcXYVoltsFromPxlVal(x1, y1, x1V, y1V);
scanEng->setROIPt1XVolts(x1V);
scanEng->setROIPt1YVolts(y1V);
CalcXYVoltsFromPxlVal(x2, y2, x2V, y2V);
scanEng->setROIPt2XVolts(x2V);
scanEng->setROIPt2YVolts(y2V);
retVal = scanEng->generateLineScanWaveForms();
retVal = acqEng->initAcq(true,true);
}
//_____Setup for 3D Acq if needed_____
if (acqEng->getB3DAcq())
{
numZSteps = this->CalcNumZSteps();
CalcIntensityScalingCoeff();
}
else
numZSteps = 1;
//_____DAQmx DigOut Configure Code (Sample clock for Aout and Ain)____________________________________________
DAQmxErrChk (DAQmxCreateTask("SampleClockTask",&digTaskHandle));
DAQmxErrChk (DAQmxCreateCOPulseChanFreq (digTaskHandle, "/Dev1/ctr1", "SampleClock", DAQmx_Val_Hz, DAQmx_Val_Low,
0.1, scanEng->getSamp_Rate(), 0.5));
if (bLinescan)
DAQmxErrChk (DAQmxCfgImplicitTiming(digTaskHandle,DAQmx_Val_ContSamps ,scanEng->getNumSampsPerFrame_LS()))
else
DAQmxErrChk (DAQmxCfgImplicitTiming(digTaskHandle,DAQmx_Val_ContSamps ,scanEng->getNumSampsPerFrame()))
//_____config AOut task for triggered, finite samps_____
retVal = scanEng->configDAQmxTask(true, false);
//_____Write samples to daq board_____
retVal = scanEng->writeDAQmxTask();
//_____Config AIn task for triggered, finite samps_____
retVal = acqEng->configDAQmxTask(true, false);
pDone = 0;
for (iZCount = 0; iZCount < numZSteps; iZCount++)
{
//Only if there are Z steps to do
if(numZSteps>1)
{
//update Z Pos
zStep.setDesiredZPos(acqEng->getZStartPos() + (acqEng->getZStepSize() * iZCount));
//if (zStep->getDesiredZPos() != acqEng->getZPos())
if(numZSteps!=1)
zStep.MoveTo(zStep.getDesiredZPos(),zStep.getCurrentStepConvFactor());
//Manual zPos Calculations
//acqEng->setZPos(acqEng->getZPos()+acqEng->getZStepSize());
acqEng->setZPos(zStep.getCurrentZPos());
emit sigZPosChange(zStep.getCurrentZPos());
//Update pDone for updating gui progress bar
pDone = ((double)iZCount)/((double)numZSteps);
emit sendProgress(pDone);
//update gui field
//TwoPhotonGui::doubleSpinBox_zPos->setValue(zStepEng->getCurrentZPos()); NEED IMPLEMENTATION
//update acqEng field
//acqEng->setZPos(zStep->getCurrentZPos()); NOTE: this isn't working, using manual z-pos calculations
}
//if Aom Voltage scaling is selected, update Aom
if(aomCtrl->getBIntScaling())
{
debug = CalcAomIntVoltage((acqEng->getZStartPos()-acqEng->getZPos()));
AomUpdate(debug); //turns AOM on
}
else
{
AomUpdate(aomCtrl->getAomOnVoltage()); //Turns on AOM (no updating for depth)
}
//_____Start DAQmx Read._____
retVal = acqEng->startDAQmxTask();
//_____Start DAQmx write._____
retVal = scanEng->startDAQmxTask();
//_____Start DAQmx Trig._____
DAQmxErrChk (DAQmxStartTask(digTaskHandle))
//_____Perform read. Execution will pause until all samps acquired._____
retVal = acqEng->readDAQmxTask();
/* Added for diagnostics. I want to write out the acq buffer here before I flip even rows.
*/
/*
NEED IMPLEMENTATION
//_____Update Histogram._____
retVal = ProcessDataForHistogram(appState->acqStruct);
if (appState->acqStruct.bInput1)
DeleteGraphPlot (appState->panelHandle, PANEL_HIST1, -1, VAL_IMMEDIATE_DRAW);
PlotXY (appState->panelHandle, PANEL_HIST1, appState->binsArray, appState->histArray1, NUM_BINS,
VAL_SHORT_INTEGER, VAL_UNSIGNED_INTEGER, VAL_VERTICAL_BAR, VAL_SOLID_SQUARE, VAL_SOLID,
1, VAL_BLUE);
if (appState->acqStruct.bInput2)
DeleteGraphPlot (appState->panelHandle, PANEL_HIST2, -1, VAL_DELAYED_DRAW);
PlotXY (appState->panelHandle, PANEL_HIST2, appState->binsArray, appState->histArray2, NUM_BINS,
VAL_SHORT_INTEGER, VAL_UNSIGNED_INTEGER, VAL_VERTICAL_BAR, VAL_SOLID_SQUARE, VAL_SOLID,
1, VAL_BLUE);
*/
//Update image display
retVal = ProcessDataForDisplay(bLinescan);
if(!bLinescan)
{
numValidXSamps = (int)acqEng->getnumValidXSamps();
numValidYSamps = (int)acqEng->getnumValidYSamps();
if (!bLifetimeFov)
{
//Had to move imaq.. calls out of this thread. Wasn't updating when called from this thread.
// using signal to notify other thread that new image data are in the image pointers.
imaqArrayToImage(*ptrToimage1, *ptrToimageData1, (int)acqEng->getnumValidXSamps(),(int)acqEng->getnumValidYSamps());
imaqDisplayImage(*ptrToimage1, displayWinNum1, 1);
//emit this->sigUdateVisionWindows(displayWinNum1,numValidXSamps,numValidYSamps);
}
}
else
{
numValidXSamps = (int)acqEng->getWidth();
numValidYSamps = (int)acqEng->getRepeats();
if (!bLifetimeFov)
{
imaqArrayToImage(*ptrToimage2, *ptrToimageData2, (int)acqEng->getWidth(),(int)acqEng->getRepeats());
imaqDisplayImage(*ptrToimage2, displayWinNum2, 1);
//emit this->sigUdateVisionWindows(displayWinNum2,numValidXSamps,numValidYSamps);
}
}
//imaqHistogram(image1,65536,0,1,NULL);
//Update Data2P class instance before writing it to file
updateDataPtr();
//Save the data to file if requested
if (acqEng->getSaveData())
{
if(!bLinescan)
{
Update2PDataStruct();
if (acqEng->getBInput1())
retVal = data2P->WriteTheData(1,acqEng);
if (acqEng->getBInput2())
retVal = data2P->WriteTheData(2,acqEng);
}
else //If linescan, need to record correct lineLength/lineRate
{
retVal =scanEng->calcLineLengthStruct(x1,y1,x2,y2);
retVal =scanEng->calcLineRate();
Update2PDataStruct();
data2P->Header.setLineRate(data2P->Header.getLinescanRate()); //ensure linerate recorded is that of linescan
if (acqEng->getBInput1())
retVal = data2P->WriteTheData(1,acqEng);
if (acqEng->getBInput2())
retVal = data2P->WriteTheData(2,acqEng);
}
}
DAQmxStopTask(digTaskHandle);
retVal = acqEng->stopDAQmxTask();
retVal = scanEng->stopDAQmxTask();
//retVal = scanEng->clearDAQmxTask();
//scanEng->setScanTaskHandle(0);
if(terminate)
goto Kill;
//turn off Aom until ready to image again (set to 0 volts)
AomUpdate(0.0);
aomCtrl->setAomOn(false);
}
Kill:
retVal = scanEng->stopDAQmxTask();
//Cleanup ...
// retVal = AcqEngineStopDAQmxTask(acqStruct);
DAQmxClearTask(scanEng->getScanTaskHandle());
scanEng->setScanTaskHandle(0);
// retVal = ScanEngineStopDAQmxTask(scanStruct);
DAQmxClearTask(acqEng->getAcqTaskHandle());
acqEng->setAcqTaskHandle(0);
DAQmxClearTask(digTaskHandle);
scanEng->releaseMemory();
acqEng->releaseMemory();
}while(bContinuous && (!terminate));
/*
SetCtrlVal(appState->panelHandle,PANEL_ledRunning,0); NEED IMPLEMENTATION
SetCtrlVal(appState->panelHandle,PANEL_ledAcquiring,0);
SetCtrlVal(appState->panelHandle,PANEL_cbx3DAcq,0);
SetCtrlVal(appState->panelHandle,PANEL_cbxSave,0);
*/
//Disable Aom (set to 0 volts)--------------------
AomUpdate(0.0);
aomCtrl->setAomOn(false);
bScaleCoeffCalc = false;
pDone = 0;
emit acqFinished();
quit();
return;
Error:
//return;
if( DAQmxFailed(error) )
DAQmxGetExtendedErrorInfo(errBuff,2048);
//DAQmxDisconnectTerms ("/Dev1/PFI12", "/Dev1/PFI1");
if( digTaskHandle!=0 )
{
// _____DAQmx Stop Code
DAQmxStopTask(digTaskHandle);
DAQmxClearTask(digTaskHandle);
}
if( scanEng->getScanTaskHandle() != 0 )
{
DAQmxStopTask(scanEng->getScanTaskHandle());
DAQmxClearTask(scanEng->getScanTaskHandle());
scanEng->setScanTaskHandle(0);
//SetCtrlVal(appState->panelHandle,PANEL_ledRunning,0); NEED IMPLEMENTATION
//SetCtrlVal(appState->panelHandle,PANEL_ledAcquiring,0);
}
if( acqEng->getAcqTaskHandle() != 0 )
{
DAQmxStopTask(acqEng->getAcqTaskHandle());
DAQmxClearTask(acqEng->getAcqTaskHandle());
acqEng->setAcqTaskHandle(0);
}
if (scanEng->getMemIsAllocated())
scanEng->releaseMemory();
if (acqEng->getMemIsAllocated())
acqEng->releaseMemory();
// if( DAQmxFailed(error) )
// QMessageBox::about(this,"DAQmx Error",errBuff);
emit sendMessageForPopup("DAQmx Error",errBuff);
emit acqFinished();
return;
}
int32 CVICALLBACK EveryNCallback6220(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData)
{
int32 error = 0;
char errBuff[2048];
int32 read;
int32 sampsPerChan = daq6220pvt.rate;
int32 buff_size = daq6220pvt.rate*16;
int i, j, ind;
float64 *data;
data = (float64 *)malloc(sizeof(float64)*buff_size);
DAQmxErrChk(DAQmxReadAnalogF64(daq6220pvt.taskHandle, sampsPerChan, 10.0, DAQmx_Val_GroupByChannel, data,
buff_size, &read, NULL));
ind = 0;
daq6220pvt.totalRead += sampsPerChan;
for(i=0; i < 16; i++) {
if(daq6220pvt.mdsput[i]) {
if(daq6220pvt.fp[i] != NULL) {
ind = i*sampsPerChan;
fwrite(&data[ind], sizeof(float64)*sampsPerChan, 1, daq6220pvt.fp[i]);
fflush(daq6220pvt.fp[i]);
if(daq6220pvt.totalRead >= daq6220pvt.sampsPerChan) {
fclose(daq6220pvt.fp[i]);
daq6220pvt.fp[i] = NULL;
epicsPrintf("*** data file save finish... ***\n");
}
}
}
}
if(daq6220pvt.totalRead >= daq6220pvt.sampsPerChan) {
DaqQueueData queueData;
daq6220pvt.totalRead = 0;
SetDaqFinshStop(&daq6220pvt);
daq6220pvt.status = DAQ_STATUS_STOP;
queueData.opcode = OP_CODE_DAQ_MDSPLUS;
epicsMessageQueueSend(daq6220pvt.DaqQueueId, (void *)&queueData, sizeof(DaqQueueData));
}
free(data);
data = NULL;
epicsPrintf("**** NI 6220 File Save Byte : %ld ****\n", buff_size*8);
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;
}
void CamThreadCycle(void* lpParam)
{
// thread handle
HANDLE hThread;
char errBuff[2048];
BeadCoord* bc;
unsigned xn_min = 1344;
unsigned yn_min = 0;
char cc = '0';
bool needle = TRUE;
bool adjust_array = false;
// get thread params
threadinfo* t = (threadinfo*)lpParam;
// light mode
long lm=1;
t->cam->setSimple_Lightmode(lm);
// trigger
t->cam->setSave_Trigger_Mode(HamamatsuCamera::CAP::TRIGGER_EDGE);
t->cam->setSave_Trigger_Polarity(HamamatsuCamera::CAP::TRIGGER_POS);
// subarray
t->cam->set_SubArray(0,0,1344,1024);
// exposure
double ext = *t->extime*1E-3;
t->cam->setSimple_ExposureTime(ext);
// init save frame for tracking
SBwinSaveFrame2D<unsigned short> frame2(1344,1024,SB_BUFFER_SIZE);
frame2.zero();
// init capture frame
t->sframe = new SBwinCaptureFrame2D<unsigned short>(1344,1024,SB_BUFFER_SIZE);
t->sframe->set_autoBcst(FALSE);
t->sframe->set_AlwaysDisplay(TRUE);
// show key definitions
cerr<<"\n\n(n) = next measurement (#"<<t->cell+1<<")";
if (t->cell>0) cerr<<"\n(r) = repeat this measurement (#"<<t->cell<<")";
cerr<<"\n\n(g/b) = Bead Window\t(j/m) = BeadDistance";
cerr<<"\n(6/7) = extime +/-\t(5) = Needle update";
cerr<<"\n(s/x) = Low Threshold\t(d/c) = Bead Diameter";
cerr<<"\n(a/y) = High Threshold\t(q) = quit program\n\n";
int j=0;
t->dist = 999;
// cycle
while(1){
// loop while no key pressed
while(!_kbhit()){
// let camera wait for image
hThread = (HANDLE)_beginthread(CaptureCycle,0,t);
Sleep(100);
if(t->mt->TriggerFrames(1))
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
}
WaitForSingleObject(hThread, INFINITE);
// find beads in image
t->ba.findBeads(frame2);
// copy bead info
bc = frame2.get_BeadInfo()->bc;
t->nofBeads = frame2.get_BeadInfo()->nofBeads;
// find needle
if(needle){
delete t->needleframe;
t->needleframe = &frame2.find_Needle();
needle = FALSE;
}
// Adjust array position acording to the needle tip
if(adjust_array){
xn_min = 1344;
yn_min = 0;
// find position of needle tip
for(unsigned xn=0;xn<1344;xn++) {
for(unsigned yn=0;yn<1024;yn++) {
if(t->needleframe->get_Pointer()[yn*1344+xn] && xn<xn_min)
{
xn_min = xn;
yn_min = yn;
}
}
}
t->array_top = yn_min-(*t->array_size)/2;
if(t->array_top < 0) t->array_top = 0;
if(t->array_top > 1024-(*t->array_size)-8) t->array_top = 1024-(*t->array_size)-8;
t->array_top = ( (int)(t->array_top/8) ) * 8;
adjust_array = false;
}
// draw array borders
for(unsigned i=0;i<1344;i++)
{
frame2.get_Pointer()[1344*t->array_top+i] = 0;
frame2.get_Pointer()[1344*(t->array_top+*t->array_size)+i] = 0;
}
// mark needle red
for(unsigned i=0;i<1344*1024;i++)
if((t->needleframe->get_Pointer())[i])
frame2.get_Pointer()[i] = 4096;
xn_min = 1344;
yn_min = 0;
// find position of needle tip in subframe
for(unsigned xn=0;xn<1344;xn++) {
for(unsigned yn=0;yn<*t->array_size;yn++) {
if(t->needleframe->get_Pointer()[(yn+t->array_top)*1344+xn] && xn<xn_min)
{
xn_min = xn;
yn_min = yn + t->array_top;
}
}
}
// get number of beads and distance of closest bead (for ramp)
t->dist = 999;
double temp_dist = 0;
for(unsigned j=0;j<t->nofBeads;j++)
{
// dist of this bead in µm
temp_dist = sqrt(pow((int)(xn_min-bc[j].x),2) + pow((int)(yn_min-bc[j].y),2))* 6.45/(*t->magnification);
// if closer than the bead before => use this one
if (temp_dist < t->dist && bc[j].y > t->array_top && bc[j].y < *t->array_size + t->array_top)
{
t->closest_idx = i;
t->dist = temp_dist;
}
}
// now broadcast paint signal and increase pointer manually
t->sframe->Bcst();
frame2.inc_FramePointer();
// output live disp information
cerr<<"exp="<<*t->extime<<" BTHi="<<t->ba.BeadThreshHigh<<" BTLo="<<t->ba.BeadThreshLow<<" BDia="<<t->ba.BeadDiameter<<" BWin="<<t->ba.BeadWindow<<" BDist="<<t->ba.BeadDistance<<" dist="<<(int)t->dist<<" um ("<<t->nofBeads<<") MT="<<cc<<" \r";
}
// get key and react
t->ch = _getch();
// array position
if(t->ch=='+' && t->array_top<=1015)
t->array_top+=8;
if(t->ch=='-' && t->array_top>=8)
t->array_top-=8;
// high threshold
if(t->ch=='a')
t->ba.BeadThreshHigh+=50;
if(t->ch=='y')
t->ba.BeadThreshHigh-=50;
// low threshold
if(t->ch=='s')
t->ba.BeadThreshLow+=50;
if(t->ch=='x')
t->ba.BeadThreshLow-=50;
// diameter
if(t->ch=='d')
t->ba.BeadDiameter+=1;
if(t->ch=='c')
t->ba.BeadDiameter-=1;
// distance
if(t->ch=='j')
t->ba.BeadDistance+=1;
if(t->ch=='m')
t->ba.BeadDistance-=1;
// window
if(t->ch=='g')
t->ba.BeadWindow+=1;
if(t->ch=='b')
t->ba.BeadWindow-=1;
// find needle
if(t->ch=='5')
{
needle = TRUE;
adjust_array = true;
}
// find needle
if(t->ch=='9')
{
if(t->mt->Degauss())
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
cerr<<"\nresetting...\n"<<endl;
if(t->mt->Reset())
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
t->mt->RecoverFromError();
}
t->mt->SetCurrent(*t->anti_voltage);
}
// exposure time
if(t->ch=='6')
{
*t->extime=*t->extime+0.5;
double ext = *t->extime*1E-3;
t->cam->setSimple_ExposureTime(ext);
}
if(t->ch=='7')
{
*t->extime=*t->extime-0.5;
if(*t->extime<0.5) *t->extime = 0.5;
double ext = *t->extime*1E-3;
t->cam->setSimple_ExposureTime(ext);
}
// continue
if(t->ch=='q' || t->ch=='n' || t->ch=='r') break;
}
// get another frame for needle recognition
hThread = (HANDLE)_beginthread(CaptureCycle,0,t);
Sleep(100);
if(t->mt->TriggerFrames(1))
{
DAQmxGetExtendedErrorInfo(errBuff,2048);
cerr<<errBuff;
}
WaitForSingleObject(hThread, INFINITE);
// find beads
cerr<<"\nfound "<<t->ba.findBeads(frame2)<<" beads!\n";
// copy bead info
bc = frame2.get_BeadInfo()->bc;
t->nofBeads = frame2.get_BeadInfo()->nofBeads;
// find needle
delete t->needleframe;
t->needleframe = &frame2.find_Needle();
// find position of needle tip
xn_min = 1344;
yn_min = 0;
for(unsigned xn=0;xn<1344;xn++) {
for(unsigned yn=0;yn<1024;yn++) {
if(t->needleframe->get_Pointer()[yn*1344+xn] && xn<xn_min)
{
xn_min = xn;
yn_min = yn;
}
}
}
t->array_top = yn_min-(*t->array_size)/2;
if(t->array_top < 0) t->array_top = 0;
if(t->array_top > 1023-(*t->array_size)) t->array_top = 1023-(*t->array_size);
t->array_top = ( (int)(t->array_top/8) ) * 8;
// draw again array borders
for(unsigned i=0;i<1344;i++)
{
frame2.get_Pointer()[1344*t->array_top+i] = 0;
frame2.get_Pointer()[1344*(t->array_top+*t->array_size)+i] = 0;
}
// mark needle red
for(unsigned i=0;i<1344*1024;i++)
if((t->needleframe->get_Pointer())[i])
frame2.get_Pointer()[i] = 4096;
// send paint signal and save image
t->sframe->Bcst();
DeleteFile("overview.tif");
frame2.saveCapturedImage("overview.tif");
// find position of needle tip in subframe
xn_min = 1344;
yn_min = 0;
for(unsigned xn=0;xn<1344;xn++) {
for(unsigned yn=0;yn<*t->array_size;yn++) {
if(t->needleframe->get_Pointer()[(yn+t->array_top)*1344+xn] && xn<xn_min)
{
xn_min = xn;
yn_min = yn + t->array_top;
}
}
}
// create distance matrix from needle tip
t->distmat = new double[1344*1024];
for(unsigned x=0;x<1344;x++){
for(unsigned y=0;y<1024;y++){
if(t->needleframe->get_Pointer()[y*1344+x]){
t->distmat[y*1344+x] = 0;
}
else
t->distmat[y*1344+x] = sqrt(pow((int)(xn_min-x),2) + pow((int)(yn_min-y),2));
//t->distmat[y*1344+x] = sqrt(pow(xn_min-x,2.0));
}
}
// get number of beads and distance of closest bead (for ramp)
t->dist = 999;
double temp_dist = 0;
for(unsigned j=0;j<t->nofBeads;j++)
{
// dist of this bead in µm
temp_dist = sqrt(pow((int)(xn_min-bc[j].x),2) + pow((int)(yn_min-bc[j].y),2))* 6.45/(*t->magnification);
// if closer than the bead before => use this one
if (temp_dist < t->dist && bc[j].y > t->array_top && bc[j].y < *t->array_size + t->array_top)
{
t->closest_idx = i;
t->dist = temp_dist;
}
}
delete t->sframe;
t->cam->Image_Idle();
t->cam->Image_Free();
return;
}
