using MathNet.Numerics.LinearAlgebra;
using Prism.Events;
using Prism.Ioc;
using Prism.Mvvm;
using Prism.Regions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Media;
using Team.FFFeederService.Interfaces;
using TeamAAS_VP.Core.PLCs;
using TeamAAS_VP.Core.ScrewDriver;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Events;
using TeamAAS_VP.Interfaces;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;
using TouchSocket.Core;
using TouchSocket.SerialPorts;
using TouchSocket.Sockets;
namespace TeamAAS_VP.Core
{
public class Management : BindableBase
{
#region 字段
IRegionManager _regionManager;
IEventAggregator _eventAggregator;
IContainerProvider _container;
IConfigService _configService;
IRobotService _robotService;
ICameraService _cameraService;
IFeederService _feederService;
IPlcService _plcService;
ILightManagerService _lightManagerService;
IProductService _productService;
ICalibrationService _calibrationService;
IRemoteCommandService _remoteCommandService;
ISystemDatabaseService _systemDatabaseService;
IMesService _mesService;
Timer yieldtimer;
private DateTime StartTime = DateTime.Now;
// Pressure collection
///
/// 压力采集信号控制CTS
///
private CancellationTokenSource[] _pressureCts = new CancellationTokenSource[10];
///
/// 压力采集超时CTS
///
private CancellationTokenSource[] _pressureTimeoutCts = new CancellationTokenSource[10];
///
/// 压力采集CTS
///
private CancellationTokenSource[] _pressureLinkedCts = new CancellationTokenSource[10];
///
/// 压力数据集合
///
private List<(DateTime Timestamp, float Value)>[] _pressureSamples = new List<(DateTime, float)>[10];
///
/// 采样间隔毫秒
///
private int _pressureSampleIntervalMs = 50; //采样间隔毫秒
///
/// 超时自动停止秒数
///
private int _pressureMaxDurationSeconds = 30; //超时自动停止秒数
DateTime StartCtqTime = DateTime.Now;//开始采集Ctq数据的时间
#endregion
#region 属性
private ObservableCollection _Renders;
///
/// 显示界面
///
public ObservableCollection Renders
{
get { return _Renders; }
set { SetProperty(ref _Renders, value); }
}
public BgCommunicate BgCommunicate { get; private set; }
public BgModbusTcpCommunicate BgModbusTcpCommunicate { get; private set; }
private ObservableCollection _Status = new ObservableCollection();
///
/// 状态栏集合
///
public ObservableCollection Status
{
get { return _Status; }
set { SetProperty(ref _Status, value); }
}
private Int64 _TotalQuantity;
///
/// 总产量
///
public Int64 TotalQuantity
{
get { return _TotalQuantity; }
set { SetProperty(ref _TotalQuantity, value); }
}
private Int64 _TotalQuantityToday;
///
/// 当天的总产量
///
public Int64 TotalQuantityToday
{
get { return _TotalQuantityToday; }
set { SetProperty(ref _TotalQuantityToday, value); }
}
private Int64 _CurrentUPH;
///
/// 当前的UPH
///
public Int64 CurrentUPH
{
get { return _CurrentUPH; }
set { SetProperty(ref _CurrentUPH, value); }
}
private SerialPortClient _Scan_Client;
public SerialPortClient Scan_Client
{
get { return _Scan_Client; }
set { _Scan_Client = value; }
}
private XYD_ScrewDriver _ScrewDriver;
public XYD_ScrewDriver ScrewDriver
{
get { return _ScrewDriver; }
set { SetProperty(ref _ScrewDriver, value); }
}
public Dictionary BackupObject { get; set; } = new Dictionary();
private double _CTtime;
///
/// ct
///
public double CTtime
{
get { return _CTtime; }
set { SetProperty(ref _CTtime, value); }
}
private ObservableCollection _dfc = new ObservableCollection();
///
/// CTQ数据集合
///
public ObservableCollection DFC
{
get { return _dfc; }
set { SetProperty(ref _dfc, value); }
}
private Int64 _ThrowNumber;
///
/// 抛料数
///
public Int64 ThrowNumber
{
get { return _ThrowNumber; }
set { SetProperty(ref _ThrowNumber, value); }
}
private Int64 _NgNumber;
///
/// ng数量
///
public Int64 NgNumber
{
get { return _NgNumber; }
set { SetProperty(ref _NgNumber, value); }
}
private double _Yield;
///
/// 良率
///
public double Yield
{
get { return _Yield; }
set { SetProperty(ref _Yield, value); }
}
private ObservableCollection _ProductList;
public ObservableCollection ProductList
{
get { return _ProductList; }
set { SetProperty(ref _ProductList, value); }
}
#endregion
#region 命令
#endregion
#region 事件
#endregion
public Management(IRegionManager regionManager, IEventAggregator ea, IContainerProvider container, IConfigService configService,
IRobotService robotService, ICameraService cameraService, IFeederService feederService, IPlcService plcService, IProductService productService,
ICalibrationService calibrationService, IRemoteCommandService remoteCommandService, ISystemDatabaseService systemDatabaseService, ILightManagerService lightManagerService,
IMesService mesService)
{
_regionManager = regionManager;
_eventAggregator = ea;
_container = container;
_configService = configService;
_robotService = robotService;
_cameraService = cameraService;
_feederService = feederService;
_plcService = plcService;
_calibrationService = calibrationService;
yieldtimer = new Timer(DoYieldTime, null, 10000, 1000);
Renders = new ObservableCollection();
_configService = configService;
_productService = productService;
_remoteCommandService = remoteCommandService;
_systemDatabaseService = systemDatabaseService;
_lightManagerService = lightManagerService;
_mesService = mesService;
InitPressure();
}
#region 初始化硬件模块
///
/// 初始化Feeder
///
///
public async Task<(bool IsSucceed, string Msg)> InitFeeders()
{
var feeders = _configService.GetAllFeeders();
StringBuilder sb = new StringBuilder();
foreach (var item in feeders)
{
_feederService.CreateFeeder(item.Id, item.FeederNo, item.FeederName, item.IP, item.Port, item.FeederBrand);
var feeder = _feederService.GetFeeder(item.Id);
Status.Add(new StatusInfo(item.Id, item.FeederName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
try
{
feeder.FeederConnectionStatusChanged += Management_FeederConnectionStatusChanged;
await feeder.ConnectAsync(); //连接Feeder
//SendTaskMessage($"{item.FeederName}已连接!", MessageLevel.Debug);
}
catch (Exception ex)
{
sb.AppendLine($"{item.FeederName}:{Lang.断开连接}![{ex.Message}]");
SendTaskMessage($"{item.FeederName}{Lang.断开连接}!", MessageLevel.Alarm);
}
}
if (sb.Length == 0)
{
return (true, "");
}
else
{
return (false, sb.ToString());
}
}
///
/// 初始化机器人
///
///
public async Task<(bool IsSucceed, string Msg)> InitRobots()
{
var robots = _configService.GetAllRobots();
StringBuilder sb = new StringBuilder();
foreach (var item in robots)
{
_robotService.CreateRobot(item.Id, item);
try
{
Status.Add(new StatusInfo(item.Id, item.RobotName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
var robot = _robotService.GetRobot(item.Id);
robot.ReceivedEvent += Management_ReceivedEvent;
robot.SendEvent += Management_SendEvent;
robot.ConnectedEvent += Management_ConnectedEvent;
robot.DisconnectedEvent += Management_DisconnectedEvent;
await robot.ConnectAsync(); //连接Robot
SendTaskMessage($"{item.RobotName}{Lang.已连接}!", MessageLevel.Debug);
}
catch (Exception ex)
{
sb.AppendLine($"{item.RobotName}:{Lang.断开连接}![{ex.Message}]");
SendTaskMessage($"{item.RobotName}{Lang.断开连接}!", MessageLevel.Alarm);
}
}
if (sb.Length == 0)
{
return (true, "");
}
else
{
return (false, sb.ToString());
}
}
///
/// 初始化PLC
///
///
public async Task<(bool IsSucceed, string Msg)> InitPlc()
{
var plcs = _configService.GetAllPlcs();
StringBuilder sb = new StringBuilder();
foreach (var item in plcs)
{
try
{
_plcService.CreatePlc(item.Id, item);
var plc = _plcService.GetPlc(item.Id);
Status.Add(new StatusInfo(item.Id, item.Name + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
plc.ConnectChangedEvent += Management_PlcConnectChangedEvent;
await plc.ConnectAsync(); //连接PLC
//SendTaskMessage($"{item.Name}{Lang.已连接}!", MessageLevel.Debug);
}
catch (Exception ex)
{
sb.AppendLine($"{item.Name}:{Lang.断开连接}![{ex.Message}]");
SendTaskMessage($"{item.Name}{Lang.断开连接}!", MessageLevel.Alarm);
}
}
try
{
await WriteSystemParameterToPlcAsync(_configService.GetSystemConfiguration());
RegisterPlcMonitorAddress();
}
catch (Exception ex)
{
LogHelper.WriteLogError("为PLC写入系统参数和订阅变量时出错", ex);
}
if (sb.Length == 0)
{
return (true, "");
}
else
{
return (false, sb.ToString());
}
}
///
/// 初始化相机
///
///
public async Task<(bool IsSucceed, string Msg)> InitCameras()
{
var cameras = _configService.GetAllCameras();
StringBuilder sb = new StringBuilder();
foreach (var item in cameras)
{
try
{
//Renders.Add(new ShowRender() { Id = item.Id, CameraName = item.CameraName });
_cameraService.CreateCamera(item.Id, item);
var camera = _cameraService.GetCamera(item.Id);
Status.Add(new StatusInfo(item.Id, item.CameraName + $"{Lang.未连接}", new SolidColorBrush(Colors.Red)));
camera.CameraConnectChangedEvent += Management_CameraConnectChangedEvent;
try
{
if (await camera.OpenDeviceAsync())
{
SendTaskMessage($"{item.CameraName}{Lang.已连接}!", MessageLevel.Debug);
}
else
{
SendTaskMessage($"{item.CameraName}{Lang.连接失败}!", MessageLevel.Alarm);
sb.AppendLine($"{item.CameraName}:{Lang.连接失败}!");
}
}
catch (Exception ex)
{
SendTaskMessage($"{item.CameraName}{ex.Message}!", MessageLevel.Alarm);
sb.AppendLine($"{item.CameraName}:{ex.Message}!");
}
}
catch (Exception ex)
{
SendTaskMessage($"{item.CameraName}{Lang.连接失败}!", MessageLevel.Alarm);
sb.AppendLine($"{item.CameraName}:{Lang.连接失败}!:{ex.Message}");
}
}
if (sb.Length == 0)
{
return (true, "");
}
else
{
return (false, sb.ToString());
}
}
///
/// 初始化光源控制器
///
///
public async Task<(bool IsSucceed, string Msg)> InitLightControllers()
{
var lightcontrollers = _configService.GetAllLightControllers();
StringBuilder sb = new StringBuilder();
foreach (var item in lightcontrollers)
{
try
{
var lishtCtr = await _lightManagerService.RegisterControllerAsync(item.Id, item);
//var lightcontroller = _cameraService.GetLightController(item.Id);
//await lightcontroller.ConnectAsync(); //连接光源控制器
//SendTaskMessage($"{item.LightControllerName}{Lang.已连接}!", MessageLevel.Debug);
}
catch (Exception ex)
{
//sb.AppendLine($"{item.LightControllerName}:{Lang.断开连接}![{ex.Message}]");
//SendTaskMessage($"{item.LightControllerName}{Lang.断开连接}!", MessageLevel.Alarm);
}
}
if (lightcontrollers.Count > 0)
{
var result = await _lightManagerService.ConnectAllAsync();
if (result)
{
return (true, "");
}
else
{
return (false, "Light Controller Connect Failed!");
}
}
return (true, "");
//if (sb.Length == 0)
//{
// return (true, "");
//}
//else
//{
// return (false, sb.ToString());
//}
}
///
/// 初始化后台TCP服务器通讯
///
public void InitBgTcp()
{
var config = _configService.GetBgTcp();
try
{
BgCommunicate = new BgCommunicate(config);
BgCommunicate.ConnectedEvent += BgCommunicate_ConnectedEvent;
BgCommunicate.DisconnectedEvent += BgCommunicate_DisconnectedEvent;
BgCommunicate.ReceivedEvent += BgCommunicate_ReceivedEvent;
BgCommunicate.SendEvent += BgCommunicate_SendEvent;
BgCommunicate.StartListening();
SendTaskMessage($"{Lang.已开启监听端口}：{config.Port}", MessageLevel.Debug);
}
catch (Exception ex)
{
SendTaskMessage($"{Lang.未开启监听端口}：{config.Port}", MessageLevel.Error);
LogHelper.WriteLogError("开启后台服务器通讯时出错!", ex);
}
}
///
/// 初始化后台ModbusTCP从站
///
public void InitModbusTcp()
{
try
{
var config = _configService.GetBgModbusTcp();
BgModbusTcpCommunicate = new BgModbusTcpCommunicate(config);
if (config.IsEnabled)
{
BgModbusTcpCommunicate.Listen();
SendTaskMessage($"Start Modbus Tcp Slave：{BgModbusTcpCommunicate.IP}:{BgModbusTcpCommunicate.Port}:{BgModbusTcpCommunicate.SlaveID}", MessageLevel.Debug);
}
}
catch (Exception ex)
{
SendTaskMessage($"No Start Modbus Tcp Slave：{ex.Message}", MessageLevel.Alarm);
LogHelper.WriteLogError("开启后台Modbus TCP通讯时出错!", ex);
}
}
///
/// 初始化后台脚本
///
public void InitBackgroundcript()
{
try
{
if (!Directory.Exists(FilePath.BackgroundScriptPath))
{
Directory.CreateDirectory(FilePath.BackgroundScriptPath);
}
try
{
string[] files = Directory.GetFiles(FilePath.BackgroundScriptPath);
List ScriptFilesCollection = new List();
foreach (string file in files)
{
string fileName = Path.GetFileName(file);
string fileExtension = Path.GetExtension(file);
if (fileExtension == ".cs")
{
ScriptFilesCollection.Add(file);
}
}
foreach (var item in ScriptFilesCollection)
{
try
{
string script = FileHelper.ReadFile(item);
SendTaskMessage($"{Lang.执行脚本}:{item}", MessageLevel.Info);
Task.Factory.StartNew(() =>
{
ScriptHelper.ExecuteScriptingAsync(script, _regionManager, _eventAggregator, _container, rst =>
{
if (!rst.Item1)
{
foreach (var err in rst.Item2)
{
SendTaskMessage($"{Lang.后台脚本出错}:{err}", MessageLevel.Error);
}
}
});
});
}
catch (Exception ex)
{
LogHelper.WriteLogError($"开启脚本时出错：{item}", ex);
}
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("读取本地脚本文件列表时出错", ex);
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("开启后台脚本时出错!", ex);
}
}
///
/// 初始化电批
///
///
public async Task InitScrewDriver()
{
try
{
var screwDriverConfig = _configService.GetScrewDriverConfig();
ScrewDriver = new XYD_ScrewDriver(screwDriverConfig.IPAdress, screwDriverConfig.Port);
Status.Add(new StatusInfo(ScrewDriver.Id, "电批未连接", new SolidColorBrush(Colors.Red)));
ScrewDriver.ConnectStateChangedEvent += ScrewDriver_ConnectStateChangedEvent;
ScrewDriver.SendTimeout = screwDriverConfig.SendTimeout;
screwDriverConfig.ReceiveTimeout = screwDriverConfig.ReceiveTimeout;
var isConnected = await ScrewDriver.ConnectAsync();
if (isConnected)
{
SendTaskMessage($"电批已连接", MessageLevel.Debug);
}
else
{
SendTaskMessage($"电批连接失败", MessageLevel.Error);
}
}
catch (Exception ex)
{
SendTaskMessage($"电批连接失败:{ex.Message}", MessageLevel.Alarm);
LogHelper.WriteLogError("连接电批时出错!", ex);
}
}
public async Task InitScan()
{
if (!File.Exists(FilePath.ScanRS232ConfigPath))
{
var scan = new ScanRs232ConfigModel();
FileHelper.WriteJsonFile(scan, FilePath.ScanRS232ConfigPath);
}
try
{
var res = FileHelper.ReadJsonFile(FilePath.ScanRS232ConfigPath);
if (res != null)
{
Scan_Client = new SerialPortClient();
Scan_Client.Connecting = (client1, e) => { return EasyTask.CompletedTask; };//即将连接到端口
Scan_Client.Connected = (client1, e) => { return EasyTask.CompletedTask; };//成功连接到端口
Scan_Client.Closing = (client1, e) => { return EasyTask.CompletedTask; };//即将从端口断开连接。此处仅主动断开才有效。
Scan_Client.Closed = (client1, e) => { return EasyTask.CompletedTask; };//从端口断开连接，当连接不成功时不会触发。
Scan_Client.Received = async (c, e) =>
{
//await Console.Out.WriteLineAsync(Encoding.UTF8.GetString(e.ByteBlock.Buffer));
await Console.Out.WriteLineAsync(e.ByteBlock.Span.ToString(Encoding.ASCII));
};
Scan_Client.Received = Scan_DataReceived;
await Scan_Client.SetupAsync(new TouchSocketConfig()
.SetSerialPortOption(new SerialPortOption()
{
BaudRate = res.BaudRate,//波特率
DataBits = res.DataBits,//数据位
Parity = res.Parity,//校验位
PortName = res.PortName,//COM
StopBits = res.StopBits//停止位
})
.SetSerialDataHandlingAdapter(() => new PeriodPackageAdapter() { CacheTimeout = TimeSpan.FromMilliseconds(100) })
);
await Scan_Client.ConnectAsync();
if (Scan_Client.Online)
{
SendTaskMessage($"扫码机已连接", MessageLevel.Debug);
}
else
{
SendTaskMessage($"扫码机未连接", MessageLevel.Debug);
}
}
else
{
SendTaskMessage("请设置扫码机串口！", MessageLevel.Error);
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("初始化扫码枪时出错！", ex);
SendTaskMessage("初始化扫码枪时出错！" + ex.Message, MessageLevel.Error);
}
}
#endregion
#region 机器人指令执行
public Dictionary RobotTCPCollection = new Dictionary();
///
/// 机器人TCP接收
///
///
///
///
private async void Management_ReceivedEvent(Guid robotid, object arg2, TouchSocket.Sockets.ReceivedDataEventArgs e)
{
try
{
if (!RobotTCPCollection.ContainsKey(robotid))
RobotTCPCollection.Add(robotid, new CancellationTokenSource());
else
{
if (RobotTCPCollection[robotid].IsCancellationRequested)
{
RobotTCPCollection[robotid] = new CancellationTokenSource();
}
}
var robot = await _robotService.GetRobotAsync(robotid);
//从服务器收到信息。但是一般byteBlock和requestInfo会根据适配器呈现不同的值。
var buffer = e.ByteBlock.Span.ToString(robot.GetEncoding());
SendTaskMessage($"{robot.Name}Received:{buffer}", MessageLevel.Info);
var _ = _remoteCommandService.ExecuteAsync(buffer, RobotTCPCollection[robotid].Token, async msg =>
{
try
{
if (robot.ConnectType == TCPConnectType.Client)
{
if (robot.IsConnected)
{
await robot.SendAsync($"{msg}");
}
}
else
{
var cient = (ITcpSessionClient)arg2;
if (cient.Online)
{
await robot.SendAsync(cient, $"{msg}");
}
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("TCP发送数据时出错！", ex);
SendTaskMessage(ex.Message, MessageLevel.Alarm);
}
});
}
catch (Exception ex)
{
LogHelper.WriteLogError("处理机器人接收的命令时出错！", ex);
SendTaskMessage(ex.Message, MessageLevel.Alarm);
}
}
#endregion
#region 机器人&Feeder&相机连接状态事件
///
/// 机器人发送事件
///
///
///
///
///
private void Management_SendEvent(Guid robotid, object arg2, string arg3)
{
var r = _robotService.GetRobot(robotid);
SendTaskMessage($"{r.Name}Send:{arg3}", MessageLevel.Info);
}
///
/// 机器人断开连接时
///
///
///
///
///
private void Management_DisconnectedEvent(Guid robotid, object arg2, ClosedEventArgs arg3)
{
if (RobotTCPCollection.ContainsKey(robotid))
{
RobotTCPCollection[robotid].Cancel();
}
var r = _configService.GetRobot(robotid);
if (r.ConnectType == TCPConnectType.Server)
{
ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
SendTaskMessage($"{r.RobotName}[{socketClient.Id}:{socketClient.IP}]{Lang.断开连接}！", MessageLevel.Error);
var robot = _robotService.GetRobot(robotid);
if (robot.TcpService.Count < 1)
{
var sta = Status.FirstOrDefault(s => s.ID == robotid);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{r.RobotName}{Lang.未连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
}
}
else
{
SendTaskMessage($"{r.RobotName}{Lang.断开连接}！", MessageLevel.Error);
var sta = Status.FirstOrDefault(s => s.ID == robotid);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{r.RobotName}{Lang.断开连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
}
}
///
/// 机器人连接成功时
///
///
///
///
///
private void Management_ConnectedEvent(Guid robotid, object arg2, ConnectedEventArgs arg3)
{
var r = _configService.GetRobot(robotid);
if (r.ConnectType == TCPConnectType.Server)
{
ITcpSessionClient socketClient = arg2 as ITcpSessionClient;
SendTaskMessage($"{r.RobotName}[{socketClient.Id}:{socketClient.IP}]{Lang.已连接}！", MessageLevel.Debug);
var robot = _robotService.GetRobot(robotid);
if (robot.TcpService.Count > 0)
{
var sta = Status.FirstOrDefault(s => s.ID == robotid);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{r.RobotName}{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
}
}
else
{
SendTaskMessage($"{r.RobotName}{Lang.已连接}！", MessageLevel.Debug);
var sta = Status.FirstOrDefault(s => s.ID == robotid);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{r.RobotName}{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
}
}
///
/// Feeder连接状态改变时
///
///
///
private void Management_FeederConnectionStatusChanged(object sender, bool state)
{
IFeeder feeder = sender as IFeeder;
var sta = Status.FirstOrDefault(s => s.ID == feeder.Id);
if (state)
{
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{feeder.Name}{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
SendTaskMessage($"{feeder.Name}{Lang.已连接}！", MessageLevel.Debug);
}
else
{
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{feeder.Name}{Lang.未连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
SendTaskMessage($"{feeder.Name}{Lang.断开连接}！", MessageLevel.Error);
}
}
///
/// 相机连接或者断开时
///
///
///
private void Management_CameraConnectChangedEvent(Guid id, bool state)
{
var sta = Status.FirstOrDefault(s => s.ID == id);
var camera = _configService.GetCamera(id);
if (sta != null && camera != null)
{
if (state)
{
App.Current.Dispatcher.Invoke(new Action(() =>
{
sta.Message = $"{camera.CameraName}{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
}
else
{
App.Current.Dispatcher.Invoke(new Action(() =>
{
sta.Message = $"{camera.CameraName}{Lang.断开连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
}
}
}
///
/// PLC连接状态改变事件
///
///
///
private async void Management_PlcConnectChangedEvent(object sender, bool isconnected)
{
IPlc plc = sender as IPlc;
var sta = Status.FirstOrDefault(s => s.ID == plc.Id);
if (plc.IsConnected)
{
SendTaskMessage($"{plc.Name}{Lang.已连接}！", MessageLevel.Debug);
if (sta == null) return;
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{plc.Name}{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
try
{
await WriteSystemParameterToPlcAsync(_configService.GetSystemConfiguration());
await WritePositionToPlcAsync();
}
catch (Exception ex)
{
LogHelper.WriteLogError("PLC连接成功时，写入系统参数和点位信息时出错！", ex);
}
}
else
{
SendTaskMessage($"{plc.Name}{Lang.断开连接}！", MessageLevel.Error);
if (sta == null) return;
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"{plc.Name}{Lang.未连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
}
}
///
/// 电批连接状态改变时
///
///
///
private void ScrewDriver_ConnectStateChangedEvent(object screwDevice, bool state)
{
try
{
XYD_ScrewDriver screwDriver = screwDevice as XYD_ScrewDriver;
if (state)
{
SendTaskMessage($"电批{Lang.已连接}！", MessageLevel.Debug);
var sta = Status.FirstOrDefault(s => s.ID == screwDriver.Id);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"电批{Lang.已连接}";
sta.Background = new SolidColorBrush(Colors.Green);
}));
}
else
{
SendTaskMessage($"电批{Lang.未连接}！", MessageLevel.Error);
var sta = Status.FirstOrDefault(s => s.ID == screwDriver.Id);
App.Current.Dispatcher.Invoke(new
Action(() =>
{
sta.Message = $"电批{Lang.未连接}";
sta.Background = new SolidColorBrush(Colors.Red);
}));
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("电批连接状态改变时出错了", ex);
}
}
#endregion
#region 后台服务器通讯事件
private void BgCommunicate_SendEvent(ITcpSessionClient client, string msg)
{
SendTaskMessage($"{Lang.服务器}[{client.ServicePort}] Send To {Lang.客户端}[{client.Id}:{client.IP}]:{msg}", MessageLevel.Info);
}
public Dictionary BgCommunicateollection = new Dictionary();
private async void BgCommunicate_ReceivedEvent(ITcpSessionClient client, string msg)
{
try
{
if (!BgCommunicateollection.ContainsKey(client.Id))
{
BgCommunicateollection.Add(client.Id, new CancellationTokenSource());
}
SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]ReceiveFor{Lang.客户端}[{client.Id}:{client.IP}]:{msg}", MessageLevel.Info);
var _ = _remoteCommandService.ExecuteAsync(msg, BgCommunicateollection[client.Id].Token, async response =>
{
try
{
if (!client.Online)
{
return;
}
await BgCommunicate.SendAsync(client, $"{response}");
}
catch (Exception ex)
{
LogHelper.WriteLogError("后台TCP发送数据时出错！", ex);
SendTaskMessage(ex.Message, MessageLevel.Alarm);
}
});
}
catch (Exception ex)
{
LogHelper.WriteLogError("处理后台服务器接收的命令时出错！", ex);
SendTaskMessage(ex.Message, MessageLevel.Alarm);
}
}
private void BgCommunicate_DisconnectedEvent(ITcpSessionClient client, ClosedEventArgs e)
{
SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]{Lang.客户端}[{client.Id}:{client.IP}]{Lang.断开连接}!", MessageLevel.Alarm);
if (BgCommunicateollection.ContainsKey(client.Id))
{
BgCommunicateollection[client.Id].Cancel();
}
}
private void BgCommunicate_ConnectedEvent(ITcpSessionClient client, ConnectedEventArgs e)
{
SendTaskMessage($"{Lang.服务器}[{client.ServicePort}]{Lang.客户端}[{client.Id}:{client.IP}]{Lang.连接成功}!", MessageLevel.Debug);
}
private async Task Scan_DataReceived(ISerialPortClient client, ReceivedDataEventArgs e)
{
try
{
string poname = client.MainSerialPort.PortName;
string data = e.ByteBlock.Span.ToString(Encoding.ASCII);
await Console.Out.WriteLineAsync(data);
string response = data.Split('\r')[0];
SendTaskMessage($"扫码机:{poname}Receive:{response}", MessageLevel.Info);
ScanValue = response;
_scanDoneEvent.Set();
}
catch (Exception ex)
{
LogHelper.WriteLogError("扭力测量仪接收信息时出错！", ex);
SendTaskMessage("扭力测量仪接收信息时出错！" + ex.Message, MessageLevel.Error);
}
}
#endregion
#region PLC
///
/// 将系统参数写入PLC
///
///
///
public async Task WriteSystemParameterToPlcAsync(SystemConfiguration systemConfiguration)
{
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
Dictionary nodeValues = new Dictionary();
nodeValues.Add(addressConfig.Out_WorkMode.Address, (Int16)systemConfiguration.WorkMode);
nodeValues.Add(addressConfig.Out_PickPointNum.Address, (Int16)systemConfiguration.PickPointNum);
nodeValues.Add(addressConfig.Out_DowmCameraNum.Address, (Int16)systemConfiguration.DowmCameraNum);
nodeValues.Add(addressConfig.Out_UpCameraPickNum.Address, (Int16)systemConfiguration.UpCameraPickNum);
nodeValues.Add(addressConfig.Out_UpCameraPutNum.Address, (Int16)systemConfiguration.UpCameraPutNum);
nodeValues.Add(addressConfig.Out_UPCameracheckNum.Address, (Int16)systemConfiguration.UPCameracheckNum);
nodeValues.Add(addressConfig.Out_FixedCameraPickNum.Address, (Int16)systemConfiguration.FixedCameraPickNum);
nodeValues.Add(addressConfig.Out_FixedCameraPutNum.Address, (Int16)systemConfiguration.FixedCameraPutNum);
nodeValues.Add(addressConfig.Out_FixedCameracheckNum.Address, (Int16)systemConfiguration.FixedCameracheckNum);
nodeValues.Add(addressConfig.Out_ScrewTeachNum.Address, (Int16)systemConfiguration.ScrewTeachNum);
var res = await plc.WriteNodesAsync(nodeValues);
}
///
/// 注册需要监控的PLC地址
///
public void RegisterPlcMonitorAddress()
{
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
//PLC地址数组
List monitorNodeIds = new List()
{
addressConfig.In_DowmCameraExe.Address,
addressConfig.In_UpCameraPickExe.Address,
addressConfig.In_UpCameraPutExe.Address,
addressConfig.In_UPCameracheckExe.Address,
addressConfig.In_FixedCameraPickExe.Address,
addressConfig.In_FixedCameraPutExe.Address,
addressConfig.In_FixedCameracheckExe.Address,
addressConfig.In_RequestPosition.Address,
addressConfig.In_ScrewTeachExe.Address,
addressConfig.In_PickINC.Address,
addressConfig.In_Throw.Address,
};
for (int i = 0; i < 10; i++)
{
monitorNodeIds.Add(string.Format(addressConfig.In_MesCheck.Address, i));
}
for (int i = 0; i < 7; i++)
{
monitorNodeIds.Add(string.Format(addressConfig.In_WorkStart.Address, i));
monitorNodeIds.Add(string.Format(addressConfig.In_WorkDone.Address, i));
}
//订阅PLC地址变化
plc.SubscribeNodes("AutoSensor", monitorNodeIds, PlcCommandTrigger);
}
///
/// 写入点位信息给PLC
///
///
public async Task WritePositionToPlcAsync()
{
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
var current = _productService.GetCurrentProduct();
if (current == null) return;
if (current.PickCameraPoints != null && current.PickCameraPoints.Count > 0)
{
foreach (var item in current.PickCameraPoints)
{
await item.WriteToPlcAddress(addressConfig.Out_PickCamera, plc);
}
}
if (current.PickPoints != null && current.PickPoints.Count > 0)
{
foreach (var item in current.PickPoints)
{
var res = await item.WriteToPlcAddress(addressConfig.Out_Pick, plc);
}
}
if (current.SecPosCameraPoints != null && current.SecPosCameraPoints.Count > 0)
{
foreach (var item in current.SecPosCameraPoints)
{
await item.WriteToPlcAddress(addressConfig.Out_SecPosCamera, plc);
}
}
if (current.ScrewCameraPoints != null && current.ScrewCameraPoints.Count > 0)
{
foreach (var item in current.ScrewCameraPoints)
{
await item.WriteToPlcAddress(addressConfig.Out_ScrewCamera, plc);
}
}
if (current.ScrewPoints != null && current.ScrewPoints.Count > 0)
{
foreach (var item in current.ScrewPoints)
{
await item.WriteToPlcAddressEx(addressConfig.Out_Screw, plc);
}
await plc.WriteNodeAsync(addressConfig.Out_WorkNum.Address, (Int16)current.ScrewPoints.Count);
}
if (current.CheckCameraPoints != null && current.CheckCameraPoints.Count > 0)
{
foreach (var item in current.CheckCameraPoints)
{
await item.WriteToPlcAddress(addressConfig.Out_CheckCamera, plc);
}
}
if (current.RemovePoints != null && current.RemovePoints.Count > 0)
{
foreach (var item in current.RemovePoints)
{
await item.WriteToPlcAddress(addressConfig.Out_RemovePos, plc);
}
}
if (current.PressurePlacePoints != null && current.PressurePlacePoints.Count > 0)
{
foreach (var item in current.PressurePlacePoints)
{
await item.WriteToPlcAddress(addressConfig.Out_PressurePlace, plc);
}
}
}
public async Task WriteParameterToPlcAsync()
{
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
// 获取当前产品
var currentProduct = _productService.GetCurrentProduct();
if (currentProduct == null) return;
try
{
if (currentProduct.GlobalParamEx == null) currentProduct.GlobalParamEx = new Models.Product.ProductGlobalParamEx();
if (currentProduct.GlobalParamEx.DownPressure == null) currentProduct.GlobalParamEx.DownPressure = new PressureModel();
await plc.WriteNodeAsync(addressConfig.Down_Time.Address, currentProduct.GlobalParamEx.DownPressure.PressureTime);
await plc.WriteNodeAsync(addressConfig.Down_WetOut_Num.Address, currentProduct.GlobalParamEx.DownPressure.PressureNum);
await plc.WriteNodeAsync(addressConfig.Down_WetOut_Num_max.Address, currentProduct.GlobalParamEx.DownPressure.PressureNumMax);
}
catch (Exception)
{
}
}
///
/// 固定向上相机拍照结果
///
OpenCvSharp.Point3f[] DowmCameraResults = new OpenCvSharp.Point3f[10];
///
/// 移动向下相机拍照结果
///
OpenCvSharp.Point3f[] UpCameraPutResults = new OpenCvSharp.Point3f[10];
///
/// 取料移动相机拍照结果
///
OpenCvSharp.Point3f UpCameraPickResult = new OpenCvSharp.Point3f();
///
/// 最终组装位置
///
OpenCvSharp.Point3f PlaceActualCoord = new OpenCvSharp.Point3f();
///
/// 零件SN
///
string PartSN = "";
///
/// 产品SN
///
string[] ProductMainSN = new string[10];//产品主sn
///
/// 工单信息
///
string[] wo = new string[10];
string[] model_num = new string[10];//产品model_num
string[] color = new string[10];//产品color
///
/// 二次定位相机的工具坐标
///
PointF DownTool = new PointF();
double _FixedUpCameraAngle = 0;
double _MoveCameraAngle = 0;
// 扫码完成事件
private readonly ManualResetEventSlim _scanDoneEvent = new ManualResetEventSlim(false);
// 扫码结果
private string ScanValue = "";
bool _LastDowmCameraExe = false;
bool _LastScrewTeachExe = false;
bool _LastUpCameraPickExe = false;
bool _LastUpCameraPutExe = false;
bool _LastUPCameracheckExe = false;
bool _LastFixedCameraPickExe = false;
bool _LastFixedCameraPutExe = false;
bool _LastFixedCameracheckExe = false;
bool _LastThrowExe = false;
Int16 _LastQrCodePhotoRequest = 0;
Int16[] _LastWorkStart = new Int16[7];
Int16[] _LastWorkDone = new Int16[7];
Int16 _LastRequestPosition = 0;
Int16 _LastPickINC = 0;
Int16[] _LastMesCheck = new Int16[10];
DateTime[] _LastMesCheckTime = new DateTime[10];
Dictionary mes_cc { get; set; } = new Dictionary();
///
/// 当前压力值
///
double[] currentPressure = new double[10];
///
/// PLC命令触发时
///
///
private async void PlcCommandTrigger((string key, string nodeId, object value) tuple)
{
try
{
if (tuple.key != "AutoSensor")
{
return;
}
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
// 获取当前产品
var currentProduct = _productService.GetCurrentProduct();
if (currentProduct == null)
{
return;
}
////获取产品编码
//_productService.CurrentProductCode = plc.ReadNode(string.Format(addressConfig.In_Code.Address, 0));
////如果产品编码为空，则以当前的时间戳作为编码
//if (string.IsNullOrEmpty(_productService.CurrentProductCode))
//{
// _productService.CurrentProductCode = DateTime.Now.ToString("yyyyMMddHHmmssfff");
//}
bool isDryMode = plc.ReadNode(addressConfig.In_DryMode.Address);
// 触发下相机拍照
if (addressConfig.In_DowmCameraExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastDowmCameraExe != state)
{
_LastDowmCameraExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发下相机拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_DowmCameraNum.Address);
SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);
// 获取机器人当前坐标
var robot = _robotService.GetAllRobots().FirstOrDefault();
if (robot == null)
{
SendTaskMessage($"未找到机器人，无法执行上相机锁附/组装拍照视觉任务", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
var currentPosition = robot.GetRobotPos();
//如果下相机拍照的次数是1，则判断用时拍照的相机是几个
int downCameraNum = _configService.GetSystemConfiguration().DowmCameraNum;
if (downCameraNum == 1)
{
//如果下相机2的流程id为空，则表示只有一个下相机
if (currentProduct.FixedUpCamera2ProcedureId == Guid.Empty)
{
//获取固定向上相机1的流程
var process = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera1ProcedureId);
if (process == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera1ProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint(process, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, cameraIndex, null);
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
if (visionResult.IsSucceed)
{
float toolX = (float)(visionResult.X - currentPosition.X);
float toolY = (float)(visionResult.Y - currentPosition.Y);
DowmCameraResults[cameraIndex] = new OpenCvSharp.Point3f(toolX, toolY, (float)visionResult.U);
DownTool = new PointF(toolX, toolY);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
}
else
{
//获取固定向上相机1的流程
var process1 = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera1ProcedureId);
if (process1 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera1ProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
//获取固定向上相机2的流程
var process2 = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera2ProcedureId);
if (process2 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera2ProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var task1 = _remoteCommandService.ExecutePhotoGetSinglePoint(process1, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 1, null);
var task2 = _remoteCommandService.ExecutePhotoGetSinglePoint(process2, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 2, null);
var visionResults = await Task.WhenAll(task1, task2);
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
if (visionResults[0].IsSucceed && visionResults[1].IsSucceed)
{
float toolX = (float)(visionResults[0].X + visionResults[1].X) / 2;
float toolY = (float)(visionResults[0].Y + visionResults[1].Y) / 2;
_FixedUpCameraAngle = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)visionResults[0].X, (float)visionResults[0].Y), new PointF((float)visionResults[1].X, (float)visionResults[1].Y));
DowmCameraResults[cameraIndex] = new OpenCvSharp.Point3f(toolX, toolY, (float)_FixedUpCameraAngle);
DownTool = new PointF(toolX, toolY);
SendTaskMessage($"固定向上相机拍照Tool: {DownTool.X:F3},{DownTool.Y:F3},{_FixedUpCameraAngle:F3}", MessageLevel.Info);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
}
}
else if (downCameraNum == 2)
{
//如果下相机2的流程id为空，则表示只有一个下相机
if (currentProduct.FixedUpCamera2ProcedureId == Guid.Empty)
{
//获取固定向上相机1的流程
//var process = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera1ProcedureId);
//if (process == null)
//{
// SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera1ProcedureId}", MessageLevel.Alarm);
// await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
// return;
//}
//// 执行视觉任务
//var _cts = new CancellationTokenSource();
//var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint(process, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token);
//if (visionResult.IsSucceed)
//{
// float toolX = (float)(visionResult.X - currentPosition.X);
// float toolY = (float)(visionResult.Y - currentPosition.Y);
// DowmCameraResults[cameraIndex] = new PointF(toolX, toolX);
// if (cameraIndex == downCameraNum)
// {
// //求取多个DowmCameraResults的中心点
// DownTool = new PointF(toolX, toolX);
// }
// await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
// return;
//}
//else
//{
// await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
// return;
//}
//暂时没有应用场景，不支持
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
else
{
//获取固定向上相机1的流程
var process1 = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera1ProcedureId);
if (process1 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera1ProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
//获取固定向上相机2的流程
var process2 = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera2ProcedureId);
if (process2 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera2ProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var task1 = _remoteCommandService.ExecutePhotoGetSinglePoint(process1, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 1, null);
var task2 = _remoteCommandService.ExecutePhotoGetSinglePoint(process2, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 2, null);
var visionResults = await Task.WhenAll(task1, task2);
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
if (visionResults[0].IsSucceed && visionResults[1].IsSucceed)
{
float toolX = (float)(visionResults[0].X + visionResults[1].X) / 2;
float toolY = (float)(visionResults[0].Y + visionResults[1].Y) / 2;
_FixedUpCameraAngle = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)visionResults[0].X, (float)visionResults[0].Y), new PointF((float)visionResults[1].X, (float)visionResults[1].Y));
DowmCameraResults[cameraIndex] = new OpenCvSharp.Point3f(toolX, toolY, (float)_FixedUpCameraAngle);
DownTool = new PointF(toolX, toolY);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
}
}
else
{
//暂时没有应用场景，不支持
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
}
else
{
SendTaskMessage($"触发下相机拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)0);
}
}
}
// 触发下相机拍照披头
if (addressConfig.In_ScrewTeachExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastScrewTeachExe != state)
{
_LastScrewTeachExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发下相机拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_DowmCameraNum.Address);
SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);
// 获取流程
//var process = _productService.GetCurrentProductProcedureModelById(currentProduct.FixedUpCamera1ProcedureId);
//if (process == null)
//{
// SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.FixedUpCamera1ProcedureId}", MessageLevel.Alarm);
// await plc.WriteNodeAsync(addressConfig.Out_ScrewTeachOk.Address, (Int16)2);
// return;
//}
//// 获取机器人当前坐标
//var robot = _robotService.GetAllRobots().FirstOrDefault();
//if (robot == null)
//{
// SendTaskMessage($"未找到机器人，无法执行上相机锁附/组装拍照视觉任务", MessageLevel.Alarm);
// await plc.WriteNodeAsync(addressConfig.Out_ScrewTeachOk.Address, (Int16)2);
// return;
//}
//var currentPosition = robot.GetRobotPos();
//// 执行视觉任务
//var _cts = new CancellationTokenSource();
//var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint(process, null, null, _cts.Token);
//if (visionResult.IsSucceed)
//{
// //披头偏差
// float offsetX = (float)(visionResult.X - currentPosition.X);
// float offsetY = (float)(visionResult.Y - currentPosition.Y);
// DowmCameraResults[cameraIndex] = new PointF(offsetX, offsetY);
// await plc.WriteNodeAsync(addressConfig.Out_ScrewTeachOk.Address, (Int16)1);
// return;
//}
//else
//{
// await plc.WriteNodeAsync(addressConfig.Out_ScrewTeachOk.Address, (Int16)2);
// return;
//}
}
else
{
SendTaskMessage($"触发下相机拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_ScrewTeachOk.Address, (Int16)0);
}
}
}
// 触发上相机取料拍照
else if (addressConfig.In_UpCameraPickExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastUpCameraPickExe != state)
{
_LastUpCameraPickExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发上相机取料拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_UpCameraPickNum.Address);
SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);
// 获取机器人当前坐标
var robot = _robotService.GetAllRobots().FirstOrDefault();
if (robot == null)
{
SendTaskMessage($"未找到机器人，无法执行上相机锁附/组装拍照视觉任务", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_DownCameraStatus.Address, (Int16)2);
return;
}
var currentPosition = robot.GetRobotPos();
//如果上相机2的流程id为空，则表示只有一个下相机
if (currentProduct.MoveDownCamer2PickPhotoProcedureId == Guid.Empty)
{
//获取移动向下相机1的流程
var process = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamer1PickPhotoProcedureId);
if (process == null)
{
SendTaskMessage($"移动向下相机1视觉流程，流程ID：{currentProduct.MoveDownCamer1PickPhotoProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint(process, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, cameraIndex, null);
if (visionResult.IsSucceed)
{
currentProduct.PickPoints[0].X_Position = (float)visionResult.X;
currentProduct.PickPoints[0].Y_Position = (float)visionResult.Y;
//currentProduct.PickPoints[0].U_Position += (float)visionResult.U;
await currentProduct.ScrewPoints[0].WriteToPlcAddress(addressConfig.Out_Pick, plc);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)2);
return;
}
}
else
{
//获取固定向上相机1的流程
var process1 = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamer1PickPhotoProcedureId);
if (process1 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.MoveDownCamer1PickPhotoProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)2);
return;
}
//获取固定向上相机2的流程
var process2 = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamer2PickPhotoProcedureId);
if (process2 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.MoveDownCamer2PickPhotoProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var task1 = _remoteCommandService.ExecutePhotoGetSinglePoint(process1, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 1, null);
var task2 = _remoteCommandService.ExecutePhotoGetSinglePoint(process2, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 2, null);
var visionResults = await Task.WhenAll(task1, task2);
if (visionResults[0].IsSucceed && visionResults[1].IsSucceed)
{
float tool1X = (float)(visionResults[0].X - visionResults[0].X);
float tool1Y = (float)(visionResults[0].Y - visionResults[0].Y);
float tool2X = (float)(visionResults[1].X - visionResults[1].X);
float tool2Y = (float)(visionResults[1].Y - visionResults[1].Y);
float toolX = (tool1X + tool2X) / 2;
float toolY = (tool1Y + tool2Y) / 2;
//计算两个点的线角度
currentProduct.PickPoints[0].X_Position = (float)toolX;
currentProduct.PickPoints[0].Y_Position = (float)toolY;
//currentProduct.PickPoints[0].U_Position += (float)visionResult.U;
await currentProduct.ScrewPoints[0].WriteToPlcAddress(addressConfig.Out_Pick, plc);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)2);
return;
}
}
}
else
{
SendTaskMessage($"触发上相机取料拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPickStatus.Address, (Int16)0);
}
}
}
// 上相机锁附/组装拍照
else if (addressConfig.In_UpCameraPutExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastUpCameraPutExe != state)
{
_LastUpCameraPutExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发上相机锁附/组装拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_UpCameraPutNum.Address);
SendTaskMessage($"编号：{cameraIndex}", MessageLevel.Info);
//视觉流程ID
Guid procedureId = currentProduct.MoveDownCamera1LockPhotoProcedureId;
// 获取机器人当前坐标
var robot = _robotService.GetAllRobots().FirstOrDefault();
if (robot == null)
{
SendTaskMessage($"未找到机器人，无法执行上相机锁附/组装拍照视觉任务", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
var currentPosition = robot.GetRobotPos();
//如果上相机2的流程id为空，则表示只有一个上相机
if (currentProduct.MoveDownCamera2LockPhotoProcedureId == Guid.Empty)
{
//获取锁付拍照的点位
var pos = currentProduct.ScrewCameraPoints.FirstOrDefault(p => p.Number == cameraIndex);
if (pos != null)
{
procedureId = pos.VisionProcessID;
}
// 获取移动向下相机的流程
var process = _productService.GetCurrentProductProcedureModelById(procedureId);
if (process == null)
{
SendTaskMessage($"未找到移动向下相机组装拍照对应的视觉流程流程ID:{procedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var visionResult = await _remoteCommandService.ExecutePhotoGetSinglePoint(process, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, cameraIndex, null);
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)1);
return;
}
if (visionResult.IsSucceed)
{
UpCameraPutResults[cameraIndex] = new OpenCvSharp.Point3f((float)visionResult.X, (float)visionResult.Y, (float)visionResult.U);
SendTaskMessage($"移动向下相机拍照[{cameraIndex}]结果: {UpCameraPutResults[cameraIndex].X:F3},{UpCameraPutResults[cameraIndex].Y:F3},{UpCameraPutResults[cameraIndex].Z:F3}", MessageLevel.Info);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
}
else
{
//获取移动向下相机1的流程
var process1 = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamera1LockPhotoProcedureId);
if (process1 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.MoveDownCamera1LockPhotoProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
//获取移动向下相机2的流程
var process2 = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamera2LockPhotoProcedureId);
if (process2 == null)
{
SendTaskMessage($"固定向上相机1视觉流程，流程ID：{currentProduct.MoveDownCamera2LockPhotoProcedureId}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
var task1 = _remoteCommandService.ExecutePhotoGetSinglePoint(process1, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 1, null);
var task2 = _remoteCommandService.ExecutePhotoGetSinglePoint(process2, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, 2, null);
var visionResults = await Task.WhenAll(task1, task2);
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)1);
return;
}
if (visionResults[0].IsSucceed && visionResults[1].IsSucceed)
{
float centerX = (float)(visionResults[0].X + visionResults[1].X) / 2;
float centerY = (float)(visionResults[0].Y + visionResults[1].Y) / 2;
_MoveCameraAngle = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)visionResults[0].X, (float)visionResults[0].Y), new PointF((float)visionResults[1].X, (float)visionResults[1].Y));
UpCameraPutResults[cameraIndex] = new OpenCvSharp.Point3f(centerX, centerY, (float)_MoveCameraAngle);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)1);
return;
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
}
}
else
{
SendTaskMessage($"触发上相机锁附/组装拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)0);
}
}
}
// 上相机检测拍照
else if (addressConfig.In_UPCameracheckExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastUPCameracheckExe != state)
{
_LastUPCameracheckExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发上相机检测拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_UPCameracheckNum.Address);
//视觉流程ID
Guid procedureId = Guid.Empty;
//获取锁付拍照的点位
var pos = currentProduct.CheckCameraPoints.FirstOrDefault(p => p.Number == cameraIndex);
if (pos != null)
{
procedureId = pos.VisionProcessID;
}
// 获取流程
var process = _productService.GetCurrentProductProcedureModelById(procedureId);
if (process == null)
{
SendTaskMessage(string.Format("未找到点位：{0}的视觉流程：{1}", cameraIndex, procedureId), MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)2);
return;
}
// 获取机器人当前坐标
var robot = _robotService.GetAllRobots().FirstOrDefault();
if (robot == null)
{
SendTaskMessage($"未找到机器人，无法执行上相机锁附/组装拍照视觉任务", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UpCameraPutStatus.Address, (Int16)2);
return;
}
var currentPosition = robot.GetRobotPos();
// 执行视觉任务
var _cts = new CancellationTokenSource();
var visionResult = await _remoteCommandService.ExecutePhotoGetDistance(1, process, null, new double[] { currentPosition.X, currentPosition.Y, currentPosition.U }, _cts.Token, cameraIndex, null);
if (visionResult.IsSucceed)
{
await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)1);
SendTaskMessage($"点位{cameraIndex}检测OK", MessageLevel.Debug);
}
else
{
await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)2);
SendTaskMessage($"点位{cameraIndex}检测NG", MessageLevel.Error);
}
if (mes_cc.ContainsKey(visionResult.distance.Split(',')[0]))
{
mes_cc[visionResult.distance.Split(',')[0]] = visionResult.distance.Split(',')[1];
}
else
{
mes_cc.Add(visionResult.distance.Split(',')[0], visionResult.distance.Split(',')[1]);
}
await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)1);
}
else
{
SendTaskMessage($"触发上相机检测拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_UPCameracheckStatus.Address, (Int16)0);
}
}
}
// 固定相机取料拍照
else if (addressConfig.In_FixedCameraPickExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastFixedCameraPickExe != state)
{
_LastFixedCameraPickExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发固定相机取料拍照...", MessageLevel.Debug);
//相机的编号
//Int16 cameraIndex = plc.ReadNode(addressConfig.In_FixedCameraPickNum.Address);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)1);
}
else
{
SendTaskMessage($"触发固定相机取料拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPickStatus.Address, (Int16)0);
}
}
}
// 固定相机锁附/组装拍照
else if (addressConfig.In_FixedCameraPutExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastFixedCameraPutExe != state)
{
_LastFixedCameraPutExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发固定相机锁附/组装拍照...", MessageLevel.Debug);
//相机的编号
//Int16 cameraIndex = plc.ReadNode(addressConfig.In_FixedCameraPutNum.Address);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPutStatus.Address, (Int16)1);
}
else
{
SendTaskMessage($"触发固定相机锁附/组装拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameraPutStatus.Address, (Int16)0);
}
}
}
// 固定相机检测拍照
else if (addressConfig.In_FixedCameracheckExe.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastFixedCameracheckExe != state)
{
_LastFixedCameracheckExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage($"触发固定相机检测拍照...", MessageLevel.Debug);
//相机的编号
Int16 cameraIndex = plc.ReadNode(addressConfig.In_FixedCameracheckNum.Address);
List> visionTasks = new List>();
List visionProcesses = new List();
if (currentProduct.MoveDownCamer1CheckProcedureId != Guid.Empty)
{
var process = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamer1CheckProcedureId);
if (process != null)
{
visionProcesses.Add(process);
}
}
if (currentProduct.MoveDownCamer2CheckProcedureId != Guid.Empty)
{
var process = _productService.GetCurrentProductProcedureModelById(currentProduct.MoveDownCamer2CheckProcedureId);
if (process != null)
{
visionProcesses.Add(process);
}
}
if (visionProcesses.Count <= 0)
{
SendTaskMessage($"未配置移动向下相机检测视觉流程", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)2);
return;
}
// 执行视觉任务
var _cts = new CancellationTokenSource();
for (int i = 0; i < visionProcesses.Count; i++)
{
visionTasks.Add(_remoteCommandService.ExecutePhotoGetSinglePoint(visionProcesses[i], null, null, _cts.Token, i + 1, null));
}
var visionResults = await Task.WhenAll(visionTasks.ToArray());
if (isDryMode)
{
await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)1);
return;
}
//获取visionResults集合中所有的结果，如果全部成功则为通过
bool allSucceed = true;
for (int i = 0; i < visionResults.Length; i++)
{
if (!visionResults[i].IsSucceed)
{
allSucceed = false;
break;
}
}
if (allSucceed)
{
SendTaskMessage($"固定相机检测OK", MessageLevel.Debug);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)1);
return;
}
else
{
SendTaskMessage($"固定相机检测NG", MessageLevel.Error);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)2);
return;
}
}
else
{
SendTaskMessage($"触发固定相机检测拍照信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_FixedCameracheckStatus.Address, (Int16)0);
}
}
}
// 多相机坐标合并
else if (addressConfig.In_RequestPosition.Address.Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastRequestPosition != state)
{
_LastRequestPosition = state;
}
else
{
return;
}
if (state == 1)
{
SendTaskMessage($"收到多相机坐标合并请求，开始合并...", MessageLevel.Debug);
if (isDryMode)
{
var point1 = currentProduct.ScrewPoints[0].Clone();
SendTaskMessage($"点：1，{point1.X_Position:F3}，{point1.Y_Position:F4}，{point1.U_Position:F4}", MessageLevel.Info);
await point1.WriteToPlcAddress(addressConfig.Out_Screw, plc);
await plc.WriteNodeAsync(addressConfig.Out_WorkNum.Address, (Int16)1);
await plc.WriteNodeAsync(addressConfig.Out_CameraDone.Address, (Int16)1);
return;
}
double upCameraX = 0, upCameraY = 0, upCameraU = 0;
upCameraX = UpCameraPutResults[1].X;
upCameraY = UpCameraPutResults[1].Y;
upCameraU = UpCameraPutResults[1].Z;
//如果下相机拍照的次数是1，则判断用时拍照的相机是几个
int upCameraNum = _configService.GetSystemConfiguration().UpCameraPutNum;
if (upCameraNum == 2)
{
upCameraX = (UpCameraPutResults[1].X + UpCameraPutResults[2].X) / 2;
upCameraY = (UpCameraPutResults[1].Y + UpCameraPutResults[2].Y) / 2;
upCameraU = Common.CalculateAngleBetweenPointsDegrees(new PointF((float)UpCameraPutResults[1].X, (float)UpCameraPutResults[1].Y), new PointF((float)UpCameraPutResults[2].X, (float)UpCameraPutResults[2].Y));
}
var point = currentProduct.ScrewPoints[0].Clone();
var pn = Vector.Build.Dense(new double[] { upCameraX, upCameraY });
//目标角度：
double angle = point.U_Position - (DowmCameraResults[1].Z - currentProduct.FixedUpCameraTempletAngle) + (upCameraU - currentProduct.MoveDownCamerTempletAngle);
var toolCoord = new ToolCoord();
toolCoord.SetTool(DowmCameraResults[1].X, DowmCameraResults[1].Y);
//将_PutPoint转换为Tool0下要走的点
var p0 = toolCoord.GetTool0Coord(pn, angle);
point.X_Position = (float)p0[0];
point.Y_Position = (float)p0[1];
point.U_Position = (float)angle;
PlaceActualCoord = new OpenCvSharp.Point3f(point.X_Position, point.Y_Position, point.U_Position);
SendTaskMessage($"点：1，{point.X_Position:F3}，{point.Y_Position:F4}，{point.U_Position:F4}", MessageLevel.Info);
await point.WriteToPlcAddress(addressConfig.Out_Screw, plc);
await plc.WriteNodeAsync(addressConfig.Out_WorkNum.Address, (Int16)1);
await plc.WriteNodeAsync(addressConfig.Out_CameraDone.Address, (Int16)1);
}
else
{
SendTaskMessage($"多相机坐标合并请求已结束或被取消，state={state}", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_CameraDone.Address, (Int16)0);
}
}
}
// 螺丝供料器螺丝递减
else if (addressConfig.In_PickINC.Address.Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastPickINC != state)
{
_LastPickINC = state;
}
else
{
return;
}
if (state != 0)
{
SendTaskMessage($"螺丝供料器...", MessageLevel.Info);
await plc.WriteNodeAsync(addressConfig.In_PickINC.Address, (Int16)0);
}
}
}
// PLC请求二维码拍照
else if (addressConfig.In_QrCodePhotoRequest.Address.Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastQrCodePhotoRequest != state)
{
_LastQrCodePhotoRequest = state;
}
else
{
return;
}
if (state == 1)
{
SendTaskMessage("收到PLC二维码拍照请求", MessageLevel.Debug);
// 四、几个非常重要的细节（工程级）
//1.Reset() 一定在发送命令前
//_scanDoneEvent.Reset();
//否则：
//上一次扫码的 Set() 还在
//本次 Wait() 会直接通过（严重 bug）
// 2.Wait() 不要直接在 UI 线程
//你这里是 async，用：
//await Task.Run(() => _scanDoneEvent.Wait(3000));
ScanValue = "";
_scanDoneEvent.Reset(); // 重要：先关门
await Scan_Client.SendAsync("T\r\n");
// 等待扫码结果，最多 3 秒
bool scanOk = await Task.Run(() => _scanDoneEvent.Wait(3000));
if (scanOk && !ScanValue.IsNullOrWhiteSpace())
{
PartSN = ScanValue;
//await plc.WriteNodeAsync(addressConfig.Out_PartCode.Address, PartSN);
SendTaskMessage($"二维码拍照成功,接收到值:{ScanValue}", MessageLevel.Info);
var stationConfig = _configService.GetDeviceInfo(0);
if (stationConfig.EnableMES)
{
(bool isSuccess, string response) = await _mesService.StationGetEx2Async(0, PartSN, "", 2);//询问零件码,是否可以使用
if (!isSuccess)//如果二维码已使用，则返回false
{
await plc.WriteNodeAsync(addressConfig.Out_QrCodePhotoResault.Address, (Int16)3);
return;
}
}
}
else
{
SendTaskMessage("二维码拍照失败或超时", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_QrCodePhotoResault.Address, (short)2);
}
}
else
{
SendTaskMessage("二维码拍照点位发送信号已关闭", MessageLevel.Alarm);
await plc.WriteNodeAsync(addressConfig.Out_QrCodePhotoResault.Address, (Int16)0);
}
}
}
// 抛料计数
else if (addressConfig.In_Throw.Address.Contains(tuple.nodeId))
{
if (tuple.value is bool state)
{
if (_LastThrowExe != state)
{
_LastThrowExe = state;
}
else
{
return;
}
if (state)
{
SendTaskMessage("收到抛料信号", MessageLevel.Info);
await _systemDatabaseService.RecordThrowNumberAsync(new ThrowRecord()
{
DayTime = DateTime.Now,
ThrowCount = 1
});
}
}
}
else
{
// 过站检查
for (int i = 0; i < 10; i++)
{
if (string.Format(addressConfig.In_MesCheck.Address, i).Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastMesCheck[i] != state)
{
_LastMesCheck[i] = state;
}
else
{
return;
}
var code = plc.ReadNode(string.Format(addressConfig.In_Code.Address, i));
string comp = "";
//过站请求
if (state == 1)
{
// 这里缺少从MES获取产品配方的内容，需要补充
_LastMesCheckTime[i] = (await _mesService.GetServerTimeAsync(i, code, 2)).Now;
//获取当前工位的配置
var stationConfig = _configService.GetDeviceInfo(i);
if (stationConfig.EnableDoubleMes)
{
SendTaskMessage($"收到{i}:{stationConfig.DeviceName}过站检查请求（当站是否生产）(当前需要双MES验证)...", MessageLevel.Debug);
LogHelper.WriteLogMes($"【mes开始QUERY】");
SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
(bool isSuccess, string response) = await _mesService.StationGetExAsync(i, code, "", 2);//询问mes
if (isSuccess)
{
LogHelper.WriteLogMes($"询问mes成功");
SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);
string ProductMainSN_Temp = "";
string[] item = response.Split('\n');
//获取过度件sn
string snItem = item.FirstOrDefault(f => f.Contains("sn="));
if (snItem != null)
{
ProductMainSN_Temp = snItem.Replace("sn=", "").Trim();
SendTaskMessage($"过度件sn：{ProductMainSN_Temp}", MessageLevel.Info);
}
(bool isSuccess2, string response2) = await _mesService.StationGetAsync(i, ProductMainSN_Temp, "", 2);//询问mes
if (isSuccess2)
{
LogHelper.WriteLogMes($"第二次询问mes成功");
SendTaskMessage($"第二次询问mes成功:{response2}", MessageLevel.Debug);
item = response2.Split('\n');
//获取产品主sn和wo用于后续上传数据使用
snItem = item.FirstOrDefault(f => f.Contains("sn="));
if (snItem != null)
{
ProductMainSN[i] = snItem.Replace("sn=", "").Trim();
if (i == 0)
{
_productService.CurrentProductCode = ProductMainSN[i];
_eventAggregator.GetEvent().Publish(true);//通知界面延迟保存图片，等待MES查询结果返回，避免图片和数据不同步
}
SendTaskMessage($"产品主sn：{ProductMainSN[i]}", MessageLevel.Info);
}
string woItem = item.FirstOrDefault(f => f.Contains("wo="));
if (woItem != null)
{
wo[i] = woItem.Replace("wo=", "").Trim();
SendTaskMessage($"工单信息：{wo[i]}", MessageLevel.Info);
}
string modelItem = item.FirstOrDefault(f => f.Contains("model_num="));
if (modelItem != null)
{
model_num[i] = modelItem.Replace("model_num=", "").Trim();
SendTaskMessage($"model_num：{model_num[i]}", MessageLevel.Info);
}
string colorItem = item.FirstOrDefault(f => f.Contains("color="));
if (colorItem != null)
{
color[i] = colorItem.Replace("color=", "").Trim();
SendTaskMessage($"color：{color[i]}", MessageLevel.Info);
}
//切换产品
if (i == 0)//i=0时才会切换产品
{
var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num[i], color[i]);
if (!string.IsNullOrEmpty(q))
{
ProductList = new ObservableCollection(_productService.GetAllProducts());
Guid productId = Guid.Empty;
foreach (var itt in ProductList)
{
if (itt.Name == q)
{
productId = itt.ID;
break;
}
}
if (currentProduct.ID != productId)
{
//切换产品
_productService.LoadProduct(productId);
_productService.SetCurrentProduct(productId);
await WritePositionToPlcAsync();
SendTaskMessage($"切换产品成功", MessageLevel.Debug);
}
}
}
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);
}
else
{
LogHelper.WriteLogMes($"第二次询问mes失败");
SendTaskMessage($"第二次询问mes失败:{response2}", MessageLevel.Error);
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)2);
}
}
else
{
LogHelper.WriteLogMes($"询问mes失败");
SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)2);
}
LogHelper.WriteLogMes($"【mes结束QUERY】");
SendTaskMessage($"mes结束QUERY", MessageLevel.Info);
}
else if (stationConfig.EnableMES)
{
SendTaskMessage($"收到{i}:{stationConfig.DeviceName}过站检查请求（当站是否生产）(当前不需要双MES验证)...", MessageLevel.Debug);
LogHelper.WriteLogMes($"【mes开始QUERY】");
SendTaskMessage($"mes开始QUERY", MessageLevel.Info);
(bool isSuccess, string response) = await _mesService.StationGetAsync(i, code, "", 2);//询问mes
if (isSuccess)
{
string[] item = response.Split('\n');
//获取产品主sn和wo用于后续上传数据使用
string snItem = item.FirstOrDefault(f => f.Contains("sn="));
if (snItem != null)
{
ProductMainSN[i] = snItem.Replace("sn=", "").Trim();
if (i == 0)
{
_productService.CurrentProductCode = ProductMainSN[i];
_eventAggregator.GetEvent().Publish(true);//通知界面延迟保存图片，等待MES查询结果返回，避免图片和数据不同步
}
SendTaskMessage($"产品主sn：{ProductMainSN[i]}", MessageLevel.Info);
}
string woItem = item.FirstOrDefault(f => f.Contains("wo="));
if (woItem != null)
{
wo[i] = woItem.Replace("wo=", "").Trim();
SendTaskMessage($"工单信息：{wo[i]}", MessageLevel.Info);
}
string modelItem = item.FirstOrDefault(f => f.Contains("model_num="));
if (modelItem != null)
{
model_num[i] = modelItem.Replace("model_num=", "").Trim();
SendTaskMessage($"model_num：{model_num[i]}", MessageLevel.Info);
}
string colorItem = item.FirstOrDefault(f => f.Contains("color="));
if (colorItem != null)
{
color[i] = colorItem.Replace("color=", "").Trim();
SendTaskMessage($"color：{color[i]}", MessageLevel.Info);
}
LogHelper.WriteLogMes($"询问mes成功");
SendTaskMessage($"询问mes成功:{response}", MessageLevel.Debug);
//切换产品
if (i == 0)//i=0时才会切换产品
{
var q = await _systemDatabaseService.QueryProductFromMesAsync(model_num[i], color[i]);
if (!string.IsNullOrEmpty(q))
{
ProductList = new ObservableCollection(_productService.GetAllProducts());
Guid productId = Guid.Empty;
foreach (var itt in ProductList)
{
if (itt.Name == q)
{
productId = itt.ID;
break;
}
}
if (currentProduct.ID != productId)
{
//切换产品
_productService.LoadProduct(productId);
_productService.SetCurrentProduct(productId);
await WritePositionToPlcAsync();
SendTaskMessage($"切换产品成功", MessageLevel.Debug);
}
}
}
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);
}
else
{
LogHelper.WriteLogMes($"询问mes失败");
SendTaskMessage($"询问mes失败:{response}", MessageLevel.Error);
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)2);
}
LogHelper.WriteLogMes($"【mes结束QUERY】");
SendTaskMessage($"mes结束QUERY", MessageLevel.Info);
}
else
{
ProductMainSN[i] = DateTime.Now.ToString();
if (i == 0)
{
_productService.CurrentProductCode = ProductMainSN[i];
_eventAggregator.GetEvent().Publish(true);//通知界面延迟保存图片，等待MES查询结果返回，避免图片和数据不同步
}
LogHelper.WriteLogMes("未启用mes");
SendTaskMessage("未启用mes", MessageLevel.Error);
//产品发生改变并且供料器发生了变化时，需要通知PLC进行取料更改
await plc.WriteNodeAsync(addressConfig.Out_ScrewFeederIsChanged.Address, (Int16)1); //不发生改变
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)1);
}
}
// 上传本站数据
else if (state == 2)
{
DFC.Clear();
//获取当前工位的配置
var stationConfig = _configService.GetDeviceInfo(i);
SendTaskMessage($"收到{i}:{stationConfig.DeviceName}上传本站数据请求...", MessageLevel.Debug);
//从服务器中获取当前时间
var serverTimeResult = await _mesService.GetServerTimeAsync(i, code, 2);
double ct = serverTimeResult.Now.Subtract(_LastMesCheckTime[i]).TotalSeconds;
if (i == 0)
{
CTtime = ct;
_eventAggregator.GetEvent().Publish(false);//通知界面延迟保存图片，等待MES查询结果返回，避免图片和数据不同步
}
//读取产品结果
Int16 resultIndex = plc.ReadNode(string.Format(addressConfig.In_Result.Address, i));
//读取压力值
float pressure = plc.ReadNode(string.Format(addressConfig.In_PressureValue.Address, i));
AssemblyRecord assemblyRecord = new AssemblyRecord();
assemblyRecord.ProductSN = ProductMainSN[i];
assemblyRecord.RecipeName = currentProduct.Name;
assemblyRecord.PartSN = PartSN;
assemblyRecord.AssemblyDurationSeconds = ct;
assemblyRecord.AssemblyPressure = pressure;
assemblyRecord.DeviceId = i;
assemblyRecord.DeviceName = stationConfig.DeviceName;
assemblyRecord.OperatorName = _systemDatabaseService.GetCurrentUser().UserName;
assemblyRecord.Success = resultIndex == 1 ? true : false;
assemblyRecord.DownCameraCoord1 = "";
assemblyRecord.DownCameraCoord2 = "";
assemblyRecord.DownCameraCoord3 = "";
assemblyRecord.DownCameraCoord4 = "";
assemblyRecord.PickMoveCameraCoord = "";
assemblyRecord.PlaceMoveCameraCoord1 = "";
assemblyRecord.PlaceMoveCameraCoord2 = "";
assemblyRecord.PlaceMoveCameraCoord3 = "";
assemblyRecord.PlaceMoveCameraCoord4 = "";
assemblyRecord.PlaceActualCoord = "";
//目前只记录当前站
if (i == 0)
{
await _systemDatabaseService.RecordProductionAsync(new ProductionRecord()
{
ProductName = currentProduct.Name,
ProductCode = ProductMainSN[i],
DeviceId = i,
DeviceName = "",
Category = resultIndex == 1 ? "OK" : "NG",
Quantity = 1,
Remark = $"TotalSeconds:{ct.ToString("F2")}",
UserName = _systemDatabaseService.GetCurrentUser().UserName,
});
assemblyRecord.DownCameraCoord1 = $"{DowmCameraResults[1].X:F3},{DowmCameraResults[1].Y:F3},{DowmCameraResults[1].Z:F3}";
assemblyRecord.PlaceMoveCameraCoord1 = $"{UpCameraPutResults[1].X:F3},{UpCameraPutResults[1].Y:F3},{UpCameraPutResults[1].Z:F3}";
assemblyRecord.PlaceMoveCameraCoord2 = $"{UpCameraPutResults[2].X:F3},{UpCameraPutResults[2].Y:F3},{UpCameraPutResults[2].Z:F3}";
assemblyRecord.PlaceActualCoord = $"{PlaceActualCoord.X:F3},{PlaceActualCoord.Y:F3},{PlaceActualCoord.Z:F3}";
App.Current.Dispatcher.Invoke(() =>
{
_eventAggregator.GetEvent().Publish(assemblyRecord);
});
}
await _systemDatabaseService.RecordAssemblyAsync(assemblyRecord);
LogHelper.WriteLogMes($"【mes开始ADD】");
SendTaskMessage($"mes开始ADD", MessageLevel.Info);
string assypress = ""; string cc = "";
cc = string.Join(",", mes_cc.OrderBy(kv => kv.Key, StringComparer.Ordinal).Select(kv => kv.Value));
assypress = currentPressure[i].ToString("F2");
SendTaskMessage($"cc:{cc},组装压力:{assypress}", MessageLevel.Debug);
//cc-复检cc,assypress-组装站压力
(bool isSuccess, string response) = await _mesService.SubmitGetAsync(i, ProductMainSN[i], comp, cc, assypress, resultIndex == 1 ? true : false, _LastMesCheckTime[i], serverTimeResult.Now);
if (!stationConfig.EnableMES || isSuccess)
{
LogHelper.WriteLogMes($"上传mes成功");
SendTaskMessage($"上传mes成功", MessageLevel.Debug);
}
else
{
LogHelper.WriteLogMes($"上传mes失败");
SendTaskMessage($"上传mes失败", MessageLevel.Error);
}
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)3);
LogHelper.WriteLogMes($"【mes结束ADD】");
SendTaskMessage($"mes结束ADD", MessageLevel.Info);
//是否保存当前的产品记录至CSV?
if (stationConfig.SaveCsv)
{
//判断锁付路径字符串是否为空，如果不为空则保存，否则不保存
if (!string.IsNullOrEmpty(stationConfig.SaveCsvPath))
{
bool assyPress = resultIndex == 1 ? true : false;
DFC.Clear();
foreach (var item in mes_cc)
{
DFC.Add(new DataFormCtq
{
PPID = ProductMainSN[i],
PROCESS_NAME = stationConfig.DataInfo.PROCESS_NAME,
PROCESS_START_TIME = _LastMesCheckTime[i].ToString("yyyy-MM-ddTHH:mm:ss.fffffff") + "+08:00",
CTQ_NAME = $"CC{item.Key}",
CTQ_VALUE = item.Value,
CTQ_LSL = "",
CTQ_USL = "",
PROCESS_END_TIME = serverTimeResult.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffffff") + "+08:00",
SUPPLIER_NAME = stationConfig.DataInfo.SUPPLIER_NAME,
COMMODITY_TYPE = stationConfig.DataInfo.COMMODITY_TYPE,
REVISION = stationConfig.DataInfo.REVISION,
WO = wo[i],
MFG_LOT = stationConfig.DataInfo.MFG_LOT,
MFG_ASSY_LINE = stationConfig.DataInfo.MFG_ASSY_LINE,
PROCESS_OUTCOME = "Pass",
PROCESS_MACHINE_ID = stationConfig.DataInfo.PROCESS_MACHINE_ID,
CTQ_UNIT_OF_MEASURE = "mm",
ERROR_MESSAGE = assyPress ? "" : "CC OOS",
});
}
DFC.Add(new DataFormCtq
{
PPID = code,
PROCESS_NAME = stationConfig.DataInfo.PROCESS_NAME,
PROCESS_START_TIME = _LastMesCheckTime[i].ToString("yyyy-MM-ddTHH:mm:ss.fffffff") + "+08:00",
CTQ_NAME = "Assy_Pressure",
CTQ_VALUE = Math.Round(double.Parse(assypress), 3).ToString(),
CTQ_LSL = currentProduct.GlobalParamEx.DownPressure.PressureDownLimit.ToString("F3"),
CTQ_USL = currentProduct.GlobalParamEx.DownPressure.PressureUpLimit.ToString("F3"),
PROCESS_END_TIME = serverTimeResult.Now.ToString("yyyy-MM-ddTHH:mm:ss.fffffff") + "+08:00",
SUPPLIER_NAME = stationConfig.DataInfo.SUPPLIER_NAME,
COMMODITY_TYPE = stationConfig.DataInfo.COMMODITY_TYPE,
REVISION = stationConfig.DataInfo.REVISION,
WO = wo[i],
MFG_LOT = stationConfig.DataInfo.MFG_LOT,
MFG_ASSY_LINE = stationConfig.DataInfo.MFG_ASSY_LINE,
PROCESS_OUTCOME = assyPress ? "Pass" : "Fail",
PROCESS_MACHINE_ID = stationConfig.DataInfo.PROCESS_MACHINE_ID,
CTQ_UNIT_OF_MEASURE = "kg",
ERROR_MESSAGE = assyPress ? "" : "Assy_Pressure OOS"
});
bool recordResult = RecordStationResult(i, DFC, ProductMainSN[i], serverTimeResult.Now.Subtract(_LastMesCheckTime[i]).TotalSeconds, _LastMesCheckTime[i], stationConfig.SaveCsvPath);
if (recordResult)
{
SendTaskMessage($"{i}:{stationConfig.DeviceName}产品记录保存成功", MessageLevel.Debug);
//上传数据
try
{
DateTime dt = DateTime.Now;
string filename = $"{ProductMainSN[i]}_{dt.ToString("yyyyMMddHHmmss")}";
var device = _configService.GetDeviceInfo();
(bool isSuc, string resp) = await _mesService.SendFtpFileAsync(ProductMainSN[i], filename);
if (isSuc)
{
LogHelper.WriteLogMes($"上传数据成功");
SendTaskMessage($"上传数据成功", MessageLevel.Debug);
string filePath = $"D:\\image\\Recored\\{dt.ToString("yyyy-MM")}\\{dt.ToString("MM-dd")}\\{currentProduct.Name}\\{ProductMainSN[i]}";
//复制csv
string source_csv = $"{stationConfig.SaveCsvPath}\\{dt.ToString("yyyy-MM")}\\{i}_{stationConfig.DeviceName}_{dt.ToString("yyyy-MM-dd")}.csv";
string target_csv = Path.Combine(filePath, Path.GetFileName(source_csv)); ;
File.Copy(source_csv, target_csv, true);
//复制log
string source_log = $"..\\Log\\LogInfo\\{dt.ToString("yyyy-MM")}\\{dt.ToString("yyyy-MM-dd")}.txt";
string target_log = Path.Combine(filePath, Path.GetFileName(source_log));
File.Copy(source_log, target_log, true);
CompressionImage(filePath, filename, device.Station, device.FixtureId);
}
else
{
LogHelper.WriteLogMes($"上传数据失败");
SendTaskMessage($"上传数据失败", MessageLevel.Error);
}
}
catch (Exception ex)
{
SendTaskMessage($"上传数据时出错:{ex.Message}", MessageLevel.Error);
LogHelper.WriteLogError($"上传数据时出错", ex);
}
}
else
{
SendTaskMessage($"{i}:{stationConfig.DeviceName}产品记录保存失败", MessageLevel.Error);
}
}
else
{
SendTaskMessage($"{i}:{stationConfig.DeviceName}工位未配置保存路径，无法保存产品记录", MessageLevel.Error);
}
}
else
{
SendTaskMessage($"{i}:{stationConfig.DeviceName}工位未配置保存产品记录", MessageLevel.Debug);
}
mes_cc.Clear();
return;
}
else
{
SendTaskMessage($"{i}过站检查信号：state={state}，处理为默认状态", MessageLevel.Alarm);
await plc.WriteNodeAsync(string.Format(addressConfig.Out_MesStatus.Address, i), (Int16)0);
return;
}
}
}
}
//开始/停止 组装/锁附
for (int i = 0; i < 7; i++)
{
//开始组装
if (string.Format(addressConfig.In_WorkStart.Address, i).Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastWorkStart[i] != state)
{
_LastWorkStart[i] = state;
}
else
{
return;
}
var code = plc.ReadNode(string.Format(addressConfig.In_Code.Address, i));
if (state == 1)
{
SendTaskMessage($"收到开始保压信号[{i}]...", MessageLevel.Debug);
// 开始采集压力值
StartPressureCollection(currentProduct.Name, code, i);
}
else
{
SendTaskMessage($"收到关闭开始保压信号[{i}]...", MessageLevel.Debug);
}
}
}
//停止组装
else if (string.Format(addressConfig.In_WorkDone.Address, i).Contains(tuple.nodeId))
{
if (tuple.value is Int16 state)
{
if (_LastWorkDone[i] != state)
{
_LastWorkDone[i] = state;
}
else
{
return;
}
if (state == 1)
{
SendTaskMessage($"收到停止压力信号[{i}]...", MessageLevel.Debug);
//获取当前锁付点
//var screwPoint = currentProduct.ScrewPoints.FirstOrDefault(p => p.Number == positionIndex);
//读取压力值
float pressure = plc.ReadNode(string.Format(addressConfig.In_PressureValue.Address, i));
currentPressure[i] = pressure;
SendTaskMessage($"[{i}]压力：{pressure}", MessageLevel.Info);
await plc.WriteNodeAsync(string.Format(addressConfig.In_WorkDone.Address, i), (Int16)0);
var code = plc.ReadNode(string.Format(addressConfig.In_Code.Address, i));
// 停止采集压力并保存
await StopAndSavePressureCollectionAsync(currentProduct.Name, code, i);
}
else
{
SendTaskMessage($"停止压力信号[{i}]已关闭", MessageLevel.Alarm);
}
}
}
}
}
}
catch (Exception ex)
{
SendTaskMessage(ex.Message, MessageLevel.Error);
}
}
#endregion
#region 方法
private void SendTaskMessage(string msg, MessageLevel level)
{
App.Current.Dispatcher.Invoke(() =>
{
_eventAggregator.GetEvent().Publish(new Models.MessageStruct() { Message = msg, level = level });
});
}
#region Pressure collection helpers
public void InitPressure()
{
for (int i = 0; i < _pressureSamples.Length; i++)
{
_pressureSamples[i] = new List<(DateTime, float)>();
}
for (int i = 0; i < _pressureCts.Length; i++)
{
_pressureCts[i] = new CancellationTokenSource();
}
for (int i = 0; i < _pressureTimeoutCts.Length; i++)
{
_pressureTimeoutCts[i] = new CancellationTokenSource();
}
for (int i = 0; i < _pressureLinkedCts.Length; i++)
{
_pressureLinkedCts[i] = new CancellationTokenSource();
}
}
///
/// 开始采集压力值
///
/// 配方名称
/// 产品编号
/// 编号
private void StartPressureCollection(string productName, string productCode, int Index)
{
try
{
// cancel existing if any
//_pressureCts[Index]?.Cancel();
//_pressureTimeoutCts[Index]?.Cancel();
//_pressureLinkedCts[Index]?.Dispose();
_pressureSamples[Index]?.Clear();
_pressureCts[Index] = new CancellationTokenSource();
_pressureTimeoutCts[Index] = new CancellationTokenSource();
// timeout after configured seconds
_pressureTimeoutCts[Index].CancelAfter(TimeSpan.FromSeconds(_pressureMaxDurationSeconds));
// link tokens so either stop or timeout cancels
_pressureLinkedCts[Index] = CancellationTokenSource.CreateLinkedTokenSource(_pressureCts[Index].Token, _pressureTimeoutCts[Index].Token);
var token = _pressureLinkedCts[Index].Token;
var addressConfig = _configService.GetPlcAddresses();
var plc = _plcService.GetPlcByNumber(addressConfig.PlcNo) as OpcUaClientPLC;
if (plc == null || !plc.IsConnected) return;
Task.Run(async () =>
{
SendTaskMessage($"Pressure collection started for position {Index}", MessageLevel.Debug);
while (!token.IsCancellationRequested)
{
try
{
float pressure = plc.ReadNode(string.Format(addressConfig.In_PressureValue.Address, Index));
lock (_pressureSamples[Index])
{
_pressureSamples[Index].Add((DateTime.Now, pressure));
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("采集压力值时出错", ex);
}
await Task.Delay(_pressureSampleIntervalMs);
}
// if cancelled due to timeout
if (_pressureTimeoutCts[Index].IsCancellationRequested && !_pressureCts[Index].IsCancellationRequested)
{
SendTaskMessage("Pressure collection timed out, saving collected data.", MessageLevel.Alarm);
await StopAndSavePressureCollectionAsync(productName, productCode, Index);
}
}, token);
}
catch (Exception ex)
{
LogHelper.WriteLogError("StartPressureCollection error", ex);
}
}
///
/// 停止采集并保存压力数据
///
///
///
///
///
private async Task StopAndSavePressureCollectionAsync(string productName, string productCode, int Index)
{
try
{
// cancel sampling
//_pressureCts[Index]?.Cancel();
// allow worker to observe cancel
await Task.Delay(50);
List<(DateTime Timestamp, float Value)> snapshot;
lock (_pressureSamples[Index])
{
snapshot = new List<(DateTime, float)>(_pressureSamples[Index]);
}
if (snapshot.Count == 0)
{
SendTaskMessage("No pressure samples collected.", MessageLevel.Info);
return;
}
// save to file under configured path
try
{
//获取系统参数
var systemConfig = _configService.GetSystemConfiguration();
if (systemConfig.PressureSensorConfig == null || systemConfig.PressureSensorConfig.Count <= 0)
{
SendTaskMessage("当前没有配置任何压力传感器！", MessageLevel.Alarm);
return;
}
//获取当前压力传感器配置
var pressureSensorConfig = systemConfig.PressureSensorConfig.FirstOrDefault(p => p.SensorId == Index);
if (pressureSensorConfig == null)
{
SendTaskMessage($"当前压力传感器配置不存在！- {Index}", MessageLevel.Alarm);
return;
}
//PressureFinishNotification : Prism.Events.PubSubEvent<(bool IsSuccess, int Index, (DateTime Timestamp, float Value)[] values,string SavePath )>
string basePath = pressureSensorConfig?.PressureCurvePath ?? Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string datePath = DateTime.Now.ToString("yyyy-MM") + "\\" + DateTime.Now.ToString("yyyy-MM-dd") + "\\";
string dirPath = Path.Combine(basePath, datePath, productName ?? "UnknownProduct", productCode ?? DateTime.Now.ToString("yyyyMMddHHmmssfff"));
if (!Directory.Exists(dirPath)) Directory.CreateDirectory(dirPath);
string csvfileName = $"pressure-{productCode}-{Index}-{DateTime.Now.ToString("HHmmss")}.csv";
string csvPath = Path.Combine(dirPath, csvfileName);
string pngfileName = $"pressure-{productCode}-{Index}-{DateTime.Now.ToString("HHmmss")}.png";
string pngPath = Path.Combine(dirPath, pngfileName);
if (!pressureSensorConfig.IsSavePressureCurve)
{
csvPath = string.Empty;
pngPath = string.Empty;
}
App.Current.Dispatcher.Invoke(() =>
{
_eventAggregator.GetEvent().Publish((true, Index, snapshot.ToArray(), pngPath));
});
//判断是否保存锁付曲线
if (pressureSensorConfig.IsSavePressureCurve)
{
if (!string.IsNullOrEmpty(csvPath))
{
var sb = new StringBuilder();
sb.AppendLine("Timestamp,Value");
foreach (var s in snapshot)
{
sb.AppendLine($"{s.Timestamp:O},{s.Value}");
}
File.WriteAllText(csvPath, sb.ToString());
SendTaskMessage($"Pressure samples saved to {csvPath}", MessageLevel.Debug);
}
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("保存压力采样文件时出错", ex);
SendTaskMessage("保存压力采样文件时出错: " + ex.Message, MessageLevel.Error);
}
}
catch (Exception ex)
{
LogHelper.WriteLogError("StopAndSavePressureCollectionAsync error", ex);
}
finally
{
try
{
_pressureLinkedCts[Index]?.Cancel();
_pressureLinkedCts[Index]?.Dispose();
_pressureTimeoutCts[Index]?.Dispose();
_pressureCts[Index]?.Dispose();
_pressureSamples[Index]?.Clear();
}
catch { }
}
}
#endregion
private async void DoYieldTime(object state)
{
try
{
//获取当前产品
var currentproduct = _productService.GetCurrentProduct();
if (currentproduct == null) return;
TotalQuantity = await _systemDatabaseService.GetOverallProductionAsync(currentproduct.Name);
TotalQuantityToday = await _systemDatabaseService.GetTodayProductionAsync(currentproduct.Name);
CurrentUPH = await _systemDatabaseService.GetLastHourProductionAsync(currentproduct.Name);
//
ThrowNumber = await _systemDatabaseService.GetThrowNumberAsync();
NgNumber = await _systemDatabaseService.GetNGProductionAsync(currentproduct.Name);
Yield = ((double)TotalQuantityToday - (double)NgNumber) / (double)TotalQuantityToday * 100;
}
catch (Exception)
{
}
}
#region vm启动检测
///
/// 杀死所有VM有关进程
///
public void KillVMProcess()
{
KillProcess("VisionMasterServerApp");
KillProcess("VisionMaster");
KillProcess("VmModuleProxy.exe");
KillProcess("vServerApp.exe");
}
///
/// 杀死指定进程名的进程
///
///
public void KillProcess(string strKillName)
{
foreach (System.Diagnostics.Process p in System.Diagnostics.Process.GetProcesses())
{
if (p.ProcessName.Contains(strKillName))
{
try
{
p.Kill();
p.WaitForExit();
}
catch (Exception ex)
{
LogHelper.WriteLogError($"杀死进程:{strKillName}时失败！", ex);
}
}
}
}
#endregion
///
/// 记录工位的结果，其他工位要存储的数据项按照键值对集合的形式传入，键为数据项名称，值为数据项的值
///
///
///
///
///
///
///
///
///
private bool RecordStationResult(int stationIndex, IEnumerable dfcs, string productMainSN, double ct, DateTime timestamp, string savePath, bool isFirstEnter = true)
{
try
{
//获取当前工位的配置
var stationConfig = _configService.GetDeviceInfo(stationIndex);
if (stationConfig == null) return false;
//如果保存路径为空，则不保存
if (string.IsNullOrEmpty(savePath)) return false;
string fullPath = savePath;
//如果保存路径是一个文件路径，则直接保存，否则按照工位和日期进行保存
if (File.Exists(savePath) || Path.HasExtension(savePath))
{
fullPath = savePath;
//如果路径不存在，则创建
// 创建目录
string directory = Path.GetDirectoryName(fullPath);
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
}
else
{
//结果保存至CSV文件，文件名格式：savePath\yyyy-MM\工位编号_工位名称_yyyy-MM-dd.csv
string datePath = timestamp.ToString("yyyy-MM") + "\\";
string dirPath = Path.Combine(savePath, datePath);
if (!Directory.Exists(dirPath)) Directory.CreateDirectory(dirPath);
string fileName = $"{stationIndex}_{stationConfig.DeviceName}_{timestamp.ToString("yyyy-MM-dd")}.csv";
fullPath = Path.Combine(dirPath, fileName);
}
StringBuilder sb = new StringBuilder();
if (!File.Exists(fullPath))
{
sb.Append("PPID,PROCESS_NAME,PROCESS_START_TIME,CTQ_NAME,CTQ_VALUE,CTQ_LSL,CTQ_USL,PROCESS_END_TIME,SUPPLIER_NAME,COMMODITY_TYPE,REVISION,WO#,MFG_LOT#," +
"MFG_ASSY_LINE,PROCESS_OUTCOME,PROCESS_MACHINE_ID,CTQ_UNIT_OF_MEASURE,ERROR_MESSAGE");
sb.AppendLine();
}
if (dfcs == null || dfcs.Count() == 0)
{
return false;
}
foreach (var dfc in dfcs)
{
sb.Append($"{dfc.PPID},{dfc.PROCESS_NAME},{dfc.PROCESS_START_TIME},{dfc.CTQ_NAME},{dfc.CTQ_VALUE},{dfc.CTQ_LSL},{dfc.CTQ_USL},{dfc.PROCESS_END_TIME},{dfc.SUPPLIER_NAME},{dfc.COMMODITY_TYPE},{dfc.REVISION},{dfc.WO},{dfc.MFG_LOT},{dfc.MFG_ASSY_LINE},{dfc.PROCESS_OUTCOME},{dfc.PROCESS_MACHINE_ID},{dfc.CTQ_UNIT_OF_MEASURE},{dfc.ERROR_MESSAGE}");
sb.AppendLine();
}
// 使用 StreamWriter 以追加模式打开文件
StreamWriter sw = new StreamWriter(fullPath, true, Encoding.UTF8);
sw.Write(sb.ToString());
sw.Close();
sw.Dispose();
return true;
}
catch (Exception ex)
{
if (!isFirstEnter)
{
return false;
}
LogHelper.WriteLogError("记录其他工位结果时出错!", ex);
//我希望在这里生成一个临时文件来保存这次的记录，因为如果本地文件被打开时可能会导致无法写入，如果不保存的话可能会丢失这次的记录，所以我想在这里生成一个临时文件来保存这次的记录
//生成临时文件的路径，格式为savePath\yyyy-MM\工位编号_yyyy-MM-dd_temp\工位编号_yyyy-MM-dd_HH-mm-ss-fff_temp.csv
string datePath = timestamp.ToString("yyyy-MM") + "\\";
string tempDirPath = Path.Combine(savePath, datePath, $"{stationIndex}_{timestamp.ToString("yyyy-MM-dd")}_temp");
string tempFileName = $"{stationIndex}_{timestamp.ToString("yyyy-MM-dd_HH-mm-ss-fff")}_temp.csv";
RecordStationResult(stationIndex, dfcs, productMainSN, ct, timestamp, tempFileName, false);
return false;
}
}
#region 压缩图片文件夹
///
/// 压缩文件
///
/// 原路径
/// 压缩后文件的名称
/// mes中的station
/// mes中的fixtureID
public async void CompressionImage(string sourcePath, string zipname, string station, string fixid)
{
string zipPath = "";
try
{
SendTaskMessage($"开始压缩文件", MessageLevel.Info);
await Task.Run(() =>
{
zipPath = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}\\{zipname}.zip";//生成的zip文件路径
string path = $"Z:\\{station}\\{fixid}\\{DateTime.Now.ToString("yyyyMMdd")}";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
ZipFile.CreateFromDirectory(sourcePath, zipPath);
});
}
catch (Exception ex)
{
LogHelper.WriteLogError($"压缩文件时出错", ex);
}
}
#endregion
#endregion
}
}