|
|
package m9z
|
|
|
|
|
|
import (
|
|
|
"crypto/sha256"
|
|
|
"encoding/base64"
|
|
|
"encoding/binary"
|
|
|
"fmt"
|
|
|
"github.com/towgo/towgo/errors/terror"
|
|
|
"io"
|
|
|
"net/http"
|
|
|
"os"
|
|
|
"path/filepath"
|
|
|
g "tgk-touch/internal/global"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
type FirmwareReadBlock struct {
|
|
|
Address uint32
|
|
|
Length uint16
|
|
|
Data []byte
|
|
|
}
|
|
|
|
|
|
// FirmwareRead 读取设备指定地址和长度的固件数据
|
|
|
// 参数:
|
|
|
// - deviceId: 设备ID
|
|
|
// - address: 读取起始地址（32位，如0x08000000）
|
|
|
// - length: 读取数据长度（16位，如512字节）
|
|
|
//
|
|
|
// 返回: 读取到的固件数据及可能的错误
|
|
|
func FirmwareRead(deviceId string, address uint32, length uint16) (*FirmwareReadBlock, error) {
|
|
|
// 1. 构建读取固件的payload
|
|
|
// 结构说明: [指令类型(1字节)][操作类型(1字节)][索引(1字节)][数据长度(1字节)][地址(4字节小端)][读取长度(2字节小端)]
|
|
|
payload := make([]byte, 0, 10) // 固定10字节payload
|
|
|
payload = append(payload, byte(firmwareData)) // 指令类型: 0x0E (固件数据相关)
|
|
|
payload = append(payload, CmdRead) // 操作类型: 0x01 (读取)
|
|
|
payload = append(payload, 0x00) // 索引: 固定0x00
|
|
|
|
|
|
// 数据长度字段: 后续地址(4字节) + 长度(2字节) = 6字节，故为0x06
|
|
|
payload = append(payload, 0x06)
|
|
|
|
|
|
// 地址字段: 32位小端序
|
|
|
addrBytes := make([]byte, 4)
|
|
|
binary.LittleEndian.PutUint32(addrBytes, address)
|
|
|
payload = append(payload, addrBytes...)
|
|
|
|
|
|
// 读取长度字段: 16位小端序
|
|
|
lenBytes := make([]byte, 2)
|
|
|
binary.LittleEndian.PutUint16(lenBytes, length)
|
|
|
payload = append(payload, lenBytes...)
|
|
|
|
|
|
// 2. 计算校验和
|
|
|
checksum := calCheckSum(payload)
|
|
|
|
|
|
// 3. 构建完整帧: [帧头][payload][校验和][帧尾]
|
|
|
frame := []byte{FrameHeader} // 帧头: 0xEE
|
|
|
frame = append(frame, payload...) // 加入payload
|
|
|
frame = append(frame, checksum) // 加入校验和
|
|
|
frame = append(frame, FrameFooter) // 帧尾: 0xFF
|
|
|
|
|
|
// 4. 发送命令并获取响应
|
|
|
respData, err := pushCommand(deviceId, frame, "读取固件数据")
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "设备[%s]读取固件数据失败（地址:0x%X, 长度:%d）", deviceId, address, length)
|
|
|
}
|
|
|
|
|
|
// 5. 解析响应帧
|
|
|
frameResp, err := ParseBlockFrame(respData)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "设备[%s]解析固件响应失败", deviceId)
|
|
|
}
|
|
|
block := &FirmwareReadBlock{}
|
|
|
block.Address = binary.LittleEndian.Uint32(frameResp.Data[0:4])
|
|
|
block.Length = BytesToUint16LE(frameResp.Data[4:6])
|
|
|
block.Data = frameResp.Data[6:]
|
|
|
|
|
|
// 校验返回数据长度是否匹配请求长度
|
|
|
if block.Length != uint16(length) {
|
|
|
return nil, fmt.Errorf("设备[%s]固件数据长度不匹配（期望:%d, 实际:%d）", deviceId, length, len(block.Data))
|
|
|
}
|
|
|
|
|
|
return block, nil
|
|
|
}
|
|
|
|
|
|
// 解析接收帧
|
|
|
func ParseBlockFrame(data []byte) (*ReadResponse, error) {
|
|
|
g.Log().Debugf("ParseFrame:[% X]", data)
|
|
|
s := ""
|
|
|
for i, d := range data {
|
|
|
if i == 0 {
|
|
|
|
|
|
}
|
|
|
s += fmt.Sprintf("0x%X,", d)
|
|
|
}
|
|
|
//g.Log().Debugf("\n ParseFrame:{%s} ", s)
|
|
|
// 基本长度检查
|
|
|
if len(data) < 5 {
|
|
|
return nil,
|
|
|
NewReadError("frame too short")
|
|
|
}
|
|
|
|
|
|
// 验证帧头帧尾
|
|
|
if data[0] != FrameHeader || data[len(data)-1] != FrameFooter {
|
|
|
return nil, NewReadError("invalid frame header or footer")
|
|
|
}
|
|
|
|
|
|
// 提取有效载荷和校验和
|
|
|
payload := data[1 : len(data)-2]
|
|
|
receivedCS := data[len(data)-2]
|
|
|
|
|
|
// 计算校验和
|
|
|
if calCheckSum(payload) != receivedCS {
|
|
|
return nil, NewReadError("checksum mismatch")
|
|
|
}
|
|
|
|
|
|
// 解析指令类型
|
|
|
if len(payload) < 2 {
|
|
|
return nil, NewReadError("invalid payload length")
|
|
|
}
|
|
|
|
|
|
instruction := payload[0]
|
|
|
_ = payload[1]
|
|
|
|
|
|
// 判断是否是响应帧（D7位是否置1）
|
|
|
_ = (instruction & ResponseFlag) != 0
|
|
|
|
|
|
return parseReadBlockResponse(payload)
|
|
|
|
|
|
}
|
|
|
|
|
|
// GenerateFirmwareShortID 生成固件的短唯一标识
|
|
|
// 参数：
|
|
|
//
|
|
|
// firmware - 固件字节数组
|
|
|
//
|
|
|
// 返回：
|
|
|
//
|
|
|
// 短唯一字符串、错误（长度非法时）
|
|
|
func GenerateFirmwareShortID(firmware []byte) (shortID string) {
|
|
|
length := 8
|
|
|
// 1. 校验长度合法性
|
|
|
//if length <= 0 || length > 43 { // Base64URL编码SHA256最大43位，十六进制最大64位
|
|
|
// return "", fmt.Errorf("短ID长度需在1~43之间（推荐8~16）")
|
|
|
//}
|
|
|
|
|
|
// 2. 计算固件的SHA256哈希（核心：内容变则哈希变）
|
|
|
firmware = append(firmware, byte(len(firmware)))
|
|
|
hash := sha256.Sum256(firmware)
|
|
|
hashBytes := hash[:] // 32字节的哈希值
|
|
|
|
|
|
// 3. Base64URL编码（无特殊字符，比十六进制更短）
|
|
|
// Base64URL：去掉+、/，替换为-、_，不补=，适合URL/文件名
|
|
|
base64URL := base64.URLEncoding.WithPadding(base64.NoPadding).EncodeToString(hashBytes)
|
|
|
|
|
|
// 4. 截取指定长度（前length位），保证短小且唯一
|
|
|
shortID = base64URL[:length]
|
|
|
|
|
|
return shortID
|
|
|
}
|
|
|
|
|
|
// 固件升级起始地址
|
|
|
const FirmwareStartAddr = 0x00000000
|
|
|
|
|
|
// FirmwareUpgrade 设备固件完整升级流程
|
|
|
func FirmwareUpgrade(deviceId string, firmware []byte, startAddr uint32) (uniqueId string, addr uint32, err error) {
|
|
|
blockSize := 512
|
|
|
initialOffset := int(startAddr - FirmwareStartAddr)
|
|
|
addr = startAddr // 起始地址
|
|
|
|
|
|
uniqueId = GenerateFirmwareShortID(firmware)
|
|
|
if startAddr == FirmwareStartAddr {
|
|
|
// 1. 擦除扇区
|
|
|
g.Log().Debug("开始擦除分区")
|
|
|
_, err = EraseSector(deviceId)
|
|
|
if err != nil {
|
|
|
return uniqueId, addr, fmt.Errorf("擦除扇区阶段失败: %v", err)
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
/* // 不是起始就要判断完整性
|
|
|
blockData := firmware[initialOffset : initialOffset+blockSize]
|
|
|
blockHash := sha256.Sum256(blockData)
|
|
|
frimwareVer := hex.EncodeToString(blockHash[:])
|
|
|
read, err := FirmwareRead(deviceId, startAddr, uint16(blockSize))
|
|
|
if err != nil {
|
|
|
return uniqueId, addr, terror.Wrapf(err, "验证设备上最新固件包失败")
|
|
|
}
|
|
|
deviceHash := sha256.Sum256(read.Data)
|
|
|
deviceVer := hex.EncodeToString(deviceHash[:])
|
|
|
if deviceVer != frimwareVer {
|
|
|
os.WriteFile("./blockData.txt", []byte(fmt.Sprintf("% X", blockData)), 0666)
|
|
|
os.WriteFile("./readData.txt", []byte(fmt.Sprintf("% X", read.Data)), 0666)
|
|
|
return uniqueId, addr, terror.Newf("设备最新不完整，建议擦除分区重试 %s != %s %d %d", frimwareVer, deviceVer, len(blockData), len(read.Data))
|
|
|
}*/
|
|
|
}
|
|
|
|
|
|
// 2. 分块下发固件数据（每块512字节，不足补零）
|
|
|
totalLen := len(firmware)
|
|
|
blockCount := 0
|
|
|
// 3. 计算起始地址对应的固件偏移量（核心：地址→偏移量映射）
|
|
|
g.Log().Debugf("起始地址0x%X对应固件偏移量: %d字节", startAddr, initialOffset)
|
|
|
for offset := initialOffset; offset < totalLen; offset += blockSize {
|
|
|
blockCount++
|
|
|
// 计算当前块数据
|
|
|
end := offset + blockSize
|
|
|
if end > totalLen {
|
|
|
end = totalLen
|
|
|
}
|
|
|
blockData := firmware[offset:end]
|
|
|
|
|
|
// 补零逻辑：如果块大小不足512字节，自动补零到512字节
|
|
|
if len(blockData) < blockSize {
|
|
|
paddingLen := blockSize - len(blockData)
|
|
|
blockData = append(blockData, make([]byte, paddingLen)...)
|
|
|
}
|
|
|
|
|
|
blockLen := uint16(len(blockData)) // 补零后长度应为512（最后一块可能补零后等于blockSize）
|
|
|
|
|
|
// 计算扩展长度（总长度高8位）和数据长度（低8位）
|
|
|
totalBlockDataLen := 6 + int(blockLen) // 1(ext) + 4(addr) + 2(len) + dataLen
|
|
|
extDataLen := byte(totalBlockDataLen >> 8)
|
|
|
|
|
|
// 下发当前块（带重试机制）
|
|
|
_, err = FirmwareDataWrite(deviceId, extDataLen, addr, blockLen, blockData)
|
|
|
/*
|
|
|
for i := 0; i < 100; i++ {
|
|
|
_, err = FirmwareDataWrite(deviceId, extDataLen, addr, blockLen, blockData)
|
|
|
if err == nil {
|
|
|
break
|
|
|
} else {
|
|
|
err = fmt.Errorf("下发固件块（偏移%d）失败: %v", offset, err)
|
|
|
g.Log().Error(err.Error())
|
|
|
}
|
|
|
time.Sleep(3 * time.Second)
|
|
|
}*/
|
|
|
if err != nil {
|
|
|
return uniqueId, addr, err
|
|
|
}
|
|
|
|
|
|
// 更新地址（按实际补零后的块长度递增）
|
|
|
addr += uint32(blockLen)
|
|
|
|
|
|
}
|
|
|
|
|
|
// 3. 加锁固件
|
|
|
_, err = LockFirmware(deviceId)
|
|
|
if err != nil {
|
|
|
return uniqueId, addr, fmt.Errorf("固件加锁阶段失败: %v", err)
|
|
|
}
|
|
|
|
|
|
// 4. 重启设备完成升级
|
|
|
if err := Restart(deviceId); err != nil {
|
|
|
return uniqueId, addr, fmt.Errorf("重启设备失败: %v", err)
|
|
|
}
|
|
|
|
|
|
return uniqueId, addr, err
|
|
|
}
|
|
|
|
|
|
// EraseSector 擦除设备扇区
|
|
|
// 指令: CMD=0x0D, IDX=0x00
|
|
|
func EraseSector(deviceId string) (*WriteResponse, error) {
|
|
|
// 固定数据格式: 04 77 88 99 00（参考示例指令）
|
|
|
data := []byte{0x04, 0x77, 0x88, 0x99, 0x00}
|
|
|
|
|
|
// 发送写入命令
|
|
|
resp, err := WriteCmd(deviceId, eraseSector, data, "擦除扇区", UpdateMarker)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "设备[%s]擦除扇区失败", deviceId)
|
|
|
}
|
|
|
|
|
|
// 验证响应状态
|
|
|
if !resp.Success {
|
|
|
return nil, fmt.Errorf("设备[%s]擦除扇区响应失败", deviceId)
|
|
|
}
|
|
|
|
|
|
return resp, nil
|
|
|
}
|
|
|
|
|
|
// FirmwareDataWrite 下发固件数据到设备
|
|
|
// 参数:
|
|
|
// - deviceId: 设备ID
|
|
|
// - extDataLen: 扩展数据长度（高8位，与dataLen组成16位总长度）
|
|
|
// - addr: 写入地址（4字节）
|
|
|
// - writeLen: 写入数据长度（2字节）
|
|
|
// - fileData: 实际固件数据
|
|
|
func FirmwareDataWrite(deviceId string, extDataLen byte, addr uint32, writeLen uint16, fileData []byte) (*WriteResponse, error) {
|
|
|
// 1. 校验参数合法性
|
|
|
totalDataLen := uint16(extDataLen)<<8 | uint16(len(fileData)+6) // 7 = 1(ext) + 4(addr) + 2(writeLen)
|
|
|
if totalDataLen != uint16(extDataLen)<<8|uint16(len(fileData)+6) {
|
|
|
return nil, fmt.Errorf("数据长度不匹配，扩展长度0x%02X，实际总长度0x%04X", extDataLen, len(fileData)+7)
|
|
|
}
|
|
|
if int(writeLen) != len(fileData) {
|
|
|
return nil, fmt.Errorf("写入长度与文件数据长度不匹配（%d vs %d）", writeLen, len(fileData))
|
|
|
}
|
|
|
|
|
|
// 2. 构造升级数据
|
|
|
upgradeData := make([]byte, 0, 6+len(fileData))
|
|
|
upgradeData = append(upgradeData, extDataLen) // 扩展数据长度（1字节）
|
|
|
|
|
|
// 写入地址（4字节，小端序）
|
|
|
addrBytes := make([]byte, 4)
|
|
|
binary.LittleEndian.PutUint32(addrBytes, addr)
|
|
|
upgradeData = append(upgradeData, addrBytes...)
|
|
|
|
|
|
// 写入长度（2字节，小端序）
|
|
|
lenBytes := make([]byte, 2)
|
|
|
binary.LittleEndian.PutUint16(lenBytes, writeLen)
|
|
|
|
|
|
upgradeData = append(upgradeData, lenBytes...)
|
|
|
|
|
|
// 固件文件数据
|
|
|
upgradeData = append(upgradeData, fileData...)
|
|
|
|
|
|
// 3. 构造命令数据（数据长度字段 + 升级数据）
|
|
|
dataLen := byte(len(upgradeData) - 1&0xFF) // 数据长度（低8位）
|
|
|
cmdData := append([]byte{dataLen}, upgradeData...)
|
|
|
|
|
|
// 4. 发送写入命令
|
|
|
resp, err := WriteCmd(deviceId, firmwareData, cmdData, "下发固件数据", UpdateMarker)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "\n设备[%s]下发固件数据失败", deviceId)
|
|
|
}
|
|
|
|
|
|
if !resp.Success {
|
|
|
return nil, fmt.Errorf("设备[%s]固件数据写入响应失败", deviceId)
|
|
|
}
|
|
|
|
|
|
return resp, nil
|
|
|
}
|
|
|
|
|
|
// LockFirmware 固件数据下发完成后加锁
|
|
|
// 指令: CMD=0x0F, IDX=0x00
|
|
|
func LockFirmware(deviceId string) (*WriteResponse, error) {
|
|
|
// 无数据 payload（参考示例指令：数据长度0x00）
|
|
|
resp, err := WriteCmd(deviceId, lockFirmware, []byte{00}, "固件加锁")
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "设备[%s]固件加锁失败", deviceId)
|
|
|
}
|
|
|
|
|
|
if !resp.Success {
|
|
|
return nil, fmt.Errorf("设备[%s]固件加锁响应失败", deviceId)
|
|
|
}
|
|
|
|
|
|
return resp, nil
|
|
|
}
|
|
|
|
|
|
// GetFirmwareFromLocal 从本地文件读取固件
|
|
|
// 参数: localPath 本地固件文件路径（如 "./firmware_v1.2.bin"）
|
|
|
func GetFirmwareFromLocal(localPath string) ([]byte, error) {
|
|
|
// 校验路径合法性
|
|
|
if localPath == "" {
|
|
|
return nil, terror.New("本地固件路径不能为空")
|
|
|
}
|
|
|
absPath, err := filepath.Abs(localPath)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "读取固件绝对路径失败（%s）", localPath)
|
|
|
}
|
|
|
|
|
|
// 检查文件是否存在
|
|
|
fileInfo, err := os.Stat(absPath)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "固件文件不存在或无法访问（%s）", absPath)
|
|
|
}
|
|
|
if fileInfo.IsDir() {
|
|
|
return nil, terror.Newf("路径指向目录，不是固件文件（%s）", absPath)
|
|
|
}
|
|
|
|
|
|
// 读取文件内容
|
|
|
firmwareData, err := os.ReadFile(absPath)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "读取固件文件失败（%s）", absPath)
|
|
|
}
|
|
|
|
|
|
g.Log().Infof("成功从本地读取固件，路径：%s，大小：%d字节", absPath, len(firmwareData))
|
|
|
return firmwareData, nil
|
|
|
}
|
|
|
|
|
|
// GetFirmwareFromURL 从网络URL下载固件
|
|
|
// 参数: url 固件下载地址（如 "http://example.com/firmware_v1.2.bin"）
|
|
|
func GetFirmwareFromURL(url string) ([]byte, error) {
|
|
|
// 校验URL合法性
|
|
|
if url == "" {
|
|
|
return nil, terror.New("固件下载URL不能为空")
|
|
|
}
|
|
|
if filepath.Ext(url) != ".bin" {
|
|
|
g.Log().Warnf("固件URL后缀非.bin，可能不是有效固件文件（%s）", url)
|
|
|
}
|
|
|
|
|
|
// 发送HTTP GET请求（设置超时时间）
|
|
|
client := &http.Client{
|
|
|
Timeout: 30 * time.Second, // 30秒超时
|
|
|
}
|
|
|
resp, err := client.Get(url)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "固件下载请求失败（%s）", url)
|
|
|
}
|
|
|
defer resp.Body.Close() // 确保响应体关闭
|
|
|
|
|
|
// 校验响应状态
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
|
return nil, terror.Newf("固件下载失败，HTTP状态码：%d（%s）", resp.StatusCode, url)
|
|
|
}
|
|
|
|
|
|
// 读取响应内容
|
|
|
firmwareData, err := io.ReadAll(resp.Body)
|
|
|
if err != nil {
|
|
|
return nil, terror.Wrapf(err, "读取固件响应内容失败（%s）", url)
|
|
|
}
|
|
|
|
|
|
g.Log().Infof("成功从网络下载固件，URL：%s，大小：%d字节", url, len(firmwareData))
|
|
|
return firmwareData, nil
|
|
|
}
|
