using CodeLibrary;
using DeviceLib;
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
{ 
    public partial class VerticalStoreBean : DeviceBase
    {
        private static bool IsIntSlvBlock = false; 
        public string CID = "";
        public VerticalStoreConfig Config; 
        public bool UseBuzzer = ConfigAppSettings.GetIntValue(Setting_Init.UseBuzzer).Equals(1);
        private System.Timers.Timer serverConnectTimer = new System.Timers.Timer();
        private System.Timers.Timer IoCheckTimer = new System.Timers.Timer();
        public AxisBean MiddleAxis = null;

        public VerticalStoreBean(VerticalStoreConfig 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;
            //添加调试
            if (config.IsInDebug == 1)
            {
                IsDebug = true;
            }
            Name = ("垂直货柜" + config.Id + " ").ToUpper();
            this.StoreID = config.Id;
            this.Config = config;
         
             
            MoveAxisConfig();
            List<VerticalPosition> positionList = CSVPositionReader<VerticalPosition>.getPositionList();
            PositionNumList = new List<string>();
            foreach (VerticalPosition position in positionList)
            {
                if (position.StoreId.Equals(StoreID))
                {
                    bool result = VerticalPosition.CheckPosition(position, Config);
                    if (result)
                    {
                        PositionNumList.Add(position.PositionNum);
                    }
                }
            }

            //初始化摄像机配置   
            IOManager.Init(); 
            IOManager.instance.ConnectionIOList(Config.DIODeviceNameList); 
            ACServerManager.LogEvent += ACServerManager_LogEvent;
            LEDManager.deviceMap.Add(Config.LED_IP, LEDBaseModule.GetModule(Config.LED_IP));

            MiddleAxis = new AxisBean(Config.Middle_Axis,"料斗旋转轴");
            mainTimer.Enabled = false;
            if (ConfigAppSettings.GetIntValue(Setting_Init.App_AutoRun).Equals(1))
            {
                mainTimer.Enabled = true;
            }
            Thread.Sleep(300);
            CloseAllLed();
        }


        public override bool StartRun()
        {
            LogUtil.info(Name + "开始启动 ");

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

            if (IOManager.IOValue(IO_Type.SuddenStop_BTN).Equals(IO_VALUE.HIGH))
            {
                if (!MiddleAxis.Open(true, out WarnMsg))
                {
                    return false;
                } 
                runStatus = StoreRunStatus.HomeMoving;
                StartReset();
                mainTimer.Enabled = true;
                IoCheckTimer.Enabled = true;
                serverConnectTimer.Enabled = true; 
                return true;
            }
            else
            {
                LogUtil.error(" (" + Name + ")启动出现错误：急停没开 ！启动失败！");
                return false;
            }
        }

        #region  复位处理

        
        public override void Reset(bool isNeedClearAuto = true)
        {
            //复位之前先停止运行
            if (isNeedClearAuto)
            {
                autoNext = false;
            }
            MoveInfo.EndMove();
            MiddleAxis.SuddenStop();
            runStatus = StoreRunStatus.Reset;
            if (!MiddleAxis.Open(true, out WarnMsg))
            {
                LogUtil.info(Name + "复位时打开轴失败，需要再次复位，直接报警停止复位");
                return;
            }
            mainTimer.Enabled = false;
            isInPro = false;
            StartReset();
            mainTimer.Enabled = true;
        }

        private void CloseAllLed()
        {
            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);
        }

        private void StartReset()
        { 
            WarnMsg = "";
            isInSuddenDown = false; 
            CurrInOutCount = 0;
            CurrInOutACount = 0;
            CloseAllLed();
            IOManager.IOMove(IO_Type.AutoRun_HddLed, IO_VALUE.HIGH);
            alarmType = StoreAlarmType.None;
            storeStatus = StoreStatus.ResetMove;
            MoveInfo.NewMove(MoveType.StoreReset);
            MoveInfo.NextMoveStep(StoreMoveStep.R01_WaitCloseDoor); 
            LogUtil.info(Name + "开始复位：等待光栅不被遮挡，关闭所有灯");
            MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(500));
            MoveInfo.WaitList.Add(WaitResultInfo.WaitIO(IO_Type.SafetyLightCurtains, IO_VALUE.HIGH));
            LEDManager.GetLedModule(Config.LED_IP).AllLightOff();
        }
    
        protected override void ResetProcess()
        {
            if (MoveInfo.IsInWait)
            {
                CheckWait();
            }
            if (MoveInfo.IsInWait)
            {
                return;
            }
            switch (MoveInfo.MoveStep)
            {
                case StoreMoveStep.R01_WaitCloseDoor:
                    Thread.Sleep(200);
                    MoveInfo.NextMoveStep(StoreMoveStep.R02_DoorClose);
                    ResetLog("复位： 关闭升降门");
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(2000)); 
                    DoorBean.StartClose(MoveInfo);
                    break;
                case StoreMoveStep.R02_DoorClose: 
                    MoveInfo.NextMoveStep(StoreMoveStep.R03_MiddleHome);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(3000));
                    ResetLog(" 复位：料斗旋转轴开始原点返回");
                    MiddleAxis.HomeMove(MoveInfo);
                    break;
                case StoreMoveStep.R03_MiddleHome:
                    MoveInfo.NextMoveStep(StoreMoveStep.R04_MiddleToP1);
                    MoveInfo.WaitList.Add(WaitResultInfo.WaitTime(1000));
                    ResetLog("复位：旋转轴到待机点P1");
                    MiddleAxis.AbsMove(MoveInfo, Config.MiddleAxis_P1, Config.MiddleAxis_P1_Speed); 
                    break;
                case StoreMoveStep.R04_MiddleToP1: 
                    LogUtil.info(Name + "复位完成");
                    runStatus = StoreRunStatus.Runing;
                    MoveInfo.EndMove();
                    storeStatus = StoreStatus.StoreOnline;
                    if (alarmType.Equals(StoreAlarmType.None))
                    {
                        WarnMsg = "";
                    }
                    break;
              

                default: break;
            }
        }

        internal void MoveAxisConfig()
        {
            VerticalStoreConfig.ConfigAxis(Config);

            moveAxisList = new List<ConfigMoveAxis>();
            Config.Middle_Axis.Axis_Brake_DO = IO_Type.Axis_Brake;
            Config.Middle_Axis.Axis_Run_DO = IO_Type.Run_Signal;
            moveAxisList.Add(Config.Middle_Axis); 

            this.AxisAlarmCodeMap = new Dictionary<string, AxisAlarmInfo>();
            foreach (ConfigMoveAxis axis in moveAxisList)
            {
                this.AxisAlarmCodeMap.Add(axis.GetNameStr(), new AxisAlarmInfo());
            }
        }

        #endregion
        public override void StopMove(bool IsCloseAxis = false)
        {
            IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
            MiddleAxis.SuddenStop();

            if (IsCloseAxis)
            {
                MiddleAxis.ServoOff();
            }
            LogUtil.info(Name + "StopMove");
            DoorBean.Stop();

            isInPro = false;
        }
        public override void StopRun()
        { 
            runStatus = StoreRunStatus.Wait;
            autoNext = false;
            IoCheckTimer.Enabled = false;
            serverConnectTimer.Enabled = false;
            mainTimer.Enabled = false;
            StopMove(true); 
            IOManager.instance.CloseAllDO();
            LEDManager.GetLedModule(Config.LED_IP).AllLightOff();
            LogUtil.info( Name + ",停止运行" );
        }

        public override void Alarm(StoreAlarmType alarmType, string alarmDetial, string alarmMsg, MoveType storeMoveType)
        {
            SaveAlarmInfo(alarmType, alarmDetial, alarmMsg, storeMoveType);
            autoNext = false;

            if (this.alarmType.Equals(alarmType) && alarmType != StoreAlarmType.SuddenStop && alarmType != StoreAlarmType.NoAirCheck)
            {
                return;
            }
            LogUtil.error ( Name + " 报警，报警类型：" + alarmType);

            this.alarmType = alarmType;
            if (alarmType.Equals(StoreAlarmType.AxisAlarm) | alarmType.Equals(StoreAlarmType.AxisMoveError))
            {
                LogUtil.error ( Name + "轴报警，关闭刹车，停止运动，关闭轴，打开报警灯");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                StopMove(true);
            }
            else if (alarmType == StoreAlarmType.SuddenStop)
            {
                isInSuddenDown = true;
                LogUtil.error ( Name + "收到急停信号，关闭刹车，停止运动，关闭轴，打开报警灯 ");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                MoveInfo.EndMove();
                StopMove(true);
                storeStatus = StoreStatus.SuddenStop;
            }
            else if (alarmType.Equals(StoreAlarmType.NoAirCheck))
            { 
                LogUtil.error ( Name + " 未检测到气压信号 ,打开刹车，停止运动，关闭轴，打开报警灯 ");
                IOManager.IOMove(IO_Type.Axis_Brake, IO_VALUE.LOW);
                MoveInfo.EndMove();
                StopMove(true);
                storeStatus = StoreStatus.SuddenStop;
            } 
        }

        #region 定时器处理

        private bool InProcess = false;
        private Stopwatch stopwatch = new Stopwatch(); 
        private IO_VALUE lastAutoRun = IO_VALUE.LOW;
        protected override void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (InProcess && stopwatch.Elapsed.TotalSeconds < 30)
            {
                return;
            }
            try
            {
                InProcess = true;
                stopwatch.Restart();
                IoCheckProcess();
                TimerProcess();
                //检查运动轴报警
                if (runStatus > StoreRunStatus.Wait && (!isInSuddenDown) )
                {
                    CheckAxisAlarm();
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "定时处理出错：" + ex.ToString());
            }
            InProcess = false;
        } 

        private void IoCheckProcess()
        {
            DateTime time = DateTime.Now;
            if (runStatus.Equals(StoreRunStatus.Wait))
            {
                //取新的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(Name + "没有启动时收到复位按钮，相当于启动按钮，开始调用启动方法！");
                        bool result = StartRun();
                        if (result.Equals(false))
                        {
                            LogUtil.error("料仓启动失败，继续等待下次启动！");
                            mainTimer.Enabled = true;
                        }
                    }
                    lastAutoRun = autoSingle;
                    return;
                }
                lastAutoRun = autoSingle;
            }
            //判断急停 
            else if (runStatus >= StoreRunStatus.HomeMoving)
            {
                //取新的Io状态 
                IO_VALUE suddenBtn = IOManager.IOValue(IO_Type.SuddenStop_BTN);
                IO_VALUE resetBtn = IOManager.IOValue(IO_Type.Reset_BTN);

              if (resetBtn.Equals(IO_VALUE.HIGH))
                {
                    //收到复位信号，若报警直接复位，若不报警且无操作，回到待机点
                    if (alarmType.Equals(StoreAlarmType.None) && isInSuddenDown.Equals(false) )
                    {
                        if (MoveInfo.MoveType.Equals(MoveType.None))
                        {
                            LogUtil.info("收到复位信号但是没有报警，且当前无操作，暂不复位"); 
                        }
                        else
                        {
                            LogUtil.info("收到复位信号但是已经在" + MoveInfo.MoveType + "处理中，且无报警，不处理"); 
                        }
                    }
                    else
                    {
                        //判断已经在复位中并且没有报警，不需要重新复位
                        if (MoveInfo.MoveType.Equals(MoveType.StoreReset) && alarmType.Equals(StoreAlarmType.None))
                        {
                            LogUtil.error("收到复位信号：已经在复位中且没有报警，不需要重新复位！");
                        }
                        else
                        {
                            //收到复位信号
                            LogUtil.info("收到复位信号，自动复位");
                            WarnMsg = "收到复位信号，自动复位";
                            Reset();
                        }
                    }
                }
            }
             
        }

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

                        //报警时会关闭所有轴
                        Alarm(StoreAlarmType.SuddenStop, "1", WarnMsg, MoveType.None);
                    }
                }
                else
                {
                    //光栅处理
                    SafetyLightProcess();
                }
            }
        }


        private void TimerProcess()
        {
            try
            {
                DateTime time = DateTime.Now;
                if (MoveInfo.MoveType != MoveType.None)
                {
                    BusyMoveProcess();
                }
                else if (runStatus.Equals(StoreRunStatus.Runing))
                {  
                    IOTimeOutProcess();

                }
            
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "定时处理出错" + ex.ToString());
            }
        }
         

        private DateTime preIoTimerOutTime = DateTime.Now;
        private void IOTimeOutProcess()
        {
            try
            {
                TimeSpan span = DateTime.Now - preIoTimerOutTime;
                if (span.TotalSeconds > 1)
                {
                    preIoTimerOutTime = DateTime.Now;
                    if (!alarmType.Equals(StoreAlarmType.IoSingleTimeOut))
                    {
                        return;
                    }
                    if (runStatus < StoreRunStatus.Runing)
                    {
                        return;
                    }
                    if (isInSuddenDown  )
                    {
                        return;
                    }

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

       
        private DateTime checkAlarmTime = DateTime.Now;
        private bool CheckAxisAlarm()
        {
            if (alarmType.Equals(StoreAlarmType.AxisAlarm) || alarmType.Equals(StoreAlarmType.AxisMoveError))
            {
                return true;
            }
            TimeSpan span = DateTime.Now - checkAlarmTime;
            //在回原点，复位，出入库时，检测报警间隔减小
            if (runStatus.Equals(StoreRunStatus.Busy) || runStatus.Equals(StoreRunStatus.HomeMoving) || runStatus.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 = Name + " 运动轴" + axisInfo.Explain + "报警";
                    info.AlarmIoValue = alarmIo;
                    Alarm(StoreAlarmType.AxisAlarm, axisInfo.ProName, WarnMsg, MoveType.None);
                    isInAlarm = true;
                }
                else
                {
                    if (!info.AlarmIoValue.Equals(alarmIo))
                    {
                        LogUtil.error(Name + "  运动轴  " + axisInfo.Explain + "，报警已解除！");
                        info.AlarmIoValue = alarmIo;
                    }
                }
                AxisAlarmCodeMap[deviceName] = info;
            }
            //});
            //判断报警状态
            return isInAlarm;
        }
        #endregion

        #region 光栅处理
        private object safetyInProcess = "";

        private void SafetyLightProcess()
        {
            if (Monitor.TryEnter(safetyInProcess))
            {
                try
                {
                    //遮挡光栅信号
                    if (IOManager.IOValue(IO_Type.SafetyLightCurtains).Equals(IO_VALUE.LOW))
                    {
                        if (NeedCheckSafetyLight.Equals(1))
                        {
                            //if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.IsStep(StoreMoveStep.SO_13_InoutToP2))
                            //{
                            //    NeedCheckSafetyLight = 2;
                            //    LogUtil.info("出库 " + MoveInfo.MoveStep + " 运动中，光栅被遮挡，停止进出轴运动");
                            //    ACServerManager.SuddenStop(Config.InOut_Axis.DeviceName, Config.InOut_Axis.GetAxisValue());
                            //}
                            //else if (MoveInfo.MoveType.Equals(MoveType.InStore) && MoveInfo.IsStep(StoreMoveStep.SI_05_InoutToP2))
                            //{
                            //    NeedCheckSafetyLight = 2;
                            //    LogUtil.info("入库 "+ MoveInfo.MoveStep + " 运动中，光栅被遮挡，停止进出轴运动");
                            //    ACServerManager.SuddenStop(Config.InOut_Axis.DeviceName, Config.InOut_Axis.GetAxisValue());
                            //}
                        }
                    }
                    else
                    {
                        if (NeedCheckSafetyLight.Equals(2))
                        {
                            //if (MoveInfo.MoveType.Equals(MoveType.OutStore) && MoveInfo.IsStep(StoreMoveStep.SO_13_InoutToP2))
                            //{
                            //    LogUtil.info("出库 " + MoveInfo.MoveStep + " 运动中，光栅已恢复，继续进出轴运动");
                            //    SO_13_InoutToP2();
                            //}
                            //else if (MoveInfo.MoveType.Equals(MoveType.InStore) && MoveInfo.IsStep(StoreMoveStep.SI_05_InoutToP2))
                            //{
                            //    LogUtil.info("入库 " + MoveInfo.MoveStep + " 运动中，光栅已恢复，继续进出轴运动");
                            //    SI_05_InoutToP2();
                            //}
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.error("光栅处理出错：" + ex.ToString());
                }
                finally
                {
                    Monitor.Exit(safetyInProcess);
                }
            }
        }

        #endregion

   
   
         
        public bool CanStarInOut()
        {
            if (isInSuddenDown ||  
              (!runStatus.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 float Max_Humidity = 0; 
        private float Max_Temperature = 0;

        public string currTempStr = "";
        private void HumidityProcess()
        {
            try
            {
                ASTemperateParam param = HumitureController.ColdLastData;
                currTempStr = "";
                if (param != null)
                {
                    currTempStr = ("冷藏区湿度：" + param.Humidity.ToString() + " 温度：" + param.Temperate.ToString() + " \n ");
                }
                param = HumitureController.WarmLastData;
                if (param != null)
                {
                    currTempStr += ("回温区湿度：" + param.Humidity.ToString() + " 温度：" + param.Temperate.ToString() + "\n ");
                }
            }
            catch (Exception ex)
            {
                LogUtil.error(Name + "HumidityProcess出错：" + ex.ToString());
            }
        }
        private bool isInProcess = false;
        public void server_connect_timer_Tick(object sender, EventArgs e)
        {
            if (isInProcess)
            {
                return;
            }
            isInProcess = true;
            if (StoreManager.IsConnectServer)
            {
                try
                {
                    SendLineStatus();
                }
                catch (Exception ex)
                {
                    LogUtil.error("定时给服务器发送消息出错：" + ex.ToString());
                }
            } 
            HumidityProcess();
            LedProcess();
            isInProcess = false;
        }
        
        private  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;
            }
          
            lineOperation.status = (int)StoreStatus.StoreOnline;

            BoxStatus boxStatus = new BoxStatus();
            boxStatus.boxId = StoreID;

            //状态
            boxStatus.status = (int)storeStatus;

            if (IsDebug)
            {
                boxStatus.status = (int)StoreStatus.Debugging;
            }
            boxStatus.msg = WarnMsg;
            lineOperation.msg = 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);
            }
            else if (!lastPosId.Equals(""))
            {
                boxStatus.data.Add(ParamDefine.posId, lastPosId);
                boxStatus.status = (int)lastPosIdStatus;
                if (lastPosId != "")
                {
                    LogUtil.info( "给服务器发送出入库完成消息：" + Name + ",status【" + lastPosIdStatus + "】posId【" + lastPosId + "】");
                }
                lastPosId = "";
            }

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

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

        private  void SendLineStatus()
        {
            DateTime time = DateTime.Now;
            //构建发送给服务器的对象
            Operation lineOperation = getLineBoxStatus();
            //如果还没湿度范围，先获取
            if (Max_Humidity <= 0 || (Max_Temperature <= 0))
            {
                lineOperation.op = 5;
                LogUtil.info( Name + "没有湿度预警范围，需要从服务器获取，发送OP=" + lineOperation.op);
            }
            string server = ConfigAppSettings.GetValue(Setting_Init.http_server);
            Operation resultOperation = HttpHelper.Post(StoreManager.GetPostApi(server), lineOperation, false);

            //发送状态信息到服务器 
            if (resultOperation == null || (resultOperation.op <= 0))
            {
                //判断服务端是否返回出库操作
                return;
            }
            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 + "，未找到对应处理");
            }
            TimeSpan span = DateTime.Now - time;
            if (span.TotalMilliseconds > 10)
            {
                LogUtil.info(Name + "执行TimerProcess 共处理了【" + 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( "收到服务器温湿度预警值：maxHumidity=" + maxHumidity + ",maxTemperature=" + maxTemp);

                try
                {
                    this.Max_Humidity = (float)Convert.ToDouble(maxHumidity);
                    this.Max_Temperature = (float)Convert.ToDouble(maxTemp);
                    LogUtil.info( "保存温湿度预警值：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))
            {
                string posIdStr = data[ParamDefine.posId];
                string plateWStr = data[ParamDefine.plateW];
                string plateHStr = data[ParamDefine.plateH];

                LogUtil.info("收到服务器出库消息：poaIs=" + posIdStr + ",platew=" + plateWStr + ",plateh=" + plateHStr);
                char splitChar = '|';
                string[] posIdArray = posIdStr.Split(splitChar);
                string[] plateWArray = plateWStr.Split(splitChar);
                string[] plateHArray = plateHStr.Split(splitChar);
                int index = -1;
                foreach (string posId in posIdArray)
                {
                    index++;
                    int plateW = Convert.ToInt32(plateWArray[index]);
                    int plateH = Convert.ToInt32(plateHArray[index]);
                    string[] posArray = posId.Split('#');
                    if (posArray.Length != 2)
                    {
                        WarnMsg = Name + "出库格式错误：库位号【" + posId + "】";
                        LogUtil.error("收到服务器出库命令：库位号【" + posId + "】格式错误");
                        continue;
                    }
                    int storeId = int.Parse(posArray[0]);

                    //根据发送的posId获取位置列表
                    VerticalPosition position = CSVPositionReader<VerticalPosition>.GetPositon(posId);
                    if (position == null)
                    {
                        //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                        WarnMsg = Name + "出库未找库位：【" + posId + "】";
                        LogUtil.error("收到服务器出库命令：未找到【" + posId + "】的库位信息");
                        continue;
                    }
                    else
                    {
                        InOutParam currInOutFixture = new InOutParam(MoveType.OutStore, posId, "", plateW, plateH);
                        //if (CanStarInOut())
                        //{
                        //    bool result = StartOutStore(currInOutFixture);
                        //    if (!result)
                        //    {
                        //        LogUtil.info(Name + " 执行出库【" + currInOutFixture.ToStr() + "】失败，加入等待队列");
                        //        AddWaitMoveParam(currInOutFixture);
                        //    }
                        //}
                        //else
                        //{
                        //    LogUtil.error("执行出库【" + currInOutFixture.ToStr() + "】失败，当前在忙碌中，加入等待队列");
                        //    AddWaitMoveParam(currInOutFixture);
                        //}
                    }

                }
                TimeSpan span = DateTime.Now - time;
                if (span.TotalMilliseconds > 10)
                {
                    LogUtil.info(Name + "执行TimerProcess 共处理了【" + span.TotalMilliseconds + "】毫秒");
                }
            }
        }

        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：料盘高度，
                //postId格式BoxId#位置
                string posId = data[ParamDefine.posId];
                int plateW = Convert.ToInt32(data[ParamDefine.plateW].Trim());
                int plateH = Convert.ToInt32(data[ParamDefine.plateH].Trim());
                string[] posArray = posId.Split('#');
                if (!(posArray.Length == 2))
                {
                    WarnMsg = Name + "入库库位格式错误：二维码【" + message + "】库位【" + posId + "】";
                    LogUtil.error("服务器反馈   入库库位格式错误：二维码【" + message + "】库位【" + posId + "】");
                    return;
                }

                int storeId = int.Parse(posArray[0]);
                //根据发送的posId获取位置列表
                VerticalPosition position = CSVPositionReader<VerticalPosition>.GetPositon(posId);
                if (position == null)
                {
                    //出入库没有找到服务器发送的库位，需要打印日志方便查询原因
                    WarnMsg = "入库未找到库位：二维码【" + message + "】库位【" + posId + "】 ";
                    LogUtil.error("收到服务器入库命令：入库未找到库位：二维码【" + message + "】库位【" + posId + "】");
                    return;
                }
                //TODO:判断BOX是否处于可以入库状态，如果调试或急停中，需要返回给服务器；
                if (CanStarInOut())
                { 
                    InOutParam param = new InOutParam(MoveType.InStore, posId, message, plateH, plateW);

                    StartInStore(param);
                    //如果当前正在出入库中，需要记录下来，等待空闲时执行
                    LogUtil.info(Name + " 收到服务器入库命令：库位号【" + posId + "】二维码【" + message + "】 开始入库！");
                }
                else
                {
                    LogUtil.info(Name + " 收到服务器入库命令：库位号【" + posId + "】二维码【" + message + "】 正在忙碌中，无法入库！"); 
                }
            }

        }
        private void LedProcess()
        {
            try
            {
                //                机器状态 顶灯显示 
                //                                              绿 黄  红
                //机器复位中                             闪 灭   灭
                //机器待机中                             亮 灭   灭
                //机器出入库中                          闪 闪   灭
                //温湿度超限报警中                   亮 闪   灭
                //温湿度超限报警中超过30分钟  亮 闪   闪
                //机器未启动                             灭 灭   灭
                //机器设备故障(非温湿度)报警    亮   灭 闪

                //报警时只需要亮红灯

                DateTime time = DateTime.Now;
               
                bool isNeedAlarmLed = false;
                //报警灯
                if (!alarmType.Equals(StoreAlarmType.None)  )
                {
                    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 (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);
                    }
                    if (UseBuzzer && IOManager.IOValue(IO_Type.Alarm_Buzzer).Equals(IO_VALUE.LOW))
                    {
                        IOManager.IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.HIGH);
                    }
                    return;
                }

                if (!UseBuzzer)
                {
                    IOManager.IOMove(IO_Type.Alarm_Buzzer, IO_VALUE.LOW);
                }

                //绿灯闪
                if ((MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore)
                  || runStatus.Equals(StoreRunStatus.HomeMoving) || runStatus.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 (MoveInfo.MoveType.Equals(MoveType.InStore) || MoveInfo.MoveType.Equals(MoveType.OutStore)    )
                {
                    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)
            {
                LogUtil.error(Name + "灯处理定时器出错：" + ex.ToString());
            }
        }
        #endregion

        private void AxisSuddenStop(ConfigMoveAxis axis)
        {
            ACServerManager.SuddenStop(axis.DeviceName, axis.GetAxisValue());
        }
        private static void ACServerManager_LogEvent(InfoType type, string msg)
        {
            if (type.Equals(InfoType.Error))
            {
                LogUtil.error(msg);
            }
            else if (type.Equals(InfoType.Info))
            {
                LogUtil.info(msg);
            }
            else
            {
                LogUtil.debug(msg);
            }
        }

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

        }
        public virtual string GetMoveStr()
        {
            string msg = ""; 
            msg += "" + runStatus +" _ "+ storeStatus+ " _ "+ alarmType+"\n";  
            msg +=  MoveInfo.MoveType + " _ "+MoveInfo.MoveStep + "\n"; 
            msg += currTempStr;
            return msg;
        }
    }
}