package home;
|
import java.math.BigInteger;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
// 重命名为PacketParser，表示数据包解析器
|
public class PacketParser {
|
// 添加十六进制字符数组常量
|
private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();
|
// 缓冲区字节数组
|
private byte[] buffer = new byte[4096];
|
// 当前缓冲区有效数据长度
|
private int bufferLength = 0;
|
|
// 追加新数据到缓冲区
|
public void appendData(byte[] newData, int length) {
|
// 检查缓冲区是否足够
|
if (bufferLength + length > buffer.length) {
|
// 创建新的更大缓冲区
|
byte[] newBuffer = new byte[bufferLength + length];
|
// 复制原有数据
|
System.arraycopy(buffer, 0, newBuffer, 0, bufferLength);
|
buffer = newBuffer;
|
}
|
// 追加新数据
|
System.arraycopy(newData, 0, buffer, bufferLength, length);
|
// 更新缓冲区长度
|
bufferLength += length;
|
}
|
|
// 新增方法：字节数组转十六进制字符串
|
public static String bytesToHexString(byte[] bytes) {
|
if (bytes == null) return "";
|
char[] hexChars = new char[bytes.length * 2];
|
for (int j = 0; j < bytes.length; j++) {
|
int v = bytes[j] & 0xFF;
|
hexChars[j * 2] = HEX_ARRAY[v >>> 4];
|
hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
|
}
|
return new String(hexChars);
|
}
|
|
// 解析缓冲区中的所有完整数据包
|
public List<DataPacket> parsePackets() {
|
List<DataPacket> packets = new ArrayList<>();
|
int index = 0; // 当前解析位置索引
|
|
// 遍历缓冲区查找完整数据包
|
while (index <= bufferLength - 4) { // 确保有足够数据检查包头
|
// 检查包头标识 0x55 0xAA
|
if (buffer[index] == 0x55 && (buffer[index + 1] & 0xFF) == 0xAA) {
|
// 获取包类型（第3字节）
|
int packetType = buffer[index + 2] & 0xFF;
|
// 获取数据长度（第4字节）
|
int dataLenField = buffer[index + 3] & 0xFF;
|
// 计算完整包长度（包头+数据+校验）
|
int totalPacketLen = 2 + dataLenField + 2; // 增加2字节校验位
|
|
// 检查是否有足够数据构成完整包
|
if (index + totalPacketLen > bufferLength) {
|
break; // 数据不足，等待更多数据
|
}
|
|
// 提取完整数据包
|
byte[] packetData = new byte[totalPacketLen];
|
System.arraycopy(buffer, index, packetData, 0, totalPacketLen);
|
|
// 验证校验和
|
if (verifyChecksum(packetData)) {
|
// 解析单个数据包
|
DataPacket packet = parseSinglePacket(packetType, packetData);
|
if (packet != null) {
|
packets.add(packet); // 添加到结果列表
|
}
|
index += totalPacketLen; // 移动到下一个包
|
} else {
|
index++; // 校验失败，跳过当前字节
|
}
|
} else {
|
index++; // 非包头标识，继续查找
|
}
|
}
|
|
// 清理已处理数据
|
if (index > 0) {
|
int remaining = bufferLength - index;
|
if (remaining > 0) {
|
// 移动剩余数据到缓冲区开头
|
System.arraycopy(buffer, index, buffer, 0, remaining);
|
}
|
bufferLength = remaining; // 更新缓冲区长度
|
}
|
|
return packets;
|
}
|
|
// 校验数据包
|
private boolean verifyChecksum(byte[] packet) {
|
int len = packet.length;
|
if (len < 4) return false;
|
|
int sum = 0;
|
// 从数据类型开始到校验码前结束 (包头2字节已跳过)
|
for (int i = 2; i < len - 2; i++) {
|
sum += packet[i] & 0xFF;
|
}
|
sum = ~sum & 0xFFFF; // 取反并保留16位
|
|
// 获取包中的校验码 (小端模式)
|
int receivedChecksum = ((packet[len - 1] & 0xFF) << 8) | (packet[len - 2] & 0xFF);
|
|
return sum == receivedChecksum;
|
}
|
|
|
|
// 解析单个数据包
|
private DataPacket parseSinglePacket(int packetType, byte[] packet) {
|
|
// 创建数据包对象（包含包类型）
|
return new DataPacket(packetType, packet);
|
}
|
|
// 数据包内部类
|
public static class DataPacket {
|
private final int packetType; // 包类型
|
private final byte[] packet;//包数据
|
|
|
public DataPacket(int packetType, byte[] packet) {
|
this.packetType = packetType;
|
this.packet = packet;
|
}
|
|
// 获取包类型
|
public int getPacketType() {
|
return packetType;
|
}
|
|
// 包数据
|
public byte[] getPacket() {
|
return packet;
|
}
|
|
}
|
|
// HEX字符串转字节数组
|
public static byte[] hexStringToBytes(String hex) {
|
// 移除空格
|
hex = hex.replaceAll("\\s", "");
|
int len = hex.length();
|
// 创建结果数组
|
byte[] data = new byte[len / 2];
|
// 每两个字符转换一个字节
|
for (int i = 0; i < len; i += 2) {
|
// 高位转换
|
int high = Character.digit(hex.charAt(i), 16) << 4;
|
// 低位转换
|
int low = Character.digit(hex.charAt(i + 1), 16);
|
data[i / 2] = (byte) (high | low);
|
}
|
return data;
|
}
|
|
|
|
|
/**输出校验码*/
|
public static String calculateChecksum(String input) {
|
// 检查输入是否为空
|
if (input == null) {
|
throw new IllegalArgumentException("输入不能为null");
|
}
|
// 移除所有空格
|
String cleanInput = input.replaceAll("\\s", "");
|
// 验证处理后的字符串
|
if (cleanInput.length() < 8 || !cleanInput.startsWith("55AA")) {
|
throw new IllegalArgumentException("输入字符串必须以55AA开头且长度至少为8（去除空格后）");
|
}
|
// 去掉包头(55AA)和最后4个字符
|
String dataPart = cleanInput.substring(4, cleanInput.length() - 4);
|
// 检查中间部分长度是否为偶数
|
if (dataPart.length() % 2 != 0) {
|
throw new IllegalArgumentException("校验出错中间部分长度必须是偶数（去除空格后）");
|
}
|
int sum = 0;
|
// 每两个字符解析为一个字节
|
for (int i = 0; i < dataPart.length(); i += 2) {
|
String byteStr = dataPart.substring(i, i + 2);
|
int byteValue = Integer.parseInt(byteStr, 16);
|
sum = (sum + byteValue) & 0xFFFF; // 保持16位范围
|
}
|
|
// 取反并保持16位
|
int checksum = (~sum) & 0xFFFF;
|
|
// 显式处理高位在前格式
|
int lowByte= (checksum >>> 8) & 0xFF; // 高8位
|
int highByte= checksum & 0xFF; // 低8位
|
|
// 格式化为4位十六进制字符串（大写），高位在前
|
return String.format("%02X%02X", highByte, lowByte);
|
}
|
|
/** 将字节数组转为十六进制字符串，例如 [55 AA 01 02 ...] */
|
private static String bytesToHex(byte[] bytes) {
|
if (bytes == null) return "null";
|
StringBuilder sb = new StringBuilder(bytes.length * 3);
|
for (byte b : bytes) {
|
sb.append(String.format("%02X ", b & 0xFF));
|
}
|
// 去掉最后一个空格
|
return sb.substring(0, sb.length() - 1);
|
}
|
|
|
}
|
