MitsubishiR3.h

Go to the documentation of this file.

//
// 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_MITSUBISHIR3_H
#define RL_HAL_MITSUBISHIR3_H
 
#include <array>
#include <cstdint>
#include <string>
 
#include "Com.h"
#include "ComException.h"
#include "Socket.h"
 
namespace rl
{
    namespace hal
    {
        class MitsubishiR3 : public Com
        {
        public:
            enum HandSts
            {
                HANDSTS_NOTUSED = -1,
                HANDSTS_OPEN = 1,
                HANDSTS_CLOSED = 2
            };
            
            enum HandType
            {
                HANDTYPE_NOTUSED = -1,
                HANDTYPE_SINGLE = 0,
                HANDTYPE_DOUBLE = 1
            };
            
            enum TaskCond
            {
                TASKCOND_START,
                TASKCOND_ALWAYS,
                TASKCOND_ERROR
            };
            
            struct EditSts
            {
                bool isEditing;
                bool isRunning;
                bool isChanged;
            };
            
            class Exception : public ComException
            {
            public:
                Exception(const int& errorNo, const ::std::string& what_arg);
                
                virtual ~Exception() throw();
                
                int getErrorNo() const;
                
            protected:
                
            private:
                int errorNo;
            };
            
            struct Hand
            {
                int outputNo;
                HandSts handSts;
                HandType handType;
            };
            
            typedef bool MechInfo[3];
            
            struct RunSts
            {
                bool isRepeat;
                bool isCycleStopOff;
                bool isMlockOn;
                bool isTeach;
                bool isTeachRunning;
                bool isServoOn;
                bool isRun;
                bool isOperationEnable;
            };
            
            struct StopSts
            {
                bool isEmgStop;
                bool isStop;
                bool isWait;
                bool isStopSignalOff;
                bool isProgramSelectEnable;
                bool isReserve;
                bool isPseudoInput;
            };
            
            struct CalibState
            {
                bool isDefined;
                bool isAxis[8];
            };
            
            struct RunState
            {
                char programName[256];
                int lineNo;
                int override;
                EditSts editSts;
                RunSts runSts;
                StopSts stopSts;
                int errorNo;
                int stepNo;
                MechInfo mechInfo;
                char taskPrgName[256];
                bool isTaskModeCycle;
                TaskCond taskCond;
                int taskPri;
                int mechNo;
            };
            
            struct StopSignalState
            {
                bool isTb;
                bool isPc;
                bool isIo;
                bool isOp;
                bool isIoEmg;
                bool isOpEmg;
                bool isTbEmg;
            };
            
            struct StopState
            {
                RunSts runSts;
                StopSts stopSts;
                int errorNo;
                int stepNo;
                int mechNo;
            };
            
            MitsubishiR3(
                const ::std::string& address,
                const unsigned short int& port = 10001
            );
            
            virtual ~MitsubishiR3();
            
            void close();
            
            void doCalib(CalibState& state);
            
            void doCntl(const bool& doOn);
            
            void doDatinst(const ::std::string& j1, const ::std::string& j2, const ::std::string& j3, const ::std::string& j4, const ::std::string& j5, const ::std::string& j6, const ::std::string& checksum);
            
            void doDatinst(const ::std::string& j1, const ::std::string& j2, const ::std::string& j3, const ::std::string& j4, const ::std::string& j5, const ::std::string& j6, const ::std::string& j7, const ::std::string& j8, const ::std::string& checksum);
            
            StopState doDstate();
            
            void doEclr();
            
            void doEmdat(const ::std::string& program);
            
            ::std::string doErrormes(const int& errorNo);
            
            void doExec(const ::std::string& instruction);
            
            void doHnd(const bool& doOpen, const int& handNo);
            
            ::std::array<Hand, 8> doHndsts();
            
            void doInEquals(const ::std::size_t& inNo, const ::std::string& inVal);
            
            void doLoad(const ::std::string& programName);
            
            void doNew();
            
            void doOutEquals(const ::std::size_t& outNo, const ::std::string& outVal);
            
            void doRstalrm();
            
            void doRstpwr();
            
            void doRun(const ::std::string& programName, const bool& doModeCycle = false);
            
            void doSave();
            
            void doSlotinit();
            
            void doSrv(const bool& doOn);
            
            RunState doState();
            
            void doStop();
            
            StopSignalState doStpsig();
            
            void loadProgram(const ::std::string& name, const ::std::string& program);
            
            void open();
            
            void startProgram(const ::std::string& name);
            
            void stopProgram();
            
        protected:
            
        private:
            Socket socket;
        };
    }
}
 
#endif // RL_HAL_MITSUBISHIR3_H