CANLIN的更改

CapMachine.Wpf/CanDrive/ToomossCan.cs

@@ -481,6 +481,7 @@ namespace CapMachine.Wpf.CanDrive
         private static Task CycleSendTask { get; set; }
 
         StringBuilder ValueSb = new StringBuilder(16);
+        double[] ValueDouble=new double[5];
 
         private bool _IsSendOk;
         /// <summary>
@@ -813,9 +814,12 @@ namespace CapMachine.Wpf.CanDrive
                             //有配置的名称的，认为是有用的，则需要读取数据
                             //if (!string.IsNullOrEmpty(item.Name))
                             //{
-                            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
+                            //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
-                            item.SignalRtValueSb = ValueSb;
+                            //double[] ValueDouble;
-                            Console.Write(ValueSb.ToString());
+                            CAN_DBCParser.DBC_GetSignalValue(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueDouble);
+                            //item.SignalRtValueSb = ValueSb;
+                            item.SignalRtValue = ValueDouble[0].ToString();
+                            //Console.Write(ValueSb.ToString());
                             //}
                         }
 

CapMachine.Wpf/LinDrive/ToomossLin.cs

@@ -7,6 +7,7 @@ using Prism.Mvvm;
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -54,6 +55,9 @@ namespace CapMachine.Wpf.LinDrive
         {
             ContainerProvider = containerProvider;
             HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
+
+            //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
+            TicksPerMs = Stopwatch.Frequency / 1000.0;
         }
 
         /// <summary>
@@ -432,6 +436,196 @@ namespace CapMachine.Wpf.LinDrive
         }
 
 
+        private bool _IsSendOk;
+        /// <summary>
+        /// 发送报文是否OK
+        /// </summary>
+        public bool IsSendOk
+        {
+            get { return _IsSendOk; }
+            set
+            {
+                if (_IsSendOk != value)
+                {
+                    RaisePropertyChanged();
+                    _IsSendOk = value;
+                }
+            }
+        }
+
+
+
+        #region 精确发送报文数据
+
+        // 添加取消标记源字段用于停止任务
+        private CancellationTokenSource CycleSendCts;
+
+        /// <summary>
+        ///  计算每毫秒对应的ticks数（只需计算一次）
+        /// </summary>
+        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();
+
+        /// <summary>
+        /// 精确周期发送CAN数据
+        /// </summary>
+        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);
+                                foreach (var itemMsg in GroupMsg)
+                                {
+                                    foreach (var itemSignal in itemMsg)
+                                    {
+                                        //主机写操作，发送数据给从机
+                                        LDFParser.LDF_SetSignalValue(LDFHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
+                                    }
+                                    //【0】参数注意
+                                    LDFParser.LDF_ExeFrameToBus(LDFHandle, new StringBuilder(itemMsg.Key), 0);
+
+                                    //读取当前的指令帧数据，LDF_ExeFrameToBus执行后就可以读取本身的数据
+                                    foreach (var item in ListLinLdfModel)
+                                    {
+                                        if (CmdData.Any(a => a.MsgName == item.MsgName))
+                                        {
+                                            LDFParser.LDF_GetSignalValueStr(LDFHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ReadValueStr);
+                                            item.SignalRtValueSb = ReadValueStr;
+                                        }
+                                    }
+                                }
+
+
+                            }
+
+                        }
+                        catch (TaskCanceledException)
+                        {
+                            // 任务被取消，正常退出
+                            break;
+                        }
+                        catch (Exception ex)
+                        {
+                            Console.WriteLine($"LIN周期发送异常: {ex.Message}");
+                            // 短暂暂停避免异常情况下CPU占用过高
+                            await Task.Delay(10, token);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    // 确保在任何情况下（正常退出、异常、取消）都会停止计时器
+                    Stopwatcher.Stop();
+
+                    // 清理其他可能的资源
+                    Console.WriteLine("LIN周期发送任务已结束，资源已清理");
+                }
+                finally
+                {
+                    // 确保在任何情况下（正常退出、异常、取消）都会停止计时器
+                    Stopwatcher.Stop();
+                }
+
+            }, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+        }
+
+
+        /// <summary>
+        /// 修改停止发送的方法
+        /// </summary>
+        public void StopCycleSendMsg()
+        {
+            IsCycleSend = false;
+            CycleSendCts?.Cancel();
+        }
+
+        #endregion
+
+
+
         /// <summary>
         /// 关闭设备
         /// </summary>

CapMachine.Wpf/Services/LinDriveService.cs

@@ -294,7 +294,8 @@ namespace CapMachine.Wpf.Services
                     {
                         ToomossLinDrive.IsCycleSend = true;
                         ToomossLinDrive.CmdData = CmdData;
-                        ToomossLinDrive.StartCycleSendMsg();
+                        ToomossLinDrive.StartPrecisionCycleSendMsg();
+                        //ToomossLinDrive.StartCycleSendMsg();
                     }
                     else
                     {

CapMachine.Wpf/Services/MachineRtDataService.cs

@@ -147,6 +147,10 @@ namespace CapMachine.Wpf.Services
 
             #region 标签管理
 
+
+
+
+
             ////三电 Sample
             TagManger.AddTag(new Tag<short>("转速", "转速[rpm]", "Speed", "程序", "VW14100", 100, 0, 1, "rpm", new ShortTagValue(), true) { DecimalPoint = 0,SVAddress= "VW14002" });
             TagManger.AddTag(new Tag<short>("排气压力", "排气压力[BarA]", "ExPress", "程序", "VW15002", 100, 0, 100, "BarA", new ShortTagValue(), true) { DecimalPoint = 2 });
@@ -1556,20 +1560,20 @@ namespace CapMachine.Wpf.Services
                                     break;
                             }
 
-                            //压缩机压缩机功率限制实时赋值
+                            ////压缩机压缩机功率限制实时赋值
-                            switch (ConfigService.CanLinRunStateModel.CurSysSelectedCanLin)
+                            //switch (ConfigService.CanLinRunStateModel.CurSysSelectedCanLin)
-                            {
+                            //{
-                                case CanLinEnum.Can:
+                            //    case CanLinEnum.Can:
-                                    //获取PLC的功率限制，更新到CAN的功率限制
+                            //        //获取PLC的功率限制，更新到CAN的功率限制
-                                    CanDriveService.UpdateCapPwLimitCmdData(OperateResultValue.Content[0]);
+                            //        CanDriveService.UpdateCapPwLimitCmdData(OperateResultValue.Content[0]);
-                                    break;
+                            //        break;
-                                case CanLinEnum.Lin:
+                            //    case CanLinEnum.Lin:
-                                    //获取PLC的功率限制，更新到LIN的功率限制
+                            //        //获取PLC的功率限制，更新到LIN的功率限制
-                                    LinDriveService.UpdateCapPwLimitCmdData(OperateResultValue.Content[0]);
+                            //        LinDriveService.UpdateCapPwLimitCmdData(OperateResultValue.Content[0]);
-                                    break;
+                            //        break;
-                                default:
+                            //    default:
-                                    break;
+                            //        break;
-                            }
+                            //}
 
 
                             //压缩机 PTC使能 实时赋值