基于 Rust 与 GBT32960 规范的编解码层

王國慶  金牌会员 | 昨天 03:38 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 926|帖子 926|积分 2782

根据架构设计，实现编解码层的代码设计
Cargo.toml 加入二进制序列化支持
  1. # 序列化支持
  2. ...
  3. bincode = "1.3"           # 添加二进制序列化支持
  4. bytes-utils = "0.1"       # 添加字节处理工具
复制代码
开始编码

错误处理惩罚（error.rs）：

定义了编解码过程中可能遇到的错误类型，利用罗列定义
  1. use thiserror::Error;
  3. #[derive(Error, Debug)]
  4. pub enum CodecError {
  5.     #[error("数据长度不足")]
  6.     InsufficientData,
  8.     #[error("校验和错误")]
  9.     ChecksumMismatch,
  11.     #[error("无效的起始符")]
  12.     InvalidStartByte,
  14.     #[error("无效的命令标识: {0}")] InvalidCommand(u8),
  16.     #[error("IO错误: {0}")] Io(#[from] std::io::Error),
  17. }
复制代码
数据帧布局（frame.rs）：

- 定义了符合 GBT32960 协议的数据帧布局
- 提供了创建和校验数据帧的方法
frame.rs
  1. use bytes::{ Bytes, BytesMut, BufMut };
  2. use chrono::NaiveDateTime;
  3. use serde::{ Serialize, Deserialize };
  5. #[derive(Debug, Clone, Serialize, Deserialize)]
  6. pub struct Frame {
  7.     pub start_byte: u8, // 起始符 0x23
  8.     pub command_flag: u8, // 命令标识
  9.     pub response_flag: u8, // 应答标志
  10.     pub vin: String, // 车辆识别码
  11.     pub encrypt_method: u8, // 加密方式
  12.     pub payload_length: u16, // 数据单元长度
  13.     pub payload: Bytes, // 数据单元
  14.     pub checksum: u8, // BCC校验码
  15. }
  17. impl Frame {
  18.     pub fn new(command: u8, vin: String, payload: Bytes) -> Self {
  19.         let payload_length = payload.len() as u16;
  20.         Self {
  21.             start_byte: 0x23,
  22.             command_flag: command,
  23.             response_flag: 0xfe,
  24.             vin,
  25.             encrypt_method: 0x01,
  26.             payload_length,
  27.             payload,
  28.             checksum: 0x00, // 将在编码时计算
  29.         }
  30.     }
  32.     pub fn calculate_checksum(&self) -> u8 {
  33.         let mut bcc: u8 = 0;
  34.         // 命令标识
  35.         bcc ^= self.command_flag;
  36.         // 应答标志
  37.         bcc ^= self.response_flag;
  38.         // VIN码（17位）
  39.         for byte in self.vin.as_bytes() {
  40.             bcc ^= byte;
  41.         }
  42.         // 加密方式
  43.         bcc ^= self.encrypt_method;
  44.         // 数据单元长度（2字节）
  45.         bcc ^= ((self.payload_length >> 8) & 0xff) as u8;
  46.         bcc ^= (self.payload_length & 0xff) as u8;
  47.         // 数据单元
  48.         for byte in self.payload.iter() {
  49.             bcc ^= byte;
  50.         }
  51.         bcc
  52.     }
  53. }
  55. #[cfg(test)]
  56. mod tests {
  57.     use super::*;
  59.     #[test]
  60.     fn test_calculate_checksum() {
  61.         let payload = Bytes::from_static(&[0x01, 0x02, 0x03]);
  62.         let frame = Frame::new(
  63.             0x01, // command
  64.             "LSVNV2182E0200001".to_string(), // vin
  65.             payload
  66.         );
  68.         let checksum = frame.calculate_checksum();
  69.         assert!(checksum != 0, "校验和不应该为0");
  71.         // 创建相同内容的帧，校验和应该相同
  72.         let frame2 = Frame::new(
  73.             0x01,
  74.             "LSVNV2182E0200001".to_string(),
  75.             Bytes::from_static(&[0x01, 0x02, 0x03])
  76.         );
  77.         assert_eq!(checksum, frame2.calculate_checksum(), "相同内容的帧应该有相同的校验和");
  78.     }
  80.     #[test]
  81.     fn test_different_content_different_checksum() {
  82.         let frame1 = Frame::new(0x01, "LSVNV2182E0200001".to_string(), Bytes::from_static(&[0x01]));
  84.         let frame2 = Frame::new(0x01, "LSVNV2182E0200001".to_string(), Bytes::from_static(&[0x02]));
  86.         assert_ne!(
  87.             frame1.calculate_checksum(),
  88.             frame2.calculate_checksum(),
  89.             "不同内容的帧应该有不同的校验和"
  90.         );
  91.     }
  92. }
复制代码
编解码器（codec.rs）：

- 实现了 tokio 的 Decoder 和 Encoder trait
- 负责数据帧的序列化和反序列化
  1. use bytes::{ BytesMut, Buf };
  2. use tokio_util::codec::{ Decoder, Encoder };
  3. use super::{ Frame, CodecError };
  5. pub struct Gbt32960Codec;
  7. impl Decoder for Gbt32960Codec {
  8.     type Item = Frame;
  9.     type Error = CodecError;
  11.     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
  12.         // 检查数据长度是否足够
  13.         if src.len() < 22 {
  14.             // 最小帧长度
  15.             return Ok(None);
  16.         }
  18.         // 检查起始符
  19.         if src[0] != 0x23 {
  20.             return Err(CodecError::InvalidStartByte);
  21.         }
  23.         // TODO: 实现完整的解码逻辑
  24.         // 1. 读取各个字段
  25.         // 2. 验证校验和
  26.         // 3. 解析数据单元
  28.         Ok(None)
  29.     }
  30. }
  32. impl Encoder<Frame> for Gbt32960Codec {
  33.     type Error = CodecError;
  35.     fn encode(&mut self, frame: Frame, dst: &mut BytesMut) -> Result<(), Self::Error> {
  36.         // TODO: 实现编码逻辑
  37.         // 1. 写入各个字段
  38.         // 2. 计算并写入校验和
  39.         Ok(())
  40.     }
  41. }
复制代码
实现完整的解码逻辑

  1. use bytes::{BytesMut, Buf, BufMut};
  2. use tokio_util::codec::{Decoder, Encoder};
  3. use super::{Frame, CodecError};
  5. pub struct Gbt32960Codec;
  7. impl Decoder for Gbt32960Codec {
  8.     type Item = Frame;
  9.     type Error = CodecError;
  11.     fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
  12.         // 检查数据长度是否足够
  13.         if src.len() < 22 {  // 最小帧长度
  14.             return Ok(None);
  15.         }
  17.         // 检查起始符
  18.         if src[0] != 0x23 {
  19.             return Err(CodecError::InvalidStartByte);
  20.         }
  22.         // 读取命令标识和应答标志
  23.         let command_flag = src[1];
  24.         let response_flag = src[2];
  26.         // 读取 VIN 码（17字节）
  27.         let vin = String::from_utf8_lossy(&src[3..20]).to_string();
  29.         // 读取加密方式
  30.         let encrypt_method = src[20];
  32.         // 读取数据单元长度（2字节）
  33.         let payload_length = ((src[21] as u16) << 8) | (src[22] as u16);
  35.         // 检查是否有足够的数据
  36.         let total_length = 23 + payload_length as usize + 1; // 头部 + 数据单元 + 校验码
  37.         if src.len() < total_length {
  38.             return Ok(None);
  39.         }
  41.         // 读取数据单元
  42.         let payload = src.slice(23..23 + payload_length as usize);
  44.         // 读取校验码
  45.         let received_checksum = src[total_length - 1];
  47.         // 创建帧对象进行校验和计算
  48.         let frame = Frame {
  49.             start_byte: 0x23,
  50.             command_flag,
  51.             response_flag,
  52.             vin,
  53.             encrypt_method,
  54.             payload_length,
  55.             payload: payload.freeze(),
  56.             checksum: received_checksum,
  57.         };
  59.         // 验证校验和
  60.         let calculated_checksum = frame.calculate_checksum();
  61.         if calculated_checksum != received_checksum {
  62.             return Err(CodecError::ChecksumMismatch);
  63.         }
  65.         // 消费已处理的字节
  66.         src.advance(total_length);
  68.         Ok(Some(frame))
  69.     }
  70. }
  72. impl Encoder<Frame> for Gbt32960Codec {
  73.     type Error = CodecError;
  75.     fn encode(&mut self, frame: Frame, dst: &mut BytesMut) -> Result<(), Self::Error> {
  76.         // TODO: 实现编码逻辑
  77.         // 1. 写入各个字段
  78.         // 2. 计算并写入校验和
  79.         Ok(())
  80.     }
  81. }
  83. #[cfg(test)]
  84. mod tests {
  85.     use super::*;
  86.     use bytes::Bytes;
  88.     #[test]
  89.     fn test_decode_valid_frame() {
  90.         let mut codec = Gbt32960Codec;
  91.         let mut buffer = BytesMut::new();
  93.         // 构造测试数据
  94.         buffer.put_u8(0x23);                          // 起始符
  95.         buffer.put_u8(0x01);                          // 命令标识
  96.         buffer.put_u8(0xFE);                          // 应答标志
  97.         buffer.extend_from_slice(b"LSVNV2182E0200001"); // VIN码
  98.         buffer.put_u8(0x01);                          // 加密方式
  99.         buffer.put_u16(2);                            // 数据长度
  100.         buffer.extend_from_slice(&[0x01, 0x02]);      // 数据单元
  101.         
  102.         // 计算并添加校验和
  103.         let checksum = buffer[1..buffer.len()].iter().fold(0u8, |acc, &x| acc ^ x);
  104.         buffer.put_u8(checksum);
  106.         // 解码
  107.         let result = codec.decode(&mut buffer).unwrap().unwrap();
  109.         // 验证解码结果
  110.         assert_eq!(result.command_flag, 0x01);
  111.         assert_eq!(result.vin, "LSVNV2182E0200001");
  112.         assert_eq!(result.payload.len(), 2);
  113.         assert_eq!(buffer.len(), 0); // 确保所有数据都被消费
  114.     }
  116.     #[test]
  117.     fn test_decode_invalid_checksum() {
  118.         let mut codec = Gbt32960Codec;
  119.         let mut buffer = BytesMut::new();
  121.         // 构造测试数据（使用错误的校验和）
  122.         buffer.put_u8(0x23);
  123.         buffer.put_u8(0x01);
  124.         buffer.put_u8(0xFE);
  125.         buffer.extend_from_slice(b"LSVNV2182E0200001");
  126.         buffer.put_u8(0x01);
  127.         buffer.put_u16(0);
  128.         buffer.put_u8(0xFF); // 错误的校验和
  130.         // 验证解码失败
  131.         assert!(matches!(
  132.             codec.decode(&mut buffer),
  133.             Err(CodecError::ChecksumMismatch)
  134.         ));
  135.     }
  136. }
复制代码
代码地址

阿里云登录 - 接待登录阿里云，安全稳定的云计算服务平台
总结

1. 完整的帧分析逻辑：
   - 起始符验证，根据接口协议验证是否0x23开头
   - 命令标识和应答标志分析
   - VIN码分析，vin码17个字节长度
   - 加密方式分析，读取加密方式，测试的时候可以先不利用，上生产情况后要打开
   - 数据单元长度分析，表示数据payload的总长度
   - 数据单元提取
   - 校验和验证
2. 数据完整性查抄：
   - 最小帧长度查抄
   - 完整数据长度查抄
   - 校验和验证
3. 添加了单元测试：
   - 测试有效帧的解码
   - 测试校验和错误的情况

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

王國慶

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表