/// <summary>
/// 发送小车任务，行：1.打标 2.坡口短缓存架 3.坡口长缓存架 4.坡口短缓存架 5.坡口机 6.组队输送架
/// </summary>
/// <param name="car"></param>
/// <param name="plc"></param>
/// <param name="task"></param>
/// <returns></returns>
public BllResult SendTaskToCar(Equipment car, CarTask task, IPLC plc)
{
try
{
List <EquipmentProp> propsToWriter = new List <EquipmentProp>();
var props = car.EquipmentProps;
var wcsConfirmTaskFinish = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsConfirmTaskFinish.ToString());
wcsConfirmTaskFinish.Value = "0";
var wcsActionType = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsActionType.ToString());
wcsActionType.Value = task.Type.ToString();
var wcsStartRow = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsStartRow.ToString());
wcsStartRow.Value = task.FromLocation.ToString();
var wcsDestinationRow = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsDestinationRow.ToString());
wcsDestinationRow.Value = task.ToLocation.ToString();
var wcsTaskHeaderId = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsTaskHeaderId.ToString());
wcsTaskHeaderId.Value = task.StepTraceId.ToString();
var wcsTaskCarId = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsTaskCarId.ToString());
wcsTaskCarId.Value = task.Id.ToString();
var wcsSwitch = props.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsSwitch.ToString());
wcsSwitch.Value = "1";
propsToWriter.AddRange(new List <EquipmentProp>()
{
wcsConfirmTaskFinish, wcsStartRow, wcsDestinationRow, wcsTaskHeaderId, wcsTaskCarId, wcsActionType, wcsSwitch
});
//return S7Helper.PlcSplitWrite(plc, propsToWriter, 20);
return(plc.Writes(propsToWriter));
}
catch (Exception ex)
{
return(BllResultFactory.Error(ex.Message));
}
}
public frmCarsTasksEdit(int?_nCarTaskID, bool _isCopy)
{
isCopy = _isCopy;
nUserID = ((RFMFormMain)Application.OpenForms[0]).UserInfo.UserID;
if (_nCarTaskID.HasValue)
{
nCarTaskID = (int)_nCarTaskID;
}
oCarTask = new CarTask();
if (oCarTask.ErrorNumber != 0)
{
IsValid = false;
}
if (IsValid)
{
oPartner = new Partner();
oZone = new Zone();
oCarTaskUnit = new CarTaskUnit();
if (oPartner.ErrorNumber != 0 || oZone.ErrorNumber != 0 || oCarTaskUnit.ErrorNumber != 0)
{
IsValid = false;
}
}
if (IsValid)
{
InitializeComponent();
}
}
public BllResult SendCleanTaskToCar(Equipment car, CarTask task, IPLC plc)
{
try
{
List <EquipmentProp> propsToWriter = new List <EquipmentProp>();
var props = car.EquipmentProps;
var action = props.Find(t => t.EquipmentTypeTemplateCode == "wcsActionType");
action.Value = "0";
var taskRow = props.Find(t => t.EquipmentTypeTemplateCode == "wcsTaskRow");
taskRow.Value = "0";
//var taskLine = props.Find(t => t.EquipmentTypeTemplateCode == "wcsTaskLine");
//taskLine.Value = "0";
//var taskLayer = props.Find(t => t.EquipmentTypeTemplateCode == "wcsTaskLayer");
//taskLayer.Value = "0";
var taskHeader = props.Find(t => t.EquipmentTypeTemplateCode == "wcsTaskHeaderId");
taskHeader.Value = "0";
var taskCar = props.Find(t => t.EquipmentTypeTemplateCode == "wcsTaskCarId");
taskCar.Value = "0";
var switchEnable = props.Find(t => t.EquipmentTypeTemplateCode == "wcsSwitch");
switchEnable.Value = "0";
var hasPallet = props.Find(t => t.EquipmentTypeTemplateCode == "hasPallet");
hasPallet.Value = "1";
propsToWriter.AddRange(new List <EquipmentProp>()
{
action, taskRow, taskHeader, taskCar, switchEnable, hasPallet
});
//return S7Helper.PlcSplitWrite(plc, propsToWriter, 20);
return(plc.Writes(propsToWriter));
}
catch (Exception ex)
{
return(BllResultFactory.Error(ex.Message));
}
}
/// <summary>
/// 处理翻转请求
/// </summary>
/// <param name="bevel"></param>
/// <param name="allEquipments"></param>
/// <param name="stepTraceList"></param>
/// <param name="plc"></param>
/// <returns></returns>
public override BllResult ExcuteFlip(Equipment bevel, List <Equipment> allEquipments, List <StepTrace> stepTraceList, IPLC plc)
{
try
{
var Step_Trace_Id = bevel.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestTaskId.ToString());
var convertResult = int.TryParse(Step_Trace_Id.Value, out int stepTraceId);
if (!convertResult)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，工序任务的id[{Step_Trace_Id.Value}]转化为整数失败！", LogLevel.Error);
return(BllResultFactory.Error());
}
if (stepTraceId == 0)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，工序跟踪ID为0", LogLevel.Error);
return(BllResultFactory.Error());
}
var stepTrace = stepTraceList.FirstOrDefault(t => t.Id == Convert.ToInt32(Step_Trace_Id.Value));
if (stepTrace == null)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，找不到未完成的工序任务id[{Step_Trace_Id.Value}]", LogLevel.Error);
return(BllResultFactory.Error());
}
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 0;
taskCar.Type = CarTaskType.取货和放货.GetIndexInt();
taskCar.FromLocation = bevel.SelfAddress.ToString();
taskCar.ToLocation = bevel.GoAddress.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Init.GetIndexInt();
//taskCar.IsFlip = Convert.ToInt32(Allow_Flip);
var updateResult = AppSession.Dal.InsertCommonModel <CarTask>(taskCar);
if (updateResult.Success)
{
return(SendFlipToPlc(bevel, true, plc));
}
}
catch (Exception ex)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号时候，发生异常：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
return(BllResultFactory.Sucess());
}
public frmCarsTasks()
{
oCarTaskList = new CarTask();
oCarTaskCur = new CarTask();
if (oCarTaskList.ErrorNumber != 0 || oCarTaskCur.ErrorNumber != 0)
{
IsValid = false;
}
oCarTaskTemp = new CarTask();
if (oCarTaskTemp.ErrorNumber != 0)
{
IsValid = false;
}
if (IsValid)
{
InitializeComponent();
}
}
/// <summary>
/// 执行下料请求
/// 注意：allEquipments引用所有设备，此为共享应用
/// </summary>
/// <param name="cutter"></param>
/// <param name="allEquipments"></param>
/// <param name="plc"></param>
/// <returns></returns>
public override BllResult ExcuteRequest(Equipment cutter, List <Equipment> allEquipments, List <StepTrace> stepTraceList, IPLC plc)
{
try
{
var RequestTaskId = cutter.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestTaskId.ToString());
var convertResult = int.TryParse(RequestTaskId.Value, out int stepTraceId);
if (!convertResult)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求失败，工序任务的id[{RequestTaskId.Value}]转化为整数失败！", LogLevel.Error);
return(BllResultFactory.Error());
}
if (stepTraceId > 0)
{
var stepTrace = stepTraceList.FirstOrDefault(t => t.Id == stepTraceId);
if (stepTrace != null)
{
if (stepTrace.Status == StepTraceStatus.设备开始生产.GetIndexInt() || stepTrace.Status == StepTraceStatus.设备请求下料.GetIndexInt())
{
////当前工序
Step step;
//下个工序
Step nextStep;
//所有的下个站台
List <StepStation> stepStations;
//下个站台对应的设备
Equipment nextEquipment = null;
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
connection.Open();
// NextStepId为0，表示没有下到工序id，就需要去工序表查询下道工序
if (stepTrace.NextStepId == 0)
{
step = connection.Get <Step>(stepTrace.StepId);
nextStep = connection.QueryFirstOrDefault <Step>($"select top 1 * from step where and sequence > {step.Sequence} order by sequence");
//更新下个工序
stepTrace.NextStepId = nextStep.Id.Value;
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
connection.Update <StepTrace>(stepTrace);
return(BllResultFactory.Error());
}
else
{
nextStep = connection.Get <Step>(stepTrace.NextStepId);
}
if (nextStep == null)
{
Logger.Log($"桁车处理站台【{stepTrace.StationId}】下料请求时候，数据错误：不存在产品[{stepTrace.ProductCode}]对应的下个工序！", LogLevel.Error);
return(BllResultFactory.Error());
}
stepStations = connection.Query <StepStation>($"select * from step_station where stepId = '{nextStep.Id}'").ToList();
}
if (stepStations.Count < 1)
{
Logger.Log($"桁车处理站台【{stepTrace.StationId}】下料请求时候，数据错误：不存在工序[{nextStep.Id}][{nextStep.Code}]对应的站台！", LogLevel.Error);
return(BllResultFactory.Error());
}
//找到工序对应的所有站台
var stationList = cutter.StationList.Where(t => stepStations.Exists(x => x.StationId == t.Id)).ToList();
// 排除已经被预定的站台
stationList.RemoveAll(t => stepTraceList.Exists(x => x.NextStationId == t.Id));
if (stationList.Count() == 0)
{
return(BllResultFactory.Error());
}
// 根据站台找到所有对应的设备
var tempEquipments = allEquipments.Where(t => stationList.Exists(x => x.Id == t.StationId)).ToList();
if (tempEquipments.Count() == 0)
{
return(BllResultFactory.Error());
}
foreach (var item in tempEquipments)
{
//如果站台请求上料，才可以用
var ArriveResult = item.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == MachineProps.ArriveResult.ToString());
if (ArriveResult?.Value == MachineMessageFlag.自动请求上料.GetIndexString())
{
//增加任务判断
var countResult = AppSession.Dal.GetCommonModelCount <StepTrace>($"where status >{StepTraceStatus.设备开始生产.GetIndexInt()} and status < {StepTraceStatus.任务完成.GetIndexInt()} and nextStationId = {item.StationId}");
if (countResult.Success && countResult.Data < 1)
{
nextEquipment = item;
break;
}
}
}
if (nextEquipment != null && nextEquipment.StationId != 0)
{
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
//taskCar.StepTraceId = Convert.ToInt32(Step_Trace_Id);
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 0;
taskCar.Type = CarTaskType.取货和放货.GetIndexInt();
taskCar.FromLocation = cutter.SelfAddress.ToString();
taskCar.ToLocation = cutter.GoAddress.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Executing.GetIndexInt();
//taskCar.IsFlip = Convert.ToInt32(Allow_Flip);
//修改工序监控
stepTrace.NextStepId = nextStep.Id.Value;
stepTrace.NextStationId = nextEquipment.StationId;
stepTrace.Status = StepTraceStatus.等待任务执行.GetIndexInt();
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
connection.Insert <CarTask>(taskCar, transaction: tran);
connection.Update <StepTrace>(stepTrace, transaction: tran);
var sendResult = SendRequestToPlc(plc, cutter, true);
if (sendResult.Success)
{
tran.Commit();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求 成功，任务:{stepTrace.Id}", LogLevel.Success);
return(BllResultFactory.Sucess());
}
else
{
tran?.Rollback();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求的时候，写入PLC失败，任务:{stepTrace.Id}，原因：{sendResult.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求的时候，发生异常，任务:{stepTrace.Id}，原因：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
}
}
return(BllResultFactory.Sucess());
}
//if (stepTrace.Status > StepTraceStatus.设备请求下料.GetIndexInt())
//{
// var WCS_Step_Trace_Id = cutter.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.WCSReplyTaskId.ToString());
// WCS_Step_Trace_Id.Value = "0";
// BllResult plcResult = plc.Write(WCS_Step_Trace_Id);
// if (plcResult.Success)
// {
// Logger.Log($"清除工位[{cutter.StationId}]设备[{cutter.Name}]的任务号{stepTrace.Id}成功", LogLevel.Success);
// return BllResultFactory.Sucess();
// }
// else
// {
// Logger.Log($"清除工位[{cutter.StationId}]设备[{cutter.Name}]的任务号{stepTrace.Id}失败，写入PLC失败：{plcResult.Msg}", LogLevel.Error);
// return BllResultFactory.Error();
// }
//}
}
else
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求失败，找不到未完成的工序任务id[{RequestTaskId.Value}]", LogLevel.Error);
return(BllResultFactory.Error());
}
}
else
{
// 如果不存在 已经处理过的任务，但是还在请求下线，说明是手动上的，或是id丢了
if (!stepTraceList.Exists(t => t.StationId == cutter.StationId && t.Status >= StepTraceStatus.设备请求下料.GetIndexInt()))
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求失败，工序跟踪ID为0", LogLevel.Error);
return(BllResultFactory.Error());
}
}
}
catch (Exception ex)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求时候，发生异常：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
return(BllResultFactory.Sucess());
}
private BllResult ExcuteRequest(Equipment bevelCcache, Equipment bevel, StepTrace stepTrace, IPLC plc)
{
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 1;
taskCar.Type = CarTaskType.取货和放货.GetIndexInt();
taskCar.FromLocation = bevelCcache.Station.TrussTakeStationId.ToString();
taskCar.ToLocation = bevel.Station.TrussPutStationId.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Init.GetIndexInt();
//taskCar.IsFlip = CarTaskType.取货和放货.GetIndexInt();
taskCar.CreateTime = DateTime.Now;
taskCar.EndTime = DateTime.Now;
taskCar.StartTime = DateTime.Now;
taskCar.UpdateTime = DateTime.Now;
//修改工序跟踪
stepTrace.NextStationId = bevel.StationId;
stepTrace.Status = StepTraceStatus.等待任务执行.GetIndexInt();
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
stepTrace.CreateTime = DateTime.Now;
stepTrace.LineInTime = DateTime.Now; //
stepTrace.LineOutTime = DateTime.Now; //
stepTrace.StationInTime = DateTime.Now;
stepTrace.StationOutTime = DateTime.Now;
var requestNumber = bevelCcache.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == PipeLineProps.RequestNumber.ToString());
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
connection.Insert <CarTask>(taskCar, transaction: tran);
connection.Update <StepTrace>(stepTrace, transaction: tran);
var sendResult = SendAddressReplyToPlc(bevelCcache, plc, StationMessageFlag.地址回复, StationLoadStatus.默认, requestNumber.Value, stepTrace.Id.ToString(), "", stepTrace.WcsProductType.ToString(), stepTrace.PipeLength.ToString(), stepTrace.PipeDiameter.ToString(), stepTrace.PipeThickness.ToString(), bevelCcache.GoAddress);
if (sendResult.Success)
{
tran.Commit();
Logger.Log($"处理工位[{bevelCcache.StationCode}]的设备[{bevelCcache.Name}] 地址请求 成功，任务:{stepTrace.Id}", LogLevel.Success);
return(BllResultFactory.Sucess());
}
else
{
tran?.Rollback();
Logger.Log($"处理工位[{bevelCcache.StationCode}]的设备[{bevelCcache.Name}] 地址请求的时候，写入PLC失败，任务:{stepTrace.Id}，原因：{sendResult.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"处理工位[{bevelCcache.StationCode}]的设备[{bevelCcache.Name}] 地址请求的时候，发生异常，任务:{stepTrace.Id}，原因：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
}
}
/// <summary>
/// 执行下料请求
/// 注意：allEquipments引用所有设备，此为共享应用
/// </summary>
/// <param name="bevel"></param>
/// <param name="allEquipments"></param>
/// <param name="plc"></param>
/// <returns></returns>
public override BllResult ExcuteRequest(Equipment bevel, List <Equipment> allEquipments, List <StepTrace> stepTraceList, IPLC plc)
{
try
{
var Step_Trace_Id = bevel.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestTaskId.ToString());
var convertResult = int.TryParse(Step_Trace_Id.Value, out int stepTraceId);
if (!convertResult)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求失败，工序任务的id[{Step_Trace_Id.Value}]转化为整数失败！", LogLevel.Error);
return(BllResultFactory.Error());
}
if (stepTraceId == 0)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求失败，工序跟踪ID为0", LogLevel.Error);
return(BllResultFactory.Error());
}
var stepTrace = stepTraceList.FirstOrDefault(t => t.Id == Convert.ToInt32(Step_Trace_Id.Value));
if (stepTrace == null)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求失败，找不到未完成的工序任务id[{Step_Trace_Id.Value}]", LogLevel.Error);
return(BllResultFactory.Error());
}
if (stepTrace.Status == StepTraceStatus.设备开始生产.GetIndexInt())
{
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
connection.Open();
// NextStepId为0，表示没有下到工序id，就需要去工序表查询下道工序
if (stepTrace.NextStepId == 0)
{
var step = connection.Get <Step>(stepTrace.StepId);
var nextStep = connection.QueryFirstOrDefault <Step>($"select top 1 * from step where and sequence > {step.Sequence} order by sequence");
//更新下个工序
stepTrace.NextStepId = nextStep.Id.Value;
stepTrace.Status = StepTraceStatus.设备请求下料.GetIndexInt();
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
connection.Update <StepTrace>(stepTrace);
return(BllResultFactory.Error());
}
}
}
if (stepTrace.Status == StepTraceStatus.设备请求下料.GetIndexInt())
{
var nextEquipment = allEquipments.FirstOrDefault(t => t.SelfAddress == bevel.GoAddress.ToString());
//判断是否有上料请求 响应下料
if (nextEquipment == null)
{
Logger.Log($"工位[{bevel.StationCode}]的设备[{bevel.Name}] 响应地址请求失败，原因：组队缓存位没有设置对应的下个设备", LogLevel.Error);
return(BllResultFactory.Error());
}
//组队区输送线没货才能去
var HasGoods = nextEquipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == PipeLineProps.HasGoods.ToString());
if (HasGoods.Value != PipeLineGoods.无货.GetIndexString())
{
return(BllResultFactory.Error());
}
//如果已经有了去下个设备的任务，那么就不能去，需要等待
if (stepTraceList.Exists(t => t.NextStationId == nextEquipment.StationId))
{
return(BllResultFactory.Error());
}
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
//taskCar.StepTraceId = Convert.ToInt32(Step_Trace_Id);
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 0;
taskCar.Type = CarTaskType.取货和放货.GetIndexInt();
taskCar.FromLocation = bevel.SelfAddress.ToString();
taskCar.ToLocation = bevel.GoAddress.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Executing.GetIndexInt();
//修改工序监控
stepTrace.NextStationId = nextEquipment.StationId;
stepTrace.Status = StepTraceStatus.等待任务执行.GetIndexInt();
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
var requestNumber = bevel.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == PipeLineProps.RequestNumber.ToString());
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
connection.Insert <CarTask>(taskCar, transaction: tran);
connection.Update <StepTrace>(stepTrace, transaction: tran);
var sendResult = SendAddressReplyToPlc(bevel, plc, MachineMessageFlag.回复允许下料, requestNumber.Value, stepTrace.Id.ToString(), "", "0", stepTrace.WcsProductType.ToString(), stepTrace.PipeLength.ToString(), stepTrace.PipeDiameter.ToString(), stepTrace.PipeThickness.ToString(), bevel.GoAddress);
if (sendResult.Success)
{
tran.Commit();
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求 成功，任务:{stepTrace.Id}", LogLevel.Success);
return(BllResultFactory.Sucess());
}
else
{
tran?.Rollback();
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求的时候，写入PLC失败，任务:{stepTrace.Id}，原因：{sendResult.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 下料请求的时候，发生异常，任务:{stepTrace.Id}，原因：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
}
}
}
catch (Exception ex)
{
Logger.Log($"处理设备【{bevel.Name}】下料请求时候，发生异常：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
return(BllResultFactory.Sucess());
}
private void frmCarsTasksEdit_Load(object sender, EventArgs e)
{
bool bResult = true;
oCarTask.ID = nCarTaskID;
// классификаторы
bResult = cboPartner_Restore() &&
cboZone_Restore() &&
cboCarTaskUnit_Restore();
if (bResult)
{
if (nCarTaskID.HasValue && (int)nCarTaskID != 0)
{
// существующее или копируемое задание
bResult = oCarTask.ReFillOne((int)nCarTaskID) && (oCarTask.ErrorNumber == 0);
if (bResult)
{
#region Поля, заполняемые одинаково в режимах редактирования и копирования
cboPartner.SelectedValue = oCarTask.PartnerID;
txtDeliveryAddress.Text = oCarTask.DeliveryAddress;
if (oCarTask.ZoneID.HasValue)
{
cboZone.SelectedValue = oCarTask.ZoneID;
}
else
{
cboZone.SelectedValue = -1;
}
if (oCarTask.Longitude.HasValue)
{
txtLongitude.Text = oCarTask.Longitude.ToString();
}
if (oCarTask.Latitude.HasValue)
{
txtLatitude.Text = oCarTask.Latitude.ToString();
}
numDistance.Value = oCarTask.Distance;
#endregion
#region Поля, заполняемые по-разному в режимах редактирования и копирования
if (isCopy)
{
// пересоздаем задание (очищаем данные)
oCarTask = new CarTask();
Text += " (копирование с " + nCarTaskID.ToString() + ")";
dtpDateTask.Value = DateTime.Today.AddDays(1);
cboUnit.SelectedValue = -1;
}
else
{
Text += " (" + nCarTaskID.ToString() + ")";
dtpDateTask.Value = oCarTask.DateTask;
if (oCarTask.CarTaskUnitID.HasValue)
{
cboUnit.SelectedValue = oCarTask.CarTaskUnitID;
}
else
{
cboUnit.SelectedValue = -1;
}
numNetto.Value = oCarTask.Netto;
numBrutto.Value = oCarTask.Brutto;
numPalletsQnt.Value = oCarTask.PalletsQnt;
numTaskInnerCost.Value = oCarTask.TaskInnerCost;
numTaskOuterCost.Value = oCarTask.TaskOuterCost;
numUnitsQnt.Value = oCarTask.UnitsQnt;
numPrice.Value = oCarTask.Price;
numTaskAmount.Value = oCarTask.TaskAmount;
txtNote.Text = oCarTask.Note;
}
#endregion
}
}
else
{
// новое задание
cboPartner.SelectedValue =
cboZone.SelectedValue =
cboUnit.SelectedValue =
-1;
dtpDateTask.Value = DateTime.Today.AddDays(1);
}
}
if (!bResult)
{
Dispose();
}
}
/// <summary>
/// 执行下料请求
/// 注意：allEquipments引用所有设备，此为共享应用
/// </summary>
/// <param name="cutter"></param>
/// <param name="allEquipments"></param>
/// <param name="plc"></param>
/// <returns></returns>
public override BllResult ExcuteRequest(Equipment cutter, List <Equipment> allEquipments, List <StepTrace> stepTraceList, IPLC plc)
{
try
{
var RequestTaskId = cutter.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestTaskId.ToString());
var convertResult = int.TryParse(RequestTaskId.Value, out int stepTraceId);
if (!convertResult)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求失败，工序任务的id[{RequestTaskId.Value}]转化为整数失败！", LogLevel.Error);
return(BllResultFactory.Error());
}
var stepTrace = stepTraceList.FirstOrDefault(t => t.Id == stepTraceId);
if (stepTrace == null)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求失败，找不到未完成的工序任务id[{RequestTaskId.Value}]", LogLevel.Error);
return(BllResultFactory.Error());
}
//下个站台对应的设备
Equipment nextEquipment = null;
var stepStationsResult = AppSession.Dal.GetCommonModelByCondition <StepStation>($" where stepId = {stepTrace.NextStepId}");
if (!stepStationsResult.Success)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求时候，数据错误：不存在工序[{stepTrace.NextStepId}]对应的站台！，原因：{stepStationsResult.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
//找到工序对应的所有站台
var stationList = cutter.StationList.Where(t => stepStationsResult.Data.Exists(x => x.StationId == t.Id)).ToList();
// 排除已经被预定的站台
stationList.RemoveAll(t => stepTraceList.Exists(x => x.NextStationId == t.Id));
if (stationList.Count() == 0)
{
return(BllResultFactory.Error());
}
// 根据站台找到所有对应的设备
var tempEquipments = allEquipments.Where(t => stationList.Exists(x => x.Id == t.StationId)).ToList();
// 缓存位不能放长度超过自己的管子
tempEquipments = tempEquipments.Where(t => t.ColumnIndex >= stepTrace.PipeLength).OrderBy(t => t.ColumnIndex).ToList();
//如果管子长度小于1800，就不能放到中间的坡口缓存位，因为间隙大，管子会掉下来
if (stepTrace.PipeLength < 1800)
{
tempEquipments.RemoveAll(t => t.Code == "BevelCache2");
}
if (tempEquipments.Count() == 0)
{
return(BllResultFactory.Error());
}
foreach (var item in tempEquipments)
{
var OperationModel = item.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == MachineProps.OperationModel.ToString());
var TotalError = item.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == MachineProps.TotalError.ToString());
if (OperationModel?.Value != OperationModelFlag.联机.GetIndexString() || TotalError?.Value != TotalErrorFlag.无故障.GetIndexString())
{
continue;
}
var ArriveMessage = item.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == MachineProps.ArriveMessage.ToString());
//如果站台请求上料 或者 输送线为空，才可以用
var HasGoods = item.EquipmentProps.FirstOrDefault(t => t.EquipmentTypeTemplateCode == PipeLineProps.HasGoods.ToString());
if (ArriveMessage?.Value == MachineMessageFlag.PLC自动请求上料.GetIndexString() || HasGoods?.Value == PipeLineGoods.无货.GetIndexString())
{
//增加任务判断
var countResult = AppSession.Dal.GetCommonModelCount <StepTrace>($"where status >{StepTraceStatus.设备开始生产.GetIndexInt()} and status < {StepTraceStatus.任务完成.GetIndexInt()} and nextStationId = {item.StationId}");
if (countResult.Success && countResult.Data < 1)
{
nextEquipment = item;
break;
}
}
}
if (nextEquipment != null && nextEquipment.StationId != 0)
{
var requestNumber = cutter.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestNumber.ToString());
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
//taskCar.StepTraceId = Convert.ToInt32(Step_Trace_Id);
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 1;
taskCar.Type = CarTaskType.取货和放货.GetIndexInt();
taskCar.FromLocation = cutter.Station.TrussTakeStationId.ToString();
taskCar.ToLocation = nextEquipment.Station.TrussPutStationId.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Init.GetIndexInt();
taskCar.StartTime = DateTime.Now;
taskCar.EndTime = DateTime.Now;
taskCar.CreateTime = DateTime.Now;
taskCar.UpdateTime = DateTime.Now;
//taskCar.IsFlip = Convert.ToInt32(Allow_Flip);
//修改工序监控
stepTrace.NextStationId = nextEquipment.StationId;
stepTrace.Status = StepTraceStatus.等待任务执行.GetIndexInt();
stepTrace.UpdateTime = DateTime.Now;
stepTrace.UpdateBy = App.User.UserCode;
using (IDbConnection connection = AppSession.Dal.GetConnection())
{
IDbTransaction tran = null;
try
{
connection.Open();
tran = connection.BeginTransaction();
connection.Insert <CarTask>(taskCar, transaction: tran);
connection.Update <StepTrace>(stepTrace, transaction: tran);
//connection.Execute($"delete from step_trace where id < {stepTrace.Id} and stationId = {cutter.StationId} and status = {StepTraceStatus.设备开始生产.GetIndexInt()}");
var sendResult = SendAddressReplyToPlc(cutter, plc, MachineMessageFlag.WCS回复允许下料, requestNumber.Value, stepTrace.Id.ToString(), "", "0", stepTrace.WcsProductType.ToString(), stepTrace.PipeLength.ToString(), stepTrace.PipeDiameter.ToString(), stepTrace.PipeThickness.ToString(), cutter.GoAddress);
if (sendResult.Success)
{
tran.Commit();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求 成功，任务:{stepTrace.Id}", LogLevel.Success);
return(BllResultFactory.Sucess());
}
else
{
tran?.Rollback();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求的时候，写入PLC失败，任务:{stepTrace.Id}，原因：{sendResult.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
}
catch (Exception ex)
{
tran?.Rollback();
Logger.Log($"处理工位[{cutter.StationCode}]的设备[{cutter.Name}] 下料请求的时候，发生异常，任务:{stepTrace.Id}，原因：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
}
}
return(BllResultFactory.Sucess());
}
catch (Exception ex)
{
Logger.Log($"处理工位[{cutter.StationId}]设备[{cutter.Name}]下料请求时候，发生异常：{ex.Message}", LogLevel.Exception, ex);
}
return(BllResultFactory.Error());
}
/// <summary>
/// 处理翻转请求
/// </summary>
/// <param name="bevel"></param>
/// <param name="allEquipments"></param>
/// <param name="stepTraceList"></param>
/// <param name="plc"></param>
/// <returns></returns>
public override BllResult ExcuteFlip(Equipment bevel, List <Equipment> allEquipments, List <StepTrace> stepTraceList, IPLC plc)
{
try
{
var RequestTaskId = bevel.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == MachineProps.RequestTaskId.ToString());
var convertResult = int.TryParse(RequestTaskId.Value, out int stepTraceId);
if (!convertResult)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，工序任务的id[{RequestTaskId.Value}]转化为整数失败！", LogLevel.Error);
return(BllResultFactory.Error());
}
if (stepTraceId == 0)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，工序跟踪ID为0", LogLevel.Error);
return(BllResultFactory.Error());
}
var stepTrace = stepTraceList.FirstOrDefault(t => t.Id == stepTraceId);
if (stepTrace == null)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号失败，找不到未完成的工序任务id[{stepTraceId}]", LogLevel.Error);
return(BllResultFactory.Error());
}
//就生成AGV任务并且插入数据库 小车任务的状态和类型需要重新定义？
CarTask taskCar = new CarTask();
taskCar.StepTraceId = stepTrace.Id;
taskCar.CarNo = 1;
taskCar.Type = CarTaskType.翻转.GetIndexInt();
taskCar.FromLocation = bevel.Station.TrussTakeStationId.ToString();
taskCar.ToLocation = bevel.Station.TrussTakeStationId.ToString();
taskCar.ReSend = 0;
taskCar.Status = TaskCarStatus.Init.GetIndexInt();
taskCar.CreateTime = DateTime.Now;
taskCar.EndTime = DateTime.Now;
taskCar.StartTime = DateTime.Now;
taskCar.UpdateTime = DateTime.Now;
//taskCar.IsFlip = Convert.ToInt32(Allow_Flip);
var updateResult = AppSession.Dal.InsertCommonModel <CarTask>(taskCar);
if (updateResult.Success)
{
var sendResult = SendFlipToPlc(bevel, plc, FlipFlag.WCS回复允许翻转);
if (sendResult.Success)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转请求成功，对应的任务[{stepTrace.Id}]信息写入设备", LogLevel.Success);
}
else
{
//PLC写入失败，就把数据改回来
AppSession.Dal.DeleteCommonModelByIds <CarTask>(new List <int>()
{
taskCar.Id.Value
});
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转请求失败，对应的任务[{stepTrace.Id}]信息写入PLC失败，原因：{sendResult.Msg}", LogLevel.Error);
}
return(sendResult);
}
}
catch (Exception ex)
{
Logger.Log($"处理工位[{bevel.StationCode}]的设备[{bevel.Name}] 翻转信号时候，发生异常：{ex.Message}", LogLevel.Exception, ex);
return(BllResultFactory.Error());
}
return(BllResultFactory.Sucess());
}
/// <summary>
/// 执行小车任务
/// </summary>
/// <param name="car"></param>
/// <param name="plc"></param>
/// <returns></returns>
public BllResult ExcuteTDR(Equipment car, IPLC plc)
{
//子任务号
int taskCarId = int.Parse(car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "TaskCarId").Value);
//主任务号
int taskheaderId = int.Parse(car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "TaskHeaderID").Value);
//小车任务类型
string actionType = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "actionType").Value;
//小车行
string row = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "row").Value;
////小车位置
//var position = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "position").Value;
//小车状态
string carStatus = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "carStatus").Value;
//小车错误状态
string carError = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "carError").Value;
//小车编码
int carNo = int.Parse(car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "carNo").Value);
//小车到达
string arriveMessage = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "arriveMessage").Value;
//输出穿梭板上是否有货
string hasPallet = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "hasPallet").Value;
//AGV控制模式
string controlMode = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == "controlMode").Value;
if (controlMode != CarControlMode.自动.GetIndexString() || carError != CarError.Normal.GetIndexString())
{
return(BllResultFactory.Error());
}
var TaskCarResult = AppSession.Dal.GetCommonModelByCondition <CarTask>($"where status < {TaskCarStatus.Executed.GetIndexInt()} and carNo={carNo}");
if (TaskCarResult.Success)
{
List <CarTask> tasks = TaskCarResult.Data.OrderBy(t => t.Id).ToList();
// 如果小车反馈完成，就修改任务状态为“完成”，然后回复小车确认完成
if (carStatus == CarStatus.Finish.GetIndexString())
{
CarTask carTask = tasks.FirstOrDefault(t => t.Id == taskCarId);
if (carTask != null)
{
//保存旧数据
var carTaskClone = (CarTask)carTask.DeepClone();
//修改状态和完成时间
carTask.EndTime = DateTime.Now;
carTask.Status = TaskCarStatus.Waiting.GetIndexInt();
if (AppSession.Dal.UpdateCommonModel <CarTask>(carTask).Success)
{
//确定过账任务完成
var sendResult = sendConfirmTaskFinish(car, plc);
if (sendResult.Success)
{
Logger.Log($"小车[car{carNo}]完成[{taskCarId}]号任务，ECS给PLC确认完成信号成功！", LogLevel.Warning);
}
else
{
AppSession.Dal.UpdateCommonModel <CarTask>(carTaskClone);
Logger.Log($"小车[car{carNo}]完成[{taskCarId}]号任务，但是ECS给PLC确认完成信号失败，原因：{sendResult.Msg}！", LogLevel.Warning);
}
}
return(BllResultFactory.Sucess());
}
else
{
Logger.Log($"小车[car{carNo}]任务已经完成ID为[{taskCarId}]的任务，但是该任务不存在！", LogLevel.Warning);
return(BllResultFactory.Error());
}
}
// 如果小车是执行中，就清除小车开启信号
if (carStatus == CarStatus.Executing.GetIndexString())
{
CarTask carTask = tasks.FirstOrDefault(t => t.Id == taskCarId);
if (carTask != null)
{
if (carTask.Status == TaskCarStatus.Init.GetIndexInt())
{
var sendResult = sendWcsSwitch(car, plc, "0");
if (sendResult.Success)
{
// 更新小车任务状态
carTask.Status = TaskCarStatus.Executing.GetIndexInt();
carTask.StartTime = DateTime.Now;
AppSession.Dal.UpdateCommonModel <CarTask>(carTask);
}
}
}
////小车到达一个地方后，如果需要ECS确认后才能走，就发出到达信号，然后等待ECS回复后，清除到达信号，最后ECS也清除回复信号
//var arrive = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == CarProps.arriveMessage.GetIndexString());
//var replyArrive = car.EquipmentProps.Find(t => t.EquipmentTypeTemplateCode == CarProps.wcsArriveMessage.GetIndexString());
//if (arrive?.Value == ArriveMessage.到达.GetIndexString() && replyArrive?.Value == ArriveMessage.默认.GetIndexString())
//{
// //回复到达
// ExcuteArrive(car, ArriveMessage.回复到达, plc);
//}
//if (arrive?.Value == ArriveMessage.默认.GetIndexString() && replyArrive?.Value == ArriveMessage.回复到达.GetIndexString())
//{
// ExcuteArrive(car, ArriveMessage.默认, plc);
//}
return(BllResultFactory.Sucess());
}
//如果小车是准备就绪，并且状态是WCS模式就可以运行
if (carStatus == CarStatus.idle.GetIndexString())
{
CarTask carTask = tasks.FirstOrDefault();
// 如果有初始化的任务，并且任务id不是刚完成的任务id
if (carTask != null && carTask.Status == TaskCarStatus.Init.GetIndexInt())
{
var result = SendTaskToCar(car, carTask, plc);
if (result.Success)
{
Logger.Log($"给小车[{car.Code}]下发ID为[{carTask.Id}]的[{((CarTaskType)carTask.Type).ToDescriptionString()}]任务成功！", LogLevel.Info);
return(BllResultFactory.Sucess());
}
else
{
Logger.Log($"给小车[{car.Code}]下发ID为[{carTask.Id}]的[{((CarTaskType)carTask.Type).ToDescriptionString()}]任务失败！原因：{result.Msg}", LogLevel.Error);
return(BllResultFactory.Error());
}
}
}
}
return(BllResultFactory.Sucess());
}
