修复时间戳解析和数据验证逻辑

啊鑫

2025-07-28 1b3d57f133b494114c1cdd30627c7057eecdf1b1

 config/ModbusDataParser.cs

@@ -92,28 +92,32 @@
                // 双寄存器，根据字节序组合
                if (config.Encoding?.ToLower() == "littleendian")
                {
                    // 小端：低位在前
                    // 小端：低位寄存器在前，高位寄存器在后
                    value = (registers[0] & 0xFFFF) | ((long)(registers[1] & 0xFFFF) << 16);
                }
                else
                {
                    // 大端：高位在前（默认）
                    // PLC默认使用大端格式进行多寄存器组合：高位寄存器在前，低位寄存器在后
                    value = ((long)(registers[0] & 0xFFFF) << 16) | (registers[1] & 0xFFFF);
                }
                
                // 检查是否为无效数据标识（如负值组合）
                if (value == 0xE2400001 || value > 0x7FFFFFFF)
                Console.WriteLine($"[PARSER-DEBUG] 双寄存器组合: [{registers[0]}, {registers[1]}] → 0x{value:X8} ({value})");
                
                // 检查是否为无效数据标识
                if (IsInvalidData(registers, value))
                {
                    // 可能是无效数据，返回0或使用特殊标识
                    Console.WriteLine($"[PARSER-DEBUG] 检测到无效数据标识，返回0");
                    return 0;
                }
            }
            else
            {
                // 多寄存器：按大端顺序组合
                Console.WriteLine($"[PARSER-DEBUG] 多寄存器组合 ({config.Length}个): [{string.Join(", ", registers.Take(config.Length))}]");
                for (int i = 0; i < Math.Min(registers.Length, config.Length); i++)
                {
                    value = (value << 16) | (registers[i] & 0xFFFF);
                    Console.WriteLine($"[PARSER-DEBUG] 步骤{i+1}: 0x{value:X} (寄存器{i}: {registers[i]})");
                }
            }

@@ -123,7 +127,9 @@
                var scaledValue = value * config.Scale;
                return Math.Round(scaledValue, config.DecimalPlaces);
            }

            
            // 如果没有配置缩放，整数数据默认返回原始值（不再自动应用小数转换）
            // 根据配置文件，测量数据已经配置了Scale: 0.01，所以会走上面的分支
            return value;
        }

@@ -135,23 +141,27 @@
            if (registers.Length == 0) return string.Empty;

            var bytes = new List<byte>();
            Console.WriteLine($"[PARSER-DEBUG] 字符串解析 ({config.Length}个寄存器): [{string.Join(", ", registers.Take(config.Length).Select(r => $"0x{r:X4}"))}]");

            foreach (var register in registers.Take(config.Length))
            {
                if (config.Encoding?.ToLower() == "littleendian")
                {
                    // 小端：低字节在前
                    // 小端：低字节在前，高字节在后
                    bytes.Add((byte)(register & 0xFF));
                    bytes.Add((byte)((register >> 8) & 0xFF));
                }
                else
                {
                    // 大端：高字节在前（默认）
                    // 注意：根据实际PLC数据，字节顺序是反的
                    var highByte = (byte)((register >> 8) & 0xFF);
                    var lowByte = (byte)(register & 0xFF);
                    // PLC字符串存储格式：寄存器值需要字节反序处理
                    // 例如：寄存器0x6261中，0x62='b', 0x61='a'，但期望输出"ab"
                    // 因此需要先输出低字节'a'，再输出高字节'b'
                    var highByte = (byte)((register >> 8) & 0xFF);  // 实际是第二个字符
                    var lowByte = (byte)(register & 0xFF);           // 实际是第一个字符
                    
                    // 先添加低字节，再添加高字节（适应PLC的字节序）
                    Console.WriteLine($"[PARSER-DEBUG] 寄存器0x{register:X4} → 低字节:'{(char)lowByte}' 高字节:'{(char)highByte}'");
                    
                    // 按期望顺序：先添加低字节，再添加高字节
                    if (lowByte != 0) bytes.Add(lowByte);
                    if (highByte != 0) bytes.Add(highByte);
                }
@@ -163,7 +173,9 @@
                bytes.RemoveAt(bytes.Count - 1);
            }

            return Encoding.ASCII.GetString(bytes.ToArray());
            var result = Encoding.ASCII.GetString(bytes.ToArray());
            Console.WriteLine($"[PARSER-DEBUG] 字符串解析结果: '{result}'");
            return result;
        }

        /// <summary>
@@ -208,20 +220,28 @@
        {
            if (registers.Length < 2) return 0.0f;

            Console.WriteLine($"[PARSER-DEBUG] 浮点数解析: [{registers[0]}, {registers[1]}] (0x{registers[0]:X4}, 0x{registers[1]:X4})");

            // IEEE 754单精度浮点数需要2个寄存器（32位）
            uint value;
            
            if (config.Encoding?.ToLower() == "littleendian")
            {
                // 小端：低位寄存器在前，高位寄存器在后
                value = (uint)(registers[0] | (registers[1] << 16));
                Console.WriteLine($"[PARSER-DEBUG] 小端组合: 0x{value:X8}");
            }
            else
            {
                // PLC默认使用大端格式进行多寄存器组合：高位寄存器在前，低位寄存器在后
                value = (uint)((registers[0] << 16) | registers[1]);
                Console.WriteLine($"[PARSER-DEBUG] 大端组合: 0x{value:X8}");
            }

            // 将32位整数转换为浮点数
            return BitConverter.ToSingle(BitConverter.GetBytes(value), 0);
            var result = BitConverter.ToSingle(BitConverter.GetBytes(value), 0);
            Console.WriteLine($"[PARSER-DEBUG] 浮点数解析结果: {result}");
            return result;
        }

        /// <summary>
@@ -241,12 +261,14 @@

        /// <summary>
        /// 解析时间戳字符串（针对数字字符数据）
        /// 大端模式存储：一个字节两个字符，按文档要求的顺序提取字符
        /// </summary>
        private static string ParseTimestampString(int[] registers, DataField config)
        {
            if (registers.Length == 0) return string.Empty;

            var chars = new List<char>();
            Console.WriteLine($"[PARSER-DEBUG] 时间戳寄存器数据: [{string.Join(", ", registers.Take(config.Length).Select(r => $"0x{r:X4}({r})"))}]");

            foreach (var register in registers.Take(config.Length))
            {
@@ -256,8 +278,12 @@
                var highByte = (byte)((register >> 8) & 0xFF);
                var lowByte = (byte)(register & 0xFF);

                // 按PLC数据格式添加字符（先低字节，后高字节）
                // 检查是否为数字字符（ASCII 48-57, '0'-'9'）
                Console.WriteLine($"[PARSER-DEBUG] 寄存器0x{register:X4}: 高字节=0x{highByte:X2}('{(char)highByte}'), 低字节=0x{lowByte:X2}('{(char)lowByte}')");

                // 根据用户提供的解析对照表：大端模式，低字节存在高地址，解析时高低地址要颠倒
                // 即：先取低字节，再取高字节
                // 例如：12338 = 0x3032 → 低字节0x32='2'，高字节0x30='0' → "20"
                
                if (lowByte >= 48 && lowByte <= 57)
                {
                    chars.Add((char)lowByte);
@@ -269,6 +295,7 @@
            }

            var result = new string(chars.ToArray());
            Console.WriteLine($"[PARSER-DEBUG] 时间戳解析结果: '{result}'");
            return result;
        }

@@ -327,6 +354,45 @@
        #region 工具方法

        /// <summary>
        /// 检测是否为无效数据标识
        /// </summary>
        /// <param name="registers">原始寄存器数据</param>
        /// <param name="combinedValue">组合后的值</param>
        /// <returns>是否为无效数据</returns>
        private static bool IsInvalidData(int[] registers, long combinedValue)
        {
            // 常见无效数据模式检测
            
            // 1. 检查是否为全FF模式（通常表示通信错误）
            if (combinedValue == 0xFFFFFFFF)
            {
                return true;
            }
            
            // 2. 检查是否为全0（可能表示未初始化）
            if (combinedValue == 0)
            {
                return true;
            }
            
            // 3. 特定的错误码模式：E240xxxx
            if ((combinedValue & 0xFFFF0000) == 0xE2400000)
            {
                Console.WriteLine($"[PARSER-DEBUG] 检测到E240错误码模式: 0x{combinedValue:X8}");
                return true;
            }
            
            // 4. 检查是否为典型的错误组合：第一个寄存器为大负数（如-7616），第二个为小正数
            if (registers.Length >= 2 && registers[0] == -7616 && registers[1] == 1)
            {
                Console.WriteLine($"[PARSER-DEBUG] 检测到特定错误模式: [{registers[0]}, {registers[1]}]");
                return true;
            }
            
            return false;
        }

        /// <summary>
        /// 获取数据类型的默认值
        /// </summary>
        /// <param name="dataType">数据类型字符串</param>