借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
7.74 KiB
XCoder
using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using NewLife;

namespace NewLife.XCoder.Tools.Can;

/// <summary>Linux SocketCAN 通道(AF_CAN 原始套接字)</summary>
/// <remarks>
/// 波特率由内核侧设置,不在应用里改:
/// sudo ip link set can0 type can bitrate 500000 &amp;&amp; sudo ip link set up can0
/// 无硬件时可用虚拟网卡联调:sudo modprobe vcan &amp;&amp; sudo ip link add dev vcan0 type vcan &amp;&amp; sudo ip link set up vcan0
/// </remarks>
[SupportedOSPlatform("linux")]
public sealed class SocketCanChannel : ICanChannel
{
    #region 字段
    private const Int32 AF_CAN = 29;
    private const Int32 SOCK_RAW = 3;
    private const Int32 CAN_RAW = 1;
    private const Int32 CanFrameSize = 16;
    private const UInt32 CanEffFlag = 0x80000000;
    private const UInt32 CanRtrFlag = 0x40000000;

    // setsockopt 参数:SOL_CAN_RAW=101、CAN_RAW_RECV_OWN_MSGS=4(默认不接收自己发的帧,调试工具需要能自收)
    private const Int32 SOL_CAN_RAW = 101;
    private const Int32 CAN_RAW_RECV_OWN_MSGS = 4;

    private readonly String _interface;
    private Int32 _fd = -1;
    private Thread? _reader;
    private volatile Boolean _running;
    #endregion

    #region 属性
    /// <summary>通道名称(网卡名,如 can0 / vcan0)</summary>
    public String Name => _interface;

    /// <summary>是否已打开</summary>
    public Boolean IsOpen => _fd >= 0;

    /// <summary>当前波特率;SocketCAN 由内核设置,这里只记录界面选择值</summary>
    public Int32 Bitrate { get; private set; }

    /// <summary>收到帧事件,在后台读取线程触发</summary>
    public event EventHandler<CanFrame>? Received;
    #endregion

    #region 构造
    /// <summary>实例化指定网卡的 SocketCAN 通道</summary>
    /// <param name="interfaceName">网卡名,如 can0 / vcan0</param>
    public SocketCanChannel(String interfaceName)
    {
        if (interfaceName.IsNullOrEmpty()) throw new ArgumentNullException(nameof(interfaceName));

        _interface = interfaceName;
    }
    #endregion

    #region 打开/关闭
    /// <summary>打开通道并启动接收线程</summary>
    /// <param name="bitrate">期望波特率,仅记录;实际速率请在系统侧设置网卡</param>
    public void Open(Int32 bitrate)
    {
        if (IsOpen) return;

        var ifIndex = ReadIfIndex(_interface);
        if (ifIndex <= 0) throw new InvalidOperationException($"网卡 {_interface} 不存在或不可用");

        var fd = socket(AF_CAN, SOCK_RAW, CAN_RAW);
        if (fd < 0) throw new InvalidOperationException($"创建 CAN 套接字失败(需要 root 或 CAP_NET_RAW):{Marshal.GetLastPInvokeErrorMessage()}");

        // sockaddr_can:family(2)+填充(2)+ifindex(4)+rx_id/tx_id(8);rx_id=0 表示接收全部帧
        var address = new Byte[16];
        BitConverter.GetBytes((UInt16)AF_CAN).CopyTo(address, 0);
        BitConverter.GetBytes(ifIndex).CopyTo(address, 4);

        if (bind(fd, address, address.Length) != 0)
        {
            var error = Marshal.GetLastPInvokeErrorMessage();
            close(fd);
            throw new InvalidOperationException($"绑定网卡 {_interface} 失败:{error}");
        }

        // 允许接收自己发出的帧(vcan 回环/单机调试时需要)
        var on = BitConverter.GetBytes(1);
        setsockopt(fd, SOL_CAN_RAW, CAN_RAW_RECV_OWN_MSGS, on, on.Length);

        _fd = fd;
        Bitrate = bitrate;
        _running = true;

        _reader = new Thread(ReadLoop) { IsBackground = true, Name = $"SocketCAN-{_interface}" };
        _reader.Start();
    }

    /// <summary>关闭通道并停止接收线程</summary>
    public void Close()
    {
        _running = false;

        var fd = _fd;
        _fd = -1;
        if (fd >= 0)
        {
            try { close(fd); } catch { }
        }

        _reader = null;
    }

    /// <summary>释放通道</summary>
    public void Dispose() => Close();
    #endregion

    #region 收发
    /// <summary>发送一帧</summary>
    /// <param name="frame">CAN 帧,数据超过 8 字节会被截断(经典 CAN)</param>
    public void Send(CanFrame frame)
    {
        if (frame == null) throw new ArgumentNullException(nameof(frame));
        if (!IsOpen) throw new InvalidOperationException("通道未打开");

        var data = frame.Data ?? [];
        if (data.Length > 8) data = data[..8];

        var buffer = new Byte[CanFrameSize];
        var id = frame.Id & 0x1FFFFFFF;
        if (frame.Extended) id |= CanEffFlag;
        if (frame.Remote) id |= CanRtrFlag;

        BitConverter.GetBytes(id).CopyTo(buffer, 0);
        buffer[4] = (Byte)data.Length;
        data.CopyTo(buffer, 8);

        if (write(_fd, buffer, buffer.Length) < 0)
            throw new InvalidOperationException($"发送失败:{Marshal.GetLastPInvokeErrorMessage()}");
    }

    private void ReadLoop()
    {
        var buffer = new Byte[CanFrameSize];

        while (_running)
        {
            eintr:
            var n = read(_fd, buffer, CanFrameSize);
            if (n < 0)
            {
                var errno = Marshal.GetLastPInvokeError();
                // EINTR 是信号打断,继续读;其余错误在关闭后视为正常退出
                if (errno == 4) goto eintr;
                if (_running) Thread.Sleep(10);
                continue;
            }
            if (n < CanFrameSize) continue;

            var canId = BitConverter.ToUInt32(buffer, 0);
            var dlc = buffer[4] > 8 ? 8 : buffer[4];
            var data = new Byte[dlc];
            Array.Copy(buffer, 8, data, 0, dlc);

            var frame = new CanFrame(
                canId & 0x1FFFFFFF,
                data,
                (canId & CanEffFlag) != 0,
                (canId & CanRtrFlag) != 0);

            try { Received?.Invoke(this, frame); } catch { }
        }
    }
    #endregion

    #region 辅助
    /// <summary>从 sysfs 读取网卡索引</summary>
    /// <param name="name">网卡名</param>
    /// <returns>索引;读取失败返回 0</returns>
    public static Int32 ReadIfIndex(String name)
    {
        try
        {
            var text = File.ReadAllText($"/sys/class/net/{name}/ifindex").Trim();
            return Int32.TryParse(text, out var index) ? index : 0;
        }
        catch
        {
            return 0;
        }
    }

    /// <summary>网卡是否处于 up 状态(sysfs 里的 operstate)</summary>
    /// <param name="name">网卡名</param>
    /// <returns>是否 up</returns>
    public static Boolean IsUp(String name)
    {
        try
        {
            var state = File.ReadAllText($"/sys/class/net/{name}/operstate").Trim();
            return state.Equals("up", StringComparison.OrdinalIgnoreCase) || state.Equals("unknown", StringComparison.OrdinalIgnoreCase);
        }
        catch
        {
            return false;
        }
    }

    private static UInt16 ToUInt16(String text) => (UInt16)(UInt32.TryParse(text, out var v) ? v : 0);

    [DllImport("libc", SetLastError = true)]
    private static extern Int32 socket(Int32 domain, Int32 type, Int32 protocol);

    [DllImport("libc", SetLastError = true)]
    private static extern Int32 bind(Int32 fd, Byte[] addr, Int32 len);

    [DllImport("libc", SetLastError = true)]
    private static extern Int32 setsockopt(Int32 fd, Int32 level, Int32 optName, Byte[] optValue, Int32 len);

    [DllImport("libc", SetLastError = true)]
    private static extern nint read(Int32 fd, Byte[] buf, nint count);

    [DllImport("libc", SetLastError = true)]
    private static extern nint write(Int32 fd, Byte[] buf, nint count);

    [DllImport("libc", SetLastError = true)]
    private static extern Int32 close(Int32 fd);
    #endregion
}