mtsIntuitiveDaVinci.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Anton Deguet, Nicolas Padoy
  Created on: 2010-04-06

  (C) Copyright 2010-2011 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#ifndef _mtsIntuitiveDaVinci_h
#define _mtsIntuitiveDaVinci_h

// cisst library headers
#include <cisstMultiTask/mtsMacros.h>
#include <cisstMultiTask/mtsTaskFromSignal.h>
#include <cisstMultiTask/mtsTaskPeriodic.h>
#include <cisstMultiTask/mtsFunctionVoid.h>
#include <cisstParameterTypes/prmPositionCartesianGet.h>
#include <cisstParameterTypes/prmVelocityCartesianGet.h>
#include <cisstParameterTypes/prmPositionJointGet.h>
#include <cisstParameterTypes/prmVelocityJointGet.h>
#include <cisstParameterTypes/prmEventButton.h>
#include <cisstParameterTypes/prmPositionCartesianSet.h>

// Always include last
#include <sawIntuitiveDaVinci/sawIntuitiveDaVinciExport.h>

// forward declarations
class mtsIntuitiveDaVinci;

namespace mtsIntuitiveDaVinciUtilities {
    void StreamCallbackInternal(void * userData);
    void EventCallbackInternal(int manipulatorId,
                               int eventId,
                               int* arguments,
                               void * userData);
};


class CISST_EXPORT mtsIntuitiveDaVinci: public mtsTaskPeriodic { //mtsTaskFromSignal {

    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_LOD_RUN_WARNING);

    friend void mtsIntuitiveDaVinciUtilities::StreamCallbackInternal(void * userData);
    friend void mtsIntuitiveDaVinciUtilities::EventCallbackInternal(int manipulatorId,
                                                                    int eventId,
                                                                    int* arguments,
                                                                    void * userData);
 public:

     mtsIntuitiveDaVinci(const std::string & name, unsigned int rateInHz);

    ~mtsIntuitiveDaVinci();

    void SetSourceHost(const std::string _ipaddress, const unsigned int _port = 5002, const unsigned int _password = 0x1111);
    void SetSourceLogFile(const std::string _filename);
    void SetOutputLogFile(const std::string filename);
    void StartLogging(void);
    void StopLogging(void);

    void Configure(const std::string & CMN_UNUSED(filename) = "") {};
    void Startup(void);
    void Run(void);
    void Cleanup(void);

    inline bool IsAPIConnected(void) const {
        return this->Connected;
    }

    typedef enum {
        MTML1 = 0,          
        MTMR1,              
        MTML2,              
        MTMR2,              
        PSM1,               
        PSM2,               
        PSM3,               
        ECM1,               
        CONSOLE1,           
        CONSOLE2,           
        CORE,               
        NUMBER_MANIPULATORS 
    } ManipulatorIndexType;

    typedef enum {
        MTM_TYPE = 0,                    
        PSM_TYPE,                        
        ECM_TYPE,                        
        CONSOLE_TYPE,                    
        NUMBER_MANIPULATOR_TYPES         
    } ManipulatorType;

 protected:

    class ArmData {
    public:
        ArmData(void);
        mtsStateTable * StateTable;
        mtsInterfaceProvided * ProvidedInterface;
        mtsFunctionVoid DataUpdated;
        mtsFloat DeviceTimestamp;
        prmPositionCartesianGet PositionCartesian;
        prmVelocityCartesianGet VelocityCartesian;
        prmPositionJointGet PositionJoint;
        prmVelocityJointGet VelocityJoint;
        prmVelocityJointGet TorqueJoint;
    };

    class MasterArmData: public ArmData {
    public:
        MasterArmData(void);
        mtsInterfaceProvided * SelectEventProvidedInterface;
        mtsFunctionWrite Select;
        bool Selected;
        static const double SelectAngle;
        mtsInterfaceProvided * ClutchEventProvidedInterface;
        mtsFunctionWrite Clutch;
        bool ClutchRestAngleNeedsUpdate;
        double ClutchRestAngle;
        bool Clutched;
        static const double ClutchAngle;
    };

    class SlaveArmData: public ArmData {
    public:
        SlaveArmData(void);
        prmPositionCartesianGet PositionCartesianRCM;
        prmPositionCartesianGet PositionCartesianSetup;
        prmPositionJointGet PositionJointSetup;
    };

    class ConsoleData
    {
    public:
        ConsoleData(void);
        mtsInterfaceProvided * ProvidedInterface;
        mtsFunctionVoid HeadIn;
        mtsFunctionVoid HeadOut;
        mtsFunctionVoid ClutchQuickTap;
        mtsFunctionVoid CameraQuickTap;

        mtsInterfaceProvided * StandbyProvidedInterface;
        mtsFunctionWrite Standby;

        mtsInterfaceProvided * ReadyProvidedInterface;
        mtsFunctionWrite Ready;

        mtsInterfaceProvided * ClutchProvidedInterface;
        mtsFunctionWrite Clutch;
        bool Clutched;

        mtsInterfaceProvided * CameraProvidedInterface;
        mtsFunctionWrite Camera;

        mtsInterfaceProvided * MastersAsMiceProvidedInterface;
        mtsFunctionWrite MastersAsMice;
        bool MastersAsMiced;

        mtsInterfaceProvided * FollowModeProvidedInterface;
        mtsFunctionWrite FollowMode;
    };

    class EventData {
    public:
        EventData(void);
        mtsInterfaceProvided * ProvidedInterface;
        vctDynamicVector<mtsFunctionWrite *> WriteFunctions;
        vctDynamicVector<std::string> EventNames;
    };

    ArmData * Arms[(ECM1 - MTML1) + 1];

    MasterArmData * MasterArms[(MTMR2 - MTML1) + 1];

    SlaveArmData * SlaveArms[(ECM1 - PSM1) + 1];

    SlaveArmData * CameraArms[(ECM1 - ECM1) + 1];

    ConsoleData Console;
    ConsoleData * Consoles[(CONSOLE2 - CONSOLE1) + 1];

    EventData Events;

    bool Connect(void);

    bool Disconnect(void);

    bool ConfigureStream(void);
    void StreamCallback(void);

    bool ConfigureEvents(void);
    void EventCallback(ManipulatorIndexType index, int eventId, int* eventArgs);

    bool StartStream(void);

    void StopStream(void);

    void LogSystemConfiguration(cmnLogLevel logLevel = CMN_LOG_LEVEL_INIT_VERBOSE) const;
    void LogManipulatorConfiguration(ManipulatorIndexType index,
                                     cmnLogLevel logLevel = CMN_LOG_LEVEL_INIT_VERBOSE) const;
    void LogToolConfiguration(ManipulatorIndexType index,
                              cmnLogLevel logLevel = CMN_LOG_LOD_INIT_VERBOSE) const;
    void LogManipulatorsAndToolsConfiguration(cmnLogLevel logLevel = CMN_LOG_LOD_INIT_VERBOSE) const;

 public:
    static const std::string & ManipulatorIndexToString(ManipulatorIndexType manipulatorIndex);

    static size_t GetNumberOfJoints(ManipulatorIndexType manipulatorIndex);

    static size_t GetNumberOfSetupJoints(ManipulatorIndexType manipulatorIndex);

    static ManipulatorType GetManipulatorType(ManipulatorIndexType manipulatorIndex);

    inline vctDynamicVector<std::string> GetEventNames(void) {
        return this->Events.EventNames;
    }

 protected:
    void SetupEventInterfaces(void);
    void SetupArmsInterfaces(void);
    void SetupMastersInterfaces(void);
    void SetupSlavesInterfaces(void);
    void SetupCameraInterfaces(void);
    void SetupConsoleInterfaces(void);
    void SetupAllInterfaces(void);

    bool Connected;

    unsigned int RateInHz;
    std::string IPAddress;
    unsigned int Port;
    unsigned int Password;
    std::string SourceLogFileName;
    bool UseLogFile;
    std::string OutputLogFileName;
};


CMN_DECLARE_SERVICES_INSTANTIATION(mtsIntuitiveDaVinci);


#endif // _mtsIntuitiveDaVinci_h