diff --git a/CapMachine.Wpf/App.xaml.cs b/CapMachine.Wpf/App.xaml.cs index f917868..d689086 100644 --- a/CapMachine.Wpf/App.xaml.cs +++ b/CapMachine.Wpf/App.xaml.cs @@ -132,6 +132,8 @@ namespace CapMachine.Wpf containerRegistry.RegisterSingleton(); containerRegistry.RegisterSingleton(); containerRegistry.RegisterSingleton(); + containerRegistry.RegisterSingleton(); + ////注册设备服务 //containerRegistry.RegisterSingleton(); containerRegistry.RegisterSingleton(); diff --git a/CapMachine.Wpf/CanDrive/ToomossCan.cs b/CapMachine.Wpf/CanDrive/ToomossCan.cs index 5dcef68..bda0124 100644 --- a/CapMachine.Wpf/CanDrive/ToomossCan.cs +++ b/CapMachine.Wpf/CanDrive/ToomossCan.cs @@ -33,6 +33,10 @@ namespace CapMachine.Wpf.CanDrive { ContainerProvider = containerProvider; HighSpeedDataService = ContainerProvider.Resolve(); + + //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000 + TicksPerMs = Stopwatch.Frequency / 1000.0; + } /// @@ -54,6 +58,11 @@ namespace CapMachine.Wpf.CanDrive /// public HighSpeedDataService HighSpeedDataService { get; set; } + /// + /// 驱动消息数据处理 + /// + public HightDriveMsgService HightDriveMsgService { get; set; } + /// /// 开始Dbc文件写入 /// @@ -288,7 +297,6 @@ namespace CapMachine.Wpf.CanDrive { Console.WriteLine("Get CAN Speed Success!"); } - } /// @@ -456,6 +464,24 @@ namespace CapMachine.Wpf.CanDrive set { _IsCycleSend = value; RaisePropertyChanged(); } } + private bool _IsSendOk; + /// + /// 发送报文是否OK + /// + public bool IsSendOk + { + get { return _IsSendOk; } + set + { + if (_IsSendOk != value) + { + RaisePropertyChanged(); + _IsSendOk = value; + } + + + } + } /// /// 循环发送数据 @@ -486,6 +512,7 @@ namespace CapMachine.Wpf.CanDrive /// /// 循环发送数据 + /// 这个是通过延迟处理的，发送的周期时间可能不精准 /// public void StartCycleSendMsg() { @@ -543,6 +570,192 @@ namespace CapMachine.Wpf.CanDrive } + + #region 精确发送报文数据 + + // 添加取消标记源字段用于停止任务 + private CancellationTokenSource CycleSendCts; + + /// + /// 计算每毫秒对应的ticks数（只需计算一次） + /// + private double TicksPerMs; + + // 类成员变量定义 精确记时用 + private readonly Stopwatch Stopwatcher = new Stopwatch(); + private long NextExecutionTime; + // 计算需要等待的时间 + private long CurrentTime; + private long DelayTicks; + private int DelayMs; + + private static readonly Random _random = new Random(); + + /// + /// 精确周期发送CAN数据 + /// + public void StartPrecisionCycleSendMsg() + { + // 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务 + var cancellationTokenSource = new CancellationTokenSource(); + var token = cancellationTokenSource.Token; + + // 保存取消标记，以便在停止时使用 + CycleSendCts = cancellationTokenSource;//将取消标记源保存到类的成员变量CycleSendCts，这样在外部调用停止方法时可以访问它 + NextExecutionTime = 0;//初始化NextExecutionTime为0，这个变量用于记录下一次执行的目标时间点 + + + CycleSendTask = Task.Factory.StartNew(async () => + { + try + { + // 设置当前线程为高优先级 + Thread.CurrentThread.Priority = ThreadPriority.AboveNormal; + + // 初始化完成后开始计时 + Stopwatcher.Restart(); + // 预先计算固定值 + long CycleInTicks = (long)(SendCycle * TicksPerMs); + //临时测试用 + long lastTicks = Stopwatcher.ElapsedTicks; + //IsCycleSend + while (IsCycleSend && !token.IsCancellationRequested) + { + try + { + // 计算下一次执行时间点 ，将当前设置的发送周期SendCycle(毫秒)转换为Stopwatch的计时单位(tick)，累加到NextExecutionTime上 + NextExecutionTime += CycleInTicks; // 转换为Stopwatch计时单位 + + // 获取当前时间点，以Stopwatch的tick为单位 + CurrentTime = Stopwatcher.ElapsedTicks; + //计算需要等待的时间，即目标时间点(NextExecutionTime)与当前时间点(CurrentTime)的差值 + DelayTicks = NextExecutionTime - CurrentTime; + + // 如果还有等待时间，则等待，只有在目标时间点还未到达时才执行等待 + if (DelayTicks > 0) + { + ////此时是需要等待的，那么需要等待多久呢， 将需等待的tick数转换回毫秒 + DelayMs = (int)(DelayTicks / TicksPerMs); + //20这个数据是预估和测试的，可能跟Windows抖动误差就是20ms左右，当然可以不用这个IF()判断，直接SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime);但是会导致当前独占一个CPU核心线程 + //所以设置一个20的阈值，20ms以下的延迟使用SpinWait.SpinUntil进行自旋等待，20ms以上的延迟使用Task.Delay进行异步等待，让CPU不至于一直的独占 + if (DelayMs <= 20) + { + SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime); + } + else + { + ////使用Task.Delay进行异步等待，大部分等待时间通过这种方式完成，避免线程阻塞 + await Task.Delay(DelayMs - 20, token); + //// 使用SpinWait.SpinUntil进行精确的微调等待。自旋等待会占用CPU资源，但能提供更高的定时精度，确保在精确的时间点执行 + ////上面的Task.Delay可能会因为系统调度等原因导致实际执行时间稍晚于预期，因此在这里使用SpinWait.SpinUntil来确保在精确的时间点执行 + SpinWait.SpinUntil(() => Stopwatcher.ElapsedTicks >= NextExecutionTime); + } + } + + // 如果已经超过了计划时间，立即执行并重新校准 + if (Stopwatcher.ElapsedTicks >= NextExecutionTime + CycleInTicks) + { + //检测是否发生了严重延迟(超过一个周期)。如果当前时间已经超过了下一次计划时间，则说明系统负载过高或其他原因导致无法按时执行， + //此时重置NextExecutionTime为当前时间，避免连续的延迟累积 + // 严重延迟，重新校准 + NextExecutionTime = Stopwatcher.ElapsedTicks; + Console.WriteLine("定时发送延迟过大，重新校准时间"); + } + + // 使用Stopwatch记录实际的执行间隔，而不是DateTime + Console.WriteLine($"--实际间隔(ms): {(Stopwatcher.ElapsedTicks - lastTicks) / TicksPerMs:F3}, 目标: {SendCycle}"); + lastTicks = Stopwatcher.ElapsedTicks; + //Console.WriteLine($"--当前时间(毫秒): {DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}"); + + // 执行发送CAN逻辑 + { + + var GroupMsg = CmdData.GroupBy(x => x.MsgName); + USB2CAN.CAN_MSG[] CanMsg = new USB2CAN.CAN_MSG[GroupMsg.Count()]; + for (int i = 0; i < GroupMsg.Count(); i++) + { + CanMsg[i] = new USB2CAN.CAN_MSG(); + CanMsg[i].Data = new Byte[64]; + } + + IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))); + int Index = 0; + //循环给MSG赋值数据 + foreach (var itemMsg in GroupMsg) + { + foreach (var itemSignal in itemMsg) + { + CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue); + } + CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend); + CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG)); + Index++; + } + + //通过DBC写入数据后生成CanMsg + //将信号值填入CAN消息里面 + + //释放申请的临时缓冲区 + Marshal.FreeHGlobal(msgPtSend); + + //发送CAN数据 + int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length); + if (SendedNum >= 0) + { + //Console.WriteLine("Success send frames:{0}", SendedNum); + IsSendOk=true; + } + else + { + //Console.WriteLine("Send CAN data failed! {0}", SendedNum); + IsSendOk = false; + } + + } + + } + catch (TaskCanceledException) + { + // 任务被取消，正常退出 + break; + } + catch (Exception ex) + { + Console.WriteLine($"CAN周期发送异常: {ex.Message}"); + // 短暂暂停避免异常情况下CPU占用过高 + await Task.Delay(10, token); + } + } + } + catch (Exception ex) + { + // 确保在任何情况下（正常退出、异常、取消）都会停止计时器 + Stopwatcher.Stop(); + + // 清理其他可能的资源 + Console.WriteLine("CAN周期发送任务已结束，资源已清理"); + } + finally + { + // 确保在任何情况下（正常退出、异常、取消）都会停止计时器 + Stopwatcher.Stop(); + } + + }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default); + } + + + /// + /// 修改停止发送的方法 + /// + public void StopCycleSendMsg() + { + IsCycleSend = false; + CycleSendCts?.Cancel(); + } + + #endregion + /// /// 循环获取CAN消息 /// @@ -585,6 +798,15 @@ namespace CapMachine.Wpf.CanDrive MsgData = BitConverter.ToString(CanMsgBuffer[i].Data), Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") }); + + //报文给高速报文处理服务 + await HightDriveMsgService.AddMessageAsync(new Models.HighSpeed.CommMsg() + { + Category = "CAN", + MsgInfo = "0x" + CanMsgBuffer[i].ID.ToString("X8"), + MsgData = BitConverter.ToString(CanMsgBuffer[i].Data), + Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff") + }); } } else if (CanNum == 0) diff --git a/CapMachine.Wpf/CapMachine.Wpf.csproj b/CapMachine.Wpf/CapMachine.Wpf.csproj index c175f67..b69e6ea 100644 --- a/CapMachine.Wpf/CapMachine.Wpf.csproj +++ b/CapMachine.Wpf/CapMachine.Wpf.csproj @@ -717,6 +717,7 @@ + diff --git a/CapMachine.Wpf/Models/ProRunTimeCalc.cs b/CapMachine.Wpf/Models/ProRunTimeCalc.cs index def81d0..513ff42 100644 --- a/CapMachine.Wpf/Models/ProRunTimeCalc.cs +++ b/CapMachine.Wpf/Models/ProRunTimeCalc.cs @@ -95,7 +95,7 @@ namespace CapMachine.Wpf.Models PauseTotalSecTime = 0; //结束时间信息 - EndTimeInfo = ProStartDt.AddSeconds(PauseTotalSecTime).ToString("yyyy-MM-dd HH:mm:ss"); + EndTimeInfo = ProStartDt.AddSeconds(TotalProSec).ToString("yyyy-MM-dd HH:mm:ss"); } /// @@ -120,7 +120,7 @@ namespace CapMachine.Wpf.Models //统计的暂停的时间 var PauseTime = (PauseEndDt - PauseStartDt).TotalSeconds; PauseTotalSecTime = PauseTotalSecTime + (int)Math.Round(PauseTime); - EndTimeInfo = ProStartDt.AddSeconds(PauseTotalSecTime).ToString("yyyy-MM-dd HH:mm:ss"); + EndTimeInfo = ProStartDt.AddSeconds(TotalProSec+ PauseTotalSecTime).ToString("yyyy-MM-dd HH:mm:ss"); CycleTimer.Start(); diff --git a/CapMachine.Wpf/Services/CanDriveService.cs b/CapMachine.Wpf/Services/CanDriveService.cs index 6cf565f..751fca9 100644 --- a/CapMachine.Wpf/Services/CanDriveService.cs +++ b/CapMachine.Wpf/Services/CanDriveService.cs @@ -231,7 +231,8 @@ namespace CapMachine.Wpf.Services { ToomossCanDrive.IsCycleSend = true; ToomossCanDrive.CmdData = CmdData; - ToomossCanDrive.StartCycleSendMsg(); + //ToomossCanDrive.StartCycleSendMsg(); + ToomossCanDrive.StartPrecisionCycleSendMsg(); } else { diff --git a/CapMachine.Wpf/Services/HighSpeedDataService.cs b/CapMachine.Wpf/Services/HighSpeedDataService.cs index bc82552..ec0c10a 100644 --- a/CapMachine.Wpf/Services/HighSpeedDataService.cs +++ b/CapMachine.Wpf/Services/HighSpeedDataService.cs @@ -29,7 +29,7 @@ namespace CapMachine.Wpf.Services /// public class HighSpeedDataService : BindableBase { - public HighSpeedDataService(ConfigService configService, ILogService logService, IFreeSql FreeSql,IContainerProvider containerProvider) + public HighSpeedDataService(ConfigService configService, ILogService logService, IFreeSql FreeSql, IContainerProvider containerProvider) { ConfigService = configService; LogService = logService; @@ -112,13 +112,13 @@ namespace CapMachine.Wpf.Services // new CommMsg() { Category = "CAN5",MsgInfo = "0x000003E3",Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"),MsgData = "33 00 00 00 37 00 04 00"}, //}; - /// - /// 周期定时器 - /// - private System.Timers.Timer CycleTimer { get; set; } + /// + /// 周期定时器 + /// + private System.Timers.Timer CycleTimer { get; set; } - private bool _IsEnable=true; + private bool _IsEnable = true; /// /// 是否启用 /// @@ -208,7 +208,7 @@ namespace CapMachine.Wpf.Services } #endregion - + #region CSV Helper 数据保存CSV diff --git a/CapMachine.Wpf/Services/HightDriveMsgService.cs b/CapMachine.Wpf/Services/HightDriveMsgService.cs new file mode 100644 index 0000000..279f53c --- /dev/null +++ b/CapMachine.Wpf/Services/HightDriveMsgService.cs @@ -0,0 +1,424 @@ +using CapMachine.Wpf.CanDrive; +using CapMachine.Wpf.Models.HighSpeed; +using Prism.Ioc; +using Prism.Mvvm; +using System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using System.Text; +using System.Threading.Channels; +using System.Threading.Tasks; +using System.Windows.Threading; + +namespace CapMachine.Wpf.Services +{ + /// + /// 高速驱动消息服务 + /// 负载高速的驱动数据的消息和转发 + /// + public class HightDriveMsgService : BindableBase + { + + #region 字段和属性 + + private readonly ILogService LogService; + + /// + /// 接收数据Channel + /// + private readonly Channel ReceiveChannel; + + /// + /// 转发数据Channel + /// + private readonly Channel ForwardChannel; + + /// + /// 取消令牌 + /// + private CancellationTokenSource TaskCancellationTokenSource; + + /// + /// 数据接受处理任务 + /// + private Task ProcessTask; + /// + /// 数据转发处理任务 + /// + private Task ForwardTask; + + /// + /// 显示的消息集合 + /// + public ObservableCollection DisplayMessages { get; set; } = new ObservableCollection(); + + /// + /// 最大显示消息数量 + /// + public int MaxDisplayCount { get; set; } = 200; + + /// + /// 是否启用CAN报文显示 + /// + private bool _IsDisplayEnabled=true; + public bool IsDisplayEnabled + { + get { return _IsDisplayEnabled; } + set + { + SetProperty(ref _IsDisplayEnabled, value); + if (!value) + { + // 不显示时清空数据节省内存 + App.Current.Dispatcher.Invoke(() => DisplayMessages.Clear()); + } + } + } + + /// + /// 是否启用CAN数据转发 + /// + private bool _IsForwardEnabled; + public bool IsForwardEnabled + { + get { return _IsForwardEnabled; } + set { SetProperty(ref _IsForwardEnabled, value); } + } + + #endregion + + #region 构造和初始化 + + /// + /// 构造函数 + /// + /// 容器服务提供者 + /// 日志服务 + public HightDriveMsgService(ILogService logService) + { + LogService = logService; + + // 创建接收Channel，设置容量和溢出策略 + ReceiveChannel = Channel.CreateBounded(new BoundedChannelOptions(100000) + { + FullMode = BoundedChannelFullMode.DropOldest, // 满时删除旧数据 + SingleReader = true, // 单一读取者 + SingleWriter = false // 允许多个写入者 + }); + + // 创建转发Channel + ForwardChannel = Channel.CreateBounded(new BoundedChannelOptions(100000) + { + FullMode = BoundedChannelFullMode.DropOldest, + SingleReader = true, + SingleWriter = false + }); + + // 初始化服务 + Initialize(); + } + + /// + /// 初始化服务 + /// + private void Initialize() + { + TaskCancellationTokenSource = new CancellationTokenSource(); + + // 启动数据处理任务 + ProcessTask = Task.Run(ProcessMessagesAsync); + + // 启动数据转发任务 + ForwardTask = Task.Run(ForwardMessagesAsync); + + //LogService.Info("HightDriveMsgService初始化完成"); + } + + #endregion + + #region 公共方法 + + /// + /// 添加CAN消息进行处理 + /// + /// CAN消息 + /// 是否添加成功 + public async Task AddMessageAsync(CommMsg message) + { + if (message == null) return false; + + try + { + if (IsDisplayEnabled) + { + // 添加到接收Channel + await ReceiveChannel.Writer.WriteAsync(message, TaskCancellationTokenSource.Token); + } + + + // 如果启用转发，也添加到转发Channel 需要判断目标的CAN是否已经打开，如果打开的话，则转发数据 + if (IsForwardEnabled) + { + await ForwardChannel.Writer.WriteAsync(message, TaskCancellationTokenSource.Token); + } + + return true; + } + catch (OperationCanceledException) + { + return false; + } + catch (Exception ex) + { + LogService.Error($"添加CAN消息失败: {ex.Message}"); + return false; + } + } + + /// + /// 批量添加CAN消息 + /// + /// 消息集合 + /// 成功添加的消息数量 + public async Task AddMessagesAsync(IEnumerable messages) + { + if (messages == null) return 0; + + int successCount = 0; + foreach (var message in messages) + { + if (await AddMessageAsync(message)) + { + successCount++; + } + } + + return successCount; + } + + /// + /// 设置转发目标CAN设备 + /// + /// 目标设备 + public void SetForwardTarget(ToomossCan targetDevice) + { + //_targetCanDevice = targetDevice; + LogService.Info($"设置转发目标设备: {(targetDevice != null ? "成功" : "未设置")}"); + } + + /// + /// 清空显示消息 + /// + public void ClearDisplayMessages() + { + App.Current.Dispatcher.Invoke(() => DisplayMessages.Clear()); + } + + #endregion + + + #region 私有方法 + + /// + /// 批量处理消息提高效率 + /// + private List MessageBatch { get; set; } = new List(); + + /// + /// 接受的批次数量 + /// + private int ReciveBatchCount { get; set; } + + /// + /// 转发的批次数量 + /// + private int ForwardBatchCount { get; set; } + + /// + /// 异步处理接收到的消息 + /// + private async Task ProcessMessagesAsync() + { + try + { + while (await ReceiveChannel.Reader.WaitToReadAsync(TaskCancellationTokenSource.Token)) + { + // 清空列表但保留容量 + MessageBatch.Clear(); + + // 读取最多100条消息或直到没有更多消息 + ReciveBatchCount = 0; + while (ReciveBatchCount < 30 && ReceiveChannel.Reader.TryRead(out CommMsg message)) + { + MessageBatch.Add(message); + ReciveBatchCount++; + } + + if (MessageBatch.Count > 0 && IsDisplayEnabled) + { + // 在UI线程更新显示 + await App.Current.Dispatcher.InvokeAsync(() => + { + foreach (var msg in MessageBatch) + { + DisplayMessages.Add(msg); + + // 控制显示消息数量 + while (DisplayMessages.Count > MaxDisplayCount) + { + DisplayMessages.RemoveAt(0); + } + } + }, DispatcherPriority.Background); + } + + // 避免CPU过度使用 + if (ReciveBatchCount == 0) + { + await Task.Delay(20); + } + } + } + catch (OperationCanceledException ex) + { + // 服务被取消，正常退出 + LogService.Error($" 服务被取消，正常退出: {ex.Message}"); + } + catch (Exception ex) + { + LogService.Error($"消息处理任务异常: {ex.Message}"); + } + } + + /// + /// 异步转发消息 + /// + private async Task ForwardMessagesAsync() + { + try + { + while (await ForwardChannel.Reader.WaitToReadAsync(TaskCancellationTokenSource.Token)) + { + //// 只有在启用转发且目标设备可用时才处理 && _targetCanDevice != null && _targetCanDevice.OpenState + //if (IsForwardEnabled) + //{ + // // 批量收集转发消息 + // List canMessages = new List(); + // ForwardBatchCount = 0; + + // // 一次最多处理50条消息 + // while (ForwardBatchCount < 50 && ForwardChannel.Reader.TryRead(out CommMsg message)) + // { + // if (message.Category == "CAN" && !string.IsNullOrEmpty(message.MsgInfo)) + // { + // try + // { + // // 转换为CAN_MSG格式 + // USB2CAN.CAN_MSG canMsg = new USB2CAN.CAN_MSG(); + // canMsg.Data = new byte[64]; + + // // 解析CAN ID + // string msgIdHex = message.MsgInfo.Replace("0x", ""); + // canMsg.ID = Convert.ToUInt32(msgIdHex, 16); + + // // 解析数据 + // string[] dataBytes = message.MsgData.Split('-'); + // canMsg.DataLen = (byte)dataBytes.Length; + + // for (int i = 0; i < dataBytes.Length && i < 64; i++) + // { + // canMsg.Data[i] = Convert.ToByte(dataBytes[i], 16); + // } + + // canMessages.Add(canMsg); + // } + // catch (Exception ex) + // { + // LogService.Error($"转换CAN消息格式失败: {ex.Message}"); + // } + // } + + // ForwardBatchCount++; + // } + + // // 批量发送转发消息 + // if (canMessages.Count > 0) + // { + // //// 在这里调用设备API发送消息 + // //int sendResult = USB2CAN.CAN_SendMsg( + // // _targetCanDevice.DevHandle, + // // _targetCanDevice.WriteCANIndex, + // // canMessages.ToArray(), + // // (uint)canMessages.Count); + + // //if (sendResult < 0) + // //{ + // // LogService.Error($"CAN消息转发失败: 错误码={sendResult}"); + // //} + // //else + // //{ + // // LogService.Debug($"成功转发{sendResult}条CAN消息"); + // //} + // } + //} + //else + //{ + // // 不转发时，清空队列减少内存占用 + // while (ForwardChannel.Reader.TryRead(out _)) { } + // await Task.Delay(10); + //} + } + } + catch (OperationCanceledException) + { + // 服务被取消，正常退出 + } + catch (Exception ex) + { + LogService.Error($"消息转发任务异常: {ex.Message}"); + } + } + + #endregion + + #region IDisposable 实现 + + /// + /// 释放资源 + /// + public void Dispose() + { + try + { + // 发送取消信号 + TaskCancellationTokenSource?.Cancel(); + + // 等待任务完成 + Task.WaitAll(new[] { ProcessTask, ForwardTask }, 1000); + } + catch { /* 忽略取消异常 */ } + finally + { + // 释放资源 + TaskCancellationTokenSource?.Dispose(); + TaskCancellationTokenSource = null; + + // 完成写入器，表示不再接受新数据 + ReceiveChannel.Writer.Complete(); + ForwardChannel.Writer.Complete(); + + // 清空显示数据 + App.Current.Dispatcher.Invoke(() => DisplayMessages.Clear()); + + + + LogService.Info("HightDriveMsgService资源已释放"); + } + } + + #endregion + + } +} diff --git a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs index 06372f0..fbc92dd 100644 --- a/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs +++ b/CapMachine.Wpf/ViewModels/CANConfigViewModel.cs @@ -38,7 +38,7 @@ namespace CapMachine.Wpf.ViewModels public CANConfigViewModel(IDialogService dialogService, IFreeSql freeSql, IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService, ComActionService actionService, LogicRuleService logicRuleService, - ConfigService configService, CanDriveService canDriveService, + ConfigService configService, CanDriveService canDriveService,HightDriveMsgService hightDriveMsgService, IMapper mapper, MachineRtDataService machineRtDataService) { //LogService = logService; @@ -50,6 +50,7 @@ namespace CapMachine.Wpf.ViewModels LogicRuleService = logicRuleService; ConfigService = configService; CanDriveService = canDriveService; + HightDriveMsgService = hightDriveMsgService; Mapper = mapper; this.MachineRtDataService = machineRtDataService; @@ -96,6 +97,7 @@ namespace CapMachine.Wpf.ViewModels public LogicRuleService LogicRuleService { get; } public ConfigService ConfigService { get; } public CanDriveService CanDriveService { get; } + public HightDriveMsgService HightDriveMsgService { get; } public IMapper Mapper { get; } private MachineRtDataService MachineRtDataService { get; } diff --git a/CapMachine.Wpf/Views/CANConfigView.xaml b/CapMachine.Wpf/Views/CANConfigView.xaml index 1ed62c6..a2b3295 100644 --- a/CapMachine.Wpf/Views/CANConfigView.xaml +++ b/CapMachine.Wpf/Views/CANConfigView.xaml @@ -910,114 +910,112 @@ - + + + + + + - + + + + + + - - - - + + + + + - - - - - - + + + + + - - - - - + - - - - - + - + + + + + - + + + + + + - - - - - + + + + + + + + + + + + + + + - - - - - - -