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;
using System.Drawing;
using System.Net;
using System.Security.Cryptography;

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;
        int safe_distance = Convert.ToInt32(CommonClassLib.AppSettings.GetValue("Safe_distance"));
        int WaitSetDoubleForkTime = Convert.ToInt32(CommonClassLib.AppSettings.GetValue("WaitSetDoubleForkTime"));
        string Lasttask = "24101,24102,24103,24104,24105,24106,24107,24108,24109,24110,24111,24112,24113,24114,24115";
        string RgvNoallow = "12402,12404,12406,12408,12410,12412,12414,12416,12418,12420,12422,12424,12426,12430";
        string StackerNoallow = "11101,11102,11103,11104,11105,11106,11107,11108,11109,11110,11111,11112,11113,11114";
        string GroupEndDevice = "22076,22051,22001,22110,22082,22101,22060,22032,22026,22010";

        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_SplitTime asc, F_ManageTaskIndex 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 ((_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + _ManageTaskIdx.ToString()) || (_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + relfid.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)//提前检测通过
                        {
                            //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判断
                            //        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();
            }
        }


        int Get_F_LockedState(int DeviceIndex)
        {
            int ManTaskReserve = 0;
            DataView dvdv = new DataView();
            sql.Remove(0, sql.Length);
            sql.Append("SELECT F_DeviceIndex, F_LockedState,F_ManTaskReserve FROM T_Base_Device where F_DeviceIndex=").Append(DeviceIndex);
            dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
            if (dvdv.Count > 0)
            {
                if (Convert.ToString(dvdv[0]["F_LockedState"]) != "" && Convert.ToString(dvdv[0]["F_LockedState"]) != null)
                {
                    ManTaskReserve = Convert.ToInt32(dvdv[0]["F_LockedState"]);
                }
                else
                {
                    ManTaskReserve = 0;
                }
            }
            else
            {
                ManTaskReserve = 0;
            }
            return ManTaskReserve;
        }

        /// <summary>
        /// 查询此设备是否有大于等于已发送状态的任务
        /// </summary>
        /// <param name="StackdeviceIndex"></param>
        /// <param name="XcoorS">取货位</param>
        /// <param name="ZcoorE">送货位</param>
        void GetStackRunX_Zcoor(int StackdeviceIndex, out int XcoorE)
        {//20111020
            DataView dv = new DataView();
            try
            {
                //XcoorS = 0;
                XcoorE = 0;
                sql = new StringBuilder(string.Format("SELECT F_DeviceCommandIndex,F_NumParam1,  F_NumParam4, F_Status 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() == "7"))//取货、运动
                    {
                        //XcoorS = Convert.ToInt32(dv[0]["F_NumParam1"]);
                        XcoorE = Convert.ToInt32(dv[0]["F_NumParam1"]);
                    }
                    else if (dv[0]["F_DeviceCommandIndex"].ToString() == "3")//送货
                    {
                        //XcoorS = Convert.ToInt32(dv[0]["F_NumParam1"]);
                        XcoorE = Convert.ToInt32(dv[0]["F_NumParam4"]);
                    }

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

        }

        /// <summary>
        /// 检测指定设备命令的执行先决条件是否成立
        /// </summary>
        /// <param name="minMidx">设备指令索引T_MONITOR_TASK主键</param>
        /// <returns>是否检测通过，true表示设备执行命令的先决条件成立</returns>
        public bool AheadDetectOK(int minMidx, string _AheadDetect)
        {
            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 controltype = ccf.GetManageTaskTypefromMonitor(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();
            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));
                            Model.MDevice tempdevice = Model.CGetInfo.GetDeviceInfo(idev);
                            if (tempdevice.DeviceIndex == tempdevice.VirtualStack)//添加虚拟设备不检测空闲
                            {
                                continue;
                            }
                            if (tempdevice.DeviceIndex == tempdevice.VirtualStack)//添加虚拟设备不检测空闲
                            {
                                continue;
                            }
                            if (idev.ToString().Length == 6)
                            {
                                idev = Convert.ToInt32(idev.ToString());
                            }
                            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)));//gjn
                                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 检测积放线正在执行任务个数

                        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;
                            }
                            Model.MDevice tempdevice = Model.CGetInfo.GetDeviceInfo(DeviceIndex);
                            if (tempdevice.DeviceIndex == tempdevice.VirtualStack)//添加虚拟设备不检测有无货
                            {
                                continue;
                            }

                            //int DeviceIndext = 0;
                            //if (devicebyte < 0)
                            //{
                            //    DeviceIndext = 0 - devicebyte;
                            //}
                            //else
                            //{
                            //    DeviceIndext = devicebyte;
                            //}
                            //tempdevice = Model.CGetInfo.GetDeviceInfo(DeviceIndext);
                            //if (tempdevice.DeviceIndex == tempdevice.VirtualStack)//添加虚拟设备不检测有无货
                            //{
                            //    continue;
                            //}
                            //判断是否检测负数索引值（负数代表是否满足开关量＝１的执行前提）
                            if (devicebyte < 0)
                            {
                                #region 负数代表值为１的开关量检测
                                devinfocheck = Model.CGetInfo.GetDeviceInfo(-devicebyte);
                                if(devinfocheck != null)
                                {
                                    int 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 = 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)&&(controltype!=2))//gjn
                    {
                        string monbarcode = ccf.GetBarCodeFromMonitor(minMidx);
                        if ((obr.ToString().IndexOf(monbarcode) < 0) && (monbarcode.IndexOf(obr.ToString()) < 0))
                        {
                            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任务正在执行（直穿多个接力取送货任务和环穿单个取送货任务）

                                AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "反向任务在执行等待");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                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放货输送线
                                        AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "反向任务在执行等待");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                        return false;
                                    }
                                }
                               
                            }
                        }
                    }
                }
                # endregion

                #region RGV入库指令判断卸货输送机出库指令
                else if ((DeviceKind == 13) && ccf.GetFCONTROLTASKTYPEFromManageTask(mti, fid) == 1)//DeviceKind == 4 || 
                {//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)
                        {//本巷道出库的堆垛机或者送出至卸货输送机的管理任务正在执行
                            AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "反向任务在执行等待");
                            UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                            return false;
                        }
                    }
                }
                #endregion
                #endregion
                #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 = 10000;//gjn 实际电器安全距离8000 
                //    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<>{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"]));
                //                int mutexDeviceLockedState = ccf.GetDeviceLockedState(devinfocheck.DeviceIndex);
                //                if (mutexDeviceLockedState == -1) return true;
                //                int mutexManTaskReserve = ccf.GetManTaskReserve(devinfocheck.DeviceIndex);
                //                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);
                //                            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);//mutexConveyor查找到的避让位置gjn
                //                            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, DeviceIdx, 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)
                //                                {
                //                                    return false;
                //                                }
                //                            }
                //                            else
                //                            {//避让车地址小于当前车，而且在目标位置范围内
                //                                if (rgvAddr - rgvSecuritydistance < mutRgvAddr)
                //                                {
                //                                    return false;
                //                                }
                //                            }
                //                        }


                //                    }

                //                }
                //            }
                //            if (ifInsert == true)
                //            {
                //                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 = 0;
                        int newZMonitor = 0;
                        int tempZ = 0;
                        #region 1,4排远位取货时，要判读是否有进位的取货任务
                        tempZ =zxy[0];
                        if (tempZ == 1 || tempZ == 4)//远位取货时，要判读是否有进位的取货任务
                        {//获取外位坐标
                            if (tempZ == 1)
                            {//1->2
                                newZ = getZ + 1;
                                newZMonitor = 2;
                            }
                            else
                            {//4->3
                                newZ = getZ - 1;
                                newZMonitor = 3;
                            }
                            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}) ", newZMonitor, zxy[1], zxy[2], DeviceIdx, fid);//and (f_managetaskindex != {4})
                            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;
                                newZMonitor = 1;
                            }
                            else
                            {
                                newZ = sendZ + 1;
                                newZMonitor = 4;
                            }
                            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);
                            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}) ", newZMonitor, zxy[4], zxy[5], DeviceIdx, fid);//and (f_managetaskindex != {4})
                            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.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,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());
                }
            }
            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());
               // dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0}.0,{0}.1)  WHERE (F_MONITORINDEX= {1}) ", realRGV1));
                
                
                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;
            }
        }

        /// <summary>
        /// 
        /// </summary>发送任务时置关联及置关联分配货叉
        /// <param name="DeviceRgv"></param>
        /// <param name="mti"></param>
        /// <param name="fid"></param>
        /// <param name="monitor"></param>
        /// <param name="forkNO"></param>
        /// <param name="correlFid"></param>
        /// <param name="correlmonitor"></param>
        /// <param name="correlForkNO"></param>
        private void SetRgvCorrelManageTaskNEW(int DeviceRgv,int mti, int fid,int monitor,int forkNO, int correlFid,int correlmonitor, int correlForkNO)
        {//一个管理任务号作为大家的关联任务号,编号小站台是1叉，编号大站台是2叉
            try
            {
                if (correlForkNO == 2)
                {
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15401.0','15401.1')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15401)", mti, correlFid));
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15402.0','15402.1')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15402)", mti, correlFid));
                }
                if (correlForkNO == 1)
                {
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15401.1','15401.0')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15401)", mti, correlFid));
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15402.1','15402.0')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15402)", mti, correlFid));
                }

                if (forkNO == 2)
                {
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15401.0','15401.1')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15401)", mti, fid));
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15402.0','15402.1')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15402)", mti, fid));
                }
                if (forkNO == 1)
                {
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15401.1','15401.0')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15401)", mti, fid));
                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'15402.1','15402.0')  WHERE (F_ManageTASKKINDINDEX= {0} AND F_ManageTaskIndex= {1} and f_deviceindex = 15402)", mti, fid));
                }
                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());

                CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "发送置关联：", correlFid.ToString(), fid.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 Channel)
        {
            //DataView dvt = new DataView();
            DataView dvgjn = new DataView();
            try
            {
                sql.Remove(0, sql.Length);
                sql.Append("select  f_address  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(xcoor).Append(" and   f_channelsindex = ").Append(Channel);//ORDER BY  desc, asc
                dvgjn = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                //dvgjn = dbo.ExceSQL(string.Format("SELECT f_address FROM T_BASE_RGV_GATE WHERE f_rgvgatedeviceindex = {0} and f_channelsindex = {1})", xcoor, Channel)).Tables[0].DefaultView;
                if (dvgjn.Count > 0)
                {
                    return Convert.ToInt32(dvgjn[0]["f_address"]);
                }
                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
            {
                dvgjn.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>
        ///// 分配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  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;
        //            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 (N1rgv == N4rgv)
        //                {//一台车跑任务全程，直接分配RGV编号,修改提前检测
        //                    SetRGVNo(deviceIdx, N1rgv, monIndex, numP4, numP4, 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);
        //                }
        //                return;
        //            }

        //        }
        //    }

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

        //    }
        //    finally
        //    {

        //    }
        //}
        /// <summary>
        /// 按没更新的取货指令的取送货位置确定经过几段区域、判断添加任务和替换车辆，并添加好提前检测，前面任务要完全检测整个行程的各个输送线有无货和状态
        /// </summary>
        /// <param name="deviceIdx">虚拟RGV</param>
        /// <param name="minMidx">设备指令索引T_MONITOR_TASK主键</param>
        /// <param name="manageKindIdx">管理任务类型</param>
        /// <param name="manageTaskIdx">管理任务索引</param>
        ///  <param name="managetasktype">管理任务索引</param>入库1 出库2 //站台移库4没有
        public string  ChangeDisassembleRGVTask(int deviceIdx, int minMidx, int manageKindIdx, int manageTaskIdx,int managetasktype)
        {
            DataView dvmon = new DataView(); DataView dvsendold = new DataView(); DataView dvfork = new DataView();
            try
            {
                string returnnum = "0";
                int numP1 = 0, numP4 = 0;int numP1Adress = 0, numP4Adress = 0;
                int UseableMonindex = 0;

                int fork = 0;//后续测试应该没用
                dvfork = dbo.ExceSQL(string.Format("select f_useawayfork  from T_MONITOR_TASK where F_MONITORINDEX={0}", minMidx)).Tables[0].DefaultView;
                if (dvfork.Count > 0)
                {
                    fork = Convert.ToInt32(dvfork[0]["f_useawayfork"]);
                }

                //查询出原来的送货
                dvsendold = dbo.ExceSQL(string.Format("select F_MONITORINDEX  from T_MONITOR_TASK where f_managetaskindex={0} and F_DeviceIndex = {1} and F_MONITORINDEX != {2}", manageTaskIdx, deviceIdx, minMidx)).Tables[0].DefaultView;
                dvmon = dbo.ExceSQL(string.Format("select F_NUMPARAM1,F_NUMPARAM4,f_txtparam,F_PRIORMONITOR,F_AGVNO,F_AGVTASK,F_AGVNEXTTASK  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 dvStartadress = dbo.ExceSQL(string.Format("select f_address,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX = {0}", numP1)).Tables[0].DefaultView;
                    DataView dvEndadress = dbo.ExceSQL(string.Format("select f_address,F_INPUT,F_OUTPUT from T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX = {0}", numP4)).Tables[0].DefaultView;
                    if (dvStartadress.Count > 0 && dvEndadress.Count > 0)
                    {
                        numP1Adress = Convert.ToInt32(dvStartadress[0]["f_address"]);
                        numP4Adress = Convert.ToInt32(dvEndadress[0]["f_address"]);
                        DataView dvScope = dbo.ExceSQL(string.Format("select F_INPUT, F_OUTPUT, f_iftransfer, F_NEARGETDEVICE, MAX(F_INPUT) from T_BASE_RGV_GATE where f_channelsindex = {2} and ((f_address <= {0} and f_address>= {1}) or (f_address >= {0} and f_address<= {1})) and F_INPUT != F_OUTPUT group by F_INPUT,F_OUTPUT,f_iftransfer,F_NEARGETDEVICE  order by F_NEARGETDEVICE", Convert.ToInt32(dvStartadress[0]["f_address"]), Convert.ToInt32(dvEndadress[0]["f_address"]), deviceIdx)).Tables[0].DefaultView;
                        if (dvScope.Count > 0)//从小到大查出所用中转区域，本项目先查出4个中转站台那区域
                        {
                            if (dvScope.Count == 1)//两车跑全程
                            {
                                //for (int i = minMidx + 1; i < minMidx + 8; 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, minMidx);
                                //    return "两车运行分配转运站台时没找到可用的连续任务号";
                                //}
                                int nom1 = Convert.ToInt32(dvmon[0]["F_PRIORMONITOR"]);
                                int nom2 = Convert.ToInt32(dvmon[0]["F_AGVNO"]);
                                int nom3 = Convert.ToInt32(dvmon[0]["F_AGVTASK"]);
                                int nom4 = Convert.ToInt32(dvmon[0]["F_AGVNEXTTASK"]);

                                int realRGV1 = Convert.ToInt32(dvStartadress[0]["F_INPUT"]);
                                int realRGV2 = 0;
                                int TransferStation = 0;
                                string barcode = Convert.ToString(dvmon[0]["f_txtparam"]);
                                if (numP1Adress > numP4Adress)
                                {
                                    realRGV2 = Convert.ToInt32(dvScope[0]["F_INPUT"]);
                                }
                                else
                                {
                                    realRGV2 = Convert.ToInt32(dvScope[0]["F_OUTPUT"]);
                                }
                                //中转站台选择
                                DataView dvtransferStation;
                                if (managetasktype == 2)
                                {
                                    dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex asc", Convert.ToInt32(dvScope[0]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                }
                                else
                                {
                                    dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex desc", Convert.ToInt32(dvScope[0]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                }
  
                                for (int j = 0; j < dvtransferStation.Count; j++)
                                {
                                    Model.MDevice devinfoTranferstation = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvtransferStation[j]["f_rgvgatedeviceindex"]));
                                    DataView dvSelectCount = dbo.ExceSQL(string.Format("select *  from T_MONITOR_TASK where (F_NUMPARAM1 = {0} and f_devicecommandindex = 2) or (F_NUMPARAM4 = {0} and f_devicecommandindex = 3)", Convert.ToInt32(dvtransferStation[j]["f_rgvgatedeviceindex"]))).Tables[0].DefaultView;
                                    //if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 < tempcount)//后面细想有货和任务不同站台选择方式
                                    //{
                                    //    tempcount = dvSelectCount.Count + devinfoTranferstation.SplitByte_0;
                                    //    TransferStation = Convert.ToInt32(dvtransferStation[j]["f_rgvgatedeviceindex"]);
                                    //}
                                    if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 >0)//后面细想有货和任务不同站台选择方式
                                    {
                                        continue;
                                    }
                                    else
                                    {
                                        TransferStation = Convert.ToInt32(dvtransferStation[j]["f_rgvgatedeviceindex"]);
                                        break;
                                    }

                                }
                                if(TransferStation == 0)
                                {
                                    return "两车运行时无中转站台可用";
                                }

                                //更新第一条原来的取货
                                int routeidsub = ccf.GetRouteIDsub(realRGV1);//取得当前RGV1所在特殊路径不是原来路径
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},F_NumParam4 = {5},f_goalconveyor={2} WHERE F_DeviceIndex = {4} and F_MONITORINDEX = {3}", realRGV1, routeidsub, numP4, minMidx, deviceIdx, TransferStation));
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", deviceIdx, realRGV1, minMidx));
                                if (fork == 2)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0}.0,{0}.1)  WHERE (F_MONITORINDEX= {1}) ", realRGV1, minMidx));
                                }
                                StringBuilder AheadDetect = new StringBuilder();
                                AheadDetect.Clear();
                                AheadDetect.Append(";D").Append(TransferStation.ToString() + ".0").Append(";I").Append(TransferStation);
                                sql.Clear();
                                sql.Append("update T_Monitor_Task set ").Append("F_AheadDetect=F_AheadDetect||'").Append(AheadDetect.ToString()).Append("' where F_MonitorIndex=").Append(minMidx);
                                dbo.ExceSQL(sql.ToString());

                                ////插入第一个送货                                                              
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV1, UseableMonindex + 1, numP1, TransferStation, numP4, fork);
                                ////插入第一个取货
                                //routeidsub = ccf.GetRouteIDsub(realRGV2);//取得当前RGV2所在特殊路径不是原来路径
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV2, UseableMonindex + 2, TransferStation, numP4, numP4, fork);
                                
                                //插入第一个送货                                                              
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV1, nom1, numP1, TransferStation, numP4, fork);
                                //插入第一个取货
                                routeidsub = ccf.GetRouteIDsub(realRGV2);//取得当前RGV2所在特殊路径不是原来路径
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV2, nom2, TransferStation, numP4, numP4, fork);



                                //更新原有送货现在变成最后一条送货
                                if (dvsendold.Count > 0)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},F_NumParam1 = {5},f_goalconveyor={2} WHERE F_DeviceIndex = {4} and F_MONITORINDEX = {3}", realRGV2, routeidsub, numP4, Convert.ToInt32(dvsendold[0]["F_MONITORINDEX"]), deviceIdx, TransferStation));
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", deviceIdx, realRGV2, Convert.ToInt32(dvsendold[0]["F_MONITORINDEX"])));
                                }
                                returnnum = "1";
                            }
                            else if (dvScope.Count == 2)//三车跑全程
                            {
                                //for (int i = minMidx + 1; i < minMidx + 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;
                                //        break;
                                //    }

                                //}
                                //if (UseableMonindex == 0)
                                //{
                                //    //AheadDetectUnallow.Clear();
                                //    //AheadDetectUnallow.Append("分配转运站台时没找到可用的连续任务号");
                                //    //UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
                                //    return "3车运行时分配转运站台时没找到可用的连续任务号";
                                //}

                                int nom1 = Convert.ToInt32(dvmon[0]["F_PRIORMONITOR"]);
                                int nom2 = Convert.ToInt32(dvmon[0]["F_AGVNO"]);
                                int nom3 = Convert.ToInt32(dvmon[0]["F_AGVTASK"]);
                                int nom4 = Convert.ToInt32(dvmon[0]["F_AGVNEXTTASK"]);

                                int realRGV1 = Convert.ToInt32(dvStartadress[0]["F_INPUT"]);
                                int realRGV2 = 0;int realRGV3 = 0;
                                int[] TransferStation = {0,0};
                                string barcode = Convert.ToString(dvmon[0]["f_txtparam"]);
                                if (numP1Adress > numP4Adress)//出库
                                {
                                    realRGV2 = Convert.ToInt32(dvScope[1]["F_INPUT"]);
                                    realRGV3 = Convert.ToInt32(dvScope[0]["F_INPUT"]);
                                    //中转站台选择
                                    for (int j = 1; j > -1; j--)
                                    {
                                       // DataView dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0}", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        DataView dvtransferStation;
                                        if (managetasktype == 2)
                                        {
                                            dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex asc", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        }
                                        else
                                        {
                                            dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex desc", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        }


                                        //int tempcount = 9999999;
                                        for (int n = 0; n < dvtransferStation.Count; n++)
                                        {
                                            Model.MDevice devinfoTranferstation = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]));
                                            DataView dvSelectCount = dbo.ExceSQL(string.Format("select *  from T_MONITOR_TASK where  (F_NUMPARAM1 = {0} and f_devicecommandindex = 2) or (F_NUMPARAM4 = {0} and f_devicecommandindex = 3)", Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]))).Tables[0].DefaultView;
                                            //if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 < tempcount)//后面细想有货和任务不同站台选择方式
                                            //{
                                            //    tempcount = dvSelectCount.Count + devinfoTranferstation.SplitByte_0;
                                            //    TransferStation[1 - j] = Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]);
                                            //}
                                            if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 > 0)//后面细想有货和任务不同站台选择方式
                                            {
                                                continue;
                                            }
                                            else
                                            {
                                                TransferStation[1 - j] = Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]);
                                            }
                                        }
                                    }
                                }
                                else//入库
                                {
                                    realRGV2 = Convert.ToInt32(dvScope[0]["F_OUTPUT"]);
                                    realRGV3 = Convert.ToInt32(dvScope[1]["F_OUTPUT"]);
                                    //中转站台选择
                                    for (int j = 0; j<dvScope.Count; j++)
                                    {
                                        //DataView dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0}", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        DataView dvtransferStation;
                                        if (managetasktype == 2)
                                        {
                                            dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex asc", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        }
                                        else
                                        {
                                            dvtransferStation = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex from T_BASE_RGV_GATE where F_NEARGETDEVICE = {0} order by f_rgvgatedeviceindex desc", Convert.ToInt32(dvScope[j]["F_NEARGETDEVICE"]))).Tables[0].DefaultView;
                                        }

                                        //int tempcount = 9999999;
                                        for (int n = 0; n < dvtransferStation.Count; n++)
                                        {
                                            Model.MDevice devinfoTranferstation = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]));
                                            DataView dvSelectCount = dbo.ExceSQL(string.Format("select *  from T_MONITOR_TASK where (F_NUMPARAM1 = {0} and f_devicecommandindex = 2) or (F_NUMPARAM4 = {0} and f_devicecommandindex = 3)", Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]))).Tables[0].DefaultView;
                                            //if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 < tempcount)//后面细想有货和任务不同站台选择方式
                                            //{
                                            //    tempcount = dvSelectCount.Count + devinfoTranferstation.SplitByte_0;
                                            //    TransferStation[j] = Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]);
                                            //}
                                            if (dvSelectCount.Count + devinfoTranferstation.SplitByte_0 > 0)//后面细想有货和任务不同站台选择方式
                                            {
                                                continue;
                                            }
                                            else
                                            {
                                                TransferStation[j] = Convert.ToInt32(dvtransferStation[n]["f_rgvgatedeviceindex"]);
                                            }
                                        }
                                    }
                                }
                                if (TransferStation[0] == 0 || TransferStation[1] == 0)
                                {
                                    return "三车运行时无连续可用中转站台";
                                }
                                //更新第一条原来的取货
                                int routeidsub = ccf.GetRouteIDsub(realRGV1);//取得当前RGV1所在特殊路径不是原来路径
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},F_NumParam4 = {5},f_goalconveyor={2} WHERE F_DeviceIndex = {4} and F_MONITORINDEX = {3}", realRGV1, routeidsub, numP4, minMidx, deviceIdx, TransferStation[0]));
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", deviceIdx, realRGV1, minMidx));
                                StringBuilder AheadDetect = new StringBuilder();
                                AheadDetect.Clear();
                                AheadDetect.Append(";D").Append(TransferStation[0].ToString() + ".0").Append(";I").Append(TransferStation[0]).Append(";D").Append(TransferStation[1].ToString() + ".0").Append(";I").Append(TransferStation[1]);
                                sql.Clear();
                                sql.Append("update T_Monitor_Task set ").Append("F_AheadDetect=F_AheadDetect||'").Append(AheadDetect.ToString()).Append("' where F_MonitorIndex=").Append(minMidx);
                                dbo.ExceSQL(sql.ToString());
                                ////插入第一个送货                                                              
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV1, UseableMonindex + 1, numP1, TransferStation[0], numP4, fork);
                                ////插入第一个取货
                                //routeidsub = ccf.GetRouteIDsub(realRGV2);//取得当前RGV2所在特殊路径不是原来路径
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV2, UseableMonindex + 2, TransferStation[0], TransferStation[1], numP4, fork);
                                ////插入第二个送货
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV2, UseableMonindex + 3, TransferStation[0], TransferStation[1], numP4, fork);
                                ////插入第二个取货
                                //routeidsub = ccf.GetRouteIDsub(realRGV3);//取得当前RGV3所在特殊路径不是原来路径
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV3, UseableMonindex + 4, TransferStation[1], numP4, numP4, fork);

                                //插入第一个送货                                                              
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV1, UseableMonindex + 1, numP1, TransferStation[0], numP4, fork);
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV1, nom1, numP1, TransferStation[0], numP4, fork);
                                //插入第一个取货
                                routeidsub = ccf.GetRouteIDsub(realRGV2);//取得当前RGV2所在特殊路径不是原来路径
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV2, UseableMonindex + 2, TransferStation[0], TransferStation[1], numP4, fork);
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV2, nom2, TransferStation[0], TransferStation[1], numP4, fork);
                                //插入第二个送货
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV2, UseableMonindex + 3, TransferStation[0], TransferStation[1], numP4, fork);
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "unload", realRGV2, nom3, TransferStation[0], TransferStation[1], numP4, fork);
                                //插入第二个取货
                                routeidsub = ccf.GetRouteIDsub(realRGV3);//取得当前RGV3所在特殊路径不是原来路径
                                //InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV3, UseableMonindex + 4, TransferStation[1], numP4, numP4, fork);
                                InsertRgvLoadUnloadTask(manageKindIdx, manageTaskIdx, barcode, routeidsub, "load", realRGV3, nom4, TransferStation[1], numP4, numP4, fork);


                                //更新原有送货现在变成最后一条送货
                                if (dvsendold.Count > 0)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},F_NumParam1 = {5},f_goalconveyor={2} WHERE F_DeviceIndex = {4} and F_MONITORINDEX = {3}", realRGV3, routeidsub, numP4, Convert.ToInt32(dvsendold[0]["F_MONITORINDEX"]), deviceIdx, TransferStation[1]));
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", deviceIdx, realRGV3, Convert.ToInt32(dvsendold[0]["F_MONITORINDEX"])));
                                }
                                returnnum = "1";
                            }
                            else
                            {
                                returnnum = "非单车运行全程，查询使用中转站台数量不符"; ;
                            }
                        }
                        else
                        {
                            if (dvScope.Count == 0)//单车跑全程
                            {
                                int realRGV = Convert.ToInt32(dvStartadress[0]["F_INPUT"]);
                                //更新实际RGV车号F_DeviceIndex，子路径编号f_routeid
                                int routeidsub = ccf.GetRouteIDsub(realRGV);
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},f_goalconveyor={2} WHERE F_DeviceIndex = {4} and f_managetaskindex = {3}", realRGV, routeidsub, numP4, manageTaskIdx, deviceIdx));
                                //更新RGV本身的提前监测
                                object[] ob = new object[3] { deviceIdx, realRGV, minMidx };
                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,{0},{1})  WHERE (F_MONITORINDEX= {2}) ", ob));

                                returnnum = "1";
                            }
                            else
                            {
                                returnnum = "单车运行时查询中转站台数量不符";;
                            }
                        }
                    }
                    else
                    {
                        returnnum = "起始点坐标无法查询出对应码值"; ;
                    }
                }
                return returnnum;
            }
            catch (Exception ex)
            {
                CControlError = string.Format("CControl.AssignRGVIndex分配RGV车号：{0}", ex.StackTrace + ex.Message);
                return "选车报错";
            }
        }

        public int GetUseForkfrommonitor(int monitorIndex)
        {
            DataView dvcorrl = dbo.ExceSQL(string.Format("SELECT F_UseAwayFork FROM T_Monitor_Task WHERE (F_MonitorIndex = {0})", monitorIndex)).Tables[0].DefaultView;//F_CORRELDEVICEINDEX != {1} and

            if (dvcorrl.Count > 0)
            {
                return Convert.ToInt32(dvcorrl[0]["F_UseAwayFork"]);
            }
            else
            {
                return 0;
            }
        }

        int GetRouteIDsub(int device)
        {
            DataView dv = new DataView();
            try
            {
                dv = dbo.ExceSQL("SELECT F_RouteIDSub, F_DeviceIndex, F_RouteID FROM T_Base_Route_Device where F_DeviceIndex=" + device + "").Tables[0].DefaultView;
                if (dv.Count > 0)
                {
                    return Convert.ToInt32(dv[0]["F_RouteIDSub"]);
                }
                else
                {
                    return -1;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dv.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;
                    }
                    #region 安全门锁控制
                    if ((deviceKind == 1) ||(deviceKind == 4 && deviceIdx != devinfo.VirtualStack))
                    {
                        Model.MDevice devinfoC = Model.CGetInfo.GetDeviceInfo(12401);
                        switch (deviceIdx)
                        {
                            case 11101:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12401);
                                break;
                            case 11102:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12403);
                                break;
                            case 11103:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12405);
                                break;
                            case 11104:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12407);
                                break;
                            case 11105:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12409);
                                break;
                            case 11106:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12411);
                                break;
                            case 11107:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12413);
                                break;
                            case 11108:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12415);
                                break;
                            case 11109:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12417);
                                break;
                            case 11110:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12419);
                                break;
                            case 11111:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12421);
                                break;
                            case 11112:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12423);
                                break;
                            case 11113:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12425);
                                break;
                            case 11114:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12429);
                                break;
                            case 11115:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12431);
                                break;
                            case 11116:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12435);
                                break;
                            case 11117:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12439);
                                break;
                            case 11118:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12443);
                                break;
                            case 11119:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12447);
                                break;
                            case 11120:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12451);
                                break;
                            case 11121:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12455);
                                break;
                            case 11201:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12463);
                                break;
                            case 11202:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12465);
                                break;
                            case 11203:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12469);
                                break;
                            case 11204:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12473);
                                break;
                            case 11205:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12477);
                                break;
                            case 11206:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12481);
                                break;
                            case 11207:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12485);
                                break;
                            case 11208:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12489);
                                break;
                            case 11209:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12491);
                                break;
                            case 11210:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12493);
                                break;
                            case 11211:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12497);
                                break;
                            case 11212:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12501);
                                break;
                            case 11213:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12505);
                                break;
                            case 11214:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12509);
                                break;
                            case 15401:
                            case 15402:
                            case 15403:
                                devinfoC = Model.CGetInfo.GetDeviceInfo(12426);
                                break;
                            default:
                                break;
                        }
                        if (devinfoC.SplitByte_7 == 1)
                        { 
                                AheadDetectUnallow.Clear();
                                AheadDetectUnallow.Append("安全门不允许动作");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                return false;
                        }

                    }
                    #endregion

                    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);
                                sdo = CommModeCreate.CreateSendDeviceOrder(gc[2]);
                                sdo.SendDeviceOrder(2, MonitorIndex, 0, gc[2], 0, out itemnames, out itemvalues);
                                AddOPCSendData(gc[2], MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        else
                        {
                            //gjn增加输送线任务发送时，判断此节为起点的任务为管理任务第一条的，如果是送出判断是否有=1的任务即 已发送  如果是非6 判断是否<=2 即只要存在正转或反转就不发送
                            DataView dbt = dbo.ExceSQL(string.Format("select * from t_monitor_task where  f_no1 = 1 and f_monitorindex != {0} and f_deviceindex ={1}", MonitorIndex, deviceIdx)).Tables[0].DefaultView; ;

                            for (int g=0;g< dbt.Count;g++)
                            {
                                if (Convert.ToInt32(dbt[g]["f_devicecommandindex"]) == 6)
                                {
                                    if (Convert.ToInt32(dbt[g]["f_status"]) ==1)
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "存在没有执行的送出任务，需要人工确认");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;

                                    }
                                }
                                else 
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append(_DeviceIdx.ToString() + "存在非送出任务，需要人工确认");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                            }

                            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)
                    #region 东台晶澳控制出库102相对优先于拆包任务
                    if ((devinfo.DeviceKind == 1) && (devinfo.DeviceIndex <= 11121) && (deviceOrder == 4) && (manageTaskType == 2))//常温库垛机出库取货
                    {
                        DataView dvCounts12202 = dbo.ExceSQL(string.Format("select fenddevice,fstartdevice,fstatus  from T_MANAGE_TASK where FID = {0}", manageTaskIdx)).Tables[0].DefaultView;
                        if (dvCounts12202.Count > 0)
                        {
                            if ((Convert.ToInt32(dvCounts12202[0]["fenddevice"]) == 12202)&&(Convert.ToInt32(dvCounts12202[0]["fstatus"]) == 0))//当前任务为去12202拆包任务
                            {
                                DataView dvCounts102 = dbo.ExceSQL(string.Format("select fenddevice from T_MANAGE_TASK where fenddevice > 20000 and fcurrentlocation <=11121 and fstartdevice = {0}", Convert.ToInt32(dvCounts12202[0]["fstartdevice"]))).Tables[0].DefaultView;
                                if (dvCounts102.Count > 0)//去102的任务数大于0
                                {
                                    DataView dvStatusandHavegood = dbo.ExceSQL(string.Format("select f_lanegatedeviceindex from T_BASE_LANE_GATE where f_laneindex  = {0} and f_lanegatedeviceindex > 12400 order by f_lanegatedeviceindex asc", Convert.ToInt32(dvCounts12202[0]["fstartdevice"]))).Tables[0].DefaultView;
                                    if (dvStatusandHavegood.Count > 0)//对应出库到102侧站台
                                    {
                                        Model.MDevice devinfoStation = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvStatusandHavegood[0]["f_lanegatedeviceindex"]));
                                        if (((devinfoStation.RunState == 0) && devinfoStation.SplitByte_0 == 1) || (devinfoStation.RunState > 1 && devinfoStation.RunState < 5))//站台状态
                                        {
                                            //do nothing 发送此任务
                                        }
                                        else
                                        {
                                            int allowsend = 0;
                                            DataView dvCounts102stepok = dbo.ExceSQL(string.Format("select fenddevice from T_MANAGE_TASK where fenddevice > 20000 and fintostepok = 1 and fcurrentlocation <=11121  and fstartdevice = {0}", Convert.ToInt32(dvCounts12202[0]["fstartdevice"]))).Tables[0].DefaultView;
                                            if (dvCounts102stepok.Count <= 0)//没有已拆分任务，判断一下路径状态，如果全不可用，发送当前去12202拆包任务
                                            {
                                                DataView dvCounts102nostepok = dbo.ExceSQL(string.Format("select distinct fenddevice,fstartdevice from T_MANAGE_TASK where fenddevice > 20000 and fintostepok = 0  and fstartdevice = {0}", Convert.ToInt32(dvCounts12202[0]["fstartdevice"]))).Tables[0].DefaultView;
                                                if (dvCounts102nostepok.Count > 0)
                                                {
                                                    for (int n = 0; n < dvCounts102nostepok.Count; n++)
                                                    {
                                                        DataView dvCounts102RouteStatus = dbo.ExceSQL(string.Format("select f_status from T_BASE_ROUTE  where f_startdevice = {0} and f_enddevice = {1} and f_status =1", Convert.ToInt32(dvCounts102nostepok[0]["fstartdevice"]), Convert.ToInt32(dvCounts102nostepok[0]["fenddevice"]))).Tables[0].DefaultView;
                                                        if (dvCounts102RouteStatus.Count > 0)
                                                        {
                                                            allowsend = 1;
                                                            break;
                                                        }

                                                    }
                                                }
                                            }
                                            if (allowsend == 1)
                                            {

                                                AheadDetectUnallow.Clear();
                                                AheadDetectUnallow.Append("等待出库组件车间任务");
                                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                return false;
                                            }
                                            else
                                            {
                                                //do nothing 
                                            }
                                        }
                                    }
                                }
                            }
                        }

                    }
                    #endregion

                    #region 东台晶澳更新穿梭车更换货叉后对应提前检测
                    if ((devinfo.DeviceKind == 4)&&(devinfo.DeviceIndex != devinfo.VirtualStack)&&(devinfo.ForkAmount == 2))
                    {
                        int fork = 0;//后续测试应该没用
                        DataView dvfork = dbo.ExceSQL(string.Format("select f_deviceindex,f_useawayfork  from T_MONITOR_TASK where F_MONITORINDEX={0}", MonitorIndex)).Tables[0].DefaultView;
                        if (dvfork.Count > 0)
                        {
                            fork = Convert.ToInt32(dvfork[0]["f_useawayfork"]);
                        }

                        if (fork == 2)
                        {
                            dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'{0}.0','{0}.1')  WHERE (F_MONITORINDEX= {1})", Convert.ToInt32(dvfork[0]["f_deviceindex"]), MonitorIndex));
                        }
                    }
                    #endregion

                    #region 东台晶澳控制四环发送四环任务时更改1道终点
                    if ((deviceIdx == 25100) && (GroupEndDevice.IndexOf(_NumParam4.ToString()) >= 0) && (manageTaskType == 2))//新功能四环更换终点
                    {
                        int[] tempstationdevice = new int[6]; int mincountstation = 0;
                        switch (_NumParam4)
                        {
                            case 22076:
                            case 22051:
                            case 22001:
                                object[] ob1 = new object[7] { MonitorIndex, 22076, 22077, 22051, 22052, 22001, 22002 };
                                int limit24101 = 0;
                                int CountsT = 0; int CountsT22076 = 0; int CountsT22051 = 0; int CountsT22001 = 0;
                                for (int n = 1; n < ob1.Length; n++)
                                {
                                    Model.MDevice devinfon = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(ob1[n]));
                                    if ((n == 1) || (n == 2))
                                    {
                                        CountsT22076 += devinfon.SplitByte_0;
                                        if (n == 1)
                                        {
                                            DataView dvHtaskCunt22076 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0  AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={1}", ob1)).Tables[0].DefaultView;// AND F_STATUS > 0
                                            CountsT22076 += dvHtaskCunt22076.Count;

                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22076 = 3;
                                        }
                                        if(CountsT22076 >= 3) CountsT22076 = 3;
                                    }
                                    else if ((n == 3) || (n == 4))
                                    {
                                        CountsT22051 += devinfon.SplitByte_0;
                                        if (n == 3)
                                        {
                                            DataView dvHtaskCunt22051 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={3}", ob1)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22051 += dvHtaskCunt22051.Count;
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22051 = 3;
                                        }
                                        if (CountsT22051 >= 3) CountsT22051 = 3;
                                    }
                                    else if ((n == 5) || (n == 6))
                                    {
                                        CountsT22001 += devinfon.SplitByte_0;
                                        if (n == 5)
                                        {
                                            DataView dvHtaskCunt22002 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0  AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={5}", ob1)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22001 += dvHtaskCunt22002.Count;

                                            dvHtaskCunt22002 = dboM.ExceSQL("select STATION_INOUT_MODE  from IO_CONTROL_MODE_SWITCH where OUTPUT_STATION_CODE = 24101 AND STATION_INOUT_MODE = 1").Tables[0].DefaultView;// AND F_STATUS > 0
                                            if (dvHtaskCunt22002.Count > 0)
                                            {
                                                limit24101 = 3;
                                                CountsT22001 = 3;
                                            }
                                        }

                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22001 = 3;
                                        }

                                        if (CountsT22001 >= 3) CountsT22001 = 3;
                                    }
                                }
                                
                                CountsT = CountsT22076 + CountsT22051 + CountsT22001;
                                //DataView dvHtaskCunt1 = dbo.ExceSQL(string.Format("select F_STATUS  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1  AND ((F_DEVICECOMMANDINDEX = 1 AND F_STATUS > 0 AND (F_NUMPARAM4 ={1} OR F_NUMPARAM4 ={2} OR F_NUMPARAM4 ={3})) OR (F_DEVICECOMMANDINDEX = 6 AND (F_NUMPARAM1 ={1} OR F_NUMPARAM1 ={2} OR F_NUMPARAM1 ={3} OR F_NUMPARAM1 ={4} OR F_NUMPARAM1 ={5}  OR F_NUMPARAM1 ={6})))", ob1)).Tables[0].DefaultView;
                                if (CountsT >= 9)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("组件车间环穿任务终点站台" + _NumParam4.ToString() + "总缓存数量上限不发送任务");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                else
                                {
                                    if ((CountsT22001 < CountsT22051) && (CountsT22001 < CountsT22076)&&(limit24101 ==0))//22001
                                    {
                                        if (_NumParam4 != 22001)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22002') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24101') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22002 ,f_numparam1 = 22002 , f_numparam4 = 24101,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22002)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22001') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22001 ,f_numparam1 = 22001 , f_numparam4 = 22002,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22001)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22001') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22001  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24101  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点，任务号:" + manageTaskIdx.ToString()+"条码：" + _TxtParam, "原终点：" + enddevice.ToString(), "更改终点：22001，22002，24101");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else if ((CountsT22051 < CountsT22076) && (CountsT22051 <= CountsT22001))//22051
                                    {
                                        if (_NumParam4 != 22051)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22052') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24102') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22052 ,f_numparam1 = 22052 , f_numparam4 = 24102,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22052)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22051') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22051 ,f_numparam1 = 22051 , f_numparam4 = 22052,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22051)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22051') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22051  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24102  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点，任务号:" + manageTaskIdx.ToString() + "条码：" + _TxtParam, "原终点：" + enddevice.ToString(), "更改终点：22001，22002，24101");

                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else//22076
                                    {
                                        if (_NumParam4 != 22076)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22077') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24103') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22077 ,f_numparam1 = 22077 , f_numparam4 = 24103,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22077)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22076') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22076 ,f_numparam1 = 22076 , f_numparam4 = 22077,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22076)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22076') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22076  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24103  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点，任务号:" + manageTaskIdx.ToString() + "条码：" + _TxtParam, "原终点：" + enddevice.ToString(), "更改终点：22001，22002，24101");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                }
                                break;
                            case 22110:
                            case 22082:
                                object[] ob2 = new object[5] { MonitorIndex, 22110, 22111, 22082, 22083};
                                int CountsT2 = 0; int CountsT22110 = 0; int CountsT22082 = 0;
                                int limit24105 = 0;
                                for (int n = 1; n < ob2.Length; n++)
                                {
                                    Model.MDevice devinfon = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(ob2[n]));
                                    if ((n == 1) || (n == 2))
                                    {
                                        CountsT22110 += devinfon.SplitByte_0;
                                        if (n == 1)
                                        {
                                            DataView dvHtaskCunt22110 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={1}", ob2)).Tables[0].DefaultView;// AND F_STATUS > 0
                                            CountsT22110 += dvHtaskCunt22110.Count;

                                            dvHtaskCunt22110 = dboM.ExceSQL("select STATION_INOUT_MODE  from IO_CONTROL_MODE_SWITCH where OUTPUT_STATION_CODE = 24105 AND STATION_INOUT_MODE = 1").Tables[0].DefaultView;// AND F_STATUS > 0
                                            if (dvHtaskCunt22110.Count > 0)
                                            {
                                                limit24105 = 3;
                                                CountsT22110 = 3;
                                            }
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22110 = 3;
                                        }
                                        if (CountsT22110 >= 3) CountsT22110 = 3;
                                    }
                                    else if ((n == 3) || (n == 4))
                                    {
                                        CountsT22082 += devinfon.SplitByte_0;
                                        if (n == 3)
                                        {
                                            DataView dvHtaskCunt22082 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={3}", ob2)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22082 += dvHtaskCunt22082.Count;
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22082 = 3;
                                        }
                                        if (CountsT22082 >= 3) CountsT22082 = 3;
                                    }
                                }
                                CountsT2 = CountsT22110 + CountsT22082;
                                //DataView dvHtaskCunt1 = dbo.ExceSQL(string.Format("select F_STATUS  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1  AND ((F_DEVICECOMMANDINDEX = 1 AND F_STATUS > 0 AND (F_NUMPARAM4 ={1} OR F_NUMPARAM4 ={2} OR F_NUMPARAM4 ={3})) OR (F_DEVICECOMMANDINDEX = 6 AND (F_NUMPARAM1 ={1} OR F_NUMPARAM1 ={2} OR F_NUMPARAM1 ={3} OR F_NUMPARAM1 ={4} OR F_NUMPARAM1 ={5}  OR F_NUMPARAM1 ={6})))", ob1)).Tables[0].DefaultView;
                                if (CountsT2 >= 6)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("组件车间环穿任务终点站台" + _NumParam4.ToString() + "总缓存数量上限不发送任务");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                else
                                {
                                    if (CountsT22082 < CountsT22110)//22082
                                    {
                                        if (_NumParam4 != 22082)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22083') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24104') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22083 ,f_numparam1 = 22083 , f_numparam4 = 24104,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22083)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22082') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22082 ,f_numparam1 = 22082 , f_numparam4 = 22083,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22082)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22082') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22082  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24104  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22082，22083，24104");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else if(limit24105 ==0)//22110
                                    {
                                        if (_NumParam4 != 22110)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22111') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24105') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22111 ,f_numparam1 = 22111 , f_numparam4 = 24105,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22111)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22110') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22110 ,f_numparam1 = 22110 , f_numparam4 = 22111,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22110)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22110') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22110  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24105  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22110，22111，24105");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                }
                                break;
                            case 22101:
                            case 22060:
                                object[] ob3 = new object[5] { MonitorIndex, 22101, 22102, 22060, 22061 };
                                int CountsT3 = 0; int CountsT22101 = 0; int CountsT22060 = 0;
                                int limit24112 = 0;
                                for (int n = 1; n < ob3.Length; n++)
                                {
                                    Model.MDevice devinfon = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(ob3[n]));
                                    if ((n == 1) || (n == 2))
                                    {
                                        CountsT22101 += devinfon.SplitByte_0;
                                        if (n == 1)
                                        {
                                            DataView dvHtaskCunt22101 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0  AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={1}", ob3)).Tables[0].DefaultView;// AND F_STATUS > 0
                                            CountsT22101 += dvHtaskCunt22101.Count;

                                            dvHtaskCunt22101 = dboM.ExceSQL("select STATION_INOUT_MODE  from IO_CONTROL_MODE_SWITCH where OUTPUT_STATION_CODE = 24112 AND STATION_INOUT_MODE = 1").Tables[0].DefaultView;// AND F_STATUS > 0
                                            if (dvHtaskCunt22101.Count > 0)
                                            {
                                                limit24112 = 3;
                                                CountsT22101 = 3;
                                            }
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22101 = 3;
                                        }
                                        if (CountsT22101 >= 3) CountsT22101 = 3;
                                    }
                                    else if ((n == 3) || (n == 4))
                                    {
                                        CountsT22060 += devinfon.SplitByte_0;
                                        if (n == 3)
                                        {
                                            DataView dvHtaskCunt22060 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={3}", ob3)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22060 += dvHtaskCunt22060.Count;
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22060 = 3;
                                        }
                                        if (CountsT22060 >= 3) CountsT22060 = 3;
                                    }
                                }
                                CountsT3 = CountsT22101 + CountsT22060;
                                //DataView dvHtaskCunt1 = dbo.ExceSQL(string.Format("select F_STATUS  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1  AND ((F_DEVICECOMMANDINDEX = 1 AND F_STATUS > 0 AND (F_NUMPARAM4 ={1} OR F_NUMPARAM4 ={2} OR F_NUMPARAM4 ={3})) OR (F_DEVICECOMMANDINDEX = 6 AND (F_NUMPARAM1 ={1} OR F_NUMPARAM1 ={2} OR F_NUMPARAM1 ={3} OR F_NUMPARAM1 ={4} OR F_NUMPARAM1 ={5}  OR F_NUMPARAM1 ={6})))", ob1)).Tables[0].DefaultView;
                                if (CountsT3 >= 6)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("组件车间环穿任务终点站台" + _NumParam4.ToString() + "总缓存数量上限不发送任务");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                else
                                {
                                    if (CountsT22060 < CountsT22101)//22060
                                    {
                                        if (_NumParam4 != 22060)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22061') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24111') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22061 ,f_numparam1 = 22061 , f_numparam4 = 24111,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22061)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22060') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22060 ,f_numparam1 = 22060 , f_numparam4 = 22061,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22060)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22060') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22060  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24111  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22060，22061，24111");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else if (limit24112 ==0)//22101
                                    {
                                        if (_NumParam4 != 22101)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22102') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24112') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22102 ,f_numparam1 = 22102 , f_numparam4 = 24112,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22102)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22101') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22101 ,f_numparam1 = 22101 , f_numparam4 = 22102,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22101)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22101') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22101  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24112  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22101，22102，24112");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                }
                                break;
                            case 22026:
                            case 22032:
                            case 22010:
                                object[] ob4 = new object[7] { MonitorIndex, 22032, 22033, 22026, 22027, 22010, 22011 };
                                int CountsT4 = 0; int CountsT22032 = 0; int CountsT22026 = 0; int CountsT22010 = 0;
                                int limit24108 = 0;
                                for (int n = 1; n < ob4.Length; n++)
                                {
                                    Model.MDevice devinfon = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(ob4[n]));
                                    if ((n == 1) || (n == 2))
                                    {
                                        CountsT22032 += devinfon.SplitByte_0;
                                        if (n == 1)
                                        {
                                            DataView dvHtaskCunt22032 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0  AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={1}", ob4)).Tables[0].DefaultView;// AND F_STATUS > 0
                                            CountsT22032 += dvHtaskCunt22032.Count;
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22032 = 3;
                                        }
                                        if (CountsT22032 >= 3) CountsT22032 = 3;
                                    }
                                    else if ((n == 3) || (n == 4))
                                    {
                                        CountsT22026 += devinfon.SplitByte_0;
                                        if (n == 3)
                                        {
                                            DataView dvHtaskCunt22026 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={3}", ob4)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22026 += dvHtaskCunt22026.Count;
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22026 = 3;
                                        }
                                        if (CountsT22026 >= 3) CountsT22026 = 3;
                                    }
                                    else if ((n == 5) || (n == 6))
                                    {
                                        CountsT22010 += devinfon.SplitByte_0;
                                        if (n == 5)
                                        {
                                            DataView dvHtaskCunt22010 = dbo.ExceSQL(string.Format("select F_NUMPARAM4  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1 AND F_STATUS > 0 AND  F_DEVICECOMMANDINDEX = 1 AND F_NUMPARAM4 ={5}", ob4)).Tables[0].DefaultView;//AND F_STATUS > 0 
                                            CountsT22010 += dvHtaskCunt22010.Count;

                                            dvHtaskCunt22010 = dbo.ExceSQL("select STATION_INOUT_MODE  from T_BASE_IOMODE_SWITCH where OUTPUT_STATION_CODE = 24108 AND STATION_INOUT_MODE = 1").Tables[0].DefaultView;// AND F_STATUS > 0
                                            if (dvHtaskCunt22010.Count > 0)
                                            {
                                                limit24108 = 3;
                                                CountsT22010 = 3;
                                            }
                                        }
                                        if ((devinfon.RunState > 1) && (devinfon.RunState < 5))
                                        {
                                            CountsT22010 = 3;
                                        }
                                        if (CountsT22010 >= 3) CountsT22010 = 3;
                                    }
                                }
                                CountsT4 = CountsT22032 + CountsT22026 + CountsT22010;
                                //DataView dvHtaskCunt1 = dbo.ExceSQL(string.Format("select F_STATUS  from T_MONITOR_TASK where F_MONITORINDEX !={0} AND F_NO1 = 1  AND ((F_DEVICECOMMANDINDEX = 1 AND F_STATUS > 0 AND (F_NUMPARAM4 ={1} OR F_NUMPARAM4 ={2} OR F_NUMPARAM4 ={3})) OR (F_DEVICECOMMANDINDEX = 6 AND (F_NUMPARAM1 ={1} OR F_NUMPARAM1 ={2} OR F_NUMPARAM1 ={3} OR F_NUMPARAM1 ={4} OR F_NUMPARAM1 ={5}  OR F_NUMPARAM1 ={6})))", ob1)).Tables[0].DefaultView;
                                if (CountsT4 >= 9)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("组件车间环穿任务终点站台" + _NumParam4.ToString() + "总缓存数量上限不发送任务");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                else
                                {
                                    if ((CountsT22010 < CountsT22032) && (CountsT22010 < CountsT22026)&&(limit24108 ==0))//22010
                                    {
                                        if (_NumParam4 != 22010)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22011') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24108') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22011 ,f_numparam1 = 22011 , f_numparam4 = 24108,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22011)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22010') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22010 ,f_numparam1 = 22010 , f_numparam4 = 22011,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22010)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22010') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22010  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24108  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22010，22011，24108");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else if ((CountsT22026 < CountsT22032) && (CountsT22026 <= CountsT22010))//22026
                                    {
                                        if (_NumParam4 != 22026)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22027') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24109') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22027 ,f_numparam1 = 22027 , f_numparam4 = 24109,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22027)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22026') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22026 ,f_numparam1 = 22026 , f_numparam4 = 22027,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22026)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22026') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22026  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24109  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22026，22027，24109");

                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                    else//22032
                                    {
                                        if (_NumParam4 != 22032)
                                        {
                                            int enddevice = ccf.GetEndDeviceFromManage(manageKindIdx, manageTaskIdx);
                                            //更换第二段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22033') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{2}', '24110') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, enddevice));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set  f_deviceindex = 22033 ,f_numparam1 = 22033 , f_numparam4 = 24110,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4 + 1, manageTaskIdx, GetRouteIDsub(22033)));

                                            //更换第一段送出
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22032') WHERE f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_deviceindex = 22032 ,f_numparam1 = 22032 , f_numparam4 = 22033,F_ROUTEID = {2} where f_deviceindex = {0} and f_managetaskindex = {1}", _NumParam4, manageTaskIdx, GetRouteIDsub(22032)));

                                            //更换环穿任务
                                            dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '22032') WHERE f_deviceindex = 25100 and f_managetaskindex = {1}", _NumParam4, manageTaskIdx));
                                            dbo.ExceSQL(string.Format("update T_MONITOR_TASK set f_numparam4 = 22032  where f_deviceindex = 25100 and f_managetaskindex = {0}", manageTaskIdx));

                                            //更换manage任务终点
                                            dbo.ExceSQL(string.Format("update T_MANAGE_TASK set fenddevice = 24110  where fid = {0}", manageTaskIdx));


                                            CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更改终点任务号:" + manageTaskIdx.ToString(), "原终点：" + enddevice.ToString(), "更改终点：22032，22033，24110");
                                            if (GetSendInfo(MonitorIndex) == false) { return false; }
                                        }
                                    }
                                }
                                break;
                        }

                    }
                    #endregion
                    //2：提取每个管理单据的第一个设备状态
                    if (GetFirstDeviceIFLocked(MonitorIndex, true) == false)//没有被锁定，空闲
                    {

                        if ((deviceKind == 1) && (deviceIdx >= 11201) && (deviceOrder == 4))
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("SELECT FENDDEVICE,FCONTROLTASKTYPE  FROM T_Manage_Task WHERE   FID = ").Append(manageTaskIdx);
                            DataView dvRLimit12566 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                            if (dvRLimit12566.Count > 0)//没有此堆垛机的出库任务在排队或者执行
                            {
                                if (Convert.ToInt32(dvRLimit12566[0]["FCONTROLTASKTYPE"]) == 2)
                                {
                                    if (Convert.ToInt32(dvRLimit12566[0]["FENDDEVICE"]) == 12566)
                                    {
                                        Model.MDevice devinfo12595 = Model.CGetInfo.GetDeviceInfo(12595);
                                        if (devinfo12595.SplitByte_0 == 1)
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append("12595有物光电开关遮挡");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                }
                            }
                        }
                        devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
                        #region 电池间供应母托盘垛控制前道缓存去往2道缓存任务发送
                        if ((deviceIdx == 15200) && (_NumParam1 == 12595))//  && (_NumParam4 == 12552)
                        {
                            sql.Remove(0, sql.Length);
                            sql.Append("select f_numparam1  from t_monitor_task where  f_deviceindex = 15200 and f_numparam1 = 12595 and f_status >0  and f_monitorindex != ").Append(MonitorIndex);// and f_numparam4 = 12552 
                            DataView dbAllow3 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;

                            sql.Remove(0, sql.Length);
                            sql.Append("select f_numparam1  from t_monitor_task where  f_deviceindex = 12552 and f_numparam4 = 12594 and f_status >0 and f_monitorindex != ").Append(MonitorIndex);
                            DataView dbAllow4 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;

                            Model.MDevice devinfo12594 = Model.CGetInfo.GetDeviceInfo(12594);

                            if (dbAllow3.Count > 0 || dbAllow4.Count > 0 || devinfo12594.SplitByte_0 == 1 || devinfo12594.RunState != 0)
                            {
                                AheadDetectUnallow.Clear();
                                AheadDetectUnallow.Append(_DeviceIdx.ToString() + "存在大于等于已发送去往2道缓存的指令");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                return false;
                            }
                        }
                        #endregion
                        #region 直穿和垛机抢中间双向输送线
                        if ((manageTaskType == 2) && (_NumParam5 == 1) && (StackerNoallow.IndexOf(deviceIdx.ToString()) >= 0)&&(deviceOrder == 4) && (devinfo.ManTaskReserve != Convert.ToInt32(manageKindIdx.ToString() + manageTaskIdx.ToString())))//直穿与垛机双向控制top 垛机站台，left垛机编号
                        {
                            DataView dbAllow = dbo.ExceSQL(string.Format("select F_RGVGATEDEVICEINDEX,F_TOP  from T_BASE_RGV_GATE where  F_LEFT  =  {0}", deviceIdx)).Tables[0].DefaultView;
                            if (dbAllow.Count > 0)
                            {
                                DataView dbAllow1 = dbo.ExceSQL(string.Format("select f_status  from t_monitor_task where  (f_no1 = 1 and f_numparam4 = {0}) or (f_numparam4 = {0} and (f_deviceindex = 15401 or f_deviceindex = 15402 or f_deviceindex = 15403))", Convert.ToInt32(dbAllow[0]["F_RGVGATEDEVICEINDEX"]))).Tables[0].DefaultView;
                                if (dbAllow1.Count > 0)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法发送任务，当前送货站台被反向任务占用");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                            }
                        }
                        #endregion

                        #region 出库任务按模式判断是否可以执行
                        int EnddeviceIndex = ccf.GetManageTaskEndDevicefromMonitor(MonitorIndex);
                        if ((manageTaskType == 2) && (deviceOrder == 4)&&((EnddeviceIndex == 14016)|| (EnddeviceIndex == 24107) || (EnddeviceIndex == 24115) || (EnddeviceIndex == 24106) || (EnddeviceIndex == 24113)))//|| (EnddeviceIndex == 24105) || (EnddeviceIndex == 24112) || (EnddeviceIndex == 24108) || (EnddeviceIndex == 24101)
                        {
                            DataView dbAllow = dbo.ExceSQL(string.Format("select station_inout_mode  from T_BASE_IOMODE_SWITCH where  output_station_code  =  {0}", EnddeviceIndex)).Tables[0].DefaultView;
                            if (dbAllow.Count > 0)
                            {
                                if (Convert.ToInt32(dbAllow[0]["station_inout_mode"])== 1)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法发送任务，当前出库终点为入库模式");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                            }
                        }
                        #endregion
                        #region 选车及更新任务
                        if (deviceIdx == devinfo.VirtualStack)
                        {
                            if (devinfo.DeviceKind == 4 && deviceOrder == 2)
                            {//根据起始点和终点更改monitor任务，设备全为虚拟设备
                                if ((manageTaskType == 1) && (RgvNoallow.IndexOf(_NumParam4.ToString()) >= 0))//直穿与垛机双向控制,入库并且对应双向站台巷道
                                {
                                    DataView dbAllow = dbo.ExceSQL(string.Format("select F_TOP,F_LEFT  from T_BASE_RGV_GATE where  F_RGVGATEDEVICEINDEX  =  {0}", _NumParam4)).Tables[0].DefaultView;
                                    if (dbAllow.Count > 0)
                                    {
                                        //third
                                       
                                        int devinfoMMM  = 0;
                                        Model.MDevice devinfoScy1 = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dbAllow[0]["F_TOP"]));
                                        Model.MDevice devinfoScy2 = Model.CGetInfo.GetDeviceInfo(_NumParam4);
                                        sql.Remove(0, sql.Length);
                                        sql.Append("select F_ManTaskReserve from  T_Base_Device where  F_DeviceIndex=").Append(Convert.ToInt32(dbAllow[0]["F_LEFT"]));
                                        object obr1 = dbo.GetSingle(sql.ToString());
                                        if (obr1 != null)
                                        {
                                            devinfoMMM = Convert.ToInt32(obr1);
                                        }
                                        if (devinfoMMM != 0)
                                        {
                                            int taskFid = Convert.ToInt32(Convert.ToString(devinfoMMM).Substring(1, Convert.ToString(devinfoMMM).Length - 1));
                                            if (taskFid != 0)
                                            {
                                                sql.Remove(0, sql.Length);
                                                sql.Append("SELECT fcontroltasktype,fenddevice FROM T_Manage_Task WHERE (fid = ").Append(taskFid).Append(")");
                                                DataView dbAllow1 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                                if (dbAllow1.Count > 0)
                                                {
                                                    if ((Convert.ToInt32(dbAllow1[0]["fcontroltasktype"]) == 2) && (Convert.ToInt32(dbAllow1[0]["fenddevice"]) > 24000))
                                                    {
                                                        AheadDetectUnallow.Clear();
                                                        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，对应入口垛机已被来此方向任务预约");
                                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                        return false;
                                                    }
                                                }
                                            }
                                        }
                                        if ((devinfoScy1.SplitByte_0 != 0) || (devinfoScy1.RunState != 0) || (devinfoScy2.SplitByte_0 != 0) || (devinfoScy2.RunState != 0))
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，对应入口输送线被占用");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }

                                        //DataView dbAllow1 = dbo.ExceSQL(string.Format("select f_status,f_monitorindex  from t_monitor_task where  f_no1 = 1 and f_numparam1 = {0}))", Convert.ToInt32(dbAllow[0]["F_TOP"]))).Tables[0].DefaultView;//f_status >0 and 
                                        //if (dbAllow1.Count > 0)//避免有时货物停在中间，没有货但空闲
                                        //{
                                        //    AheadDetectUnallow.Clear();
                                        //    AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，当前送货站台被反向任务占用");
                                        //    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        //    return false;
                                        //}

                                        //secound
                                        //DataView dbAllow1 = dbo.ExceSQL(string.Format("select f_status,f_monitorindex  from t_monitor_task where  f_no1 = 1 and f_numparam1 = {0}))", Convert.ToInt32(dbAllow[0]["F_TOP"]))).Tables[0].DefaultView;//f_status >0 and 
                                        //if (dbAllow1.Count > 0)
                                        //{
                                        //    AheadDetectUnallow.Clear();
                                        //    AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，当前送货站台被反向任务占用");
                                        //    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        //    return false;
                                        //}

                                        //DataView dbAllow2 = dbo.ExceSQL(string.Format("select f_status,f_monitorindex  from t_monitor_task where  f_no1 = 1 and (f_numparam5 = 1 and f_deviceindex = {0})", Convert.ToInt32(dbAllow[0]["F_LEFT"]))).Tables[0].DefaultView;//f_status >0 and 
                                        //if (dbAllow2.Count > 0)
                                        //{
                                        //    Model.MDevice devinfoMMM = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dbAllow[0]["F_LEFT"]));
                                        //    int manageKindIdxt = ccf.GetManageTaskKindIndexFromMonitor(Convert.ToInt32(dbAllow2[0]["f_monitorindex"]));
                                        //    int manageTaskIdxt = ccf.GetManageTaskIndexFromMonitor(Convert.ToInt32(dbAllow2[0]["f_monitorindex"]));
                                        //    if (devinfoMMM.ManTaskReserve == Convert.ToInt32(manageKindIdxt.ToString() + manageTaskIdxt.ToString()))
                                        //    {
                                        //        AheadDetectUnallow.Clear();
                                        //        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，当前送货站台被反向任务占用");
                                        //        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        //        return false;
                                        //    }
                                        //}
                                    }

                                    //first 
                                    //DataView dbAllow = dbo.ExceSQL(string.Format("select F_TOP,F_LEFT  from T_BASE_RGV_GATE where  F_RGVGATEDEVICEINDEX  =  {0}", _NumParam4)).Tables[0].DefaultView;
                                    //if (dbAllow.Count > 0)
                                    //{
                                    //    DataView dbAllow1 = dbo.ExceSQL(string.Format("select f_status  from t_monitor_task where  f_no1 = 1 and (f_numparam1 = {0} or (f_status >0 and f_numparam5 = 1 and f_deviceindex = {1}))", Convert.ToInt32(dbAllow[0]["F_TOP"]), Convert.ToInt32(dbAllow[0]["F_LEFT"]))).Tables[0].DefaultView;
                                    //    if (dbAllow1.Count > 0)
                                    //    {
                                    //        AheadDetectUnallow.Clear();
                                    //        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "无法替换真实车辆，当前送货站台被反向任务占用");
                                    //        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    //        return false;
                                    //    }
                                    //}
                                }

                                DataView dvDeleteMore = dbo.ExceSQL(string.Format("SELECT f_monitorindex FROM T_MONITOR_TASK where  F_MANAGETASKINDEX={0} and F_DEVICEINDEX = 15400  order by f_monitorindex", manageTaskIdx)).Tables[0].DefaultView;
                                if(dvDeleteMore.Count>2)
                                {
                                    for(int n=2;n< dvDeleteMore.Count;n++)
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append("delete from T_Monitor_Task   where F_MonitorIndex=").Append(dvDeleteMore[n]["f_monitorindex"]);
                                        dbo.ExceSQL(sql.ToString());
                                        CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "删除多余拆分的穿梭车任务： ", Convert.ToString(dvDeleteMore[n]["f_monitorindex"]), manageTaskIdx.ToString());
                                    }
                                }

                                string flag = ChangeDisassembleRGVTask(deviceIdx, MonitorIndex, manageKindIdx, manageTaskIdx,manageTaskType);
                                if(flag !="1")
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append(_DeviceIdx.ToString() + flag);
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                else
                                {
                                    return true;
                                }
                            }
                        }
                        #endregion
                        #region 同区域的双工位RGV取货任务配双叉20231215 do nothing
                       
                        //if (devinfo.DeviceKind == 4 && devinfo.ForkAmount == 2 && deviceOrder == 2 && ccf.GetRELATIVECONTORLIDFromManageTask(manageKindIdx, manageTaskIdx) <= 0)
                        //{
                        //    DataView dvcorrl = dbo.ExceSQL(string.Format("SELECT F_CORRELDEVICEINDEX,F_FORKNO,F_NEARGETDEVICE FROM T_BASE_RGV_GATE where  F_RGVGATEDEVICEINDEX={0}", _NumParam1)).Tables[0].DefaultView;//F_CORRELDEVICEINDEX != {1} and
                        //    if (dvcorrl.Count > 0)
                        //    {
                        //        if (Convert.ToString(dvcorrl[0]["F_CORRELDEVICEINDEX"]) != "")//先判断本任务取货站台的同步取货关联站台
                        //        {
                        //            char[] cc = new char[1];
                        //            cc[0] = '/';
                        //            string[] rgvCorrelStation = Convert.ToString(dvcorrl[0]["F_CORRELDEVICEINDEX"]).Split(cc);

                        //            for (int i = rgvCorrelStation.GetLowerBound(0); i <= rgvCorrelStation.GetUpperBound(0); i++)
                        //            {
                        //                int rgvCorrelStationt = Convert.ToInt32(rgvCorrelStation[i]);//与电气讨论可同步取送货的缓存站台
                        //                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[i])));
                        //                object[] obarr = new object[5] { manageKindIdx, deviceIdx, deviceOrder, rgvCorrelStation[i], 1 };///1213
                        //                DataView dvcorr2 = dbo.ExceSQL(string.Format("SELECT F_MANAGETASKINDEX,f_monitorindex FROM T_MONITOR_TASK where F_STATUS=0 and F_MANAGETASKKINDINDEX={0} and F_DEVICEINDEX={1} and F_DEVICECOMMANDINDEX={2} and F_NUMPARAM1={3} and f_no1 = {4}", obarr)).Tables[0].DefaultView;
                        //                for (int n = 0; n < dvcorr2.Count; n++)
                        //                {
                        //                    int controltype = ccf.GetManageTaskTypefromMonitor(Convert.ToInt32(dvcorr2[n]["f_monitorindex"]));
                        //                    if (controltype == manageTaskType)//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                        //                    {
                        //                        int correlfid = Convert.ToInt32(dvcorr2[n]["F_MANAGETASKINDEX"]);
                        //                        //int MonitortaskCourrent  = Convert.ToInt32(dvcorr2[n]["f_monitorindex"]);
                        //                        SetRgvCorrelManageTask(manageKindIdx, manageTaskIdx, _NumParam1, rgvForkNo, rgvCorrelStationt, correlfid, rgvCorrelForkNo);//, MonitortaskCourrent
                        //                        return false;
                        //                    }
                        //                }
                        //                //如果配不上双叉return false 失效，再次分配货叉暂定1叉后续再优化
                        //                sql.Remove(0, sql.Length);
                        //                sql.Append("update T_Manage_Task set FUseAwayFork='1'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                        //                dbo.ExecuteSql(sql.ToString());
                        //                sql.Remove(0, sql.Length);
                        //                sql.Append("update T_Monitor_Task set F_UseAwayFork='1'").Append("where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                        //                dbo.ExecuteSql(sql.ToString());
                        //            }
                        //        }
                        //        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 (Convert.ToString(dvcorrl[0]["F_NEARGETDEVICE"]) != "")
                        //            {
                        //                int neargateArea = Convert.ToInt32(dvcorrl[0]["F_NEARGETDEVICE"]);
                        //                object[] obarr = new object[6] { manageKindIdx, deviceIdx, deviceOrder, MonitorIndex, neargateArea, 1 };//1213
                        //                DataView dvcorr2 = dbo.ExceSQL(string.Format("SELECT F_MANAGETASKINDEX,F_NUMPARAM1,f_monitorindex 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_no1 = {5} 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;
                        //                for (int n = 0; n < dvcorr2.Count; n++)
                        //                {
                        //                    int controltype = ccf.GetManageTaskTypefromMonitor(Convert.ToInt32(dvcorr2[n]["f_monitorindex"]));
                        //                    if (controltype == manageTaskType)//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                        //                    {
                        //                        int correlfid = Convert.ToInt32(dvcorr2[n]["F_MANAGETASKINDEX"]);
                        //                        int rgvCorrelStation = Convert.ToInt32(dvcorr2[n]["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(manageKindIdx, manageTaskIdx, _NumParam1, rgvForkNo, rgvCorrelStation, correlfid, rgvCorrelForkNo);
                        //                        return false;
                        //                    }
                        //                }
                        //                //如果配不上双叉return false 失效，再次分配货叉 暂定1叉后续再优化
                        //                sql.Remove(0, sql.Length);
                        //                sql.Append("update T_Manage_Task set FUseAwayFork='1'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                        //                dbo.ExecuteSql(sql.ToString());
                        //                sql.Remove(0, sql.Length);
                        //                sql.Append("update T_Monitor_Task set F_UseAwayFork='1'").Append("where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                        //                dbo.ExecuteSql(sql.ToString());
                        //            }
                        //        }
                        //    }
                        //}
                        #endregion
                        #region 发送置关联,分配货叉，发送取货时置关联送货终点不能同一个站台，否则可能送不下去
                        if (deviceIdx != devinfo.VirtualStack && devinfo.DeviceKind == 4 && devinfo.ForkAmount == 2 && deviceOrder == 2 && ccf.GetRELATIVECONTORLIDFromManageTask(manageKindIdx, manageTaskIdx) <= 0)
                        {
                            DataView dvcorrl = dbo.ExceSQL(string.Format("SELECT F_CORRELDEVICEINDEX,F_FORKNO,F_NEARGETDEVICE FROM T_BASE_RGV_GATE where  F_RGVGATEDEVICEINDEX={0}", _NumParam1)).Tables[0].DefaultView;//F_CORRELDEVICEINDEX != {1} and
                            if (dvcorrl.Count > 0)
                            {
                                if (Convert.ToString(dvcorrl[0]["F_CORRELDEVICEINDEX"]) != "")//中转站台此字段所有都有值，先判断本任务取货站台的同步取货站台是否有任务可以关联
                                {
                                    char[] cc = new char[1];
                                    cc[0] = '/';
                                    string tempstation = "";//DTJA特殊写，因为不愿意更改字段类型
                                    if (Convert.ToString(dvcorrl[0]["F_CORRELDEVICEINDEX"]) == "12427")
                                    {
                                        tempstation = "12427/12511";
                                    }
                                    else
                                    {
                                        tempstation = Convert.ToString(dvcorrl[0]["F_CORRELDEVICEINDEX"]);
                                    }
                                    string[] rgvCorrelStation = tempstation.Split(cc);
                                    for (int i = rgvCorrelStation.GetLowerBound(0); i <= rgvCorrelStation.GetUpperBound(0); i++)//变例关联站台，最少有一个
                                    {
                                        int rgvCorrelStationt = Convert.ToInt32(rgvCorrelStation[i]);//关联取货站台

                                        object[] obarr = new object[6] { manageKindIdx, deviceIdx, deviceOrder, rgvCorrelStation[i], 1, _NumParam4 };
                                        DataView dvcorr2 = dbo.ExceSQL(string.Format("SELECT f_managetaskkindindex,F_MANAGETASKINDEX,f_monitorindex FROM T_MONITOR_TASK where F_STATUS=0 and F_MANAGETASKKINDINDEX={0} and F_DEVICEINDEX={1} and F_DEVICECOMMANDINDEX={2} and F_NUMPARAM1={3} and f_no1 = {4} and F_NUMPARAM4 != {5}", obarr)).Tables[0].DefaultView;
                                        if (dvcorr2.Count > 0)//如果能同步站台有要取货的第一条指令置优先关联
                                        {
                                            for (int n = 0; n < dvcorr2.Count; n++)
                                            {
                                                int controltype = ccf.GetManageTaskTypefromMonitor(Convert.ToInt32(dvcorr2[n]["f_monitorindex"]));
                                                int tempRELATIVE = ccf.GetRELATIVECONTORLIDFromManageTask(Convert.ToInt32(dvcorr2[n]["f_managetaskkindindex"]), Convert.ToInt32(dvcorr2[n]["F_MANAGETASKINDEX"]));
                                                if ((controltype == manageTaskType)&&(tempRELATIVE ==-1))//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                                                {
                                                    int correlfid = Convert.ToInt32(dvcorr2[n]["F_MANAGETASKINDEX"]);
                                                    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[i])));

                                                    if((_NumParam1 == 12428)&&(rgvCorrelStationt!=12428))
                                                    {
                                                        if(rgvCorrelForkNo ==1)
                                                        {
                                                            rgvForkNo = 2;
                                                        }
                                                        else
                                                        {
                                                            rgvForkNo = 1;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (rgvForkNo == 1)
                                                        {
                                                            rgvCorrelForkNo = 2;
                                                        }
                                                        else
                                                        {
                                                            rgvCorrelForkNo = 1;
                                                        }
                                                    }

                                                    SetRgvCorrelManageTaskNEW(deviceIdx, manageKindIdx, manageTaskIdx, MonitorIndex, rgvForkNo, correlfid, Convert.ToInt32(dvcorr2[n]["f_monitorindex"]), rgvCorrelForkNo);
                                                    return false;
                                                }
                                            }
                                        }
                                        else//缓存站台没有可以同取送的站台第一条任务，查找缓存站台不同步取送的任务
                                        {
                                            int neargateArea = Convert.ToInt32(dvcorrl[0]["F_NEARGETDEVICE"]);//获取区域
                                            object[] obarr3 = new object[7] { manageKindIdx, deviceIdx, deviceOrder, MonitorIndex, neargateArea, 1, _NumParam4 };
                                            DataView dvcorr3 = dbo.ExceSQL(string.Format("SELECT f_managetaskkindindex,F_MANAGETASKINDEX,F_NUMPARAM1,F_NUMPARAM4,f_monitorindex 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_no1 = {5} and F_NUMPARAM4 != {6} and F_NUMPARAM1 in (SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where F_NEARGETDEVICE={4}) order by F_SPLITTIME asc", obarr3)).Tables[0].DefaultView;
                                            if (dvcorr3.Count > 0)
                                            {
                                                for (int n = 0; n < dvcorr3.Count; n++)
                                                {
                                                    int controltype = ccf.GetManageTaskTypefromMonitor(Convert.ToInt32(dvcorr3[n]["f_monitorindex"]));
                                                    int tempRELATIVE = ccf.GetRELATIVECONTORLIDFromManageTask(Convert.ToInt32(dvcorr3[n]["f_managetaskkindindex"]), Convert.ToInt32(dvcorr3[n]["F_MANAGETASKINDEX"]));
                                                    if ((controltype == manageTaskType) && (tempRELATIVE == -1))//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                                                        //if (controltype == manageTaskType)//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                                                    {
                                                        int correlfid = Convert.ToInt32(dvcorr3[n]["F_MANAGETASKINDEX"]);
                                                        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}", Convert.ToInt32(dvcorr3[n]["F_NUMPARAM1"]))));
                                                        if ((_NumParam1 == 12428) && (rgvCorrelStationt != 12428))
                                                        {
                                                            if (rgvCorrelForkNo == 1)
                                                            {
                                                                rgvForkNo = 2;
                                                            }
                                                            else
                                                            {
                                                                rgvForkNo = 1;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if (rgvForkNo == 1)
                                                            {
                                                                rgvCorrelForkNo = 2;
                                                            }
                                                            else
                                                            {
                                                                rgvCorrelForkNo = 1;
                                                            }
                                                        }
                                                        SetRgvCorrelManageTaskNEW(deviceIdx, manageKindIdx, manageTaskIdx, MonitorIndex, rgvForkNo, correlfid, Convert.ToInt32(dvcorr3[n]["f_monitorindex"]), rgvCorrelForkNo);
                                                        return false;
                                                    }
                                                }
                                            }
                                            else//缓存站台取货配不上双叉，只分配货叉
                                            {
                                                //发送任务时无法置关联分配货叉
                                                int rgvForkNo = Convert.ToInt32(dvcorrl[0]["F_FORKNO"]);//本任务取货货叉
                                                if (rgvForkNo != 0)
                                                {
                                                    sql.Remove(0, sql.Length);
                                                    sql.Append("update T_Manage_Task set FUseAwayFork = '").Append(rgvForkNo).Append("'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                                                    dbo.ExecuteSql(sql.ToString());
                                                    sql.Remove(0, sql.Length);
                                                    sql.Append("update T_Monitor_Task set F_UseAwayFork = '").Append(rgvForkNo).Append("' where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                                                    dbo.ExecuteSql(sql.ToString());

                                                    int temprgvForkNo = GetUseForkfrommonitor(MonitorIndex);//本任务取货货叉
                                                    if ((rgvForkNo == 2)&&(temprgvForkNo!=2))
                                                    {
                                                        dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'{0}.0','{0}.1')  WHERE (F_MONITORINDEX= {1})", deviceIdx, MonitorIndex));
                                                        return false;
                                                    }
                                                }
                                                else
                                                {
                                                    rgvForkNo = 1;
                                                    sql.Remove(0, sql.Length);
                                                    sql.Append("update T_Manage_Task set FUseAwayFork = '").Append(rgvForkNo).Append("'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                                                    dbo.ExecuteSql(sql.ToString());
                                                    sql.Remove(0, sql.Length);
                                                    sql.Append("update T_Monitor_Task set F_UseAwayFork = '").Append(rgvForkNo).Append("' where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                                                    dbo.ExecuteSql(sql.ToString());
                                                }
                                            }
                                        }
                                    }
                                }
                                else//非中转站台取货任务
                                {
                                    DataView dvcorrlGJN = dbo.ExceSQL(string.Format("SELECT F_CORRELDEVICEINDEX,F_FORKNO,F_NEARGETDEVICE FROM T_BASE_RGV_GATE where  F_RGVGATEDEVICEINDEX={0}", _NumParam4)).Tables[0].DefaultView;//F_CORRELDEVICEINDEX != {1} and

                                    int neargateArea = Convert.ToInt32(dvcorrlGJN[0]["F_NEARGETDEVICE"]);//获取送货区域
                                    object[] obarr4 = new object[7] { manageKindIdx, deviceIdx, deviceOrder, MonitorIndex, neargateArea, 1, _NumParam4 };
                                    DataView dvcorr4 = dbo.ExceSQL(string.Format("SELECT f_managetaskkindindex,F_MANAGETASKINDEX,F_NUMPARAM1,F_NUMPARAM4,f_monitorindex 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_no1 = {5} and F_NUMPARAM4 != {6} and F_NUMPARAM4 in (SELECT F_RGVGATEDEVICEINDEX FROM T_BASE_RGV_GATE where F_NEARGETDEVICE={4}) order by F_SPLITTIME asc", obarr4)).Tables[0].DefaultView;
                                    if (dvcorr4.Count > 0)
                                    {
                                        for (int n = 0; n < dvcorr4.Count; n++)
                                        {
                                            int controltype = ccf.GetManageTaskTypefromMonitor(Convert.ToInt32(dvcorr4[n]["f_monitorindex"]));
                                            int tempRELATIVE = ccf.GetRELATIVECONTORLIDFromManageTask(Convert.ToInt32(dvcorr4[n]["f_managetaskkindindex"]), Convert.ToInt32(dvcorr4[n]["F_MANAGETASKINDEX"]));
                                            if ((controltype == manageTaskType) && (tempRELATIVE == -1))//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                                                //if (controltype == manageTaskType)//查找到的任务和欲发送任务出库找出库关联，入库找入库关联
                                            {
                                                int correlfid = Convert.ToInt32(dvcorr4[n]["F_MANAGETASKINDEX"]);
                                                //按终点站台选取货叉
                                                int rgvForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", _NumParam4)));
                                                int rgvCorrelForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", Convert.ToInt32(dvcorr4[n]["F_NUMPARAM4"]))));

                                                if (neargateArea == 2 || neargateArea == 4)//中转区送货
                                                {
                                                    if ((_NumParam4 == 12428) && (Convert.ToInt32(dvcorr4[n]["F_NUMPARAM4"]) != 12428))
                                                    {
                                                        if (rgvCorrelForkNo == 1)
                                                        {
                                                            rgvForkNo = 2;
                                                        }
                                                        else
                                                        {
                                                            rgvForkNo = 1;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (rgvForkNo == 1)
                                                        {
                                                            rgvCorrelForkNo = 2;
                                                        }
                                                        else
                                                        {
                                                            rgvCorrelForkNo = 1;
                                                        }
                                                    }
                                                }
                                                else//取送货都非中转区
                                                {
                                                    if (rgvForkNo == 0 || rgvCorrelForkNo == 0)
                                                    {
                                                        if (rgvForkNo == 0 && rgvCorrelForkNo == 0)//理论上两个任务都叉都为0
                                                        {
                                                            if (_NumParam4 < Convert.ToInt32(dvcorr4[n]["F_NUMPARAM4"]))
                                                            {
                                                                rgvForkNo = 2;
                                                                rgvCorrelForkNo = 1;
                                                            }
                                                            else
                                                            {
                                                                rgvForkNo = 1;
                                                                rgvCorrelForkNo = 2;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if (rgvForkNo == 0 && rgvCorrelForkNo != 0)
                                                            {
                                                                if (rgvCorrelForkNo == 1)
                                                                {
                                                                    rgvForkNo = 2;
                                                                }
                                                                else
                                                                {
                                                                    rgvForkNo = 1;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                if (rgvForkNo == 1)
                                                                {
                                                                    rgvCorrelForkNo = 2;
                                                                }
                                                                else
                                                                {
                                                                    rgvCorrelForkNo = 1;
                                                                }
                                                            }
                                                        }
                                                    }

                                                }
                                                
                                                SetRgvCorrelManageTaskNEW(deviceIdx, manageKindIdx, manageTaskIdx, MonitorIndex, rgvForkNo, correlfid, Convert.ToInt32(dvcorr4[n]["f_monitorindex"]), rgvCorrelForkNo);
                                                return false;
                                            }
                                        }
                                    }
                                    else//非中转站台取货任务没配上双叉，只分配货叉
                                    {
                                        //发送任务时无法置关联分配货叉
                                        int rgvForkNo = Convert.ToInt32(dbo.GetSingle(string.Format("SELECT F_FORKNO FROM T_BASE_RGV_GATE where F_RGVGATEDEVICEINDEX={0}", _NumParam4)));
                                        if (rgvForkNo != 0)
                                        {
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Manage_Task set FUseAwayFork = '").Append(rgvForkNo).Append("'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                                            dbo.ExecuteSql(sql.ToString());
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Monitor_Task set F_UseAwayFork = '").Append(rgvForkNo).Append("' where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                                            dbo.ExecuteSql(sql.ToString());
                                            int temprgvForkNo = GetUseForkfrommonitor(MonitorIndex);//本任务取货货叉
                                            if ((rgvForkNo == 2) && (temprgvForkNo != 2))
                                            //if (rgvForkNo == 2)
                                            {
                                                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect =replace(F_AheadDetect,'{0}.0','{0}.1')  WHERE (F_MONITORINDEX= {1})", deviceIdx, MonitorIndex));
                                                return false;
                                            }
                                        }
                                        else
                                        {
                                            rgvForkNo = 1;
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Manage_Task set FUseAwayFork = '").Append(rgvForkNo).Append("'").Append(" where F_ManageTaskKindIndex=").Append(manageKindIdx).Append(" and FID=").Append(manageTaskIdx);
                                            dbo.ExecuteSql(sql.ToString());
                                            sql.Remove(0, sql.Length);
                                            sql.Append("update T_Monitor_Task set F_UseAwayFork = '").Append(rgvForkNo).Append("' where F_ManageTASKKINDINDEX=").Append(manageKindIdx).Append(" and F_ManageTaskIndex=").Append(manageTaskIdx);
                                            dbo.ExecuteSql(sql.ToString());
                                        }
                                    }
                                }
                            }
                        }
                        #endregion
                        #region gjn记录更新完车能发送任务的时间，为等待配叉的起始时间，超时单叉走
                        //int tempaheadtimeFLag = ccf.GetdoubletimeFlagFromMonitor(MonitorIndex);
                        //if (ccf.GetRELATIVECONTORLIDFromManageTask(manageKindIdx, manageTaskIdx) <= 0 && devinfo.DeviceKind == 4 && devinfo.ForkAmount == 2 && deviceOrder == 2)
                        //{
                        //    if (tempaheadtimeFLag == 0)
                        //    {
                        //        ccf.SetdoubletimeFromMonitor(MonitorIndex);
                        //        ccf.SetdoubletimeFlagFromMonitor(MonitorIndex);
                        //        return false;
                        //    }
                        //    else
                        //    {
                        //        DateTime startTime = Convert.ToDateTime(dbo.GetSingle(string.Format("select  f_starttime  from  T_Monitor_Task where f_monitorindex={0}", MonitorIndex)));
                        //        TimeSpan SecoundSpan = new TimeSpan(DateTime.Now.Ticks - startTime.Ticks);
                        //        int TimeLong = (int)SecoundSpan.Seconds;
                        //        if (TimeLong < WaitSetDoubleForkTime)
                        //        {
                        //            AheadDetectUnallow.Clear();
                        //            AheadDetectUnallow.Append(_DeviceIdx.ToString() + "等待配双叉");
                        //            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                        //            return false;
                        //        }
                        //        else
                        //        {
                        //            //do nothing 发送
                        //        }

                        //    }
                        //}
                        #endregion
                        #region 避让gjn
                        if (devinfo.DeviceKind == 4 && devinfo.VirtualStack > 0 && devinfo.VirtualStack != devinfo.DeviceIndex)
                        {
                            DataView dvspS = new DataView(); DataView dvspE = new DataView(); DataView dvspifcreat = new DataView();
                            DataView dvgjn = new DataView();
                            DataView dvspavoid = new DataView(); DataView dvspavoid2 = new DataView();
                            int locationTask = 0; int locationRelationTask = 0;

                            Model.MDevice devinfoUse = Model.CGetInfo.GetDeviceInfo(devinfo.DeviceIndex);
                            Model.MDevice[] devinfoOther = new Model.MDevice[2];
                            DataView dvVirtual = dbo.ExceSQL(string.Format("SELECT F_RGVINDEX,F_RGVLANENO,F_VIRTUALRGV FROM T_BASE_RGVINFO where f_virtualrgv = {0} and F_VIRTUALRGV<>F_RGVINDEX and F_RGVINDEX != {1}", devinfo.VirtualStack, devinfo.DeviceIndex)).Tables[0].DefaultView;
                            for (int j = 0; j < dvVirtual.Count; j++)
                            {
                                devinfoOther[j] = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(dvVirtual[j]["F_RGVINDEX"]));
                            }

                            int MonitorIndexRelation = ccf.GetRELATIVECONTORLIDFromManageTask(manageKindIdx, manageTaskIdx);
                            #region 无关联任务时避让处理
                            if (MonitorIndexRelation == -1)
                            {
                                int[] coor = Model.CGeneralFunction.GetCoorFromMonitorRGV(MonitorIndex);//获得堆垛机的取货和送货坐标
                                if (coor == null)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                int Xcoor = coor[0];
                                int XcoorS = coor[1];
                                if ((deviceOrder == 2) || (deviceOrder == 7))
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select  F_ADDRESS  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex  =  ").Append(Xcoor).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);//ORDER BY  desc, asc
                                    dvspS = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (dvspS.Count > 0)
                                    {
                                        locationTask = Convert.ToInt32(dvspS[0]["F_ADDRESS"]);
                                    }
                                    else
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;
                                    }
                                }
                                else if (deviceOrder == 3)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select  F_ADDRESS  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex  =  ").Append(XcoorS).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);//ORDER BY  desc, asc
                                    dvspS = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (dvspS.Count > 0)
                                    {
                                        locationTask = Convert.ToInt32(dvspS[0]["F_ADDRESS"]);
                                    }
                                    else
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;
                                    }
                                }
                                //取出所用车当前位置和指令位置大小，即确定行程
                                int tempMin = devinfoUse.XCoor < locationTask ? devinfoUse.XCoor : locationTask;
                                int tempMax = devinfoUse.XCoor > locationTask ? devinfoUse.XCoor : locationTask;
                                //取出任务条码
                                string temp_F_TxtParam = ccf.GetF_TxtParamfromMonitor(MonitorIndex);

                                bool ifcreat = false;
                                for (int j = 0; j < devinfoOther.Length; j++)//查询另外车辆是否需要对此任务的避让任务及处理方式
                                {
                                    if (devinfoOther[j] == null)
                                    {
                                        continue;
                                    }
                                    dvspifcreat = dbo.ExceSQL(string.Format("select F_Status  from T_Monitor_Task where F_DeviceIndex={0} and F_TxtParam='{1}' and  F_ManageTASKKINDINDEX = 4", devinfoOther[j].DeviceIndex, temp_F_TxtParam)).Tables[0].DefaultView;
                                    if (dvspifcreat.Count <= 0)
                                    {
                                        ifcreat = true;
                                    }
                                    else
                                    {
                                        if (Convert.ToInt32(dvspifcreat[0]["F_Status"]) > 1)//添加避让任务已经执行后可以发送当前要执行任务
                                        {
                                            ifcreat = true;//do nothing 发送当前任务
                                        }
                                        else
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append("等待避让任务执行");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                }
                                int tempreturnflag = 0;
                                for (int j = 0; j < devinfoOther.Length; j++)//判断其余车是否需要避让
                                {
                                    //int Reserve_task_otherdevice = Get_F_ManTaskReserve(devinfoOther.DeviceIndex);
                                    int OtherDeviceLockedState = Get_F_LockedState(devinfoOther[j].DeviceIndex);
                                    int otherXcoorE;
                                    GetStackRunX_Zcoor(devinfoOther[j].DeviceIndex, out otherXcoorE);
                                    if ((devinfoOther[j].XCoor > tempMin - safe_distance) && (devinfoOther[j].XCoor < tempMax + safe_distance))//可能避让车辆当前位置在避让区内
                                    {
                                        if ((devinfoOther[j].RunState == 0) && (ifcreat == true) && (otherXcoorE <= 0))//空闲，无避让任务，无>=已发送状态的任务
                                        {
                                            if (devinfoOther[j].DeviceIndex > devinfo.DeviceIndex)//DTJA大车号在条码大的方向
                                            {
                                                dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from  T_BASE_RGV_GATE  where   f_address >={0} and f_channelsindex = {1}   order by f_address ", tempMax + safe_distance+1600, devinfo.VirtualStack)).Tables[0].DefaultView;
                                            }
                                            else
                                            {
                                                dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from T_BASE_RGV_GATE where   f_address <= {0} and f_channelsindex = {1}  order by f_address  DESC ", tempMin - safe_distance-1600, devinfo.VirtualStack)).Tables[0].DefaultView;
                                            }
                                            if (dvspavoid.Count > 0)
                                            {
                                                //if ((Zselect == 1) && (Convert.ToInt32(dvspavoid[0]["ZCoor"]) == 1))//由于记录位置码值都为1叉，当取送货为2叉但避让位1叉时实际避让位置可能不够
                                                //{

                                                //}
                                                int hidx = ccf.GetManageHandIdx();//1
                                                int hmindx = ccf.GetMonitorIndex(hidx, 4);
                                                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_UseAwayFork,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,f_no1) ").
                                                        Append("values(2,").Append(ccf.GetRouteIDsub(devinfoOther[j].DeviceIndex)).Append(",").
                                                        Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(devinfoOther[j].DeviceIndex).
                                                        Append(",").Append(7).Append(",").Append(1).Append(",").Append(dvspavoid[0]["f_rgvgatedeviceindex"]).Append(",0 ,0,0,0,0,'").Append(temp_F_TxtParam).Append("','-',1)");
                                                dbo.ExecuteSql(sql.ToString());

                                                string Sql = string.Empty; string dtime = DateTime.Now.ToString("u");
                                                Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                                                temp_F_TxtParam + "'," + hidx + ",4,-1,1," + devinfoOther[j].DeviceIndex + ",'','" + devinfoOther[j].DeviceIndex
                                                + "'," + dvspavoid[0]["f_rgvgatedeviceindex"] + ",'" + dvspavoid[0]["f_rgvgatedeviceindex"] + "','" + dtime + "',0)";
                                                dbo.ExceSQL(Sql);

                                                sql.Remove(0, sql.Length);//添加预约
                                                sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(manageKindIdx.ToString()).Append(manageTaskIdx.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(devinfoUse.DeviceIndex).Append(")");
                                                dbo.ExceSQL(sql.ToString());
                                                tempreturnflag = 1;
                                            }
                                            else//避让安全距离后超出双叉穿梭车行程范围 
                                            {
                                                if (devinfoOther[j].DeviceIndex > devinfo.DeviceIndex)//DTJA大车号在条码大的方向
                                                {
                                                    dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from  T_BASE_RGV_GATE  where  f_channelsindex = {0}   order by f_address  DESC", devinfo.VirtualStack)).Tables[0].DefaultView;
                                                }
                                                else
                                                {
                                                    dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from T_BASE_RGV_GATE where   f_channelsindex = {0}  order by f_address  ASC ", devinfo.VirtualStack)).Tables[0].DefaultView;
                                                }

                                                if (dvspavoid.Count > 0)
                                                {
                                                    int hidx = ccf.GetManageHandIdx();//2
                                                    int hmindx = ccf.GetMonitorIndex(hidx, 4);
                                                    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_UseAwayFork,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,f_no1) ").
                                                            Append("values(2,").Append(ccf.GetRouteIDsub(devinfoOther[j].DeviceIndex)).Append(",").
                                                            Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(devinfoOther[j].DeviceIndex).
                                                            Append(",").Append(7).Append(",").Append(1).Append(",").Append(dvspavoid[0]["f_rgvgatedeviceindex"]).Append(",0 ,0,0,0,0,'").Append(temp_F_TxtParam).Append("','-',1)");
                                                    dbo.ExecuteSql(sql.ToString());

                                                    string Sql = string.Empty; string dtime = DateTime.Now.ToString("u");
                                                    Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                                                    temp_F_TxtParam + "'," + hidx + ",4,-1,1," + devinfoOther[j].DeviceIndex + ",'','" + devinfoOther[j].DeviceIndex
                                                    + "'," + dvspavoid[0]["f_rgvgatedeviceindex"] + ",'" + dvspavoid[0]["f_rgvgatedeviceindex"] + "','" + dtime + "',0)";
                                                    dbo.ExceSQL(Sql);

                                                    sql.Remove(0, sql.Length);//添加预约
                                                    sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(manageKindIdx.ToString()).Append(manageTaskIdx.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(devinfoUse.DeviceIndex).Append(")");
                                                    dbo.ExceSQL(sql.ToString());
                                                    tempreturnflag = 1;
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (otherXcoorE > 0)//可能避让车有>=已发送非避让任务
                                            {
                                                int Eed_Position = 0;
                                                sql.Remove(0, sql.Length);
                                                sql.Append("select  f_address  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(otherXcoorE).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);//ORDER BY  desc, asc
                                                dvspavoid2 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                                if (dvspavoid2.Count > 0)
                                                {
                                                    Eed_Position = Convert.ToInt32(dvspavoid2[0]["f_address"]);
                                                }
                                                //并且车辆已经运行
                                                if ((((devinfoOther[j].DeviceIndex > devinfo.DeviceIndex) && (Eed_Position > tempMax + safe_distance)) || ((devinfoOther[j].DeviceIndex < devinfo.DeviceIndex) && (Eed_Position < tempMin - safe_distance))) && (devinfoOther[j].RunState == 1))
                                                {
                                                    //直接发送当前任务
                                                }
                                                else
                                                {
                                                    AheadDetectUnallow.Append(string.Format("等待避让设备{0}任务执行完任务! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                            }
                                            else//可能避让车没有>=已发送的指令
                                            {
                                                if ((devinfoOther[j].RunState > 0) || (OtherDeviceLockedState != 0))
                                                {// 报警或者
                                                    AheadDetectUnallow.Append(string.Format("等待避让设备{0}状态恢复! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                                else
                                                {
                                                    AheadDetectUnallow.Append(string.Format("不明原因，请查看车辆{0}状态及任务状态! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                            }
                                        }
                                    }
                                    else//当前位置不在避让区内
                                    {
                                        if (otherXcoorE > 0)//可能避让车,有已发送任务
                                        {
                                            int otheradress = GetBarcodeCoor(otherXcoorE, devinfo.VirtualStack);//获得互斥堆垛机正在执行任务的坐标列条码值

                                            //如果当前位置或者终点位置在避让区，等待执行完任务在判断是否足要避让
                                            if (((devinfoOther[j].XCoor > tempMin - safe_distance) && (devinfoOther[j].XCoor < tempMax + safe_distance)) || ((otheradress < tempMax + safe_distance) && (otheradress > tempMin - safe_distance)))
                                            {//如果避让车任务终点在安全距离外
                                                AheadDetectUnallow.Append(string.Format("等待设备{0}执行完任务! ", devinfoOther[j].DeviceIndex));
                                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                tempreturnflag = 1;
                                            }
                                        }
                                    }
                                }
                                if (tempreturnflag == 1)
                                {
                                    return false;
                                }
                            }
                            #endregion
                            #region 有关联任务时避让处理
                            else//有关联任务
                            {
                                int[] coor1 = Model.CGeneralFunction.GetCoorFromMonitorRGV(MonitorIndex);//获得堆垛机的取货和送货坐标
                                int temp_relationMonitor = 0;
                                sql.Remove(0, sql.Length);//指令关联任务的同车的取送货坐标
                                //sql.Append("SELECT  F_MonitorIndex  FROM T_Monitor_Task WHERE F_ManageTaskIndex = ").Append(MonitorIndexRelation).Append(" AND f_deviceindex like '%154%'").Append(" AND F_DeviceCommandIndex = ").Append(deviceOrder).Append("order by F_MonitorIndex");//东台晶澳特殊写   可以后续优化
                                sql.Append("SELECT  F_MonitorIndex  FROM T_Monitor_Task WHERE F_ManageTaskIndex = ").Append(MonitorIndexRelation).Append(" AND f_deviceindex = ").Append(devinfo.DeviceIndex).Append("order by F_MonitorIndex");//东台晶澳特殊写   可以后续优化

                                DataView dvRealtionMonitor = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                if (dvRealtionMonitor.Count > 0)
                                {
                                    temp_relationMonitor = Convert.ToInt32(dvRealtionMonitor[0]["F_MonitorIndex"]);
                                }
                                int[] coor2 = Model.CGeneralFunction.GetCoorFromMonitorRGV(temp_relationMonitor);//获得堆垛机的取货和送货坐标
                                if (coor1 == null)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("发送关联命令时取送货坐标有误");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }
                                int tempflagrelation = 0;
                                //if ((coor2 == null)&& (deviceOrder == 3))
                                if (dvRealtionMonitor.Count<=0)
                                {
                                    tempflagrelation = 1;
                                }

                                int Xcoor = coor1[0];
                                int XcoorS = coor1[1];
                                int Xcoor1 = coor1[0];
                                int XcoorS1 = coor1[1];
                                if (tempflagrelation == 0)
                                {
                                    Xcoor1 = coor2[0];
                                    XcoorS1 = coor2[1];
                                }

                                if ((deviceOrder == 2) || (deviceOrder == 7))
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select  F_ADDRESS  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex  = ").Append(Xcoor).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);
                                    dvspS = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (dvspS.Count > 0)
                                    {
                                        locationTask = Convert.ToInt32(dvspS[0]["F_ADDRESS"]);
                                    }
                                    else
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;
                                    }

                                    if (tempflagrelation == 0)
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append("select  F_ADDRESS from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(Xcoor1).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);
                                        dvspS = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                        if (dvspS.Count > 0)
                                        {
                                            locationRelationTask = Convert.ToInt32(dvspS[0]["F_ADDRESS"]);
                                        }
                                        else
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                }
                                else if (deviceOrder == 3)
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("select  F_ADDRESS from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(XcoorS).Append(" and   f_channelsindex =  ").Append(devinfo.VirtualStack);
                                    dvspE = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                    if (dvspE.Count > 0)
                                    {
                                        locationTask = Convert.ToInt32(dvspE[0]["F_ADDRESS"]);
                                    }
                                    else
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;
                                    }

                                    if (tempflagrelation == 0)
                                    {
                                        sql.Remove(0, sql.Length);
                                        sql.Append("select  F_ADDRESS from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(XcoorS1).Append(" and   f_channelsindex =  ").Append(devinfo.VirtualStack);
                                        dvspE = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                        if (dvspE.Count > 0)
                                        {
                                            locationRelationTask = Convert.ToInt32(dvspE[0]["F_ADDRESS"]);
                                        }
                                        else
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append("发送命令时取送货坐标有误");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                }
                                int tempMin = devinfoUse.XCoor < locationTask ? devinfoUse.XCoor : locationTask;
                                if (tempflagrelation == 0)
                                {
                                    tempMin = tempMin < locationRelationTask ? tempMin : locationRelationTask;
                                }
                                int tempMax = devinfoUse.XCoor > locationTask ? devinfoUse.XCoor : locationTask;
                                if (tempflagrelation == 0)
                                {
                                    tempMax = tempMax > locationRelationTask ? tempMax : locationRelationTask;
                                }
                                string temp_F_TxtParam = ccf.GetF_TxtParamfromMonitor(MonitorIndex);

                                bool ifcreat = false;

                                for (int j = 0; j < devinfoOther.Length; j++)//查询另外车辆是否需要对此任务的避让任务及处理方式 
                                {
                                    dvspifcreat = dbo.ExceSQL(string.Format("select F_MonitorIndex,F_NumParam2,F_Status from T_Monitor_Task where F_DeviceIndex={0} and F_TxtParam='{1}' and  F_ManageTASKKINDINDEX = 4", devinfoOther[j].DeviceIndex, temp_F_TxtParam)).Tables[0].DefaultView;
                                    if (dvspifcreat.Count <= 0)
                                    {
                                        ifcreat = true;
                                    }
                                    else
                                    {
                                        if (Convert.ToInt32(dvspifcreat[0]["F_Status"]) > 1)//添加避让任务已经执行后可以发送当前要执行任务
                                        {
                                            ifcreat = true;//do nothing 发送当前任务
                                        }
                                        else
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append("等待避让任务执行结束");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                }

                                int tempreturnflag = 0;
                                int temphavetaskflag = 0;
                                for (int j = 0; j < devinfoOther.Length; j++)//判断其余车是否需要避让
                                {
                                    DataView dvdtja = dbo.ExceSQL(string.Format("select F_MonitorIndex,F_NumParam2,F_Status from T_Monitor_Task where F_DeviceIndex={0} and F_DeviceCommandIndex = 7 and  F_ManageTASKKINDINDEX = 4", devinfoOther[j].DeviceIndex)).Tables[0].DefaultView;
                                    if (dvdtja.Count <= 0)
                                    {
                                        temphavetaskflag = 1;
                                    }
                                    int otherXcoorE;
                                    GetStackRunX_Zcoor(devinfoOther[j].DeviceIndex, out otherXcoorE);
                                    int OtherDeviceLockedState = Get_F_LockedState(devinfoOther[j].DeviceIndex);
                                    if ((devinfoOther[j].XCoor > tempMin - safe_distance) && (devinfoOther[j].XCoor < tempMax + safe_distance))//可能避让车辆当前位置在避让区内
                                    {
                                        if ((devinfoOther[j].RunState == 0) && (ifcreat == true) && (otherXcoorE <= 0))////空闲，无避让任务，无>=已发送状态的任务
                                        {
                                            if (devinfoOther[j].DeviceIndex > devinfo.DeviceIndex)//DTJA大车号在条码大的方向
                                            {
                                                dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from  T_BASE_RGV_GATE  where   f_address >={0} and f_channelsindex = {1}   order by f_address ", tempMax + safe_distance+1600, devinfo.VirtualStack)).Tables[0].DefaultView;
                                            }
                                            else
                                            {
                                                dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from T_BASE_RGV_GATE where   f_address <= {0} and f_channelsindex = {1}  order by f_address  DESC ", tempMin - safe_distance-1600, devinfo.VirtualStack)).Tables[0].DefaultView;
                                            }
                                            if (dvspavoid.Count > 0)
                                            {
                                                dvspifcreat = dbo.ExceSQL(string.Format("select F_TxtParam,F_Status from T_Monitor_Task where F_DeviceIndex={0}  and  F_ManageTASKKINDINDEX = 4 and f_devicecommandindex =7 and F_NumParam1 = {1}", devinfoOther[j].DeviceIndex, dvspavoid[0]["f_rgvgatedeviceindex"])).Tables[0].DefaultView;
                                                if ((dvspifcreat.Count <= 0)&&(temphavetaskflag == 1))//添加不存在此车的避让任务才插入新任务
                                                {
                                                    int hidx = ccf.GetManageHandIdx();//
                                                    int hmindx = ccf.GetMonitorIndex(hidx, 4);
                                                    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_UseAwayFork,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,f_no1) ").
                                                            Append("values(2,").Append(ccf.GetRouteIDsub(devinfoOther[j].DeviceIndex)).Append(",").
                                                            Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(devinfoOther[j].DeviceIndex).
                                                            Append(",").Append(7).Append(",").Append(1).Append(",").Append(dvspavoid[0]["f_rgvgatedeviceindex"]).Append(",0 ,0,0,0,0,'").Append(temp_F_TxtParam).Append("','-',1)");
                                                    dbo.ExecuteSql(sql.ToString());

                                                    string Sql = string.Empty; string dtime = DateTime.Now.ToString("u");
                                                    Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                                                    temp_F_TxtParam + "'," + hidx + ",4,-1,1," + devinfoOther[j].DeviceIndex + ",'','" + devinfoOther[j].DeviceIndex
                                                    + "'," + dvspavoid[0]["f_rgvgatedeviceindex"] + ",'" + dvspavoid[0]["f_rgvgatedeviceindex"] + "','" + dtime + "',0)";
                                                    dbo.ExceSQL(Sql);

                                                    sql.Remove(0, sql.Length);//添加预约
                                                    sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(manageKindIdx.ToString()).Append(manageTaskIdx.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(devinfoUse.DeviceIndex).Append(")");
                                                    dbo.ExceSQL(sql.ToString());
                                                    tempreturnflag = 1;
                                                }
                                            }
                                            else//避让安全距离后超出双叉穿梭车行程范围 
                                            {
                                                if (devinfoOther[j].DeviceIndex > devinfo.DeviceIndex)//DTJA大车号在条码大的方向
                                                {
                                                    dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from  T_BASE_RGV_GATE  where  f_channelsindex = {0}   order by f_address  DESC", devinfo.VirtualStack)).Tables[0].DefaultView;
                                                }
                                                else
                                                {
                                                    dvspavoid = dbo.ExceSQL(string.Format("select f_rgvgatedeviceindex  from T_BASE_RGV_GATE where   f_channelsindex = {0}  order by f_address  ASC ", devinfo.VirtualStack)).Tables[0].DefaultView;
                                                }

                                                if (dvspavoid.Count > 0)
                                                {
                                                    dvspifcreat = dbo.ExceSQL(string.Format("select F_TxtParam,F_Status from T_Monitor_Task where F_DeviceIndex={0}  and  F_ManageTASKKINDINDEX = 4 and f_devicecommandindex =7 and F_NumParam1 = {1}", devinfoOther[j].DeviceIndex, dvspavoid[0]["f_rgvgatedeviceindex"])).Tables[0].DefaultView;
                                                   // if (dvspifcreat.Count <= 0) 
                                                    if ((dvspifcreat.Count <= 0) && (temphavetaskflag == 1))//添加不存在此车的避让任务才插入新任务
                                                        {
                                                        int hidx = ccf.GetManageHandIdx();//4
                                                        int hmindx = ccf.GetMonitorIndex(hidx, 4);
                                                        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_UseAwayFork,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4,F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,f_no1) ").
                                                                Append("values(2,").Append(ccf.GetRouteIDsub(devinfoOther[j].DeviceIndex)).Append(",").
                                                                Append(hidx).Append(",4,").Append(hmindx).Append(",").Append(devinfoOther[j].DeviceIndex).
                                                                Append(",").Append(7).Append(",").Append(1).Append(",").Append(dvspavoid[0]["f_rgvgatedeviceindex"]).Append(",0 ,0,0,0,0,'").Append(temp_F_TxtParam).Append("','-',1)");
                                                        dbo.ExecuteSql(sql.ToString());

                                                        string Sql = string.Empty; string dtime = DateTime.Now.ToString("u");
                                                        Sql = "insert into T_Manage_Task(FPALLETBARCODE,FID,F_ManageTaskKindIndex,F_RELATIVECONTORLID,FIntoStepOK,FSTARTDEVICE,FREMARK,FSTARTCELL,FENDDEVICE,FENDCELL,FBEGTIME,WORK_MODE) values('" +
                                                        temp_F_TxtParam + "'," + hidx + ",4,-1,1," + devinfoOther[j].DeviceIndex + ",'','" + devinfoOther[j].DeviceIndex
                                                        + "'," + dvspavoid[0]["f_rgvgatedeviceindex"] + ",'" + dvspavoid[0]["f_rgvgatedeviceindex"] + "','" + dtime + "',0)";
                                                        dbo.ExceSQL(Sql);

                                                        sql.Remove(0, sql.Length);//添加预约
                                                        sql.Append("UPDATE T_Base_Device SET F_ManTaskReserve = (").Append(manageKindIdx.ToString()).Append(manageTaskIdx.ToString()).Append(") WHERE (F_DeviceIndex = ").Append(devinfoUse.DeviceIndex).Append(")");
                                                        dbo.ExceSQL(sql.ToString());
                                                        tempreturnflag = 1;
                                                    }
                                                }
                                            }
                                        }
                                        else
                                        {
                                            if (otherXcoorE > 0)//可能避让车有>=已发送非避让任务
                                            {
                                                int End_Position = 0;
                                                sql.Remove(0, sql.Length);
                                                sql.Append("select  f_address  from  T_BASE_RGV_GATE  where f_rgvgatedeviceindex =  ").Append(otherXcoorE).Append(" and   f_channelsindex = ").Append(devinfo.VirtualStack);//ORDER BY  desc, asc
                                                dvspavoid2 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
                                                if (dvspavoid2.Count > 0)
                                                {
                                                    End_Position = Convert.ToInt32(dvspavoid2[0]["f_address"]);
                                                }
                                                //并且车辆已经运行
                                                if ((((devinfoOther[j].DeviceIndex > devinfo.DeviceIndex) && (End_Position > tempMax + safe_distance)) || ((devinfoOther[j].DeviceIndex < devinfo.DeviceIndex) && (End_Position < tempMin - safe_distance))) && (devinfoOther[j].RunState == 1))
                                                {
                                                    //直接发送当前任务
                                                }
                                                else
                                                {
                                                    AheadDetectUnallow.Append(string.Format("等待避让设备{0}任务执行完任务! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                            }
                                            else//可能避让车没有>=已发送的指令
                                            {
                                                if ((devinfoOther[j].RunState > 0) || (OtherDeviceLockedState != 0))
                                                {// 报警或者
                                                    AheadDetectUnallow.Append(string.Format("等待避让设备{0}状态恢复! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                                else
                                                {
                                                    AheadDetectUnallow.Append(string.Format("不明原因，请查看车辆{0}状态及任务状态! ", devinfoOther[j].DeviceIndex));
                                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                    tempreturnflag = 1;
                                                }
                                            }
                                        }
                                    }
                                    else//当前位置不在避让区内
                                    {
                                        if (otherXcoorE > 0)//可能避让车,有已发送任务
                                        {
                                            int otheradress = GetBarcodeCoor(otherXcoorE, devinfo.VirtualStack);//获得互斥堆垛机正在执行任务的坐标列条码值
                                            //int otheradress = 0;

                                            //try
                                            //{
                                            //    dvgjn = dbo.ExceSQL(string.Format("SELECT f_address FROM T_BASE_RGV_GATE WHERE f_rgvgatedeviceindex = {0} and f_channelsindex = {1})", otherXcoorE, devinfo.VirtualStack)).Tables[0].DefaultView;
                                            //    if (dvgjn.Count > 0)
                                            //    {
                                            //        otheradress = Convert.ToInt32(dvgjn[0][0]);
                                            //    }
                                            //}
                                            //catch (Exception ex)
                                            //{
                                            //    throw ex;
                                            //}

                                            //如果当前位置或者终点位置在避让区，等待执行完任务在判断是否足要避让
                                            if (((devinfoOther[j].XCoor > tempMin - safe_distance) && (devinfoOther[j].XCoor < tempMax + safe_distance)) || ((otheradress < tempMax + safe_distance) && (otheradress > tempMin - safe_distance)))
                                            {//如果避让车任务终点在安全距离外
                                                AheadDetectUnallow.Append(string.Format("等待设备{0}执行完任务! ", devinfoOther[j].DeviceIndex));
                                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                                tempreturnflag = 1;
                                            }
                                        }
                                    }
                                }
                                if (tempreturnflag == 1)
                                {
                                    return false;
                                }
                            }
                            #endregion
                        }
                        #endregion

                        #region 添加直穿货叉2次选择
                        if (devinfo.DeviceKind == 4 && devinfo.VirtualStack > 0 && devinfo.VirtualStack != devinfo.DeviceIndex)
                        {
                            int MonitorIndexRelation = ccf.GetRELATIVECONTORLIDFromManageTask(manageKindIdx, manageTaskIdx);
                            if (MonitorIndexRelation == -1)
                            {
                                int fork = 0;//后续测试应该没用
                                DataView dvfork = dbo.ExceSQL(string.Format("select f_useawayfork  from T_MONITOR_TASK where F_MONITORINDEX={0}", MonitorIndex)).Tables[0].DefaultView;
                                if (dvfork.Count > 0)
                                {
                                    fork = Convert.ToInt32(dvfork[0]["f_useawayfork"]);
                                }
                                if (fork == 0)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET f_useawayfork = 1  WHERE (f_managetaskindex= {0})", manageTaskIdx));
                                }
                            }
                            else
                            {
                                //暂时发现没选货叉的都是无关联人物do nothing 
                            }
                        }
                        #endregion
                        
                        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];
                                }
                                DataView dvAlreadyHavemonitorTask = dbo.ExceSQL(string.Format("select F_Status  from T_Monitor_Task where F_Status > 0 and F_DeviceIndex={0}", deviceIdx)).Tables[0].DefaultView;
                                if (dvAlreadyHavemonitorTask.Count >0)
                                {
                                    AheadDetectUnallow.Clear();
                                    AheadDetectUnallow.Append("此车有>已发送的任务");
                                    UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                    return false;
                                }

                                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_Base_PLC_Ask.F_BarCode = T_Monitor_Task.F_TxtParam 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() != 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)
                            {
                                //增加环穿组件车间缓存位取货任务发送成功，更新为无货
                                if (((gc[2] == 22155) || (gc[2] == 22128) || (gc[2] == 22130)))//功能屏蔽组件车间缓存 && (1 == 0)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_BASE_HORT  SET have_flag = 0 WHERE (f_device_index = {0}) ", gc[2]));
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "组件车间由于发送环穿到缓存位取货任务成功更新缓存位为0无货", Convert.ToString(gc[2]), Convert.ToString(gc[2]));
                                }
                                AddOPCSendData(deviceIdx, MonitorIndex, itemnames, itemvalues);

                                //int taskRGV = 0;
                                ////richard.liu20230718，增加给取货输送机发送环穿取货指令索引
                                //object obt = dbo.GetSingle(string.Format("select F_CHANNELSINDEX from T_BASE_RGV_GATE, t_base_device where F_CHANNELSINDEX=f_deviceindex and f_devicekindindex=13 and F_RGVGATEDEVICEINDEX={0}", devidx));
                                //if (obt != null)
                                //{
                                //    obt = dbo.GetSingle(string.Format("select f_monitorindex from  t_monitor_task where f_monitorindex >{0} and f_deviceindex= {1} order by f_monitorindex asc", taskindex, Convert.ToInt32(obt)));
                                //    if (obt != null)
                                //    {
                                //        taskRGV = Convert.ToInt32(obt);
                                //    }
                                //}
                                //gc[2]为环穿取货位置
                                sdo = CommModeCreate.CreateSendDeviceOrder(gc[2]);
                                sdo.SendDeviceOrder(2, MonitorIndex, 0, gc[2], 0, out itemnames, out itemvalues);
                                AddOPCSendData(gc[2], MonitorIndex, itemnames, itemvalues);
                            }
                        }
                        else
                        {
                            //gjn增加输送线任务发送时，判断此节为起点的任务为管理任务第一条的，如果是送出判断是否由<=1的任务即 等待执行或已发送  如果是非6 判断是否<=2 即只要存在正转或反转就不发送
                            DataView dbt = dbo.ExceSQL(string.Format("select f_devicecommandindex,f_status  from t_monitor_task where  f_no1 = 1 and f_monitorindex != {0} and f_deviceindex ={1}", MonitorIndex, deviceIdx)).Tables[0].DefaultView;
                            {
                                for (int g = 0; g < dbt.Count; g++)
                                {
                                    if (Convert.ToInt32(dbt[g]["f_devicecommandindex"]) == 6)
                                    {
                                        if (Convert.ToInt32(dbt[g]["f_status"]) < 1)//如果有送出任务没执行
                                        {
                                            AheadDetectUnallow.Clear();
                                            AheadDetectUnallow.Append(_DeviceIdx.ToString() + "存在没有执行的送出任务，需要人工确认");
                                            UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                            return false;
                                        }
                                    }
                                    else
                                    {
                                        AheadDetectUnallow.Clear();
                                        AheadDetectUnallow.Append(_DeviceIdx.ToString() + "存在非送出任务，需要人工确认");
                                        UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                        return false;
                                    }
                                }
                            }
                            //gjn增加出库到组件车间，如果对应口有过账任务没确认后续任务最后一步送出任务等待
                            DataView dvPassBill = dbo.ExceSQL(string.Format("select * from t_monitor_task where f_deviceindex = {1} and f_numparam1={0}", Convert.ToInt32("3"+Convert.ToString(gc[5])),gc[5])).Tables[0].DefaultView;
                            if(dvPassBill.Count>0)
                            {
                                AheadDetectUnallow.Clear();
                                AheadDetectUnallow.Append("终点存在没有确认的过账信息");
                                UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
                                return false;
                            }


                            if (deviceIdx == 12230)
                            {
                                int Enddeviexindex = 0;//后续测试应该没用
                                DataView dvEvddeviexindex = dbo.ExceSQL(string.Format("select fenddevice  from  T_MANAGE_TASK  where fid = {0}", manageTaskIdx)).Tables[0].DefaultView;
                                if (dvEvddeviexindex.Count > 0)
                                {
                                    Enddeviexindex = Convert.ToInt32(dvEvddeviexindex[0]["fenddevice"]);
                                    if (Enddeviexindex == 12233)
                                    {
                                        deviceOrder = 8;//东台晶澳拆包再入库时异常路径特殊命令
                                    }
                                }
                            }

                            sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[5], out StringBuilder[] itemnames, out StringBuilder[] itemvalues);
                            //20231017
                            if (sendok == true)
                            {
                                //增加输送线组件车间缓存位送出任务发送成功，更新为无货
                                if (((deviceIdx == 22155) || (deviceIdx == 22128) || (deviceIdx == 22130)))//功能屏蔽组件车间缓存 && (1 == 0)
                                {
                                    dbo.ExecuteSql(string.Format("UPDATE T_BASE_HORT  SET have_flag = 0 WHERE (f_device_index = {0}) ", deviceIdx));
                                    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "组件车间由于发送输送线缓存位送出任务成功更新缓存位为0无货", Convert.ToString(deviceIdx), Convert.ToString(deviceIdx));
                                }

                                if (Lasttask.IndexOf(gc[5].ToString()) >= 0)//组件车间通知管理当前执行位置和终点
                                {
                                    sql.Remove(0, sql.Length);
                                    sql.Append("update IO_Control set current_position=").Append(gc[5]).Append(",END_DEVICE_CODE = '").Append(gc[5]).Append("' where Control_ID=").Append(manageTaskIdx);
                                    dboM.ExceSQL(sql.ToString());

                                    CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "更新管理任务当前位置及终点位置", Convert.ToString(gc[5]), Convert.ToString(gc[5]));

                                }
                                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 UpdateRGVNo(int managetaskID,int dummyRgvno, int realRgvno, int monIndex,int oldUnloadConveyor,int unloadConveyor,int goalConveyor)
        {
            try
            {
                //更新实际RGV车号F_DeviceIndex，子路径编号f_routeid
                int routeidsub = ccf.GetRouteIDsub(realRgvno);
                dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex ={0},f_routeid={1},f_goalconveyor={2} WHERE f_managetaskindex = {3}", realRgvno,routeidsub,goalConveyor, managetaskID));
                //更新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));
                
            }
            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>
        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;
            //    //开始循环
            //    while (true)
            //    {
            //        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
            //                        {//出库2，不允许出现大于2情况
            //                            oppositeIOtasktype = 1;
            //                        }
            //                        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;
            //                }
            //                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 exitIdleRgvGate, int goalConveyor)
        //{
        //    try
        //    {
        //        StringBuilder AheadDetect = new StringBuilder();
        //        if (loadORunload == "unload")
        //        {//unload送货
        //            devinfocheck = Model.CGetInfo.GetDeviceInfo(exitIdleRgvGate);
        //            AheadDetect.Clear();
        //            AheadDetect.Append("I").Append(currRgv).Append(";D-").Append(currRgv).Append(".0;I").Append(exitIdleRgvGate).Append(";D").Append(devinfocheck.BindingDevice).Append(";D").Append(devinfocheck.SendOutDetect);//.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)").Append(
        //            "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(0
        //                ).Append(",").Append(currRgv).Append(",").Append(3).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(exitIdleRgvGate).Append(",0").Append(
        //                ",0,").Append(exitIdleRgvGate).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("',").Append(goalConveyor).Append(")");
        //            dbo.ExceSQL(sql.ToString());
        //            //补充上一个取货任务的送货位置的提前检测和送货地址
        //            AheadDetect.Clear();
        //            AheadDetect.Append(";I").Append(exitIdleRgvGate).Append(";D").Append(devinfo.BindingDevice).Append(";D").Append(devinfocheck.SendOutDetect);//.Append(devinfocheck.BindingDeviceOut);//gjn
        //            sql.Clear();
        //            sql.Append("update T_Monitor_Task set F_NumParam4=").Append(exitIdleRgvGate).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(exitIdleRgvGate);
        //            AheadDetect.Clear();
        //            AheadDetect.Append("I").Append(currRgv).Append(";D").Append(currRgv).Append(".0;I").Append(exitIdleRgvGate).Append(";D-").Append(devinfocheck.SendOutDetect);//.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)").Append(
        //            "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(0
        //                ).Append(",").Append(currRgv).Append(",").Append(2).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(exitIdleRgvGate).Append(",0").Append(
        //                ",0,").Append(0).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("')");
        //            dbo.ExceSQL(sql.ToString());
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        throw ex;
        //    }
        //}

        /// <summary>
        /// 插入路过中转站台的任务
        /// </summary>
        /// <param name="mankind">原任务的管理任务类型</param>
        /// <param name="manFID">原任务的管理任务fid</param>
        /// <param name="barcode">任务条码</param>
        /// <param name="routeidsub">此指令routeidsub</param>
        /// <param name="loadORunload">取货还是送货</param>
        /// <param name="currRgv">选定的rgv</param>
        /// <param name="monIndex">新任务的指令ID</param>
        /// <param name="loadstation">取货站台</param>
        /// <param name="unloadStation">,送货位</param>
        /// <param name="goalConveyor">最终送货终点</param>
        /// <param name="usefork">选用货叉</param>
        /// use 
        private void InsertRgvLoadUnloadTask(int mankind, int manFID, string barcode, int routeidsub, string loadORunload, int currRgv, int monIndex, int loadstation,int unloadStation, int goalConveyor,int usefork)
        {
            try
            {
                StringBuilder AheadDetect = new StringBuilder();
                if (loadORunload == "unload")
                {//unload送货
                    devinfocheck = Model.CGetInfo.GetDeviceInfo(unloadStation);
                    Model.MDevice devinfoCurrRgv = Model.CGetInfo.GetDeviceInfo(currRgv);
                    AheadDetect.Clear();
                    if(usefork > 1)//&&(devinfoCurrRgv.DoubleFork)//非多叉设备不可能有>1的货叉
                    {
                        AheadDetect.Append("I").Append(currRgv).Append(";D-").Append(currRgv).Append(".1;I").Append(unloadStation).Append(";D").Append(devinfocheck.BindingDevice);//.Append(";D").Append(devinfocheck.SendOutDetect);//.Append(devinfocheck.BindingDeviceOut);//gjn
                    }
                    else
                    {
                        AheadDetect.Append("I").Append(currRgv).Append(";D-").Append(currRgv).Append(".0;I").Append(unloadStation).Append(";D").Append(devinfocheck.BindingDevice);//.Append(";D").Append(devinfocheck.SendOutDetect);//.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_useawayfork)").Append(
                    "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(0
                        ).Append(",").Append(currRgv).Append(",").Append(3).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(loadstation).Append(",0").Append(
                         ",0,").Append(unloadStation).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("',").Append(goalConveyor).Append(",").Append(usefork).Append(")");
                    dbo.ExceSQL(sql.ToString());
                }
                else
                {//load取货
                    devinfo = Model.CGetInfo.GetDeviceInfo(loadstation);
                    devinfocheck = Model.CGetInfo.GetDeviceInfo(unloadStation);
                    AheadDetect.Clear();
                    if (usefork > 1)
                    {
                        AheadDetect.Append("I").Append(currRgv).Append(";D").Append(currRgv).Append(".1;I").Append(devinfo.DeviceIndex).Append(";D-").Append(devinfo.BindingDevice).Append(";I").Append(devinfocheck.DeviceIndex).Append(";D").Append(devinfocheck.BindingDevice);
                    }
                    else
                    {
                        AheadDetect.Append("I").Append(currRgv).Append(";D").Append(currRgv).Append(".0;I").Append(devinfo.DeviceIndex).Append(";D-").Append(devinfo.BindingDevice).Append(";I").Append(devinfocheck.DeviceIndex).Append(";D").Append(devinfocheck.BindingDevice);

                    }
                    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_useawayfork)").Append(
                    "VALUES (").Append(manFID).Append(",").Append(mankind).Append(",").Append(monIndex).Append(",").Append(0
                        ).Append(",").Append(currRgv).Append(",").Append(2).Append(",").Append(routeidsub).Append(",").Append(0).Append(",").Append(loadstation).Append(",0").Append(
                    ",0,").Append(unloadStation).Append(",0,0,'").Append(AheadDetect.ToString()).Append("','").Append(barcode).Append("',").Append(usefork).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();
            }
        }
    }
}