OHV/Dev/OHV/VehicleControlSystem/ControlLayer/Vehicle.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Threading;
using System.Threading.Tasks;
using FluentResults;
using GSG.NET.Concurrent;
using GSG.NET.Extensions;
using GSG.NET.LINQ;
using GSG.NET.Logging;
using GSG.NET.Quartz;
using GSG.NET.Utils;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Events;
using VehicleControlSystem.ControlLayer.Actuator.Cylinder;
using VehicleControlSystem.ControlLayer.Drive;
using VehicleControlSystem.ControlLayer.IO;
using VehicleControlSystem.ControlLayer.MQ;
using VehicleControlSystem.ControlLayer.Serial.BatteryTabos;
using VehicleControlSystem.ControlLayer.Serial.DataModel;
using VehicleControlSystem.Managers;
using static VehicleControlSystem.ControlLayer.Drive.GSIDrive;

namespace VehicleControlSystem.ControlLayer
{
    public class VehicleRefObjects
    {
        public GSIDrive Drive { get; set; }
        public Clamp Clamp { get; set; }
        public Conveyor Conveyor { get; set; }
        public EzIO IO { get; set; }
        public Steering Steering { get; set; }
        public BMUManager BMUManager { get; set; }
        public ZmqManager ZmqManager { get; set; }
        public List<Alarm> Alarms { get; set; }
        public HostManager HostManager { get; set; }
        public SqliteManager Sqlite { get; set; }
        public AutoManager AutoManager { get; set; }
    }

    /// <summary>
    /// Control Layer 의 자원을 여기서 사용하자.
    /// </summary>
    public class Vehicle : ControlObjectBase, IDisposable
    {
        /// <summary>
        /// OCS Report Code
        /// 목적지에 도착해서 Load, Unload 시 발생하는 Alarm
        /// </summary>
        public enum eFailCode
        {
            Load_PortHasNotCarrier = 1,
            Load_VehicleHasCarrier,
            Unload_PortHasCarrier,
            Unload_VehicleHasNotCarrier,
            LoadPIOInterlockTimeout,
            UnlaodPIOInterlockTimeout,
        }

        static Logger logger = Logger.GetLogger();
        static Logger loggerPIO = Logger.GetLogger("PIO");

        #region Properties
        /// <summary>
        /// Tag 위치
        /// </summary>
        private int currentTag = 0;
        public int CurrentTag
        {
            get { return currentTag; }
            set
            {
                if (SetField(ref this.currentTag, value))
                {
                    //var info = this.refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
                    //info.CurrentTag = value.ToString();
                    //this.refObjects.Sqlite.VehicleInfoDAL.Update( info );

                    this.OnCurrentTagChanged?.Invoke(value);
                }
            }
        }

        /// <summary>
        /// Scale Value
        /// </summary>
        private double currentPosition;
        public double CurrentPosition
        {
            get { return currentPosition; }
            set
            {
                if (SetField(ref this.currentPosition, value))
                {
                }
            }
        }

        private double currentSpeed;
        public double CurrentSpeed
        {
            get { return currentSpeed; }
            set { SetField(ref this.currentSpeed, value); }
        }

        private double currentTorque;
        public double CurrentTorque
        {
            get { return currentTorque; }
            set { SetField(ref this.currentTorque, value); }
        }

        private bool isContain;
        public bool IsContain
        {
            get { return isContain; }
            set { SetField(ref this.isContain, value); }
        }

        eClampState _clampState;
        public eClampState ClampState
        {
            get { return this._clampState; }
            set { this.SetField(ref this._clampState, value); }
        }

        private eSteeringState steeringState;
        public eSteeringState SteeringState
        {
            get { return steeringState; }
            set
            {
                if (SetField(ref this.steeringState, value))
                {
                    this.refObjects.ZmqManager.SetCurrentSteeringState(value);
                }
            }
        }

        private int _obstacleDrive;
        public int ObstacleDrive { get { return this._obstacleDrive; } set { SetField(ref this._obstacleDrive, value); } }
        private int _obstacleCurve;
        public int ObstacleCurve { get { return this._obstacleCurve; } set { SetField(ref this._obstacleCurve, value); } }
        private int obstacleCurrent;
        public int ObstacleCurrent { get { return this.ObstacleCurrent; } set { SetField(ref this.obstacleCurrent, value); } }

        private eObstacleState obstacleState = eObstacleState.Normal;
        public eObstacleState ObstacleStateProperty
        {
            get { return obstacleState; }
            set
            {
                if (SetField(ref this.obstacleState, value))
                {
                    if (value == eObstacleState.Blocked)
                        this.VehicleStateProperty = eVehicleState.Blocked;
                }
            }
        }

        private eVehicleState vehicleState = eVehicleState.None;
        public eVehicleState VehicleStateProperty
        {
            get { return vehicleState; }
            set
            {
                if (SetField(ref this.vehicleState, value))
                {
                    var info = this.refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
                    info.VehicleState = value;
                    //this.refObjects.Sqlite.VehicleInfoDAL.Update( info );
                }
            }
        }

        private eMachineMode machineMode = eMachineMode.LocalMode;
        public eMachineMode MachineMode
        {
            get { return machineMode; }
            set
            {
                if (SetField(ref this.machineMode, value))
                {
                    var info = this.refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
                    info.MachineMode = value;
                    //this.refObjects.Sqlite.VehicleInfoDAL.Update( info );
                }
            }
        }

        private eVehicleOnRailState vehicleOnRailState = eVehicleOnRailState.None;
        public eVehicleOnRailState VehicleOnRailState
        {
            get => this.vehicleOnRailState;
            set
            {
                if (SetField(ref this.vehicleOnRailState, value))
                {
                    var info = refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
                    info.VehicleOnRailState = value;
                    refObjects.Sqlite.VehicleInfoDAL.Update(info);

                    if (value == eVehicleOnRailState.Install)
                        refObjects.HostManager.Send_Inline();
                    else
                        refObjects.HostManager.Send_Outline();
                }
            }
        }

        private int obstaclePattern;
        public int ObstaclePattern
        {
            get { return obstaclePattern; }
            set { SetField(ref this.obstaclePattern, value); }
        }

        private DriveState frontDriveState;
        public DriveState FrontDriveState
        {
            get { return frontDriveState; }
            set { SetField(ref this.frontDriveState, value); }
        }

        private DriveState rearDriveState;
        public DriveState RearDriveState
        {
            get { return rearDriveState; }
            set { SetField(ref this.rearDriveState, value); }
        }

        private eVehicleAutoReadyState autoReadyState;

        public eVehicleAutoReadyState AutoReadyState
        {
            get { return autoReadyState; }
            set { SetField(ref this.autoReadyState, value); }
        }


        //이동
        public bool Busy
        {
            get
            {
                return this.CurrentSubCommand == null ? false : true;
            }
            set { }
        }

        public bool IsMoving { get => this.refObjects.Drive.IsDriveMoving(); }

        private bool batteryChargeState;

        public bool BatteryChargeState
        {
            get { return batteryChargeState; }
            set
            {
                if (SetField(ref batteryChargeState, value))
                {
                    if (value)
                    {
                        this.OnChargingStart?.Invoke();
                        LockUtils.Wait(1000);
                        this.OnCharging?.Invoke();

                        //QuartzUtils.Invoke("BatterLogger", QuartzUtils.GetExpnMinute(1), () => { batteryLogger.I($"SOC - {this.BatteryStateOfCharge} / Current - {this.BatteryCurrent} / Voltage - {this.BatteryVoltage} / Capacity - {this.BatteryCapacity} / Energy - {this.BatteryEnergy}"); });
                    }
                    else
                    {
                        //QuartzUtils.StopSchedule("BatterLogger");
                        this.OnChargingFull?.Invoke();
                    }
                }
            }
        }

        #region Battery Property

        double batteryVoltage;
        public double BatteryVoltage
        {
            get { return this.batteryVoltage; }
            set
            {
                //var d = Math.Truncate( value * 10 ) / 10;
                //this.SetField( ref this.batteryVoltage, d );
                this.SetField(ref this.batteryVoltage, value);
            }
        }

        double batteryCurrent;
        public double BatteryCurrent
        {
            get { return this.batteryCurrent; }
            set { this.SetField(ref this.batteryCurrent, value); }
        }

        double batteryState;
        public double BatteryState
        {
            get { return this.batteryState; }
            set { this.SetField(ref this.batteryState, value); }
        }

        double batteryChargeTime;
        public double BatteryChargeTime
        {
            get { return this.batteryChargeTime; }
            set { this.SetField(ref this.batteryChargeTime, value); }
        }

        double batteryDisChargeTime;
        public double BatteryDisChargeTime
        {
            get { return this.batteryDisChargeTime; }
            set { this.SetField(ref this.batteryDisChargeTime, value); }
        }

        double batteryStateOfCharge;
        public double BatteryStateOfCharge
        {
            get { return this.batteryStateOfCharge; }
            set { if (this.SetField(ref this.batteryStateOfCharge, value)) { this.BatteryChargeStateLED(value); } }
        }

        double batteryStateOfHealth;
        public double BatteryStateOfHealth
        {
            get { return this.batteryStateOfHealth; }
            set
            {
                if (this.SetField(ref this.batteryStateOfHealth, value)) { }
            }
        }

        double batteryCapacity;
        public double BatteryCapacity
        {
            get { return this.batteryCapacity; }
            set { this.SetField(ref this.batteryCapacity, value); }
        }

        double batteryEnergy;
        public double BatteryEnergy
        {
            get { return this.batteryEnergy; }
            set
            {
                var d = Math.Truncate(value * 10) / 10;
                this.SetField(ref this.batteryEnergy, d);
            }
        }

        double batteryTemperature;
        public double BatteryTemperature
        {
            get { return this.batteryTemperature; }
            set { this.SetField(ref this.batteryTemperature, value); }
        }

        bool batteryIsConnect;
        public bool BatteryIsConnect
        {
            get
            {
                return batteryIsConnect;
            }
            set { this.SetField(ref this.batteryIsConnect, value); }
        }
        #endregion

        public bool IsError
        {
            get
            {
                if (refObjects.AutoManager.ActiveAlarms.Count > 0)
                    return true;
                else
                    return false;
            }
        }

        public SubCmd CurrentSubCommand { get; private set; }

        double frontLoadFactor = 0;
        public double FrontLoadFactor
        {
            get { return this.frontLoadFactor; }
            set { SetField(ref this.frontLoadFactor, value); }
        }

        double frontRpm = 0;
        public double FrontRpm
        {
            get { return this.frontRpm; }
            set { SetField(ref this.frontRpm, value); }
        }

        double frontSpeed = 0;
        public double FrontSpeed
        {
            get { return this.frontSpeed; }
            set { SetField(ref this.frontSpeed, value); }
        }

        double frontTorque = 0;
        public double FrontTorque
        {
            get { return this.frontTorque; }
            set { SetField(ref this.frontTorque, value); }
        }

        double rearLoadFactor = 0;
        public double RearLoadFactor
        {
            get { return this.rearLoadFactor; }
            set { SetField(ref this.rearLoadFactor, value); }
        }

        double rearRpm = 0;
        public double RearRpm
        {
            get { return this.rearRpm; }
            set { SetField(ref this.rearRpm, value); }
        }

        double rearSpeed = 0;
        public double RearSpeed
        {
            get { return this.rearSpeed; }
            set { SetField(ref this.rearSpeed, value); }
        }

        double rearTorque = 0;
        public double RearTorque
        {
            get { return this.rearTorque; }
            set { SetField(ref this.rearTorque, value); }
        }

        private double linearSpeed;

        public double LinearSpeed
        {
            get { return linearSpeed; }
            set { SetField(ref this.linearSpeed, value); }
        }

        private double curveSpeed;

        public double CurveSpeed
        {
            get { return curveSpeed; }
            set { SetField(ref this.curveSpeed, value); }
        }

        private double accelSpeed;

        public double AccelSpeed
        {
            get { return accelSpeed; }
            set { SetField(ref this.accelSpeed, value); }
        }

        private double decelSpeed;

        public double DecelSpeed
        {
            get { return decelSpeed; }
            set { SetField(ref this.decelSpeed, value); }
        }

        private double creepSpeed;

        public double CreepSpeed
        {
            get { return creepSpeed; }
            set { SetField(ref this.creepSpeed, value); }
        }

        private double creepDistance;

        public double CreepDistance
        {
            get { return creepDistance; }
            set { SetField(ref this.creepDistance, value); }
        }

        private double jogSpeed;

        public double JogSPeed
        {
            get { return jogSpeed; }
            set { SetField(ref this.jogSpeed, value); }
        }

        private bool isCanStanbyLocation;

        public bool IsCanStanbyLocation
        {
            get { return isCanStanbyLocation; }
            set { this.SetField(ref this.isCanStanbyLocation, value); }
        }

        public bool IsAutoRun { get; internal set; } = false;

        #endregion

        #region Event 
        public event Action OnMoveReady;
        public event Action OnMoving;
        public event Action OnMoveFinish;

        public event Action OnChargingStart;
        public event Action OnCharging;
        public event Action OnChargingFull;
        //public event Action<double> OnBatteryVelueChanged;

        public event Action<bool> OnPIOStart;
        public event Action<bool> OnConveyorStart;
        public event Action<bool> OnConveyorStop;
        public event Action<bool> OnCarrierDetected;
        public event Action OnLoadComplete;
        public event Action OnUnloadComplete;

        public event Action<int> OnCurrentTagChanged;

        public event Action<eFailCode> OnFailReport;
        #endregion

        #region List.
        List<ICylinder> cylinders = new List<ICylinder>();

        List<string> obstacleBitList = new List<string>();
        #endregion

        VehicleRefObjects refObjects = null;

        //SqliteManager sql = null;
        //AutoManager autoManager = null;

        ThreadCancel cancel = new ThreadCancel();
        TaskCancel taskCancel = new TaskCancel();
        TaskCancel taskMoveCancel = new TaskCancel();

        IEventAggregator eventAggregator;

        public Vehicle(IEventAggregator ea)
        {
            this.obstacleBitList.AddRange(new string[]
            {
                "OUT_OBSTRUCTION_PATTERN_00",
                "OUT_OBSTRUCTION_PATTERN_01",
                "OUT_OBSTRUCTION_PATTERN_02",
                "OUT_OBSTRUCTION_PATTERN_03",
                "OUT_OBSTRUCTION_PATTERN_04",
            });

            this.eventAggregator = ea;

            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Unsubscribe(ReceiveDriveControlEvent);
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Subscribe(ReceiveDriveControlEvent);

            this.eventAggregator.GetEvent<ObstacleControlPubSubEvent>().Unsubscribe(ObstacleReceiveEvent);
            this.eventAggregator.GetEvent<ObstacleControlPubSubEvent>().Subscribe(ObstacleReceiveEvent);
        }

        public void DependencyInjection(VehicleRefObjects vehicleRefObjects)
        {
            this.refObjects = vehicleRefObjects;

            this.refObjects.IO.OnChangedIO += IO_OnChangedIO;

            this.refObjects.BMUManager.OnConnect += BMUManager_OnConnect;
            this.refObjects.BMUManager.OnDisconnect += BMUManager_OnDisconnect;
            this.refObjects.BMUManager.OnChangedReceivedData += BMUManager_OnChangedReceivedData;
            this.refObjects.BMUManager.OnFirstColtd += BMUManager_OnFirstColtd;

            this.refObjects.Drive.PropertyChanged += Motion_PropertyChanged;

            this.refObjects.Clamp.PropertyChanged += Clamp_PropertyChanged;

            this.refObjects.Steering.OnSteeringError += Steering_OnSteeringError;
            this.refObjects.Steering.PropertyChanged += Steering_PropertyChanged;

            this.refObjects.ZmqManager.PropertyChanged += ZmqManager_PropertyChanged;
            this.refObjects.ZmqManager.OnDriveAlarmBitArrayChg += ZmqManager_OnDriveAlarmBitArrayChg;

            this.refObjects.AutoManager.OnOperationModeChanged += AutoManager_OnOperationModeChanged;
        }

        private void ZmqManager_OnDriveAlarmBitArrayChg(BitArray obj)
        {
            for (int i = 0; i < obj.Count; i++)
            {
                if (obj[i])
                    this.OccurVehicleAlarm(i + 1000);
                else
                    this.refObjects.AutoManager.ClearAlarm(i + 1000);
            }

            if ( this.refObjects.AutoManager.ActiveAlarms.Count <= 0)
                this.VehicleStateProperty = eVehicleState.Idle;
        }

        private void ObstacleReceiveEvent(ObstacleControlEventArgs obj)
        {
            if (this.refObjects.AutoManager.OperationModeProperty != eOperatationMode.ManualMode)
                return;

            if (obj.EventDir == ObstacleControlEventArgs.eEventDir.ToBack)
            {
                switch (obj.ControlKind)
                {
                    case ObstacleControlEventArgs.eControlKind.NONE:
                        break;
                    case ObstacleControlEventArgs.eControlKind.DRIVE:
                        //this.ChgObstacleDetectPattern( new Random().Next( 0 , 40 ) );
                        break;
                    case ObstacleControlEventArgs.eControlKind.CURVE:
                        //this.ChgObstacleDetectPattern( new Random().Next( 0 , 40 ) );
                        break;
                    case ObstacleControlEventArgs.eControlKind.STATE:
                        //var value = this.GetObstacleDetectPattern();
                        break;
                    case ObstacleControlEventArgs.eControlKind.INFO:
                        {
                            var msg = new ObstacleControlEventArgs
                            {
                                ControlKind = ObstacleControlEventArgs.eControlKind.INFO,
                                Drive = this.ObstacleDrive,
                                Curve = this.ObstacleCurve,
                                Current = this.GetObstacleDetectPattern(),
                                ObstacleState = this.ObstacleStateProperty.ToString()
                            };
                            this.ObstacleControlEventPublish(msg);
                        }
                        break;
                    case ObstacleControlEventArgs.eControlKind.SAVE:
                        {
                            this.ObstacleCurve = obj.Curve;
                            this.ObstacleDrive = obj.Drive;

                            var reply = new ObstacleControlEventArgs
                            {
                                ControlKind = ObstacleControlEventArgs.eControlKind.SAVE
                            };
                            reply.Result = Results.Ok(ObstacleControlEventArgs.eControlKind.SAVE);
                            this.ObstacleControlEventPublish(reply);
                        }
                        break;
                }
            }
        }

        private void ObstacleControlEventPublish(ObstacleControlEventArgs args)
        {
            args.EventDir = ObstacleControlEventArgs.eEventDir.ToFront;
            this.eventAggregator.GetEvent<ObstacleControlPubSubEvent>().Publish(args);
        }

        private void ReceiveDriveControlEvent(DriveControlEventArgs args)
        {
            var msg = args;
            if (msg.EventDir == DriveControlEventArgs.eEventDir.ToBack)
            {
                switch (msg.ControlKind)
                {
                    case DriveControlEventArgs.eControlKind.MOVE:
                        this.ReqMoveToPos(args);
                        break;

                    case DriveControlEventArgs.eControlKind.STOP:
                        break;

                    case DriveControlEventArgs.eControlKind.Steering:
                        if ( msg.MoveDir == DriveControlEventArgs.eMoveDir.LEFT )
                            this.refObjects.Steering.RequestControl( eSteeringState.Left );
                        else
                            this.refObjects.Steering.RequestControl( eSteeringState.Right );
                        break;

                    case DriveControlEventArgs.eControlKind.SteeringState:
                        {
                            var reply = new DriveControlEventArgs();
                            reply.ControlKind = DriveControlEventArgs.eControlKind.SteeringState;
                            if (this.refObjects.Steering.IsLeft())
                            {
                                reply.Args = eSteeringState.Left;
                                reply.Result = FluentResults.Results.Ok();
                            }
                            else if (this.refObjects.Steering.IsRight())
                            {
                                reply.Args = eSteeringState.Right;
                                reply.Result = FluentResults.Results.Ok();
                            }
                            else
                                reply.Result = FluentResults.Results.Fail(new Error());

                            this.DriveControlEventPublish(reply);
                        }
                        break;

                    case DriveControlEventArgs.eControlKind.ReqCurrentPos:
                        //this.ReqCurrentPos();
                        break;

                    case DriveControlEventArgs.eControlKind.ReqStopCurrentPos:
                        //this.taskCancel.Cancel();
                        //this.taskCancel.WaitAll();
                        break;

                    case DriveControlEventArgs.eControlKind.FaultReset:
                        this.ReqFaultReset(args);
                        break;

                    case DriveControlEventArgs.eControlKind.DriveON:
                        this.ReqDriveOn(args);
                        break;

                    case DriveControlEventArgs.eControlKind.DriveOFF:
                        this.ReqDriveOff(args);
                        break;

                    case DriveControlEventArgs.eControlKind.JOG:
                        this.ReqJog(args);
                        break;

                    case DriveControlEventArgs.eControlKind.VehicleState:
                        ReqVehicleState(args);
                        break;

                    default:
                        break;
                }
            }
        }

        public void ReqConveyorMove(string dir)
        {
            if (dir.Equals("CW"))
                this.refObjects.Conveyor.OnOffConveyor(true, false);
            else if (dir.Equals("CCW"))
                this.refObjects.Conveyor.OnOffConveyor(true, true);
            else if (dir.Equals("STOP"))
                this.refObjects.Conveyor.OnOffConveyor(false, false);
        }

        private void DriveControlEventPublish(DriveControlEventArgs args)
        {
            args.EventDir = DriveControlEventArgs.eEventDir.ToFront;
            this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish(args);
        }

        public void Init()
        {
            ThreadStart();

            //TimerUtils.Once(5000, () => { this.CurrentPosition = 1000; });
            var v = refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
            v.CurrentTag = "0000";
            v.VehicleState = eVehicleState.None;
            v.MachineMode = eMachineMode.LocalMode;
            
            this.VehicleOnRailState = v.VehicleOnRailState;
            this.CurrentTag = this.refObjects.ZmqManager.CurrentPointNo;

            //refObjects.Sqlite.VehicleInfoDAL.Update( v );
        }

        public int InitializationVehicle()
        {
#if SIMULATION
            this.VehicleStateProperty = eVehicleState.Idle;
            return 0;
#else
            int result = 0;

            //PIOClear();
            //PIOSensorOff();

            result = this.refObjects.Clamp.IsAllAxisOriginReturn();
            if (result != ConstInt.EXECUTE_SUCCESS)
            {
                this.refObjects.Clamp.AllOriginReturn();
                LockUtils.Wait(2000);
            }

            if (this.refObjects.Conveyor.IsDetectedCenter()) //자제가 있으면 Lock
                result = this.refObjects.Clamp.Lock_Sync();
            else
                result = this.refObjects.Clamp.Unlock_Sync();

            result = 0;

            if (result != 0)
            {
                this.VehicleStateProperty = eVehicleState.Abnormal;
                return result;
            }

            if (this.refObjects.Drive.IsErrorOn)
                return 22;

            if (IsChargeCylinderForword())
            {
                result = this.StopBatteryCharge();
                if (result != 0)
                    return result;
            }

            this.VehicleStateProperty = eVehicleState.Idle;

            return result;
#endif
        }

        public void Dispose()
        {
            this.taskCancel.Cancel();

            this.cancel.Cancel();
            this.cancel.StopWaitAll();
        }

        #region Request Method
        private void ReqVehicleState(DriveControlEventArgs args)
        {
            VehicleInfo state = new VehicleInfo();
            state.CurrentPosition = this.CurrentPosition;
            state.CurrentSpeed = this.CurrentSpeed;
            state.CurrentTag = this.CurrentTag.ToString();
            state.CurrentTorque = this.CurrentTorque;

            var msg = new DriveControlEventArgs();
            msg.ControlKind = args.ControlKind;
            msg.Args = state;

            DriveControlEventPublish(msg);
        }

        private void ReqMoveToPos(DriveControlEventArgs args)
        {
            //var result = drive.Move( args.PositionTag );
            //this.MoveTo( "1111" );
            var reply = new DriveControlEventArgs();

            int targetTag = args.TargetRouteID;
            var route = this.refObjects.Sqlite.RouteDal.Get(x => x.Name.Equals(targetTag)).FirstOrDefault();
            if (route == null)
            {
                reply.Result = Results.Fail("Not Found Route");
                this.DriveControlEventPublish(reply);
                return;
            }

            var subCommand = new SubCmd();
            subCommand.TargetID = route.Name;

            this.MoveTo(subCommand);
            reply.Result = Results.Ok("Position Move");
            this.DriveControlEventPublish(reply);
        }

        void ReqFaultReset(DriveControlEventArgs _args)
        {
            var msg = new DriveControlEventArgs
            {
                ControlKind = DriveControlEventArgs.eControlKind.FaultReset
            };

            var ll = this.refObjects.ZmqManager.SetDriveControl(eDriveControl.ResetFault);

            if (ll == 38)
            {
                logger.E($"Drive Fault Reset Error");
                msg.Result = Results.Fail("Drive Fault Reset Error");
            }
            else
                msg.Result = Results.Ok();

            this.DriveControlEventPublish(msg);
        }

        void ReqJog(DriveControlEventArgs _args)
        {
            if (_args.JogDir == DriveControlEventArgs.eJogMoveDir.Positive)
                this.refObjects.Drive.JogForword();
            else
                this.refObjects.Drive.JogBackword();
        }

        Logger batteryLogger = Logger.GetLogger("BatteryLogger");
        void ReqCurrentPos()
        {
            var task = Task.Factory.StartNew(() =>
            {
                while (!this.taskCancel.Canceled)
                {
                    LockUtils.Wait(1000);

                    batteryLogger.I($"SOC - {this.BatteryStateOfCharge} / Current - {this.BatteryCurrent} / Voltage - {this.BatteryVoltage} / Capacity - {this.BatteryCapacity} / Energy - {this.BatteryEnergy}");

                     //var msg = new DriveControlEventArgs
                     //{
                     //    EventDir = DriveControlEventArgs.eEventDir.ToFront,
                     //    ControlKind = DriveControlEventArgs.eControlKind.ReqCurrentPos,
                     //    CurrentPosition = new Random().Next( 0, 1000 ),
                     //};

                     //this.DriveControlEventPublish( msg );
                 }
            });

            this.taskCancel.Add(task);
        }

        void ReqDriveOn(DriveControlEventArgs _args)
        {
            var msg = new DriveControlEventArgs
            {
                ControlKind = DriveControlEventArgs.eControlKind.DriveON
            };

            var ll = this.refObjects.ZmqManager.SetDriveControl(eDriveControl.ServoOn);

            if (ll == 38)
            {
                logger.E($"Drive On Error");
                msg.Result = Results.Fail("Drive On Error");
            }
            else
                msg.Result = Results.Ok("Drive On");

            this.DriveControlEventPublish(msg);
        }

        void ReqDriveOff(DriveControlEventArgs _args)
        {
            var ll = this.refObjects.ZmqManager.SetDriveControl(eDriveControl.ServoOff);

            if (ll == 38)
            {
                logger.E($"Servo Off Error");
            }

            var msg = new DriveControlEventArgs
            {
                ControlKind = DriveControlEventArgs.eControlKind.DriveOFF
            };
            msg.Result = Results.Ok("Drive On");

            this.DriveControlEventPublish(msg);
        }
        #endregion 

        #region Thread
        void ThreadStart()
        {
            this.cancel.AddGo(new Action(this.ThreadJob));

            //this.cancel.AddGo(new Action(this._ThVehicleStateCheck));
            //this.cancel.AddGo(new Action(this._ThVehicleStateCheck));
        }

        //장애물 감지 Thread
        //장애물 감지 패턴 변경도 여기 하자.
        private void _ThVehicleStateCheck()
        {
            while (!this.cancel.Canceled)
            {
                try
                {
                    //if ( this.autoManager.OperationModeProperty == eOperatationMode.AutoMode )
                    //this.CheckObstacle();

                    //this.CheckIOState();
                }
                catch (ThreadInterruptedException threadInterruptedException)
                {
                    logger.E(threadInterruptedException);
                }
                catch (Exception exception)
                {
                    logger.E(exception);
                }
                finally
                {
                    LockUtils.Wait(5);
                }
            }
            logger.D("Vehicle - _ThObstacleChecker Dispose");
        }

        void ThreadJob()
        {
            Thread.CurrentThread.Name = $"{this.GetType().Name}Job";
            logger.D($"Vehicle - Process Started {Thread.CurrentThread.Name}");

            while (!this.taskCancel.Canceled)
            {
                try
                {
                    switch (this.refObjects.AutoManager.OperationModeProperty)
                    {
                        case eOperatationMode.ManualMode:
                            break;
                        case eOperatationMode.AutoMode:
                            {
                                switch (this.refObjects.AutoManager.AutoModeStateProperty)
                                {
                                    case eAutoModeState.ErrorStop:
                                        break;
                                    case eAutoModeState.StartRun:
                                        this.IsAutoRun = true;
                                        break;
                                    case eAutoModeState.Run:
                                        this.DoWork();
                                        break;
                                    case eAutoModeState.Stop:
                                        this.IsAutoRun = false;
                                        break;
                                    case eAutoModeState.WaitStop:
                                        break;
                                    default:
                                        break;
                                }
                            }
                            break;
                        case eOperatationMode.InitialMode:
                            break;
                        default:
                            break;
                    }
                }
                catch (Exception ex)
                {
                    logger.E(ex);
                }
                finally
                {
                    LockUtils.Wait(500);
                }
            }

            logger.D("Vehicle - Process Disposed");
        }

        void DoWork()
        {
            //2020.08.18.Kang. 상위 연결이 안되어 있으면 SubCmd 실행을 안하고 대기함.
            if (!this.refObjects.HostManager.IsConnected)
                return;

            var subCmd = this.refObjects.Sqlite.SubCmdDAL.GetAll().FirstOrDefault();
            if (subCmd == null) return;

            if (!this.refObjects.Sqlite.CommandDAL.GetAll().Any(x => x.CommandID.Equals(subCmd.CmdID)))
            {
                if (subCmd.CmdType == SubCmd.eCmdType.Auto) //자동 명령중 Main Command 가 없으면 삭제.
                {
                    this.refObjects.Sqlite.SubCmdDAL.Delete(subCmd.ID);
                    logger.I($"SubCmd Deleted Main Command Not Exist - ID={subCmd.ID}, CommandID={subCmd.CmdID}");
                    return;
                }
            }

            switch (subCmd.Type)
            {
                case eSubCommandType.Move:
                    this.CurrentSubCommand = subCmd;
                    this.Move(subCmd);
                    break;

                case eSubCommandType.Load:
                    this.CurrentSubCommand = subCmd;
                    this.LoadCarrier(subCmd);
                    break;

                case eSubCommandType.Unload:
                    this.CurrentSubCommand = subCmd;
                    this.UnloadCarrier(subCmd);
                    break;

                case eSubCommandType.Charge:
                    this.CurrentSubCommand = subCmd;
                    this.BatteryCharge(subCmd);
                    break;

                case eSubCommandType.Cancel:
                    this.CurrentSubCommand = subCmd;
                    CancelCommand(subCmd);
                    break;

                default:
                    break;
            }
        }

        /// <summary>
        /// Scheduler 가 주는 Sub Command 를 이용하여 동작하자.
        /// </summary>
        public void _ThSubCmdWorker()
        {
            while (!this.cancel.Canceled)
            {
                try
                {
                    if (this.refObjects.AutoManager.AutoModeStateProperty != eAutoModeState.Run)
                        continue;

                    var subCmd = this.refObjects.Sqlite.SubCmdDAL.GetAll().FirstOrDefault();
                    if (subCmd == null) continue;

                    if (!this.refObjects.Sqlite.CommandDAL.GetAll().Any(x => x.CommandID.Equals(subCmd.CmdID)))
                    {
                        if (subCmd.CmdType == SubCmd.eCmdType.Auto) //자동 명령중 Main Command 가 없으면 삭제.
                        {
                            this.refObjects.Sqlite.SubCmdDAL.Delete(subCmd.ID);
                            logger.I($"SubCmd Deleted Main Command Not Exist - ID={subCmd.ID}, CommandID={subCmd.CmdID}");
                            continue;
                        }
                    }

                    switch (subCmd.Type)
                    {
                        case eSubCommandType.Move:
                            this.CurrentSubCommand = subCmd;
                            this.Move(subCmd);
                            break;

                        case eSubCommandType.Load:
                            this.CurrentSubCommand = subCmd;
                            this.LoadCarrier(subCmd);
                            break;

                        case eSubCommandType.Unload:
                            this.CurrentSubCommand = subCmd;
                            this.UnloadCarrier(subCmd);
                            break;

                        case eSubCommandType.Charge:
                            this.CurrentSubCommand = subCmd;
                            this.BatteryCharge(subCmd);
                            break;

                        case eSubCommandType.Cancel:
                            this.CurrentSubCommand = subCmd;
                            CancelCommand(subCmd);
                            break;

                        default:
                            break;
                    }
                }
                catch (Exception exception)
                {
                    logger.E(exception);
                }
                finally
                {
                    LockUtils.Wait(500);
                }
            }
            logger.D("Vehicle - _ThSubCmdWorker Dispose");
        }

        private void CancelCommand(SubCmd subCmd)
        {
            this.refObjects.Drive.CancelCommand(subCmd);

            var cmd = this.refObjects.Sqlite.CommandDAL.GetById(subCmd.CmdID);
            cmd.State = eCommandState.Complete;
            this.refObjects.Sqlite.CommandDAL.Update(cmd);
            this.refObjects.Sqlite.SubCmdDAL.Clean();

            logger.D($"[Cancel Command] {cmd.TargetID} / {cmd.Type}");
        }

        #endregion

        #region Control Action Method
        public void EStop()
        {
            this.refObjects.Conveyor.OnOffConveyor(false);
            //Clamp EStop
            //this.refObjects.Clamp.ClampEStop();
            this.refObjects.Drive.EStop();

            //this.OccurVehicleAlarm( 23 );
        }

        #region For Moving
        void Move(SubCmd sub)
        {
            logger.I($"[SubCommand Start] - Target : {sub.TargetID} / Type : {sub.Type}");

            //Move 시작 시 충전 중이면 충전 중지 실행.
            int result = 0;
            if (this.IsChargeCylinderForword())
            {
                result = this.StopBatteryCharge();
                if (result != 0)
                {
                    OccurVehicleAlarm(result);
                    return;
                }
            }

            var iTarget = Convert.ToInt32(sub.TargetID);
            if (iTarget != CurrentTag) //하나의 목표 위치로 왔을때 현재 위치와 동일 하면 이동안함.
            {
                result = this.MoveTo(sub);
                if (result != ConstInt.EXECUTE_SUCCESS)
                {
                    OccurVehicleAlarm(result);
                }
            }

            //result = this.MoveTo(sub);
            //if (result != ConstInt.EXECUTE_SUCCESS)
            //{
            //    OccurVehicleAlarm(result);
            //    return;
            //}

            //2020.07.29. Kang Move 이후 OCS 연결이 없으면 Load/Unlaod 동작을 하지 말자.
            //if ( !this.refObjects.HostManager.IsConnected )
            //{
            //    var cmd = this.refObjects.Sqlite.CommandDAL.GetById( sub.CmdID );
            //    cmd.IsSecondCommanded = true;
            //    cmd.State = eCommandState.Complete;
            //    this.refObjects.Sqlite.CommandDAL.Update( cmd );
            //}

            LockUtils.Wait(500);
            this.refObjects.Sqlite.SubCmdDAL.Clean();

            //this.taskMoveCancel.Cancel();
            //this.taskMoveCancel.WaitAll();

            //this.CheckOCSConnectionState();

            logger.I($"[SubCommand Complete] - Target : {sub.TargetID} / Type : {sub.Type}");
        }

        int MoveTo(SubCmd sub)
        {
            PIOClear();
            PIOSensorOff();

            if (this.VehicleStateProperty == eVehicleState.Idle)
            {
                this.OnMoveReady?.Invoke();

                var moveReadyBuzzerTime = Convert.ToInt32(this.refObjects.Sqlite.ConfigDal.GetById(ConstString.BuzzerStartReadyTime).Value);
                Thread.Sleep(moveReadyBuzzerTime);

                this.VehicleStateProperty = eVehicleState.Move;

                this.ObstaclePatternChange(this.refObjects.ZmqManager.SegmentID);
            }

            this.OnMoving?.Invoke();

            //이전에 있던 작업들 종료 및 삭제
            //this.taskMoveCancel.Cancel();
            //this.taskMoveCancel.WaitAll();
            //this.taskMoveCancel.Add(CheckCrossPoint());

            this.VehicleStateProperty = eVehicleState.Move;

            int result = this.refObjects.Drive.MoveToPoint(sub, 100);
            if (result != ConstInt.EXECUTE_SUCCESS)
                return result;

            result = this.Wait4MoveDone();
            if (result != ConstInt.EXECUTE_SUCCESS)
                return result;

            //Drive 에서 정지 확인 후 상태 변경
            if (this.refObjects.Drive.IsDriveStop())
            {
                this.OnMoveFinish?.Invoke();

                this.VehicleStateProperty = eVehicleState.Idle;
                logger.D("Move Finish");

                AddCurrentDriveDistance();

                //2020.08.13. Kang. 주행이 끝나면 장애물감지센서의 패턴을 특정 패턴으로 변경(나성권B 요청)
                var pattern = Convert.ToInt32(this.refObjects.Sqlite.ConfigDal.GetById(ConstString.StandbyPattern).Value);
                this.ChgObstacleDetectPattern(pattern);
            }

            return result;
        }

        int Wait4MoveDone()
        {
            int waitTime = 10 * ConstUtils.ONE_MINUTE; //설정 할 수있게.
            long st = SwUtils.CurrentTimeMillis;
            bool isComingStop = false;

            while (true)
            {
                LockUtils.Wait(50); //2020.07.29. Kang 빠르게 확인 할 필요가 없으므로 5ms -> 50ms 로 변경

                if (SwUtils.Gt(st, waitTime))
                {
                    logger.D("Wait4MoveDone Time Over");
                    return 39;
                }

                //이동중 메인 명력이 없어진다면 정지 후 
                if (null == this.refObjects.Sqlite.CommandDAL.GetById(this.CurrentSubCommand.CmdID))
                {
                    logger.D("[Wait Move Done] - 메인 명령 사라짐");
                    var cmd = this.refObjects.Sqlite.CommandDAL.GetAll();
                    if (cmd == null)
                    {
                        logger.D("[Wait Move Done] - Main Command not Exist Motion Stop");
                        this.refObjects.Drive.Stop();
                        return 40;
                    }
                    else
                    {
                        logger.D("[Wait Move Done] - Main Command not Exist Motion command, New Command Exist");
                        break;
                    }
                }

                if (this.refObjects.Drive.IsDriveFault)
                    return 45;

                //2020.08.04. Kang. 드라이브에서 알람이 발생하여 Auto Run 상태 가 아니면 기다리지 말고 Thread 종료를 위해.
                if (this.refObjects.AutoManager.AutoModeStateProperty != eAutoModeState.Run)
                {
                    if (!isComingStop) //stop 명령을 한번만 내리기 위해.
                    {
                        isComingStop = true;
                        this.refObjects.Drive.Stop();
                    }
                }

                if (this.refObjects.Drive.IsDriveStop()) //Move Stop
                    break;
            }

            return ConstInt.EXECUTE_SUCCESS;
        }

        Task CheckCrossPoint()
        {
            var task = Task.Run(() =>
           {
               long sTime = SwUtils.CurrentTimeMillis;

               while (!this.taskMoveCancel.Canceled)
               {
                   Thread.Sleep(10);

                    //ToDo: approach Cross Point Check

                    //ToDo: Obstacle Laser Sensor Pattern Change Method 구현 필요.
                }
           });

            return task;
        }
        #endregion

        public bool LoadCarrier(SubCmd sub)
        {
            logger.I($"[SubCommand Start] - Target : {sub.TargetID} / Type : {sub.Type}");

            this.VehicleStateProperty = eVehicleState.Load;

            var targetNo = Convert.ToInt32(sub.TargetID);
            if (this.CurrentTag != targetNo)
            {
                this.OccurVehicleAlarm(20);
                return false; //Alarm
            }

            //var route = sql.RouteDal.GetRoute( sub.TargetID );
            //if ( !CorrectPosition( route, this.CurrentPosition ) )
            //{
            //    this.OccurVehicleAlarm( 20 );
            //    return false; //Alarm
            //}

            int result = 0;

            result = this.PIOAndLoad(sub.TargetID);
            if (result != 0)
            {
                this.OccurVehicleAlarm(result);
                return false;
            }
            this.PIOSensorOff();

            //Load, Unload 가 끝나면 메인 Command 를 완료 했다고 판단.
            logger.I($"[SubCommand Complete] - Target : {sub.TargetID} / Type : {sub.Type}");
            this.refObjects.Sqlite.SubCmdDAL.Clean();
            var cmd = this.refObjects.Sqlite.CommandDAL.GetById(sub.CmdID);
            if (cmd != null)
            {
                cmd.State = eCommandState.Complete;
                this.refObjects.Sqlite.CommandDAL.Update(cmd);
            }

            //LockUtils.Wait( 1000 );
            //this.OnLoadComplete?.Invoke(); //일찍 주면 다음 명령을 500ms 안에 주는 현상 있음. 그러니까 천천히 주자 
            this.VehicleStateProperty = eVehicleState.Idle;

            return true;
        }

        public bool UnloadCarrier(SubCmd sub)
        {
            logger.I($"[SubCommand Start] - Target : {sub.TargetID} / Type : {sub.Type}");

            var targetNo = Convert.ToInt32(sub.TargetID);
            if (this.CurrentTag != targetNo)
            {
                this.OccurVehicleAlarm(21);
                return false; //Alarm
            }

            //var route = sql.RouteDal.GetRoute( sub.TargetID );

            //if ( !CorrectPosition( route, this.CurrentPosition ) )
            //{
            //    this.OccurVehicleAlarm( 21 );
            //    return false; //Alarm
            //}

            //PIO 내부로 이동.
            //int result = this.clamp.Unlock_Sync();
            //if ( result != 0 )
            //{
            //    this.OccurVehicleAlarm( result );
            //    return false;
            //}
            this.VehicleStateProperty = eVehicleState.Unload;

            int result = 0;
            result = this.PIOAndUnload(sub.TargetID);
            if (result != 0)
            {
                this.refObjects.IO.OutputOn("OUT_PIO_SENSOR_ONOFF");
                this.OccurVehicleAlarm(result);
                return false;
            }

            this.PIOSensorOff();

            logger.I($"[SubCommand Complete] - Target : {sub.TargetID} / Type : {sub.Type}");
            this.refObjects.Sqlite.SubCmdDAL.Clean();
            var cmd = this.refObjects.Sqlite.CommandDAL.GetById(sub.CmdID);
            if (cmd != null)
            {
                cmd.State = eCommandState.Complete;
                this.refObjects.Sqlite.CommandDAL.Update(cmd);
            }

            //LockUtils.Wait( 1000 );
            //this.OnUnloadComplete?.Invoke(); //일찍 주면 다음 명령을 500ms 안에 주는 현상 있음. 그러니까 천천히 주자 
            this.VehicleStateProperty = eVehicleState.Idle;

            return true;
        }

        public void BatteryCharge(SubCmd subCmd)
        {
            int result = 0;
            result = this.StartBatteryCharge();
            if (result != ConstInt.EXECUTE_SUCCESS)
                this.OccurVehicleAlarm(result);

            this.refObjects.Sqlite.SubCmdDAL.Clean();

            var cmd = this.refObjects.Sqlite.CommandDAL.GetById(subCmd.CmdID);
            if (cmd == null)
                return;

            cmd.State = eCommandState.Complete;
            this.refObjects.Sqlite.CommandDAL.Update(cmd);
        }

        /// <summary>
        /// Battery Charge
        /// 충전 시 PIO 를 해야 함.
        /// </summary>
        /// <param name="sub"></param>
        /// <returns></returns>
        int PIOBatteryCharge(SubCmd sub)
        {
            var route = this.refObjects.Sqlite.RouteDal.GetById(sub.TargetID);

            if (!CorrectPosition(route, this.CurrentPosition))
            {
                this.OccurVehicleAlarm(21);
                return 0; //Alarm
            }

            var pioTimeout = CastTo<int>.From<string>(this.refObjects.Sqlite.ConfigDal.GetById(ConstString.PIOTimeOut).Value);

            PIOClear();
            loggerPIO.I($"Start Charge PIO - [{sub.TargetID}]");
            if (!this.refObjects.IO.IsOn("IN_PIO_READY"))
            {
                loggerPIO.E("[Port] - 1 Ready not On");
                this.OccurVehicleAlarm(25);
                return 0;
            }

            this.refObjects.IO.WriteOutputIO("OUT_PIO_READY", true);
            loggerPIO.I("[Vehicle] - 1 Ready On");

            if (!this.refObjects.IO.WaitChangeInputIO(true, pioTimeout, "IN_PIO_RECEIVE_RUN"))
            {
                PIOClear();
                loggerPIO.E("[Port] - 2 Receive CV Run Timeout");
                this.OccurVehicleAlarm(26);
                return 0;
            }

            this.refObjects.IO.WriteOutputIO("OUT_PIO_SENDING_RUN", true);
            loggerPIO.I("[Vehicle] - 2 Send Run On");

            var sTime = SwUtils.CurrentTimeMillis;
            while (true)
            {
                Thread.Sleep(5);

                if (!this.refObjects.IO.IsOn("IN_PIO_READY") || this.refObjects.IO.IsOn("IN_PIO_RECEIVE_RUN"))
                    break;

                if (null == this.refObjects.Sqlite.CommandDAL.GetById(this.CurrentSubCommand.CmdID))
                {
                    PIOClear();
                    logger.D("[Wait Charging] - 메인 명령 사라짐");
                    break;
                }
            }

            if (!this.refObjects.IO.WaitChangeInputIO(true, pioTimeout, "IN_PIO_RECEIVE_COMPLITE"))
            {
                PIOClear();
                loggerPIO.E("[Port] - 3 Receive Complete Timeout");
                this.OccurVehicleAlarm(26);
                return 0;
            }

            PIOClear();

            this.refObjects.IO.WriteOutputIO("OUT_PIO_SEND_COMPLITE", true);
            Thread.Sleep(1000);
            this.refObjects.IO.WriteOutputIO("OUT_PIO_SEND_COMPLITE", false);

            return 0;
        }

        public int StartBatteryCharge()
        {
#if SIMULATION
            this.PIOSensorOn();

            var pioTimeout = CastTo<int>.From<string>( refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            PIOClear();
            loggerPIO.I( $"Start Battery Charge PIO" );

            //if ( !this.iO.WaitChangeInputIO( true, pioTimeout, "IN_PIO_SENDABLE" ) )
            //{
            //    PIOClear();
            //    loggerPIO.E( "[Port] - 4 Ready Time Out" );
            //    return 34;
            //}
            Thread.Sleep( 1000 );
            loggerPIO.E( "[Port] - 4 Ready On" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVABLE", true );
            loggerPIO.I( "[Vehicle] - 4 Receivable" );

            //if ( !this.iO.WaitChangeInputIO( true, 20000, "IN_PIO_SEND_RUN" ) )
            //{
            //    PIOClear();
            //    loggerPIO.E( "[Port] - 5 Sending Run Time Out" );
            //    return 35;
            //}
            Thread.Sleep( 1000 );
            loggerPIO.I( "[Port] - 5 Sending Run On" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVE_RUN", true );
            loggerPIO.I( "[Vehicle] - 5 Receive Run On" );

            this.VehicleStateProperty = eVehicleState.Charge;
            this.OnChargingStart?.Invoke();
            Thread.Sleep( 1000 );
            this.OnCharging?.Invoke();

            return 0;
#else
            PIOClear();
            this.PIOSensorOn();

            var pioTimeout = Convert.ToInt32(this.refObjects.Sqlite.ConfigDal.GetById(ConstString.PIOTimeOut).Value);

            loggerPIO.I($"Start Battery Charge PIO");

            if (!this.refObjects.IO.WaitChangeInputIO(true, pioTimeout, "IN_PIO_SENDABLE"))
            {
                PIOClear();
                loggerPIO.E("[Port] - 4 Ready Time Out");
                return 34;
            }
            loggerPIO.I("[Port] - 4 Ready On");

            this.refObjects.IO.WriteOutputIO("OUT_PIO_RECEIVABLE", true);
            loggerPIO.I("[Vehicle] - 4 Receivable");

            if (!this.refObjects.IO.WaitChangeInputIO(true, 5000, "IN_PIO_SEND_RUN"))
            {
                PIOClear();
                loggerPIO.E("[Port] - 5 Sending Run Time Out");
                return 35;
            }
            loggerPIO.I("[Port] - 5 Sending Run On");

            long sTime = SwUtils.CurrentTimeMillis;
            while (!IsChargeCylinderForword())
            {
                LockUtils.Wait(10);
                if (SwUtils.Gt(sTime, 5000))
                {
                    PIOClear();
                    return 45; //Alarm ID 추가.
                }
            }

            this.refObjects.IO.WriteOutputIO("OUT_PIO_RECEIVE_RUN", true);
            loggerPIO.I("[Vehicle] - 5 Receive Run On");

            //this.VehicleStateProperty = eVehicleState.Charge;

            return 0;
#endif

        }

        public int StopBatteryCharge()
        {
#if SIMULATION
            loggerPIO.I( $"Stop Battery Charge PIO" );

            var pioTimeout = CastTo<int>.From<string>( refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            this.PIOClear();

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", true );
            loggerPIO.I( "[Vehicle] Receive Complete On" );

            //if ( !this.iO.WaitChangeInputIO( true, 20000, "IN_PIO_SEND_COMPLITE" ) )
            //{
            //    this.iO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false );
            //    loggerPIO.E( "[Port]  IN_PIO_SEND_COMPLITE On Time Out" );
            //    return 36;
            //}
            Thread.Sleep( 1000 );
            loggerPIO.I( "[Port] Send Complete On" );

            Thread.Sleep( 1000 );
            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false );

            this.OnChargingFull?.Invoke();

            this.PIOSensorOff();

            this.VehicleStateProperty = eVehicleState.Idle;

            return 0;
#else
            loggerPIO.I($"Stop Battery Charge PIO");

            var pioTimeout = Convert.ToInt32(this.refObjects.Sqlite.ConfigDal.GetById(ConstString.PIOTimeOut).Value);

            this.PIOClear();

            this.refObjects.IO.WriteOutputIO("OUT_PIO_RECIVE_COMPLITE", true);
            loggerPIO.I("[Vehicle] Receive Complete On");

            if (!this.refObjects.IO.WaitChangeInputIO(true, 5000, "IN_PIO_SEND_COMPLITE"))
            {
                this.refObjects.IO.WriteOutputIO("OUT_PIO_RECIVE_COMPLITE", false);
                loggerPIO.E("[Port]  IN_PIO_SEND_COMPLITE On Time Out");
                return 36;
            }
            loggerPIO.I("[Port] Send Complete On");

            long sTime = SwUtils.CurrentTimeMillis;
            while (IsChargeCylinderForword())
            {
                LockUtils.Wait(10);
                if (SwUtils.Gt(sTime, 5000))
                {
                    PIOClear();
                    return 44; //Alarm ID 추가.
                }
            }

            Thread.Sleep(1000);
            this.refObjects.IO.WriteOutputIO("OUT_PIO_RECIVE_COMPLITE", false);

            this.PIOSensorOff();

            //this.OnChargingFull?.Invoke();
            //this.VehicleStateProperty = eVehicleState.Idle;

            return 0;
#endif
        }

        #endregion

        #region Check Method
        bool CheckObstacle()
        {
            if (this.refObjects.IO.IsOff("IN_OBSTRUCTION_DETECT_SAFETY") || this.refObjects.IO.IsOff("IN_OBSTRUCTION_DETECT_ERROR"))
            {
                this.ObstacleStateProperty = eObstacleState.Abnormal;
                //this.OccurVehicleAlarm( 42 );
            }
            else if (this.refObjects.IO.IsOff("IN_OBSTRUCTION_DETECT_STOP"))
            {
                this.ObstacleStateProperty = eObstacleState.Blocked;
            }
            else if (this.refObjects.IO.IsOff("IN_OBSTRUCTION_DETECT_SLOW"))
            {
                this.ObstacleStateProperty = eObstacleState.Decelerate;
            }
            else
            {
                this.ObstacleStateProperty = eObstacleState.Normal;
            }

            this.refObjects.Drive.SetObstacleState(this.ObstacleStateProperty);

            return false;
        }

        #endregion

        #region Mechanical Method

        #region IO
        /// <summary>
        /// Out Put 을 On 이면 Sensor Off
        /// </summary>
        public void PIOSensorOn() 
        { 
            this.refObjects.IO.OutputOff( "OUT_PIO_SENSOR_ONOFF" );
            LockUtils.Wait(500); //Sensor 가 커지고 안정 되는것을 기다리자.
        }

        /// <summary>
        /// Out Put 을 Off 이면 Sensor On
        /// </summary>
        public void PIOSensorOff() => this.refObjects.IO.OutputOn( "OUT_PIO_SENSOR_ONOFF" );
        public bool IsChargeCylinderForword() => this.refObjects.IO.IsOn( "IN_CHARGE_CYL_FWD_DETECT" );

        /// <summary>
        /// 충전 중일때 MTL PIO Bit 가 살아 있다 
        /// 이걸 보고 판단 하자. 충전 단자 전진 상태임.
        /// </summary>
        /// <returns></returns>
        public bool CheckBatteryCharge()
        {
            if ( this.VehicleStateProperty == eVehicleState.Charge || IsChargeCylinderForword() )
                return true;

            return false;
        }
        #endregion

        #region Conveyor
        public void ConveyorOff() => this.refObjects.Conveyor.OnOffConveyor( false );
        public int ConveyorLoad() => this.refObjects.Conveyor.ConveyorLoad();
        public int ConveyorUnload() => this.refObjects.Conveyor.ConveyorUnload();

        public void PIOClear()
        {
            string[] pio = { "OUT_PIO_READY", "OUT_PIO_SENDING_RUN", "OUT_PIO_SEND_COMPLITE", "OUT_PIO_RECEIVABLE", "OUT_PIO_RECEIVE_RUN", "OUT_PIO_RECIVE_COMPLITE", "OUT_PIO_INTERLOCK" };
            pio.FwEach( x => { this.refObjects.IO.OutputOff( x ); } );
        }

        public int PIOAndLoad( string targetName )
        {
#if SIMULATION
            PIOClear();
            loggerPIO.I( $"Start Load PIO - [{targetName}]" );
            this.OnPIOStart?.Invoke( true );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVE_RUN", true );
            loggerPIO.I( "[Vehicle] - 4 Receive Run On" );

            Thread.Sleep( 1000 );//상대 IO 기다린다 생각.
            loggerPIO.E( "[Port] - 4 Ready On" );

            //Conveyor Start
            loggerPIO.I( "[Vehicle] - Conveyor Run" );
            this.OnConveyorStart?.Invoke( true );

            Thread.Sleep( 10000 );//Conveyor 구동
            this.OnCarrierDetected?.Invoke( true );

            PIOClear();
            Thread.Sleep( 1000 );
            this.OnConveyorStop?.Invoke( true );

            Thread.Sleep( 1000 );
            this.OnLoadComplete?.Invoke();
#else
            loggerPIO.I( $"Start Load PIO - [{targetName}]" );

            PIOClear();
            this.PIOSensorOn();

            int result = 0;
            var pioTimeout = Convert.ToInt32( this.refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            result = this.refObjects.Clamp.Unlock_Sync();
            if ( result != 0 )
                return result;

            //if (this.refObjects.Conveyor.IsInverterError())
            //    return 16;

            if ( this.refObjects.Conveyor.IsDetectedCenter() )
            {
                this.OnFailReport?.Invoke( eFailCode.Load_VehicleHasCarrier );
                return 0;
            }

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 40 * ConstUtils.ONE_SECOND, "IN_LIFTER_POSITION_DETECT" ) )
            {
                loggerPIO.E( "[Port] - Lift Position Check Error" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.LoadPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.LoadPIOInterlockTimeout );
                return 0; //14
            }

            //if ( !this.refObjects.Conveyor.IsLifterPositinCheck() )
            //{
            //    loggerPIO.E( "[Port] - Lift Position Check Error" );
            //    this.OnFailReport?.Invoke( eFailCode.LoadPIOInterlockTimeout );
            //    return 0; //14
            //}

            //Todo: Sensor Setting 이 후 주석 풀기.
            //if ( !this.IsLifterDuplication() )
            //{
            //    this.OnFailReport?.Invoke( eFailCode.Load_PortHasNotCarrier );
            //    return 0;
            //}

            this.OnPIOStart?.Invoke( true );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVABLE", true );
            loggerPIO.I( "[Vehicle] - 4 Receivable" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 20 * ConstUtils.ONE_SECOND, "IN_PIO_SENDABLE" ) )
            {
                PIOClear();
                loggerPIO.E( "[Port] - 4 Ready Time Out" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.LoadPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.LoadPIOInterlockTimeout );
                return 0;
            }
            loggerPIO.I( "[Port] - 4 Ready On" );

            //this.conveyor.SetConveyorSpeed( true );
            result = this.refObjects.Conveyor.OnOffConveyor( true, true );
            if ( result != ConstInt.EXECUTE_SUCCESS )
                return result;

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVE_RUN", true, 1000 ); //1Sec 이후 On
            loggerPIO.I( "[Vehicle] - Conveyor Run" );
            this.OnConveyorStart?.Invoke( true );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, pioTimeout, "IN_PIO_SEND_RUN" ) )
            {
                this.refObjects.Conveyor.OnOffConveyor( false, true );
                PIOClear();
                loggerPIO.E( "[Port] - 5 Sending Run Time Out" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.LoadPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.LoadPIOInterlockTimeout );
                return 0;
            }
            loggerPIO.I( "[Port] - 5 Sending Run On" );

            bool isStartDetected = false;
            var sTime = SwUtils.CurrentTimeMillis;
            while ( true )
            {
                LockUtils.Wait( 50 );

                if ( SwUtils.Gt( sTime, 30 * ConstUtils.ONE_SECOND ) )
                {
                    this.refObjects.IO.WriteOutputIO( "OUT_PIO_INTERLOCK", true );

                    this.refObjects.Conveyor.OnOffConveyor( false, true );
                    loggerPIO.E( "[Vehicle] Conveyor Wait Time Out" );
                    //TimerUtils.Once( 1000, this.OnFailReport, eFailCode.LoadPIOInterlockTimeout );

                    return 10; //Conveyor Moving Timeout
                }

                //if ( this.refObjects.Conveyor.IsDetectedLoadStart() && !isStartDetected )
                //    isStartDetected = true;

                //if ( !this.refObjects.Conveyor.IsDetectedLoadStart() && isStartDetected ) { }
                //this.conveyor.SetConveyorSpeed( false );

                if ( this.refObjects.Conveyor.IsDetectedLoadStop() ) break;

                if ( this.refObjects.Conveyor.IsPIOInterLockOn() )
                {
                    this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
                    loggerPIO.E( "[Port] PIO InterLock On " );
                    return 19; //
                }
            }

            if ( this.refObjects.Conveyor.IsDetectedCenter() )
                this.OnCarrierDetected?.Invoke( true );

            this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
            PIOClear();
            this.OnConveyorStop?.Invoke( true );
            loggerPIO.I( "[Vehicle] Conveyor Stop" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", true );
            loggerPIO.I( "[Vehicle] Receive Complete On" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, pioTimeout, "IN_PIO_SEND_COMPLITE" ) )
            {
                this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false );
                loggerPIO.E( "[Port]  IN_PIO_SEND_COMPLITE On Time Out" );
            }
            loggerPIO.I( "[Port] Send Complete On" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false, 1000 );

            loggerPIO.I( $"End Load PIO - [{targetName}]" );

            result = this.refObjects.Clamp.Lock_Sync();
            if ( result != 0 )
            {
                this.OccurVehicleAlarm( result );
                return result;
            }
#endif
            //2020.08.18.Kang. Conveyor 작동후 OCS 연결이 끊어지면 알람 처리
            //if (!this.refObjects.HostManager.IsConnected)
            //    return 43;

            TimerUtils.Once(2000, this.OnLoadComplete);

            return 0;
        }

        public int PIOAndUnload( string targetName )
        {
#if SIMULATION
            PIOClear();
            loggerPIO.I( $"Start Unload PIO - [{targetName}]" );
            this.OnPIOStart?.Invoke( false );

            Thread.Sleep( 1000 );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_READY", true );
            loggerPIO.I( "[Vehicle] - 1 Ready On" );

            Thread.Sleep( 1000 );
            this.OnConveyorStart?.Invoke( false );

            Thread.Sleep( 10000 );
            this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
            this.OnConveyorStop?.Invoke( false );
            PIOClear();

            Thread.Sleep( 1000 );
            this.OnUnloadComplete?.Invoke();
#else
            loggerPIO.I( $"Start Unload PIO -[{targetName}]" );
            PIOClear();
            this.PIOSensorOn();

            int result = 0;

            var pioTimeout = Convert.ToInt32( this.refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            if ( this.refObjects.Conveyor.IsInverterError() )
                return 16;

            //if ( this.refObjects.Conveyor.IsLifterDuplication() )
            //{
            //    this.OnFailReport?.Invoke( eFailCode.Unload_PortHasCarrier );
            //    return 0;
            //}

            if ( !this.refObjects.Conveyor.IsDetectedCenter() )
            {
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.Unload_VehicleHasNotCarrier );
                //this.OnFailReport?.Invoke( eFailCode.Unload_VehicleHasNotCarrier );
                return 0;
            }

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 40 * ConstUtils.ONE_SECOND, "IN_LIFTER_POSITION_DETECT" ) )
            {
                loggerPIO.E( "[Port] - Lift Position Check Error" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.UnlaodPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.UnlaodPIOInterlockTimeout );
                return 0;
            }

            //if ( !this.refObjects.Conveyor.IsLifterPositinCheck() )
            //{
            //    loggerPIO.E( "[Port] - Lift Position Check Error" );
            //    this.OnFailReport?.Invoke( eFailCode.UnlaodPIOInterlockTimeout ); //Unloading Fail Code 를 Time Out 으로 하자. 정의 된 코드 없음.
            //    return 0; //13 -> Alarm Code 보고 없음. 경알람 상태 이므로 한번 보고 후 정상 동작
            //}

            PIOClear();
            this.OnPIOStart?.Invoke( false );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 20 * ConstUtils.ONE_SECOND, "IN_PIO_READY" ) )
            {
                loggerPIO.E( "[Port] - 1 Ready not On" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.UnlaodPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.UnlaodPIOInterlockTimeout );
                return 0;
            }

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_READY", true );
            loggerPIO.I( "[Vehicle] - 1 Ready On" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 10 * ConstUtils.ONE_SECOND, "IN_PIO_RECEIVE_RUN" ) )
            {
                PIOClear();
                loggerPIO.E( "[Port] - 2 Receive CV Run Timeout" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.UnlaodPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.UnlaodPIOInterlockTimeout );
                return 0;
            }
            loggerPIO.I( "[Port] - 2 Receive CV Run On" );

            result = this.refObjects.Clamp.Unlock_Sync();
            if ( result != 0 )
                return result;

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SENDING_RUN", true );
            loggerPIO.I( "[Vehicle] - 2 Send Run On" );

            //this.conveyor.SetConveyorSpeed( true );
            this.refObjects.Conveyor.OnOffConveyor( true );
            this.OnConveyorStart?.Invoke( false );

            var sTime = SwUtils.CurrentTimeMillis;
            while ( true )
            {
                LockUtils.Wait(50);

                if ( SwUtils.Gt( sTime, 30 * ConstUtils.ONE_SECOND ) )
                {
                    this.refObjects.IO.WriteOutputIO( "OUT_PIO_INTERLOCK", true );

                    this.refObjects.Conveyor.OnOffConveyor( false, true );
                    loggerPIO.E( "[Port] Conveyor Wait Time Out" );
                    //TimerUtils.Once( 1000, this.OnFailReport, eFailCode.UnlaodPIOInterlockTimeout );

                    return 12; // 2020.07.18 Kang. 센서에 걸리지 않아도 중간에 걸려 있을 가능성 때문에 알람 처리.

                    //if ( this.refObjects.Conveyor.IsDetectedLoadStart() || this.refObjects.Conveyor.IsDetectedCenter() ) //중간에 걸려 있다고 생각해서 알람 처리.
                    //    return 12; //Conveyor Moving Timeout
                    //else
                    //{
                    //    if ( this.refObjects.Conveyor.IsDetectedCenter() ) //Time Out 후 아직 Tray 가 있으면 다시 Clamp Lock.
                    //    {
                    //        result = this.refObjects.Clamp.Unlock_Sync();
                    //        if ( result != 0 )
                    //        {
                    //            this.OccurVehicleAlarm( result );
                    //            return result;
                    //        }
                    //    }
                    //    else
                    //        return 0;
                    //}
                }

                if ( !this.refObjects.Conveyor.IsDetectedLoadStart() && !this.refObjects.Conveyor.IsDetectedCenter() )
                {
                    if ( this.refObjects.IO.IsOn( "IN_PIO_RECEIVE_COMPLITE" ) )
                    {
                        loggerPIO.I( "[Port] - 3 Receive Complete On" );
                        break;
                    }
                }

                if ( this.refObjects.Conveyor.IsPIOInterLockOn() )
                {
                    this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
                    loggerPIO.E( "[Port] PIO InterLock On " );
                    return 19; //
                }
            }

            if ( !this.refObjects.Conveyor.IsDetectedCenter() )
                this.OnCarrierDetected?.Invoke( false );

            this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
            this.OnConveyorStop?.Invoke( false );
            PIOClear();

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SEND_COMPLITE", true );
            Thread.Sleep( 1000 );
            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SEND_COMPLITE", false );
            loggerPIO.I( "[Vehicle] - 3 Send Complete OnOff" );
#endif
            loggerPIO.I( $"End Unload PIO - [{targetName}]" );

            //2020.08.18.Kang. Conveyor 작동후 OCS 연결이 끊어지면 알람 처리
            //if (!this.refObjects.HostManager.IsConnected)
            //    return 43;

            TimerUtils.Once(2000, this.OnUnloadComplete);

            return 0;
        }

        public int ManualPIOAndLoad()
        {
            loggerPIO.I( $"Start Load PIO - [{this.CurrentTag}]" );

            PIOClear();

            this.PIOSensorOn();

            int result = ConstInt.EXECUTE_SUCCESS;

            var pioTimeout = Convert.ToInt32( this.refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            result = this.refObjects.Clamp.Unlock_Sync();
            if ( result != 0 )
            {
                this.OccurVehicleAlarm( result );
                return result;
            }

            if ( this.refObjects.Conveyor.IsInverterError() )
                return 16;

            if ( this.refObjects.Conveyor.IsDetectedCenter() )
                return 9;

            if ( !this.refObjects.Conveyor.IsLifterPositinCheck() )
            {
                loggerPIO.E( "[Port] - Lift Position Check Error" );
                return 14;
            }

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVABLE", true );
            loggerPIO.I( "[Vehicle] - 4 Receivable" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 1 * ConstUtils.ONE_SECOND, "IN_PIO_SENDABLE" ) )
            {
                PIOClear();
                loggerPIO.E( "[Port] - 4 Ready Time Out" );
                TimerUtils.Once( 1000, this.OnFailReport, eFailCode.LoadPIOInterlockTimeout );
                //this.OnFailReport?.Invoke( eFailCode.LoadPIOInterlockTimeout );
                return 18;
            }
            loggerPIO.I( "[Port] - 4 Ready On" );

            //this.conveyor.SetConveyorSpeed( true );
            this.refObjects.Conveyor.OnOffConveyor( true, true );
            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECEIVE_RUN", true, 1000 ); //1Sec 이후 On
            loggerPIO.I( "[Vehicle] - Conveyor Run" );
            this.OnConveyorStart?.Invoke( true );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, pioTimeout, "IN_PIO_SEND_RUN" ) )
            {
                this.refObjects.Conveyor.OnOffConveyor( false, true );
                PIOClear();
                loggerPIO.E( "[Port] - 5 Sending Run Time Out" );
                return 18;
            }
            loggerPIO.I( "[Port] - 5 Sending Run On" );

            bool isStartDetected = false;
            var sTime = SwUtils.CurrentTimeMillis;
            while ( true )
            {
                LockUtils.Wait( 10 );

                if ( SwUtils.Gt( sTime, 20 * ConstUtils.ONE_SECOND ) )
                {
                    PIOClear();
                    this.refObjects.Conveyor.OnOffConveyor( false, true );
                    loggerPIO.E( "[Vehicle] Conveyor Wait Time Out" );
                    return 10; //Conveyor Time Out
                }

                if ( this.refObjects.Conveyor.IsDetectedLoadStart() && !isStartDetected )
                    isStartDetected = true;

                if ( !this.refObjects.Conveyor.IsDetectedLoadStart() && isStartDetected ) { }

                if ( this.refObjects.Conveyor.IsDetectedLoadStop() ) break;

                if ( this.refObjects.Conveyor.IsPIOInterLockOn() )
                {
                    PIOClear();
                    this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
                    loggerPIO.E( "[Port] PIO InterLock On " );
                    return 19; //
                }
            }

            this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
            PIOClear();
            loggerPIO.I( "[Vehicle] Conveyor Stop" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", true );
            loggerPIO.I( "[Vehicle] Receive Complete On" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, pioTimeout, "IN_PIO_SEND_COMPLITE" ) )
            {
                this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false );
                loggerPIO.E( "[Port]  IN_PIO_SEND_COMPLITE On Time Out" );
            }
            loggerPIO.I( "[Port] Send Complete On" );

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_RECIVE_COMPLITE", false, 1000 );

            loggerPIO.I( $"End Load PIO - [{this.CurrentTag}]" );

            result = this.refObjects.Clamp.Lock_Sync();
            if ( result != 0 )
                return result;

            return result;
        }

        public int ManualPIOAndUnlaod()
        {
            loggerPIO.I( $"Start Unload PIO -[{this.CurrentTag}]" );

            PIOClear();
            this.PIOSensorOn();

            int result = 0;

            var pioTimeout = Convert.ToInt32( this.refObjects.Sqlite.ConfigDal.GetById( ConstString.PIOTimeOut ).Value );

            if ( this.refObjects.Conveyor.IsInverterError() )
                return 16;

            if ( !this.refObjects.Conveyor.IsDetectedCenter() )
            {
                return 11;
            }

            if ( !this.refObjects.Conveyor.IsLifterPositinCheck() )
            {
                loggerPIO.E( "[Port] - Lift Position Check Error" );
                return 13;
            }

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 1 * ConstUtils.ONE_SECOND, "IN_PIO_READY" ) )
            {
                loggerPIO.E( "[Port] - 1 Ready not On" );
                return 17;
            }

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_READY", true );
            loggerPIO.I( "[Vehicle] - 1 Ready On" );

            if ( !this.refObjects.IO.WaitChangeInputIO( true, 3 * ConstUtils.ONE_SECOND, "IN_PIO_RECEIVE_RUN" ) )
            {
                PIOClear();
                loggerPIO.E( "[Port] - 2 Receive CV Run Timeout" );
                return 0;
            }
            loggerPIO.I( "[Port] - 2 Receive CV Run On" );

            result = this.refObjects.Clamp.Unlock_Sync();
            if ( result != 0 )
                return result;

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SENDING_RUN", true );
            loggerPIO.I( "[Vehicle] - 2 Send Run On" );

            this.refObjects.Conveyor.OnOffConveyor( true );

            var sTime = SwUtils.CurrentTimeMillis;
            while ( true )
            {
                if ( SwUtils.Gt( sTime, 20 * ConstUtils.ONE_SECOND ) )
                {
                    PIOClear();
                    this.refObjects.Conveyor.OnOffConveyor( false, true );
                    loggerPIO.E( "[Port] Conveyor Wait Time Out" );
                    return 12; //Conveyor Moving Timeout
                }

                if ( !this.refObjects.Conveyor.IsDetectedLoadStart() && !this.refObjects.Conveyor.IsDetectedCenter() )
                {
                    if ( this.refObjects.IO.IsOn( "IN_PIO_RECEIVE_COMPLITE" ) )
                    {
                        loggerPIO.I( "[Port] - 3 Receive Complete On" );
                        break;
                    }
                }
            }

            this.refObjects.Conveyor.OnOffConveyor( false ); //Stop
            PIOClear();

            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SEND_COMPLITE", true );
            LockUtils.Wait( 1000 );
            this.refObjects.IO.WriteOutputIO( "OUT_PIO_SEND_COMPLITE", false );
            loggerPIO.I( "[Vehicle] - 3 Send Complete OnOff" );
            loggerPIO.I( $"End Unload PIO - [{CurrentTag}]" );

            return result;
        }

        #endregion

        #endregion

        #region Help Method
        void AddCurrentDriveDistance()
        {
            var cD = refObjects.ZmqManager.GetDriveDistance();
            if (cD == 0)
                return;

            var info = refObjects.Sqlite.VehicleInfoDAL.GetAll().FirstOrDefault();
            if ((info.TripDistance += (cD * 0.001)) >= double.MaxValue)
            {
                info.TripDistance = 0d;
                logger.E("Trip Distance Limit Over - Zero Set!");
            }

            if ((info.CumulativeDistance += (cD * 0.001)) >= double.MaxValue)
            {
                info.CumulativeDistance = 0d;
                logger.E("Cumulative Distance Limit Over - Zero Set!");
            }

            refObjects.Sqlite.VehicleInfoDAL.Update(info);
        }

        Task taskHostConnection = null;
        /// <summary>
        /// Move 이후 OCS 연결을 확인 후 Disconnected 상태이면 5분 상태 확인 후 Alarm 발생.
        /// </summary>
        void CheckOCSConnectionState()
        {
            if ( this.taskHostConnection != null )
                return;

            if ( refObjects.HostManager.IsConnected )
                return;

            this.taskHostConnection = new Task( () =>
             {
                 long sTime = SwUtils.CurrentTimeMillis;
                 while ( !refObjects.HostManager.IsConnected )
                 {
                     LockUtils.Wait( 100 );

                     if ( SwUtils.Gt( sTime, 30 * ConstUtils.ONE_SECOND ) )
                     {
                         OccurVehicleAlarm( 43 );
                         break;
                     }
                 }
             } );

            this.taskHostConnection = null;
        }

        void BatteryChargeStateLED( double percent )
        {
            if ( percent > 60 )
            {
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_00", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_01", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_02", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_03", true );
            }
            else if ( percent > 45 )
            {
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_00", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_01", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_02", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_03", false );
            }
            else if ( percent > 30 )
            {
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_00", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_01", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_02", false );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_03", false );
            }
            else
            {
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_00", true );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_01", false );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_02", false );
                this.refObjects.IO.WriteOutputIO( "OUT_BATTERY_LED_03", false );
            }
        }

        /// <summary>
        /// 현재 Point 가 변경될때 장애물 감지 센서의 패턴을 변경한다.
        /// </summary>
        /// <param name="v"></param>
        private void ObstaclePatternChange( int v )
        {
            //2020.08.13. Kang 주행 중이 아닐때는 패턴 변경 안함.(나성권B 요청)
            if (this.refObjects.Drive.IsDriveStop())
                return;

            if ( !RouteManager.Instance.Segments.Any( s => s.ID == v ) )
            {
                logger.E( "Current Tag Not Exist RouteManager Point List" );
                return;
            }

            var obstacle = RouteManager.Instance.Obstacles.Where( o => o.segmentID == v ).Single();

            this.ChgObstacleDetectPattern( obstacle.fieldset );
            logger.D( $"[Obstacle Pattern Chg] - {obstacle.fieldset}" );
        }

        /// <summary>
        /// 현재 좌표 값이 등록된 Route 에 맞는 위치인지 확인한다.
        /// 판단 기준은 Route 에 Tolerance 범위를 사용.
        /// </summary>
        /// <param name="route"></param>
        /// <param name="currentPosition"></param>
        /// <returns></returns>
        bool CorrectPosition( Route route, double currentPosition )
        {
            var rScale = route.ScaleValue;
            var rTolerance = route.ScaleTolerance;
            var result = currentPosition - rScale;
            if ( rTolerance < Math.Abs( result ) )
                return false;

            return true;
        }

        /// <summary>
        /// if no is zero, Laser Off
        /// bit Off, On, On, On,On Area1
        /// </summary>
        /// <param name="no"> 0 == Off Laser</param>
        /// <returns></returns>
        public bool ChgObstacleDetectPattern( int no )
        {
            var bitArray = BitUtils.ChgBitArray( no );

            int bitIndex = 0;
            this.obstacleBitList.ForEach( b =>
             {
                 if ( bitArray[bitIndex] )
                     this.refObjects.IO.OutputOff( b );
                 else
                     this.refObjects.IO.OutputOn( b );
                 bitIndex++;
             } );

            ObstaclePattern = no;

            return true;
        }

        public int GetObstacleDetectPattern()
        {
            int bitIndex = 0;

            BitArray bitArray = new BitArray( this.obstacleBitList.Count );

            this.obstacleBitList.ForEach( b =>
             {
                 if ( this.refObjects.IO.IsOn( b, false ) )
                     bitArray.Set( bitIndex, false );
                 else
                     bitArray.Set( bitIndex, true );
                 bitIndex++;
             } );

            return BitUtils.ChgInt32( bitArray );
        }

        /// <summary>
        /// Vehicle 이동 및 동작 중 Alarm 발생 시 처리
        /// </summary>
        /// <param name="alarmID"></param>
        public void OccurVehicleAlarm( int alarmID )
        {
            logger.D($"[{this.GetType().Name}] - Occur Alarm Method- {alarmID}");

            var alarm = refObjects.Alarms.FirstOrDefault( x=>x.AlarmId == alarmID );
            if ( alarm != null )
            {
                if ( alarm.Level == eAlarmLevel.Fault )
                {
                    this.MachineMode = eMachineMode.LocalMode;
                    this.VehicleStateProperty = eVehicleState.Abnormal;
                    this.ConveyorOff();
                }
            }

            this.refObjects.AutoManager.ProcessAlarm( alarmID );
        }

        public void SetObstaclePattern( ObstacleControlEventArgs.eControlKind state, int value )
        {
            if ( state == ObstacleControlEventArgs.eControlKind.DRIVE )
            {
                this.ObstacleDrive = value;
                ChgObstacleDetectPattern( this.ObstacleDrive );
            }
            else if ( state == ObstacleControlEventArgs.eControlKind.CURVE )
            {
                this.ObstacleCurve = value;
                ChgObstacleDetectPattern( this.ObstacleCurve );
            }
            else
                return;
        }

        public eSteeringState GetESteeringState() => this.refObjects.Steering.GetSteeringState();
        #endregion

        #region Event Subscribe 
        private void BMUManager_OnDisconnect( string obj )
        {
            this.BatteryIsConnect = false;
            this.OccurVehicleAlarm( 32 );
        }

        private void BMUManager_OnConnect( string obj )
        {
            this.BatteryIsConnect = true;
            //ReqCurrentPos();
        }

        private void BMUManager_OnFirstColtd( List<ReceivedData> obj )
        {
        }

        private void BMUManager_OnChangedReceivedData( Serial.DataModel.ReceivedData obj )
        {
            var kind = CastTo<eDataKind>.From<Enum>( obj.DataKind );
            switch ( kind )
            {
                case eDataKind.Voltage:
                    this.BatteryVoltage = (double)obj.Value;
                    break;

                case eDataKind.Current:
                    this.BatteryCurrent = (double)obj.Value;
                    //if ( BatteryCurrent > 3 && IsChargeCylinderForword() )
                    //    this.BatteryChargeState = true;
                    //else
                    //    this.BatteryChargeState = false;
                    break;

                case eDataKind.BatteryState:
                    this.BatteryState = (double)obj.Value;
                    break;

                case eDataKind.ChargeCompleteTime:
                    this.BatteryChargeTime = (double)obj.Value;
                    break;

                case eDataKind.DisChargeCompleteTime:
                    this.BatteryDisChargeTime = (double)obj.Value;
                    break;

                case eDataKind.SOC:
                    this.BatteryStateOfCharge = (double)obj.Value;
                    break;

                case eDataKind.SOH:
                    this.BatteryStateOfHealth = (double)obj.Value;
                    break;

                case eDataKind.ResidualCapacity:
                    this.BatteryCapacity = (double)obj.Value;
                    break;

                case eDataKind.ResidualEnergy:
                    this.BatteryEnergy = (double)obj.Value;
                    break;

                case eDataKind.Temperature:
                    this.BatteryTemperature = (double)obj.Value;
                    break;

                default:
                    break;
            }
        }

        private void AutoManager_OnOperationModeChanged( eOperatationMode obj )
        {
            //this.refObjects.Drive.SetDriveOperationMode(obj);
        }

        private void ZmqManager_PropertyChanged( object sender, System.ComponentModel.PropertyChangedEventArgs e )
        {
            var property = sender.GetType().GetProperty( e.PropertyName );
            var newValue = property.GetValue( sender, null );

            switch ( e.PropertyName )
            {
                case "SegmentID":
                    {
                        var v = CastTo<int>.From<object>( newValue );
                        this.ObstaclePatternChange( v );
                    }
                    break;

                case "RequestSteering":
                    {
                        var v = CastTo<eSteeringState>.From<object>( newValue );
                        switch ( v )
                        {
                            case eSteeringState.None:
                                break;
                            case eSteeringState.Left:
                                this.refObjects.Steering.RequestControl( eSteeringState.Left );
                                break;
                            case eSteeringState.Right:
                                this.refObjects.Steering.RequestControl( eSteeringState.Right );
                                break;
                            default:
                                break;
                        }
                        logger.D( $"[Request Steering] - {v}" );
                    }
                    break;

                case "CurrentPointNo":
                    {
                        var v = CastTo<int>.From<object>( newValue );
                        logger.D( $"{this.CurrentTag} -> {v}" );
                        this.CurrentTag = v;
                    }
                    break;

                case "CurrentMCR":

                    break;

                case "RearDriveState":
                    {
                        this.RearDriveState = CastTo<DriveState>.From<object>( newValue );
                    }
                    break;

                case "FrontLoadFactor":
                    {
                        this.FrontLoadFactor = CastTo<double>.From<object>( newValue );
                        this.FrontTorque = Math.Truncate( ( ( FrontLoadFactor * 1.9 ) / 1000 ) * 100 ) / 100;
                    }
                    break;

                case "FrontRPM":
                    {
                        this.FrontRpm = CastTo<double>.From<object>( newValue );

                        var ll = ( ( ( ( FrontRpm / 60 ) * ( 2 * Math.PI ) ) * 0.06 ) / 10 );
                        this.FrontSpeed = Math.Truncate( ll * 100 ) / 100;
                    }
                    break;

                case "RearLoadFactor":
                    {
                        this.RearLoadFactor = CastTo<double>.From<object>( newValue );
                        this.RearTorque = Math.Truncate( ( ( RearLoadFactor * 1.9 ) / 1000 ) * 100 ) / 100;
                    }
                    break;

                case "RearRPM":
                    {
                        this.RearRpm = CastTo<double>.From<object>( newValue );

                        var ll = ( ( ( ( RearRpm / 60 ) * ( 2 * Math.PI ) ) * 0.06 ) / 10 );
                        this.RearSpeed = Math.Truncate( ll * 100 ) / 100;
                    }
                    break;

                case "IsReqConnected":
                    {

                        var isConnected = CastTo<bool>.From<object>( newValue );
                        if ( !isConnected )
                            OccurVehicleAlarm( 44 );
                    }
                    break;


                //case "LinearSpeed":
                //    {
                //        this.LinearSpeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "CurveSpeed":
                //    {
                //        this.CurveSpeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "JogSPeed":
                //    {
                //        this.JogSPeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "AccelSpeed":
                //    {
                //        this.AccelSpeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "DecelSpeed":
                //    {
                //        this.DecelSpeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "CreepSpeed":
                //    {
                //        this.CreepSpeed = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "CreepDistance":
                //    {
                //        this.CreepDistance = CastTo<double>.From<object>(newValue);
                //    }
                //    break;
                //case "IsCanStanbyLocation":
                //    this.IsCanStanbyLocation = CastTo<bool>.From<object>(newValue);
                //    break;
                default:
                    break;
            }
        }

        private void Motion_PropertyChanged( object sender, System.ComponentModel.PropertyChangedEventArgs e )
        {
            var property = sender.GetType().GetProperty( e.PropertyName );
            var newValue = property.GetValue( sender, null );

            switch ( e.PropertyName )
            {
                case "CurrentPos":
                    {
                        var v = CastTo<double>.From<object>( newValue );
                        this.CurrentPosition = v;
                    }
                    break;
                //case "CurrentTag":
                //    {
                //        var v = CastTo<int>.From<object>( newValue );
                //        logger.D( $"{this.CurrentTag} -> {v}" );
                //        this.CurrentTag = v;
                //    }
                //    break;
                case "CurrentSpeed":
                    {
                        var v = CastTo<double>.From<object>( newValue );
                        this.CurrentSpeed = v;
                    }
                    break;
                case "CurrentTorque":
                    {
                        var v = CastTo<double>.From<object>( newValue );
                        this.CurrentTorque = v;
                    }
                    break;
                case "ReqSteeringState":
                    //{
                    //    var v = CastTo<eSteeringState>.From<object>( newValue );
                    //    switch ( v )
                    //    {
                    //        case eSteeringState.None:
                    //            break;
                    //        case eSteeringState.Left:
                    //            this.refObjects.Steering.ControlSteering( true );
                    //            break;
                    //        case eSteeringState.Right:
                    //            this.refObjects.Steering.ControlSteering();
                    //            break;
                    //        default:
                    //            break;
                    //    }
                    //}
                    break;
                case "DriveServoState":
                    {
                        var v = CastTo<eDriveServoState>.From<object>( newValue );
                        if ( v == eDriveServoState.ServoOn )
                            this.refObjects.IO.OutputOn( "OUT_DRIVE_BRAKE_OFF" );
                        else
                            this.refObjects.IO.OutputOff( "OUT_DRIVE_BRAKE_OFF" );
                    }
                    break;
                case "FrontDriveState":
                    {
                        var v = CastTo<DriveState>.From<object>( newValue );
                        this.FrontDriveState = v;
                    }
                    break;
                case "RearDriveState":
                    {
                        var v = CastTo<DriveState>.From<object>( newValue );
                        this.RearDriveState = v;
                    }
                    break;
                default:
                    break;
            }
        }

        private void Steering_PropertyChanged( object sender, System.ComponentModel.PropertyChangedEventArgs e )
        {
            var property = sender.GetType().GetProperty( e.PropertyName );
            var newValue = property.GetValue( sender, null );

            //Todo: 나중에 Test 하자
            //var ownPropperty = this.GetType().GetProperty(e.PropertyName);
            if ( e.PropertyName.Equals( "SteeringState" ) )
            {
                var v = CastTo<eSteeringState>.From<object>( newValue );
                this.SteeringState = v;
                logger.D( $"steering - {v}" );
            }
        }

        private void Clamp_PropertyChanged( object sender, System.ComponentModel.PropertyChangedEventArgs e )
        {
            var property = sender.GetType().GetProperty( e.PropertyName );
            var newValue = property.GetValue( sender, null );

            if ( e.PropertyName.Equals( "ClampState" ) )
            {
                var v = CastTo<eClampState>.From<object>( newValue );
                this.ClampState = v;
            }
        }

        private void IO_OnChangedIO( BitBlock bit )
        {
            switch ( bit.Tag )
            {
                case "IN_CV_DETECT_01":
                    this.IsContain = bit.IsBitOn;
                    this.refObjects.ZmqManager.Publish( "Contain", this.IsContain.ToString() );
                    break;

                case "IN_MC_ON":
                    if ( bit.IsBitOn )
                    {
                        if (!this.refObjects.IO.IsOn("IN_EMS_SW") && this.refObjects.IO.IsOn("IN_CP_ON_SAFETY") && this.refObjects.IO.IsOn("IN_CP_ON_24V"))
                        {
                            //this.VehicleStateProperty = eVehicleState.Idle;
                        }
                    }
                    else
                    {
                        if ( this.ObstacleStateProperty == eObstacleState.Abnormal )
                            this.OccurVehicleAlarm( 42 );
                        else
                            this.OccurVehicleAlarm( 29 );
                    }
                    break;

                case "IN_EMS_SW":
                    if ( bit.IsBitOn )
                        this.OccurVehicleAlarm( 28 );
                    break;

                case "IN_CP_ON_SAFETY":
                    if ( !bit.IsBitOn )
                        this.OccurVehicleAlarm( 31 );
                    break;

                case "IN_CP_ON_24V":
                    if ( !bit.IsBitOn )
                        this.OccurVehicleAlarm( 30 );
                    break;


                case "IN_OBSTRUCTION_DETECT_ERROR":
                case "IN_OBSTRUCTION_DETECT_SAFETY":
                case "IN_OBSTRUCTION_DETECT_STOP":
                case "IN_OBSTRUCTION_DETECT_SLOW":
                    CheckObstacle();
                    break;

                case "IN_BUMPER_DETECT":
                    if ( bit.IsBitOn )
                        this.refObjects.ZmqManager.SetSafetyBumper();
                    break;

                case "IN_CHARGE_CYL_FWD_DETECT":
                    if ( bit.IsBitOn )
                        this.BatteryChargeState = true;
                    else
                        this.BatteryChargeState = false;
                    break;

                case "IN_VEHICLE_FRONT_DETECT":
                    this.refObjects.ZmqManager.SetFrontDetectedVehicle(bit.IsBitOn);
                    break;

                case "IN_F_STEERING_DETECT_LEFT":
                case "IN_F_STEERING_DETECT_RIGHT":
                case "IN_R_STEERING_DETECT_LEFT":
                case "IN_R_STEERING_DETECT_RIGHT":
                    var frontLeft = this.refObjects.IO.IsOn("IN_F_STEERING_DETECT_LEFT");
                    var frontRight = this.refObjects.IO.IsOn("IN_F_STEERING_DETECT_RIGHT");
                    var rearLeft = this.refObjects.IO.IsOn("IN_R_STEERING_DETECT_LEFT");
                    var rearRight = this.refObjects.IO.IsOn("IN_R_STEERING_DETECT_RIGHT");

                    this.refObjects.ZmqManager.SetSteerDetectSensorState(frontLeft, frontRight, rearLeft, rearRight);
                    logger.D($"[STEERING DETECTED] - {bit.Tag} / {bit.IsBitOn}");
                    break;

                default:
                    break;
            }
        }

        private void Steering_OnSteeringError( object sender, int e )
        {
            if ( e != 0 )
            {
                logger.E( $"[Steering] - Control Error {e}" );
                this.OccurVehicleAlarm( e );
            }
            else
            {
                var msg = new DriveControlEventArgs()
                {
                    EventDir = DriveControlEventArgs.eEventDir.ToFront,
                    ControlKind = DriveControlEventArgs.eControlKind.Steering,
                    Result = FluentResults.Results.Ok<DriveControlEventArgs.eMoveDir>( DriveControlEventArgs.eMoveDir.LEFT ),
                };

                this.eventAggregator.GetEvent<DriveControlPubSubEvent>().Publish( msg );
            }

        }

        #endregion
    }
}