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

周立功开发过程1

Browse Source
This commit is contained in:
Tyrone CT
2026-02-02 21:22:01 +08:00
parent 4d16b474c6
commit 2e8ad1cffa
42 changed files with 11571 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CapMachine.Wpf/Services/NavigationMenuService.cs
View File

@@ -79,6 +79,8 @@ namespace CapMachine.Wpf.Services
MenuItems.Add(new NavigationItem("", "CAN配置", "CANConfigView"));
MenuItems.Add(new NavigationItem("", "CANFD配置", "CANFDConfigView"));
MenuItems.Add(new NavigationItem("", "LIN配置", "LINConfigView"));
MenuItems.Add(new NavigationItem("", "ZLG CAN配置", "ZlgCanDriveConfigView"));
MenuItems.Add(new NavigationItem("", "ZLG LIN配置", "ZlgLinDriveConfigView"));
MenuItems.Add(new NavigationItem("", "工艺参数", "ProConfigView"));
MenuItems.Add(new NavigationItem("", "工艺曲线", "RealTimeChartView"));
MenuItems.Add(new NavigationItem("", "动作日志", "ActionLogView"));

320
CapMachine.Wpf/Services/ZlgCanDriveService.cs Normal file
View File

@@ -0,0 +1,320 @@
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.CanDrive;
using CapMachine.Wpf.CanDrive.ZlgCan;
using ImTools;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
namespace CapMachine.Wpf.Services
{
/// <summary>
/// ZLG CAN/CANFD 驱动服务（共享设备句柄）。
/// </summary>
public sealed class ZlgCanDriveService : BindableBase
{
private readonly ILogService _log;
/// <summary>
/// 共享的 ZLG 驱动实例（CAN/CANFD/LIN）。
/// </summary>
public ZlgCanFd200uDriver Driver { get; }
/// <summary>
/// 当前选中的配置程序（沿用原有 FreeSql 模型）。
/// </summary>
public CanLinConfigPro? SelectedCanLinConfigPro { get; set; }
/// <summary>
/// Dbc 消息集合（用于 UI 绑定）。
/// </summary>
public ObservableCollection<CanDbcModel> ListCanDbcModel { get; private set; } = new ObservableCollection<CanDbcModel>();
private bool _dbcParserState;
/// <summary>
/// DBC 解析状态。
/// </summary>
public bool DbcParserState
{
get { return _dbcParserState; }
private set { _dbcParserState = value; RaisePropertyChanged(); }
}
private bool _openState;
/// <summary>
/// 设备打开状态。
/// </summary>
public bool OpenState
{
get { return _openState; }
private set { _openState = value; RaisePropertyChanged(); }
}
private ZlgCanMode _mode;
/// <summary>
/// CAN 模式（单选：CAN 或 CANFD）。
/// </summary>
public ZlgCanMode Mode
{
get { return _mode; }
set { _mode = value; RaisePropertyChanged(); }
}
/// <summary>
/// 发送使能（与 UI 的调度表使能语义对齐）。
/// </summary>
public bool SchEnable
{
get { return Driver.SchEnable; }
set { Driver.SchEnable = value; RaisePropertyChanged(); }
}
/// <summary>
/// 是否启用事件驱动发送。
/// </summary>
public bool IsCycleSend
{
get { return Driver.IsCycleSend; }
set { Driver.IsCycleSend = value; RaisePropertyChanged(); }
}
/// <summary>
/// 是否正在循环接收（对齐 Toomoss：IsCycleRevice）。
/// </summary>
public bool IsCycleRevice
{
get { return Driver.IsReceiving; }
}
/// <summary>
/// 最近是否发送成功（用于 UI 指示）。
/// </summary>
public bool IsSendOk
{
get { return Driver.IsSendOk; }
}
/// <summary>
/// 最近是否接收成功（用于 UI 指示）。
/// </summary>
public bool IsReviceOk
{
get { return Driver.IsReviceOk; }
}
/// <summary>
/// 要发送的 CAN 指令数据。
/// </summary>
public List<CanCmdData> CmdData { get; } = new List<CanCmdData>();
private CanCmdData? SpeedCanCmdData { get; set; }
private uint _deviceIndex = 0;
private ZlgCanFdChannelOptions _channel0 = new ZlgCanFdChannelOptions();
/// <summary>
/// 构造。
/// </summary>
/// <param name="logService">日志服务。</param>
public ZlgCanDriveService(ILogService logService)
{
_log = logService;
Driver = new ZlgCanFd200uDriver(logService);
Driver.PropertyChanged += (_, __) =>
{
OpenState = Driver.OpenState;
RaisePropertyChanged(nameof(IsCycleRevice));
RaisePropertyChanged(nameof(IsSendOk));
RaisePropertyChanged(nameof(IsReviceOk));
};
OpenState = Driver.OpenState;
Mode = ZlgCanMode.Can;
}
/// <summary>
/// 初始化 CAN 配置信息，并将配置中的名称映射到 DBC 信号集合（用于 UI 显示）。
/// </summary>
/// <param name="selectedCanLinConfigPro">选中的配置。</param>
public void InitCanConfig(CanLinConfigPro selectedCanLinConfigPro)
{
SelectedCanLinConfigPro = selectedCanLinConfigPro;
if (SelectedCanLinConfigPro?.CanLinConfigContents == null) return;
foreach (var item in SelectedCanLinConfigPro.CanLinConfigContents)
{
var find = ListCanDbcModel.FindFirst(a => a.SignalName == item.SignalName);
if (find != null)
{
find.Name = item.Name;
}
}
}
/// <summary>
/// 更新配置（从 DTO/DB 同步到驱动）。
/// </summary>
/// <param name="deviceIndex">设备索引。</param>
/// <param name="arbBaudRate">仲裁波特率（bps）。</param>
/// <param name="dataBaudRate">数据波特率（bps）。</param>
/// <param name="resEnable">终端电阻使能。</param>
/// <param name="mergeReceive">是否合并接收。</param>
/// <param name="mergeReceiveBufferFrames">合并接收缓冲帧数。</param>
public void UpdateConfig(uint deviceIndex, uint arbBaudRate, uint dataBaudRate, bool resEnable, bool mergeReceive = false, int mergeReceiveBufferFrames = 100)
{
_deviceIndex = deviceIndex;
_channel0.ArbitrationBaudRate = arbBaudRate;
_channel0.DataBaudRate = dataBaudRate;
_channel0.EnableInternalResistance = resEnable;
_channel0.EnableMergeReceive = mergeReceive;
_channel0.MergeReceiveBufferFrames = mergeReceiveBufferFrames;
}
/// <summary>
/// 打开 CAN/CANFD（按 Mode）。
/// </summary>
public void StartCanDrive()
{
if (OpenState)
{
return;
}
Driver.OpenAndInitCan(_deviceIndex, _channel0);
Driver.StartReceiveLoop(_channel0.EnableMergeReceive, _channel0.MergeReceiveBufferFrames);
OpenState = Driver.OpenState;
}
/// <summary>
/// 使能/停止循环接收。
/// </summary>
/// <param name="enable">true=启动接收线程，false=停止接收线程。</param>
public void SetReceiveEnabled(bool enable)
{
if (!OpenState)
{
throw new InvalidOperationException("设备未连接，无法切换循环接收。");
}
if (enable)
{
if (!Driver.IsReceiving)
{
Driver.StartReceiveLoop(_channel0.EnableMergeReceive, _channel0.MergeReceiveBufferFrames);
}
}
else
{
if (Driver.IsReceiving)
{
Driver.StopReceiveLoop();
}
}
RaisePropertyChanged(nameof(IsCycleRevice));
}
/// <summary>
/// 关闭设备（会同时关闭共享的 LIN 通道）。
/// </summary>
public void CloseDevice()
{
try
{
Driver.Close();
}
finally
{
OpenState = Driver.OpenState;
DbcParserState = false;
}
}
/// <summary>
/// 加载 DBC。
/// </summary>
/// <param name="path">DBC 路径。</param>
public ObservableCollection<CanDbcModel> StartDbc(string path)
{
if (!OpenState)
{
throw new InvalidOperationException("请先打开设备后再加载 DBC。");
}
ListCanDbcModel = Driver.StartDbc(path);
DbcParserState = ListCanDbcModel != null && ListCanDbcModel.Count > 0;
return ListCanDbcModel;
}
/// <summary>
/// 加载要发送的数据（订阅数据变化事件）。
/// </summary>
/// <param name="cmdData">指令数据集合。</param>
public void LoadCmdDataToDrive(List<CanCmdData> cmdData)
{
var list = cmdData ?? new List<CanCmdData>();
CmdData.Clear();
CmdData.AddRange(list);
foreach (var item in CmdData)
{
if (string.Equals(item.ConfigName, "转速", StringComparison.Ordinal))
{
SpeedCanCmdData = item;
}
}
Driver.LoadCmdDataToDrive(CmdData, channelIndex: 0, frameType: Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD);
}
/// <summary>
/// 手动发送（目前对齐原服务：仅发送转速）。
/// </summary>
/// <param name="speedData">转速。</param>
public void SendMsgToCanDrive(double speedData)
{
if (!OpenState)
{
return;
}
if (SpeedCanCmdData != null)
{
SpeedCanCmdData.SignalCmdValue = speedData;
}
else
{
_log.Warn("未配置转速指令项（ConfigName=转速），忽略手动发送。");
}
// 若未启用事件驱动发送，则这里主动发送一次（与旧行为兼容）
if (!IsCycleSend || !SchEnable)
{
var firstMsg = CmdData.FirstOrDefault()?.MsgName;
if (!string.IsNullOrWhiteSpace(firstMsg))
{
Driver.SendOneMsgByCmdData(firstMsg, 0, Mode == ZlgCanMode.Can ? (byte)ZDBC.FT_CAN : (byte)ZDBC.FT_CANFD);
}
}
}
}
/// <summary>
/// ZLG CAN 工作模式。
/// </summary>
public enum ZlgCanMode
{
/// <summary>
/// CAN 经典帧。
/// </summary>
Can = 0,
/// <summary>
/// CAN FD。
/// </summary>
CanFd = 1
}
}

157
CapMachine.Wpf/Services/ZlgLinDriveService.cs Normal file
View File

@@ -0,0 +1,157 @@
using CapMachine.Model.CANLIN;
using CapMachine.Wpf.LinDrive;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
namespace CapMachine.Wpf.Services
{
/// <summary>
/// ZLG LIN 驱动服务（共享设备句柄）。
/// </summary>
public sealed class ZlgLinDriveService : BindableBase
{
private readonly ILogService _log;
private readonly ZlgCanDriveService _zlgCanDriveService;
/// <summary>
/// 当前选中的配置程序（沿用原有 FreeSql 模型）。
/// </summary>
public CanLinConfigPro? SelectedCanLinConfigPro { get; set; }
private bool _openState;
/// <summary>
/// LIN 打开状态。
/// </summary>
public bool OpenState
{
get { return _openState; }
private set { _openState = value; RaisePropertyChanged(); }
}
private bool _ldfParserState;
/// <summary>
/// LDF 解析状态（ZLG LIN 暂未接入 LDF，固定为 false）。
/// </summary>
public bool LdfParserState
{
get { return _ldfParserState; }
private set { _ldfParserState = value; RaisePropertyChanged(); }
}
/// <summary>
/// LDF 消息集合（UI 绑定），ZLG LIN 暂未接入 LDF，默认空。
/// </summary>
public ObservableCollection<LinLdfModel> ListLinLdfModel { get; private set; } = new ObservableCollection<LinLdfModel>();
/// <summary>
/// 是否启用调度发送（与 UI 的调度表使能语义对齐）。
/// </summary>
public bool SchEnable
{
get { return _zlgCanDriveService.Driver.SchEnable; }
set { _zlgCanDriveService.Driver.SchEnable = value; RaisePropertyChanged(); }
}
/// <summary>
/// 是否启用事件驱动发送。
/// </summary>
public bool IsCycleSend
{
get { return _zlgCanDriveService.Driver.IsCycleSend; }
set { _zlgCanDriveService.Driver.IsCycleSend = value; RaisePropertyChanged(); }
}
/// <summary>
/// 构造。
/// </summary>
/// <param name="zlgCanDriveService">共享 CAN 服务。</param>
/// <param name="logService">日志服务。</param>
public ZlgLinDriveService(ZlgCanDriveService zlgCanDriveService, ILogService logService)
{
_zlgCanDriveService = zlgCanDriveService;
_log = logService;
_zlgCanDriveService.Driver.LinFrameReceived += frame =>
{
// 未来接入 LDF 后在这里做 Sync/Decode；当前仅保留事件链路，不做假解析。
};
}
/// <summary>
/// 初始化 LIN 配置信息（目前仅缓存）。
/// </summary>
/// <param name="selectedLinConfigPro">选中的配置。</param>
public void InitLinConfig(CanLinConfigPro selectedLinConfigPro)
{
SelectedCanLinConfigPro = selectedLinConfigPro;
}
/// <summary>
/// 打开 LIN（共享设备句柄）。
/// </summary>
/// <param name="deviceIndex">设备索引。</param>
/// <param name="baudRate">波特率。</param>
/// <param name="isMaster">是否主节点。</param>
public void StartLinDrive(uint deviceIndex, uint baudRate, bool isMaster)
{
if (OpenState)
{
return;
}
try
{
// 先确保设备打开（不影响 CAN 后续 Init）
_zlgCanDriveService.Driver.OpenDevice(deviceIndex);
// 初始化 LIN 通道
_zlgCanDriveService.Driver.OpenAndInitLin(0, new CanDrive.ZlgCan.ZlgLinChannelOptions
{
BaudRate = baudRate,
IsMaster = isMaster,
MaxLength = 8,
ChecksumMode = 3
});
// 统一由 CAN 服务侧启动接收线程（设备级 merge 接收可以同时收 CAN/LIN）
if (!_zlgCanDriveService.Driver.IsReceiving)
{
_zlgCanDriveService.Driver.StartReceiveLoop(mergeReceive: true, bufferFrames: 200);
}
OpenState = true;
LdfParserState = false;
}
catch (Exception ex)
{
_log.Error($"ZLG LIN 打开失败：{ex.Message}");
OpenState = false;
throw;
}
}
/// <summary>
/// 关闭 LIN（共享设备句柄下，当前实现以 CloseDevice 为准：关闭将同时关闭 CAN/LIN）。
/// </summary>
public void CloseDevice()
{
// ZLG 的通道句柄都在 Driver 内部；当前 Close 会关闭所有通道，保持与旧系统“同一时刻只有一种驱动工作”的原则一致。
_zlgCanDriveService.CloseDevice();
OpenState = false;
LdfParserState = false;
}
/// <summary>
/// 加载 LDF（ZLG LIN 暂未接入 LDF 解析 DLL，因此此处明确失败，不返回模拟数据）。
/// </summary>
/// <param name="path">LDF 路径。</param>
public ObservableCollection<LinLdfModel> StartLdf(string path)
{
_log.Warn("ZLG LIN 当前版本未接入 LDF 解析（项目内仅存在 USB2XXX.dll 的 LDFParser）。");
throw new NotSupportedException("ZLG LIN 暂未支持 LDF 解析，请后续提供/确认 ZLG 的 LDF DLL 接口（如 zldf.dll）后再接入。");
}
}
}