Files
6098/Cowain.Bake.Main/Station/UnLoadingStation.cs

773 lines
35 KiB
C#
Raw Normal View History

using Cowain.Bake.BLL;
using Cowain.Bake.Common;
using Cowain.Bake.Common.Core;
using Cowain.Bake.Common.Enums;
using Cowain.Bake.Common.Interface;
using Cowain.Bake.Common.Models;
using Cowain.Bake.Communication.Interface;
using Cowain.Bake.Communication.MOM;
using Cowain.Bake.Main.ViewModels;
using Cowain.Bake.Main.Views;
using Cowain.Bake.Model;
using Cowain.Bake.Model.Entity;
using Cowain.Bake.Model.Models;
using Cowain.Bake.UI.CsvMap;
using HslCommunication;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using Unity;
using static Cowain.Bake.Common.Models.MESModel;
using JSON = Newtonsoft.Json.JsonConvert;
namespace Cowain.Bake.Main.Station
{
public class UnLoadingStation : IServerManager
{
IPLCDevice PLC { get; set; }
const int DUMMY_POS_SIZE = 3;
private int _batteryCodeLen = 0;
List<IScanCodeBase> _deviceScann = new List<IScanCodeBase>();
List<TBatteryInfo> _tempList = new List<TBatteryInfo>();
public string Name { get; set; }
public IUnityContainer _unityContainer { get; set; }
private readonly Prism.Events.IEventAggregator _eventAggregator;
public UnLoadingStation(IUnityContainer unityContainer, Prism.Events.IEventAggregator eventAggregator)
{
_unityContainer = unityContainer;
_eventAggregator = eventAggregator;
TDeviceConfig config = _unityContainer.Resolve<DeviceConfigService>().GetConfig(EDeviceType.PLC, EDeviceName.Loading)[0]; //上下料一个PLC
Name = config.Name;
SetBatteryCodeLen();
Start();
}
bool IsConnectPLC()
{
if (null == PLC || !PLC.IsConnect)
{
LogHelper.Instance.Error($"PalletVirtualId:{PLC.Name},PLC为空!");
return false;
}
return true;
}
public void Start()
{
var configScann = _unityContainer.Resolve<DeviceConfigService>().GetConfig(EDeviceType.SCANNER).OrderByDescending(x => x.Id).Take(8).ToList();
foreach (var item in configScann)
{
IScanCodeBase device = _unityContainer.Resolve<IScanCodeBase>(item.Name);
_deviceScann.Add(device);
}
PLC = _unityContainer.Resolve<IPLCDevice>(Name); //下料PLC
System.Threading.Tasks.Task.Run(() => BuildRecordFile());
}
void BuildRecordFile()
{
string dateFile = "";
string filePath = "";
string path = _unityContainer.Resolve<SysSetupService>().GetValueByParaID(ESysSetup.DataFilePath.ToString());//
path += "\\出站";
while (true)
{
Thread.Sleep(1000 * 60);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
dateFile = DateTime.Now.ToString("yyyyMMdd");
filePath = path + $"\\{dateFile}.csv";
var batteryList = _unityContainer.Resolve<BatteryInfoService>().GetOutbound();
if (null == batteryList)
{
continue;
}
try
{
CSVHelper.WriteMap<BatteryInfoEntity, BatteryInfoDetailMap>(batteryList, filePath);
foreach (var item in batteryList)
{
if (0 == _unityContainer.Resolve<BatteryInfoService>().UpdateStatus(item.Id, (int)EBatteryStatus.OutBoundRecord))
{
LogHelper.Instance.Fatal("修改记录出站状态失败!");
}
}
}
catch (Exception ex)
{
LogHelper.Instance.Fatal($"BuildRecordFile{ex.Message}");
}
}
}
void SetDummyToWaterPlatform(string param)
{
int number = int.Parse(param);
int palletId = _unityContainer.Resolve<CavityInfoService>().GetPalletId((int)EStationType.UnLoading, number);
_unityContainer.Resolve<BLL.BatteryInfoService>().SetDummyToWaterPlatform(palletId);
}
//开始下料 ,,验证数据库OK (分二次执行,一次取假电芯,一次取正常电芯)
public void ExecuteUnLoading(int curValue, string param, Variable node)
{
//Int16 batteryType = 1; //1:假电芯, 0:正常电芯
dynamic d = JsonConvert.DeserializeObject<dynamic>(node.Json);
if (!IsConnectPLC()) return;
try
{
if (GetUnloadBattery(param, node.Json, out bool isUnLodingDummy, out TPalletInfo palletInfo))
{
_unityContainer.Resolve<LogService>().AddLog("ExecuteUnLoading:下料写入托盘电池信息!", E_LogType.Info.ToString());
WriteBatteryPostionToPLC(palletInfo, node.Json, isUnLodingDummy);
}
else
{
//SetEmptyPallet(node.Json); //如果上料中写了下料电芯数据,此时再重启上位机,状态为“下料中”,会清除,所以注释
}
var writeResult = PLC.Write<Int16>((string)d.WriteResult, 1);
if (!writeResult.IsSuccess)
{
LogHelper.Instance.Error($"ExecuteScanPallet-写数据失败:{(string)d.WriteResult}:{writeResult.Message}");
}
}
catch (Exception ex)
{
LogHelper.Instance.Error($"ExecuteUnLoading出错,{ex.Message},param{param},{node.Json}");
}
_unityContainer.Resolve<BasicInfoViewModel>().SetEvent("结束:" + node.VarDesc);
}
/// <summary>
/// 结果数据上传到MOM烘烤开始时间烘烤结束时间烘烤温度真空值,出炉冷却后温度
/// </summary>BakingOutputCmd,MESReturnCmdModel
/// <param name="batterys"></param>
/// <param name="palletInfo"></param>
public MESReturnCmdModel MesOutUnBinding(TPalletInfo palletInfo, List<TBatteryInfo> betterys, bool realTimeSend = false)
{
if (0 == palletInfo.BakingPosition.Value)
{
palletInfo.BakingPosition = 1; //防呆
LogHelper.Instance.Error("手动触发烘烤完成,没有烘烤位置!");
}
TCavityInfo cavityInfo = _unityContainer.Resolve<CavityInfoService>().GetStationDetailById(palletInfo.BakingPosition.Value);
if (null == cavityInfo)
{
LogHelper.Instance.GetCurrentClassError("通过烘烤位置查找托盘位置失败");
return null;
}
return _unityContainer.Resolve<MESProcess>().MESBakingOutput(cavityInfo.Name, palletInfo, betterys, true, realTimeSend);
}
//请求下料,出现异常处理
TPalletInfo DealStartUnloadFail(int number)
{
//去机器人上获取夹具信息,此时没有转移。
TPalletInfo palletInfo = _unityContainer.Resolve<BLL.PalletInfoService>().GetRobotPallet();
if (null != palletInfo)
{
LogHelper.Instance.Error("请求下料的夹具在机器人上面!");
return palletInfo;
}
//如果还没有,再到下料获取。
int palletId = _unityContainer.Resolve<CavityInfoService>().GetPalletId((int)EStationType.UnLoading, number);
return _unityContainer.Resolve<BLL.PalletInfoService>().GetPalletInfo(palletId);
}
private bool GetUnloadBattery(string param, string reply, out bool isUnLodingDummy, out TPalletInfo palletInfo)
{
isUnLodingDummy = false;
dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
OperateResult operateResultX = null, operateResultY = null;
OperateResult operateResult = null;
List<TBatteryInfo> batterys = null;
TBatteryInfo dummy;
Int16 batteryType = 1; //1:假电芯, 0:正常电芯
int number = int.Parse(param);
Int16[] dummyPos = new Int16[DUMMY_POS_SIZE];
int[] batteryVirtualId = new int[Global.PALLET_MAX_BATTERYS];
Array.Clear(batteryVirtualId, 0, Global.PALLET_MAX_BATTERYS);
int palletId = _unityContainer.Resolve<CavityInfoService>().GetPalletId((int)EStationType.UnLoading, number);
palletInfo = _unityContainer.Resolve<BLL.PalletInfoService>().GetPalletInfo(palletId);
//要求PLC必须在上位机反馈任务完成之后再请求托盘参数
if (null == palletInfo) //会出现异常(发触发下料,再告诉上位机放)
{
palletInfo = DealStartUnloadFail(number);
if (null == palletInfo) //
{
LogHelper.Instance.Error($"接收到下料信号,但获取不到下料工站{param}的夹具信息!", true);
return false;
}
}
batterys = _unityContainer.Resolve<BLL.BatteryInfoService>().GetBatteryInfos(palletInfo.VirtualId);
if (0 == batterys.Count)
{
_unityContainer.Resolve<LogService>().AddLog($"下料工站{param},找不到电池位置数据!", E_LogType.Info.ToString());
return false;
}
//要满足下料条件
if (palletInfo.PalletStatus != (int)EPalletStatus.BakeOver
&& palletInfo.PalletStatus != (int)EPalletStatus.TestOK)
{
LogHelper.Instance.Fatal($"下料夹具状态不对,请人为处理,要求状态:{EPalletStatus.BakeOver.GetDescription()},{EPalletStatus.TestOK.GetDescription()},实际状态:" +
$"{((EPalletStatus)palletInfo.PalletStatus).GetDescription()}");
return false;
}
if (palletInfo.PalletStatus == (int)EPalletStatus.BakeOver
&& _unityContainer.Resolve<BLL.BatteryInfoService>().IsPalletDummy(palletInfo.VirtualId)) //带水含量电芯,要测试
{
dummy = _unityContainer.Resolve<BLL.BatteryInfoService>().FindDummy(palletInfo, batterys);
isUnLodingDummy = true;
if (null == dummy)
{
LogHelper.Instance.Fatal("获取假电芯信息失败!");
return false;
}
dummyPos[1] = (Int16)dummy.PositionX.Value;
dummyPos[2] = (Int16)dummy.PositionY.Value;
operateResultX = PLC.Write<Int16>((string)d.WriteDummyX, dummyPos[1]); //托盘假电池行列数
operateResultY = PLC.Write<Int16>((string)d.WriteDummyY, dummyPos[2]); //托盘假电池行列数
if (!operateResultX.IsSuccess
|| !operateResultY.IsSuccess)
{
LogHelper.Instance.Debug($"设置托盘假电池行列数失败:{operateResultX.Message},{operateResultY.Message}");
return false;
}
}
else
{
batteryType = 0; //正常电芯
_unityContainer.Resolve<BLL.PalletInfoService>().UpdateUnLoadingBegingTime(palletInfo.Id);
List<TBatteryInfo> normalBatterys = (from b in batterys
where b.BatteryStatus <= (int)EBatteryStatus.ToPallet
select b).ToList();
if (Global.PALLET_ROWS < Global.PALLET_COLS) //7行24列:行少列多
{
foreach (var item in normalBatterys)
{
batteryVirtualId[(item.PositionX.Value - 1) * Global.PALLET_COLS + item.PositionY.Value] = item.Id;
}
}
else//48行,2列: 行少列多
{
foreach (var item in normalBatterys)
{
batteryVirtualId[(item.PositionY.Value - 1) * Global.PALLET_ROWS + item.PositionX.Value] = item.Id;
}
}
LogHelper.Instance.Info("下料写入电芯位置:" + JSON.SerializeObject(batteryVirtualId));
}
//水含量电芯时全为0
operateResult = PLC.Write<int[]>((string)d.WriteVirtualIds, batteryVirtualId); //托盘_有无电池[1-120]
if (!operateResult.IsSuccess)
{
LogHelper.Instance.Error($"设置托盘_有无电池失败:{operateResult.Message}");
}
//电芯类型
operateResult = PLC.Write<Int16>((string)d.WriteType, batteryType); //托盘1正常电芯下料
if (!operateResult.IsSuccess)
{
LogHelper.Instance.Error($"写下料电芯类型失败:{(string)d.WriteType},{operateResult.Message}");
return false;
}
return true;
}
//写下料位置的电池位置信息给PLC
private void WriteBatteryPostionToPLC(TPalletInfo palletInfo, string reply, bool isUnLodingDummy)
{
Int16 lastValue = 0;
dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
OperateResult operateResult = null;
////水含量电芯时全为0
//operateResult = PLC.Write<int[]>((string)d.WriteVirtualIds, batteryVirtualId); //托盘_有无电池[1-120]
//if (!operateResult.IsSuccess)
//{
// LogHelper.Instance.Error($"设置托盘_有无电池失败:{operateResult.Message}");
//}
if (!isUnLodingDummy)
{
lastValue = (Int16)(palletInfo.LastFlag ? 1 : 0);
}
operateResult = PLC.Write<Int16>((string)d.WriteLastFlag, lastValue); //最后一盘
if (!operateResult.IsSuccess)
{
LogHelper.Instance.Error($"设置托盘最后一盘失败:{operateResult.Message},{operateResult.Message}");
}
//在给下料参数成功之后,再更新托盘状态。
if (0 == _unityContainer.Resolve<BLL.PalletInfoService>().UpdatePalletStatus(palletInfo.Id, (int)EPalletStatus.Blank))
{
LogHelper.Instance.Error($"在给下料参数成功之后,再更新托盘状态:{operateResult.Message},{operateResult.Message}");
}
}
public void SetEmptyPallet(string reply)
{
_unityContainer.Resolve<LogService>().AddLog("SetEmptyPallet:设置空托盘", E_LogType.Info.ToString());
dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
List<AddrValue> makeAddrValues = new List<AddrValue>();
int[] batteryVirtualId = new int[Global.PALLET_MAX_BATTERYS];
Array.Clear(batteryVirtualId, 0, Global.PALLET_MAX_BATTERYS);
makeAddrValues.Add(new AddrValue()
{
Addr = (string)d.WriteDummyX,
Value = (Int16)0
});
makeAddrValues.Add(new AddrValue()
{
Addr = (string)d.WriteDummyY,
Value = (Int16)0
});
makeAddrValues.Add(new AddrValue()
{
Addr = (string)d.WriteType,
Value = (Int16)0
});
makeAddrValues.Add(new AddrValue()
{
Addr = (string)d.WriteVirtualIds,
Value = batteryVirtualId
});
makeAddrValues.Add(new AddrValue()
{
Addr = (string)d.WriteResult,
Value = true
});
OperateResult result = PLC.Writes(makeAddrValues.Select(x => x.Addr).ToArray(), makeAddrValues.Select(x => x.Value).ToArray());
if (!result.IsSuccess)
{
LogHelper.Instance.GetCurrentClassError("清空托盘失败!");
}
}
public void ExecuteUnLoadingFinish(int curValue, string param, Variable node)
{
dynamic d = JsonConvert.DeserializeObject<dynamic>(node.Json);
//-----------------------------------------------------------------------------
int debugMode = int.Parse(_unityContainer.Resolve<SysSetupService>().GetValueByParaID(ESysSetup.DebugMode.ToString())); //0为测试模式1为正式模式
if (!IsConnectPLC()) return;
//得到这个工站的夹具,通过夹具得到电芯
int number = int.Parse(param);
int palletId = _unityContainer.Resolve<BLL.CavityInfoService>().GetPalletId((int)EStationType.UnLoading, number);
TPalletInfo palletInfo = _unityContainer.Resolve<BLL.PalletInfoService>().GetPalletInfo(palletId);
if (null == palletInfo)
{
LogHelper.Instance.Error($"托盘为空, 下料{number}#工站,palletId:{palletId}");
return;
}
_unityContainer.Resolve<BLL.PalletInfoService>().UpdateUnLoadingOverTime(palletInfo.Id);
if (0 == palletInfo.VirtualId
|| 1 == palletInfo.Id)
{
LogHelper.Instance.Error($"下料夹具异常, 下料托盘的虚拟码为0或下料托盘为【新夹具】");
}
else
{
_unityContainer.Resolve<BLL.PalletInfoService>().PalletInfoToHistory(palletInfo.VirtualId,
(int)EPalletStatus.BlankOver, (int)EBatteryStatus.Over, (int)EStationType.UnLoading, number);
}
var writeResult = PLC.Write<Int16>((string)d.WriteResult, 1);
if (!writeResult.IsSuccess)
{
LogHelper.Instance.Warn($"ExecuteUnLoadingFinish-{(string)d.WriteResult}:{writeResult.Message}");
}
_unityContainer.Resolve<BasicInfoViewModel>().SetEvent("结束:" + node.VarDesc);
}
/// <summary>
/// 核对电芯条码,下料扫码
/// </summary>
//void VerifyBatteryCode(int curValue, string param, string reply)
//{
// dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
// var result = DealVerify(reply);
// var writeResult = PLC.Write<bool[]>((string)d.WriteResult, result.Result);//
// if (!writeResult.IsSuccess)
// {
// LogHelper.Instance.GetCurrentClassWarn($"{(string)d.WriteResult}:{writeResult.Message}");
// }
//}
//async Task<bool[]> DealVerify(string reply)
//{
// int index = 0, j = 0;
// bool[] results = new bool[Global.ONCE_SCAN_BATTERY];
// Array.Clear(results, 0, Global.ONCE_SCAN_BATTERY);
// List<Task<OperateResult<string>>> scannTasks = new List<Task<OperateResult<string>>>();
// dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
// if (!IsConnectPLC()) return results;
// OperateResult<Int32[]> batterys = PLC.Read<Int32[]>((string)d.ReadVirtualIds); //下料处电芯虚拟码 读取下料温度[1..8]
// if (!batterys.IsSuccess)
// {
// LogHelper.Instance.Warn($"核对电芯条码时,读取电芯虚拟码错误:{batterys.Message}");
// return results;
// }
// if (batterys.Content.All(x => x == 0)) //True 全部为0
// {
// LogHelper.Instance.Warn($"核对电芯条码时读取电芯虚拟码异常全部虚拟码都为0");
// return results;
// }
// //读条码
// for (EScanCode s = EScanCode.UnLoadingBatteryScan1; s <= EScanCode.UnLoadingBatteryScan8; s++, index++)
// {
// if (0 == batterys.Content[index])
// {
// continue;
// }
// IScanCodeBase scanDevice = _deviceScann.Find(x => x.Name == s.ToString());
// if (!scanDevice.IsConnect)
// {
// string msg = $"获取{s.GetDescription()}失败,请检测线路!";
// LogHelper.Instance.Error(msg, true); //弹屏,人为处理好后,再次触发
// _unityContainer.Resolve<MainWindowViewModel>().AddPromptContent(msg);
// scanDevice.Connect();
// --s; //再次获取
// continue;
// }
// scannTasks.Add(Task.Run(() => scanDevice.ReadCode())); // 启动并行任务
// }
// await Task.WhenAll(scannTasks); //等待所有任务(扫码)完成
// index = 0;
// var batteryCodes = GetBatteryCode(batterys.Content);//获取PLC传过来的虚拟码
// //比较条码
// for (EScanCode s = EScanCode.UnLoadingBatteryScan1; s <= EScanCode.UnLoadingBatteryScan8; s++, j++)
// {
// if (0 == batterys.Content[index])
// {
// continue;
// }
// if (!batteryCodes.Contains(scannTasks[index++].Result.Content)) //没有用等于号,是因为这样兼容更好一点
// {
// LogHelper.Instance.Warn($"下料核对电芯异常PLC电芯:{string.Join(",", batteryCodes)},扫码电芯:{JSON.SerializeObject(scannTasks)}");
// //continue; //异常
// }
// else
// {
// results[j] = true;
// }
// }
// _unityContainer.Resolve<MainWindowViewModel>().DeletePromptContent();
// return results;
//}
//取假电芯完成验证数据库OK
public void ExecuteTakeDummyFinish(int curValue, string param, Variable node)
{
dynamic d = JsonConvert.DeserializeObject<dynamic>(node.Json);
if (!IsConnectPLC()) return;
_unityContainer.Resolve<LogService>().AddLog("UnLoadingStation:ExecuteTakeDummyFinish:取假电池开始:" + param, E_LogType.Info.ToString());
int number = int.Parse(param);
int palletId = _unityContainer.Resolve<BLL.CavityInfoService>().GetPalletId((int)EStationType.UnLoading, number);
TPalletInfo palletInfo = _unityContainer.Resolve<BLL.PalletInfoService>().GetPalletInfo(palletId);
if (null == palletInfo)
{
LogHelper.Instance.Error($"接收下料{number}工站取假电芯完成信号,但获取不到下料夹具!", true);
return;
}
//这里再改假电芯状态
SetDummyToWaterPlatform(param);
//重启后可能再次收到1#托盘取假电池完成信号待水含量测试此时状态可能测试OK或NG
if (palletInfo.PalletStatus == (int)EPalletStatus.BakeOver
|| palletInfo.PalletStatus == (int)EPalletStatus.Blank) //取水含量电芯时,也是下料中状态
{
_unityContainer.Resolve<BLL.PalletInfoService>().UpdatePalletStatus(palletInfo.Id, (int)EPalletStatus.WaitTest);
}
var writeResult = PLC.Write<Int16>((string)d.WriteResult, 1);
if (!writeResult.IsSuccess)
{
LogHelper.Instance.Warn($"ExecuteTakeDummyFinish-{(string)d.WriteResult}:{writeResult.Message}");
}
_unityContainer.Resolve<BasicInfoViewModel>().SetEvent("结束:" + node.VarDesc);
}
public void SetBatteryCodeLen()
{
_batteryCodeLen = int.Parse(_unityContainer.Resolve<Cowain.Bake.BLL.SysSetupService>().GetValueByParaID(ESysSetup.BatteryCodeLen.ToString()));
}
public async Task<List<OperateResult<string>>> GetScannResult(int curValue)
{
int index = 1;
List<string> batteryCodes = new List<string>();
List<OperateResult<string>> scannList = new List<OperateResult<string>>();
List<Task<OperateResult<string>>> scannTasks = new List<Task<OperateResult<string>>>();
OperateResult<string> scanResult = new OperateResult<string>()
{
IsSuccess = false,
};
for (EScanCode s = EScanCode.UnLoadingBatteryScan1; s <= EScanCode.UnLoadingBatteryScan8; s++, index++)
{
if (((curValue >> index) & 1) != 1) //第index位不是1,就是不需要扫码
{
continue;
}
IScanCodeBase scanDevice = _deviceScann.Find(x => x.Name == s.ToString());
if (!scanDevice.IsConnect)
{
string msg = $"获取{s.GetDescription()}失败,请检测线路!";
LogHelper.Instance.Error(msg, true); //弹屏,人为处理好后,再次触发
_unityContainer.Resolve<MainWindowViewModel>().AddPromptContent(msg);
scanDevice.Connect();
--s; //再次获取
continue;
}
scannTasks.Add(Task.Run(() => scanDevice.ReadCode())); // 启动并行任务
}
await Task.WhenAll(scannTasks); //等待所有任务(扫码)完成
foreach (var task in scannTasks)
{
scannList.Add(task.Result);
}
return scannList;
}
public async Task<bool[]> DealTemp(IPLCDevice plc, int curValue, string reply)
{
string msg = "";
int index = 1;
int scannIndex = 0;
bool[] repResults = new bool[Global.ONCE_SCAN_BATTERY + 1];
dynamic d = JsonConvert.DeserializeObject<dynamic>(reply);
List<string> batteryCodes = null;
List<OperateResult<string>> scannList;
MESReturnCmdModel result = null;
bool isDummy = false;
Array.Clear(repResults, 0, Global.ONCE_SCAN_BATTERY + 1);
int debugMode = int.Parse(_unityContainer.Resolve<SysSetupService>().GetValueByParaID(ESysSetup.DebugMode.ToString())); //0为测试模式1为正式模式
_tempList.Clear();
try
{
if (!IsConnectPLC()) return null;
OperateResult<float[]> readTemps = plc.Read<float[]>((string)d.ReadTemp); //下料处电芯温度,读取下料温度[1..4]
if (!readTemps.IsSuccess)
{
LogHelper.Instance.Warn("读取下料温度失败");
return null;
}
if ((int)EProductionMode.Debug == debugMode) //调试模式
{
repResults[1] = true;
return repResults;
}
scannList = await GetScannResult(curValue); //
for (EScanCode s = EScanCode.UnLoadingBatteryScan1; s <= EScanCode.UnLoadingBatteryScan8; s++, index++)
{
if (((curValue >> index) & 1) != 1) //第index位不是1,就是不需要扫码
{
continue;
}
repResults[index] = true;
if (scannList[scannIndex].IsSuccess)
{
_tempList.Add(new TBatteryInfo()
{
BatteryCode = scannList[scannIndex].Content, //实际要扫码
CoolTemp = readTemps.Content[index] //1...8排序
});
}
else
{
if (MessageBoxResult.Yes == HandyControl.Controls.MessageBox.Show($"[{s.GetDescription()}]扫码失败,您确定此位置是否有电芯?", "提示", MessageBoxButton.YesNo, MessageBoxImage.Information))
{
_tempList.Add(new TBatteryInfo()
{
BatteryCode = GetBatteryCode(s.GetDescription()), //弹屏,输入电芯条码
CoolTemp = readTemps.Content[index] //1...8排序
});
}
else //无电芯
{
repResults[index] = false; //扫码NG并人为确认无电芯
}
}
scannIndex++;
}
batteryCodes = _tempList.Select(x => x.BatteryCode).ToList();
LogHelper.Instance.Info($"读取下料PLC的电芯虚拟码:{string.Join(",", batteryCodes)}");
List<TBatteryInfo> currentBatterys = _unityContainer.Resolve<BatteryInfoService>().GetBatterys(batteryCodes); //8个电芯(最多),可能会来自多个托盘
if (null == currentBatterys
|| currentBatterys.Count == 0) //PLC有BUG有时为0导致上位机没办法回复会PLC超时
{
msg = $"下发温度读取失败,{Global.ONCE_SCAN_BATTERY}个电池虚拟码为0!";
LogHelper.Instance.Error("下发温度读取完成失败,电池虚拟码为0!");
_unityContainer.Resolve<LogService>().AddLog("下发温度读取完成失败,电池虚拟码为0!", E_LogType.Fatal.ToString());
_unityContainer.Resolve<MainWindowViewModel>().AddPromptContent(msg);
return repResults;
}
else if (currentBatterys.Count == 1) //一个电芯,判断是否是假电芯
{
if (_unityContainer.Resolve<BatteryInfoService>().IsDummy(currentBatterys[0].Id))
{
isDummy = true;
return repResults; //假电芯就不上传了
}
}
_unityContainer.Resolve<BatteryInfoService>().UpdateCoolTempAndUnBindingTime(currentBatterys, _tempList);// temps);
if (int.Parse(_unityContainer.Resolve<SysSetupService>().GetValueByParaID(ESysSetup.MOMEnable.ToString())) == (int)EMOMEnable.Enable)
{
var batterySort = currentBatterys.GroupBy(p => new { p.PalletVirtualId }).Select(s => s.FirstOrDefault()).ToList(); //获取一个托盘中的一个电芯
foreach (var item in batterySort) //一个托盘只返回第一个电芯
{
var palletBatterys = currentBatterys.Where(x => batteryCodes.Contains(x.BatteryCode) && x.PalletVirtualId == item.PalletVirtualId).ToList(); //获取一个托盘中的电芯
TPalletInfo palletInfo = _unityContainer.Resolve<BLL.PalletInfoService>().GetPalletInfoByBatteryVirtualId(item.PalletVirtualId); //此时托盘可能已经转历史盘托了
if (null == palletInfo)
{
msg = $"MOM上传冷却温度时,找不到电芯所在托盘,电芯:{string.Join(",", palletBatterys.Select(x => x.BatteryCode).ToList())}!";
LogHelper.Instance.Fatal(msg);
_unityContainer.Resolve<MainWindowViewModel>().AddPromptContent(msg);
return null;
}
var mesResult = MesOutUnBinding(palletInfo, palletBatterys);//组装数据 发送
//因为没有等MOM所以注掉下面代码
//if (mesResult == null)
//{
// LogHelper.Instance.Error($"自动出站MOM返回超时,电芯条码:{string.Join(",", palletBatterys.Select(x => x.BatteryCode).ToList())}"); //偶尔会返回空,导致人为要处理,麻烦,所以只保存到日志
//}
//else if (mesResult.Info.ResultFlag.ToUpper() == "NG" && (!isDummy))
//{
// msg = $"自动出站MOM返回信息异常,信息:{JSON.SerializeObject(result)}";
// LogHelper.Instance.Error(msg);
// _unityContainer.Resolve<MainWindowViewModel>().AddPromptContent(msg);
//}
//else
//{
// _unityContainer.Resolve<MainWindowViewModel>().DeletePromptContent();
//}
}
}
}
catch (Exception e)
{
LogHelper.Instance.Fatal($"读温失败:{e.Message},{e.StackTrace}");
}
return repResults;
}
public string GetBatteryCode(string desc)
{
string batteryCode = "";
while (string.IsNullOrEmpty(batteryCode))
{
Application.Current.Dispatcher.Invoke((Action)(() =>
{
PalletIdInputWindow f = new PalletIdInputWindow("电芯码输入框", $"{desc}扫码失败," + "请输入电芯条码", "确定输入电芯条码?")
{
WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen,
};
f.ShowDialog();
batteryCode = f.PalletId;
}));
if (!_unityContainer.Resolve<BatteryInfoService>().IsBatteryCodeRepeat(batteryCode))
{
LogHelper.Instance.Error($"【{batteryCode}】,不存在,请重新输入!", true);
batteryCode = "";
}
}
return batteryCode;
}
//获取下料温度
public async Task GetTemp(int curValue, string param, Variable node)
{
OperateResult operateResult = null;
dynamic d = JsonConvert.DeserializeObject<dynamic>(node.Json);
IPLCDevice plc = _unityContainer.Resolve<IPLCDevice>((string)d.PLCName); //上料PLC
var result = await DealTemp(plc, curValue, node.Json);
if (result == null)
{
return;
}
operateResult = plc.Write<bool[]>((string)d.WriteResult, result); //MOM没有返回数据导致
if (!operateResult.IsSuccess)
{
LogHelper.Instance.Error("下发温度读取完成失败!");
return;
}
_unityContainer.Resolve<BasicInfoViewModel>().SetEvent("结束:" + node.VarDesc);
}
public void Stop()
{
}
}
}