jaus++/2.0/include/jaus/extras/controllers/controldevice.h

Go to the documentation of this file.

#ifndef __JAUS_EXTRAS_CONTROLLERS_CONTROL_DEVICE__H
#define __JAUS_EXTRAS_CONTROLLERS_CONTROL_DEVICE__H

#include "jaus/extras/jausextrasdll.h"
#include "jaus/extras/mcu/setmicrocontrollerstate.h"
#include "jaus/core/management/management.h"
#include "jaus/mobility/drivers/primitivedriver.h"
#include "jaus/mobility/drivers/setwrencheffort.h"

namespace JAUS
{
    class JAUS_EXTRAS_DLL ControlDevice : public Management::Child
    {
    public:
        enum ButtonActions
        {
            RequestDriveControl = 0, 
            ReleaseDriveControl,     
        };
        enum WrenchEffort
        {
            PropulsiveLinearEffortX = 0,
            PropulsiveLinearEffortY,
            PropulsiveLinearEffortZ,
            PropulsiveRotationalEffortX,
            PropulsiveRotationalEffortY,
            PropulsiveRotationalEffortZ,
            ResistiveLinearEffortX,
            ResistiveLinearEffortY,
            ResistiveLinearEffortZ,
            ResistiveRotationalEffortX,
            ResistiveRotationalEffortY,
            ResistiveRotationalEffortZ,
        };
        const static std::string Name; 
        // Constructor.
        ControlDevice();
        // Destructor.
        virtual ~ControlDevice();
        // Load settings from a file.
        virtual bool LoadSettings(const std::string& filename);
        // Loads settings for a specific type of robot to control
        virtual bool LoadSettingsForVehicle(const std::string& vehicleIdentificationName,
                                            const std::string& directory);
        // Shutsdown the Service.
        virtual void Shutdown() ;
        // Sets the ID of the subsystem to take control of (when control is to be taken).
        void SetSubsystemToControl(const UShort id);
        // Force take control of a subsystem (enable without button event).
        virtual void TakeDriveControl(const bool enable = true);
        // Method to check if we have control of a Primitive Driver
        virtual bool HaveDriveControl() const;
        // Method called when a button has been pressed.
        virtual void SignalButtonPress(const int buttonNumber);
        // Method called when a button has been released.
        virtual void SignalButtonRelease(const int buttonNumber);
        // Method called when a controller/joystick axis has been updated.
        virtual void UpdateWrench(const int inputID, const double percentEffort);
        // Method called when a controller/joystick axis has been updated.
        virtual void UpdateAnalogOut(const int inputID, const double signalValue);
        // Sends the current wrench efforts.
        virtual void SendWrenchEffort();
        // Sends the SetMicrocontrollerState command.
        virtual void SendMicrocontrollerState();
        // Clears current wrench effort being constructed.
        virtual void ClearWrenchEffort();
        // Clears current microcontroller state message being constructed.
        virtual void ClearMicrocontrollState();
        // Method to map a button on a controller to an actioan.
        virtual void MapButtonToAction(const int buttonNumber, const ButtonActions action);
        // Method to map a button on a controller to an actioan.
        virtual void MapButtonToDigitalOut(const int buttonNumber, 
                                           const std::string& digital,
                                           const bool onPress = true);
        // Method to map a controller axis/input to a Wrench.
        virtual void MapInputToWrench(const int inputID, 
                                      const WrenchEffort wrenchID,
                                      const double deadzone,
                                      const bool invert,
                                      const double limit);
        // Method to map a controller axis/input to a Wrench.
        virtual void MapInputToAnalogOut(const int inputID, 
                                         const std::string& analog,
                                         const bool invert,
                                         const double limit);
        // Method called periodically by Component or other Services, can be used for periodic udpdates.
        virtual void CheckServiceStatus(const unsigned int timeSinceLastCheckMs);
        // Method called when an Event has been signaled, generates an Event message.
        virtual bool GenerateEvent(const Events::Subscription& info) const { return false; }
        // Method called to determine if an Event is supported by the service.
        virtual bool IsEventSupported(const Events::Type type,
                                      const double requestedPeriodicRate,
                                      const Message* queryMessage,
                                      double& confirmedPeriodicRate,
                                      std::string& errorMessage) const { return false; }
        virtual void ProcessAcquisitionOfControl(const Address& controlledComponent);
        // VideoSubscriber doesn't need to be discovered.
        virtual bool IsDiscoverable() const { return false; }
        // Processes messages associated with the VideoSubscriber Services.
        virtual void Receive(const Message* message);
        // Creates messages associated with the VideoSubscriber Service.
        virtual Message* CreateMessage(const UShort messageCode) const;
        // Method called when transitioning to a ready state.
        virtual bool Resume() { return true; }
        // Method called to transition due to reset.
        virtual bool Reset() { return true; }
        // Method called when transitioning to a standby state.
        virtual bool Standby() { return true; }
        // Method called when transitioning to an emergency state.
        virtual bool SetEmergency() { return true; }
        // Method called when leaving the emergency state.
        virtual bool ClearEmergency() { return true; }
        // Method called when control is released.
        virtual bool ReleaseControl() { return true; }
        // Prints information about the service.
        virtual void PrintStatus() const;
        // Gets the ID of the driving component.
        Address GetDriverID() const { Mutex::ScopedLock lock(&mControlDevice); return mPrimitiveDriverID; }
        // Gets the mappings of input IDs to wrench efforts.
        std::map<int, WrenchEffort> GetInputIdToWrenchMapping(){ Mutex::ScopedLock lock(&mControlDevice); return mWrenchMapping; }
    private:
        Mutex mControlDevice;       
        bool mTakeDriveControlFlag; 
        bool mAutoBrakingFlag;      
        UShort mSubsystemID;        
        Address mPrimitiveDriverID; 
        Address mMicrocontrollerID; 
        std::map<int, WrenchEffort> mWrenchMapping;     
        std::map<int, double> mDeadzoneMapping;
        std::map<int, bool> mInvertMapping;    
        std::map<int, ButtonActions> mButtonMapping;    
        std::map<int, double> mLimitsMapping;  
        std::map<int, std::string> mAnalogMapping;           
        std::map<std::string, bool> mAnalogInvertMapping;    
        std::map<std::string, bool> mDigitalButtonState;     
        std::map<int, std::string> mButtonDigitalMapping;    
        std::map<std::string, double> mAnalogLimitsMapping;  
        SetWrenchEffort mWrenchEffort;                  
        SetMicrocontrollerState mMicrocontrollerState;  
    };
}

#endif
/* End of File */