729 lines
30 KiB
C#
729 lines
30 KiB
C#
using Prism.Commands;
|
||
using System;
|
||
using System.Collections.ObjectModel;
|
||
using System.IO;
|
||
using System.Text;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
using Microsoft.Win32;
|
||
using TSMasterCAN;
|
||
using UIShare.ViewModelBase;
|
||
using XCPCore;
|
||
|
||
namespace TSMasterXCPModule.ViewModels
|
||
{
|
||
/// <summary>
|
||
/// TSMaster XCP 测试视图模型：总线连接（TSMaster）、XCP 会话（CONNECT/GET_STATUS）、
|
||
/// 内存读写（SET_MTA/UPLOAD/DOWNLOAD）与 DAQ 采集（FREE_DAQ/ALLOC_DAQ/WRITE_DAQ/START_STOP）。
|
||
/// 协议核心来自 XCPCore（<see cref="XcpMaster"/> + <see cref="XcpCanTransport"/>）。
|
||
/// </summary>
|
||
public class TSMasterXCPViewModel : NavigateViewModelBase, IDisposable
|
||
{
|
||
#region 字段
|
||
|
||
/// <summary>XCP CAN 传输层（XcpConnect 成功后创建）</summary>
|
||
private XcpCanTransport? _transport;
|
||
|
||
/// <summary>XCP 主站协议核心（XcpConnect 成功后创建）</summary>
|
||
private XcpMaster? _master;
|
||
|
||
/// <summary>日志缓冲（防止无限增长）</summary>
|
||
private readonly StringBuilder _logBuffer = new();
|
||
|
||
#endregion
|
||
|
||
#region 属性
|
||
|
||
private bool _isBusy;
|
||
/// <summary>是否正在执行异步操作（驱动 Busy 指示条）</summary>
|
||
public bool IsBusy { get => _isBusy; set { SetProperty(ref _isBusy, value); } }
|
||
|
||
private string _responseLog = string.Empty;
|
||
/// <summary>操作日志（时间戳前缀，只读展示）</summary>
|
||
public string ResponseLog { get => _responseLog; set => SetProperty(ref _responseLog, value); }
|
||
|
||
// ---------- TSMaster 总线 ----------
|
||
|
||
private string _tsMasterProjectPath = string.Empty;
|
||
/// <summary>TSMaster 工程文件路径（可空：空则初始化默认工程）</summary>
|
||
public string TSMasterProjectPath { get => _tsMasterProjectPath; set => SetProperty(ref _tsMasterProjectPath, value); }
|
||
|
||
private bool _isBusConnected;
|
||
/// <summary>TSMaster 总线是否已连接（tsapp_connect + rbs_start 成功）</summary>
|
||
public bool IsBusConnected { get => _isBusConnected; set => SetProperty(ref _isBusConnected, value); }
|
||
|
||
// ---------- A2L 描述文件 ----------
|
||
|
||
private string _a2lFilePath = string.Empty;
|
||
/// <summary>A2L 文件路径</summary>
|
||
public string A2lFilePath { get => _a2lFilePath; set => SetProperty(ref _a2lFilePath, value); }
|
||
|
||
private string _a2lSummaryText = "未加载 A2L 文件";
|
||
/// <summary>A2L 解析结果摘要</summary>
|
||
public string A2lSummaryText { get => _a2lSummaryText; set => SetProperty(ref _a2lSummaryText, value); }
|
||
|
||
/// <summary>解析出的测量量列表（选中后自动填入 DAQ 地址与长度）</summary>
|
||
public ObservableCollection<A2lMeasurement> A2lMeasurements { get; } = new ObservableCollection<A2lMeasurement>();
|
||
|
||
/// <summary>解析出的标定量列表（选中后自动填入内存读写地址与长度）</summary>
|
||
public ObservableCollection<A2lCharacteristic> A2lCharacteristics { get; } = new ObservableCollection<A2lCharacteristic>();
|
||
|
||
private A2lMeasurement? _selectedMeasurement;
|
||
/// <summary>当前选中的测量量：自动带入 DAQ 的 ODT 地址与长度</summary>
|
||
public A2lMeasurement? SelectedMeasurement
|
||
{
|
||
get => _selectedMeasurement;
|
||
set
|
||
{
|
||
if (!SetProperty(ref _selectedMeasurement, value) || value == null) return;
|
||
|
||
OdtAddressText = value.AddressText;
|
||
if (value.SizeBytes > 0) OdtLength = value.SizeBytes.ToString();
|
||
Log($"A2L 测量量 {value.Name}：地址 {value.AddressText}，长度 {value.SizeText}（已填入 DAQ 配置）");
|
||
}
|
||
}
|
||
|
||
private A2lCharacteristic? _selectedCharacteristic;
|
||
/// <summary>当前选中的标定量：自动带入内存读写的地址与长度</summary>
|
||
public A2lCharacteristic? SelectedCharacteristic
|
||
{
|
||
get => _selectedCharacteristic;
|
||
set
|
||
{
|
||
if (!SetProperty(ref _selectedCharacteristic, value) || value == null) return;
|
||
|
||
MemAddressText = value.AddressText;
|
||
if (value.SizeBytes > 0 && value.SizeBytes <= 200) MemReadLength = value.SizeBytes.ToString();
|
||
Log($"A2L 标定量 {value.Name}（{value.CharacteristicType}）：地址 {value.AddressText}，长度 {value.SizeText}（已填入内存读写）");
|
||
}
|
||
}
|
||
|
||
// ---------- XCP 连接配置 ----------
|
||
|
||
private string _canChannel = "0";
|
||
/// <summary>CAN 通道号（0 起始）</summary>
|
||
public string CanChannel { get => _canChannel; set => SetProperty(ref _canChannel, value); }
|
||
|
||
private string _croIdText = "0x7E0";
|
||
/// <summary>CRO CAN ID（命令发送，hex）</summary>
|
||
public string CroIdText { get => _croIdText; set => SetProperty(ref _croIdText, value); }
|
||
|
||
private string _dtoIdText = "0x7E8";
|
||
/// <summary>DTO/RES CAN ID（响应接收，hex）</summary>
|
||
public string DtoIdText { get => _dtoIdText; set => SetProperty(ref _dtoIdText, value); }
|
||
|
||
private bool _isExtendedFrame;
|
||
/// <summary>是否扩展帧（29 位 ID）</summary>
|
||
public bool IsExtendedFrame { get => _isExtendedFrame; set => SetProperty(ref _isExtendedFrame, value); }
|
||
|
||
private bool _isCanFd;
|
||
/// <summary>是否 CAN FD 帧</summary>
|
||
public bool IsCanFd { get => _isCanFd; set => SetProperty(ref _isCanFd, value); }
|
||
|
||
private string _commandTimeoutMs = "1000";
|
||
/// <summary>XCP 命令响应超时（毫秒）</summary>
|
||
public string CommandTimeoutMs { get => _commandTimeoutMs; set => SetProperty(ref _commandTimeoutMs, value); }
|
||
|
||
private bool _isConnected;
|
||
/// <summary>XCP 逻辑连接是否建立（CONNECT 成功）</summary>
|
||
public bool IsConnected { get => _isConnected; set => SetProperty(ref _isConnected, value); }
|
||
|
||
private string _slaveInfoText = "未连接";
|
||
/// <summary>从站能力信息（CONNECT 响应解析）</summary>
|
||
public string SlaveInfoText { get => _slaveInfoText; set => SetProperty(ref _slaveInfoText, value); }
|
||
|
||
// ---------- 内存读写 ----------
|
||
|
||
private string _memAddressText = "0x00000000";
|
||
/// <summary>内存地址（hex）</summary>
|
||
public string MemAddressText { get => _memAddressText; set => SetProperty(ref _memAddressText, value); }
|
||
|
||
private string _memReadLength = "8";
|
||
/// <summary>读取长度（字节）</summary>
|
||
public string MemReadLength { get => _memReadLength; set => SetProperty(ref _memReadLength, value); }
|
||
|
||
private string _memWriteDataText = string.Empty;
|
||
/// <summary>写入数据（hex 字节序列）</summary>
|
||
public string MemWriteDataText { get => _memWriteDataText; set => SetProperty(ref _memWriteDataText, value); }
|
||
|
||
private string _readResultText = string.Empty;
|
||
/// <summary>最近一次读取结果（hex）</summary>
|
||
public string ReadResultText { get => _readResultText; set => SetProperty(ref _readResultText, value); }
|
||
|
||
// ---------- DAQ 采集 ----------
|
||
|
||
private string _daqListNumber = "0";
|
||
/// <summary>DAQ 列表编号</summary>
|
||
public string DaqListNumber { get => _daqListNumber; set => SetProperty(ref _daqListNumber, value); }
|
||
|
||
private string _eventChannel = "0";
|
||
/// <summary>DAQ 事件通道编号</summary>
|
||
public string EventChannel { get => _eventChannel; set => SetProperty(ref _eventChannel, value); }
|
||
|
||
private string _prescaler = "1";
|
||
/// <summary>DAQ 预分频（每 N 个事件采集一次）</summary>
|
||
public string Prescaler { get => _prescaler; set => SetProperty(ref _prescaler, value); }
|
||
|
||
private string _odtAddressText = "0x00000000";
|
||
/// <summary>ODT 条目地址（hex，信号在从站内存中的地址）</summary>
|
||
public string OdtAddressText { get => _odtAddressText; set => SetProperty(ref _odtAddressText, value); }
|
||
|
||
private string _odtLength = "4";
|
||
/// <summary>ODT 条目长度（字节）</summary>
|
||
public string OdtLength { get => _odtLength; set => SetProperty(ref _odtLength, value); }
|
||
|
||
private string _latestDtoText = string.Empty;
|
||
/// <summary>最近收到的 DTO 帧（hex）</summary>
|
||
public string LatestDtoText { get => _latestDtoText; set => SetProperty(ref _latestDtoText, value); }
|
||
|
||
private int _dtoFrameCount;
|
||
/// <summary>已接收 DTO 帧计数</summary>
|
||
public int DtoFrameCount { get => _dtoFrameCount; set => SetProperty(ref _dtoFrameCount, value); }
|
||
|
||
#endregion
|
||
|
||
#region 命令
|
||
|
||
/// <summary>浏览并加载 A2L 描述文件</summary>
|
||
public DelegateCommand BrowseA2lCommand { get; }
|
||
/// <summary>按当前路径重新解析 A2L 描述文件</summary>
|
||
public DelegateCommand ReloadA2lCommand { get; }
|
||
|
||
/// <summary>初始化 TSMaster 驱动（可选加载工程）</summary>
|
||
public DelegateCommand InitDriverCommand { get; }
|
||
/// <summary>释放 TSMaster 驱动</summary>
|
||
public DelegateCommand ReleaseDriverCommand { get; }
|
||
/// <summary>连接 TSMaster CAN 总线</summary>
|
||
public DelegateCommand ConnectBusCommand { get; }
|
||
/// <summary>断开 TSMaster CAN 总线</summary>
|
||
public DelegateCommand DisconnectBusCommand { get; }
|
||
/// <summary>建立 XCP 逻辑连接（CONNECT）</summary>
|
||
public DelegateCommand XcpConnectCommand { get; }
|
||
/// <summary>断开 XCP 逻辑连接（DISCONNECT + 传输层关闭）</summary>
|
||
public DelegateCommand XcpDisconnectCommand { get; }
|
||
/// <summary>查询从站状态（GET_STATUS）</summary>
|
||
public DelegateCommand GetStatusCommand { get; }
|
||
/// <summary>读取内存（SET_MTA + UPLOAD）</summary>
|
||
public DelegateCommand ReadMemoryCommand { get; }
|
||
/// <summary>写入内存（SET_MTA + DOWNLOAD）</summary>
|
||
public DelegateCommand WriteMemoryCommand { get; }
|
||
/// <summary>配置 DAQ 列表（FREE_DAQ → ALLOC_DAQ → SET_DAQ_PTR/WRITE_DAQ → SET_DAQ_LIST_MODE）</summary>
|
||
public DelegateCommand ConfigureDaqCommand { get; }
|
||
/// <summary>启动 DAQ 采集</summary>
|
||
public DelegateCommand StartDaqCommand { get; }
|
||
/// <summary>停止 DAQ 采集</summary>
|
||
public DelegateCommand StopDaqCommand { get; }
|
||
/// <summary>接收一帧 DTO 数据</summary>
|
||
public DelegateCommand ReceiveDtoCommand { get; }
|
||
/// <summary>清空日志</summary>
|
||
public DelegateCommand ClearLogCommand { get; }
|
||
|
||
#endregion
|
||
|
||
/// <summary>创建视图模型</summary>
|
||
public TSMasterXCPViewModel(IContainerProvider containerProvider) : base(containerProvider)
|
||
{
|
||
BrowseA2lCommand = new DelegateCommand(BrowseA2l);
|
||
ReloadA2lCommand = new DelegateCommand(ReloadA2l);
|
||
InitDriverCommand = new DelegateCommand(() => RunGuarded(InitDriverAsync, "初始化驱动"));
|
||
ReleaseDriverCommand = new DelegateCommand(() => RunGuarded(ReleaseDriverAsync, "释放驱动"));
|
||
ConnectBusCommand = new DelegateCommand(() => RunGuarded(ConnectBusAsync, "连接总线"));
|
||
DisconnectBusCommand = new DelegateCommand(() => RunGuarded(DisconnectBusAsync, "断开总线"));
|
||
XcpConnectCommand = new DelegateCommand(() => RunGuarded(XcpConnectAsync, "XCP 连接"));
|
||
XcpDisconnectCommand = new DelegateCommand(() => RunGuarded(XcpDisconnectAsync, "XCP 断开"));
|
||
GetStatusCommand = new DelegateCommand(() => RunGuarded(GetStatusAsync, "查询状态"));
|
||
ReadMemoryCommand = new DelegateCommand(() => RunGuarded(ReadMemoryAsync, "读取内存"));
|
||
WriteMemoryCommand = new DelegateCommand(() => RunGuarded(WriteMemoryAsync, "写入内存"));
|
||
ConfigureDaqCommand = new DelegateCommand(() => RunGuarded(ConfigureDaqAsync, "配置 DAQ"));
|
||
StartDaqCommand = new DelegateCommand(() => RunGuarded(StartDaqAsync, "启动 DAQ"));
|
||
StopDaqCommand = new DelegateCommand(() => RunGuarded(StopDaqAsync, "停止 DAQ"));
|
||
ReceiveDtoCommand = new DelegateCommand(() => RunGuarded(ReceiveDtoAsync, "接收 DTO"));
|
||
ClearLogCommand = new DelegateCommand(() =>
|
||
{
|
||
_logBuffer.Clear();
|
||
ResponseLog = string.Empty;
|
||
});
|
||
|
||
Log("TSMaster XCP 测试界面就绪。使用顺序：初始化驱动 → 连接总线 → XCP 连接 → 内存读写 / DAQ。");
|
||
}
|
||
|
||
#region 命令处理 —— A2L 描述文件
|
||
|
||
/// <summary>浏览选择 A2L 文件并解析</summary>
|
||
private void BrowseA2l()
|
||
{
|
||
var dialog = new OpenFileDialog
|
||
{
|
||
Title = "选择 A2L 描述文件",
|
||
Filter = "A2L 描述文件 (*.a2l)|*.a2l|所有文件 (*.*)|*.*",
|
||
CheckFileExists = true,
|
||
Multiselect = false
|
||
};
|
||
|
||
var currentDir = Path.GetDirectoryName(A2lFilePath);
|
||
if (!string.IsNullOrEmpty(currentDir) && Directory.Exists(currentDir))
|
||
dialog.InitialDirectory = currentDir;
|
||
|
||
if (dialog.ShowDialog() != true) return;
|
||
LoadA2l(dialog.FileName);
|
||
}
|
||
|
||
/// <summary>按当前路径重新解析 A2L</summary>
|
||
private void ReloadA2l()
|
||
{
|
||
var path = A2lFilePath?.Trim() ?? string.Empty;
|
||
if (path.Length == 0)
|
||
{
|
||
Log("[提示] 请先选择 A2L 文件（点击「浏览...」）。");
|
||
return;
|
||
}
|
||
LoadA2l(path);
|
||
}
|
||
|
||
/// <summary>解析并刷新测量量 / 标定量列表</summary>
|
||
private void LoadA2l(string filePath)
|
||
{
|
||
if (!File.Exists(filePath))
|
||
{
|
||
A2lSummaryText = "A2L 文件不存在";
|
||
Log($"[错误] A2L 文件不存在: {filePath}");
|
||
return;
|
||
}
|
||
|
||
try
|
||
{
|
||
var db = A2lParser.LoadFile(filePath);
|
||
A2lFilePath = filePath;
|
||
|
||
A2lMeasurements.Clear();
|
||
foreach (var item in db.Measurements) A2lMeasurements.Add(item);
|
||
|
||
A2lCharacteristics.Clear();
|
||
foreach (var item in db.Characteristics) A2lCharacteristics.Add(item);
|
||
|
||
SelectedMeasurement = null;
|
||
SelectedCharacteristic = null;
|
||
|
||
A2lSummaryText = $"{db.Summary} · {Path.GetFileName(filePath)}";
|
||
Log($"已加载 A2L：{filePath}（{db.Summary}）");
|
||
|
||
if (db.Measurements.Count == 0 && db.Characteristics.Count == 0)
|
||
Log("[警告] 未解析出可用条目，请确认该文件是 A2L（ASAM MCD-2 MC）描述文件。");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
A2lMeasurements.Clear();
|
||
A2lCharacteristics.Clear();
|
||
A2lSummaryText = "A2L 解析失败";
|
||
Log($"[错误] 解析 A2L 失败：{ex.Message}");
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 命令处理 —— TSMaster 总线
|
||
|
||
private async Task InitDriverAsync()
|
||
{
|
||
var project = TSMasterProjectPath?.Trim() ?? string.Empty;
|
||
int re;
|
||
if (string.IsNullOrEmpty(project))
|
||
{
|
||
re = CAN.Init("TSMasterXCP");
|
||
Log("初始化 TSMaster 驱动（默认工程）...");
|
||
}
|
||
else
|
||
{
|
||
if (!File.Exists(project))
|
||
{
|
||
Log($"[错误] TSMaster 工程文件不存在: {project}");
|
||
return;
|
||
}
|
||
re = CAN.Init("TSMasterXCP", project);
|
||
Log($"初始化 TSMaster 驱动（工程: {project}）...");
|
||
}
|
||
|
||
if (re != 0)
|
||
{
|
||
Log($"[错误] 驱动初始化失败，返回码 {re}：{CAN.GetErrorDescription(re)}");
|
||
return;
|
||
}
|
||
Log("TSMaster 驱动初始化成功。");
|
||
await Task.CompletedTask;
|
||
}
|
||
|
||
private async Task ReleaseDriverAsync()
|
||
{
|
||
if (_master != null)
|
||
await XcpDisconnectAsync();
|
||
|
||
CAN.Release();
|
||
IsBusConnected = false;
|
||
Log("TSMaster 驱动已释放。");
|
||
await Task.CompletedTask;
|
||
}
|
||
|
||
private async Task ConnectBusAsync()
|
||
{
|
||
if (!CAN.ConnectFlag)
|
||
{
|
||
Log("连接 TSMaster CAN 总线...");
|
||
int re = CAN.Connect();
|
||
if (re != 0)
|
||
{
|
||
Log($"[错误] 总线连接失败，返回码 {re}：{CAN.GetErrorDescription(re)}（请检查硬件通道映射）");
|
||
return;
|
||
}
|
||
}
|
||
IsBusConnected = true;
|
||
Log("TSMaster CAN 总线已连接。");
|
||
await Task.CompletedTask;
|
||
}
|
||
|
||
private async Task DisconnectBusAsync()
|
||
{
|
||
if (_master != null)
|
||
await XcpDisconnectAsync();
|
||
|
||
int re = CAN.DisConnect();
|
||
IsBusConnected = false;
|
||
Log(re == 0 ? "TSMaster CAN 总线已断开。" : $"[警告] 总线断开返回码 {re}：{CAN.GetErrorDescription(re)}");
|
||
await Task.CompletedTask;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 命令处理 —— XCP 会话
|
||
|
||
private async Task XcpConnectAsync()
|
||
{
|
||
if (!CAN.ConnectFlag)
|
||
{
|
||
Log("[错误] TSMaster 总线未连接，请先执行「初始化驱动 → 连接总线」。");
|
||
return;
|
||
}
|
||
if (_master != null && _master.State != XcpSessionState.Disconnected)
|
||
{
|
||
Log("XCP 已处于连接状态，如需重连请先断开。");
|
||
return;
|
||
}
|
||
|
||
if (!TryGetChannel(out byte channel)) return;
|
||
if (!TryGetHexUint(CroIdText, "CRO ID", out uint croId)) return;
|
||
if (!TryGetHexUint(DtoIdText, "DTO ID", out uint dtoId)) return;
|
||
int timeoutMs = ParseInt(CommandTimeoutMs, 1000);
|
||
|
||
// 每次连接按当前界面参数重建传输层与主站
|
||
_transport = new XcpCanTransport(channel, croId, dtoId, IsExtendedFrame, IsCanFd, timeoutMs);
|
||
_master = new XcpMaster(_transport, new XcpConfig { CommandTimeoutMs = timeoutMs });
|
||
|
||
Log($"XCP CONNECT: CH={channel}, CRO=0x{croId:X}, DTO=0x{dtoId:X}, {(IsCanFd ? "CAN FD" : "经典 CAN")}...");
|
||
bool ok = await _master.ConnectAsync(0x00);
|
||
if (!ok)
|
||
{
|
||
Log("[错误] XCP CONNECT 失败（无有效响应，请检查从站上电、ID 配置与接线）。");
|
||
_master = null;
|
||
_transport?.Close();
|
||
_transport = null;
|
||
IsConnected = false;
|
||
return;
|
||
}
|
||
|
||
IsConnected = true;
|
||
var info = _master.SlaveInfo;
|
||
SlaveInfoText = $"MaxCto={info.MaxCtoSize} MaxDto={info.MaxDtoSize} 资源=0x{info.Resource:X2}"
|
||
+ $" 协议版本={info.ProtocolVersion} 传输层版本={info.TransportLayerVersion}";
|
||
Log($"XCP CONNECT 成功。{SlaveInfoText}");
|
||
}
|
||
|
||
private async Task XcpDisconnectAsync()
|
||
{
|
||
if (_master != null)
|
||
{
|
||
await _master.FullDisconnectAsync();
|
||
Log("XCP 已断开（DISCONNECT + 传输层关闭）。");
|
||
}
|
||
_master = null;
|
||
_transport = null;
|
||
IsConnected = false;
|
||
SlaveInfoText = "未连接";
|
||
}
|
||
|
||
private async Task GetStatusAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
|
||
var status = await _master!.GetStatusAsync();
|
||
if (status == null)
|
||
{
|
||
Log("[错误] GET_STATUS 无响应。");
|
||
return;
|
||
}
|
||
|
||
// 正响应: [FF][SESSION_STATUS][PROTECTION_STATUS][SEQ][DAQ_COUNT(2)][EVENT_COUNT(2)]
|
||
var sb = new StringBuilder("GET_STATUS: ");
|
||
sb.Append($"会话状态=0x{status[1]:X2}");
|
||
if (status.Length > 2) sb.Append($", 保护状态=0x{status[2]:X2}");
|
||
if (status.Length > 4) sb.Append($", 配置的 DAQ 列表数={(status[4] << 8) | status[5]}");
|
||
if (status.Length > 6) sb.Append($", 事件通道数={(status[6] << 8) | status[7]}");
|
||
Log(sb.ToString());
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 命令处理 —— 内存读写
|
||
|
||
private async Task ReadMemoryAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
if (!TryGetHexUint(MemAddressText, "地址", out uint address)) return;
|
||
int length = ParseInt(MemReadLength, 8);
|
||
if (length <= 0 || length > 200)
|
||
{
|
||
Log("[错误] 读取长度须在 1~200 字节之间。");
|
||
return;
|
||
}
|
||
|
||
var data = await _master!.ReadMemoryAsync(address, length);
|
||
if (data == null)
|
||
{
|
||
Log($"[错误] 读取内存 0x{address:X8} 失败。");
|
||
return;
|
||
}
|
||
|
||
ReadResultText = ToHexString(data);
|
||
Log($"读取 0x{address:X8} × {data.Length} 字节: {ReadResultText}");
|
||
}
|
||
|
||
private async Task WriteMemoryAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
if (!TryGetHexUint(MemAddressText, "地址", out uint address)) return;
|
||
|
||
byte[] data;
|
||
try
|
||
{
|
||
data = ParseHexBytes(MemWriteDataText);
|
||
}
|
||
catch (FormatException)
|
||
{
|
||
Log("[错误] 写入数据格式无效，请输入 hex 字节序列（如 FF 00 1A）。");
|
||
return;
|
||
}
|
||
if (data.Length == 0)
|
||
{
|
||
Log("[错误] 写入数据为空。");
|
||
return;
|
||
}
|
||
|
||
bool ok = await _master!.WriteMemoryAsync(address, data);
|
||
Log(ok
|
||
? $"写入 0x{address:X8} × {data.Length} 字节成功: {ToHexString(data)}"
|
||
: $"[错误] 写入内存 0x{address:X8} 失败。");
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 命令处理 —— DAQ 采集
|
||
|
||
private async Task ConfigureDaqAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
ushort daqList = (ushort)Math.Clamp(ParseInt(DaqListNumber, 0), 0, 0xFFFF);
|
||
ushort eventChannel = (ushort)Math.Clamp(ParseInt(EventChannel, 0), 0, 0xFFFF);
|
||
ushort prescaler = (ushort)Math.Clamp(ParseInt(Prescaler, 1), 1, 0xFFFF);
|
||
if (!TryGetHexUint(OdtAddressText, "ODT 地址", out uint address)) return;
|
||
int odtLen = ParseInt(OdtLength, 4);
|
||
if (odtLen <= 0 || odtLen > 64)
|
||
{
|
||
Log("[错误] ODT 条目长度须在 1~64 字节之间。");
|
||
return;
|
||
}
|
||
|
||
var config = new DaqListConfig
|
||
{
|
||
DaqListNumber = daqList,
|
||
EventChannel = eventChannel,
|
||
Prescaler = prescaler,
|
||
Mode = 0x00,
|
||
Enable = true,
|
||
OdEntries = { new OdEntry { Address = address, AddressExtension = 0, Length = (byte)odtLen, Name = $"ODT0_{address:X8}" } }
|
||
};
|
||
|
||
bool ok = await _master!.ConfigureDaqListAsync(config);
|
||
Log(ok
|
||
? $"DAQ 配置成功：列表 {daqList}，事件通道 {eventChannel}，预分频 {prescaler}，条目 0x{address:X8} × {odtLen}B。"
|
||
: "[错误] DAQ 配置失败（FREE_DAQ/ALLOC_DAQ/WRITE_DAQ/SET_DAQ_LIST_MODE 某一步被从站拒绝）。");
|
||
}
|
||
|
||
private async Task StartDaqAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
ushort daqList = (ushort)Math.Clamp(ParseInt(DaqListNumber, 0), 0, 0xFFFF);
|
||
bool ok = await _master!.StartStopDaqAsync(true, daqList);
|
||
Log(ok ? $"DAQ 列表 {daqList} 已启动采集。" : $"[错误] 启动 DAQ 列表 {daqList} 失败。");
|
||
}
|
||
|
||
private async Task StopDaqAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
ushort daqList = (ushort)Math.Clamp(ParseInt(DaqListNumber, 0), 0, 0xFFFF);
|
||
bool ok = await _master!.StartStopDaqAsync(false, daqList);
|
||
Log(ok ? $"DAQ 列表 {daqList} 已停止。" : $"[错误] 停止 DAQ 列表 {daqList} 失败。");
|
||
}
|
||
|
||
private async Task ReceiveDtoAsync()
|
||
{
|
||
if (!RequireMaster()) return;
|
||
|
||
var dto = await _master!.ReceiveDtoAsync(500);
|
||
if (dto == null)
|
||
{
|
||
Log("500ms 内未收到 DTO 帧（确认 DAQ 是否已启动、DTO ID 是否正确）。");
|
||
return;
|
||
}
|
||
|
||
DtoFrameCount++;
|
||
LatestDtoText = ToHexString(dto);
|
||
Log($"DTO #{DtoFrameCount}: {LatestDtoText}");
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region 通用辅助
|
||
|
||
/// <summary>统一命令入口：Busy 指示 + 异常捕获 + 日志</summary>
|
||
private async void RunGuarded(Func<Task> action, string actionName)
|
||
{
|
||
if (IsBusy) return;
|
||
IsBusy = true;
|
||
try
|
||
{
|
||
await action();
|
||
}
|
||
catch (TimeoutException tex)
|
||
{
|
||
Log($"[错误] {actionName} 超时：{tex.Message}");
|
||
}
|
||
catch (XcpProtocolException xex)
|
||
{
|
||
Log($"[错误] {actionName} 协议错误：{xex.Message}");
|
||
}
|
||
catch (InvalidOperationException ioex)
|
||
{
|
||
Log($"[错误] {actionName}：{ioex.Message}");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Log($"[错误] {actionName} 异常：{ex.Message}");
|
||
}
|
||
finally
|
||
{
|
||
IsBusy = false;
|
||
}
|
||
}
|
||
|
||
/// <summary>确认 XCP 主站已创建（界面校验）</summary>
|
||
private bool RequireMaster()
|
||
{
|
||
if (_master == null || _master.State == XcpSessionState.Disconnected)
|
||
{
|
||
Log("[错误] XCP 未连接，请先执行「XCP 连接」。");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>解析 CAN 通道号（0 起始）</summary>
|
||
private bool TryGetChannel(out byte channel)
|
||
{
|
||
channel = 0;
|
||
if (!int.TryParse(CanChannel?.Trim(), out int value) || value < 0 || value > 255)
|
||
{
|
||
Log($"[错误] CAN 通道号无效: {CanChannel}（0~255）。");
|
||
return false;
|
||
}
|
||
channel = (byte)value;
|
||
return true;
|
||
}
|
||
|
||
/// <summary>解析 hex 整数：支持 0x 前缀 / 纯 hex（如 7E0 / 0x7E0）</summary>
|
||
private bool TryGetHexUint(string text, string fieldName, out uint value)
|
||
{
|
||
value = 0;
|
||
var cleaned = (text ?? string.Empty).Trim().Replace(" ", "");
|
||
if (cleaned.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
||
cleaned = cleaned[2..];
|
||
if (cleaned.Length == 0 || !uint.TryParse(cleaned,
|
||
System.Globalization.NumberStyles.HexNumber,
|
||
System.Globalization.CultureInfo.InvariantCulture, out value))
|
||
{
|
||
Log($"[错误] {fieldName} 格式无效: {text}（应为 hex，如 0x7E0）。");
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/// <summary>解析 hex 字节序列：FF 00 1A / FF,00,1A / 0xFF-0x00 均可</summary>
|
||
private static byte[] ParseHexBytes(string text)
|
||
{
|
||
var tokens = (text ?? string.Empty).Split(new[] { ' ', ',', '-', ';' }, StringSplitOptions.RemoveEmptyEntries);
|
||
var result = new byte[tokens.Length];
|
||
for (int i = 0; i < tokens.Length; i++)
|
||
{
|
||
var token = tokens[i];
|
||
if (token.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
|
||
token = token[2..];
|
||
result[i] = byte.Parse(token, System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/// <summary>字节数组转 hex 字符串（大写、空格分隔）</summary>
|
||
private static string ToHexString(byte[] data)
|
||
{
|
||
if (data == null || data.Length == 0) return string.Empty;
|
||
var sb = new StringBuilder(data.Length * 3);
|
||
foreach (var b in data)
|
||
sb.Append(b.ToString("X2")).Append(' ');
|
||
return sb.ToString().TrimEnd();
|
||
}
|
||
|
||
/// <summary>安全解析整数（失败用默认值）</summary>
|
||
private static int ParseInt(string? text, int defaultValue)
|
||
=> int.TryParse(text?.Trim(), out int value) ? value : defaultValue;
|
||
|
||
/// <summary>追加一行带时间戳的日志（超 200 行自动截断头部）</summary>
|
||
private void Log(string message)
|
||
{
|
||
var line = $"[{DateTime.Now:HH:mm:ss.fff}] {message}";
|
||
_logBuffer.AppendLine(line);
|
||
var text = _logBuffer.ToString();
|
||
var lines = text.Split('\n');
|
||
if (lines.Length > 200)
|
||
{
|
||
_logBuffer.Clear();
|
||
_logBuffer.Append(string.Join("\n", lines[^200..]));
|
||
}
|
||
ResponseLog = _logBuffer.ToString().TrimEnd();
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>释放资源：断开 XCP 连接并关闭传输层</summary>
|
||
public void Dispose()
|
||
{
|
||
try
|
||
{
|
||
if (_master != null)
|
||
_master.FullDisconnectAsync().Wait(2000);
|
||
else
|
||
_transport?.Close();
|
||
}
|
||
catch { }
|
||
_master = null;
|
||
_transport = null;
|
||
}
|
||
}
|
||
}
|