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; }
/****************************************************************************** ** ** 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); }
int main(void) { int32 error=0; TaskHandle taskHandle=0; int32 read; float64 data[1000]; char errBuff[2048]={'\0'}; int i; /*********************************************/ // DAQmx Configure Code /*********************************************/ DAQmxErrChk (DAQmxCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxCreateAIVoltageChan(taskHandle,"Dev1/ai0","",DAQmx_Val_Cfg_Default,-10.0,10.0,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxCfgSampClkTiming(taskHandle,"",10000.0,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,1000)); /*********************************************/ // DAQmx Start Code /*********************************************/ DAQmxErrChk (DAQmxStartTask(taskHandle)); /*********************************************/ // DAQmx Read Code /*********************************************/ DAQmxErrChk (DAQmxReadAnalogF64(taskHandle,1000,10.0,DAQmx_Val_GroupByChannel,data,1000,&read,NULL)); printf("Acquired %d points\n",read); for (i = 0; i < 1000; i++) { printf ("data[%d] = %f\n", i, data[i]); } Error: if( DAQmxFailed(error) ) DAQmxGetExtendedErrorInfo(errBuff,2048); if( taskHandle!=0 ) { /*********************************************/ // DAQmx Stop Code /*********************************************/ DAQmxStopTask(taskHandle); DAQmxClearTask(taskHandle); } if( DAQmxFailed(error) ) printf("DAQmx Error: %s\n",errBuff); printf("End of program, press Enter key to quit\n"); getchar(); return 0; }
int EXPORT_API EOGStopTask(TaskHandle taskHandle) { int32 error = 0; char errBuff[2048] = { '\0' }; if (taskHandle != 0) { DAQmxErrChk(DAQmxStopTask(taskHandle)); DAQmxClearTask(taskHandle); return 1; } else { return 2; } Error: if (DAQmxFailed(error)) { DAQmxGetExtendedErrorInfo(errBuff, 2048); Cleanup(); printf("DAQmx Error: %s\n", errBuff); } return 0; }
void DexNiDaqTargets::Quit( void ) { int32 error_code; if( taskHandle!=0 ) { // I think that the task stops itself after the read, but I'm not sure. // In any case, it doesn't seem to hurt to do this. error_code = DAQmxStopTask(taskHandle); if( DAQmxFailed( error_code )) ReportNiDaqError(); // I don't know what happens if you don't clear a task before leaving, // but the NI examples says to do it, so I do it. error_code = DAQmxClearTask(taskHandle); if( DAQmxFailed( error_code ) ) ReportNiDaqError(); } screen_targets->Quit(); }
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; }
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; }
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; }
int main (int argc, char *argv[]) { // Task parameters int32 error = 0; TaskHandle taskHandle = 0; char errBuff[2048]= {'\0'}; int32 i; // Channel parameters char chan[] = "Dev1/ai0"; float64 min = -10.0; float64 max = 10.0; // Timing parameters char source[] = "OnboardClock"; uInt64 samplesPerChan = 100; float64 sampleRate = 1200.0; // Data read parameters #define bufferSize (uInt32)1000 float64 data[bufferSize]; int32 pointsToRead = -1; int32 pointsRead; float64 timeout = 10.0; while(1) { printf("new task\n\n"); DAQmxErrChk (DAQmxBaseCreateTask ("", &taskHandle)); DAQmxErrChk (DAQmxBaseCreateAIVoltageChan (taskHandle, chan, "", DAQmx_Val_NRSE, min, max, DAQmx_Val_Volts, NULL)); DAQmxErrChk (DAQmxBaseCfgSampClkTiming (taskHandle, source, sampleRate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, samplesPerChan)); DAQmxErrChk (DAQmxBaseStartTask (taskHandle)); DAQmxErrChk (DAQmxBaseReadAnalogF64 (taskHandle, pointsToRead, timeout, 0, data, bufferSize, &pointsRead, NULL)); printf("pointsRead: %d\n",pointsRead); // Just print out the first 10 points for (i = 0; i < 8; ++i) { printf ("%f\n", data[i]); } DAQmxBaseStopTask (taskHandle); DAQmxBaseClearTask (taskHandle); } Error: if (DAQmxFailed (error)) DAQmxBaseGetExtendedErrorInfo (errBuff, 2048); if (taskHandle != 0) { DAQmxBaseStopTask (taskHandle); DAQmxBaseClearTask (taskHandle); } if (error) printf ("DAQmxBase Error %d: %s\n", error, errBuff); return 0; }
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); } }
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; } }
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; }
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; }
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; }
int DoneStartle(void) { if( startleDaqHandle!=0 ) { /*********************************************/ // DAQmx Stop Code /*********************************************/ DAQmxStopTask(startleDaqHandle); DAQmxClearTask(startleDaqHandle); } if( DAQmxFailed(error) ) printf("DAQmx Error: %s\n",errBuff); Error: 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; }
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(); }
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; }
int DAQmxErrChk(int32 rueckgabeWert) { //Fehlerbehandlung char errBuff[2048]; if( DAQmxFailed(rueckgabeWert) ) { DAQmxBaseGetExtendedErrorInfo (errBuff, 2048); printf ("DAQmxBase Error %ld: %s\n", rueckgabeWert, errBuff); DAQmxBaseResetDevice ("Dev1"); if (exitBeiFehler) { printf("\nACHTUNG: Programm wurde wegen eines Fehlers beendet!\n"); exit(1); } return 1; } return 0; }
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; }
void QxrdNIDAQPlugin::errorCheck(const char* file, int line, int err) { if (DAQmxFailed(err)) { int sz = DAQmxGetErrorString(err, NULL, 0); if (sz > 0) { char *buff = (char*) malloc(sz); if (DAQmxGetErrorString(err, buff, sz) == 0) { if (m_ErrorOutput && QMetaObject::invokeMethod(m_ErrorOutput, "printMessage", Qt::QueuedConnection, Q_ARG(QString, tr("%1:%2 NI-DAQ Error %3 : %4").arg(file).arg(line).arg(err).arg(buff)))) { } else { printf("%s:%d NI-DAQ Error %d : %s\n", file, line, err, buff); } } free(buff); } } }
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; }
// 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; }
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; }
/* * static int gRunning=0; int main(int argc, char *argv[]) { // Task parameters int32 error = 0; TaskHandle taskHandle = 0; int32 i = 0; char errBuff[2048]={'\0'}; time_t startTime; bool32 done=0; // Channel parameters char chan[] = "Dev2/ao0"; float64 min = -10.0; float64 max = 10.0; // Timing parameters #define bufferSize 512 uInt64 samplesPerChan = bufferSize; float64 sampleRate = 20000.0; // Data write parameters float64 data[bufferSize]; int32 pointsWritten; float64 timeout = 10.0; for(;i<bufferSize;i++) data[i] = 9.95*sin((double)i*20.0*PI/(double)bufferSize); DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,chan,"",min,max,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxBaseCfgSampClkTiming(taskHandle,"",sampleRate,DAQmx_Val_Rising,DAQmx_Val_ContSamps,samplesPerChan)); DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,samplesPerChan,0,timeout,DAQmx_Val_GroupByChannel,data,&pointsWritten,NULL)); DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); gRunning = 1; // The loop will quit after 10 seconds startTime = time(NULL); while( gRunning && !done && time(NULL)<startTime+10 ) { DAQmxErrChk (DAQmxBaseIsTaskDone(taskHandle,&done)); if( !done ) usleep(100000); } Error: if( DAQmxFailed(error) ) DAQmxBaseGetExtendedErrorInfo(errBuff,2048); if( taskHandle!=0 ) { DAQmxBaseStopTask(taskHandle); DAQmxBaseClearTask(taskHandle); } if( DAQmxFailed(error) ) printf("DAQmxBase Error: %s\n",errBuff); return 0; } * */ static PyObject * pyni_ao(PyObject *self, PyObject *args) { float sampr; int32 error = 0; TaskHandle taskHandle = 0; int32 i = 0; int32 pointsWritten; char errBuff[2048]={'\0'}; time_t startTime; bool32 done=0; PyObject *monitor; PyArrayObject *data; Py_ssize_t l; int64 bs=20000; int gRunning = 1; double data2[20000]; char *name, *chanids; if (!PyArg_ParseTuple(args, "OfsO", &monitor, &sampr, &chanids, &data)) return NULL; data=PyArray_FROM_OTF(data, NPY_FLOAT64 , C_ARRAY); DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); // for (i=0;i<PyList_Size(chanids);i++) // { // name=PyString_AsString(PyList_GetItem(chanids, i)); // printf("%s\n", name); // } for(;i<bs;i++) data2[i] = 9.95*sin((double)i*20.0*PI/(double)bs); DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,"Dev2/ao0","",-10,10,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxBaseCfgSampClkTiming(taskHandle,"", 10000,DAQmx_Val_Rising,DAQmx_Val_ContSamps,bs)); DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,bs,0,10.0,DAQmx_Val_GroupByChannel,data2,&pointsWritten,NULL)); DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); // The loop will quit after 10 seconds startTime = time(NULL); while( gRunning && !done && time(NULL)<startTime+10 ) { DAQmxErrChk (DAQmxBaseIsTaskDone(taskHandle,&done)); //if( !done ) // usleep(100000000); } //DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle, chanids ,"", 0.0, 5.0, DAQmx_Val_Volts,NULL)); //DAQmxErrChk (DAQmxBaseCfgSampClkTiming(taskHandle,"",sampr,DAQmx_Val_Rising,DAQmx_Val_FiniteSamps,data->dimensions[0])); // DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle, data->dimensions[0] ,FALSE, 10 ,DAQmx_Val_GroupByScanNumber ,PyArray_DATA(data),&pointsWritten,NULL)); // DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); // startTime = time(NULL); // while( !done && time(NULL)<startTime+10 ) { // DAQmxErrChk (DAQmxBaseIsTaskDone(taskHandle,&done)); // if( !done ) // usleep(1000); // } // startTime=time(NULL)-startTime; // DAQmxBaseStopTask(taskHandle); // DAQmxBaseClearTask(taskHandle); i=PyList_SetItem(monitor, 1, Py_BuildValue("i", pointsWritten) ); i=PyList_SetItem(monitor, 0, Py_BuildValue("i", 1) ); printf("wrote %i samples in %.2f sec\n", pointsWritten, (double)startTime); Py_XDECREF(data); //Py_XDECREF(monitor); //Py_XDECREF(chanids); return monitor; _fail: if( taskHandle!=0 ) { DAQmxBaseStopTask(taskHandle); DAQmxBaseClearTask(taskHandle); } if( DAQmxFailed(error) ) { DAQmxBaseGetExtendedErrorInfo(errBuff,2048); printf("DAQmxBase Error: %s\n",errBuff); } Py_XDECREF(data); //Py_XDECREF(monitor); //Py_XDECREF(chanids); return PyErr_Format(PyExc_StandardError, errBuff); }
int main(int argc, char *argv[]) { // Task parameters FILE *stimfile; int32 error = 0; TaskHandle taskHandle = 0; int32 i = 0; char errBuff[2048]={'\0'}; time_t startTime; bool32 done=0; // Channel parameters char chan[10] = "Dev1/ao0"; float64 min = -10.0; float64 max = 10.0; // Data write parameters int32 pointsWritten; float64 timeout = 10.0; float32 header[2]; float32 datval; float64 *data; int off=0; long fsize; long sampPerChan; stimfile=fopen(argv[1],"r"); if (stimfile==NULL) { printf("Unable to open file %s \n", argv[1]); exit (8); } fread( (char *)header, 4, 2, stimfile); fseek(stimfile, 0, SEEK_END); fsize=ftell(stimfile)-8; fsize=fsize/4; fseek(stimfile, 8, SEEK_SET); sampPerChan=fsize/header[0]; printf("Playing file %s: %i channels with %i samples at %.2f Hz ...\n", argv[1], (int)header[0], sampPerChan, header[1]); data=(float64 *) calloc(fsize, 8); for (i=0;i<fsize;i++) { fread( (char *)&datval, 4, 1, stimfile); data[i] = (float64)datval; } if ((int)header[0] > 1) { sprintf(chan, "Dev1/ao0:%i", (int) header[0]-1); } printf("Using device %s \n", chan); DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateAOVoltageChan(taskHandle,chan,"",min,max,DAQmx_Val_Volts,NULL)); DAQmxErrChk (DAQmxBaseCfgSampClkTiming(taskHandle,"",(float64) header[1], DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, sampPerChan)); DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,512, FALSE,timeout,DAQmx_Val_GroupByScanNumber, data ,&pointsWritten,NULL)); off+=1024; DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); gRunning = 1; // The loop will quit after 10 seconds startTime = time(NULL); while( gRunning && !done && time(NULL)<startTime+10 ) { DAQmxErrChk (DAQmxBaseWriteAnalogF64(taskHandle,512, FALSE,timeout,DAQmx_Val_GroupByScanNumber, data+off ,&pointsWritten,NULL)); if (off>= fsize - 1024) { done=1; } else { off+=1024; DAQmxErrChk (DAQmxBaseIsTaskDone(taskHandle,&done)); } } printf("Done. Sent %i samples in %.2f seconds \n", pointsWritten, (float) time(NULL)-startTime); if (!done) { DAQmxBaseStopTask(taskHandle); DAQmxBaseClearTask(taskHandle); } Error: if( DAQmxFailed(error) ) DAQmxBaseGetExtendedErrorInfo(errBuff,2048); if( taskHandle!=0 ) { DAQmxBaseStopTask(taskHandle); DAQmxBaseClearTask(taskHandle); } if( DAQmxFailed(error) ) printf("DAQmxBase Error: %s\n",errBuff); return 0; }
void acquire(void (*pyCallbackFunc)(uInt32), double (*pyVoltFunc)(uInt32), _Bool (*isFinished)(uInt32)) { // Task parameters int32 error = 0; // TaskHandle taskHandle = 0; char errBuff[2048]={'\0'}; time_t startTime; // Data read parameters uInt32 data; float64 timeout = 5.0; // Channel parameters float64 min = 0.0; float64 max = 5.0; // Task parameters // memcpy(writeParams.gerrBuff, '\0', 1); // Data write parameters TaskHandle taskHandle = 0; float64 voltage = 0.0; uInt32 count = 0; uInt32 previousCount = 0; writeParams.gtimeout = 10.0; writeParams.taskHandle = 0; writeParams.samplesPerChan = 1; // counter stuff DAQmxErrChk (DAQmxBaseCreateTask("",&taskHandle)); DAQmxErrChk (DAQmxBaseCreateCICountEdgesChan(taskHandle, userData.readChannel,"", DAQmx_Val_Falling,0, DAQmx_Val_CountUp)); DAQmxErrChk (DAQmxBaseStartTask(taskHandle)); gRunning = 1; // analogue output stuff DAQmxErrChk(DAQmxBaseCreateTask("", &writeParams.taskHandle)); DAQmxErrChk(DAQmxBaseCreateAOVoltageChan(writeParams.taskHandle, userData.writeChannel, "",min,max, DAQmx_Val_Volts,NULL)); DAQmxErrChk(DAQmxBaseStartTask(writeParams.taskHandle)); // The loop will quit after 10 seconds startTime = time(NULL); printf("Beginning main loop\n"); // set initial voltage voltage = pyVoltFunc(0); DAQmxErrChk(DAQmxBaseWriteAnalogF64(writeParams.taskHandle, writeParams.samplesPerChan,0, writeParams.gtimeout, DAQmx_Val_GroupByChannel, &voltage, &writeParams.gpointsWritten, NULL)); while( gRunning && !isFinished(0) ) { // measure counts every time DAQmxErrChk (DAQmxBaseReadCounterScalarU32(taskHandle, timeout,&data,NULL)); if(count++ % userData.reportEvery == 0) { /* This represents the end of one complete voltage measure. We report back the count, set data to 0, set the new voltage */ // set voltage voltage = pyVoltFunc(0); DAQmxErrChk(DAQmxBaseWriteAnalogF64(writeParams.taskHandle, writeParams.samplesPerChan,0, writeParams.gtimeout, DAQmx_Val_GroupByChannel, &voltage, &writeParams.gpointsWritten, NULL)); // read data pyCallbackFunc(data - previousCount); previousCount = data; } } Error: puts(""); if( DAQmxFailed(error) ) DAQmxBaseGetExtendedErrorInfo(errBuff,2048); if( taskHandle!=0 ) { DAQmxBaseStopTask(taskHandle); DAQmxBaseClearTask(taskHandle); } if( writeParams.taskHandle!=0 ) { DAQmxBaseStopTask(writeParams.taskHandle); DAQmxBaseClearTask(writeParams.taskHandle); } if( DAQmxFailed(error) ) printf ("DAQmxBase Error %ld: %s\n", error, errBuff); }