crrc/internal/app/stc/data/msgdata.go

package msgdata

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

// Protocol 定义协议数据结构
type Protocol struct {
	StartBytes    [3]byte // 协议开始符
	SourceID      uint8   // 源设备号
	DestinationID uint8   // 目的设备号
	MessageID     uint8   // 消息号
	DataLength    uint16  // 数据长度
	Data          []byte  // 数据
	Checksum      uint8   // 异或校验码
	EndByte       uint8   // 协议结束符
}

// NewProtocol 创建一个新的 Protocol 实例
func NewProtocol() *Protocol {
	return &Protocol{
		StartBytes: [3]byte{0x7F, 0x8E, 0x9D},
		EndByte:    0xFE,
	}

}

// Encode 将 Protocol 结构体编码为字节切片
func (p *Protocol) Encode() ([]byte, error) {
	// 初始化字节缓冲区
	var buf bytes.Buffer // 写入协议开始符
	buf.Write(p.StartBytes[:])

	//init src and dst ID
	p.SourceID = 0x02
	p.DestinationID = 0x01
	// 写入源设备号、目的设备号和消息号
	binary.Write(&buf, binary.BigEndian, p.SourceID)
	binary.Write(&buf, binary.BigEndian, p.DestinationID)
	binary.Write(&buf, binary.BigEndian, p.MessageID)

	// 写入数据长度
	binary.Write(&buf, binary.BigEndian, p.DataLength)

	// 写入数据
	buf.Write(p.Data[:])

	// 计算校验码
	checksum := p.CalculateChecksum()
	p.Checksum = checksum // 写入校验码
	binary.Write(&buf, binary.BigEndian, p.Checksum)

	// 写入协议结束符
	binary.Write(&buf, binary.BigEndian, p.EndByte)

	return buf.Bytes(), nil
}

// CalculateChecksum 计算校验码
func (p *Protocol) CalculateChecksum() uint8 {
	// 初始化校验码
	checksum := uint8(0)

	// 跳过协议开始符
	data := append([]byte{byte(p.SourceID), byte(p.DestinationID), byte(p.MessageID)},
		append([]byte{byte(p.DataLength >> 8), byte(p.DataLength)}, p.Data...)...)

	// 计算校验码
	for _, b := range data {
		checksum ^= b
	}

	return checksum
}

// Decode 解码字节切片为 Protocol 结构体
func Decode(data []byte) (*Protocol, error) {
	if len(data) < 10 { // 最小长度：3（StartBytes） +1（SourceID） +1（DestinationID） +1（MessageID） +2（DataLength） +1（Checksum） +1（EndByte）
		return nil, fmt.Errorf("data too short")
	}

	p := NewProtocol()

	// 读取协议开始符
	copy(p.StartBytes[:], data[:3])

	// 读取源设备号、目的设备号和消息号
	p.SourceID = data[3]
	p.DestinationID = data[4]
	p.MessageID = data[5]

	// 读取数据长度
	p.DataLength = binary.BigEndian.Uint16(data[6:8])

	// 读取数据
	dataLength := int(p.DataLength)
	if len(data) < 10+dataLength {
		return nil, fmt.Errorf("data length mismatch")
	}
	p.Data = data[8 : 8+dataLength]

	// 读取校验码
	p.Checksum = data[8+dataLength]

	// 读取协议结束符
	p.EndByte = data[9+dataLength]

	// 验证校验码
	if p.Checksum != p.CalculateChecksum() {
		return nil, fmt.Errorf("checksum mismatch")
	}

	return p, nil
}
func SubstrByRune(s string, start, length int) string {
	runes := []rune(s)
	if start >= len(runes) {
		return ""
	}
	end := start + length
	if end > len(runes) {
		end = len(runes)
	}
	return string(runes[start:end])
}

// extractPacket 从 buffer 中提取第一个完整数据包
func ExtractPacket(buf *bytes.Buffer) ([]byte, error) {
	data := buf.Bytes()
	startIdx := -1
	endIdx := -1

	// 查找起始标记 0x7f 0x83 0x9d
	for i := 0; i < len(data)-2; i++ {
		if data[i] == 0x7f && data[i+1] == 0x8e && data[i+2] == 0x9d {
			startIdx = i
			break
		}
	}

	if startIdx == -1 {
		// 没找到起始标记，清掉前面无用数据（防止 OOM）
		if buf.Len() > 1024 {
			buf.Next(buf.Len() - 10) // 保留最后10字节继续查找
		}
		return nil, fmt.Errorf("no start marker found")
	}

	// 从起始位置开始查找结束标记 0xFE
	for i := startIdx; i < len(data); i++ {
		if data[i] == 0xFE {
			endIdx = i
			break
		}
	}

	if endIdx == -1 {
		return nil, fmt.Errorf("no end marker found")
	}

	// 提取完整包 [startIdx 到 endIdx]
	packet := make([]byte, endIdx-startIdx+1)
	copy(packet, data[startIdx:endIdx+1])

	// 从 buffer 中删除已处理的数据
	buf.Next(endIdx + 1)

	return packet, nil
}