/// <summary>
/// 异常日志
/// </summary>
/// <param name="item"></param>
/// <param name="order"></param>
/// <param name="err"></param>
/// <returns></returns>
public String GetLogMessE(WCS_TASK_ITEM item, byte[] order, String err)
{
String message = String.Format(@"【Error】{0}({1})：WCS单号[ {2} ]，ID[ {3} ]，设备号[ {4} ]，异常信息[ {5} ].",
ItemId.GetItemIdName(item.ITEM_ID), item.ITEM_ID, item.WCS_NO, item.ID, item.DEVICE, err);
return(message);
}
/// <summary>
/// 创建行车出入库取放货 ITEM 任务
/// </summary>
/// <param name="item"></param>
public void CreateTask_ABC(WCS_TASK_ITEM item)
{
try
{
// 判断是出入库类型
switch (item.WCS_NO.Substring(0, 1))
{
case "I": // 入库 行车 (货物)==> 货位
// 行车放货
task.CreateCustomItem(item.WCS_NO, ItemId.行车放货, item.DEVICE, "", item.LOC_TO, ItemStatus.请求执行);
break;
case "O": // 出库 货位 (货物)==> 行车
// 行车取货
task.CreateCustomItem(item.WCS_NO, ItemId.行车取货, item.DEVICE, "", item.LOC_TO, ItemStatus.请求执行);
break;
default:
break;
}
//行车&运输车初始任务更新状态——完成
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.完成任务);
}
catch (Exception ex)
{
//恢复
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.交接中);
task.DeleteItem(item.WCS_NO, ItemId.行车取货);
task.DeleteItem(item.WCS_NO, ItemId.行车放货);
throw ex;
}
}
public ABCTack(WCS_TASK_ITEM item, string deviceType, byte[] order) : base(item, deviceType, order)
{
_device = new ABC(ITEM.DEVICE);
log = new Log("Task_ABC-" + ITEM.ID + "-");
// 记录生成指令LOG
log.LOG(DataControl._mTaskTools.GetLogMessC(item, order));
}
/// <summary>
/// AGV 装货中
/// </summary>
/// <param name="id"></param>
/// <param name="agv"></param>
public void SubmitAgvLoading(int id, string agv)
{
try
{
// 获取对应AGV任务资讯
String sql = String.Format(@"select * from wcs_agv_info where MAGIC = '{0}' and ID = '{1}' and AGV = '{2}'", AGVMagic.到达装货点, id.ToString(), agv);
DataTable dt = DataControl._mMySql.SelectAll(sql);
if (DataControl._mStools.IsNoData(dt))
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("SubmitNDCPlcLoading()", "AGV装货中[AGV任务ID，AGV设备号]", id.ToString(), agv, "找不到对应AGV任务资讯！");
return;
}
WCS_AGV_INFO info = dt.ToDataEntity <WCS_AGV_INFO>();
// 生成包装线固定辊台指令
FRT frt = new FRT(info.PICKSTATION);
// 获取指令-- 反向送货
byte[] order = FRT._RollerControl(frt.FRTNum(), FRT.RollerRunAll, FRT.RunObverse, FRT.GoodsDeliver, FRT.GoodsQty1);
// 加入任务作业链表
WCS_TASK_ITEM item = new WCS_TASK_ITEM()
{
ITEM_ID = "包装线送货",
WCS_NO = info.TASK_UID,
ID = info.ID,
DEVICE = info.PICKSTATION,
LOC_TO = info.AGV
};
DataControl._mTaskControler.StartTask(new AGVFRTTack(item, DeviceType.固定辊台, order));
}
catch (Exception ex)
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("SubmitNDCPlcLoading()", "AGV装货中[AGV任务ID，AGV设备号]", id.ToString(), agv, ex.ToString());
}
}
/// <summary>
/// 发送命令日志
/// </summary>
/// <param name="item"></param>
/// <param name="order"></param>
/// <returns></returns>
public String GetLogMess(WCS_TASK_ITEM item, byte[] order)
{
String ORDER = DataControl._mStools.BytetToString(order);
String message = String.Format(@"【SendOrder】{0}({1})：WCS单号[ {2} ]，ID[ {3} ]，设备号[ {4} ]，来源[ {5} ]，目标[ {6} ]，指令[ {7} ].",
ItemId.GetItemIdName(item.ITEM_ID), item.ITEM_ID, item.WCS_NO, item.ID, item.DEVICE, item.LOC_FROM, item.LOC_TO, ORDER);
return(message);
}
public AGVFRTTack(WCS_TASK_ITEM item, string deviceType, byte[] order) : base(item, deviceType, order)
{
_device = new FRT(ITEM.DEVICE);
log = new Log("AGV_FRT-" + ITEM.ID + "-");
// 记录生成指令LOG
log.LOG(String.Format(@"【CreatOrder】{0}：WMS任务ID[ {1} ]，AGV任务ID[ {2} ]，设备号[ {3} ], 指令[ {4} ].",
item.ITEM_ID, item.WCS_NO, item.ID, item.DEVICE, DataControl._mStools.BytetToString(order)));
}
/// <summary>
/// 创建摆渡车&运输车对接出入库 ITEM 任务
/// </summary>
/// <param name="item"></param>
public void CreateTask_ARF_RGV(WCS_TASK_ITEM item)
{
String wcsno_R = "";
String itemid_R = "";
String device_R = "";
try
{
// 查看运输车是否到位
String sql_R = String.Format(@"select WCS_NO, ITEM_ID, DEVICE from WCS_TASK_ITEM where STATUS = 'R' and WCS_NO = '{0}' and ITEM_ID = '{1}'", item.WCS_NO, ItemId.运输车复位1);
DataTable dtitem_R = mySQL.SelectAll(sql_R);
if (tools.IsNoData(dtitem_R))
{
return;
}
wcsno_R = dtitem_R.Rows[0]["WCS_NO"].ToString();
itemid_R = dtitem_R.Rows[0]["ITEM_ID"].ToString();
device_R = dtitem_R.Rows[0]["DEVICE"].ToString();
// 判断是出入库类型
switch (item.WCS_NO.Substring(0, 1))
{
case "I": // 入库 摆渡车 (货物)==> 运输车
// 先动运输车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.运输车入库, device_R, "", "", ItemStatus.请求执行);
// 后动摆渡车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车入库, item.DEVICE, "", device_R, ItemStatus.请求执行); //入库目的为运输车
break;
case "O": // 出库 运输车 (货物)==> 摆渡车
// 先动摆渡车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车出库, item.DEVICE, "", "", ItemStatus.请求执行);
// 后动运输车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.运输车出库, device_R, "", item.DEVICE, ItemStatus.请求执行); //出库目的为摆渡车
break;
default:
break;
}
//摆渡车&运输车初始任务更新状态——完成
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.完成任务);
task.UpdateItem(wcsno_R, itemid_R, ItemColumnName.作业状态, ItemStatus.完成任务);
}
catch (Exception ex)
{
//恢复
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.交接中);
task.UpdateItem(wcsno_R, itemid_R, ItemColumnName.作业状态, ItemStatus.交接中);
task.DeleteItem(item.WCS_NO, ItemId.运输车入库);
task.DeleteItem(item.WCS_NO, ItemId.摆渡车入库);
task.DeleteItem(item.WCS_NO, ItemId.摆渡车出库);
task.DeleteItem(item.WCS_NO, ItemId.运输车出库);
throw ex;
}
}
/// <summary>
/// 创建运输车&行车对接出入库 ITEM 任务
/// </summary>
/// <param name="item"></param>
public void CreateTask_RGV_ABC(WCS_TASK_ITEM item)
{
String wcsno_R = "";
String itemid_R = "";
String device_R = "";
try
{
// 查看运输车是否在运输车对接待命点
String sql_R = String.Format(@"select WCS_NO, ITEM_ID, DEVICE from WCS_TASK_ITEM where STATUS = 'R' and WCS_NO = '{0}' and ITEM_ID = '{1}'", item.WCS_NO, ItemId.运输车定位);
DataTable dtitem_R = mySQL.SelectAll(sql_R);
if (tools.IsNoData(dtitem_R))
{
return;
}
wcsno_R = dtitem_R.Rows[0]["WCS_NO"].ToString();
itemid_R = dtitem_R.Rows[0]["ITEM_ID"].ToString();
device_R = dtitem_R.Rows[0]["DEVICE"].ToString();
// 判断是出入库类型
switch (item.WCS_NO.Substring(0, 1))
{
case "I": // 入库 运输车 (货物)==> 行车
// 行车取货
task.CreateCustomItem(item.WCS_NO, ItemId.行车取货, item.DEVICE, "", item.LOC_TO, ItemStatus.请求执行);
break;
case "O": // 出库 行车 (货物)==> 运输车
// 行车放货
task.CreateCustomItem(item.WCS_NO, ItemId.行车放货, item.DEVICE, "", item.LOC_TO, ItemStatus.请求执行);
break;
default:
break;
}
//行车&运输车初始任务更新状态——完成
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.完成任务);
task.UpdateItem(wcsno_R, itemid_R, ItemColumnName.作业状态, ItemStatus.完成任务);
}
catch (Exception ex)
{
//恢复
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.交接中);
task.UpdateItem(wcsno_R, itemid_R, ItemColumnName.作业状态, ItemStatus.交接中);
task.DeleteItem(item.WCS_NO, ItemId.行车取货);
task.DeleteItem(item.WCS_NO, ItemId.行车放货);
throw ex;
}
}
/// <summary>
/// 下发设备指令(除滚棒任务)
/// </summary>
/// <param name="item"></param>
public void WriteDeviceNotRoller(WCS_TASK_ITEM item)
{
try
{
// =>运输车[外]对接目的位置需计算
// =>组合资讯，下发指令
//更新状态
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.任务中);
}
catch (Exception ex)
{
//初始化
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.请求执行);
throw ex;
}
}
/// <summary>
/// 后续任务作业
/// </summary>
/// <param name="item"></param>
public void Task_Continued(WCS_TASK_ITEM item)
{
try
{
// 任务目的比对检测
CheckTask(item.WCS_NO, item.LOC_TO);
// 清单是[结束]状态不作业
if (task.GetCommandStep(item.WCS_NO) == CommandStep.结束)
{
return;
}
// Item非[完成]状态不作业
if (item.STATUS != ItemStatus.完成任务)
{
return;
}
// 依出入库类型处理
switch (item.WCS_NO.Substring(0, 1))
{
case "I": //入库
ProcessInTask(item);
break;
case "O": //出库
ProcessOutTask(item);
break;
default:
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 创建摆渡车&固定辊台对接出入库 ITEM 任务
/// </summary>
/// <param name="item"></param>
public void CreateTask_ARF_FRT(WCS_TASK_ITEM item)
{
try
{
// 判断是出入库类型
switch (item.WCS_NO.Substring(0, 1))
{
case "I": // 入库 固定辊台 (货物)==> 摆渡车
// 先动摆渡车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车入库, item.DEVICE, "", "", ItemStatus.请求执行);
// 后动固定辊台滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.固定辊台入库, task.GetFRTDevice(item.LOC_TO), "", item.DEVICE, ItemStatus.请求执行); //入库目的为摆渡车
break;
case "O": // 出库 摆渡车 (货物)==> 固定辊台
// 先动固定辊台滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.固定辊台出库, task.GetFRTDevice(item.LOC_TO), "", "", ItemStatus.请求执行);
// 后动摆渡车滚棒
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车出库, item.DEVICE, "", task.GetFRTDevice(item.LOC_TO), ItemStatus.请求执行); //出库目的为固定辊台
break;
default:
break;
}
//摆渡车初始任务更新状态——完成
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.完成任务);
}
catch (Exception ex)
{
//恢复
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.交接中);
task.DeleteItem(item.WCS_NO, ItemId.固定辊台入库);
task.DeleteItem(item.WCS_NO, ItemId.固定辊台出库);
task.DeleteItem(item.WCS_NO, ItemId.摆渡车入库);
task.DeleteItem(item.WCS_NO, ItemId.摆渡车出库);
throw ex;
}
}
private void UpdateTask()
{
String sql = String.Format(@"select * From wcs_task_item where id = '{0}'", _ID);
DataTable dt = DataControl._mMySql.SelectAll(sql);
if (DataControl._mStools.IsNoData(dt))
{
Notice.Show("异常：找不到资讯！", "错误", 3, MessageBoxIcon.Error);
this.Close();
}
WCS_TASK_ITEM item = dt.ToDataEntity <WCS_TASK_ITEM>();
// 锁定
TBwcsno.Text = item.WCS_NO;
TBlocfrom.Text = item.LOC_FROM;
TBlocto.Text = item.LOC_TO;
CBitemid.Text = item.ITEM_ID + " - " + ItemId.GetItemIdName(item.ITEM_ID);
TBwcsno.IsEnabled = false;
CBitemid.IsEnabled = false;
AddCombBoxForDev(item.DEVICE, item.STATUS);
BTNuse.Content = "更新";
_DEV = item.DEVICE;
}
/// <summary>
/// 生成对应辊台任务指令
/// </summary>
/// <param name="agv"></param>
public void CreatOrderTask(WCS_AGV_INFO agv)
{
try
{
// 按任务当前状态处理
switch (Convert.ToInt32(agv.MAGIC))
{
case AGVMagic.到达装货点:
// 获取对应包装线固定辊台资讯
FRT frt = new FRT(agv.PICKSTATION);
// 是否作业中
if (frt.CurrentStatus() != FRT.RollerStop)
{
return;
}
// 是否存在货物
//if (frt.GoodsStatus() == FRT.GoodsYesAll)
if (frt.GoodsStatus() == FRT.GoodsYesAll || PublicParam.IsIgnoreFRT) //add调试判断
{
// 分配 WMS TASK
if (String.IsNullOrEmpty(agv.TASK_UID.Trim()))
{
// 获取WMS TASK ID
String sql = String.Format(@"select TASK_UID from wcs_task_info where TASK_TYPE = '{0}' and W_S_LOC = '{1}' and TASK_UID not in
(select DISTINCT TASK_UID from wcs_agv_info where TASK_UID is not null)", TaskType.AGV搬运, DataControl._mTaskTools.GetArea(agv.PICKSTATION));
DataTable dt = DataControl._mMySql.SelectAll(sql);
if (DataControl._mStools.IsNoData(dt))
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("CreatOrderTask()", "AGV辊台任务[AGV任务ID]", agv.ID.ToString(), "", "无对应 WMS Task！");
return;
}
// 更新AGV任务资讯-- WMS TASK ID
agv.TASK_UID = dt.Rows[0]["TASK_UID"].ToString();
sql = String.Format(@"update wcs_agv_info set TASK_UID = '{1}' where ID = '{0}'", agv.ID, agv.TASK_UID);
DataControl._mMySql.ExcuteSql(sql);
}
// 分配卸货点
if (agv.UPDATE_TIME == null)
{
// 获取 WMS 任务目标点
String sqlloc = String.Format(@"select distinct DEVICE from wcs_config_device where FLAG in('{1}','{2}') and TYPE = '{3}'
and AREA in (select W_D_LOC from wcs_task_info where TASK_UID = '{0}')
and DEVICE in (select distinct DROPSTATION From wcs_agv_info where MAGIC <> {4} group by DROPSTATION HAVING count(DROPSTATION) < {5})
order by FLAG,CREATION_TIME", agv.TASK_UID, DeviceFlag.占用, DeviceFlag.空闲, DeviceType.固定辊台, AGVMagic.任务完成, 3);//最多三辆车
DataTable dtloc = DataControl._mMySql.SelectAll(sqlloc);
if (DataControl._mStools.IsNoData(dtloc))
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("CreatOrderTask()", "AGV辊台任务[AGV任务ID]", agv.ID.ToString(), "", "无对应 WMS Task 目标位置！");
return;
}
// 更新AGV任务资讯-- 卸货点
agv.DROPSTATION = dtloc.Rows[0]["DEVICE"].ToString();
sqlloc = String.Format(@"update wcs_agv_info set UPDATE_TIME = NOW(), DROPSTATION = '{1}' where ID = '{0}';
update wcs_config_device set FLAG = '{2}' where DEVICE = '{1}'", agv.ID, agv.DROPSTATION, DeviceFlag.占用);
DataControl._mMySql.ExcuteSql(sqlloc);
// 发送 NDC 更新点位
UpdateAGVStation(agv.ID, agv.DROPSTATION);
}
// 发指令请求AGV启动辊台装货
if (!DataControl._mNDCControl.DoLoad(agv.ID, Convert.ToInt32(agv.AGV), out string result))
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("CreatOrderTask()", "AGV辊台任务[AGV任务ID]", agv.ID.ToString(), "", result.ToString());
return;
}
}
break;
case AGVMagic.到达卸货点:
// 获取对应包装线固定辊台资讯
FRT frtdrop = new FRT(agv.DROPSTATION);
// 是否作业中
if (frtdrop.CurrentStatus() != FRT.RollerStop)
{
// 当已启动辊台
if (frtdrop.CurrentTask() == FRT.TaskTake && (frtdrop.CurrentStatus() == FRT.RollerRun1 || frtdrop.CurrentStatus() == FRT.RollerRunAll))
{
// 发指令请求AGV启动辊台装货
if (!DataControl._mNDCControl.DoUnLoad(agv.ID, Convert.ToInt32(agv.AGV), out string result))
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("CreatOrderTask()", "AGV辊台任务[AGV任务ID]", agv.ID.ToString(), "", result.ToString());
return;
}
}
return;
}
else // 未启动辊台
{
byte[] order = null;
// 当辊台都无货
//if (frtdrop.GoodsStatus() == FRT.GoodsNoAll)
if (frtdrop.GoodsStatus() == FRT.GoodsNoAll || PublicParam.IsIgnoreFRT) //add调试判断
{
// 获取指令-- 启动所有辊台 正向接货
order = FRT._RollerControl(frtdrop.FRTNum(), FRT.RollerRunAll, FRT.RunFront, FRT.GoodsReceive, FRT.GoodsQty1);
}
// 当仅2#辊台有货
else if (frtdrop.GoodsStatus() == FRT.GoodsYes2)
{
// 获取指令-- 只启动1#辊台 正向接货
order = FRT._RollerControl(frtdrop.FRTNum(), FRT.RollerRun1, FRT.RunFront, FRT.GoodsReceive, FRT.GoodsQty1);
}
// 加入任务作业链表
WCS_TASK_ITEM item = new WCS_TASK_ITEM()
{
ITEM_ID = "库区接货",
WCS_NO = agv.TASK_UID,
ID = agv.ID,
DEVICE = agv.DROPSTATION,
LOC_FROM = agv.AGV
};
DataControl._mTaskControler.StartTask(new AGVFRTTack(item, DeviceType.固定辊台, order));
}
break;
default:
return;
}
}
catch (Exception ex)
{
// LOG
DataControl._mTaskTools.RecordTaskErrLog("CreatOrderTask()", "AGV辊台任务[AGV任务ID]", agv.ID.ToString(), "", ex.ToString());
}
}
/// <summary>
/// 分配任务设备
/// </summary>
/// <param name="item"></param>
public void ReadDevice(WCS_TASK_ITEM item)
{
try
{
// 获取任务所在固定辊台
String frt = task.GetFRTByWCSNo(item.WCS_NO);
if (String.IsNullOrEmpty(frt))
{
return;
}
// 获取任务所在作业区域
String area = task.GetArea(frt);
if (String.IsNullOrEmpty(frt))
{
return;
}
switch (item.ITEM_ID.Substring(0, 2))
{
case "01":
#region 摆渡车
// 获取作业区域内空闲的摆渡车
List <WCS_CONFIG_DEVICE> dList_ARF = task.GetDeviceList(area, DeviceType.摆渡车);
// 确认其中最适合的摆渡车
// =>根据任务讯息获取位置允许范围可用设备
// =>确认设备
//更新状态
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.请求执行);
#endregion
break;
case "02":
#region 运输车
// =>根据任务讯息获取位置允许范围可用设备
// =>确认设备
//更新状态
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.请求执行);
#endregion
break;
case "03":
#region 行车
// =>根据任务讯息获取位置允许范围可用设备
// =>确认设备
//更新状态
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.请求执行);
#endregion
break;
default:
break;
}
}
catch (Exception ex)
{
//初始化
task.UpdateItem(item.WCS_NO, item.ITEM_ID, ItemColumnName.作业状态, ItemStatus.可执行);
throw ex;
}
}
/// <summary>
/// 出库任务处理
/// </summary>
/// <param name="item"></param>
public void ProcessOutTask(WCS_TASK_ITEM item)
{
try
{
// 运输车
String rgv;
// 摆渡车于运输车对接点
String AR = ConfigurationManager.AppSettings["StandbyAR"];
// 运输车[外]待命复位点
String R1 = ConfigurationManager.AppSettings["StandbyP1"];
// 运输车[内]待命复位点
String R2 = ConfigurationManager.AppSettings["StandbyP2"];
// 运输车于运输车对接点
String RR = ConfigurationManager.AppSettings["StandbyRR"];
// 获取对应清单
String sql = String.Format(@"select FRT, TASK_UID_1,LOC_FROM_1,SITE_1, TASK_UID_2,LOC_FROM_2,SITE_2 from wcs_command_v where WCS_NO = '{0}'", item.WCS_NO);
DataTable dt = mySQL.SelectAll(sql);
if (tools.IsNoData(dt))
{
return;
}
String frt = dt.Rows[0]["FRT"].ToString(); // 锁定固定辊台
String taskid1 = dt.Rows[0]["TASK_UID_1"].ToString(); //任务1
String taskid2 = dt.Rows[0]["TASK_UID_2"].ToString(); //任务2
String site1 = dt.Rows[0]["SITE_1"].ToString(); //状态1
String site2 = dt.Rows[0]["SITE_2"].ToString(); //状态2
String loc1 = dt.Rows[0]["LOC_FROM_1"].ToString(); //来源点1
String loc2 = dt.Rows[0]["LOC_FROM_2"].ToString(); //来源点2
// 默认出库时 taskid1对接运输车设备辊台①、taskid2对接运输车设备辊台②
String loc_1 = task.GetRGVLoc(1, loc1); //辊台①任务1
String loc_2 = task.GetRGVLoc(2, loc2); //辊台②任务2
switch (item.ITEM_ID) //根据最后的设备指令，可得货物已在流程中该设备对接的下一设备处
{
case ItemId.行车取货:
#region 行车轨道定位与运输车对接点
// 生成行车库存定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.行车轨道定位, item.DEVICE, "", task.GetABCTrackLoc(item.LOC_TO), ItemStatus.请求执行);
#endregion
break;
case ItemId.行车放货:
#region 将运输车复位待命点 / 将运输车移至行车对接位置 && 行车库存定位
// 获取当前运输车加以分配
rgv = task.GetItemDeviceLast(item.WCS_NO, ItemId.运输车定位);
// 流程上确认是先分配运输车辊台①放置货物，即现确认运输车辊台②是否有货
// => 获取当前运输车资讯
// => 辊台②是否有货？
// 有货 则将运输车复位待命点
// => 当前设备位置 > 运输车[内]待命复位点 ? 运输车[内]复位 ：运输车[外]复位
task.CreateCustomItem(item.WCS_NO, ItemId.运输车复位2, rgv, "", R2, ItemStatus.请求执行);
task.CreateCustomItem(item.WCS_NO, ItemId.运输车复位1, rgv, "", R1, ItemStatus.请求执行);
// 无货 则将运输车移至行车对接位置 && 行车库存定位
// 生成运输车定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.运输车定位, rgv, "", loc_2, ItemStatus.请求执行);
// 生成行车库存定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.行车库存定位, item.DEVICE, "", task.GetABCTrackLoc(loc2), ItemStatus.请求执行);
#endregion
break;
case ItemId.运输车出库:
#region 将摆渡车移至固定辊台对接点 / 将运输车移至摆渡车对接点(复位待命点1)
// 获取当前运输车加以分配
rgv = task.GetItemDeviceLast(item.WCS_NO, ItemId.运输车定位);
// => 获取当前运输车资讯
// => 当位置在待命点1时，判断为将货物移至摆渡车
// 生成将摆渡车移至固定辊台对接点任务
String ARFloc = task.GetARFLoc(frt); //获取对应摆渡车位置
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车定位固定辊台, item.LOC_TO, "", ARFloc, ItemStatus.请求执行);
// => 当位置在待命点2时，判断为将货物移至运输车[外]
// 生成将运输车复位待命点1任务
task.CreateCustomItem(item.WCS_NO, ItemId.运输车复位1, item.LOC_TO, "", R1, ItemStatus.请求执行);
#endregion
break;
default:
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 入库任务处理
/// </summary>
/// <param name="item"></param>
public void ProcessInTask(WCS_TASK_ITEM item)
{
try
{
// 摆渡车于运输车对接点
String AR = ConfigurationManager.AppSettings["StandbyAR"];
// 运输车[内]待命复位点
String R = ConfigurationManager.AppSettings["StandbyP2"];
// 运输车于运输车对接点
String RR = ConfigurationManager.AppSettings["StandbyRR"];
// 获取对应清单
String sql = String.Format(@"select TASK_UID_1,LOC_TO_1,SITE_1, TASK_UID_2,LOC_TO_2,SITE_2 from wcs_command_v where WCS_NO = '{0}'", item.WCS_NO);
DataTable dt = mySQL.SelectAll(sql);
if (tools.IsNoData(dt))
{
return;
}
String taskid1 = dt.Rows[0]["TASK_UID_1"].ToString(); //任务1
String taskid2 = dt.Rows[0]["TASK_UID_2"].ToString(); //任务2
String site1 = dt.Rows[0]["SITE_1"].ToString(); //状态1
String site2 = dt.Rows[0]["SITE_2"].ToString(); //状态2
String loc1 = dt.Rows[0]["LOC_TO_1"].ToString(); //目标点1
String loc2 = dt.Rows[0]["LOC_TO_2"].ToString(); //目标点2
// 默认入库时 taskid1对接运输车设备辊台②、taskid2对接运输车设备辊台①
String loc_1 = task.GetRGVLoc(2, loc1); //辊台②任务1
String loc_2 = task.GetRGVLoc(1, loc2); //辊台①任务2
String loc; //执行目标
switch (item.ITEM_ID) //根据最后的设备指令，可得货物已在流程中该设备对接的下一设备处
{
case ItemId.固定辊台入库: //目的设备为对接的摆渡车，可直接加以分配
#region 将摆渡车移至运输车对接位置
// 可断定货物需移至运输车
// 生成摆渡车任务
task.CreateCustomItem(item.WCS_NO, ItemId.摆渡车定位运输车对接, item.LOC_TO, "", AR, ItemStatus.请求执行);
#endregion
break;
case ItemId.摆渡车入库: //目的设备为对接的运输车，可直接加以分配
#region 将运输车移至行车对接位置 || 运输车间对接
// 根据货物目的地判断是否需要运输车对接运输车
loc = task.GetLocByRgvToLoc(loc_1, loc_2);
if (loc == "NG")
{
//不能没有货物目的位置
break;
}
// 判断是否需要对接到运输车[内]范围内作业
if (Convert.ToInt32(loc) >= Convert.ToInt32(R)) // 需对接运输车[内]
{
// 生成运输车[内]复位任务
task.CreateItem(item.WCS_NO, ItemId.运输车复位2, R); // 待分配设备
// 生成运输车[外]对接位任务
task.CreateCustomItem(item.WCS_NO, ItemId.运输车对接定位, item.LOC_TO, "", RR, ItemStatus.请求执行);
}
else
{
// 生成运输车[外]定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.运输车定位, item.LOC_TO, "", loc, ItemStatus.请求执行);
}
#endregion
break;
case ItemId.运输车入库: //目的设备为对接的运输车，可直接加以分配
#region 将运输车移至行车对接位置
// 判断是否作业过运输车定位对接行车任务
String sqlrr = String.Format(@"select * from wcs_task_item where ITEM_ID = '033' and STATUS not in ('E','X') and WCS_NO = '{0}'", item.WCS_NO);
DataTable dtrr = mySQL.SelectAll(sqlrr);
if (tools.IsNoData(dt))
{
loc = task.GetLocByRgvToLoc(loc_1, loc_2);
if (loc == "NG")
{
//不能没有货物目的位置
break;
}
// 生成运输车定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.运输车定位, item.LOC_TO, "", loc, ItemStatus.请求执行);
}
#endregion
break;
case ItemId.行车取货:
#region 将运输车移至行车对接位置 && 行车定位
// 默认入库时 taskid1对接运输车设备辊台②、taskid2对接运输车设备辊台①
// 获取当前运输车加以分配
String rgv = task.GetItemDeviceLast(item.WCS_NO, ItemId.运输车定位);
// =>获取当前运输车资讯
// =>获取有货&无货辊台各对应的WMS任务目标
String loc_Y = ""; //有货辊台对应目标点
String loc_N = ""; //无货辊台对应目标点
// 根据当前运输车坐标及任务目标，生成对应运输车定位/对接运输车任务
// 生成行车库存定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.行车库存定位, item.DEVICE, "", task.GetABCStockLoc(loc_N), ItemStatus.请求执行);
#endregion
break;
case ItemId.行车放货:
#region 行车定位
// 未完成的任务目标点
loc = site1 == "Y" ? loc2 : loc1;
// 行车到运输车对接取货点
String ABCloc = task.GetABCTrackLoc(loc); //获取对应行车位置
// 生成行车轨道定位任务
task.CreateCustomItem(item.WCS_NO, ItemId.行车轨道定位, item.DEVICE, "", ABCloc, ItemStatus.请求执行);
#endregion
break;
default:
break;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="item"></param>
/// <param name="deviceType"></param>
/// <param name="order"></param>
public Task(WCS_TASK_ITEM item, string deviceType, byte[] order)
{
_ITEM = item;
_deviceType = deviceType;
_order = order;
}
/// <summary>
/// 摆渡车复位
/// </summary>
/// <param name="dev"></param>
/// <param name="mes"></param>
public void ResetLoc_ARF(List <WCS_CONFIG_DEVICE> dev, out string mes)
{
try
{
// 摆渡车待命点1
int loc1 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyF1"));
// 摆渡车待命点2
int loc2 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyF2"));
// 获取当前摆渡车资讯
ARF a1 = new ARF(dev[0].DEVICE);
ARF a2 = new ARF(dev[1].DEVICE);
// 定位任务指令
byte[] order1;
byte[] order2;
// 任务明细
WCS_TASK_ITEM item1;
WCS_TASK_ITEM item2;
if (a1.CurrentSite() < a2.CurrentSite())
{
// 定位任务指令
order1 = ARF._Position(a1.ARFNum(), (byte)loc1);
order2 = ARF._Position(a2.ARFNum(), (byte)loc2);
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.摆渡车复位,
ID = 1,
DEVICE = dev[0].DEVICE,
LOC_TO = loc1.ToString()
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.摆渡车复位,
ID = 2,
DEVICE = dev[1].DEVICE,
LOC_TO = loc2.ToString()
};
}
else
{
// 定位任务指令
order1 = ARF._Position(a1.ARFNum(), (byte)loc2);
order2 = ARF._Position(a2.ARFNum(), (byte)loc1);
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.摆渡车复位,
ID = 1,
DEVICE = dev[0].DEVICE,
LOC_TO = loc2.ToString()
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.摆渡车复位,
ID = 2,
DEVICE = dev[1].DEVICE,
LOC_TO = loc1.ToString()
};
}
// 加入任务作业链表
mes = null;
if (dev[0].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new ARFTack(item1, DeviceType.摆渡车, order1));
}
else
{
mes = dev[0].DEVICE + " 摆渡车目前无法操作复位任务; \r";
}
if (dev[1].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new ARFTack(item2, DeviceType.摆渡车, order2));
}
else
{
mes = mes + dev[0].DEVICE + " 摆渡车目前无法操作复位任务; \r";
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 行车复位
/// </summary>
/// <param name="dev"></param>
/// <param name="mes"></param>
public void ResetLoc_ABC(List <WCS_CONFIG_DEVICE> dev, out string mes)
{
try
{
int locY = 1;
int locZ = 1;
// 行车待命点1
int locX1 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyA1"));
// 行车待命点2
int locX2 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyA2"));
// 获取当前摆渡车资讯
ABC a1 = new ABC(dev[0].DEVICE);
ABC a2 = new ABC(dev[1].DEVICE);
// 定位任务指令
byte[] order1;
byte[] order2;
// 任务明细
WCS_TASK_ITEM item1;
WCS_TASK_ITEM item2;
if (DataControl._mStools.BytesToInt(a1.CurrentXsite(), 0) < DataControl._mStools.BytesToInt(a2.CurrentXsite(), 0))
{
// 定位任务指令
order1 = ABC._TaskControl(ABC.TaskLocate, a1.ABCNum(), DataControl._mStools.IntToBytes(locX1), DataControl._mStools.IntToBytes(locY), DataControl._mStools.IntToBytes(locZ));
order2 = ABC._TaskControl(ABC.TaskLocate, a2.ABCNum(), DataControl._mStools.IntToBytes(locX2), DataControl._mStools.IntToBytes(locY), DataControl._mStools.IntToBytes(locZ));
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.行车复位,
ID = 5,
DEVICE = dev[0].DEVICE,
LOC_TO = Convert.ToString(locX1) + "-" + Convert.ToString(locY) + "-" + Convert.ToString(locZ)
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.行车复位,
ID = 6,
DEVICE = dev[1].DEVICE,
LOC_TO = Convert.ToString(locX2) + "-" + Convert.ToString(locY) + "-" + Convert.ToString(locZ)
};
}
else
{
// 定位任务指令
order1 = ABC._TaskControl(ABC.TaskLocate, a1.ABCNum(), DataControl._mStools.IntToBytes(locX2), DataControl._mStools.IntToBytes(locY), DataControl._mStools.IntToBytes(locZ));
order2 = ABC._TaskControl(ABC.TaskLocate, a2.ABCNum(), DataControl._mStools.IntToBytes(locX1), DataControl._mStools.IntToBytes(locY), DataControl._mStools.IntToBytes(locZ));
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.行车复位,
ID = 5,
DEVICE = dev[0].DEVICE,
LOC_TO = Convert.ToString(locX2) + "-" + Convert.ToString(locY) + "-" + Convert.ToString(locZ)
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.行车复位,
ID = 6,
DEVICE = dev[1].DEVICE,
LOC_TO = Convert.ToString(locX1) + "-" + Convert.ToString(locY) + "-" + Convert.ToString(locZ)
};
}
// 加入任务作业链表
mes = null;
if (dev[0].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new ABCTack(item1, DeviceType.行车, order1));
}
else
{
mes = dev[0].DEVICE + " 行车目前无法操作复位任务; \r";
}
if (dev[1].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new ABCTack(item2, DeviceType.行车, order2));
}
else
{
mes = mes + dev[1].DEVICE + " 行车目前无法操作复位任务; \r";
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 运输车复位
/// </summary>
/// <param name="dev"></param>
/// <param name="mes"></param>
public void ResetLoc_RGV(List <WCS_CONFIG_DEVICE> dev, out string mes)
{
try
{
// 运输车待命点1
int loc1 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyR1"));
// 运输车待命点2
int loc2 = Convert.ToInt32(DataControl._mStools.GetValueByKey("StandbyR2"));
// 获取当前摆渡车资讯
RGV a1 = new RGV(dev[0].DEVICE);
RGV a2 = new RGV(dev[1].DEVICE);
// 定位任务指令
byte[] order1;
byte[] order2;
// 任务明细
WCS_TASK_ITEM item1;
WCS_TASK_ITEM item2;
if (a1.GetCurrentSite() < a2.GetCurrentSite())
{
// 定位任务指令
order1 = RGV._Position(a1.RGVNum(), DataControl._mStools.IntToBytes(loc1));
order2 = RGV._Position(a2.RGVNum(), DataControl._mStools.IntToBytes(loc2));
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.运输车复位1,
ID = 3,
DEVICE = dev[0].DEVICE,
LOC_TO = loc1.ToString()
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.运输车复位2,
ID = 4,
DEVICE = dev[1].DEVICE,
LOC_TO = loc2.ToString()
};
}
else
{
// 定位任务指令
order1 = RGV._Position(a1.RGVNum(), DataControl._mStools.IntToBytes(loc2));
order2 = RGV._Position(a2.RGVNum(), DataControl._mStools.IntToBytes(loc1));
// 任务明细
item1 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.运输车复位2,
ID = 3,
DEVICE = dev[0].DEVICE,
LOC_TO = loc2.ToString()
};
item2 = new WCS_TASK_ITEM()
{
ITEM_ID = ItemId.运输车复位1,
ID = 4,
DEVICE = dev[1].DEVICE,
LOC_TO = loc1.ToString()
};
}
// 加入任务作业链表
mes = null;
if (dev[0].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new RGVTack(item1, DeviceType.运输车, order1));
}
else
{
mes = dev[0].DEVICE + " 运输车目前无法操作复位任务; \r";
}
if (dev[1].FLAG == DeviceFlag.空闲)
{
DataControl._mTaskControler.StartTask(new ARFTack(item2, DeviceType.运输车, order2));
}
else
{
mes = mes + dev[1].DEVICE + " 运输车目前无法操作复位任务; \r";
}
}
catch (Exception ex)
{
throw ex;
}
}
