Fluctus

From WikiSonix
Jump to: navigation, search

Overview[edit]

Fluctus is an SDK for connecting to the ECG unit on a Sonix system (note that SonixTOUCH Research comes standard with ECG, but not Sonix RP). Programs using Fluctus should not run while the Sonix research interface software is running, as the port will be held by the software and not available to Fluctus.

Fluctus is ideal for custom programs built with Texo or Porta that require the use of ECG gating or trace capture during imaging or the acquisition of images and raw data. The Sonix research platform supports the use of the L&T and Corscience ECG modules.

Programming[edit]

The following show the settings that are supported by each ECG module type. The pseudo-code below shows how to initialize and modify the ecg parameters.

enum ecgVersion
{
    ////////////////////////////////////////////////////////////////////////////////
    /// L&T ECG
    /// Supports:
    /// \li Selectable lead retrieval (I, II, III, STD)
    /// \li 3 Gain levels
    /// \li Fixed 200 Hz sampling rate
    /// \li Lead off / cable off detection
    /// \li Pulse rate values
    /// \li Arrhythmia values
    ////////////////////////////////////////////////////////////////////////////////
    ecgVersionLT = 2,
    ////////////////////////////////////////////////////////////////////////////////
    /// Corscience ECG
    /// \par
    /// Supports:
    /// \li Selectable lead retrieval (II and III)
    /// \li Programmable sampling rates
    /// \li Lead off / cable off detection
    /// \li Pulse rate values
    /// \li Arrhythmia values
    ////////////////////////////////////////////////////////////////////////////////
    ecgVersionCorscience = 3
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Information Codes
////////////////////////////////////////////////////////////////////////////////
enum ecgInformation
{
    ////////////////////////////////////////////////////////////////////////////////
    /// Used internally.
    ////////////////////////////////////////////////////////////////////////////////
    ecgUnknown = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead data message
    /// L&T and Corscience Version
    /// Data: selected lead data
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadData = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// Pulse rate message
    /// L&T and Corscience Versions
    /// Data: pulse rate in Hz
    ////////////////////////////////////////////////////////////////////////////////
    ecgPulseRate,
    ////////////////////////////////////////////////////////////////////////////////
    /// Arrhythmia message
    /// L&T Version
    /// Data: arrhythmia value
    ////////////////////////////////////////////////////////////////////////////////
    ecgArrhythmia,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead off message
    /// L&T Versions
    /// Data: unused
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadOff,
    ////////////////////////////////////////////////////////////////////////////////
    /// No cable connected message
    /// L&T and Corscience Version
    /// Data: unused
    ////////////////////////////////////////////////////////////////////////////////
    ecgNoCableDetected,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead and gain information message
    /// L&T Version
    /// Data: selected lead (high 16 bits), and selected gain (low 16 bits)
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadGainInfo,
    ////////////////////////////////////////////////////////////////////////////////
    /// Version information message
    /// L&T Version
    /// Data: ecg version
    ////////////////////////////////////////////////////////////////////////////////
    ecgVersionInfo,
    ////////////////////////////////////////////////////////////////////////////////
    /// Information code passed back when the previous lead data sent back was
    /// detected as the requested part of the waveform to be detected (QRS+PT)
    /// L&T Versions
    /// Data: unused
    ////////////////////////////////////////////////////////////////////////////////
    ecgWFDetect
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Lead Selection
/// Supports: L&T (all leads), and Corscience (leads II and III)
////////////////////////////////////////////////////////////////////////////////
enum ecgLead
{
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead I
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadI = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead II
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadII = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead III
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadIII,
    ////////////////////////////////////////////////////////////////////////////////
    /// Lead STD
    ////////////////////////////////////////////////////////////////////////////////
    ecgLeadSTD
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Gain Selection
/// Supports: L&T Version
////////////////////////////////////////////////////////////////////////////////
enum ecgGainLevel
{
    ////////////////////////////////////////////////////////////////////////////////
    /// Low Gain
    /// L&T: 0.3 mV
    ////////////////////////////////////////////////////////////////////////////////
    ecgGainLow = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// Medium Gain
    /// L&T: 1 mV
    ////////////////////////////////////////////////////////////////////////////////
    ecgGainMed = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// High Gain
    /// L&T: 2 mV
    ////////////////////////////////////////////////////////////////////////////////
    ecgGainHigh
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Sampling Rate Selection
/// Supports: Corscience Version
////////////////////////////////////////////////////////////////////////////////
enum ecgSamplingRate
{
    ////////////////////////////////////////////////////////////////////////////////
    /// Low Sampling Rate
    /// Corscience: 100 Hz
    ////////////////////////////////////////////////////////////////////////////////
    ecgSamplingRateLow = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// Medium Sampling Rate
    /// Corscience: 200 Hz
    ////////////////////////////////////////////////////////////////////////////////
    ecgSamplingRateMed = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// High Sampling Rate
    /// Corscience: 500 Hz
    ////////////////////////////////////////////////////////////////////////////////
    ecgSamplingRateHigh,
    ////////////////////////////////////////////////////////////////////////////////
    /// Max Sampling Rate
    /// Corscience: 1000 Hz
    ////////////////////////////////////////////////////////////////////////////////
    ecgSamplingRateMax
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Peak Detection Selection
/// Supports: L&T Version
////////////////////////////////////////////////////////////////////////////////
enum ecgPeakDetection
{
    ////////////////////////////////////////////////////////////////////////////////
    /// No detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectNone = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// P Wave detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectPWave = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// Q Wave detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectQWave = 2,
    ////////////////////////////////////////////////////////////////////////////////
    /// R Wave detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectRWave = 3,
    ////////////////////////////////////////////////////////////////////////////////
    /// S Wave detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectSWave = 4,
    ////////////////////////////////////////////////////////////////////////////////
    /// T Wave detection
    ////////////////////////////////////////////////////////////////////////////////
    ecgDetectTWave = 3
};

////////////////////////////////////////////////////////////////////////////////
/// ECG Error Codes
////////////////////////////////////////////////////////////////////////////////
enum ecgError
{
    ////////////////////////////////////////////////////////////////////////////////
    /// No error
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorNone = 0,
    ////////////////////////////////////////////////////////////////////////////////
    /// Generic error
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorGeneric = 1,
    ////////////////////////////////////////////////////////////////////////////////
    /// ECG has not been initialized
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorInitialization,
    ////////////////////////////////////////////////////////////////////////////////
    /// Function not supported by ECG version
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorFunctionNotSupported,
    ////////////////////////////////////////////////////////////////////////////////
    /// Serial port error
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorSerialPort,
    ////////////////////////////////////////////////////////////////////////////////
    /// Thread synchronization error
    ////////////////////////////////////////////////////////////////////////////////
    ecgErrorThreadSync
};

bool startEcg(ecgVersion version, int port)
{
    // initialize the ECG the version can be L&T or Corscience module
    if (ecg.init(version, port))
    {
        // start running
        ecg.start();
        return true;
    }

    return false;
}

void setSamplingRate(ecgSamplingRate sr)
{
    // where sr can be ecgSamplingRateLow, ecgSamplingRateMed, ecgSamplingRateHigh
    // for the Corscience ecg it is best to set a rate of 100Hz or 200Hz
    ecg.setSamplingRate(sr);
}

void adjustGain(ecgGainLevel gain)
{
   // where gain can be ecgGainHigh, ecgGainMed or ecgGainLow
    ecg.setGain(gain);
}

void adjustLead(ecgLead lead)
{
    // where:
    // lead can be set to ecgLeadII or ecgLeadIII for Corscience ecg
    // lead can be set to ecgLeadSTD, ecgLeadI, ecgLeadII or ecgLeadIII for L&T ecg
    ecg.setLead(lead);
}

PDF Download[edit]

Download all Fluctus SDK documentation as a PDF