using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using Aging.Infrastructure.Contracts;
|
using CanSimulator;
|
using log4net;
|
|
namespace Aging.Infrastructure.Drivers
|
{
|
/// <summary>
|
/// CAN 通讯驱动适配器。
|
/// 封装 CanSimulator，实现统一的 IDeviceDriver 接口。
|
/// 命令格式约定:
|
/// 发送: "SEND:frameId:data" 如 "SEND:0x100:01 02 03 04"
|
/// 查询:
|
/// "RECV" - 获取接收邮箱中的下一帧
|
/// "RECV_ALL" - 获取接收邮箱中的所有帧
|
/// "STATUS" - 获取节点/总线状态
|
/// "FILTER:id:mask" - 设置接收滤波器
|
/// "FILTER_CLEAR" - 清除所有滤波器
|
/// "PROMISCUOUS" - 设置混杂模式（接收所有帧）
|
/// "LOG" - 获取总线日志
|
/// "BUS_STATUS" - 获取总线状态摘要
|
/// </summary>
|
public sealed class CanDriverAdapter : IDeviceDriver
|
{
|
private static readonly ILog Log = LogManager.GetLogger(typeof(CanDriverAdapter));
|
|
/// <summary>
|
/// 全局 CAN 总线模拟器实例（所有 CAN 驱动共享）
|
/// </summary>
|
private static readonly Dictionary<string, CanBusSimulator> _sharedBuses = new();
|
private static readonly object _busLock = new();
|
|
private readonly string _ip; // 总线名称（用 ip 字段映射）
|
private readonly int _port; // 节点编号（用 port 字段映射）
|
private CanBusSimulator? _bus;
|
private CanNode? _node;
|
private bool _disposed;
|
private readonly Stopwatch _latencyStopwatch = new();
|
private double _lastLatencyMs;
|
private string _lastError = string.Empty;
|
private DateTime? _lastErrorTime;
|
private int _reconnectCount;
|
|
/// <summary>
|
/// 接收到的帧缓存（用于 RECV 查询）
|
/// </summary>
|
private readonly Queue<CanFrame> _recvBuffer = new();
|
|
/// <inheritdoc/>
|
public string DeviceId { get; }
|
|
/// <inheritdoc/>
|
public bool IsConnected => _node != null && _node.IsActive;
|
|
/// <inheritdoc/>
|
public event EventHandler<DeviceConnectionEventArgs>? ConnectionChanged;
|
|
/// <summary>
|
/// 初始化 CAN 驱动适配器
|
/// </summary>
|
/// <param name="deviceId">设备唯一标识符</param>
|
/// <param name="busName">总线名称（如 CAN_BUS_1）</param>
|
/// <param name="nodeIndex">节点编号（用于区分同一总线上的不同设备）</param>
|
public CanDriverAdapter(string deviceId, string busName, int nodeIndex)
|
{
|
DeviceId = deviceId ?? throw new ArgumentNullException(nameof(deviceId));
|
_ip = busName ?? "CAN_BUS_1";
|
_port = nodeIndex;
|
}
|
|
/// <summary>
|
/// 获取或创建共享总线
|
/// </summary>
|
private CanBusSimulator GetOrCreateBus(string busName)
|
{
|
lock (_busLock)
|
{
|
if (!_sharedBuses.TryGetValue(busName, out var bus))
|
{
|
bus = new CanBusSimulator(busName);
|
_sharedBuses[busName] = bus;
|
Log.Info($"[CAN] 创建新的虚拟总线: {busName}");
|
}
|
return bus;
|
}
|
}
|
|
/// <inheritdoc/>
|
public Task ConnectAsync(CancellationToken ct)
|
{
|
ThrowIfDisposed();
|
Log.Info($"[CAN] 设备 {DeviceId} 正在连接到总线 {_ip} (节点: {_port})...");
|
|
try
|
{
|
// 获取或创建共享总线
|
_bus = GetOrCreateBus(_ip);
|
|
// 如果总线未启动，自动启动
|
if (_bus.State != CanBusState.Running)
|
{
|
_bus.Start();
|
}
|
|
// 注册节点
|
string nodeId = $"{DeviceId}_node{_port}";
|
_node = _bus.RegisterNode(nodeId, DeviceId);
|
|
// 设置默认滤波器（接收所有帧）
|
_node.SetPromiscuousMode();
|
|
// 激活节点
|
_node.Activate();
|
|
// 订阅接收事件
|
_node.FrameReceived += OnFrameReceived;
|
|
_lastError = string.Empty;
|
Log.Info($"[CAN] 设备 {DeviceId} 已成功连接到总线 {_ip} (节点: {_node.NodeId})");
|
OnConnectionChanged(true, "连接成功");
|
}
|
catch (Exception ex)
|
{
|
_lastError = ex.Message;
|
_lastErrorTime = DateTime.Now;
|
Log.Error($"[CAN] 设备 {DeviceId} 连接异常: {ex.Message}", ex);
|
_node?.Deactivate();
|
_node = null;
|
throw;
|
}
|
|
return Task.CompletedTask;
|
}
|
|
/// <inheritdoc/>
|
public Task DisconnectAsync()
|
{
|
ThrowIfDisposed();
|
Log.Info($"[CAN] 设备 {DeviceId} 正在断开连接...");
|
|
try
|
{
|
if (_node != null)
|
{
|
_node.FrameReceived -= OnFrameReceived;
|
_node.Deactivate();
|
_bus?.UnregisterNode(_node.NodeId);
|
_node = null;
|
}
|
|
Log.Info($"[CAN] 设备 {DeviceId} 已断开连接");
|
OnConnectionChanged(false, "主动断开");
|
}
|
catch (Exception ex)
|
{
|
_lastError = ex.Message;
|
_lastErrorTime = DateTime.Now;
|
Log.Error($"[CAN] 设备 {DeviceId} 断开连接异常: {ex.Message}", ex);
|
_node = null;
|
}
|
|
return Task.CompletedTask;
|
}
|
|
/// <inheritdoc/>
|
public Task<string> SendCommandAsync(string command, CancellationToken ct)
|
{
|
ThrowIfDisposed();
|
if (!IsConnected) throw new InvalidOperationException("[CAN] 设备未连接");
|
|
_latencyStopwatch.Restart();
|
try
|
{
|
Log.Debug($"[CAN] 设备 {DeviceId} 发送命令: {command}");
|
|
// 解析命令格式: "SEND:frameId:data"
|
string[] parts = command.Split(':');
|
if (parts.Length < 3)
|
{
|
throw new ArgumentException($"[CAN] 命令格式错误，应为 SEND:frameId:data，实际: {command}");
|
}
|
|
string operation = parts[0].ToUpper();
|
if (operation != "SEND")
|
{
|
throw new ArgumentException($"[CAN] 不支持的操作类型: {operation}，应为 SEND");
|
}
|
|
// 解析帧 ID
|
string frameIdStr = parts[1];
|
uint frameId = CanFrame.ParseFrameId(frameIdStr);
|
|
// 解析数据
|
string dataStr = parts[2];
|
byte[] data = CanFrame.ParseData(dataStr);
|
|
// 验证数据长度
|
if (data.Length > 8)
|
{
|
throw new ArgumentException($"[CAN] 数据长度超限: {data.Length} 字节（最大 8 字节）");
|
}
|
|
// 创建并发送帧
|
var frame = new CanFrame
|
{
|
FrameId = frameId,
|
Format = frameId > 0x7FF ? CanFrameFormat.Extended : CanFrameFormat.Standard,
|
Type = CanFrameType.Data,
|
Data = data
|
};
|
|
_node!.SendFrame(frame);
|
|
_latencyStopwatch.Stop();
|
_lastLatencyMs = _latencyStopwatch.Elapsed.TotalMilliseconds;
|
|
string response = $"OK:TX:{frame.FrameIdHex}:{frame.Dlc}";
|
Log.Debug($"[CAN] 设备 {DeviceId} 发送成功 (延迟 {_lastLatencyMs:F2}ms): {response}");
|
return Task.FromResult(response);
|
}
|
catch (Exception ex)
|
{
|
_latencyStopwatch.Stop();
|
_lastLatencyMs = _latencyStopwatch.Elapsed.TotalMilliseconds;
|
_lastError = ex.Message;
|
_lastErrorTime = DateTime.Now;
|
Log.Error($"[CAN] 设备 {DeviceId} 发送命令失败: {ex.Message}", ex);
|
throw;
|
}
|
}
|
|
/// <inheritdoc/>
|
public Task<string> QueryAsync(string query, CancellationToken ct)
|
{
|
ThrowIfDisposed();
|
if (!IsConnected) throw new InvalidOperationException("[CAN] 设备未连接");
|
|
_latencyStopwatch.Restart();
|
try
|
{
|
Log.Debug($"[CAN] 设备 {DeviceId} 查询: {query}");
|
|
string[] parts = query.Split(':');
|
string operation = parts[0].ToUpper();
|
|
string response;
|
switch (operation)
|
{
|
case "RECV":
|
response = HandleRecv();
|
break;
|
|
case "RECV_ALL":
|
response = HandleRecvAll();
|
break;
|
|
case "STATUS":
|
response = HandleStatus();
|
break;
|
|
case "FILTER":
|
response = HandleFilter(parts);
|
break;
|
|
case "FILTER_CLEAR":
|
_node!.ClearFilters();
|
response = "OK:滤波器已清除";
|
break;
|
|
case "PROMISCUOUS":
|
_node!.SetPromiscuousMode();
|
response = "OK:混杂模式已启用";
|
break;
|
|
case "AUTO_RESPONSE":
|
response = HandleAutoResponse(parts);
|
break;
|
|
case "RESPONSE_DELAY":
|
response = HandleResponseDelay(parts);
|
break;
|
|
case "LOG":
|
response = HandleLog();
|
break;
|
|
case "BUS_STATUS":
|
response = _bus?.GetStatusSummary() ?? "总线未初始化";
|
break;
|
|
default:
|
throw new ArgumentException($"[CAN] 不支持的查询类型: {operation}");
|
}
|
|
_latencyStopwatch.Stop();
|
_lastLatencyMs = _latencyStopwatch.Elapsed.TotalMilliseconds;
|
Log.Debug($"[CAN] 设备 {DeviceId} 查询响应: {response} (延迟 {_lastLatencyMs:F2}ms)");
|
return Task.FromResult(response);
|
}
|
catch (Exception ex)
|
{
|
_latencyStopwatch.Stop();
|
_lastLatencyMs = _latencyStopwatch.Elapsed.TotalMilliseconds;
|
_lastError = ex.Message;
|
_lastErrorTime = DateTime.Now;
|
Log.Error($"[CAN] 设备 {DeviceId} 查询失败: {ex.Message}", ex);
|
throw;
|
}
|
}
|
|
/// <summary>
|
/// 处理 RECV 查询 - 获取下一帧
|
/// </summary>
|
private string HandleRecv()
|
{
|
// 先从缓冲区取
|
if (_recvBuffer.Count > 0)
|
{
|
var frame = _recvBuffer.Dequeue();
|
return $"RECV:{frame.FrameIdHex}:{frame.DataHex}:{frame.Timestamp:HH:mm:ss.fff}";
|
}
|
|
// 从节点邮箱取
|
if (_node!.TryDequeueReceived(out var frame2))
|
{
|
return $"RECV:{frame2!.FrameIdHex}:{frame2.DataHex}:{frame2.Timestamp:HH:mm:ss.fff}";
|
}
|
|
return "RECV:EMPTY";
|
}
|
|
/// <summary>
|
/// 处理 RECV_ALL 查询 - 获取所有帧
|
/// </summary>
|
private string HandleRecvAll()
|
{
|
var frames = new List<string>();
|
|
// 先取缓冲区
|
while (_recvBuffer.Count > 0)
|
{
|
var f = _recvBuffer.Dequeue();
|
frames.Add($"{f.FrameIdHex}:{f.DataHex}");
|
}
|
|
// 再取节点邮箱
|
var mailbox = _node!.PeekReceiveMailbox();
|
_node.ClearReceiveMailbox();
|
foreach (var f in mailbox)
|
{
|
frames.Add($"{f.FrameIdHex}:{f.DataHex}:{f.Timestamp:HH:mm:ss.fff}");
|
}
|
|
return frames.Count > 0 ? $"RECV_ALL:{frames.Count}:{string.Join("|", frames)}" : "RECV_ALL:0";
|
}
|
|
/// <summary>
|
/// 处理 STATUS 查询
|
/// </summary>
|
private string HandleStatus()
|
{
|
var nodeStatus = _node?.GetStatusSummary() ?? "节点未初始化";
|
var busStatus = _bus?.GetStatusSummary() ?? "总线未初始化";
|
return $"STATUS:{nodeStatus}|{busStatus}";
|
}
|
|
/// <summary>
|
/// 处理 FILTER 设置
|
/// </summary>
|
private string HandleFilter(string[] parts)
|
{
|
if (parts.Length < 3)
|
{
|
throw new ArgumentException("[CAN] FILTER 命令格式错误，应为 FILTER:id:mask");
|
}
|
|
uint filterId = CanFrame.ParseFrameId(parts[1]);
|
uint mask = CanFrame.ParseFrameId(parts[2]);
|
|
_node!.AddFilter(new AcceptanceFilter
|
{
|
FilterId = filterId,
|
Mask = mask,
|
IsExtended = filterId > 0x7FF
|
});
|
|
return $"OK:滤波器已添加 ID=0x{filterId:X3}, Mask=0x{mask:X3}";
|
}
|
|
/// <summary>
|
/// 处理 AUTO_RESPONSE 命令
|
/// 格式: AUTO_RESPONSE:on|off
|
/// </summary>
|
private string HandleAutoResponse(string[] parts)
|
{
|
if (parts.Length < 2)
|
{
|
// 查询当前状态
|
bool current = _node!.AutoResponseEnabled;
|
return $"AUTO_RESPONSE:{(current ? "ON" : "OFF")}";
|
}
|
|
string mode = parts[1].Trim().ToUpper();
|
switch (mode)
|
{
|
case "ON":
|
case "1":
|
case "TRUE":
|
case "ENABLE":
|
_node!.AutoResponseEnabled = true;
|
Log.Info($"[CAN] 设备 {DeviceId} 启用自动响应模式");
|
return "OK:自动响应模式已启用";
|
|
case "OFF":
|
case "0":
|
case "FALSE":
|
case "DISABLE":
|
_node!.AutoResponseEnabled = false;
|
Log.Info($"[CAN] 设备 {DeviceId} 禁用自动响应模式");
|
return "OK:自动响应模式已禁用";
|
|
default:
|
throw new ArgumentException($"[CAN] AUTO_RESPONSE 参数错误: {mode}，应为 on/off");
|
}
|
}
|
|
/// <summary>
|
/// 处理 RESPONSE_DELAY 命令
|
/// 格式: RESPONSE_DELAY:毫秒数
|
/// </summary>
|
private string HandleResponseDelay(string[] parts)
|
{
|
if (parts.Length < 2)
|
{
|
// 查询当前延迟
|
return $"RESPONSE_DELAY:{_node!.AutoResponseDelayMs}ms";
|
}
|
|
if (!int.TryParse(parts[1].Trim(), out int delayMs) || delayMs < 0)
|
{
|
throw new ArgumentException($"[CAN] RESPONSE_DELAY 参数错误: {parts[1]}，应为非负整数（毫秒）");
|
}
|
|
_node!.AutoResponseDelayMs = delayMs;
|
Log.Info($"[CAN] 设备 {DeviceId} 设置响应延迟: {delayMs}ms");
|
return $"OK:响应延迟已设置为 {delayMs}ms";
|
}
|
|
/// <summary>
|
/// 处理 LOG 查询
|
/// </summary>
|
private string HandleLog()
|
{
|
var log = _bus?.GetBusLog(50) ?? new List<CanFrame>();
|
if (log.Count == 0) return "LOG:EMPTY";
|
|
var entries = log.Select(f =>
|
$"[{f.Timestamp:HH:mm:ss.fff}]{f.SourceNodeId}>{f.FrameIdHex}:{f.DataHex}");
|
return $"LOG:{log.Count}:{string.Join("|", entries)}";
|
}
|
|
/// <summary>
|
/// 帧接收事件（公开给外部订阅）
|
/// </summary>
|
public event EventHandler<CanFrame>? DriverFrameReceived;
|
|
/// <summary>
|
/// 帧接收事件处理
|
/// </summary>
|
private void OnFrameReceived(object? sender, CanFrame frame)
|
{
|
// 放入接收缓冲区（用于 RECV/RECV_ALL 查询）
|
while (_recvBuffer.Count >= 1000)
|
{
|
_recvBuffer.Dequeue();
|
}
|
_recvBuffer.Enqueue(frame);
|
|
// 触发公开事件（用于即时显示）
|
DriverFrameReceived?.Invoke(this, frame);
|
}
|
|
/// <inheritdoc/>
|
public DeviceDriverStatus GetStatus()
|
{
|
return new DeviceDriverStatus
|
{
|
IsConnected = IsConnected,
|
IsHealthy = IsConnected && string.IsNullOrEmpty(_lastError),
|
LastError = _lastError,
|
LastErrorTime = _lastErrorTime,
|
LatencyMs = _lastLatencyMs,
|
ReconnectCount = _reconnectCount
|
};
|
}
|
|
/// <inheritdoc/>
|
public void Dispose()
|
{
|
if (_disposed) return;
|
_disposed = true;
|
|
try
|
{
|
if (_node != null)
|
{
|
_node.FrameReceived -= OnFrameReceived;
|
_node.Deactivate();
|
_bus?.UnregisterNode(_node.NodeId);
|
}
|
}
|
catch (Exception ex)
|
{
|
Log.Error($"[CAN] 设备 {DeviceId} 释放资源异常: {ex.Message}", ex);
|
}
|
}
|
|
/// <summary>
|
/// 触发所有总线和节点（用于测试清理）
|
/// </summary>
|
public static void ResetAllBuses()
|
{
|
lock (_busLock)
|
{
|
foreach (var bus in _sharedBuses.Values)
|
{
|
bus.Dispose();
|
}
|
_sharedBuses.Clear();
|
Log.Info("[CAN] 所有虚拟总线已重置");
|
}
|
}
|
|
/// <summary>
|
/// 触发所有总线实例（供外部查询）
|
/// </summary>
|
public static IReadOnlyDictionary<string, CanBusSimulator> GetAllBuses()
|
{
|
lock (_busLock)
|
{
|
return new Dictionary<string, CanBusSimulator>(_sharedBuses);
|
}
|
}
|
|
/// <summary>
|
/// 触发连接状态变化事件
|
/// </summary>
|
private void OnConnectionChanged(bool isConnected, string reason)
|
{
|
ConnectionChanged?.Invoke(this, new DeviceConnectionEventArgs
|
{
|
DeviceId = DeviceId,
|
IsConnected = isConnected,
|
Reason = reason
|
});
|
|
if (!isConnected)
|
{
|
_reconnectCount++;
|
}
|
}
|
|
/// <summary>
|
/// 检查是否已释放
|
/// </summary>
|
private void ThrowIfDisposed()
|
{
|
if (_disposed) throw new ObjectDisposedException(nameof(CanDriverAdapter));
|
}
|
}
|
}
|
