using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.Data;
using System;
using CommLayerFactory;
using ICommLayer;
using DBFactory;
using CommonLib;
using Model;
using System.Security.AccessControl;
using OPCClient;

namespace WcfControlMonitorLib
{
    
    /// <summary>
    /// Creator:Richard.liu
    /// 监控调度类
    /// </summary>
   
    public class CControl
    {//20230811richard.liu周期内按S7连接批量发送，重构CControl.cs\文件夹Communication、Common内通讯相关文件
        /// <summary>
        /// 一个周期内一个S7连接发送所有标签的个数
        /// </summary>
        Dictionary<string, int> OpcS7TagCount = new Dictionary<string, int>();
        /// <summary>
        /// 每个PLC连接里对应设备发送标签名称集合
        /// </summary>
        Dictionary<string,Dictionary<int,StringBuilder[]>> OPCItemNamesDicInfo = new Dictionary<string,Dictionary<int, StringBuilder[]>>();
        /// <summary>
        /// 每个PLC连接里对应设备发送标签数值集合
        /// </summary>
        Dictionary<string, Dictionary<int, StringBuilder[]>> OPCItemValuesDicInfo = new Dictionary<string, Dictionary<int, StringBuilder[]>>();
        /// <summary>
        ///  S7连接设备一个周期内发送设备索引和指令索引
        /// </summary>
        Dictionary<string, List<int> >OPCS7connDeviceSendTaskIndexdic = new Dictionary<string, List<int>>();
        
        int StackMutexXCoor = 4800;
        int minStackMutexXCoor = 2400;
        int StackZeroXCoor = 1950;
        StringBuilder AheadDetectUnallow = new StringBuilder();//20110505
        StringBuilder sql = new StringBuilder();
        char[] dd = new char[1] { '.' };//20101124
        string[] DS;//20101124
        private Object thisLock = new Object();
        DBOperator dbo =CStaticClass.dbo;
        DBOperator dboM = CStaticClass.dboM;
        Model.MDevice devinfocheck;
        
        Model.MDevice devinfo;
        ISendDeviceOrder sdo;
        CCommonFunction ccf = new CCommonFunction();
        int _DeviceIdx = 0;//设备索引
        int _routeID = 0;//路径唯一索引
        int _serialNumber = 0;//路径上的设备方向性链表的序号
        int _ManageTaskIdx = 0;//调度任务索引
        int _ManageKindIdx = 0;//调度任务类型
        int _DeviceOrder = 0;//设备命令
        int _LockedState = 0;
        int _Associate = 0;
        int _ManTaskReserve = 0;
        string _AheadDetect = "";
        int _NumParam1=0;
        int _NumParam2 = 0;
        int _NumParam3 = 0;
        int _NumParam4 = 0;
        int _NumParam5 = 0;
        int _NumParam6 = 0;
        string _TxtParam = "-";
        int _DeviceKind = 0;
        int _OutsideAltDevice = 0;
        int _InsideAltDevice = 0;
        int _StartDevice = 0;
        int _EndDevice = 0;
        int _RouteKind = 0;
       
        
        //int _UseAwayFork = 1;
        int _AgvNo = 65535;
        string _CControlError = "";//监控调度类错误说明
        public string CControlError
        {
            get { return _CControlError; }
            set { _CControlError = value;
            RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", _CControlError);
            OnRefreshMonitor(rme);
            }
        }
        public static event CDataSourceChangeEventHandler DataChange;
        public static void OnDataChange(object sender,CDataChangeEventArgs e)
        {
            if (DataChange != null)
            {
                DataChange(sender, e);
            }
        }
        public static event RefreshMonitorEventHandler RefreshMonitor;
        public static void OnRefreshMonitor(RefreshMonitorEventArgs e)
        {
            if (RefreshMonitor != null)
            {
                RefreshMonitor(e);
            }
        }
        public CControl()
        {
            //dbo.Open();
        }
        //~CControl()
        //{
        //    dbo.Close();
        //}
        public void StartOrder()
        {
            //首先检测第一个调度任务单的“第一个”（所有剩下中的第一个）设备是否被占用，被占用则执行下一个调度任务单；
            //然后检测第一个设备的F_AheadDetect都是否满足条件，不满足，则执行下一个调度任务单；
            //最后开始执行时检查同步运行的关联设备F_AssociateDeviceIndex,准备给该设备发指令；
            //更改作业记录的状态F_Status为1,更改设备为占用状态（T_Base_device的F_LockedState=设备指令单）
            //给调度任务表回写调度任务IO_Control的正在执行状态FSTATUS=1;T_Manage_Task的正在执行状态FSTATUS=1
            //路径明细表F_LockedDeviceIndex里的所有对应设备索引加锁，但是关联设备不加锁
            StringBuilder  taskkind =new StringBuilder() ;
            DataView dv = new DataView(); DataView dvM = new DataView();
            try
            {
                if (CStaticClass.Order == true)
                {
                    taskkind.Append(" (F_ManageTaskKindIndex = 1 or F_ManageTaskKindIndex = 2 or F_ManageTaskKindIndex = 4) "); //调度任务与调度生成的自动任务
                }
                else
                {
                    return;
                }
                dvM = new DataView();
                char[] sep = new char[1] { '-' };
                //获得管理单据
                sql.Remove(0, sql.Length);
                //20120820
                sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task where ").Append(
                    taskkind.ToString()).Append(" and f_no1='1' and f_status=0 order by F_ManageTaskKindIndex desc, F_MonitorTaskLevel desc,F_ManageTaskIndex asc,F_SplitTime asc");

                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    for (int i = 0; i < dv.Count; i++)
                    {
                        try
                        {
                            SendMonitorTask(Convert.ToInt32(dv[i]["F_MonitorIndex"]));
                        }
                        catch (Exception ex)
                        {
                            CControlError = string.Format("发送命令调用StartOrder时：{0}", ex.StackTrace+ex.Message);
                        }
                    }//for语句结束
                    //20230811richard.liu
                    #region 按S7通讯连接发送批量数据20230811richard.liu
                    StringBuilder[] itmenames=new StringBuilder[0];
                    StringBuilder[] itmevalues=new StringBuilder[0];
                    foreach (string s7conn in OPCItemNamesDicInfo.Keys)
                    {
                        itmenames = new StringBuilder[OpcS7TagCount[s7conn]];
                        itmevalues= new StringBuilder[OpcS7TagCount[s7conn]];
                        int deviceTagCount = 0;
                        int devindexone = 0;
                        foreach (int devidx in OPCItemNamesDicInfo[s7conn].Keys)
                        {
                            devindexone = devidx;
                            Array.Copy(OPCItemNamesDicInfo[s7conn][devidx], 0, itmenames, deviceTagCount, OPCItemNamesDicInfo[s7conn][devidx].Length);
                            Array.Copy(OPCItemValuesDicInfo[s7conn][devidx], 0, itmevalues, deviceTagCount, OPCItemValuesDicInfo[s7conn][devidx].Length);
                            deviceTagCount += OPCItemNamesDicInfo[s7conn][devidx].Length;
                        }
                        
                        sdo = CommModeCreate.CreateSendDeviceOrder(devindexone);
                        if (sdo.WriteDBData(itmenames, itmevalues, s7conn) == false)
                        {//20231017 S7连接设备发送失败
                            //回滚发送成功的数据F_SendFlag,F_StartTime,F_Status,F_SendCount,F_LockedState；直穿和堆垛机 取货的T_Base_Device 的F_ManTaskReserve
                            foreach (var deviceTask in OPCS7connDeviceSendTaskIndexdic[s7conn])
                            {
                                sql.Clear();
                                sql.Append("update T_Monitor_Task set F_SendFlag='0',F_StartTime='-',F_Status=0,F_SendCount=F_SendCount-1,F_Status=0 where F_MonitorIndex=").Append(deviceTask);
                                dbo.ExceSQL(sql.ToString());
                                sql.Clear();
                                sql.Append("update T_Base_device set F_LockedState=0 where F_LockedState=").Append(deviceTask);
                                dbo.ExceSQL(sql.ToString());
                                //直穿和堆垛机 取货的T_Base_Device 的F_ManTaskReserve=0
                                int devidx= ccf.GetDeviceindexFromMonitor(deviceTask);
                                int devkind=ccf.GetDeviceKindIdx(devidx);
                                int devorder=ccf.GetDeviceOrderFromMonitor(deviceTask);
                                int mankind=ccf.GetManageTaskKindIndexFromMonitor(deviceTask);
                                int manFid = ccf.GetManageTaskIndexFromMonitor(deviceTask);
                                if ((devkind ==1 && devorder==4) || (devkind == 4 && devorder == 2))
                                {
                                    sql.Clear();
                                    sql.Append("update T_Base_device set F_ManTaskReserve=0 where F_ManTaskReserve=").Append(mankind).Append(manFid);
                                    dbo.ExceSQL(sql.ToString());
                                }
                            }
                            if (sdo.CommLayerError != null)
                            {
                                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", sdo.CommLayerError);
                                OnRefreshMonitor(rmea);
                            }
                           
                        }
                        
                    }
                    OPCItemNamesDicInfo.Clear();
                    OPCItemValuesDicInfo.Clear();
                    OpcS7TagCount.Clear();
                    OPCS7connDeviceSendTaskIndexdic.Clear();

                    #endregion
                    return;
                }
                else
                {
                    return;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dvM.Dispose();
            }
        }
        /// <summary>
        /// 提取每个管理单据的第一个设备是否被锁定,true表示被锁定；false表示空闲
        /// </summary>
        /// <param name="minMidx">调度任务号</param>
        /// <returns>true表示被锁定；false表示空闲</returns>
        public bool GetFirstDeviceIFLocked(int minMidx, bool checkLockedstate)
        {
            char[] sep = new char[1] { '-' };
            int msgIdx = 0;//消息编号
            int adidx = 0;//关联设备的设备指令索引
            DataView dv = new DataView();
            try
            {
                //获得要发送的信息
                if (GetSendInfo(minMidx) == false)
                {//20120420
                    return true;
                }
                int DeviceIdx = _DeviceIdx;//设备索引
                int routeID = _routeID;//路径唯一索引
                int serialNumber = _serialNumber;//路径上的设备方向性链表的序号
                int ManageTaskIdx = _ManageTaskIdx;//调度任务索引
                int ManageKindIdx = _ManageKindIdx;//调度任务类型
                int DeviceOrder = _DeviceOrder;//设备命令
                int LockedState = _LockedState;
                int Associate = _Associate;
                int ManTaskReserve = _ManTaskReserve;
                string AheadDetect = _AheadDetect;
                int NumParam1 = _NumParam1;
                int NumParam2 = _NumParam2;
                int NumParam3 = _NumParam3;
                int NumParam4 = _NumParam4;
                int NumParam5 = _NumParam5;
                int NumParam6 = _NumParam6;
                string TxtParam = _TxtParam;
                int DeviceKind = _DeviceKind;
                int OutsideAltDevice = _OutsideAltDevice;
                int InsideAltDevice = _InsideAltDevice;
                int StartDevice = _StartDevice;
                int EndDevice = _EndDevice;
                int RouteKind = _RouteKind;
                int AgvNo = _AgvNo;

                #region 设备故障时是否自动改道
                
                if (CStaticClass.DeviceErrorAutoModifyRoutePath == "1")
                {//20100108
                    #region 只针对与RGV有关的五个动作判断改路径
                    //20100108 输送机的接货对接指令不参与改道
                    if ((_DeviceKind == 4) || ((_DeviceKind == 2) && ((_DeviceOrder == 3))) && (RouteKind != 3))
                    {
                        bool IfModify = false, IfUseNegativeDevice = false;//20100610
                        //20091102 RGV的第一个被提前触发的运动指令不需要更改路径
                        if ((_DeviceKind == 4) && (_DeviceOrder == 7) &&
                            (ccf.GetSerialNumberFromRouteDevice(_routeID, _DeviceIdx) >
                            ccf.GetSerialNumberFromRouteDevice(_routeID, _NumParam1)))
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT MIN(F_MonitorIndex) AS mmi FROM T_Monitor_Task WHERE (F_ManageTaskIndex = " ).Append( ManageTaskIdx ).Append( ") AND (F_ManageTASKKINDINDEX = 1)");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                //20091218

                                if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() == minMidx.ToString()))
                                {
                                    IfModify = true;
                                    IfUseNegativeDevice = true;//20100610
                                }
                            }
                            
                        }
                        else if ((_DeviceKind == 4) && ((_DeviceOrder == 3) || (_DeviceOrder == 5)))
                        {//20100108对穿梭车送货对接应该加于限制，载货，空闲
                            devinfo = Model.CGetInfo.DeviceInfo[DeviceIdx];
                            if ((devinfo.RunState == 0) && (devinfo.HaveGoods == true))
                            {
                                IfModify = true;
                                IfUseNegativeDevice = false;//20100610
                            }
                            devinfo = null;
                        }
                        else
                        {
                            IfModify = true;
                            IfUseNegativeDevice = true;//20100610

                        }
                        if (IfModify == true)
                        {
                            int altsn = ccf.GetSerialNumberFromRouteDevice(_routeID, _OutsideAltDevice);
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_SerialNumber FROM T_Base_Device,T_Base_Route_Device,T_Base_Device_State where " ).Append(
                            " T_Base_Device.F_DeviceIndex = T_Base_Route_Device.F_DeviceIndex and F_ErrorCode =F_DeviceErrorIndex and " ).Append(
                            " T_Base_Device_State.F_DeviceKindIndex = T_Base_Device.F_DeviceKindIndex AND T_Base_Device.F_ErrorCode > 0 AND " ).Append(
                            " T_Base_Route_Device.F_SerialNumber > " ).Append( _serialNumber ).Append( " AND T_Base_Route_Device.F_SerialNumber > " ).Append(
                            altsn ).Append( " AND T_Base_Route_Device.F_RouteIDSub = " ).Append( _routeID ).Append( " and F_ErrorLevel=2 "); 
                            dv= dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                //判断能否改道;向管理申请改道;把ManageTaskIdx，ManageKindIdx 的调度任务全部申请改道
                                if (GetUsableDestination(_ManageTaskIdx, _ManageKindIdx) == true)
                                {
                                    
                                    return true;
                                }
                            }
                            #region RGV目标位置被占用需要申请改道
                            //20100610
                            devinfo = null;
                            if (_DeviceKind == 4)
                            {//RGV
                                devinfo = Model.CGetInfo.GetDeviceInfo(CDisassembleTask.GetNextDevice(_routeID, _serialNumber)[0]);
                            }
                            else
                            {//输送机送货
                                devinfo = Model.CGetInfo.GetDeviceInfo(CDisassembleTask.GetNextDevice(_routeID, _serialNumber)[0]);//RGV
                                int sn = 0;
                                if (devinfo != null)
                                {
                                    sn = ccf.GetSerialNumberFromRouteDevice(_routeID, devinfo.DeviceIndex);
                                }
                                devinfo  = Model.CGetInfo.GetDeviceInfo(CDisassembleTask.GetNextDevice(_routeID, sn)[0]);//接货输送机
                                
                            }
                            if (devinfo != null)
                            {
                                if (devinfo.HaveGoods == true)
                                {//目标位置被占用，申请改道
                                    if (GetRGVIdleDestination(_ManageTaskIdx, _ManageKindIdx, devinfo.DeviceIndex, IfUseNegativeDevice) == true)
                                    {
                                        return true;
                                    }
                                }
                            }
                            #endregion
                        }
                        
                    }
                    #endregion

                }

                #endregion
                if (DeviceKind == 6)
                {//20100512 AGV
                    #region AGV
                    if (AgvNo != 65535)//如果是已经分配车号的AGV命令，检查这个车号对应的设备索引是否被锁定
                    {
                        LockedState = Convert.ToInt32(dbo.GetSingle("SELECT F_LockedState FROM T_Base_Device where F_DeviceIndex=" + (DeviceIdx + AgvNo) + ""));
                        if(LockedState>0)return true;
                    }
                    if (AheadDetectOK(minMidx, _AheadDetect) == true)//提前检测通过
                    {
                        #region 双叉AGV检测，能同步的关联任务是否AheadDetectOK
                        //20100323
                        devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
                        if (devinfo.IfCorrelDoubleFork == "1")
                        {
                            int[] synctask=Model.CGeneralFunction.MutiForkIfSync(minMidx, _DeviceIdx, _DeviceKind);
                            if (synctask != null)//20120616
                            {
                                if((synctask.GetLength(0)==1)&&(synctask[0]==minMidx ))return true;//20120616等待未拆分的可同步执行的任务
                                string[] df =null;
                                Dictionary<int,string[]> mforkmonitorinfo= Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, _DeviceIdx);
                                foreach (int i in mforkmonitorinfo.Keys)
                                {
                                    df = mforkmonitorinfo[i];
                                    if (df != null)
                                    {
                                        if (AheadDetectOK(Convert.ToInt32(df[0]), df[1]) == false)//多叉关联提前检测失败
                                        {
                                            return true;
                                        }
                                        #region 关联指令不是第一个指令不能发送
                                        int rmankind = Model.CGeneralFunction.GetManageTaskKindIndexFromMonitor(Convert.ToInt32(df[0]));
                                        int rman = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(Convert.ToInt32(df[0]));
                                        sql.Remove(0, sql.Length);
                                        sql.Append("SELECT MIN(F_MonitorIndex) AS mmi FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(rman).Append(") AND (F_ManageTASKKINDINDEX = ").Append(rmankind).Append(")");
                                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                        if (dv.Count > 0)
                                        {
                                            if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() != df[0]))
                                            {
                                                return true;
                                            }
                                        }
                                        #endregion
                                    }
                                }
                            }
                        }
                        #endregion
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                    #endregion
                }
                else
                {//非AGV设备：输送机、堆垛机、RGV等
                    #region 非AGV设备：输送机、堆垛机、RGV等
                    //第一个设备是否被占用，RGV和堆垛机要考虑分步控制时，没执行完连续动作时不接受新的调度任务
                    if (((_LockedState == 0) && (checkLockedstate == true)) || (checkLockedstate == false))
                    {
                        #region 检查RGV、堆垛机等是否被调度任务预约F_ManTaskReserve
                        if (_ManTaskReserve > 0 && DeviceKind!=2)//20140309
                        {
                            devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
                            if (devinfo.IfCorrelDoubleFork == "1")
                            {
                                #region 多叉关联
                                Dictionary<int,string[]> mforkmonInfo= Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, _DeviceIdx);
                                bool iftrue = true; 
                                int relfid = ccf.GetRELATIVECONTORLIDFromManageTask(_ManageKindIdx, _ManageTaskIdx);

                                if (_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + _ManageTaskIdx.ToString())
                                {
                                    iftrue = false;
                                }
                                else
                                {
                                    if (relfid > 0)
                                    {//20130704
                                        dv = dbo.ExceSQL(string.Format("SELECT FID FROM  T_Manage_Task where F_RELATIVECONTORLID={0} and F_ManageTaskKindIndex={1}", relfid, _ManageKindIdx)).Tables[0].DefaultView;
                                        for (int mt = 0; mt < dv.Count; mt++)
                                        {
                                            if (_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + dv[mt]["FID"].ToString())
                                            {
                                                iftrue = false;
                                            }
                                        }
                                    }
                                }
                                if (iftrue == true)
                                {
                                    UpdateAheadDetectUnallow(new StringBuilder(_DeviceIdx.ToString() + "被任务预约" + _ManTaskReserve.ToString().Substring(1)), minMidx);
                                    return true;
                                }
                                #endregion
                            }
                            else
                            {
                                if (_ManTaskReserve.ToString() != _ManageKindIdx.ToString() + _ManageTaskIdx.ToString())
                                {
                                    UpdateAheadDetectUnallow(new StringBuilder(_DeviceIdx.ToString() + "被任务预约" + _ManTaskReserve.ToString().Substring(1)), minMidx);
                                    return true;
                                }
                            }
                        }
                        #endregion

                        //3：F_AheadDetect检测(检测开关编号组“;”)
                        if (AheadDetectOK(minMidx, _AheadDetect) == true)//提前检测通过
                        {
                            if (minMidx == 27691)
                            { }
                            devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
                            if (_DeviceIdx == devinfo.VirtualStack)
                            {//20230718richard分配实际执行任务的堆垛机和RGV编号
                                if (devinfo.DeviceKind == 1)
                                {
                                    AssignStackNo(_DeviceIdx, minMidx, ManageKindIdx, ManageTaskIdx);
                                }
                                else if (devinfo.DeviceKind == 4)
                                {//根据终点设备跨度五个区域（1-5）和换车站台、RGV可用情况修改拆分路径：由编号大区到小区，或者由编号小区到大区
                                 //根据最临近的F_input（近1巷道RGV）和f_output（远离1巷道RGV）记录的RGV判断
                                    DataView dvWait = dbo.ExceSQL(string.Format("select f_numparam4,f_status from T_MONITOR_TASK where f_status > 0 and  f_numparam4 ={0}", NumParam4)).Tables[0].DefaultView;//gjn 控制前面有大于等于已发送的到终点的任务，不选车等待，主要用于控制取货
                                    if (dvWait.Count <= 0)
                                    {
                                        AssignRGVIndex(_DeviceIdx, minMidx, ManageKindIdx, ManageTaskIdx);
                                    }
                                }
                                return true;//20120906
                            }
                            #region 多叉堆垛机检测，能同步的DoubleFork是否AheadDetectOK
                            //20100323
                            devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
                            if (devinfo.IfCorrelDoubleFork == "1" && (devinfo.DeviceKind==1 || devinfo.DeviceKind == 4))
                            {
                                int[] synctask=Model.CGeneralFunction.MutiForkIfSync(minMidx, _DeviceIdx, _DeviceKind);
                                if (synctask != null)//20120616
                                {
                                    if ((synctask.GetLength(0) == 1) && (synctask[0] == minMidx)) return true;//20120616等待未拆分的可同步执行的任务
                                    string[] df = null;
                                    Dictionary<int, string[]> mforkmonitorinfo = Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, _DeviceIdx);
                                    foreach (int i in mforkmonitorinfo.Keys)
                                    {
                                        if (Array.IndexOf<int>(synctask, i) >= 0)
                                        {//20120906
                                            df = mforkmonitorinfo[i];
                                            if (df != null)
                                            {
                                                if (AheadDetectOK(Convert.ToInt32(df[0]), df[1]) == false)//多叉关联提前检测失败
                                                {
                                                    return true;
                                                }
                                                #region 关联指令不是第一个指令不能发送
                                                int rmankind = Model.CGeneralFunction.GetManageTaskKindIndexFromMonitor(Convert.ToInt32(df[0]));
                                                int rman = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(Convert.ToInt32(df[0]));
                                                sql.Remove(0, sql.Length);
                                                sql.Append("SELECT MIN(F_MonitorIndex) AS mmi FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(rman).Append(") AND (F_ManageTASKKINDINDEX = ").Append(rmankind).Append(")");
                                                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                                if (dv.Count > 0)
                                                {
                                                    if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() != df[0]))
                                                    {
                                                        return true;
                                                    }
                                                }
                                                #endregion
                                            }
                                        }
                                    }
                                }
                            }
                            #endregion
                            //检查同步运行的关联设备F_AssociateDeviceIndex
                            //4：是否有关联设备命令？
                            #region 是否有关联设备命令
                            //AssociateDevice = ccf.GetAssociateDevice(minMidx);
                            if (_Associate != 0)
                            {
                                //5：如果有，找到可以运行的关联设备的设备指令,能否运行？
                                //重复递归到2
                                //split = AssociateDevice.Split(sep);
                                adidx = _Associate;
                                if (adidx != 0)
                                {
                                    #region 有关联任务
                                    if (ccf.GetAssociateMonitor(minMidx) == 0)
                                    {
                                        RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "设备指令：" + minMidx.ToString() + "无法获得关联任务" + adidx.ToString() + "，不能发送此类命令！"); 
                                        OnRefreshMonitor(rmea);
                                        return true;
                                    }
                                    if (GetFirstDeviceIFLocked(adidx, false) == false)
                                    {
                                        //6：发送关联设备命令
                                        //CStaticClass.MessageIndex++;
                                        CStaticClass.MessageIndex = 1;
                                        msgIdx = (CStaticClass.MessageIndex);
                                        sdo = CommModeCreate.CreateSendDeviceOrder(_DeviceIdx);
                                        //判断是否为堆垛机设备
                                        bool sendok;
                                        int[] gc = new int[6] { _NumParam2, _NumParam3, _NumParam1, _NumParam5, _NumParam6, _NumParam4 }; //ccf.GetCoordinatesFromMonitorTask(adidx);//获得坐标

                                        if ((_DeviceKind == 1) || (_DeviceKind == 6))
                                        {
                                            //1：堆垛机；4：RGV；6：AGV如果需要优化调度（设备表的F_NeedOptimize='1'）
                                            //直接写入表：T_Monitor_Task_Child，不发送命令
                                            if (ccf.NeedOptimize(_DeviceIdx) == true)
                                            {
                                                ccf.InsertMonitorOptimizeChildTask(adidx);
                                                sendok = true;
                                            }
                                            else
                                            {
                                                sendok = sdo.SendDeviceOrder(msgIdx, adidx, _DeviceOrder,
                                                    _DeviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                                AddOPCSendData( DeviceIdx,adidx,itemnames, itemvalues);
                                            }
                                        }
                                        else if (_DeviceKind == 4)
                                        {
                                            if (ccf.NeedOptimize(_DeviceIdx) == true)
                                            {
                                                ccf.InsertMonitorOptimizeChildTask(adidx);
                                                sendok = true;
                                            }
                                            else
                                            {
                                                sendok = sdo.SendDeviceOrder(msgIdx, adidx, _DeviceOrder, _DeviceIdx, gc[2], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                                AddOPCSendData(DeviceIdx, adidx,itemnames, itemvalues);
                                            }
                                        }
                                        else
                                        {
                                            sendok = sdo.SendDeviceOrder(msgIdx, adidx, _DeviceOrder, _DeviceIdx, gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                            AddOPCSendData(DeviceIdx, adidx,itemnames, itemvalues);
                                        }
                                        if (sendok == false)
                                        {
                                            return true;
                                        }
                                        else
                                        {
                                            //8：更改作业记录的状态F_Status为1,更改设备为占用状态（T_Base_device的F_LockedState=设备指令单）
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Monitor_Task set F_StartTime='" ).Append( DateTime.Now.ToString("u") ).Append( "',F_Status='1' where F_MonitorIndex=" ).Append( adidx);
                                            dbo.ExceSQL(sql.ToString());
                                            
                                            //返回到原来设备值
                                            _DeviceIdx = DeviceIdx;//设备索引
                                            _routeID = routeID;//路径唯一索引
                                            _serialNumber = serialNumber;//路径上的设备方向性链表的序号
                                            _ManageTaskIdx = ManageTaskIdx;//调度任务索引
                                            _ManageKindIdx = ManageKindIdx;//调度任务类型
                                            _DeviceOrder = DeviceOrder;//设备命令
                                            _LockedState = LockedState;
                                            _Associate = Associate;
                                            _ManTaskReserve = ManTaskReserve;
                                            _AheadDetect = AheadDetect;
                                            _NumParam1 = NumParam1;
                                            _NumParam2 = NumParam2;
                                            _NumParam3 = NumParam3;
                                            _NumParam4 = NumParam4;
                                            _NumParam5 = NumParam5;
                                            _NumParam6 = NumParam6;
                                            _TxtParam = TxtParam;
                                            _DeviceKind = DeviceKind;
                                            _OutsideAltDevice = OutsideAltDevice;
                                            _InsideAltDevice = InsideAltDevice;
                                            _StartDevice = StartDevice;
                                            _EndDevice = EndDevice;
                                            _RouteKind = RouteKind;
                                            _AgvNo = AgvNo;
                                            return false;
                                        }
                                    }
                                    else
                                    {
                                        return true;
                                    }
                                    #endregion
                                }
                                else//
                                {
                                    #region MyRegion
		 
	
                                    //返回到原来设备值
                                    _DeviceIdx = DeviceIdx;//设备索引
                                    _routeID = routeID;//路径唯一索引
                                    _serialNumber = serialNumber;//路径上的设备方向性链表的序号
                                    _ManageTaskIdx = ManageTaskIdx;//调度任务索引
                                    _ManageKindIdx = ManageKindIdx;//调度任务类型
                                    _DeviceOrder = DeviceOrder;//设备命令
                                    _LockedState = LockedState;
                                    _Associate = Associate;
                                    _ManTaskReserve = ManTaskReserve;
                                    _AheadDetect = AheadDetect;
                                    _NumParam1 = NumParam1;
                                    _NumParam2 = NumParam2;
                                    _NumParam3 = NumParam3;
                                    _NumParam4 = NumParam4;
                                    _NumParam5 = NumParam5;
                                    _NumParam6 = NumParam6;
                                    _TxtParam = TxtParam;
                                    _DeviceKind = DeviceKind;
                                    _OutsideAltDevice = OutsideAltDevice;
                                    _InsideAltDevice = InsideAltDevice;
                                    _StartDevice = StartDevice;
                                    _EndDevice = EndDevice;
                                    _RouteKind = RouteKind;
                                    #endregion
                                    CControlError = string.Format( "拆分调度任务得到的设备指令与详细路径的检索到的关联设备指令不匹配，系统作为没有关联设备指令处理！");
                                    return false;
                                }
                            }
                            else
                            {
                                #region 返回到原来设备值
                                //返回到原来设备值
                                _DeviceIdx = DeviceIdx;//设备索引
                                _routeID = routeID;//路径唯一索引
                                _serialNumber = serialNumber;//路径上的设备方向性链表的序号
                                _ManageTaskIdx = ManageTaskIdx;//调度任务索引
                                _ManageKindIdx = ManageKindIdx;//调度任务类型
                                _DeviceOrder = DeviceOrder;//设备命令
                                _LockedState = LockedState;
                                _Associate = Associate;
                                _ManTaskReserve = ManTaskReserve;
                                _AheadDetect = AheadDetect;
                                _NumParam1 = NumParam1;
                                _NumParam2 = NumParam2;
                                _NumParam3 = NumParam3;
                                _NumParam4 = NumParam4;
                                _NumParam5 = NumParam5;
                                _NumParam6 = NumParam6;
                                _TxtParam = TxtParam;
                                _DeviceKind = DeviceKind;
                                _OutsideAltDevice = OutsideAltDevice;
                                _InsideAltDevice = InsideAltDevice;
                                _StartDevice = StartDevice;
                                _EndDevice = EndDevice;
                                _RouteKind = RouteKind;
                                #endregion
                                return false;
                            }
                            #endregion
                        }
                        else
                        {
                            return true;
                        }
                    }
                    else
                    {
                        return true;
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {
                CControlError = string.Format("发送命令调用GetFirstDeviceIFLocked时：{0}" ,ex.StackTrace+ex.Message );
                
                return true;
            }
            finally
            {
                dv.Dispose();
            }
        }
        /// <summary>
        /// 分配RGV车号，重新拆分后续RGV取送货指令，考虑3车、2车、1车情况
        /// </summary>
        /// <param name="deviceIdx">虚拟RGV</param>
        /// <param name="minMidx">设备指令索引T_MONITOR_TASK主键</param>
        /// <param name="manageKindIdx">管理任务类型</param>
        /// <param name="manageTaskIdx">管理任务索引</param>
        private void AssignRGVIndex(int deviceIdx, int minMidx, int manageKindIdx, int manageTaskIdx)
        {//分配RGV车号，重新拆分后续RGV取送货指令，考虑3车、2车、1车情况
            DataView dvmon = new DataView();
            try
            {//根据T_BASE_RGV_GATE终点设备编号判断从属于F_INPUT、F_OUTPUT里面RGV编号，找到记录里出现不同RGV编号的区域，
             //找到对应换车站台F_IFTRANSFER=1 and F_INPUT<>F_OUTPUT ，无换车站台时就是只剩下一台rgv车涵盖全程的情况
                int numP1 = 0, numP4 = 0,monIndex=0;
                dvmon = dbo.ExceSQL(string.Format("select F_MONITORINDEX,F_NUMPARAM1,F_NUMPARAM4,f_devicecommandindex,F_MANAGETASKINDEX  from T_MONITOR_TASK where F_MONITORINDEX={0}", minMidx)).Tables[0].DefaultView;
                if (dvmon.Count > 0) 
                {
                    monIndex = Convert.ToInt32(dvmon[0]["F_MONITORINDEX"]);
                    numP1 =Convert.ToInt32( dvmon[0]["F_NUMPARAM1"]);
                    numP4 = Convert.ToInt32(dvmon[0]["F_NUMPARAM4"]);
                    //DataView dvNUMPARAM1=dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where F_INPUT=F_OUTPUT and F_RGVGATEDEVICEINDEX={0} and F_IFTRANSFER='0'", numP1)).Tables[0].DefaultView;
                    //DataView dvNUMPARAM4 = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where F_INPUT=F_OUTPUT and F_RGVGATEDEVICEINDEX={0}  and F_IFTRANSFER='0'", numP4)).Tables[0].DefaultView;
                    DataView dvNUMPARAM1 = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where   F_RGVGATEDEVICEINDEX={0} ", numP1)).Tables[0].DefaultView;
                    DataView dvNUMPARAM4 = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}  ", numP4)).Tables[0].DefaultView;
                    int lasttaskindex = Convert.ToInt32(dbo.GetSingle("select F_MONITORINDEX from t_monitor_task where F_DEVICEINDEX=" + deviceIdx + " and F_DEVICECOMMANDINDEX=3 and F_MANAGETASKINDEX=" + dvmon[0]["F_MANAGETASKINDEX"]));
                    if (dvNUMPARAM1.Count > 0 && dvNUMPARAM4.Count > 0)
                    {
                        int N1rgv = Convert.ToInt32(dvNUMPARAM1[0]["F_INPUT"]);
                        int N4rgv = Convert.ToInt32(dvNUMPARAM4[0]["F_INPUT"]);
                        int N1area = Convert.ToInt32(dvNUMPARAM1[0]["F_NEARGETDEVICE"]);
                        int N4area = Convert.ToInt32(dvNUMPARAM4[0]["F_NEARGETDEVICE"]);
                        if (N1area == 2)//后期改为正向逐个查找缓存站台，反向给次查找所有缓存站台的模式，有在缓存站台选车的情况
                        {
                            N1rgv = Convert.ToInt32(dvNUMPARAM1[0]["F_OUTPUT"]);
                        }
                        if ((numP1 == 32151 || numP1 == 32149 || numP1 == 32154 || numP1 == 32155) && (numP4 == 32231 || numP4 == 32233 || numP4 == 32235))//直接送货倒车浪费时间
                        {
                            SetRGVNo(deviceIdx, N1rgv, monIndex, numP4, numP1, numP4,numP1,numP4);
                            SetRGVNo(deviceIdx, N1rgv, lasttaskindex, numP4, numP1, numP4,numP1,numP4);
                            return;
                        }
                        //if ((numP1 == 32146) && (numP4 == 32219 || numP4 == 32221 ))//直接送货倒车浪费时间
                        //{
                        //    SetRGVNo(deviceIdx, N1rgv, monIndex, numP4, numP1, numP4, numP1, numP4);
                        //    SetRGVNo(deviceIdx, N1rgv, lasttaskindex, numP4, numP1, numP4, numP1, numP4);
                        //    return;
                        //}
                        if ((numP1 == 32908|| numP1 == 32918 || numP1 == 32146) && (numP4 < 32219&&numP4>=32201 ))//直接送货倒车浪费时间
                        {
                            SetRGVNo(deviceIdx, N4rgv, monIndex, numP4, numP1, numP4, numP1, numP4);
                            SetRGVNo(deviceIdx, N4rgv, lasttaskindex, numP4, numP1, numP4, numP1, numP4);
                            return;
                        }
                        if (N1rgv == N4rgv)
                        {//一台车跑任务全程，直接分配RGV编号,修改提前检测
                            SetRGVNo(deviceIdx, N1rgv, monIndex, numP4, numP1, numP4,numP1,numP4);
                            SetRGVNo(deviceIdx, N1rgv, lasttaskindex, numP4, numP1, numP4, numP1, numP4);
                            return;
                        }
                        else if (N1area > N4area)
                        {//区域按照由大到小排列找到经过不同的RGV，是否为换车站台并且可用，是就记录下来
                            RecursionDisassembleRGVTask(monIndex, deviceIdx, numP1, N1rgv, N1area, numP4, "desc");
                        }
                        else if (N1area < N4area)
                        {//由小到大
                            RecursionDisassembleRGVTask(monIndex, deviceIdx, numP1, N1rgv, N1area, numP4, "asc");
                        }
                        else
                        {//区域相等，不需要换车跨区直接分配RGV编号,修改提前检测

                            SetRGVNo(deviceIdx, N1rgv, monIndex, numP4, numP4, numP4,numP1,numP4);
                        }
                        return;
                    }
                    //---------------------------------------modify by bz---------------------------------------//
                    //else//gjn
                    //{
                    //    //gjn
                    //    DataView dvStart = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT,f_iftransfer from T_BASE_RGV_GATE where   F_RGVGATEDEVICEINDEX={0} ", numP1)).Tables[0].DefaultView;//f_iftransfer = 1 and
                    //    if ((dvStart.Count > 0) && (Convert.ToInt32(dvmon[0]["f_devicecommandindex"]) == 2))
                    //    {
                    //        //送货位置在哪个区域就用哪个车
                    //        DataView dveND = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT,f_iftransfer from T_BASE_RGV_GATE where   F_RGVGATEDEVICEINDEX={0} ", numP4)).Tables[0].DefaultView;
                    //        if (dveND.Count > 0)
                    //        {
                    //            if (Convert.ToInt32(dvStart[0]["f_iftransfer"]) == 1 && Convert.ToInt32(dveND[0]["f_iftransfer"]) == 0)
                    //            {
                    //                if (Convert.ToString(dveND[0]["F_INPUT"]) == Convert.ToString(dveND[0]["F_OUTPUT"]))
                    //                {
                    //                    SetRGVNo(deviceIdx, Convert.ToInt32(dveND[0]["F_OUTPUT"]), monIndex, numP4, numP4, numP4);
                    //                }
                    //            }
                    //            else if (Convert.ToInt32(dvStart[0]["f_iftransfer"]) == 0 && Convert.ToInt32(dveND[0]["f_iftransfer"]) == 1)
                    //            {
                    //                if (Convert.ToString(dvStart[0]["F_INPUT"]) == Convert.ToString(dvStart[0]["F_OUTPUT"]))
                    //                {
                    //                    SetRGVNo(deviceIdx, Convert.ToInt32(dvStart[0]["F_OUTPUT"]), monIndex, numP4, numP4, numP4);
                    //                }
                    //            }
                    //            else if (Convert.ToInt32(dvStart[0]["f_iftransfer"]) == 1 && Convert.ToInt32(dveND[0]["f_iftransfer"]) == 1)
                    //            {//连续倒货中转站台，用两个到货站台中间的车//待后续验证现在只有两个车
                    //                int BigNEAR = 0;
                    //                int SmallNEAR = 0;
                    //                BigNEAR = Convert.ToInt32(dvStart[0]["F_NEARGETDEVICE"]) > Convert.ToInt32(dveND[0]["F_NEARGETDEVICE"]) ? Convert.ToInt32(dvStart[0]["F_NEARGETDEVICE"]) : Convert.ToInt32(dveND[0]["F_NEARGETDEVICE"]);
                    //                SmallNEAR = Convert.ToInt32(dvStart[0]["F_NEARGETDEVICE"]) < Convert.ToInt32(dveND[0]["F_NEARGETDEVICE"]) ? Convert.ToInt32(dvStart[0]["F_NEARGETDEVICE"]) : Convert.ToInt32(dveND[0]["F_NEARGETDEVICE"]);
                    //                dveND = dbo.ExceSQL(string.Format("select F_NEARGETDEVICE,F_INPUT,F_OUTPUT,f_iftransfer from T_BASE_RGV_GATE where   F_NEARGETDEVICE > {0} and F_NEARGETDEVICE < {1}", SmallNEAR, BigNEAR)).Tables[0].DefaultView;
                    //                if (dveND.Count > 0)
                    //                {
                    //                    if (Convert.ToString(dveND[0]["F_INPUT"]) == Convert.ToString(dveND[0]["F_OUTPUT"]))
                    //                    {
                    //                        SetRGVNo(deviceIdx, Convert.ToInt32(dveND[0]["F_OUTPUT"]), monIndex, numP4, numP4, numP4);
                    //                    }
                    //                }

                    //            }
                               
                    //        }
                    //    }
                    //}
                    //---------------------------------------modify by bz---------------------------------------//

                }
            }

            catch (Exception ex)
            {
                CControlError = string.Format("CControl.AssignRGVIndex分配RGV车号：{0}", ex.StackTrace + ex.Message);

            }
            finally
            {

            }
        }



        /// <summary>
        /// 检测指定设备命令的执行先决条件是否成立
        /// </summary>
        /// <param name="minMidx">设备指令索引T_MONITOR_TASK主键</param>
        /// <returns>是否检测通过，true表示设备执行命令的先决条件成立</returns>
        public bool AheadDetectOK(int minMidx, string _AheadDetect)
        {
            if (minMidx == 27691)
            { }
            AheadDetectUnallow.Remove(0, AheadDetectUnallow.Length);//20110505
            int[] States;
            string dtime = DateTime.Now.ToString("u");
            dtime = dtime.Substring(0, dtime.Length - 1);
            int DeviceIdx = _DeviceIdx;
            int TaskIdx = minMidx;
            int fid = ccf.GetManageTaskIndexFromMonitor(TaskIdx);
            int mti = ccf.GetManageTaskKindIndexFromMonitor(TaskIdx);
            int DeviceKind = ccf.GetDeviceKindIdx(DeviceIdx);//20100617
            int order = ccf.GetDeviceOrderFromMonitor(TaskIdx);
            int DeviceOrder = _DeviceOrder;//设备命令
            int StartDevice = _StartDevice;//当前调度任务起点
            int EndDevice = _EndDevice;//当前调度任务终点
            int routeidsub =_routeID;
            #region 补充顶升机不在高位的顶升命令
            //if ((DeviceIdx >= 35000) && (DeviceIdx <= 35003)&&(order ==4))
            //{//20120110补充顶升机不在高位的顶升命令

            //    if (_AheadDetect.IndexOf("D-32036.6") >= 0)
            //    {
            //        if(CStaticClass.GetDevicePhotoelectric(32036,7)==1)
            //        {
            //            InsertUpDeviceUP(32036, mti, fid,minMidx);
            //        }
            //    }
            //    else if (_AheadDetect.IndexOf("D-32049.6") >= 0)
            //    {
            //        if (CStaticClass.GetDevicePhotoelectric(32049, 7) == 1)
            //        {
            //            InsertUpDeviceUP(32049, mti, fid, minMidx);
            //        }
            //    }
            //}
            #endregion
            //20100706
            devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
            if (ccf.GetBarCodeFromMonitor(minMidx) == "brbrbr")//避让指令检测条件20120110
            {
                int zc=1,xc=0;
                GetStackRunX_Zcoor(DeviceIdx, out xc, out zc);
                if (devinfo.RunState == 0 && xc==0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            if (DeviceKind == 1 && order==1)//回原点检测条件20120110
            {
                if (devinfo.RunState == 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            
            //检测(检测开关编号组“;”)
            DataView dv = new DataView();
            DataView dvdv = new DataView();
            DataView temp = new DataView();
            try
            {
                if (devinfo.CommType == "OPCClient")//20100706 只有OPCClient通讯类型的检查设备状态
                {
                    #region OPC通讯设备检测设备是否故障

                    if (CCommonOPCClient.ConnectCount.ContainsKey(devinfo.S7Connection))
                    {//20231017
                        if (CCommonOPCClient.ConnectCount[devinfo.S7Connection] > 0)
                        {//20231017
                            AheadDetectUnallow.Append("设备所在PLC已离线!");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                        
                    }
                    else
                    {
                        AheadDetectUnallow.Append( "设备所在PLC已离线!");
                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                        return false;
                    }

                    #endregion
                }
                #region 高端设备U线正在运行总数控制
                //if ((DeviceKind == 13) && (order==6))
                //{//20120328
                //    int arrdevice = ccf.GetDeviceArrowFromMonitor(minMidx);
                //    int startdevice = ccf.GetDeviceStartFromMonitor(minMidx);
                //    object ob0 = dbo.GetSingle(string.Format("SELECT count(F_MonitorIndex) as UTaskCount FROM T_Monitor_Task where F_DeviceIndex={0} and F_DeviceCommandIndex={1} and F_Status>0", DeviceIdx, order));
                //    DataView dvu = dbo.ExceSQL(string.Format("SELECT F_MaxRunTask,F_OutputUDevice,F_InputUDevice FROM T_Base_UArea WHERE (F_UCODE = {0})", DeviceIdx)).Tables[0].DefaultView;
                //    if ((dvu.Count>0) && (ob0 != null))
                //    {
                //        if (arrdevice == Convert.ToInt32(dvu[0]["F_OutputUDevice"]))
                //        {
                //            //if (Convert.ToInt32(ob0) >= Convert.ToInt32(dvu[0]["F_MaxRunTask"]))
                //            //{
                //            //    AheadDetectUnallow.Append("U线：" + DeviceIdx.ToString() + "正在运行任务已经超限！");
                //            //    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                //            //    return false;
                //            //}

                //        }
                //        else
                //        {
                //            if ((Convert.ToInt32(ob0) >= (Convert.ToInt32(dvu[0]["F_MaxRunTask"]) - 2)) && (startdevice == Convert.ToInt32(dvu[0]["F_InputUDevice"])))
                //            {
                //                AheadDetectUnallow.Append("U线：" + DeviceIdx.ToString() + "正在运行任务已经超限！");
                //                UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                //                return false;
                //            }
                //            if ((Convert.ToInt32(ob0) >= (Convert.ToInt32(dvu[0]["F_MaxRunTask"]) - 1)) && (startdevice != Convert.ToInt32(dvu[0]["F_InputUDevice"])))
                //            {
                //                //AheadDetectUnallow.Append("U线：" + DeviceIdx.ToString() + "正在运行任务已经超限！");
                //                //UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                //                //return false;
                //            }
                //        }
                //    }
                    
                    
                //}
                #endregion

                #region 提前检测信息处理
                if ((_AheadDetect != "") && (_AheadDetect != null))
                {


                    char[] cc = new char[1];
                    cc[0] = ';';
                    string[] AheadDetect = _AheadDetect.Split(cc);
                    string[] sp;

                    //通过抽象类工厂获得IGetDeviceState的派生类
                    //IGetDeviceState GDS;
                    int s = 0;
                    //int[] sss;
                    int fs = 1;
                    //int[] fsss;
                    //提取光电开关索引值
                    int devk = 0;
                    #region 查找所有禁用设备//20141201张磊发现错误，应该增加设备是否被停用
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_DeviceIndex FROM T_Base_Device WHERE (F_LockedState = - 1) ");
                    DataView dvJY = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20141201张磊发现错误，应该增加设备是否被停用
                    dvJY.Sort = "F_DeviceIndex";//20141201张磊发现错误，应该增加设备是否被停用
                    #endregion
                    for (int i = AheadDetect.GetLowerBound(0); i <= AheadDetect.GetUpperBound(0); i++)
                    {
                        if (AheadDetect[i].Trim().Length <= 0) continue;
                        #region 检测逻辑有探物

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "H")//检测逻辑有探物
                        {
                            devk = ccf.GetDeviceKindIdx(Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                            if (devk == 9)
                            {//机台需要从管理设备表读取
                                //sql.Remove(0, sql.Length);
                                //sql.Append("SELECT FID FROM T_ITEMDEVICESTATION WHERE (FCODE = '" ).Append( AheadDetect[i].Trim().Substring(1) ).Append( "') AND (FSTATUS = '1002')");
                                //if (dboM.ExceSQL(sql.ToString()).Tables[0].DefaultView.Count > 0)
                                //{
                                //    fs = fs & 1;
                                //}
                                //else
                                //{
                                //    fs = fs & 0;
                                //}
                            }
                            else
                            {
                                //本地设备表读取
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT F_DeviceIndex, F_HaveGoods FROM T_Base_Device where F_DeviceIndex=").Append(
                                    Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                                dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                if (dvdv.Count > 0)
                                {
                                    int havegoods = -1;
                                    if (Convert.ToInt32(dvdv[0]["F_HaveGoods"]) == 0)//20110505
                                    {
                                        havegoods = 0;
                                        AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "设备逻辑无物！");
                                    }
                                    else
                                    {
                                        havegoods = 1;
                                    }
                                    fs = fs & havegoods;
                                }
                            }
                            continue;
                        }

                        #endregion

                        #region 检测逻辑无探物

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "N")//检测逻辑无探物
                        {
                            devk = ccf.GetDeviceKindIdx(Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                            if (devk == 9)
                            {//机台需要从管理设备表读取;20101028管理依赖任务控制机台的站台是否有物
                                //if (dboM.ExceSQL("SELECT FID FROM T_ITEMDEVICESTATION WHERE (FCODE = '" + AheadDetect[i].Trim().Substring(1) + "') AND (FSTATUS = '1002')").Tables[0].DefaultView.Count > 0)
                                //{
                                //    fs = fs & 1;
                                //}
                                //else
                                //{
                                //    fs = fs & 0;
                                //}
                            }
                            else
                            {
                                //本地设备表读取
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT F_DeviceIndex, F_HaveGoods FROM T_Base_Device where  F_DeviceIndex=").Append(
                                    Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                                dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                if (dvdv.Count > 0)
                                {
                                    if (Convert.ToInt32(dvdv[0]["F_HaveGoods"]) > 0)//20110505
                                    {
                                        AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "设备逻辑有物！");
                                    }
                                    s = s + Convert.ToInt32(dvdv[0]["F_HaveGoods"]);
                                }
                            }
                            continue;
                        }

                        #endregion

                        #region 检测设备是否空闲

                        //20090803检测设备是否空闲idle
                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "I")//检测设备是否空闲idle
                        {
                            int idev = Convert.ToInt32(AheadDetect[i].Trim().Substring(1));
                            if (idev.ToString().Length == 6)
                            {
                                idev = Convert.ToInt32(idev.ToString());
                            }
                            if (idev != 35400)//gjn直穿虚拟设备不检测空闲
                            {
                                States = CStaticClass.GetDeviceState(idev);

                                if (States != null)
                                {
                                    //if ((States[1] == 5) && (ccf.GetDeviceKindIdx(Convert.ToInt32(AheadDetect[i].Trim().Substring(1))) == 2))
                                    //{//20120409只有输送机的完成可作为空闲
                                    //    States[1] = 0;
                                    //}
                                    int kind = ccf.GetDeviceKindIdx(Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                                    if ((DeviceHandTaskIfRun(Convert.ToInt32(AheadDetect[i].Trim().Substring(1))) == true) && (kind == 1))
                                    {//20120207
                                        AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "手工任务或者避让任务正在运行！");
                                        States[1] = 1;
                                    }
                                    if (States[1] != 0)//20110505
                                    {
                                        AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "设备不空闲！");
                                    }
                                    s = s + States[1];
                                }
                                if (dvJY.Find(idev) >= 0)
                                {//20141201张磊发现错误，应该增加设备是否被停用
                                    AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "设备被停用！");
                                    s += 1;
                                }
                            }
                            continue;
                        }

                        #endregion

                        #region 检测F_NumParam1，F_NumParam4设备无正在运行的任务

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "U")//检测F_NumParam1，F_NumParam4设备无正在运行的任务
                        {
                            sql.Clear();
                            sql.Append(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_NumParam1 = {0} or F_NumParam4 = {0}) AND (F_Status > 0)", Convert.ToInt32(AheadDetect[i].Trim().Substring(1))));
                            dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvdv.Count > 0)
                            {
                                s = s + 1;
                                AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "有任务正在执行！");
                            }
                            else
                            {
                                s = s + 0;
                            }

                            continue;
                        }
                        #endregion
                        #region 检测是否有到该终点的任务V

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "V")//检测F_NumParam1，F_NumParam4设备无正在运行的任务
                        {
                            sql.Clear();
                            sql.Append(string.Format("SELECT fid FROM T_Manage_Task WHERE fenddevice={0}", Convert.ToInt32(AheadDetect[i].Trim().Substring(1))));
                            dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvdv.Count > 0)
                            {
                                s = s + 1;
                                AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "有任务正在执行！");
                            }
                            else
                            {
                                s = s + 0;
                            }

                            continue;
                        }
                        #endregion
                        #region 检测该站台是否为出库模式

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "W")//检测F_NumParam1，F_NumParam4设备无正在运行的任务
                        {
                            sql.Clear();
                            sql.Append(string.Format("select *  from T_BASE_IOMODE_SWITCH where output_station_code={0} and station_inout_mode=2", Convert.ToInt32(AheadDetect[i].Trim().Substring(1))));
                            dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvdv.Count <= 0)
                            {
                                s = s + 1;
                                AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "出入库模式不正确！");
                            }
                            else
                            {
                                s = s + 0;
                            }

                            continue;
                        }
                        #endregion
                        #region 检测积放线正在执行任务个数

                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "J")//检测积放线正在执行任务个数（J12008,2）
                        {
                            cc[0] = ',';
                            sp = AheadDetect[i].Trim().Substring(1).Split(cc);
                            if (sp.GetLength(0) == 2)
                            {
                                sql.Clear();
                                sql.Append(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex={0}) AND (F_Status > 0)", Convert.ToInt32(sp[0])));
                                dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                if (dvdv.Count >= Convert.ToInt32(sp[1]))
                                {
                                    s = s + 1;
                                    AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "积放任务超限！");
                                }
                                else
                                {
                                    s = s + 0;
                                }
                            }
                            continue;
                        }

                        #endregion

                        #region 检测设备是否被堆垛机预约
                        //20120409
                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "R" && DeviceKind == 1)////20140309检测设备是否被堆垛机预约
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("select F_ManTaskReserve from  T_Base_Device where F_ManTaskReserve>0 and F_DeviceIndex=").Append(Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
                            object obr1 = dbo.GetSingle(sql.ToString());
                            if (obr1 != null)
                            {
                                if (obr1.ToString() != (mti.ToString() + fid.ToString()))
                                {
                                    s = s + 1;
                                    AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "被调度任务:").Append(obr1.ToString()).Append("预约！");
                                }
                                else
                                {
                                    s = s + 0;
                                }
                            }
                            continue;
                        }

                        #endregion

                        #region 检测设备光电信号

                        //检测设备的光电信号：D-12001.0表示输送机12001的入口开关有物；D12001.1表示输送机12001的入口开关无物
                        //D-12001.2表示输送机12001的顶升高位（高到位）；D12001.3表示输送机12001的顶升不在低位（不是低到位）
                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "D")
                        {
                            int devicebyte = 0, devbit = 0;
                            DS = AheadDetect[i].Trim().Substring(1).Split(dd);
                            int.TryParse(DS[0], out devicebyte);
                            int.TryParse(DS[1], out devbit);
                            //判断是否检测负数索引值（负数代表是否满足开关量＝１的执行前提）
                            int DeviceIndex = 0;
                            if (devicebyte < 0)
                            {
                                DeviceIndex = 0 - devicebyte;
                            }
                            else
                            {
                                DeviceIndex = devicebyte;
                            }
                            if (DeviceIndex == 35400)//gjn
                            {
                                continue;
                            }
                            if (devicebyte < 0)
                            {
                                #region 负数代表值为１的开关量检测
                                devinfocheck = Model.CGetInfo.GetDeviceInfo(-devicebyte);
                                if(devinfocheck != null)
                                {
                                    int fsn = 1;
                                    if (-devicebyte != 35400)
                                    {
                                        fsn = CStaticClass.GetDevicePhotoelectric(-devicebyte, devbit);//20101124
                                    }
                                    

                                    if (fsn != 1)//20110505
                                    {
                                        StringBuilder kg = new StringBuilder();
                                        switch (devbit)
                                        {
                                            case 0:
                                                kg.Append(".0有物");
                                                break;
                                            case 1:
                                                kg.Append(".1有物");
                                                break;
                                            case 2:

                                                if (ccf.GetDeviceKindIdx(-devicebyte) == 31)
                                                {
                                                    kg.Append("高位");
                                                }
                                                else
                                                {
                                                    kg.Append(".2有物");

                                                }
                                                break;
                                            case 3:
                                                //kg.Append(".3低位");

                                                //break;
                                                   if ((devinfocheck.DeviceKind == 1) && (devinfocheck.IfCorrelDoubleFork == "1"))
                                                    {
                                                        kg.Append(".3垛机1叉居中");
                                                    }
                                                    else if (((devinfocheck.DeviceKind == 1) || (devinfocheck.DeviceKind == 4)) && (devinfocheck.IfCorrelDoubleFork == "0"))
                                                    {
                                                        kg.Append(".3垛机叉居中");
                                                    }
                                                    else if ((devinfocheck.DeviceKind == 2))
                                                    {
                                                        kg.Append(".3堆垛机/穿梭车允许输送线动作");
                                                    }
                                                    else
                                                    {
                                                        kg.Append(".3低位");
                                                    }
                                                    break;
                                            case 4:
                                                if ((devinfocheck.DeviceKind == 1 )&& (devinfocheck.IfCorrelDoubleFork == "1"))
                                                {
                                                    kg.Append(".4垛机2叉居中");
                                                }
                                                else if ((devinfocheck.DeviceKind == 2))
                                                {
                                                    kg.Append(".4输送线允许堆垛机/穿梭车动作");
                                                }
                                                else
                                                {
                                                    kg.Append(".4高位");
                                                }
                                                break;
                                                //kg.Append(".4高位");
                                                //break;
                                            case 5:
                                                kg.Append("地面安全门关闭");
                                                break;
                                            case 6:
                                                kg.Append("高位");
                                                break;
                                            case 7:
                                                kg.Append("低位");
                                                break;

                                            default:
                                                break;
                                        }
                                        AheadDetectUnallow.Append(Convert.ToInt32((-devicebyte)).ToString() + kg.ToString() + "光电开关不遮挡！");
                                    }
                                    fs = fs & fsn;
                            }
                                #endregion
                            }
                            else
                            {//
                                #region 正数值不能为１的开关量检测
                                int sssn = 1;
                                if (devicebyte != 35400)
                                {
                                    sssn = CStaticClass.GetDevicePhotoelectric(devicebyte, devbit);
                                }
                                

                                if (sssn != 0)//20110505
                                {
                                    StringBuilder kg = new StringBuilder();
                                    switch (devbit)
                                    {
                                        case 0:
                                            kg.Append(".0有物");
                                            break;
                                        case 1:
                                            kg.Append(".1有物");
                                            break;
                                        case 2:

                                            if (ccf.GetDeviceKindIdx(devicebyte) == 31)
                                            {
                                                kg.Append("高位");
                                            }
                                            else
                                            {
                                                kg.Append(".2有物");

                                            }
                                            break;
                                        case 3:
                                            kg.Append(".3低位");

                                            break;
                                        case 4:
                                            kg.Append(".4高位");
                                            break;
                                        case 5:
                                            kg.Append("有物");
                                            break;
                                        case 6:
                                            kg.Append("高位");
                                            break;
                                        case 7:
                                            kg.Append("低位");
                                            break;
                                        default:
                                            break;
                                    }
                                    AheadDetectUnallow.Append(devicebyte.ToString() + kg.ToString() + "光电开关遮挡！");
                                }
                                s = s + sssn;
                                #endregion
                            }


                        }

                        #endregion

                        #region 叠盘货位是否已满
                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "P")
                        {
                            string des_zxy = AheadDetect[i].Trim().Substring(1);
                            sql.Remove(0, sql.Length);
                            sql.Append("select * from T_LANE_PILE where f_zxy = '").Append(des_zxy).Append("'");
                            DataView dvtemp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if ((dvtemp.Count > 0) && (Convert.ToInt32(dvtemp[0]["F_CUR_NUM"]) >= Convert.ToInt32(dvtemp[0]["F_MAX_NUM"])))
                            {
                                AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "叠盘货位已满！");
                                s += 1; ;
                            }
                            continue;
                        }
                        #endregion

                        #region 是否有到终点的其他任务,终点是否有位置
                        if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "M")
                        {
                            string desdevice = AheadDetect[i].Trim().Substring(1);
                            sql.Remove(0, sql.Length);
                            sql.Append("select * from T_MANAGE_TASK where fenddevice = ").Append(desdevice).Append(" and fstatus != 0 and fid != ").Append(fid);
                            DataView dvtemp = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvtemp.Count > 0)
                            {
                                AheadDetectUnallow.Append("终点位置").Append(AheadDetect[i].Trim().Substring(1) + "存在执行中的任务！");
                                s += 1; ;
                            }
                            else
                            {
                                int sssn = CStaticClass.GetDevicePhotoelectric(Convert.ToInt32(desdevice), 0);
                                if (sssn != 0)//20110505
                                {
                                    AheadDetectUnallow.Append(desdevice + ".0光电开关遮挡！");
                                }
                                s = s + sssn;
                            }
                            continue;
                        }
                        #endregion
                    }

                    #region 非手工任务，如果有手工任务等待执行先执行手工任务
                    if (mti != 4)
                    {//20120405
                        if (DeviceHandTaskIfWaitRun(devinfo.DeviceIndex) == true)
                        {
                            AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "手工任务或者避让任务等待运行！");
                            s += 1;
                        }
                    }
                    #endregion

                    #region 检测向管理申请入库任务条码和PLCASK记录是否匹配
                    //20130709增加输送站台向管理申请入库任务，或者条码比对的任务，扫描后人工随意搬走箱子的保护，入库任务条码和PLCAsk记录的不相同不再执行任务
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_BarCode FROM T_Base_Device,T_Base_PLC_Ask WHERE  ( T_Base_Device.F_DeviceIndex = T_Base_PLC_Ask.F_DeviceIndex)  and  (T_Base_Device.F_DeviceKindIndex = 7) AND T_Base_PLC_Ask.F_BindingDevice = ").Append(devinfo.DeviceIndex);
                    object obr = dbo.GetSingle(sql.ToString());
                    if (obr != null)
                    {
                        if (obr.ToString().Length > 3)
                        {
                            if(obr.ToString().Substring(0,3)=="JAC"&&DeviceIdx!=32400&&DeviceIdx!=32402&&DeviceIdx!=32408 && DeviceIdx != 32466 && DeviceIdx != 32472)//gjn   暂时迎合夜班
                            {
                                string monbarcode = ccf.GetBarCodeFromMonitor(minMidx);
                                if (DeviceIdx == 22544 )
                                {
                                    if (EndDevice != 22337)
                                    {
                                        if ((obr.ToString().IndexOf(monbarcode) < 0) && (monbarcode.IndexOf(obr.ToString()) < 0) && monbarcode.Length == 8)
                                        {
                                            s = s + 1;
                                            AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "上扫码器读到的条码【").Append(obr.ToString()).Append("】和任务条码【").Append(monbarcode).Append("】不匹配！");
                                        }
                                    }

                                }
                                else
                                {
                                    if ((obr.ToString().IndexOf(monbarcode) < 0) && (monbarcode.IndexOf(obr.ToString()) < 0) && monbarcode.Length == 8)
                                    {
                                        s = s + 1;
                                        AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "上扫码器读到的条码【").Append(obr.ToString()).Append("】和任务条码【").Append(monbarcode).Append("】不匹配！");
                                    }
                                }
                                
                            }
                        }
                       

                    }

                    #endregion
                    if ((s != 0) || (fs != 1))
                    {
                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                        return false;
                    }

                }




                #endregion
                
                #region 正反向的出入库输送机导致RGV和堆垛机相互限制20230718richard
                #region 堆垛机出库判断RGV入库正反向站台
                if (DeviceKind == 1 && order==4 && ccf.GetFCONTROLTASKTYPEFromManageTask(mti, fid) == 2)
                {//出库任务的堆垛机取货指令4，找到放货站台和对应RGV判断是否存在入库的RGV任务正在执行或者本巷道入库任务已经执行完RGV任务到输送机
                    int stackroutesn=ccf.GetSerialNumberFromRouteDevice(routeidsub, DeviceIdx);
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_DEVICEINDEX  FROM T_Base_Route_Device WHERE F_RouteIDSub = ").Append(routeidsub).Append(" AND F_SerialNumber > ").Append(stackroutesn).Append(" order by F_SerialNumber");
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {//找到堆垛机放货输送机
                        int stackunloadconveyor = Convert.ToInt16(dv[0]["F_DEVICEINDEX"]);
                        dv= dbo.ExceSQL(string.Format("SELECT F_RELATEDRGV,f_neardevice FROM T_BASE_LANE_GATE where F_LANEGATEDEVICEINDEX={0} and F_IOSWITCH='1' and F_RELATEDRGV>0", stackunloadconveyor)).Tables[0].DefaultView;
                        if (dv.Count>0)
                        {//判断是否存在入库的RGV任务正在执行或者本巷道入库任务已经执行完RGV任务到输送机
                            //RGV和环穿考虑15100-15133通配为'151%'
                            int relatedRGV = Convert.ToInt16(dv[0]["F_RELATEDRGV"]);
                            int goalConveyor = Convert.ToInt16(dv[0]["f_neardevice"]);//堆垛机取放货输送机关联的RGV取放货站台
                            sql.Clear();
                            sql.Append("SELECT F_MONITORINDEX FROM T_MANAGE_TASK,T_MONITOR_TASK where FID = T_MONITOR_TASK.F_MANAGETASKINDEX AND T_MANAGE_TASK.F_MANAGETASKKINDINDEX =T_MONITOR_TASK.F_MANAGETASKKINDINDEX and FCONTROLTASKTYPE =1 AND F_STATUS > 0 AND (f_goalconveyor=").Append(goalConveyor).Append(" or F_NUMPARAM4=").Append(goalConveyor).Append(") and F_DEVICEINDEX like '").Append(relatedRGV.ToString().Substring(0,3)).Append("%'");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {//入库到本巷道的RGV任务正在执行（直穿多个接力取送货任务和环穿单个取送货任务）
                                return false;
                            }
                            sql.Clear();
                            sql.Append("SELECT distinct FID,T_MANAGE_TASK.F_MANAGETASKKINDINDEX FROM T_MANAGE_TASK,T_MONITOR_TASK where FID = T_MONITOR_TASK.F_MANAGETASKINDEX AND  T_MANAGE_TASK.F_MANAGETASKKINDINDEX =T_MONITOR_TASK.F_MANAGETASKKINDINDEX and FCONTROLTASKTYPE =1 and FSTATUS>0 AND F_NUMPARAM4=").Append(stackunloadconveyor);
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {//包含堆垛机放货站台的入库管理任务正在运行
                                DataView dvrgv;
                                for (int i = 0; i< dv.Count; i++)
                                {
                                    sql.Clear();
                                    sql.Append("SELECT F_DEVICEINDEX FROM T_MONITOR_TASK where F_DEVICEINDEX like '").Append(relatedRGV.ToString().Substring(0,3)).Append("%' and F_MANAGETASKINDEX=").Append(Convert.ToInt32(dv[i]["FID"])).Append(" and F_MANAGETASKKINDINDEX= ").Append(Convert.ToInt32( dv[i]["F_MANAGETASKKINDINDEX"]));
                                    dvrgv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (dvrgv.Count== 0)
                                    {//任务离开RGV运行到RGV放货输送线
                                        return false;
                                    }
                                }
                               
                            }
                        }
                    }
                }
                # endregion

                #region RGV入库指令判断卸货输送机出库指令
                else if ((DeviceKind == 4 || DeviceKind == 13) && ccf.GetFCONTROLTASKTYPEFromManageTask(mti, fid) == 1)
                {//RGV入库指令，找到对应终点位置是RGV放货输送机送出指令的出库管理任务已经开始执行
                    int rgvunloadConveyor=_NumParam4;//环穿或者直穿送货站台编号
                    object ob = dbo.GetSingle(string.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0} and F_IOSWITCH='1'", rgvunloadConveyor));
                    if (ob != null)
                    {
                        sql.Clear();
                        sql.Append("SELECT F_MONITORINDEX FROM T_MANAGE_TASK,T_MONITOR_TASK where FID = T_MONITOR_TASK.F_MANAGETASKINDEX AND T_MANAGE_TASK.F_MANAGETASKKINDINDEX =T_MONITOR_TASK.F_MANAGETASKKINDINDEX and FCONTROLTASKTYPE =2 AND FSTATUS > 0 AND F_NUMPARAM4=").Append(rgvunloadConveyor);
                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {//本巷道出库的堆垛机或者送出至卸货输送机的管理任务正在执行
                            return false;
                        }

                    }
                    
                }
                #endregion
                #endregion
                #region 102转台特殊判断
                devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                if (devinfo.DeviceIndex == 22326 || devinfo.DeviceIndex == 22327||devinfo.DeviceIndex==22316||devinfo.DeviceIndex==22301)//转台上连廊需要校验是否与去异常
                {
                    switch (devinfo.DeviceIndex)
                    {
                        case 22326:
                            if (EndDevice == 22580)
                            {
                                if (Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where FSTARTDEVICE=22327 and FENDDEVICE in (22338,22337) and FSTATUS>0")) > 0)
                                {
                                    AheadDetectUnallow.Append("有22327去异常的任务没完成");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            
                            break;
                        case 22327:
                            if (EndDevice == 22338 || EndDevice == 22337)
                            {
                                if (Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where FSTARTDEVICE=22326 and FENDDEVICE=22580 and FSTATUS>0")) > 0)
                                {
                                    AheadDetectUnallow.Append("有22326去22580的任务没完成");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            
                            break;
                        case 22316:
                            if (EndDevice == 22501)
                            {
                                if (Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where FSTARTDEVICE=22301 and FENDDEVICE in (22336,22337) and FSTATUS>0")) > 0)
                                {
                                    AheadDetectUnallow.Append("有22301去异常的任务没完成");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            
                            break;
                        case 22301:
                            if (EndDevice == 22336 || EndDevice == 22337)
                            {
                                if (Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where FSTARTDEVICE=22316 and FENDDEVICE=22501 and FSTATUS>0")) > 0)
                                {
                                    AheadDetectUnallow.Append("有22316去22501的任务没完成");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            
                            break;

                    }
                }
                #endregion
                #region 35002-35006去合托判断是否有单托流转出库
                //if (((EndDevice == 32120 || EndDevice == 32086 || EndDevice == 32103 )&&((DeviceIdx>=35002&&DeviceIdx<=35006)||DeviceIdx==32034))||(EndDevice == 32072&&DeviceIdx==32034))
                //{
                //    int relid = Convert.ToInt32(dbo.GetSingle("select F_RELATIVECONTORLID from t_manage_task where fid=" + fid));
                //    if (relid > 0)
                //    {
                //        int temp1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where F_RELATIVECONTORLID<=0 and FENDDEVICE=" + EndDevice+" and FSTARTDEVICE  in (38101,38102,38103,38104)"));
                //        if (temp1 > 0)
                //        {
                //            AheadDetectUnallow.Append("避让单托任务");
                //            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                //            return false;
                //        }
                //    }

                //}

                #endregion
                //if (DeviceIdx == 32039 || DeviceIdx == 32071|| DeviceIdx == 32094|| DeviceIdx == 32102|| DeviceIdx == 32119||(DeviceIdx==31101&&order==4&&EndDevice==32072))//堆垛机出口何时去合托机
                   if (DeviceIdx == 32039 || DeviceIdx == 32071 || DeviceIdx == 32094 || DeviceIdx == 32102 || DeviceIdx == 32119 || (DeviceIdx == 32034 &&EndDevice == 32086))//堆垛机出口何时去合托机
                    {
                    int relid = Convert.ToInt32(dbo.GetSingle("select F_RELATIVECONTORLID from t_manage_task where fid=" + fid));
                    if (relid > 0)
                    {
                        int temp1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where F_RELATIVECONTORLID>0 and F_RELATIVECONTORLID<" + relid + " and FENDDEVICE=" + EndDevice));
                        if (temp1 > 0)
                        {
                            AheadDetectUnallow.Append("等待早期任务合托完成");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                    }
                }
                if (((DeviceIdx == 31101  && EndDevice == 32072)|| (DeviceIdx == 31102 && EndDevice == 32086)|| (DeviceIdx == 31103 && EndDevice == 32103)|| (DeviceIdx == 31104 && EndDevice == 32120))&&order==4)//缓存叠托在堆垛机出口等待
                {
                    int relid = Convert.ToInt32(dbo.GetSingle("select F_RELATIVECONTORLID from t_manage_task where fid=" + fid));
                    if (relid > 0)
                    {
                        int temp1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where FSTARTDEVICE="+StartDevice+" and F_RELATIVECONTORLID>0 and F_RELATIVECONTORLID<" + relid + " and FENDDEVICE=" + EndDevice));
                        if (temp1 > 0)
                        {
                            AheadDetectUnallow.Append("等待先下达的合托任务出库");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                    }
                }
                //if ((EndDevice == 32120 || EndDevice == 32103) && DeviceIdx >= 35002 && DeviceIdx <= 35006)//3/4线缓存，效率优化多下任务，但在提升机不下发
                  if ((EndDevice == 32120 || EndDevice == 32103) && DeviceIdx >= 32013 && DeviceIdx <= 32020)//3/4线缓存，效率优化多下任务，但在提升机不下发
                    {
                    int relid = Convert.ToInt32(dbo.GetSingle("select F_RELATIVECONTORLID from t_manage_task where fid=" + fid));
                    if (relid > 0)
                    {
                        int temp1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_manage_task where F_RELATIVECONTORLID>0 and F_RELATIVECONTORLID<" + relid + " and FENDDEVICE=" + EndDevice));
                        if (temp1 > 0)
                        {
                            AheadDetectUnallow.Append("等待早期任务合托完成");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                    }
                }
                if (EndDevice == 22337 && (order == 4||DeviceIdx==32001))//返库的取货任务
                {
                    int temp1 = Convert.ToInt32(dbo.GetSingle("select station_inout_mode from T_BASE_IOMODE_SWITCH  where input_station_code='22337'"));
                    if (temp1 != 2)
                    {
                        AheadDetectUnallow.Append("当前不是返库模式");
                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                        return false;
                    }
                }
                #region 同区域的双工位RGV取货任务配双叉20230718
                //同区域是否有可关联取货任务，同步双取优先执行
                devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
                if (devinfo.DeviceKind==4 && devinfo.ForkAmount==2 && order==2 && ccf.GetRELATIVECONTORLIDFromManageTask(mti,fid)<=0)
                {
                    //先判断本任务取货站台的同步取货关联站台
                    DataView dvcorrl = dbo.ExceSQL(string.Format("SELECT F_CORRELDEVICEINDEX,F_FORKNO FROM T_BASE_RGV_GATE where F_CORRELDEVICEINDEX>0 and F_RGVGATEDEVICEINDEX={0}", _NumParam1)).Tables[0].DefaultView;
                    if (dvcorrl.Count > 0)
                    {
                        int rgvCorrelStation = Convert.ToInt32(dvcorrl[0]["F_CORRELDEVICEINDEX"]);
                        int rgvForkNo = Convert.ToInt32(dvcorrl[0]["F_FORKNO"]);
                        int rgvCorrelForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", rgvCorrelStation)));
                        object[] obarr = new object[4] { mti, DeviceIdx, order, rgvCorrelStation };
                        object ob1 = dbo.GetSingle(string.Format("SELECT F_MANAGETASKINDEX FROM T_MONITOR_TASK where F_STATUS=0 and F_MANAGETASKKINDINDEX={0} and F_DEVICEINDEX={1} and F_DEVICECOMMANDINDEX={2} and F_NUMPARAM1={3}", obarr));
                        if (ob1 != null)
                        {
                            int correlfid = Convert.ToInt32(ob1);
                            SetRgvCorrelManageTask(mti, fid,_NumParam1 ,rgvForkNo, rgvCorrelStation, correlfid, rgvCorrelForkNo);
                            return false;
                        }

                    }
                    else
                    {//同区域的取货任务
                        object ob1 = dbo.GetSingle(string.Format("SELECT F_NEARGETDEVICE FROM T_BASE_RGV_GATE where F_NEARGETDEVICE>0 and F_RGVGATEDEVICEINDEX={0}", _NumParam1));
                        if (ob1 != null)
                        {
                            int neargateArea=Convert.ToInt32(ob1);
                            object[] obarr = new object[5] { mti, DeviceIdx, order, TaskIdx,neargateArea};
                            dvcorrl = dbo.ExceSQL(string.Format("SELECT F_MANAGETASKINDEX,F_NUMPARAM1 FROM T_MONITOR_TASK where F_STATUS=0 and F_MANAGETASKKINDINDEX={0} and F_DEVICEINDEX={1} and F_DEVICECOMMANDINDEX={2} and f_monitorindex<>{3} and F_NUMPARAM1 in (SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where F_NEARGETDEVICE={4}) order by F_SPLITTIME asc", obarr)).Tables[0].DefaultView;
                            if (dvcorrl.Count > 0)
                            {
                                int correlfid = Convert.ToInt32(dvcorrl[0]["F_MANAGETASKINDEX"]);
                                int rgvCorrelStation = Convert.ToInt32(dvcorrl[0]["F_NUMPARAM1"]);
                                int rgvForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", _NumParam1)));
                                int rgvCorrelForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", rgvCorrelStation)));
                                
                                SetRgvCorrelManageTask(mti, fid,_NumParam1, rgvForkNo, rgvCorrelStation, correlfid, rgvCorrelForkNo);
                                return false;
                            }
                        }
                    }

                }
                #endregion
                #region 有避让双工位RGV设备20230718richard
                if (DeviceKind == 4 && devinfo.VirtualStack > 0)
                {//判断当前位置至目标位置之间是否有其它车停靠
                 //避让车地址如果大于本车，让避让车运动7大于目标站台+安全距离的临近非换车站台
                 //避让车地址如果小于本车，让避让车运动7小于目标站台-安全距离的临近非换车站台
                    
                    int rgvSecuritydistance = 5000;
                    dvdv = dbo.ExceSQL(string.Format("SELECT F_RGVINDEX,F_RGVLANENO,F_VIRTUALRGV FROM T_BASE_RGVINFO where F_VIRTUALRGV<>F_RGVINDEX and F_RGVINDEX={0}", DeviceIdx)).Tables[0].DefaultView;
                    if (dvdv.Count > 0)
                    {
                        int rgvlane = Convert.ToInt32(dvdv[0]["F_RGVLANENO"]);
                        int arrowXcorr=0;int arrowConveyor=0;
                        if (order == 2 || order == 7)//取货或者运动
                        {
                            arrowConveyor = _NumParam1;
                        }
                        else if(order == 3)//送货
                        {
                            arrowConveyor = _NumParam4;
                        }
                        arrowXcorr = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_ADDRESS FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}",arrowConveyor)));
                        
                        dvdv = dbo.ExceSQL(string.Format("SELECT F_RGVINDEX,F_RGVLANENO,F_VIRTUALRGV FROM T_BASE_RGVINFO where f_rgvindex<>35400 and f_rgvindex<>{0} and F_RGVLANENO={1}",devinfo.DeviceIndex, rgvlane )).Tables[0].DefaultView;
                        if (dvdv.Count > 0)
                        {
                            bool ifInsert = false; object ob;
                            for (int i = 0; i < dvdv.Count; i++)
                            {//检查每个rgv的位置是否和目标位置有冲突，有冲突增加避让运动至安全距离外的站台位置
                                
                                //避让车信息
                                devinfocheck = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvdv[i]["F_RGVINDEX"]));
                                //-----------------------------modify by bz----------------------------------//
                                #region 有任务的车有冲突需要等待任务执行完成
                                temp = dbo.ExceSQL("select * from t_monitor_task where F_STATUS>0 and F_DEVICEINDEX=" + dvdv[i]["F_RGVINDEX"]).Tables[0].DefaultView;//找是否存在任务
                                if (temp.Count > 0)
                                {
                                    for (int t = 0; t < temp.Count; t++)
                                    {
                                        int num1 = 0, num4 = 0, num1address, num4address;
                                        switch (temp[t]["F_DEVICECOMMANDINDEX"].ToString())
                                        {
                                            case "2":
                                                num1 = Convert.ToInt32(dbo.GetSingle("select F_NUMPARAM1 from t_monitor_task where F_MONITORINDEX=" + temp[t]["F_MONITORINDEX"]));
                                                num1address = Convert.ToInt32(dbo.GetSingle("select f_address from t_base_rgv_gate where F_RGVGATEDEVICEINDEX=" + num1));
                                                if (System.Math.Abs(arrowXcorr - num1address) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num1address && num1address < arrowXcorr) || (devinfo.XCoor > num1address && num1address > arrowXcorr))//其他车取货任务有冲突(考虑车在中间但离执行任务站台远的情况)
                                                {
                                                    return false;
                                                }
                                                //object tempnum4 = dbo.GetSingle("select F_NUMPARAM4 from t_monitor_task where F_DEVICEINDEX=" + dvdv[i]["F_RGVINDEX"] + " and F_MANAGETASKINDEX=(select F_MANAGETASKINDEX from t_monitor_task where F_MONITORINDEX=" + temp[t]["F_MONITORINDEX"] + ") and F_DEVICECOMMANDINDEX=3");
                                                //if (tempnum4 != null)
                                                //{
                                                //    num4 = Convert.ToInt32(tempnum4);
                                                //    num4address = Convert.ToInt32(dbo.GetSingle("select f_address from t_base_rgv_gate where F_RGVGATEDEVICEINDEX=" + num4));
                                                //    if (System.Math.Abs(arrowXcorr - num4address) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr))//其他车取货之后送货的任务有冲突
                                                //    {
                                                //        return false;
                                                //    }
                                                //}
                                                if (System.Math.Abs(arrowXcorr - devinfocheck.XCoor) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num1address && num1address < arrowXcorr) || (devinfo.XCoor > num1address && num1address > arrowXcorr))//有任务的车当前位置有冲突
                                                {
                                                    return false;
                                                }
                                                break;
                                            case "3":
                                                num4 = Convert.ToInt32(dbo.GetSingle("select F_NUMPARAM4 from t_monitor_task where F_MONITORINDEX=" + temp[t]["F_MONITORINDEX"]));
                                                num4address = Convert.ToInt32(dbo.GetSingle("select f_address from t_base_rgv_gate where F_RGVGATEDEVICEINDEX=" + num4));
                                                if (System.Math.Abs(arrowXcorr - num4address) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num4address && num4address < arrowXcorr) || (devinfo.XCoor > num4address && num4address > arrowXcorr))
                                                {
                                                    return false;
                                                }
                                                if (System.Math.Abs(arrowXcorr - devinfocheck.XCoor) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num4address && num4address < arrowXcorr) || (devinfo.XCoor > num4address && num4address > arrowXcorr))//有任务的车当前位置有冲突
                                                {
                                                    return false;
                                                }
                                                break;
                                            case "7":
                                                num1 = Convert.ToInt32(dbo.GetSingle("select F_NUMPARAM1 from t_monitor_task where F_MONITORINDEX=" + temp[t]["F_MONITORINDEX"]));
                                                num1address = Convert.ToInt32(dbo.GetSingle("select f_address from t_base_rgv_gate where F_RGVGATEDEVICEINDEX=" + num1));
                                                if (System.Math.Abs(arrowXcorr - num1address) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num1address && num1address < arrowXcorr) || (devinfo.XCoor > num1address && num1address > arrowXcorr))//其他车取货任务有冲突
                                                {
                                                    return false;
                                                }
                                                if (System.Math.Abs(arrowXcorr - devinfocheck.XCoor) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr) || (devinfo.XCoor < num1address && num1address < arrowXcorr) || (devinfo.XCoor > num1address && num1address > arrowXcorr))//有任务的车当前位置有冲突
                                                {
                                                    return false;
                                                }
                                                break;
                                        }
                                    }
                                }
                                #endregion

                                //-----------------------------modify by bz----------------------------------//
                                #region 以前程序
                                //int mutexDeviceLockedState = ccf.GetDeviceLockedState(devinfocheck.DeviceIndex);
                                //if (mutexDeviceLockedState == -1) return true;
                                //int mutexManTaskReserve = ccf.GetManTaskReserve(devinfocheck.DeviceIndex);
                                //int existtask = 0;//gjn
                                //string temp_F_TxtParam = ccf.GetF_TxtParamfromMonitor(TaskIdx);
                                //if ((devinfocheck.RunState == 0) && (mutexManTaskReserve <= 0) && (mutexDeviceLockedState == 0))
                                //{//避让车空闲无任务
                                    
                                //    if (devinfocheck.XCoor > devinfo.XCoor && devinfocheck.XCoor < arrowXcorr + (rgvSecuritydistance-2000))//gjn2000 数值待定&& existtask==0
                                //    {//避让车地址大于当前车，而且在目标位置范围内,找到大于目标位置的本区最近输送机
                                //        ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS>{1} order by F_ADDRESS asc", devinfocheck.DeviceIndex, arrowXcorr + rgvSecuritydistance));
                                //        if (ob != null)
                                //        {
                                //            int mutexConveyor = Convert.ToInt32(ob);
                                //            InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);//mutexConveyor查找到的避让位置gjn
                                //            ifInsert = true;
                                //            break;
                                //        }
                                //        else
                                //        {
                                //            CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                //            return false;
                                //        }
                                //    }
                                //    else if (devinfocheck.XCoor < devinfo.XCoor && devinfocheck.XCoor > arrowXcorr- (rgvSecuritydistance-2000))//gjn 2000 数值待定&& existtask==0
                                //    {//避让车地址小于当前车，而且在目标位置范围内,找到小于目标位置的本区最近输送机
                                        
                                //        ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS<{1} order by F_ADDRESS desc", devinfocheck.DeviceIndex, arrowXcorr - rgvSecuritydistance));
                                //        if (ob != null)
                                //        {
                                //            int mutexConveyor = Convert.ToInt32(ob);
                                //            InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);
                                //            ifInsert = true;
                                //            break;
                                //        }
                                //        else
                                //        {
                                //            CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                //            return false;
                                //        }
                                //    }
                                //}
                                //else
                                //{//有互斥的RGV任务在运行
                                //    int rgvAddr = Model.CGeneralFunction.GetRgvAddrFromMonitor(TaskIdx, devinfo.DeviceIndex, ccf.GetDeviceOrderFromMonitor(TaskIdx));
                                //    int mutRgvAddr= Model.CGeneralFunction.GetRgvAddrFromMonitor(mutexDeviceLockedState, devinfocheck.DeviceIndex, ccf.GetDeviceOrderFromMonitor(mutexDeviceLockedState));
                                //    if (mutRgvAddr > 0)
                                //    {
                                //        //被管理任务预约了，但是还没运行（【送货】等待运行
                                //        if ((devinfocheck.RunState == 0) && (mutexManTaskReserve > 0) && (mutexDeviceLockedState == 0))
                                //        {
                                //            #region mutex被管理任务预约了，但是还没运行（【送货】等待运行）
                                //            int deviceorder = GetDeviceOrderFromManTaskReserve(mutexManTaskReserve, devinfocheck.DeviceIndex);
                                //            if (deviceorder == -1) return false;

                                //            if (mutRgvAddr >= rgvAddr)
                                //            {//避让车地址大于当前车，而且在目标位置范围内,找到大于目标位置的本区最近输送机
                                //                if ((rgvAddr + (rgvSecuritydistance) > mutRgvAddr))
                                //                {
                                //                    ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS>{1} order by F_ADDRESS asc", devinfocheck.DeviceIndex, rgvAddr + rgvSecuritydistance));
                                //                    if (ob != null)
                                //                    {
                                //                        int mutexConveyor = Convert.ToInt32(ob);
                                //                        InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);
                                //                        ifInsert = true;
                                //                        break;
                                //                    }
                                //                    else
                                //                    {
                                //                        CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                //                        return false;
                                //                    }
                                //                }
                                //            }
                                //            else
                                //            {//避让车地址小于当前车，而且在目标位置范围内,找到小于目标位置的本区最近输送机
                                //                if ((rgvAddr - (rgvSecuritydistance) < mutRgvAddr))
                                //                {
                                //                    ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS<{1} order by F_ADDRESS desc", devinfocheck.DeviceIndex, rgvAddr - rgvSecuritydistance));
                                //                    if (ob != null)
                                //                    {
                                //                        int mutexConveyor = Convert.ToInt32(ob);
                                //                        InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);
                                //                        ifInsert = true;
                                //                        break;
                                //                    }
                                //                    else
                                //                    {
                                //                        CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                //                        return false;
                                //                    }
                                //                }
                                //            }


                                //            #endregion
                                //        }
                                //        else
                                //        {//有任务，被预约，但没运行任务,可能报警或者触摸屏控制
                                //            if (mutRgvAddr >= rgvAddr)
                                //            {//避让车地址大于等于当前车，而且在目标位置范围内  都是判断目标地址
                                //                if (rgvAddr - (rgvSecuritydistance) > mutRgvAddr)//gjn
                                //                {
                                //                    return false;
                                //                }
                                //            }
                                //            else
                                //            {//避让车地址小于当前车，而且在目标位置范围内   
                                //                if (rgvAddr - (rgvSecuritydistance) < mutRgvAddr)//gjn
                                //                {
                                //                    return false;
                                //                }
                                //            }
                                //        }
                                        

                                //    }
                                    
                                //}
                                #endregion
                            }
                            //-------------------------------------------add by bz-----------------------------------------//
                            for (int i = 0; i < dvdv.Count; i++)//上一个循环确定车没任务后查找是否有被预约的车（取货完成等待送货下发或者任务被重发）有冲突
                            {
                                devinfocheck = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvdv[i]["F_RGVINDEX"]));
                                int mutexDeviceLockedState = ccf.GetDeviceLockedState(devinfocheck.DeviceIndex);
                                int mutexManTaskReserve = ccf.GetManTaskReserve(devinfocheck.DeviceIndex);
                                if (System.Math.Abs(arrowXcorr - devinfocheck.XCoor) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr))//车当前位置有冲突
                                {
                                    if (mutexDeviceLockedState > 0 || mutexManTaskReserve > 0)
                                    {
                                        return false;
                                    }

                                }
                            }
                            for (int i = 0; i < dvdv.Count; i++)//上一个循环确定车没任务后查找是否有被预约的车（取货完成等待送货下发或者任务被重发）有冲突
                            {
                                devinfocheck = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvdv[i]["F_RGVINDEX"]));
                                int mutexDeviceLockedState = ccf.GetDeviceLockedState(devinfocheck.DeviceIndex);
                                int mutexManTaskReserve = ccf.GetManTaskReserve(devinfocheck.DeviceIndex);
                                if (System.Math.Abs(arrowXcorr - devinfocheck.XCoor) <= rgvSecuritydistance || (devinfo.XCoor < devinfocheck.XCoor && devinfocheck.XCoor < arrowXcorr) || (devinfo.XCoor > devinfocheck.XCoor && devinfocheck.XCoor > arrowXcorr))//车当前位置有冲突
                                {
                                    //插入避让任务
                                    if (Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_DEVICECOMMANDINDEX=7 and F_DEVICEINDEX=" + devinfocheck.DeviceIndex)) == 0)
                                    {
                                        if (devinfo.XCoor >= arrowXcorr)//需要让冲突车向小条码方向避让
                                        {
                                            ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS<{1} order by f_turn, F_ADDRESS desc", devinfocheck.DeviceIndex, arrowXcorr - rgvSecuritydistance));
                                            if (ob != null)
                                            {
                                                int mutexConveyor = Convert.ToInt32(ob);
                                                InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);
                                                sql.Remove(0, sql.Length);
                                                sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(mti.ToString()).Append(fid.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(DeviceIdx).Append(")");
                                                dbo.ExceSQL(sql.ToString());
                                                break;
                                            }
                                            else
                                            {
                                                CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                                return false;
                                            }
                                        }
                                        else//需要让冲突车向大条码方向避让
                                        {
                                            ob = dbo.GetSingle(String.Format("SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where (F_INPUT={0} or F_OUTPUT={0}) and F_ADDRESS>{1} order by f_turn, F_ADDRESS asc", devinfocheck.DeviceIndex, arrowXcorr + rgvSecuritydistance));
                                            if (ob != null)
                                            {
                                                int mutexConveyor = Convert.ToInt32(ob);
                                                InsertRgvMutexTask(devinfo.DeviceIndex, devinfocheck.DeviceIndex, 7, mutexConveyor);
                                                sql.Remove(0, sql.Length);
                                                sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(mti.ToString()).Append(fid.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(DeviceIdx).Append(")");
                                                dbo.ExceSQL(sql.ToString());
                                                break;
                                            }
                                            else
                                            {
                                                CControlError = string.Format("发送命令调用AheadDetectOK时：没有找到避让车{0}可用的躲避站台，可能RGV{1}跨区下任务了", devinfocheck.DeviceIndex, devinfo.DeviceIndex);
                                                return false;
                                            }
                                        }
                                    }
                                    else//已经有运动任务，需要等待
                                    {
                                        return false;
                                    }

                                }
                            }
                            //-------------------------------------------add by bz-----------------------------------------//
                            //if (ifInsert == true) 
                            //{
                            //    return false;
                            //}
                        }
                    }
                }

                //gjn
                //35402RunAfter35401
                DataView dvallow = dbo.ExceSQL(string.Format("SELECT f_status,f_txtparam FROM T_Monitor_Task where f_txtparam like '%35402%' or f_txtparam like '%35401%' or f_txtparam like '%35403%' ")).Tables[0].DefaultView;//gjn

                for (int j = 0; j < dvallow.Count; j++)
                {
                    if (Convert.ToString(dvallow[j]["f_txtparam"]).Substring(0, 5) == Convert.ToString(DeviceIdx))
                    {
                        if (Convert.ToInt32(dvallow[j]["f_status"]) <= 1)
                        {
                            AheadDetectUnallow.Append("等待避让任务执行!");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                    }
                }

                //gjn考虑送到中转站台时，考虑是否有送货到终点的任务  如果有等待，防止占用中转站台
                //DataView dvallowMiddle = dbo.ExceSQL(string.Format("SELECT f_iftransfer FROM T_BASE_RGV_GATE where f_iftransfer = 1 and  f_rgvgatedeviceindex = {0}", _NumParam4)).Tables[0].DefaultView;//gjn
                //if ((dvallowMiddle.Count > 0) && (order == 2))//如果送货站台是中转站台的取货指令
                //{
                //    DataView dvallowEnd = dbo.ExceSQL(string.Format("SELECT F_NUMPARAM4 FROM T_Monitor_Task where F_DEVICECOMMANDINDEX = 3 and  F_MANAGETASKINDEX = {0} and f_managetaskkindindex = {1} order by F_MONITORINDEX desc", fid, mti)).Tables[0].DefaultView;//gjn
                //    if (dvallowEnd.Count > 0)
                //    {
                //        DataView dvallowLastEnd = dbo.ExceSQL(string.Format("SELECT F_STATUS FROM T_Monitor_Task where F_NUMPARAM4 = {0} and  F_STATUS > 0 ", Convert.ToInt32(dvallowEnd[0]["F_NUMPARAM4"]))).Tables[0].DefaultView;//gjn
                //        if (dvallowLastEnd.Count > 0)
                //        {
                //            AheadDetectUnallow.Append("终点送货站台有已经发送的任务!");
                //            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                //            return false;
                //        }

                //    }

                //}
                #endregion
                #region 有互斥设备的堆垛机20111020
                if (DeviceKind == 1 && devinfo.VirtualStack > 0)
                {
                    int mutex = ccf.GetStackMutexDevice(DeviceIdx);
                    if (mutex > 0)
                    {//检查互斥设备空闲时的位置和运行的目标位置
                        Model.MDevice mutexdev = Model.CGetInfo.GetDeviceInfo(mutex);

                        int mutexDeviceLockedState = ccf.GetDeviceLockedState(mutex);
                        if (mutexDeviceLockedState == -1) return true;//20120110
                        int mutexManTaskReserve = ccf.GetManTaskReserve(mutex);
                        if ((mutexdev.RunState == 0) && (mutexManTaskReserve <= 0) && (mutexDeviceLockedState == 0))
                        {//
                            #region mutex空闲、无任务、无管理任务预约锁

                            int xcoor = Model.CGeneralFunction.GetXCoorFromMonitor(TaskIdx, DeviceIdx, ccf.GetDeviceOrderFromMonitor(TaskIdx));
                            int zcoor = Model.CGeneralFunction.GetZCoorFromMonitor(TaskIdx, DeviceIdx, ccf.GetDeviceOrderFromMonitor(TaskIdx));
                            int BCcoor = GetBarcodeCoor(xcoor, zcoor);
                            if (mutex > DeviceIdx)
                            {//mutex=35002

                                if ((BCcoor + StackMutexXCoor) >= mutexdev.XCoor)//mdev.XCoor如果是条码带值需要转换为列值
                                {
                                    InsertStackMutexOrder(mutex, 2, (BCcoor + StackMutexXCoor), 5);
                                    if (mutexdev.XCoor > 52000)//20120110
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        if (devinfo.XCoor <= mutexdev.XCoor - minStackMutexXCoor)
                                        {
                                            return true;
                                        }

                                        else
                                        {
                                            return false;
                                        }
                                    }
                                }
                            }
                            else
                            {//mutex35001
                                if (BCcoor >= (StackMutexXCoor + StackZeroXCoor))
                                {
                                    BCcoor = (BCcoor - StackMutexXCoor);
                                }
                                else
                                {
                                    return true;//对开报警吧，管理下任务错了，或者分配堆垛机设备错误
                                }
                                if (BCcoor <= mutexdev.XCoor)//mdev.XCoor如果是条码带值需要转换为列值
                                {
                                    InsertStackMutexOrder(mutex, 2, BCcoor, 5);
                                    if (mutexdev.XCoor < 4481)//20120110
                                    {
                                        return true;
                                    }
                                    else
                                    {
                                        if (devinfo.XCoor > mutexdev.XCoor + minStackMutexXCoor)
                                        {
                                            return true;
                                        }

                                        else
                                        {
                                            return false;
                                        }

                                    }

                                }
                            }

                            #endregion
                        }
                        else
                        {//mutex有任务运行
                            int xcoor = Model.CGeneralFunction.GetXCoorFromMonitor(TaskIdx, DeviceIdx, ccf.GetDeviceOrderFromMonitor(TaskIdx));
                            int zcoor = Model.CGeneralFunction.GetZCoorFromMonitor(TaskIdx, DeviceIdx, ccf.GetDeviceOrderFromMonitor(TaskIdx));
                            int bccoor = GetBarcodeCoor(xcoor, zcoor);
                            int mutXcoor; int mutZcoor;
                            GetStackRunX_Zcoor(mutex, out mutXcoor, out mutZcoor);
                            if (mutXcoor > 0)
                            {
                                #region 互斥有任务正在运行

                                int mutbccoor = GetBarcodeCoor(mutXcoor, mutZcoor);
                                if (mutex > DeviceIdx)
                                {
                                    if (mutbccoor <= (bccoor + StackMutexXCoor))
                                    {
                                        if (mutbccoor > 52000)
                                        {//20120110
                                            return true;
                                        }
                                        else
                                        {
                                            return false;
                                        }
                                    }


                                }
                                else
                                {//mutex小
                                    if (bccoor >= (StackMutexXCoor + StackZeroXCoor))
                                    {
                                        if (mutbccoor >= (bccoor - StackMutexXCoor))
                                        {

                                            if (mutbccoor < 4481)//20120110
                                            {//20120110
                                                return true;
                                            }
                                            else
                                            {
                                                return false;
                                            }


                                        }
                                    }
                                    else
                                    {
                                        if (bccoor >= 52000)
                                        {
                                            return true;
                                        }
                                        else
                                        {
                                            return false;
                                        }
                                    }
                                }

                                #endregion
                            }
                            else
                            {//有任务，被预约，但没运行任务,可能报警或者触摸屏控制
                                if ((mutexdev.RunState > 0) || (mutexDeviceLockedState != 0))
                                {// 报警或者被任务锁定
                                    #region 互斥设备不空闲

                                    if (mutex > DeviceIdx)
                                    {//mutex=35002
                                        if (mutexdev.XCoor <= (bccoor + StackMutexXCoor))
                                        {
                                            return false;//或者放行直接报警
                                        }

                                    }
                                    else
                                    {//mutex=35001
                                        if (bccoor >= (StackMutexXCoor + StackZeroXCoor))
                                        {
                                            if (mutexdev.XCoor >= (bccoor - StackMutexXCoor))
                                            {
                                                return false;
                                            }
                                        }
                                        else
                                        {
                                            return false;

                                        }
                                    }

                                    #endregion
                                }
                                else
                                {
                                    #region mutex被管理任务预约了，但是还没运行（【送货】等待运行）
                                    int deviceorder = GetDeviceOrderFromManTaskReserve(mutexManTaskReserve, mutex);
                                    if (deviceorder == -1) return false;
                                    GetStackRunReserveX_Zcoor(mutex, out mutXcoor, out mutZcoor);
                                    if (mutex > DeviceIdx)
                                    {
                                        if (mutexdev.XCoor <= (bccoor + StackMutexXCoor))
                                        {
                                            //去货位高度合适位置避让，或者到52列（60000）
                                            InsertStackMutexOrder(mutex, deviceorder, (bccoor + StackMutexXCoor), GetLayerHigh(mutZcoor, mutXcoor));
                                            if (mutexdev.XCoor > 52000)//20120110
                                            {
                                                return true;
                                            }
                                            else
                                            {
                                                if (devinfo.XCoor < mutexdev.XCoor - minStackMutexXCoor)
                                                {
                                                    return true;
                                                }

                                                else
                                                {
                                                    return false;
                                                }
                                            }
                                        }

                                    }
                                    else
                                    {//mutex小
                                        if (bccoor >= (StackMutexXCoor + StackZeroXCoor))
                                        {
                                            if (mutexdev.XCoor >= (bccoor - StackMutexXCoor))
                                            {
                                                //去货位高度合适位置避让，或者到0列（2000）
                                                InsertStackMutexOrder(mutex, deviceorder, (bccoor - StackMutexXCoor), GetLayerHigh(mutZcoor, mutXcoor));
                                                if (mutexdev.XCoor < 4481)
                                                {
                                                    return true;
                                                }
                                                else
                                                {
                                                    if (devinfo.XCoor > mutexdev.XCoor + minStackMutexXCoor)
                                                    {
                                                        return true;
                                                    }

                                                    else
                                                    {
                                                        return false;
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            return false;

                                        }
                                    }

                                    #endregion
                                }
                            }
                        }
                    }
                }
                #endregion

                #region 顶升机先控制近叉输送机送出
                ////20111226
                //string r1 = "12001,42001,32001,12009,42009,32009,12017,42017,32017";
                //if ((r1.IndexOf(DeviceIdx.ToString()) >= 0) &&(devinfo.IfCorrelDoubleFork!="1"))
                //{
                //    if (IFExitTopPriDeviceIdxTaskWait(DeviceIdx+1) == true)
                //    {
                //        return false;
                //    }
                //}
                #endregion

                int CONTROLTASKTYPE = ccf.GetFCONTROLTASKTYPEFromManageTask(mti, fid);

                #region 顶升机构自关联入库任务单独处理//20101011
                
                //20100406入库顶升时必要检测：1102内探物“-11021”；1121低到位“-11212”；有关联任务时，1102外探物“-11022”；
                if ((ccf.GetCorrel_DeviceIndex(devinfo.DeviceIndex, true) == "0") && (CONTROLTASKTYPE == 1) && (devinfo.IfCorrelDoubleFork == "1"))//顶升设备自关联，入库任务20101124增加顶升设备是否双叉判断
                {
                    string[] CorrelInfo = ccf.GetOwnCorrel_DeviceInfo(devinfo.DeviceIndex);
                    if (CorrelInfo == null)
                    {
                        //20110505
                        AheadDetectUnallow.Append("顶升机构" + devinfo.DeviceIndex.ToString()+"没有自关联！");
                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                        return false;

                    }
                    if ((CStaticClass.GetDevicePhotoelectric(CorrelInfo[5]) == 1) && (CStaticClass.GetDevicePhotoelectric(CorrelInfo[2]) == 1))//近巷道有物，顶升低位//20101124
                    {
                        #region 等待关联任务配对
                        //在CStaticClass.DoubleForkWaitTime规定时间内等待；1102（11027）转动等待
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT F_TaskIndex,F_DeviceIndex,F_Remark FROM T_Base_PLC_Ask WHERE (F_TaskIndex =").Append(TaskIdx).Append(") AND (F_Remark is not null) AND (F_DeviceIndex=").Append(devinfo.DeviceIndex).Append(")");
                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {

                            //(Convert.ToDateTime(dv[0]["F_Remark"]).AddSeconds(Convert.ToInt32(CStaticClass.DoubleForkWaitTime)) > DateTime.Now) ||
                            if ((GetIOControlStatus(minMidx) != Model.CGeneralFunction.TASKSINGLEFORKRUN) ||
                                ((CStaticClass.GetDevicePhotoelectric(CorrelInfo[6]) == 1) && (CStaticClass.GetDevicePhotoelectric(CorrelInfo[4]) == 0)))//20101124
                            {
                                if ((CStaticClass.GetDevicePhotoelectric(CorrelInfo[6]) == 1)
                                    && (CStaticClass.GetDevicePhotoelectric(CorrelInfo[4]) == 0))//外探物，运行//20101124
                                {
                                    //查找本地管理任务做多叉关联配对，关联任务分配近叉
                                    int mfid = GetEnableDoubleForkManageTask(1, devinfo.DeviceIndex, fid);
                                    if (mfid > 0)
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(mfid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                                        dbo.ExecuteSql(sql.ToString());
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Manage_Task set FUseAwayFork='0',F_RELATIVECONTORLID=").Append(fid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(mfid);
                                        dbo.ExecuteSql(sql.ToString());
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Monitor_Task set F_UseAwayFork='0' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and F_ManageTaskIndex=").Append(mfid).Append("");
                                        dbo.ExecuteSql(sql.ToString());
                                        //由于已经分配路径不一定符合远近货叉的分配原则，需要改道
                                        AlterRoutePath(mti, mfid, CONTROLTASKTYPE, '0', devinfo.DeviceIndex);
                                    }

                                    return true;
                                }
                                else
                                {
                                    //20110505
                                    AheadDetectUnallow.Append("顶升机构" + devinfo.DeviceIndex.ToString() + "等待关联任务！");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            else
                            {//超过等待时间或者管理强制执行单叉任务
                                if (CStaticClass.GetDevicePhotoelectric(CorrelInfo[4]) == 1)//20101124
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Base_PLC_Ask set F_Remark='").Append(dtime).Append("' where (F_DeviceIndex=").Append(devinfo.DeviceIndex).Append(")");
                                    dbo.ExecuteSql(sql.ToString());
                                    //20110505
                                    AheadDetectUnallow.Append("顶升机构" + devinfo.DeviceIndex.ToString() + "等待关联任务！");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=0,F_Remark='' where (F_DeviceIndex=").Append(devinfo.DeviceIndex).Append(")");
                                dbo.ExecuteSql(sql.ToString());
                                return true;

                            }
                        }
                        else
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_TaskIndex,F_DeviceIndex,F_Remark FROM T_Base_PLC_Ask WHERE (F_TaskIndex =0) AND (F_Remark is null) AND (F_DeviceIndex=").Append(devinfo.DeviceIndex).Append(")");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=").Append(TaskIdx).Append(",F_Remark='").Append(dtime).Append("' where (F_DeviceIndex=").Append(devinfo.DeviceIndex).Append(")");
                                dbo.ExecuteSql(sql.ToString());
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Monitor_Task set F_UseAwayFork='1' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and F_ManageTaskIndex=").Append(fid).Append("");
                                dbo.ExecuteSql(sql.ToString());
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Manage_Task set FUseAwayFork='1' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and FID=").Append(fid).Append("");
                                dbo.ExecuteSql(sql.ToString());
                                //由于已经分配路径不一定符合远近货叉的分配原则，需要改道
                                AlterRoutePath(mti, fid, CONTROLTASKTYPE, '1', devinfo.DeviceIndex);
                                return false;
                            }
                        }

                        #endregion
                    }
                    else
                    {
                        //20110505
                        AheadDetectUnallow.Append("顶升机构" + devinfo.DeviceIndex.ToString() + "不满足关联状态！");
                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                        return false;
                    }

                }

                #endregion

                //双伸远货位曲取货时判断是否有近货位的任务如果有不发送
                #region 双伸位的堆垛机在执行起点是里位(1,4排)的任务时,判读是否有起点是外位(2,3排)的任务，送货到货位时(终点为2,3)判断有没有(1,4)的任务，控制近远叉取送货先后
                if (devinfo.StackReach == 2 && DeviceKind == 1 && (DeviceOrder == 4))// 双伸堆垛机， 取货
                {//z转换后2,3排是近货位，1,4远货位
                    int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
                    string neighborzxy = string.Empty;
                    string sqlstrzxy = string.Empty;//
                    string sqlman = string.Empty;
                    bool check = false;
                    if (zxy != null)
                    {
                        int getZ=0;//取货的排坐标
                        object obz = dbo.GetSingle(string.Format("select T_BASE_SENDROW.F_WMSZ from T_BASE_SENDROW,T_BASE_STACKINFO where T_BASE_STACKINFO.f_laneno =T_BASE_SENDROW.f_laneno and T_BASE_STACKINFO.F_STACKINDEX={0} and T_BASE_SENDROW.F_SENDZ={1}",devinfo.DeviceIndex, zxy[0]));
                        if (obz != null)
                        {
                            getZ = Convert.ToInt32(obz);//取货的排坐标
                        }
                        int sendZ=0 ; //送货位置对应的排坐标
                        obz = dbo.GetSingle(string.Format("select T_BASE_SENDROW.F_WMSZ from T_BASE_SENDROW,T_BASE_STACKINFO where T_BASE_STACKINFO.f_laneno =T_BASE_SENDROW.f_laneno and T_BASE_STACKINFO.F_STACKINDEX={0} and T_BASE_SENDROW.F_SENDZ={1}", devinfo.DeviceIndex, zxy[3]));
                        if (obz != null)
                        {
                            sendZ = Convert.ToInt32(obz);//送货位置对应的排坐标
                        }
                        int newZ;
                        int tempZ = 0;
                        #region 1,4排远位取货时，要判读是否有进位的取货任务
                        tempZ =zxy[0];
                        if (tempZ == 1 || tempZ == 4)//远位取货时，要判读是否有进位的取货任务
                        {//获取外位坐标
                            if (tempZ == 1)
                            {//1->2
                                newZ = getZ + 1;
                            }
                            else
                            {//4->3
                                newZ = getZ - 1;
                            }
                            neighborzxy = string.Format("{0:D2}-{1:D2}-{2:D2}", newZ, zxy[1], zxy[2]);//获得外位坐标
                            sqlstrzxy = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE  (F_DeviceCommandIndex =4)  and (F_NumParam1 = {0}) AND (F_NumParam2 = {1}) AND (F_NumParam3 = {2}) and (F_DeviceIndex={3})", newZ, zxy[1], zxy[2], DeviceIdx);
                            sqlman = string.Format("SELECT FID FROM T_Manage_Task WHERE  (FSTATUS = 0) AND(FSTARTDEVICE = {0}) AND (FSTARTCELL = '{1}') ", StartDevice, neighborzxy);
                            
                            check = true;

                            if (check)
                            {
                                dvdv = dbo.ExceSQL(sqlstrzxy).Tables[0].DefaultView;
                                if (dvdv.Count > 0)// 
                                {

                                    AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));

                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;//不能执行出库任务
                                }
                                dvdv = dbo.ExceSQL(sqlman).Tables[0].DefaultView;
                                if (dvdv.Count > 0)// 
                                {

                                    AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));

                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;//不能执行出库任务
                                }
                            }
                        }
                        #endregion

                        #region 2,3排近位送货时，要判读是否有远位的送货任务
                        
                        tempZ = zxy[3] % 4;
                        if (tempZ == 2 || tempZ == 3)//近位送货时，要判读是否有远位的送货任务
                        {//获取里位坐标
                            if (tempZ == 2)
                            {
                                newZ = sendZ - 1;
                            }
                            else
                            {
                                newZ = sendZ + 1;
                            }
                            neighborzxy = string.Format("{0:D2}-{1:D2}-{2:D2}", newZ, zxy[4], zxy[5]);//获得外位坐标
                            sqlstrzxy = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE  ( F_DeviceCommandIndex =5)  and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2}) and (F_DeviceIndex={3})", newZ, zxy[4], zxy[5], DeviceIdx);
                            sqlman = string.Format("SELECT FID FROM T_Manage_Task WHERE  (FSTATUS = 0) AND(FENDDEVICE = {0}) AND (FENDCELL = '{1}') ", EndDevice, neighborzxy);
                            check = true;
                            if (check)
                            {
                                dvdv = dbo.ExceSQL(sqlstrzxy).Tables[0].DefaultView;
                                if (dvdv.Count > 0)// 
                                {

                                    AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));

                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;//不能执行出库任务
                                }
                                dvdv = dbo.ExceSQL(sqlman).Tables[0].DefaultView;
                                if (dvdv.Count > 0)// 
                                {
                                    AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));

                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;//不能执行出库任务
                                }
                            }
                        }
                        #endregion
                    }

                }
                #endregion

                //20101011
                #region 双叉堆垛机的取货任务在此判断是否关联双叉、验证双叉任务是否为双叉极限货位
                if ((devinfo.DeviceKind == 1) && (devinfo.IfCorrelDoubleFork == "1") && (ccf.GetDeviceOrderFromMonitor(minMidx) == 4) )
                {
                    string[] DevLanewayIOInfo = ccf.GetDeviceLaneGateInfoFromStackCoor(devinfo.DeviceIndex,minMidx);
                    if (DevLanewayIOInfo == null)
                    {
                        //不是巷道口的取货任务不需要关联
                        CommonClassLib.CCarryConvert.WriteDarkCasket("单叉执行原因", minMidx.ToString(), devinfo.DeviceIndex.ToString(), "不是巷道口的取货任务不需要关联");
                        return true ;
                    }
                    Dictionary<int, string[]> corrinfo=Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, devinfo.DeviceIndex);
                    
                    if (corrinfo == null)//20110412没关联任务
                    {
                        #region 20110412堆垛机在顶升机取单叉任务，验证是否需要换货叉
                        string ChangeForkCell = ccf.IfLimitCellChangeFork(minMidx, devinfo.DeviceIndex);

                        if (ChangeForkCell != "-")//主任务需要倒换货叉
                        {
                            ccf.ChangeEndCellCode(minMidx, ChangeForkCell, devinfo.DeviceIndex);
                            return false;//20140423richard如果不返回false，还会使用原来的坐标继续发送
                        }
                        #endregion

                        #region 没关联任务

                        //string IfCorrel = ccf.GetCorrel_DeviceIndex(minMidx);//20110505
                        //if (IfCorrel == "")//无关联
                        //{
                        //}
                        //else if (IfCorrel == "0")//自关联
                        //{
                        //    //20110108
                        //    dbo.ExecuteSql("update T_Monitor_Task set F_UseAwayFork='1' where F_ManageTASKKINDINDEX=" + mti + " and F_ManageTaskIndex=" + fid + "");
                        //    dbo.ExecuteSql("update T_Manage_Task set FUseAwayFork='1' where F_ManageTASKKINDINDEX=" + mti + " and FID=" + fid + "");

                        //    #region 20110412堆垛机在顶升机取单叉任务，验证是否需要换货叉
                        //    string ChangeForkCell = ccf.IfLimitCellChangeFork(minMidx, devinfo.DeviceIndex);

                        //    if (ChangeForkCell != "-")//主任务需要倒换货叉
                        //    {
                        //        ccf.ChangeEndCellCode(minMidx, ChangeForkCell, devinfo.DeviceIndex);

                        //    }
                        //    #endregion
                        //}

                        //else
                        //{//有关联站台
                        //    #region 双叉对等站台的单任务在此等待关联，双叉极限货位不关联

                        //    if ((CStaticClass.GetDevicePhotoelectric(DevLanewayIOInfo[3]) == 1) && (CStaticClass.GetDevicePhotoelectric(DevLanewayIOInfo[1]) == 1))//有货，顶升高位
                        //    {
                        //        #region 顶升高位有货
                        //        bool isend;
                        //        return GetCorrManageTask(DevLanewayIOInfo, TaskIdx, CONTROLTASKTYPE, mti, fid, dtime,out isend);

                        //        #endregion
                        //    }
                        //    else
                        //    {
                        //        CommonClassLib.CCarryConvert.WriteDarkCasket("单叉执行原因", minMidx.ToString(), devinfo.DeviceIndex.ToString(), "顶升高位和有物信号不满足条件");
                        //    }
                        //    #endregion
                        
                        //}
                        
                        #endregion
                    }
                    else
                    {
                        #region 有关联任务信息
                        #region 判断是否还有可关联的关联站台任务20120906
                        //bool isend;
                        //GetCorrManageTask(DevLanewayIOInfo, TaskIdx, CONTROLTASKTYPE, mti, fid, dtime,out isend);
                        //if (isend == false) return false;
                        #endregion
                        foreach (int CorrTaskindex in corrinfo.Keys)
                        {
                            #region 双叉任务在此验证，是否为双叉极限货位，双极限货位使用双叉倒库货位修改任务
                            //把倒库货位作为取货和送货动作的目标货位，增加取货和送货动作对于倒库货位的逻辑有物的提前检测
                            //报告倒库货位完成时，追加倒库货位---》需要换叉的极限货位的取货和送货任务
                            
                            #region 检查关联任务
                            string ChangeForkCell1 = ccf.IfLimitCellChangeFork(CorrTaskindex, devinfo.DeviceIndex);

                            #endregion
                            if (ChangeForkCell1 != "-") //关联任务需要倒换货叉
                            {
                                ccf.ChangeEndCellCode(CorrTaskindex, ChangeForkCell1, devinfo.DeviceIndex);
                                return false;//20140423richard如果不返回false，还会使用原来的坐标继续发送
                            }
                            #endregion
                        }

                        #endregion
                    }

                    

                    
                }
                #endregion

                #region 双叉AGV的入库取货任务在此判断是否关联双叉、验证双叉任务是否为双叉极限货位
                if ((devinfo.DeviceKind == 6) && (devinfo.IfCorrelDoubleFork == "1") && (ccf.GetDeviceOrderFromMonitor(minMidx) ==2) && ((CONTROLTASKTYPE == 1)||(CONTROLTASKTYPE == 4)))
                {

                    Dictionary<int, string[]> corrinfo = Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, devinfo.DeviceIndex);

                    if (corrinfo == null)
                    {
                        #region 双叉对等站台的单任务在此等待关联，双叉极限货位不关联
                        if (GetIOControlStatus(TaskIdx) != Model.CGeneralFunction.TASKSINGLEFORKRUN)
                        {//没强制单叉执行
                            
                            //查找关联站台
                            int agvCorrel = GetAGVCorrelIndex(TaskIdx);
                            if (agvCorrel != -1)
                            {
                                //查找本地管理任务做多叉关联配对，关联任务分配货叉
                                int mfid = GetAGVEnableDoubleForkManageTask(CONTROLTASKTYPE, agvCorrel, devinfo.DeviceIndex);
                                if (mfid > 0)
                                {
                                    #region 双叉同为前极限后者后极限不关联，单独执行
                                    if ((IfInSameLimitX(fid, mfid, mti) == true) && (mti == 1))
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(fid).Append(")");
                                        dboM.ExecuteSql(sql.ToString());
                                        sql.Remove(0, sql.Length);
                                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(mfid).Append(")");
                                        dboM.ExecuteSql(sql.ToString());
                                        return true;
                                    }
                                    #endregion
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(mfid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                                    dbo.ExecuteSql(sql.ToString());
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(fid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(mfid);
                                    dbo.ExecuteSql(sql.ToString());
                                    return true;
                                }

                                else
                                {
                                    //20110505
                                    AheadDetectUnallow.Append("双叉AGV在双叉校表站台取货" + "，等待多叉关联站台"+agvCorrel.ToString()+"的任务！");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            else
                                return true ;
                        }
                        else
                        {//管理强制执行单叉任务
                            return true;

                        }
                        

                        #endregion
                    }

                }
                #endregion

                #region 双叉AGV的出库口输送机取货任务在此判断是否关联双叉20110412
                if ((devinfo.DeviceKind == 6) && (devinfo.IfCorrelDoubleFork == "1") && ((ccf.GetDeviceOrderFromMonitor(minMidx) == 2) 
                    || (ccf.GetDeviceOrderFromMonitor(minMidx) == 4)) && (CONTROLTASKTYPE == 2))
                {

                    Dictionary<int, string[]> corrinfo = Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, devinfo.DeviceIndex);

                    if (corrinfo == null)
                    {
                        #region 双叉对等站台的单任务在此等待关联，双叉极限货位不关联
                        if (GetIOControlStatus(TaskIdx)!= Model.CGeneralFunction.TASKSINGLEFORKRUN)//20110429测试应该为GetIOControlStatus(TaskIdx)！=
                        {//没强制单叉执行

                            //查找关联站台
                            int agvCorrel = GetAGVCorrelConveyorIndex(TaskIdx);
                            if (agvCorrel != -1)
                            {
                                #region 查找队列中是否有agvCorrel的任务：如果没有，不再等待，单叉执行；

                                if (GetAGVEnableDoubleForkManageTask(2, agvCorrel, devinfo.DeviceIndex) <= 0)//没有能关联的任务，不再等待，单叉执行
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(fid).Append(")");
                                    dboM.ExecuteSql(sql.ToString());
                                    return true;
                                }
                                
                                #endregion
                                #region 20110412有能关联的任务，判断agvCorrel是否有物而且任务已经到取货状态
                                int[] cstates = CStaticClass.GetDeviceState(agvCorrel);
                                int cssstate = -1;
                                if (cstates != null)
                                {
                                    cssstate = cstates[1];
                                }
                                if ((cssstate!=0) || (CStaticClass.GetDevicePhotoelectric(agvCorrel - 2, 0) != 1) || (CStaticClass.GetDevicePhotoelectric(agvCorrel, 2) != 1))//20110412顶升机空闲、有货、低位
                                {
                                    //20110505
                                    AheadDetectUnallow.Append("双叉AGV在双叉校表站台取货" + "，等待多叉关联站台" + agvCorrel.ToString() + "的任务！");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                                #endregion
                                //查找本地管理任务做双叉在输送机取货任务关联配对，关联任务分配货叉
                                int mfid = GetAGVFromConveyorDoubleForkGetGoodManageTask(2, agvCorrel, devinfo.DeviceIndex);
                                if (mfid > 0)
                                {
                                    #region 终点不相同，单叉分别执行
                                    if (IFHaveSameEndDevice(fid, mfid, mti) == false)
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(fid).Append(")");
                                        dboM.ExecuteSql(sql.ToString());
                                        sql.Remove(0, sql.Length);
                                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(mfid).Append(")");
                                        dboM.ExecuteSql(sql.ToString());
                                        return true;
                                    }
                                    #endregion
                                    #region 双叉同为前极限后者后极限不关联，单独执行
                                    //if ((IfInSameLimitX(fid, mfid, mti) == true) && (mti == 1))
                                    //{
                                    //    sql.Remove(0, sql.Length);
                                    //    sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(fid).Append(")");
                                    //    dboM.ExecuteSql(sql.ToString());
                                    //    sql.Remove(0, sql.Length);
                                    //    sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(mfid).Append(")");
                                    //    dboM.ExecuteSql(sql.ToString());
                                    //    return true;
                                    //}
                                    #endregion
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(mfid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                                    dbo.ExecuteSql(sql.ToString());
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(fid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(mfid);
                                    dbo.ExecuteSql(sql.ToString());
                                    return true;
                                }

                                else
                                {
                                    //20110505
                                    AheadDetectUnallow.Append("双叉AGV在输送机取货" + "，没找到多叉关联任务，关联站台"+agvCorrel.ToString()+"有异常物体遮挡开关！");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                    return false;
                                }
                            }
                            else
                                return true;
                        }
                        else
                        {//管理强制执行单叉任务
                            return true;

                        }


                        #endregion
                    }

                }
                #endregion

                return true;


            }
            catch (Exception ex)
            {
                RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", "发送指令提前检测时发生错误：" + ex.StackTrace + ex.Message);
                OnRefreshMonitor(rme);
                return false;
            }
            finally
            {
                dv.Dispose();
                dvdv.Dispose();
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="mutexRgv">避让RGV</param>
        /// <param name="order">避让命令字7</param>
        /// <param name="mutexConveyor">用于避让的输送机</param>
        /// <exception cref="NotImplementedException"></exception>
        private void InsertRgvMutexTask(int rgv,int mutexRgv, int order, int mutexConveyor)
        {
            try
            {
                DataView dv = dbo.ExceSQL(string.Format("select F_MonitorIndex from T_Monitor_Task where F_DeviceIndex={0} and F_TxtParam='{1}RunAfter{0}'", mutexRgv,rgv)).Tables[0].DefaultView;
                if (dv.Count <= 0)
                {
                    int hidx = ccf.GetManageHandIdx();
                    int hmindx = ccf.GetMonitorIndex(hidx, 2);
                    string dtime = DateTime.Now.ToString("u");
                    sql.Remove(0, sql.Length);
                    sql.Append("insert into T_Monitor_Task(F_MonitorTaskLevel,F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex,").
                            Append("F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,f_no1)").
                            Append("values(2,").Append(ccf.GetRouteIDsub(mutexRgv)).Append(",").
                            Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(mutexRgv).
                            Append(",").Append(order).Append(",").Append(mutexConveyor).Append(",").Append(0).Append(",").Append(0).Append(",").Append(0).Append(",").Append(0).Append(",").Append(0).Append(",'").Append(rgv).Append("RunAfter").Append(mutexRgv).Append("','I").Append(mutexRgv).Append("',").Append(1).Append(")");//gjn
                    dbo.ExecuteSql(sql.ToString());
                   string sql1 = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                    rgv + "RunAfter"+mutexRgv+"'," + hidx + ",4,-1,1," + mutexConveyor + ",'0" + "','-" 
                    + "'," + mutexConveyor + ",'" + "-" + "','" + dtime + "'," + "0" + ")";
                    dbo.ExceSQL(sql1);
                }
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 设置RGV可以关联的双叉取货任务,分配货叉
        /// </summary>
        /// <param name="mti">管理任务类型</param>
        /// <param name="fid">管理任务索引</param>
        /// <param name="forkNO">叉编号</param>
        /// <param name="correlFid">关联管理任务索引</param>
        /// <param name="correlForkNO">管理任务叉编号</param>
        private void SetRgvCorrelManageTask(int mti,int fid,int rgvStation,int forkNO,int rgvCorrelStation, int correlFid,int correlForkNO)
        {//一个管理任务号作为大家的关联任务号,编号小站台是1叉，编号大站台是2叉
            try
            {
                if (forkNO == 0 || correlForkNO == 0)
                {
                    if (forkNO == 0 && correlForkNO == 0)
                    {
                        if (rgvStation < rgvCorrelStation)
                        {
                            forkNO = 2;
                            correlForkNO = 1;
                        }
                        else
                        {
                            forkNO = 1;
                            correlForkNO = 2;
                        }
                    }
                    else
                    {
                        if (forkNO == 0 && correlForkNO != 0)
                        {
                            if (correlForkNO == 1)
                            {
                                forkNO = 2;
                            }
                            else
                            {
                                forkNO = 1;
                            }
                        }
                        else
                        {
                            if (forkNO == 1)
                            {
                                correlForkNO = 2;
                            }
                            else
                            {
                                correlForkNO = 1;
                            }
                        }
                    }
                }
                sql.Remove(0, sql.Length);
                sql.Append("update T_Manage_Task set FUseAwayFork='").Append(forkNO).Append("',F_RELATIVECONTORLID=").Append(correlFid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                dbo.ExecuteSql(sql.ToString());
                sql.Remove(0, sql.Length);
                sql.Append("update T_Monitor_Task set F_UseAwayFork='").Append(forkNO).Append("' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and F_ManageTaskIndex=").Append(fid);
                dbo.ExecuteSql(sql.ToString());
                sql.Remove(0, sql.Length);
                sql.Append("update T_Manage_Task set FUseAwayFork='").Append(correlForkNO).Append("',F_RELATIVECONTORLID=").Append(correlFid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(correlFid);
                dbo.ExecuteSql(sql.ToString());
                sql.Remove(0, sql.Length);
                sql.Append("update T_Monitor_Task set F_UseAwayFork='").Append(correlForkNO).Append("' where F_ManageTASKKINDINDEX=").Append(mti).Append(" and F_ManageTaskIndex=").Append(correlFid);
                dbo.ExecuteSql(sql.ToString());
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private bool IFExitTopPriDeviceIdxTaskWait(int DeviceIdx)
        {
            sql.Clear();
            DataView dv0 = new DataView(); DataView dv = new DataView();
            try
            {
                sql.Append(string.Format("SELECT F_ManageTaskIndex, F_ManageTASKKINDINDEX FROM T_Monitor_Task WHERE (F_DeviceIndex = {0})", DeviceIdx));
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                for (int i = 0; i < dv.Count; i++)
                {
                    sql.Clear();
                    if (CStaticClass.DBFactory == "OracleDBFactory")
                    {//20151120调度系统oracle的特殊语句
                        sql.Append(string.Format("SELECT F_DeviceIndex,F_Status FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX = {0}) and F_ManageTaskIndex={1} order by F_MonitorIndex asc  FETCH FIRST ROWS ONLY", Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dv[i]["F_ManageTASKINDEX"])));
                    }
                    else
                    {
                        sql.Append(string.Format("SELECT top 1 F_DeviceIndex,F_Status FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX = {0}) and F_ManageTaskIndex={1} order by F_MonitorIndex asc", Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dv[i]["F_ManageTASKINDEX"])));
                    }
                    dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
                    if (dv0.Count > 0)
                    {
                        if ((dv0[0]["F_DeviceIndex"].ToString() == DeviceIdx.ToString()) && (dv0[0]["F_Status"].ToString() == "0"))
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv0.Dispose();
            }
        }

        private int GetBarcodeCoor(int xcoor, int zcoor)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT BarcodeCoor FROM T_Base_BarcodeCoor WHERE (XCoor = {0}) AND (ZCoor = {1})", xcoor, zcoor)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0][0]);
                }
                else
                {
                    dv = dbo.ExceSQL(string.Format("SELECT BarcodeCoor FROM T_Base_BarcodeCoor WHERE (XCoor1 = {0}) AND (ZCoor1 = {1})", xcoor, zcoor)).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        return Convert.ToInt32(dv[0][0]);
                    }
                    else
                    {
                        return 0;
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }

        /// <summary>
        /// 获得发送信息
        /// </summary>
        /// <param name="minMidx">设备指令索引</param>
        public bool  GetSendInfo(int minMidx)
        {
            DataView dvD = new DataView();
            try
            {

                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_DeviceKindIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4," ).Append(
                    "F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,F_ManTaskReserve,F_LockedState," ).Append(
                    "F_Associate,F_SerialNumber,F_RouteID,F_DeviceIndex,F_DeviceCommandIndex," ).Append(
                    "F_MonitorIndex,F_ManageTaskIndex,F_ManageTaskKindIndex,F_OutsideAltDevice," ).Append(
                    "F_InsideAltDevice,F_StartDevice,F_EndDevice,F_RouteKind,F_UseAwayFork,F_AgvNo " ).Append(
                    " FROM  V_Monitor_Route_Device where F_MonitorIndex=" ).Append( minMidx);
                
                dvD = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;

                if (dvD.Count > 0)
                {
                    if (dvD[0]["F_AheadDetect"] != DBNull.Value)
                    {
                        _AheadDetect = dvD[0]["F_AheadDetect"].ToString();
                    }
                    else
                    {
                        _AheadDetect = "";
                    }
                    if (dvD[0]["F_ManTaskReserve"] != DBNull.Value)
                    {
                        _ManTaskReserve = Convert.ToInt32(dvD[0]["F_ManTaskReserve"]);
                    }
                    else
                    {
                        _ManTaskReserve = 0;
                    }
                    if (dvD[0]["F_Associate"] != DBNull.Value)
                    {
                        _Associate = Convert.ToInt32(dvD[0]["F_Associate"]);
                    }
                    else
                    {
                        _Associate = 0;
                    }
                    if (dvD[0]["F_LockedState"] != DBNull.Value)
                    {
                        _LockedState = Convert.ToInt32(dvD[0]["F_LockedState"]);
                    }
                    else
                    {
                        _LockedState = 0;
                    }
                    if (dvD[0]["F_NumParam1"] != DBNull.Value)
                    {
                        _NumParam1 = Convert.ToInt32(dvD[0]["F_NumParam1"]);
                    }
                    else
                    {
                        _NumParam1 = 0;
                    }
                    if (dvD[0]["F_NumParam2"] != DBNull.Value)
                    {
                        _NumParam2 = Convert.ToInt32(dvD[0]["F_NumParam2"]);
                    }
                    else
                    {
                        _NumParam2 = 0;
                    }
                    if (dvD[0]["F_NumParam3"] != DBNull.Value)
                    {
                        _NumParam3 = Convert.ToInt32(dvD[0]["F_NumParam3"]);
                    }
                    else
                    {
                        _NumParam3 = 0;
                    }
                    if (dvD[0]["F_NumParam4"] != DBNull.Value)
                    {
                        _NumParam4 = Convert.ToInt32(dvD[0]["F_NumParam4"]);
                    }
                    else
                    {
                        _NumParam4 = 0;
                    }
                    if (dvD[0]["F_NumParam5"] != DBNull.Value)
                    {
                        _NumParam5 = Convert.ToInt32(dvD[0]["F_NumParam5"]);
                    }
                    else
                    {
                        _NumParam5 = 0;
                    }
                    if (dvD[0]["F_NumParam6"] != DBNull.Value)
                    {
                        _NumParam6 = Convert.ToInt32(dvD[0]["F_NumParam6"]);
                    }
                    else
                    {
                        _NumParam6 = 0;
                    }
                    if (dvD[0]["F_TxtParam"] != DBNull.Value)
                    {
                        _TxtParam = dvD[0]["F_TxtParam"].ToString();
                    }
                    else
                    {
                        _TxtParam = "-";
                    }
                    _serialNumber = Convert.ToInt32(dvD[0]["F_SerialNumber"]);
                    _routeID = Convert.ToInt32(dvD[0]["F_RouteID"]);
                    _DeviceIdx = Convert.ToInt32(dvD[0]["F_DeviceIndex"]);
                    _DeviceOrder = Convert.ToInt32(dvD[0]["F_DeviceCommandIndex"]);
                    _ManageKindIdx = Convert.ToInt32(dvD[0]["F_ManageTaskKindIndex"]);
                    _ManageTaskIdx = Convert.ToInt32(dvD[0]["F_ManageTaskIndex"]);
                    _DeviceKind = Convert.ToInt32(dvD[0]["F_DeviceKindIndex"]);
                    if (dvD[0]["F_OutsideAltDevice"] != DBNull.Value)
                    {
                        _OutsideAltDevice = Convert.ToInt32(dvD[0]["F_OutsideAltDevice"]);
                    }
                    else 
                    {
                        _OutsideAltDevice = 0;
                    }
                    if (dvD[0]["F_InsideAltDevice"] != DBNull.Value)
                    {
                        _InsideAltDevice = Convert.ToInt32(dvD[0]["F_InsideAltDevice"]);
                    }
                    else
                    {
                        _InsideAltDevice = 0;
                    }
                    _StartDevice = Convert.ToInt32(dvD[0]["F_StartDevice"]);
                    _EndDevice = Convert.ToInt32(dvD[0]["F_EndDevice"]);
                    _RouteKind = Convert.ToInt32(dvD[0]["F_RouteKind"]);
                    
                    if (dvD[0]["F_AgvNo"] != DBNull.Value)
                    {
                        _AgvNo = Convert.ToInt32(dvD[0]["F_AgvNo"]);
                    }
                    else
                    {
                        _AgvNo = 65535;
                    }
                    return true;
                }
                else
                {//20120420
                    CControlError = string.Format("发送命令调用GetSendInfo时：路径表里【{0}】设备索引不存在！", GetDeviceFromMonitor(minMidx).ToString());
                    
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dvD.Dispose();
            }
        }
        /// <summary>
        /// 发送指定调度任务号的命令
        /// </summary>
        /// <param name="MonitorIndex"></param>
        /// <returns></returns>
        public bool SendMonitorTask(int MonitorIndex)
        {//20230811richard.liu
            try
            {
               
                lock (thisLock)
                {
                    char[] sep = new char[1] { '-' };
                    int msgIdx = 0;//消息编号
                    bool sendok;
                    #region 多叉关联设备指令，如果不能同步执行，发送距离堆垛机当前位置近的设备指令
                    MonitorIndex = GetDoubleForkMinRouteTask(MonitorIndex);
                    if (MonitorIndex == -1) { return false; }
                    #endregion

                    //获得要发送的信息
                    if (GetSendInfo(MonitorIndex) == false) { return false; }
                    int deviceIdx = _DeviceIdx;
                    int deviceKind = _DeviceKind;
                    int deviceOrder = _DeviceOrder;
                    int startdevice = _StartDevice;
                    int manageKindIdx = ccf.GetManageTaskKindIndexFromMonitor(MonitorIndex);
                    int manageTaskIdx = ccf.GetManageTaskIndexFromMonitor(MonitorIndex);
                    int manageTaskType = ccf.GetManageTaskTypefromMonitor(MonitorIndex);
                    devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
                    if (((deviceKind == 1 && (devinfo.XCoor == 0) && (devinfo.YCoor == 0)) || (deviceKind == 4) && (devinfo.XCoor == 0) && (devinfo.YCoor == 0)) && (devinfo.VirtualStack != deviceIdx))//20130510
                    {
                        AheadDetectUnallow.Clear();
                        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "的光通讯被遮挡，或者没上电！");
                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                        return false;
                    }
                    if (deviceIdx == 32901 && deviceOrder == 7)
                    {
                        int count1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_NUMPARAM4=32905"));
                        int count2 = CStaticClass.GetDevicePhotoelectric(32905, 0);
                        int count3 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_NUMPARAM4=32904"));
                        int count4 = CStaticClass.GetDevicePhotoelectric(32904, 0);
                        if (count1 + count2 <= count3 + count4)
                        {
                            dbo.ExceSQL("update t_monitor_task set F_DEVICECOMMANDINDEX=6,F_NUMPARAM4=32905 where F_MONITORINDEX=" + MonitorIndex);
                        }
                        else
                        {
                            dbo.ExceSQL("update t_monitor_task set F_DEVICECOMMANDINDEX=6,F_NUMPARAM4=32904 where F_MONITORINDEX=" + MonitorIndex);
                        }
                        return false;
                    }
                    if (deviceIdx == 32911 && deviceOrder == 7)
                    {
                        int count1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_NUMPARAM4=32915"));
                        int count2 = CStaticClass.GetDevicePhotoelectric(32915, 0);
                        int count3 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_NUMPARAM4=32914"));
                        int count4 = CStaticClass.GetDevicePhotoelectric(32914, 0);
                        if (count1 + count2 <= count3 + count4)
                        {
                            dbo.ExceSQL("update t_monitor_task set F_DEVICECOMMANDINDEX=6,F_NUMPARAM4=32915 where F_MONITORINDEX=" + MonitorIndex);
                        }
                        else
                        {
                            dbo.ExceSQL("update t_monitor_task set F_DEVICECOMMANDINDEX=6,F_NUMPARAM4=32914 where F_MONITORINDEX=" + MonitorIndex);
                        }
                        return false;
                    }
                    if (ccf.GetManageTaskKindIndexFromMonitor(MonitorIndex) == 4)
                    {
                        #region 手工任务
                        string ah = "I" + deviceIdx.ToString();
                        if ((deviceKind != 1) && ((deviceKind != 4)))
                        {
                            ah = "";
                        }
                        if (AheadDetectOK(MonitorIndex, ah) == false) //不符合运行条件ccf.GetBeDetectedDevices(_DeviceIdx))
                        {
                            return false;
                        }

                        //CStaticClass.MessageIndex++;
                        CStaticClass.MessageIndex = 1;
                        msgIdx = (CStaticClass.MessageIndex);

                        sdo = CommModeCreate.CreateSendDeviceOrder(deviceIdx);

                        int[] gc = new int[6] { _NumParam2, _NumParam3, _NumParam1, _NumParam5, _NumParam6, _NumParam4 };

                        if ((deviceKind == 1) || (deviceKind == 6))
                        {
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
                               deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        else if (deviceKind == 4)
                        {
                            if (ccf.NeedOptimize(deviceIdx) == true)
                            {
                                ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
                                sendok = true;
                            }
                            else
                            {
                                int location = gc[2];//gjn
                                if (deviceOrder == 2 || deviceOrder == 7)
                                {
                                    location = gc[2];
                                }
                                else if (deviceOrder == 3)
                                {
                                    location = gc[5];
                                }
                                sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, location, out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                //20231017
                                if (sendok == true)
                                {
                                    AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                                }
                            }

                        }
                        else if (_DeviceKind == 13)
                        {//richard.liu20230718鸿安环穿
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
                                    deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        else
                        {
                            //if ((deviceIdx == 32072 || deviceIdx == 32086 || deviceIdx == 32103 || deviceIdx == 32120) && (deviceOrder == 6))//&&Order==1
                            //{
                            //    if (devinfo.SplitByte_7 == 0)
                            //    {
                            //        AheadDetectUnallow.Clear();
                            //        AheadDetectUnallow.Append(deviceIdx.ToString() + "等待叠托机允许运行信号");
                            //        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                            //    }

                            //}
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        if (sendok == false)
                        {
                            if (sdo.CommLayerError != null)
                            {
                                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", sdo.CommLayerError);
                                OnRefreshMonitor(rmea);
                            }
                            return false;
                        }
                        else
                        {
                            //20231017richard.liu
                            ccf.SendOrderSuccess(manageKindIdx, manageTaskIdx, MonitorIndex, deviceIdx, _routeID);
                            #region 多叉关联任务，能同步的同时报告发送命令成功
                            //20100323
                            devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
                            if (devinfo.IfCorrelDoubleFork == "1")
                            {
                                int[] mforkMoninfo = Model.CGeneralFunction.MutiForkIfSync(MonitorIndex, deviceIdx, deviceKind);
                                if (mforkMoninfo != null)
                                {
                                    Dictionary<int, string[]> corr = Model.CGeneralFunction.GetDoubleForkMonitorInfo(MonitorIndex, deviceIdx);
                                    for (int i = 0; i < mforkMoninfo.GetLength(0); i++)
                                    {
                                        ccf.SendOrderSuccess(ccf.GetManageTaskKindIndexFromMonitor(mforkMoninfo[i]), ccf.GetManageTaskIndexFromMonitor(mforkMoninfo[i]), mforkMoninfo[i], Convert.ToInt32(corr[mforkMoninfo[i]][2]), Convert.ToInt32(corr[mforkMoninfo[i]][3]));

                                    }
                                }
                            }
                            #endregion
                            return true;
                        }
                        #endregion
                    }
                    #region 自动命令(taskkind == 1，2)

                    //2：提取每个管理单据的第一个设备状态
                    if (GetFirstDeviceIFLocked(MonitorIndex, true) == false)//没有被锁定，空闲
                    {
                        devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
                        //7：发送此设备命令
                        //CStaticClass.MessageIndex++;
                        CStaticClass.MessageIndex = 1;
                        msgIdx = (CStaticClass.MessageIndex);
                        sdo = CommModeCreate.CreateSendDeviceOrder(deviceIdx);
                        //判断设备是否为堆垛机RGV和ＡＧＶ
                        int[] gc = new int[6] { _NumParam2, _NumParam3, _NumParam1, _NumParam5, _NumParam6, _NumParam4 };//获得坐标
                        if (gc == null)
                        {
                            this.CControlError +=string.Format( "发送命令时不能取得设备坐标！");
                            return false;
                        }
                        if (deviceKind == 1)
                        {
                            //1：堆垛机；4：RGV；6：AGV如果需要优化调度（设备表的F_NeedOptimize='1'）
                            //直接写入表：T_Monitor_Task_Child，不发送命令
                            if (ccf.NeedOptimize(deviceIdx) == true)
                            {
                                ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
                                sendok = true;
                            }
                            else
                            {
                                sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
                                    deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                //20231017
                                if (sendok == true)
                                {
                                    AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                                }

                            }
                        }
                        else if (deviceKind == 6)
                        {
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
                                    deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            if ((deviceKind == 6) && (sendok == false))
                            {
                                AheadDetectUnallow.Clear();
                                AheadDetectUnallow.Append(_DeviceIdx.ToString() + "对应的AGV无法连接！");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                            }
                        }
                        else if (_DeviceKind == 4)
                        {
                            if (ccf.NeedOptimize(deviceIdx) == true)
                            {
                                ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
                                sendok = true;
                            }
                            else
                            {
                                int location = gc[2];//gjn
                                if (deviceOrder == 2 || deviceOrder == 7)
                                {
                                    location = gc[2];
                                }
                                else if (deviceOrder == 3)
                                {
                                    location = gc[5];
                                }
                                sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, location, out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                                //20231017
                                if (sendok == true)
                                {
                                    AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                                }
                            }
                        }
                        else if (_DeviceKind == 7)
                        {
                            object[] ob;
                            #region 条码设备直接比对
                            DataView dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex,T_Base_PLC_Ask.* FROM T_Base_PLC_Ask ,T_Monitor_Task WHERE T_Base_PLC_Ask.F_DeviceIndex = T_Monitor_Task.F_DeviceIndex AND T_Monitor_Task.F_TxtParam like '%'||T_Base_PLC_Ask.F_BarCode||'%' and (T_Monitor_Task.F_MonitorIndex = {0})", MonitorIndex)).Tables[0].DefaultView;
                            if ((dv.Count > 0))
                            {//先扫描到条码，比对正确，条码申请任务
                                Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
                                #region 向管理申请任务
                                try
                                {
                                    ob = new object[4]{dv[0]["F_MANAGEASKKIND"].ToString(),dv[0]["F_BINDINGDEVICE"].ToString(),
                                        dv[0]["F_BARCODE"].ToString(),DateTime.Now.ToString("u").Substring(0, 19)};
                                    dboM.ExecuteSql(string.Format("INSERT INTO IO_CONTROL_APPLY(CONTROL_APPLY_ID,CONTROL_APPLY_TYPE,DEVICE_CODE, STOCK_BARCODE, APPLY_TASK_STATUS, CREATE_TIME)VALUES (IO_CONTROL_APPLY_SEQ.nextval,{0},'{1}','{2}',0,'{3}')", ob));
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "向管理条码申请任务:", deviceIdx.ToString(),
                                        string.Format(",站台：{1}，条码：{2}，申请类型：{0}", ob));
                                }
                                catch (Exception ex)
                                {
                                    RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "发送条码比对向管理申请入库任务时发生错误：" + ex.StackTrace + ex.Message);
                                    OnRefreshMonitor(rmea);
                                }
                                #endregion
                            }
                            else
                            {
                                //1：上报时间小于3秒，而且条码不同
                                dv = dbo.ExceSQL(string.Format("select f_barcode,f_time from T_BASE_PLC_ASK where f_deviceindex={0} ", deviceIdx)).Tables[0].DefaultView;
                                if (dv.Count > 0)
                                {
                                    DateTime.TryParse(dv[0]["f_time"].ToString(), out DateTime dt);
                                    if (dt.AddSeconds(+3) > DateTime.Now && dv[0]["f_barcode"].ToString().Contains( ccf.GetBarCodeFromMonitor(MonitorIndex)))
                                    {//比对错误，条码申请异常任务
                                        Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 990);
                                        #region 向管理申请任务
                                        try
                                        {
                                            ob = new object[4]{dv[0]["F_MANAGEASKKIND"].ToString(),dv[0]["F_BINDINGDEVICE"].ToString(),
                                            dv[0]["F_BARCODE"].ToString(),DateTime.Now.ToString("u").Substring(0, 19)};
                                            dboM.ExecuteSql(string.Format("INSERT INTO IO_CONTROL_APPLY(CONTROL_APPLY_ID,CONTROL_APPLY_TYPE,DEVICE_CODE, STOCK_BARCODE, APPLY_TASK_STATUS, CREATE_TIME)VALUES (IO_CONTROL_APPLY_SEQ.nextval,{0},'{1}','{2}',0,'{3}')", ob));
                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "向管理条码申请任务:", deviceIdx.ToString(),
                                                string.Format(",站台：{1}，条码：{2}，申请类型：{0}", ob));
                                        }
                                        catch (Exception ex)
                                        {
                                            RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "发送条码比对向管理申请入库任务时发生错误：" + ex.StackTrace + ex.Message);
                                            OnRefreshMonitor(rmea);
                                        }
                                        #endregion
                                    }
                                }
                                //2：条码还未上报，改为已发送（一个设备当且仅当只有一个条码扫描任务已发送），等待订阅返回再补充完成
                                object ob1 = dbo.GetSingle(string.Format("select f_monitorindex from T_MONITOR_TASK where f_deviceindex={0} and f_status>0", deviceIdx));
                                if (ob1 == null)
                                {
                                    ccf.SendOrderSuccess(manageKindIdx, manageTaskIdx, MonitorIndex, deviceIdx, 0);
                                }
                            }
                            #endregion
                            sendok = true;
                        }
                        else if (_DeviceKind == 8)
                        {//20130510在订阅处理称重任务和重量
                            #region 称重
                            ////DataView dv = dbo.ExceSQL(string.Format("SELECT F_BoxBarcode FROM T_Base_PLC_Ask WHERE F_BoxBarcode!='0' and T_Base_PLC_Ask.F_DeviceIndex = {0}", deviceIdx)).Tables[0].DefaultView;
                            ////if (dv.Count > 0)
                            ////{
                            ////    //向管理写入重量
                            ////    dboM.ExecuteSql(string.Format("UPDATE IO_CONTROL SET CONTROL_REMARK ={0} WHERE  CONTROL_ID={1}", dv[0][0].ToString(), manageTaskIdx));
                            ////    Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
                            ////    dbo.ExecuteSql(string.Format("UPDATE T_Base_PLC_Ask SET F_BoxBarcode = '0' WHERE (F_DeviceIndex = {0})", deviceIdx));
                            ////}
                            #endregion
                            //return true;
                            sendok = true;
                        }
                        else if (_DeviceKind == 13)
                        {//richard.liu20230718鸿安环穿
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
                                    deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                                sdo = CommModeCreate.CreateSendDeviceOrder(gc[2]);
                                sdo.SendDeviceOrder(2, MonitorIndex, 0, gc[2], 0, out itemnames, out itemvalues);
                                AddOPCSendData(gc[2], MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        else
                        {
                            //if ((deviceIdx == 32072 || deviceIdx == 32086 || deviceIdx == 32103 || deviceIdx == 32120)&&(deviceOrder == 6))//&&Order==1
                            //{
                            //    if (devinfo.SplitByte_7 == 0)
                            //    {
                            //        AheadDetectUnallow.Clear();
                            //        AheadDetectUnallow.Append(deviceIdx.ToString() + "等待叠托机允许运行信号");
                            //        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                            //    }

                            //}
                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        if (sendok == false)
                        {
                            if (sdo.CommLayerError != null)
                            {
                                RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", sdo.CommLayerError);
                                OnRefreshMonitor(rmea);
                            }
                            return false;
                        }
                        else//发送命令成功
                        {
                            //20231017richard.liu
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Monitor_Task set F_SendFlag='1' where F_MonitorIndex=").Append(MonitorIndex);
                            ccf.SendOrderSuccess(manageKindIdx, manageTaskIdx, MonitorIndex, deviceIdx, _routeID);
                            #region 多叉关联任务，能同步的同时报告发送命令成功
                            ////20231017
                            devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
                            if (devinfo.IfCorrelDoubleFork == "1")
                            {
                                int[] corrtask = Model.CGeneralFunction.MutiForkIfSync(MonitorIndex, deviceIdx, deviceKind);
                                if (corrtask != null)
                                {
                                    int rfid = 0, rmankind = 0, rdev = 0;
                                    for (int i = 0; i < corrtask.GetLength(0); i++)
                                    {
                                        rfid = ccf.GetManageTaskIndexFromMonitor(corrtask[i]);
                                        rmankind = ccf.GetManageTaskKindIndexFromMonitor(corrtask[i]);
                                        rdev = ccf.GetDeviceindexFromMonitor(corrtask[i]);
                                        ccf.SendOrderSuccess(rmankind, rfid, corrtask[i], rdev, 0);
                                        sql.Remove(0, sql.Length);
                                        sql.Append("update T_Monitor_Task set F_SendFlag='2' where F_MonitorIndex=").Append(corrtask[i]);
                                        dbo.ExecuteSql(sql.ToString());//richard.liu20181212被同步运行设备指令做标记2，OEE时不统计时间
                                    }
                                }
                            }
                            #endregion

                            return true;
                        }
                    }
                    else
                    {
                        return false;
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            {//20110608
                CControlError = string.Format( "发送命令调用SendMonitorTask时：{0}" ,ex.StackTrace+ ex.Message);
                return false;
            }
        }

        private void AddOPCSendData(int deviceIndex, int sendTaskIndex,StringBuilder[] itemnames, StringBuilder[] itemvalues)
        {//20230811richard.liu
            
            try
            {
                devinfo = Model.CGetInfo.GetDeviceInfo(deviceIndex);
                
                if (OPCItemNamesDicInfo.ContainsKey(devinfo.S7Connection))
                {//添加OPC连接+dic 设备编码+数组 发送数据
                    if (OPCItemNamesDicInfo[devinfo.S7Connection].ContainsKey(devinfo.DeviceIndex) == false)
                    {
                        OPCItemNamesDicInfo[devinfo.S7Connection].Add(devinfo.DeviceIndex, itemnames);
                        OPCItemValuesDicInfo[devinfo.S7Connection].Add(devinfo.DeviceIndex, itemvalues);
                        OpcS7TagCount[devinfo.S7Connection] += itemnames.Length;
                        if (OPCS7connDeviceSendTaskIndexdic.ContainsKey(devinfo.S7Connection))
                        {
                            if (OPCS7connDeviceSendTaskIndexdic[devinfo.S7Connection].Contains(sendTaskIndex) == false)
                            {
                                OPCS7connDeviceSendTaskIndexdic[devinfo.S7Connection].Add(sendTaskIndex);
                            }
                        }
                        else
                        {
                            List<int> sti = new List<int>(); sti.Add(sendTaskIndex);

                            OPCS7connDeviceSendTaskIndexdic.Add(devinfo.S7Connection, sti);
                        }
                    }
                    
                }
                else
                {
                    Dictionary<int, StringBuilder[]> OPCDeviceSendtagNamedic = new Dictionary<int, StringBuilder[]>();
                    Dictionary<int, StringBuilder[]> OPCDeviceSendtagValuedic = new Dictionary<int, StringBuilder[]>();
                    OPCDeviceSendtagNamedic.Add(devinfo.DeviceIndex, itemnames);
                    OPCDeviceSendtagValuedic.Add(devinfo.DeviceIndex, itemvalues);
                    OpcS7TagCount.Add(devinfo.S7Connection, itemnames.Length);
                    OPCItemNamesDicInfo.Add(devinfo.S7Connection,  OPCDeviceSendtagNamedic);
                    OPCItemValuesDicInfo.Add(devinfo.S7Connection, OPCDeviceSendtagValuedic);
                    if (OPCS7connDeviceSendTaskIndexdic.ContainsKey(devinfo.S7Connection))
                    {
                        if (OPCS7connDeviceSendTaskIndexdic[devinfo.S7Connection].Contains(sendTaskIndex) == false)
                        {
                            OPCS7connDeviceSendTaskIndexdic[devinfo.S7Connection].Add(sendTaskIndex);
                        }
                    }
                    else
                    {
                        List<int> sti = new List<int>(); sti.Add(sendTaskIndex);

                        OPCS7connDeviceSendTaskIndexdic.Add(devinfo.S7Connection, sti);
                    }
                }
                
                



            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        int GetDeviceFromMonitor(int monitorIndex)
        {
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_MonitorIndex, F_DeviceIndex FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(monitorIndex).Append(")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0]["F_DeviceIndex"]);
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }

        /// <summary>
        /// 获取可用的目标位置：入库的巷道或者出库站台
        /// </summary>
        /// <param name="manageTaskIdx">调度任务索引</param>
        /// <param name="manageKindIdx">调度任务类别</param>
        /// <returns></returns>
        bool  GetUsableDestination(int manageTaskIdx,int manageKindIdx )
        {
            //20100610查找一个路径可用，任务数最少的终点设备
            Dictionary<int, int> advDev=new Dictionary<int,int>();
            object ob;
            DataView dv = new DataView();
            DataRowView dr = null ;
            DataView dvIO = new DataView();
            DataTable dtd = new DataTable();
            DataTable dt = new DataTable();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT * FROM T_Manage_Task WHERE (FID = ").Append(manageTaskIdx).Append(") AND (F_ManageTaskKindIndex = ").Append(manageKindIdx).Append(")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count <= 0)
                {
                    return false;
                }
                dr = dv[0];

                //20091107
                sql.Remove(0, sql.Length);
                sql.Append("select CONTROL_ID, CONTROL_STATUS from IO_Control where (CONTROL_ID = ").Append(Convert.ToInt32(dr["FID"])).Append(") AND ((CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKALTERROUTEAPPLY).Append(") or (CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKALTERROUTEREPLY).Append("))");
                dvIO = dboM.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dvIO.Count <= 0)
                {
                    //只修申请改调度任务的路径，不修改调度自动任务路径
                    if (dr["F_ManageTaskKindIndex"].ToString() != "1") return false;

                    string adviceDev = "";
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT F_TASKKIND, F_DESTINATION FROM T_Base_Destination WHERE (F_Warehouse='").Append(dr["FENDWAREHOUSE"]).Append("') and (F_TASKKIND = ").Append(dr["FCONTROLTASKTYPE"]).Append(") and (F_AbendStation=1) and (F_DESTINATION=").Append(dr["FENDDEVICE"]).Append(")");
                    dtd = dbo.ExceSQL(sql.ToString()).Tables[0];
                    if (dtd.Rows.Count > 0)//原来终点是应急站台那么还分配这个站台，不需要改变
                    {
                        adviceDev = dtd.Rows[0]["F_DESTINATION"].ToString();
                        return false;
                    }
                    else
                    {
                        //查找可用目标位置
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT F_TASKKIND, F_DESTINATION FROM T_Base_Destination WHERE (F_Warehouse='").Append(dr["FENDWAREHOUSE"]).Append("') and (F_TASKKIND = ").Append(dr["FCONTROLTASKTYPE"]).Append(") and (F_DESTINATION !=").Append(dr["FENDDEVICE"]).Append(") and (F_AbendStation=0)");
                        dt = dbo.ExceSQL(sql.ToString()).Tables[0];
                        if (dt.Rows.Count > 0)
                        {
                            for (int i = 0; i < dt.Rows.Count; i++)
                            {
                                if (CDisassembleTask.MinRouteID(Convert.ToInt32(dr["FSTARTDEVICE"]), Convert.ToInt32(dt.Rows[i]["F_DESTINATION"]), dr["FUseAwayFork"]) != -1)
                                {

                                    //20100610统计到终点设备正在执行的任务数
                                    sql.Remove(0, sql.Length);
                                    sql.Append("SELECT count(FENDDEVICE) as counts FROM T_Manage_Task where FENDDEVICE='").Append(dt.Rows[i]["F_DESTINATION"]).Append("' and fstatus>0");
                                    ob = dbo.GetSingle(sql.ToString());
                                    advDev.Add(Convert.ToInt32(dt.Rows[i]["F_DESTINATION"]), Convert.ToInt32(ob));

                                    //20100610 break;
                                }
                            }
                            if (advDev.Count == 0)//20100610
                            {

                                return false;


                            }
                            else
                            {//20100610
                                int mincount = 9999;
                                foreach (int aaa in advDev.Keys)
                                {
                                    if (advDev[aaa] < mincount)
                                    {
                                        mincount = advDev[aaa];
                                        adviceDev = aaa.ToString();
                                    }
                                }
                                if (adviceDev == "")
                                {

                                    return false;

                                }
                            }
                        }
                        else
                        {//20100610
                            return false;
                        }
                    }

                    string dtime = DateTime.Now.ToString("u");
                    dtime = dtime.Substring(0, dtime.Length - 1);
                    //20091128
                    dboM.TransBegin();
                    try
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKALTERROUTEAPPLY).Append(" where CONTROL_ID=").Append(dr["FID"]).Append("");
                        dboM.ExceSQL(sql.ToString());
                        //向管理申请修改任务//
                        int appid = dboM.GetManageTableIndex("IO_CONTROL_APPLY", true);//CONTROL_APPLY_ID
                  
                        sql.Remove(0, sql.Length);
                        sql.Append("INSERT INTO IO_CONTROL_APPLY ( CONTROL_APPLY_ID,CONTROL_ID,CONTROL_APPLY_TYPE,WAREHOUSE_CODE, STOCK_BARCODE, DEVICE_CODE, APPLY_TASK_STATUS, CREATE_TIME, ").Append(
                                " CONTROL_APPLY_REMARK)").Append(
                        "VALUES (").Append(appid).Append(",").Append(dr["FID"]).Append(",2,'").Append(dr["FENDWAREHOUSE"]).Append("','").Append(dr["FPALLETBARCODE"]).Append("','").Append(adviceDev).Append("',0,'").Append(dtime).Append("',null)");


                        dboM.ExceSQL(sql.ToString());
                        dboM.TransCommit();
                        //把ManageTaskIdx，ManageKindIdx 的调度任务全部申请改道
                        sql.Remove(0, sql.Length);
                        sql.Append("UPDATE T_Monitor_Task SET  F_Status = 3 WHERE (F_ManageTaskIndex = ").Append(manageTaskIdx).Append(") AND (F_ManageTASKKINDINDEX =").Append(manageKindIdx).Append(")");
                        dbo.ExceSQL(sql.ToString());
                        CommonClassLib.CCarryConvert.WriteDarkCasket("CControl.GetUsableDestination", "堆垛机入库目标位置发生改道", "管理任务：" +
                            manageKindIdx.ToString() + "-" + manageTaskIdx.ToString(), "条码：" + dr["FPALLETBARCODE"].ToString().ToUpper());
                        return true;
                    }
                    catch (Exception ex)
                    {
                        CControlError = string.Format("发送指令，申请改道时：{0}", ex.StackTrace+ex.Message);
                        dboM.TransRollback();
                        return false;
                    }


                }
                else
                {
                    return false;

                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dt.Dispose();
                dtd.Dispose();
                dv.Dispose();
                dvIO.Dispose();
                dr=null ;
            }
        }
        
        bool GetRGVIdleDestination(int manageTaskIdx, int manageKindIdx,int RGVGateDevice, bool IfUseNegativeDevice)
        {

            //20100610 t_Base_device 表F_UsableEndDevice字段存放入库或者出库对等的设备索引组（以分号隔开）：
            //负数代表位于当前设备前面（环形RGV行走方向的反方向），只允许在发送RGV取货和第一、二个运动时使用；
            //正数代表当前设备后面的设备，可以在发送送货和之前的所有命令使用.直道RGV都是正数。
            //T_Base_RGV_Gate新增字段“F_EndDevice”用于记载入库时靠近巷道一侧的RGV出入口输送机的对应的巷道设备索引
            //或者出库时靠近出库站台一侧的输送机对应的出库站台索引

            //可变更目标位置的选择原则：RGV目标位置空闲、无物；目标位置参与的正在执行的调度任务数最少

            DataView dv = new DataView();
            DataRowView dr = null ;
            
            string adviceDev = "";
            char[] cc = new char[1] { ';' };
            string[] sp;
            DataView dvIO = new DataView();
            Dictionary<int, int> advDev=new Dictionary<int,int>();
            object ob;
            DataView dvu = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT * FROM T_Manage_Task WHERE (FID = " ).Append( manageTaskIdx ).Append( ") AND (F_ManageTaskKindIndex = " ).Append( manageKindIdx ).Append( ")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count <= 0)
                {
                    return false;
                }
                dr = dv[0];
                //只修申请改调度任务的路径，不修改调度自动任务路径
                if (dr["F_ManageTaskKindIndex"].ToString() != "1") return false;
                sql.Remove(0, sql.Length);
                sql.Append("select CONTROL_ID, CONTROL_STATUS from IO_Control where (CONTROL_ID = " ).Append( Convert.ToInt32(dr["FID"]) ).Append( ") AND ((CONTROL_STATUS=" ).Append( Model.CGeneralFunction.TASKALTERROUTEAPPLY ).Append( ") or (CONTROL_STATUS=" ).Append( Model.CGeneralFunction.TASKCANCEL ).Append( ") or(CONTROL_STATUS=" ).Append( Model.CGeneralFunction.TASKALTERROUTEREPLY ).Append( "))");
                dvIO = dboM.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dvIO.Count <= 0)
                {

                    #region 根据T_Base_Device表的F_UsableEndDevice查找可用终点设备
                    sql.Remove(0, sql.Length);
                    sql.Append("select F_UsableEndDevice from T_Base_Device where F_UsableEndDevice is not null and F_DeviceIndex=" ).Append( RGVGateDevice ).Append( "");
                    dvu = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dvu.Count > 0)
                    {
                        int enddv = 0, DESTINATION = 0;
                        sp = dvu[0]["F_UsableEndDevice"].ToString().Split(cc);

                        for (int i = sp.GetLowerBound(0); i <= sp.GetUpperBound(0); i++)
                        {
                            if (int.TryParse(sp[i], out enddv) == false) continue;
                            enddv = Convert.ToInt32(sp[i]);
                            if (enddv < 0)
                            {
                                //负数代表当前设备前面的设备（环形RGV行走方向的反方向）
                                if (IfUseNegativeDevice == true)
                                {
                                    enddv = -(enddv);
                                }
                                else
                                {
                                    continue;
                                }
                            }
                            devinfo = Model.CGetInfo.GetDeviceInfo(enddv);
                            if ((devinfo.HaveGoods == true)||(devinfo.RunState==2))
                            {//目标位置被占用或者故障
                                continue;
                            }
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_EndDevice FROM T_Base_RGV_Gate WHERE (F_RGVGateDeviceIndex = " ).Append( enddv ).Append( ") AND (F_EndDevice IS NOT NULL)");
                            ob = dbo.GetSingle(sql.ToString());
                            if (ob == null) continue;
                            DESTINATION = Convert.ToInt32(ob);
                            if (CDisassembleTask.MinRouteID(Convert.ToInt32(dr["FSTARTDEVICE"]), DESTINATION, dr["FUseAwayFork"]) != -1)
                            {
                                //20100609统计到终点设备正在执行的任务数
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT count(FENDDEVICE) as counts FROM T_Manage_Task where FENDDEVICE='" ).Append( DESTINATION ).Append( "' and fstatus>0");
                                ob = dbo.GetSingle(sql.ToString());
                                advDev.Add(DESTINATION, Convert.ToInt32(ob));

                            }

                        }
                    }
                    else
                    {
                        return false;
                    }
                    
                    if (advDev.Count<=0)
                    {
                        return false;
                    }
                    else
                    {
                        int mincount = 9999;
                        foreach (int aaa in advDev.Keys)
                        {
                            if (advDev[aaa] < mincount)
                            {
                                mincount = advDev[aaa];
                                adviceDev = aaa.ToString();
                            }
                        }
                        if (adviceDev == "")
                        {

                            return false;

                        }
                    }
                    #endregion

                    //20101108int fid = dboM.GetManageTableIndex("IO_CONTROL_APPLY");
                    string dtime = DateTime.Now.ToString("u");
                    dtime = dtime.Substring(0, dtime.Length - 1);

                    dboM.TransBegin();
                    try
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append(" update IO_CONTROL set CONTROL_STATUS=" ).Append( Model.CGeneralFunction.TASKALTERROUTEAPPLY ).Append( " where CONTROL_ID=" ).Append( dr["FID"] ).Append( " and CONTROL_STATUS!=" ).Append( Model.CGeneralFunction.TASKCANCEL ).Append( "");
                        dboM.ExceSQL(sql.ToString());
                        //向管理申请修改任务
                        int appid = dboM.GetManageTableIndex("IO_CONTROL_APPLY", true);//CONTROL_APPLY_ID
                  
                        sql.Remove(0, sql.Length);
                        sql.Append("INSERT INTO IO_CONTROL_APPLY (CONTROL_APPLY_ID, CONTROL_ID, WAREHOUSE_CODE, STOCK_BARCODE, DEVICE_CODE, APPLY_TASK_STATUS, CREATE_TIME,CONTROL_APPLY_REMARK)").Append(
                        "VALUES (" ).Append(appid).Append(",").Append( dr["FID"] ).Append( ",'" ).Append( dr["FENDWAREHOUSE"] ).Append( "','" ).Append( dr["FPALLETBARCODE"] ).Append( "','" ).Append( adviceDev ).Append( "',0,'" ).Append( dtime ).Append( "',null)");
                        
                        dboM.ExceSQL(sql.ToString());
                        dboM.TransCommit();
                        //把ManageTaskIdx，ManageKindIdx 的调度任务全部申请改道
                        sql.Remove(0, sql.Length);
                        sql.Append("UPDATE T_Monitor_Task SET  F_Status = 3 WHERE (F_ManageTaskIndex = " ).Append( manageTaskIdx ).Append( ") AND (F_ManageTASKKINDINDEX =" ).Append( manageKindIdx ).Append( ")");
                        dbo.ExceSQL(sql.ToString());
                        CommonClassLib.CCarryConvert.WriteDarkCasket("CControl.GetRGVIdleDestination", "穿梭车目标位置发生改道", "管理任务："+
                        manageKindIdx.ToString() + "-" + manageTaskIdx.ToString(), "条码：" + dr["FPALLETBARCODE"].ToString().ToUpper());
                        return true;
                    }
                    catch (Exception ex)
                    {
                        dboM.TransRollback();
                        CControlError = string.Format( "发送指令，申请改道时：{0}", ex.StackTrace+ex.Message);
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                CControlError = string.Format("发送指令，申请改道时：{0}" , ex.StackTrace+ex.Message);
                return false;
            }
            finally
            {
                dv.Dispose();
                dr = null;
                cc = null;
                sp = null;
                dvIO.Dispose();
                dvu.Dispose();
            }
        }
        /// <summary>
        /// 返回在顶升处入库任务可以多叉关联的调度任务索引
        /// </summary>
        /// <param name="controlTaskType">控制任务类型</param>
        /// <param name="devindex">设备索引</param>
        /// <returns></returns>
        int GetEnableDoubleForkManageTask(int controlTaskType, int devindex,int FID)
        {
            DataView dv0 = new DataView(); DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_MonitorIndex,T_Monitor_Task.F_ManageTaskIndex,T_Monitor_Task.F_ManageTASKKINDINDEX FROM T_Monitor_Task ,T_Manage_Task where T_Monitor_Task.F_ManageTaskIndex = T_Manage_Task.FID AND T_Monitor_Task.F_ManageTASKKINDINDEX = T_Manage_Task.F_ManageTaskKindIndex AND F_DeviceIndex=").Append(devindex).Append(" and FCONTROLTASKTYPE=").Append(controlTaskType);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    for (int i = 0; i < dv.Count; i++)
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("select min(F_MonitorIndex) as mm from T_Monitor_Task where F_ManageTaskIndex=").Append(dv[i]["F_ManageTaskIndex"]).Append(" and F_ManageTASKKINDINDEX=").Append(dv[i]["F_ManageTASKKINDINDEX"]);
                        dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv0.Count > 0)
                        {
                            if (dv0[0]["mm"].ToString() == dv[i]["F_MonitorIndex"].ToString())
                            {
                                if (FID != Convert.ToInt32(dv[i]["F_ManageTaskIndex"]))
                                {
                                    return Convert.ToInt32(dv[i]["F_ManageTaskIndex"]);
                                }
                            }
                        }
                    }
                    return -1;
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv0.Dispose();
            }
        }
        /// <summary>
        /// 获得堆垛机在对等站台取货的多叉关联任务
        /// </summary>
        /// <param name="controlTaskType">控制任务类型</param>
        /// <param name="Stackdevindex">堆垛机设备索引</param>
        /// <param name="StationDevice">站台设备索引</param>
        /// <param name="FID">调度任务索引</param>
        /// <returns></returns>
        int GetEnableDoubleForkManageTask(int controlTaskType, int Stackdevindex,int StationDevice, int FID)
        {
            DataView dv1 = new DataView();
            DataView dv0 = new DataView();
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_ZXY FROM T_Base_Lane_Gate,T_Base_LaneInfo WHERE ").Append(
                    "(T_Base_Lane_Gate.F_LaneIndex = T_Base_LaneInfo.F_LaneDeviceIndex) and (T_Base_LaneInfo.F_StackIndex = ").Append(
                    Stackdevindex).Append(") and (F_LaneGateDeviceIndex=").Append(StationDevice).Append(")");
                dv1 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv1.Count <= 0) return -1;
                char[] cc = new char[1] { '-' };
                string[] zxy = dv1[0]["F_ZXY"].ToString().Split(cc);

                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_MonitorIndex,T_Monitor_Task.F_ManageTaskIndex,T_Monitor_Task.F_ManageTASKKINDINDEX ").Append(
                    " FROM T_Monitor_Task ,T_Manage_Task where T_Monitor_Task.F_ManageTaskIndex = T_Manage_Task.FID AND ").Append(
                    "T_Monitor_Task.F_ManageTASKKINDINDEX = T_Manage_Task.F_ManageTaskKindIndex AND F_DeviceIndex=").Append(
                    Stackdevindex).Append(" and FCONTROLTASKTYPE=").Append(controlTaskType).Append(" and F_NumParam1=").Append(zxy[0]).Append(
                    " and F_NumParam2=").Append(zxy[1]).Append(" and F_NumParam3=").Append(zxy[2]).Append(" and F_RELATIVECONTORLID!=").Append(FID);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    for (int i = 0; i < dv.Count; i++)
                    {
                        sql.Remove(0, sql.Length);
                        sql.Append("select min(F_MonitorIndex) as mm from T_Monitor_Task where F_ManageTaskIndex=").Append(dv[i]["F_ManageTaskIndex"]).Append(" and F_ManageTASKKINDINDEX=").Append(dv[i]["F_ManageTASKKINDINDEX"]).Append(" ");
                        dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv0.Count > 0)
                        {
                            if (dv0[0]["mm"].ToString() == dv[i]["F_MonitorIndex"].ToString())
                            {
                                if (FID != Convert.ToInt32(dv[i]["F_ManageTaskIndex"]))
                                {
                                    return Convert.ToInt32(dv[i]["F_ManageTaskIndex"]);
                                }
                            }
                        }
                    }
                    return -1;
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv0.Dispose();
                dv1.Dispose();
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="Mankind">调度任务类型索引</param>
        /// <param name="FID">调度任务索引</param>
        /// <param name="ControlTaskType">调度任务类型</param>
        /// <param name="UseAwayFork">最后分配的远、近货叉</param>
        void AlterRoutePath(int Mankind,int FID,int ControlTaskType,char UseAwayFork,int NowDevice)
        {
            DataView dv = new DataView(); DataView dv1 = new DataView(); DataView dvnew = new DataView();
            
            //先找到以前的路径是否与最后分配的货叉匹配，不匹配的改道
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT  T_Monitor_Task.F_MonitorIndex,T_Monitor_Task.F_DeviceIndex FROM T_Monitor_Task,T_Base_Route_Device where ").Append(
                    " T_Monitor_Task.F_RouteID = T_Base_Route_Device.F_RouteIDSub AND T_Monitor_Task.F_DeviceIndex = T_Base_Route_Device.F_DeviceIndex and T_Monitor_Task.F_ManageTaskIndex=").Append(
                    FID).Append(" and T_Monitor_Task.F_ManageTASKKINDINDEX=").Append(Mankind).Append(" and T_Base_Route_Device.F_UseAwayFork!='").Append(UseAwayFork).Append("'");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("select * from T_Manage_Task where F_ManageTaskKindIndex=" ).Append( Mankind ).Append( " and FID=" ).Append( FID);
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        //20100702
                        sql.Remove(0, sql.Length);
                        sql.Append("SELECT T_Base_Route_Device.F_RouteIDSub FROM T_Base_Route,T_Base_Route_Device where T_Base_Route.F_RouteID = T_Base_Route_Device.F_RouteID " ).Append(
                            " and (T_Base_Route_Device.F_UseAwayFork = '" ).Append( UseAwayFork ).Append( "') AND (T_Base_Route_Device.F_DeviceIndex = " ).Append( NowDevice ).Append( ") AND (T_Base_Route.F_StartDevice = " ).Append(
                            dv[0]["FSTARTDEVICE"] ).Append( ") AND (T_Base_Route.F_EndDevice = " ).Append( dv[0]["FENDDEVICE"] ).Append( " and F_RouteKind=").Append(ControlTaskType).Append(")");
                        ;
                        dv1 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv1.Count > 0)
                        {
                            int routeidNew=Convert.ToInt32( dv1[0][0]);
                            //删除原来的申请修改路径任务，拆分新的任务并且只保留现有设备开始的任务
                            sql.Remove(0, sql.Length);
                            sql.Append("DELETE FROM T_Monitor_Task WHERE (F_ManageTaskIndex = " ).Append( FID ).Append( ") AND (F_ManageTASKKINDINDEX =").Append(Mankind).Append(")");
                            dbo.ExceSQL(sql.ToString());
                            if (CDisassembleTask.CreateMonitor(Mankind, FID, routeidNew, dv[0], 3) > 0)
                            {
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = " ).Append(
                                                FID ).Append( ") AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = " ).Append(
                                                NowDevice ).Append( ") AND (F_RouteID = " ).Append( routeidNew ).Append(
                                                ") AND (F_Status = 3) ");
                                dvnew = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                if (dvnew.Count > 0)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("delete from T_Monitor_Task where F_MonitorIndex<" ).Append( dvnew[0]["F_MonitorIndex"] ).Append( " and (F_ManageTaskIndex = " ).Append(
                                    FID ).Append( ") AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_Status = 3)");
                                    dbo.ExceSQL(sql.ToString());
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update  T_Monitor_Task set F_Status =0 where  (F_ManageTaskIndex = " ).Append(
                                    FID ).Append( ") AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_Status = 3)");
                                    dbo.ExceSQL(sql.ToString());


                                }
                            }
                        }
                        
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv1.Dispose();
                dvnew.Dispose();
            }
        }
        int GetDoubleForkMinRouteTask(int taskno)
        {
            DataView dv = new DataView();
            try
            {

                //不是双叉的直接返回taskno；是双叉但是可以同步的直接返回taskno
                //双叉不能同步的反馈距离当前堆垛机位置最短的taskno

                int manKind = Model.CGeneralFunction.GetManageTaskKindIndexFromMonitor(taskno);
                int manFid = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(taskno);
                int deviceindex = Model.CGeneralFunction.GetDeviceIndexFromMonitor(taskno);
                int devKind = Model.CGeneralFunction.GetDeviceKindIdx(deviceindex);
                int devOrder = Model.CGeneralFunction.GetDeviceOrderFromMonitor(taskno);

                devinfo = Model.CGetInfo.GetDeviceInfo(deviceindex);

                int nX = Model.CGeneralFunction.GetXCoorFromMonitor(taskno, deviceindex, devOrder);
                int nY = Model.CGeneralFunction.GetYCoorFromMonitor(taskno, deviceindex, devOrder);
                double nXY = 0, doubleXY = 0, doubleX = 0, doubleY=0;
                nXY = Math.Pow((double)(nX - devinfo.XCoor), 2) + (Math.Pow((double)(nY - devinfo.YCoor), 2));

                if (devinfo.IfCorrelDoubleFork == "1")
                {
                    Dictionary<int, string[]> df = Model.CGeneralFunction.GetDoubleForkMonitorInfo(taskno, deviceindex);
                    if (df == null) return taskno;
                    if (Model.CGeneralFunction.MutiForkIfSync(taskno, deviceindex, devKind) == null )
                    {
                        #region 遍历每个关联任务
                        
                        foreach (int cortask in df.Keys)
                        {
                            //20120906
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(cortask ).Append(") AND (F_status = 0)");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count <= 0)
                            {
                                continue;
                            }
                            
                            #region 关联指令不是第一个指令不能发送
                            int rmankind = Model.CGeneralFunction.GetManageTaskKindIndexFromMonitor(cortask);
                            int rman = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(cortask);
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT MIN(F_MonitorIndex) AS mmi FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(rman).Append(") AND (F_ManageTASKKINDINDEX = ").Append(rmankind).Append(")");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() != cortask.ToString()))
                                {
                                   return -1 ;
                                }
                            }
                            #endregion
                            if (devKind == 1)//堆垛机
                            {//如果存在倒库货位，则后执行该任务20120906嘉兴电力改进，倒库货位的取货命令检测堆垛机货叉对应开关是否有货
                                //if (devOrder == 5)//送货指令时判断20110505
                                //{
                                    
                                //    if (true == IfChangeForkCell_LastRun(cortask))
                                //    {
                                //        continue;
                                //    }

                                //}
                                doubleX = Model.CGeneralFunction.GetXCoorFromMonitor(cortask, deviceindex, devOrder);
                                doubleY = Model.CGeneralFunction.GetYCoorFromMonitor(cortask, deviceindex, devOrder);
                                doubleXY = Math.Pow((double)(doubleX - devinfo.XCoor), 2) + (Math.Pow((double)(doubleY - devinfo.YCoor), 2));
                                if (nXY >doubleXY)
                                {
                                    nXY=doubleXY;
                                    taskno = cortask;
                                }
                                
                            }
                            else if (devKind == 6)//AGV
                            {
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT F_Sequence FROM T_Base_AGV_Gate WHERE (F_AGVGateDeviceIndex = ").Append(nX).Append(")");
                                nXY = Convert.ToInt32(dbo.GetSingle(sql.ToString()));
                                sql.Remove(0, sql.Length);
                                sql.Append("SELECT F_Sequence FROM T_Base_AGV_Gate WHERE (F_AGVGateDeviceIndex = ").Append(doubleX).Append(")");
                                doubleXY = Convert.ToInt32(dbo.GetSingle(sql.ToString()));
                                if (nXY < doubleXY)
                                {
                                    return taskno;
                                }
                                else
                                {
                                    return Convert.ToInt32(df[0]);
                                }
                            }
                            else
                            {
                                return taskno;
                            }
                        }

                        #endregion
                        //返回最小值的任务号
                        return taskno;

                    }
                    else
                    {
                        #region 遍历每个关联任务

                        foreach (int cortask in df.Keys)
                        {
                            
                            #region 关联指令不是第一个指令不能发送
                            int rmankind = Model.CGeneralFunction.GetManageTaskKindIndexFromMonitor(cortask);
                            int rman = Model.CGeneralFunction.GetManageTaskIndexfromMonitor(cortask);
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT MIN(F_MonitorIndex) AS mmi FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(rman).Append(") AND (F_ManageTASKKINDINDEX = ").Append(rmankind).Append(")");
                            dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dv.Count > 0)
                            {
                                if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() != cortask.ToString()))
                                {
                                    return -1;
                                }
                            }
                            #endregion
                            
                        }

                        #endregion

                        return taskno;
                    }

                }
                else
                {
                    return taskno;
                }
            }
            catch (Exception ex)
            {
                CControlError = string.Format("发送命令调用GetDoubleForkMinRouteTask时：{0},{1}", sql.ToString(), ex.StackTrace+ex.Message );
                return taskno;
            }
            finally
            {
                dv.Dispose();
            }
            
        }

        
        bool IFAGVGate(int devIndex)
        {
            sql.Remove(0, sql.Length);
            sql.Append("SELECT F_AGVGateDeviceIndex FROM T_Base_AGV_Gate WHERE (F_AGVGateDeviceIndex = ").Append(devIndex ).Append(")");
            if (dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView.Count > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        
        /// <summary>
        /// 同轨两个堆垛机组合作业，通过中转货位交替作业
        /// </summary>
        /// <param name="taskindex"></param>
        /// <param name="ChangeStackCell"></param>
        /// <param name="StackIndex"></param>
        void ChangeStackCellCode(int taskindex, string ChangeStackCell, int StackIndex)
        {//20120820
            int[] zxy = ccf.GetCoordinatesFromMonitorTask(taskindex);
            StringBuilder zxystr = new StringBuilder();
            DataView dvl = new DataView(); DataView dv =new DataView();
            if (zxy != null)
            {
                zxystr.Append((zxy[3].ToString().Length == 1 ? "0" + zxy[3].ToString() : zxy[3].ToString())).Append("-").Append(
                    ((zxy[4].ToString().Length == 1) ? ("0" + zxy[4].ToString()) : (zxy[4].ToString()))).Append("-").Append(
                    ((zxy[5].ToString().Length == 1) ? ("0" + zxy[5].ToString()) : (zxy[5].ToString())));
            }
            int laneway = 0;
            dvl = dbo.ExceSQL(string.Format("SELECT F_LaneDeviceIndex FROM  T_Base_LaneInfo WHERE (F_StackIndex = {0})", StackIndex)).Tables[0].DefaultView;
            if (dvl.Count > 0)
            {
                laneway = Convert.ToInt32(dvl[0]["F_LaneDeviceIndex"]);
            }
            else
                return;

            char[] cc = new char[1] { '-' };
            string[] endCell = ChangeStackCell.Split(cc);
            int fid = ccf.GetManageTaskIndexFromMonitor(taskindex);
            int Mankind = ccf.GetManageTaskKindIndexFromMonitor(taskindex);
            //dbo.TransBegin();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_LaneGateDeviceIndex FROM T_Base_Lane_Gate,T_Base_Device WHERE (T_Base_Lane_Gate.F_LaneGateDeviceIndex = T_Base_Device.F_DeviceIndex) and (F_ZXY = '").Append(ChangeStackCell).Append("') and F_LaneIndex=").Append(laneway);
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    sql.Remove(0, sql.Length);//20120420
                    sql.Append("update T_Monitor_Task set F_AheadDetect=F_AheadDetect+'").Append(";N").Append(dv[0]["F_LaneGateDeviceIndex"].ToString()).Append(";R").Append(dv[0]["F_LaneGateDeviceIndex"].ToString())
                        .Append("', F_NumParam4=").Append(endCell[0]).Append(",F_NumParam5=").Append(endCell[1]).Append(",F_ChangeStackCell='").Append(laneway.ToString()+","+ChangeStackCell
                        ).Append("',F_NumParam6=").Append(endCell[2]).Append(" where F_ManageTaskIndex=").Append(fid).Append(" and F_ManageTASKKINDINDEX=").Append(Mankind).Append(" and F_DeviceIndex=").Append(StackIndex);
                    dbo.ExecuteSql(sql.ToString());
                    sql.Remove(0, sql.Length);
                    sql.Append("update T_Manage_Task set FREMARK='").Append(zxystr.ToString()).Append("',FExceptionNO=").Append(Model.CGeneralFunction.TASKCHANGESTACK).Append(" where FID=").Append(fid).Append(" and F_ManageTaskKindIndex=").Append(Mankind);
                    dbo.ExecuteSql(sql.ToString());
                }
                //dbo.TransCommit();
            }
            catch (Exception ex)
            {
                throw ex;
                //dbo.TransRollback();
            }
            finally
            {
                dv.Dispose();
                dvl.Dispose();
            }
        }
        int GetIOControlStatus(int TaskIndex)
        {
            int mankind = ccf.GetManageTaskKindIndexFromMonitor(TaskIndex);
            int Fid = ccf.GetManageTaskIndexFromMonitor(TaskIndex);
            if (mankind == 1)
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT CONTROL_STATUS FROM IO_CONTROL WHERE (CONTROL_ID = ").Append(Fid).Append(")");
                object ob=dboM.GetSingle(sql.ToString());
                if (ob != null)
                {
                    return Convert.ToInt32(ob);
                }
                else
                {
                    return 1;
                }
            }
            else
            {
                return 1;
            }
        }
        /// <summary>
        /// 返回AGV双叉的关联站台,“-1”代表没有关联
        /// </summary>
        /// <param name="taskindex">设备指令索引</param>
        /// <returns></returns>
        int GetAGVCorrelIndex(int taskindex)
        {
            sql.Remove(0, sql.Length);
            sql.Append("SELECT F_NumParam2 FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(taskindex).Append(")");
            object ob = dbo.GetSingle(sql.ToString());
            if (ob != null)
            {
                int cs = Convert.ToInt32(ob);
                if (cs % 2 == 0)
                {
                    return (cs-1);
                }
                else
                {
                    return (cs + 1);
                }
            }
            else
            {
                return -1;
            }
        }
        int GetAGVCorrelConveyorIndex(int taskindex)
        {
            sql.Remove(0, sql.Length);
            sql.Append("SELECT F_NumParam2 FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(taskindex).Append(")");
            object ob = dbo.GetSingle(sql.ToString());
            if (ob != null)
            {
                int cs = Convert.ToInt32(ob);
                if (cs % 2 == 0)
                {
                    return (cs + 1);
                }
                else
                {
                    return (cs - 1);
                }
            }
            else
            {
                return -1;
            }
        }
        /// <summary>
        /// 返回AGV在此站台取货的调度任务索引
        /// </summary>
        /// <param name="controltype">控制任务类型</param>
        /// <param name="stationIndex">AGV站台索引</param>
        /// <returns></returns>
        int GetAGVEnableDoubleForkManageTask(int controltype, int stationIndex,int agv)
        {//20110412
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_MonitorIndex,T_Monitor_Task.F_ManageTaskIndex,T_Monitor_Task.F_ManageTASKKINDINDEX  ").Append(
                    " FROM T_Monitor_Task ,T_Manage_Task where T_Monitor_Task.F_ManageTaskIndex = T_Manage_Task.FID AND ").Append(
                    "T_Monitor_Task.F_ManageTASKKINDINDEX = T_Manage_Task.F_ManageTaskKindIndex and FCONTROLTASKTYPE=").Append(
                    controltype).Append(" and F_NumParam2=").Append(stationIndex).Append(" and F_DeviceIndex=").Append(agv).Append(" and F_Status=0 and F_DeviceCommandIndex=2");

                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0]["F_ManageTaskIndex"]);
                }

                return -1;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        bool IfInSameLimitX(int fid, int mfid,int manKind)
        {
            DataView dv = new DataView(); DataView dv1 = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_ForwardLimitX,F_BackLimitX,FEndCol FROM T_Manage_Task,T_Base_LaneInfo WHERE T_Manage_Task.FLANEWAY = T_Base_LaneInfo.F_LaneDeviceIndex and (F_ManageTaskKindIndex = ").Append(manKind).Append(") AND (FID = ").Append(fid).Append(")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count == 0)
                {
                    return false;
                }
                sql.Remove(0, sql.Length);
                sql.Append("SELECT F_ForwardLimitX,F_BackLimitX,FEndCol FROM T_Manage_Task,T_Base_LaneInfo WHERE T_Manage_Task.FLANEWAY = T_Base_LaneInfo.F_LaneDeviceIndex and (F_ManageTaskKindIndex = ").Append(manKind).Append(") AND (FID = ").Append(mfid).Append(")");
                dv1 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv1.Count == 0)
                {
                    return false;
                }
                if ((dv[0]["FEndCol"].ToString() == dv[0]["F_ForwardLimitX"].ToString()) && (dv1[0]["F_ForwardLimitX"].ToString() == dv1[0]["FEndCol"].ToString()))
                {
                    return true;
                }
                if ((dv[0]["FEndCol"].ToString() == dv[0]["F_BackLimitX"].ToString()) && (dv1[0]["F_BackLimitX"].ToString() == dv1[0]["FEndCol"].ToString()))
                {
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv1.Dispose();
            }
        }
        int GetAGVFromConveyorDoubleForkGetGoodManageTask(int controltype, int stationIndex,int agv)
        {
            DataView dv0 = new DataView();
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT T_Monitor_Task.F_ManageTaskIndex,F_MonitorIndex,T_Manage_Task.F_ManageTaskKindIndex  ").Append(
                    " FROM T_Monitor_Task ,T_Manage_Task where T_Monitor_Task.F_ManageTaskIndex = T_Manage_Task.FID AND ").Append(
                    "T_Monitor_Task.F_ManageTASKKINDINDEX = T_Manage_Task.F_ManageTaskKindIndex and FCONTROLTASKTYPE=").Append(
                    controltype).Append(" and F_NumParam2=").Append(stationIndex).Append(" and F_DeviceIndex=").Append(agv).Append("  and F_Status=0  and F_DeviceCommandIndex=2 order by F_MonitorIndex asc");//20110412
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    for (int i = 0; i < dv.Count; i++)
                    {
                        sql.Remove(0, sql.Length);
                        if (CStaticClass.DBFactory == "OracleDBFactory")
                        {//20151120调度系统oracle的特殊语句
                            sql.Append("SELECT F_MonitorIndex  ").Append(" FROM T_Monitor_Task where T_Monitor_Task.F_ManageTaskIndex = ")
                                .Append(dv[i]["F_ManageTaskIndex"].ToString()).Append(
                                " and F_ManageTASKKINDINDEX = ").Append(dv[i]["F_ManageTaskKindIndex"].ToString()).Append(" order by F_MonitorIndex asc  FETCH FIRST ROWS ONLY");
                        }
                        else
                        {//20151120调度系统SQLServer的特殊语句
                            sql.Append("SELECT top 1 F_MonitorIndex  ").Append(" FROM T_Monitor_Task where T_Monitor_Task.F_ManageTaskIndex = ")
                                .Append(dv[i]["F_ManageTaskIndex"].ToString()).Append(
                                " and F_ManageTASKKINDINDEX = ").Append(dv[i]["F_ManageTaskKindIndex"].ToString()).Append(" order by F_MonitorIndex asc");
                        }
                        dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
                        if (dv0[0]["F_MonitorIndex"].ToString() == dv[i]["F_MonitorIndex"].ToString())
                        {
                            
                            return Convert.ToInt32(dv[i]["F_ManageTaskIndex"]);
                        }
                    }
                }

                return -1;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv0.Dispose();
            }
        }
        bool IFHaveSameEndDevice(int fid,int CorrelFid,int mti)
        {
            DataView dv0 = new DataView(); DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT FENDDEVICE, FENDCELL, FUseAwayFork FROM T_Manage_Task WHERE (F_ManageTaskKindIndex = ").Append(mti).Append(") AND (FID = ").Append(fid).Append(")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    sql.Remove(0, sql.Length);
                    sql.Append("SELECT FENDDEVICE, FENDCELL, FUseAwayFork FROM T_Manage_Task WHERE (F_ManageTaskKindIndex = ").Append(mti).Append(") AND (FID = ").Append(CorrelFid).Append(")");
                    dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv0.Count > 0)
                    {
                        if ((dv[0]["FENDDEVICE"].ToString() == dv0[0]["FENDDEVICE"].ToString()) && (dv[0]["FENDDEVICE"].ToString() == "28001") && (Math.Abs(Convert.ToInt32(dv[0]["FENDCELL"]) - Convert.ToInt32(dv0[0]["FENDCELL"])) == 1))//20110412
                        {
                            if ((Convert.ToInt32(dv[0]["FENDCELL"]) > Convert.ToInt32(dv0[0]["FENDCELL"])) && (Convert.ToInt32(dv[0]["FUseAwayFork"]) > Convert.ToInt32(dv0[0]["FUseAwayFork"])))
                            {
                                return true;
                            }
                            if ((Convert.ToInt32(dv[0]["FENDCELL"]) < Convert.ToInt32(dv0[0]["FENDCELL"])) && (Convert.ToInt32(dv[0]["FUseAwayFork"]) < Convert.ToInt32(dv0[0]["FUseAwayFork"])))
                            {
                                return true;
                            }
                            return false;
                        }
                        else
                        {
                            return false;
                        }
                    }
                    else
                    {
                        return false;
                    }
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                dv0.Dispose();
            }
        }
        void UpdateAheadDetectUnallow(StringBuilder  aheadUnallow, int taskindex)
        {
            #region 20110505增加的信息提示
            int rec = 0;
            if (aheadUnallow.Length > 0)
            {
                rec = dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET  F_ErrorCode ='{0}' WHERE F_MonitorIndex ={1} and (F_ErrorCode !='{0}' or F_ErrorCode is null)", aheadUnallow.ToString(), taskindex));
            }
            else
            {
                rec = dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET  F_ErrorCode ='' WHERE F_MonitorIndex ={1} and (F_ErrorCode is not null or F_ErrorCode is null)", aheadUnallow.ToString(), taskindex));
            }
            if (rec > 0)
            {
                CDataChangeEventArgs cea = new CDataChangeEventArgs(null, null);
                OnDataChange("发送提前检测时，异常",cea);
                
            }
            #endregion
        }
        /// <summary>
        /// 如果是倒叉货位，那它后执行
        /// </summary>
        /// <param name="TaskIndex"></param>
        /// <returns></returns>
        bool IfChangeForkCell_LastRun(int TaskIndex)
        {//20110505
            DataView dv = new DataView();
            try
            {
                
                int laneway = ccf.GetLaneWayFromLaneInfo(ccf.GetDeviceindexFromMonitor(TaskIndex));
                int[] zxy = ccf.GetCoordinatesFromMonitorTask(TaskIndex);
                string zxystr = (zxy[3].ToString().Length == 1 ? "0" + zxy[0].ToString() : zxy[3].ToString()) + "-" +
                        ((zxy[4].ToString().Length == 1) ? ("0" + zxy[4].ToString()) : (zxy[4].ToString())) + "-" +
                        ((zxy[5].ToString().Length == 1) ? ("0" + zxy[5].ToString()) : (zxy[5].ToString()));
                int lanedev = ccf.GetChangeCellStationFromLaneGate(laneway,zxystr);

                dv = dbo.ExceSQL(string.Format("SELECT F_ChangeForkCell FROM T_Base_LaneInfo WHERE F_LaneDeviceIndex={0} and (F_ChangeForkCell like '%{1}%' or F_ChangeForkCell like '%{2}%')", laneway, zxystr,lanedev)).Tables[0].DefaultView;
                if (dv.Count > 0)//倒库货位的任务后执行
                {
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();

            }

        }
        /// <summary>
        /// 分配实际工作的堆垛机设备索引20111020
        /// </summary>
        /// <param name="deviceIndex">虚拟堆垛机设备索引</param>
        /// <param name="taskIndex">设备指令索引</param>
        /// <param name="manKind">调度任务类型</param>
        /// <param name="fid">调度任务索引</param>
        bool AssignStackNo(int deviceIndex, int taskIndex,int manKind,int fid)
        {//20120820
            DataView dv = new DataView();
            Model.MDevice devinfo; int resDev = 0;
            try
            {
                int Xcoor = Model.CGeneralFunction.GetXCoorFromMonitor(taskIndex, deviceIndex, ccf.GetDeviceOrderFromMonitor(taskIndex));
                int Zcoor = Model.CGeneralFunction.GetZCoorFromMonitor(taskIndex, deviceIndex, ccf.GetDeviceOrderFromMonitor(taskIndex));
                int XcoorS = Model.CGeneralFunction.GetXCoorFromMonitor(taskIndex, deviceIndex, 5);
                int ZcoorS = Model.CGeneralFunction.GetZCoorFromMonitor(taskIndex, deviceIndex, 5);
                int sno = 0; bool IfCombinedWork = false;
                GetSpecialStackNo(deviceIndex, Zcoor, Xcoor, ZcoorS, XcoorS, out sno, out IfCombinedWork);
                //先考虑特殊情况20111226
                if (IfCombinedWork == true)
                {
                    //两个堆垛机组合交替作业
                    string ChangeStackCell = GetChangeStackCell(deviceIndex);
                    if (ChangeStackCell != "")
                    {

                        ChangeStackCellCode(taskIndex, ChangeStackCell, deviceIndex);
                        SetStackNo(deviceIndex, sno, manKind, fid);
                        return true;
                    }
                    else
                    {//20120820没有空闲的两个堆垛机公用的交接货位
                        return false;
                    }
                }
                //然后其余情况根据总列数折中分配给两个堆垛机
                resDev = GetPRIStackNo(deviceIndex, Zcoor, Xcoor, ZcoorS, XcoorS);

                devinfo = Model.CGetInfo.GetDeviceInfo(resDev);
                if (devinfo.RunState == 0 && ccf.GetManTaskReserve(resDev) <= 0 && ccf.GetDeviceLockedState(resDev) == 0)
                {//空闲、无任务执行、无管理任务预约锁
                    SetStackNo(deviceIndex, resDev, manKind, fid);
                    return true;
                }
                else
                {//根据35001当前位置和正在执行的任务的目标位置考虑是否分配35002
                    resDev = devinfo.MutexStack;
                    devinfo = Model.CGetInfo.GetDeviceInfo(resDev);
                    if (devinfo.RunState == 0 && ccf.GetManTaskReserve(resDev) <= 0 && ccf.GetDeviceLockedState(resDev) == 0)
                    {
                        sql = new StringBuilder(string.Format("SELECT F_DeviceCommandIndex,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5, F_NumParam6 FROM T_Monitor_Task WHERE (F_Status > 0) AND (F_DeviceIndex = {0})", devinfo.MutexStack));
                        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                        if (dv.Count > 0)
                        {
                            if (dv[0]["F_DeviceCommandIndex"].ToString() == "4")//取货
                            {
                                if ((GetBarcodeCoor(Convert.ToInt32(dv[0]["F_NumParam2"]), Convert.ToInt32(dv[0]["F_NumParam1"])) + StackMutexXCoor) <= GetBarcodeCoor(Xcoor, Zcoor))
                                {
                                    SetStackNo(deviceIndex, resDev, manKind, fid);
                                    return true;
                                }
                            }
                            if (dv[0]["F_DeviceCommandIndex"].ToString() == "5")//送货
                            {
                                if ((GetBarcodeCoor(Convert.ToInt32(dv[0]["F_NumParam5"]), Convert.ToInt32(dv[0]["F_NumParam4"])) + StackMutexXCoor) <= GetBarcodeCoor(Xcoor, Zcoor))
                                {
                                    SetStackNo(deviceIndex, resDev, manKind, fid);
                                    return true;
                                }
                            }
                        }
                        else
                        {//(resDev - devinfo.MutexStack)设备编号小的设备，实际行走位置的坐标值也小
                            int xcMutex = (resDev - devinfo.MutexStack) * (GetBarcodeCoor(Xcoor, Zcoor) - Model.CGetInfo.GetDeviceInfo(devinfo.MutexStack).XCoor);//20120513
                            int xMutex = Math.Abs(GetBarcodeCoor(Xcoor, Zcoor) - Model.CGetInfo.GetDeviceInfo(devinfo.MutexStack).XCoor);
                            int xDev = Math.Abs(GetBarcodeCoor(Xcoor, Zcoor) - Model.CGetInfo.GetDeviceInfo(resDev).XCoor);
                            devinfo = Model.CGetInfo.GetDeviceInfo(devinfo.MutexStack);//20120513
                            if ((xDev < xMutex) || ((devinfo.RunState >= 2) && (devinfo.RunState <= 4) && (xcMutex > StackMutexXCoor)))//20120513
                            {
                                SetStackNo(deviceIndex, resDev, manKind, fid);
                                return true;
                            }
                        }
                    }
                }

                return false;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }

        private string  GetChangeStackCell(int stack)
        {//20120820根据两个堆垛机的组合任务判断哪个更换堆垛机站台空闲
            DataView dv = new DataView();
            int fids = 0; string cell = ""; int minfids = int.MaxValue;
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_LaneDeviceIndex, F_ChangeStackCell  FROM  T_Base_LaneInfo where F_StackIndex={0}", stack)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    char[] cc = new char[1] { ';'};
                    string[] sp=dv[0]["F_ChangeStackCell"].ToString().Split(cc);
                    string ChangeStackCell=string.Empty ;
                    int lanedev = 0;
                    for (int i = 0; i < sp.GetLength(0); i++)
                    {//T_Monitor_Task表新增 F_ChangeStackCell  "18001,01-30-02"
                        int.TryParse(sp[i], out lanedev);
                        if (lanedev > 0)
                        {//T_Base_LaneInfo表的 F_ChangeStackCell 和F_ChangeForkCell字段可以填写倒叉货位对应虚拟站台的设备索引
                            sp[i] = ccf.GetChangeCellFromLaneGate(Convert.ToInt32( dv[0]["F_LaneDeviceIndex"]), lanedev);
                        }
                        ChangeStackCell = dv[0]["F_LaneDeviceIndex"].ToString() + "," + sp[i];
                        fids = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT count(distinct F_ManageTaskIndex) as fids  FROM T_Monitor_Task where F_ChangeStackCell='{0}'", ChangeStackCell)));
                        if (fids < minfids)
                        {
                            minfids = fids;
                            cell = sp[i];
                        }
                    }
                }
                
                return cell;
                

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        void SetStackNo(int dummyStackno, int stackno, int manKind, int fid)
        {
            try
            {
                //20111226考虑调整配套的站台和提前检测，35001-32038；35002-32036
                if (StackIfExitTask(stackno) == true) return;

                object[] ob = new object[4] { stackno, manKind, fid, dummyStackno };
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0}  WHERE (F_ManageTASKKINDINDEX = {1}) AND (F_ManageTaskIndex = {2}) AND (F_DeviceIndex = {3})", ob));
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{3},{0})  WHERE (F_ManageTASKKINDINDEX = {1}) AND (F_ManageTaskIndex = {2}) ", ob));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 分配实际RGV车号，修改本RGV车的提前检测
        /// </summary>
        /// <param name="dummyRgvno">虚拟RGV</param>
        /// <param name="realRgvno">实际RGV</param>
        /// <param name="monIndex">设备指令索引</param>
        /// <param name="oldUnloadConveyor">原来送货站台</param>
        /// <param name="unloadConveyor">实际送货站台</param>
        /// <param name="goalConveyor">最终送货站台</param>
        void SetRGVNo(int dummyRgvno, int realRgvno, int monIndex,int oldUnloadConveyor,int unloadConveyor,int goalConveyor,int realnum1,int realnum4)
        {
            try
            {
                int routeidsub = ccf.GetRouteIDsub(realRgvno);
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},f_goalconveyor={2},F_NUMPARAM1={4},F_NUMPARAM4={5} WHERE F_MONITORINDEX = {3}", realRgvno, routeidsub, goalConveyor, monIndex,realnum1,realnum4));
                //更新RGV本身的提前监测
                object[] ob = new object[3] { dummyRgvno, realRgvno, monIndex };
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", ob));
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", unloadConveyor,realnum1,monIndex));
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", goalConveyor, realnum4, monIndex));
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = concat(F_AheadDetect,';D-{0}.5')  WHERE (F_MONITORINDEX= {1}) ", realRgvno, monIndex));

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// 递归拆分补充RGV换车取送货指令
        /// </summary>
        /// <param name="currMonindex">当前RGV取货指令</param>
        /// <param name="currRgvChannel">虚拟RGV编号</param>
        /// <param name="currConveyor">当前RGV取货输送机</param>
        /// <param name="currRgv">当前RGV</param>
        /// <param name="currArea">当前区域</param>
        /// <param name="goalConveyor">RGV最终送货输送机</param>
        /// <param name="areaOrderBy">RGV任务区域排序（与RGV编号排序一致）方式：小到大asc，大到小desc</param>
        /// RecursionDisassembleRGVTask(monIndex, deviceIdx, numP1, N1rgv, N1area, numP4, "asc");
        ///                                                  取货位F_INPUT 取货位F_NEARGETDEVICE 
        void RecursionDisassembleRGVTask(int currMonindex, int currRgvChannel, int currConveyor, int currRgv, int currArea, int goalConveyor, string areaOrderBy)
        {
            try
            {
                List<StringBuilder> insertMonList = new List<StringBuilder>();
                DataView dvRgvgate; object ob; StringBuilder sbAreaOrderBy=new StringBuilder("");
                string barcode = ccf.GetBarCodeFromMonitor(currMonindex);
                int mankind = ccf.GetManageTaskKindIndexFromMonitor(currMonindex);
                int manFID = ccf.GetManageTaskIndexFromMonitor(currMonindex);
                int routeidsub =Convert.ToInt32( dbo.GetSingle(string.Format("SELECT F_ROUTEID FROM T_MONITOR_TASK where F_MonitorIndex={0}",currMonindex)));
                int ioControlTaskType = ccf.GetFCONTROLTASKTYPEFromManageTask(mankind, manFID);
                int tmpgoalConveyor = goalConveyor;
                int UseableMonindex = 0;

                //---------------------------modify by bz--------------------------------//
                #region
                int area1RGV = 0, INarea2RGV = 0, OUTarea2RGV = 0, area3RGV = 0, INarea4RGV = 0, OUTarea4RGV = 0, area5RGV = 0, tempstation2 = -1, tempstation4 = -1;

                int realloadRGV = Convert.ToInt32(dbo.GetSingle("select f_input  from T_BASE_RGV_GATE where f_rgvgatedeviceindex=" + currConveyor));
                if (currArea == 2)
                {
                    realloadRGV = Convert.ToInt32(dbo.GetSingle("select f_output  from T_BASE_RGV_GATE where f_rgvgatedeviceindex=" + currConveyor));
                }
                int realunloadRGV = Convert.ToInt32(dbo.GetSingle("select f_input  from T_BASE_RGV_GATE where f_rgvgatedeviceindex=" + goalConveyor));
                int goalarea = Convert.ToInt32(dbo.GetSingle("select f_neargetdevice from T_BASE_RGV_GATE where f_rgvgatedeviceindex=" + goalConveyor.ToString()));
                int lasttaskindex = Convert.ToInt32(dbo.GetSingle("select F_MONITORINDEX from t_monitor_task where F_DEVICEINDEX=" + currRgvChannel + " and F_DEVICECOMMANDINDEX=3 and F_MANAGETASKINDEX=" + manFID));
                if (areaOrderBy == "asc")
                {
                    for (int i = currArea; i <= goalarea; i++)//先赋值每个区域的车，换车区域如果车相同则tempstation保持-1，不同改成0
                    {
                        if (i == 2 && currArea != 2) 
                        {
                            INarea2RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_input from T_BASE_RGV_GATE  where f_neargetdevice=2"));
                            OUTarea2RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_output from T_BASE_RGV_GATE  where f_neargetdevice=2"));
                            if (INarea2RGV != OUTarea2RGV)
                            {
                                tempstation2 = 0;
                            }
                        }
                        if (i == 4 ) 
                        {
                            INarea4RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_input from T_BASE_RGV_GATE  where f_neargetdevice=4"));
                            OUTarea4RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_output from T_BASE_RGV_GATE  where f_neargetdevice=4"));
                            if (INarea4RGV != OUTarea4RGV)
                            {
                                tempstation4 = 0;
                            }
                        }

                    }
                }
                else
                {
                    for (int i = currArea; i >= goalarea; i--)//先赋值每个区域的车，换车区域如果车相同则tempstation保持-1，不同改成0
                    {
                        if (i == 2)
                        {
                            INarea2RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_input from T_BASE_RGV_GATE  where f_neargetdevice=2"));
                            OUTarea2RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_output from T_BASE_RGV_GATE  where f_neargetdevice=2"));
                            if (INarea2RGV != OUTarea2RGV)
                            {
                                tempstation2 = 0;
                            }
                        }
                        if (i == 4)
                        {
                            INarea4RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_input from T_BASE_RGV_GATE  where f_neargetdevice=4"));
                            OUTarea4RGV = Convert.ToInt32(dbo.GetSingle("select distinct f_output from T_BASE_RGV_GATE  where f_neargetdevice=4"));
                            if (INarea4RGV != OUTarea4RGV)
                            {
                                tempstation4 = 0;
                            }
                        }

                    }
                }
                if (areaOrderBy == "asc")
                {
                    for (int i = currArea; i <= goalarea; i++)//找换车区域站台是否可用
                    {
                        if (i == 2 && currArea != 2) 
                        {
                            if (INarea2RGV != OUTarea2RGV)
                            {
                                DataView tempdv = dbo.ExceSQL("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_neargetdevice=" + i).Tables[0].DefaultView;
                                if (tempdv.Count > 0)
                                {
                                    for (int j = 0; j < tempdv.Count; j++)
                                    {
                                        int mantaskreceive = Convert.ToInt32(dbo.GetSingle("select F_MANTASKRESERVE from t_base_device where F_DEVICEINDEX=" + tempdv[j]["f_rgvgatedeviceindex"]));
                                        if (mantaskreceive == 0)
                                        {
                                            tempstation2 = Convert.ToInt32(tempdv[j]["f_rgvgatedeviceindex"]);
                                            break;
                                        }
                                    }
                                    if (tempstation2 == -1)
                                    {
                                        tempstation2 = 0;//没有找到合适的换车站台
                                    }
                                }
                            }


                        }
                        if (i == 4 && tempstation2 == -1) 
                        {
                            if (INarea4RGV != OUTarea4RGV)
                            {
                                DataView tempdv = dbo.ExceSQL("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_neargetdevice=" + i).Tables[0].DefaultView;
                                if (tempdv.Count > 0)
                                {
                                    for (int j = 0; j < tempdv.Count; j++)
                                    {
                                        int mantaskreceive = Convert.ToInt32(dbo.GetSingle("select F_MANTASKRESERVE from t_base_device where F_DEVICEINDEX=" + tempdv[j]["f_rgvgatedeviceindex"]));
                                        if (mantaskreceive == 0)
                                        {
                                            tempstation4 = Convert.ToInt32(tempdv[j]["f_rgvgatedeviceindex"]);
                                            break;
                                        }
                                    }
                                    if (tempstation4 == -1)//没有找到合适的换车站台
                                    {
                                        tempstation4 = 0;
                                    }
                                }
                            }


                        }
                    }
                    if (tempstation2 == 0 || (tempstation4 == 0&&tempstation2==-1))//换车区域不满足条件
                    {
                        return;
                    }
                    else
                    {
                        for (int i = currMonindex + 1; i < currMonindex + 3; i++)
                        {
                            int nom1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + i));
                            int nom2 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i+1)));
                            //int nom3 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i + 2)));
                            //int nom4 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i + 3)));
                            if (nom1 + nom2  == 0) 
                            {
                                UseableMonindex = i;
                                break;
                            }
                            
                        }
                        if (UseableMonindex == 0)
                        {
                            AheadDetectUnallow.Clear();
                            AheadDetectUnallow.Append("分配转运站台时未找到可用的连续任务号");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, currMonindex);
                            return;
                        }
                        if (tempstation2 > 0)
                        {
                            SetRGVNo(currRgvChannel, realloadRGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor,currConveyor,tempstation2);
                            routeidsub = ccf.GetRouteIDsub(INarea2RGV);
                            InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", INarea2RGV, UseableMonindex, currConveyor, goalConveyor,tempstation2);
                           
                            //routeidsub = ccf.GetRouteIDsub(OUTarea2RGV);
                            if (tempstation4 >= 0)//会路过第二组中转站台
                            {
                                routeidsub = ccf.GetRouteIDsub(35400);
                                InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", 35400, UseableMonindex+1, tempstation2, goalConveyor, goalConveyor);
                                //InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", OUTarea2RGV, UseableMonindex + 1, tempstation2, goalConveyor, tempstation4);
                            }
                            else
                            {
                                routeidsub = ccf.GetRouteIDsub(OUTarea2RGV);
                                InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", OUTarea2RGV, UseableMonindex + 1, tempstation2, goalConveyor, goalConveyor);
                                SetRGVNo(currRgvChannel, realunloadRGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor,tempstation2,goalConveyor);
                            }
                            
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mankind.ToString() + manFID.ToString())).Append(" where F_deviceindex=").Append(tempstation2);
                            dbo.ExceSQL(sql.ToString());
                        }
                        else if (tempstation4 > 0)
                        {
                            SetRGVNo(currRgvChannel, realloadRGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor, currConveyor, tempstation4);
                            
                            routeidsub = ccf.GetRouteIDsub(INarea4RGV);
                            InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", INarea4RGV, UseableMonindex, currConveyor, goalConveyor, tempstation4);
                            //if (currArea == 2)
                            //{
                            //    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", INarea4RGV, UseableMonindex+1, currConveyor, goalConveyor, tempstation4);
                            //}
                            //else
                            //{
                            //    SetRGVNo(currRgvChannel, realloadRGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor,currConveyor,tempstation4);
                            //    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", INarea4RGV, UseableMonindex+1, currConveyor, goalConveyor, tempstation4);
                            //}
                            routeidsub = ccf.GetRouteIDsub(OUTarea4RGV);
                            InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", OUTarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor,goalConveyor);
                            SetRGVNo(currRgvChannel, realunloadRGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor, tempstation4, goalConveyor);
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mankind.ToString() + manFID.ToString())).Append(" where F_deviceindex=").Append(tempstation4);
                            dbo.ExceSQL(sql.ToString());
                        }
                        
                        

                    }
                }
                else
                {
                    for (int i = currArea; i >= goalarea; i--)//找换车区域站台是否可用
                    {
                        if (i == 2)
                        {
                            if (INarea2RGV != OUTarea2RGV)
                            {
                                DataView tempdv = dbo.ExceSQL("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_neargetdevice=" + i).Tables[0].DefaultView;
                                if (tempdv.Count > 0)
                                {
                                    for (int j = 0; j < tempdv.Count; j++)
                                    {
                                        int mantaskreceive = Convert.ToInt32(dbo.GetSingle("select F_MANTASKRESERVE from t_base_device where F_DEVICEINDEX=" + tempdv[j]["f_rgvgatedeviceindex"]));
                                        if (mantaskreceive == 0)
                                        {
                                            tempstation2 = Convert.ToInt32(tempdv[j]["f_rgvgatedeviceindex"]);
                                            break;
                                        }
                                    }
                                    if (tempstation2 == -1)//没有找到合适的换车站台
                                    {
                                        tempstation2 = 0;
                                    }
                                }
                            }


                        }
                        if (i == 4)
                        {
                            if (INarea4RGV != OUTarea4RGV)
                            {
                                DataView tempdv = dbo.ExceSQL("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_neargetdevice=" + i).Tables[0].DefaultView;
                                if (tempdv.Count > 0)
                                {
                                    for (int j = 0; j < tempdv.Count; j++)
                                    {
                                        int mantaskreceive = Convert.ToInt32(dbo.GetSingle("select F_MANTASKRESERVE from t_base_device where F_DEVICEINDEX=" + tempdv[j]["f_rgvgatedeviceindex"]));
                                        if (mantaskreceive == 0)
                                        {
                                            tempstation4 = Convert.ToInt32(tempdv[j]["f_rgvgatedeviceindex"]);
                                            break;
                                        }
                                    }
                                    if (tempstation4 == -1)//没有找到合适的换车站台
                                    {
                                        tempstation4 = 0;
                                    }
                                }
                            }


                        }
                    }
                    if ((tempstation2 == 0 && goalConveyor != 32153) || tempstation4 == 0)//换车区域不满足条件
                    {
                        return;
                    }
                    else
                    {
                        for (int i = currMonindex + 1; i < currMonindex + 6; i++)
                        {
                            int nom1 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + i));
                            int nom2 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i + 1)));
                            int nom3 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i + 2)));
                            int nom4 = Convert.ToInt32(dbo.GetSingle("select count(0) from t_monitor_task where F_MONITORINDEX=" + (i + 3)));
                            if (nom1 + nom2 + nom3 + nom4 == 0)
                            {
                                UseableMonindex = i;
                            }

                        }
                        if (UseableMonindex == 0)
                        {
                            AheadDetectUnallow.Clear();
                            AheadDetectUnallow.Append("分配转运站台时未找到可用的连续任务号");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, currMonindex);
                            return;
                        }
                        if (tempstation4 > 0)
                        {
                            SetRGVNo(currRgvChannel, realloadRGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor, currConveyor, tempstation4);
                            routeidsub = ccf.GetRouteIDsub(OUTarea4RGV);
                            InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", OUTarea4RGV, UseableMonindex, currConveyor, goalConveyor, tempstation4);
                            if (goalConveyor != 32153)
                            {
                                routeidsub = ccf.GetRouteIDsub(INarea4RGV);
                                if (tempstation2 > 0)
                                {
                                    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor, tempstation2);
                                }
                                else
                                {
                                    SetRGVNo(currRgvChannel, realunloadRGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor, tempstation4, goalConveyor);
                                    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor, goalConveyor);
                                }
                            }
                            else
                            {
                                routeidsub = ccf.GetRouteIDsub(INarea4RGV);
                                InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor, goalConveyor);
                                SetRGVNo(currRgvChannel, INarea4RGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor, tempstation4, goalConveyor);
                                //if (tempstation2 > 0)
                                //{
                                //    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor, tempstation2);
                                //}
                                //else
                                //{
                                //    SetRGVNo(currRgvChannel, realunloadRGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor, tempstation4, goalConveyor);
                                //    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea4RGV, UseableMonindex + 1, tempstation4, goalConveyor, goalConveyor);
                                //}
                            }
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mankind.ToString() + manFID.ToString())).Append(" where F_deviceindex=").Append(tempstation4);
                            dbo.ExceSQL(sql.ToString());
                        }
                        else if (tempstation4 == -1 && goalConveyor == 32153)
                        {
                            SetRGVNo(currRgvChannel, OUTarea2RGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor, currConveyor, goalConveyor);
                            SetRGVNo(currRgvChannel, OUTarea2RGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor, currConveyor, goalConveyor);
                        }
                        if (tempstation2 > 0&&goalConveyor!=32153)
                        {
                            SetRGVNo(currRgvChannel, realunloadRGV, lasttaskindex, tmpgoalConveyor, currConveyor, goalConveyor,tempstation2,goalConveyor);
                            routeidsub = ccf.GetRouteIDsub(OUTarea2RGV);
                            if (tempstation4 > 0)
                            {
                                InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", OUTarea2RGV, UseableMonindex + 2, tempstation4, goalConveyor, tempstation2);
                            }
                            else
                            {
                                SetRGVNo(currRgvChannel, realloadRGV, currMonindex, tmpgoalConveyor, currConveyor, goalConveyor, currConveyor, tempstation2);
                                InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", OUTarea2RGV, UseableMonindex + 2, currConveyor, goalConveyor, tempstation2);
                            }
                            
                            routeidsub = ccf.GetRouteIDsub(INarea2RGV);
                            InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", INarea2RGV, UseableMonindex + 3, tempstation2, goalConveyor,goalConveyor);
                            sql.Remove(0, sql.Length);
                            sql.Append("update T_Base_Device set F_ManTaskReserve=").Append((mankind.ToString() + manFID.ToString())).Append(" where F_deviceindex=").Append(tempstation2);
                            dbo.ExceSQL(sql.ToString());
                        }
                        
                        
                        
                    }
                }
                #endregion
                //---------------------------modify by bz--------------------------------//

                //开始循环
                //while (true)//gjn
                //------------------------------------------原来程序-----------------------------------//
                //{
                //    sbAreaOrderBy.Clear();
                //    if (areaOrderBy == "desc")
                //    {
                //        sbAreaOrderBy.Append(string.Format(" <{0} ", currArea));
                //    }
                //    else
                //    {
                //        sbAreaOrderBy.Append(string.Format(" >{0} ", currArea));
                //    }
                //    dvRgvgate = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex,f_channelsindex,f_neargetdevice,f_input,f_output,f_iftransfer from T_BASE_RGV_GATE where   f_channelsindex={1} and f_neargetdevice {2} order by f_neargetdevice {3}", 
                //        currRgv, currRgvChannel, sbAreaOrderBy.ToString(), areaOrderBy)).Tables[0].DefaultView;
                //    if (dvRgvgate.Count > 0)
                //    {//合适记录是换车站台，而且无任务选中，再次查找，直到找到goalConveyor为止;currMonindex是第一个RGV取货，currMonindex+1第一个换车站台送货
                //        int rgvArea = Convert.ToInt32(dvRgvgate[0]["f_neargetdevice"]);
                //        int finput = Convert.ToInt32(dvRgvgate[0]["f_input"]);
                //        int foutput = Convert.ToInt32(dvRgvgate[0]["f_output"]);
                //        char iftransfer = Convert.ToChar(dvRgvgate[0]["f_iftransfer"]);
                //        if (iftransfer == '1' && finput!= foutput)
                //        {//本区是换车区域，选无任务占用的换车站台，currMonindex修改车号后插入在换车站台的放货currMonindex+1
                //            //1.本区找空闲换车站台
                //            dvRgvgate = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_channelsindex={0} and f_neargetdevice= {1} and f_iftransfer='1'", currRgvChannel, rgvArea)).Tables[0].DefaultView;
                //            if (dvRgvgate.Count > 0)
                //            {
                //                int exitIdleRgvGate = 0;
                //                Hashtable deviceTaskcount= new Hashtable();

                //                for (int igate = 0; igate < dvRgvgate.Count; igate++)
                //                {
                //                    //本区无空闲换车站台，找入出库同向任务少的换车站台但是不能有反向任务存在
                //                    int oppositeIOtasktype = 0;
                //                    if (ioControlTaskType == 1)
                //                    {//和管理约定入库1
                //                        oppositeIOtasktype = 2;
                //                    }
                //                    else //if(ioControlTaskType == 1)//gjn 考虑类型为4或5怎么弄
                //                    {//出库2，不允许出现大于2情况
                //                        oppositeIOtasktype = 1;
                //                    }
                //                    //gjn
                //                    ob = dbo.GetSingle(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task,T_MANAGE_TASK WHERE T_MANAGE_TASK.F_MANAGETASKKINDINDEX=T_Monitor_Task.F_MANAGETASKKINDINDEX and FID=F_MANAGETASKINDEX and F_NumParam1 = {0} or F_NumParam4 = {0} and FCONTROLTASKTYPE={1}",
                //                        Convert.ToInt32(dvRgvgate[igate]["f_rgvgatedeviceindex"]),oppositeIOtasktype));
                //                    if (ob == null)
                //                    {//无反向任务存在
                //                        ob = dbo.GetSingle(string.Format("SELECT count(F_MonitorIndex) as MonitorTaskCount FROM T_Monitor_Task,T_MANAGE_TASK WHERE T_MANAGE_TASK.F_MANAGETASKKINDINDEX=T_Monitor_Task.F_MANAGETASKKINDINDEX and FID=F_MANAGETASKINDEX and F_NumParam1 = {0} or F_NumParam4 = {0} and FCONTROLTASKTYPE={1}",
                //                        Convert.ToInt32(dvRgvgate[igate]["f_rgvgatedeviceindex"]), ioControlTaskType));
                //                        if (ob != null)
                //                        {//可选换车站台
                //                         //记录同向出入库任务数量，选中任务最少的一个站台
                //                            deviceTaskcount.Add(Convert.ToInt32(dvRgvgate[igate]["f_rgvgatedeviceindex"]), Convert.ToInt32(ob));
                //                        }
                //                    }
                //                }
                //                if (deviceTaskcount.Count > 0)
                //                {
                //                    int min = 999;
                //                    foreach (int key in deviceTaskcount.Keys)
                //                    {
                //                        if ((int)deviceTaskcount[key]< min)
                //                        {
                //                            min = (int)deviceTaskcount[key];
                //                            exitIdleRgvGate = key;
                //                        }
                //                    }

                //                    routeidsub = ccf.GetRouteIDsub(currRgv);//取得当前RGV所在特殊路径不是原来路径
                //                    //新车号修改之前的取货指令currMonindex车号、原来送货输送机
                //                    SetRGVNo(currRgvChannel, currRgv, currMonindex, tmpgoalConveyor, exitIdleRgvGate,goalConveyor );
                //                    //换车站台的放货currMonindex+1
                //                    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "unload", currRgv, currMonindex + 1, exitIdleRgvGate,goalConveyor);
                //                    //换车站台的虚拟RGV的取货currMonindex+2
                //                    routeidsub = ccf.GetRouteIDsub(currRgvChannel);
                //                    InsertRgvLoadUnloadTask(mankind, manFID, barcode, routeidsub, "load", currRgvChannel, currMonindex + 2, exitIdleRgvGate,goalConveyor);
                //                    if (currRgv != finput)
                //                    {//与上一区域不同的rgv编号
                //                        currRgv = finput;
                //                    }
                //                    else
                //                    {
                //                        currRgv = foutput;
                //                    }
                //                    currMonindex += 2;
                //                    tmpgoalConveyor = exitIdleRgvGate;
                //                    currArea = rgvArea;
                //                }

                //            }
                //        }
                //        else
                //        {//判断rgvArea是否为goalConveyor所在区域
                //            ob = dbo.GetSingle(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where f_neargetdevice={0} and f_rgvgatedeviceindex={1}", rgvArea, goalConveyor));
                //            if (ob != null)
                //            {//是goalConveyor在rgvArea区域，分配rgv编号退出循环
                //                if (finput == foutput)
                //                {
                //                    //修改上一换车站台生成的虚拟车号的取货任务的实际车号
                //                    SetRGVNo(currRgvChannel, finput,currMonindex, goalConveyor, goalConveyor, goalConveyor);
                //                    //补充上一换车站台生成的虚拟车号的取货任务的送货位置的提前检测和送货地址
                //                    StringBuilder AheadDetect = new StringBuilder();
                //                    devinfocheck = Model.CGetInfo.GetDeviceInfo(goalConveyor);
                //                    AheadDetect.Append(";I").Append(goalConveyor).Append(";D").Append(devinfocheck.BindingDevice).Append(";D").Append(devinfocheck.SendOutDetect); //.Append(devinfocheck.BindingDeviceOut);//gjn
                //                    sql.Clear();
                //                    sql.Append("update T_Monitor_Task set F_NumParam4=").Append(goalConveyor).Append(", F_AheadDetect=F_AheadDetect||'").Append(AheadDetect.ToString()).Append("' where F_MonitorIndex=").Append(currMonindex);
                //                    dbo.ExceSQL(sql.ToString());
                //                    object[] obarr = new object[4] {currRgvChannel,mankind,manFID,goalConveyor }; 
                //                    ob = dbo.GetSingle(String.Format("SELECT F_MONITORINDEX FROM T_MONITOR_TASK where F_DEVICEINDEX={0} and F_MANAGETASKKINDINDEX={1} and F_MANAGETASKINDEX={2} and F_NUMPARAM4={3}",obarr));
                //                    if (ob != null)
                //                    {
                //                        SetRGVNo(currRgvChannel, finput, Convert.ToInt32(ob),goalConveyor,goalConveyor,goalConveyor);//原来任务的虚拟车号送货任务也修改车号

                //                    }
                //                    else
                //                    {//没找到原来拆分的RGV送货指令
                //                        CControlError = string.Format("CControl.RecursionDisassembleRGVTask异常：没找到原来拆分的RGV送货指令");
                //                    }

                //                }
                //                else
                //                {//rgvgate表配置错误
                //                    CControlError = string.Format("CControl.RecursionDisassembleRGVTask异常：非换车站台区域，配置的进出本区的RGV不相同");
                //                }
                //                //break;//gjn
                //            }
                //            else
                //            {//rgvArea不包含goalConveyor的非换车区域，继续找
                //                currArea = rgvArea;
                //                currRgv = finput;
                //            }
                //        }
                //    }

                //}
                //------------------------------------------原来程序-----------------------------------//
            }
            catch (Exception ex)
            {
                CControlError = string.Format("CControl.RecursionDisassembleRGVTask异常：{0}", ex.StackTrace + ex.Message);
            }
        }

        private void InsertRgvLoadUnloadTask(int mankind, int manFID, string barcode, int routeidsub, string loadORunload, int currRgv, int monIndex, int num1,int goalConveyor,int num4)
        {
            try
            {
                StringBuilder AheadDetect = new StringBuilder();
                if (loadORunload == "unload")
                {//unload送货
                    devinfocheck = Model.CGetInfo.GetDeviceInfo(num4);
                    AheadDetect.Clear();
                    AheadDetect.Append("I").Append(currRgv).Append(";D-").Append(currRgv).Append(".0;I").Append(num4).Append(";D").Append(devinfocheck.BindingDevice).Append(";D").Append(devinfocheck.SendOutDetect).Append(";D-").Append(currRgv).Append(".5");//.Append(devinfocheck.BindingDeviceOut);//gjn
                    sql.Clear();
                    sql.Append("INSERT INTO T_Monitor_Task ").Append(
                        "(F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex,F_MonitorTaskLevel,").Append(
                        " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2,").Append(
                        " F_NumParam3, F_NumParam4,F_NumParam5, F_NumParam6,F_AheadDetect,F_TxtParam,f_goalconveyor,F_SplitTime)").Append(
                    "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(100
                        ).Append(",").Append(currRgv).Append(",").Append(3).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(num1).Append(",0").Append(
                         ",0,").Append(num4).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("',").Append(goalConveyor).Append(",'").Append(DateTime.Now.ToString("u")).Append("')");
                        //",0,").Append(goalConveyor).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("',").Append(goalConveyor).Append(")");//gjn
                    dbo.ExceSQL(sql.ToString());
                    //补充上一个取货任务的送货位置的提前检测和送货地址
                    AheadDetect.Clear();
                    AheadDetect.Append(";I").Append(num4).Append(";D").Append(devinfo.BindingDevice).Append(";D").Append(devinfo.SendOutDetect);//.Append(devinfo.BindingDeviceOut);//gjn
                    devinfo = Model.CGetInfo.GetDeviceInfo(goalConveyor);//gjn
                    AheadDetect.Append(";D").Append(devinfo.BindingDevice).Append(";I").Append(devinfo.DeviceIndex);
                    sql.Clear();
                    sql.Append("update T_Monitor_Task set F_NumParam4=").Append(num4).Append(", F_AheadDetect=F_AheadDetect||'").Append(AheadDetect.ToString()).Append("' where F_MonitorIndex=").Append(monIndex-1);
                    dbo.ExceSQL(sql.ToString());
                }
                else
                {//load取货
                    devinfo = Model.CGetInfo.GetDeviceInfo(num1);
                    AheadDetect.Clear();
                    AheadDetect.Append("I").Append(currRgv).Append(";D").Append(currRgv).Append(".0;I").Append(num1).Append(";D-").Append(devinfo.SendOutDetect).Append(";D-").Append(currRgv).Append(".5");//.Append(devinfo.BindingDeviceOut);//gjn
                    devinfo = Model.CGetInfo.GetDeviceInfo(goalConveyor);
                    //AheadDetect.Clear();
                    AheadDetect.Append(";D").Append(devinfo.BindingDevice).Append(";I").Append(devinfo.DeviceIndex); ;//.Append(devinfo.BindingDeviceOut);//gjn

                    sql.Clear();
                    sql.Append("INSERT INTO T_Monitor_Task ").Append(
                        "(F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex,F_MonitorTaskLevel,").Append(
                        " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam2,").Append(
                        " F_NumParam3, F_NumParam4,F_NumParam5, F_NumParam6,F_AheadDetect,F_TxtParam,F_SplitTime)").Append(
                    "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(100
                        ).Append(",").Append(currRgv).Append(",").Append(2).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(num1).Append(",0").Append(
                        //",0,").Append(0).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("')");//gjn
                    ",0,").Append(num4).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("','").Append(DateTime.Now.ToString("u")).Append("')");
                    dbo.ExceSQL(sql.ToString());
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        void GetStackRunX_Zcoor(int StackdeviceIndex,out int Xcoor,out int Zcoor)
        {//20111020
            DataView dv = new DataView();
            try
            {
                Xcoor = 0;
                Zcoor = 1;
                sql = new StringBuilder(string.Format("SELECT F_DeviceCommandIndex,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5, F_NumParam6 FROM T_Monitor_Task WHERE (F_Status > 0) AND (F_DeviceIndex = {0})", StackdeviceIndex));
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    if ((dv[0]["F_DeviceCommandIndex"].ToString() == "2") || (dv[0]["F_DeviceCommandIndex"].ToString() == "4"))//将取，取货
                    {
                        Zcoor = Convert.ToInt32(dv[0]["F_NumParam1"]);
                        Xcoor = Convert.ToInt32(dv[0]["F_NumParam2"]);
                    }
                    else if (dv[0]["F_DeviceCommandIndex"].ToString() == "5")//送货
                    {
                        Zcoor = Convert.ToInt32(dv[0]["F_NumParam4"]);
                        Xcoor = Convert.ToInt32(dv[0]["F_NumParam5"]);

                    }

                }
                //else
                //{

                //    int ManTaskReserve = ccf.GetManTaskReserve(StackdeviceIndex);
                //    if (ManTaskReserve > 0)
                //    {
                //        int mti =Convert.ToInt32( ManTaskReserve.ToString().Substring(0, 1));
                //        int fid = Convert.ToInt32(ManTaskReserve.ToString().Substring(1));
                //        sql = new StringBuilder(string.Format("SELECT F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5, F_NumParam6 FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX={0}) AND (F_ManageTaskIndex = {1}) order by F_MonitorIndex asc", mti, fid));
                //        dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                //        if (dv.Count > 0)
                //        {
                //            if (dv[0]["F_DeviceIndex"].ToString() == StackdeviceIndex.ToString())
                //            {
                //                if ((dv[0]["F_DeviceCommandIndex"].ToString() == "2") || (dv[0]["F_DeviceCommandIndex"].ToString() == "4"))//将取，取货
                //                {
                //                    Zcoor = Convert.ToInt32(dv[0]["F_NumParam1"]);
                //                    Xcoor = Convert.ToInt32(dv[0]["F_NumParam2"]);
                //                }
                //                else if (dv[0]["F_DeviceCommandIndex"].ToString() == "5")//送货
                //                {
                //                    Zcoor = Convert.ToInt32(dv[0]["F_NumParam4"]);
                //                    Xcoor = Convert.ToInt32(dv[0]["F_NumParam5"]);

                //                }
                //            }
                //        }
                //    }
                //}
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
            
        }
        void GetStackRunReserveX_Zcoor(int StackdeviceIndex, out int Xcoor, out int Zcoor)
        {//20111020
            Xcoor = 0;
            Zcoor = 1; DataView dv = new DataView();
            try
            {
                int ManTaskReserve = ccf.GetManTaskReserve(StackdeviceIndex);
                if (ManTaskReserve > 0)
                {
                    int mti = Convert.ToInt32(ManTaskReserve.ToString().Substring(0, 1));
                    int fid = Convert.ToInt32(ManTaskReserve.ToString().Substring(1));
                    sql = new StringBuilder(string.Format("SELECT F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1, F_NumParam2, F_NumParam3, F_NumParam4, F_NumParam5, F_NumParam6 FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX={0}) AND (F_ManageTaskIndex = {1}) order by F_MonitorIndex asc", mti, fid));
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        if (dv[0]["F_DeviceIndex"].ToString() == StackdeviceIndex.ToString())
                        {
                            if ((dv[0]["F_DeviceCommandIndex"].ToString() == "2") || (dv[0]["F_DeviceCommandIndex"].ToString() == "4"))//将取，取货
                            {
                                Zcoor = Convert.ToInt32(dv[0]["F_NumParam1"]);
                                Xcoor = Convert.ToInt32(dv[0]["F_NumParam2"]);
                            }
                            else if (dv[0]["F_DeviceCommandIndex"].ToString() == "5")//送货
                            {
                                Zcoor = Convert.ToInt32(dv[0]["F_NumParam4"]);
                                Xcoor = Convert.ToInt32(dv[0]["F_NumParam5"]);

                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }

        }
        /// <summary>
        /// 插入避让指令
        /// </summary>
        /// <param name="stackno">避让堆垛机</param>
        /// <param name="order">指令</param>
        /// <param name="Barcodecoor">避让到达的条码坐标</param>
        /// <param name="layerhigh">避让堆垛机的货物层高度</param>
        void InsertStackMutexOrder(int stackno,int order,int Barcodecoor,int layerhigh)
        {//20111020
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL("SELECT MAX(BarcodeCoor) AS maxcoor, MIN(BarcodeCoor) AS mincoor FROM T_Base_BarcodeCoor").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    if (Barcodecoor > Convert.ToInt32(dv[0]["maxcoor"]))
                    {
                        Barcodecoor = Convert.ToInt32(dv[0]["maxcoor"]);
                    }
                    if (Barcodecoor < Convert.ToInt32(dv[0]["mincoor"]))
                    {
                        Barcodecoor = Convert.ToInt32(dv[0]["mincoor"]);
                    }
                }
                else
                {
                    return;
                }
                if (order == 2 || order == 4)
                {
                    if (CStaticClass.GetDevicePhotoelectric(stackno, 0) == 0)//20120110
                    {
                        order = 2;

                    }
                    else
                    {
                        order = 1;
                    }


                }
                else
                {
                    if (CStaticClass.GetDevicePhotoelectric(stackno, 0) == 1)//20120110
                    {
                        order = 3;

                    }
                    else
                    {
                        order = 1;
                    }

                }
                int zc = 0, xc = 0, yc = 0, zc1 = 0, xc1 = 0, yc1 = 0;
                if (stackno == 35001)
                {
                    sql.Clear();
                    if (CStaticClass.DBFactory == "OracleDBFactory")
                    {//20151120调度系统oracle的特殊语句
                        sql.Append(string.Format("SELECT ABS(MIN(BarcodeCoor - {0})) AS Expr1, XCoor, ZCoor FROM T_Base_BarcodeCoor where  BarcodeCoor<={0} and layerhigh<={1} and (brorder=0 or brorder={2}) GROUP BY XCoor, ZCoor ORDER BY Expr1  FETCH FIRST ROWS ONLY", Barcodecoor, layerhigh, order));
                    }
                    else
                    {//20151120调度系统SQLServer的特殊语句
                        sql.Append(string.Format("SELECT TOP 1 ABS(MIN(BarcodeCoor - {0})) AS Expr1, XCoor, ZCoor FROM T_Base_BarcodeCoor where BarcodeCoor<={0} and layerhigh<={1} and (brorder=0 or brorder={2}) GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh, order));
                    }
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
                }
                else
                {
                    sql.Clear();
                    if (CStaticClass.DBFactory == "OracleDBFactory")
                    {//20151120调度系统oracle的特殊语句
                        sql.Append(string.Format("SELECT ABS(MIN(BarcodeCoor - {0})) AS Expr1, XCoor, ZCoor FROM T_Base_BarcodeCoor where BarcodeCoor>={0} and layerhigh<={1} and (brorder=0 or brorder={2}) GROUP BY XCoor, ZCoor ORDER BY Expr1  FETCH FIRST ROWS ONLY", Barcodecoor, layerhigh, order));
                    }
                    else
                    {//20151120调度系统SQLServer的特殊语句
                        sql.Append(string.Format("SELECT TOP 1 ABS(MIN(BarcodeCoor - {0})) AS Expr1, XCoor, ZCoor FROM T_Base_BarcodeCoor where BarcodeCoor>={0} and layerhigh<={1} and (brorder=0 or brorder={2}) GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh, order));
                    }
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句

                }
                
                if (dv.Count > 0)
                {

                    if (order == 2)
                    {
                        zc = Convert.ToInt32(dv[0]["ZCoor"]);
                        xc = Convert.ToInt32(dv[0]["XCoor"]);
                        if (xc == 51) xc = 52;//20120110
                        if (xc <= 5)
                        {
                            zc = 2;
                            xc = 2;
                        }
                        yc = 1;
                        if (xc == 52) zc = 1;
                    }
                    else
                    {
                        zc1 = Convert.ToInt32(dv[0]["ZCoor"]);
                        xc1 = Convert.ToInt32(dv[0]["XCoor"]);
                        if (xc1 == 51) xc1 = 52;//20120110
                        if (xc1 <= 5)
                        {
                            zc1 = 2;
                            xc1 = 2;
                        }
                        yc1 = 1;

                        if (xc1 == 52) zc1 = 2;
                    }
                }
                else
                {
                    if (order != 1)
                    {
                        return;
                    }
                }


                dv = dbo.ExceSQL(string.Format("select F_MonitorIndex from T_Monitor_Task where F_DeviceIndex={0} and F_TxtParam='brbrbr'", stackno)).Tables[0].DefaultView;
                if (dv.Count <= 0)
                {
                    int hidx = ccf.GetTempManageIdx();
                    int hmindx = ccf.GetMonitorIndex(hidx, 2);
                    sql.Remove(0, sql.Length);
                    sql.Append("insert into T_Monitor_Task(F_MonitorTaskLevel,F_RouteID,F_ManageTaskIndex,F_ManageTaskKindIndex,F_MonitorIndex,").
                            Append("F_DeviceIndex,F_DeviceCommandIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect) ").
                            Append("values(2,").Append(ccf.GetRouteIDsub(stackno)).Append(",").
                            Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(stackno).
                            Append(",").Append(order).Append(",").Append(zc).Append(",").Append(xc).Append(",").Append(yc).Append(",").Append(zc1).Append(",").Append(xc1).Append(",").Append(yc1).Append(",'brbrbr','-')");
                    dbo.ExecuteSql(sql.ToString());
                }
            }
            catch (Exception ex)
            {
                CControlError = string.Format("插入互斥堆垛机避让指令时：{0}", ex.StackTrace+ex.Message );
                
            }
            finally
            {
                dv.Dispose();
            }
        }
        int GetNowDevice(int taskindex)
        {
            DataView dvb = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("SELECT  F_NumParam1 FROM T_Monitor_Task WHERE (F_MonitorIndex = ").Append(taskindex).Append(")");
                dvb = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dvb.Count > 0)
                {
                    return Convert.ToInt32(dvb[0]["F_NumParam1"]);
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dvb.Dispose();
            }
        }
        
        /// <summary>
        /// 设备指令队列中是否存在可以关联堆垛机的取货命令
        /// </summary>
        /// <param name="Stackdev">堆垛机</param>
        /// <param name="zxy">取货货位</param>
        /// <param name="Correlzxy">关联货位</param>
        /// <param name="nottaskindex">此次设备指令索引</param>
        /// <returns></returns>
        bool IFHaveStackCorrelGetCommand(int Stackdev,string zxy, string Correlzxy,int nottaskindex)
        {
            DataView dv = new DataView();
                char[] cc = new char[1] { '-' };
                string[] zxystr = zxy.Split(cc);
                string[] zxystrCorrl = Correlzxy.Split(cc);
            try
            {
                int laneway=ccf.GetLaneWayNoFromStack(Stackdev);
                int corrdev = 0;
                dv = dbo.ExceSQL(string.Format("SELECT F_LaneGateDeviceIndex FROM T_Base_Lane_Gate WHERE (F_LaneIndex = {0}) AND (F_ZXY = '{1}')",laneway,Correlzxy)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    corrdev = Convert.ToInt32(dv[0]["F_LaneGateDeviceIndex"]);
                }
                
                object[] ob = new object[8] { Stackdev, nottaskindex, Convert.ToInt32(zxystr[0]), Convert.ToInt32(zxystr[1]),Convert.ToInt32(zxystr[2]),
                Convert.ToInt32(zxystrCorrl[0]),Convert.ToInt32(zxystrCorrl[1]),Convert.ToInt32(zxystrCorrl[2]) };
                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex = {0}) AND (F_DeviceCommandIndex =4) AND (F_MonitorIndex!={1}) and (((F_NumParam1 = {2}) AND (F_NumParam2 = {3}) AND (F_NumParam3 = {4})) or ((F_NumParam1 = {5}) AND (F_NumParam2 = {6}) AND (F_NumParam3 = {7})))", ob)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {//20120906不是已经等待多叉关联任务
                    sql.Remove(0, sql.Length);//输送机等待双叉任务号等于堆垛机取货TaskIdx
                    sql.Append("SELECT F_TaskIndex,F_DeviceIndex,F_Remark FROM T_Base_PLC_Ask WHERE (F_TaskIndex =").Append(Convert.ToInt32(dv[0]["F_MonitorIndex"])).Append(") AND (F_DeviceIndex=").Append(corrdev).Append(")");
                    dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                    if (dv.Count > 0)
                    {
                        return false;
                    }
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
                cc = null;
                zxystrCorrl = null;
                zxystr = null;
            }
        }
        int GetDeviceOrderFromManTaskReserve(int manTaskReserve,int deviceIndex)
        {
            DataView dv = new DataView();
            try
            {
                int mti = Convert.ToInt32(manTaskReserve.ToString().Substring(0, 1));
                int fid = Convert.ToInt32(manTaskReserve.ToString().Substring(1));
                dv = dbo.ExceSQL(string.Format("SELECT F_DeviceIndex,F_DeviceCommandIndex FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX = {0}) AND (F_ManageTaskIndex = {1}) order by F_MonitorIndex asc", mti, fid)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    if (deviceIndex == Convert.ToInt32(dv[0]["F_DeviceIndex"]))
                    {
                        return Convert.ToInt32(dv[0]["F_DeviceCommandIndex"]);
                    }
                    else
                    {
                        return -1;
                    }
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        int GetLayerHigh(int Zcoor, int Xcoor)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT LayerHigh FROM T_Base_BarcodeCoor WHERE (ZCoor = {0}) AND (XCoor = {1})", Zcoor, Xcoor)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0][0]);

                }
                else
                {
                    return 3;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }
        void InsertUpDeviceUP(int updevice, int Mankind, int ManFID, int mindex)
        {
            DataRowView drv = null ; DataView dv = new DataView();
            try
            {


                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorTaskLevel, F_RouteID, F_TxtParam, F_UseAwayFork,F_PriorMonitor FROM  T_Monitor_Task  WHERE F_MonitorIndex={0}", mindex)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    mindex = Convert.ToInt32(dv[0]["F_PriorMonitor"]);
                    drv = dv[0];
                }
                else
                    return;
                StringBuilder ah = new StringBuilder();
                ah.Append("D-").Append(updevice).Append(".7;D").Append(updevice).Append(".0;I").Append(updevice);
                if (DeviceAndOrderExitInMonitor(Mankind, ManFID, updevice, 9, 0) == false)
                {
                    #region 生成输送机命令


                    sql.Remove(0, sql.Length);
                    sql.Append("INSERT INTO T_Monitor_Task ").Append(
                        "(F_ManageTaskIndex, F_ManageTASKKINDINDEX, F_MonitorIndex,F_MonitorTaskLevel,").Append(
                        " F_DeviceIndex, F_DeviceCommandIndex, F_RouteID, F_Status,F_NumParam1, F_NumParam4,").Append(
                        " F_AheadDetect,F_TxtParam,F_UseAwayFork)").Append(
                    "VALUES (").Append(ManFID).Append(",").Append(Mankind).Append(",").Append(mindex).Append(",").Append(drv["F_MonitorTaskLevel"]
                        ).Append(",").Append(updevice).Append(",").Append(9).Append(",").Append(drv["F_RouteID"]).Append(",").Append(0).Append(",").Append(updevice).Append("," + 0
                        ).Append(",'").Append(ah).Append("','").Append(drv["F_TxtParam"]).Append("','").Append(drv["F_UseAwayFork"]).Append("')");
                    dbo.ExceSQL(sql.ToString());


                    #endregion
                }
            }
            catch (Exception ex)
            {
                CControlError = "插入顶升机上升指令时：" + ex.StackTrace+ ex.Message ;
                
            }
            finally
            {
                dv.Dispose();
                drv = null;
            }
        }
        /// <summary>
        /// 判断调度表T_Monitor_Task是否存在调度任务的设备和命令
        /// </summary>
        /// <param name="Mankind">调度任务类型</param>
        /// <param name="ManFID">调度任务索引</param>
        /// <param name="DeviceIndex">设备所引</param>
        /// <param name="Order">设备命令</param>
        /// <returns></returns>
        public  bool DeviceAndOrderExitInMonitor(int Mankind, int ManFID, int DeviceIndex, int Order, int ArrowAddress)
        {
            DataView dv = new DataView();
            try
            {
                if (Order == -1) return true;
                sql.Remove(0, sql.Length);
                switch (ccf.GetDeviceKindIdx(DeviceIndex))
                {
                    case 1://堆垛机
                        sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(ManFID).Append(")").Append(
                        " AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = ").Append(DeviceIndex).Append(")").Append(
                        " AND (F_DeviceCommandIndex = ").Append(Order).Append(")");
                        break;
                    case 2://输送机
                        sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(ManFID).Append(")").Append(
                        " AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = ").Append(DeviceIndex).Append(")").Append(
                        " AND (F_DeviceCommandIndex = ").Append(Order).Append(")");
                        break;
                    case 4://RGV
                        sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(ManFID).Append(")").Append(
                        " AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = ").Append(DeviceIndex).Append(")").Append(
                        " AND (F_DeviceCommandIndex = ").Append(Order).Append(") and F_NumParam1=").Append(ArrowAddress);
                        break;
                    case 6://AGV
                        sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(ManFID).Append(")").Append(
                        " AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = ").Append(DeviceIndex).Append(")").Append(
                        " AND (F_DeviceCommandIndex = ").Append(Order).Append(")");
                        break;
                    default:
                        sql.Append("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(ManFID).Append(")").Append(
                        " AND (F_ManageTASKKINDINDEX = ").Append(Mankind).Append(") AND (F_DeviceIndex = ").Append(DeviceIndex).Append(")").Append(
                        " AND (F_DeviceCommandIndex = ").Append(Order).Append(")");
                        break;
                }
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                CControlError = "ControlSystem.CControl.DeviceAndOrderExitInMonitor:" +ex.StackTrace+ ex.Message;
                return false;
            }
            finally
            {
                dv.Dispose() ;

            }
        }
        /// <summary>
        /// 堆垛机是否存在避让指令正在运行
        /// </summary>
        /// <param name="DeviceIndex"></param>
        /// <returns></returns>
        bool DeviceHandTaskIfRun(int DeviceIndex)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task where F_ManageTASKKINDINDEX=4 and F_DeviceIndex={0} and F_Status>0", DeviceIndex)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }

        }
        /// <summary>
        /// 堆垛机是否存在避让指令等待运行
        /// </summary>
        /// <param name="DeviceIndex"></param>
        /// <returns></returns>
        bool DeviceHandTaskIfWaitRun(int DeviceIndex)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task where F_ManageTASKKINDINDEX=4 and F_DeviceIndex={0} and F_Status=0", DeviceIndex)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }

        }
        bool StackIfExitTask(int stackno)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex  FROM  T_Monitor_Task where  F_DeviceIndex={0}", stackno)).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.Dispose();
            }
        }

        void GetSpecialStackNo(int virStack, int startZ, int startX, int endZ, int endX, out int stackno, out bool IfCombinedWork)
        {
            stackno = 0; IfCombinedWork = false;
            int Getdevice = 0, Sendevice = 0;
            char[] fcc = new char[1] { ';' };
            char[] dcc = new char[1] { ',' };
            char[] hcc = new char[1] { '-' };
            DataView dv = new DataView();
            string[] zxys; string[] zx_x; string[] x_x;
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT T_Base_StackInfo.F_StackIndex, T_Base_StackInfo.F_SpecialZXArea,T_Base_StackInfo.F_PRIZXArea FROM T_Base_StackInfo WHERE T_Base_StackInfo.F_Mutex IS NOT NULL and T_Base_StackInfo.F_VirtualStack={0}", virStack)).Tables[0].DefaultView;

                for (int i = 0; i < dv.Count; i++)
                {
                    zxys = dv[i]["F_SpecialZXArea"].ToString().Split(fcc);//1,0-2;2,0-5

                    for (int d = 0; d < zxys.GetLength(0); d++)
                    {
                        zx_x = zxys[d].Split(dcc);
                        if (zx_x.GetLength(0) > 1)
                        {
                            for (int h = 1; h < zx_x.GetLength(0); h++)
                            {
                                x_x = zx_x[h].Split(hcc);

                                if (x_x.GetLength(0) > 1)
                                {
                                    if ((Convert.ToInt32(zx_x[0]) == startZ) && (startX >= Convert.ToInt32(x_x[0])) && (startX <= Convert.ToInt32(x_x[1])))
                                    {
                                        Getdevice = Convert.ToInt32(dv[i]["F_StackIndex"]);
                                    }
                                    if ((Convert.ToInt32(zx_x[0]) == endZ) && (endX >= Convert.ToInt32(x_x[0])) && (endX <= Convert.ToInt32(x_x[1])))
                                    {
                                        Sendevice = Convert.ToInt32(dv[i]["F_StackIndex"]);
                                    }
                                }
                            }
                        }
                    }
                }
                stackno = Getdevice;
                if (Getdevice != Sendevice)
                {
                    devinfo = Model.CGetInfo.GetDeviceInfo(Getdevice);
                    if (Sendevice == devinfo.VirtualStack)
                    {
                        IfCombinedWork = true;
                    }
                    else
                    {
                        IfCombinedWork = false;
                    }
                }
                else
                {
                    IfCombinedWork = false;
                }
            }
            catch (Exception ex)
            {
                CControlError = "分配堆垛机号GetSpecialStackNo:" + ex.StackTrace+ex.Message ;
            }
            finally
            {

            }
        }

        int GetPRIStackNo(int virStack, int startZ, int startX, int endZ, int endX)
        {
            int Getdevice = 0;
            char[] fcc = new char[1] { ';' };
            char[] dcc = new char[1] { ',' };
            char[] hcc = new char[1] { '-' };
            DataView dv=new DataView();

            string[] zxys; string[] zx_x; string[] x_x;
            try
            {
                dv = dbo.ExceSQL(string.Format("SELECT T_Base_StackInfo.F_StackIndex, T_Base_StackInfo.F_SpecialZXArea,T_Base_StackInfo.F_PRIZXArea FROM T_Base_StackInfo WHERE T_Base_StackInfo.F_Mutex IS NOT NULL and T_Base_StackInfo.F_VirtualStack={0}", virStack)).Tables[0].DefaultView;


                for (int i = 0; i < dv.Count; i++)
                {
                    zxys = dv[i]["F_PRIZXArea"].ToString().Split(fcc);//1,0-2;2,0-5

                    for (int d = 0; d < zxys.GetLength(0); d++)
                    {
                        zx_x = zxys[d].Split(dcc);
                        if (zx_x.GetLength(0) > 1)
                        {
                            for (int h = 1; h < zx_x.GetLength(0); h++)
                            {
                                x_x = zx_x[h].Split(hcc);

                                if (x_x.GetLength(0) > 1)
                                {
                                    if ((Convert.ToInt32(zx_x[0]) == startZ) && (startX >= Convert.ToInt32(x_x[0])) && (startX <= Convert.ToInt32(x_x[1])))
                                    {
                                        Getdevice = Convert.ToInt32(dv[i]["F_StackIndex"]);
                                    }

                                }
                            }
                        }
                    }
                }
                return Getdevice;
            }
            catch (Exception ex)
            {
                CControlError = "分配堆垛机号GetPRIStackNo:" + ex.StackTrace+ex.Message ;
                return Getdevice;
            }
            finally
            {
                dv.Dispose();

            }
            
        }
        /// <summary>
        /// 获取可关联的任务进行配多叉关联
        /// </summary>
        /// <param name="DevLanewayIOInfo">巷道出入口信息</param>
        /// <param name="TaskIdx">设备指令索引</param>
        /// <param name="CONTROLTASKTYPE">控制任务类型</param>
        /// <param name="mti">控制任务类别</param>
        /// <param name="fid">控制任务编号</param>
        /// <param name="dtime">当前时间</param>
        /// <returns></returns>
        bool GetCorrManageTask(string[] DevLanewayIOInfo, int TaskIdx, int CONTROLTASKTYPE,int mti,int fid,string dtime,out bool IfCorrTaskEnd)
        {
            IfCorrTaskEnd = false;
            DataView dv = new DataView();
            try
            {
                sql.Remove(0, sql.Length);//输送机等待双叉任务号等于堆垛机取货TaskIdx
                sql.Append("SELECT F_TaskIndex,F_DeviceIndex,F_Remark FROM T_Base_PLC_Ask WHERE (F_TaskIndex =").Append(Convert.ToInt32(TaskIdx)).Append(") AND (F_Remark is not null) AND (F_DeviceIndex=").Append(DevLanewayIOInfo[0]).Append(")");
                dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    #region 有任务等待关联任务

                    string zxy = DevLanewayIOInfo[9];
                    int waitdevice = Convert.ToInt32(dv[0]["F_DeviceIndex"]);
                    //DevLanewayIOInfo[8]包含多个关联设备信息逐一检查20120906
                    char[] cc = new char[1] { ';' };
                    string[] CorrStations = DevLanewayIOInfo[8].Split(cc);
                    foreach (string cs in CorrStations)
                    {
                        DevLanewayIOInfo = ccf.GetLanewayDeviceInfoFromStackDev(devinfo.DeviceIndex, Convert.ToInt32(cs));//关联站台的信息
                        string Correlzxy = DevLanewayIOInfo[9];
                        DateTime dtq = Convert.ToDateTime(dv[0]["F_Remark"]).AddSeconds(Convert.ToInt32(CStaticClass.DoubleForkWaitTime));
                        if ((GetIOControlStatus(TaskIdx) != Model.CGeneralFunction.TASKSINGLEFORKRUN) && (dtq > DateTime.Now))
                        {
                            #region 没超时,不是单叉运行

                            //20111231没超时,不是单叉运行
                            //查找本地管理任务做多叉关联配对，关联任务分配货叉
                            int mfid = GetEnableDoubleForkManageTask(CONTROLTASKTYPE, devinfo.DeviceIndex, int.Parse(DevLanewayIOInfo[0]), fid);
                            if (mfid > 0)
                            {
                                #region 双叉同为前极限后者后极限不关联，单独执行
                                if ((IfInSameLimitX(fid, mfid, mti) == true) && (mti == 1))
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(fid).Append(")");
                                    dboM.ExecuteSql(sql.ToString());
                                    sql.Remove(0, sql.Length);
                                    sql.Append(" update IO_CONTROL set CONTROL_STATUS=").Append(Model.CGeneralFunction.TASKSINGLEFORKRUN).Append(" WHERE (CONTROL_ID = ").Append(mfid).Append(")");
                                    dboM.ExecuteSql(sql.ToString());
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("单叉执行原因", TaskIdx.ToString(), devinfo.DeviceIndex.ToString(), "双叉同为前极限后者后极限不关联，单独执行");
                                    IfCorrTaskEnd = true;
                                    return true;
                                }
                                #endregion

                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(fid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
                                dbo.ExecuteSql(sql.ToString());
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Manage_Task set F_RELATIVECONTORLID=").Append(fid).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(mfid);
                                dbo.ExecuteSql(sql.ToString());
                                //判断是否为1叉的关联任务:是，配叉结束
                                if (ccf.GetManageTaskStackFork(mti, mfid) == "1")
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update T_Base_PLC_Ask set F_Remark='' where (F_TaskIndex=").Append(TaskIdx).Append(")");
                                    dbo.ExecuteSql(sql.ToString());
                                    IfCorrTaskEnd = true;
                                }
                                continue;
                            }
                            else
                            {
                                //20110505
                                AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "双叉堆垛机等待多叉关联取货任务！");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, TaskIdx);
                                continue;
                            }

                            #endregion
                        }
                        else
                        {
                            #region 20111230单叉执行极限货位需要倒货叉
                            #region 堆垛机在顶升机取单叉任务，验证是否需要换货叉
                            string ChangeForkCell = ccf.IfLimitCellChangeFork(TaskIdx, devinfo.DeviceIndex);

                            if (ChangeForkCell != "-")//主任务需要倒换货叉
                            {
                                ccf.ChangeEndCellCode(TaskIdx, ChangeForkCell, devinfo.DeviceIndex);
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=0,F_Remark='' where (F_DeviceIndex=").Append(waitdevice).Append(")");
                                dbo.ExecuteSql(sql.ToString());
                                CommonClassLib.CCarryConvert.WriteDarkCasket("单叉执行原因", TaskIdx.ToString(), devinfo.DeviceIndex.ToString(), "主任务需要倒换货叉");
                                IfCorrTaskEnd = true;
                                return true;
                            }
                            #endregion
                            #endregion

                            if ((IFHaveStackCorrelGetCommand(devinfo.DeviceIndex, zxy, Correlzxy, TaskIdx) == true) && (GetIOControlStatus(TaskIdx) != Model.CGeneralFunction.TASKSINGLEFORKRUN))//20101124
                            {//队列中有可以关联的任务，重新计时
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_Remark='").Append(dtime).Append("' where (F_DeviceIndex=").Append(waitdevice).Append(")");
                                dbo.ExecuteSql(sql.ToString());
                                //20110505
                                AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "双叉堆垛机在双叉对等站台取货" + "，等待多叉关联任务！");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, TaskIdx);
                                return false;
                            }
                            else
                            {//超时或者管理强制执行单叉任务
                                sql.Remove(0, sql.Length);
                                sql.Append("update T_Base_PLC_Ask set F_TaskIndex=0,F_Remark='' where (F_DeviceIndex=").Append(waitdevice).Append(")");
                                dbo.ExecuteSql(sql.ToString());
                                CommonClassLib.CCarryConvert.WriteDarkCasket("单叉执行原因", TaskIdx.ToString(), devinfo.DeviceIndex.ToString(), "超时或者管理强制执行单叉任务");
                                IfCorrTaskEnd = true;
                                return true;
                            }

                        }
                    }
                    #endregion
                }
                return false;
            }
            catch (Exception ex)
            {
                CControlError = "获取堆垛机关联配叉GetCorrManageTask:"+ex.StackTrace+ex.Message ;
                return false;
            }
            finally
            {
                dv.Dispose();
            }
        }
    }
}