ControlBoardWrapper.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_DEV_CONTROLBOARDWRAPPER_CONTROLBOARDWRAPPER_H
#define YARP_DEV_CONTROLBOARDWRAPPER_CONTROLBOARDWRAPPER_H
 
 
// ControlBoardWrapper
// A modified version of the remote control board class
// which remaps joints, it can also merge networks into a single part.
//
 
#include <yarp/os/PortablePair.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Time.h>
#include <yarp/os/Network.h>
#include <yarp/os/PeriodicThread.h>
#include <yarp/os/Stamp.h>
#include <yarp/os/Vocab.h>
 
#include <yarp/dev/ControlBoardInterfaces.h>
#include <yarp/dev/PolyDriver.h>
#include <yarp/dev/ControlBoardInterfacesImpl.h>
#include <yarp/dev/IPreciselyTimed.h>
#include <yarp/sig/Vector.h>
#include <yarp/dev/IMultipleWrapper.h>
#include <yarp/dev/ControlBoardHelpers.h>
 
#include <mutex>
#include <string>
#include <vector>
 
#include <yarp/dev/impl/jointData.h>           // struct for YARP extended port
 
#include "SubDevice.h"
#include "StreamingMessagesParser.h"
#include "RPCMessagesParser.h"
 
// ROS state publisher
#include <yarp/os/Node.h>
#include <yarp/os/Publisher.h>
#include <yarp/rosmsg/sensor_msgs/JointState.h>
#include <yarp/rosmsg/impl/yarpRosHelper.h>
 
#ifdef MSVC
    #pragma warning(disable:4355)
#endif
 
#define PROTOCOL_VERSION_MAJOR 1
#define PROTOCOL_VERSION_MINOR 9
#define PROTOCOL_VERSION_TWEAK 0
 
/*
 * To optimize memory allocation, for group of joints we can have one mem reserver for rpc port
 * and on e for streaming. The size could be numOfSubDevices*maxNumOfjointForSubdevice.
 * (we could also use the actual joint number for each subdevice using a for loop). TODO
 */
 
class CommandsHelper;
class SubDevice;
class WrappedDevice;
 
class MultiJointData
{
public:
    int deviceNum{0};
    int maxJointsNumForDevice{0};
 
    int *subdev_jointsVectorLen{nullptr}; // number of joints belonging to each subdevice
    int **jointNumbers{nullptr};
    int **modes{nullptr};
    double **values{nullptr};
    SubDevice **subdevices_p{nullptr};
 
    MultiJointData() = default;
 
    void resize(int _deviceNum, int _maxJointsNumForDevice, WrappedDevice *_device)
    {
        deviceNum = _deviceNum;
        maxJointsNumForDevice = _maxJointsNumForDevice;
        subdev_jointsVectorLen    = new int  [deviceNum];
        jointNumbers    = new int *[deviceNum];                             // alloc a vector of pointers
        jointNumbers[0] = new int[deviceNum * _maxJointsNumForDevice];      // alloc real memory for data
 
        modes           = new int *[deviceNum];                             // alloc a vector of pointers
        modes[0]        = new int[deviceNum * _maxJointsNumForDevice];      // alloc real memory for data
 
        values      = new double *[deviceNum];                          // alloc a vector of pointers
        values[0]   = new double[deviceNum * _maxJointsNumForDevice];   // alloc real memory for data
 
        subdevices_p = new SubDevice *[deviceNum];
        subdevices_p[0] = _device->getSubdevice(0);
 
        for (int i = 1; i < deviceNum; i++)
        {
            jointNumbers[i] =  jointNumbers[i-1] + _maxJointsNumForDevice;   // set pointer to correct location
            values      [i] = values[i-1] + _maxJointsNumForDevice;      // set pointer to correct location
            modes       [i] = modes[i-1]  + _maxJointsNumForDevice;      // set pointer to correct location
            subdevices_p[i] = _device->getSubdevice(i);
        }
    }
 
    void destroy()
    {
        // release matrix memory
        delete[] jointNumbers[0];
        delete[] values[0];
        delete[] modes[0];
 
        // release vector of pointers
        delete[] jointNumbers;
        delete[] values;
        delete[] modes;
 
        // delete other vectors
        delete[] subdev_jointsVectorLen;
        delete[] subdevices_p;
    }
};
 
class ControlBoardWrapper :
        public yarp::dev::DeviceDriver,
        public yarp::os::PeriodicThread,
        public yarp::dev::IPidControl,
        public yarp::dev::IPositionControl,
        public yarp::dev::IPositionDirect,
        public yarp::dev::IVelocityControl,
        public yarp::dev::IEncodersTimed,
        public yarp::dev::IMotor,
        public yarp::dev::IMotorEncoders,
        public yarp::dev::IAmplifierControl,
        public yarp::dev::IControlLimits,
        public yarp::dev::IRemoteCalibrator,
        public yarp::dev::IControlCalibration,
        public yarp::dev::ITorqueControl,
        public yarp::dev::IImpedanceControl,
        public yarp::dev::IControlMode,
        public yarp::dev::IMultipleWrapper,
        public yarp::dev::IAxisInfo,
        public yarp::dev::IPreciselyTimed,
        public yarp::dev::IInteractionMode,
        public yarp::dev::IRemoteVariables,
        public yarp::dev::IPWMControl,
        public yarp::dev::ICurrentControl
{
private:
    std::string rootName;
    WrappedDevice device;
 
    bool checkPortName(yarp::os::Searchable &params);
 
    yarp::rosmsg::sensor_msgs::JointState ros_struct;
 
    yarp::os::BufferedPort<yarp::sig::Vector>  outputPositionStatePort;   // Port /state:o streaming out the encoder positions
    yarp::os::BufferedPort<CommandMessage>     inputStreamingPort;        // Input streaming port for high frequency commands
    yarp::os::Port inputRPCPort;                // Input RPC port for set/get remote calls
    yarp::os::Stamp time;                       // envelope to attach to the state port
    yarp::sig::Vector times;                    // time for each joint
    std::mutex timeMutex;
 
    // Buffer associated to the extendedOutputStatePort port; in this case we will use the type generated
    // from the YARP .thrift file
    yarp::os::PortWriterBuffer<yarp::dev::impl::jointData>           extendedOutputState_buffer;
    yarp::os::Port extendedOutputStatePort;         // Port /stateExt:o streaming out the struct with the robot data
 
    // ROS state publisher
    ROSTopicUsageType                                   useROS;                     // decide if open ROS topic or not
    std::vector<std::string>                            jointNames;                 // name of the joints
    std::string                                         rosNodeName;                // name of the rosNode
    std::string                                         rosTopicName;               // name of the rosTopic
    yarp::os::Node                                      *rosNode;                   // add a ROS node
    yarp::os::NetUint32                                 rosMsgCounter;              // incremental counter in the ROS message
    yarp::os::PortWriterBuffer<yarp::rosmsg::sensor_msgs::JointState> rosOutputState_buffer; // Buffer associated to the ROS topic
    yarp::os::Publisher<yarp::rosmsg::sensor_msgs::JointState> rosPublisherPort;    // Dedicated ROS topic publisher
 
    yarp::os::PortReaderBuffer<yarp::os::Bottle>    inputRPC_buffer;                // Buffer associated to the inputRPCPort port
    RPCMessagesParser              RPC_parser;                     // Message parser associated to the inputRPCPort port
    StreamingMessagesParser        streaming_parser;               // Message parser associated to the inputStreamingPort port
 
 
    // RPC calls are concurrent from multiple clients, data used inside the calls has to be protected
    std::mutex                                 rpcDataMutex;                   // mutex to avoid concurrency between more clients using rppc port
    MultiJointData                 rpcData;                        // Structure used to re-arrange data from "multiple_joints" calls.
 
    std::string         partName;               // to open ports and print more detailed debug messages
 
    int               controlledJoints;
    int               base;         // to be removed
    int               top;          // to be removed
    double            period;       // thread rate for publishing data
    bool              _verb;        // make it work and propagate to subdevice if --subdevice option is used
 
    yarp::os::Bottle getOptions();
    bool updateAxisName();
    bool checkROSParams(yarp::os::Searchable &config);
    bool initialize_ROS();
    bool initialize_YARP(yarp::os::Searchable &prop);
    void cleanup_yarpPorts();
 
    // Default usage
    // Open the wrapper only, the attach method needs to be called before using it
    bool openDeferredAttach(yarp::os::Property& prop);
 
    // For the simulator, if a subdevice parameter is given to the wrapper, it will
    // open it and attach to it immediately.
    yarp::dev::PolyDriver *subDeviceOwned;
    bool openAndAttachSubDevice(yarp::os::Property& prop);
 
    bool ownDevices;
    inline void printError(std::string func_name, std::string info, bool result)
    {
        //If result is false, this means that en error occurred in function named func_name, otherwise means that the device doesn't implement the interface to witch func_name belongs to.
       // if(false == result)
       //    yCError(CONTROLBOARDREMAPPER) << "CBW(" << partName << "): " << func_name.c_str() << " on device" << info.c_str() << " returns false";
        //Commented in order to maintain the old behaviour (none message appear if device desn't implement the interface)
        //else
            // yCError(CONTROLBOARDREMAPPER) << "CBW(" << partName << "): " << func_name.c_str() << " on device" << info.c_str() << ": the interface is not available.";
    }
 
    void calculateMaxNumOfJointsInDevices();
 
public:
    ControlBoardWrapper();
    ControlBoardWrapper(const ControlBoardWrapper&) = delete;
    ControlBoardWrapper(ControlBoardWrapper&&) = delete;
    ControlBoardWrapper& operator=(const ControlBoardWrapper&) = delete;
    ControlBoardWrapper& operator=(ControlBoardWrapper&&) = delete;
    ~ControlBoardWrapper() override;
 
    bool verbose() const
    {
        return _verb;
    }
 
    /* Return id of this device */
    std::string getId()
    {
        return partName;
    }
 
    bool close() override;
 
 
    bool open(yarp::os::Searchable& prop) override;
 
    bool detachAll() override;
 
    bool attachAll(const yarp::dev::PolyDriverList &l) override;
 
    void run() override;
 
    /* IPidControl
    These methods are documented by Doxygen in IPidControl.h*/
    bool setPid(const yarp::dev::PidControlTypeEnum& pidtype, int j, const yarp::dev::Pid &p) override;
    bool setPids(const yarp::dev::PidControlTypeEnum& pidtype, const yarp::dev::Pid *ps) override;
    bool setPidReference(const yarp::dev::PidControlTypeEnum& pidtype, int j, double ref) override;
    bool setPidReferences(const yarp::dev::PidControlTypeEnum& pidtype, const double *refs) override;
    bool setPidErrorLimit(const yarp::dev::PidControlTypeEnum& pidtype, int j, double limit) override;
    bool setPidErrorLimits(const yarp::dev::PidControlTypeEnum& pidtype, const double *limits) override;
    bool getPidError(const yarp::dev::PidControlTypeEnum& pidtype, int j, double *err) override;
    bool getPidErrors(const yarp::dev::PidControlTypeEnum& pidtype, double *errs) override;
    bool getPidOutput(const yarp::dev::PidControlTypeEnum& pidtype, int j, double *out) override;
    bool getPidOutputs(const yarp::dev::PidControlTypeEnum& pidtype, double *outs) override;
    bool setPidOffset(const yarp::dev::PidControlTypeEnum& pidtype, int j, double v) override;
    bool getPid(const yarp::dev::PidControlTypeEnum& pidtype, int j, yarp::dev::Pid *p) override;
    bool getPids(const yarp::dev::PidControlTypeEnum& pidtype, yarp::dev::Pid *pids) override;
    bool getPidReference(const yarp::dev::PidControlTypeEnum& pidtype, int j, double *ref) override;
    bool getPidReferences(const yarp::dev::PidControlTypeEnum& pidtype, double *refs) override;
    bool getPidErrorLimit(const yarp::dev::PidControlTypeEnum& pidtype, int j, double *limit) override;
    bool getPidErrorLimits(const yarp::dev::PidControlTypeEnum& pidtype, double *limits) override;
    bool resetPid(const yarp::dev::PidControlTypeEnum& pidtype, int j) override;
    bool disablePid(const yarp::dev::PidControlTypeEnum& pidtype, int j) override;
    bool enablePid(const yarp::dev::PidControlTypeEnum& pidtype, int j) override;
    bool isPidEnabled(const yarp::dev::PidControlTypeEnum& pidtype, int j, bool* enabled) override;
 
    /* IPositionControl */
 
    bool getAxes(int *ax) override;
 
    bool positionMove(int j, double ref) override;
 
    bool positionMove(const double *refs) override;
 
    bool positionMove(const int n_joints, const int *joints, const double *refs) override;
 
    bool getTargetPosition(const int joint, double *ref) override;
 
    bool getTargetPositions(double *refs) override;
 
    bool getTargetPositions(const int n_joint, const int *joints, double *refs) override;
 
    bool relativeMove(int j, double delta) override;
 
    bool relativeMove(const double *deltas) override;
 
    bool relativeMove(const int n_joints, const int *joints, const double *deltas) override;
 
    bool checkMotionDone(int j, bool *flag) override;
    bool checkMotionDone(bool *flag) override;
 
    bool checkMotionDone(const int n_joints, const int *joints, bool *flags) override;
 
    bool setRefSpeed(int j, double sp) override;
 
    bool setRefSpeeds(const double *spds) override;
 
    bool setRefSpeeds(const int n_joints, const int *joints, const double *spds) override;
 
    bool setRefAcceleration(int j, double acc) override;
 
    bool setRefAccelerations(const double *accs) override;
 
    bool setRefAccelerations(const int n_joints, const int *joints, const double *accs) override;
 
    bool getRefSpeed(int j, double *ref) override;
 
    bool getRefSpeeds(double *spds) override;
 
    bool getRefSpeeds(const int n_joints, const int *joints, double *spds) override;
 
    bool getRefAcceleration(int j, double *acc) override;
 
    bool getRefAccelerations(double *accs) override;
 
    bool getRefAccelerations(const int n_joints, const int *joints, double *accs) override;
 
    bool stop(int j) override;
 
    bool stop() override;
 
 
    bool stop(const int n_joints, const int *joints) override;
 
    /* IVelocityControl */
 
    bool velocityMove(int j, double v) override;
 
    bool velocityMove(const double *v) override;
 
    /* IEncoders */
 
    bool resetEncoder(int j) override;
 
    bool resetEncoders() override;
 
    bool setEncoder(int j, double val) override;
 
    bool setEncoders(const double *vals) override;
 
    bool getEncoder(int j, double *v) override;
 
    bool getEncoders(double *encs) override;
 
    bool getEncodersTimed(double *encs, double *t) override;
 
    bool getEncoderTimed(int j, double *v, double *t) override;
 
    bool getEncoderSpeed(int j, double *sp) override;
 
    bool getEncoderSpeeds(double *spds) override;
 
    bool getEncoderAcceleration(int j, double *acc) override;
    bool getEncoderAccelerations(double *accs) override;
 
    /* IMotorEncoders */
 
    bool getNumberOfMotorEncoders(int *num) override;
 
    bool resetMotorEncoder(int m) override;
 
    bool resetMotorEncoders() override;
 
    bool setMotorEncoderCountsPerRevolution(int m, const double cpr) override;
 
    bool getMotorEncoderCountsPerRevolution(int m, double *cpr) override;
 
    bool setMotorEncoder(int m, const double val) override;
 
    bool setMotorEncoders(const double *vals) override;
 
    bool getMotorEncoder(int m, double *v) override;
 
    bool getMotorEncoders(double *encs) override;
 
    bool getMotorEncodersTimed(double *encs, double *t) override;
 
    bool getMotorEncoderTimed(int m, double *v, double *t) override;
 
    bool getMotorEncoderSpeed(int m, double *sp) override;
 
    bool getMotorEncoderSpeeds(double *spds) override;
 
    bool getMotorEncoderAcceleration(int m, double *acc) override;
    bool getMotorEncoderAccelerations(double *accs) override;
 
    /* IAmplifierControl */
 
    bool enableAmp(int j) override;
 
    bool disableAmp(int j) override;
 
    bool getAmpStatus(int *st) override;
 
    bool getAmpStatus(int j, int *v) override;
 
    bool getCurrents(double *vals) override;
 
    bool getCurrent(int j, double *val) override;
 
    bool setMaxCurrent(int j, double v) override;
 
    bool getMaxCurrent(int j, double *v) override;
 
    /* Get the the nominal current which can be kept for an indefinite amount of time
     * without harming the motor. This value is specific for each motor and it is typically
     * found in its datasheet. The units are Ampere.
     * This value and the peak current may be used by the firmware to configure
     * an I2T filter.
     * @param m motor number
     * @param val storage for return value. [Ampere]
     * @return true/false success failure.
     */
    bool getNominalCurrent(int m, double *val) override;
 
    /* Set the the nominal current which can be kept for an indefinite amount of time
    * without harming the motor. This value is specific for each motor and it is typically
    * found in its datasheet. The units are Ampere.
    * This value and the peak current may be used by the firmware to configure
    * an I2T filter.
    * @param m motor number
    * @param val storage for return value. [Ampere]
    * @return true/false success failure.
    */
    bool setNominalCurrent(int m, const double val) override;
 
    /* Get the the peak current which causes damage to the motor if maintained
     * for a long amount of time.
     * The value is often found in the motor datasheet, units are Ampere.
     * This value and the nominal current may be used by the firmware to configure
     * an I2T filter.
     * @param m motor number
     * @param val storage for return value. [Ampere]
     * @return true/false success failure.
     */
    bool getPeakCurrent(int m, double *val) override;
 
    /* Set the the peak current. This value  which causes damage to the motor if maintained
     * for a long amount of time.
     * The value is often found in the motor datasheet, units are Ampere.
     * This value and the nominal current may be used by the firmware to configure
     * an I2T filter.
     * @param m motor number
     * @param val storage for return value. [Ampere]
     * @return true/false success failure.
     */
    bool setPeakCurrent(int m, const double val) override;
 
    /* Get the the current PWM value used to control the motor.
     * The units are firmware dependent, either machine units or percentage.
     * @param m motor number
     * @param val filled with PWM value.
     * @return true/false success failure.
     */
    bool getPWM(int m, double* val) override;
 
    /* Get the PWM limit for the given motor.
     * The units are firmware dependent, either machine units or percentage.
     * @param m motor number
     * @param val filled with PWM limit value.
     * @return true/false success failure.
     */
    bool getPWMLimit(int m, double* val) override;
 
    /* Set the PWM limit for the given motor.
     * The units are firmware dependent, either machine units or percentage.
     * @param m motor number
     * @param val new value for the PWM limit.
     * @return true/false success failure.
     */
    bool setPWMLimit(int m, const double val) override;
 
    /* Get the power source voltage for the given motor in Volt.
     * @param m motor number
     * @param val filled with return value.
     * @return true/false success failure.
     */
    bool getPowerSupplyVoltage(int m, double* val) override;
 
    /* IControlLimits */
 
    bool setLimits(int j, double min, double max) override;
 
    bool getLimits(int j, double *min, double *max) override;
 
    bool setVelLimits(int j, double min, double max) override;
 
    bool getVelLimits(int j, double *min, double *max) override;
 
    /* IRemoteVariables */
 
    bool getRemoteVariable(std::string key, yarp::os::Bottle& val) override;
 
    bool setRemoteVariable(std::string key, const yarp::os::Bottle& val) override;
 
    bool getRemoteVariablesList(yarp::os::Bottle* listOfKeys) override;
 
    /* IRemoteCalibrator */
 
    bool isCalibratorDevicePresent(bool *isCalib) override;
 
    yarp::dev::IRemoteCalibrator *getCalibratorDevice() override;
 
    bool calibrateSingleJoint(int j) override;
 
    bool calibrateWholePart() override;
 
    bool homingSingleJoint(int j) override;
 
    bool homingWholePart() override;
 
    bool parkSingleJoint(int j, bool _wait=true) override;
 
    bool parkWholePart() override;
 
    bool quitCalibrate() override;
 
    bool quitPark() override;
 
    /* IControlCalibration */
    bool calibrateAxisWithParams(int j, unsigned int ui, double v1, double v2, double v3) override;
 
    bool setCalibrationParameters(int j, const yarp::dev::CalibrationParameters& params) override;
 
    bool calibrationDone(int j) override;
 
    bool abortPark() override;
 
    bool abortCalibration() override;
 
    /* IMotor */
    bool getNumberOfMotors   (int *num) override;
 
    bool getTemperature      (int m, double* val) override;
 
    bool getTemperatures     (double *vals) override;
 
    bool getTemperatureLimit (int m, double* val) override;
 
    bool setTemperatureLimit (int m, const double val) override;
 
    bool getGearboxRatio(int m, double* val) override;
 
    bool setGearboxRatio(int m, const double val) override;
 
    /* IAxisInfo */
    bool getAxisName(int j, std::string& name) override;
 
    bool getJointType(int j, yarp::dev::JointTypeEnum& type) override;
 
    bool getRefTorques(double *refs) override;
 
    bool getRefTorque(int j, double *t) override;
 
    bool setRefTorques(const double *t) override;
 
    bool setRefTorque(int j, double t) override;
 
    bool setRefTorques(const int n_joint, const int *joints, const double *t) override;
 
    bool getMotorTorqueParams(int j,  yarp::dev::MotorTorqueParameters *params) override;
 
    bool setMotorTorqueParams(int j,  const yarp::dev::MotorTorqueParameters params) override;
 
     bool setImpedance(int j, double stiff, double damp) override;
 
    bool setImpedanceOffset(int j, double offset) override;
 
    bool getTorque(int j, double *t) override;
 
    bool getTorques(double *t) override;
 
    bool getTorqueRange(int j, double *min, double *max) override;
 
    bool getTorqueRanges(double *min, double *max) override;
 
    bool getImpedance(int j, double* stiff, double* damp) override;
 
    bool getImpedanceOffset(int j, double* offset) override;
 
    bool getCurrentImpedanceLimit(int j, double *min_stiff, double *max_stiff, double *min_damp, double *max_damp) override;
 
    bool getControlMode(int j, int *mode) override;
 
    bool getControlModes(int *modes) override;
 
    // iControlMode2
    bool getControlModes(const int n_joint, const int *joints, int *modes) override;
 
    bool setControlMode(const int j, const int mode) override;
 
    bool setControlModes(const int n_joints, const int *joints, int *modes) override;
 
    bool setControlModes(int *modes) override;
 
    // IPositionDirect
 
    bool setPosition(int j, double ref) override;
 
    bool setPositions(const int n_joints, const int *joints, const double *dpos) override;
 
    bool setPositions(const double *refs) override;
 
    bool getRefPosition(const int joint, double *ref) override;
 
    bool getRefPositions(double *refs) override;
 
    bool getRefPositions(const int n_joint, const int *joints, double *refs) override;
 
    yarp::os::Stamp getLastInputStamp() override;
 
    //
    // IVelocityControl2 Interface
    //
    bool velocityMove(const int n_joints, const int *joints, const double *spds) override;
 
    bool getRefVelocity(const int joint, double* vel) override;
 
    bool getRefVelocities(double* vels) override;
 
    bool getRefVelocities(const int n_joint, const int* joints, double* vels) override;
 
    bool getInteractionMode(int j, yarp::dev::InteractionModeEnum* mode) override;
 
    bool getInteractionModes(int n_joints, int *joints, yarp::dev::InteractionModeEnum* modes) override;
 
    bool getInteractionModes(yarp::dev::InteractionModeEnum* modes) override;
 
    bool setInteractionMode(int j, yarp::dev::InteractionModeEnum mode) override;
 
    bool setInteractionModes(int n_joints, int *joints, yarp::dev::InteractionModeEnum* modes) override;
 
    bool setInteractionModes(yarp::dev::InteractionModeEnum* modes) override;
 
    //
    // IPWMControl Interface
    //
 
    bool setRefDutyCycle(int j, double v) override;
    bool setRefDutyCycles(const double *v) override;
    bool getRefDutyCycle(int j, double *v) override;
    bool getRefDutyCycles(double *v) override;
    bool getDutyCycle(int j, double *v) override;
    bool getDutyCycles(double *v) override;
 
    //
    // ICurrentControl Interface
    //
 
    //bool getAxes(int *ax) override;
    //bool getCurrent(int j, double *t) override;
    //bool getCurrents(double *t) override;
    bool getCurrentRange(int j, double *min, double *max) override;
    bool getCurrentRanges(double *min, double *max) override;
    bool setRefCurrents(const double *t) override;
    bool setRefCurrent(int j, double t) override;
    bool setRefCurrents(const int n_joint, const int *joints, const double *t) override;
    bool getRefCurrents(double *t) override;
    bool getRefCurrent(int j, double *t) override;
};
 
 
#endif // YARP_DEV_CONTROLBOARDWRAPPER_CONTROLBOARDWRAPPER_H