Example #1
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;
}
Example #2
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;
}
Example #3
0
motorControl::~motorControl()
{
    DAQmxClearTask(motorEnableHandle);
    DAQmxClearTask(motorTaskHandle);
    DAQmxClearTask(loadCelltaskHandle);
    live = FALSE;
}
// from StopTasks();
int LifetimeAcq::stopTasks()
{
	
	//Stop Task;
	if( aoTaskHandle!=0 ) 
	{
		DAQmxStopTask(aoTaskHandle);
		DAQmxClearTask(aoTaskHandle);
		aoTaskHandle = 0; 
	}

	if( acqTaskHandle!=0 ) 
	{
		DAQmxStopTask(acqTaskHandle);
		DAQmxClearTask(acqTaskHandle);
		acqTaskHandle = 0; 
	}

	if( ctrTaskHandle!=0 ) 
	{
		DAQmxStopTask(ctrTaskHandle);
		DAQmxClearTask(ctrTaskHandle);
		ctrTaskHandle = 0; 
	}
	return 1;
}
Example #5
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;
}
Example #6
0
int motorControl::motorControllerEnd()
{
    live = FALSE;
    motorControl::motorDisable();
    isControlling = FALSE;
    DAQmxStopTask(motorTaskHandle);
	DAQmxClearTask(motorTaskHandle);
    DAQmxStopTask(loadCelltaskHandle);
	DAQmxClearTask(loadCelltaskHandle);
    DAQmxStopTask(encodertaskHandle);
	DAQmxClearTask(encodertaskHandle);
    return 0;
}
Example #7
0
void ScanThreadLinear::StopTasks(void)
{
	DAQmxStopTask(taskAnalog);
	DAQmxStopTask(taskTrig);
	DAQmxStopTask(taskTrA);
	DAQmxStopTask(taskClock);
	
	//CLEAR TASKS
	DAQmxClearTask(taskAnalog);
	DAQmxClearTask(taskTrig);
	DAQmxClearTask(taskTrA);
	DAQmxClearTask(taskClock);
}
Example #8
0
int microStep(int in)
{
	uInt8 MS1Sig[2];
	uInt8 MS2Sig[2];

	// Pull to zero for active in current controller mode
	switch (in){
	case 1 : // no mirostep
		MS1Sig[0] = 0;	MS1Sig[1] = 0;
		MS2Sig[0] = 0;	MS2Sig[1] = 0;
		break;
	case 2 : // half step
		MS1Sig[0] = 1;	MS1Sig[1] = 1;
		MS2Sig[0] = 0;	MS2Sig[1] = 0;
		break;
	case 4: // quarter step
		MS1Sig[0] = 0;	MS1Sig[1] = 0;
		MS2Sig[0] = 1;	MS2Sig[1] = 1;
		break;
	case 8: // eighth step
		MS1Sig[0] = 1;	MS1Sig[1] = 1;
		MS2Sig[0] = 1;	MS2Sig[1] = 1;
		break;
	default :
		return -1;
	}

	TaskHandle microStep = 0;

	DAQmxCreateTask("MS1", &microStep);
	DAQmxCreateDOChan(microStep, "Dev1/port0/line6", "MS1", DAQmx_Val_ChanForAllLines); // MS1
	DAQmxCfgSampClkTiming(microStep, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
	DAQmxWriteDigitalLines(microStep, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, MS1Sig, NULL, NULL); // MS1 out 
	DAQmxStartTask(microStep);
	DAQmxWaitUntilTaskDone(microStep, 1.0); // Wait for action to be completed
	DAQmxStopTask(microStep);
	DAQmxClearTask(microStep);

	microStep = 0;

	DAQmxCreateTask("MS2", &microStep);
	DAQmxCreateDOChan(microStep, "Dev1/port0/line7", "MS2", DAQmx_Val_ChanForAllLines); // MS1
	DAQmxCfgSampClkTiming(microStep, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
	DAQmxWriteDigitalLines(microStep, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, MS2Sig, NULL, NULL); // MS1 out 
	DAQmxStartTask(microStep);
	DAQmxWaitUntilTaskDone(microStep, 1.0); // Wait for action to be completed
	DAQmxStopTask(microStep);
	DAQmxClearTask(microStep);
	
	return 0;
}
Example #9
0
// destructor
Tweezers::~Tweezers()
{
	cerr<<"reset...";
	Reset();
	DAQmxClearTask(AItaskHandle);
	DAQmxClearTask(AOtaskHandle);
	DAQmxClearTask(DOtaskHandle);
	DAQmxClearTask(TRtaskHandle);
	DAQmxResetDevice("Dev1");
	
	DAQmxGetExtendedErrorInfo(errBuff,2048);
	cerr<<errBuff;
	cerr<<"delete.\n";
}
Example #10
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;
	}
Example #11
0
void   QxrdNIDAQPlugin::setAnalogOutput(int chan, double value)
{
  QMutexLocker lock(&m_Mutex);

  int error;

  if (m_AOTaskHandle) {
    DAQmxStopTask(m_AOTaskHandle);
    DAQmxClearTask(m_AOTaskHandle);
    m_AOTaskHandle = 0;
  }

  if (chan >= 0) {
    DAQmxErrChk(DAQmxCreateTask("qxrd-output", &m_AOTaskHandle));
    DAQmxErrChk(DAQmxCreateAOVoltageChan (m_AOTaskHandle,
                                          qPrintable(tr("Dev1/ao%1").arg(chan)), NULL, -10.0, 10.0, DAQmx_Val_Volts, NULL));

    if (m_AOTaskHandle) {
      DAQmxErrChk(DAQmxWriteAnalogScalarF64(m_AOTaskHandle, true, 10.0, value, NULL));
    }
  }

Error:
  return;
}
Example #12
0
double QxrdNIDAQPlugin::getAnalogInput(int chan)
{
  QMutexLocker lock(&m_Mutex);

  int error;
  float64 res = 0;

  if (m_AITaskHandle) {
    DAQmxStopTask(m_AITaskHandle);
    DAQmxClearTask(m_AITaskHandle);
    m_AITaskHandle = 0;
  }

  if (chan >= 0) {
    DAQmxErrChk(DAQmxCreateTask("qxrd-input", &m_AITaskHandle));
    DAQmxErrChk(DAQmxCreateAIVoltageChan (m_AITaskHandle,
                                          qPrintable(tr("Dev1/ai%1").arg(chan)), NULL, DAQmx_Val_Cfg_Default, -10.0, 10.0, DAQmx_Val_Volts, NULL));

    if (m_AITaskHandle) {
      DAQmxErrChk(DAQmxReadAnalogScalarF64(m_AITaskHandle, 10.0, &res, NULL));
    }
  }

Error:
  return res;
}
Example #13
0
double QxrdNIDAQPlugin::count(int /* chan */, double /* time */)
{
  QMutexLocker lock(&m_Mutex);

  static TaskHandle counterTask = 0;
  int error;
  float64 res = 0;

  if (counterTask == 0) {
    DAQmxErrChk(DAQmxCreateTask("counter", &counterTask));
    DAQmxErrChk(DAQmxCreateCICountEdgesChan(counterTask,"Dev1/ctr2", "", DAQmx_Val_Rising, 0, DAQmx_Val_CountUp));
    DAQmxErrChk(DAQmxSetCICountEdgesTerm(counterTask, "/Dev1/ctr2", "/Dev1/100MHzTimebase"));
    DAQmxErrChk(DAQmxStartTask(counterTask));
  }

  if (counterTask) {
    DAQmxErrChk(DAQmxReadCounterScalarF64(counterTask, 0, &res, NULL));
  }

  return res;

Error:
  DAQmxClearTask(counterTask);
  return res;
}
Example #14
0
void   QxrdNIDAQPlugin::setAnalogWaveform(QString chan, double rate, double wfm[], int size)
{
  QMutexLocker lock(&m_Mutex);
//  printf("setAnalogWaveform(%g,%g...,%d)\n", rate, wfm[0], size);

  int error;
  int32 nsampwrt;

  if (m_AOTaskHandle) {
    DAQmxStopTask(m_AOTaskHandle);
    DAQmxClearTask(m_AOTaskHandle);
    m_AOTaskHandle = 0;
  }

  if (chan >= 0) {
    DAQmxErrChk(DAQmxCreateTask("qxrd-output", &m_AOTaskHandle));
    DAQmxErrChk(DAQmxCreateAOVoltageChan (m_AOTaskHandle,
                                          qPrintable(chan), NULL, -10.0, 10.0, DAQmx_Val_Volts, NULL));

    if (m_AOTaskHandle) {
      DAQmxErrChk(
            DAQmxCfgSampClkTiming(m_AOTaskHandle, NULL, rate, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, size)
            );

      DAQmxErrChk(
            DAQmxWriteAnalogF64(m_AOTaskHandle, size, false, -1, DAQmx_Val_GroupByChannel, wfm, &nsampwrt, NULL)
            );
    }
  }

//  printf("%d samples written\n", nsampwrt);

Error:
  return;
}
Example #15
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;
}
ATIDAQHardwareInterface::~ATIDAQHardwareInterface()
{
    /*stop and clear tasks, without regard to error*/
    DAQmxClearTask( *m_thDAQTask );
    /*delete unmanaged pointers*/
    delete m_thDAQTask;
}
Example #17
0
    //************************************
    // Method:    setupCLK
    // FullName:  fetch::device::NationalInstrumentsDAQ::setupCLK
    // Access:    public
    // Returns:   void
    // Qualifier:
    //
    // set up counter for sample clock
    // - A finite pulse sequence is generated by a pair of on-board counters.
    //   In testing, it appears that after the device is reset, initializing
    //   the counter task doesn't work quite right.  First, I have to start the
    //   task with the paired counter once.  Then, I can set things up normally.
    //   After initializing with the paired counter once, things work fine until
    //   the device (or computer) is reset.  My guess is this is a fault of the
    //   board or driver software.
    // - below, we just cycle the counters when config gets called.  This ensures
    //   everything configures correctly the first time, even after a device
    //   reset or cold start.
    //************************************
    void NationalInstrumentsDAQ::setupCLK(float64 nrecords, float64 record_frequency_Hz)
    {
      TaskHandle clk = 0;

      int32      N = _config->ao_samples_per_waveform();
      float64   hz = computeSampleFrequency(nrecords, record_frequency_Hz);
      const char *dev          =_config->name().c_str(),
                 *ctr          =_config->ctr().c_str(),
                 *armstart_in  =_config->armstart().c_str(),
                 *gate_out     =_config->frame_trigger_out().c_str(),
                 *trig         =_config->trigger().c_str();
      float64     lvl          =_config->level_volts();
      char term_ctr[1024]={0},
           term_gate[1024]={0},
           term_arm_out[1024]={0};
      make_terminal_name(term_ctr    ,sizeof(term_ctr)    ,dev,ctr);
      make_terminal_name(term_gate   ,sizeof(term_gate)   ,dev,ctr);
      strcat(term_gate,"Gate");
      make_terminal_name(term_arm_out,sizeof(term_arm_out),dev,gate_out);

      DAQERR( DAQmxClearTask(_clk.daqtask) ); // Once a DAQ task is started, it needs to be cleared before restarting
      DAQERR( DAQmxCreateTask("fetch_CLK",&_clk.daqtask));
      clk = _clk.daqtask;
      DAQERR(DAQmxCreateCOPulseChanFreq     (clk,term_ctr,NULL,DAQmx_Val_Hz,DAQmx_Val_Low,0.0,hz,0.5));
      DAQERR(DAQmxCfgImplicitTiming         (clk,DAQmx_Val_FiniteSamps,N));
      DAQERR(DAQmxCfgDigEdgeStartTrig       (clk,"AnalogComparisonEvent",DAQmx_Val_Rising));
      DAQERR(DAQmxSetArmStartTrigType       (clk,DAQmx_Val_DigEdge));             // Arm trigger has to be through clk
      DAQERR(DAQmxSetDigEdgeArmStartTrigSrc (clk,armstart_in));
      DAQERR(DAQmxSetDigEdgeArmStartTrigEdge(clk,DAQmx_Val_Rising));
      DAQERR(DAQmxSetStartTrigRetriggerable (clk,1));
      DAQERR(DAQmxConnectTerms(term_gate,term_arm_out,DAQmx_Val_DoNotInvertPolarity));
    }
Example #18
0
    void NationalInstrumentsDAQ::setupAO( float64 nrecords, float64 record_frequency_Hz )
    {

      float64 freq = computeSampleFrequency(nrecords, record_frequency_Hz);

      DAQERR( DAQmxClearTask(_ao.daqtask) );
      DAQERR( DAQmxCreateTask( "fetch_AO", &_ao.daqtask));
      registerDoneEvent();
    }
Example #19
0
/******************************************************************************
**
** Fonction d'arret et de suppresion de tache d'acquisition de la vitesse
**
******************************************************************************/
bool NI6211::stopSpeed()
{
    bool error=0;
    /*------ DAQmx Stop Code ------*/
    error+=DAQmxStopTask(*taskFreq);
    error+=DAQmxClearTask(*taskFreq);
    delete taskFreq;
    taskFreq = NULL;
    return error;
}
Example #20
0
int DllExport _nidaq_close (int id)
{
	sTask *pTask;
	
	pTask = tasks.item + id;
	DAQmxClearTask (pTask->handle);
	pTask->handle = 0;

	return 1;
}
Example #21
0
void QxrdNIDAQPlugin::closeTaskHandles()
{
  QMutexLocker lock(&m_Mutex);

  if (m_AOTaskHandle) {
    DAQmxClearTask(m_AOTaskHandle);
    m_AOTaskHandle = 0;
  }

  if (m_AITaskHandle) {
    DAQmxClearTask(m_AITaskHandle);
    m_AITaskHandle = 0;
  }

  if (m_TrigAOTask) {
    DAQmxClearTask(m_TrigAOTask);
    m_TrigAOTask = 0;
  }
}
Example #22
0
/******************************************************************************
**
** Fonction d'arret et de suppresion de tache d'acquisition de la vitesse
**
******************************************************************************/
bool NI6211::stopCapot()
{
    bool error=0;
    /*------ DAQmx Stop Code ------*/
    error+=DAQmxStopTask(*taskCapot);
    error+=DAQmxClearTask(*taskCapot);
    delete taskCapot;
    taskCapot = NULL;
    return error;
}
Example #23
0
/******************************************************************************
**
** Fonction d'arret et de suppresion de tache du compteur
**
******************************************************************************/
bool NI6211::stopCounter()
{
    bool error=0;
    /*------ DAQmx Stop Code ------*/
    error+=DAQmxStopTask(*taskCounter);
    error+=DAQmxClearTask(*taskCounter);
    delete taskCounter;
    taskCounter = NULL;
    return error;
}
Example #24
0
/******************************************************************************
**
** Fonction d'arret et de suppresion de tache d'acquisition
**
******************************************************************************/
bool NI6211::stopAcquisition()
{
    bool error=0;
    /*------ DAQmx Stop Code ------*/
    error+=DAQmxStopTask(*taskRead);
    error+=DAQmxClearTask(*taskRead);
    delete taskRead;
    taskRead=NULL;
    return error;
}
Example #25
0
	void Cleanup(void)
	{
		if (taskHandle != 0)
		{
			/*********************************************/
			// DAQmx Stop Code
			/*********************************************/
			DAQmxStopTask(taskHandle);
			DAQmxClearTask(taskHandle);
			taskHandle = 0;
		}
	}
Example #26
0
void DaqMagControl::set_volts(double this_volts)
{
    DAQmxCreateTask("",&taskHandle);
    DAQmxCreateAOVoltageChan (taskHandle, chan_char, "", -10.0, 10.0, DAQmx_Val_Volts , NULL);
    DAQmxStartTask(taskHandle);
    double volts=this_volts;
    DAQmxWriteAnalogF64(taskHandle,1,1,10.0,DAQmx_Val_GroupByChannel,&volts,NULL,NULL);
    if( taskHandle!=0 )
    {
        DAQmxStopTask(taskHandle);
        DAQmxClearTask(taskHandle);
    }
}
Example #27
0
void YON(int in)
{
	TaskHandle YOn = 0;	
	uInt8 onSig[2] = { in, in };

	DAQmxCreateTask("YON", &YOn);
	DAQmxCreateDOChan(YOn, "Dev1/port0/line5", "YON", DAQmx_Val_ChanForAllLines); // Yon	
	DAQmxCfgSampClkTiming(YOn, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Ext. Trig
	DAQmxWriteDigitalLines(YOn, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, onSig, NULL, NULL); // turn Off 
	DAQmxStartTask(YOn);
	DAQmxWaitUntilTaskDone(YOn, 1.0); // Wait for action to be completed
	DAQmxStopTask(YOn);
	DAQmxClearTask(YOn);
}
Example #28
0
void YDIR(int in)
{
	TaskHandle YDir = 0;
	uInt8 dirSig[2] = { in, in };

	DAQmxCreateTask("YDir", &YDir);
	DAQmxCreateDOChan(YDir, "Dev1/port0/line3", "YDir", DAQmx_Val_ChanForAllLines); // Ydirection
	DAQmxCfgSampClkTiming(YDir, NULL, 3000.0, DAQmx_Val_Rising, DAQmx_Val_FiniteSamps, 2); // Int. Trig
	DAQmxWriteDigitalLines(YDir, 2, 0, 1000.0, DAQmx_Val_GroupByChannel, dirSig, NULL, NULL); // turn Off 
	DAQmxStartTask(YDir);
	DAQmxWaitUntilTaskDone(YDir, 1.0); // Wait for action to be completed
	DAQmxStopTask(YDir);
	DAQmxClearTask(YDir);
}
Example #29
0
/******************************************************************************
**
** Fonction d'arret et de suppresion de tache d'alimentation du moteur
** La vitesse du moteur est préalablement fixé à 0% par sécurité
**
******************************************************************************/
bool NI6211::stopMotor()
{
    int error=1;
    if(!DAQmxWriteAnalogF64(*taskVOut,1,1,10.0,DAQmx_Val_GroupByChannel,0,NULL,NULL))
    {
        /*------ DAQmx Stop Code ------*/
        DAQmxStopTask(*taskVOut);
        DAQmxClearTask(*taskVOut);
        delete taskVOut;
        taskVOut = NULL;
        error=0;
    }
    return error;
}
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;
}