Kuka160nAxesVelocityController.hpp

#ifndef KUKA160_NAXES_VELOCITY_CONTROLLER_HPP
#define KUKA160_NAXES_VELOCITY_CONTROLLER_HPP

#include <vector>
#include <rtt/RTT.hpp>

#include <rtt/TaskContext.hpp>
#include <rtt/Ports.hpp>
#include <rtt/Event.hpp>
#include <rtt/Command.hpp>
#include <rtt/Properties.hpp>

#if defined (OROPKG_OS_LXRT)
#include "dev/ComediDevice.hpp"
#include "dev/ComediSubDeviceAOut.hpp"
#include "dev/ComediSubDeviceDIn.hpp"
#include "dev/ComediSubDeviceDOut.hpp"
#include "dev/ComediEncoder.hpp"
#include "dev/IncrementalEncoderSensor.hpp"
#include <rtt/dev/AnalogOutput.hpp>
#include <rtt/dev/DigitalOutput.hpp>
#include <rtt/dev/DigitalInput.hpp>
#include "dev/AnalogDrive.hpp"
#include "dev/Axis.hpp"
#endif
#include "dev/SimulationAxis.hpp"
#include <rtt/dev/AxisInterface.hpp>

#include <ocl/OCL.hpp>
#include <ocl/VectorTemplateComposition.hpp>

#include <kdl/chain.hpp>
namespace OCL
{
    class Kuka160nAxesVelocityController : public RTT::TaskContext
    {
    public:
        Kuka160nAxesVelocityController(std::string name);
        virtual ~Kuka160nAxesVelocityController();


    protected:
        RTT::ReadDataPort<std::vector<double> >   driveValues_port;
        RTT::DataPort<std::vector<bool> >    referenceValues_port;
        RTT::DataPort<std::vector<double> >       positionValues_port;


        Property<std::vector<double> > driveLimits_prop;

        Property<std::vector<double> > lowerPositionLimits_prop;

        Property<std::vector<double> > upperPositionLimits_prop;

        Property<std::vector <double> > initialPosition_prop;

        Property<std::vector <double> > driveOffset_prop;

        Property<bool > simulation_prop;
        bool            simulation;

        Property<std::vector<std::string> > EmergencyEvents_prop;


        RTT::Constant<unsigned int> num_axes_attr;

        Attribute<KDL::Chain> chain_attr;
        KDL::Chain kinematics;

        RTT::Event< void(std::string) > driveOutOfRange_evt;

        RTT::Event< void(std::string) > positionOutOfRange_evt;

    private:
        //
        // Members implementing the component interface
        //

        //
        // COMMANDS :
        //

        virtual bool startAllAxes();
        virtual bool stopAllAxes();
        virtual bool lockAllAxes();
        virtual bool unlockAllAxes();
        virtual bool addDriveOffset(const std::vector<double>& offset);

        virtual bool initPosition(const std::vector<double>& switchposition);

        virtual bool prepareForUse();
        virtual bool prepareForUseCompleted() const;

        virtual bool prepareForShutdown();
        virtual bool prepareForShutdownCompleted() const;

        void EmergencyStop(std::string message)
        {
            log(Error) << "---------------------------------------------" << endlog();
            log(Error) << "--------- EMERGENCY STOP --------------------" << endlog();
            log(Error) << "---------------------------------------------" << endlog();
            log(Error) << message << endlog();
            this->fatal();
        };
        std::vector<RTT::Handle> EmergencyEventHandlers;

        bool activated;

        std::vector<double>     positionConvertFactor;

        std::vector<double>     driveConvertFactor;
        std::vector<double>     driveValues,positionValues;
        std::vector<bool>       references;


    public:
        virtual bool configureHook();
        virtual bool startHook();
        virtual void updateHook();
        virtual void stopHook();
        virtual void cleanupHook();

        //
        // Members implementing the interface to the hardware
        //
#if  (defined (OROPKG_OS_LXRT))
        ComediDevice*                    comediDevAOut;
        ComediDevice*                    comediDevEncoder;
        ComediDevice*                    comediDevDInOut;
        ComediSubDeviceAOut*             comediSubdevAOut;
        ComediSubDeviceDIn*              comediSubdevDIn;
        ComediSubDeviceDOut*             comediSubdevDOut;
        std::vector<RTT::EncoderInterface*>   encoderInterface;

        std::vector<RTT::AnalogOutput*> vref;
        std::vector<OCL::IncrementalEncoderSensor*>   encoder;
        std::vector<RTT::DigitalOutput*>      enable;
        std::vector<OCL::AnalogDrive*>        drive;
        std::vector<RTT::DigitalOutput*>      brake;
        std::vector<RTT::DigitalInput*>       reference;
        std::vector<OCL::Axis*>               axes_hardware;
#endif
        std::vector<OCL::AxisInterface*>      axes;
        std::vector<OCL::SimulationAxis*>     axes_simulation;


    };//class Kuka160nAxesVelocityController
}//namespace Orocos
#endif // KUKA160NAXESVELOCITYCONTROLLER

---