using Hanhe.iWCS.Business;
|
using Hanhe.iWCS.Common;
|
using Hanhe.iWCS.DeviceDriver;
|
using Hanhe.iWCS.MData;
|
using Hanhe.iWCS.Model;
|
using Hanhe.iWCS.Model.AMS;
|
using Hanhe.iWCS.Model.H883;
|
using MongoDB.Bson;
|
using MongoDB.Driver;
|
using MongoDB.Driver.Builders;
|
using MySql.Data.MySqlClient;
|
using Newtonsoft.Json;
|
using SqlSugar;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Net.Configuration;
|
using System.Text;
|
using System.Threading.Tasks;
|
using System.Web.UI.WebControls.WebParts;
|
using static Hanhe.iWCS.IndonesiaGLMProtocol.AMSHelper;
|
using static Hanhe.iWCS.IndonesiaGLMProtocol.EnentListen;
|
using static Hanhe.iWCS.IndonesiaGLMProtocol.MESHelper;
|
using static Hanhe.iWCS.IndonesiaGLMProtocol.PLCControl;
|
using static Hanhe.iWCS.IndonesiaGLMProtocol.ProtocolAnalysis;
|
using static System.Runtime.CompilerServices.RuntimeHelpers;
|
|
namespace Hanhe.iWCS.IndonesiaGLMProtocol
|
{
|
public class ProcessHelper
|
{
|
private static ICallTaskProcessing callTaskProcessing = new ICallTaskProcessing();
|
private static WebApiHelper webApiHelper = new WebApiHelper();
|
|
public static bool CheckStartFree(string bit) {
|
var result = false;
|
var tasks = MongoDBSingleton.Instance.Find<TN_I_TASK_MST>(Query.EQ("CN_S_START_BIT", bit), "TN_I_TASK_MST");
|
if (tasks.Count == 0) {
|
result = true;
|
}
|
else {
|
for (int i = 0; i < tasks.Count; i++) {
|
if (!WorkFlowAction.ExistsTrackLogs(tasks[i].CN_S_TASK_NO, 1, 4)) {
|
break;
|
}
|
}
|
}
|
return result;
|
}
|
|
public static bool PickUpStartFree(string bit)
|
{
|
var result = false;
|
var tasks = MongoDBSingleton.Instance.Find<TN_I_TASK_MST>(Query.EQ("CN_S_START_BIT", bit), "TN_I_TASK_MST");
|
if (tasks.Count == 0)
|
{
|
result = true;
|
}
|
else
|
{
|
result = true;
|
for (int i = 0; i < tasks.Count; i++)
|
{
|
if (!WorkFlowAction.ExistsTrackLogs(tasks[i].CN_S_TASK_NO, 1, 4))
|
{
|
result = false;
|
break;
|
}
|
}
|
}
|
return result;
|
}
|
|
public static bool PickUpEndFree(string bit)
|
{
|
var result = false;
|
var tasks = MongoDBSingleton.Instance.Find<TN_I_TASK_MST>(Query.EQ("CN_S_END_BIT", bit), "TN_I_TASK_MST");
|
if (tasks.Count == 0)
|
{
|
result = true;
|
}
|
else
|
{
|
result = true;
|
for (int i = 0; i < tasks.Count; i++)
|
{
|
if (!WorkFlowAction.ExistsTrackLogs(tasks[i].CN_S_TASK_NO, 1, 6))
|
{
|
result = false;
|
break;
|
}
|
}
|
}
|
return result;
|
}
|
|
internal static bool CheckEndFree(string bit) {
|
var count = MongoDBSingleton.Instance.FindCount<TN_I_TASK_MST>(Query.EQ("CN_S_END_BIT", bit), "TN_I_TASK_MST");
|
return count == 0;
|
}
|
|
/// <summary>
|
/// 发送任务——已增加起点终点层数，特殊AGV站点推送
|
/// </summary>
|
/// <param name="mst"></param>
|
internal static void SendTask(TN_I_TASK_MST mst)
|
{
|
try
|
{
|
if (mst.CN_S_STATUS == "未执行" || mst.CN_S_STATUS == "待推送")
|
{
|
mst.CN_S_BUSS_TYPE = getTaskType(mst.CN_S_BUSS_TYPE,false);
|
|
if (mst.CN_S_END_BIT == "CK001_XN-01")
|
{
|
mst = MongoDBSingleton.Instance.FindOne<TN_I_TASK_MST>(Query.EQ("CN_S_TASK_NO", mst.CN_S_TASK_NO), "TN_I_TASK_MST");
|
}
|
StringBuilder sbMsg = new StringBuilder();
|
var start = StockInstance.Instance.GetLocationInfoTwo(mst.CN_S_START_BIT);
|
var end = StockInstance.Instance.GetLocationInfoTwo(mst.CN_S_END_BIT);
|
string FRow = string.IsNullOrEmpty(start.CN_S_FLOOR) ? "1" : start.CN_S_FLOOR;
|
string TRow = string.IsNullOrEmpty(end.CN_S_FLOOR) ? "1" : end.CN_S_FLOOR;
|
int location = -1;
|
CMMLog.Info($"任务推送：货位编码：起点信息:{JsonConvert.SerializeObject(start)},终点信息:{JsonConvert.SerializeObject(end)}；任务信息：{JsonConvert.SerializeObject(mst)}");
|
|
if (mst.CN_S_BUSS_TYPE.Contains("3楼复称入缓存架"))
|
{
|
//更改任务为已推送
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_STATUS", "已推送"), UpdateFlags.None);
|
CMMLog.Info("任务更改成功");
|
return;
|
}
|
if (mst.CN_S_BUSS_TYPE == "包装线补空")
|
{
|
CMMLog.Info($"任务推送特殊任务处理-包装线补空：任务号：{mst.CN_S_TASK_NO},准备获取 AGVLocationList 配置数据。备注：此任务类型仅获取起点。");
|
var agvLoc = Settings.GetDDSiteList().Where(a => a.ddLoc == mst.CN_S_START_BIT).FirstOrDefault();
|
if (agvLoc != null)
|
{
|
var emp = MongoDBSingleton.Instance.FindOne<BZEmptyPoint>(Query.EQ("Bit", mst.CN_S_START_BIT), "BZEmptyPoint");
|
if (emp != null)
|
{
|
location = agvLoc.Site[emp.Quantity - 1];
|
}
|
}
|
}
|
if (mst.CN_S_BUSS_TYPE == "缓存架入立库")
|
{
|
TRow = "1";
|
}
|
if (mst.CN_S_BUSS_TYPE == "3楼成品出库")
|
{
|
FRow = "1";
|
}
|
#region 电梯任务处理
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托" || mst.CN_S_BUSS_TYPE == "3楼包装补空" || mst.CN_S_BUSS_TYPE == "转运" || mst.CN_S_BUSS_TYPE == "1楼辅材入2楼" || mst.CN_S_BUSS_TYPE == "转运到包装机")
|
{
|
CMMLog.Info("电梯任务处理");
|
//电梯任务处理流程
|
#region 根据任务类型判断任务终点楼层
|
int floor = 0;
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托")
|
{
|
floor = 1;
|
}
|
if (mst.CN_S_BUSS_TYPE == "3楼包装补空")
|
{
|
floor = 2;
|
}
|
if (mst.CN_S_BUSS_TYPE == "转运到包装机")
|
{
|
if(mst.CN_S_START_AREA != mst.CN_S_END_AREA)
|
{
|
floor = 2;
|
}
|
}
|
if (mst.CN_S_BUSS_TYPE == "转运")
|
{
|
//判断点到点转运任务是否需要经过电梯，如果需要经过电梯，则判断起点终点的楼层，如果不经过电梯，则直接推送
|
if (mst.CN_S_START_AREA != mst.CN_S_END_AREA)
|
{
|
floor = mst.CN_S_END_AREA.Contains("2") ? 2 : 1;
|
}
|
}
|
if (mst.CN_S_BUSS_TYPE == "1楼辅材入2楼")
|
{
|
floor = 2;
|
}
|
#endregion
|
|
if(floor != 0)
|
{
|
CMMLog.Info($"任务终点：{floor}，任务类型：{mst.CN_S_BUSS_TYPE}");
|
//1、判断当前电梯是否有任务，无任务则推送
|
var eleInfo = MongoDBSingleton.Instance.FindOne<elevatorTask>(Query.EQ("S_USE", "0"), "elevatorTask");
|
if (eleInfo == null)
|
{
|
var plcInfo = Settings.GetPlcInfo().Where(a => a.deviceType == "22" && a.enable == 1).First();
|
if (plcInfo != null)
|
{
|
string endLoc = floor == 1 ? plcInfo.location.Split(',')[0] : plcInfo.location.Split(',')[1];
|
string startLoc = floor == 1 ? plcInfo.location.Split(',')[1] : plcInfo.location.Split(',')[0];
|
//更改任务的终点为电梯
|
var updateBuider = Update.Set("CN_S_END_BIT", endLoc);//新目的地
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("CN_S_TASK_NO", mst.CN_S_TASK_NO), updateBuider, UpdateFlags.None);
|
CMMLog.Info($"更改任务的终点：{endLoc}");
|
MongoDBSingleton.Instance.Insert<elevatorTask>(new elevatorTask
|
{
|
S_DT_LOC = startLoc,
|
S_END_LOC = mst.CN_S_END_BIT,
|
S_END_FLOOR = floor,
|
S_TASK_TYPE = mst.CN_S_BUSS_TYPE,
|
task_mst = mst,
|
wmsInfo = MongoDBSingleton.Instance.FindOne<WMSInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), "WMSInfo"),
|
S_USE = "0",
|
time = DateTime.Now
|
});
|
CMMLog.Info("插入中间表数据");
|
mst = MongoDBSingleton.Instance.FindOne<TN_I_TASK_MST>(Query.EQ("_id", mst._id), "TN_I_TASK_MST");
|
start = StockInstance.Instance.GetLocationInfoTwo(mst.CN_S_START_BIT);
|
end = StockInstance.Instance.GetLocationInfoTwo(mst.CN_S_END_BIT);
|
FRow = string.IsNullOrEmpty(start.CN_S_FLOOR) ? "1" : start.CN_S_FLOOR;
|
TRow = string.IsNullOrEmpty(end.CN_S_FLOOR) ? "1" : end.CN_S_FLOOR;
|
}
|
else CMMLog.Info("提升机未配置");
|
}
|
else
|
{
|
CMMLog.Info("电梯正在使用");
|
return;
|
}
|
}
|
}
|
#endregion
|
try
|
{
|
start.CN_N_AGV_LOCATION = location == -1 ? start.CN_N_AGV_LOCATION : location;
|
var req = $"<Req><Order TS='1' Pri='{mst.CN_N_PRIORITY}' From='{start.CN_N_AGV_LOCATION}' To='{end.CN_N_AGV_LOCATION}' No='{mst.CN_S_TASK_NO}_1' Ext1='1' Ext2='CALLADDAGV' Ext3='' FRow='{1}' TRow='{1}'/></Req>";
|
CMMLog.Info($"任务推送：下发 Hosttoagv 数据：{req}.");
|
HardwareAccessObject AGVHao = HardwareAccessHelper.Instance.GetEquipmentsHAO("1");
|
if (AGVHao != null)
|
{
|
object[] args = new object[1];
|
args[0] = req;
|
object xmlData = AGVHao._WebServiceInstance.Invoke("AddNewOrder", args);
|
string errMsg = string.Empty;
|
int errCode = -1;
|
if (xmlData != null)
|
{
|
errCode = Hanhe.iWCS.AGVWebService.AGVHelper.Instance.AGVXmlResult((string)xmlData, out errMsg);
|
}
|
var msg = "WCS To AGV send task; errcode=" + errCode + "！data=" + sbMsg.ToString() + ";url=" + AGVHao.WebUrl;
|
CMMLog.Info($"任务推送：接收 Hosttoagv 数据：{msg}.");
|
if (errCode == Constants.WCS_AGV_ERRCode || errCode == 99999)
|
{
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_STATUS", "未执行"), UpdateFlags.None);
|
AMSHelper.TaskTrackLogMessage(mst.CN_S_TASK_NO, "1", "1027", "AGV任务拦截推送失败", errCode.ToString());
|
//Console.WriteLine(mst.CN_S_TASK_NO + ", \"1\", \"1027\", \"AGV任务拦截推送失败\"," + errCode.ToString());
|
CMMLog.Info(mst.CN_S_TASK_NO + ", \"1\", \"1027\", \"AGV任务拦截推送失败\"," + errCode.ToString());
|
}
|
else
|
{
|
if (errCode == 0 || errCode == 50009)
|
{
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_STATUS", "已推送"), UpdateFlags.None);
|
}
|
AMSHelper.TaskTrackLogMessage(mst.CN_S_TASK_NO, "1", "1027", "AGV任务下达成功");
|
//Console.WriteLine(mst.CN_S_TASK_NO + "\"1\", \"1027\", \"AGV任务下达成功\"");
|
CMMLog.Info(mst.CN_S_TASK_NO + "\"1\", \"1027\", \"AGV任务下达成功\"");
|
}
|
}
|
else
|
{
|
//Console.WriteLine("WCS To AGV send task fail; ts1 not set in ams work center");
|
CMMLog.Info("WCS To AGV send task fail; ts1 not set in ams work center");
|
}
|
}
|
catch (Exception ex)
|
{
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_STATUS", "未执行"), UpdateFlags.None);
|
CMMLog.Error("WCS To AGV send task fail;param=" + mst.CN_S_TASK_NO + ";err=" + ex.Message);
|
AMSHelper.TaskTrackLogMessage(mst.CN_S_TASK_NO, "1", "1027", "AGV任务拦截推送失败");
|
}
|
}
|
}
|
catch(Exception ex)
|
{
|
CMMLog.Info($"任务推送报错：err:{ex.Message}");
|
}
|
|
}
|
|
#region 3楼设备任务
|
|
/// <summary>
|
/// 终点安全对接：1013安全请求进入；6安全请求退出
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="code"></param>
|
internal static void EndPickUpDoorSafe(TN_I_TASK_MST mst, int code)
|
{
|
//3楼包装补空：包装机补空托流程——3楼包装机安全门交互
|
var plc = Settings.GetPlcInfo().Where(a => a.location.Contains(mst.CN_S_END_BIT)).FirstOrDefault();
|
//if (plc != null || mst.CN_S_BUSS_TYPE == "3楼复称入缓存架")
|
CMMLog.Info($"{mst.CN_S_END_BIT}");
|
CMMLog.Info($"{plc}");
|
if (plc != null || mst.CN_S_BUSS_TYPE == "3楼打包下线")
|
{
|
CMMLog.Info($"进入{mst.CN_S_BUSS_TYPE}流程{code}的处理");
|
if (code == 1013)
|
{
|
//卸货申请，先判断设备是否允许进料，如果是直接改参数，并通知设备
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.SecondWeightSafe(plc.ip, mst.CN_S_TASK_NO, plc.port);
|
//if (mst.CN_S_BUSS_TYPE == "3楼复称入缓存架") PLCControl.SecondWeightInCache1013(mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托") PLCControl.CacheStackingMouth1013(plc.deviceType, mst.CN_S_TASK_NO, mst.CN_S_END_BIT);
|
if (mst.CN_S_BUSS_TYPE == "3楼拆盘补空") PLCControl.DiscRemoverReqUnload(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "包装线补空" || mst.CN_S_BUSS_TYPE == "转运到包装机") PLCControl.PackingLine(plc.ip, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼打包下线") PLCControl.outWare(mst.CN_S_TASK_NO, true);
|
if (mst.CN_S_BUSS_TYPE == "3楼成品出库") PLCControl.productOutWare(mst.CN_S_END_BIT, mst.CN_S_TASK_NO, true);
|
if (mst.CN_S_BUSS_TYPE == "3楼包装补空" || mst.CN_S_BUSS_TYPE == "1楼辅材入2楼") PLCControl.machineEmpty1013(plc.deviceType, mst.CN_S_TASK_NO,true);
|
if (mst.CN_S_BUSS_TYPE.Contains("提升机")) PLCControl.CacheStackingMouth1013Two(plc.deviceType, mst.CN_S_TASK_NO);
|
}
|
if (code == 6)
|
{
|
//卸货完成申请，判断设备那边进料完成，改参数通知agv离开
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.CheckUpUnloadComplete(plc.ip, mst.CN_S_TASK_NO, mst.CN_S_START_BIT, plc.port);
|
//if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.SecondWeightSafeComplete(plc.ip, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼拆盘补空") PLCControl.DiscRemoverUnloadComplete(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼打包下线") PLCControl.outWare(mst.CN_S_TASK_NO, false);
|
if (mst.CN_S_BUSS_TYPE == "包装线补空" || mst.CN_S_BUSS_TYPE == "转运到包装机") PLCControl.PackingLineComplete(plc.ip);
|
if (mst.CN_S_BUSS_TYPE == "3楼成品出库") PLCControl.productOutWare(mst.CN_S_END_BIT, mst.CN_S_TASK_NO, false);
|
if (mst.CN_S_BUSS_TYPE == "叠包提升机") PLCControl.CacheStackingMouth6Two(mst.CN_S_END_BIT);
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托" || mst.CN_S_BUSS_TYPE == "3楼包装补空") PLCControl.SecondWeightInCache6(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼包装补空" || mst.CN_S_BUSS_TYPE == "1楼辅材入2楼") PLCControl.machineEmpty1013(plc.deviceType, mst.CN_S_TASK_NO,false);
|
}
|
}
|
else CMMLog.Info($"PlcInfo中未找到该点位，点位：{mst.CN_S_END_BIT}");
|
}
|
|
/// <summary>
|
/// 滚筒车终点到位信号：4 取货完成：1213
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="code"></param>
|
internal static void DiscRemoverEmptySupport(TN_I_TASK_MST mst, int code)
|
{
|
var plc = Settings.GetPlcInfo().Where(a => a.location == mst.CN_S_END_BIT).FirstOrDefault();
|
if (plc != null)
|
{
|
if (code == 4)
|
{
|
//卸货申请，先判断设备是否允许进料，如果是直接改参数，并通知设备
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.CheckUpReqUnload(plc, mst.CN_S_TASK_NO);
|
}
|
if (code == 1213)
|
{
|
//卸货完成申请，判断设备那边进料完成，改参数通知agv离开
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.CheckUpUnloadComplete(plc.ip, mst.CN_S_TASK_NO,mst.CN_S_START_BIT,plc.port);
|
}
|
}
|
else CMMLog.Info($"设备未配置：{mst.CN_S_END_BIT}");
|
}
|
|
/// <summary>
|
/// 起点安全对接：1012安全请求进入；4安全请求退出
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="code"></param>
|
internal static void StartPickUpDoorSafe(TN_I_TASK_MST mst, int code)
|
{
|
//3楼包装补空：包装机补空托流程——3楼包装机安全门交互
|
var plc = Settings.GetPlcInfo().Where(a => a.location.Contains(mst.CN_S_START_BIT)).FirstOrDefault();
|
if (plc != null)
|
{
|
CMMLog.Info($"进入任务{mst.CN_S_BUSS_TYPE}的流程{code}");
|
if (code == 1012)
|
{
|
//卸货申请，先判断设备是否允许进料，如果是直接改参数，并通知设备
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.PickUpFullDoorUnload(plc.ip, mst.CN_S_TASK_NO,plc.deviceType);//进入3楼包装取料流程1012,ip:{plc.ip},task:{mst.CN_S_TASK_NO}
|
//if (mst.CN_S_BUSS_TYPE == "3楼复称入缓存架" || mst.CN_S_BUSS_TYPE == "3楼复称入缓存架NG") PLCControl.SecondWeightInCache1012(plc.ip, mst.CN_S_TASK_NO);//二期：直接改参数
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托") TSHelper.GoToAGV(mst.CN_S_TASK_NO, 10, 1);
|
if (mst.CN_S_BUSS_TYPE == "3楼叠盘下线") PLCControl.StackingReqUnload(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼打包下线") PLCControl.PackingLineUnload1012(plc.ip, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE.Contains("提升机")) PLCControl.ElevatorStart(plc.ip, mst.CN_S_TASK_NO, mst.CN_S_BUSS_TYPE,plc.port);
|
}
|
if (code == 4)
|
{
|
//卸货完成申请，判断设备那边进料完成，改参数通知agv离开
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.PickUpFullDoorComplete(plc.ip, mst.CN_S_TASK_NO, plc.deviceType);
|
//if (mst.CN_S_BUSS_TYPE == "3楼复称入缓存架" || mst.CN_S_BUSS_TYPE == "3楼复称入缓存架NG") PLCControl.SecondWeightInCache4(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼叠盘下线") PLCControl.StackingComplete(plc.deviceType, mst.CN_S_TASK_NO);
|
if (mst.CN_S_BUSS_TYPE == "3楼打包下线") PLCControl.PackingLineComplete4(plc.ip, mst.CN_S_SOURCE_NO);
|
if (mst.CN_S_BUSS_TYPE != "3楼包装取料") WMSHelper.ExecuteState(mst.CN_S_SOURCE_NO, 4);
|
if (mst.CN_S_BUSS_TYPE.Contains("提升机")) PLCControl.ElevatorEnd(plc.ip, mst.CN_S_TASK_NO, mst.CN_S_BUSS_TYPE);
|
}
|
}
|
else CMMLog.Info($"点位{mst.CN_S_START_BIT}未配置");
|
}
|
|
/// <summary>
|
/// 滚筒车起点到位信号：1112 取货完成：1212
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="code"></param>
|
internal static void PickupAndUnload(TN_I_TASK_MST mst,int code)
|
{
|
//3楼包装补空：包装机补空托流程——空托输送线交互（取空托，取空托完成）
|
//3楼包装取料：3楼包装机取料去复称平台流程——进入包装机安全门后取料
|
var plc = Settings.GetPlcInfo().Where(a => a.location == mst.CN_S_START_BIT).FirstOrDefault();
|
if (plc != null)
|
{
|
if (code == 1112)
|
{
|
//三楼包装机进安全门内对接
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.PickUpFullUnload(plc.ip, mst.CN_S_TASK_NO, plc.port);
|
}
|
if (code == 1212)
|
{
|
//三楼包装机安全门内对接 二期没有滚筒车，因此无需向 包装机 写入 滚筒停止指令
|
//if (mst.CN_S_BUSS_TYPE == "3楼包装取料") PLCControl.PickUpFullComplete(plc.ip, mst.CN_S_TASK_NO);
|
}
|
}
|
}
|
|
#endregion
|
|
#region 任务处理——拦截任务-电梯任务-取消任务
|
|
/// <summary>
|
/// 拦截WMS发送的任务，因为WCS需要对任务类型进行分类处理
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <returns></returns>
|
internal static bool Intercept(TN_I_TASK_MST mst)
|
{
|
bool result = false;// false:直接推送 true:拦截不推送
|
try
|
{
|
//对WMS下发的任务进行拦截，因为AMS需要对任务类型进行区分处理（调试通过后，可以考虑封装为方法）
|
|
CMMLog.Info($"任务拦截处理：执行开始！任务号：{mst.CN_S_TASK_NO},ext1:{mst.Ext1}");
|
|
//if (!string.IsNullOrEmpty(mst.CN_S_BUSS_TYPE) && mst.CN_S_BUSS_TYPE != "转运")
|
//{
|
// CMMLog.Info($"bussType:{mst.CN_S_BUSS_TYPE}");
|
// mst.CN_S_BUSS_TYPE = getTaskType(mst.CN_S_BUSS_TYPE, false);
|
// if (string.IsNullOrEmpty(mst.CN_S_BUSS_TYPE))
|
// {
|
// return true;
|
// }
|
//}
|
|
#region
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托")
|
{
|
//寻找所有正在执行中的 3楼缓存架入叠托 任务
|
//var taskInfoList = MongoDBSingleton.Instance.Find<TN_I_TASK_MST>(Query.And(Query.EQ("CN_S_BUSS_TYPE", "3楼缓存架入叠托"), Query.NotIn("CN_S_STATUS", new List<MongoDB.Bson.BsonValue>() { "未执行", "待推送" })), "TN_I_TASK_MST");
|
//if (taskInfoList.Count > 0)
|
//{
|
// //找到了有正在执行中的任务，通过是否卸货完成判断是否可推送任务
|
// try
|
// {
|
// for (int i = taskInfoList.Count - 1; i >= 0; i--)
|
// {
|
// //查询所有的已推送的任务，判断是否卸货完成，卸货完成从列表中掉
|
// var taskNo = taskInfoList[i].CN_S_TASK_NO;
|
// var trackInfo = MongoDBSingleton.Instance.FindOne<TN_I_TASK_DTL_ACTION_TrackLog>(Query.And(Query.EQ("CN_S_TASK_NO", taskNo), Query.EQ("CN_S_ACTION_CODE", 6)), "TN_I_TASK_DTL_ACTION_TrackLog");
|
// if (trackInfo != null) taskInfoList.Remove(taskInfoList[i]);
|
// }
|
//
|
// if(taskInfoList.Count > 0)
|
// {
|
// int a = 0;
|
// int b = 0;
|
// foreach (var c in taskInfoList)
|
// {
|
// //查询所有未推送的任务
|
// if (c.CN_S_START_BIT.Substring(0,1) == mst.CN_S_START_BIT.Substring(0, 1)) a = a + 1;
|
// else b = b + 1;
|
// }
|
// if (a > b) return true;
|
// }
|
//
|
// //判断是否还有没有取货完成的任务，若还有，不推送
|
// if (taskInfoList.Count > 0)
|
// {
|
// return true;
|
// }
|
// }
|
// catch (Exception ex)
|
// {
|
// Console.WriteLine("3楼缓存架入叠托:" + ex.Message);
|
// }
|
//}
|
}
|
#endregion
|
|
#region 点到点转运到包装机
|
var plcInfo = Settings.GetPlcInfo().Where(a => a.location == mst.CN_S_END_BIT && a.enable == 1).FirstOrDefault();
|
if(plcInfo != null && plcInfo.deviceType == "1")
|
{
|
CMMLog.Info($"ext1:{mst.Ext1},{string.IsNullOrEmpty(mst.Ext1)}");
|
CMMLog.Info($"CN_S_BUSS_TYPE:{mst.CN_S_BUSS_TYPE},{string.IsNullOrEmpty(mst.CN_S_BUSS_TYPE)}");
|
if (string.IsNullOrEmpty(mst.Ext1) && (string.IsNullOrEmpty(mst.CN_S_BUSS_TYPE) || mst.CN_S_BUSS_TYPE == "转运"))
|
{
|
//确定是上包装机的任务
|
mst.Ext1 = "DDD_BZJ";
|
}
|
}
|
#endregion
|
|
var bussTypeInfo = Settings.GetHouWeiCodeo().Where(a => a.location == mst.Ext1).FirstOrDefault();
|
if (bussTypeInfo != null)
|
{
|
CMMLog.Info($"type:{bussTypeInfo.taskType}");
|
string taskType = getTaskType(bussTypeInfo.taskType, true);
|
if (!string.IsNullOrEmpty(taskType))
|
{
|
if (bussTypeInfo.task != "5" && bussTypeInfo.task != "15")
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_BUSS_TYPE", taskType).Set("Ext1", mst.Ext1 + taskType), "TN_I_TASK_MST", UpdateFlags.None);
|
else
|
{
|
var wmsinfo = MongoDBSingleton.Instance.FindOne<WMSInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), "WMSInfo");
|
if (wmsinfo == null)
|
{
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_BUSS_TYPE", taskType).Set("Ext1", mst.Ext1 + taskType), "TN_I_TASK_MST", UpdateFlags.None);
|
var transInfo = mst.transportInfo.First();
|
List<string> list = new List<string>(transInfo.itemWeight.Split(','));
|
MongoDBSingleton.Instance.Insert<WMSInfo>(new WMSInfo
|
{
|
trayCode = mst.CN_S_BATCH_NO,
|
itemCode = transInfo.itemCode,
|
itemPCode = transInfo.itemPCode,
|
location = transInfo.itemName,
|
productWeight = list[0],
|
trayCodeWeight = list[1],
|
oneTrayWeight = list[2],
|
palletLayers = list[3],
|
addState = int.Parse(transInfo.itemFeatures),
|
packageCode = transInfo.trayCode,
|
TaskNo = mst.CN_S_TASK_NO,
|
dateTime = DateTime.Now
|
});
|
}
|
else
|
{
|
//Console.WriteLine("任务拦截处理：WMSINFO中间表目前正在有缓存架入叠托的任务在执行！");
|
CMMLog.Info("任务拦截处理：WMSINFO中间表目前正在有缓存架入叠托的任务在执行！");
|
}
|
}
|
result = true;
|
|
if (bussTypeInfo.task == "21")
|
{
|
//立库入库的优先级要高于出库的优先级
|
var taskInfo = MongoDBSingleton.Instance.FindOne<TN_I_TASK_MST>(Query.And(Query.EQ("CN_S_BUSS_TYPE", "缓存架入立库"), Query.EQ("CN_S_STATUS", "未执行")), "TN_I_TASK_MST");
|
if (taskInfo == null)
|
{
|
//3楼成品出库任务拦截
|
if (OutWareTask(mst))
|
{
|
CMMLog.Info("成品出库流程，任务更改为false");
|
result = false;
|
}
|
else
|
{
|
CMMLog.Info("成品出库流程，任务更改为true");
|
result = true;
|
}
|
}
|
else
|
{
|
result = true;
|
}
|
}
|
}
|
else
|
{
|
MongoDBSingleton.Instance.Insert(new taskTypeConversion
|
{
|
ChineseType = bussTypeInfo.taskType
|
}, "taskTypeConversion");
|
|
CMMLog.Info($"任务类型转换表未配置该任务的英文任务类型，任务类型：{bussTypeInfo.taskType}");
|
}
|
}
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("_id", mst._id), Update.Set("CN_S_STATUS", "未执行"), "TN_I_TASK_MST", UpdateFlags.None);
|
CMMLog.Info("任务拦截处理：执行完毕！");
|
}
|
catch(Exception ex)
|
{
|
Console.WriteLine($"taskNo:{mst.CN_S_TASK_NO},Intercept ex:{ex}");
|
return true;
|
}
|
CMMLog.Info($"RESULT:{result}");
|
return result;
|
}
|
|
/// <summary>
|
/// 任务中英文转换
|
/// </summary>
|
/// <param name="taskType"></param>
|
/// <param name="result">true 中-英</param>
|
/// <returns></returns>
|
internal static string getTaskType(string taskType,bool result)
|
{
|
string type = "";
|
|
try
|
{
|
if (result)
|
{
|
//根据中文查询英文
|
type = MongoDBSingleton.Instance.FindOne<taskTypeConversion>(Query.EQ("ChineseType", taskType), "taskTypeConversion").EnglishType;
|
}
|
else
|
{
|
//根据英文查询中文
|
type = MongoDBSingleton.Instance.FindOne<taskTypeConversion>(Query.EQ("EnglishType", taskType), "taskTypeConversion").ChineseType;
|
}
|
}
|
catch (Exception ex)
|
{
|
CMMLog.Info("getTaskType err:"+ex.Message);
|
return "";
|
}
|
|
return type;
|
}
|
|
public class taskTypeConversion
|
{
|
public ObjectId _id { get; set; }
|
public string EnglishType { get; set; }
|
public string ChineseType { get; set; }
|
}
|
|
|
internal static bool OutWareTask(TN_I_TASK_MST mst)
|
{
|
bool result = false;
|
CMMLog.Info("成品出库任务流程处理开始");
|
string endMachLoc = "";
|
string endLoc = "";
|
//1、判断上料平台是否空闲，若空闲更改终点到上料平台
|
var plc = Settings.GetPlcInfo().Where(a => a.deviceType == "18" && a.enable == 1).ToList();
|
if (plc.Count > 0)
|
{
|
foreach(var a in plc)
|
{
|
CMMLog.Info($"查询输送线当前点位：{a.location}");
|
if (CheckEndFree(a.location))
|
{
|
CMMLog.Info($"当前输送线无任务");
|
//var num = a.device == "26" ? 1 : 2;
|
|
var result1 = OITcpHelper.RegisterReadOutPut(new OITcpHelper.RegisterReadOutPutModel
|
{
|
dataNum = 1,
|
addr = a.readAddr + 1,
|
host = a.ip,
|
port = a.port
|
});
|
CMMLog.Debug($"成品出库流程：读取输送线{a.device},ip:{a.ip},port:{a.port},通道号为：{a.readAddr + 1}的值为：{result1.result[0]}");
|
if (result1 != null && result1.errCode == 0)
|
{
|
if (result1.result[0] == 1)
|
{
|
endMachLoc = a.location;
|
break;
|
}
|
}
|
}
|
}
|
|
if (string.IsNullOrEmpty(endMachLoc))
|
{
|
CMMLog.Info("输送线不可用，生成任务到缓存货架");
|
//设备非空闲，计算终点到货架
|
var locInfo = MongoDBSingleton.Instance.FindOne<location>(Query.And(Query.EQ("N_CURRENT_NUM",0),Query.EQ("S_LOC_STATE", "无")), "location");
|
if (locInfo != null)
|
{
|
endLoc = locInfo.S_LOC_CODE;
|
}
|
if (!string.IsNullOrEmpty(endLoc))
|
{
|
//改任务的终点
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("CN_S_TASK_NO", mst.CN_S_TASK_NO), Update.Set("CN_S_END_BIT", endLoc), UpdateFlags.None);
|
|
//终点上锁
|
var trayCode = mst.transportInfo[0].trayCode;
|
MongoDBSingleton.Instance.Update<location>(Query.EQ("S_LOC_CODE", endLoc), Update.Set("S_LOC_STATE", "入库锁").Set("S_TRAY_CODE", trayCode), UpdateFlags.None);
|
|
new SqlHelper<object>().ExecuteSql($"update dbo.tn_am_task_mst set CN_S_END_BIE='{endLoc}',CN_S_END_AGVBIT = '{StockInstance.Instance.GetAGVCodeForBitCode(endLoc)}' where CN_S_TASK_NO = '{mst.CN_S_TASK_NO}'");
|
result = true;
|
}
|
}
|
else
|
{
|
CMMLog.Info($"生成任务到输送线，更改任务终点，货位号：{endMachLoc}");
|
//改任务的终点
|
MongoDBSingleton.Instance.Update<TN_I_TASK_MST>(Query.EQ("CN_S_TASK_NO", mst.CN_S_TASK_NO), Update.Set("CN_S_END_BIT", endMachLoc), UpdateFlags.None);
|
|
endBitModel bit = new endBitModel
|
{
|
CN_S_TASK_NO = mst.CN_S_TASK_NO,
|
CN_S_END_BIT = endMachLoc,
|
};
|
string json = JsonConvert.SerializeObject(bit);
|
|
new SqlHelper<object>().ExecuteSql($"update dbo.tn_am_task_mst set CN_S_END_BIE='{endMachLoc}',CN_S_END_AGVBIT = '{StockInstance.Instance.GetAGVCodeForBitCode(endMachLoc)}' where CN_S_TASK_NO = '{mst.CN_S_TASK_NO}'");
|
result = true;
|
}
|
}
|
else
|
{
|
CMMLog.Info("上料平台设备未配置");
|
}
|
CMMLog.Info($"OutWareTask result:{result}");
|
return result;
|
}
|
|
public class endBitModel
|
{
|
public string CN_S_TASK_NO { get; set; }
|
public string CN_S_END_BIT { get; set; }
|
}
|
|
/// <summary>
|
/// 成品出库任务中间表
|
/// </summary>
|
public class OutWareTable
|
{
|
public ObjectId _id { get; set; }
|
public string itemCode { get; set; }
|
public string batchNo { get; set; }
|
}
|
|
public class location
|
{
|
public ObjectId _id { get; set; }
|
public string S_LOC_CODE { get; set; }
|
//public string S_ITEM_CODE { get; set; }
|
//public string S_BATCH_NO { get; set; }
|
public string S_LOC_STATE { get; set; } = "无";
|
public int N_CURRENT_NUM { get; set; }
|
public string S_TRAY_CODE { get; set; }
|
}
|
|
/// <summary>
|
/// 电梯任务
|
/// </summary>
|
public class elevatorTask
|
{
|
public ObjectId _id { get; set; }
|
/// <summary>
|
/// 电梯点位
|
/// </summary>
|
public string S_DT_LOC { get; set; }
|
/// <summary>
|
/// 任务终点
|
/// </summary>
|
public string S_END_LOC { get; set; }
|
/// <summary>
|
/// 终点楼层
|
/// </summary>
|
public int S_END_FLOOR { get; set; }
|
/// <summary>
|
/// 任务类型
|
/// </summary>
|
public string S_TASK_TYPE { get; set; }
|
/// <summary>
|
/// 取货完成 0-未完成 1-已完成
|
/// </summary>
|
public string S_USE { get; set; }
|
public TN_I_TASK_MST task_mst {get;set;}
|
public WMSInfo wmsInfo { get; set; }
|
/// <summary>
|
/// 任务创建时间
|
/// </summary>
|
public DateTime time { get; set; }
|
}
|
|
/// <summary>
|
/// 取消任务处理
|
/// </summary>
|
/// <param name="mst"></param>
|
public static void TaskCancel(TN_I_TASK_MST mst)
|
{
|
CMMLog.Info($"进入取消任务流程！任务类型：{mst.CN_S_BUSS_TYPE}");
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料")
|
{
|
CMMLog.Info($"任务类型：{mst.CN_S_BUSS_TYPE},任务操作：查询<MachineInfo>表中已当前起点为包装机号的数据machineNo，不为空，删除！任务号：{mst.CN_S_TASK_NO},任务起点：{mst.CN_S_START_BIT},任务终点：{mst.CN_S_END_BIT}");
|
var tray = MongoDBSingleton.Instance.FindOne<MachineInfo>(Query.EQ("machineNo", mst.CN_S_START_BIT), "MachineInfo");
|
if(tray != null)
|
{
|
MongoDBSingleton.Instance.Remove<MachineInfo>(Query.EQ("machineNo", mst.CN_S_START_BIT), RemoveFlags.Single);
|
if (ERPService.ERPSwitch01 == "0") MongoDBSingleton.Instance.Remove<MachineInfoTwo>(Query.EQ("machineNo", mst.CN_S_START_BIT), "MachineInfoTwo", RemoveFlags.Single);
|
}
|
}
|
if (mst.CN_S_BUSS_TYPE == "3楼缓存架入叠托")
|
{
|
var plc = Settings.GetPlcInfo().Where(a => a.deviceType == "3").FirstOrDefault();
|
if (plc != null)
|
{
|
var machine = MongoDBSingleton.Instance.FindOne<WMSInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), "WMSInfo");
|
if (machine != null)
|
{
|
#region 写多个MODBUS数据
|
int[] num = DiePan(machine);
|
|
CMMLog.Info($"send num:");
|
CMMLog.Info(JsonConvert.SerializeObject(num));
|
var wirteall01 = OITcpHelper.RegisterWriteOutPutMulti(new OITcpHelper.RegisterWriteOutPutModelMulti
|
{
|
addr = plc.writeAddr + 10,
|
host = plc.ip,
|
port = plc.port,
|
data = num
|
});
|
#endregion
|
MongoDBSingleton.Instance.Remove<WMSInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), RemoveFlags.Single);
|
}
|
}
|
}
|
MongoDBSingleton.Instance.Remove<Mongo_AGV_TASK_STATE>(Query.EQ("TaskNo", mst.CN_S_TASK_NO), RemoveFlags.None);
|
CMMLog.Info($"取消任务流程结束！");
|
}
|
/// <summary>
|
/// 强制完成任务处理
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="action"></param>
|
public static void ForceComplete(TN_I_TASK_MST mst, TN_I_TASK_DTL_ACTION action)
|
{
|
CMMLog.Info($"强制完成任务处理：收到2信号之后特殊任务类型处理：任务号：{mst.CN_S_TASK_NO},任务类型：{mst.CN_S_BUSS_TYPE}");
|
if(mst.CN_S_BUSS_TYPE == "3楼包装取料")
|
{
|
MongoDBSingleton.Instance.Remove<MachineInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), RemoveFlags.Single);
|
if (ERPService.ERPSwitch01 == "0") MongoDBSingleton.Instance.Remove<MachineInfoTwo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), "MachineInfoTwo", RemoveFlags.Single);
|
}
|
}
|
/// <summary>
|
/// 电梯取消删除任务
|
/// </summary>
|
/// <param name="mst"></param>
|
/// <param name="action"></param>
|
public static void ForceCancel(TN_I_TASK_MST mst, TN_I_TASK_DTL_ACTION action)
|
{
|
CMMLog.Info($"取消任务处理：收到2信号之后特殊任务类型处理：任务号：{mst.CN_S_TASK_NO},任务类型：{mst.CN_S_BUSS_TYPE}");
|
if (mst.CN_S_BUSS_TYPE == "3楼包装取料")
|
{
|
MongoDBSingleton.Instance.Remove<MachineInfo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), RemoveFlags.Single);
|
if (ERPService.ERPSwitch01 == "0") MongoDBSingleton.Instance.Remove<MachineInfoTwo>(Query.EQ("trayCode", mst.CN_S_BATCH_NO), "MachineInfoTwo", RemoveFlags.Single);
|
}
|
}
|
#endregion
|
|
#region 充电任务
|
public static string battery = Settings.BatteryTime;
|
internal static void AGVBatteryTime()
|
{
|
CMMLog.Info("进入充电任务流程判断：执行开始！");
|
var now = DateTime.Today;
|
string date = now.Year.ToString() + "-" + now.Month.ToString() + "-" + now.Day.ToString() + " " + battery;
|
DateTime dt = Convert.ToDateTime(date);
|
//十分钟以内判断当前充电桩是否有小车在充电，没有则推送当前充电桩电量最低的一辆小车去充电，并写入充电桩状态
|
CMMLog.Info("进入充电任务流程:获取配置文件时间，并判断当前时间减去配置文件时间是否在20分钟以内！");
|
if (DateTime.Now.Subtract(dt).TotalMinutes <= 20 && DateTime.Now.Subtract(dt).TotalMinutes > 0)
|
{
|
//先判断中间表是否有当前充电桩的状态，有则不操作，反之进入小车电量查询
|
CMMLog.Info("进入充电任务流程:当前时间满足生成充电任务基本要求，开始判断ChargingPile配置项中当前充电桩状态是否开启");//ChargingPile
|
var list = Settings.GetChargingPile().Where(a => a.enable == "1").ToList();
|
if (list.Count > 0)
|
{
|
//CMMLog.Info("04");
|
list.ForEach(a => {
|
//CMMLog.Info("05");
|
var margin = MongoDBSingleton.Instance.FindOne<MarginAGV>(Query.EQ("marginGroup", int.Parse(a.charginGroup)), "MarginAGV");
|
int agvBattery = 1000, agvNo = 0, marginGroup = 0;
|
if (margin == null)
|
{
|
CMMLog.Info($"进入充电任务流程：判断当前充电桩分组{a.charginGroup}能否在ChargingPile配置项中查找到且enable为开启状态！");
|
var list2 = Settings.GetChargingPile().Where(b => b.charginGroup == a.charginGroup && b.enable == "1").ToList();
|
list2.ForEach(b =>
|
{
|
CMMLog.Info($"进入充电任务流程：判断当前车号能否在<HangChaAGV>小车车身状态表中查询到数据，车号agvNo:{b.agvNo}");
|
var battery = MongoDBSingleton.Instance.FindOne<HangChaAGV>(Query.EQ("agvNo", b.agvNo), "HangChaAGV");
|
if(battery != null)
|
{
|
if (int.Parse(battery.agvBattery) < agvBattery)
|
{
|
//CMMLog.Info($"进入充电任务流程：06 ");
|
agvBattery = int.Parse(battery.agvBattery);
|
agvNo = int.Parse(b.agvNo);
|
marginGroup = int.Parse(b.charginGroup);
|
}
|
}
|
else CMMLog.Info($"进入充电任务流程：error:当前车号在HangChaAgv中间表中查询不到数据！车号：{b.agvNo},所属充电桩：{b.charginGroup}");
|
});
|
//推送小车前往指定充电桩，并插入中间表状态
|
var agv = MongoDBSingleton.Instance.FindOne<MarginAGV>(Query.And(Query.EQ("agvNo", agvNo),Query.EQ("marginGroup", marginGroup)), "MarginAGV");
|
if(agv == null && agvNo != 0)
|
{
|
TSHelper.SendChargeTask(agvNo.ToString(), true);
|
//增加时间
|
MongoDBSingleton.Instance.Insert<MarginAGV>(new MarginAGV { agvNo = agvNo, marginGroup = marginGroup ,dateTime = DateTime.Now});
|
}
|
}
|
});
|
}
|
}
|
else
|
{
|
CMMLog.Info("进入充电任务流程：超过十分钟，删除中间表");
|
//超过十分钟，删除中间表
|
MongoDBSingleton.Instance.ReomveAll<MarginAGV>();
|
}
|
CMMLog.Info("进入充电任务流程判断：执行结束！");
|
}
|
#endregion
|
|
/// <summary>
|
/// 获取杭叉AGV<HangChaAGV>表里小车电量，并将其写入MODBUS中
|
/// </summary>
|
public static int[] GetBatteryHang()
|
{
|
int[] num = new int[5];
|
var bits = Settings.GetChargingAgvNo();
|
CMMLog.Info($"获取小车车号信息：{JsonConvert.SerializeObject(bits)}");//6723
|
for (int i = 0; i < num.Length; i++)
|
{
|
var battery = MongoDBSingleton.Instance.FindOne<HangChaAGV>(Query.EQ("agvNo", bits[i]), "HangChaAGV");
|
num[i] = battery == null ? 0 : int.Parse(battery.agvBattery);
|
}
|
CMMLog.Info($"获取小车电量：{JsonConvert.SerializeObject(num)}");
|
return num;
|
}
|
|
/// <summary>
|
/// WMS叠盘机任务中存储信息
|
/// </summary>
|
public class WMSInfo
|
{
|
public ObjectId _id { get; set; }
|
/// <summary>
|
/// 产品型号 11 60
|
/// </summary>
|
public string itemCode { get; set; }
|
/// <summary>
|
/// 批次号 30 30
|
/// </summary>
|
public string itemPCode { get; set; }
|
/// <summary>
|
/// 设备通道数据3——托盘码
|
/// </summary>
|
public string trayCode { get; set; }
|
/// <summary>
|
/// 设备通道数据1——包装机号
|
/// </summary>
|
public string location { get; set; }
|
/// <summary>
|
/// 设备通道数据2——产品需求重量：32位整数
|
/// </summary>
|
public string productWeight { get; set; }
|
/// <summary>
|
/// 设备通道数据2——托盘重量：32位整数
|
/// </summary>
|
public string trayCodeWeight { get; set; }
|
/// <summary>
|
/// 设备通道数据2——单托实际重量：32位整数
|
/// </summary>
|
public string oneTrayWeight { get; set; }
|
/// <summary>
|
/// 是否叠底托（1-不叠底托，2-叠底托）
|
/// </summary>
|
public string palletLayers { get; set; }
|
/// <summary>
|
/// 设备通道数据1——是否需要叠包：1：叠包，2：不叠包
|
/// </summary>
|
public int addState { get; set; }
|
/// <summary>
|
/// 设备通道数据1——袋号(001,002,003…999)
|
/// </summary>
|
public string packageCode { get; set; }
|
public DateTime dateTime { get; set; }
|
public string TaskNo { get; set; }
|
}
|
/// <summary>
|
/// 充电任务中间表
|
/// </summary>
|
public class MarginAGV
|
{
|
public ObjectId id { get; set; }
|
public int agvNo { get; set; }
|
public int marginGroup { get; set; }
|
public DateTime dateTime { get; set; }
|
}
|
/// <summary>
|
/// 去除字符串中NULL字符串
|
/// </summary>
|
internal static string RemoveNull(string str)
|
{
|
CMMLog.Info($"remove:{str}");
|
string result = "";
|
string empty = null;
|
for(int i = 0; i <= str.Length-1; i++)
|
{
|
if(str.Substring(i,1) != empty && str.Substring(i, 1) != "" && str.Substring(i, 1) != " " && str.Substring(i,1) != "\0")
|
{
|
//CMMLog.Debug($"str.substring:{i},{str.Substring(i, 1)}");
|
result = result + str.Substring(i, 1);
|
}
|
else
|
{
|
return result;
|
}
|
}
|
return result;
|
}
|
|
/// <summary>
|
/// 获取时间戳
|
/// </summary>
|
/// <param name="DataBitType">数据位数：值：32|64 含义：32位|64位</param>
|
/// <param name="TimeType">获取时间类型：值：1|2 含义：1-秒级 2-毫秒级</param>
|
/// <param name="TimeUtcType">获取时间Utc类型：值：1|2 含义：1-本地时间 2-Utc时间</param>
|
/// <returns></returns>
|
public static string GetTimeStamp(int DataBitType, int TimeType, int TimeUtcType)
|
{
|
string timeStamp = "";
|
|
//时间戳打印
|
DateTime dateTime = TimeUtcType == 1 ? DateTime.Now : DateTime.UtcNow;//本地时间|Utc时间获取
|
TimeSpan ts = dateTime - new DateTime(1970, 1, 1, 0, 0, 0, 0);//时间戳获取
|
double tsTime = TimeType == 1 ? ts.TotalSeconds : ts.TotalMilliseconds;//秒级|毫秒级时间获取
|
|
string TimeTypeInfo = TimeType == 1 ? "秒级" : "毫秒级";
|
string TimeUtcTypeInfo = TimeUtcType == 1 ? "本地时间" : "Utc时间";
|
timeStamp = DataBitType == 32 ? Convert.ToInt32(tsTime).ToString() : Convert.ToInt64(tsTime).ToString();
|
|
//Console.WriteLine($"时间戳打印：{DataBitType}位，{TimeTypeInfo}，{TimeUtcTypeInfo}，时间戳：{timeStamp}");
|
|
return timeStamp;
|
}
|
|
public static int GetWeekOfMonth(DateTime daytime)
|
{
|
int dayInMonth = daytime.Day;
|
//本月第一天
|
DateTime firstDay = daytime.AddDays(1 - daytime.Day);
|
//本月第一天是周几
|
int weekday = (int)firstDay.DayOfWeek == 0 ? 7 : (int)firstDay.DayOfWeek;
|
//本月第一周有几天
|
int firstWeekEndDay = 7 - (weekday - 1);
|
//当前日期和第一周之差
|
int diffday = dayInMonth - firstWeekEndDay;
|
|
diffday = diffday > 0 ? diffday : 1;
|
//当前是第几周,如果整除7就减一天
|
int WeekNumInMonth = ((diffday % 7) == 0 ? (diffday / 7 - 1) : (diffday / 7)) + 1 + (dayInMonth > firstWeekEndDay ? 1 : 0);
|
|
return WeekNumInMonth;
|
}
|
|
internal static void createDTTask()
|
{
|
var ele = MongoDBSingleton.Instance.FindOne<elevatorTask>(Query.EQ("S_USE", "0"),"elevatorTask");
|
if(ele != null)
|
{
|
CMMLog.Info("提升机在指定楼层，并且是开门状态，生成二段任务");
|
string taskType = getTaskType(ele.S_TASK_TYPE, true) + "-ELETwo";
|
HHAmsExecuteResult req = AMSHelper.CreateTask(DateTime.Now.Ticks.ToString(), ele.S_DT_LOC, ele.S_END_LOC, taskType, 0);
|
if (req.success)
|
{
|
CMMLog.Info($"【{taskType}】任务生成成功");
|
}
|
}
|
else
|
{
|
CMMLog.Info("电梯二段任务生成异常，中间表无数据");
|
}
|
|
}
|
}
|
}
|
