ControlBoardRemapperHelpers.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_DEV_CONTROLBOARDREMAPPER_CONTROLBOARDREMAPPERHELPERS_H
#define YARP_DEV_CONTROLBOARDREMAPPER_CONTROLBOARDREMAPPERHELPERS_H
 
 
#include <yarp/os/PortablePair.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Time.h>
#include <yarp/os/Network.h>
#include <yarp/os/Stamp.h>
#include <yarp/os/Vocab.h>
 
#include <yarp/dev/ControlBoardInterfaces.h>
#include <yarp/dev/IInteractionMode.h>
#include <yarp/dev/IControlLimits.h>
#include <yarp/dev/PolyDriver.h>
#include <yarp/dev/IPreciselyTimed.h>
#include <yarp/dev/IControlMode.h>
 
 
#include <yarp/sig/Vector.h>
 
#include <mutex>
#include <string>
#include <vector>
 
 
#ifdef MSVC
    #pragma warning(disable:4355)
#endif
 
/*
 * Helper class for the ControlBoardRemapper.
 * It contains all the data structure related
 * to a given controlboard used by the remapper.
 */
class RemappedSubControlBoard
{
public:
    std::string id;
 
    yarp::dev::PolyDriver            *subdevice = nullptr;
    yarp::dev::IPidControl           *pid = nullptr;
    yarp::dev::IPositionControl      *pos = nullptr;
    yarp::dev::IVelocityControl      *vel = nullptr;
    yarp::dev::IVelocityDirect       *iVelDir = nullptr;
    yarp::dev::IEncodersTimed        *iJntEnc = nullptr;
    yarp::dev::IMotorEncoders        *iMotEnc = nullptr;
    yarp::dev::IAmplifierControl     *amp = nullptr;
    yarp::dev::IControlLimits        *lim = nullptr;
    yarp::dev::IControlCalibration   *calib = nullptr;
    yarp::dev::IRemoteCalibrator     *remcalib = nullptr;
    yarp::dev::IPreciselyTimed       *iTimed = nullptr;
    yarp::dev::ITorqueControl        *iTorque = nullptr;
    yarp::dev::IImpedanceControl     *iImpedance = nullptr;
    yarp::dev::IControlMode          *iMode = nullptr;
    yarp::dev::IAxisInfo             *info = nullptr;
    yarp::dev::IPositionDirect       *posDir = nullptr;
    yarp::dev::IInteractionMode      *iInteract = nullptr;
    yarp::dev::IMotor                *imotor = nullptr;
    yarp::dev::IRemoteVariables      *iVar = nullptr;
    yarp::dev::IPWMControl           *iPwm = nullptr;
    yarp::dev::ICurrentControl       *iCurr = nullptr;
    yarp::dev::IJointFault           *iFault = nullptr;
    yarp::dev::IJointBrake           *iBrake = nullptr;
 
    RemappedSubControlBoard();
 
    bool attach(yarp::dev::PolyDriver *d, const std::string &id);
    void detach();
 
    inline void setVerbose(bool _verbose) {_subDevVerbose = _verbose; }
 
    bool isAttached()
    { return attachedF; }
 
private:
    bool _subDevVerbose;
    bool attachedF;
};
 
class RemappedAxis
{
public:
    size_t subControlBoardIndex;
 
    size_t axisIndexInSubControlBoard;
};
 
class RemappedControlBoards
{
public:
    std::vector<RemappedSubControlBoard> subdevices;
 
    std::vector<RemappedAxis> lut;
 
    inline RemappedSubControlBoard* getSubControlBoard(size_t i)
    {
        return &(subdevices[i]);
    }
 
    size_t getNrOfSubControlBoards() const
    {
        return subdevices.size();
    }
 
    size_t getNrOfRemappedAxes() const
    {
        return lut.size();
    }
};
 
class ControlBoardRemapperBuffers
{
public:
    std::mutex mutex;
    std::vector<int> controlBoardModes;
    std::vector<double> dummyBuffer;
    yarp::os::Stamp stamp;
 
};
 
class ControlBoardSubControlBoardAxesDecomposition
{
public:
    bool configure(const RemappedControlBoards & remappedControlBoards);
 
    void fillSubControlBoardBuffersFromCompleteJointVector(const double * full, const RemappedControlBoards & remappedControlBoards);
 
 
    void fillSubControlBoardBuffersFromCompleteJointVector(const int * full,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillSubControlBoardBuffersFromCompleteJointVector(const yarp::dev::InteractionModeEnum * full,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillCompleteJointVectorFromSubControlBoardBuffers(double * full, const RemappedControlBoards & remappedControlBoards);
 
    void fillCompleteJointVectorFromSubControlBoardBuffers(int * full,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillCompleteJointVectorFromSubControlBoardBuffers(yarp::dev::InteractionModeEnum * full,
                                                           const RemappedControlBoards & remappedControlBoards);
 
 
    std::mutex mutex;
 
    // Buffer to be used in MultiJoint version of the
    int m_nrOfControlledAxesInRemappedCtrlBrd;
    std::vector<int> m_nJointsInSubControlBoard;
    std::vector< std::vector<int> > m_jointsInSubControlBoard;
 
 
    std::vector< std::vector<double> > m_bufferForSubControlBoard;
    std::vector< std::vector<int>    > m_bufferForSubControlBoardControlModes;
    std::vector< std::vector<yarp::dev::InteractionModeEnum>  > m_bufferForSubControlBoardInteractionModes;
 
    std::vector<int> m_counterForControlBoard;
};
 
class ControlBoardArbitraryAxesDecomposition
{
    void createListOfJointsDecomposition(const int n_joints, const int *joints, const RemappedControlBoards & remappedControlBoards);
 
public:
    bool configure(const RemappedControlBoards & remappedControlBoards);
 
 
    void fillSubControlBoardBuffersFromArbitraryJointVector(const double * arbitraryVec,
                                                            const int n_joints,
                                                            const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillSubControlBoardBuffersFromArbitraryJointVector(const int * arbitraryVec,
                                                            const int n_joints,
                                                            const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillSubControlBoardBuffersFromArbitraryJointVector(const yarp::dev::InteractionModeEnum * arbitraryVec,
                                                            const int n_joints,
                                                            const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void resizeSubControlBoardBuffers(const int n_joints,
                                      const int *joints,
                                      const RemappedControlBoards & remappedControlBoards);
 
    void fillArbitraryJointVectorFromSubControlBoardBuffers(double * arbitraryVec,
                                                            const int n_joints, const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillArbitraryJointVectorFromSubControlBoardBuffers(int * arbitraryVec,
                                                            const int n_joints, const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    void fillArbitraryJointVectorFromSubControlBoardBuffers(yarp::dev::InteractionModeEnum * arbitraryVec,
                                                            const int n_joints, const int *joints,
                                                            const RemappedControlBoards & remappedControlBoards);
 
    std::mutex mutex;
 
    // Total number of axes in the remapped controlboard
    int m_nrOfControlledAxesInRemappedCtrlBrd;
 
    // Vector of size getNrOfSubControlBoards
    std::vector<int> m_nJointsInSubControlBoard;
    std::vector< std::vector<int> > m_jointsInSubControlBoard;
 
    // Buffers for the control board (the size of each one should
    // match the size of m_nJointsInSubControlBoard[ctrlBoard] and
    // the size of m_jointsInSubControlBoard[ctrlBoard].size()
    std::vector< std::vector<double> > m_bufferForSubControlBoard;
    std::vector< std::vector<int>    > m_bufferForSubControlBoardControlModes;
    std::vector< std::vector<yarp::dev::InteractionModeEnum>  > m_bufferForSubControlBoardInteractionModes;
 
 
    // Counter used when converting a full vector to
    // the subcontrolboard buffers
    std::vector<int> m_counterForControlBoard;
};
 
#endif  // YARP_DEV_CONTROLBOARDREMAPPER_CONTROLBOARDREMAPPERHELPERS_H