NDI_commands.h

Go to the documentation of this file.

#ifndef NDI_COMMANDS_H
#define NDI_COMMANDS_H

#include <map>
#include <deque>
#include <memory>
#include <iostream>
#include <OpenTracker/misc/serialcomm.h>

namespace ot {

class SerialIO;


class TransformData
{
public:
        TransformData()
        {
                strPortHandle = "";
                bIsTracked = false;
                bIsDisabled = false;
                bIsMissing = false;
                fQ0 = 0.0f;
                fQX = 0.0f;
                fQY = 0.0f;
                fQZ = 0.0f;
                fX = 0.0f;
                fY = 0.0f;
                fZ = 0.0f;
                fError = 0.0f;
                bOutOfVolume = false;
                bPartiallyOutOfVolume = false;
                bDisturbanceDetected = false;
                uFrameNumber = 0;
        }
        std::string strPortHandle;

        // ToolID given in the xml file (matching the Aurora/Polaris toolID)
        std::string toolID;

        bool bIsTracked, bIsDisabled, bIsMissing;
        
        float fQ0, fQX, fQY, fQZ;

        float fX, fY, fZ;

        float fError;

        bool bOutOfVolume, bPartiallyOutOfVolume, bDisturbanceDetected;

        unsigned long uFrameNumber;
};



class NDICommands
{
public:

    static const int TOOL_ADDED;

    static const int TOOL_REMOVED;
    
    static const int NORMAL_EXECUTION;  

                static const int INTERFERENCE;
  
    NDICommands(const std::string& strDevice, long nBaudeRate, int nDataBits, char cParity, int nStopBits, bool bHardwareHandShake);
        
    ~NDICommands();

    void initialize();

    void trackNodes(std::deque<TransformData>& queTransformData, int* nStatus);

    int getNumberOfMagneticPorts() const;
    
    void getOccupiedPortHandles(std::deque<std::string>& occupiedPorts);
    
    void getFreeablePortHandles(std::deque<std::string>& occupiedPorts);
    
    void getEnabledPortHandles(std::deque<std::string>& enabledPorts);

    void initializePort(std::string strPort);

    void enablePort(std::string strPort, bool bIsDynamic);

    std::string getToolID(std::string);

    std::string getFirmwareVersion();

    void enterTrackingMode();

    void freeToolPort(std::string strPort);
  
    void voidToolTracking(std::string strPort);

    void setUseCRC(bool bEnable);

    void setCheckCRC(bool bEnable);

    void reset();

    void changeCommSettings(long        nBaudRate,
                            int         nDataBits,
                            char        cParity,
                            int         nStopBits,
                            bool        bHardwareHandshake);

    void exitTrackingMode(bool bExpedient);

    void checkProcessorStatus();

    void turnOnGPIO(std::string strPort);
    
    void turnOffGPIO(std::string strPort);

                // gets a port handle for a new wireless port
                std::string getWirelessPortHandle();
                
                // send SROM data
                void sendSROMData(std::string strPort,unsigned char sROM[1024]);

                // set rotation and translation multipliers
                void setMultipliers(long rotation, long translation);


    static const std::string m_strScope;

    // Strings to indicate error
    static const std::string m_strCantInitializeNDI;
    static const std::string m_strUnexpectedReply;
    static const std::string m_strFailedToReset;
    static const std::string m_strFailedToChangeCommSettings;
    static const std::string m_strCommandFailed;
    static const std::string m_strTimeout;
    static const std::string m_strCRCError;
    static const std::string m_strInvalidPort;
    static const std::string m_strNoToolPluggedIn;
    static const std::string m_strInvalidBaudRate;
    static const std::string m_strInvalidDataBits;
    static const std::string m_strInvalidParity;
    static const std::string m_strInvalidStopBits;
    static const std::string m_strErrorFromNDI;
    static const std::string m_strBadProcessorStatus;
    static const std::string m_strSynchronizationError;
    static const std::string m_strInvalidVolume;
    static const std::string m_strTooMuchInterference;

protected:

    void sendGPIO(std::string strOption);

    const std::string sendCommand(const std::string& strExpectedReply,
                              const std::string& strCode,
                              const std::string& strParams,
                              const int nMaxRetries = 5);
                                                
    const std::string sendCommand(const std::string& strCode,
                              const std::string& strParams,
                              const int nMaxRetries = 5);

    const std::string mapCommParams(long nBaudRate,
                                int nDataBits,
                                char cParity,
                                int nStopBits,
                                bool bHardwareHandshake);

    float parseTransform(const std::string strField,
                         int* nOffset,
                         const int nLength,
                         const long nMultiplier) const;

    int handleTransformStatus(const std::string& strStatus);

    //std::string getSection(std::string theString, int start, int end);

    void getSomePortHandles(std::deque<std::string>& occupiedPorts, std::string strOption);

    const std::string getReply();

    bool headMatches(std::string sOne, std::string sTwo);
        
    bool bitTest(unsigned int nBitField, int nBit) const;

    void handleNDIError(const std::string strErrorCode);

    std::string getNextField(const std::string& str,
                         int* nOffset,
                         const std::string& strDelimiter);

    std::string calcCRC16(const char* ptr, int nLen);

    // Various commands send to/received from the Aurora/Polaris
    static const std::string mt_strCOMM;
    static const std::string mt_strDSTART;
    static const std::string mt_strDSTOP;
    static const std::string mt_strERROR;
    static const std::string mt_strGX;
    static const std::string mt_strINIT;
    static const std::string mt_strOKAY;
    static const std::string mt_strPENA;
    static const std::string mt_strPDIS;
    static const std::string mt_strPINIT;
    static const std::string mt_strPSTAT;
    static const std::string mt_strPURD;
    static const std::string mt_strPVCLR;
                static const std::string mt_strPHRQ;
    static const std::string mt_strPVWR;
    static const std::string mt_strRESET;
    static const std::string mt_strSFLIST;
    static const std::string mt_strSSTAT;
    static const std::string mt_strTSTART;
    static const std::string mt_strTSTOP;
    static const std::string mt_strVER;
    static const std::string mt_strVSEL;
    static const std::string mt_strBX;
    static const std::string mt_strTX;
    static const std::string mt_strPHINF;
    static const std::string mt_strPHSR;
    static const std::string mt_strPHF;
    static const std::string mt_strPSOUT;
    
    // Command sending/timing parameters
    static const unsigned int mt_nCommSleepInMilliseconds;
    static const int mt_nPINITReadTimeoutInMilliSeconds;
    static const std::string mt_strFieldDelimiter;
    static const int mt_nBlockSize;
    static const int mt_nMarkerInfoLength;

    // The Strings from the tool status
    static const std::string mt_strDISABLED;
    static const std::string mt_strMISSING;

    // Stuff to parse and convert the tranform data
    static const int mt_nRotationLength;
    static long mt_nRotationMultiplier;
    static const int mt_nTranslationLength;
    static long mt_nTranslationMultiplier;
    static const int mt_nErrorLength;
    static const long mt_nErrorMultiplier;
    static const int mt_nFrameNumberLength;

    static const int mt_nDefaultMaxRetries;

    //maps a long integer from baud rate to an "NDI happy" char 
    std::map<long, char> mt_BaudMap;

    SerialPort port;

    int mt_pSerialIO;

    bool mt_bUseCRC;
        
    bool mt_bCheckCRC;

    NDICommands(const NDICommands&);
        
    int m_nNumFieldGenerators;

    int m_nNumMagneticPorts;
};
}

#endif

---