StreamingDevice.hpp

#ifndef __STREAMING_DEVICE_HPP__
#define __STREAMING_DEVICE_HPP__
 
#include <string>
#include <vector>
 
#include <yarp/os/Searchable.h>
#include <yarp/os/Value.h>
#include <yarp/dev/PolyDriver.h>
 
#include "ICartesianControl.h"
#include "CentroidTransform.hpp"
 
namespace roboticslab
{
 
class StreamingDevice;
class CentroidTransform;
 
class StreamingDeviceFactory
{
public:
    static StreamingDevice * makeDevice(const std::string & deviceName, yarp::os::Searchable & config);
 
private:
    StreamingDeviceFactory();
};
 
class StreamingDevice : protected yarp::dev::PolyDriver
{
    friend CentroidTransform;
 
public:
    using PolyDriver::isValid;
 
    StreamingDevice(yarp::os::Searchable & config);
 
    virtual ~StreamingDevice();
 
    virtual bool acquireInterfaces() = 0;
 
    virtual bool initialize(bool usingStreamingPreset)
    {
        return true;
    }
 
    virtual bool acquireData() = 0;
 
    virtual bool transformData(double scaling);
 
    virtual int getActuatorState()
    {
        return actuatorState;
    }
 
    virtual bool hasValidMovementData() const;
 
    virtual void sendMovementCommand(double timestamp) = 0;
 
    virtual void stopMotion() = 0;
 
    void setCartesianControllerHandle(ICartesianControl * iCartesianControl)
    {
        this->iCartesianControl = iCartesianControl;
    }
 
protected:
    ICartesianControl * iCartesianControl;
 
    std::vector<double> data;
    std::vector<bool> fixedAxes;
 
    int actuatorState;
 
private:
    void configureFixedAxes(const yarp::os::Value & v);
};
 
class InvalidDevice : public StreamingDevice
{
public:
    InvalidDevice()
        : StreamingDevice(yarp::os::Value::getNullValue())
    {}
 
    bool acquireInterfaces() override
    {
        return false;
    }
 
    bool acquireData() override
    {
        return false;
    }
 
    void sendMovementCommand(double timestamp) override
    {}
 
    void stopMotion() override
    {}
};
 
} // namespace roboticslab
 
#endif // __STREAMING_DEVICE_HPP__