using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System;
using CommLayerFactory;
using ICommLayer;
using DBFactory;
using CommonLib;
namespace WcfControlMonitorLib
{
/// <summary>
/// Creator:Richard.liu
/// 监控调度类
/// </summary>
public class CControl
{
int StackMutexXCoor = 4000;
int minStackMutexXCoor = 3000;//1488是坐标转换差
int StackZeroXCoor = 4228;
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 devinfo;
Model.MDevice devinfocheck;
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 DISTINCT F_ManageTaskIndex AS MIndex,F_MonitorTaskLevel,F_ManageTaskKindIndex,F_SplitTime FROM T_Monitor_Task where ").Append(
taskkind.ToString()).Append(" order by F_ManageTaskKindIndex desc, F_MonitorTaskLevel desc,F_SplitTime asc, F_ManageTaskIndex asc");//20120616
dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dv.Count > 0)
{
for (int i = 0; i < dv.Count; i++)
{
try
{
//1：提取每个管理单据的第一个设备指令
sql.Remove(0, sql.Length);
if (CStaticClass.DBFactory == "OracleDBFactory")
{//20151120调度系统oracle的特殊语句
sql.Append("select min(F_MonitorIndex) as minMidx,f_status from T_Monitor_Task where rownum=1 and ").Append(taskkind.ToString()).Append(" and F_ManageTaskIndex = ").Append(dv[i]["MIndex"]).Append(" GROUP BY F_MonitorIndex, F_Status");
}
else
{//20151120调度系统SQLServer的特殊语句
sql.Append("select top 1 min(F_MonitorIndex) as minMidx,f_status from T_Monitor_Task where ").Append(taskkind.ToString()).Append(" and F_ManageTaskIndex = ").Append(dv[i]["MIndex"]).Append(" GROUP BY F_MonitorIndex, F_Status");
}
dvM = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
if (dvM.Count > 0)
{//20110412
if (dvM[0]["F_Status"].ToString() == "0" && dvM[0]["minMidx"] != DBNull.Value)
{
SendMonitorTask(Convert.ToInt32(dvM[0]["minMidx"]));
}
else
{
continue;
}
}
else
{
continue;
}
}
catch (Exception ex)
{
CControlError = string.Format("发送命令调用StartOrder时：{0}", ex.StackTrace+ex.Message);
}
}
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 MyRegion
/*
#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 dbo.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
}
#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, "NO") == 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);
if (mforkmonitorinfo!=null)
{
foreach (int i in mforkmonitorinfo.Keys)
{
df = mforkmonitorinfo[i];
if (df != null)
{
if (minMidx != Convert.ToInt32(df[0]) && AheadDetectOK(Convert.ToInt32(df[0]), df[1], "NO") == 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 dbo.T_Monitor_Task WHERE (F_ManageTaskIndex = ").Append(rman).Append(") AND (F_ManageTASKKINDINDEX = ").Append(rmankind).Append(")");
//dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
//if (dv.Count > 0)
//{
// if ((dv[0]["mmi"] != DBNull.Value) && (dv[0]["mmi"].ToString() != df[0]))
// {
// return true;
// }
//}
#endregion
}
}
}
}
}
#endregion
return false;
}
else
{
return true;
}
#endregion
}
else
{//非AGV设备：输送机、堆垛机、RGV等
#region 非AGV设备：输送机、堆垛机、RGV等
//第一个设备是否被占用，RGV和堆垛机要考虑分步控制时，没执行完连续动作时不接受新的调度任务
if (((_LockedState == 0) && (checkLockedstate == true)) || (checkLockedstate == false))
{
#region 检查RGV、堆垛机等是否被调度任务预约F_ManTaskReserve
if (_ManTaskReserve > 0 && DeviceKind!=2)//20140309
{
devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
if (devinfo.IfCorrelDoubleFork == "1")
{
#region 多叉关联
Dictionary<int,string[]> mforkmonInfo= Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, _DeviceIdx);
bool iftrue = true;
int relfid = ccf.GetRELATIVECONTORLIDFromManageTask(_ManageKindIdx, _ManageTaskIdx);
if (_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + _ManageTaskIdx.ToString())
{
iftrue = false;
}
else
{
if (relfid > 0)
{//20130704
dv = dbo.ExceSQL(string.Format("SELECT FID FROM T_Manage_Task where F_RELATIVECONTORLID={0} and F_ManageTaskKindIndex={1}", relfid, _ManageKindIdx)).Tables[0].DefaultView;
for (int mt = 0; mt < dv.Count; mt++)
{
if (_ManTaskReserve.ToString() == _ManageKindIdx.ToString() + dv[mt]["FID"].ToString())
{
iftrue = false;
}
}
}
}
if (iftrue == true)
{
UpdateAheadDetectUnallow(new StringBuilder(_DeviceIdx.ToString() + "被任务预约" + _ManTaskReserve.ToString().Substring(1)), minMidx);
return true;
}
#endregion
}
else
{
if (_ManTaskReserve.ToString() != _ManageKindIdx.ToString() + _ManageTaskIdx.ToString())
{
UpdateAheadDetectUnallow(new StringBuilder(_DeviceIdx.ToString() + "被任务预约" + _ManTaskReserve.ToString().Substring(1)), minMidx);
return true;
}
}
}
#endregion
//3：F_AheadDetect检测(检测开关编号组“;”)
if (AheadDetectOK(minMidx, _AheadDetect, "NO") == true)//提前检测通过
{
bool canAssign = true;
int CONTROLTASKTYPE = ccf.GetFCONTROLTASKTYPEFromManageTask(ManageKindIdx, ManageTaskIdx);
devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
if (_DeviceIdx == devinfo.VirtualStack && devinfo.IfCorrelDoubleFork != "1")//20181017
{//20111020
//string DoWorkStack, string ChangeCell, string ChangeStackCell2,int UseAwayFork,int UseAwayFork2, bool DeleteRelative
AssignStackNo(_DeviceIdx, minMidx, ManageKindIdx, ManageTaskIdx,"","","",0,0,false, CONTROLTASKTYPE);
return true;//20120906
}
#region 多叉堆垛机检测，能同步的DoubleFork是否AheadDetectOK
//20100323
//devinfo = Model.CGetInfo.GetDeviceInfo(_DeviceIdx);
if (devinfo.IfCorrelDoubleFork == "1" && devinfo.DeviceKind == 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)
{
if (Array.IndexOf<int>(synctask, i) >= 0)
{//20120906
df = mforkmonitorinfo[i];
if (df != null && Convert.ToInt32(df[0]) != minMidx)//20181007自己可以不用判断了
{
if (AheadDetectOK(Convert.ToInt32(df[0]), df[1], "NO") == false)//多叉关联提前检测失败
{
if (DeviceIdx == devinfo.VirtualStack)//20181007
{
canAssign = false;
break;
}
else
{
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 dbo.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]))
{
if (DeviceIdx == devinfo.VirtualStack)//20181007
{
canAssign = false;
break;
}
else
{
return true;
}
}
}
#endregion
}
}
}
}
if (_DeviceIdx == devinfo.VirtualStack && devinfo.DeviceKind == 1)
{
if (canAssign)//双叉检测都通过
{
string[] df = null;
//查找双叉任务分别对应的取送货堆垛机
Dictionary<int, string[]> mforkmonitorinfo = Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, _DeviceIdx);
bool IfCombinedWork = false;
string getstack, sendstack;
int workstackcount;
bool IfCombinedWork2 = false;
string getstack2, sendstack2;
int workstackcount2;
bool ifget = GetWorkStack(_DeviceIdx, minMidx, out getstack, out sendstack, out IfCombinedWork, out workstackcount);
bool sameCombined = false;//同时倒换堆垛机，此时需要选择两个相邻的中转站台
bool deleteRelative = false;//是否解除关联关系
string workstack = string.Empty;
string cell = "";
string cell2 = "";
string TaskUseAwayFork = "0";//1,2,3;0没分配货叉
string TaskUseAwayFork2 = "0";//1,2,3;0没分配货叉
int temptask = minMidx;
if (mforkmonitorinfo!=null)
{
foreach (int CorrTaskindex in mforkmonitorinfo.Keys)
{
if (CorrTaskindex != minMidx)
{
int ManageTaskIdx2 = ccf.GetManageTaskIndexfromMonitor(CorrTaskindex);
int ManageKindIdx2 = ccf.GetManageTaskKindIndexFromMonitor(CorrTaskindex);
bool ifCorrget = GetWorkStack(_DeviceIdx, CorrTaskindex, out getstack2, out sendstack2, out IfCombinedWork2, out workstackcount2);
if (IfCombinedWork && IfCombinedWork2)//表示同时倒换堆垛机
{
sameCombined = true;//表示同时倒换堆垛机
TaskUseAwayFork = Model.CGeneralFunction.GetUseAwayFork(minMidx);//1,2,3;0没分配货叉
TaskUseAwayFork2 = Model.CGeneralFunction.GetUseAwayFork(CorrTaskindex);//1,2,3;0没分配货叉
//cell = GetChangeStackCellFromStackInfoByFork(getstack, Convert.ToInt32(TaskUseAwayFork));
//cell2 = GetChangeStackCellFromStackInfoByFork(getstack2, Convert.ToInt32(TaskUseAwayFork2));
cell= GetDoubleChangeStackCellFromStackInfoByFork(getstack, Convert.ToInt32(TaskUseAwayFork), Convert.ToInt32(TaskUseAwayFork2), out cell2);
if (cell == "" || cell2 == "")
{
UpdateAheadDetectUnallow(new StringBuilder("需要两个中转站台，存在不可用中转站台"), minMidx);
UpdateAheadDetectUnallow(new StringBuilder("需要两个中转站台，存在不可用中转站台"), CorrTaskindex);
return true;
}
//查找本任务货叉对应的中转站台
//查找关联任务货叉对应的中转站台
//都找到对应中转站台之后，才能进行虚拟堆垛机的分配
//ccf.GetFreeStation();
//ccf.GetFreeStation();
}
if (!IfCombinedWork && !IfCombinedWork2)//都不需要倒换堆垛机
{
//判读取货堆垛机是否相同，如果相同则正常分配，如果不同则解除关联关系
if (getstack != getstack2)
{
if (getstack.Contains(getstack2))//使用关联任务堆垛机
{
workstack = getstack2;
minMidx = CorrTaskindex;
ManageTaskIdx = ManageTaskIdx2;
ManageKindIdx = ManageKindIdx2;
}
else
if (getstack2.Contains(getstack))//使用该堆垛机
{
workstack = getstack;
}
else//解除关联关系
{
deleteRelative = true;
}
}
else//使用谁都可以
{
}
}
if (IfCombinedWork && !IfCombinedWork2)//使用中转的IfCombinedWork的堆垛机
{
workstack = getstack;
if(CONTROLTASKTYPE==1) //入库任务，使用不需要中转的堆垛机
{
workstack = getstack2;
minMidx = CorrTaskindex;
ManageTaskIdx = ManageTaskIdx2;
ManageKindIdx = ManageKindIdx2;
cell2 = "";
}
}
if (!IfCombinedWork && IfCombinedWork2)//使用IfCombinedWork2的堆垛机
{
workstack = getstack2;
minMidx = CorrTaskindex;
if (CONTROLTASKTYPE == 1) //入库任务，使用不需要中转的堆垛机
{
workstack = getstack;
minMidx = temptask;
//ManageTaskIdx = ManageTaskIdx2;
//ManageKindIdx = ManageKindIdx2;//20181219
cell2 = "";
}
}
}
}
}
//string DoWorkStack, string ChangeCell, string ChangeStackCell2,int UseAwayFork,int UseAwayFork2, bool DeleteRelative
AssignStackNo(_DeviceIdx, minMidx, ManageKindIdx, ManageTaskIdx, workstack, cell, cell2,Convert.ToInt32( TaskUseAwayFork),Convert.ToInt32( TaskUseAwayFork2), deleteRelative, CONTROLTASKTYPE);
return true;//20120906
}
return true;//20120906
}
}
#endregion
//if (_DeviceIdx == devinfo.VirtualStack)
//{//20111020
// if(canAssign)
// {
// AssignStackNo(_DeviceIdx, minMidx, ManageKindIdx, ManageTaskIdx);
// }
// return true;//20120906
//}
//检查同步运行的关联设备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]);
}
}
else if (_DeviceKind == 4)
{
if (ccf.NeedOptimize(_DeviceIdx) == true)
{
ccf.InsertMonitorOptimizeChildTask(adidx);
sendok = true;
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, adidx, _DeviceOrder, _DeviceIdx, gc[2]);
}
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, adidx, _DeviceOrder, _DeviceIdx, gc[5]);
}
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);
sql.Append("update T_Monitor_Task set F_StartTime='").Append(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")).Append("',F_Status='1' where F_MonitorIndex=").Append(adidx); //获取到毫秒的时间值20170923
dbo.ExceSQL(sql.ToString());
//返回到原来设备值
_DeviceIdx = DeviceIdx;//设备索引
_routeID = routeID;//路径唯一索引
_serialNumber = serialNumber;//路径上的设备方向性链表的序号
_ManageTaskIdx = ManageTaskIdx;//调度任务索引
_ManageKindIdx = ManageKindIdx;//调度任务类型
_DeviceOrder = DeviceOrder;//设备命令
_LockedState = LockedState;
_Associate = Associate;
_ManTaskReserve = ManTaskReserve;
_AheadDetect = AheadDetect;
_NumParam1 = NumParam1;
_NumParam2 = NumParam2;
_NumParam3 = NumParam3;
_NumParam4 = NumParam4;
_NumParam5 = NumParam5;
_NumParam6 = NumParam6;
_TxtParam = TxtParam;
_DeviceKind = DeviceKind;
_OutsideAltDevice = OutsideAltDevice;
_InsideAltDevice = InsideAltDevice;
_StartDevice = StartDevice;
_EndDevice = EndDevice;
_RouteKind = RouteKind;
_AgvNo = AgvNo;
return false;
}
}
else
{
return true;
}
#endregion
}
else//
{
#region MyRegion
//返回到原来设备值
_DeviceIdx = DeviceIdx;//设备索引
_routeID = routeID;//路径唯一索引
_serialNumber = serialNumber;//路径上的设备方向性链表的序号
_ManageTaskIdx = ManageTaskIdx;//调度任务索引
_ManageKindIdx = ManageKindIdx;//调度任务类型
_DeviceOrder = DeviceOrder;//设备命令
_LockedState = LockedState;
_Associate = Associate;
_ManTaskReserve = ManTaskReserve;
_AheadDetect = AheadDetect;
_NumParam1 = NumParam1;
_NumParam2 = NumParam2;
_NumParam3 = NumParam3;
_NumParam4 = NumParam4;
_NumParam5 = NumParam5;
_NumParam6 = NumParam6;
_TxtParam = TxtParam;
_DeviceKind = DeviceKind;
_OutsideAltDevice = OutsideAltDevice;
_InsideAltDevice = InsideAltDevice;
_StartDevice = StartDevice;
_EndDevice = EndDevice;
_RouteKind = RouteKind;
#endregion
CControlError = string.Format( "拆分调度任务得到的设备指令与详细路径的检索到的关联设备指令不匹配，系统作为没有关联设备指令处理！");
return false;
}
}
else
{
#region 返回到原来设备值
//返回到原来设备值
_DeviceIdx = DeviceIdx;//设备索引
_routeID = routeID;//路径唯一索引
_serialNumber = serialNumber;//路径上的设备方向性链表的序号
_ManageTaskIdx = ManageTaskIdx;//调度任务索引
_ManageKindIdx = ManageKindIdx;//调度任务类型
_DeviceOrder = DeviceOrder;//设备命令
_LockedState = LockedState;
_Associate = Associate;
_ManTaskReserve = ManTaskReserve;
_AheadDetect = AheadDetect;
_NumParam1 = NumParam1;
_NumParam2 = NumParam2;
_NumParam3 = NumParam3;
_NumParam4 = NumParam4;
_NumParam5 = NumParam5;
_NumParam6 = NumParam6;
_TxtParam = TxtParam;
_DeviceKind = DeviceKind;
_OutsideAltDevice = OutsideAltDevice;
_InsideAltDevice = InsideAltDevice;
_StartDevice = StartDevice;
_EndDevice = EndDevice;
_RouteKind = RouteKind;
#endregion
return false;
}
#endregion
}
else
{
return true;
}
}
else
{
return true;
}
#endregion
}
}
catch (Exception ex)
{
CControlError = string.Format("发送命令调用GetFirstDeviceIFLocked时：{0}" ,ex.StackTrace+ex.Message );
return true;
}
finally
{
dv.Dispose();
}
}
/// <summary>
/// 检测指定设备命令的执行先决条件是否成立
/// </summary>
/// <param name="minMidx">监控唯一索引</param>
/// <returns>是否检测通过，true表示设备执行命令的先决条件成立</returns>
public bool AheadDetectOK(int minMidx, string _AheadDetect,string NoDetect)
{
//if (NoDetect!="NO")
{
//获得要发送的信息
if (GetSendInfo(minMidx) == false)
{//20120420
return false;
}
}
AheadDetectUnallow.Remove(0, AheadDetectUnallow.Length);//20110505
int[] States;
string dtime = DateTime.Now.ToString("u");
dtime = dtime.Substring(0, dtime.Length - 1);
int DeviceIdx = _DeviceIdx;
int TaskIdx = minMidx;
int fid = ccf.GetManageTaskIndexfromMonitor(TaskIdx);
int mti = ccf.GetManageTaskKindIndexFromMonitor(TaskIdx);
int DeviceKind = ccf.GetDeviceKindIdx(DeviceIdx);//20100617
int order = ccf.GetDeviceOrderFromMonitor(TaskIdx);
int StartDevice = _StartDevice;//当前调度任务起点
int EndDevice = _EndDevice;//当前调度任务终点
int DeviceOrder = _DeviceOrder;//设备命令
bool checktask = true;
int CONTROLTASKTYPE = ccf.GetFCONTROLTASKTYPEFromManageTask(mti, fid);
int EXCEPTIONNO = ccf.GetExceptionNOFromManageTask(fid, mti);
#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;
//// //}
////}
//string sqlR = string.Format("SELECT CONTROL_FLAG FROM T_Manage_Task WHERE (FID = {0}) AND (F_ManageTaskKindIndex ={1} and CONTROL_FLAG = 0)", fid, mti);
//DataView dvR = dbo.ExceSQL(sqlR).Tables[0].DefaultView;
//if ((dvR.Count > 0) && (DeviceIdx == 15011) && (DeviceOrder == 4 || DeviceOrder == 2))//扬州晶澳判断更换货叉项目实际极限位12004只能用1叉取且单
//{
// int f_fork_used = 0;
// string sqlS = string.Format("SELECT F_NumParam1, F_NumParam2,F_NumParam3 FROM T_Monitor_Task WHERE (F_MonitorIndex = {0})", minMidx);
// DataView dvS = dbo.ExceSQL(sqlS).Tables[0].DefaultView;
// if (dvS.Count > 0)
// {
// string cell = string.Format("{0:D2}-{1:D2}-{2:D2}", Convert.ToInt32(dvS[0]["F_NumParam1"]), Convert.ToInt32(dvS[0]["F_NumParam2"]), Convert.ToInt32(dvS[0]["F_NumParam3"]));
// string sqlG = string.Format("SELECT F_LaneGateDeviceIndex,F_UseAwayFork FROM T_Base_Lane_Gate WHERE (F_ZXY = '{0}' and F_LaneIndex = 18020)", cell);
// DataView dvG = dbo.ExceSQL(sqlG).Tables[0].DefaultView;
// if (dvG.Count > 0)
// {
// if (Convert.ToInt32(dvG[0]["F_LaneGateDeviceIndex"]) == 12002)
// {
// f_fork_used = 2;
// }
// else if (Convert.ToInt32(dvG[0]["F_LaneGateDeviceIndex"]) == 12001)
// {
// f_fork_used = 1;
// }
// else
// {
// if (devinfo.SplitByte_0 == 1 && devinfo.SplitByte_1 == 0)
// {
// f_fork_used = 2;
// }
// else
// {
// f_fork_used = 1;
// }
// }
// sql.Clear();
// sql.Append("UPDATE T_Monitor_Task SET F_UseAwayFork = '").Append(f_fork_used).Append("' WHERE (F_ManageTaskIndex = ")
// .Append(fid).Append(") AND (F_ManageTASKKINDINDEX = ")
// .Append(mti).Append(")");//.Append(DeviceIndex);
// dbo.ExecuteSql(sql.ToString());
// sql.Clear();
// sql.Append("UPDATE T_Manage_Task SET FUseAwayFork = '").Append(f_fork_used).Append("' WHERE (FID = ")
// .Append(fid).Append(") AND (F_ManageTASKKINDINDEX = ")
// .Append(mti).Append(")");
// dbo.ExecuteSql(sql.ToString());
// sql.Clear();
// sql.Append("UPDATE T_Manage_Task SET CONTROL_FLAG = 1 ").Append(" WHERE (FID = ")
// .Append(fid).Append(") AND (F_ManageTASKKINDINDEX = ")
// .Append(mti).Append(")");
// dbo.ExecuteSql(sql.ToString());
// object[] ob = new object[5] { devinfo.DeviceIndex, f_fork_used, fid, mti, DeviceIdx };
// if (f_fork_used == 1)
// {
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}.1', '{0}.0') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={2}) AND (F_ManageTASKKINDINDEX ={3})", ob));
// }
// else if (f_fork_used == 2)
// {
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{0}.0', '{0}.1') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={2}) AND (F_ManageTASKKINDINDEX ={3})", ob));
// }
// }
// }
// AheadDetectUnallow.Clear();
// AheadDetectUnallow.Append("更换货叉及提前检测");
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// 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通讯设备检测设备是否故障
// //gds = CommModeCreate.CreateGetDeviceState(DeviceIdx);
// try
// {
// //States = gds.GetDeviceState(DeviceIdx, TaskIdx);//1完成,2任务号,5设备号
// if (DeviceKind == 13)
// {
// DeviceIdx = GetNowDevice(minMidx);
// }
// States = CStaticClass.GetDeviceState(DeviceIdx);
// }
// catch (Exception ex)
// {//20110505
// RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "提前检测时：" + ex.Message);
// OnRefreshMonitor(rmea);
// return false;
// }
// if (States == null)//没接收到任何返回值
// {
// RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "发送命令时，提前检测没收到PLC数据！");
// OnRefreshMonitor(rmea);
// return false;
// }
// if (((States[1] == 1) || (States[1] >= 30)) && ((DeviceKind != 13) && (DeviceKind != 31)))//运行或者故障
// {
// if (States[1] >= 30)
// {
// devinfo = Model.CGetInfo.GetDeviceInfo(DeviceIdx);
// int ErrId = States[1];
// //20110505
// errs = Model.CGetInfo.GetErrorInfo(Convert.ToInt32(_DeviceKind.ToString() + States[1].ToString()));
// AheadDetectUnallow.Append(DeviceIdx + "有故障：" + errs.ErrorName);
// //20090910
// //有过记录的故障设备的任务号，不再重复处理
// sql.Remove(0, sql.Length);
// sql.Append("SELECT F_DeviceIndex FROM T_Base_Device where F_DeviceIndex=" ).Append( DeviceIdx ).Append( " and F_ErrorTaskNo=" ).Append( TaskIdx );
// ;
// dt = dbo.ExceSQL(sql.ToString()).Tables[0];
// if (dt.Rows.Count >= 1)
// {
// //20110505
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// //记录发生故障的设备正在执行的任务号
// sql.Remove(0, sql.Length);
// sql.Append("update T_Base_Device set F_ErrorTaskNo= " ).Append( TaskIdx ).Append( " where F_DeviceIndex= " ).Append( DeviceIdx);
// dbo.ExceSQL(sql.ToString());
// if (CStaticClass.IsEquals(devinfo.ReturnMessage, States, 2) == true) return false;
// //if ((_DeviceKind == 2) || (_DeviceKind == 4))
// //{//输送机故障清零
// // sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
// // sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0);
// //}
// //if (_DeviceKind == 1) //堆垛机、RGV
// //{
// // sdo = CommModeCreate.CreateSendDeviceOrder(DeviceIdx);
// // sdo.SendDeviceOrder(2, 0, 0, DeviceIdx, 0, 0, 0, 0, 0, 0);
// //}
// //20110505
// RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", "设备索引" + DeviceIdx + "有故障：" + errs.ErrorName);
// OnRefreshMonitor(rmea);
// rmea = new RefreshMonitorEventArgs("notifyIcon1", "警告:" + devinfo.DeviceName + "," + DeviceIdx + "发生故障：" + errs.ErrorName);
// OnRefreshMonitor(rmea);
// if (mti == 1)
// {
// sql.Remove(0, sql.Length);
// sql.Append("update IO_Control set ERROR_TEXT='" ).Append( "准备执行管理任务时：" ).Append( devinfo.DeviceName ).Append( "," ).Append( DeviceIdx ).Append( errs.ErrorName ).Append( "' where Control_ID=" ).Append( fid);
// dboM.ExceSQL(sql.ToString());
// }
// sql.Remove(0, sql.Length);
// sql.Append("update T_Manage_Task set FERRORCODE='" ).Append( "准备执行管理任务时：" ).Append( devinfo.DeviceName ).Append( "," ).Append( DeviceIdx ).Append( errs.ErrorName ).Append( "' where F_ManageTaskKindIndex=" ).Append( mti ).Append( " and FID=" ).Append( fid);
// dbo.ExceSQL(sql.ToString());
// CDataChangeEventArgs cea = new CDataChangeEventArgs(null, null);
// OnDataChange("发送指令提前检测时，",cea);
// }
// return false;
// }
// #endregion
//}
//else
//{
// #region 延吉：20100319 AGV的指令67：允许AGV放残托时，如果有1219的送出指令、1220的指令正在执行或者已发送，提前检测失败，需要等待
// //
// //if (ccf.GetDeviceOrderFromMonitor(minMidx) == 67)
// //{
// // dv = dbo.ExceSQL("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex = 1219) AND (F_DeviceCommandIndex = 6) AND (F_Status > 0)").Tables[0].DefaultView;
// // if (dv.Count > 0)
// // {
// // return false;
// // }
// // dv = dbo.ExceSQL("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceIndex = 1220) AND (F_Status > 0)").Tables[0].DefaultView;
// // if (dv.Count > 0)
// // {
// // 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 限制堆垛机执行同一终点出库任务的数量
//任务为出库时，限制数量>0时，设备为堆垛机时，指令为取货时
int outcount =0;//普通出库任务暂时不限制
string enddevices,startsdevices,strinfo=string.Empty;//拆垛任务终点
string sqlstr = string.Empty;
string checkgoodsdevice = string.Empty;
bool checkSendDevice = true;//出库时在执行取货任务时，是否判断目标输送机的状态
string sqlin = "SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX group by F_ManageTaskIndex";
//只判断起点是巷道的任务
if ( DeviceKind == 1 && (DeviceOrder == 2 || DeviceOrder == 4) && StartDevice.ToString().IndexOf("80") >= 0 && (devinfo.IfCorrelDoubleFork != "1"))// && EndDevice.ToString().IndexOf("180") < 0)//限制不为0，堆垛机， 取货， 起点是巷道
{
//先判断是否有该任务的关联任务已经执行，如果有则该任务也可以执行
//判断逻辑区域与该任务相同的任务数量
//20130402
sqlstr = string.Format("select * from T_Base_TaskCount where F_DeviceIndex={0}", EndDevice);//查找终点设备对应的出库任务获取数量和执行数量
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int getcount, execount;
getcount = Convert.ToInt32(dvdv[0]["F_MAXCOUNT"]);
execount = Convert.ToInt32(dvdv[0]["F_EXECOUNT"]);//T_Base_TaskCount 表的最大出库数量限制
//checkdevice = Convert.ToInt32(dvdv[0]["F_CHECKDEVICE"]);//
enddevices = Convert.ToString(dvdv[0]["F_CHECKENDDEVICE"]);//要判读是否存在该终点的设备
startsdevices = Convert.ToString(dvdv[0]["F_CHECKSTARTDEVICE"]);//要判断是否存在该起点的设备
checkgoodsdevice = Convert.ToString(dvdv[0]["F_CHECKGOODS"]);//判读输送机是否有货
outcount = execount;
if (startsdevices != "0" || enddevices != "0")//表示同时执行时
{
sqlstr = string.Format("SELECT FID,F_ManageTaskKindIndex FROM T_Manage_Task WHERE (FSTARTDEVICE in({0})) OR (FENDDEVICE in({1}))", startsdevices, enddevices);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
if (dvdv.Count > 0)//存在相互干扰的出入库任务时，按出库数量限制
{
outcount = execount;
}
else//只存在当前终点的任务时，按获取数量限制，一般情况 获取数量要大于执行数量
{
outcount = getcount;
}
}
if (outcount > 0)//只有在>0时判断
{
int area = ccf.GetLogicAreaFromManageTask(mti, fid);//获得逻辑区域
sqlstr = string.Format("SELECT FID,F_ManageTaskKindIndex FROM T_Manage_Task WHERE (FSTATUS > 0) AND FID!={0} AND FCONTROLTASKTYPE != 4 AND (FLOGIC_AREA ={1}) ", fid, area);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
int count = dvdv.Count;//已经执行的任务数量
//拆垛位要判断，起位置是否有货
#region 拆垛任务
enddevices = "21001,21002";//拆垛位的任务
if (enddevices.IndexOf(EndDevice.ToString()) >= 0)
{
int device = 0;
if (EndDevice == 21001)
{
device = 22058;
}
else
{
device = 22038;
}
devinfocheck = Model.CGetInfo.GetDeviceInfo(device);
if (devinfocheck != null)
{
if (devinfocheck.SplitByte_1 == 1)//拆垛位有货
{
count += 1;
}
}
strinfo = "拆垛";
}
#endregion
int goodscounts = ccf.GetTransDeviceGoodsCounts(checkgoodsdevice);//判读出库目标输送机货物数量
count += goodscounts;
if (count >= outcount)
{
//如果是已经执行的任务不判断。执行时发生故障，再次发送时可能不满足发送条件
int status = ccf.GetManageTaskStatus(fid, mti);
if (status == 0)//只判断未执行的任务
{
int relFID = Model.CGeneralFunction.GetRelativeControlID(mti, fid); //如果是双叉关联任务则不判断
if (relFID == -1)//对于已经进行双叉关联的任务，不进行判断，由于上面判断了是否有货，所以可能会出现堆垛机取完一个货物后，在取第二个货时不满足条件
{
AheadDetectUnallow.Append(string.Format("{0}出库任务数量限制为:{1}，该出库任务暂时不能执行，请耐心等待! ", strinfo, outcount));
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;//不能执行出库任务
}
}
}
}
else
{//如果出库数量是0的时候 这时候执行出库的时候不执行提前检测，堆垛机会驮个货在身上等着
checkSendDevice = false;
}
}
//判断是否能执行到拆盘机的任务
#region 有拆垛任务时，不能执行空托盘出库任务
int enddeviceindex = 0;
if (EndDevice == 22052)
{
enddeviceindex = 21002;
}
else
if (EndDevice == 22066)
{
enddeviceindex = 21001;
}
if (enddeviceindex>0)
{
sqlstr = string.Format("SELECT FID,F_ManageTaskKindIndex FROM T_Manage_Task WHERE (FSTATUS > 0) and (FLOGIC_AREA ={0}) ", enddeviceindex);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
AheadDetectUnallow.Append(string.Format("存在正在执行的拆垛任务，空托盘出库任务暂时不能执行，请耐心等待!"));
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;//不能执行出库任务
}
}
#endregion
}
#endregion
#region 在发送任务起点是输送机的任务时，要判断不存在该起点的其他任务
////对于一个等待执行的调度任务，当发送第一条设备指令时，要判断是否存在该起点的等待执行的调度任务
////起点设备是输送机
////CControl_AheadDetectOK_NotOnlyOneTask
//if (mti != 4 && ( DeviceKind == 2))
//{
// int status = ccf.GetManageTaskStatus(fid, mti);
// if (status == 0)
// {
// //判断起点设备类型
// //int kind =cc
// int kind = ccf.GetDeviceKindIdx(StartDevice);//20100617
// if (kind == 2)
// {
// //sqlstr = string.Format("SELECT FID,F_ManageTaskKindIndex FROM T_Manage_Task WHERE (FSTATUS = 0) AND FID!={0} AND FCONTROLTASKTYPE != 4 AND (FSTARTDEVICE ={1}) ", fid, StartDevice);
// sqlstr = string.Format("SELECT FID,F_ManageTaskKindIndex FROM T_Manage_Task WHERE (FSTATUS = 0) AND FID!={0} AND (FSTARTDEVICE ={1}) ", fid, StartDevice);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// int count = dvdv.Count;
// if (count > 0)
// {
// AheadDetectUnallow.Append(string.Format("该起点等待执行的任务数量为:{0}，不能执行! ", count+1));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// }
//}
#endregion
#region 在发送socket任务时判断发送时间间隔在200毫秒以上20170923
if (DeviceKind == 6)
{
//查找已经发送的任务
int timespan=Convert.ToInt32( CStaticClass.SendTimeSpan);
sqlstr = string.Format("SELECT F_ManageTASKKINDINDEX, F_DeviceIndex, F_Status,F_StartTime FROM T_Monitor_Task WHERE (F_Status>0 ) AND F_DeviceIndex=({0}) ", DeviceIdx);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
int count = dvdv.Count;
for (int i = 0; i < count;i++ )
{
DateTime appdt = new DateTime();
DateTime timenow = DateTime.Now.AddMilliseconds(-timespan);
if (dvdv[i]["F_StartTime"] == DBNull.Value)
{
appdt = DateTime.Now.AddMilliseconds(-300);
}
else
{
DateTime.TryParse(dvdv[i]["F_StartTime"].ToString(), out appdt);
}
if (timenow < appdt)
{
AheadDetectUnallow.Append(string.Format("距上一个任务的发送时间间隔小于{0}毫秒，不能发送! ", timespan));
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
//CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "PLC等待发送", "", "");
return false;//不能执行出库任务
}
}
}
#endregion
#region 拆零区中转的判断
//if (DeviceKind == 1 && DeviceOrder == 4
// && devinfo.VirtualStack > 0
// && (devinfo.IfCorrelDoubleFork == "1")
// && (EndDevice == 12011 || EndDevice == 12015 || EndDevice == 12019 ))//双叉，且互拆堆垛机
// //&& (EndDevice == 12011 || EndDevice == 12015 || EndDevice == 12019 || (EndDevice == 12023 && CONTROLTASKTYPE == 2) || (EndDevice == 12028 && CONTROLTASKTYPE == 2)))//双叉，且互拆堆垛机
//{
// //查看送货的目标位置是lanegate且需要中转，且取货位置不是中转站台
// //获取坐标，查找lanegate
// string errmessage;
// Dictionary<int, string[]> corrinfo = Model.CGeneralFunction.GetDoubleForkMonitorInfo(minMidx, devinfo.DeviceIndex);
// string Fidend = ccf.GetEndDeviceFromManage(mti, fid);
// int VirtualStack = devinfo.VirtualStack;
// if (corrinfo == null)//20110412没关联任务
// { //查找空位
// int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);//获得任务坐标
// if (zxy != null)
// {
// string getcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[0], zxy[1], zxy[2]);// get pallete z-x-y
// string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);
// string[] exchangearea = ccf.GetExchangeStationAndEndAreaFromLaneGate(sendcell);//判读是否是到拆零区的任务
// if (exchangearea != null)
// {
// string TaskUseAwayFork = Model.CGeneralFunction.GetUseAwayFork(minMidx);//1,2,3;0没分配货叉
// string changecell;
// bool needexchange = ccf.IfNeedExchangeTask(minMidx, zxy, exchangearea);//是否需要中转，已经在中转站台的任务不需要中转
// if (needexchange)//需要中转
// {
// bool mustexchange = ccf.IfExchange(VirtualStack, minMidx, Fidend,0, zxy, exchangearea, false, out changecell);//不需要指定货叉
// if (mustexchange)
// {
// if (changecell == "-")
// {
// AheadDetectUnallow.Append(string.Format("{0}中无可用站台", exchangearea[2]));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// else
// {
// if(devinfo.DeviceIndex != devinfo.VirtualStack)//已分配堆垛机
// {
// ChangeStackCellCode(minMidx, changecell, DeviceIdx, Model.CGeneralFunction.TASKEXCHANGE);
// return false;
// //设置中转
// }
// else
// {
// checktask = false;
// _AheadDetect = _AheadDetect.Replace(exchangearea[0], "0");
// }
// }
// }
// }
// else//从中转站台到目标，要判读目标是否为空闲
// {
// if (!ccf.GetIfAreaFree(minMidx, VirtualStack, exchangearea[3], exchangearea[4], out errmessage))
// {
// AheadDetectUnallow.Append(string.Format("区域{0}不空闲 ", exchangearea[3]));
// //CommonClassLib.CCarryConvert.WriteDarkCasket("检测区域不空闲", minMidx.ToString(), devinfo.DeviceIndex.ToString(), exchangearea[3]);
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// //不能有到目标位置的已经分配堆垛机的任务
// }
// //false 不需要中转可以直接放到终点
// //}
// }// if (exchangearea!=null)
// }//if (zxy != null)
// }
// else
// {
// bool sameend = false;
// bool forceexchange = false;
// int mankind=0 ;
// int corrfid=0 ;
// string corrend="";
// foreach (int CorrTaskindex in corrinfo.Keys)
// {
// if (CorrTaskindex != minMidx)
// {
// mankind = ccf.GetManageTaskKindIndexFromMonitor(CorrTaskindex);
// corrfid = ccf.GetManageTaskIndexfromMonitor(CorrTaskindex);
// corrend = ccf.GetEndDeviceFromManage(mankind, corrfid);
// if (Fidend == corrend)//终点相同
// {
// sameend = true;
// }
// }
// }
// foreach (int CorrTaskindex in corrinfo.Keys)
// {
// int[] zxy = ccf.GetCoordinatesFromMonitorTask(CorrTaskindex);//获得任务坐标
// if (zxy != null)
// {
// string getcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[0], zxy[1], zxy[2]);// get pallete z-x-y
// string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);
// string[] exchangearea = ccf.GetExchangeStationAndEndAreaFromLaneGate(sendcell);//判读是否是到拆零区的任务
// if (exchangearea != null)
// {
// string TaskUseAwayFork = "0";
// if (sameend)
// {
// TaskUseAwayFork = Model.CGeneralFunction.GetUseAwayFork(CorrTaskindex);//1,2,3;0没分配货叉
// }
// string changecell;
// bool needexchange = ccf.IfNeedExchangeTask(CorrTaskindex, zxy, exchangearea);//是否需要中转，已经在中转站台的任务不需要中转
// string endsgroup;
// if (CorrTaskindex != minMidx)
// {
// endsgroup = corrend;
// }
// else
// {
// endsgroup = Fidend;
// }
// string [] ends= endsgroup.Split(';');
// int counts = ends.Length;
// if (needexchange)//需要中转
// {
// if (sameend)// counts>2表示是出库区，不用中转
// {
// //如果minMidx已经中转，CorrTaskindex就不要中转了
// if (counts < 2)
// {
// int exceptionno = ccf.GetExceptionNOFromManageTask(fid, mti);
// if (exceptionno != Model.CGeneralFunction.TASKEXCHANGE)
// {
// if (CorrTaskindex != minMidx)
// {
// forceexchange = true;
// }
// }
// }
// else
// {
// int ffid= fid, mmti= mti;
// if (CorrTaskindex == minMidx)
// {
// ffid = corrfid;
// mmti = mankind;
// }
// int exceptionno = ccf.GetExceptionNOFromManageTask(ffid,mmti);//判断关联任务的状态
// if (exceptionno == Model.CGeneralFunction.TASKEXCHANGE)
// {
// forceexchange = true;
// }
// }
// }
// bool mustexchange = ccf.IfExchange(VirtualStack, CorrTaskindex, endsgroup, Convert.ToInt32(TaskUseAwayFork), zxy, exchangearea, forceexchange, out changecell);//不需要指定货叉
// if (mustexchange)
// {
// if (changecell == "-")
// {
// AheadDetectUnallow.Append(string.Format("{0}中无可用站台", exchangearea[2]));
// UpdateAheadDetectUnallow(AheadDetectUnallow, CorrTaskindex);
// return false;
// }
// else
// {
// if (devinfo.DeviceIndex != devinfo.VirtualStack)//已经分配堆垛机
// {
// ChangeStackCellCode(CorrTaskindex, changecell, DeviceIdx, Model.CGeneralFunction.TASKEXCHANGE);
// return false;
// //设置中转
// }
// else
// {
// if (CorrTaskindex == minMidx)
// {
// checktask = false;//未分配堆垛机
// _AheadDetect = _AheadDetect.Replace(exchangearea[0], "0");
// }
// }
// }
// }
// else
// {
// CommonClassLib.CCarryConvert.WriteDarkCasket("拆零不中转,任务号:", CorrTaskindex.ToString(), endsgroup, "");
// }
// }
// else//从中转站台到目标，要判读目标是否为空闲
// {
// if (!ccf.GetIfAreaFree(CorrTaskindex, VirtualStack, exchangearea[3], exchangearea[4], out errmessage))
// {
// AheadDetectUnallow.Append(string.Format("区域{0}不空闲 ", exchangearea[3]));
// UpdateAheadDetectUnallow(AheadDetectUnallow, CorrTaskindex);
// return false;//不能执行出库任务
// }
// }
// //false 不需要中转可以直接放到终点
// //}
// }// if (exchangearea!=null)
// }//if (zxy != null)
// }
// }
//}
#endregion
#region 堆垛机送货位置相同的任务只能有一个正在执行，互斥判断：也不能有终点坐标是该位置的输送机的任务，也要判断RGV任务
////if (DeviceKind == 1 && (DeviceOrder == 4 || DeviceOrder == 5) )// 取货，送货
//if (DeviceKind == 1 && (DeviceOrder == 4 || DeviceOrder == 5) && devinfo.VirtualStack > 0)// 取货，送货
//{
// int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
// if (zxy != null)
// {
// sqlstr = string.Format("SELECT F_LaneNo FROM T_Base_StackInfo WHERE F_StackIndex ={0}", DeviceIdx);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int lane = Convert.ToInt32(dvdv[0]["F_LaneNo"]);
// // int exceptionno = ccf.GetExceptionNOFromManageTask(fid, mti);
// //20181222
// string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);//lanegate 坐标
// //int gate = ccf.GetLaneGateDeviceIndexFromLaneGate(sendcell);//送货位置的设备编号
// //string groups = "12027;12032";
// //bool ifcheck = !groups.Contains(gate.ToString());//20181020
// #region 堆垛机送货位置相同的任务只能有一个正在执行
// //if (devinfo.VirtualStack > 0 && checktask && DeviceOrder == 4 && ifcheck)//并且不能是倒库的任务
// if (DeviceIdx != devinfo.VirtualStack && devinfo.VirtualStack > 0 && checktask && DeviceOrder == 4 && EXCEPTIONNO != Model.CGeneralFunction.TASKCHANGESTACK)//并且不能是倒库的任务
// {
// //sql = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task,T_Base_StackInfo WHERE F_DeviceIndex !={4} and F_DeviceIndex =F_StackIndex and F_LaneNo ={0} and (F_DeviceCommandIndex =4 OR F_DeviceCommandIndex =5) and (F_NumParam4 = {1}) AND (F_NumParam5 = {2}) AND (F_NumParam6 = {3})", lane, zxy[0], zxy[1], zxy[2], VirtualStack);
// //在该巷道内，不能有终点坐标相同的任务在执行
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task,T_Base_StackInfo WHERE F_Status >0 and F_DeviceIndex =F_StackIndex and F_LaneNo ={0} and (F_DeviceCommandIndex =4 OR F_DeviceCommandIndex =5) and (F_NumParam4 = {1}) AND (F_NumParam5 = {2}) AND (F_NumParam6 = {3})", lane, zxy[3], zxy[4], zxy[5]);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)// 有该出库任务终点货位对应的堆垛机取货任务
// {
// AheadDetectUnallow.Append(string.Format("存在相同终点{0:D2}-{1:D2}-{2:D2}的任务，该任务暂时不能执行! ", zxy[3], zxy[4], zxy[5]));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// else
// {
// ////第一条指令不能是送货任务
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task,T_Base_StackInfo WHERE F_MonitorIndex in({4}) and F_MonitorIndex !={5} and F_DeviceIndex =F_StackIndex and F_LaneNo ={0} and (F_DeviceCommandIndex =5) and (F_NumParam4 = {1}) AND (F_NumParam5 = {2}) AND (F_NumParam6 = {3})", lane, zxy[3], zxy[4], zxy[5], sqlin,minMidx);
// //dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// //if (dvdv.Count > 0)// 有该出库任务终点货位对应的堆垛机取货任务
// //{
// // AheadDetectUnallow.Append(string.Format("存在相同终点{0:D2}-{1:D2}-{2:D2}的任务，该任务暂时不能执行! ", zxy[3], zxy[4], zxy[5]));
// // UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// // return false;//不能执行出库任务
// //}
// }
// }
// #endregion
// sqlstr = string.Format("SELECT * FROM T_Base_Lane_Gate where (F_MutexTransEnd is not null or F_CorrelDetect is not null ) and F_ZXY='{0}' and F_LaneIndex={1} ", sendcell, lane);//在lanegate表中查找需要判断的lanegate
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)// 有该出库任务终点货位对应的堆垛机取货任务
// {
// int Checkgate = Convert.ToInt32(dvdv[0]["F_LaneGateDeviceIndex"]);
// string mutexend = Convert.ToString(dvdv[0]["F_MutexEnd"]);
// string mutextransend = Convert.ToString(dvdv[0]["F_MutexTransEnd"]);
// string CheckForbidden = Convert.ToString(dvdv[0]["F_ChangeCheckForbidden"]);//判断其是否被禁用，以触发变更
// string CheckOtherForbidden = Convert.ToString(dvdv[0]["F_ChangeCheckOtherForbidden"]);//被禁用，不触发变更
// string ChangeCheckNext = Convert.ToString(dvdv[0]["F_ChangeCheckNext"]);
// string ChangeCheckEnd = Convert.ToString(dvdv[0]["F_ChangeCheckEnd"]);
// string ChangeToNewStart = Convert.ToString(dvdv[0]["F_ChangeToNewStart"]);
// string ChangeToNewNext = Convert.ToString(dvdv[0]["F_ChangeToNewNext"]);
// string ChangeToNewEnd = Convert.ToString(dvdv[0]["F_ChangeToNewEnd"]);
// string CorrelDetect = Convert.ToString(dvdv[0]["F_CorrelDetect"]);
// #region 检测放货位置的相邻位置是否有货
// if (CorrelDetect != "")//取货或送货时判断
// {
// int devicebyte = 0, devbit = 0;
// DS = CorrelDetect.Trim().Split(dd);
// int.TryParse(DS[0], out devicebyte);
// int.TryParse(DS[1], out devbit);
// int sssn = CStaticClass.GetDevicePhotoelectric(devicebyte, devbit);
// if (sssn != 0)
// {
// //int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("{0}有物光电开关遮挡! ", CorrelDetect));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_DeviceIndex = {0} and F_Status =1", devicebyte);
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex=6 and F_Status >0 and F_NumParam4 in({0}) ", mutextransend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在阻挡的输送机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// #endregion
// if (DeviceOrder == 4)
// {
// #region 双向互斥任务的判断，需要判断输送机和穿梭车
// //查找互斥RGV任务
// if (mutexend != "")
// {
// //不能有执行的任务
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE ((F_DeviceCommandIndex =2 and F_NumParam4 = {0}) OR (F_DeviceCommandIndex =3 AND F_NumParam1= {0})) and F_Status>0 ", Convert.ToInt32(mutexend));
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的RGV任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// else
// {
// //不能有第一条指令时送货的RGV任务
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex =3 AND F_NumParam1= {0} and F_MonitorIndex in({1}) ", Convert.ToInt32(mutexend), sqlin);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的RGV任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// }
// //查找互斥输送机任务
// if (mutextransend != "")
// {
// //任务号和调度任务类型和管理都一样 查调度任务号 是命令是1和6 起点设备 是Lane_Gate 表对应的 F_MutexTransEnd
// //限制堆垛机当前有任务 没执行完 不执行其他任务
// sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex in (6,1) and F_NumParam1 in({0}) and F_MonitorIndex in(SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX group by F_ManageTaskIndex) ", mutextransend);
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex=6 and F_Status >0 and F_NumParam4 in({0}) ", mutextransend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的输送机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// #endregion
// //
// #region 变更堆垛机及输送机，RGV的任务
// object[] ob;
// if (CheckForbidden != "" && CheckOtherForbidden != "")//
// {
// int ifForbidden = ccf.GetDeviceLockedState(Convert.ToInt32(CheckForbidden));
// if (ifForbidden == -1)//禁用
// {
// int ifotherForbidden = ccf.GetDeviceLockedState(Convert.ToInt32(CheckOtherForbidden));
// if (ifotherForbidden != -1)//不能被禁用
// { //获得送货位置对应的坐标
// string newcell = ccf.GetStackCoordinateFromLaneGate(Convert.ToInt32(ChangeToNewStart));//新的送货坐标
// string[] newzxy = newcell.Split('-');
// if (newcell != "-" && newzxy.Length > 2)
// {
// //更改堆垛机送货坐标, 检测条件
// ob = new object[8] { DeviceIdx, fid, mti, newzxy[0], newzxy[1], newzxy[2], Checkgate, ChangeToNewStart };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam4={3}, F_NumParam5={4}, F_NumParam6={5},F_AheadDetect = REPLACE(F_AheadDetect, '{6}', '{7}') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// //更改送货输送机的起点和终点，及送出条件
// //
// ob = new object[8] { Checkgate, fid, mti, ChangeToNewStart, ChangeToNewEnd, ccf.GetRouteIDsub(Convert.ToInt32(ChangeToNewStart)), Checkgate, ChangeToNewStart };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam1={3},F_NumParam4={4},F_RouteID={5}, F_AheadDetect = REPLACE(F_AheadDetect, '{6}', '{7}') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// //更改next设备
// ob = new object[6] { Checkgate, fid, mti, ChangeToNewStart, ChangeCheckNext, ChangeToNewNext };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex={3}, F_AheadDetect = REPLACE(F_AheadDetect, '{4}', '{5}') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// //变更RGV的取货点，检测条件。
// ob = new object[6] { ChangeCheckEnd, fid, mti, ChangeToNewEnd, ChangeCheckEnd, ChangeToNewEnd };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam1={3}, F_AheadDetect = REPLACE(F_AheadDetect, '{4}', '{5}') WHERE F_DeviceCommandIndex =2 and F_NumParam1={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// CommonClassLib.CCarryConvert.WriteDarkCasket("设备禁用变更后续路径", minMidx.ToString(), DeviceIdx.ToString(), CheckForbidden);
// return false;
// }
// }
// }
// }
// #endregion
// }
// }
// }
// }
//}
#endregion
#region 提前检测信息处理
if ((_AheadDetect != "") && (_AheadDetect != null))
{
#region 对于倒换堆垛机的任务，不判断最终目标位置的状态
if (DeviceKind == 1 && devinfo.VirtualStack > 0 && (order == 4 || order == 5))//
{
string sendcell = "";
if (order == 4)
{
int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
if (zxy != null)
{
sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);//lanegate 坐标
}
}
else
{
sql.Remove(0, sql.Length);
sql.Append("SELECT FREMARK FROM T_Manage_Task WHERE (FID = ").Append(fid).Append(") AND (F_ManageTaskKindIndex = ").Append(mti).Append(") and (FExceptionNO =").Append(Model.CGeneralFunction.TASKCHANGESTACK).Append(")");
object arrcell = dbo.GetSingle(sql.ToString());
string cell = Convert.ToString(arrcell);
string[] cellzxy = cell.Split('-');
if (cellzxy.Length > 2)
{
sendcell = cell;
}
}
int gate = ccf.GetLaneGateDeviceIndexFromLaneGate(sendcell);//送货位置的设备编号
//string groups = "12027;12032;13003;13004";
string groups = "12027;12032";
bool ifcheck = groups.Contains(gate.ToString());//20181020
if (ifcheck&&gate!=0)
{
string Nocheck = gate.ToString();
_AheadDetect = _AheadDetect.Replace(Nocheck, "0");
}
}
#endregion
char[] cc = new char[1];
cc[0] = ';';
//string[] AheadDetect
//去除重复项
_AheadDetect = _AheadDetect.Replace(NoDetect, "");
string[] stringArray = _AheadDetect.Split(cc);
List<string> listString = new List<string>();
foreach (string eachString in stringArray)
{
if (!listString.Contains(eachString))//判断新拼成的检测字符串是否已含有次循环的
{
if(!checkSendDevice)//不检测出库输送机
{
if (eachString.Contains(DeviceIdx.ToString()))//当前串是否是堆垛机检测条件
{
listString.Add(eachString);//将堆垛机检测条件加入到新的检测串中
}
}
else
{
listString.Add(eachString);//检测输送线的时候 将原有所有的检测条件都新加到新的串中
}
}
}
string[] AheadDetect = listString.ToArray();//新的检测条件赋值给AheadDetect
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)//注释20180522
//{//机台需要从管理设备表读取;20101028管理依赖任务控制机台的站台是否有物
// //if (dboM.ExceSQL("SELECT FID FROM T_ITEMDEVICESTATION WHERE (FCODE = '" + AheadDetect[i].Trim().Substring(1) + "') AND (FSTATUS = '1002')").Tables[0].DefaultView.Count > 0)
// //{
// // fs = fs & 1;
// //}
// //else
// //{
// // fs = fs & 0;
// //}
//}
//else
{
//本地设备表读取
sql.Remove(0, sql.Length);
sql.Append("SELECT F_DeviceIndex, F_HaveGoods FROM T_Base_Device where F_DeviceIndex=").Append(
Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
if (Convert.ToInt32(dvdv[0]["F_HaveGoods"]) > 0)//20110505
{
AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "设备逻辑有物！");
}
s = s + Convert.ToInt32(dvdv[0]["F_HaveGoods"]);
}
}
continue;
}
#endregion
#region 检测设备是否空闲
//20090803检测设备是否空闲idle
if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "I")//检测设备是否空闲idle
{
int idev = Convert.ToInt32(AheadDetect[i].Trim().Substring(1));
if (idev.ToString().Length == 6)
{
idev = Convert.ToInt32(idev.ToString().Substring(0, 5));
}
States = CStaticClass.GetDeviceState(idev);
if (States != null)
{
int kind= ccf.GetDeviceKindIdx(Convert.ToInt32(AheadDetect[i].Trim().Substring(1)));
//if ((States[1] == 5) && (kind==2))
//{//20120409只有输送机的完成可作为空闲
// States[1] = 0;
//}
if (kind==1&&DeviceHandTaskIfRun(Convert.ToInt32(AheadDetect[i].Trim().Substring(1))) == true)
{//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 检测AGV控制台是否连接
////20090803检测设备是否空闲idle
if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "C")//检测设备是否空闲idle
{
int idev = Convert.ToInt32(AheadDetect[i].Trim().Substring(1));
if (idev.ToString().Length == 6)
{
idev = Convert.ToInt32(idev.ToString().Substring(0, 5));
}
devinfocheck = Model.CGetInfo.GetDeviceInfo(idev);
if (devinfocheck != null && SocketsTCPIP.CClientTCPIP.IfConnectServer(devinfocheck.RemoteIP))
{
s = s + 0;
}
else
{
s = s + 1;
AheadDetectUnallow.Append(devinfocheck.DeviceName + "设备未连接！");
}
continue;
}
#endregion
#region 检测设备是否被锁定
//20090803检测设备是否空闲idle
if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "L")//检测设备是否被锁定
{
int idev = Convert.ToInt32(AheadDetect[i].Trim().Substring(1));
if (idev.ToString().Length == 6)
{
idev = Convert.ToInt32(idev.ToString().Substring(0, 5));
}
//本地设备表读取
sql.Remove(0, sql.Length);
sql.Append("SELECT F_DeviceIndex, F_LockedState FROM T_Base_Device where F_DeviceIndex=").Append(idev);
dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int lockstatus=Convert.ToInt32(dvdv[0]["F_LockedState"]) ;
if (lockstatus== 0)//20110505
{
s=s+0;
}
else
{
s=s+1;
AheadDetectUnallow.Append(idev + "设备被锁定！"); }
}
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 检查是否有可用缓冲站台20181006
if (AheadDetect[i].Trim().Substring(0, 1).ToUpper() == "Z")//检测
{
string []stations= AheadDetect[i].Trim().Substring(1).Split(',');
int goodscount = 0;
for (int k = 0; k < stations.Length; k++)
{
int device = Convert.ToInt32(stations[k]);//
int count = 0;
devinfocheck = Model.CGetInfo.GetDeviceInfo(device);
if (devinfocheck != null)
{
if (devinfocheck.SplitByte_0 == 1 || devinfocheck.SplitByte_1 == 1)//有货
{
count = 1;
}
}
sql.Remove(0, sql.Length);
sql.Append("SELECT F_DeviceIndex, F_HaveGoods FROM T_Base_Device where F_DeviceIndex=").Append(device);
dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
if (Convert.ToInt32(dvdv[0]["F_HaveGoods"]) == 1)//20110505
{
count = 1;
}
}
goodscount += count;
}
if (goodscount == stations.Length)//有货站台数量和站台数量相等
{
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 obr = dbo.GetSingle(sql.ToString());
if (obr != null)
{
if (obr.ToString() != (mti.ToString() + fid.ToString()))
{
bool iftrue = true;
int relfid = ccf.GetRELATIVECONTORLIDFromManageTask(mti, fid);
if (relfid > 0)
{//20130704
dv = dbo.ExceSQL(string.Format("SELECT FID FROM T_Manage_Task where F_RELATIVECONTORLID={0} and F_ManageTaskKindIndex={1}", relfid, mti)).Tables[0].DefaultView;
for (int mt = 0; mt < dv.Count; mt++)
{
if (obr.ToString() == mti.ToString() + dv[mt]["FID"].ToString())
{
iftrue = false;
}
}
}
if (iftrue == true)
{
s = s + 1;
AheadDetectUnallow.Append(AheadDetect[i].Trim().Substring(1) + "被调度任务:").Append(obr.ToString()).Append("预约！");
}
else
{
s = s + 0;
}
}
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);
//判断是否检测负数索引值（负数代表是否满足开关量＝１的执行前提）
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;
case 4:
kg.Append(".4输送线允许移动设备运行信号");
break;
case 5:
kg.Append("有物");
break;
case 6:
kg.Append("高位");
break;
case 7:
kg.Append("低位");
break;
case 8:
kg.Append("允许入库输送线动作信号");
break;
case 9:
kg.Append("取货站台允许堆垛机取货信号");
break;
case 10:
kg.Append("允许出库输送线动作信号");
break;
case 11:
kg.Append("送货站台允许堆垛机送货信号");
break;
default:
break;
}
AheadDetectUnallow.Append(Convert.ToInt32((-devicebyte)).ToString() + kg.ToString() + "光电开关不遮挡！");
}
fs = fs & fsn;
}
#endregion
}
else
{//
#region 正数值不能为１的开关量检测
devinfocheck = Model.CGetInfo.GetDeviceInfo(devicebyte);
if (devinfocheck != null)
{
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 (mti != 4)
{//20120405
if (DeviceHandTaskIfWaitRun(devinfo.DeviceIndex) == true)
{
AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "手工任务或者避让任务等待运行！");
s += 1;
}
}
#endregion
#region 检测向管理申请入库任务条码和PLCASK记录是否匹配，是否有互斥任务
//20130709增加输送站台向管理申请入库任务，或者条码比对的任务，扫描后人工随意搬走箱子的保护，入库任务条码和PLCAsk记录的不相同不再执行任务
//20170110 只判断F_Askkind =4的类型
sql.Remove(0, sql.Length);
sql.Append("SELECT T_Base_Device.F_DeviceIndex,F_CheckSendEnd,F_CheckTransEnd,F_CheckTaskEndDevice, F_CheckExeDevice 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_Askkind=4) AND T_Base_PLC_Ask.F_BindingDevice = ").Append(devinfo.DeviceIndex);
dvdv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if ((dvdv.Count > 0) && (mti != 4) && (CONTROLTASKTYPE == 1) && (devinfo.DeviceIndex != 42012) && (devinfo.DeviceIndex != 12125) && (devinfo.DeviceIndex != 42013))//&& (CONTROLTASKTYPE==1)
//西泵铸造添加三个碟盘机除外，因为碟盘机申请离开不报条码
{
sql.Remove(0, sql.Length);
sql.Append("SELECT F_BarCode FROM T_Base_PLC_Ask where F_askkind=4 and F_BindingDevice=").Append(devinfo.DeviceIndex);
object obr = dbo.GetSingle(sql.ToString());
if (obr != null)
{
if (obr.ToString().IndexOf( "11111")<0)//只判断前五位就可以 在扫到条码的情况下才判断
{
if ((obr.ToString().IndexOf(ccf.GetBarCodeFromMonitor(minMidx)) < 0) && (ccf.GetBarCodeFromMonitor(minMidx).IndexOf(obr.ToString()) < 0))
{
s = s + 1;
AheadDetectUnallow.Append(devinfo.DeviceIndex.ToString() + "记录的条码:").Append(obr.ToString()).Append("，和任务条码").Append(ccf.GetBarCodeFromMonitor(minMidx)).Append("不匹配！");
}
}
}
#region 判断是否有与该输送机互斥的任务
string checksenddevice = Convert.ToString(dvdv[0]["F_CheckSendEnd"]);//20181003,如果是货位就判断是否有到改坐标的堆垛机任务在执行，如果不是就判断是否有到该位置的RGV任务
string checktransdevice = Convert.ToString(dvdv[0]["F_CheckTransEnd"]);//20181003查找终点是该目标的调度任务，第一天设备指令是否是到该终点的，
string checktaskend = Convert.ToString(dvdv[0]["F_CheckTaskEndDevice"]);//20181003, H行区域，判断终点任务是否有互斥任务
string checkexedevice = Convert.ToString(dvdv[0]["F_CheckExeDevice"]);//20181003
int starttransdevice = devinfo.DeviceIndex;
string[] sendcell;//20181003
string sqlstrs;
int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
int transend = 0;
if (zxy != null)
{
transend = zxy[3];//送出指令的终点设备
}
//更改条码值
if (checksenddevice != "")
{
char[] cc1 = new char[1] { '-' };//20181003
sendcell = checksenddevice.Split(cc1);
if (sendcell.GetLength(0) >= 2)//堆垛机
{
string lanegatecell = ccf.GetStackCoordinateFromLaneGate(transend);
if (checksenddevice == lanegatecell)//终点设备如果是lanegate
{
sqlstrs = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =4 OR F_DeviceCommandIndex =5) and F_Status>0 and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2})", Convert.ToInt32(sendcell[0]), Convert.ToInt32(sendcell[1]), Convert.ToInt32(sendcell[2]));
dvdv = dbo.ExceSQL(sqlstrs).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
s = s + 1;
AheadDetectUnallow.Append("存在堆垛机互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务不能执行!");
}
else
{
//不能有到该位置的送货任务是第一条指令
sqlstrs = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =5) and F_MonitorIndex in({3}) and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2})", Convert.ToInt32(sendcell[0]), Convert.ToInt32(sendcell[1]), Convert.ToInt32(sendcell[2]), sqlin);
dvdv = dbo.ExceSQL(sqlstrs).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
s = s + 1;
AheadDetectUnallow.Append("存在堆垛机互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务不能执行!");
}
}
}
}
else//RGV
{
//
if (transend.ToString()== checksenddevice)//送出终点设备和RGVgate相同
{
sqlstrs = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE ((F_DeviceCommandIndex =2 and F_NumParam4 = {0}) OR (F_DeviceCommandIndex =3 AND F_NumParam1= {0})) and F_Status>0 ", Convert.ToInt32(checksenddevice));
dvdv = dbo.ExceSQL(sqlstrs).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
s = s + 1;
AheadDetectUnallow.Append("存在穿梭车互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务不能执行!");
}
else
{
//不能有到该位置的送货任务是第一条指令
sqlstrs = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex =3 AND F_NumParam1= {0} and F_MonitorIndex in({1}) ", Convert.ToInt32(checksenddevice), sqlin);
dvdv = dbo.ExceSQL(sqlstrs).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
s = s + 1;
AheadDetectUnallow.Append("存在穿梭车互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务不能执行!");
}
}
}
}
}
if (checktransdevice != "")
{//判断终点到该位置的任务的第一条设备指令是否是checktransdevice
//sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_NumParam4= {0} and F_MonitorIndex in(SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX and FSTATUS>0 and FENDDEVICE= {0} group by F_ManageTaskIndex) ", Convert.ToInt32(checktransdevice));
if (zxy != null)
{
if (Convert.ToInt32( checktransdevice)!=zxy[3])
{
sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_NumParam4= {0} and F_MonitorIndex != {1} and F_MonitorIndex in(SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX and FENDDEVICE= {0} group by F_ManageTaskIndex) ", Convert.ToInt32(checktransdevice), minMidx);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
if (dvdv.Count > 0)
{
int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
s = s + 1;
AheadDetectUnallow.Append("存在互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务不能执行!");
}
}
}
}
#region H型是否存在别的通道终点的任务，与该起点通道互斥
if (checktaskend != "" && checkexedevice != "")
{
if (!checktaskend.Contains(zxy[3].ToString()) )//不能是回退任务
{
//在到该申请设备对应的终点组中，执行的任务中，执行设备要在执行组中，指令才能发送（起点不是该设备，终点在终点组中的任务）
sqlstr = string.Format(" SELECT F_MonitorIndex,F_CurrentLocation FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_Status>0 and F_NumParam1!= {0} and F_NumParam4 in({1}) ", starttransdevice, checktaskend);
dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
for (int i = 0; i < dvdv.Count; i++)
{
string currentlocation = Convert.ToString(dvdv[i]["F_CurrentLocation"]);
int task = Convert.ToInt32(dvdv[i]["F_MonitorIndex"]);
if (!checkexedevice.Contains(currentlocation))
{
s = s + 1;
AheadDetectUnallow.Append("存在互斥任务:").Append(task).Append(",条码:").Append(ccf.GetBarCodeFromMonitor(task)).Append(",该任务暂时不能执行!");
break;
}
}
}
}
#endregion
#endregion
}
#endregion
if ((s != 0) || (fs != 1))
{
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;
}
}
#endregion
#region 徐州地铁 执行出库堆垛机取货的时候先判断输送线是否空闲无货
//int endDevice;
//if (DeviceKind == 1 && DeviceOrder == 4 && CONTROLTASKTYPE == 2)
//{
// //string sql = string.Format("select FENDDEVICE from T_Manage_Task where FID={0}", fid);
// //DataView dwEndDevice = dbo.ExceSQL(sql).Tables[0].DefaultView;
// //if (dwEndDevice.Count > 0)
// //{
// // endDevice = Convert.ToInt32(dwEndDevice[0]["FENDDEVICE"].ToString().Trim());
// //}
// DataView dwInTask = dbo.ExceSQL(string.Format("select FID from T_Manage_Task where FSTARTDEVICE={0}", EndDevice)).Tables[0].DefaultView;
// devinfo = Model.CGetInfo.GetDeviceInfo(EndDevice);
// if (devinfo.SplitByte_0 != 0 || devinfo.SplitByte_1 != 0 || devinfo.SplitByte_2 != 0 || devinfo.RunState != 0 || dwInTask.Count > 0)
// {
// AheadDetectUnallow.Append(string.Format("{0}站台不可用，该出库任务暂时不能执行，请耐心等待! ", EndDevice));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
//}
#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
//同一位置的出入库任务，先执行入库任务，再执行出库任务（针对堆垛机的送货位置就是任务的终点，堆垛机的取货位置就是任务的起点）
//堆垛机送货位置相同的任务只能有一个正在执行，互斥判断：也不能有终点坐标是该位置的输送机的任务，也要判断RGV任务
#region 判读是否存在RGV的互斥任务，包括堆垛机和输送机
//if (DeviceKind ==4 && (DeviceOrder == 2 || DeviceOrder == 3))// 取货，送货
//{
// int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
// if (zxy != null)
// {
// int nextdevice = zxy[0];//默认F_NumParam1
// if (DeviceOrder==2)
// {
// nextdevice = zxy[3];//取货任务的目标位置存在F_NumParam4
// }
// //string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);//lanegate 坐标
// sqlstr = string.Format("SELECT * FROM T_Base_RGV_Gate WHERE F_MutexTransEnd is not null and F_ChannelsIndex = {0} and F_RGVGateDeviceIndex={1}", DeviceIdx, nextdevice);//在lanegate表中查找需要判断的lanegate
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)// 有该出库任务终点货位对应的堆垛机取货任务
// {
// int Checkgate = Convert.ToInt32(dvdv[0]["F_RGVGateDeviceIndex"]);
// string mutexend = Convert.ToString(dvdv[0]["F_MutexEnd"]);
// string mutextransend = Convert.ToString(dvdv[0]["F_MutexTransEnd"]);
// string CheckForbidden = Convert.ToString(dvdv[0]["F_ChangeCheckForbidden"]);//判断其是否被禁用，以触发变更
// string CheckOtherForbidden = Convert.ToString(dvdv[0]["F_ChangeCheckOtherForbidden"]);//被禁用，不触发变更
// string ChangeCheckNext = Convert.ToString(dvdv[0]["F_ChangeCheckNext"]);
// string ChangeCheckEnd = Convert.ToString(dvdv[0]["F_ChangeCheckEnd"]);//;分隔
// string ChangeToNewStart = Convert.ToString(dvdv[0]["F_ChangeToNewStart"]);
// string ChangeToNewNext = Convert.ToString(dvdv[0]["F_ChangeToNewNext"]);
// string ChangeToNewEnd = Convert.ToString(dvdv[0]["F_ChangeToNewEnd"]);//；分隔
// char[] cc = new char[1] { ',' };
// //查找互斥的堆垛机任务
// #region 双向互斥任务的判断，需要判断输送机和穿梭车
// if (mutexend != "")
// {
// string[] StackMutexEnd = mutexend.Split(cc);//13001;13002
// string sendcell;
// string[] cellzxy;
// for (int i = 0; i < StackMutexEnd.Length; i++)
// {
// int lanegate = Convert.ToInt32(StackMutexEnd[i]);
// sendcell = ccf.GetStackCoordinateFromLaneGate(lanegate);
// if (sendcell != "-")
// {
// cellzxy = sendcell.Split('-');
// if (cellzxy.Length == 3)
// {
// //不能有到该位置的执行任务
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =4 OR F_DeviceCommandIndex =5) and F_Status>0 and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2})", Convert.ToInt32(cellzxy[0]), Convert.ToInt32(cellzxy[1]), Convert.ToInt32(cellzxy[2]));
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的堆垛机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// else
// {
// //不能有到该位置的送货任务是第一条指令
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =5) and F_MonitorIndex in({3}) and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2})", Convert.ToInt32(cellzxy[0]), Convert.ToInt32(cellzxy[1]), Convert.ToInt32(cellzxy[2]), sqlin);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的堆垛机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// }
// }
// }
// }
// //查找互斥输送机任务
// if (mutextransend != "")
// {
// sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_NumParam4 in({0}) and F_MonitorIndex in(SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX group by F_ManageTaskIndex) ", mutextransend);
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex=6 and F_Status >0 and F_NumParam4 in({0}) ", mutextransend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的输送机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// #endregion
// #region 变更RGV的任务及输送机，堆垛机
// object[] ob;
// if (CheckForbidden != "" && CheckOtherForbidden != "")//
// {
// int ifForbidden = ccf.GetDeviceLockedState(Convert.ToInt32(CheckForbidden));
// if (ifForbidden == -1)//禁用
// {
// int ifotherForbidden = ccf.GetDeviceLockedState(Convert.ToInt32(CheckOtherForbidden));
// if (ifotherForbidden != -1)//不能被禁用
// { //获得送货位置对应的坐标
// string[] end = ChangeToNewEnd.Split(';');
// bool flag = true;
// if (end.Length > 1)
// {
// flag = false;//不需要更新堆垛机坐标
// }
// if (flag)
// {
// string checkcell = ccf.GetStackCoordinateFromLaneGate(Convert.ToInt32(ChangeCheckEnd));//原来的取货坐标
// string newcell = ccf.GetStackCoordinateFromLaneGate(Convert.ToInt32(ChangeToNewEnd));//新的取货坐标
// string[] checkzxy = checkcell.Split('-');
// string[] newzxy = newcell.Split('-');
// if (checkcell != "-" && checkzxy.Length > 2 && newcell != "-" && newzxy.Length > 2)
// {
// //更改堆垛机送货坐标, 检测条件
// ob = new object[10] { fid, mti, newzxy[0], newzxy[1], newzxy[2], ChangeCheckEnd, ChangeToNewEnd, checkzxy[0], checkzxy[1], checkzxy[2] };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam1={2}, F_NumParam2={3}, F_NumParam3={4},F_AheadDetect = REPLACE(F_AheadDetect, '{5}', '{6}') WHERE F_NumParam1={7} and F_NumParam2={8} and F_NumParam3={9} and (F_ManageTaskIndex ={0}) AND (F_ManageTASKKINDINDEX ={1})", ob));
// }
// }
// //
// //获得出库任务终点
// string[] checkend = ChangeCheckEnd.Split(';');
// string[] newend = ChangeToNewEnd.Split(';');
// if (checkend.Length > 1 && newend.Length > 1)
// {
// int index = Array.IndexOf(checkend, EndDevice.ToString());//查找任务终点是否在检测组中
// if (index > -1)
// {
// ChangeToNewEnd = newend[index];
// }
// // 变更任务终点
// sql.Remove(0, sql.Length);
// sql.Append("update T_Manage_Task set FENDDEVICE= ").Append(ChangeToNewEnd).Append(" where F_ManageTaskKindIndex=").Append(mti).Append(" and FID=").Append(fid);
// dbo.ExecuteSql(sql.ToString());
// }
// //更改送货输送机的起点和终点，及送出条件
// ob = new object[9] { Checkgate, fid, mti, ChangeToNewStart, ChangeToNewEnd, ccf.GetRouteIDsub(Convert.ToInt32(ChangeToNewStart)), Checkgate, ChangeToNewStart, ChangeToNewEnd };
// int count=dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_NumParam1={3},F_NumParam4={4},F_RouteID={5}, F_AheadDetect = REPLACE(F_AheadDetect, '{6}', '{7}') WHERE F_NumParam4 !={8} and F_DeviceIndex={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// //更改next设备
// ob = new object[6] { Checkgate, fid, mti, ChangeToNewStart, ChangeCheckNext, ChangeToNewNext };
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_DeviceIndex={3}, F_AheadDetect = REPLACE(F_AheadDetect, '{4}', '{5}') WHERE F_DeviceIndex={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// //变更RGV的送货点，检测条件。
// //
// ob = new object[5] { Checkgate, fid, mti, Checkgate, ChangeToNewStart };//更该检测条件
// //string ssss = string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{3}', '{4}') WHERE ((F_DeviceCommandIndex = 2 and F_NumParam4 = {0}) OR(F_DeviceCommandIndex = 3 AND F_NumParam1 = {0})) and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob);
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_AheadDetect = REPLACE(F_AheadDetect, '{3}', '{4}') WHERE ((F_DeviceCommandIndex = 2 and F_NumParam4 = {0}) OR(F_DeviceCommandIndex = 3 AND F_NumParam1 = {0})) and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// ob = new object[4] { Checkgate, fid, mti, ChangeToNewStart };//更改送货坐标
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam4={3} WHERE F_DeviceCommandIndex =2 and F_NumParam4={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// ob = new object[4] { Checkgate, fid, mti, ChangeToNewStart };//更改送货坐标
// dbo.ExceSQL(string.Format("UPDATE T_Monitor_Task SET F_NumParam1={3} WHERE F_DeviceCommandIndex =3 and F_NumParam1={0} and (F_ManageTaskIndex ={1}) AND (F_ManageTASKKINDINDEX ={2})", ob));
// CommonClassLib.CCarryConvert.WriteDarkCasket("设备禁用变更后续路径", minMidx.ToString(), DeviceIdx.ToString(), CheckForbidden);
// if (count > 0)
// {
// return false;
// }
// }
// }
// }
// #endregion
// }
// }
//}
#endregion
#region 判读是否存在输送机的互斥任务，包括堆垛机和RGv
//if (DeviceKind == 2 && (DeviceOrder == 6))// 送出指令
//{
// int gate = DeviceIdx;
// string mutexend = "";
// string mutextransend = "";
// sqlstr = string.Format("SELECT F_LaneGateDeviceIndex,F_MutexEnd, F_MutexTransEnd FROM T_Base_Lane_Gate where F_MutexTransEnd is not null and F_LaneGateDeviceIndex={0} ", gate);//在lanegate表中查找需要判断的lanegate
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)// 有该出库任务终点货位对应的堆垛机取货任务
// {
// mutexend = Convert.ToString(dvdv[0]["F_MutexEnd"]);
// mutextransend = Convert.ToString(dvdv[0]["F_MutexTransEnd"]);
// }
// #region 双向互斥任务的判断，需要判断输送机和穿梭车
// //string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);//lanegate 坐标
// string ChangeCheckEnd = "";//;分隔
// string ChangeToNewEnd = "";//；分隔
// string CheckTaskStart = "";//,逗号分隔，判断是否存在该起点的任务
// string CheckTaskNewStart = "";//，分隔
// sqlstr = string.Format("SELECT * FROM T_Base_RGV_Gate WHERE F_MutexTransEnd is not null and F_RGVGateDeviceIndex={0}", gate);//在lanegate表中查找需要判断的lanegate
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)// 有该出库任务终点货位对应的RGV取货任务
// {
// mutexend = Convert.ToString(dvdv[0]["F_MutexEnd"]);
// mutextransend = Convert.ToString(dvdv[0]["F_MutexTransEnd"]);
// ChangeCheckEnd = Convert.ToString(dvdv[0]["F_ChangeCheckEnd"]);//;分隔
// ChangeToNewEnd = Convert.ToString(dvdv[0]["F_ChangeToNewEnd"]);//；分隔
// CheckTaskStart = Convert.ToString(dvdv[0]["F_CheckTaskStart"]);//,逗号分隔，判断是否存在该起点的任务
// CheckTaskNewStart = Convert.ToString(dvdv[0]["F_CheckTaskNewStart"]);//，分隔
// }
// char[] cc = new char[1] { ',' };
// //查找互斥的堆垛机任务
// if (mutexend != "")
// {
// string[] StackMutexEnd = mutexend.Split(cc);//13001;13002
// string sendcell;
// string[] cellzxy;
// for (int i = 0; i < StackMutexEnd.Length; i++)
// {
// int lanegate = Convert.ToInt32(StackMutexEnd[i]);
// sendcell = ccf.GetStackCoordinateFromLaneGate(lanegate);
// if (sendcell != "-")
// {
// cellzxy = sendcell.Split('-');
// if (cellzxy.Length == 3)
// {
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =4 OR F_DeviceCommandIndex =5) and F_Status>0 and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2})", Convert.ToInt32(cellzxy[0]), Convert.ToInt32(cellzxy[1]), Convert.ToInt32(cellzxy[2]));
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的堆垛机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// }
// }
// }
// //查找互斥RGV任务
// if (mutexend != "")
// {
// sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE ((F_DeviceCommandIndex =2 and F_NumParam4 in ({0})) OR (F_DeviceCommandIndex =3 AND F_NumParam1 in ({0}))) and F_Status>0 ", mutexend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的RGV任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// //查找互斥输送机任务
// if (mutextransend != "")
// {
// sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_NumParam4 in({0}) and F_MonitorIndex <>{1} and F_MonitorIndex in(SELECT min(F_MonitorIndex) as minMidx FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX group by F_ManageTaskIndex) ", mutextransend, TaskIdx);
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex=6 and F_Status >0 and F_NumParam4 in({0}) ", mutextransend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的输送机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// #region H型RGV站台送出指令的判断
// if (CheckTaskStart != "" && CheckTaskNewStart != "")
// {
// //查找站台送出任务对应的终点，在哪组终点中，获得对应的起点组
// //不能存在该起点组的任务
// //ChangeCheckEnd = Convert.ToString(dvdv[0]["F_ChangeCheckEnd"]);//;分隔
// //ChangeToNewEnd = Convert.ToString(dvdv[0]["F_ChangeToNewEnd"]);//；分隔
// //CheckTaskStart = Convert.ToString(dvdv[0]["F_CheckTaskStart"]);//,逗号分隔，判断是否存在该起点的任务
// //CheckTaskNewStart = Convert.ToString(dvdv[0]["F_CheckTaskNewStart"]);//，分隔
// int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
// if (zxy != null)
// {
// string checkend = string.Empty;
// string checkstart = string.Empty;
// int transend = zxy[3];//任务对应的终点输送机
// if(ChangeCheckEnd.Contains(transend.ToString()))
// {
// checkend = ChangeCheckEnd.Replace(';',',');// input.Replace("}", "");
// checkstart = CheckTaskStart;
// }
// if(ChangeToNewEnd.Contains(transend.ToString()))
// {
// checkend = ChangeToNewEnd.Replace(';', ',');
// checkstart = CheckTaskNewStart;
// }
// //不能存在起点是checkstart，终点是checkend的任务
// sqlstr = string.Format(" SELECT F_MonitorIndex FROM T_Monitor_Task where F_DeviceCommandIndex=6 and F_NumParam4 not in({0}) and F_NumParam1 in ({1})", checkend,checkstart);
// //sqlstr = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE F_DeviceCommandIndex=6 and F_Status >0 and F_NumParam4 in({0}) ", mutextransend);
// dvdv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
// if (dvdv.Count > 0)
// {
// int task = Convert.ToInt32(dvdv[0]["F_MonitorIndex"]);
// AheadDetectUnallow.Append(string.Format("存在互斥的输送机任务:{0}，该任务不能执行! ", task));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//不能执行出库任务
// }
// }
// }
// #endregion
// #endregion
//}
#endregion
#region 双伸位的堆垛机在执行起点是里位(1,4排)的任务时,判读是否有起点是外位(2,3排)的任务 送货到货位时(终点为2,3)判断有没有(1,4)的任务，控制近远叉取送货先后
if (devinfo.StackReach==2 && DeviceKind == 1 && ( DeviceOrder == 4))// 双伸堆垛机， 取货
{
int[] zxy = ccf.GetCoordinatesFromMonitorTask(minMidx);
string neighborzxy = string.Empty;
string sqlstrzxy = string.Empty;//
string sqlman = string.Empty;
//bool insidecell = false;//当前任务对应的里位还是外位
bool check = false;
if (zxy != null)
{
int getZ = zxy[0];//取货的排坐标
int sendZ = zxy[3]; //送货位置对应的排坐标
int newZ,newX ,newY;
int tempZ=getZ;
//// if (tempZ>4)
////{
// tempZ =getZ%4;
////}
if ((tempZ == 1) || (tempZ == 5) || (tempZ == 11) || (tempZ == 15) || (tempZ == 4) || (tempZ == 10) || (tempZ == 14) || (tempZ == 18))//里位取货时，要判读是否有外位的取货任务)//里位取货时，要判读是否有外位的取货任务
{//获取外位坐标
if ((tempZ == 1) || (tempZ == 5) || (tempZ == 11) || (tempZ == 15))
{
newZ=getZ+1;
}
else
{ newZ=getZ-1;
}
neighborzxy = string.Format("{0:D2}-{1:D2}-{2:D2}", newZ, zxy[1], zxy[2]);//获得外位坐标
sqlstrzxy = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE (F_DeviceCommandIndex =4) and (F_NumParam1 = {0}) AND (F_NumParam2 = {1}) AND (F_NumParam3 = {2}) and (F_DeviceIndex={3})", newZ, zxy[1], zxy[2], DeviceIdx);
//sqlstrzxy
sqlman = string.Format("SELECT FID FROM T_Manage_Task WHERE (FSTATUS = 0) AND(FSTARTDEVICE = {0}) AND (FSTARTCELL = '{1}') ", StartDevice, neighborzxy);
//sqlstrzxy
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;//不能执行出库任务
}
}
}
tempZ=sendZ;
////if (tempZ>4)
////{
// tempZ =sendZ%4;
////}
if ((tempZ == 2) || (tempZ == 6) || (tempZ == 12) || (tempZ == 16) || (tempZ == 3) || (tempZ == 9) || (tempZ == 13) || (tempZ == 17))//外位送货时，要判读是否有里位的送货任务
{//获取里位坐标
if ((tempZ == 2) || (tempZ == 6) || (tempZ == 12) || (tempZ == 16))
{
newZ = sendZ - 1;
}
else
{
newZ = sendZ + 1;
}
neighborzxy = string.Format("{0:D2}-{1:D2}-{2:D2}", newZ, zxy[4], zxy[5]);//获得外位坐标
sqlstrzxy = string.Format("SELECT F_MonitorIndex FROM T_Monitor_Task WHERE ( F_DeviceCommandIndex =5) and (F_NumParam4 = {0}) AND (F_NumParam5 = {1}) AND (F_NumParam6 = {2}) and (F_DeviceIndex={3})", newZ, zxy[4], zxy[5], DeviceIdx);
sqlman = string.Format("SELECT FID FROM T_Manage_Task WHERE (FSTATUS = 0) AND(FENDDEVICE = {0}) AND (FENDCELL = '{1}') ", EndDevice, neighborzxy);
check = true;
if (check)
{
dvdv = dbo.ExceSQL(sqlstrzxy).Tables[0].DefaultView;
if (dvdv.Count > 0)//
{
AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;//不能执行出库任务
}
dvdv = dbo.ExceSQL(sqlman).Tables[0].DefaultView;
if (dvdv.Count > 0)//
{
AheadDetectUnallow.Append(string.Format("存在相邻货位{0}的优先任务，该任务暂时不能执行! ", neighborzxy));
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;//不能执行出库任务
}
}
}
}
}
#endregion
#region 顶升机构自关联入库任务单独处理//20101011
//20100406入库顶升时必要检测：1102内探物“-11021”；1121低到位“-11212”；有关联任务时，1102外探物“-11022”；
if ((ccf.GetCorrel_DeviceIndex(devinfo.DeviceIndex, true) == "0") && (CONTROLTASKTYPE == 1) && (devinfo.IfCorrelDoubleFork == "1") && (devinfo.VirtualStack == 0))//顶升设备自关联，入库任务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 <> '') 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 = '') 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
//20101011
#region 双叉堆垛机的取货任务在此判断是否关联双叉、验证双叉任务是否为双叉极限货位
if ((devinfo.DeviceKind == 1) && (devinfo.IfCorrelDoubleFork == "1") && (ccf.GetDeviceOrderFromMonitor(minMidx) == 4) && (CONTROLTASKTYPE == 1)&&(devinfo.VirtualStack==0))
{
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 20170110单叉入库任务执行时判读关联位置载货状态
int device =Convert.ToInt32( DevLanewayIOInfo[0]); //站台设备编号
string checkgoods = DevLanewayIOInfo[5];//判读该站台的关联站台是否有货
if (checkgoods!="")//不为空
{
int devicebyte = 0, devbit = 0;
DS = checkgoods.Trim().Split(dd);
int.TryParse(DS[0], out devicebyte);
int.TryParse(DS[1], out devbit);
//判断是否检测负数索引值（负数代表是否满足开关量＝１的执行前提）
int havegoods = CStaticClass.GetDevicePhotoelectric(devicebyte, devbit);//20101124
if(havegoods==1)
{
string msg = string.Format("执行单叉入库任务时，入库站台{0}的关联站台有货，不能执行单叉入库", device);
AheadDetectUnallow.Append(msg);
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return 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
}
//判断堆垛机上是否载货
#region 20170110判断堆垛机上是否载货
if (devinfo.SplitByte_0 == 1 || devinfo.SplitByte_1 == 1)
{
string msg = string.Format("执行双叉入库任务时,堆垛机{0}上有货，不能执行双叉入库", devinfo.DeviceIndex);
AheadDetectUnallow.Append(msg);
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return 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
#region 有互斥设备的堆垛机20111020
//if (DeviceKind == 1 && devinfo.VirtualStack > 0 && DeviceIdx != devinfo.VirtualStack)//&& DeviceKind != 1)
//{
// int xcoor = Model.CGeneralFunction.GetXCoorFromMonitor(TaskIdx, DeviceIdx, order);
// int zcoor = Model.CGeneralFunction.GetZCoorFromMonitor(TaskIdx, DeviceIdx, order);
// int BCcoor = GetBarcodeCoor(xcoor, zcoor,devinfo.VirtualStack);//获得任务对应的位置的条码值
// int mutex = ccf.GetStackMutexDevice(DeviceIdx, devinfo.XCoor, devinfo.Sequence, BCcoor,devinfo.VirtualStack);
// int[] mutexdistance = ccf.GetMutexSafeDistanceFromStackInfo(devinfo.VirtualStack);
// if (mutexdistance!=null)
// {
// StackMutexXCoor = mutexdistance[0];
// minStackMutexXCoor = mutexdistance[1];
// StackZeroXCoor = mutexdistance[2];
// }
// 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空闲、无任务、无管理任务预约锁
// if (mutexdev.Sequence > devinfo.Sequence)//执行任务的堆垛机坐标小
// {//mutex=35002
// if ((BCcoor + StackMutexXCoor) >= mutexdev.XCoor)//mdev.XCoor如果是条码带值需要转换为列值
// {
// InsertStackMutexOrder(mutex, 2, (BCcoor + StackMutexXCoor), 5, mutexdev.Sequence, devinfo.Sequence,devinfo.VirtualStack);
// if (devinfo.XCoor <= mutexdev.XCoor - minStackMutexXCoor)//在最小安全距离以外，可以运动
// {
// return true;
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}避让! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// }
// }
// else//执行任务的堆垛机坐标大
// {//mutex35001
// //if (BCcoor >= (StackMutexXCoor + StackZeroXCoor))
// //{
// // BCcoor = (BCcoor - StackMutexXCoor);
// //}
// //else
// //{
// // return true;//对开报警吧，管理下任务错了，或者分配堆垛机设备错误
// //}
// if (BCcoor <= (mutexdev.XCoor + StackMutexXCoor))//mdev.XCoor如果是条码带值需要转换为列值
// {
// InsertStackMutexOrder(mutex, 2, BCcoor - StackMutexXCoor, 5, mutexdev.Sequence, devinfo.Sequence,devinfo.VirtualStack);
// if (devinfo.XCoor > mutexdev.XCoor + minStackMutexXCoor)
// {
// return true;
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}避让! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// 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,mutexdev.VirtualStack);//获得互斥堆垛机执行任务的坐标列条码值
// if (mutexdev.Sequence > devinfo.Sequence)//互斥堆垛机的序列号大，坐标值大
// {
// if (mutbccoor <= (BCcoor + StackMutexXCoor))
// {
// //if (mutbccoor > 52000)
// //{//20120110
// // return true;
// //}
// //else
// //{
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}执行完任务! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// //}
// }
// }
// else//互斥堆垛机的序列号小，坐标值小
// {//mutex小
// if (BCcoor >= (StackMutexXCoor + StackZeroXCoor))
// {
// if (mutbccoor >= (BCcoor - StackMutexXCoor))
// {
// //if (mutbccoor < 4481)//20120110
// //{//20120110
// // return true;
// //}
// //else
// //{
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}执行完任务! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// //}
// }
// }
// else
// {
// //if (BCcoor >= 52000)
// //{
// // return true;
// //}
// //else
// //{
// AheadDetectUnallow.Append(string.Format("堆垛机不能执行{0}列任务! ", xcoor));//小于安全距离
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// //}
// }
// }
// #endregion
// }
// else
// {//有任务，被预约，但没运行任务,可能报警或者触摸屏控制
// if ((mutexdev.RunState > 0) || (mutexDeviceLockedState != 0))
// {// 报警或者被任务锁定
// #region 互斥设备不空闲
// if (mutexdev.Sequence > devinfo.Sequence)
// {//mutex=35002
// if (mutexdev.XCoor <= (BCcoor + StackMutexXCoor))
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}执行完任务! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;//或者放行直接报警
// }
// }
// else
// {//mutex=35001
// if (BCcoor >= (StackMutexXCoor + StackZeroXCoor))
// {
// if (mutexdev.XCoor >= (BCcoor - StackMutexXCoor))
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}执行完任务! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("堆垛机不能执行{0}列任务! ", xcoor));//小于安全距离
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// }
// #endregion
// }
// else
// {
// #region mutex被管理任务预约了，但是还没运行（【送货】等待运行）
// int deviceorder = GetDeviceOrderFromManTaskReserve(mutexManTaskReserve, mutex);
// if (deviceorder == -1) return false;
// GetStackRunReserveX_Zcoor(mutex, out mutXcoor, out mutZcoor);
// if (mutexdev.Sequence > devinfo.Sequence)
// {
// if (mutexdev.XCoor <= (BCcoor + StackMutexXCoor))
// {
// //去货位高度合适位置避让，或者到52列（60000）
// InsertStackMutexOrder(mutex, deviceorder, (BCcoor + StackMutexXCoor), GetLayerHigh(mutZcoor, mutXcoor,mutexdev.VirtualStack), mutexdev.Sequence, devinfo.Sequence,mutexdev.VirtualStack);
// //if (mutexdev.XCoor > 52000)//20120110
// //{
// // return true;
// //}
// //else
// //{
// if (devinfo.XCoor < mutexdev.XCoor - minStackMutexXCoor)
// {
// return true;
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}避让! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// //}
// }
// }
// else
// {//mutex小
// if (BCcoor >= (StackMutexXCoor + StackZeroXCoor))
// {
// if (mutexdev.XCoor >= (BCcoor - StackMutexXCoor))
// {
// //去货位高度合适位置避让，或者到0列（2000）
// InsertStackMutexOrder(mutex, deviceorder, (BCcoor - StackMutexXCoor), GetLayerHigh(mutZcoor, mutXcoor,mutexdev.VirtualStack), mutexdev.Sequence, devinfo.Sequence,mutexdev.VirtualStack);
// //if (mutexdev.XCoor < 4481)
// //{
// // return true;
// //}
// //else
// //{
// if (devinfo.XCoor > mutexdev.XCoor + minStackMutexXCoor)
// {
// return true;
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("等待堆垛机{0}避让! ", mutex));
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// //}
// }
// }
// else
// {
// AheadDetectUnallow.Append(string.Format("堆垛机不能执行{0}列任务! ", xcoor));//小于安全距离
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
// }
// #endregion
// }
// }
// }
// }
//}
#endregion
#region 弯道堆垛机需要优化处理
if (devinfo.DeviceKind == 1 )
{
//先判断是否是弯道堆垛机
//获得堆垛机当前所在的巷道
int lanecount = ccf.GetLaneCountsStackIn(DeviceIdx);
if (lanecount>1)//堆垛机对应多个巷道
{
int curlane = devinfo.ZCoor;//当前所在排Z，可能是1，2，3 ;3代表在弯道
if (curlane<3)//在弯道时不予判读
{
int stack =Convert.ToInt32( DeviceIdx.ToString().Substring(2));//01（1101）,001（11001）
//先获得堆垛机编号，设备号的后两位M，计算出所在的巷道号：M+Z
int lane; //得到堆垛机当前所在的巷道号：1，2，3，4
if (curlane % 2 == 0)
{
lane = curlane* stack;
}
else
{
lane =1+ (stack-1)*2;
}
int tasklane = ccf.GetLaneByTask(minMidx,order);//当前任务所在巷道
if (lane != tasklane)//当堆垛机所在巷道和任务所在巷道不同时
{
if (order == 4)//
{
//查看是否存在所在巷道的任务
bool havelanetask = ccf.IfExistTaskInLane(lane);
if (havelanetask)
{
AheadDetectUnallow.Append(string.Format("{0}巷道还有任务未执行完! ", lane));//小于安全距离
//AheadDetectUnallow.Append(DeviceIdx.ToString() + "还有巷道" + lane.ToString() + "的任务没有执行完");
UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
return false;
}
}
//else
//if (order == 3||order == 5)//送货任务禁止夸hang'dao
//{
// if (devinfo.SplitByte_0==1)
// {
// AheadDetectUnallow.Append(string.Format("禁止载货经过弯道! "));//小于安全距离
// UpdateAheadDetectUnallow(AheadDetectUnallow, minMidx);
// return false;
// }
//}
}
//获取任务所在巷道
//判读是否存在当前所在巷道的任务
}
}
}
#endregion
return true;
}
catch (Exception ex)
{
string mes = string.Format("发送指令:{0}提前检测:{1}时发生错误：{2}{3}", minMidx, _AheadDetect, ex.StackTrace , ex.Message);
RefreshMonitorEventArgs rme = new RefreshMonitorEventArgs("tsStatus", mes);
OnRefreshMonitor(rme);
return false;
}
finally
{
dv.Dispose();
dvdv.Dispose();
}
}
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 rownum=1 and (F_ManageTASKKINDINDEX = {0}) and F_ManageTaskIndex={1} order by F_MonitorIndex asc", Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dv[i]["F_ManageTASKINDEX"])));
}
else
{
sql.Append(string.Format("SELECT top 1 F_DeviceIndex,F_Status FROM T_Monitor_Task WHERE (F_ManageTASKKINDINDEX = {0}) and F_ManageTaskIndex={1} order by F_MonitorIndex asc", Convert.ToInt32(dv[i]["F_ManageTASKKINDINDEX"]), Convert.ToInt32(dv[i]["F_ManageTASKINDEX"])));
}
dv0 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
if (dv0.Count > 0)
{
if ((dv0[0]["F_DeviceIndex"].ToString() == DeviceIdx.ToString()) && (dv0[0]["F_Status"].ToString() == "0"))
{
return true;
}
}
}
return false;
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
dv0.Dispose();
}
}
private int GetBarcodeCoor(int xcoor, int zcoor,int vStack)
{
DataView dv = new DataView();
try
{
dv = dbo.ExceSQL(string.Format("SELECT BarcodeCoor FROM T_Base_BarcodeCoor WHERE (XCoor = {0}) AND (ZCoor = {1}) and (VirtualStack={2})", xcoor, zcoor,vStack)).Tables[0].DefaultView;
if (dv.Count > 0)
{
return Convert.ToInt32(dv[0][0]);
}
else
{
dv = dbo.ExceSQL(string.Format("SELECT BarcodeCoor FROM T_Base_BarcodeCoor WHERE (XCoor = {0}) and (VirtualStack={1})", xcoor, vStack)).Tables[0].DefaultView;
if (dv.Count > 0)
{
return Convert.ToInt32(dv[0][0]);
}
else
{
return 0;
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
}
}
/// <summary>
/// 获得发送信息
/// </summary>
/// <param name="minMidx">设备指令索引</param>
public bool GetSendInfo(int minMidx)
{
DataView dvD = new DataView();
try
{
sql.Remove(0, sql.Length);
sql.Append("SELECT F_DeviceKindIndex,F_NumParam1,F_NumParam2,F_NumParam3,F_NumParam4," ).Append(
"F_NumParam5,F_NumParam6,F_TxtParam,F_AheadDetect,F_ManTaskReserve,F_LockedState," ).Append(
"F_Associate,F_SerialNumber,F_RouteID,F_DeviceIndex,F_DeviceCommandIndex," ).Append(
"F_MonitorIndex,F_ManageTaskIndex,F_ManageTaskKindIndex,F_OutsideAltDevice," ).Append(
"F_InsideAltDevice,F_StartDevice,F_EndDevice,F_RouteKind,F_UseAwayFork,F_AgvNo " ).Append(
" FROM V_Monitor_Route_Device where F_MonitorIndex=" ).Append( minMidx);
dvD = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dvD.Count > 0)
{
if (dvD[0]["F_AheadDetect"] != DBNull.Value)
{
_AheadDetect = dvD[0]["F_AheadDetect"].ToString();
}
else
{
_AheadDetect = "";
}
if (dvD[0]["F_ManTaskReserve"] != DBNull.Value)
{
_ManTaskReserve = Convert.ToInt32(dvD[0]["F_ManTaskReserve"]);
}
else
{
_ManTaskReserve = 0;
}
if (dvD[0]["F_Associate"] != DBNull.Value)
{
_Associate = Convert.ToInt32(dvD[0]["F_Associate"]);
}
else
{
_Associate = 0;
}
if (dvD[0]["F_LockedState"] != DBNull.Value)
{
_LockedState = Convert.ToInt32(dvD[0]["F_LockedState"]);
}
else
{
_LockedState = 0;
}
if (dvD[0]["F_NumParam1"] != DBNull.Value)
{
_NumParam1 = Convert.ToInt32(dvD[0]["F_NumParam1"]);
}
else
{
_NumParam1 = 0;
}
if (dvD[0]["F_NumParam2"] != DBNull.Value)
{
_NumParam2 = Convert.ToInt32(dvD[0]["F_NumParam2"]);
}
else
{
_NumParam2 = 0;
}
if (dvD[0]["F_NumParam3"] != DBNull.Value)
{
_NumParam3 = Convert.ToInt32(dvD[0]["F_NumParam3"]);
}
else
{
_NumParam3 = 0;
}
if (dvD[0]["F_NumParam4"] != DBNull.Value)
{
_NumParam4 = Convert.ToInt32(dvD[0]["F_NumParam4"]);
}
else
{
_NumParam4 = 0;
}
if (dvD[0]["F_NumParam5"] != DBNull.Value)
{
_NumParam5 = Convert.ToInt32(dvD[0]["F_NumParam5"]);
}
else
{
_NumParam5 = 0;
}
if (dvD[0]["F_NumParam6"] != DBNull.Value)
{
_NumParam6 = Convert.ToInt32(dvD[0]["F_NumParam6"]);
}
else
{
_NumParam6 = 0;
}
if (dvD[0]["F_TxtParam"] != DBNull.Value)
{
_TxtParam = dvD[0]["F_TxtParam"].ToString();
}
else
{
_TxtParam = "-";
}
_serialNumber = Convert.ToInt32(dvD[0]["F_SerialNumber"]);
_routeID = Convert.ToInt32(dvD[0]["F_RouteID"]);
_DeviceIdx = Convert.ToInt32(dvD[0]["F_DeviceIndex"]);
_DeviceOrder = Convert.ToInt32(dvD[0]["F_DeviceCommandIndex"]);
_ManageKindIdx = Convert.ToInt32(dvD[0]["F_ManageTaskKindIndex"]);
_ManageTaskIdx = Convert.ToInt32(dvD[0]["F_ManageTaskIndex"]);
_DeviceKind = Convert.ToInt32(dvD[0]["F_DeviceKindIndex"]);
if (dvD[0]["F_OutsideAltDevice"] != DBNull.Value)
{
_OutsideAltDevice = Convert.ToInt32(dvD[0]["F_OutsideAltDevice"]);
}
else
{
_OutsideAltDevice = 0;
}
if (dvD[0]["F_InsideAltDevice"] != DBNull.Value)
{
_InsideAltDevice = Convert.ToInt32(dvD[0]["F_InsideAltDevice"]);
}
else
{
_InsideAltDevice = 0;
}
_StartDevice = Convert.ToInt32(dvD[0]["F_StartDevice"]);
_EndDevice = Convert.ToInt32(dvD[0]["F_EndDevice"]);
_RouteKind = Convert.ToInt32(dvD[0]["F_RouteKind"]);
if (dvD[0]["F_AgvNo"] != DBNull.Value)
{
_AgvNo = Convert.ToInt32(dvD[0]["F_AgvNo"]);
}
else
{
_AgvNo = 65535;
}
return true;
}
else
{//20120420
CControlError = string.Format("发送命令调用GetSendInfo时：路径表里【{0}】设备索引不存在！", GetDeviceFromMonitor(minMidx).ToString());
return false;
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
dvD.Dispose();
}
}
/// <summary>
/// 发送指定调度任务号的命令
/// </summary>
/// <param name="MonitorIndex"></param>
/// <returns></returns>
public bool SendMonitorTask(int MonitorIndex)
{
//return false;
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 manageKindIdx = ccf.GetManageTaskKindIndexFromMonitor(MonitorIndex);
int manageTaskIdx = ccf.GetManageTaskIndexfromMonitor(MonitorIndex);
int TaskControlType = ccf.GetManageTaskTypefromMonitor(MonitorIndex);
int ManageStartDeviceIndex = ccf.GetManageStartdevicefromMonitor(MonitorIndex);
int ManageEnddeviceIndex = ccf.GetManageEnddevicefromMonitor(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 ((deviceIdx == 12109) || (deviceIdx == 12214) || (deviceIdx == 22201) || (deviceIdx == 12116))
//{
// DataView dvspHave = new DataView(); DataView dvspN4 = new DataView();
// sql.Remove(0, sql.Length);
// sql.Append("select * from T_Monitor_Task where F_MonitorIndex = ").Append(MonitorIndex);
// dvspN4 = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
// if (dvspN4.Count > 0)
// {
// int N4 = Convert.ToInt32(dvspN4[0]["F_NumParam4"]);
// if ((N4 == 12401) || (N4 == 12403))
// {
// Model.MDevice devinfoN4;
// devinfoN4 = Model.CGetInfo.GetDeviceInfo(N4);
// sql.Remove(0, sql.Length);
// sql.Append("select * from T_Monitor_Task where F_DeviceIndex = ").Append(deviceIdx).Append(" and F_NumParam4 = ").Append(N4).Append(" and F_MonitorIndex != ").Append(MonitorIndex);
// dvspHave = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
// if (dvspHave.Count + devinfoN4.SplitByte_0 >= 2)
// {
// AheadDetectUnallow.Clear();
// AheadDetectUnallow.Append(_DeviceIdx.ToString() + "不能发送任务,巷道入口满货或任务数上限");
// UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
// return false;
// }
// }
// else if ((N4 == 12116))
// {
// Model.MDevice devinfoN4;
// devinfoN4 = Model.CGetInfo.GetDeviceInfo(N4);
// sql.Remove(0, sql.Length);
// sql.Append("select * from T_Monitor_Task where F_DeviceIndex = ").Append(deviceIdx).Append(" and F_NumParam4 = ").Append(N4).Append(" and F_MonitorIndex != ").Append(MonitorIndex);
// dvspHave = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
// if (dvspHave.Count + devinfoN4.SplitByte_0 >= 1)
// {
// AheadDetectUnallow.Clear();
// AheadDetectUnallow.Append(_DeviceIdx.ToString() + "不能发送任务,异常口满货或任务数上限");
// 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,"NO") == 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]);
}
else if (deviceKind == 4)
{
if (ccf.NeedOptimize(deviceIdx) == true)
{
ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
sendok = true;
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[2]);
}
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[5]);
}
if (sendok == false)
{
if (sdo.CommLayerError != null)
{
RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", sdo.CommLayerError);
OnRefreshMonitor(rmea);
}
return false;
}
else
{
//////////////////////////
ccf.SendOrderSuccess(manageKindIdx, manageTaskIdx, MonitorIndex, deviceIdx, _routeID,0);
#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]),1);
}
}
}
#endregion
return true;
}
#endregion
}
#region 自动命令(taskkind == 1，2)
//(taskkind == 1，2)自动命令和临时管理管理命令
///////////////////////////////////////
//2--6应该做递归调用函数
///////////////////////////////////////
/////////////////////
//20100208
#region 环形穿梭车RGV分配车号修改提前检测
#endregion
////////////////////
//2：提取每个管理单据的第一个设备状态
if (GetFirstDeviceIFLocked(MonitorIndex, true) == false)//没有被锁定，空闲
{
//攀枝花当升控制投料层，双向输送线顶牛
if ((deviceIdx == 15001) && (deviceOrder == 2) && (TaskControlType == 1))//执行穿梭车入库取货任务
{
DataView dvRouteN = dbo.ExceSQL(string.Format("SELECT * FROM T_Manage_Task WHERE FCONTROLTASKTYPE =2 and FSTATUS > 0 and FSTARTDEVICE = {0} and FENDDEVICE > 22020 and FENDDEVICE < 22049 and FCurrentLocation < 22019", ManageEnddeviceIndex)).Tables[0].DefaultView;
if (dvRouteN.Count > 0)//存在已执行的投料口出库任务
{
AheadDetectUnallow.Clear();
AheadDetectUnallow.Append("此终点巷道的出库任务已经运行且位置已经进入冲撞区");
UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
return false;
}
}
if ((devinfo.DeviceKind == 1) && (deviceOrder == 4) && (TaskControlType == 2) && (ManageEnddeviceIndex > 22020) && (ManageEnddeviceIndex < 22049))//执行垛机投料口取货任务
{
//for (int g = 0; g < 3; g++)//控制出库不能在输送线上停盘
//{
//}
DataView dvRouteJ = dbo.ExceSQL(string.Format("SELECT * FROM T_Manage_Task WHERE FCONTROLTASKTYPE =1 and FENDDEVICE = {0} and (FSTARTDEVICE = 22021 or FSTARTDEVICE = 22006 or FSTARTDEVICE = 22012)", ManageStartDeviceIndex)).Tables[0].DefaultView;// and FCurrentLocation < 22019//and FSTATUS > 0
if (dvRouteJ.Count > 0)//存在已执行的对应巷道3楼入库库任务，且已经运行到穿梭车货巷道对应输送线上或穿梭车上
{
AheadDetectUnallow.Clear();
AheadDetectUnallow.Append("此巷道为终点的入库任务已经运行且位置已经进入冲撞区");
UpdateAheadDetectUnallow(AheadDetectUnallow, MonitorIndex);
return false;
}
}
devinfo = Model.CGetInfo.GetDeviceInfo(deviceIdx);
//7：发送此设备命令
//CStaticClass.MessageIndex++;
CStaticClass.MessageIndex = 1;
msgIdx = (CStaticClass.MessageIndex);
sdo = CommModeCreate.CreateSendDeviceOrder(deviceIdx);
//判断设备是否为堆垛机RGV和ＡＧＶ
int[] gc = new int[6] { _NumParam2, _NumParam3, _NumParam1, _NumParam5, _NumParam6, _NumParam4 };//获得坐标
if (gc == null)
{
this.CControlError +=string.Format( "发送命令时不能取得设备坐标！");
return false;
}
if (deviceKind == 1)
{
//1：堆垛机；4：RGV；6：AGV如果需要优化调度（设备表的F_NeedOptimize='1'）
//直接写入表：T_Monitor_Task_Child，不发送命令
if (ccf.NeedOptimize(deviceIdx) == true)
{
ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
sendok = true;
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder,
deviceIdx, gc[0], gc[1], gc[2], gc[3], gc[4], gc[5]);
}
}
else if (deviceKind == 6)//agv
{
int iTaskLevel = ccf.GetTaskLevel(manageTaskIdx);
string strPalletBarcode = ccf.GetBarCodeFromManageTask(manageTaskIdx, manageKindIdx);
sendok = sdo.SendDeviceOrder(MonitorIndex, iTaskLevel, strPalletBarcode, gc[0].ToString(), gc[3].ToString(), 0, 0, DateTime.Now);
//int TaskIndex, int TASK_LEVEL, string PALLET_BARCODE, string START_DEVICE_CODE, string FINISH_DEVICE_CODE, int status, int agvcode, DateTime time
}
else if (_DeviceKind == 4)
{
if (ccf.NeedOptimize(deviceIdx) == true)
{
ccf.InsertMonitorOptimizeChildTask(MonitorIndex);
sendok = true;
}
else
{
sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[2]);
}
}
else if (_DeviceKind == 7)
{
int ControlType = ccf.GetFCONTROLTASKTYPEFromManageTask(_ManageKindIdx, _ManageTaskIdx);
#region 条码设备直接比对
DataView dv = dbo.ExceSQL(string.Format("SELECT F_MonitorIndex 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) || (ControlType != 1))
{//比对正确
object[] obj = new object[3] { _ManageKindIdx, _ManageTaskIdx, Model.CGeneralFunction.TASKABEND };
dbo.ExecuteSql(string.Format("UPDATE T_Manage_Task SET FExceptionNO=NULL WHERE (F_ManageTaskKindIndex ={0}) AND (FID ={1}) and FExceptionNO={2}", obj));
Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
}
else
{//比对错误，改道异常处理口
//修改目标位置至异常口
dv = dbo.ExceSQL(string.Format("SELECT F_Remark,F_BindingDevice,F_BarCode FROM T_Base_PLC_Ask WHERE T_Base_PLC_Ask.F_DeviceIndex = {0}", deviceIdx)).Tables[0].DefaultView;
if (dv.Count > 0)
{
if ((CStaticClass.DeviceErrorAutoModifyRoutePath == "1") && (dv[0]["F_BarCode"].ToString().IndexOf("11111") < 0))
{
object[] obj = new object[5] { _ManageKindIdx, _ManageTaskIdx, Convert.ToInt32(dv[0]["F_Remark"]), Model.CGeneralFunction.TASKABEND, Convert.ToInt32(dv[0]["F_BindingDevice"]) };
dbo.ExecuteSql(string.Format("UPDATE T_Manage_Task SET FExceptionNO={3},FSTARTDEVICE ={4}, FSTARTCELL ='-',FENDDEVICE ={2}, FENDCELL ='-', FENDUCODE =0 WHERE (F_ManageTaskKindIndex ={0}) AND (FID ={1})", obj));
ccf.GetUseableRouteIDSubAndModifyRoute(_ManageTaskIdx, _ManageKindIdx, Convert.ToInt32(dv[0]["F_BindingDevice"]));
}
else
{
Model.MError me;
if (dv[0]["F_BarCode"].ToString() == "-")//扫描器未读条码
{
me = null;
Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
//me = Model.CGetInfo.GetErrorInfo(732);
//dbo.ExecuteSql(string.Format("update T_Monitor_Task set F_Status=32 WHERE (T_Monitor_Task.F_MonitorIndex = {0})", MonitorIndex));
}
else if (dv[0]["F_BarCode"].ToString().IndexOf("11111") >= 0)
{//"1111111111"条码未读到
object[] obj = new object[3] { _ManageKindIdx, _ManageTaskIdx, Model.CGeneralFunction.TASKABEND };
dbo.ExecuteSql(string.Format("UPDATE T_Manage_Task SET FExceptionNO={2} WHERE (F_ManageTaskKindIndex ={0}) AND (FID ={1})", obj));
Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
//dbo.ExecuteSql(string.Format("update T_Monitor_Task set F_Status=30 WHERE (T_Monitor_Task.F_MonitorIndex = {0})", MonitorIndex));
me = Model.CGetInfo.GetErrorInfo(730);
}
else
{//条码不正确
object[] obj = new object[3] { _ManageKindIdx, _ManageTaskIdx, Model.CGeneralFunction.TASKABEND };
dbo.ExecuteSql(string.Format("UPDATE T_Manage_Task SET FExceptionNO={2} WHERE (F_ManageTaskKindIndex ={0}) AND (FID ={1})", obj));
Model.CGeneralFunction.ActionComplete(deviceIdx, MonitorIndex, 0);
// dbo.ExecuteSql(string.Format("update T_Monitor_Task set F_Status=31 WHERE (T_Monitor_Task.F_MonitorIndex = {0})", MonitorIndex));
me = Model.CGetInfo.GetErrorInfo(731);
}
if (me != null)
{
RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("notifyIcon1", "警告:" + devinfo.DeviceName + "," + deviceIdx + "发生故障：" + me.ErrorName);
OnRefreshMonitor(rmea);
}
}
if (_ManageKindIdx == 1)
{
sql.Remove(0, sql.Length);
sql.Append("update IO_Control set ERROR_TEXT='").Append(devinfo.DeviceName).Append(",").Append(deviceIdx).Append("条码不正确！").Append("' where CONTROL_ID=").Append(manageTaskIdx);
dboM.ExceSQL(sql.ToString());
}
}
}
//20130709 dbo.ExecuteSql(string.Format("UPDATE T_Base_PLC_Ask SET F_BarCode = '-' WHERE (F_DeviceIndex = {0}) ", deviceIdx));
#endregion
return 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 (devinfo.DeviceIndex == 42002)
//{
// Model.MDevice devinfo42038 = Model.CGetInfo.GetDeviceInfo(42038);
// Model.MDevice devinfo42043 = Model.CGetInfo.GetDeviceInfo(42043);
// if ((devinfo42038.RunState == 4) && (devinfo42043.RunState != 4))
// {
// gc[5] = 42043;
// CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "42038禁用,更改终点位置", "42043", MonitorIndex.ToString());
// }
// else
// {
// //do nothing
// }
//}
//if (devinfo.DeviceIndex == 42007)
//{
// Model.MDevice devinfo42038 = Model.CGetInfo.GetDeviceInfo(42038);
// Model.MDevice devinfo42043 = Model.CGetInfo.GetDeviceInfo(42043);
// if ((devinfo42043.RunState == 4) && (devinfo42038.RunState != 4))
// {
// gc[5] = 42038;
// CommonClassLib.CCarryConvert.WriteDarkCasket("OPCClient", "42043禁用,更改终点位置", "42038", MonitorIndex.ToString());
// }
// else
// {
// //do nothing
// }
//}
sendok = sdo.SendDeviceOrder(msgIdx, MonitorIndex, deviceOrder, deviceIdx, gc[5]);
}
if (sendok == false)
{
if (sdo.CommLayerError != null)
{
RefreshMonitorEventArgs rmea = new RefreshMonitorEventArgs("tsStatus", sdo.CommLayerError);
OnRefreshMonitor(rmea);
}
return false;
}
else//发送命令成功
{
sql.Remove(0, sql.Length);
sql.Append("update T_Monitor_Task set F_SendFlag='1' where F_MonitorIndex=").Append(MonitorIndex);
dbo.ExecuteSql(sql.ToString());//20100905只重发主任务
// 电气有拆叠盘机满朵后再入进拆叠盘机任务时才时给申请，固删除此控制，更改在拆叠盘机申请离开时直接给管理申请
//if (deviceKind == 2)//广西华友 当发送任务去32024时 判断拆碟盘机如果有挂起的离开申请，向管理申请托盘垛回库
//{
// if (gc[5] == 32024)
// {
// DataView dvsp320242 = new DataView();
// dvsp320242 = dbo.ExceSQL(string.Format("select Apply_Flag from T_Base_Device_Apply WHERE (DeviceIndex = 390011) ")).Tables[0].DefaultView;
// if (dvsp320242.Count > 0)//如有来挂起的申请
// {
// if (Convert.ToString(dvsp320242[0]["Apply_Flag"]) == "1")
// {
// StringBuilder dtime2 = new StringBuilder(DateTime.Now.ToString("u"));
// dtime2.Remove(dtime2.Length - 1, 1);
// object[] ob2 = new object[10]
// {
// 1, 32024, 6, 0, dtime2,0,0,0,0,0
// };
// CStaticClass.dboM.ExecuteSql(
// string.Format(
// "INSERT INTO IO_CONTROL_APPLY (CONTROL_APPLY_TYPE,DEVICE_CODE, STOCK_BARCODE, APPLY_TASK_STATUS, CREATE_TIME)VALUES ({0},'{1}','{2}',{3},'{4}')",
// ob2));
// CommonClassLib.CCarryConvert.WriteDarkCasket(
// "OPCClient", "去32024任务发送成功时，有32024挂起的离开申请:", "",
// ",站台：32024" + "，标识：" +
// Convert.ToString(dvsp320242[0]["Apply_Flag"])); //20140218
// }
// }
// }
//}
//if (devinfo.DeviceIndex == 32024)//广西华友 当有32024离开的任务发送成功时，如果有挂起的离开任务清除挂起的申请离开
//{
// DataView dvsp320243 = new DataView();
// dvsp320243 = dbo.ExceSQL(string.Format("select Apply_Flag from T_Base_Device_Apply WHERE (DeviceIndex = 390011) ")).Tables[0].DefaultView;
// if (dvsp320243.Count > 0)//如有来挂起的申请离开
// {
// if (Convert.ToString(dvsp320243[0]["Apply_Flag"]) == "1")//申请离开
// {
// dbo.ExceSQL("UPDATE T_Base_Device_Apply SET Apply_Flag = 0 where DeviceIndex = 390011");
// CommonClassLib.CCarryConvert.WriteDarkCasket("32024", "", "", "32024离开任务发送成功 ，若果有32024挂起的申请离开，删除挂起的申请");
// }
// }
// DataView dvsp320244 = new DataView();
// dvsp320244 = dbo.ExceSQL(string.Format("SELECT FCONTROLTASKTYPE FROM T_Manage_Task WHERE (FID = "+manageTaskIdx.ToString()+") ")).Tables[0].DefaultView;
// if (dvsp320244.Count > 0)//如过离开拆碟盘机任务为入库 置39001为空,如过离开拆碟盘机任务为站台间移库 置39001为不满货
// {
// if (Convert.ToString(dvsp320244[0]["FCONTROLTASKTYPE"]) == "1")
// {
// dbo.ExceSQL("UPDATE T_Base_Device_Full_NotFull SET Full_Flag = 0 where DeviceIndex = 39001");
// CommonClassLib.CCarryConvert.WriteDarkCasket("32024", "", "", "32024整垛离开任务发送成功 ，更新39001为空0");
// }
// else if (Convert.ToString(dvsp320244[0]["FCONTROLTASKTYPE"]) == "4")
// {
// dbo.ExceSQL("UPDATE T_Base_Device_Full_NotFull SET Full_Flag = 1 where DeviceIndex = 39001");
// CommonClassLib.CCarryConvert.WriteDarkCasket("32024", "", "", "32024单盘离开任务发送成功 ，更新39001为有货（不满货）1");
// }
// }
//}
//if ((deviceIdx == 32043) && (gc[5] == 32024))
//{
// DataView dvsp320245 = new DataView();
// dvsp320245 = dbo.ExceSQL(string.Format("SELECT FCONTROLTASKTYPE FROM T_Manage_Task WHERE (FID = "+manageTaskIdx.ToString()+") ")).Tables[0].DefaultView;
// if (dvsp320245.Count > 0)
// {
// if (Convert.ToString(dvsp320245[0]["FCONTROLTASKTYPE"]) == "2")
// {
// dbo.ExceSQL("UPDATE T_Base_Device_Full_NotFull SET Full_Flag =2 where DeviceIndex = 39001");
// CommonClassLib.CCarryConvert.WriteDarkCasket("32024", "", "", "32043发送到32024任务为出库任务 ，更新39001为满货2");
// }
// else
// {
// dbo.ExceSQL("UPDATE T_Base_Device_Full_NotFull SET Full_Flag = 1 where DeviceIndex = 39001");
// CommonClassLib.CCarryConvert.WriteDarkCasket("32024", "", "", "32043发送到32024任务为单盘任务 ，更新39001为有货1");//拆碟盘机为空时进入单盘
// }
// }
//}
if (devinfo.DeviceIndex == 50001)
{
sql.Remove(0, sql.Length);
sql.Append("update T_Monitor_Task set F_Status= 1 where F_MonitorIndex=").Append(MonitorIndex);
dbo.ExecuteSql(sql.ToString());//中间表AGV任务 插入成功后 立即更新为已发送
}
ccf.SendOrderSuccess(manageKindIdx, manageTaskIdx, MonitorIndex, deviceIdx, _routeID,0);
#region 多叉关联任务，能同步的同时报告发送命令成功
//20100323
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,1);
}
}
}
#endregion
return true;
}
}
else
{
return false;
}
#endregion
}
}
catch (Exception ex)
{//20110608
CControlError = string.Format( "发送命令调用SendMonitorTask时：{0}" ,ex.StackTrace+ ex.Message);
return false;
}
}
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;
//int XCoor = devinfo.SplitByte_6;
//int YCoor = devinfo.SplitByte_7;
int XCoor = devinfo.XCoor;
int YCoor = devinfo.YCoor;
nXY = Math.Pow((double)(nX - XCoor), 2) + (Math.Pow((double)(nY - 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 dbo.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 dbo.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()))
{
AheadDetectUnallow.Clear();
AheadDetectUnallow.Append("关联指令不是第一个指令");
UpdateAheadDetectUnallow(AheadDetectUnallow, cortask);
return -1 ;
}
}
#endregion
if (devKind == 1)//堆垛机
{//如果存在倒库货位，则后执行该任务20120906嘉兴电力改进，倒库货位的取货命令检测堆垛机货叉对应开关是否有货
if (devOrder == 5)//送货指令时判断20110505
{
if (true == IfChangeForkCell_LastRun(deviceindex, cortask))//双叉入库时
{
continue;
}
//else
//{
// taskno = cortask;
//}
}
doubleX = Model.CGeneralFunction.GetXCoorFromMonitor(cortask, deviceindex, devOrder);
doubleY = Model.CGeneralFunction.GetYCoorFromMonitor(cortask, deviceindex, devOrder);
doubleXY = Math.Pow((double)(doubleX - XCoor), 2) + (Math.Pow((double)(doubleY - YCoor), 2));
//if (nXY == doubleXY)
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 dbo.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()))
{
AheadDetectUnallow.Clear();
AheadDetectUnallow.Append("关联指令不是第一个指令");
UpdateAheadDetectUnallow(AheadDetectUnallow, taskno);
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,int changetype)
{//20120820
int[] zxy;
int fid = ccf.GetManageTaskIndexfromMonitor(taskindex);
int Mankind = ccf.GetManageTaskKindIndexFromMonitor(taskindex);
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())));
}
string sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", zxy[3], zxy[4], zxy[5]);//送货位置
if (changetype== Model.CGeneralFunction.TASKEXCHANGE)//如果是缓存任务，判断remark 是否为null,不为空则取remark作为终点
{
sql.Remove(0, sql.Length);
sql.Append("SELECT FREMARK FROM T_Manage_Task WHERE (FID = ").Append(fid).Append(") AND (F_ManageTaskKindIndex = ").Append(Mankind).Append(")");
object arrcell = dbo.GetSingle(sql.ToString());
string cell = Convert.ToString(arrcell);
string[] cellzxy = cell.Split('-');
if(cellzxy.Length>2)
{
sendcell = cell;
}
}
int getgate = ccf.GetLaneGateDeviceIndexFromLaneGate(sendcell);//送货位置的设备编号
int laneway = 0;
devinfocheck = Model.CGetInfo.GetDeviceInfo(StackIndex);
int vstack = StackIndex;
if (devinfocheck!=null)
{
vstack = devinfocheck.VirtualStack;
}
dvl = dbo.ExceSQL(string.Format("SELECT F_LaneDeviceIndex FROM T_Base_LaneInfo WHERE (F_StackIndex = {0})", vstack)).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);//Z-X-Y
//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
if (changetype == Model.CGeneralFunction.TASKCHANGESTACK)//倒换堆垛机时，不判断需要中转的任务的目标状态
{
//
//20181222
string[] exchangearea = ccf.GetExchangeStationAndEndAreaFromLaneGate(sendcell);//判读是否是到中转站台的任务
if (exchangearea != null)
{
sql.Remove(0, sql.Length);
sql.Append("update T_Monitor_Task set F_AheadDetect=REPLACE(F_AheadDetect,'").Append(getgate).Append("','").Append(dv[0]["F_LaneGateDeviceIndex"].ToString())
.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_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());
}
if (changetype == Model.CGeneralFunction.TASKEXCHANGE)//中转 //F_AheadDetect = REPLACE(F_AheadDetect, '{0}', '{1}')
{
//int getgate = ccf.GetLaneGateDeviceIndexFromLaneGate(zxystr.ToString());//送货位置的设备编号
sql.Remove(0, sql.Length);
sql.Append("update T_Monitor_Task set F_AheadDetect=REPLACE(F_AheadDetect,'").Append(getgate).Append("','").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(sendcell).Append("',FExceptionNO=").Append(changetype).Append(" where FID=").Append(fid).Append(" and F_ManageTaskKindIndex=").Append(Mankind);
dbo.ExecuteSql(sql.ToString());
CommonClassLib.CCarryConvert.WriteDarkCasket("任务中转,任务号:", taskindex.ToString(), ChangeStackCell, changetype.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 rownum=1 and 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");
}
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();
}
}
/// <summary>
/// 增加信息提示
/// </summary>
/// <param name="TaskIndex"></param>
/// <returns></returns>
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}'", aheadUnallow.ToString(), taskindex ));
}
else
{
rec = dbo.ExecuteSql(string.Format("UPDATE T_Monitor_Task SET F_ErrorCode ='' WHERE F_MonitorIndex ={1} and F_ErrorCode <>''", 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 deviceindex,int TaskIndex)
{//20110505
DataView dv = new DataView();
try
{
int laneway = ccf.GetLaneWayFromLaneInfo(deviceindex);
int[] zxy = ccf.GetCoordinatesFromMonitorTask(TaskIndex);
//写错了 string zxystr = (zxy[3].ToString().Length == 1 ? "0" + zxy[3].ToString() : zxy[0].ToString()) + "-" +
string zxystr = (zxy[3].ToString().Length == 1 ? "0" + zxy[3].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);
//别用like
dv = dbo.ExceSQL(string.Format("SELECT F_ChangeForkCell FROM T_Base_LaneInfo WHERE F_LaneDeviceIndex={0} and (F_ChangeForkCell ='{1}' or F_ChangeForkCell = '{2}')", laneway, zxystr,lanedev)).Tables[0].DefaultView;
if (dv.Count > 0)//倒库货位的任务后执行
{
return true;
}
return false;
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
}
}
bool GetWorkStack(int deviceIndex, int taskIndex, out string getstack, out string sendstack, out bool IfCombinedWork, out int workstackcount)
{//20120820
//DataView dv = new DataView();
//Model.MDevice devinfo; int resDev = 0;
string getcell = string.Empty;
string sendcell = string.Empty;
IfCombinedWork = false;
getstack = "";
sendstack ="";
workstackcount=0;
try
{
int[] coor = Model.CGeneralFunction.GetCoorFromMonitor(taskIndex);//获得堆垛机的取货和送货坐标
if (coor == null)
{
return false;
}
int Xcoor = coor[1];
int Zcoor = coor[0];
int Ycoor = coor[2];
int XcoorS = coor[4];
int ZcoorS = coor[3];
int YcoorS = coor[5];
int sno = 0;
//bool IfCombinedWork = false;
//string getstack, sendstack;
//int workstackcount;
//string lanegate;
getcell = string.Format("{0:D2}-{1:D2}-{2:D2}", Zcoor, Xcoor, Ycoor);
sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", ZcoorS, XcoorS, YcoorS);
int laneway = ccf.GetLaneWayFromLaneInfo(deviceIndex);//获得巷道
GetWorkStackNo(laneway, getcell, sendcell, out getstack, out sendstack, out IfCombinedWork, out workstackcount);
return true;
}
catch (Exception ex)
{
return false;
}
}
/// <summary>
/// 分配实际工作的堆垛机设备索引20111020
/// </summary>
/// <param name="deviceIndex">虚拟堆垛机设备索引</param>
/// <param name="taskIndex">设备指令索引</param>
/// <param name="manKind">调度任务类型</param>
/// <param name="fid">调度任务索引</param>
///
public bool AssignStackNo(int deviceIndex, int taskIndex, int manKind, int fid, string DoWorkStack, string ChangeCell, string ChangeStackCell2,int UseAwayFork,int UseAwayFork2, bool DeleteRelative, int CONTROLTASKTYPE)// ChangeStackCell:该任务倒库货位 , string ChangeStackCell2关联任务倒库货位
{//20120820
DataView dv = new DataView();
Model.MDevice devinfo; int resDev = 0;
string getcell = string.Empty;
string sendcell = string.Empty;
try
{
fid = ccf.GetManageTaskIndexfromMonitor(taskIndex);//20181219
int []coor = Model.CGeneralFunction.GetCoorFromMonitor(taskIndex);//获得堆垛机的取货和送货坐标
if (coor == null)
{
return false;
}
int Xcoor = coor[1];
int Zcoor = coor[0];
int Ycoor = coor[2];
int XcoorS = coor[4];
int ZcoorS = coor[3];
int YcoorS = coor[5];
int sno = 0; bool IfCombinedWork = false;
string getstack,sendstack;
int workstackcount;
string lanegate;
getcell = string.Format("{0:D2}-{1:D2}-{2:D2}", Zcoor, Xcoor, Ycoor);
sendcell = string.Format("{0:D2}-{1:D2}-{2:D2}", ZcoorS, XcoorS, YcoorS);
//int CONTROLTASKTYPE = ccf.GetFCONTROLTASKTYPEFromManageTask(manKind, fid);
//GetSpecialStackNo(deviceIndex, Zcoor, Xcoor, ZcoorS, XcoorS, out sno, out IfCombinedWork);
int laneway = ccf.GetLaneWayFromLaneInfo(deviceIndex);//获得巷道
GetWorkStackNo(laneway,getcell, sendcell, out getstack, out sendstack, out IfCombinedWork, out workstackcount);
//强制进行倒换堆垛机（堆垛机可以相同）
//
#region 选择不被禁用的堆垛机执行全部任务
string[] stack = getstack.Split(';');
int count = stack.Length;
for (int i = 0; i < count; i++)
{
int device=Convert.ToInt32( stack[i]);//取货堆垛机
int lockstate= ccf.GetDeviceLockedState(device);
string mutex= ccf.GetStackMutexDevice(device);//通用写法是获取堆垛机的互斥堆垛机组，懒得写了，先按一个来吧
int mutexlockstate= ccf.GetDeviceLockedState(Convert.ToInt32(mutex));
if (lockstate == -1)//当前堆垛机被禁用
{
if (mutexlockstate == -1)//互斥堆垛机也被禁用
{
return false;
}
else
{
//要判断当前堆垛机是否在维修区停靠，未在维修区停靠 ，判断安全门的开关状态
SetStackNo(deviceIndex, Convert.ToInt32(mutex), manKind, fid,taskIndex,"",UseAwayFork2,DeleteRelative, CONTROLTASKTYPE,0);//20181225
return true;
}
}
else//当前堆垛机没有被禁用
{
if (mutexlockstate == -1)//互斥堆垛机被禁用
{
SetStackNo(deviceIndex, device, manKind, fid,taskIndex,"",UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);//20181225
return true;
}
//else//都没被禁用
}
}
#endregion
//先考虑特殊情况20111226
if (IfCombinedWork == true)//需要多台堆垛机协作
{//两种情况：需要两台，需要三台
devinfo = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(getstack));
//堆垛机组合交替作业
string ChangeStackCell;
if (devinfo.IfCorrelDoubleFork == "1")
{
if (ChangeCell=="")//20181220
{
ChangeStackCell = GetChangeStackCellFromStackInfoByFork(getstack, UseAwayFork);
}
else
{
ChangeStackCell = ChangeCell;
}
}
else
{
ChangeStackCell= GetChangeStackCellFromStackInfo(CONTROLTASKTYPE, Zcoor,ZcoorS, getstack, sendstack, out lanegate);//返回货位编码 Z-X-Y
}
if (ChangeStackCell != "")
{
if (StackIfExitTask(Convert.ToInt32(getstack), CONTROLTASKTYPE, 0) == false)//20191219
{
ChangeStackCellCode(taskIndex, ChangeStackCell, deviceIndex, Model.CGeneralFunction.TASKCHANGESTACK);
SetStackNo(deviceIndex, Convert.ToInt32(getstack), manKind, fid, taskIndex, ChangeStackCell2, UseAwayFork2, DeleteRelative, CONTROLTASKTYPE, 0);
return true;
}
else
{
return false;
}
}
else
{//20120820没有空闲的两个堆垛机公用的交接货位
return false;
}
}
else//单台堆垛机作业
{//分两种情况：getstack含一个设备，含两个设备
string[] workstack = getstack.Split(';');
int workcount = workstack.Length;
#region 不需二次选择
if (workcount == 1)//单台堆垛机
{
SetStackNo(deviceIndex, Convert.ToInt32(workstack[0]), manKind, fid, taskIndex, ChangeStackCell2, UseAwayFork2, DeleteRelative, CONTROLTASKTYPE, 0);
//SetStackNo(deviceIndex, Convert.ToInt32(workstack[0]), manKind, fid,taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE,1);
return true;
}
#endregion
#region 需要二次选择
else
if (workcount > 1)//多台堆垛机中选择合适的堆垛机
{
//然后其余情况根据总列数折中分配给两个堆垛机
resDev = GetPRIStackNo(deviceIndex, Zcoor, Xcoor, ZcoorS, XcoorS);
int MutexStack = resDev;
for (int i = 0; i < workcount; i++)
{
if (resDev != Convert.ToInt32(workstack[i]))
{
MutexStack = Convert.ToInt32(workstack[i]);
}
}
devinfo = Model.CGetInfo.GetDeviceInfo(resDev);
int stacksequence=devinfo.Sequence;
if (devinfo.RunState == 0 && ccf.GetManTaskReserve(resDev) <= 0 && ccf.GetDeviceLockedState(resDev) == 0)
{//空闲、无任务执行、无管理任务预约锁
SetStackNo(deviceIndex, resDev, manKind, fid, taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);
return true;
}
else
{//根据35001当前位置和正在执行的任务的目标位置考虑是否分配35002
int Mutex = resDev;//正在工作的堆垛机
resDev = MutexStack;
MutexStack = Mutex;
devinfo = Model.CGetInfo.GetDeviceInfo(resDev);
if (devinfo != null && 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})", Mutex));
dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;
if (dv.Count > 0)
{// 判读两台堆垛机的位置关系
int xcoor=0, zcoor=0;
string order =dv[0]["F_DeviceCommandIndex"].ToString() ;
if (order == "4")//取货
{
xcoor = Convert.ToInt32(dv[0]["F_NumParam2"]);
zcoor = Convert.ToInt32(dv[0]["F_NumParam1"]);
}
else
if (order == "5")//送货
{
xcoor = Convert.ToInt32(dv[0]["F_NumParam5"]);
zcoor = Convert.ToInt32(dv[0]["F_NumParam4"]);
}
if (devinfo.Sequence > stacksequence)//devinfo.Sequence待选堆垛机的序列号，stacksequence正在任务的堆垛机的序列号，序列号小的说明条码值小
{
//GetBarcodeCoor(xcoor, zcoor)获得正在执行任务对应的坐标；GetBarcodeCoor(Xcoor, Zcoor)待执行任务的坐标
if ((GetBarcodeCoor(xcoor, zcoor, deviceIndex) + StackMutexXCoor) <= GetBarcodeCoor(Xcoor, Zcoor, deviceIndex))
{
SetStackNo(deviceIndex, resDev, manKind, fid, taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);
return true;
}
}
else
if (devinfo.Sequence < stacksequence)//devinfo.Sequence待选堆垛机的序列号，stacksequence正在任务的堆垛机的序列号，序列号小的说明条码值小
{
//GetBarcodeCoor(xcoor, zcoor)获得正在执行任务对应的坐标；GetBarcodeCoor(Xcoor, Zcoor)待执行任务的坐标
if ((GetBarcodeCoor(Xcoor, Zcoor, deviceIndex) + StackMutexXCoor) <= GetBarcodeCoor(xcoor, zcoor, deviceIndex))
{
SetStackNo(deviceIndex, resDev, manKind, fid, taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);
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;
//}
int taskbarcode = GetBarcodeCoor(Xcoor, Zcoor, deviceIndex);//待执行任务的条码值
int MutexStackbarcode= Model.CGetInfo.GetDeviceInfo(MutexStack).XCoor;//不空闲堆垛机对应的条码值
if (devinfo.Sequence > stacksequence)//devinfo.Sequence待选堆垛机的序列号，stacksequence不空闲堆垛机的序列号，序列号小的说明条码值小
{
//GetBarcodeCoor(xcoor, zcoor)获得正在执行任务对应的坐标；GetBarcodeCoor(Xcoor, Zcoor)待执行任务的坐标
if (taskbarcode > devinfo.XCoor || (taskbarcode > MutexStackbarcode + StackMutexXCoor))
{
SetStackNo(deviceIndex, resDev, manKind, fid, taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);
return true;
}
}
else
if (devinfo.Sequence < stacksequence)//devinfo.Sequence待选堆垛机的序列号，stacksequence正在任务的堆垛机的序列号，序列号小的说明条码值小
{
//GetBarcodeCoor(xcoor, zcoor)获得正在执行任务对应的坐标；GetBarcodeCoor(Xcoor, Zcoor)待执行任务的坐标
if (taskbarcode < devinfo.XCoor || (MutexStackbarcode > taskbarcode + StackMutexXCoor))
{
SetStackNo(deviceIndex, resDev, manKind, fid, taskIndex,ChangeStackCell2,UseAwayFork2,DeleteRelative, CONTROLTASKTYPE, 0);
return true;
}
}
}
}
}
}
#endregion
}
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();
}
}
/// <summary>
///
/// </summary>
/// <param name="type">任务类型</param>
/// <param name="ZcoorG">取货位置排坐标</param>
/// <param name="ZcoorS">送货位置拍坐标</param>
/// <param name="getstack"></param>
/// <param name="sendstack"></param>
/// <param name="lanegate"></param>
/// <returns></returns>
private string GetChangeStackCellFromStackInfo(int type, int ZcoorG, int ZcoorS, string getstack, string sendstack, out string lanegate)
{//20120820根据两个堆垛机的组合任务判断哪个更换堆垛机站台空闲
DataView dv = new DataView();
string cell = "";
lanegate = "";
// string lanegate="";
int laneindex=0;
string sql = string.Empty;
char[] cc = new char[1] { ';' };
//string ChangeStackCell = string.Empty;
string GetChangeStackCell = string.Empty;
string SendChangeStackCell = string.Empty;
string[] Getcell;
string[] Sendcell;
//string[] changecell;
string stack;
try
{
#region 计算双伸堆垛机倒库站台所在的排坐标
int stackreach = 1;
int needZ;//倒库站台所在的排坐标
devinfo = Model.CGetInfo.GetDeviceInfo(Convert.ToInt32(getstack));//20180610
if (devinfo != null)
{
stackreach = devinfo.StackReach;
}
if (type == 1)//入库
{
needZ = ZcoorS;//判断送货位置所在排一侧是否有倒库货位
}
else
{
needZ = ZcoorG;//判断取货位置所在排一侧是否有倒库货位
}
//needZ = needZ % 4;//排坐标
bool ifleft = true;
if (needZ <= 2)//1，2排是左侧
{
ifleft = true;
}
else
{
ifleft = false;
}
#endregion
sql = string.Format("SELECT F_StackIndex, F_ChangeStackCell,F_LaneNo FROM T_Base_StackInfo where F_StackIndex={0} or F_StackIndex={1}",getstack ,sendstack);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
for (int i = 0; i < dv.Count;i++ )
{
stack = Convert.ToString(dv[i]["F_StackIndex"]);
laneindex=Convert.ToInt32(dv[i]["F_LaneNo"]);
if (stack==getstack)
{
GetChangeStackCell = Convert.ToString(dv[i]["F_ChangeStackCell"]);
}
else
if (stack == sendstack)
{
SendChangeStackCell = Convert.ToString(dv[i]["F_ChangeStackCell"]);
}
}
Getcell = GetChangeStackCell.Split(cc);
Sendcell=SendChangeStackCell.Split(cc);
bool findedflag = false;
int changeZ;
for (int i = 0; i < Getcell.Length;i++ )
{
//不相邻的堆垛机，选择取货堆垛机的倒货站台 19006和19007，
lanegate = Getcell[i];
for (int k = 0; k < Sendcell.Length;k++ )
{
if(Getcell[i]==Sendcell[k])
{
lanegate = Getcell[i];//相邻的堆垛机使用双方都可到达的倒货站台 19006 和 19006；19007
if (stackreach!=2)
{
findedflag = true;
}
if(stackreach ==2)
{
cell = ccf.GetChangeCellFromLaneGate(laneindex, Convert.ToInt32(lanegate));
changeZ =Convert.ToInt32( cell.Split('-')[0]);//倒库站台对应的排坐标
//changeZ = changeZ % 4;
if (ifleft && (changeZ <= 2))
{
findedflag = true;
}
if (!ifleft && (changeZ > 2))
{
findedflag = true;
}
}
}
}
if (findedflag)
{
break;
}
}
if (lanegate != "")
{
cell = ccf.GetChangeCellFromLaneGate(laneindex, Convert.ToInt32( lanegate));
}
//同时只能执行一个倒货任务，防止11001到11003，和11003到11001同时执行，出现堵死的情况
string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell ='{0},{1}' ", laneindex, cell);
//string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell !='' ");
int changetaskcount= Convert.ToInt32(dbo.GetSingle(sqllstr));
if (changetaskcount>0)
{
cell = "";
}
}
return cell;//返回倒货站台对应的设备号19006
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <param name="type">任务类型</param>
/// <param name="ZcoorG">取货位置排坐标</param>
/// <param name="ZcoorS">送货位置拍坐标</param>
/// <param name="getstack"></param>
/// <param name="sendstack"></param>
/// <param name="lanegate"></param>
/// <returns></returns>
private string GetChangeStackCellFromStackInfoByFork(string getstack,int UseAwayFork)
{//20120820根据两个堆垛机的组合任务判断哪个更换堆垛机站台空闲
DataView dv = new DataView();
string cell = "";
int laneindex = 0;
string sql = string.Empty;
string GetChangeStackCell = string.Empty;
string stack;
try
{
sql = string.Format("SELECT F_StackIndex, F_ChangeStackCell,F_LaneNo FROM T_Base_StackInfo where F_StackIndex={0}", getstack);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
stack = Convert.ToString(dv[0]["F_StackIndex"]);
laneindex = Convert.ToInt32(dv[0]["F_LaneNo"]);
GetChangeStackCell = Convert.ToString(dv[0]["F_ChangeStackCell"]);
string stationmessage;
string ExchangeStation=GetChangeStackCell.Replace(';',',');
cell=ccf.GetFreeStation(ExchangeStation, UseAwayFork, out stationmessage);//获得新的目标
if (cell != "-")
{
//同时只能执行一个倒货任务，防止11001到11003，和11003到11001同时执行，出现堵死的情况
string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell ='{0},{1}' ", laneindex, cell);
//string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell !='' ");
int changetaskcount = Convert.ToInt32(dbo.GetSingle(sqllstr));
if (changetaskcount > 0)
{
cell = "";
}
}
else
{
cell = "";
}
}
return cell;
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <param name="type">任务类型</param>
/// <param name="ZcoorG">取货位置排坐标</param>
/// <param name="ZcoorS">送货位置拍坐标</param>
/// <param name="getstack"></param>
/// <param name="sendstack"></param>
/// <param name="lanegate"></param>
/// <returns></returns>
private string GetDoubleChangeStackCellFromStackInfoByFork(string getstack, int UseAwayFork, int UseAwayFork2, out string stationcell2)
{//20120820根据两个堆垛机的组合任务判断哪个更换堆垛机站台空闲
DataView dv = new DataView();
string cell = "";
stationcell2 = "";
int laneindex = 0;
string sql = string.Empty;
string message;
string GetChangeStackCell = string.Empty;
string stack;
try
{
sql = string.Format("SELECT F_StackIndex, F_ChangeStackCell,F_LaneNo FROM T_Base_StackInfo where F_StackIndex={0}", getstack);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
stack = Convert.ToString(dv[0]["F_StackIndex"]);
laneindex = Convert.ToInt32(dv[0]["F_LaneNo"]);
GetChangeStackCell = Convert.ToString(dv[0]["F_ChangeStackCell"]);
string stationmessage;
string ExchangeStation = GetChangeStackCell.Replace(';', ',');
//cell = ccf.GetFreeStation(ExchangeStation, UseAwayFork, out stationmessage);//获得新的目标
cell = ccf.GetDoubleFreeStation(ExchangeStation, UseAwayFork, UseAwayFork2, out stationcell2,out message);
if (cell != "-")
{
////同时只能执行一个倒货任务，防止11001到11003，和11003到11001同时执行，出现堵死的情况
//string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell ='{0},{1}' ", laneindex, cell);
////string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell !='' ");
//int changetaskcount = Convert.ToInt32(dbo.GetSingle(sqllstr));
//if (changetaskcount > 0)
//{
// cell = "";
//}
}
else
{
cell = "";
}
if (stationcell2 != "-")
{
////同时只能执行一个倒货任务，防止11001到11003，和11003到11001同时执行，出现堵死的情况
//string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell ='{0},{1}' ", laneindex, cell);
////string sqllstr = string.Format("SELECT count(distinct F_ManageTaskIndex) as fids FROM T_Monitor_Task where F_ChangeStackCell !='' ");
//int changetaskcount = Convert.ToInt32(dbo.GetSingle(sqllstr));
//if (changetaskcount > 0)
//{
// cell = "";
//}
}
else
{
stationcell2 = "";
}
}
return cell;
}
catch (Exception ex)
{
throw ex;
}
finally
{
dv.Dispose();
}
}
void SetStackNo(int dummyStackno, int stackno, int manKind, int fid, int monitorindex, string ChangeStackCell2, int UseAwayFork2, bool DeleteRelative, int CONTROLTASKTYPE,int CanSet )
{
//20111226考虑调整配套的站台和提前检测，35001-32038；35002-32036
if (StackIfExitTask(stackno, CONTROLTASKTYPE,CanSet) == true) return;
Dictionary<int, string[]> corr = Model.CGeneralFunction.GetDoubleForkMonitorInfo(monitorindex, dummyStackno);
string sqlstr = string.Empty;
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));
CommonClassLib.CCarryConvert.WriteDarkCasket("分配堆垛机,任务号:", fid.ToString(), monitorindex.ToString(), stackno.ToString());
if (corr!=null)
{
foreach (int CorrTaskindex in corr.Keys)
{
int fid1 = ccf.GetManageTaskIndexfromMonitor(CorrTaskindex);
int mankind1 = ccf.GetManageTaskKindIndexFromMonitor(CorrTaskindex);
if (CorrTaskindex != monitorindex && !DeleteRelative)
{
if (ChangeStackCell2!="")
{
ChangeStackCellCode(CorrTaskindex, ChangeStackCell2, dummyStackno, Model.CGeneralFunction.TASKCHANGESTACK);
}
ob = new object[4] { stackno, mankind1, fid1, 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));
CommonClassLib.CCarryConvert.WriteDarkCasket("分配双叉堆垛机,任务号:", fid1.ToString(), CorrTaskindex.ToString(), stackno.ToString());
}
if (DeleteRelative)//解除关联关系
{
sqlstr = string.Format("update T_Manage_Task set F_RELATIVECONTORLID = - 1 where F_ManageTaskKindIndex={0} and FID={1}",mankind1,fid1);
dbo.ExecuteSql(sqlstr);
}
}
}
}
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, int stacksequence, int workstacksequence, int vStack)
{//20111020
DataView dv = new DataView();
string sqlstr;//20180827
try
{
sqlstr = string.Format("SELECT MAX(BarcodeCoor) AS maxcoor, MIN(BarcodeCoor) AS mincoor FROM T_Base_BarcodeCoor where VirtualStack={0}", vStack);
dv = dbo.ExceSQL(sqlstr).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 (stacksequence< workstacksequence)
{
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 rownum=1 and BarcodeCoor<={0} and layerhigh<={1} and VirtualStack={2} GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh,vStack));
}
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 VirtualStack={2} GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh,vStack));
}
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 rownum=1 and BarcodeCoor>={0} and layerhigh<={1} and VirtualStack={2} GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh,vStack));
}
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 VirtualStack={2} GROUP BY XCoor, ZCoor ORDER BY Expr1", Barcodecoor, layerhigh,vStack));
}
dv = dbo.ExceSQL(sql.ToString()).Tables[0].DefaultView;//20151120调度系统oracle的特殊语句
}
//order =7 运动20181010
order = 7;
if (dv.Count > 0)
{
if (order == 2|| order == 7)
{
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;
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;
}
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;
}
}
bool ifcreat = false;
dv = dbo.ExceSQL(string.Format("select F_MonitorIndex,F_NumParam2 from T_Monitor_Task where F_DeviceIndex={0} and F_TxtParam='brbrbr'", stackno)).Tables[0].DefaultView;
if (dv.Count <= 0)
{
ifcreat=true;
}
else
{
int xcoor = Convert.ToInt32(dv[0]["F_NumParam2"]);//
if(Math.Abs(xc - xcoor)>1)//
{
ifcreat = true;
}
}
if(ifcreat)
{
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,int vStack)
{
DataView dv = new DataView();
try
{
dv = dbo.ExceSQL(string.Format("SELECT LayerHigh FROM T_Base_BarcodeCoor WHERE (ZCoor = {0}) AND (XCoor = {1}) and (VirtualStack={2})", Zcoor, Xcoor,vStack)).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,int CONTROLTASKTYPE,int CanSet)
{
DataView dv = new DataView();
string sqlstr = string.Empty;
try
{
//是否存在brbrbr的任务，存在避让任务，就不要分配了
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)
{
return true;
}
devinfo = Model.CGetInfo.GetDeviceInfo(stackno);
int count =0;
if (devinfo != null)
{
if (devinfo.IfCorrelDoubleFork == "1")
{
count = 1;
//sqlstr = string.Format("SELECT DISTINCT F_ManageTaskIndex FROM T_Monitor_Task where F_DeviceIndex={0}", stackno);//按照关联任务
//sqlstr = string.Format("SELECT DISTINCT F_RELATIVECONTORLID FROM T_Monitor_Task,T_Manage_Task where FID = F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex = T_Monitor_Task.F_ManageTASKKINDINDEX and F_DeviceIndex ={0}", stackno);//按照关联任务
sqlstr = string.Format("SELECT DISTINCT F_RELATIVECONTORLID FROM T_Monitor_Task,T_Manage_Task where FID = F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex = T_Monitor_Task.F_ManageTASKKINDINDEX and F_DeviceIndex ={0} and FCONTROLTASKTYPE={1}", stackno, CONTROLTASKTYPE);//按照关联任务
}
else
{
count = 0;
//按照出库，入库，移库 每种类型可以有一个任务
sqlstr = string.Format("SELECT DISTINCT F_ManageTaskIndex FROM T_Monitor_Task,T_Manage_Task where FID=F_ManageTaskIndex and T_Manage_Task. F_ManageTaskKindIndex=T_Monitor_Task.F_ManageTASKKINDINDEX and F_DeviceIndex={0} and FCONTROLTASKTYPE={1}", stackno, CONTROLTASKTYPE);
if (CanSet == 1)
{
return false;
}
}
}
//可以存在一条该堆垛机的任务
dv = dbo.ExceSQL(sqlstr).Tables[0].DefaultView;
if (dv.Count > count)
{
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
{
}
}
void GetWorkStackNo(int lane, string getcell,string sendcell, out string getstacknos,out string sendstacknos, out bool IfCombinedWork,out int workstackcount)
{
getstacknos = string.Empty ; IfCombinedWork = false;
sendstacknos = string.Empty; workstackcount = 0;
string sql = string.Empty;
DataView dv = new DataView();
char[] cc = new char[1] { ';' };
string[] getstack ;
string[] sendstack;
int getlanegate,sendlanegate;//判读取送货位置是否为站台
try
{
string getstacks;
string sendstacks;
//getstacks = GetWorkStackNoFromCell(lane, getcell, out getlanegate);
//sendstacks = GetWorkStackNoFromCell(lane, sendcell, out sendlanegate);
//强制指定堆垛机
GetWorkStackNoFromCell(lane, getcell, sendcell, out getstacks, out sendstacks);
getstack = getstacks.Split(cc);//获得可执行取货货位的堆垛机编号
sendstack = sendstacks.Split(cc);//获得可执行送货货位的堆垛机编号
//分析堆垛机的关系，找出执行任务的流程
int getstackcount = getstack.Length;//获得堆垛机数量
int sendstackcount = sendstack.Length;//获得堆垛机数量
//货位可以分为4类；11001、11001；11002、11002；11003、11003
#region 单台可取，单台可送
if (getstackcount == 1 && sendstackcount == 1)//只有单台堆垛机能进行取送货
{
if (getstack[0] == sendstack[0])//在堆垛机的独立工作区域
{
getstacknos = getstack[0];
sendstacknos = sendstack[0];
IfCombinedWork = false;
workstackcount = 1;
}
else//需要倒换堆垛机
{
getstacknos = getstack[0];
sendstacknos = sendstack[0];//最终执行任务的堆垛机，需要二次选择堆垛机
IfCombinedWork = true;
workstackcount = 3;
}
return;
}
#endregion
#region 多台可取、多台可送
if (getstackcount>1 && sendstackcount >1)//多堆垛机能进行取送货
{
if (getstacks == sendstacks)//在多台堆垛机的都能工作的区域，需要二次选择堆垛机
{
getstacknos = getstacks;//返回多台堆垛机的组合
sendstacknos = sendstacks;
IfCombinedWork = false;
workstackcount = 1;
}
else
{
for (int i = 0; i < getstackcount; i++)
{
string stack1 = getstack[i];
for (int k = 0; k < sendstackcount; k++)
{
string stack2 = sendstack[k];
if (stack1 == stack2)//选择都能到当达的堆垛机11002
{
getstacknos = stack1;
sendstacknos = stack2;
IfCombinedWork = false;
workstackcount = 1;
}
}
}
}
return;
}
#endregion
#region 单台可取，多台可送
if (getstackcount == 1 && sendstackcount > 1)//
{
for (int i = 0; i < getstackcount; i++)
{
int stack1 =Convert.ToInt32( getstack[i]);
for (int k = 0; k < sendstackcount; k++)
{
int stack2 = Convert.ToInt32( sendstack[k]);
if (stack1 == stack2)
{
getstacknos = stack1.ToString();
sendstacknos = stack2.ToString();
IfCombinedWork = false;
workstackcount = 1;
return;
}
if (1==Math.Abs(stack1 -stack2))//相邻的堆垛机
{
getstacknos = stack1.ToString();
sendstacknos = stack2.ToString();
IfCombinedWork = true;
workstackcount = 2;
}
}
}
return;
}
#endregion
#region 多台可取，单台可送
if (getstackcount >1 && sendstackcount == 1)//
{
for (int i = 0; i < getstackcount; i++)
{
int stack1 = Convert.ToInt32(getstack[i]);
for (int k = 0; k < sendstackcount; k++)
{
int stack2 = Convert.ToInt32(sendstack[k]);
if (stack1 == stack2)
{
getstacknos = stack1.ToString();
sendstacknos = stack2.ToString();
IfCombinedWork = false;
workstackcount = 1;
return;
}
if (1 == Math.Abs(stack1 - stack2))//相邻的堆垛机
{
getstacknos = stack1.ToString();
sendstacknos = stack2.ToString();
IfCombinedWork = true;
workstackcount = 2;
}
}
}
return;
}
#endregion
}
catch (Exception ex)
{
CControlError = "分配堆垛机号GetWorkStackNo:" + ex.StackTrace + ex.Message;
}
finally
{
}
}
string GetWorkStackNoFromCell(int lane, string cellcode,out int lanegate)
{
string stackno = string.Empty;
string sql = string.Empty;
DataView dv = new DataView();
lanegate = 0;
try
{
sql = string.Format("SELECT FWorkStack FROM ST_CELL where FCELLCODE='{0}' and FLaneWay={1}", cellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
stackno = Convert.ToString(dv[0]["FWorkStack"]);
}
else
{
sql = string.Format("SELECT F_WorkStack,F_LaneGateDeviceIndex FROM T_Base_Lane_Gate where F_ZXY='{0}'and F_LaneIndex={1}", cellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
stackno = Convert.ToString(dv[0]["F_WorkStack"]);
lanegate = Convert.ToInt32(dv[0]["F_LaneGateDeviceIndex"]);
}
}
return stackno;
}
catch (Exception ex)
{
CControlError = "分配堆垛机号GetWorkStackNo:" + ex.StackTrace + ex.Message;
return stackno;
}
finally
{
dv.Dispose();
}
}
void GetWorkStackNoFromCell(int lane, string getcellcode, string sendcellcode, out string getstack,out string sendstack)
{
string stackno = string.Empty;
string sql = string.Empty;
DataView dv = new DataView();
string forcesgettackno = "";
string forcessendtackno = "";
getstack = "";
sendstack = "";
//lanegate = 0;
try
{
//获得取货货位相关的工作堆垛机和强制工作堆垛机
sql = string.Format("SELECT FWorkStack FROM ST_CELL where FCELLCODE='{0}' and FLaneWay={1}", getcellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
getstack = Convert.ToString(dv[0]["FWorkStack"]);
}
else
{
sql = string.Format("SELECT F_WorkStack,F_LaneGateDeviceIndex,F_ForceWorkStack FROM T_Base_Lane_Gate where F_ZXY='{0}'and F_LaneIndex={1}", getcellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
getstack = Convert.ToString(dv[0]["F_WorkStack"]);
forcesgettackno = Convert.ToString(dv[0]["F_ForceWorkStack"]);
}
}
//获得送货货位相关的工作堆垛机和强制工作堆垛机
sql = string.Format("SELECT FWorkStack FROM ST_CELL where FCELLCODE='{0}' and FLaneWay={1}", sendcellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
sendstack = Convert.ToString(dv[0]["FWorkStack"]);
}
else
{
sql = string.Format("SELECT F_WorkStack,F_LaneGateDeviceIndex,F_ForceWorkStack FROM T_Base_Lane_Gate where F_ZXY='{0}'and F_LaneIndex={1}", sendcellcode, lane);
dv = dbo.ExceSQL(sql).Tables[0].DefaultView;
if (dv.Count > 0)
{
sendstack = Convert.ToString(dv[0]["F_WorkStack"]);
forcessendtackno = Convert.ToString(dv[0]["F_ForceWorkStack"]);
}
}
if(forcesgettackno!=""&& forcessendtackno!="")
{
getstack = forcesgettackno;
sendstack = forcessendtackno;
}
//return stackno;
}
catch (Exception ex)
{
CControlError = "分配堆垛机号GetWorkStackNo:" + ex.StackTrace + ex.Message;
//return stackno;
}
finally
{
dv.Dispose();
}
}
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 <> '') 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();
}
}
}
}