ClaudeCode 更改2

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "mcp__filesystem__directory_tree"
+    ]
+  }
+}

CapMachine.Wpf/App.xaml.cs

@@ -261,7 +261,7 @@ namespace CapMachine.Wpf
 
             //给当前的全局异常捕捉服务使用
             LogService = ContainerLocator.Container.Resolve<ILogService>();
-            LogService.Error("Start-->OnInitialized");
+            LogService.Info("程序启动");
             base.OnInitialized();
 
             //#endregion
@@ -283,13 +283,31 @@ namespace CapMachine.Wpf
             TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
             //非UI线程未捕获异常处理事件 (例如自己创建的一个子线程)
             AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
+
+            //首次抛出（含被吞掉的）异常也落日志，便于排查闪退场景下原生互操作异常
+            AppDomain.CurrentDomain.FirstChanceException += (s, fce) =>
+            {
+                try
+                {
+                    var ex = fce.Exception;
+                    //只关心严重异常，避免日志被刷爆
+                    if (ex is AccessViolationException
+                        || ex is System.Runtime.InteropServices.SEHException
+                        || ex is StackOverflowException
+                        || ex is OutOfMemoryException)
+                    {
+                        LogService?.Error($"[FirstChance-FATAL] {ex.GetType().Name}: {ex.Message}\r\n{ex.StackTrace}");
+                    }
+                }
+                catch { /* 异常处理函数中绝不能再抛 */ }
+            };
         }
 
 
         void App_Exit(object sender, ExitEventArgs e)
         {
             //程序退出时需要处理的业务
-            LogService.Error("程序退出");
+            LogService.Info("App-程序退出");
         }
 
 
@@ -304,12 +322,14 @@ namespace CapMachine.Wpf
             try
             {
                 HandleException(e.Exception);
-                MessageBox.Show("UI线程异常:" + e.Exception.Message);
+                //MessageBox.Show("UI线程异常:" + e.Exception.Message);
+                LogService.Error("UI线程异常:" + e.Exception.Message);
             }
             catch (Exception ex)
             {
                 HandleException(ex);
-                MessageBox.Show("UI线程发生致命错误！");
+                //MessageBox.Show("UI线程发生致命错误！");
+                LogService.Error("UI线程发生致命错误！");
             }
             finally
             {
@@ -346,8 +366,8 @@ namespace CapMachine.Wpf
                     {
                         sbEx.Append(e.ExceptionObject);
                     }
-                    MessageBox.Show(sbEx.ToString());
-
+                    //MessageBox.Show(sbEx.ToString());
+                    LogService.Error(sbEx.ToString());
                 }
             }
             catch (Exception ex)
@@ -374,7 +394,8 @@ namespace CapMachine.Wpf
                 {
                     HandleException(exception);
                     //task线程内未处理捕获
-                    MessageBox.Show("Task线程异常：" + e.Exception.Message);
+                    //MessageBox.Show("Task线程异常：" + e.Exception.Message);
+                    LogService.Error($"Task线程异常");
                 }
             }
             catch (Exception ex)
@@ -395,7 +416,7 @@ namespace CapMachine.Wpf
         private void HandleException(Exception ex)
         {
             //记录日志
-            LogService.Error(ex.ToString());
+            LogService.Error($"App捕捉HandleException-{ex.ToString()}");
 
         }
 

CapMachine.Wpf/CanDrive/ToomossCan.cs

@@ -12,6 +12,7 @@ using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using System.Windows.Interop;
@@ -25,6 +26,21 @@ namespace CapMachine.Wpf.CanDrive
     public class ToomossCan : BindableBase
     {
         private readonly IContainerProvider ContainerProvider;
+        private readonly object _dbcParserLock = new object();
+        private readonly object _canSendLock = new object();
+        private readonly object _recvBufferLock = new object();
+        private const int DbcStringBufferCapacity = 256;
+        private const int RecvBufferSize = 128;
+
+        /// <summary>
+        /// 预分配的接收缓冲区指针，避免每次循环分配/释放
+        /// </summary>
+        private IntPtr RecvMsgBufferPtr = IntPtr.Zero;
+
+        /// <summary>
+        /// 接收缓冲区对应的托管数组
+        /// </summary>
+        private readonly USB2CAN.CAN_MSG[] RecvMsgBuffer = new USB2CAN.CAN_MSG[RecvBufferSize];
 
         /// <summary>
         /// 实例化函数
@@ -33,6 +49,9 @@ namespace CapMachine.Wpf.CanDrive
         {
             ContainerProvider = containerProvider;
             HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
+
+            //Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
+            TicksPerMs = Stopwatch.Frequency / 1000.0;
         }
 
         /// <summary>
@@ -328,6 +347,8 @@ namespace CapMachine.Wpf.CanDrive
         /// DBC解析
         /// </summary>
         public void DBC_Parser(string Path)
+        {
+            lock (_dbcParserLock)
             {
                 //解析DBC文件
                 DBCHandle = CAN_DBCParser.DBC_ParserFile(DevHandle, new StringBuilder(Path));
@@ -348,21 +369,21 @@ namespace CapMachine.Wpf.CanDrive
                 int DBCMsgNum = CAN_DBCParser.DBC_GetMsgQuantity(DBCHandle);
                 for (int i = 0; i < DBCMsgNum; i++)
                 {
-                StringBuilder MsgName = new StringBuilder(32);
+                    StringBuilder MsgName = new StringBuilder(DbcStringBufferCapacity);
                     CAN_DBCParser.DBC_GetMsgName(DBCHandle, i, MsgName);
-                Console.WriteLine("Msg.Name = {0}", MsgName);
+                    //Console.WriteLine("Msg.Name = {0}", MsgName);
                     int DBCSigNum = CAN_DBCParser.DBC_GetMsgSignalQuantity(DBCHandle, MsgName);
-                StringBuilder Publisher = new StringBuilder(32);
+                    StringBuilder Publisher = new StringBuilder(DbcStringBufferCapacity);
                     CAN_DBCParser.DBC_GetMsgPublisher(DBCHandle, MsgName, Publisher);
                     long MsgId;
                     MsgId = CAN_DBCParser.DBC_GetMsgIDByName(DBCHandle, MsgName);
 
-                Console.Write("Signals:");
+                    //Console.Write("Signals:");
                     for (int j = 0; j < DBCSigNum; j++)
                     {
-                    StringBuilder SigName = new StringBuilder(32);
+                        StringBuilder SigName = new StringBuilder(DbcStringBufferCapacity);
                         CAN_DBCParser.DBC_GetMsgSignalName(DBCHandle, MsgName, j, SigName);
-                    Console.Write("{0} ", SigName);
+                        //Console.Write("{0} ", SigName);
 
                         //增加信息数据
                         ListCanDbcModel.Add(new CanDbcModel()
@@ -376,12 +397,13 @@ namespace CapMachine.Wpf.CanDrive
                             Publisher = Publisher.ToString()
                         });
                     }
-                Console.WriteLine("");
+                    //Console.WriteLine("");
                 }
 
                 //Dbc解析成功
                 DbcParserState = true;
             }
+        }
 
         /// <summary>
         /// 发送CAN数据
@@ -389,48 +411,77 @@ namespace CapMachine.Wpf.CanDrive
         /// </summary>
         public void SendCanMsg(List<CanCmdData> CmdData)
         {
-            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];
+            SendCanMessagesByDbc(CmdData);
         }
 
-            IntPtr msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
-            int Index = 0;
+        private void SendCanMessagesByDbc(IEnumerable<CanCmdData> sourceCmdData)
+        {
+            var cmdDataSnapshot = sourceCmdData
+                .Where(x => !string.IsNullOrWhiteSpace(x.MsgName) && !string.IsNullOrWhiteSpace(x.SignalName))
+                .Select(x => new CanCmdData
+                {
+                    ConfigName = x.ConfigName,
+                    MsgName = x.MsgName,
+                    SignalName = x.SignalName,
+                    SignalCmdValue = x.SignalCmdValue
+                })
+                .ToList();
+            if (cmdDataSnapshot.Count == 0)
+            {
+                return;
+            }
+
+            var groupMsg = cmdDataSnapshot.GroupBy(x => x.MsgName).ToList();
+            int msgCount = groupMsg.Count;
+            USB2CAN.CAN_MSG[] canMsgBuffer = new USB2CAN.CAN_MSG[msgCount];
+            for (int i = 0; i < canMsgBuffer.Length; i++)
+            {
+                canMsgBuffer[i] = new USB2CAN.CAN_MSG();
+                canMsgBuffer[i].Data = new byte[8];
+            }
+
+            IntPtr msgPt = IntPtr.Zero;
+            try
+            {
+                msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
+                int index = 0;
+                lock (_canSendLock)
+                {
+                    lock (_dbcParserLock)
+                    {
                         //循环给MSG赋值数据
-            foreach (var itemMsg in GroupMsg)
+                        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);
+                                int setResult = CAN_DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
+                                if (setResult != CAN_DBCParser.DBC_PARSER_OK)
+                                {
+                                    return;
                                 }
-                CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt);
-                CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CAN.CAN_MSG));
-                Index++;
                             }
-
-            //设置信号值
-            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), 2412);
-            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), 980);
-            //DBCParser.DBC_SetSignalValue(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), 120);
-
-            //通过DBC写入数据后生成CanMsg
-            //将信号值填入CAN消息里面
-
-            //释放申请的临时缓冲区
+                            int syncResult = CAN_DBCParser.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPt);
+                            if (syncResult != CAN_DBCParser.DBC_PARSER_OK)
+                            {
+                                return;
+                            }
+                            canMsgBuffer[index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPt, typeof(USB2CAN.CAN_MSG));
+                            if (canMsgBuffer[index].Data == null || canMsgBuffer[index].Data.Length != 8)
+                            {
+                                canMsgBuffer[index].Data = new byte[8];
+                            }
+                            index++;
+                        }
+                    }
+                    USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, canMsgBuffer, (uint)msgCount);
+                }
+            }
+            finally
+            {
+                if (msgPt != IntPtr.Zero)
+                {
                     Marshal.FreeHGlobal(msgPt);
-            Console.WriteLine("");
-            //发送CAN数据
-            int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
-            if (SendedNum >= 0)
-            {
-                Console.WriteLine("Success send frames:{0}", SendedNum);
                 }
-            else
-            {
-                Console.WriteLine("Send CAN data failed! {0}", SendedNum);
             }
         }
 
@@ -470,12 +521,12 @@ namespace CapMachine.Wpf.CanDrive
         /// <summary>
         /// CycleRevice 扫描Task
         /// </summary>
-        private static Task CycleReviceTask { get; set; }
+        private Task? CycleReviceTask { get; set; }
 
         /// <summary>
         /// CycleSend 扫描Task
         /// </summary>
-        private static Task CycleSendTask { get; set; }
+        private Task? CycleSendTask { get; set; }
 
         StringBuilder ValueSb = new StringBuilder(16);
 
@@ -489,6 +540,11 @@ namespace CapMachine.Wpf.CanDrive
         /// </summary>
         public void StartCycleSendMsg()
         {
+            if (CycleSendTask != null && !CycleSendTask.IsCompleted)
+            {
+                return;
+            }
+
             CycleSendTask = Task.Run(async () =>
             {
                 while (IsCycleSend)
@@ -496,6 +552,421 @@ namespace CapMachine.Wpf.CanDrive
                     await Task.Delay(SendCycle);
                     try
                     {
+                        SendCanMessagesByDbc(CmdData);
+                    }
+                    catch (Exception ex)
+                    {
+                        //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
+                    }
+                }
+            });
+        }
+
+
+        /// <summary>
+        /// 循环获取CAN消息（使用预分配缓冲区，避免每次循环内存分配/释放）
+        /// </summary>
+        public void StartCycleReviceCanMsg1()
+        {
+            if (CycleReviceTask != null && !CycleReviceTask.IsCompleted)
+            {
+                return;
+            }
+
+            // 预分配接收缓冲区（仅在首次或已释放后分配）
+            EnsureRecvBufferAllocated();
+
+            CycleReviceTask = Task.Run(async () =>
+            {
+                var msgSize = Marshal.SizeOf(typeof(USB2CAN.CAN_MSG));
+                double[] valueDouble = new double[1];
+
+                while (IsCycleRevice)
+                {
+                    await Task.Delay(ReviceCycle);
+                    try
+                    {
+                        int CanNum;
+                        lock (_recvBufferLock)
+                        {
+                            if (RecvMsgBufferPtr == IntPtr.Zero) break;
+                            CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, RecvMsgBufferPtr, RecvBufferSize);
+
+                            if (CanNum > 0)
+                            {
+                                for (int i = 0; i < CanNum; i++)
+                                {
+                                    RecvMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(
+                                        (IntPtr)(RecvMsgBufferPtr + i * msgSize), typeof(USB2CAN.CAN_MSG));
+
+                                    HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
+                                    {
+                                        Category = "CAN",
+                                        MsgInfo = "0x" + RecvMsgBuffer[i].ID.ToString("X8"),
+                                        MsgData = BitConverter.ToString(RecvMsgBuffer[i].Data),
+                                        Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
+                                    });
+                                }
+                            }
+                        }
+
+                        if (CanNum > 0)
+                        {
+                            lock (_dbcParserLock)
+                            {
+                                lock (_recvBufferLock)
+                                {
+                                    if (RecvMsgBufferPtr == IntPtr.Zero) break;
+                                    CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, RecvMsgBufferPtr, CanNum);
+                                }
+
+                                foreach (var item in ListCanDbcModel)
+                                {
+                                    valueDouble[0] = 0;
+                                    CAN_DBCParser.DBC_GetSignalValue(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), valueDouble);
+                                    item.SignalRtValue = valueDouble[0].ToString();
+                                }
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Console.WriteLine($"CAN循环接收异常: {ex.Message}");
+                    }
+                }
+            });
+        }
+
+
+        // 保护接收缓冲的并发锁（接收读与关闭释放之间的互斥）
+        private readonly object RecvBufferSync = new object();
+
+        //StringBuilder ValueSb = new StringBuilder(16);
+        double[] ValueDouble = new double[5];
+
+        // 接收缓冲池（重用，避免每轮分配）
+        //private IntPtr RecvMsgBufferPtr = IntPtr.Zero;
+        private int RecvMsgBufferCapacity = 1024;
+        private readonly int CanMsgSize = Marshal.SizeOf(typeof(USB2CAN.CAN_MSG));
+
+        // 名称 StringBuilder 缓存（DBC 调用复用，避免频繁分配）
+        private readonly Dictionary<string, StringBuilder> MsgNameSBCache = new Dictionary<string, StringBuilder>(StringComparer.Ordinal);
+        private readonly Dictionary<string, StringBuilder> SigNameSBCache = new Dictionary<string, StringBuilder>(StringComparer.Ordinal);
+
+        // 控制台调试输出开关（默认关闭，防止日志风暴）
+        public bool EnableConsoleDebugLog { get; set; } = true;
+
+        // 保护接收缓冲的并发锁（接收读与关闭释放之间的互斥）
+        //private readonly object RecvBufferSync = new object();
+
+        private StringBuilder GetMsgSB(string key) => GetCachedSB(MsgNameSBCache, key);
+        private StringBuilder GetSigSB(string key) => GetCachedSB(SigNameSBCache, key);
+
+        private StringBuilder GetCachedSB(Dictionary<string, StringBuilder> cache, string key)
+        {
+            key ??= string.Empty;
+            if (cache.TryGetValue(key, out var sb)) return sb;
+            var nsb = new StringBuilder(key);
+            cache[key] = nsb;
+            return nsb;
+        }
+
+        /// <summary>
+        /// 启动后台循环接收 CAN 报文，并同步到 DBC 信号实时值。
+        /// </summary>
+        /// <remarks>
+        /// 关键点：
+        /// - 使用 CAN_GetMsgWithSize 从设备内部 FIFO 拉取报文；
+        /// - 使用 <see cref="RecvMsgBufferPtr"/> 作为重用缓冲，避免每轮申请/释放非托管内存导致碎片与性能问题；
+        /// - 使用 <see cref="RecvBufferSync"/> 与 <see cref="CloseDevice"/> 互斥，避免指针并发释放。
+        /// </remarks>
+        public void StartCycleReviceCanMsg()
+        {
+            // 防止重复启动，若已有任务在运行则直接返回
+            if (CycleReviceTask != null && !CycleReviceTask.IsCompleted)
+            {
+                return;
+            }
+            //monitorValueLog
+            CycleReviceTask = Task.Run(async () =>
+            {
+                try
+                {
+                    while (IsCycleRevice)
+                    {
+                        await Task.Delay(ReviceCycle);
+                        try
+                        {
+                            // 另一个CAN通道读取数据（与 CloseDevice 释放互斥，保护指针安全）
+                            IntPtr msgPtRead;
+                            int CanNum;
+                            lock (RecvBufferSync)
+                            {
+                                if (RecvMsgBufferPtr == IntPtr.Zero)
+                                {
+                                    RecvMsgBufferPtr = Marshal.AllocHGlobal(CanMsgSize * RecvMsgBufferCapacity);
+                                    //LoggerService.Info("申请 RecvMsgBufferPtr");
+                                }
+                                msgPtRead = RecvMsgBufferPtr;
+                                CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPtRead, RecvMsgBufferCapacity);
+                                //int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, 1, msgPtRead, RecvMsgBufferCapacity);//测试用，CAN卡 CAN1和CAN2 短接时测试用
+                                //monitorValueLog.UpdateValue4(CanNum);
+                                int SyncCANMsgToValue = CAN_DBCParser.DBC_PARSER_OK;
+                                if (CanNum > 0)
+                                {
+                                    //仅当确实收到了报文，才把缓冲区交给 DBC 解析器，避免负数 / 0 传给原生函数造成越界读后堆腐败
+                                    SyncCANMsgToValue = CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum);
+                                    IsReviceOk = true;
+                                    if (EnableConsoleDebugLog) Console.WriteLine("Read CanMsgNum = {0}", CanNum);
+                                    for (int i = 0; i < CanNum; i++)
+                                    {
+                                        var msgPtr = (IntPtr)(msgPtRead + i * CanMsgSize);
+                                        var msg = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtr, typeof(USB2CAN.CAN_MSG));
+
+                                        if (EnableConsoleDebugLog)
+                                        {
+                                            Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, msg.ID.ToString("X8"));
+                                            Console.WriteLine("CanMsg[{0}].TimeStamp = {1}", i, msg.TimeStamp);
+                                            Console.Write("CanMsg[{0}].Data = ", i);
+                                            for (int j = 0; j < msg.DataLen; j++)
+                                            {
+                                                Console.Write("{0} ", msg.Data[j].ToString("X2"));
+                                            }
+                                            Console.WriteLine("");
+                                        }
+
+                                        //// 报文给高速记录的服务
+                                        //HighSpeedDataService.AppendOrUpdateMsg(new Models.HighSpeed.CommMsg()
+                                        //{
+                                        //    Category = "CAN",
+                                        //    MsgInfo = "0x" + msg.ID.ToString("X8"),
+                                        //    MsgData = BitConverter.ToString(msg.Data),
+                                        //    Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
+                                        //});
+                                    }
+                                }
+                                else if (CanNum == 0)
+                                {
+                                    IsReviceOk = false;
+                                    if (EnableConsoleDebugLog) Console.WriteLine("No CAN data!");
+                                }
+                                else
+                                {
+                                    IsReviceOk = false;
+                                    if (EnableConsoleDebugLog) Console.WriteLine("Get CAN data error!");
+                                }
+                                //【已修复】原来此处无条件调用 DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum)
+                                //当 CanNum == 0（无报文）或 CanNum < 0（读失败）时把无效 MsgLen 传给原生 DBC 解析器，
+                                //会越界读 msgPtRead 缓冲后的内存导致 GC 堆腐败，运行一段时间后随机位置 AV(0xC0000005)。
+                                //现已挪到 CanNum > 0 分支内（参考 HASCO_Simple25001 的 StartCycleReviceCanMsg1 写法）。
+                            }
+
+                            //循环获取消息的数据
+                            foreach (var item in ListCanDbcModel)
+                            {
+                                // 复用 StringBuilder 缓存，避免频繁分配
+                                var msgNameSB = GetMsgSB(item.MsgName);
+                                var sigNameSB = GetSigSB(item.SignalName);
+                                CAN_DBCParser.DBC_GetSignalValue(DBCHandle, msgNameSB, sigNameSB, ValueDouble);
+                                item.SignalRtValue = ValueDouble[0].ToString();
+                                //Console.Write(ValueSb.ToString());
+                            }
+                            // 缓冲区在 CloseDevice 或任务退出的 finally 中统一释放，避免频繁申请/释放
+
+
+                        }
+                        catch (Exception ex)
+                        {
+                            IsReviceOk = false;
+                            //LoggerService.Info($"CAN指令接收出现异常:{ex.Message}");
+                        }
+                        //finally
+                        //{
+                        //    IsReviceOk = false;
+                        //}
+                    }
+                }
+                finally
+                {
+                    IsReviceOk = false;
+                    //LoggerService.Info("CAN指令接收 finally结束");
+                    // 接收任务退出时释放接收缓冲，避免仅停止接收时的缓冲常驻
+                    lock (RecvBufferSync)
+                    {
+                        if (RecvMsgBufferPtr != IntPtr.Zero)
+                        {
+                            try { Marshal.FreeHGlobal(RecvMsgBufferPtr); }
+                            catch { }
+                            finally { RecvMsgBufferPtr = IntPtr.Zero; }
+                        }
+                    }
+                }
+            });
+        }
+
+
+        private bool _IsReviceOk;
+        /// <summary>
+        /// 最近一次接收是否成功。
+        /// </summary>
+        /// <remarks>
+        /// 该状态反映最近一次轮询读取 CAN_GetMsgWithSize 的结果：
+        /// - CanNum &gt; 0：成功收到数据；
+        /// - CanNum == 0：本轮无数据；
+        /// - CanNum &lt; 0：调用失败。
+        /// </remarks>
+        public bool IsReviceOk
+        {
+            get { return _IsReviceOk; }
+            set
+            {
+                if (_IsReviceOk != value)
+                {
+                    RaisePropertyChanged();
+                    _IsReviceOk = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 确保接收缓冲区已分配
+        /// </summary>
+        private void EnsureRecvBufferAllocated()
+        {
+            lock (_recvBufferLock)
+            {
+                if (RecvMsgBufferPtr == IntPtr.Zero)
+                {
+                    RecvMsgBufferPtr = Marshal.AllocHGlobal(
+                        Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * RecvBufferSize);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 释放接收缓冲区
+        /// </summary>
+        private void FreeRecvBuffer()
+        {
+            lock (_recvBufferLock)
+            {
+                if (RecvMsgBufferPtr != IntPtr.Zero)
+                {
+                    Marshal.FreeHGlobal(RecvMsgBufferPtr);
+                    RecvMsgBufferPtr = IntPtr.Zero;
+                }
+            }
+        }
+
+
+        #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;
+
+        /// <summary>
+        /// 精确周期发送CAN数据
+        /// </summary>
+        public void StartPrecisionCycleSendMsg()
+        {
+            if (CycleSendTask != null && !CycleSendTask.IsCompleted)
+            {
+                return;
+            }
+
+            // 创建取消标记源 用于控制任务的取消 允许在需要时通过取消令牌来优雅停止任务
+            var cancellationTokenSource = new CancellationTokenSource();
+            var token = cancellationTokenSource.Token;
+
+            // 保存取消标记，以便在停止时使用
+            CycleSendCts = cancellationTokenSource;//将取消标记源保存到类的成员变量CycleSendCts，这样在外部调用停止方法时可以访问它
+            NextExecutionTime = 0;//初始化NextExecutionTime为0，这个变量用于记录下一次执行的目标时间点
+
+            CycleSendTask = Task.Run(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逻辑
+                            //{
+                            //    SendCanMessagesByDbc(CmdData);
+                            //}
+
+                            // 执行发送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++)
@@ -504,6 +975,7 @@ namespace CapMachine.Wpf.CanDrive
                                     CanMsg[i].Data = new Byte[64];
                                 }
 
+                                // 发送构帧临时缓冲：每轮申请/释放，避免与其他线程共享同一指针导致并发问题
                                 IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
                                 int Index = 0;
                                 //循环给MSG赋值数据
@@ -517,168 +989,91 @@ namespace CapMachine.Wpf.CanDrive
                                     CanMsg[Index] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
                                     Index++;
                                 }
+
                                 //通过DBC写入数据后生成CanMsg
                                 //将信号值填入CAN消息里面
 
-                        //释放申请的临时缓冲区
+                                // 释放非托管缓冲区（务必释放，否则长时间运行会造成内存泄漏）
                                 Marshal.FreeHGlobal(msgPtSend);
-                        Console.WriteLine("");
+
                                 //发送CAN数据
                                 int SendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, CanMsg, (uint)CanMsg.Length);
                                 if (SendedNum >= 0)
                                 {
-                            Console.WriteLine("Success send frames:{0}", SendedNum);
+                                    //Console.WriteLine("Success send frames:{0}", SendedNum);
+                                    IsSendOk = true;
                                 }
                                 else
                                 {
-                            Console.WriteLine("Send CAN data failed! {0}", SendedNum);
+                                    //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)
                 {
-                        //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
+                    Console.WriteLine($"CAN精确周期发送异常: {ex.Message}");
                 }
-                }
-            });
+                finally
+                {
+                    // 确保在任何情况下（正常退出、异常、取消）都会停止计时器
+                    Stopwatcher.Stop();
+                    Console.WriteLine("CAN周期发送任务已结束，资源已清理");
                 }
 
+            }, token);
+        }
 
+        private bool _IsSendOk;
         /// <summary>
-        /// 循环获取CAN消息
+        /// 最近一次发送是否成功。
         /// </summary>
-        public void StartCycleReviceCanMsg()
+        /// <remarks>
+        /// - 软件循环发送路径：由 CAN_SendMsg 返回值决定；
+        /// - 调度表更新路径：由 CAN_UpdateSchedule 返回值决定。
+        /// </remarks>
+        public bool IsSendOk
         {
-            CycleReviceTask = Task.Run(async () =>
+            get { return _IsSendOk; }
+            set
             {
-                while (IsCycleRevice)
+                if (_IsSendOk != value)
                 {
-                    await Task.Delay(ReviceCycle);
-                    try
-                    {
-                        //另外一个CAN通道读取数据
-                        USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[128];
-                        //申请数据缓冲区
-                        IntPtr msgPtRead = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length);
-                        int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPtRead, CanMsgBuffer.Length);
-                        if (CanNum > 0)
-                        {
-                            Console.WriteLine("Read CanMsgNum = {0}", CanNum);
-                            for (int i = 0; i < CanNum; i++)
-                            {
-                                //CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPtRead + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG)); //有溢出报错
-                                CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)(msgPtRead + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG));
-
-                                Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8"));
-                                Console.WriteLine("CanMsg[{0}].TimeStamp = {1}", i, CanMsgBuffer[i].TimeStamp);
-                                Console.Write("CanMsg[{0}].Data = ", i);
-                                for (int j = 0; j < CanMsgBuffer[i].DataLen; j++)
-                                {
-                                    Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
+                    RaisePropertyChanged();
+                    _IsSendOk = value;
                 }
-                                Console.WriteLine("");
-
-                                //报文给高速记录的服务
-                                HighSpeedDataService.AppendOrUpdateMsg(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")
-                                });
+                //RaisePropertyChanged();
             }
         }
-                        else if (CanNum == 0)
-                        {
-                            Console.WriteLine("No CAN data!");
-                        }
-                        else
-                        {
-                            Console.WriteLine("Get CAN data error!");
-                        }
-                        Console.WriteLine("");
-
-                        //将CAN消息数据填充到信号里面，用DBC解析数据
-                        CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPtRead, CanNum);
-
-                        //循环获取消息的数据
-                        foreach (var item in ListCanDbcModel)
-                        {
-                            //有配置的名称的，认为是有用的，则需要读取数据
-                            //if (!string.IsNullOrEmpty(item.Name))
-                            //{
-                            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
-                            item.SignalRtValueSb = ValueSb;
-                            Console.Write(ValueSb.ToString());
-                            //}
-                        }
-
-                        //释放数据缓冲区，必须释放，否则程序运行一段时间后会报内存不足
-                        Marshal.FreeHGlobal(msgPtRead);
-                        Thread.Sleep(10);
-
-                        ////获取信号值并打印出来
-                        //StringBuilder ValueStr = new StringBuilder(32);
-                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
-                        //Console.WriteLine("moto_speed = {0}", ValueStr);
-                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
-                        //Console.WriteLine("oil_pressure = {0}", ValueStr);
-                        //CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
-                        //Console.WriteLine("speed_can = {0}", ValueStr);
-                    }
-                    catch (Exception ex)
-                    {
-                        //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
-                    }
-                }
-            });
-        }
 
         /// <summary>
-        /// 接受CAN消息
+        /// 修改停止发送的方法
         /// </summary>
-        public void ReciveCanMsg()
+        public void StopCycleSendMsg()
         {
-            //另外一个CAN通道读取数据
-            USB2CAN.CAN_MSG[] CanMsgBuffer = new USB2CAN.CAN_MSG[10];
-            msgPt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)) * CanMsgBuffer.Length);
-            int CanNum = USB2CAN.CAN_GetMsgWithSize(DevHandle, ReadCANIndex, msgPt, CanMsgBuffer.Length);
-            if (CanNum > 0)
-            {
-                Console.WriteLine("Read CanMsgNum = {0}", CanNum);
-                for (int i = 0; i < CanNum; i++)
-                {
-                    CanMsgBuffer[i] = (USB2CAN.CAN_MSG)Marshal.PtrToStructure((IntPtr)((UInt32)msgPt + i * Marshal.SizeOf(typeof(USB2CAN.CAN_MSG))), typeof(USB2CAN.CAN_MSG));
-                    Console.WriteLine("CanMsg[{0}].ID = 0x{1}", i, CanMsgBuffer[i].ID.ToString("X8"));
-                    //Console.WriteLine("CanMsg[{0}].TimeStamp = {1}",i,CanMsgBuffer[i].TimeStamp);
-                    Console.Write("CanMsg[{0}].Data = ", i);
-                    for (int j = 0; j < CanMsgBuffer[i].DataLen; j++)
-                    {
-                        Console.Write("{0} ", CanMsgBuffer[i].Data[j].ToString("X2"));
+            IsCycleSend = false;
+            CycleSendCts?.Cancel();
         }
-                    Console.WriteLine("");
-                }
-            }
-            else if (CanNum == 0)
-            {
-                Console.WriteLine("No CAN data!");
-            }
-            else
-            {
-                Console.WriteLine("Get CAN data error!");
-            }
-            Console.WriteLine("");
 
-            //将CAN消息数据填充到信号里面
-            CAN_DBCParser.DBC_SyncCANMsgToValue(DBCHandle, msgPt, CanNum);
-            //获取信号值并打印出来
-            StringBuilder ValueStr = new StringBuilder(32);
-            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_moto_speed"), new StringBuilder("moto_speed"), ValueStr);
-            Console.WriteLine("moto_speed = {0}", ValueStr);
-            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_oil_pressure"), new StringBuilder("oil_pressure"), ValueStr);
-            Console.WriteLine("oil_pressure = {0}", ValueStr);
-            CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder("msg_speed_can"), new StringBuilder("speed_can"), ValueStr);
-            Console.WriteLine("speed_can = {0}", ValueStr);
-        }
+        #endregion
+
 
 
         /// <summary>
@@ -686,12 +1081,64 @@ namespace CapMachine.Wpf.CanDrive
         /// </summary>
         public void CloseDevice()
         {
+            IsCycleRevice = false;
+            IsCycleSend = false;
+
+            // 停止精确发送并释放CTS
+            try
+            {
+                StopCycleSendMsg();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"停止CAN发送异常: {ex.Message}");
+            }
+
+            // 等待发送任务结束
+            try
+            {
+                var sendTask = CycleSendTask;
+                if (sendTask != null && !sendTask.IsCompleted)
+                {
+                    sendTask.Wait(TimeSpan.FromMilliseconds(SendCycle * 3 + 500));
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"等待CAN发送任务结束异常: {ex.Message}");
+            }
+
+            // 等待接收任务结束
+            try
+            {
+                var recvTask = CycleReviceTask;
+                if (recvTask != null && !recvTask.IsCompleted)
+                {
+                    recvTask.Wait(TimeSpan.FromMilliseconds(ReviceCycle + 500));
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"等待CAN接收任务结束异常: {ex.Message}");
+            }
+
+            // 释放接收缓冲区
+            FreeRecvBuffer();
+
+            // 释放CTS资源
+            try
+            {
+                CycleSendCts?.Dispose();
+                CycleSendCts = null;
+            }
+            catch
+            {
+            }
+
             //关闭设备
             USB_DEVICE.USB_CloseDevice(DevHandle);
             OpenState = false;
             DbcParserState = false;
-            IsCycleRevice = false;
-            IsCycleSend = false;
         }
 
     }

CapMachine.Wpf/CapMachine.Wpf.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Exe</OutputType>
+    <OutputType>WinExe</OutputType>
     <TargetFramework>net6.0-windows</TargetFramework>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
@@ -15,6 +15,7 @@
     <None Remove="Assets\Images\favicon.ico" />
     <None Remove="Assets\Images\Logo.png" />
     <None Remove="Assets\Images\参考工艺图.png" />
+    <None Remove="NLog.config" />
     <None Remove="PPCalculation\REFPROP\FLUIDS\13BUTADIENE.FLD" />
     <None Remove="PPCalculation\REFPROP\FLUIDS\1BUTENE.FLD" />
     <None Remove="PPCalculation\REFPROP\FLUIDS\1BUTYNE.FLD" />
@@ -184,6 +185,9 @@
     <Content Include="Assets\Images\Logo.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="NLog.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="PPCalculation\REFPROP\FLUIDS\13BUTADIENE.FLD">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>

CapMachine.Wpf/Converts/SecToStrConvert.cs

@@ -43,10 +43,22 @@ namespace CapMachine.Wpf.Converts
             //int second = TotalSec % 60;
 
             //return string.Format("{0}:{1}:{2}", hour, minute, second);
-            ////Console.WriteLine(result);
+            //////Console.WriteLine(result);
 
-            TimeSpan TimeInfo = TimeSpan.FromSeconds(TotalSec);
-            return TimeInfo.ToString();
+            //TimeSpan TimeInfo = TimeSpan.FromSeconds(TotalSec);
+            //return TimeInfo.ToString();
+
+            return ConvertSecToTimeStr(TotalSec);
+        }
+
+        private string ConvertSecToTimeStr(int totalSeconds)
+        {
+            int hours = totalSeconds / 3600;
+            int remainingSeconds = totalSeconds % 3600;
+            int minutes = remainingSeconds / 60;
+            int seconds = remainingSeconds % 60;
+
+            return $"{hours}:{minutes:D2}:{seconds:D2}";
         }
 
         /// <summary>
@@ -57,8 +69,9 @@ namespace CapMachine.Wpf.Converts
         {
             try
             {
-                TimeSpan TimeInfo = TimeSpan.Parse(timeString);
-                return (int)TimeInfo.TotalSeconds;
+                //TimeSpan TimeInfo = TimeSpan.Parse(timeString);
+                //return (int)TimeInfo.TotalSeconds;
+                return ConvertTimeStrToSecs(timeString);
             }
             catch (Exception ex)
             {
@@ -68,5 +81,23 @@ namespace CapMachine.Wpf.Converts
            
             
         }
+
+        public  int ConvertTimeStrToSecs(string timeString)
+        {
+            string[] parts = timeString.Split(':');
+            if (parts.Length != 3) return 0;
+            //throw new FormatException("Invalid time format. Use 'hh:mm:ss'");
+
+            if (!int.TryParse(parts[0], out int hours) || hours < 0) return 0;
+            //throw new ArgumentException("小時必須為非負整數");
+
+            if (!int.TryParse(parts[1], out int minutes) || minutes < 0 || minutes >= 60) return 0;
+            //throw new ArgumentException("分鐘必須為 0-59 的整數");
+
+            if (!int.TryParse(parts[2], out int seconds) || seconds < 0 || seconds >= 60) return 0;
+            //throw new ArgumentException("秒必須為 0-59 的整數");
+
+            return hours * 3600 + minutes * 60 + seconds;
+        }
     }
 }

CapMachine.Wpf/Models/Tag/QuickTag.cs

@@ -72,6 +72,8 @@ namespace CapMachine.Wpf.Models.Tag
             get { return _OperateResultSource; }
             set
             {
+                if (value!.Content == null) return;
+            
                 switch (ValueType)
                 {
                     case DataType.Short:

CapMachine.Wpf/Services/CanDriveService.cs

@@ -102,6 +102,7 @@ namespace CapMachine.Wpf.Services
         /// 在程序配置好后就确定要发送哪些数据
         /// </summary>
         public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();
+        private readonly object _cmdDataLock = new object();
 
         /// <summary>
         /// 增加发送的指令数据
@@ -128,8 +129,11 @@ namespace CapMachine.Wpf.Services
                     break;
             }
             //添加到发送数据集合
+            lock (_cmdDataLock)
+            {
                 CmdData.Add(SendCanCmdData);
             }
+        }
 
 
         /// <summary>
@@ -140,9 +144,12 @@ namespace CapMachine.Wpf.Services
         public void UpdateSpeedCmdData(double SpeedData)
         {
             if (SpeedCanCmdData != null)
+            {
+                lock (_cmdDataLock)
                 {
                     SpeedCanCmdData.SignalCmdValue = SpeedData;
                 }
+            }
             //if (EnableCanCmdData != null)
             //{
             //    EnableCanCmdData.SignalCmdValue = 1;
@@ -156,10 +163,13 @@ namespace CapMachine.Wpf.Services
         public void UpdateCapEnableCmdData(bool IsEnable)
         {
             if (EnableCanCmdData != null)
+            {
+                lock (_cmdDataLock)
                 {
                     EnableCanCmdData.SignalCmdValue = IsEnable ? 1 : 0;
                 }
             }
+        }
 
 
         /// <summary>
@@ -174,7 +184,18 @@ namespace CapMachine.Wpf.Services
                     //更新速度信息
                     UpdateSpeedCmdData(SpeedData);
 
-                    ToomossCanDrive.SendCanMsg(CmdData);
+                    List<CanCmdData> cmdDataSnapshot;
+                    lock (_cmdDataLock)
+                    {
+                        cmdDataSnapshot = CmdData.Select(x => new CanCmdData
+                        {
+                            ConfigName = x.ConfigName,
+                            MsgName = x.MsgName,
+                            SignalName = x.SignalName,
+                            SignalCmdValue = x.SignalCmdValue
+                        }).ToList();
+                    }
+                    ToomossCanDrive.SendCanMsg(cmdDataSnapshot);
                 }
                 else
                 {
@@ -201,7 +222,7 @@ namespace CapMachine.Wpf.Services
                     {
                         ToomossCanDrive.IsCycleSend = true;
                         ToomossCanDrive.CmdData = CmdData;
-                        ToomossCanDrive.StartCycleSendMsg();
+                        ToomossCanDrive.StartPrecisionCycleSendMsg();
                     }
                     else
                     {
@@ -210,7 +231,7 @@ namespace CapMachine.Wpf.Services
                 }
                 else
                 {
-                    ToomossCanDrive.IsCycleSend = false;
+                    ToomossCanDrive.StopCycleSendMsg();
                 }
 
             }
@@ -255,10 +276,10 @@ namespace CapMachine.Wpf.Services
         {
             if (!ToomossCanDrive.IsCycleRevice) return 0;
 
-            if (ListCanDbcModel.Any(a => a.Name == Name))
+            var dbcModel = ListCanDbcModel.FindFirst(a => a.Name == Name);
+            if (dbcModel != null && !string.IsNullOrWhiteSpace(dbcModel.SignalRtValue))
             {
-                //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);
-                return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
+                return double.TryParse(dbcModel.SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
             }
             return 0;
         }
@@ -274,10 +295,10 @@ namespace CapMachine.Wpf.Services
         {
             if (!ToomossCanDrive.IsCycleRevice) return 0;
 
-            if (ListCanDbcModel.Any(a => a.Name == Name))
+            var dbcModel = ListCanDbcModel.FindFirst(a => a.Name == Name);
+            if (dbcModel != null && !string.IsNullOrWhiteSpace(dbcModel.SignalRtValue))
             {
-                //double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue, out double Result1);
-                return double.TryParse(ListCanDbcModel.FindFirst(a => a.Name == Name).SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
+                return double.TryParse(dbcModel.SignalRtValue.Split(" ")[0], out double Result) == true ? Result : 0;
             }
             return 0;
         }

CapMachine.Wpf/Services/MachineRtDataService.cs

@@ -36,6 +36,7 @@ namespace CapMachine.Wpf.Services
         public CanDriveService CanDriveService { get; }
         public LinDriveService LinDriveService { get; }
         public SysRunService SysRunService { get; }
+        public ILogService LogService { get; }
 
         /// <summary>
         /// PLCScanTask扫描Task
@@ -112,7 +113,7 @@ namespace CapMachine.Wpf.Services
         /// </summary>
         /// <param name="eventAggregator"></param>
         public MachineRtDataService(IEventAggregator eventAggregator, AlarmService alarmService, ConfigService configService,
-            CanDriveService canDriveService, LinDriveService linDriveService, SysRunService sysRunService)//, AlarmService alarmService
+            CanDriveService canDriveService, LinDriveService linDriveService, SysRunService sysRunService, ILogService logService)//, AlarmService alarmService
         {
             //ConcurrentDictionary<DateTime, RecordInfo> keyValuePairs = new ConcurrentDictionary<DateTime, RecordInfo>();
 
@@ -130,6 +131,7 @@ namespace CapMachine.Wpf.Services
             CanDriveService = canDriveService;
             LinDriveService = linDriveService;
             SysRunService = sysRunService;
+            LogService = logService;
 
             //秒触发一次
             CycleTimer = new System.Timers.Timer(500);
@@ -1108,14 +1110,20 @@ namespace CapMachine.Wpf.Services
         /// </summary>
         private void RtScanDeviceStart()
         {
+            LogService.Info("RtScanDeviceStart 开始启动 PLC 扫描线程");
             PLCScanTask = Task.Run(async () =>
             {
                 Stopwatch stopwatch = new Stopwatch();
+                int cycleCount = 0;
 
                 while (ThreadEnable)
                 {
-                    //await Task.Delay(5);
-                    await Task.CompletedTask;
+                    cycleCount++;
+                    if (cycleCount % 100 == 0)
+                    {
+                        LogService.Info($"RtScanDeviceStart 循环计数: {cycleCount}");
+                    }
+                    await Task.Delay(50);
 
                     DiagnosticsTime.Reset();
                     DiagnosticsTime.Start();
@@ -1134,6 +1142,7 @@ namespace CapMachine.Wpf.Services
                         //    IsShowCount = 0;
                         //    IsValueShow = true;
                         //}
+
                         foreach (var itemTag in TagManger.DicTags)
                         {
                             //TagManger.GetTagInfoValueByName<short>(itemTag.Value.Name)!.Value = (short)random.Next(0, 100);
@@ -1172,7 +1181,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)CanDriveService.GetDbcSpeedValueBySpeedName("通讯转速"));
+                                                    try
+                                                    {
+                                                        var speedValue = CanDriveService.GetDbcSpeedValueBySpeedName("通讯转速");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)speedValue);
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯转速失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1190,7 +1207,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)(CanDriveService.GetDbcValueByName("通讯母线电压") * itemTag.Value.Precision));
+                                                    try
+                                                    {
+                                                        var voltageValue = CanDriveService.GetDbcValueByName("通讯母线电压");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)(voltageValue * itemTag.Value.Precision));
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯母线电压失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1208,7 +1233,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)(CanDriveService.GetDbcValueByName("通讯母线电流") * itemTag.Value.Precision));
+                                                    try
+                                                    {
+                                                        var currentValue = CanDriveService.GetDbcValueByName("通讯母线电流");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)(currentValue * itemTag.Value.Precision));
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯母线电流失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1226,7 +1259,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)(CanDriveService.GetDbcValueByName("通讯相电流") * itemTag.Value.Precision));
+                                                    try
+                                                    {
+                                                        var phaseCurrentValue = CanDriveService.GetDbcValueByName("通讯相电流");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)(phaseCurrentValue * itemTag.Value.Precision));
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯相电流失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1244,7 +1285,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)(CanDriveService.GetDbcValueByName("通讯功率") * itemTag.Value.Precision));
+                                                    try
+                                                    {
+                                                        var powerValue = CanDriveService.GetDbcValueByName("通讯功率");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)(powerValue * itemTag.Value.Precision));
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯功率失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1262,7 +1311,15 @@ namespace CapMachine.Wpf.Services
                                             {
                                                 case CanLinEnum.Can:
                                                     //通信转速 Dbc中间配置名称的转速数据读取出来 给PLC
-                                                    SiemensDrive.Write(itemTag.Value.PVAddress, (short)(CanDriveService.GetDbcValueByName("通讯芯片温度") * itemTag.Value.Precision));
+                                                    try
+                                                    {
+                                                        var tempValue = CanDriveService.GetDbcValueByName("通讯芯片温度");
+                                                        SiemensDrive.Write(itemTag.Value.PVAddress, (short)(tempValue * itemTag.Value.Precision));
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 读取CAN通讯芯片温度失败: {ex.Message}");
+                                                    }
                                                     //itemTag.Value.EngPvValue = 0;
                                                     break;
                                                 case CanLinEnum.Lin:
@@ -1296,7 +1353,15 @@ namespace CapMachine.Wpf.Services
                                                 if (itemTag.Value.Group == "CANLIN")
                                                 {
                                                     //回读CAN通信的DBC集合数据到集合中
-                                                    itemTag.Value.EngPvValue = CanDriveService.GetDbcValueByName(itemTag.Value.NameNoUnit);
+                                                    try
+                                                    {
+                                                        var dbcValue = CanDriveService.GetDbcValueByName(itemTag.Value.NameNoUnit);
+                                                        itemTag.Value.EngPvValue = dbcValue;
+                                                    }
+                                                    catch (Exception ex)
+                                                    {
+                                                        LogService.Error($"RtScanDeviceStart 回读CAN数据 {itemTag.Value.NameNoUnit} 失败: {ex.Message}");
+                                                    }
                                                 }
                                                 break;
                                             case CanLinEnum.Lin:
@@ -1437,8 +1502,11 @@ namespace CapMachine.Wpf.Services
                     }
                     catch (Exception ex)
                     {
-                        //LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
-
+                        LogService.Error($"RtScanDeviceStart 扫描异常 (周期 {cycleCount}): {ex.Message}\r\n堆栈: {ex.StackTrace}");
+                    }
+                    finally
+                    {
+                        DiagnosticsTime.Stop();
                     }
 
                     DiagnosticsTime.Stop();

CapMachine.Wpf/ViewModels/CANConfigViewModel.cs

@@ -39,9 +39,9 @@ namespace CapMachine.Wpf.ViewModels
             IEventAggregator eventAggregator, IRegionManager regionManager, SysRunService sysRunService,
             ComActionService actionService,
             ConfigService configService, CanDriveService canDriveService,
-            IMapper mapper, MachineRtDataService machineRtDataService)
+            IMapper mapper, MachineRtDataService machineRtDataService, ILogService logService)
         {
-            //LogService = logService;
+            LogService = logService;
             FreeSql = freeSql;
             EventAggregator = eventAggregator;
             RegionManager = regionManager;
@@ -52,7 +52,6 @@ namespace CapMachine.Wpf.ViewModels
             Mapper = mapper;
             this.MachineRtDataService = machineRtDataService;
 
-            //MachineDataService = machineDataService;
             DialogService = dialogService;
 
             WriteNameCbxItems = new ObservableCollection<CbxItems>()
@@ -89,6 +88,7 @@ namespace CapMachine.Wpf.ViewModels
         public CanDriveService CanDriveService { get; }
         public IMapper Mapper { get; }
         private MachineRtDataService MachineRtDataService { get; }
+        public ILogService LogService { get; }
 
         /// <summary>
         /// 弹窗服务
@@ -104,6 +104,9 @@ namespace CapMachine.Wpf.ViewModels
         /// </summary>
         private void InitLoadCanConfigPro()
         {
+            try
+            {
+                LogService.Info("开始加载CAN配置数据");
                 //CAN配置集合数据
                 canLinConfigPros = FreeSql.Select<CanLinConfigPro>().Where(a => a.CANLINInfo == CANLIN.CAN)
                     .Include(a => a.CANConfigExd)
@@ -136,13 +139,6 @@ namespace CapMachine.Wpf.ViewModels
                                 SignalName = item.SignalName,
                                 SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
                             });
-                        //CanDriveService.CmdData.Add(new CanCmdData()
-                        //{
-                        //    ConfigName = item.Name,
-                        //    MsgName = item.MsgFrameName,
-                        //    SignalName = item.SignalName,
-                        //    SignalCmdValue = double.TryParse(item.DefautValue, out double result) == true ? result : 0,
-                        //});
                         }
                     }
                     var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
@@ -154,6 +150,13 @@ namespace CapMachine.Wpf.ViewModels
                     //匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel
                     MatchSeletedAndCanDbcModel();
                 }
+                LogService.Info("CAN配置数据加载成功");
+            }
+            catch (Exception ex)
+            {
+                LogService.Error($"加载CAN配置数据失败: {ex.Message}\r\n堆栈: {ex.StackTrace}");
+                System.Windows.MessageBox.Show($"加载CAN配置数据失败: {ex.Message}", "错误", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
+            }
         }
 
         /// <summary>
@@ -373,15 +376,21 @@ namespace CapMachine.Wpf.ViewModels
                     }
                     break;
                 case "Active":
-
+                    try
+                    {
+                        LogService.Info("开始执行CAN配置激活操作");
                         //激活到取消的状态的判断
                         if (IsCanConfigProActive == true)
                         {
+                            LogService.Info("准备取消激活状态");
                             //控件的激活
                             IsCanConfigProActive = !IsCanConfigProActive;
+                            LogService.Info("IsCanConfigProActive已更新");
                             //控件的激活配置信息
                             IsCANConfigDatagridActive = !IsCanConfigProActive;
+                            LogService.Info("IsCANConfigDatagridActive已更新");
 
+                            LogService.Info("CAN配置已取消激活");
                             return;
                         }
 
@@ -389,15 +398,22 @@ namespace CapMachine.Wpf.ViewModels
                         {
                             if (SelectCanLinConfigPro != null)
                             {
+                                LogService.Info($"准备激活配置: {SelectCanLinConfigPro.ConfigName}");
                                 //控件的激活
                                 IsCanConfigProActive = !IsCanConfigProActive;
+                                LogService.Info("IsCanConfigProActive已更新为true");
                                 //控件的激活配置信息
                                 IsCANConfigDatagridActive = !IsCanConfigProActive;
+                                LogService.Info("IsCANConfigDatagridActive已更新");
 
                                 //当前使用的CAN 配置信息
+                                LogService.Info("开始调用InitCanConfig");
                                 CanDriveService.InitCanConfig(SelectCanLinConfigPro);
+                                LogService.Info("InitCanConfig完成");
 
+                                LogService.Info("开始调用InitLoadCanConfigPro");
                                 InitLoadCanConfigPro();
+                                LogService.Info($"CAN配置激活成功: {SelectCanLinConfigPro.ConfigName}");
                             }
                             else
                             {
@@ -409,6 +425,22 @@ namespace CapMachine.Wpf.ViewModels
                         {
                             System.Windows.MessageBox.Show("请确保CAN连接打开和Dbc解析成功后再激活", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
                         }
+                    }
+                    catch (Exception ex)
+                    {
+                        LogService.Error($"CAN配置激活操作失败: {ex.Message}\r\n堆栈: {ex.StackTrace}");
+                        System.Windows.MessageBox.Show($"CAN配置激活操作失败: {ex.Message}", "错误", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Error);
+                        //恢复状态
+                        try
+                        {
+                            IsCanConfigProActive = false;
+                            IsCANConfigDatagridActive = true;
+                        }
+                        catch (Exception restoreEx)
+                        {
+                            LogService.Error($"恢复状态失败: {restoreEx.Message}");
+                        }
+                    }
                     break;
                 default:
                     break;

CapMachine.Wpf/ViewModels/ProConfigViewModel.cs

@@ -17,6 +17,7 @@ using System.Collections.ObjectModel;
 using System.Data;
 using System.Text;
 using System.Windows;
+using System.Windows.Controls;
 
 namespace CapMachine.Wpf.ViewModels
 {
@@ -1759,7 +1760,16 @@ namespace CapMachine.Wpf.ViewModels
             //    cr.EndEdit();
             //}
 
-            var dd = par;
+            //if (par is DataGrid dataGrid && dataGrid.SelectedCells.Count > 0)
+            //{
+            //    var selectedCell = dataGrid.SelectedCells[0];
+            //    string columnHeader = selectedCell.Column.Header?.ToString();
+            //    // 处理列头信息
+            //}
+
+            //var dd = par;
+
+
             //var dd = new SelectedCellsCollection();
             //if (par is SelectedCellCo selectedCells)
             //{
@@ -15897,8 +15907,16 @@ namespace CapMachine.Wpf.ViewModels
         {
             try
             {
-                TimeSpan TimeInfo = TimeSpan.FromSeconds(TotalSec);
-                return TimeInfo.ToString();
+                //TimeSpan TimeInfo = TimeSpan.FromSeconds(TotalSec);
+                //return TimeInfo.ToString();
+
+                int hours = TotalSec / 3600;
+                int remainingSeconds = TotalSec % 3600;
+                int minutes = remainingSeconds / 60;
+                int seconds = remainingSeconds % 60;
+
+                return $"{hours}:{minutes:D2}:{seconds:D2}";
+
             }
             catch (Exception ex)
             {
@@ -15908,8 +15926,6 @@ namespace CapMachine.Wpf.ViewModels
 
         }
 
-
-
         #region 公共库
 
         /// <summary>

CapMachine.Wpf/Views/ProConfigView.xaml

@@ -833,9 +833,11 @@
                             <prism:InvokeCommandAction Command="{Binding GridSelectionChangedCmd}" CommandParameter="{Binding ElementName=MainDatagrid, Path=SelectedItem}" />
                         </i:EventTrigger>
                         <i:EventTrigger EventName="SelectedCellsChanged">
-                            <prism:InvokeCommandAction Command="{Binding GridSelectedCellsChangedCmd}" CommandParameter="{Binding SelectedCells, ElementName=MainDatagrid}" />
+                            <prism:InvokeCommandAction Command="{Binding GridSelectedCellsChangedCmd}" CommandParameter="{Binding ElementName=MainDatagrid}" />
                         </i:EventTrigger>
                     </i:Interaction.Triggers>
+                    <!--  CommandParameter="{Binding SelectedCells, ElementName=MainDatagrid}" />  -->
+
                     <!--<prism:InvokeCommandAction Command="{Binding GridSelectionChangedCmd}" CommandParameter="{Binding RelativeSource={RelativeSource AncestorType=DataGrid}}" />-->
                     <!--  CommandParameter="{Binding ElementName=MainDatagrid, Path=SelectedItem}"  -->
                     <!--<DataGrid.RowStyle>
@@ -1474,7 +1476,7 @@
                                             VerticalAlignment="Center"
                                             FontSize="12"
                                             FontWeight="Bold"
-                                            Text="COND1温度&#10;(℃)" />
+                                            Text="冷凝器出口水温&#x0A;(℃)" />
                                     </StackPanel>
                                 </TabItem.Header>
                                 <Controls:MeterConfig
@@ -1488,7 +1490,7 @@
                                     EditCommand="{Binding ProStepCond1TempEditCmd}"
                                     IsTimeOk="{Binding MeterCond1TempExDto.IsTimeOk}"
                                     ListMeter="{Binding ListSlopMeterCond1TempItems}"
-                                    MeterName="COND1温度"
+                                    MeterName="冷凝器出口水温"
                                     MeterSelectedChangedCmd="{Binding MeterCond1TempSlopSelectedChangedCmd}"
                                     ParConfigCommand="{Binding MeterCond1TempParConfigCmd}"
                                     SelectedMeter="{Binding SelectedSlopCond1Temp, Mode=TwoWay}"
@@ -1633,6 +1635,40 @@
                             </TabItem>-->
 
 
+                            <TabItem>
+                                <TabItem.Header>
+                                    <StackPanel
+                                        Width="90"
+                                        Margin="-20"
+                                        HorizontalAlignment="Center"
+                                        VerticalAlignment="Center">
+                                        <TextBlock
+                                            HorizontalAlignment="Center"
+                                            VerticalAlignment="Center"
+                                            FontSize="12"
+                                            FontWeight="Bold"
+                                            Text="吸气混合器温度&#x0A;(℃)" />
+                                    </StackPanel>
+                                </TabItem.Header>
+                                <Controls:MeterConfig
+                                    Margin="5,5,0,5"
+                                    AddCommand="{Binding ProStepOS2TempAddCmd}"
+                                    ConstSlopSelectedIndex="{Binding ProStepOS2TempSwitchConstSlopIndex, Mode=TwoWay}"
+                                    ConstantSaveCommand="{Binding ProStepOS2TempConstantSaveCmd}"
+                                    ConstantValue="{Binding SelectedConstOS2TempValue, Mode=TwoWay}"
+                                    Cycle="{Binding MeterOS2TempExDto.SlopCycle}"
+                                    DeleteCommand="{Binding ProStepOS2TempDeleteCmd}"
+                                    EditCommand="{Binding ProStepOS2TempEditCmd}"
+                                    IsTimeOk="{Binding MeterOS2TempExDto.IsTimeOk}"
+                                    ListMeter="{Binding ListSlopMeterOS2TempItems}"
+                                    MeterName="吸气混合器温度"
+                                    MeterSelectedChangedCmd="{Binding MeterOS2TempSlopSelectedChangedCmd}"
+                                    ParConfigCommand="{Binding MeterOS2TempParConfigCmd}"
+                                    SelectedMeter="{Binding SelectedSlopOS2Temp, Mode=TwoWay}"
+                                    SwitchConstSlopCommand="{Binding MeterOS2TempSwitchConstSlopCmd}"
+                                    TotalSlopTime="{Binding MeterOS2TempExDto.SlopTime}" />
+                            </TabItem>
+
 
                             <TabItem>
                                 <TabItem.Header>
@@ -1668,7 +1704,6 @@
                                     TotalSlopTime="{Binding MeterHVVolExDto.SlopTime}" />
                             </TabItem>
 
-
                             <TabItem>
                                 <TabItem.Header>
                                     <StackPanel
@@ -1771,39 +1806,7 @@
                                     TotalSlopTime="{Binding MeterOS1TempExDto.SlopTime}" />
                             </TabItem>-->
 
-                            <TabItem>
-                                <TabItem.Header>
-                                    <StackPanel
-                                        Width="90"
-                                        Margin="-20"
-                                        HorizontalAlignment="Center"
-                                        VerticalAlignment="Center">
-                                        <TextBlock
-                                            HorizontalAlignment="Center"
-                                            VerticalAlignment="Center"
-                                            FontSize="12"
-                                            FontWeight="Bold"
-                                            Text="OS2温度&#10;(℃)" />
-                                    </StackPanel>
-                                </TabItem.Header>
-                                <Controls:MeterConfig
-                                    Margin="5,5,0,5"
-                                    AddCommand="{Binding ProStepOS2TempAddCmd}"
-                                    ConstSlopSelectedIndex="{Binding ProStepOS2TempSwitchConstSlopIndex, Mode=TwoWay}"
-                                    ConstantSaveCommand="{Binding ProStepOS2TempConstantSaveCmd}"
-                                    ConstantValue="{Binding SelectedConstOS2TempValue, Mode=TwoWay}"
-                                    Cycle="{Binding MeterOS2TempExDto.SlopCycle}"
-                                    DeleteCommand="{Binding ProStepOS2TempDeleteCmd}"
-                                    EditCommand="{Binding ProStepOS2TempEditCmd}"
-                                    IsTimeOk="{Binding MeterOS2TempExDto.IsTimeOk}"
-                                    ListMeter="{Binding ListSlopMeterOS2TempItems}"
-                                    MeterName="OS2温度"
-                                    MeterSelectedChangedCmd="{Binding MeterOS2TempSlopSelectedChangedCmd}"
-                                    ParConfigCommand="{Binding MeterOS2TempParConfigCmd}"
-                                    SelectedMeter="{Binding SelectedSlopOS2Temp, Mode=TwoWay}"
-                                    SwitchConstSlopCommand="{Binding MeterOS2TempSwitchConstSlopCmd}"
-                                    TotalSlopTime="{Binding MeterOS2TempExDto.SlopTime}" />
-                            </TabItem>
+
 
                             <!--<TabItem>
                                 <TabItem.Header>
@@ -1906,40 +1909,6 @@
                                     TotalSlopTime="{Binding MeterPTCPwExDto.SlopTime}" />
                             </TabItem>-->
 
-                            <TabItem>
-                                <TabItem.Header>
-                                    <StackPanel
-                                        Width="90"
-                                        Margin="-20"
-                                        HorizontalAlignment="Center"
-                                        VerticalAlignment="Center">
-                                        <TextBlock
-                                            HorizontalAlignment="Center"
-                                            VerticalAlignment="Center"
-                                            FontSize="12"
-                                            FontWeight="Bold"
-                                            Text="压缩机环境湿度&#10;(%)" />
-                                    </StackPanel>
-                                </TabItem.Header>
-                                <Controls:MeterConfig
-                                    Margin="5,5,0,5"
-                                    AddCommand="{Binding ProStepEnvRHAddCmd}"
-                                    ConstSlopSelectedIndex="{Binding ProStepEnvRHSwitchConstSlopIndex, Mode=TwoWay}"
-                                    ConstantSaveCommand="{Binding ProStepEnvRHConstantSaveCmd}"
-                                    ConstantValue="{Binding SelectedConstEnvRHValue, Mode=TwoWay}"
-                                    Cycle="{Binding MeterEnvRHExDto.SlopCycle}"
-                                    DeleteCommand="{Binding ProStepEnvRHDeleteCmd}"
-                                    EditCommand="{Binding ProStepEnvRHEditCmd}"
-                                    IsTimeOk="{Binding MeterEnvRHExDto.IsTimeOk}"
-                                    ListMeter="{Binding ListSlopMeterEnvRHItems}"
-                                    MeterName="压缩机环境湿度"
-                                    MeterSelectedChangedCmd="{Binding MeterEnvRHSlopSelectedChangedCmd}"
-                                    ParConfigCommand="{Binding MeterEnvRHParConfigCmd}"
-                                    SelectedMeter="{Binding SelectedSlopEnvRH, Mode=TwoWay}"
-                                    SwitchConstSlopCommand="{Binding MeterEnvRHSwitchConstSlopCmd}"
-                                    TotalSlopTime="{Binding MeterEnvRHExDto.SlopTime}" />
-                            </TabItem>
-
                             <TabItem>
                                 <TabItem.Header>
                                     <StackPanel
@@ -1974,6 +1943,40 @@
                                     TotalSlopTime="{Binding MeterEnvTempExDto.SlopTime}" />
                             </TabItem>
 
+                            <TabItem>
+                                <TabItem.Header>
+                                    <StackPanel
+                                        Width="90"
+                                        Margin="-20"
+                                        HorizontalAlignment="Center"
+                                        VerticalAlignment="Center">
+                                        <TextBlock
+                                            HorizontalAlignment="Center"
+                                            VerticalAlignment="Center"
+                                            FontSize="12"
+                                            FontWeight="Bold"
+                                            Text="压缩机环境湿度&#10;(%)" />
+                                    </StackPanel>
+                                </TabItem.Header>
+                                <Controls:MeterConfig
+                                    Margin="5,5,0,5"
+                                    AddCommand="{Binding ProStepEnvRHAddCmd}"
+                                    ConstSlopSelectedIndex="{Binding ProStepEnvRHSwitchConstSlopIndex, Mode=TwoWay}"
+                                    ConstantSaveCommand="{Binding ProStepEnvRHConstantSaveCmd}"
+                                    ConstantValue="{Binding SelectedConstEnvRHValue, Mode=TwoWay}"
+                                    Cycle="{Binding MeterEnvRHExDto.SlopCycle}"
+                                    DeleteCommand="{Binding ProStepEnvRHDeleteCmd}"
+                                    EditCommand="{Binding ProStepEnvRHEditCmd}"
+                                    IsTimeOk="{Binding MeterEnvRHExDto.IsTimeOk}"
+                                    ListMeter="{Binding ListSlopMeterEnvRHItems}"
+                                    MeterName="压缩机环境湿度"
+                                    MeterSelectedChangedCmd="{Binding MeterEnvRHSlopSelectedChangedCmd}"
+                                    ParConfigCommand="{Binding MeterEnvRHParConfigCmd}"
+                                    SelectedMeter="{Binding SelectedSlopEnvRH, Mode=TwoWay}"
+                                    SwitchConstSlopCommand="{Binding MeterEnvRHSwitchConstSlopCmd}"
+                                    TotalSlopTime="{Binding MeterEnvRHExDto.SlopTime}" />
+                            </TabItem>
+
                         </TabControl>