using OnlineStore.Common;
using OnlineStore.LoadCSVLibrary;
using System; 
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace OnlineStore.DeviceLibrary
{
    /// <summary>
    /// 流水线自动料仓-Box类
    /// </summary>
    public partial class Square_BoxBean : KTK_Store
    {
        private static bool IsIntSlvBlock = false;
        /// <summary>
        /// 开始运行
        /// </summary>
        public static bool IsRun = false;
        public string CID = "";
        public Box_Config Config;
        /// <summary>
        /// 记录最后一次 出库的posID,出库完成发送给服务器之后清除
        /// </summary>
        public string lastPosId = "";
        public int lastDoor = 0;
        public StoreStatus lastPosIdStatus = StoreStatus.StoreOnline;
        /// <summary>
        /// 轴列表
        /// </summary>
        public List<ConfigMoveAxis> moveAxisList = new List<ConfigMoveAxis>();
        /// <summary>
        /// 轴报警信息
        /// </summary>
        private Dictionary<string, AxisAlarmInfo> AxisAlarmCodeMap = new Dictionary<string, AxisAlarmInfo>();

        public ShelfMoveBean LeftShlefMove = null;
        public ShelfMoveBean RightShelfMove = null;
        
        private System.Timers.Timer serverConnectTimer = new System.Timers.Timer();
        private System.Timers.Timer IoCheckTimer = new System.Timers.Timer();
        public Square_BoxBean(Box_Config config)
        {
            Init();
            serverConnectTimer = new System.Timers.Timer();
            serverConnectTimer.Interval = 1000;
            serverConnectTimer.AutoReset = true;
            serverConnectTimer.Enabled = false;
            serverConnectTimer.Elapsed += server_connect_timer_Tick;
            IoCheckTimer = new System.Timers.Timer();
            IoCheckTimer.Interval = 200;
            IoCheckTimer.AutoReset = true;
            IoCheckTimer.Enabled = false;
            IoCheckTimer.Elapsed += IoCheckTimer_Elapsed;

            //添加调试 
            IsDebug = ConfigAppSettings.GetIntValue(Setting_Init.IsInDebug).Equals(1);
             
            StoreName = ("料仓BOX_" + config.Id + " ").ToUpper();
            this.StoreID = config.Id;
            this.Config = config;
            moveAxisList = new List<ConfigMoveAxis>();
            MoveAxisConfig();
            List<ACSquareSPosition> positionList = CSVPositionReader<ACSquareSPosition>.getPositionList();
            PositionNumList = new List<string>();
            foreach (ACSquareSPosition position in positionList)
            {
              //  if (position.StoreId.Equals(StoreID))
                {
                    bool result = ACSquareSPosition.CheckPosition(position, Config);
                    if (result)
                    {
                        PositionNumList.Add(position.PositionNum);
                    }
                }
            }

            IOManager.Init();
            IOManager.instance.ConnectionIOList(Config.DIODeviceNameList);
            LeftShlefMove = new ShelfMoveBean(1);
            RightShelfMove = new ShelfMoveBean(2);
            mainTimer.Enabled = false;
            int isAuto = ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun);
            if (isAuto == 1)
            {
                mainTimer.Enabled = true;
            }

            Thread.Sleep(300);
            //默认三个灯都亮
            IOManager.IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
            IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            posDebug = PosDebug.Init(PositionNumList);
        }

        private void IoCheckTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            //判断急停 
            if (storeRunStatus >= StoreRunStatus.HomeMoving)
            {
                if (IOManager.IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                {
                    if (isInSuddenDown.Equals(false))
                    {
                        isInSuddenDown = true;
                        LogUtil.error(LOGGER, StoreName + "收到急停信号,报警急停");
                        WarnMsg = StoreName + "收到急停信号，报警急停";

                        //报警时会关闭所有轴
                        Alarm(StoreAlarmType.SuddenStop, "1", WarnMsg, StoreMoveType.None);
                    }
                }
                else if (IOManager.IOValue(IO_Type.DoorLimit_L).Equals(IO_VALUE.LOW))
                {
                    isInSuddenDown = true;
                    LogUtil.error(LOGGER, StoreName + "前门打开 ,报警急停");
                    WarnMsg = StoreName + "前门打开，报警急停";

                    //报警时会关闭所有轴
                    Alarm(StoreAlarmType.SuddenStop, "1", WarnMsg, StoreMoveType.None);
                }
                else if (IOManager.IOValue(IO_Type.DoorLimit_B).Equals(IO_VALUE.LOW))
                {
                    isInSuddenDown = true;
                    LogUtil.error(LOGGER, StoreName + "后门打开,报警急停");
                    WarnMsg = StoreName + "后门打开，报警急停";

                    //报警时会关闭所有轴
                    Alarm(StoreAlarmType.SuddenStop, "1", WarnMsg, StoreMoveType.None);
                }

            }
        }
        /// <summary>
        /// 配置速度，加减速时间
        /// </summary>
        public void MoveAxisConfig()
        {
            Box_Config.ConfigAxis(Config);

            moveAxisList = new List<ConfigMoveAxis>();
            moveAxisList.Add(Config.Middle_Axis);
            moveAxisList.Add(Config.InOut_Axis);
            moveAxisList.Add(Config.UpDown_Axis);

            this.AxisAlarmCodeMap = new Dictionary<string, AxisAlarmInfo>();
            this.AxisAlarmCodeMap.Add(this.Config.Middle_Axis.GetNameStr(), new AxisAlarmInfo());
            this.AxisAlarmCodeMap.Add(Config.InOut_Axis.GetNameStr(), new AxisAlarmInfo());
            this.AxisAlarmCodeMap.Add(Config.UpDown_Axis.GetNameStr(), new AxisAlarmInfo());
        }

        /// <summary>
        /// 开始运行
        /// </summary>
        public override bool StartRun()
        {
            LogUtil.info(LOGGER, StoreName + "开始启动，启动时间：" + StartTime.ToString());

            autoNext = false;
            mainTimer.Enabled = false;
            alarmType = StoreAlarmType.None;

            //急停按钮和气压检测需要一起判断
            IO_VALUE suddenBtn = IOManager.IOValue(IO_Type.SuddenStop_BTN);
            IO_VALUE airCheck = IOManager.IOValue(IO_Type.Airpressure_Check);

            //if (suddenBtn == IO_VALUE.HIGH)         
            if (suddenBtn.Equals(IO_VALUE.HIGH) && (airCheck.Equals(IO_VALUE.HIGH) || Config.HasDoor.Equals(0)))
            {
                //lastAirValue = airCheck;
                lastAirCloseTime = DateTime.Now;
                string doorMsg = DoorIsClose();
                if (!String.IsNullOrEmpty(doorMsg))
                {
                    WarnMsg = "启动失败：" + doorMsg;
                    LogUtil.error(StoreName + WarnMsg);
                    return false;
                }

                if (!RunAxis(true))
                {
                    return false;
                }
              
                //TODO 启动时先所有轴远点返回，测试暂时关闭 
                storeRunStatus = StoreRunStatus.HomeMoving;
                storeStatus = StoreStatus.ResetMove;
                //启动温湿度服务器 
                HumitureController.OpenAll(Config.GetHumpPortList().ToArray());
                //LineConnect.StartConnect();

                ReturnHome();
                StartTime = DateTime.Now;
                mainTimer.Enabled = true;
                IoCheckTimer.Enabled = true;
                serverConnectTimer.Enabled = true;
                IsRun = true;
                return true;
            }
            else
            {
                if (suddenBtn.Equals(IO_VALUE.LOW))
                {
                    LogUtil.error(LOGGER, " (" + StoreName + ")启动出现错误：急停没开 ！启动失败！");
                }
                else
                {
                    LogUtil.error(LOGGER, " (" + StoreName + ")启动出现错误：没有气压信号 ！启动失败！");
                }
                return false;
            }
        }


        #region 原点返回和复位处理
        private void ReturnHome()
        {
            isNoAirCheck = false;
            isInSuddenDown = false;
            WarnMsg = ""; 
            CurrInOutACount = 0;
            CurrInOutCount = 0;
            IOManager.IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
            IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            storeRunStatus = StoreRunStatus.HomeMoving;
            StoreMove.NewMove(StoreMoveType.ReturnHome);

             StoreMove.NextMoveStep(StoreMoveStep.SH_12_InOutBack);
            ACAxisHomeMove(Config.InOut_Axis);
            LogUtil.info(LOGGER, StoreName + "开始原点返回，先把进出轴回原点");

            StoreMove.WaitList.Add(WaitResultInfo.WaitTime(2000));
        }
        public void MoveToP1()
        {
            //叉子回到P1,关闭门前后轴和升降轴回到P1
            StoreMove.NewMove(StoreMoveType.StoreReset);
            StoreMove.NextMoveStep(StoreMoveStep.SP1_01_InOutToP1);
            LogUtil.info(LOGGER, StoreName + "到待机状态，进出轴到P1");
            ACAxisMove(Config.InOut_Axis, Config.InOutAxis_P1_Position, Config.InOutAxis_P1_Speed); 
        }

        public override void Reset(bool isNeedClearAuto = true)
        {
            CurrInOutCount = 0;
            CurrInOutACount = 0;

            IOManager.IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
            IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
            IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
            //复位之前先停止运行
            if (isNeedClearAuto)
            {
                autoNext = false;
            }
            ACServerManager.SuddenStop(Config.Middle_Axis.DeviceName, Config.Middle_Axis.GetAxisValue());
            ACServerManager.SuddenStop(Config.UpDown_Axis.DeviceName, Config.UpDown_Axis.GetAxisValue());
            ACServerManager.SuddenStop(Config.InOut_Axis.DeviceName, Config.InOut_Axis.GetAxisValue());
            isInSuddenDown = false;
            isNoAirCheck = false;
            alarmType = StoreAlarmType.None;
            storeRunStatus = StoreRunStatus.Reset;
            storeStatus = StoreStatus.ResetMove;
            StoreMove.NewMove(StoreMoveType.StoreReset);
            WarnMsg = "";

            if (!RunAxis(true))
            ////打开四个轴
            //if (!OpenAllAxis())
            {
                LogUtil.info(LOGGER, StoreName + "复位时打开轴失败，需要再次复位，直接报警停止复位");
                return;
            }
            string doorMsg = DoorIsClose();
            if (!String.IsNullOrEmpty(doorMsg))
            {
                WarnMsg = "复位失败：" + doorMsg;
                return  ;
            }

            InoutStartReset();

            isInPro = false;
        }
        private void InoutStartReset()
        {
            LeftShlefMove.Stop();
            RightShelfMove.Stop();

            StoreMove.NextMoveStep(StoreMoveStep.SH_12_InOutBack);
            LogUtil.info(LOGGER, StoreName + "复位中，进出轴开始原点返回");
            ACAxisHomeMove(Config.InOut_Axis);
            StoreMove.WaitList.Add(WaitResultInfo.WaitTime(2000));
        }
        /// <summary>
        /// 复位处理
        /// </summary>
        protected override void ResetProcess()
        {
            string logName = "复位中：";
            if (StoreMove.MoveType.Equals(StoreMoveType.ReturnHome))
            {
                logName = "回原点：";
            }
            if (StoreMove.IsInWait)
            {
                CheckWait();
            }
            if (StoreMove.IsInWait)
            {
                return;
            }
            switch (StoreMove.MoveStep)
            {
                case StoreMoveStep.SH_10_LocationCylinderBack:
                    InoutStartReset();
                    break;
                case StoreMoveStep.SH_11_InOutMove:
                    StoreMove.NextMoveStep(StoreMoveStep.SH_12_InOutBack);
                    ACAxisHomeMove(Config.InOut_Axis);
                    LogUtil.info(LOGGER, StoreName + logName + " 进出轴开始原点返回");
                    StoreMove.WaitList.Add(WaitResultInfo.WaitTime(2000));
                    break;
                case StoreMoveStep.SH_12_InOutBack:
                    Thread.Sleep(200);
                    StoreMove.NextMoveStep(StoreMoveStep.SH_13_InOutToP1);
                    LogUtil.info(LOGGER, StoreName + logName + " 进出轴到待机点P1，关闭左右两侧门");
                    //进出轴原点返回完成，将进出轴的位置设置=0
                    AxisCountClear(Config.InOut_Axis);
                    ACAxisMove(Config.InOut_Axis, Config.InOutAxis_P1_Position, Config.InOutAxis_P1_Speed);
                    CloseDoor(1);
                    CloseDoor(2);
                    break;
                case StoreMoveStep.SH_13_InOutToP1:
                    //如果此时轴三还在报警，需要提示错误并等待 
                    if (ACServerManager.GetAlarmStatus(Config.InOut_Axis.DeviceName, Config.InOut_Axis.GetAxisValue()) > 0)
                    {
                        LogUtil.error(LOGGER, "进出轴报警！复位失败，请检查！");
                    }

                    //复位和回原点要等轴3进出轴ORG亮了以后才能返回其他轴
                    LogUtil.info(LOGGER, StoreName + logName + " 前后轴，升降轴开始 原点返回 ，左右托盘前进");
                    StoreMove.NextMoveStep(StoreMoveStep.SH_14_UpdownBack);
                    StoreMove.TimeOutSeconds = 100; 
                    ACAxisHomeMove(Config.UpDown_Axis);
                    ShelfForward(1);
                    ShelfForward(2);
                    break;
                case StoreMoveStep.SH_14_UpdownBack:
                    StoreMove.NextMoveStep(StoreMoveStep.SH_15_UpdownToP1);
                    LogUtil.info(LOGGER, StoreName + logName + " 升降轴走到P1");
                    ACAxisMove(Config.UpDown_Axis, Config.UpDownAxis_DoorO_P1, Config.UpDownAxis_P1_Speed);
                    break;
                case StoreMoveStep.SH_15_UpdownToP1:
                    StoreMove.NextMoveStep(StoreMoveStep.SH_16_MiddleBack);
                    LogUtil.info(LOGGER, StoreName + logName + " 前后轴原点返回");
                    StoreMove.TimeOutSeconds = 100;
                    ACAxisHomeMove(Config.Middle_Axis);
                    break;
                case StoreMoveStep.SH_16_MiddleBack:

                    StoreMove.NextMoveStep(StoreMoveStep.SH_17_MiddleToP1);
                    LogUtil.info(LOGGER, StoreName + logName + " 前后轴运动到P1，托架前进到位");
                    ACAxisMove(Config.Middle_Axis, Config.MiddleAxis_P1_Position, Config.MiddleAxis_P1_Speed);
                    //ACAxisMove(Config.UpDown_Axis, Config.UpDownAxis_DoorO_P1, Config.UpDownAxis_P1_Speed);
                    ShelfForward(1, StoreMove);
                    ShelfForward(2, StoreMove);
                    break;
                case StoreMoveStep.SH_17_MiddleToP1:
                    LogUtil.info(LOGGER, StoreName + "复位完成");
                    storeRunStatus = StoreRunStatus.Runing;
                    StoreMove.EndMove();
                    storeStatus = StoreStatus.StoreOnline;
                    if (alarmType.Equals(StoreAlarmType.None))
                    {
                        WarnMsg = "";
                    }
                    break;

                case StoreMoveStep.SP1_01_InOutToP1:
                    StoreMove.NextMoveStep(StoreMoveStep.SP1_02_CloseDoor);
                    LogUtil.info(LOGGER, StoreName + "到待机状态，关闭左右两侧门，托架前进");
                    CloseDoor(1);
                    CloseDoor(2);
                    break;
                case StoreMoveStep.SP1_02_CloseDoor:
                    StoreMove.NextMoveStep(StoreMoveStep.SP1_03_UpdownToP1);
                    LogUtil.info(LOGGER, StoreName + "到待机状态：升降轴走到P1");
                    ACAxisMove(Config.UpDown_Axis, Config.UpDownAxis_DoorO_P1, Config.UpDownAxis_P1_Speed);
                    //ACAxisMove(Config.Middle_Axis, Config.MiddleAxis_P1_Position, Config.MiddleAxis_P1_Speed);
                    break;
                case StoreMoveStep.SP1_03_UpdownToP1:
                    StoreMove.NextMoveStep(StoreMoveStep.SP1_04_MiddleToP1);
                    LogUtil.info(LOGGER, StoreName + "到待机状态：前后轴到P1");
                    //ACAxisMove(Config.UpDown_Axis, Config.UpDownAxis_DoorO_P1, Config.UpDownAxis_P1_Speed);
                    ACAxisMove(Config.Middle_Axis, Config.MiddleAxis_P1_Position, Config.MiddleAxis_P1_Speed);
                    break;
                case StoreMoveStep.SP1_04_MiddleToP1:
                    StoreMove.NextMoveStep(StoreMoveStep.SP1_05_ShelfForward);
                    LogUtil.info(LOGGER, StoreName + "到待机状态：托架前进");

                    ShelfForward(1, StoreMove);
                    ShelfForward(2, StoreMove);
                    break;
                case StoreMoveStep.SP1_05_ShelfForward:
                    LogUtil.info(LOGGER, StoreName + "到待机状态完成");
                    StoreMove.EndMove();
                    storeStatus = StoreStatus.StoreOnline;
                    storeRunStatus = StoreRunStatus.Runing;
                    if (alarmType.Equals(StoreAlarmType.None))
                    {
                        WarnMsg = "";
                    }

                    break;

                default: break;
            }
        }
        public void ShelfBack(int shelfType = 1, StoreMoveInfo moveInfo = null)
        {
            if (shelfType.Equals(1))
            {
                LeftShlefMove.StartBack(moveInfo);
            }
            else
            {
                RightShelfMove.StartBack(moveInfo);
            }
        }
        public void ShelfForward(int shelfType = 1, StoreMoveInfo moveInfo = null)
        {
            if (shelfType.Equals(1))
            {
                LeftShlefMove.StartForward(moveInfo);
            }
            else
            {
                RightShelfMove.StartForward(moveInfo);
            }
        }
        public string  DoorIsClose( )
        {
            //if (!IOManager.IOValue(IO_Type.LeftDoor_Close).Equals(IO_VALUE.HIGH))
            //{
            //    return "左侧门未关";
            //}
            //if (!IOManager.IOValue(IO_Type.RightDoor_Close).Equals(IO_VALUE.HIGH))
            //{
            //    return "右侧门未关";
            //}
            if (!IOManager.IOValue(IO_Type.DoorLimit_L).Equals(IO_VALUE.HIGH))
            {
                return "前门未关"; 
            }
            if (!IOManager.IOValue(IO_Type.DoorLimit_B).Equals(IO_VALUE.HIGH))
            {
                return "后门未关"; 
            }
            return "";
        }
        //public void OpenDoor(int type=1,StoreMoveInfo moveInfo=null)
        //{
        //    if (type.Equals(1))
        //    {

        //    }
        //    else
        //    {

        //    }
        //    if (moveInfo != null)
        //    {

        //    }
        //}
        //public void CloseDoor(int type = 1, StoreMoveInfo moveInfo=null)
        //{
        //    if (type.Equals(1))
        //    {

        //    }
        //    else
        //    {

        //    }
        //    if (moveInfo != null)
        //    {

        //    }
        //} 

        /// <summary>
        /// 原点返回处理
        /// </summary>
        protected override void ReturnHomeProcess()
        {
            ResetProcess();
        }
        #endregion

        public bool RunAxis(bool isCheck)
        {
            IOManager.IOMove(IO_Type.Run_Signal, IO_VALUE.HIGH);
            Thread.Sleep(1000);
            //打开所有轴
            foreach (ConfigMoveAxis moveAxis in moveAxisList)
            {
                string portName = moveAxis.DeviceName;
                short slvAddr = moveAxis.GetAxisValue();
                ACServerManager.OpenPort(portName);
                Thread.Sleep(50);
                //初始化串口
                //ACServerManager.InitSlvAddr(portName, slvAddr);
                if (!IsIntSlvBlock)
                {
                    ACServerManager.InitSlvAddr(portName, slvAddr, moveAxis.TargetSpeed, moveAxis.AddSpeed, moveAxis.DelSpeed);
                    Thread.Sleep(100);
                }
                ACServerManager.AlarmClear(portName, slvAddr);
                Thread.Sleep(50);
                ACServerManager.ServoOn(portName, slvAddr);
            }
            Thread.Sleep(500);
            //打开所有轴
            if (isCheck)
            {
                if (!OpenAllAxis())
                {
                    return false;
                }
            }
            IsIntSlvBlock = true;
            Thread.Sleep(200);
            IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.HIGH);
            return true;
        }
        /// <summary>
        /// 打开所有轴
        /// </summary>
        /// <returns></returns>
        private bool OpenAllAxis()
        {
            //判断轴是否正常
            foreach (ConfigMoveAxis axis in moveAxisList)
            {
                if (ACServerManager.ServerOnStatus(axis.DeviceName, axis.GetAxisValue()))
                {
                    LogUtil.info(LOGGER, StoreName + "成功打开轴：" + axis.Explain);
                }
                else
                {
                    //清理报警，再重新打开一次
                    LogUtil.info(LOGGER, StoreName + "第一次打开轴" + axis.Explain + "失败，先清理一下报警，再重新打开一次");
                    ACServerManager.AlarmClear(axis.DeviceName, axis.GetAxisValue());
                    System.Threading.Thread.Sleep(1200);
                    ACServerManager.ServoOn(axis.DeviceName, axis.GetAxisValue());
                    System.Threading.Thread.Sleep(100);
                    if (ACServerManager.ServerOnStatus(axis.DeviceName, axis.GetAxisValue()))
                    {
                        LogUtil.info(LOGGER, StoreName + "清理报警后重新打卡轴成功：" + axis.Explain);
                    }
                    else
                    {
                        ACServerManager.ServoOff(axis.DeviceName, axis.GetAxisValue());
                        int alarmCode = GetAlarmCodeByAxis(axis);
                        WarnMsg = StoreName + "打开轴" + axis.Explain + "失败 ";
                        LogUtil.info(LOGGER, StoreName + WarnMsg);
                        Alarm(StoreAlarmType.AxisAlarm, GetAlarmCodeByAxis(axis).ToString(), WarnMsg, StoreMove.MoveType);
                        return false;
                    }
                }
            }
            return true;
        }

        public void CloseAllAxis()
        {
            LogUtil.info(StoreName + "关闭刹车，关闭伺服");
            IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
            foreach (ConfigMoveAxis axis in moveAxisList)
            {
                ACServerManager.ServoOff(axis.DeviceName, axis.GetAxisValue());
                //关闭串口，等下次重新打开
           //     ACServerManager.ColsePort(axis.DeviceName);
            }
            Thread.Sleep(100);
            IOManager.IOMove(IO_Type.Run_Signal, IO_VALUE.LOW);
        }

        private int GetAlarmCodeByAxis(ConfigMoveAxis axis)
        {
            int alarmCode = LineAlarm.InOutAxisAlarm;
            int axisType = axis.GetAxisValue() % 4;
            if (axisType == 1)
            {
                alarmCode = LineAlarm.MiddleAxisAlarm;
            }
            else if (axisType == 2)
            {
                alarmCode = LineAlarm.UpDownAxisAlarm;
            }
            else if (axisType == 3)
            {
                alarmCode = LineAlarm.InOutAxisAlarm;
            }
            else
            {
                alarmCode = LineAlarm.CompressAxisAlarm;
            }
            return alarmCode;
        }

        /// <summary>
        /// 停止运行
        /// </summary>
        public override void StopRun()
        {
            WarnMsg = "";
            autoNext = false;
            IoCheckTimer.Enabled = false;
            serverConnectTimer.Enabled = false;
            StopMove(true);

            storeRunStatus = StoreRunStatus.Wait;
            mainTimer.Enabled = false;
            TimeSpan span = DateTime.Now - StartTime;
            IsRun = false;

            //LineConnect.StopConnect();
            IOManager.instance.CloseAllDO();
        
            LogUtil.info(LOGGER, StoreName + ",停止运行，总运行时间：" + span.ToString());
        }

        public override void Alarm(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, StoreMoveType storeMoveType)
        {
            SaveAlarmInfo(alarmType, alarmDetial, alarmMsg, storeMoveType);
            if (autoNext)
            {
                autoNext = false;
                LogUtil.error(LOGGER, StoreName + " Alarm 报警，报警类型：" + alarmType + "，停止自动出入库");
            }
            if (this.alarmType.Equals(alarmType) && alarmType != StoreAlarmType.SuddenStop && alarmType != StoreAlarmType.NoAirCheck)
            {
                return;
            }
            LogUtil.error(LOGGER, StoreName + " 报警，报警类型：" + alarmType);

            this.alarmType = alarmType;
            if (alarmType.Equals(StoreAlarmType.AxisAlarm) | alarmType.Equals(StoreAlarmType.AxisMoveError))
            {
                LogUtil.error(LOGGER, StoreName + "轴报警，关闭刹车，停止运动，关闭轴，打开报警灯");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                StopMove(true);
            }
            else if (alarmType == StoreAlarmType.SuddenStop)
            {
                isInSuddenDown = true;
                LogUtil.error(LOGGER, StoreName + "收到急停信号，关闭刹车，停止运动，关闭轴，打开报警灯 ");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                StoreMove.EndMove();
                StopMove(true);
                storeStatus = StoreStatus.SuddenStop;
            }
            else if (alarmType.Equals(StoreAlarmType.NoAirCheck))
            {
                isNoAirCheck = true;
                LogUtil.error(LOGGER, StoreName + " 未检测到气压信号 ,打开刹车，停止运动，关闭轴，打开报警灯 ");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                StoreMove.EndMove();
                StopMove(true);
                storeStatus = StoreStatus.SuddenStop;
            }
        }
        private bool InProcess = false;
        //private DateTime preProcessTime = DateTime.Now;
        private bool IsChongfu = false;
        private Stopwatch stopwatch = new Stopwatch();
        protected override void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (InProcess)
            {
                //TimeSpan span = DateTime.Now - preProcessTime;
                if (stopwatch.Elapsed.TotalMinutes < 1)
                {
                    return;
                }
                else
                {
                    LogUtil.error("主定时器：InProcess已等待" + stopwatch.Elapsed.ToString() + "重新处理");
                    IsChongfu = true;
                }
            }
            try
            {
                InProcess = true;
                //preProcessTime = DateTime.Now;
                stopwatch.Restart();
                IoCheckProcess();
                ShowTimeLog("IoCheckProcess");
                TimerProcess();
                ShowTimeLog("TimerProcess");
                //检查运动轴报警
                if (storeRunStatus > StoreRunStatus.Wait && (!isInSuddenDown) && (!isNoAirCheck))
                {
                    ShowTimeLog("开始检测轴报警");
                    CheckAxisAlarm();
                    ShowTimeLog("轴报警检测完成");
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(StoreName + "定时处理出错：" + ex.ToString());
            }
            IsChongfu = false;
            InProcess = false;
        }
        private IO_VALUE preAirValue = IO_VALUE.HIGH;
        private void AirCheckProcess()
        {
            if (Config.HasDoor.Equals(0))
            {
                return;
            }
            IO_VALUE currAirValue = IOManager.IOValue(IO_Type.Airpressure_Check);
            if (isInSuddenDown)
            {
                return;
            }
            if (isNoAirCheck)
            {
                return;
            }
            if (currAirValue.Equals(IO_VALUE.LOW))
            {
                //判断是否持续了3秒
                if (preAirValue.Equals(IO_VALUE.LOW))
                {
                    TimeSpan span = DateTime.Now - lastAirCloseTime;
                    if (span.TotalSeconds > Config.AirCheckSeconds)
                    {
                        WarnMsg = "未检测到气压信号";
                        preAirValue = IO_VALUE.LOW;
                        LogUtil.info("已持续【" + FormUtil.GetSpanStr(span) + "】未检测到气压信号，报警");
                        Alarm(StoreAlarmType.NoAirCheck, "2", WarnMsg, StoreMoveType.None);
                        return;
                    }
                }
                else
                {
                    lastAirCloseTime = DateTime.Now;
                    isNoAirCheck = false;
                }
            }
            else
            {
                isNoAirCheck = false;
            }
            preAirValue = currAirValue;
        }
        private void ShowTimeLog(string info)
        {
            if (IsChongfu)
            {
                LogUtil.info("【" + info + "】 处理完成，耗时：" + stopwatch.Elapsed.ToString());
            }
        }
        public bool use_Alarm_Buzzer = ConfigAppSettings.GetIntValue(Setting_Init.UseAlarmBuzzer,"")==1?true:false;
        private void LedProcess()
        {
            try
            {
                //                机器状态 顶灯显示 
                //                                              绿 黄  红
                //机器复位中                             闪 灭   灭
                //机器待机中                             亮 灭   灭
                //机器出入库中                          闪 闪   灭
                //温湿度超限报警中                   亮 闪   灭
                //温湿度超限报警中超过30分钟  亮 闪   闪
                //机器未启动                             灭 灭   灭
                //机器设备故障(非温湿度)报警    亮   灭 闪

                //报警时只需要亮红灯

                DateTime time = DateTime.Now;
                bool isTemp30M = false;
                if (TempOrHumidityIsAlarm)
                {
                    TimeSpan span = DateTime.Now - TempAlarmTime;
                    if (span.Minutes > 30)
                    {
                        isTemp30M = true;
                    }
                }
                bool isNeedAlarmLed = false;
                //报警灯
                if (!alarmType.Equals(StoreAlarmType.None) || isTemp30M)
                {
                    isNeedAlarmLed = true;
                }
                if (isNeedAlarmLed && IOManager.IOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.LOW))
                {
                    IOManager.IOMove(IO_Type.Alarm_HddLed, IO_VALUE.HIGH);
                }
                else
                {
                    if (IOManager.IOValue(IO_Type.Alarm_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.Alarm_HddLed, IO_VALUE.LOW);
                    }
                }
                if(use_Alarm_Buzzer)
                {
                    if (isNeedAlarmLed && IOManager.IOValue(IO_Type.Alarm_Buzzer).Equals(IO_VALUE.LOW))
                    {
                        IOManager.IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.HIGH);
                    }
                    else
                    {
                        if (IOManager.IOValue(IO_Type.Alarm_Buzzer).Equals(IO_VALUE.HIGH))
                        {
                            IOManager.IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
                        }
                    }
                }
                else
                {
                    IOManager.IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
                }

                //报警时绿灯和黄灯灭
                if (isNeedAlarmLed)
                {
                    if (IOManager.IOValue(IO_Type.AutoRun_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                    if (IOManager.IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                    }
                    return;
                }

                //绿灯闪
                if ((StoreMove.MoveType.Equals(StoreMoveType.InStore) || StoreMove.MoveType.Equals(StoreMoveType.OutStore)
                  || storeRunStatus.Equals(StoreRunStatus.HomeMoving) || storeRunStatus.Equals(StoreRunStatus.Reset))
                  && IOManager.IOValue(IO_Type.AutoRun_HddLed).Equals(IO_VALUE.HIGH))
                {
                    IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.LOW);
                }
                else
                {
                    //绿灯亮
                    IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
                }
                //黄灯
                if (StoreMove.MoveType.Equals(StoreMoveType.InStore) || StoreMove.MoveType.Equals(StoreMoveType.OutStore) || TempOrHumidityIsAlarm || isTemp30M)
                {
                    if (IOManager.IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                    else
                    {
                        IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.HIGH);
                    }
                }
                else
                {
                    if (IOManager.IOValue(IO_Type.RunSign_HddLed).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.RunSign_HddLed, IO_VALUE.LOW);
                    }
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(StoreName + "灯处理定时器出错：", ex);
            }
        }
        private IO_VALUE lastAutoRun = IO_VALUE.LOW;
        //   private IO_VALUE lastAirValue = IO_VALUE.LOW;
        public void IoCheckProcess()
        {
            DateTime time = DateTime.Now;
            if (storeRunStatus.Equals(StoreRunStatus.Wait))
            { 
                //处理急停信号，如果急停未开，自动停止刹车信号 
                if (IOManager.IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.LOW))
                {
                    if (IOManager.IOValue(IO_Type.Axis_Brake).Equals(IO_VALUE.HIGH))
                    {
                        IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                        LogUtil.info(StoreName + "：急停未开，自动关闭信号：Axis_Brake");
                    }
                }

                //取新的Io状态
                IO_VALUE autoSingle = IOManager.IOValue(IO_Type.Reset_BTN);
                if (ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun).Equals(1))
                {
                    if (autoSingle.Equals(IO_VALUE.HIGH) && lastAutoRun.Equals(IO_VALUE.LOW))
                    {
                        //没有启动时收到复位按钮，相当于启动按钮
                        LogUtil.info(LOGGER, StoreName + "没有启动时收到复位按钮，相当于启动按钮，开始调用启动方法！");
                        bool result = StartRun();
                        if (result.Equals(false))
                        {
                            LogUtil.error("料仓启动失败，继续等待下次启动！");
                            mainTimer.Enabled = true;
                        }
                    }
                    lastAutoRun = autoSingle;
                    return;
                }
                lastAutoRun = autoSingle; 
            }
            //判断急停 
            else if (storeRunStatus >= StoreRunStatus.HomeMoving)
            {
                //取新的Io状态 
                IO_VALUE suddenBtn = IOManager.IOValue(IO_Type.SuddenStop_BTN);
                IO_VALUE resetBtn = IOManager.IOValue(IO_Type.Reset_BTN);

                //急停按钮 
                if (suddenBtn.Equals(IO_VALUE.LOW))
                {
                    AirCheckProcess();
                }
                else if (resetBtn.Equals(IO_VALUE.HIGH))
                {
                    //收到复位信号，若报警直接复位，若不报警且无操作，回到待机点
                    if (alarmType.Equals(StoreAlarmType.None) && isInSuddenDown.Equals(false) && isNoAirCheck.Equals(false))
                    {
                        if (StoreMove.MoveType.Equals(StoreMoveType.None))
                        {
                            LogUtil.info(LOGGER, "收到复位信号，当前无报警，且空闲中，只回到待机点");
                            MoveToP1();
                        }
                        else
                        {
                            LogUtil.info(LOGGER, "收到复位信号，当前无报警， 在" + StoreMove.MoveType + "处理中，不处理复位");
                        }
                    }
                    else
                    {
                        //收到复位信号
                        LogUtil.info(LOGGER, "收到复位信号，自动复位");
                        WarnMsg = "收到复位信号，自动复位";
                        Reset(); 
                    }
                }
            }
        }


        public void TimerProcess()
        {
            try
            {
                DateTime time = DateTime.Now;
                if (StoreMove.MoveType != StoreMoveType.None)
                {
                    BusyMoveProcess();
                    ShowTimeLog("BusyMoveProcess");
                }
                else if (storeRunStatus.Equals(StoreRunStatus.Runing))
                {

                    ShowTimeLog("判断是否需要出入库");
                    AutoResetProcess();
                    ShowTimeLog("AutoResetProcess");
                    IOTimeOutProcess();
                    ShowTimeLog("IOTimeOutProcess");

                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(StoreName + "定时处理出错", ex);
            }
        }


        private DateTime preIoTimerOutTime = DateTime.Now;
        /// <summary>
        /// io检测异常
        /// </summary>
        private void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 1)
                {
                    preIoTimerOutTime = DateTime.Now;
                    if (!alarmType.Equals(StoreAlarmType.IoSingleTimeOut))
                    {
                        return;
                    }
                    if (storeRunStatus < StoreRunStatus.Runing)
                    {
                        return;
                    }
                    if (isInSuddenDown || isNoAirCheck)
                    {
                        return;
                    }

                    //若BOX和移栽都没有在等待Io的过程中则此Io超时异常可能已经处理过
                    if (StoreMove.IsInWait == false)
                    {
                        LogUtil.info(StoreName + "之前有IO超时异常【" + alarmInfo.alarmDetail + "】,但是当前已经没有在等待中，清理信号超时异常！");
                        alarmType = StoreAlarmType.None;
                        WarnMsg = "";
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "IOTimeOutProcess出错：" + ex.ToString());
            }
        }

        /// <summary> 
        /// 超过配置次数时需要复位
        /// </summary>
        private void AutoResetProcess()
        {
            try
            {
                    bool noInStore = waitOutStoreList.Count <= 0;
                if (CurrInOutACount >= this.Config.Box_ResetACount &&noInStore)
                {
                    if (storeRunStatus < StoreRunStatus.Runing || StoreMove.MoveType == StoreMoveType.InStore || StoreMove.MoveType == StoreMoveType.OutStore)
                    {
                        LogUtil.info(LOGGER, StoreName + "已经累计出入库" + CurrInOutACount + "次，当时当前正在忙碌中暂不复位");
                    }
                    else
                    {
                        LogUtil.info(LOGGER, StoreName + "已经累计出入库" + CurrInOutACount + "次，需要复位一下");
                        Reset();
                    }
                }
                else if (CurrInOutCount >= this.Config.Box_ResetMCount && noInStore)
                {
                    if (storeRunStatus < StoreRunStatus.Runing || StoreMove.MoveType == StoreMoveType.InStore || StoreMove.MoveType == StoreMoveType.OutStore)
                    {
                        LogUtil.info(LOGGER, StoreName + "已经累计出入库" + CurrInOutCount + "次，当时当前正在忙碌中暂不复位前后轴");
                    }
                    else
                    {
                        LogUtil.info(LOGGER, StoreName + "已经累计出入库" + CurrInOutCount + "次，需要复位一下前后轴");
                    }
                }
             //   else if (LineConnect.CanStartOut() || IsDebug)
             else
                {
                    InOutPosInfo currInOutFixture = null;
                    lock (waitOutListLock)
                    {
                        if (waitOutStoreList.Count > 0 && CanStarInOut())
                        {
                            currInOutFixture = waitOutStoreList[0];
                            waitOutStoreList.RemoveAt(0);
                        }
                    }
                    if (currInOutFixture != null)
                    {  //出库

                        LogUtil.info(LOGGER, StoreName + "开始执行排队中的出库【" + currInOutFixture.ToStr() + "】");
                        bool result = StartOutStoreMove(new InOutParam(currInOutFixture));
                        //bool result = StartOutStoreMove(new InOutParam("", currInOutFixture.PosId, currInOutFixture.plateH, currInOutFixture.plateW));
                        if (!result)
                        {
                            LogUtil.info(LOGGER, StoreName + " 执行排队中的出库【" + currInOutFixture.ToStr() + "】失败，重新加入等待队列");
                            AddWaitOutInfo(currInOutFixture);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(LOGGER, "处理出入库排队列表出错：" + ex.ToString());
            }
        }

        /// <summary>
        /// 判断是否报警，返回 true表示报警  报警检测2秒钟检测一次
        /// </summary>
        /// <returns></returns>
        private DateTime checkAlarmTime = DateTime.Now;
        public bool CheckAxisAlarm()
        {
            if (alarmType.Equals(StoreAlarmType.AxisAlarm) || alarmType.Equals(StoreAlarmType.AxisMoveError))
            {
                return true;
            }
            TimeSpan span = DateTime.Now - checkAlarmTime;
            //在回原点，复位，出入库时，检测报警间隔减小
            if (storeRunStatus.Equals(StoreRunStatus.Busy) || storeRunStatus.Equals(StoreRunStatus.HomeMoving) || storeRunStatus.Equals(StoreRunStatus.Reset))
            {
                if (span.TotalSeconds < 1)
                {
                    return false;
                }
            }
            else
            {
                if (span.TotalSeconds < 3)
                {
                    return false;
                }
            }
            checkAlarmTime = DateTime.Now;
            bool isInAlarm = false;
            //Task.Factory.StartNew(delegate
            // {
            foreach (ConfigMoveAxis axisInfo in moveAxisList)
            {
                short axis = axisInfo.GetAxisValue();
                string deviceName = axisInfo.GetNameStr();
                AxisAlarmInfo info = AxisAlarmCodeMap[deviceName];

                int alarmIo = ACServerManager.GetAlarmStatus(deviceName, axis);

                if (alarmIo == 1)
                {
                    WarnMsg = StoreName + " 运动轴" + axisInfo.Explain + "报警";
                    info.AlarmIoValue = alarmIo;
                    Alarm(StoreAlarmType.AxisAlarm, GetAlarmCodeByAxis(axisInfo).ToString(), WarnMsg, StoreMoveType.None);
                    isInAlarm = true;
                }
                else
                {
                    if (!info.AlarmIoValue.Equals(alarmIo))
                    {
                        LogUtil.error(LOGGER, StoreName + "  运动轴  " + axisInfo.Explain + "，报警已解除！");
                        info.AlarmIoValue = alarmIo;
                    }
                }
                AxisAlarmCodeMap[deviceName] = info;
            }
            //});
            //判断报警状态
            return isInAlarm;
        }
        /// <summary>
        /// 停止所有运行
        /// </summary>
        public override void StopMove(bool IsCloseAxis)
        {
            LeftShlefMove.Stop();
            RightShelfMove.Stop();

            IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
            //运动版停止 
            ACServerManager.SuddenStop(Config.Middle_Axis.DeviceName, Config.Middle_Axis.GetAxisValue());
            ACServerManager.SuddenStop(Config.UpDown_Axis.DeviceName, Config.UpDown_Axis.GetAxisValue());
            ACServerManager.SuddenStop(Config.InOut_Axis.DeviceName, Config.InOut_Axis.GetAxisValue());

          
            if (IsCloseAxis)
            {
                CloseAllAxis();
            }
            LogUtil.info(LOGGER, StoreName + "StopMove"); 

            isInPro = false;
        }


        /// <summary>
        /// 判断是可以开始出入库（当前在忙碌状态则需要排队等待）
        /// </summary>
        /// <returns></returns>
        public bool CanStarInOut()
        {
            if (isInSuddenDown || isNoAirCheck ||
              (!storeRunStatus.Equals(StoreRunStatus.Runing))
              || storeStatus.Equals(StoreStatus.InStoreExecute) || storeStatus.Equals(StoreStatus.OutStoreExecute)
              || storeStatus.Equals(StoreStatus.InStoreEnd) || storeStatus.Equals(StoreStatus.OutStoreBoxEnd))
            {
                return false;
            }
            return true;
        }


        #region 入库命令处理

        private void ReviceInStoreProcess(string message, Operation resultOperation)
        {
            Dictionary<string, string> data = resultOperation.data;
            if (data != null && data.ContainsKey(ParamDefine.posId) && data.ContainsKey(ParamDefine.plateH) && data.ContainsKey(ParamDefine.plateW))
            {
                //服务器返回时有：posId库位编号，plateW:料盘宽度,plateH：料盘高度， 
                string posId = data[ParamDefine.posId];
                string plateW = data[ParamDefine.plateW];
                string plateH = data[ParamDefine.plateH];
                int door = Convert.ToInt32(data[ParamDefine.door]);
                InOutPosInfo inoutInfo = new InOutPosInfo(message, posId, plateH, plateW,door);

                //根据发送的posId获取位置列表
                ACSquareSPosition position = CSVPositionReader<ACSquareSPosition>.GetPositon(posId);
                if (position == null)
                {   //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                    WarnMsg = "入库未找到库位：【" + inoutInfo.ToStr() + "】 ";
                    LogUtil.error(LOGGER, "收到服务器入库命令：入库未找到库位：【" + inoutInfo.ToStr() + "】");
                    LogUtil.info(LOGGER, "收到服务器入库命令：入库未找到库位：【" + inoutInfo.ToStr() + "】");
                    return;
                }
                //TODO:判断BOX是否处于可以入库状态，如果调试或急停中，需要返回给服务器；
                if (CanStarInOut())
                {
                    //如果当前正在出入库中，需要记录下来，等待空闲时执行
                    LogUtil.info(LOGGER, StoreName + " 收到服务器入库命令：【" + inoutInfo.ToStr() + "】开始入库！");
                    InOutParam param = new InOutParam(inoutInfo);
                    StartInStoreMove(param);
                }
                else
                {
                    LogUtil.info(LOGGER, StoreName + " 收到服务器入库命令：【" + inoutInfo.ToStr() + "】 正在忙碌中，无法入库！");

                }
            }
        }


        //public bool ReviceLineCheckInStoreCMD(string posId, string plateH, string plateW, string message)
        //{
        //    string logName = "入库库位验证【 " + message + "】【" + posId + "】：";
        //    try
        //    {
               
        //        if (storeRunStatus.Equals(StoreRunStatus.Wait))
        //        {
        //            LogUtil.info(LOGGER,  logName+ " 设备未启动，验证失败");
        //            return false;
        //        }
        //        // CodeMsg = "收到二维码【 " + message + "】，发送给服务器获取入库PosID";
        //        LogUtil.debug(LOGGER, logName+"发送给服务器验证入库PosID");
        //        //发送扫码内容到服务器进行入库操作
        //        Operation operation = getLineBoxStatus();
        //        operation.op = 1;
        //        operation.data = new Dictionary<string, string>() { { "code", message }, { "boxId", StoreID.ToString() } };
        //        operation.data.Add("inPos", posId);
        //        string server = ConfigAppSettings.GetValue(Setting_Init.http_server);
        //        Operation resultOperation = HttpHelper.Post(StoreManager.GetPostApi(server), operation, false);
        //        if (resultOperation == null)
        //        {
        //            // CodeMsg = "二维码【" + message + "】没有收到服务器反馈";
        //            LogUtil.info(LOGGER, logName +  " 没有收到服务器反馈 ");
        //        }
        //        else if (!string.IsNullOrEmpty(resultOperation.msg))
        //        {
        //            //如果有提示消息，直接显示提示
        //            LogUtil.info(LOGGER, logName + "服务器反馈 ：" + resultOperation.msg);

        //        }
        //        else if (resultOperation.op.Equals(1))
        //        {
        //            LogUtil.info(LOGGER, logName + " 成功");
        //            return true;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        LogUtil.info(LOGGER, logName + " 出错：" + ex.ToString());

        //    }
        //    return false;
        //}
        //public void ReviceLineInStoreCMD(string posId, string plateH, string plateW, string message)
        //{
        //    string logName = "流水线入库命令【 " + message + "】【" + posId + "】：";
        //    //if (!LineConnect.WaitInStoreList.Contains(posId))
        //    //{
        //    //    LogUtil.error(logName + "库位未验证通过，重新验证库位");
        //    //    bool result = ReviceLineCheckInStoreCMD(posId, plateH, plateW, message);
        //    //    if (!result)
        //    //    {
        //    //        return;
        //    //    } 
        //    //}
        //    //else
        //    //{
        //    //    LineConnect.WaitInStoreList.Remove(posId);
        //    //}
        //    //根据发送的posId获取位置列表
        //    ACSquareSPosition position = CSVPositionReader<ACSquareSPosition>.GetPositon(posId);
        //    if (position == null)
        //    {   //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
        //        WarnMsg = "入库未找到库位：二维码【" + message + "】库位【" + posId + "】 ";
        //        LogUtil.error(logName + "未找到库位");
        //        //     LogUtil.info(LOGGER, "收到流水线入库：入库未找到库位：二维码【" + message + "】库位【" + posId + "】");
        //        return;
        //    }
        //    //TODO:判断BOX是否处于可以入库状态，如果调试或急停中，需要返回给服务器；
        //    if (CanStarInOut())
        //    {
        //        InOutParam param = new InOutParam(new InOutPosInfo( message, posId, plateH, plateW));
        //        LogUtil.info(logName + "  开始入库！");
        //        StartInStoreMove(param);
        //        //如果当前正在出入库中，需要记录下来，等待空闲时执行
        //    }
        //    else
        //    {
        //        LogUtil.info(logName + "  正在忙碌中，无法入库！");
        //    }
        //} 

        #endregion


        #region 温湿度处理
        /// <summary>
        /// 湿度标准，超过后需要报警
        /// </summary>
        private float Max_Humidity = 0;
        /// <summary>
        /// 温度标准，超过后需要报警
        /// </summary>
        private float Max_Temperature = 0;
        private bool IsInBlowing = false;
        private DateTime LastBeginBlowTime = DateTime.Now;
        private DateTime LastEndBlowTime = new DateTime(1997, 1, 1);
        private DateTime preLogTime = DateTime.Now;

        public bool TempOrHumidityIsAlarm = false;
        public DateTime TempAlarmTime = DateTime.Now;

        private float StartBlowValue = (float)ConfigAppSettings.GetNumValue(Setting_Init.StartBlowValue);
        private float StopBlowValue = (float)ConfigAppSettings.GetNumValue(Setting_Init.StopBlowValue);
        public string currTempStr = "";
        public void HumidityProcess()
        {
            try
            {
              
                if ((DateTime.Now - preLogTime).TotalSeconds > 10&&storeRunStatus>StoreRunStatus.Wait)
                {
                    HumitureController.QueryData(Config.GetHumpPortList().ToArray());
                    ASTemperateParam param = HumitureController.LastData;
                    double humidity = 0;
                    double temp = 0;
                    if (param != null)
                    {
                        humidity = param.Humidity;
                        temp = param.Temperate;
                        currTempStr = ("当前湿度：" + humidity.ToString() + "，当前温度：" + temp);
                    }
                    preLogTime = DateTime.Now;
                    //用最大的湿度判断是否需要吹气，开始吹气的值=发过来的值-4
                    //温湿度
                    //ASTemperateParam param = HumitureServer.GetTemperateParam(Config.GetTempAddrList());
                 
                    //double currMaxHumidity = HumitureServer.GetMaxHumidity(Config.GetTempAddrList());
                    double currMaxHumidity = param.Humidity;
                    float startBlowHumidity = Max_Humidity - StartBlowValue;
                    float stopBlowHumidity = Max_Humidity - StopBlowValue;


                    //判断是否需要吹气
                    if (startBlowHumidity > 0 && startBlowHumidity < currMaxHumidity && IsInBlowing.Equals(false))
                    {
                        //判断是否距离上次结束指定的时间
                        TimeSpan span = DateTime.Now - LastEndBlowTime;
                        if (span.TotalMinutes > this.Config.BlowAir_Interval)
                        {
                            LOGGER.Info("当前最大湿度：" + currMaxHumidity.ToString() + "，开始吹气湿度：" + startBlowHumidity + "，当前不在吹气中，且间隔超过" + Config.BlowAir_Interval + "分钟，开始吹气！");
                            IsInBlowing = true;
                            //Thread.Sleep(100);
                            IOManager.IOMove(IO_Type.StartOrStopBlow, IO_VALUE.HIGH);
                            LastBeginBlowTime = DateTime.Now;
                            LastEndBlowTime = DateTime.Now;
                        }
                    }

                    if (IsInBlowing && stopBlowHumidity > currMaxHumidity)
                    {
                        LOGGER.Info("当前最大湿度：" + currMaxHumidity.ToString() + ",停止吹气湿度：" + stopBlowHumidity + "，停止吹气！");
                        IsInBlowing = false;
                        IOManager.IOMove(IO_Type.StartOrStopBlow, IO_VALUE.LOW);
                        LastEndBlowTime = DateTime.Now;
                    }
                    if (IsInBlowing)
                    {
                        //判断是否需要结束吹气
                        TimeSpan span = DateTime.Now - LastBeginBlowTime;
                        if (span.TotalMinutes > this.Config.BlowAir_Time)
                        {
                            LOGGER.Info("已经吹气" + span.TotalMinutes + "分钟，超过配置的吹气时间" + Config.BlowAir_Time + "分钟，停止吹气！");
                            IsInBlowing = false;
                            //Thread.Sleep(100);
                            IOManager.IOMove(IO_Type.StartOrStopBlow, IO_VALUE.LOW);
                            LastEndBlowTime = DateTime.Now;
                        }
                    }
                    bool needAlarm = false;
                    //如果开始吹气并且当前达到报警值
                    if (IsInBlowing && humidity > Max_Humidity)
                    {
                        needAlarm = true;
                    }
                    else if (temp > Max_Temperature && Max_Temperature > 0)
                    {
                        LOGGER.Info("当前温度【" + param.Temperate + "】超过最高温度【" + Max_Temperature + "】，开始报警！");
                        needAlarm = true;
                        //Thread.Sleep(100);
                        IOManager.IOMove(IO_Type.StartOrStopBlow, IO_VALUE.LOW);
                    }
                    else if (temp < Max_Temperature)
                    {
                        if (IsInBlowing.Equals(false) && TempOrHumidityIsAlarm)
                        {
                            LOGGER.Info("不在吹气中，且当前温度【" + param.Temperate + "】低于【" + Max_Temperature + "】，关闭报警！");
                            TempOrHumidityIsAlarm = false;
                            //Thread.Sleep(100);
                            IOManager.IOMove(IO_Type.StartOrStopBlow, IO_VALUE.LOW);
                        }
                    }
                    else
                    {
                        TempOrHumidityIsAlarm = false;
                    }
                    if (needAlarm)
                    {
                        HTAlarm();
                    }
                }
            }
            catch (Exception ex)
            {
                LOGGER.Error(StoreName + "HumidityProcess出错：" + ex.ToString());
            }
        }
        private void HTAlarm()
        {
            if (TempOrHumidityIsAlarm)
            {
                return;
            }
            TempAlarmTime = DateTime.Now;
            TempOrHumidityIsAlarm = true;
        }
        #endregion

        #region 与服务器通信定时器，每1秒向服务器通知一次状态,同时执行出库操作
        
        private string CodeMsg = "";
        private bool isInProcess = false;
        public void server_connect_timer_Tick(object sender, EventArgs e)
        {
            if (isInProcess)
            {
                return;
            } 
            isInProcess = true;
            try
            { 
                if (StoreManager.IsConnectServer)
                {
                    try
                    {
                        SendLineStatus();
                    }
                    catch (Exception ex)
                    {
                        LOGGER.Error("定时给服务器发送消息出错：", ex);
                    }
                }

               // HumitureController.QueryData(Config.GetHumpPortList().ToArray());
                //HumidityProcess();
                LedProcess();
            }catch(Exception ex)
            {
                LogUtil.error("server_connect_timer_Tick出错："+ex.ToString());
            }
            isInProcess = false;
        }

        /// <summary>
        /// 获取整个料仓的状态
        /// </summary> 
        public Operation getLineBoxStatus()
        {
            //构建发送给服务器的对象
            Operation lineOperation = new Operation();
            lineOperation.msg = "";
            lineOperation.alarmList = new List<AlarmInfo>();
            lineOperation.cid = CID;
            lineOperation.seq = ConfigAppSettings.nextSeq();
            lineOperation.status = 1;
            if (WarnMsg != "")
            {
                lineOperation.status = (int)StoreStatus.Warning;
                lineOperation.msg = WarnMsg;
            }
            else if (IsRun)
            {
                lineOperation.status = (int)StoreStatus.StoreOnline;
            }
            lineOperation.status = (int)StoreStatus.StoreOnline;

            BoxStatus boxStatus = new BoxStatus();
            boxStatus.boxId = 1;
 
            boxStatus.msg = WarnMsg;
            lineOperation.msg = WarnMsg;

            if (WarnMsg.Equals(""))
            {
                boxStatus.msg = CodeMsg;
                lineOperation.msg = CodeMsg;
            }
            if (CodeMsg.Equals(""))
            {
                if (storeRunStatus.Equals(StoreRunStatus.Runing) && IOManager.IOValue(IO_Type.TrayCheck_Fixture).Equals(IO_VALUE.HIGH))
                {
                    boxStatus.msg = "货叉物料检测有料，请检查";
                    lineOperation.msg = "货叉物料检测有料，请检查";
                }
            }
            CodeMsg = "";
            //WarnMsg = ""; 
            //状态
            boxStatus.status = (int)storeStatus;
            if (IsDebug)
            {
                boxStatus.status = (int)StoreStatus.Debugging;
            }
            else if (storeStatus.Equals(StoreStatus.OutStoreBoxEnd) || storeStatus.Equals(StoreStatus.InStoreEnd))
            {
                boxStatus.data.Add(ParamDefine.posId, lastPosId); 
                if (lastPosIdStatus.Equals(StoreStatus.OutStoreBoxEnd) || lastPosIdStatus.Equals(StoreStatus.InStoreEnd))
                {
                    boxStatus.data.Add(ParamDefine.door, lastDoor.ToString()); 
                }
            }
            else if (!lastPosId.Equals(""))
            {
                boxStatus.data.Add(ParamDefine.posId, lastPosId);
                boxStatus.status = (int)lastPosIdStatus;
                string doorP = "";
                if (lastPosIdStatus.Equals(StoreStatus.OutStoreBoxEnd) || lastPosIdStatus.Equals(StoreStatus.InStoreEnd))
                {
                    boxStatus.data.Add(ParamDefine.door, lastDoor.ToString());
                    doorP = "door【" + lastDoor + "】";
                }
                if (lastPosId != "")
                {
                    LogUtil.info(LOGGER, "给服务器发送出入库完成消息：" + StoreName + ",status【" + lastPosIdStatus + "】posId【" + lastPosId + "】" + doorP);
                }
                lastPosId = "";
            }

            //如果在空闲中，且有入库未完成，直接发送入库执行中 
            if (boxStatus.status.Equals((int)StoreStatus.StoreOnline))
            {
                //List<string> list = new List<string>(LineConnect.WaitInStoreList);
                //if (list.Count > 0 && (LineConnect.CanStartOut().Equals(false)))
                //{
                //    boxStatus.status = (int)StoreStatus.InStoreExecute;
                //}
            }
            //3  仓门状态上传: 字段为door1和doo2, 状态: opened为已打开, closed为已关闭, opening为打开中, closing为关闭中
            boxStatus.data.Add(ParamDefine.door1, GetDoorStatus(1));
            boxStatus.data.Add(ParamDefine.door2, GetDoorStatus(2));

            //温湿度
            //ASTemperateParam param = HumitureServer.GetTemperateParam(Config.Temperate_Serveraddress);
            ASTemperateParam param = HumitureController.LastData;
            if (param != null)
            {
                boxStatus.humidity = param.Humidity.ToString();
                boxStatus.temperature = param.Temperate.ToString();
            }
            lineOperation.boxStatus.Add(1, boxStatus);

            if (!alarmType.Equals(StoreAlarmType.None))
            {
                lineOperation.alarmList.Add(alarmInfo);
            }
            return lineOperation;
        }

        public void SendLineStatus()
        {
            DateTime time = DateTime.Now;
            //构建发送给服务器的对象
            Operation lineOperation = getLineBoxStatus();
            //如果还没湿度范围，先获取
            if (Max_Humidity <= 0 || (Max_Temperature <= 0))
            {
                lineOperation.op = 5;
                LogUtil.info(LOGGER, StoreName + "没有湿度预警范围，需要从服务器获取，发送OP=" + lineOperation.op);
            }
            string server = ConfigAppSettings.GetValue(Setting_Init.http_server);
            Operation resultOperation = HttpHelper.Post(StoreManager.GetPostApi(server), lineOperation, false);
            
            //发送状态信息到服务器 
            if (resultOperation == null )
            {
                //判断服务端是否返回出库操作
                return;
            }
            if (resultOperation.op > 0)
            {
                if (resultOperation.op.Equals(1))
                {
                    ReviceInStoreProcess("", resultOperation);
                }
                else if (resultOperation.op.Equals(2))
                {
                    ReviceOutStoreProcess(resultOperation);
                }
                else if (resultOperation.op.Equals(5))
                {
                    ProcessHumidityCMD(resultOperation);
                }
                else
                {
                    LogUtil.error("收到服务器命令：op=" + resultOperation.op + "，未找到对应处理");
                }
            }
            else if (resultOperation.data != null)
            {
                //4  开关门操作: 开门openDoor = 1为1号仓门打开, = 2为2号仓门打开, closeDoor = 1为1号仓门关闭,= 2为2号仓门关闭
                bool result = false;
                Dictionary<string, string> dataMap = resultOperation.data;

                if (dataMap.ContainsKey(ParamDefine.openDoor))
                {
                    string openDoorV = dataMap[ParamDefine.openDoor];
                    LogUtil.info(StoreName + "收到服务器命令：openDoor= "+ openDoorV);
                    if (openDoorV.Equals("1"))
                    {
                        result= OpenDoor(1);
                    }
                    else if (openDoorV.Equals("2"))
                    { 
                        result = OpenDoor(2);
                    }
                    if (!result)
                    {
                        LogUtil.info(StoreName + "收到服务器命令：openDoor 执行失败：" + result);
                    }
                }
                else if (dataMap.ContainsKey(ParamDefine.closeDoor))
                {
                    string closeDoorV = dataMap[ParamDefine.openDoor];
                    LogUtil.info(StoreName + "收到服务器命令：closeDoor="+ closeDoorV);
                    if (closeDoorV.Equals("1"))
                    {
                        result =CloseDoor(1);
                    }
                    else if (closeDoorV.Equals("2"))
                    { 
                        result = CloseDoor(2);
                    }
                    if (!result)
                    {
                        LogUtil.info(StoreName + "收到服务器命令： closeDoor 执行失败：" + result);
                    }
                } 
            }
            TimeSpan span = DateTime.Now - time;
            if (span.TotalMilliseconds > 500)
            {
                LogUtil.info(StoreName + "执行 SendLineStatus 共处理了【" + span.TotalMilliseconds + "】毫秒");
            }
        }
        private void ProcessHumidityCMD(Operation resultOperation)
        {
            Dictionary<string, string> data = resultOperation.data;
            if (data != null && data.ContainsKey(ParamDefine.maxHumidity) && data.ContainsKey(ParamDefine.maxTemperature))
            {
                string maxHumidity = data[ParamDefine.maxHumidity];
                string maxTemp = data[ParamDefine.maxTemperature];
                LogUtil.info(LOGGER, "收到服务器温湿度预警值：maxHumidity=" + maxHumidity + ",maxTemperature=" + maxTemp);

                try
                {
                    this.Max_Humidity = (float)Convert.ToDouble(maxHumidity);
                    this.Max_Temperature = (float)Convert.ToDouble(maxTemp);
                    LogUtil.info(LOGGER, "保存温湿度预警值：Max_Humidity=" + Max_Humidity + ",Max_Temperature=" + Max_Temperature);
                }
                catch (Exception ex)
                {
                    LogUtil.error("转换温湿度失败：" + ex.ToString());
                }
            }
        }
     
        private void ReviceOutStoreProcess(Operation resultOperation) {
            DateTime time = DateTime.Now;
            Dictionary<string, string> data = resultOperation.data;
             

            if (data != null && data.ContainsKey(ParamDefine.posId)
                   && data.ContainsKey(ParamDefine.plateH) && data.ContainsKey(ParamDefine.plateW))
            {
                char splitChar = '|';
                string[] posIdArray = data[ParamDefine.posId].Split(splitChar);
                string[] plateWArray = data[ParamDefine.plateW].Split(splitChar);
                string[] plateHArray = data[ParamDefine.plateH].Split(splitChar);

                //bool urgentReel =FormUtil. GetBoolData( data,ParamDefine.urgentReel);
                //bool cutReel= FormUtil.GetBoolData(data, ParamDefine.cutReel);
                //bool smallReel = FormUtil.GetBoolData(data, ParamDefine.smallReel);
                //string rfid = data.ContainsKey(ParamDefine.rfid) ? data[ParamDefine.rfid] : "";
                //int rfidLoc = FormUtil.GetIntData(data, ParamDefine.rfidLoc);
                string barcode = data.ContainsKey(ParamDefine.barcode) ? data[ParamDefine.barcode] : "";
                ////urgentReel: true 表示紧急料,需要出到料串上
                ////cutReel: true 表示分盘料,需要出到料串上
                ////smallReel: true  小料(7x8),放置到小料架上
                ////rfid: 分配的料架RFID
                ////rfidLoc: 料架的架位,值为 - 1时,可以自由分配皮带线, 小料时,架位为1 - 46优先走1 / 2号皮带线,47 - 92优先走3 / 4号皮带线, 70,71,72时只能分配到3 / 4号皮带线; 大料时,架位1 - 6优先走1 / 2号皮带线, 7 - 12优先走3 / 4号皮带线

                string dataStr = JsonHelper.SerializeObject(data);
                LogUtil.info(LOGGER, "收到服务器出库消息：【" + dataStr+"】");
              
                int index = -1;
                foreach (string posId in posIdArray)
                {
                    index++;
                    string plateW = plateWArray[index];
                    string plateH = plateHArray[index];
                    InOutPosInfo intouInfo = new InOutPosInfo(barcode, posId, plateW, plateH   );
                 
                    //根据发送的posId获取位置列表
                    ACSquareSPosition position = CSVPositionReader<ACSquareSPosition>.GetPositon(posId);
                    if (position == null)
                    {
                        //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                        WarnMsg = StoreName + "未找到库位：【" + intouInfo.ToStr() + "】";
                        LogUtil.error(LOGGER, WarnMsg);
                        continue;
                    }

                    try
                    {
                        //判断是否接收过此库位的出库信息
                        if (StoreMove.MoveType.Equals(StoreMoveType.OutStore) && StoreMove.MoveParam.PosInfo.PosId.Equals(posId))
                        {
                            LogUtil.info(LOGGER, StoreName + " 出库命令【" + intouInfo.ToStr() + "】重复，正在【" + posId + "】出库中");
                            continue;
                        }
                        else
                        {
                            //判断排队列表中是否已存在
                            List<InOutPosInfo> reviceList = new List<InOutPosInfo>(waitOutStoreList);
                            reviceList = (from m in reviceList where m.PosId.Equals(posId) select m).ToList<InOutPosInfo>();
                            if (reviceList.Count > 0)
                            {
                                LogUtil.debug(LOGGER, StoreName + " 出库命令【" + intouInfo.ToStr() + "】重复，排队列表中已存在【" + reviceList[0].ToStr() + "】");
                                continue;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        LogUtil.error("验证出库【" + intouInfo.ToStr() + "】是否重复出错：" + ex.ToString());
                    }

                    if (CanStarInOut()   || IsDebug )
                    {
                        bool result = StartOutStoreMove(new InOutParam(intouInfo));
                        if (!result)
                        {
                            LogUtil.info(LOGGER, StoreName + " 执行出库【" + intouInfo.ToStr() + "】失败，加入等待队列");
                            AddWaitOutInfo(intouInfo);
                        }
                    }
                    else
                    {
                        LogUtil.error(LOGGER, "执行出库【" + intouInfo.ToStr() + "】失败，当前在忙碌中，加入等待队列");
                        AddWaitOutInfo(intouInfo);
                    }
                    
                }
                TimeSpan span = DateTime.Now - time;
                if (span.TotalMilliseconds > 500)
                {
                    LogUtil.info(StoreName + "执行 ReviceOutStoreProcess 共处理了【" + span.TotalMilliseconds + "】毫秒");
                }
            }
        }
        #endregion


        public void CylinderMove(StoreMoveInfo moveInfo, string IoLowType, string IoHighType)
        {
            try
            {
                IOManager.IOMove(IoLowType, IO_VALUE.LOW);
                IOManager.IOMove(IoHighType, IO_VALUE.HIGH); 
            }
            catch (Exception ex)
            {
                LogUtil.error("CylinderMove  [" + IoLowType + "] [" + IoHighType + "] 出错：" + ex.ToString());
            }
            if (moveInfo != null)
            {
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoLowType, IO_VALUE.LOW));
                moveInfo.WaitList.Add(WaitResultInfo.WaitIO(IoHighType, IO_VALUE.HIGH));
            }
        }
    }
}