CyberX8/Framework/RTEquipmentLibrary/HardwareUnits/Robots/NX100/Handler.cs

using System;
using System.Text;
using Aitex.Core.RT.Device;
using Aitex.Sorter.Common;
using MECF.Framework.Common.Equipment;
using MECF.Framework.Common.SubstrateTrackings;
using System.Text.RegularExpressions;
using Aitex.Core.RT.Log;
using System.Collections.Generic;

namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Robot.NX100
{
    /* 
     * A command is transmitted from the host in the following format.
     * $ UNo (SeqNo) COMMAND Parameter Sum CR\
     * • $: Start mark (1 byte)
        Indicates the start of the message.
        • UNo: Unit No. (1 byte)
        Indicates the unit number
        • SeqNo: Sequence number (Non/1/2/3 bytes)
        Sequence number is used to avoid duplicate motion when sending of
        commands improperly. An integer parameter can specify the length of
        SeqNo. (Non/1/2/3 bytes). See parameter table for more details. (Default:
        Non), 设置 2bytes
        • Parameter: Parameter (Differs depending on the command.)
        Sets the operation axis, the moving amount, etc. following a command.
        • Sum: Checksum (2 bytes)
        This information is used for the communications error check.
        Calculate the sum of the ASCII characters (‘0’ to ‘9’ and ‘A’ to ‘F’), in “Uno”,
        “COMMAND” and “Parameter” section, and take the lowest tow digit.
    */
    public class handler<T> : IHandler where T : ITransferMsg, new()
    {
        public int ID { get; set; }
        public int Unit { get; set; }

        public bool IsBackground { get { return _imp.background; } }


        private static int retry_time = 3;
        private int retry_count = retry_time;

        private object[] _objs = null;



        private TokenGenerator _generator;

        private T _imp = new T();

        private List<string> _words = new List<string>();

        public handler(IDevice device)
        {
            _imp.Robot = device;
        }

        public handler(IDevice device, ref TokenGenerator gen, params object[] objs)
        {
            _imp.Robot = device;
            this._generator = gen;
            this._objs = objs;
        }


        public bool Execute<TPort>(ref TPort port) where TPort : ICommunication
        {
            retry_count = retry_time;
            ID = _generator.create();
            return port.Write(string.Format("{0}{1}{2}", ProtocolTag.tag_cmd_start, package().Replace(",", ""), ProtocolTag.tag_end));
        }
        /// <summary>
        /// return value: bhandle
        /// </summary>
        /// <typeparam name="TPort"></typeparam>
        /// <param name="port"></param>
        /// <param name="msg"></param>
        /// <param name="completed"></param>
        /// <returns></returns>
        /// 

        public bool OnMessage<TPort>(ref TPort port, string message, out bool completed) where TPort : ICommunication
        {
            //$1E000003AC0300010
            //message = ">,1,EVNT,100,2018/11/16 17:01:06,2BA0,A1";
            //message = " !,1,36,40,2BA0,MTRS,002200,-0011931,-0610171,00179995,00049818,00186336,57";
            //message = "!,1,16,40,0000,MTCH,000483,-0011862,00000000,00179516,00090369,00172882,0A";
            //message = "$156000000RMAPC2FF01OK02OK03OK04OK05OK06OK07OK08OK09--10--11--12--13--14--15--16--17--18--19--20--21--22--23--24--25--96";
            //message =!283000000MALNE5. 
            try
            {
                completed = false;

                string package = message;
                _words.Clear();


                string type = package.Substring(0,1);
                _words.Add(type);

                int unit = int.Parse(package.Substring(1, 1));
                _words.Add(package.Substring(1, 1));  

                string sum = package.Substring(package.Length - 2, 2);
                string check = Checksum(package);
                if (sum != check)
                {
                    throw (new InvalidPackageException(string.Format("check sum error{0}", package)));
                }

                if (type != ProtocolTag.resp_tag_event && type != ProtocolTag.resp_tag_error)
                {
                    _words.Add(package.Substring(2, 2));
                    int seq = int.Parse(package.Substring(2,2));

                    if (seq != ID)
                        return false;

                    if (unit != Unit)
                    {
                        throw (new InvalidPackageException(string.Format("invalid unit {0}", package)));
                    }
                }

                if (type == ProtocolTag.resp_tag_error)
                {
                    //? Ackcd Sum CR
                    string error = package.Substring(1,4);
                    //‘1’: Warning 1 (W1), ‘2’: Warning 2 (W2), ‘3’: Important alarm 1 (A1), ‘4’: Important alarm 2 (A2),
                    //‘5’: Serious alarm (F)

                    if (error[0] != '1' || error[0] != '2')
                    {
                        string warning = string.Format("can't execute retry, {0}", error);
                        //LOG.Warning(warning);
                        throw (new ExcuteFailedException(warning));
                    }
                    if (retry_count-- <= 0)
                    {
                        string warning = string.Format("retry over {0} times", retry_time);
                        //LOG.Warning(warning);
                        throw (new ExcuteFailedException(warning));
                    }

                    port.Write(string.Format("{0}{1}{2}", ProtocolTag.tag_cmd_start, this.package(), ProtocolTag.tag_end));
                    return true;
                }
                else if (type == ProtocolTag.resp_tag_event)
                {
                    //0 1   2-3    4-7    8-10 
                    //> UNo SeqNo COMMAND EvNo EvData Sum CR
                    //• COMMAND : Command (4 Byte) EVNT(Fixed length)
                    //• EvNo: Event number(

                    _words.Add(package.Substring(4, 4));   //stsN

                    string evtType = package.Substring(8, 10);
                    _words.Add(evtType);   //Errcd

                    string evtInfo = package.Substring(11, package.Length - 10 -2 );
                    _words.Add(evtInfo);   //Errcd

                    if (_imp.evt)
                        completed = _imp.unpackage(type, _words.ToArray());
                    return _imp.evt;
                }
                else
                {
                    //0 1   2,3     4,5  6-9
                    //! UNo (SeqNo) StsN Errcd COMMAND Sum 

                    _words.Add(package.Substring(4, 2));   //stsN
                    string error = package.Substring(6, 4);
                    //int intError = Convert.ToInt32(error, 16);
                    if (error !=  "0000")
                    {
                        string warning = string.Format("Robot execute failed, return error {0}", error);
                        throw (new ExcuteFailedException(warning));
                    }

                    _words.Add(error);   //Errcd


                    _words.Add(package.Substring(10, package.Length - 10 -2)) ;   //COMMAND

                    completed = _imp.unpackage(type, _words.ToArray());
                    if (completed)
                    {
                        _generator.release(ID);
                        if (_imp.background)
                        {
                            ID = this._generator.create();
                            port.Write(string.Format("{0}{1}{2}", ProtocolTag.tag_cmd_start, ackn(), ProtocolTag.tag_end));
                            _generator.release(ID);
                        }

                        //wait 2ms
                        return true;
                    }

                    return true;
                }

            }
            catch (ExcuteFailedException e)
            {
                throw (e);
            }
            catch (InvalidPackageException e)
            {
                throw e;
            }
            catch (Exception ex)
            {
                LOG.WriteExeption(ex);

                throw (new InvalidPackageException(message));
            }
        }

        private string Checksum(string package)
        {
            int start = package.IndexOf(ProtocolTag.cmd_token);
            int end = package.LastIndexOf(ProtocolTag.cmd_token);

            start = 1;
            end = package.Length - 2 - 1;


            int len = end - start + 1;
            if (len > 1)
            {
                string data = package.Substring(start, len);
                return Checksum(Encoding.Default.GetBytes(data));
            }

            return "";
        }

        private string Checksum(byte[] bytes)
        {
            int sum = 0;
            foreach (byte code in bytes)
            {
                sum += code;
            }
            string hex = String.Format("{0:X2}", sum % 256);
            return hex;
        }


        private string package()
        {
            //$,<UNo>(,<SeqNo>),<Command>,<Parameter>(,<Sum>)<CR>
            string data = string.Empty;
            data = string.Format("{0:D1}{1:D2}{2}", Unit, ID, _imp.package(this._objs).Replace(",",""));

            string sum = Checksum(Encoding.ASCII.GetBytes(data));

            return data + sum;
        }

        private string ackn()
        {
            //$<UNo>(<SeqNo>)ACKN(<Sum>)<CR>
            string data = string.Empty;
            data = string.Format("{0:D1}{1:D2}ACKN", Unit, ID);

            string sum = Checksum(Encoding.ASCII.GetBytes(data));

            return data + sum;
        }
    }

    public class RobotMotionHandler : ITransferMsg
    {
        public bool background { get; protected set; }
        public bool evt { get { return false; } }

        public string deviceID { private get; set; }

        public string _cmd = string.Empty;

        public IDevice Robot { set { _device = (Robot)value; } }
        protected Robot _device;

        public RobotMotionHandler()
        {
            background = false;
        }

        public virtual string package(params object[] args)
        {
            return "";
        }

        public bool unpackage(string type, string[] items)
        {
            //! <UNo> (<SeqNo>) <StsN> <Errcd> MTRG <Sum> <CR>
            int value = Convert.ToInt32(items[3],16);
 
            _device.Status = value;
     
            int error = Convert.ToInt32(items[4], 16);
            _device.ErrorCode = error;
           if(error > 0)
                _device.LastErrorCode = error;
            

            if (type.Equals(ProtocolTag.resp_tag_excute))
            {
                //_device.ElapseTime = int.Parse(items[6]);

                //_device.Rotation = int.Parse(items[7]);
                //_device.Extension = int.Parse(items[8]);
                //_device.Wrist1= int.Parse(items[9]);
                //_device.Wrist2= int.Parse(items[10]);
                //_device.Evevation = int.Parse(items[11]);

                if (error == 0)
                {
                    update(items);    
                }

                return true;
            }

            return !background;
        }


        protected virtual void update(string[] data)
        { 
        
        }
    }



    public class RbInitHandler : RobotMotionHandler
    {
        public RbInitHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) INIT<IMode> <Sum> <CR>
            // IMode: Initialization mode(2 Byte)
            //• ”00”: Error clear, servo ON and all axes move to home position
            //• ”01”: Servo ON and all axes move to home position
            //• ”05”: Error clear, servo ON and arm moves to home position.
            //• ”06”: Servo ON and arm moves to home position
            //• ”10”: Error clear and servo ON
            updateBefore();
            return ",INIT,00,";
        }

        protected void updateBefore()
        {
            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }

        protected override void update(string[] data)
        {
            _device.Initalized = true;
            _device.Swap = false;
        }
    }


    public class RbHomeHandler : RobotMotionHandler
    {
        public RbHomeHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
                //$ < UNo > > (< SeqNo >) MHOM<MMode> < Sum > < CR >
                //• UNo: Unit number(1 byte)
                //• ‘1’ to ‘4’: Unit specified
                //• SeqNo: Sequence number(Non/ 1 / 2 / 3 byte)
                //• MMode: Motion mode(1 byte)
                //• ‘F’: All axes
                //• ‘A’: Arm(s) only
              updateBefore();
             return ",MHOM,F,";
        }

        protected void updateBefore()
        {
            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);

            _device.CmdBladeTarget = $"{_device.Name}.A";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";
        }

        protected override void update(string[] data)
        {
            _device.Initalized = true;
            _device.Swap = false;
        }
    }

    public class RbClearErrorHandler : RobotMotionHandler
    {
       
        public RbClearErrorHandler()
        {
            background = true;
        }
        //$ <UNo> (<SeqNo>) CCLR <CMode> <Sum> <CR>
        public override string package(params object[] args)
        {
            //• CMode: Clear mode(1 byte)
            //• ‘E’: Releases the error status.
            //• ‘H’: Clears the error history.
            return ",CCLR,E,";
        }
    }
    public class RbGripHandler : RobotMotionHandler
    {
        Hand _hand;
        public RbGripHandler()
        {
            background = true;
        }
        //Command wafer hold/release signal to the solenoid of the specified unit.
        //$ <UNo> (<SeqNo>) CSOL <Fork> <Sw> <Sum> <CR> 
        //• Fork: Fork specified(1 byte)
        //• ‘A’: Extension axis 1 (Blade 1), pre-aligner
        //• ‘B’: Extension axis 2 (Blade 2)
        //• Sw: Chucking command(1 byte)
        //• ‘0’: Chucking OFF
        //• ‘1’: Chucking ON
        public override string package(params object[] args)
        { 
            _hand = (Hand)args[0];
            bool bHold = (bool)args[1];
            if(bHold)
                return string.Format(",CSOL,{0},1,",RobotConvertor.hand2string(_hand));

            return string.Format(",CSOL,{0},0,", RobotConvertor.hand2string(_hand));
        }
    }

    public class RbStopHandler : RobotMotionHandler
    {
        public RbStopHandler()
        {
            background = true;
        }
        //$ <UNo> (<SeqNo>) CHLTs <Sum> <CR>
        //Pause (decelerate and stop) the motion of the specified unit during the drive command execution.

        public override string package(params object[] args)
        {
            bool isEmergency = (bool)args[0];
            if (isEmergency)
                return ",CEMG,";

            //$ < UNo > (< SeqNo >) CHLT<Sum> < CR >
            return ",CHLT,";
            //return ",MHOM,F,";
        }
    }

    public class RbResumeHandler : RobotMotionHandler
    {
        public RbResumeHandler()
        {
            background = true;
        }
        //$ <UNo> (<SeqNo>) CRSM <Sum> <CR> 
 
        public override string package(params object[] args)
        {
            return ",CRSM,";
        }
    }

    public class PickHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;
        public PickHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //Move To Ready position and wafer Get motion(MTRS+MGET)
            //$ <UNo> (<SeqNo>) MTRG <TrsSt> <SlotNo> <MtnMode> <Posture> <Sum> <CR>
            //            • TrsSt: Transfer station(2 bytes)
            //• "C1" to "C8": When cassette stage specified
            //• "S1" to "SC": When transfer stage specified
            //• "P1" to “P2”: When P/ A stage specified
            //Note: P2 station is effective only when two or more PA stations exist.
            //• SlotNo: Slot number(2 bytes)
            //< Manipulator >
            //• "01" to "XX": When cassette stage is specified by < TrsST >
            //(The maximum value of "XX" is in the ASCII code of the number of slots specified by parameter.)
            //• "00": When transfer stage or P / A stage specified by < TrsSt >
            //• MtnMode: Motion mode(2 bytes)
            //• "GA": Wafer Get motion at extension axis 1(Blade 1).
            //• "GB": Wafer Get motion at extension axis 2(Blade 2).
            //• "GW": Wafer Get motion with extension axis 1 and 2(Blade 1 and 2). < WGet motion >

           _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];

            updateBefore();

            if (_hand == Hand.Both)
            {
                return string.Format(",MTRG,{0},{1:D2},G{2},A,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1) ,
                RobotConvertor.hand2string(_hand));
            }
            return string.Format(",MTRG,{0},{1:D2},G{2},A,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.hand2string(_hand));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }

        protected override void update(string[] data)
        {
            if (_hand == Hand.Blade1)
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1);
            }
            else if (_hand == Hand.Blade2)
            {
                for (int i = 0; i < _device.Blade2Slots; i++)
                    WaferManager.Instance.WaferMoved(_chamber, _slot + i, ModuleHelper.Converter(_device.Name), (int)Hand.Blade2 + i);
            }
            else
            {
                for (int i = 0; i < _device.Blade2Slots + 1; i++)
                    WaferManager.Instance.WaferMoved(_chamber, _slot + i, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1 + i);
            }


            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }

    public class PickExtendHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;
        public PickExtendHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) MTPT <TrsSt> <SlotNo> <NextMtn> <Posture> <TrsPnt> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];

            updateBefore();

            return string.Format(",MTPT,{0},{1:D2},G{2},A,Gb,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
                RobotConvertor.hand2string(_hand));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }
    }

    public class PickRetractHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;
        public PickRetractHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            // $ <UNo> (<SeqNo>) MPNT <TrsPnt> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];

            updateBefore();

            return ",MPNT,G4,";
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }

        protected override void update(string[] data)
        {
            if (_hand == Hand.Both)
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1);
                WaferManager.Instance.WaferMoved(_chamber, _slot + 1, ModuleHelper.Converter(_device.Name), (int)Hand.Blade2);
            }
            else
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)_hand);
            }

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }


    public class PlaceHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;

        public PlaceHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            // $ <UNo> (<SeqNo>) MTRP <TrsSt> <SlotNo> <MtnMode> <Posture> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];
            updateBefore();

            if (_hand == Hand.Both)
            {
                return string.Format(",MTRP,{0},{1:D2},P{2},A,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
                RobotConvertor.hand2string(_hand));
            }


            return string.Format(",MTRP,{0},{1:D2},P{2},A,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.hand2string(_hand));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }


        protected override void update(string[] data)
        {
            if (_hand == Hand.Blade1)
            {
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1, _chamber, _slot);
            }
            else if (_hand == Hand.Blade2)
            {
                for (int i = 0; i < _device.Blade2Slots; i++)
                    WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade2 +i, _chamber, _slot + i);
            }
            else
            {
                for (int i = 0; i < _device.Blade2Slots + 1; i++)
                    WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1 + i, _chamber, _slot + i);
            }

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }

    public class PlaceExtendHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;

        public PlaceExtendHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) MTPT <TrsSt> <SlotNo> <NextMtn> <Posture> <TrsPnt> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];

            updateBefore();

            return string.Format(",MTPT,{0},{1:D2},G{2},A,Pb,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
                RobotConvertor.hand2string(_hand));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }
    }

    public class PlaceRetractHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;

        public PlaceRetractHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) MPNT <TrsPnt> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];
            updateBefore();
            return ",MPNT,P4,";
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }


        protected override void update(string[] data)
        {
            if (_hand == Hand.Both)
            {
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1, _chamber, _slot);
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade2, _chamber, _slot + 1);
            }
            else
            {
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)_hand, _chamber, _slot);
            }
            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }


    public class ExchangeHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;


        public ExchangeHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            // $ <UNo> (<SeqNo>) MTRE <TrsSt> <SlotNo> <MtnMode> <Posture> <Sum> <CR>
            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];
            if (_hand == Hand.Blade1)
                _hand = Hand.Blade2;
            else
                _hand = Hand.Blade1;

            updateBefore();

            return string.Format(",MTRE,{0},{1:D2},E{2},A,",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.hand2string(_hand));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;
            _device.Swap = true;
            _device.PlaceBalde = _hand;
        }

        protected override void update(string[] data)
        {
            if (_hand == Hand.Blade2)
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)Hand.Blade2);
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1, _chamber, _slot);
            }
            else
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1);
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade2, _chamber, _slot);
            }

            _device.Swap = false;
            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }

    public class GotoHandler : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Motion _next;
        private Hand _hand;
        public GotoHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //Move to ready position with specified adjustment offset
            //$<UNo>(<SeqNo>) MTRO <TrsSt> <SlotNo> <NextMtn> <Posture> <OffsetX> <OffsetY> <OffsetZ> <Sum>

            //• OffsetN: Offset(5 bytes each)
            //• OffsetX: X direction offset
            //• OffsetY: Y direction offset
            //• OffsetZ: Z direction offset
            //• Specified in the range between "-9999" and "99999"(Resolution: 0.01[mm])
            //• If value is less than 5 digits, fill the higher digit with ‘0’ so that the field always has 5 digits.

            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _next = (Motion)args[2];
            _hand = (Hand)args[3];

            int x = (int)args[4];
            int y = (int)args[5];
            int z = (int)args[6];

            updateBefore();
            return string.Format(",MTRO,{0},{1:D2},{2},A,{3},{4},{5}",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.NextMotion2String(_next, _hand),
                RobotConvertor.Offset2String(x),
                RobotConvertor.Offset2String(y),
                RobotConvertor.Offset2String(z)
                ); ;
        }

        private void updateBefore()
        {
            if(_hand == Hand.Blade1)
                _device.Blade1Target = _chamber;
            else if (_hand == Hand.Blade2)
                _device.Blade2Target = _chamber;
            else
            {
                _device.Blade1Target = _chamber;
                _device.Blade2Target = _chamber;
            }
        }
    }


    public class PickHandlerEx : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;
        public PickHandlerEx()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //Move to ready position and get wafer with adjustment offset(MTRO+MGET)
            //$ < UNo > (< SeqNo >) MTGO<TrsSt> < SlotNo > < NextMtn > < Posture > < OffsetX > < OffsetY > < OffsetZ > < Sum > < CR >
            //• UNo: Unit number(1 byte)
            //• ‘1’ to ‘4’: Unit specified
            //• SeqNo: Sequence number(Non/ 1 / 2 / 3 byte)
            //• TrsSt: Transfer station(2 bytes)
            //• "C1" to "C8": When cassette stage specified
            //• "S1" to "SC": When transfer stage specified
            //• "P1" to “P2”: When P/ A stage specified
            //Note: P2 station is effective only when two or more PA stations exist.
            //• SlotNo: Slot number(2 bytes)
            //• "01" to "XX": When cassette stage specified by<TrsST>
            //(The maximum value of "XX" is in the ASCII code of the number of slots specified by parameter.)
            //• "00": When transfer stage or P / A stage specified by < TrsSt >
            //• NextMtn: Next motion mode(2 bytes)
            //• "GA": Next motion is wafer Get motion with extension axis 1(Blade 1).
            //• "GB": Next motion is wafer Get motion with extension axis 2(Blade 2).
            //• "GW": Next motion is wafer Get motion with extension axis 1 and 2(Blade 1 and 2). < WGet motion >
            //Note 1.The motion of extension axis 2(or blade 2) is available only for a dual-arm manipulator and dual blade
            //linear motion manipulator.
            //2.The WGet motion is available for a dual-arm manipulator and dual blade linear motion manipulator.


            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];
            int x = (int)args[3];
            int y = (int)args[4];
            int z = (int)args[5];
            updateBefore();
            if (_hand == Hand.Both)
            {
                return string.Format(",MTGO,{0},{1:D2},G{2},A,{3},{4},{5}",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
                RobotConvertor.hand2string(_hand),
                RobotConvertor.Offset2String(x),
                RobotConvertor.Offset2String(y),
                RobotConvertor.Offset2String(z)
                );
            }

            return string.Format(",MTGO,{0},{1:D2},G{2},A,{3},{4},{5}",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.hand2string(_hand),
                RobotConvertor.Offset2String(x),
                RobotConvertor.Offset2String(y),
                RobotConvertor.Offset2String(z)
);
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }

        protected override void update(string[] data)
        {
            if (_hand == Hand.Blade1)
            {
                WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1);
            }
            else if (_hand == Hand.Blade2)
            {
                for (int i = 0; i < _device.Blade2Slots; i++)
                    WaferManager.Instance.WaferMoved(_chamber, _slot + i, ModuleHelper.Converter(_device.Name), (int)Hand.Blade2 + i);
            }
            else
            {
                for (int i = 0; i < _device.Blade2Slots + 1; i++)
                    WaferManager.Instance.WaferMoved(_chamber, _slot + i, ModuleHelper.Converter(_device.Name), (int)Hand.Blade1 + i);
            }


            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);
        }
    }


    public class PlaceHandlerEx : RobotMotionHandler
    {
        private ModuleName _chamber;
        private int _slot;
        private Hand _hand;

        public PlaceHandlerEx()
        {
            background = true;
        }

        public override string package(params object[] args)
        {

            _chamber = (ModuleName)args[0];
            _slot = (int)args[1];
            _hand = (Hand)args[2];
            int x = (int)args[3];
            int y = (int)args[4];
            int z = (int)args[5];
            updateBefore();
            if (_hand == Hand.Both)
            {
                return string.Format(",MTPO,{0},{1:D2},P{2},A,{3},{4},{5}",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
                RobotConvertor.hand2string(_hand),
                RobotConvertor.Offset2String(x),
                RobotConvertor.Offset2String(y),
                RobotConvertor.Offset2String(z)
                );
            }

            return string.Format(",MTPO,{0},{1:D2},P{2},A,{3},{4},{5}",
                RobotConvertor.chamber2staion(_chamber),
                RobotConvertor.chamberSlot2Slot(_chamber, _slot),
                RobotConvertor.hand2string(_hand),
                RobotConvertor.Offset2String(x),
                RobotConvertor.Offset2String(y),
                RobotConvertor.Offset2String(z)
);
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = _hand == Hand.Blade1 ? "1" : "0";
            _device.CmdBlade2Extend = _hand == Hand.Blade1 ? "0" : "1";
        }


        protected override void update(string[] data)
        {
            if (_hand == Hand.Blade1)
            {
                WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1, _chamber, _slot);
            }
            else if (_hand == Hand.Blade2)
            {
                for (int i = 0; i < _device.Blade2Slots; i++)
                    WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade2 + i, _chamber, _slot + i);
            }
            else
            {
                for (int i = 0; i < _device.Blade2Slots + 1; i++)
                    WaferManager.Instance.WaferMoved(ModuleHelper.Converter(_device.Name), (int)Hand.Blade1 + i, _chamber, _slot + i);
            }

            _device.Blade1Target = ModuleHelper.Converter(_device.Name);
            _device.Blade2Target = ModuleHelper.Converter(_device.Name);

            string arm = _hand == Hand.Blade1 ? "A" : "B";
            _device.CmdBladeTarget = $"{_chamber}.{arm}";
            _device.CmdBlade1Extend = "0";
            _device.CmdBlade2Extend = "0";
        }
    }

    //NOT SUPPORT with OFFSET
    //public class ExchangeHandlerEx : RobotMotionHandler
    //{
    //    private ModuleName _chamber;
    //    private int _slot;
    //    private Hand _hand;


    //    public ExchangeHandlerEx()
    //    {
    //        background = true;
    //    }

    //    public override string package(params object[] args)
    //    {
    //        // $ <UNo> (<SeqNo>) MEXG <Sum> <CR>
    //        _chamber = (ModuleName)args[0];
    //        _slot = (int)args[1];
    //        _hand = (Hand)args[2];
    //        if (_hand == Hand.Blade1)
    //            _hand = Hand.Blade2;
    //        else
    //            _hand = Hand.Blade1;

    //        updateBefore();

    //        int x = (int)args[3];
    //        int y = (int)args[4];
    //        int z = (int)args[5];
    //        updateBefore();
    //        if (_hand == Hand.Both)
    //        {
    //            return string.Format(",MTPO,{0},{1:D2},G{2},A,{3},{4},{5}",
    //            RobotConvertor.chamber2staion(_chamber),
    //            RobotConvertor.chamberSlot2Slot(_chamber, _slot + 1),
    //            RobotConvertor.hand2string(_hand),
    //            RobotConvertor.Offset2String(x),
    //            RobotConvertor.Offset2String(y),
    //            RobotConvertor.Offset2String(z)
    //            );
    //        }

    //        return string.Format(",MTPO,{0},{1:D2},G{2},A,{3},{4},{5}",
    //            RobotConvertor.chamber2staion(_chamber),
    //            RobotConvertor.chamberSlot2Slot(_chamber, _slot),
    //            RobotConvertor.hand2string(_hand),
    //            RobotConvertor.Offset2String(x),
    //            RobotConvertor.Offset2String(y),
    //            RobotConvertor.Offset2String(z));

    //    }

    //    private void updateBefore()
    //    {
    //        _device.Blade1Target = _chamber;
    //        _device.Blade2Target = _chamber;
    //        _device.Swap = true;
    //        _device.PlaceBalde = _hand;
    //    }

    //    protected override void update(string[] data)
    //    {
    //        if (_hand == Hand.Blade2)
    //        {
    //            WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleName.Robot, (int)Hand.Blade2);
    //            WaferManager.Instance.WaferMoved(ModuleName.Robot, (int)Hand.Blade1, _chamber, _slot);
    //        }
    //        else
    //        {
    //            WaferManager.Instance.WaferMoved(_chamber, _slot, ModuleName.Robot, (int)Hand.Blade1);
    //            WaferManager.Instance.WaferMoved(ModuleName.Robot, (int)Hand.Blade2, _chamber, _slot);
    //        }

    //        _device.Swap = false;
    //        _device.Blade1Target = ModuleName.Robot;
    //        _device.Blade2Target = ModuleName.Robot;
    //    }
    //}

    public class RBWaferMappingHandler : RobotMotionHandler
    {
        private ModuleName _chamber;

        public RBWaferMappingHandler()
        {
            background = true;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) MMAP <TrsSt> <SlotNo> <Sum> <CR>
            // SlotNo: Slot number(2 bytes)
            //• "FF": When all slots specified
            //• ”01” to ”XX”: When cassette stage is specified by < TrsSt >
            //(The maximum value of "XX" is in ASCII code of the number of slots specified by parameter.)
            //• ”00”: When transfer stage or P / A stage specified by<TrsSt>
            //  Note: Specific slot section definition cannot be performed.
            //• Reception rejected: Responds with the error code.
            _chamber = (ModuleName)args[0];
            //_slot = (int)args[1];
            //_hand = (Hand)args[2];

            updateBefore();
            return string.Format(",MMAP,{0},FF,",
                RobotConvertor.chamber2staion(_chamber));
        }

        private void updateBefore()
        {
            _device.Blade1Target = _chamber;
            _device.Blade2Target = _chamber;
        }
    }

    public class RBQueryWaferMapHandler : ITransferMsg
    {
        public bool background { get; protected set; }
        public bool evt { get { return false; } }
        public string deviceID { private get; set; }

        public string _cmd = string.Empty;
        private ModuleName _chamber;
        public IDevice Robot { set { _device = (Robot)value; } }
        protected Robot _device;

        public RBQueryWaferMapHandler()
        {
            background = false;
        }

        //$ <UNo> (<SeqNo>) RMAP <TrsSt> <SlotNo> <Sum> <CR>
        public string package(params object[] args)
        {
            _chamber = (ModuleName)args[0];

            return string.Format(",RMAP,{0},FF,",
                           RobotConvertor.chamber2staion(_chamber));
        }

        public bool unpackage(string type, string[] items)
        {
            //$,<UNo>(,<SeqNo>),<Sts>,<Ackcd>,RMAP,<TrsSt>,<Slot>,
            //01:<Result1>…,N:<ResultN>(,<Sum>)<CR>
            //• UNo : Unit number (1 byte)
            //• SeqNo : Sequence number (None / 2 bytes)
            //• Sts : Status (2 bytes)
            //• Ackcd : Response code (4 bytes)
            //• TrsSt : Transfer station (3 bytes)
            //• Slot : Slot number (2 bytes)
            //• Result* : Mapping result (2 bytes each)
            //• “--” : No wafer detected.
            //• “OK” : Wafer inserted correctly.
            //• “CW” : Wafer inserted incorrectly (inclined).
            //• “DW” : Wafer inserted incorrectly (duplicated).
            //Note) Responds with the number of slots of the specified transfer station.
            //$,1,00,0000,RMAP,C02,00,
            //01:OK,02:DW,03:OK,04:CW,05:CW,06:OK,07:OK,08:--,09:OK,10:OK    
            // No wafer: "0", Wafer: "1", Crossed:"2", Undefined: "?", Overlapping wafers: "W" 
            if (items.Length > 5)
            {
                string data = items[5];
                StringBuilder sb = new StringBuilder();

           
                for (int i = 0; i < data.Length; i += 4)
                {
                    string value = data.Substring(i + 2, 2);
                    switch (value)
                    {
                        case "--":
                            sb.Append("0");
                            break;
                        case "OK":
                            sb.Append("1");
                            break;
                        case "CW":
                            sb.Append("2");
                            break;
                        case "DW":
                            sb.Append("W");
                            break;
                    }
                }

                _device.NotifySlotMapResult(_chamber, sb.ToString());
                return true;
            }

            return !background;
        }
    }


    //    Transfer speed level setting
    public class RbSetSpeedHandler : RobotMotionHandler
    {
        private int _speed = 0;
        public RbSetSpeedHandler()
        {
            background = false;
        }

        public override string package(params object[] args)
        {
            _speed = (int)args[0];
            //$ < UNo > (< SeqNo >) SSLV<Level> < Sum > < CR >
            ///
            ///            • ’H’ : High speed level
             //• ’M’ : Medium speed level
                //• ’L’ : Low speed level
                ///
                if(_speed == 1)
                    return string.Format(",SSLV,H,");
                else if (_speed == 2)
                    return string.Format(",SSLV,M,");

                return string.Format(",SSLV,L,");
        }
    }

    //    Transfer speed level setting
    public class RbSetOffsetHandler : RobotMotionHandler
    {
        public RbSetOffsetHandler()
        {
            background = false;
        }

        public override string package(params object[] args)
        {
            //$ <UNo> (<SeqNo>) SOFS <Mem> <TrsSt> <Offset1> <Offset2> … <Offset5> <Sum> <CR>
            ///Mem: Memory (1 byte) ‘V’: Volatile memory ‘N’: Non -volatile memory
            //• TrsSt: Transfer station(2 bytes)
            //• "C1" to "C8": When cassette stage specified
            //• "S1" to "SC": When transfer stage specified
            //• "P1" to “P2”: When P/ A stage specified
            //Note: P2 station is effective only when two or more PA stations exist.
            //• Offset: Transfer offset(4 bytes each)
            //• Offset1: Downward offset
            //• Offset2: Upward offset
            //• Offset3: Offset in the extending direction(with the edge - grip - type fork)
            //• Offset4: Offset in the retracting direction(with the edge - grip - type fork)
            //• Offset5: Put downward offset(with the edge - grip - type fork)
            //Note: Offset3 to Offset5 are omitted when the fork type is not the edge - grip type.
            //• About Offset3 to Offset5, it is omissible with a parameter setup.
            //• Specified in the range between "-999" and "9999"(resolution: 0.01[mm])
            //• If a value is less than specified digits, fill the higher digit with ‘0’ so that the field always has specfied digits.
            ModuleName _chamber = (ModuleName)args[0];
            int down = (int)args[1];
            int up = (int)args[2];
            int extend = (int)args[2];
            int retract = (int)args[2];
            int pdown = (int)args[2];

            return string.Format(",SOFS,V，{0},{1:D4},{2:D4},{3:D4},{4:D4},",
                RobotConvertor.chamber2staion(_chamber),
                down,
                up,
                extend,
                retract,
                pdown
               );
        }
    }

    public class RBQueryStateHandler : ITransferMsg
    {
        public bool background { get; protected set; }
        public bool evt { get { return false; } }
        public string deviceID { private get; set; }

        public string _cmd = string.Empty;

        public IDevice Robot { set { _device = (Robot)value; } }
        protected Robot _device;
        public RBQueryStateHandler()
        {
            background = false;
        }

        //$ <UNo> (<SeqNo>) <StsN> <Ackcd> <Sum> <CR>
        //$ <UNo> (<SeqNo>) <StsN> <Ackcd> <Errcd> <Status1> … <Status4> <Sum> <CR>

        public string package(params object[] args)
        {
            return ",RSTS,";
        }

        public bool unpackage(string type, string[] items)
        {

            return !background;
        }
    }

    public class RbEventHandler : ITransferMsg
    {
        public bool background { get { return false; } }
        public bool evt { get { return true; } }
        public string deviceID { private get; set; }

        public string _cmd = string.Empty;

        public IDevice Robot { set { _device = (Robot)value; } }
        protected Robot _device;
        public RbEventHandler()
        {

        }

        //$,<UNo>(,<SeqNo>),RSTS(,<Sum>)<CR> 

        public string package(params object[] args)
        {
            return "";
        }

        public bool unpackage(string type, string[] items)
        {
            string evtType = items[3];
            if (evtType.Equals(ProtocolTag.resp_evt_error))
            {
                int error = Convert.ToInt32(items[5], 16);
                _device.ErrorCode = error;
                if (error > 0)
                    _device.LastErrorCode = error;
                return true;
            }
            return false;
        }
    }

    public class RBQueryPositionHandler : ITransferMsg
    {
        public bool background { get; protected set; }
        public bool evt { get { return false; } }
        public string deviceID { private get; set; }

        public string _cmd = string.Empty;

        public IDevice Robot { set { _device = (Robot)value; } }
        protected Robot _device;

        public RBQueryPositionHandler()
        {
            background = false;

        }

        //$ <UNo> (<SeqNo>) RPOS <TrsSt> <Fork> <Posture> <Sum> <CR>
        //     • TrsSt: Transfer station(2 bytes)
        //• "C1" to "C8": When the lowest-layer position of the cassette stage specified
        //• "H1" to "H8": When the highest-layer position of the cassette stage specified
        //• "S1" to "SC": When transfer stage specified
        //• "P1" to “P2”: When P/A stage specified
        //Note: P2 station is effective only when two or more PA stations exist.
        //• "FF": When current position specified
        //• "FE": When specify the feedback of present location
        //<Three-axis pre-aligner, Edge-grip pre-aligner>
        //• "FF": When current position specified
        //• "FE": When specify the feedback of present location
        //• Fork: Fork specified(1 byte)
        //• ‘A’: When extension axis 1 (Blade 1) specified
        //• ‘B’: When extension axis 2 (Blade 2) specified(for dual-arm manipulator and dual blade linear motion
        //manipulator only)
        //Note: Fixed to ‘A’ when the current position and feedback of present location are specified at<TrsSt>
        public string package(params object[] args)
        {
            return ",RPOS,FF,A,A,";
        }

        public bool unpackage(string type, string[] items)
        {
            //$ <UNo> (<SeqNo>) <StsN> <Ackcd> <Value1> … <ValueN> <Sum> <CR>
            //            • ValueN: Coordinate(8 bytes each)
            //• Specified in the range as follows (The resolution is 0.01[mm] or[deg])
            //8 Byte: between "-9999999" ~"99999999"
            //• If a value is less than specified digits, fill the higher digit with ‘0’ so that the field always has specfied digits.
            //• The sign is added to the highest digit.
            //• The number of “ValueN” depends on the unit type.
            //Responds with as many axis numbers as the specified unit has.See the table bellow.
            //Unit Value1 Value2 Value3 Value4 Value5 Value6
            //Single - arm manipulator Rotation    //Elevation           //(Track            
            //Dual - arm manipulator Rotation      //Extension            //axis 1   //axis 2   //(Track
         
            if (items.Length > 7)
            {  
                _device.Rotation = int.Parse(items[7]);
                _device.Extension = int.Parse(items[8]);
                _device.Wrist1 = int.Parse(items[9]);
                _device.Wrist2 = int.Parse(items[10]);
                _device.Evevation = int.Parse(items[11]);
                
                return true;
            }

            return !background;
        }
    }
}