TyroneGit/CapMachine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CAN FD 调度表初步更改

Browse Source
This commit is contained in:
Tyrone CT
2026-01-14 17:55:45 +08:00
parent 427cdc5305
commit 4d16b474c6
19 changed files with 2130 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
CapMachine.Model/CANLIN/CANFdConfigExd.cs
View File

@@ -49,5 +49,11 @@ namespace CapMachine.Model.CANLIN
/// </summary>
[Column(Name = "DbcPath", IsNullable = false, StringLength = 500)]
public string? DbcPath { get; set; }
/// <summary>
/// 调度表是否启用
/// </summary>
[Column(Name = "SchEnable")]
public bool SchEnable { get; set; }
}
}

60
CapMachine.Model/CANLIN/CANFdScheduleConfig.cs Normal file
View File

@@ -0,0 +1,60 @@
using FreeSql.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Model.CANLIN
{
/// <summary>
/// 调度表的配置
/// 其实这些调度表是在DBC中有的，但是图莫斯的驱动没有读取到这些信息
/// 那么我们在系统层面进行操作和保存这些信息
/// </summary>
[Table(Name = "CANFdScheduleConfig")]
public class CANFdScheduleConfig
{
/// <summary>
/// 主键
/// </summary>
[Column(IsPrimary = true, IsIdentity = true)]
public long Id { get; set; }
/// <summary>
/// 消息名称
/// </summary>
[Column(Name = "MsgName")]
public string? MsgName { get; set; }
/// <summary>
/// 消息的周期
/// </summary>
[Column(Name = "Cycle")]
public int Cycle { get; set; }
/// <summary>
/// 发送方式
/// </summary>
[Column(Name = "OrderSend")]
public int OrderSend { get; set; }
/// <summary>
/// 调度表的Index
/// //约定每帧对应一个调度表，预设5个调度表，每个调度表对应一个帧
/// 0-4这个范围的设置Index
/// </summary>
[Column(Name = "SchTabIndex")]
public int SchTabIndex { get; set; }
/// <summary>
/// ///////////////////////////////////////////导航属性///////////////////////////////////////////////////////
/// </summary>
public long CanLinConfigProId { get; set; }
public CanLinConfigPro? CanLinConfigPro { get; set; }
}
}

6
CapMachine.Model/CANLIN/CanLinConfigPro.cs
View File

@@ -50,6 +50,12 @@ namespace CapMachine.Model.CANLIN
///CAN 的调度表配置模式
public List<CANScheduleConfig>? CanScheduleConfigs { get; set; }
/// <summary>
/// ///////////////////////////////////////////导航属性///////////////////////////////////////////////////////
/// </summary>
///CAN 的调度表配置模式
public List<CANFdScheduleConfig>? CanFdScheduleConfigs { get; set; }
/// <summary>
/// ///////////////////////////////////////////导航属性///////////////////////////////////////////////////////
/// </summary>

21
CapMachine.Model/HistoryWorkCondFile.cs
View File

@@ -1,4 +1,5 @@
using FreeSql.DataAnnotations;
using System.ComponentModel;
namespace CapMachine.Model
{
@@ -6,7 +7,7 @@ namespace CapMachine.Model
/// 历史工况对应的文件信息
/// </summary>
[Table(Name = "HistoryWorkCondFile")]
public class HistoryWorkCondFile
public class HistoryWorkCondFile : INotifyPropertyChanged
{
/// <summary>
/// 主键
@@ -49,5 +50,23 @@ namespace CapMachine.Model
/// </summary>
public long HistoryExpId { get; set; }
public HistoryExp? HistoryExp { get; set; }
[Column(IsIgnore = true)]
public bool IsSelected
{
get { return _isSelected; }
set
{
if (_isSelected != value)
{
_isSelected = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsSelected)));
}
}
}
private bool _isSelected;
public event PropertyChangedEventHandler? PropertyChanged;
}
}

3
CapMachine.Wpf/App.xaml.cs
View File

@@ -199,7 +199,8 @@ namespace CapMachine.Wpf
containerRegistry.RegisterDialog<DialogLimitConfigView, DialogLimitConfigViewModel>();
containerRegistry.RegisterDialog<DialogSuperHeatCoolConfigView, DialogSuperHeatCoolConfigViewModel>();
containerRegistry.RegisterDialog<DialogLogicRuleView, DialogLogicRuleViewModel>();
containerRegistry.RegisterDialog<DialogCANFdSchConfigView, DialogCANFdSchConfigViewModel>();
containerRegistry.RegisterDialog<DialogCANSchConfigView, DialogCANSchConfigViewModel>();
containerRegistry.RegisterDialog<DialogLINSchConfigView, DialogLINSchConfigViewModel>();

18
CapMachine.Wpf/CanDrive/CanFD/DBCParserByFD.cs
View File

@@ -28,6 +28,23 @@ namespace CapMachine.Wpf.CanDrive.CanFD
public static extern Int32 DBC_GetMsgQuantity(UInt64 DBCHandle);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgName(UInt64 DBCHandle, int index, StringBuilder pMsgName);
/// <summary>
///
/// </summary>
/// <param name="DBCHandle"></param>
/// <param name="ID"></param>
/// <param name="pMsgName"></param>
/// <returns></returns>
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgNameByID(UInt64 DBCHandle, int ID, StringBuilder pMsgName);
/// <summary>
/// 获取ID根据名称
/// </summary>
/// <param name="DBCHandle"></param>
/// <param name="pMsgName"></param>
/// <returns></returns>
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgIDByName(UInt64 DBCHandle, StringBuilder pMsgName);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_GetMsgSignalQuantity(UInt64 DBCHandle, StringBuilder pMsgName);
[DllImport("USB2XXX.dll")]
@@ -53,5 +70,6 @@ namespace CapMachine.Wpf.CanDrive.CanFD
public static extern Int32 DBC_SyncValueToCANMsg(UInt64 DBCHandle, StringBuilder pMsgName, IntPtr pCANMsg);
[DllImport("USB2XXX.dll")]
public static extern Int32 DBC_SyncValueToCANFDMsg(UInt64 DBCHandle, StringBuilder pMsgName, IntPtr pCANFDMsg);
}
}

726
CapMachine.Wpf/CanDrive/CanFD/ToomossCanFD.cs
View File

@@ -1,10 +1,13 @@
using CapMachine.Wpf.CanDrive.CanFD;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.Models.Tag;
using CapMachine.Wpf.Services;
using ImTools;
using NPOI.OpenXmlFormats.Wordprocessing;
using Prism.Ioc;
using Prism.Mvvm;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
@@ -28,11 +31,12 @@ namespace CapMachine.Wpf.CanDrive
/// <summary>
/// 实例化函数
/// </summary>
public ToomossCanFD(IContainerProvider containerProvider)
public ToomossCanFD(IContainerProvider containerProvider, ILogService logService)
{
ContainerProvider = containerProvider;
LoggerService = logService;
HighSpeedDataService = ContainerProvider.Resolve<HighSpeedDataService>();
LogService = ContainerProvider.Resolve<ILogService>();
//LogService = ContainerProvider.Resolve<ILogService>();
//Stopwatch.Frequency表示高精度计时器每秒的计数次数（ticks/秒）每毫秒的ticks数 = 每秒的ticks数 ÷ 1000
TicksPerMs = Stopwatch.Frequency / 1000.0;
}
@@ -42,7 +46,7 @@ namespace CapMachine.Wpf.CanDrive
/// </summary>
public HighSpeedDataService HighSpeedDataService { get; set; }
public ILogService LogService { get; set; }
public ILogService LoggerService { get; set; }
/// <summary>
/// 开始CAN的驱动
@@ -60,7 +64,7 @@ namespace CapMachine.Wpf.CanDrive
}
catch (Exception ex)
{
LogService.Error(ex.Message);
LoggerService.Error(ex.Message);
System.Windows.MessageBox.Show($"{ex.Message}", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
}
@@ -482,6 +486,11 @@ namespace CapMachine.Wpf.CanDrive
private static readonly Random _random = new Random();
/// <summary>
/// 定时扫描更新数据 扫描Task
/// </summary>
private static Task CycleUpdateCmdTask { get; set; }
/// <summary>
/// 精确周期发送CAN数据
/// </summary>
@@ -549,6 +558,7 @@ namespace CapMachine.Wpf.CanDrive
//此时重置NextExecutionTime为当前时间，避免连续的延迟累积
// 严重延迟，重新校准
NextExecutionTime = Stopwatcher.ElapsedTicks;
LoggerService.Info("定时发送延迟过大，重新校准时间");
Console.WriteLine("定时发送延迟过大，重新校准时间");
}
@@ -611,29 +621,35 @@ namespace CapMachine.Wpf.CanDrive
catch (TaskCanceledException)
{
// 任务被取消，正常退出
IsSendOk = false;
break;
}
catch (Exception ex)
{
LogService.Error(ex.Message);
LoggerService.Error(ex.Message);
Console.WriteLine($"CAN周期发送异常: {ex.Message}");
// 短暂暂停避免异常情况下CPU占用过高
IsSendOk = false;
await Task.Delay(10, token);
}
}
IsSendOk = false;
}
catch (Exception ex)
{
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
Stopwatcher.Stop();
LogService.Error(ex.Message);
LoggerService.Error(ex.Message);
// 清理其他可能的资源
Console.WriteLine("CAN周期发送任务已结束，资源已清理");
IsSendOk = false;
}
finally
{
// 确保在任何情况下（正常退出、异常、取消）都会停止计时器
Stopwatcher.Stop();
IsSendOk = false;
}
}, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
@@ -677,6 +693,651 @@ namespace CapMachine.Wpf.CanDrive
#endregion
#region 并行多线程发送报文
/// <summary>
/// 并行精确周期发送CAN数据
/// </summary>
public void StartParallelPrecisionCycleSendMsg()
{
// 创建取消标记源
var cancellationTokenSource = new CancellationTokenSource();
var token = cancellationTokenSource.Token;
// 保存取消标记，以便在停止时使用
CycleSendCts = cancellationTokenSource;
// 初始化计时基准
TicksPerMs = Stopwatch.Frequency / 1000.0;
// 分组消息，按照消息名称进行分组
var groupedMessages = CmdData.GroupBy(x => x.MsgName).ToList();
// 创建发送任务列表
var sendTasks = new List<Task>();
// 创建线程同步对象，确保DBC操作和发送操作的线程安全
object dbcLock = new object();
// 为每组消息创建单独的发送任务
foreach (var messageGroup in groupedMessages)
{
var msgName = messageGroup.Key;
var signals = messageGroup.ToList();
// 为每个消息组创建一个发送任务
var sendTask = Task.Factory.StartNew(async () =>
{
try
{
// 设置线程优先级
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
// 每个消息使用独立的计时器
var messageStopwatch = new Stopwatch();
messageStopwatch.Start();
// 计算该消息的发送周期(可以为不同消息设置不同周期)
// 这里可以从配置或参数中获取特定消息的周期
long cycleInTicks = (long)(SendCycle * TicksPerMs);
long nextExecutionTime = 0;
while (IsCycleSend && !token.IsCancellationRequested)
{
try
{
// 计算下一次执行时间
nextExecutionTime += cycleInTicks;
// 获取当前时间
long currentTime = messageStopwatch.ElapsedTicks;
long delayTicks = nextExecutionTime - currentTime;
// 精确等待逻辑
if (delayTicks > 0)
{
int delayMs = (int)(delayTicks / TicksPerMs);
if (delayMs <= 20)
{
SpinWait.SpinUntil(() => messageStopwatch.ElapsedTicks >= nextExecutionTime);
}
else
{
await Task.Delay(delayMs - 20, token);
SpinWait.SpinUntil(() => messageStopwatch.ElapsedTicks >= nextExecutionTime);
}
}
// 校准时间，处理严重延迟情况
if (messageStopwatch.ElapsedTicks >= nextExecutionTime + cycleInTicks)
{
nextExecutionTime = messageStopwatch.ElapsedTicks;
LoggerService.Info($"消息{msgName}定时发送延迟过大，重新校准时间");
}
// 使用锁确保DBC操作和发送的线程安全
lock (dbcLock)
{
// 构建CAN消息
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CAN.CAN_MSG)));
try
{
// 为信号赋值
foreach (var signal in signals)
{
DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(msgName),
new StringBuilder(signal.SignalName), signal.SignalCmdValue);
}
// 同步值到CAN消息
DBCParserByFD.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(msgName), msgPtSend);
var canMsg = (USB2CAN.CAN_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CAN.CAN_MSG));
// 直接发送此消息，无需通过队列
USB2CAN.CAN_MSG[] canMsgArray = new USB2CAN.CAN_MSG[] { canMsg };
int sendedNum = USB2CAN.CAN_SendMsg(DevHandle, WriteCANIndex, canMsgArray, 1);
// 更新发送状态
if (sendedNum >= 0)
{
// 发送成功
IsSendOk = true;
}
else
{
IsSendOk = false;
LoggerService.Info($"消息{msgName}发送失败: {sendedNum}");
}
}
finally
{
// 确保释放非托管资源
Marshal.FreeHGlobal(msgPtSend);
}
}
}
catch (TaskCanceledException)
{
LoggerService.Info($"消息{msgName}发送任务被取消");
break;
}
catch (Exception ex)
{
LoggerService.Info($"消息{msgName}发送异常: {ex.Message}");
await Task.Delay(10, token);
}
}
}
catch (Exception ex)
{
LoggerService.Info($"消息{msgName}发送线程异常: {ex.Message}");
}
finally
{
LoggerService.Info($"消息{msgName}发送线程已退出");
}
}, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
sendTasks.Add(sendTask);
}
// 创建监控任务，监控所有发送任务的状态
CycleSendTask = Task.Factory.StartNew(async () =>
{
try
{
// 等待所有任务完成或取消
await Task.WhenAll(sendTasks.ToArray());
}
catch (Exception ex)
{
LoggerService.Info($"并行发送监控任务异常: {ex.Message}");
}
finally
{
LoggerService.Info("并行发送任务已全部结束");
IsSendOk = false;
}
}, token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
#endregion
#region 调度表发送报文
private bool _SchEnable;
/// <summary>
/// 调度表使能
/// </summary>
public bool SchEnable
{
get { return _SchEnable; }
set
{
_SchEnable = value;
RaisePropertyChanged();
}
}
/// <summary>
/// 调度表的发送的报文数据
/// </summary>
private USB2CANFD.CANFD_MSG[] SchCanMsg { get; set; }
/// <summary>
/// 依据消息的分组
/// </summary>
private IEnumerable<IGrouping<string, CanCmdData>> GroupMsg { get; set; }
/// <summary>
/// 调度表集合数据
/// 总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据
/// Byte[] MsgTabNum = new Byte[3] { 3, 6, 11 };
/// </summary>
private Byte[] MsgTabNum { get; set; }
/// <summary>
/// 调度表发送的次数集合
/// 第一个调度表循环发送数据，第二个调度表循环发送数据，第三个调度表只发送3次
/// UInt16[] SendTimes = new UInt16[3] { 0xFFFF, 0xFFFF, 3 };
/// </summary>
private UInt16[] SendTimes { get; set; }
/// <summary>
/// 预设的调度表的个数 常值
/// </summary>
private const int MsgTabCount = 5;
/// <summary>
/// 定时更新时间
/// </summary>
private int UpdateCycle { get; set; } = 100;
/// <summary>
/// CNA 调度表的配置信息
/// </summary>
public List<CANFdScheduleConfigDto> ListCANScheduleConfig { get; set; }
Random random = new Random();
/// <summary>
/// 监控数据
/// 查找问题用，平时不用
/// </summary>
//public MonitorValueLog monitorValueLog { get; set; }
/// <summary>
/// 更新数据 测试用废弃了
/// </summary>
public void UpdateValue()
{
//通过DBC进行对消息赋值
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
int Index = 0;
//循环给MSG赋值数据
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
itemSignal.SignalCmdValue = random.Next(0, 100);
DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
DBCParserByFD.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
SchCanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG));
Index++;
}
//通过DBC写入数据后生成CanMsg
//将信号值填入CAN消息里面
//释放申请的临时缓冲区
Marshal.FreeHGlobal(msgPtSend);
////总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据
//MsgTabNum = new Byte[1] { 1 };
////第一个调度表循环发送数据，第二个调度表循环发送数据，第三个调度表只发送3次
//SendTimes = new UInt16[1] { 0xFFFF };
//var ret = USB2CANFD.CAN_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
var ret = USB2CANFD.CANFD_UpdateSchedule(DevHandle, WriteCANIndex, 0, 0, SchCanMsg, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
if (ret == USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Update CAN Schedule Success");
}
else
{
Console.WriteLine("Update CAN Schedule Error ret = {0}", ret);
return;
}
}
/// <summary>
/// 开始调度表执行
/// </summary>
public void StartSchedule()
{
if (CmdData.Count() == 0) return;
//依据报文进行分组
GroupMsg = CmdData.GroupBy(x => x.MsgName)!;
//初始化调度表要发送的消息结构
SchCanMsg = new USB2CANFD.CANFD_MSG[GroupMsg.Count()];
for (int i = 0; i < GroupMsg.Count(); i++)
{
SchCanMsg[i] = new USB2CANFD.CANFD_MSG();
SchCanMsg[i].Data = new Byte[64];
}
//通过DBC进行对消息赋值
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
int Index = 0;
//循环给MSG赋值数据
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
DBCParserByFD.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
//每个分组就是一个帧指令/消息数据
SchCanMsg[Index] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG));
//分配当前消息帧在集合中的位置信息到ListCANScheduleConfig中，方便实时更新时定位帧的位置
if (ListCANScheduleConfig.Any(a => a.MsgName == itemMsg.Key))
{
//把帧的位置给ListCANScheduleConfig，方便更新时定位数据
ListCANScheduleConfig.FindFirst(a => a.MsgName == itemMsg.Key).MsgIndex = Index;
//设置当前这个报文的在调度表中的发送周期
SchCanMsg[Index].TimeStamp = (uint)ListCANScheduleConfig.FindFirst(a => a.MsgName == itemMsg.Key).Cycle;
}
Index++;
}
//通过DBC写入数据后生成CanMsg
//将信号值填入CAN消息里面
//释放申请的临时缓冲区
Marshal.FreeHGlobal(msgPtSend);
//********就是可以设置多个调度表放那里，但是运行时同一个时刻只能运行调度表其中的一个 ********
//****** 控制报文SchCanMsg和调度器中第一个调度器中的报文集合和要更新的报文集合都是同一个变量SchCanMsg， ********
// *** SchCanMsg的Index序号和ListCANScheduleConfig的MsgIndex是一样的 ***
//图莫斯的Sample：总共3个调度表，第一个表里面包含3帧数据，第二个调度表包含6帧数据，第三个调度表包含11帧数据
//预设5个调度表，但是我们只用其中第一个调度表，第一个调度表中包括多少消息帧，由系统的控制指令的帧的分布决定，SchCanMsg.Count()是所需要的控制发送的帧，都放到第一个调度表中
MsgTabNum = new Byte[MsgTabCount] { (byte)SchCanMsg.Count(), 1, 1, 1, 1 };
//0xFFFF：调度表循环发送数据，X：调度表循环发送的次数
//设置每个调度表的发送方式，约定全部为循环发送
SendTimes = new UInt16[MsgTabCount] { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF };
//SchCanMsg:需要发送的消息集合；MsgTabNum：调度表集合数据；SendTimes：发送次数集合数据；调度表个数：MsgTabCount
var ret = USB2CANFD.CANFD_SetSchedule(DevHandle, WriteCANIndex, SchCanMsg, MsgTabNum, SendTimes, MsgTabCount);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
if (ret == USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine("Set CAN Schedule Success");
}
else
{
Console.WriteLine("Set CAN Schedule Error ret = {0}", ret);
LoggerService.Info($"Set CAN Schedule Error; 返回错误代码：{ret}");
return;
}
//约定使用Index=0 1号调度器，因为同一个时刻只能有一个调度器工作，把所有的报文都要放到这个调度器中
//CAN_MSG的TimeStamp就是这个报文发送的周期，由调度器协调
ret = USB2CANFD.CANFD_StartSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)100, (byte)ListCANScheduleConfig.FirstOrDefault()!.OrderSend);
if (ret == USB2CANFD.CANFD_SUCCESS)
{
Console.WriteLine($"Start CAN Schedule 1 Success，SchTabIndex：{(byte)0} - Cycle：{(byte)100} - OrderSend：{(byte)1}");
}
else
{
Console.WriteLine("Start CAN Schedule 1 Error ret = {0}", ret);
LoggerService.Info($"Start CAN Schedule 1 Error;");
return;
}
//foreach (var itemGroupMsg in GroupMsg)
//{
// if (itemGroupMsg == null) continue;
// if (ListCANScheduleConfig.Any(a => a.MsgName!.Contains(itemGroupMsg.Key)))
// {
// var CANScheduleConfig = ListCANScheduleConfig.FindFirst(a => a.MsgName!.Contains(itemGroupMsg.Key));
// //配置表里面包括这个报文消息内容
// ret = USB2CANFD.CAN_StartSchedule(DevHandle, WriteCANIndex, (byte)CANScheduleConfig.SchTabIndex, (byte)CANScheduleConfig.Cycle, (byte)CANScheduleConfig.OrderSend);
// if (ret == USB2CANFD.CAN_SUCCESS)
// {
// Console.WriteLine($"Start CAN Schedule 1 Success，SchTabIndex：{(byte)CANScheduleConfig.SchTabIndex} - Cycle：{(byte)CANScheduleConfig.Cycle} - OrderSend：{(byte)CANScheduleConfig.OrderSend}");
// }
// else
// {
// Console.WriteLine("Start CAN Schedule 1 Error ret = {0}", ret);
// LoggerService.Info($"Start CAN Schedule 1 Error;消息名称：{CANScheduleConfig.MsgName}");
// return;
// }
// }
// else
// {
// LoggerService.Info($"调度表配置未发现对应的消息报文信息；报文信息{itemGroupMsg.Key}");
// }
//}
//走到这里说明调度表执行的是OK的
//IsSendOk = true;
}
/// <summary>
/// 停止调度表
/// </summary>
public void StopSchedule()
{
ret = USB2CANFD.CANFD_StopSchedule(DevHandle, WriteCANIndex);//启动第一个调度表,表里面的CAN帧并行发送
if (ret == USB2CANFD.CANFD_SUCCESS)
{
IsSendOk = false;
Console.WriteLine("Stop CAN Schedule");
LoggerService.Info($"Stop CAN Schedule");
}
else
{
Console.WriteLine("Start CAN Schedule Error ret = {0}", ret);
LoggerService.Info($"Stop CAN Schedule");
return;
}
}
/// <summary>
/// 循环使用的
/// </summary>
private int CycleUpdateIndex = 0;
/// <summary>
/// 循环更新调度表的指令数据
/// 定时更新数据到调度表中
/// </summary>
public void StartCycleUpdateCmd()
{
CycleUpdateCmdTask = Task.Run(async () =>
{
while (IsCycleSend)
{
await Task.Delay(UpdateCycle);
try
{
//通过DBC进行对消息赋值
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
CycleUpdateIndex = 0;
//循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
//itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用
DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
}
DBCParserByFD.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
SchCanMsg[CycleUpdateIndex] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG));
CycleUpdateIndex++;
}
//通过DBC写入数据后生成CanMsg
//将信号值填入CAN消息里面
//释放申请的临时缓冲区
Marshal.FreeHGlobal(msgPtSend);
//CAN_UpdateSchedule 官网解释
// ---MsgTabIndex CAN调度表索引号
// ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面
// ---pCanMsg 需要更新的CAN帧指针
// ---MsgNum pCanMsgTab里面包含的有效帧数
//CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号
//因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg
//默认1号调度表，一个更新所有的帧数据
var ret = USB2CANFD.CANFD_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
if (ret == USB2CANFD.CANFD_SUCCESS)
{
IsSendOk = true;
Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)} ");
}
else
{
IsSendOk = false;
Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}");
//return;
}
//一个报文帧一个报文帧进行更新数据
////配置信息 默认启用1号调度器,MsgTabIndex=0；
//foreach (var itemMsgSchConfig in ListCANScheduleConfig)
//{
// //USB2CANFD.CAN_MSG[] SchCanMsg1=new CAN_MSG[1];
// //SchCanMsg1[0] = SchCanMsg[itemMsgSchConfig.MsgIndex];
// // MsgTabIndex CAN调度表索引号 ;MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面， ;
// // pCanMsg 需要更新的CAN帧指针,消息数据 ; MsgNum pCanMsgTab里面包含的有效帧数，一个调度表对应一个帧/消息，即为：1 (byte)(itemMsgSchConfig.MsgIndex+0)
// var ret = USB2CANFD.CAN_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(itemMsgSchConfig.MsgIndex), SchCanMsg, 1);//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
// if (ret == USB2CANFD.CAN_SUCCESS)
// {
// Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)itemMsgSchConfig.SchTabIndex} -- MsgIndex：{(byte)(itemMsgSchConfig.MsgIndex)} ");
// }
// else
// {
// Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)itemMsgSchConfig.SchTabIndex} -- MsgIndex：{(byte)(itemMsgSchConfig.MsgIndex)}");
// //return;
// }
//}
}
catch (Exception ex)
{
IsSendOk = false;
LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}");
}
}
IsSendOk = false;
});
}
/// <summary>
/// 加载要发送的数据
/// 一般是激活后才注册事件
/// </summary>
/// <param name="cmdData"></param>
public void LoadCmdDataToDrive(List<CanCmdData> cmdData)
{
// Unsubscribe from events on the old CmdData items
if (CmdData != null && CmdData.Count > 0)
{
foreach (var cmd in CmdData)
{
cmd.CanCmdDataChangedHandler -= CmdData_CanCmdDataChangedHandler;
}
}
// Set the new data and subscribe to events
CmdData = cmdData;
foreach (var cmd in cmdData)
{
cmd.CanCmdDataChangedHandler += CmdData_CanCmdDataChangedHandler;
}
}
/// <summary>
/// 指令数据发生变化执行方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CmdData_CanCmdDataChangedHandler(object? sender, string e)
{
UpdateSchDataByCmdDataChanged();
}
/// <summary>
/// 指令数据发生变化执行更新调度表锁
/// </summary>
private readonly object SchUpdateLock = new object();
/// <summary>
/// 指令数据发生变化执行方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UpdateSchDataByCmdDataChanged()
{
try
{
if (!IsCycleSend) return;
if (!SchEnable) return;
// 基础防御：确保 DBC/ 调度表 / 分组已经初始化
if (DBCHandle == 0 || SchCanMsg == null || GroupMsg == null)
{
return;
}
lock (SchUpdateLock)
{
//通过DBC进行对消息赋值
IntPtr msgPtSend = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(USB2CANFD.CANFD_MSG)));
int CycleUpdateIndex = 0;
//循环给MSG赋值数据，顺序是固定的，跟初始时设置是一样的
foreach (var itemMsg in GroupMsg)
{
foreach (var itemSignal in itemMsg)
{
//itemSignal.SignalCmdValue = random.Next(0, 100); //仿真测试数据使用
var SetSignalValue = DBCParserByFD.DBC_SetSignalValue(DBCHandle, new StringBuilder(itemMsg.Key), new StringBuilder(itemSignal.SignalName), itemSignal.SignalCmdValue);
//monitorValueLog.UpdateValue1(SetSignalValue);
}
var SyncValueToCanMsg = DBCParserByFD.DBC_SyncValueToCANMsg(DBCHandle, new StringBuilder(itemMsg.Key), msgPtSend);
//monitorValueLog.UpdateValue2(SyncValueToCanMsg);
SchCanMsg[CycleUpdateIndex] = (USB2CANFD.CANFD_MSG)Marshal.PtrToStructure(msgPtSend, typeof(USB2CANFD.CANFD_MSG));
CycleUpdateIndex++;
}
//通过DBC写入数据后生成CanMsg
//将信号值填入CAN消息里面
//释放申请的临时缓冲区
Marshal.FreeHGlobal(msgPtSend);
//CAN_UpdateSchedule 官网解释
// ---MsgTabIndex CAN调度表索引号
// ---MsgIndex 开始更新帧起始索引，若起始索引大于调度表帧数，则将帧添加到调度表后面
// ---pCanMsg 需要更新的CAN帧指针
// ---MsgNum pCanMsgTab里面包含的有效帧数
//CAN_UpdateSchedule中的MsgIndex表示当前的调度器中的帧Index序号
//因为调度表中的帧集合和控制帧的集合和要更新的帧集合都是同一个集合SchCanMsg
//默认1号调度表，一个更新所有的帧数据
var ret = USB2CANFD.CANFD_UpdateSchedule(DevHandle, WriteCANIndex, (byte)0, (byte)(0), SchCanMsg, (byte)SchCanMsg.Count());//配置调度表，该函数耗时可能会比较长，但是只需要执行一次即可
if (ret == USB2CANFD.CANFD_SUCCESS)
{
IsSendOk = true;
//Console.WriteLine($"Update CAN Schedule Success -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)} ");
//monitorValueLog.UpdateValue3(ret);
}
else
{
IsSendOk = false;
//Console.WriteLine($"Update CAN Schedule Error ret = {ret} -- SchTabIndex：{(byte)0} -- MsgIndex：{(byte)(0)}");
//monitorValueLog.UpdateValue3(ret);
LoggerService.Info($"更新调度表失败，错误码：{ret}");
//return;
}
}
}
catch (Exception ex)
{
IsSendOk = false;
LoggerService.Info($"时间:{DateTime.Now.ToString()}-【MSG】-{ex.Message}");
}
}
#endregion
private bool _IsCycleRevice;
/// <summary>
/// 是否循环接收数据
@@ -739,6 +1400,25 @@ namespace CapMachine.Wpf.CanDrive
}
}
private bool _IsReviceOk;
/// <summary>
/// 接收报文是否OK
/// </summary>
public bool IsReviceOk
{
get { return _IsReviceOk; }
set
{
if (_IsReviceOk != value)
{
RaisePropertyChanged();
_IsReviceOk = value;
}
}
}
/// <summary>
/// 要发送的数据
/// </summary>
@@ -751,7 +1431,7 @@ namespace CapMachine.Wpf.CanDrive
{
CycleReviceTask = Task.Run(async () =>
{
//var ret = USB2CANFD.CANFD_StartGetMsg(DevHandle, ReadCANIndex);
//var ret = USB2CANFDFD.CANFD_StartGetMsg(DevHandle, ReadCANIndex);
while (IsCycleRevice)
{
await Task.Delay(ReviceCycle);
@@ -763,6 +1443,7 @@ namespace CapMachine.Wpf.CanDrive
int CanNum = USB2CANFD.CANFD_GetMsg(DevHandle, ReadCANIndex, msgPtRead, CanMsgBuffer.Length);
if (CanNum > 0)
{
IsReviceOk = true;
Console.WriteLine("Read CanMsgNum = {0}", CanNum);
for (int i = 0; i < CanNum; i++)
{
@@ -787,10 +1468,12 @@ namespace CapMachine.Wpf.CanDrive
}
else if (CanNum == 0)
{
IsReviceOk = false;
Console.WriteLine("No CAN data!");
}
else
{
IsReviceOk = false;
Console.WriteLine("Get CAN data error!");
}
Console.WriteLine("");
@@ -804,7 +1487,7 @@ namespace CapMachine.Wpf.CanDrive
//有配置的名称的，认为是有用的，则需要读取数据
//if (!string.IsNullOrEmpty(item.Name))
//{
//CAN_DBCParser.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
//DBCParserByFD.DBC_GetSignalValueStr(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueSb);
//double[] ValueDouble;
DBCParserByFD.DBC_GetSignalValue(DBCHandle, new StringBuilder(item.MsgName), new StringBuilder(item.SignalName), ValueDouble);
//item.SignalRtValueSb = ValueSb;
@@ -826,10 +1509,14 @@ namespace CapMachine.Wpf.CanDrive
}
catch (Exception ex)
{
LogService.Error(ex.Message);
//LogService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
IsReviceOk = false;
LoggerService.Error(ex.Message);
//LoggerService.Info($"时间:{DateTime.Now.ToString()}-【Meter】-{ex.Message}");
}
}
IsReviceOk = false;
});
}
@@ -893,6 +1580,25 @@ namespace CapMachine.Wpf.CanDrive
DbcParserState = false;
IsCycleRevice = false;
IsCycleSend = false;
if (SchEnable)
{
StopSchedule();
}
// 确保定时器发送被停止并释放资源
//try { StopTimerCycleSendMsg(); } catch { }
// 等待接收任务结束后释放非托管缓冲区，避免并发释放
try
{
var task = CycleReviceTask;
if (task != null && !task.IsCompleted)
{
task.Wait(TimeSpan.FromMilliseconds(ReviceCycle + 500));
}
}
catch { }
}
}

37
CapMachine.Wpf/CanDrive/CanFD/USB2CANFD.cs
View File

@@ -4,6 +4,7 @@ using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using static CapMachine.Wpf.CanDrive.USB2CAN;
namespace CapMachine.Wpf.CanDrive
{
@@ -119,16 +120,24 @@ namespace CapMachine.Wpf.CanDrive
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_Init(Int32 DevHandle, Byte CANIndex, ref CANFD_INIT_CONFIG pCanConfig);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_Init2(Int32 DevHandle, Byte CANIndex, Int32 BaudRateNBTBps, Int32 BaudRateDBTBps, Byte EnResistor, Byte ISOCRCEnable);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_StartGetMsg(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_StopGetMsg(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_SendMsg(Int32 DevHandle, Byte CANIndex, CANFD_MSG[] pCanSendMsg, Int32 SendMsgNum);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_SendMsgWithTime(Int32 DevHandle, Byte CANIndex, CANFD_MSG[] pCanSendMsg, Int32 SendMsgNum);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_GetMsg(Int32 DevHandle, Byte CANIndex, IntPtr pCanGetMsg, Int32 BufferSize);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_ClearMsg(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_SetFilter(Int32 DevHandle, Byte CANIndex, ref CANFD_FILTER_CONFIG pCanFilter, Byte Len);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_FilterList_Init(Int32 DevHandle, Byte CANIndex, UInt32[] pIDList, Byte IDListLen);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_GetDiagnostic(Int32 DevHandle, Byte CANIndex, ref CANFD_DIAGNOSTIC pCanDiagnostic);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_GetBusError(Int32 DevHandle, Byte CANIndex, ref CANFD_BUS_ERROR pCanBusError);
@@ -139,9 +148,37 @@ namespace CapMachine.Wpf.CanDrive
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_StartSchedule(Int32 DevHandle, Byte CANIndex, Byte MsgTabIndex, Byte TimePrecMs, Byte OrderSend);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_UpdateSchedule(Int32 DevHandle, Byte CANIndex, Byte MsgTabIndex, Byte MsgIndex, CANFD_MSG[] pCanMsg, Byte MsgNum);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_StopSchedule(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int64 CANFD_GetStartTime(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_ResetStartTime(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CANFD_SetRelay(Int32 DevHandle, Byte RelayState);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_Stop(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int64 CAN_GetStartTime(Int32 DevHandle, Byte CANIndex);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_ResetStartTime(Int32 DevHandle, Byte CANIndex);
//CAN Bootloader相关函数
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_Init(Int32 DevHandle, Int32 CANIndex, ref CAN_INIT_CONFIG pInitConfig, ref CBL_CMD_LIST pCmdList);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_NodeCheck(Int32 DevHandle, Int32 CANIndex, UInt16 NodeAddr, UInt32[] pVersion, UInt32[] pType, UInt32 TimeOut);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_Erase(Int32 DevHandle, Int32 CANIndex, UInt16 NodeAddr, UInt32 FlashSize, UInt32 TimeOut);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_Write(Int32 DevHandle, Int32 CANIndex, UInt16 NodeAddr, UInt32 AddrOffset, Byte[] pData, UInt32 DataNum, UInt32 TimeOut);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_Excute(Int32 DevHandle, Int32 CANIndex, UInt16 NodeAddr, UInt32 Type);
[DllImport("USB2XXX.dll")]
public static extern Int32 CAN_BL_SetNewBaudRate(Int32 DevHandle, Int32 CANIndex, UInt16 NodeAddr, ref CAN_INIT_CONFIG pInitConfig, UInt32 NewBaudRate, UInt32 TimeOut);
}
}

11
CapMachine.Wpf/Dtos/CANFdConfigExdDto.cs
View File

@@ -73,5 +73,16 @@ namespace CapMachine.Wpf.Dtos
get { return _DbcPath; }
set { _DbcPath = value; RaisePropertyChanged(); }
}
private bool _SchEnable;
/// <summary>
/// 调度表是否启用
/// </summary>
public bool SchEnable
{
get { return _SchEnable; }
set { _SchEnable = value; RaisePropertyChanged(); }
}
}
}

83
CapMachine.Wpf/Dtos/CANFdScheduleConfigDto.cs Normal file
View File

@@ -0,0 +1,83 @@
using CapMachine.Model.CANLIN;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CapMachine.Wpf.Dtos
{
/// <summary>
/// CANFdScheduleConfigDto
/// </summary>
public class CANFdScheduleConfigDto : BindableBase
{
/// <summary>
/// 主键
/// </summary>
public long Id { get; set; }
private string? _MsgName;
/// <summary>
/// 消息名称/帧名称
/// </summary>
public string? MsgName
{
get { return _MsgName; }
set { _MsgName = value; RaisePropertyChanged(); }
}
private int _Cycle;
/// <summary>
/// 周期
/// </summary>
public int Cycle
{
get { return _Cycle; }
set { _Cycle = value; RaisePropertyChanged(); }
}
private int _OrderSend;
/// <summary>
/// 发送方式
/// </summary>
public int OrderSend
{
get { return _OrderSend; }
set { _OrderSend = value; RaisePropertyChanged(); }
}
private int _SchTabIndex;
/// <summary>
/// 调度表的Index序列
/// </summary>
public int SchTabIndex
{
get { return _SchTabIndex; }
set { _SchTabIndex = value; RaisePropertyChanged(); }
}
/// <summary>
/// 在更新调度表数据时,我们有一个整体的帧数据指令集合，但是这些帧数据集合，分属于不同的调度表，
/// 这个在开始时生成整体的帧数据指令集合才会把这个MsgIndex分配上，这个不需要保存到数据库中，对接使用
/// </summary>
public int MsgIndex { get; set; }
/// <summary>
/// 程序的ID
/// </summary>
public long CanLinConfigProId { get; set; }
private CanLinConfigPro _CanLinConfigPro;
/// <summary>
/// 所属的程序
/// </summary>
public CanLinConfigPro CanLinConfigPro
{
get { return _CanLinConfigPro; }
set { _CanLinConfigPro = value; RaisePropertyChanged(); }
}
}
}

14
CapMachine.Wpf/MapperProfile/CANFdScheduleConfigProfile.cs Normal file
View File

@@ -0,0 +1,14 @@
using AutoMapper;
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.Dtos;
namespace CapMachine.Wpf.MapperProfile
{
public class CANFdScheduleConfigProfile : Profile
{
public CANFdScheduleConfigProfile()
{
CreateMap<CANFdScheduleConfig, CANFdScheduleConfigDto>().ReverseMap();
}
}
}

55
CapMachine.Wpf/Services/CanFdDriveService.cs
View File

@@ -1,5 +1,6 @@
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.Dtos;
using CapMachine.Wpf.Models;
using CapMachine.Wpf.Models.ProModelPars;
using ImTools;
@@ -25,9 +26,9 @@ namespace CapMachine.Wpf.Services
/// <summary>
/// 实例化函数
/// </summary>
public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService)
public CanFdDriveService(HighSpeedDataService highSpeedDataService, IContainerProvider containerProvider, LogicRuleService logicRuleService, ILogService logService)
{
ToomossCanFDDrive = new ToomossCanFD(containerProvider);
ToomossCanFDDrive = new ToomossCanFD(containerProvider, logService);
//高速数据服务
HighSpeedDataService = highSpeedDataService;
LogicRuleService = logicRuleService;
@@ -126,6 +127,11 @@ namespace CapMachine.Wpf.Services
/// </summary>
public List<CanCmdData> CmdData { get; set; } = new List<CanCmdData>();
/// <summary>
/// CNA 调度表的配置信息
/// </summary>
public List<CANFdScheduleConfigDto> ListCANFdScheduleConfig { get; set; }
/// <summary>
/// 增加发送的指令数据
/// </summary>
@@ -322,10 +328,39 @@ namespace CapMachine.Wpf.Services
{
if (CmdData.Count > 0)
{
ToomossCanFDDrive.IsCycleSend = true;
//把指令数据赋值给CAN 驱动
ToomossCanFDDrive.CmdData = CmdData;
//ToomossCanFDDrive.StartCycleSendMsg();
ToomossCanFDDrive.StartPrecisionCycleSendMsg();
if (ToomossCanFDDrive.SchEnable)
{
//使用调度表的话，需要在调度表中配置信息后才可以进行操作
var GroupMsg = ToomossCanFDDrive.CmdData.GroupBy(a => a.MsgName).ToList();
foreach (var itemMsg in GroupMsg)
{
if (!ListCANFdScheduleConfig.ToList().Any(a => a.MsgName == itemMsg.Key))
{
System.Windows.MessageBox.Show($"你使能了调度表，但是调度表中没有设置【{itemMsg.Key}】信息，请设置后再操作", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
return;
}
}
if (ListCANFdScheduleConfig == null && ListCANFdScheduleConfig!.Count() == 0)
{
System.Windows.MessageBox.Show("调度表配置为空数据，请检查！将无法发送数据", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
return;
}
ToomossCanFDDrive.ListCANScheduleConfig = ListCANFdScheduleConfig!;
ToomossCanFDDrive.StartSchedule();
//ToomossCanFDDrive.StartCycleUpdateCmd();
}
else
{
ToomossCanFDDrive.StartPrecisionCycleSendMsg();
//ToomossCanFDDrive.StartCycleSendMsg();
}
ToomossCanFDDrive.IsCycleSend = true;
}
else
{
@@ -334,7 +369,15 @@ namespace CapMachine.Wpf.Services
}
else
{
ToomossCanFDDrive.IsCycleSend = false;
if (ToomossCanFDDrive.SchEnable)
{
ToomossCanFDDrive.IsCycleSend = false;
ToomossCanFDDrive.StopSchedule();
}
else
{
ToomossCanFDDrive.IsCycleSend = false;
}
}
}

139
CapMachine.Wpf/ViewModels/CANFDConfigViewModel.cs
View File

@@ -200,7 +200,7 @@ namespace CapMachine.Wpf.ViewModels
canLinConfigPros = FreeSql.Select<CanLinConfigPro>().Where(a => a.CANLINInfo == CANLIN.CANFD)
.Include(a => a.CANFdConfigExd)
.IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))//,then=> then.Include(b=>b.LogicRule)
//.IncludeMany(a => a.CanLinConfigContents)
.IncludeMany(a => a.CanFdScheduleConfigs)//
.ToList();
ListCanLinConfigPro = new ObservableCollection<CanLinConfigPro>(canLinConfigPros);
@@ -245,11 +245,25 @@ namespace CapMachine.Wpf.ViewModels
//});
}
}
else
{
ListWriteCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
}
var ReadData = SelectCanLinConfigPro.CanLinConfigContents!.Where(a => a.RWInfo == RW.Read).ToList();
if (ReadData != null && ReadData.Count > 0)
{
ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>(Mapper.Map<List<CanLinRWConfigDto>>(ReadData));
}
else
{
ListReadCanLinRWConfigDto = new ObservableCollection<CanLinRWConfigDto>();
}
//调度表配置信息
if (SelectCanLinConfigPro.CanFdScheduleConfigs != null && SelectCanLinConfigPro.CanFdScheduleConfigs.Count() > 0)
{
ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>(Mapper.Map<List<CANFdScheduleConfigDto>>(SelectCanLinConfigPro.CanFdScheduleConfigs));
}
//匹配选中的SelectCanLinConfigPro.CanLinConfigContents和ListCanDbcModel
MatchSeletedAndCanDbcModel();
@@ -499,6 +513,8 @@ namespace CapMachine.Wpf.ViewModels
CanFdDriveService.InitCanConfig(SelectCanLinConfigPro);
InitLoadCanConfigPro();
CanFdDriveService.ToomossCanFDDrive.LoadCmdDataToDrive(CanFdDriveService.CmdData);
}
else
{
@@ -616,6 +632,18 @@ namespace CapMachine.Wpf.ViewModels
SelectCanLinConfigProConfigName = SelectCanLinConfigPro.ConfigName;
//调度表配置信息
if (SelectCanLinConfigPro.CanFdScheduleConfigs != null && SelectCanLinConfigPro.CanFdScheduleConfigs.Count() > 0)
{
ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>(Mapper.Map<List<CANFdScheduleConfigDto>>(SelectCanLinConfigPro.CanFdScheduleConfigs));
}
else
{
ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>();
}
return;
}
//先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
@@ -918,6 +946,49 @@ namespace CapMachine.Wpf.ViewModels
set { _ArbBaudRateCbxItems = value; RaisePropertyChanged(); }
}
private DelegateCommand<object> _SchEnableCmd;
/// <summary>
/// 调度表的使能 操作的指令
/// </summary>
public DelegateCommand<object> SchEnableCmd
{
set
{
_SchEnableCmd = value;
}
get
{
if (_SchEnableCmd == null)
{
_SchEnableCmd = new DelegateCommand<object>((Par) => SchEnableCmdCall(Par));
}
return _SchEnableCmd;
}
}
/// <summary>
/// 调度表的使能信息
/// </summary>
/// <param name="par"></param>
/// <exception cref="NotImplementedException"></exception>
private void SchEnableCmdCall(object par)
{
var dd = SelectedCANConfigExdDto.SchEnable;
var Result = (bool)par;
if (Result)
{
CanFdDriveService.ToomossCanFDDrive.SchEnable = true;
}
else
{
CanFdDriveService.ToomossCanFDDrive.SchEnable = false;
}
}
private DelegateCommand<string> _CanOpCmd;
/// <summary>
/// CAN操作的指令
@@ -1009,6 +1080,7 @@ namespace CapMachine.Wpf.ViewModels
.Set(a => a.ArbBaudRate, SelectedCANConfigExdDto.ArbBaudRate)
.Set(a => a.ISOEnable, SelectedCANConfigExdDto.ISOEnable)
.Set(a => a.ResEnable, SelectedCANConfigExdDto.ResEnable)
.Set(a => a.SchEnable, SelectedCANConfigExdDto.SchEnable)
.Where(a => a.Id == SelectedCANConfigExdDto.Id)
.ExecuteUpdated();
}
@@ -1070,6 +1142,12 @@ namespace CapMachine.Wpf.ViewModels
break;
case "CycleSend"://循环发送你
//有可能加载完毕后不手动改变状态，导致值没有传输，所以这里赋值
CanFdDriveService.ToomossCanFDDrive.SchEnable = SelectedCANConfigExdDto.SchEnable;
//无论有没有调度表，都要把这个配置给CanDriveService
CanFdDriveService.ListCANFdScheduleConfig = ListCANFdScheduleConfigDto.ToList();
//循环发送数据
CanFdDriveService.CycleSendMsg();
@@ -1133,6 +1211,26 @@ namespace CapMachine.Wpf.ViewModels
set { _WriteRuleCbxItems = value; RaisePropertyChanged(); }
}
private ObservableCollection<CbxItems> _ReadRuleCbxItems;
/// <summary>
/// 读取的规格集合
/// </summary>
public ObservableCollection<CbxItems> ReadRuleCbxItems
{
get { return _ReadRuleCbxItems; }
set { _ReadRuleCbxItems = value; RaisePropertyChanged(); }
}
private ObservableCollection<CANFdScheduleConfigDto> _ListCANFdScheduleConfigDto;
/// <summary>
///调度表集合
/// </summary>
public ObservableCollection<CANFdScheduleConfigDto> ListCANFdScheduleConfigDto
{
get { return _ListCANFdScheduleConfigDto; }
set { _ListCANFdScheduleConfigDto = value; RaisePropertyChanged(); }
}
//private string _SelectedWriteName;
///// <summary>
///// 选中的写入的Name
@@ -1278,6 +1376,45 @@ namespace CapMachine.Wpf.ViewModels
System.Windows.MessageBox.Show("请选中后再进行【删除】操作？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
break;
case "WriteSch"://调度表
var data = CanFdDriveService.CmdData.GroupBy(a => a.MsgName).Select(a => a.Key).ToList();
if (data != null && data.Count > 0)
{
//弹窗
DialogService.ShowDialog("DialogCANFdSchConfigView", new DialogParameters() {
{"ListMsg", CanFdDriveService.CmdData.GroupBy(a=>a.MsgName).Select(a=>a.Key).ToList() },
{ "ListCANFdScheduleConfigDto",ListCANFdScheduleConfigDto},
{ "SelectCanLinConfigProId",SelectCanLinConfigPro.Id},
}, (par) =>
{
if (par.Result == ButtonResult.OK)
{
////程序名称
ListCANFdScheduleConfigDto = par.Parameters.GetValue<ObservableCollection<CANFdScheduleConfigDto>>("ReturnValue");
//把更新后的最新值给当前的主集合中
SelectCanLinConfigPro.CanFdScheduleConfigs = Mapper.Map<List<CANFdScheduleConfig>>(ListCANFdScheduleConfigDto.ToList());
}
else if (par.Result == ButtonResult.Cancel)
{
//取消
}
});
}
else
{
System.Windows.MessageBox.Show("未发现写入的执行的命令数据，无法配置？", "提示", System.Windows.MessageBoxButton.OK, System.Windows.MessageBoxImage.Hand);
}
break;
default:
break;

377
CapMachine.Wpf/ViewModels/DialogCANFdSchConfigViewModel.cs Normal file
View File

@@ -0,0 +1,377 @@
using AutoMapper;
using CapMachine.Core;
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.Dtos;
using Prism.Commands;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
namespace CapMachine.Wpf.ViewModels
{
/// <summary>
/// CAN Fd 调度表配置
/// </summary>
public class DialogCANFdSchConfigViewModel : DialogViewModel
{
/// <summary>
/// 构造函数
/// </summary>
public DialogCANFdSchConfigViewModel(IFreeSql freeSql, IMapper mapper)
{
Title = "调度表 CAN 配置";
FreeSql = freeSql;
Mapper = mapper;
SendOrderCbxItems = new ObservableCollection<CbxItems>()
{
new CbxItems(){
Key="0",
Text="并行",
},
new CbxItems(){
Key="1",
Text="顺序",
},
};
//默认只能用1号调度器
SchTabIndexCbxItems = new ObservableCollection<CbxItems>()
{
new CbxItems(){
Key="0",
Text="0",
},
//new CbxItems(){
// Key="1",
// Text="1",
//},
//new CbxItems(){
// Key="2",
// Text="2",
//},
//new CbxItems(){
// Key="3",
// Text="3",
//},
//new CbxItems(){
// Key="4",
// Text="4",
//},
};
}
public IFreeSql FreeSql { get; }
public IMapper Mapper { get; }
private string name;
/// <summary>
/// 名称
/// </summary>
public string Name
{
get { return name; }
set { name = value; RaisePropertyChanged(); }
}
private ObservableCollection<CANFdScheduleConfigDto> _ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>();
/// <summary>
/// CAN 调度表数据集合
/// </summary>
public ObservableCollection<CANFdScheduleConfigDto> ListCANFdScheduleConfigDto
{
get { return _ListCANFdScheduleConfigDto; }
set { _ListCANFdScheduleConfigDto = value; RaisePropertyChanged(); }
}
/// <summary>
/// 消息/帧报文信息集合
/// </summary>
public List<string> ListMsg { get; set; }
private ObservableCollection<CbxItems> _MsgCbxItems;
/// <summary>
/// 消息名称 集合信息
/// </summary>
public ObservableCollection<CbxItems> MsgCbxItems
{
get { return _MsgCbxItems; }
set { _MsgCbxItems = value; RaisePropertyChanged(); }
}
/// <summary>
/// 选中的程序的Id
/// </summary>
public long SelectCanLinConfigProId { get; set; }
private ObservableCollection<CbxItems> _SendOrderCbxItems;
/// <summary>
/// 发送方式 集合信息
/// </summary>
public ObservableCollection<CbxItems> SendOrderCbxItems
{
get { return _SendOrderCbxItems; }
set { _SendOrderCbxItems = value; RaisePropertyChanged(); }
}
private string? _CurSendOrder;
/// <summary>
/// 当前发送方式
/// </summary>
public string? CurSendOrder
{
get { return _CurSendOrder; }
set { _CurSendOrder = value; RaisePropertyChanged(); }
}
private ObservableCollection<CbxItems> _SchTabIndexCbxItems;
/// <summary>
/// 调度器序号 集合信息
/// </summary>
public ObservableCollection<CbxItems> SchTabIndexCbxItems
{
get { return _SchTabIndexCbxItems; }
set { _SchTabIndexCbxItems = value; RaisePropertyChanged(); }
}
private CANFdScheduleConfigDto _CurSelectedItem;
/// <summary>
/// 选中的数据
/// </summary>
public CANFdScheduleConfigDto CurSelectedItem
{
get { return _CurSelectedItem; }
set { _CurSelectedItem = value; RaisePropertyChanged(); }
}
private DelegateCommand<object> _GridSelectionChangedCmd;
/// <summary>
/// 选中行数据命令
/// </summary>
public DelegateCommand<object> GridSelectionChangedCmd
{
set
{
_GridSelectionChangedCmd = value;
}
get
{
if (_GridSelectionChangedCmd == null)
{
_GridSelectionChangedCmd = new DelegateCommand<object>((par) => GridSelectionChangedCmdMethod(par));
}
return _GridSelectionChangedCmd;
}
}
private void GridSelectionChangedCmdMethod(object par)
{
//先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
var Selecteddata = par as CANFdScheduleConfigDto;
if (Selecteddata != null)
{
CurSelectedItem = Selecteddata;
}
}
//OpCmd
private DelegateCommand<string> _OpCmd;
/// <summary>
/// 增加方法命令
/// </summary>
public DelegateCommand<string> OpCmd
{
set
{
_OpCmd = value;
}
get
{
if (_OpCmd == null)
{
_OpCmd = new DelegateCommand<string>((Par) => OpCmdCall(Par));
}
return _OpCmd;
}
}
private void OpCmdCall(string Par)
{
switch (Par)
{
case "Add":
ListCANFdScheduleConfigDto.Add(new CANFdScheduleConfigDto
{
CanLinConfigProId = SelectCanLinConfigProId,
Cycle = 100,
SchTabIndex = 0,
OrderSend = 1,
});
break;
case "Delete":
if (CurSelectedItem != null)
{
//直接删除掉，如果没有ID的话，这就不需要删除了
FreeSql.Delete<CANFdScheduleConfig>(CurSelectedItem.Id).ExecuteAffrows();
ListCANFdScheduleConfigDto.Remove(CurSelectedItem);
CurSelectedItem = null;
}
else
{
MessageBox.Show("请选中后再进行【删除】操作？", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
}
break;
default:
break;
}
}
private DelegateCommand saveCmd;
/// <summary>
/// 保存命令
/// </summary>
public DelegateCommand SaveCmd
{
set
{
saveCmd = value;
}
get
{
if (saveCmd == null)
{
saveCmd = new DelegateCommand(() => SaveCmdMethod());
}
return saveCmd;
}
}
/// <summary>
/// 保存命令方法
/// </summary>
/// <exception cref="NotImplementedException"></exception>
private void SaveCmdMethod()
{
//检查空的数据
foreach (var item in ListCANFdScheduleConfigDto)
{
//整个的发送方式赋值给每个子项
item.OrderSend = CurSendOrder == "0" ? 0 : 1;
if (string.IsNullOrEmpty(item.MsgName))
{
MessageBox.Show("请确认消息名称是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
return;
}
if (item.Cycle == 0)
{
MessageBox.Show("请确认周期是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
return;
}
if (item.OrderSend >= 2)
{
MessageBox.Show("请确认发送方式是否正确", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
return;
}
}
//发送的控制帧都放到同一个调度表中，不需要检查了
////检查重复设置问题
//bool isRepeat = ListCANScheduleConfigDto.GroupBy(i => i.MsgName).Any(g => g.Count() > 1);
//if (isRepeat)
//{
// MessageBox.Show("请确认是否重复设置", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
// return;
//}
//检查数据是否正常
foreach (var item in ListCANFdScheduleConfigDto)
{
FreeSql.InsertOrUpdate<CANFdScheduleConfig>()
.SetSource(Mapper.Map<CANFdScheduleConfig>(item)).
ExecuteAffrows();
}
ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>(Mapper.Map<List<CANFdScheduleConfigDto>>(FreeSql.Select<CANFdScheduleConfig>().Where(a => a.CanLinConfigProId == SelectCanLinConfigProId).ToList()));
DialogParameters pars = new DialogParameters
{
{ "ReturnValue", ListCANFdScheduleConfigDto }
};
RaiseRequestClose(new DialogResult(ButtonResult.OK, pars));
}
private DelegateCommand cancelCmd;
/// <summary>
/// 保存命令
/// </summary>
public DelegateCommand CancelCmd
{
set
{
cancelCmd = value;
}
get
{
if (cancelCmd == null)
{
cancelCmd = new DelegateCommand(() => CancelCmdMethod());
}
return cancelCmd;
}
}
/// <summary>
/// 取消命令方法
/// </summary>
/// <exception cref="NotImplementedException"></exception>
private void CancelCmdMethod()
{
RaiseRequestClose(new DialogResult(ButtonResult.Cancel));
}
/// <summary>
/// 窗口打开时的传递的参数
/// </summary>
/// <param name="parameters"></param>
public override void OnDialogOpened(IDialogParameters parameters)
{
ListMsg = parameters.GetValue<List<string>>("ListMsg");
// 转换为CbxItems集合，都是文本内容
MsgCbxItems = new ObservableCollection<CbxItems>(
ListMsg.Select(value => new CbxItems
{
Key = value,
Text = value
}));
ListCANFdScheduleConfigDto = parameters.GetValue<ObservableCollection<CANFdScheduleConfigDto>>("ListCANFdScheduleConfigDto");
//防止返回的数据为空，就无法增加了
if (ListCANFdScheduleConfigDto == null) ListCANFdScheduleConfigDto = new ObservableCollection<CANFdScheduleConfigDto>();
//Name = parameters.GetValue<string>("Name");
if (ListCANFdScheduleConfigDto.Count > 0)
{
CurSendOrder = ListCANFdScheduleConfigDto.FirstOrDefault()!.OrderSend.ToString();
}
SelectCanLinConfigProId = parameters.GetValue<long>("SelectCanLinConfigProId");
}
}
}

345
CapMachine.Wpf/ViewModels/HistoryDataViewModel.cs
View File

@@ -15,8 +15,8 @@ using Prism.Events;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
@@ -51,7 +51,7 @@ namespace CapMachine.Wpf.ViewModels
/// <param name="eventAggregator"></param>
/// <param name="mapper"></param>
/// <param name="logger"></param>
public HistoryDataViewModel(IDialogService dialogService, IFreeSql freeSql, IEventAggregator eventAggregator, IMapper mapper,ConfigService configService)
public HistoryDataViewModel(IDialogService dialogService, IFreeSql freeSql, IEventAggregator eventAggregator, IMapper mapper, ConfigService configService)
{
DialogService = dialogService;
FreeSql = freeSql;
@@ -132,6 +132,20 @@ namespace CapMachine.Wpf.ViewModels
set { _IsLeftDrawerOpen = value; RaisePropertyChanged(); }
}
private bool _IsBusy;
public bool IsBusy
{
get { return _IsBusy; }
set { _IsBusy = value; RaisePropertyChanged(); }
}
private string _BusyMessage = "正在加载，请稍候...";
public string BusyMessage
{
get { return _BusyMessage; }
set { _BusyMessage = value; RaisePropertyChanged(); }
}
/// <summary>
@@ -224,15 +238,7 @@ namespace CapMachine.Wpf.ViewModels
set { _SelectedHistoryExp = value; RaisePropertyChanged(); }
}
private HistoryWorkCondFile _SelectedHistoryWorkCondFile;
/// <summary>
/// 选中的历史数据文件
/// </summary>
public HistoryWorkCondFile SelectedHistoryWorkCondFile
{
get { return _SelectedHistoryWorkCondFile; }
set { _SelectedHistoryWorkCondFile = value; RaisePropertyChanged(); }
}
/// <summary>
/// 当前搜索的工况条件
@@ -268,7 +274,13 @@ namespace CapMachine.Wpf.ViewModels
if (par is HistoryExp)
{
SelectedHistoryExp = par as HistoryExp;
ListHistoryWorkCondFile = SelectedHistoryExp!.HistoryWorkCondFiles!;
var files = SelectedHistoryExp!.HistoryWorkCondFiles!;
foreach (var f in files)
{
if (f != null) f.IsSelected = false;
}
ListHistoryWorkCondFile = files.ToList();
//ListHistoryWorkCondFile = ListHistoryWorkCondFile.ToList();
return;
}
if ((par as SelectionChangedEventArgs)!.AddedItems.Count == 0)
@@ -290,63 +302,18 @@ namespace CapMachine.Wpf.ViewModels
if (Selecteddata != null)
{
SelectedHistoryExp = Selecteddata;
ListHistoryWorkCondFile = SelectedHistoryExp.HistoryWorkCondFiles!;
}
}
private DelegateCommand<object> _FileGridSelectionChangedCmd;
/// <summary>
/// 试验信息选中行数据命令
/// </summary>
public DelegateCommand<object> FileGridSelectionChangedCmd
{
set
{
_FileGridSelectionChangedCmd = value;
}
get
{
if (_FileGridSelectionChangedCmd == null)
var files = SelectedHistoryExp.HistoryWorkCondFiles!;
foreach (var f in files)
{
_FileGridSelectionChangedCmd = new DelegateCommand<object>((par) => FileGridSelectionChangedCmdMethod(par));
if (f != null) f.IsSelected = false;
}
return _FileGridSelectionChangedCmd;
ListHistoryWorkCondFile = files;
ListHistoryWorkCondFile = ListHistoryWorkCondFile.ToList();
}
}
private void FileGridSelectionChangedCmdMethod(object par)
{
if (par == null)
{
return;
}
if (par is HistoryWorkCondFile)
{
SelectedHistoryWorkCondFile = par as HistoryWorkCondFile;
return;
}
if ((par as SelectionChangedEventArgs)!.AddedItems.Count == 0)
{
return;
}
//先判断是否是正确的集合数据，防止DataGrid的数据源刷新导致的触发事件
var Selecteddata = (par as SelectionChangedEventArgs)!.AddedItems[0] as HistoryWorkCondFile;
////选中的行数据
//var Selecteddata = (par as DataGrid)!.SelectedItem as HistoryExp;
////选中的列数据
//var selectedColumn = (par as DataGrid)!.CurrentColumn;
//SelectedIndex= ProParsHelper.GetIndexByName(selectedColumn);
//SelectedProStepDto = par as ProStepDto;
if (Selecteddata != null)
{
SelectedHistoryWorkCondFile = Selecteddata;
}
}
private DelegateCommand _FilterHistoryDataFileCmd;
/// <summary>
@@ -397,6 +364,48 @@ namespace CapMachine.Wpf.ViewModels
HasHeaderRecord = false,
};
private DelegateCommand<object> _SelectAllFilesCmd;
public DelegateCommand<object> SelectAllFilesCmd
{
set
{
_SelectAllFilesCmd = value;
}
get
{
if (_SelectAllFilesCmd == null)
{
_SelectAllFilesCmd = new DelegateCommand<object>((par) => SelectAllFilesCmdMethod(par));
}
return _SelectAllFilesCmd;
}
}
private void SelectAllFilesCmdMethod(object par)
{
bool isChecked = false;
if (par is bool b) { isChecked = b; }
else
{
var nb = par as bool?;
if (nb.HasValue) isChecked = nb.Value;
else
{
var sb = par as string;
if (!string.IsNullOrWhiteSpace(sb))
{
bool.TryParse(sb, out isChecked);
}
}
}
if (ListHistoryWorkCondFile == null) return;
foreach (var f in ListHistoryWorkCondFile)
{
if (f != null) f.IsSelected = isChecked;
}
// 触发刷新
ListHistoryWorkCondFile = ListHistoryWorkCondFile.ToList();
}
Stopwatch stopwatch = new Stopwatch();
private DelegateCommand _HistoryDataFileCmd;
@@ -422,118 +431,134 @@ namespace CapMachine.Wpf.ViewModels
/// <summary>
/// 获取试验数据的命令的执行方法
/// </summary>
private void HistoryDataFileCmdMethod()
private async void HistoryDataFileCmdMethod()
{
//SelectedHistoryWorkCondFile
if (SelectedHistoryExp != null && SelectedHistoryWorkCondFile != null)
{
CsvRecordModels = new List<CsvRecordModel>();
////第一次计时
stopwatch.Start(); //启动Stopwatch
if (!string.IsNullOrEmpty(SelectedHistoryWorkCondFile.FilePath))
{
if (File.Exists(SelectedHistoryWorkCondFile.FilePath))//是否存在文件
{
lock (ConfigService.CsvFileLock)
{
using (var reader = new StreamReader(SelectedHistoryWorkCondFile.FilePath))
using (var csv = new CsvReader(reader, CultureInfo.CurrentCulture))
{
csv.Context.RegisterClassMap<CsvRecordModelMap>();
//GetRecords<CsvRecordModel>().ToList();
CsvRecordModels.AddRange(csv.GetRecords<CsvRecordModel>().ToList());
}
}
}
else
{
System.Windows.MessageBox.Show("没有发现地址对应的文件");
}
}
else
{
System.Windows.MessageBox.Show("发现空的文件地址");
}
//数据加载完毕后进入到Chart曲线中
if (CsvRecordModels.Count > 0)
{
EventAggregator.GetEvent<HistoryDataToChartEvent>().Publish(new HistoryDataToChartMsg() { Machine = "History", Data = CsvRecordModels });
}
stopwatch.Stop(); //停止Stopwatch
Console.WriteLine("加载CSV数据耗时：:{0}", stopwatch.Elapsed.TotalSeconds.ToString());
stopwatch.Reset();
IsLeftDrawerOpen = false;
}
else
if (SelectedHistoryExp == null)
{
System.Windows.MessageBox.Show("请选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
return;
}
var files = new List<HistoryWorkCondFile>();
if (ListHistoryWorkCondFile != null)
{
foreach (var f in ListHistoryWorkCondFile)
{
if (f != null && f.IsSelected)
{
files.Add(f);
}
}
}
#region 整个工况
//整个试验工况一起加载数据
//if (SelectedHistoryExp != null && SelectedHistoryExp.HistoryWorkCondFiles != null)
//{
// CsvRecordModels = new List<CsvRecordModel>();
files = files
.Where(f => f != null)
.GroupBy(f => string.IsNullOrWhiteSpace(f.FilePath) ? $"ID:{f.Id}" : f.FilePath)
.Select(g => g.First())
.ToList();
// ////第一次计时
// stopwatch.Start(); //启动Stopwatch
if (files.Count == 0)
{
System.Windows.MessageBox.Show("请先在右侧勾选至少一个CSV文件", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
return;
}
// foreach (var item in SelectedHistoryExp.HistoryWorkCondFiles)
// {
// if (!string.IsNullOrEmpty(item.FilePath))
// {
// if (File.Exists(item.FilePath))//是否存在文件
// {
// lock (ConfigService.CsvFileLock)
// {
// using (var reader = new StreamReader(item.FilePath))
// using (var csv = new CsvReader(reader, CultureInfo.CurrentCulture))
// {
// csv.Context.RegisterClassMap<CsvRecordModelMap>();
// //GetRecords<CsvRecordModel>().ToList();
BusyMessage = "正在加载CSV数据，请稍候...";
IsBusy = true;
// CsvRecordModels.AddRange(csv.GetRecords<CsvRecordModel>().ToList());
// }
// }
var loaded = new List<CsvRecordModel>();
string errorText = string.Empty;
// }
// else
// {
// System.Windows.MessageBox.Show("没有发现地址对应的文件");
// }
// }
// else
// {
// System.Windows.MessageBox.Show("发现空的文件地址");
// }
// }
stopwatch.Start();
// //数据加载完毕后进入到Chart曲线中
// if (CsvRecordModels.Count > 0)
// {
// EventAggregator.GetEvent<HistoryDataToChartEvent>().Publish(new HistoryDataToChartMsg() { Machine = "History", Data = CsvRecordModels });
// }
try
{
await Task.Run(() =>
{
var errors = new StringBuilder();
for (int i = 0; i < files.Count; i++)
{
var f = files[i];
try
{
Application.Current.Dispatcher.Invoke(() =>
{
BusyMessage = $"正在加载({i + 1}/{files.Count})：{System.IO.Path.GetFileName(f?.FilePath)}";
});
// stopwatch.Stop(); //停止Stopwatch
// Console.WriteLine("加载CSV数据耗时：:{0}", stopwatch.Elapsed.TotalSeconds.ToString());
// stopwatch.Reset();
if (f == null) continue;
if (string.IsNullOrWhiteSpace(f.FilePath))
{
errors.AppendLine("发现空的文件地址");
continue;
}
if (!File.Exists(f.FilePath))
{
errors.AppendLine($"没有发现地址对应的文件: {f.FilePath}");
continue;
}
// IsLeftDrawerOpen = false;
//}
//else
//{
// System.Windows.MessageBox.Show("请选中后再操作", "提示", MessageBoxButton.OK, MessageBoxImage.Hand);
//}
var rec = ReadCsvFile(f.FilePath);
if (rec != null && rec.Count > 0)
{
loaded.AddRange(rec);
}
}
catch (Exception ex)
{
errors.AppendLine($"读取CSV失败: {ex.Message}");
}
}
errorText = errors.ToString();
});
#endregion
if (!string.IsNullOrWhiteSpace(errorText))
{
System.Windows.MessageBox.Show(errorText, "读取提示", MessageBoxButton.OK, MessageBoxImage.Warning);
}
CsvRecordModels = new List<CsvRecordModel>();
if (loaded != null && loaded.Count > 0)
{
CsvRecordModels = loaded
.Where(r => r != null)
.OrderBy(r => r.CreateTime)
.ToList();
Application.Current.Dispatcher.Invoke(() =>
{
EventAggregator.GetEvent<HistoryDataToChartEvent>().Publish(new HistoryDataToChartMsg() { Machine = "History", Data = CsvRecordModels });
});
}
}
finally
{
stopwatch.Stop();
Console.WriteLine("加载CSV数据耗时：:{0}", stopwatch.Elapsed.TotalSeconds.ToString());
stopwatch.Reset();
IsBusy = false;
IsLeftDrawerOpen = false;
}
}
private List<CsvRecordModel> ReadCsvFile(string filePath)
{
var result = new List<CsvRecordModel>();
lock (ConfigService.CsvFileLock)
{
using (var reader = new StreamReader(filePath, Encoding.UTF8))
using (var csv = new CsvReader(reader, CultureInfo.CurrentCulture))
{
csv.Context.RegisterClassMap<CsvRecordModelMap>();
var list = csv.GetRecords<CsvRecordModel>().ToList();
if (list != null && list.Count > 0)
{
// 过滤无效时间，避免排序异常
result = list.Where(r => r != null && r.CreateTime != default && r.CreateTime != DateTime.MinValue).ToList();
}
}
}
return result;
}
@@ -1075,7 +1100,7 @@ namespace CapMachine.Wpf.ViewModels
SeletedGroup6ListViewTabIndex = 0;
SeletedGroup7ListViewTabIndex = 0;
SeletedGroup8ListViewTabIndex = 0;
}
else
{

99
CapMachine.Wpf/Views/CANFDConfigView.xaml
View File

@@ -636,6 +636,87 @@
</StackPanel>
<StackPanel
Grid.Row="1"
Grid.Column="1"
Margin="-15,0"
Orientation="Horizontal">
<TextBlock
Margin="0,0,0,0"
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="20"
Text="&#xe977;" />
<TextBlock
Width="80"
Style="{StaticResource TextBlockStyle}"
Text="报文状态：" />
<Border
Margin="0,12"
BorderThickness="1"
CornerRadius="5">
<Border.Style>
<Style TargetType="Border">
<Setter Property="Background" Value="Gray" />
<Style.Triggers>
<DataTrigger Binding="{Binding CanFdDriveService.ToomossCanFDDrive.IsSendOk}" Value="true">
<Setter Property="Background" Value="LimeGreen" />
</DataTrigger>
</Style.Triggers>
</Style>
</Border.Style>
<TextBlock
Margin="5"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Foreground="White"
Text="发送" />
</Border>
<Border
Margin="2,12"
BorderThickness="1"
CornerRadius="5">
<Border.Style>
<Style TargetType="Border">
<Setter Property="Background" Value="Gray" />
<Style.Triggers>
<DataTrigger Binding="{Binding CanFdDriveService.ToomossCanFDDrive.IsReviceOk}" Value="true">
<Setter Property="Background" Value="LimeGreen" />
</DataTrigger>
</Style.Triggers>
</Style>
</Border.Style>
<TextBlock
Margin="5"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Foreground="White"
Text="接收" />
</Border>
<TextBlock
Margin="2,0,0,0"
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="20"
Text="&#xe796;" />
<TextBlock
Width="90"
Style="{StaticResource TextBlockStyle}"
Text="启用调度表:" />
<ToggleButton
Width="40"
Margin="2,2"
Command="{Binding SchEnableCmd}"
CommandParameter="{Binding SelectedCANConfigExdDto.SchEnable}"
IsChecked="{Binding SelectedCANConfigExdDto.SchEnable}"
Style="{StaticResource MaterialDesignSwitchToggleButton}"
ToolTip="启用调度表" />
</StackPanel>
</Grid>
</Grid>
@@ -694,6 +775,24 @@
Margin="0,0,15,0"
HorizontalAlignment="Right"
Orientation="Horizontal">
<Button
Margin="5,0"
Command="{Binding WriteCmd}"
CommandParameter="WriteSch"
Foreground="White">
<StackPanel Orientation="Horizontal">
<TextBlock
Margin="2,0"
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="18"
Text="&#xe796;" />
<TextBlock
VerticalAlignment="Center"
FontSize="14"
Text="调度表" />
</StackPanel>
</Button>
<Button
Margin="5,0"
Command="{Binding WriteCmd}"

206
CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml Normal file
View File

@@ -0,0 +1,206 @@
<UserControl
x:Class="CapMachine.Wpf.Views.DialogCANFdSchConfigView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:i="http://schemas.microsoft.com/xaml/behaviors"
xmlns:local="clr-namespace:CapMachine.Wpf.Views"
xmlns:localEx="clr-namespace:CapMachine.Wpf"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:prism="http://prismlibrary.com/"
Width="1000"
Height="800"
mc:Ignorable="d">
<UserControl.Resources>
<localEx:BindingProxy x:Key="Proxy" Data="{Binding}" />
<Style x:Key="myHeaderStyle" TargetType="{x:Type GridViewColumnHeader}">
<Setter Property="FontSize" Value="24" />
<Setter Property="Width" Value="218" />
</Style>
<Style x:Key="myHeaderStyle1" TargetType="{x:Type GridViewColumnHeader}">
<Setter Property="FontSize" Value="16" />
<Setter Property="Background" Value="Transparent" />
<Setter Property="BorderThickness" Value="0" />
<Setter Property="BorderBrush" Value="Transparent" />
</Style>
</UserControl.Resources>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="60" />
<RowDefinition />
<RowDefinition Height="auto" />
</Grid.RowDefinitions>
<StackPanel HorizontalAlignment="Left" Orientation="Horizontal">
<Button
Margin="10,0"
Command="{Binding OpCmd}"
CommandParameter="Add"
FontWeight="Bold"
Foreground="#404040"
Style="{StaticResource MaterialDesignFlatAccentBgButton}">
<StackPanel Orientation="Horizontal">
<TextBlock
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="14"
Foreground="#404040"
Text="&#xe8c0; " />
<TextBlock
VerticalAlignment="Center"
FontSize="14"
Text="新增" />
</StackPanel>
</Button>
<!--<Button
Margin="10,0"
Command="{Binding CopyCmd}"
FontWeight="Bold"
Foreground="#404040"
Style="{StaticResource MaterialDesignFlatAccentBgButton}">
<StackPanel Orientation="Horizontal">
<TextBlock
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="14"
Foreground="#404040"
Text="&#xe9c6;" />
<TextBlock
VerticalAlignment="Center"
FontSize="14"
Text="复制" />
</StackPanel>
</Button>-->
<Button
Margin="10,0"
Command="{Binding OpCmd}"
CommandParameter="Delete"
FontWeight="Bold"
Foreground="#404040"
Style="{StaticResource MaterialDesignFlatAccentBgButton}">
<StackPanel Orientation="Horizontal">
<TextBlock
Margin="0,0,5,0"
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="14"
Foreground="#404040"
Text="&#xe9d9;" />
<TextBlock
VerticalAlignment="Center"
FontSize="14"
Text="删除" />
</StackPanel>
</Button>
</StackPanel>
<StackPanel
Margin="30,0"
HorizontalAlignment="Right"
Orientation="Horizontal">
<TextBlock
Margin="10,0,5,0"
VerticalAlignment="Center"
FontFamily="/Assets/Fonts/#iconfont"
FontSize="22"
Text="&#xe9ff;" />
<TextBlock
HorizontalAlignment="Center"
VerticalAlignment="Center"
FontSize="20"
Text="报文发送方式："
TextAlignment="Center" />
<ComboBox
Width="120"
DisplayMemberPath="Text"
FontSize="20"
ItemsSource="{Binding SendOrderCbxItems}"
SelectedValue="{Binding CurSendOrder, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
SelectedValuePath="Key" />
</StackPanel>
<Grid Grid.Row="1">
<DataGrid
x:Name="MainDatagrid"
Margin="5"
AutoGenerateColumns="False"
CanUserAddRows="False"
HeadersVisibility="Column"
ItemsSource="{Binding ListCANFdScheduleConfigDto}"
SelectionMode="Extended"
SelectionUnit="FullRow">
<DataGrid.Columns>
<!--<DataGridTextColumn
Binding="{Binding Index}"
Header="序号"
IsReadOnly="True" />-->
<DataGridTemplateColumn Width="260" Header="消息名">
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<ComboBox
DisplayMemberPath="Text"
ItemsSource="{Binding Source={StaticResource Proxy}, Path=Data.MsgCbxItems}"
SelectedValue="{Binding MsgName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
SelectedValuePath="Key" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>
<DataGridTextColumn
Width="100"
Binding="{Binding Cycle}"
Header="周期" />
<!--<DataGridTemplateColumn Width="200" Header="发送方式">
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<ComboBox
DisplayMemberPath="Text"
ItemsSource="{Binding Source={StaticResource Proxy}, Path=Data.SendOrderCbxItems}"
SelectedValue="{Binding OrderSend, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
SelectedValuePath="Key" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>-->
<DataGridTemplateColumn Width="160" Header="调度器序号">
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<ComboBox
DisplayMemberPath="Text"
ItemsSource="{Binding Source={StaticResource Proxy}, Path=Data.SchTabIndexCbxItems}"
SelectedValue="{Binding SchTabIndex, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
SelectedValuePath="Key" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
</DataGridTemplateColumn>
<!--<DataGridCheckBoxColumn Binding="{Binding IsEnable}" Header="是否启用" />-->
</DataGrid.Columns>
<i:Interaction.Triggers>
<i:EventTrigger EventName="SelectionChanged">
<prism:InvokeCommandAction Command="{Binding GridSelectionChangedCmd}" CommandParameter="{Binding ElementName=MainDatagrid, Path=SelectedItem}" />
</i:EventTrigger>
</i:Interaction.Triggers>
</DataGrid>
</Grid>
<StackPanel
Grid.Row="2"
HorizontalAlignment="Right"
Orientation="Horizontal">
<Button
Margin="10,10"
Command="{Binding SaveCmd}"
Content="确定"
Foreground="White" />
<Button
Margin="10,0"
Command="{Binding CancelCmd}"
Content="取消"
Foreground="White" />
</StackPanel>
</Grid>
</UserControl>

28
CapMachine.Wpf/Views/DialogCANFdSchConfigView.xaml.cs Normal file
View File

@@ -0,0 +1,28 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
namespace CapMachine.Wpf.Views
{
/// <summary>
/// DialogCANFdSchConfigView.xaml 的交互逻辑
/// </summary>
public partial class DialogCANFdSchConfigView : UserControl
{
public DialogCANFdSchConfigView()
{
InitializeComponent();
}
}
}

82
CapMachine.Wpf/Views/HistoryDataView.xaml
View File

@@ -26,6 +26,7 @@
<Setter Property="BorderThickness" Value="0" />
<Setter Property="BorderBrush" Value="Transparent" />
</Style>
<BooleanToVisibilityConverter x:Key="BoolToVisibilityConverter" />
</UserControl.Resources>
<materialDesign:DrawerHost
x:Name="HistoryDrawerHost"
@@ -265,28 +266,95 @@
AutoGenerateColumns="False"
BorderBrush="Black"
BorderThickness="1"
CanUserAddRows="False"
FontWeight="Bold"
IsReadOnly="True"
ItemsSource="{Binding ListHistoryWorkCondFile}"
SelectionMode="Extended"
SelectionMode="Single"
SelectionUnit="FullRow">
<DataGrid.Columns>
<DataGridTextColumn MinWidth="300" Binding="{Binding WorkDay}">
<DataGridTemplateColumn Width="80">
<DataGridTemplateColumn.Header>
<CheckBox
x:Name="HeaderSelectAll"
Content="全选"
DataContext="{Binding DataContext, ElementName=DetailDatagrid}">
<i:Interaction.Triggers>
<i:EventTrigger EventName="Checked">
<prism:InvokeCommandAction Command="{Binding SelectAllFilesCmd}" CommandParameter="True" />
</i:EventTrigger>
<i:EventTrigger EventName="Unchecked">
<prism:InvokeCommandAction Command="{Binding SelectAllFilesCmd}" CommandParameter="False" />
</i:EventTrigger>
</i:Interaction.Triggers>
</CheckBox>
</DataGridTemplateColumn.Header>
<DataGridTemplateColumn.CellTemplate>
<DataTemplate>
<CheckBox
HorizontalAlignment="Center"
VerticalAlignment="Center"
Focusable="False"
IsChecked="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
IsThreeState="False" />
</DataTemplate>
</DataGridTemplateColumn.CellTemplate>
<DataGridTemplateColumn.CellEditingTemplate>
<DataTemplate>
<CheckBox
HorizontalAlignment="Center"
VerticalAlignment="Center"
Focusable="False"
IsChecked="{Binding IsSelected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
IsThreeState="False" />
</DataTemplate>
</DataGridTemplateColumn.CellEditingTemplate>
</DataGridTemplateColumn>
<DataGridTextColumn
MinWidth="200"
Binding="{Binding WorkDay}"
IsReadOnly="True">
<DataGridTextColumn.Header>
<TextBlock FontWeight="Bold" Text="文件名称/日期" />
</DataGridTextColumn.Header>
</DataGridTextColumn>
</DataGrid.Columns>
<!-- CommandParameter="{Binding ElementName=MainDatagrid, Path=SelectedItem}" -->
<i:Interaction.Triggers>
<i:EventTrigger EventName="SelectionChanged">
<prism:InvokeCommandAction Command="{Binding FileGridSelectionChangedCmd}" CommandParameter="{Binding ElementName=DetailDatagrid, Path=SelectedItem}" />
</i:EventTrigger>
</i:Interaction.Triggers>
</DataGrid>
<!-- 忙碌遮罩 -->
<Grid
x:Name="BusyOverlay"
Grid.Row="1"
Panel.ZIndex="999"
Background="#66000000"
Visibility="{Binding IsBusy, Converter={StaticResource BoolToVisibilityConverter}}">
<Border
Padding="16"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Background="White"
CornerRadius="6">
<StackPanel>
<ProgressBar
Width="220"
Height="6"
IsIndeterminate="True" />
<TextBlock
Margin="0,10,0,0"
HorizontalAlignment="Center"
FontSize="14"
Foreground="Black"
Text="{Binding BusyMessage}" />
</StackPanel>
</Border>
</Grid>
</Grid>
</Grid>
</Grid>