d4/d08/_mitsubishi_h7_8h_source.html

//

// Copyright (c) 2009, Markus Rickert

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are met:

//

// * Redistributions of source code must retain the above copyright notice,

//   this list of conditions and the following disclaimer.

// * Redistributions in binary form must reproduce the above copyright notice,

//   this list of conditions and the following disclaimer in the documentation

//   and/or other materials provided with the distribution.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

//


#ifndef RL_HAL_MITSUBISHIH7_H

#define RL_HAL_MITSUBISHIH7_H


#include <cstdint>

#include <string>


#include "CartesianPositionActuator.h"

#include "CartesianPositionSensor.h"

#include "CyclicDevice.h"

#include "Gripper.h"

#include "JointPositionActuator.h"

#include "JointPositionSensor.h"

#include "MitsubishiR3.h"

#include "Socket.h"


namespace rl

{

    namespace hal

    {

        class MitsubishiH7 :

            public CartesianPositionActuator,

            public CartesianPositionSensor,

            public CyclicDevice,

            public Gripper,

            public JointPositionActuator,

            public JointPositionSensor

        {

        public:

            enum Mode

            {

                MODE_JOINT = 1,

                MODE_POSE = 0,

                MODE_PULSE = 2

            };


            MitsubishiH7(

                const ::std::size_t& dof,

                const ::std::string& addressServer,

                const ::std::string& addressClient,

                const unsigned short int& portTcp = 10001,

                const unsigned short int& portUdp = 10000,

                const Mode& mode = MODE_JOINT,

                const ::std::uint16_t& haltIoData = 0x00AA,

                const ::std::uint16_t& releaseIoData = 0x00A6,

                const ::std::uint16_t& shutIoData = 0x000A9

            );


            virtual ~MitsubishiH7();


            void close();


            ::rl::math::Transform getCartesianPosition() const;


            ::Eigen::Matrix< ::std::int32_t, ::Eigen::Dynamic, 1> getCurrentFeedback() const;


            ::std::size_t getFilter() const;


            ::std::uint16_t getIoData() const;


            ::rl::math::Vector getJointPosition() const;


            Mode getMode() const;


            ::Eigen::Matrix< ::std::int32_t, ::Eigen::Dynamic, 1> getMotorPulse() const;


            void halt();


            void loadProgram(const ::std::string& name, const ::std::string& program);


            void open();


            void release();


            void setCartesianPosition(const ::rl::math::Transform& x);


            void setFilter(const ::std::size_t& filter);


            void setInput(const ::std::uint16_t& bitTop);


            void setJointPosition(const ::rl::math::Vector& q);


            void setMode(const Mode& mode);


            void setMotorPulse(const ::Eigen::Matrix< ::std::int32_t, ::Eigen::Dynamic, 1>& p);


            void setOutput(const ::std::uint16_t& bitTop, const ::std::uint16_t& bitMask, const ::std::uint16_t& ioData);


            void shut();


            void start();


            void startProgram(const ::std::string& name);


            void step();


            void stop();


            void stopProgram();


        protected:

            struct World

            {

                float x;

                float y;

                float z;

                float a;

                float b;

                float c;

                float l1;

                float l2;

            };


            struct Joint

            {

                float j1;

                float j2;

                float j3;

                float j4;

                float j5;

                float j6;

                float j7;

                float j8;

            };


            struct Pose

            {

                World w;

                ::std::uint32_t sflg1;

                ::std::uint32_t sflg2;

            };


            struct Pulse

            {

                ::std::int32_t p1;

                ::std::int32_t p2;

                ::std::int32_t p3;

                ::std::int32_t p4;

                ::std::int32_t p5;

                ::std::int32_t p6;

                ::std::int32_t p7;

                ::std::int32_t p8;

            };


            struct Command

            {

                union Data

                {

                    Pose pos;

                    Joint jnt;

                    Pulse pls;

                    ::std::int32_t lng[8];

                };

                ::std::uint16_t command;

                ::std::uint16_t sendType;

                ::std::uint16_t recvType;

                ::std::uint16_t reserve;

                Data dat;

                ::std::uint16_t sendIoType;

                ::std::uint16_t recvIoType;

                ::std::uint16_t bitTop;

                ::std::uint16_t bitMask;

                ::std::uint16_t ioData;

                ::std::uint16_t tCount;

                ::std::uint32_t cCount;

                ::std::uint16_t recvType1;

                ::std::uint16_t reserve1;

                Data dat1;

                ::std::uint16_t recvType2;

                ::std::uint16_t reserve2;

                Data dat2;

                ::std::uint16_t recvType3;

                ::std::uint16_t reserve3;

                Data dat3;

            };


            const static ::std::uint16_t MXT_COMMAND_NULL = 0;

            const static ::std::uint16_t MXT_COMMAND_MOVE = 1;

            const static ::std::uint16_t MXT_COMMAND_END = 255;


            const static ::std::uint16_t MXT_IO_NULL = 0;

            const static ::std::uint16_t MXT_IO_OUT = 1;

            const static ::std::uint16_t MXT_IO_IN = 2;


            const static ::std::uint16_t MXT_TYPE_NULL = 0;

            const static ::std::uint16_t MXT_TYPE_POSE = 1;

            const static ::std::uint16_t MXT_TYPE_JOINT = 2;

            const static ::std::uint16_t MXT_TYPE_PULSE = 3;

            const static ::std::uint16_t MXT_TYPE_POSE_FILTER = 4;

            const static ::std::uint16_t MXT_TYPE_JOINT_FILTER = 5;

            const static ::std::uint16_t MXT_TYPE_PULSE_FILTER = 6;

            const static ::std::uint16_t MXT_TYPE_POSE_FEEDBACK = 7;

            const static ::std::uint16_t MXT_TYPE_JOINT_FEEDBACK = 8;

            const static ::std::uint16_t MXT_TYPE_PULSE_FEEDBACK = 9;

            const static ::std::uint16_t MXT_TYPE_CURRENT_COMMAND = 10;

            const static ::std::uint16_t MXT_TYPE_CURRENT_FEEDBACK = 11;


        private:

            ::std::string addressClient;


            ::std::string addressServer;


            ::std::size_t filter;


            ::std::uint16_t haltIoData;


            Command in;


            Mode mode;


            Command out;


            MitsubishiR3 r3;


            ::std::uint16_t releaseIoData;


            ::std::uint16_t shutIoData;


            Socket socket;

        };

    }

}


#endif // RL_HAL_MITSUBISHIH7_H