#include <qxrdsynchronizedacquisition.h>

Inheritance diagram for QxrdSynchronizedAcquisition:

Collaboration diagram for QxrdSynchronizedAcquisition:

Public Types
enum	{ SyncAcquisitionModeNone, SyncAcquisitionModeStepped, SyncAcquisitionModeContinuous }

enum	{ SyncAcquisitionWaveformSquare, SyncAcquisitionWaveformSine, SyncAcquisitionWaveformTriangle, SyncAcquisitionWaveformSawtooth, SyncAcquisitionWaveformBipolarTriangle }

Public Slots
void	setManualOutput ()

void	triggerOnce ()

Public Slots inherited from QcepObject
virtual void	printLine (QString line)

virtual void	printMessage (QString msg, QDateTime dt=QDateTime::currentDateTime()) const

virtual void	criticalMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const

virtual void	statusMessage (QString msg, QDateTime ts=QDateTime::currentDateTime()) const

virtual QString	settingsScript ()

QString	scriptValueLiteral (QVariant v)

Public Member Functions
	QxrdSynchronizedAcquisition (QcepSettingsSaverWPtr saver, QxrdAcquisitionWPtr acq)

virtual	~QxrdSynchronizedAcquisition ()

void	prepareForAcquisition (QxrdAcquisitionParameterPackWPtr parms)

void	prepareForDarkAcquisition (QxrdDarkAcquisitionParameterPackWPtr parms)

void	finishedAcquisition ()

void	acquiredFrameAvailable (int currentPhase)

void	setNIDAQPlugin (QxrdNIDAQPluginInterfaceWPtr nidaqPlugin)

QxrdNIDAQPluginInterfaceWPtr	nidaqPlugin () const

QVector< double >	outputTimes ()

QVector< double >	outputVoltage ()

QxrdAcquisitionParameterPackWPtr	parms ()

Public Member Functions inherited from QcepObject
	QcepObject (QString name, QcepObject *parent)

virtual	~QcepObject ()

virtual void	writeSettings (QSettings *set, QString section)

virtual void	readSettings (QSettings *set, QString section)

QString	get_Name () const

void	set_Name (QString name)

Properties
int	syncAcquisitionMode

int	syncAcquisitionWaveform

QString	syncAcquisitionOutputDevice

QString	syncAcquisitionOutputChannel

double	syncAcquisitionMinimum

double	syncAcquisitionMaximum

double	syncAcquisitionSymmetry

double	syncAcquisitionPhaseShift

double	syncAcquisitionManualValue

Properties inherited from QcepObject
QString	name

Private Attributes
QMutex	m_Mutex

QxrdAcquisitionWPtr	m_Acquisition

QxrdAcquisitionParameterPackWPtr	m_AcquisitionParms

QxrdNIDAQPluginInterfaceWPtr	m_NIDAQPlugin

int	m_SyncMode

QVector< double >	m_OutputTimes

QVector< double >	m_OutputVoltage

Additional Inherited Members
Static Public Member Functions inherited from QcepObject
static int	allocatedObjects ()

static int	deletedObjects ()

static QSet< QcepObject * >	allocatedObjectsSet ()

static QString	addSlashes (QString str)

Detailed Description

Definition at line 15 of file qxrdsynchronizedacquisition.h.

Member Enumeration Documentation

anonymous enum

Enumerator
SyncAcquisitionModeNone
SyncAcquisitionModeStepped
SyncAcquisitionModeContinuous

Definition at line 26 of file qxrdsynchronizedacquisition.h.

        {
     SyncAcquisitionModeNone,
     SyncAcquisitionModeStepped,
     SyncAcquisitionModeContinuous
   };

anonymous enum

Enumerator
SyncAcquisitionWaveformSquare
SyncAcquisitionWaveformSine
SyncAcquisitionWaveformTriangle
SyncAcquisitionWaveformSawtooth
SyncAcquisitionWaveformBipolarTriangle

Definition at line 35 of file qxrdsynchronizedacquisition.h.

Constructor & Destructor Documentation

QxrdSynchronizedAcquisition::QxrdSynchronizedAcquisition	(	QcepSettingsSaverWPtr	saver,
		QxrdAcquisitionWPtr	acq
	)

explicit

Definition at line 9 of file qxrdsynchronizedacquisition.cpp.

                                                                                                              :
   QcepObject("synchronization", NULL),
   m_SyncAcquisitionMode(saver, this,"syncAcquisitionMode", 0, "Synchronized Acquisition Mode (0 = None, 1 = Stepped, 2 = Continuous)"),
   m_SyncAcquisitionWaveform(saver, this,"syncAcquisitionWaveform", 0,
                             "Synchronized Acquisition Waveform (0 = Square, 1 = Sine, 2 = Triangle, 3 = Sawtooth, 4 = Bipolar Triangle)"),
   m_SyncAcquisitionOutputDevice(saver, this,"syncAcquisitionOutputDevice", "", "Synchronized Acquisition Output Device"),
   m_SyncAcquisitionOutputChannel(saver, this,"syncAcquisitionOutputChannel", "", "Synchronized Acquisition Output Channel"),
 //  m_SyncAcquisitionFlagChannel(saver, this,"syncAcquisitionFlagChannel", 0, "Synchronized Acquisition Flags"),
   m_SyncAcquisitionMinimum(saver, this,"syncAcquisitionMinimum", 0.0, "Synchronized Acquisition Minimum (in Volts)"),
   m_SyncAcquisitionMaximum(saver, this,"syncAcquisitionMaximum", 5.0, "Synchronized Acquisition Maximum (in Volts)"),
   m_SyncAcquisitionSymmetry(saver, this,"syncAcquisitionSymmetry", 0.0, "Synchronized Acquisition Symmetry (0 = symmetric)"),
   m_SyncAcquisitionPhaseShift(saver, this,"syncAcquisitionPhaseShift", 0.0, "Synchronized Acquisition Phase Shift (deg)"),
   m_SyncAcquisitionManualValue(saver, this,"syncAcquisitionManualValue", 0.0, "Manual Output Voltage (in Volts)"),
   m_Acquisition(acq),
   m_SyncMode(0)
 {
 }

QxrdSynchronizedAcquisition::~QxrdSynchronizedAcquisition ( )

virtual

Definition at line 27 of file qxrdsynchronizedacquisition.cpp.

 {
 #ifndef QT_NO_DEBUG
   printf("Deleting synchronized acquisition\n");
 #endif
 }

Member Function Documentation

void QxrdSynchronizedAcquisition::acquiredFrameAvailable ( int currentPhase )

Definition at line 188 of file qxrdsynchronizedacquisition.cpp.

References m_Acquisition, m_AcquisitionParms, m_NIDAQPlugin, m_SyncMode, and parms().

 {
   QxrdNIDAQPluginInterfacePtr nidaq(m_NIDAQPlugin);
 
   if (nidaq) {
     nidaq->pulseOutput();
   }
 
   QxrdAcquisitionPtr acq(m_Acquisition);
   QxrdAcquisitionParameterPackPtr parms(m_AcquisitionParms);
 
   if (m_SyncMode && acq && parms) {
     if (acq->acquisitionStatus(0.0) == 0) {
 //      printf("QxrdSynchronizedAcquisition::acquiredFrameAvailable(%d)\n", frameNumber);
 
       int skipBefore = parms->skipBefore();
       int skipBetween = parms->skipBetween();
       int nPhases = parms->nphases();
       int nSummed = parms->nsummed();
       int nGroups = parms->postTrigger();
       int perGroup = nPhases*nSummed+skipBetween;
       int inGroup = (frameNumber-skipBefore) % perGroup;
       int phase = inGroup % nPhases;
 
       if (nPhases > 0) {
         if ((frameNumber >= skipBefore) && (frameNumber < (nGroups*perGroup-skipBetween+skipBefore))) {
           if (inGroup < nPhases*nSummed) {
             if (phase == 0) {
               if (nidaq) {
 //                printf("Triggered on frame %d\n", frameNumber);
                 nidaq->triggerAnalogWaveform();
               }
             }
           }
         }
       }
 //      printf("elapsed[%d] %d msec\n", currentPhase, tick.restart());
     }
   }
 }

Here is the call graph for this function:

void QxrdSynchronizedAcquisition::finishedAcquisition ( )

Definition at line 49 of file qxrdsynchronizedacquisition.cpp.

References m_AcquisitionParms, and m_SyncMode.

 {
   m_AcquisitionParms = QxrdAcquisitionParameterPackWPtr();
   m_SyncMode = 0;
 }

QxrdNIDAQPluginInterfaceWPtr QxrdSynchronizedAcquisition::nidaqPlugin ( ) const

Definition at line 39 of file qxrdsynchronizedacquisition.cpp.

References m_NIDAQPlugin.

Referenced by setNIDAQPlugin().

 {
   return m_NIDAQPlugin;
 }

Here is the caller graph for this function:

QVector< double > QxrdSynchronizedAcquisition::outputTimes ( )

Definition at line 257 of file qxrdsynchronizedacquisition.cpp.

References m_Mutex, and m_OutputTimes.

Referenced by prepareForAcquisition().

 {
   QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex);
 
   return m_OutputTimes;
 }

Here is the caller graph for this function:

QVector< double > QxrdSynchronizedAcquisition::outputVoltage ( )

Definition at line 264 of file qxrdsynchronizedacquisition.cpp.

References m_Mutex, and m_OutputVoltage.

Referenced by prepareForAcquisition().

 {
   QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex);
 
   return m_OutputVoltage;
 }

Here is the caller graph for this function:

QxrdAcquisitionParameterPackWPtr QxrdSynchronizedAcquisition::parms ( )

Definition at line 44 of file qxrdsynchronizedacquisition.cpp.

References m_AcquisitionParms.

Referenced by acquiredFrameAvailable(), prepareForAcquisition(), and triggerOnce().

 {
   return m_AcquisitionParms;
 }

Here is the caller graph for this function:

void QxrdSynchronizedAcquisition::prepareForAcquisition ( QxrdAcquisitionParameterPackWPtr parms )

nsummed

Definition at line 60 of file qxrdsynchronizedacquisition.cpp.

References m_AcquisitionParms, m_Mutex, m_NIDAQPlugin, m_OutputTimes, m_OutputVoltage, m_SyncMode, outputTimes(), outputVoltage(), parms(), SyncAcquisitionWaveformBipolarTriangle, SyncAcquisitionWaveformSawtooth, SyncAcquisitionWaveformSine, SyncAcquisitionWaveformSquare, and SyncAcquisitionWaveformTriangle.

Referenced by triggerOnce().

 {
   m_AcquisitionParms = parms;
 
   QxrdAcquisitionParameterPackPtr parmsp(parms);
 
   if (parmsp) {
     m_SyncMode = 0;
     m_AcquisitionParms = parms;
 
     double exposureTime = parmsp->exposure();
     int    nphases      = parmsp->nphases();
     double cycleTime    = exposureTime*nphases;
     double sampleRate   = 1000;
     double nSamples     = cycleTime*sampleRate;
     double minVal       = get_SyncAcquisitionMinimum();
     double maxVal       = get_SyncAcquisitionMaximum();
     QString chan        = get_SyncAcquisitionOutputChannel();
     int wfm             = get_SyncAcquisitionWaveform();
     m_SyncMode          = get_SyncAcquisitionMode();
     double symm         = get_SyncAcquisitionSymmetry();
     double phase        = get_SyncAcquisitionPhaseShift();
 
     if (symm > 1.0) {
       symm = 1.0;
     } else if (symm < -1.0) {
       symm = -1.0;
     }
 
     if (nphases <= 0) {
       m_SyncMode = 0;
     } else if (m_SyncMode) {
 
       while (nSamples > 10000) {
         sampleRate /= 10;
         nSamples = cycleTime*sampleRate;
       }
 
       int iSamples = (int) nSamples;
       double divide = iSamples * (0.5 + symm/2.0);
       double divideBy2 = divide/2;
       int shift = (int)((double) phase*iSamples/360.0 + nphases) % iSamples;
 
       QVector<double> outputTimes(iSamples+1);
       QVector<double> outputVoltage(iSamples+1);
 
       for (int i=0; i<=iSamples; i++) {
         outputTimes[i] = ((double)i)/((double) sampleRate);
       }
 
       switch (wfm) {
       case SyncAcquisitionWaveformSquare:
         for (int ii=0; ii<iSamples; ii++) {
           int i = (ii+iSamples-shift) % iSamples;
           if (i<divide) {
             outputVoltage[ii] = minVal;
           } else {
             outputVoltage[ii] = maxVal;
           }
         }
         break;
 
       case SyncAcquisitionWaveformSine:
         for (int ii=0; ii<iSamples; ii++) {
           int i = (ii+iSamples-shift) % iSamples;
           double x;
           if (i<divide) {
             x = M_PI*i/divide;
           } else {
             x = M_PI+M_PI*(i-divide)/(iSamples-divide);
           }
           outputVoltage[ii] = minVal + (maxVal-minVal)*(1.0 - cos(x))/2.0;
         }
         break;
 
       case SyncAcquisitionWaveformTriangle:
         for (int ii=0; ii<iSamples; ii++) {
           int i = (ii+iSamples-shift) % iSamples;
           if (i<divide) {
             outputVoltage[ii] = minVal + i*(maxVal-minVal)/divide;
           } else {
             outputVoltage[ii] = maxVal - (i-divide)*(maxVal-minVal)/(iSamples-divide);
           }
         }
         break;
 
       case SyncAcquisitionWaveformBipolarTriangle:
         for (int ii=0; ii<iSamples; ii++) {
           int i = (ii+iSamples-shift) % iSamples;
           if (i < divideBy2) {
             outputVoltage[ii] = minVal + i*(maxVal-minVal)/divideBy2;
           } else if (i < (iSamples-divideBy2)) {
             outputVoltage[ii] = maxVal - (i-divideBy2)*(maxVal-minVal)/((iSamples-divide)/2);
           } else {
             outputVoltage[ii] = minVal - (iSamples-i)*(maxVal-minVal)/divideBy2;
           }
         }
         break;
 
       case SyncAcquisitionWaveformSawtooth:
       default:
         for (int ii=0; ii<iSamples; ii++) {
           int i = (ii+iSamples-shift) % iSamples;
           outputVoltage[ii] = minVal + i*(maxVal-minVal)/iSamples;
         }
         break;
       }
 
       outputVoltage[iSamples] = outputVoltage[0]; // Return output voltage to starting value at the end of the waveform
 
       QxrdNIDAQPluginInterfacePtr nidaq(m_NIDAQPlugin);
 
       if (nidaq) {
         nidaq->setAnalogWaveform(chan, sampleRate, outputVoltage.data(), iSamples+1);
       }
 
       {
         QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex);
 
         m_OutputTimes = outputTimes;
         m_OutputVoltage = outputVoltage;
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void QxrdSynchronizedAcquisition::prepareForDarkAcquisition ( QxrdDarkAcquisitionParameterPackWPtr parms )

Definition at line 55 of file qxrdsynchronizedacquisition.cpp.

References m_SyncMode.

 {
   m_SyncMode = 0;
 }

void QxrdSynchronizedAcquisition::setManualOutput ( )

slot

Definition at line 229 of file qxrdsynchronizedacquisition.cpp.

References m_Acquisition, and m_NIDAQPlugin.

Referenced by QxrdSynchronizedAcquisitionDialog::QxrdSynchronizedAcquisitionDialog().

 {
   QxrdAcquisitionPtr acq(m_Acquisition);
   QxrdNIDAQPluginInterfacePtr nidaq(m_NIDAQPlugin);
 
   if (acq && nidaq) {
     QString fullChannel = get_SyncAcquisitionOutputChannel();
 
     acq->printMessage(tr("Manually Setting %1 to %2 V")
                                 .arg(fullChannel)
                                 .arg(get_SyncAcquisitionManualValue()));
 
     nidaq->setAnalogOutput(fullChannel, get_SyncAcquisitionManualValue());
   }
 }

Here is the caller graph for this function:

void QxrdSynchronizedAcquisition::setNIDAQPlugin ( QxrdNIDAQPluginInterfaceWPtr nidaqPlugin )

Definition at line 34 of file qxrdsynchronizedacquisition.cpp.

References m_NIDAQPlugin, and nidaqPlugin().

 {
   m_NIDAQPlugin = nidaqPlugin;
 }

Here is the call graph for this function:

void QxrdSynchronizedAcquisition::triggerOnce ( )

slot

Definition at line 245 of file qxrdsynchronizedacquisition.cpp.

References m_Acquisition, m_AcquisitionParms, m_NIDAQPlugin, parms(), and prepareForAcquisition().

Referenced by QxrdSynchronizedAcquisitionDialog::QxrdSynchronizedAcquisitionDialog().

 {
   QxrdAcquisitionPtr acq(m_Acquisition);
   QxrdNIDAQPluginInterfacePtr nidaq(m_NIDAQPlugin);
   QxrdAcquisitionParameterPackPtr parms(m_AcquisitionParms);
 
   if (acq && nidaq && parms) {
     prepareForAcquisition(parms);
     nidaq->triggerAnalogWaveform();
   }
 }