借助网络配置,控制Modbus工具的日志显示,避免卡死界面
智能大石头 authored at 2021-12-11 22:09:19
6.29 KiB
XCoder
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text.RegularExpressions;

namespace NewLife.XCoder.Tools.Dbc;

/// <summary>DBC 信号</summary>
/// <param name="Name">信号名</param>
/// <param name="Start">起始位</param>
/// <param name="Length">位长度</param>
/// <param name="LittleEndian">是否 Intel(小端)格式</param>
/// <param name="Signed">是否有符号</param>
/// <param name="Factor">系数</param>
/// <param name="Offset">偏移</param>
/// <param name="Minimum">最小值</param>
/// <param name="Maximum">最大值</param>
/// <param name="Unit">单位</param>
/// <param name="Receivers">接收节点</param>
public sealed record DbcSignal(
    String Name,
    Int32 Start,
    Int32 Length,
    Boolean LittleEndian,
    Boolean Signed,
    Double Factor,
    Double Offset,
    Double Minimum,
    Double Maximum,
    String Unit,
    IReadOnlyList<String> Receivers);

/// <summary>DBC 报文</summary>
/// <param name="Id">报文 ID</param>
/// <param name="Name">报文名</param>
/// <param name="Dlc">数据长度</param>
/// <param name="Sender">发送节点</param>
/// <param name="Signals">信号列表</param>
public sealed record DbcMessage(UInt32 Id, String Name, Int32 Dlc, String Sender, IReadOnlyList<DbcSignal> Signals);

/// <summary>DBC 文件解析与信号解码</summary>
public static partial class DbcParser
{
    [GeneratedRegex(@"^\s*BO_\s+(\d+)\s+(\w+)\s*:\s*(\d+)\s+(\w+)")]
    private static partial System.Text.RegularExpressions.Regex MessageRegex();

    [GeneratedRegex("^\\s*SG_\\s+(\\w+)\\s*:\\s*(\\d+)\\|(\\d+)@([01])([+-])\\s*\\(([^,]+),([^)]+)\\)\\s*\\[([^|]*)\\|([^\\]]*)\\]\\s*\"([^\"]*)\"\\s*(.*)$")]
    private static partial System.Text.RegularExpressions.Regex SignalRegex();

    /// <summary>解析 DBC 文本</summary>
    /// <param name="text">DBC 内容</param>
    public static IReadOnlyList<DbcMessage> Parse(String text)
    {
        var list = new List<DbcMessage>();
        if (text == null) return list;

        var current = default((UInt32 Id, String Name, Int32 Dlc, String Sender, List<DbcSignal> Signals)?);

        void Flush()
        {
            if (current != null)
            {
                list.Add(new DbcMessage(current.Value.Id, current.Value.Name, current.Value.Dlc, current.Value.Sender, current.Value.Signals));
                current = null;
            }
        }

        foreach (var raw in text.Replace("\r\n", "\n").Split('\n'))
        {
            var match = MessageRegex().Match(raw);
            if (match.Success)
            {
                Flush();
                current = (
                    UInt32.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture),
                    match.Groups[2].Value,
                    Int32.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture),
                    match.Groups[4].Value,
                    []);
                continue;
            }

            if (current == null) continue;

            var signal = SignalRegex().Match(raw);
            if (!signal.Success) continue;

            var receivers = signal.Groups[11].Value
                .Split([',', ' '], StringSplitOptions.RemoveEmptyEntries)
                .ToArray();

            current.Value.Signals.Add(new DbcSignal(
                signal.Groups[1].Value,
                Int32.Parse(signal.Groups[2].Value, CultureInfo.InvariantCulture),
                Int32.Parse(signal.Groups[3].Value, CultureInfo.InvariantCulture),
                signal.Groups[4].Value == "1",
                signal.Groups[5].Value == "-",
                ParseDouble(signal.Groups[6].Value),
                ParseDouble(signal.Groups[7].Value),
                ParseDouble(signal.Groups[8].Value),
                ParseDouble(signal.Groups[9].Value),
                signal.Groups[10].Value,
                receivers));
        }

        Flush();

        return list;
    }

    /// <summary>按信号定义提取原始整数</summary>
    /// <param name="signal">信号</param>
    /// <param name="data">报文数据</param>
    public static Int64 DecodeRaw(DbcSignal signal, ReadOnlySpan<Byte> data)
    {
        if (signal == null) throw new ArgumentNullException(nameof(signal));
        if (signal.Length is <= 0 or > 64) throw new ArgumentOutOfRangeException(nameof(signal), "信号长度必须在 1~64 之间");

        UInt64 value = 0;
        if (signal.LittleEndian)
        {
            for (var i = 0; i < signal.Length; i++)
            {
                var index = signal.Start + i;
                if (GetBit(data, index)) value |= 1UL << i;
            }
        }
        else
        {
            var index = signal.Start;
            for (var i = 0; i < signal.Length; i++)
            {
                value = (value << 1) | (GetBit(data, index) ? 1UL : 0UL);
                index = index % 8 == 0 ? index + 15 : index - 1;
            }
        }

        if (!signal.Signed) return (Int64)value;

        // 符号扩展
        if (signal.Length < 64 && (value & (1UL << (signal.Length - 1))) != 0)
            value |= ulong.MaxValue << signal.Length;

        return (Int64)value;
    }

    /// <summary>解码物理值(原始值 × 系数 + 偏移)</summary>
    /// <param name="signal">信号</param>
    /// <param name="data">报文数据</param>
    public static Double DecodePhysical(DbcSignal signal, ReadOnlySpan<Byte> data) => DecodeRaw(signal, data) * signal.Factor + signal.Offset;

    /// <summary>把十六进制报文解析为字节</summary>
    /// <param name="hex">如 "01 A2 3F"</param>
    public static Byte[] ParseHex(String hex)
    {
        var value = (hex ?? "").Replace(" ", "").Replace("-", "").Replace("0x", "").Replace("0X", "");
        if (value.Length % 2 != 0) throw new FormatException("十六进制长度必须为偶数");

        return Convert.FromHexString(value);
    }

    private static Boolean GetBit(ReadOnlySpan<Byte> data, Int32 index)
    {
        var offset = index / 8;
        if (offset < 0 || offset >= data.Length) return false;

        return (data[offset] & (1 << (index % 8))) != 0;
    }

    private static Double ParseDouble(String text)
    {
        var value = text.Trim();
        return value.Length == 0 ? 0 : Double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var d) ? d : 0;
    }
}