using CodeLibrary;
using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms.VisualStyles;

namespace OnlineStore.DeviceLibrary
{
    partial class BoxEquip
    {
        protected override bool CheckWaitResult(DeviceMoveInfo moveInfo, WaitResultInfo wait)
        {
            return false;
        }
        
        //public bool InputMiddleAxisCanMove()
        //{
        //    if()
        //    return false;
        //}
        /// <summary>
        /// 忽略相机检测到的抽屉误差误差
        /// </summary>
        public void SetIgnoreCamDect()
        {
            if (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore))
            {
                IgnoreCamDect = true;
            }
        }
        /// <summary>
        /// 检查当前面是否A面
        /// </summary>
        /// <returns></returns>
        private bool CheckASide()
        {
            if (MoveInfo.MoveParam.PosInfo.GetPosSide().Equals("A"))
                return true;
            return false;
        }
        /// <summary>
        /// 检查当前面是否A面
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool CheckASide(InOutParam param)
        {
            if (param.PosInfo.GetPosSide().Equals("A"))
                return true;
            return false;
        }
        #region 行走机构
        /// <summary>
        /// 行走机构到待机点P1
        /// </summary>
        private void MoveAxisToP1()
        {
            if (!MoveAxis.IsInPosition(MoveInfo.MoveParam.MoveP.MoveAxis_P1))
                MoveAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.MoveAxis_P1, Config.MoveAxis_P1_Speed);
        }
        /// <summary>
        /// 行走机构到进出料机构取放点P2
        /// </summary>
        private void MoveAxisToP2()
        {
            MoveAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.MoveAxis_P2, Config.MoveAxis_P2_Speed);
        }
        /// <summary>
        /// 行走机构到存储库位取放点位P3
        /// </summary>
        private void MoveAxisToP3()
        {
            MoveAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.MoveAxis_P3, Config.MoveAxis_P3_Speed);
        }
        #endregion
        #region 料屉拉取进出轴
        /// <summary>
        /// 料斗拉取进出轴到料屉库位点P3/P5
        /// </summary>
        private void PullAxis_Inout_To_P3_P5()
        {
            if (CheckASide())
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P3_P5, Config.PullAxis_Inout_P3_Speed);
            }
            else
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P3_P5, Config.PullAxis_Inout_P5_Speed);
            }
        }
        /// <summary>
        /// 料斗拉取进出轴到料屉提取点P2/P4
        /// </summary>
        private void PullAxis_Inout_To_P2_P4()
        {
            if (CheckASide())
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P2_Speed);
            }
            else
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P4_Speed);
            }
        }
        private void PullAxis_Inout_To_P1()
        {
            PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P1, Config.PullAxis_Inout_P1_Speed);
        }
        #region 移栽升降轴
        /// <summary>
        /// 移栽升降轴到料屉取放点P7/P13
        /// </summary>
        private void UpdownAxisToP7_P13()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P7_P13, Config.Updown_P7_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P7_P13, Config.Updown_P13_Speed);
            }
        }

        /// <summary>
        /// 移栽升降轴到料屉上方过渡点P6/P12
        /// </summary>
        private void UpdownAxisTo_P6_P12()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P6_P12, Config.Updown_P6_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.Updown_P6_P12, Config.Updown_P12_Speed);
            }
        }
        /// <summary>
        /// 移栽升降轴到下暂存区放料高点P4/P10
        /// </summary>
        private void UpdownAxisTo_P4_P10()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P4, Config.Updown_P4_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P10, Config.Updown_P10_Speed);
            }
        }
        /// <summary>
        /// 移栽升降轴到上暂存区取料高点P2/P8
        /// </summary>
        private void UpdownAxisTo_P2_P8()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P2, Config.Updown_P2_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P8, Config.Updown_P8_Speed);
            }
        }
        /// <summary>
        /// 移栽升降轴到上暂存区取料低点P3/P9
        /// </summary>
        private void UpdownAxisTo_P3_P9()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P3, Config.Updown_P3_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P9, Config.Updown_P9_Speed);
            }
        }
        /// <summary>
        /// 移栽升降轴到下暂存区放料低点P5/P11
        /// </summary>
        private void UpdownAxisTo_P5_P11()
        {
            if (CheckASide())
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P5, Config.Updown_P5_Speed);
            }
            else
            {
                UpdownAxis.AbsMove(MoveInfo, Config.Updown_P11, Config.Updown_P11_Speed);
            }
        }
        #endregion

        #region 移栽X轴
        /// <summary>
        /// AB面移栽X轴到进出料暂存区取放点P2
        /// </summary>
        private void XAxis_To_P2()
        {
            if (CheckASide())
            {
                XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P2, Config.XAxis_A_P2_Speed);
            }
            else
            {
                XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P2, Config.XAxis_B_P2_Speed);
            }
        }
        /// <summary>
        /// AB面移栽X轴到料屉库位取放料点P3
        /// </summary>
        private void XAxis_To_P3()
        {
            if (CheckASide())
            {
                XAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.XAxis_AB_P3, Config.XAxis_A_P3_Speed);
            }
            else
            {
                XAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.XAxis_AB_P3, Config.XAxis_B_P3_Speed);
            }
        }       
        /// <summary>
        /// AB面移栽X轴到待机点
        /// </summary>
        private void XAxis_To_P1()
        {
            if (CheckASide())
            {
                if (!XAxis_A.IsInPosition(Config.XAxis_A_P1))
                    XAxis_A.AbsMove(MoveInfo, Config.XAxis_A_P1, Config.XAxis_A_P1_Speed);
            }
            else
            {
                if (!XAxis_B.IsInPosition(Config.XAxis_B_P1))
                    XAxis_B.AbsMove(MoveInfo, Config.XAxis_B_P1, Config.XAxis_B_P1_Speed);
            }
        }
        #endregion

        #region 压紧轴
        /// <summary>
        /// AB移栽压紧轴到压紧前点P2
        /// </summary>
        private void ComAxis_To_P2()
        {
            if (CheckASide())
            {
                ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_A_P2_Speed);
            }
            else
            {
                ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P2, Config.ComAxis_B_P2_Speed);
            }
        }
        /// <summary>
        /// AB移栽压紧轴到压紧点P3
        /// </summary>
        private void ComAxis_To_P3()
        {
            if (CheckASide())
            {
                ComAxis_A.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P3, Config.ComAxis_A_P3_Speed);
            }
            else
            {
                ComAxis_B.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.ComAxis_AB_P3, Config.ComAxis_B_P3_Speed);
            }
        }
        #endregion
        #region 料屉拉取升降轴
        /// <summary>
        /// 抽屉待机点
        /// </summary>
        private void PullAxis_UpdownToP1()
        {
            PullAxis_Updown.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Updown_P1, Config.PullAxis_Updown_P1_Speed);
        }
        /// <summary>
        /// 抽屉高点，料斗拉取升降轴到料屉提取高点P3
        /// </summary>
        private void PullAxis_UpdownToHighP3()
        {
            PullAxis_Updown.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Updown_P3, Config.PullAxis_Updown_P3_Speed);
        }
        /// <summary>
        /// 抽屉水平点，料斗拉取升降轴到料屉水平点P2
        /// </summary>
        private void PullAxis_UpdownToMiddleP2()
        {
            PullAxis_Updown.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Updown_P2, Config.PullAxis_Updown_P2_Speed);
        }
        /// <summary>
        /// 抽屉低点，料斗拉取升降轴到料屉提取低点P4
        /// </summary>
        private void PullAxis_UpdownToLowP4()
        {
            PullAxis_Updown.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Updown_P4, Config.PullAxis_Updown_P4_Speed);
        }
        #endregion

        #region 旋转轴
        /// <summary>
        /// AB面移栽旋转轴到料屉库位垂直取放料点P3
        /// </summary>
        private void MiddleAxis_To_P3()
        {
            if (CheckASide())
            {
                MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P3, Config.MiddleAxis_A_P3_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitAxisOrg(MiddleAxis_A.Config, IO_VALUE.HIGH));
            }
            else
            {
                MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P3, Config.MiddleAxis_B_P3_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitAxisOrg(MiddleAxis_B.Config, IO_VALUE.HIGH));
            }
        }
        /// <summary>
        /// AB面移栽旋转轴到水平点P2
        /// </summary>
        private void MiddleAxis_To_P2()
        {
            if (CheckASide())
            {
                MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P2, Config.MiddleAxis_A_P2_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.AHorizontal_Check, IO_VALUE.HIGH));
            }
            else
            {
                MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P2, Config.MiddleAxis_B_P2_Speed);
                MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.BHorizontal_Check, IO_VALUE.HIGH));
            }
        }
        /// <summary>
        /// AB面移栽旋转轴到点P1
        /// </summary>
        private void MiddleAxis_To_P1()
        {
            if (CheckASide())
            {
                MiddleAxis_A.AbsMove(MoveInfo, Config.MiddleAxis_A_P1, Config.MiddleAxis_A_P1_Speed);
            }
            else
            {
                MiddleAxis_B.AbsMove(MoveInfo, Config.MiddleAxis_B_P1, Config.MiddleAxis_B_P1_Speed);
            }
        }
        #endregion

        /// <summary>
        /// 到抽屉提取点，料斗拉取进出轴到P2（A/B面料屉提取点）
        /// </summary>
        private void ToTray()
        {
            if (CheckASide())
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P2_Speed);
            }
            else
            {
                PullAxis_Inout.AbsMove(MoveInfo, MoveInfo.MoveParam.MoveP.PullAxis_Inout_P2_P4, Config.PullAxis_Inout_P4_Speed);
            }
        }

        /// <summary>
        /// 获取当前位置
        /// </summary>
        /// <param name="PosId"></param>
        /// <returns>true表示抽屉挂在轴上</returns>
        private bool GetCurLocation()
        {
            int row = 1;
            int col = 1;
            string side = "BB";
            string PosId = "05BB01010101";
            for (int i = 1; i <= trayRows.Length; i++)
            {
                if (i == trayRows.Length)
                    break;
                if (IOValue(trayRows[i]).Equals(IO_VALUE.HIGH))
                {
                    LogUtil.info($"复位 检测到料屉在第{i}层");
                    row = i;
                    break;
                }
            }
            bool atBside = false;
            for (int i = 1; i <= trayBColumns.Length; i++)
            {
                if (i == trayBColumns.Length)
                    break;
                if (GetShieldState(sheidBColmns[i]))
                    continue;
                if (IOValue(trayBColumns[i]).Equals(IO_VALUE.LOW))//&& PullAxis_Inout.GetAclPosition()<=Config.PullAxis_Inout_P1
                {
                    LogUtil.info($"复位 检测到料屉在B面");
                    side = "BB";
                    atBside = true;
                    col = i;
                    PosId = $"05{side}{row.ToString().PadLeft(2, '0')}{col.ToString().PadLeft(2, '0')}0101";
                    return true;
                }
            }
            if (!atBside)
            {
                for (int i = 1; i <= trayAColumns.Length; i++)
                {
                    if (i == trayBColumns.Length)
                        break;
                    if (GetShieldState(sheidAColmns[i]))
                        continue;
                    if (IOValue(trayAColumns[i]).Equals(IO_VALUE.LOW))//&& PullAxis_Inout.GetAclPosition() >= Config.PullAxis_Inout_P1
                    {
                        LogUtil.info($"复位 检测到料屉在A面");
                        side = "AA";
                        col = i;
                        PosId = $"05{side}{row.ToString().PadLeft(2, '0')}{col.ToString().PadLeft(2, '0')}0101";
                        return true;
                    }
                }
            }
            PosId = $"05{side}{row.ToString().PadLeft(2, '0')}{col.ToString().PadLeft(2, '0')}0101";
            MoveInfo.MoveParam = new InOutParam(new InOutPosInfo("Reset", PosId));
            MoveInfo.MoveParam.MoveP = new LineMoveP(Config, MoveInfo.MoveParam.PosInfo.PosId);
            return false;
        }
        /// <summary>
        /// 获取列屏蔽状态
        /// </summary>
        /// <param name="name"></param>
        /// <returns>true表示屏蔽</returns>
        private bool GetShieldState(string name)
        {
            int res = 0;
            switch (name)
            {
                case "A_Col1_Sig_Shield":
                    res = Config.A_Col1_Sig_Shield;
                    break;
                case "A_Col2_Sig_Shield":
                    res = Config.A_Col2_Sig_Shield;
                    break;
                case "A_Col3_Sig_Shield":
                    res = Config.A_Col3_Sig_Shield;
                    break;
                case "A_Col4_Sig_Shield":
                    res = Config.A_Col4_Sig_Shield;
                    break;
                case "A_Col5_Sig_Shield":
                    res = Config.A_Col5_Sig_Shield;
                    break;
                case "A_Col6_Sig_Shield":
                    res = Config.A_Col6_Sig_Shield;
                    break;
                case "B_Col1_Sig_Shield":
                    res = Config.B_Col1_Sig_Shield;
                    break;
                case "B_Col2_Sig_Shield":
                    res = Config.B_Col2_Sig_Shield;
                    break;
                case "B_Col3_Sig_Shield":
                    res = Config.B_Col3_Sig_Shield;
                    break;
                case "B_Col4_Sig_Shield":
                    res = Config.B_Col4_Sig_Shield;
                    break;
                case "B_Col5_Sig_Shield":
                    res = Config.B_Col5_Sig_Shield;
                    break;
                case "B_Col6_Sig_Shield":
                    res = Config.B_Col6_Sig_Shield;
                    break;
            }
            LogInfo(string.Format("列信号屏蔽状态：{0}={1}", name, res == 0 ? "屏蔽" : "开启"));
            return res == 0 ? true : false;
        }
        #endregion
        /// <summary>
        /// 设置料仓状态
        /// </summary>
        /// <param name="deviceStatus">设备上报服务端的状态</param>
        /// <param name="runStatus">设备显示的状态</param>
        private void SetBoxStatus(DeviceStatus deviceStatus, RunStatus runStatus, string lastPosId = "")
        {
            if (!string.IsNullOrEmpty(lastPosId))
                this.lastPosId = lastPosId;
            this.deviceStatus = deviceStatus;
            this.runStatus = runStatus;
        }
        private void PullAxisToP1(string InOutType = "入库")
        {
            if (!PullAxis_Updown.IsInPosition(Config.PullAxis_Updown_P1))
            {
                PullAxis_Updown.AbsMove(MoveInfo, Config.PullAxis_Updown_P1, Config.PullAxis_Updown_P1_Speed);
            }
            if (!PullAxis_Inout.IsInPosition(Config.PullAxis_Inout_P1))
            {
                PullAxis_Inout.AbsMove(MoveInfo, Config.PullAxis_Inout_P1, Config.PullAxis_Inout_P1_Speed);
            }
            if (MoveInfo.MoveStep.Equals(StepEnum.SI_00_StartInstore))
            {
                MoveInfo.NextMoveStep(StepEnum.SI_01_PullAxis_Ready);
            }
            else if (MoveInfo.MoveStep.Equals(StepEnum.SO_00_StartOutstore))
            {
                MoveInfo.NextMoveStep(StepEnum.SO_01_PullAxis_Ready);
            }
            LogInfo($"{InOutType} {MoveInfo.SLog}：料屉拉取升降轴、料屉拉取进出轴到待机点P1");
        }
        /// <summary>
        /// 判断行走机构是否在安全位置
        /// </summary>
        /// <returns></returns>
        public bool IsMoveAxisInSafePos()
        {
            if (MoveAxis.GetAclPosition() >= Config.MoveAxis_SafePos)
                return true;
            return false;
        }
        private bool UpdownAxisCanMove()
        {
            return false;
        }
        #region 相机检查库位
        /// <summary>
        /// 检查抽屉是否偏位
        /// </summary>
        /// <returns></returns>
        private bool CamCheckReelPosition()
        {
            if (IgnoreCamDect)
            {
                return true;
            }
            Bitmap bitmap = AcqImage(CamPosSide(MoveInfo.MoveParam.PosInfo.PosId));
            int res = AutoFindPos.GetMarkInfo(bitmap, $"{MoveInfo.MoveParam.PosInfo.PosId.Substring(0, 4)}", $"row{autoFindPos.CurRow}_col{autoFindPos.CurColumn}", out ocsFXYR);
            if (res == 0)
            {
                LogInfo($"相机检查库位 {MoveInfo.SLog}：取图并检查Mark点[{MoveInfo.MoveParam.PosInfo.PosId}]");
            }
            else if (res == -4)
            {
                SetWarnMsg($"相机检查库位异常[code={res}]，未找到Mark点。库位号:{MoveInfo.MoveParam.PosInfo.PosId}");
                CamDetectError = true;
                return false;
            }
            else
            {
                SetWarnMsg($"相机检查库位异常[code={res}]，未找到Mark点。库位号:{MoveInfo.MoveParam.PosInfo.PosId}");
                CamDetectError = true;
                return false;
            }

            if (Math.Abs(Config.Drawer_X - ocsFXYR.fX) < Config.Drawer_X_Error && Math.Abs(Config.Drawer_Y - ocsFXYR.fY) < Config.Drawer_Y_Error)
            {
                CamDetectError = false;
                return true;
            }
            else
            {
                SetWarnMsg($"相机检查库位异常 {MoveInfo.SLog}：Mark点Y轴坐标{ocsFXYR.fY},模板Mark点Y轴坐标{Config.Drawer_Y},Y轴偏差{(Config.Drawer_Y - ocsFXYR.fY)};" +
                    $"Mark点X轴坐标{ ocsFXYR.fX},模板Mark点X轴坐标{ Config.Drawer_X},X轴偏差{ (Config.Drawer_X - ocsFXYR.fX)}，");
            }
            CamDetectError = true;
            return false;
        }
        #endregion
        #region 入库
        private DateTime startInStoreTime = DateTime.Now;
        public override bool StartInstore(InOutParam param)
        {
            if (isInSuddenDown || isNoAirpressure_Check ||
           (!runStatus.Equals(RunStatus.Runing))
           || (!MoveInfo.MoveType.Equals(MoveType.None)))
            {
                LogUtil.error(Name + " 启动入库出错，忙碌或报警中 ，storeStatus=" + runStatus + ",MoveType=" + MoveInfo.MoveType + ",isInSuddenDown=" + isInSuddenDown + ",isNoAirpressure_Check=" + isNoAirpressure_Check);
                return false;
            }
            if (!PreInStoreCheck(param))
            {
                return false;
            }
            startInStoreTime = DateTime.Now;
            LogInfo(" 启动入库【" + param.PosInfo.ToStr() + "】 ");
            param.MoveP = new LineMoveP(Config, param.PosInfo.PosId);
            LogInfo("LoadInoutParam:" + JsonHelper.SerializeObject(param.MoveP));
            MoveInfo.NewMove(MoveType.InStore, param);
            IgnoreCamDect = false;
            SetBoxStatus(DeviceStatus.InStoreExecute, RunStatus.Busy, param.PosInfo.PosId);
            MoveInfo.NextMoveStep(StepEnum.SI_00_StartInstore);
            return true;
        }

        private bool InDoorCheck(InOutParam param)
        {
            if (param.PosInfo == null)
                return false;
            if (CheckASide(param))
            {
                if (IOValue(IO_Type.UpperArea_Check_A).Equals(IO_VALUE.HIGH) && param.PosInfo != null)
                {
                    return true;
                }
            }
            else
            {
                if (IOValue(IO_Type.UpperArea_Check_B).Equals(IO_VALUE.HIGH) && param.PosInfo != null)
                {
                    return true;
                }
            }

            return false;
        }

        protected override void InstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            InstoreExecute();
        }
        #endregion

        #region 出库
        /// <summary>
        /// 出库前验证
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        private bool OutDoorCheck(InOutParam param)
        {
            if (param.PosInfo == null)
                return false;
            if (param.PosInfo.GetPosSide().Equals("A"))//A面
            {
                if (CheckAOutDoor())
                {
                    return true;
                }
            }
            else if (param.PosInfo.GetPosSide().Equals("B"))//B面
            {
                if (CheckBOutDoor())
                {
                    return true;
                }
            }

            return false;
        }
        /// <summary>
        /// 检查A出料口状态
        /// </summary>
        /// <returns>true:A口可以出料</returns>
        private bool CheckAOutDoor()
        {
            if (BufferDataManager.AOutStoreInfo == null && IOValue(IO_Type.UnderArea_Check_A).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 检查B出料口状态
        /// </summary>
        /// <returns>true:B口可以出料</returns>
        private bool CheckBOutDoor()
        {
            if (BufferDataManager.BOutStoreInfo == null && IOValue(IO_Type.UnderArea_Check_B).Equals(IO_VALUE.LOW))
            {
                return true;
            }
            return false;
        }
        private static object outStoreObject = new object();
        public void StartExecuctOut(InOutParam param)
        {
            bool result = false;
            result = StartOutstore(param);
            if (!result)
            {
                lock (outStoreObject)
                {
                    if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.MoveParam.PosInfo.PosId.Equals(param.PosInfo.PosId))
                    {
                        LogUtil.error(Name + " 出库命令【" + param.PosInfo.ToStr() + "】重复，【" + MoveInfo.MoveParam.PosInfo.PosId + "】出库执行中");
                        return;
                    }

                    List<InOutParam> reviceList = new List<InOutParam>();
                    reviceList.AddRange(waitAOutStoreList);
                    reviceList.AddRange(waitBOutStoreList);
                    reviceList = (from m in reviceList where m.PosInfo.PosId.Equals(param.PosInfo.PosId) select m).ToList<InOutParam>();
                    if (reviceList.Count == 0)
                    {
                        LogInfo(" 执行出库【" + param.PosInfo.ToStr() + "】失败，加入等待队列");
                        if (param.PosInfo.GetPosSide().Equals("A"))
                        {
                            waitAOutStoreList.Enqueue(param);
                        }
                        else if (param.PosInfo.GetPosSide().Equals("B"))
                        {
                            waitBOutStoreList.Enqueue(param);
                        }
                    }
                }
            }
        }
        private DateTime startOutStoreTime = DateTime.Now;
        public override bool StartOutstore(InOutParam param)
        {
            if (!OutDoorCheck(param))
            {
                return false;
            }
            if (isInSuddenDown || isNoAirpressure_Check
                || !runStatus.Equals(RunStatus.Runing)
                || !MoveInfo.MoveType.Equals(MoveType.None))
            {
                SetWarnMsg(Name + " 启动出库【" + param.PosInfo.ToStr() + "】失败，忙碌或报警中 ，storeStatus：" + runStatus + ",MoveType：" + MoveInfo.MoveType + ",isInSuddenDown：" + isInSuddenDown + ",isNoAirCheck：" + isNoAirpressure_Check);
                return false;
            }

            if (!param.PosInfo.CheckPosition())
            {
                SetWarnMsg(Name + " 启动出库【" + param.PosInfo.ToStr() + "】出错，找不到库位信息");
                return false;
            }
            startOutStoreTime = DateTime.Now;
            param.MoveP = new LineMoveP(Config, param.PosInfo.PosId);
            SetBoxStatus(DeviceStatus.OutStoreExecute, RunStatus.Busy, param.PosInfo.PosId);
            MoveInfo.NewMove(MoveType.OutStore, param);
            LogInfo("启动出库【" + param.PosInfo.ToStr() + "】  ");
            LogInfo("LoadInoutParam:" + JsonHelper.SerializeObject(param.MoveP));
            IgnoreCamDect = false;
            MoveInfo.NextMoveStep(StepEnum.SO_00_StartOutstore);

            return true;
        }

        protected override void OutstoreProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait(MoveInfo);
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            OutstoreExecute();
        }
        #endregion

    }
}