1010 lines
45 KiB
Python
1010 lines
45 KiB
Python
import time
|
|
import hashlib
|
|
from math import ceil
|
|
from tqdm import tqdm
|
|
from pathlib import Path
|
|
from serial import Serial
|
|
|
|
from . import tools
|
|
from . import function
|
|
from .tools import ByteConv, IntelHex
|
|
from .function import protocols, file_upgrade
|
|
from .DeviceSerial import DeviceSerial
|
|
|
|
ParamMap_LaminaController = {
|
|
# 1 - Hex
|
|
# 2 - Int16
|
|
# 3 - lnt32
|
|
# 4 - str
|
|
# 5 - addr
|
|
# 6 - float
|
|
# 7 - numberList
|
|
0x00: ["绝缘检测正电阻", 6],
|
|
0x02: ["绝缘检测负电阻", 6],
|
|
0x0B: ["事件标志", 1],
|
|
0x0C: ["告警字1", 1],
|
|
0x0D: ["告警字2", 1],
|
|
0x0E: ["故障字1", 1],
|
|
0x0F: ["故障字2", 1],
|
|
0x10: ["系统工作状态" , 1],
|
|
0x11: ["Boost1工作状态" , 1],
|
|
0x12: ["Boost2工作状态" , 1],
|
|
0x13: ["开关机状态" , 1],
|
|
0x14: ["光伏组串1输入电压" , 2, 10],
|
|
0x15: ["光伏组串2输入电压" , 2, 10],
|
|
0x16: ["Boost1电感电流" , 2, 100],
|
|
0x17: ["Boost2电感电流" , 2, 100],
|
|
0x18: ["Boost输出电压" , 2, 10],
|
|
0x19: ["Boost输出总电流" , 2, 100],
|
|
0x1A: ["Boost1功率" , 3, 1000],
|
|
0x1C: ["Boost2功率" , 3, 1000],
|
|
0x1E: ["输入总功率" , 3, 1000],
|
|
0x20: ["LLC输出电压" , 2, 10],
|
|
0x21: ["端口输出电压" , 2, 10],
|
|
0x22: ["LLC输出电流均值" , 2, 100],
|
|
0x23: ["LLC输出电流峰值" , 2, 100],
|
|
0x24: ["绝缘检测电压" , 2, 10],
|
|
0x25: ["散热片温度" , 2, 10],
|
|
0x26: ["腔体1温度" , 2, 10],
|
|
0x27: ["腔体2温度" , 2, 10],
|
|
0x28: ["设备温度" , 2, 10],
|
|
|
|
0x50: ["启停控制命令" , 2],
|
|
0x51: ["故障清除命令" , 2],
|
|
0x52: ["参数还原命令" , 2],
|
|
0x53: ["设备复位命令" , 2],
|
|
0x54: ["模式更改命令" , 2],
|
|
0x55: ["短时停机命令(未启用)" , 2],
|
|
0x56: ["手动录波命令" , 2],
|
|
0x57: ["时间配置命令" , 7, 3],
|
|
|
|
0x60: ["整机运行使能", 1],
|
|
0x61: ["最小启动允许输入电压", 2, 10],
|
|
0x62: ["最大启动允许输入电压", 2, 10],
|
|
0x63: ["最小停机输入电压", 2, 10],
|
|
0x64: ["最大停机输入电压", 2, 10],
|
|
0x65: ["最小启动允许输出电压", 2, 10],
|
|
0x66: ["最大启动允许输出电压", 2, 10],
|
|
0x67: ["最小停止允许输出电压", 2, 10],
|
|
0x68: ["最大停止允许输出电压", 2, 10],
|
|
0x69: ["最小MPPT电流限值", 2, 100],
|
|
0x6A: ["最大MPPT电流限值", 2, 100],
|
|
0x6B: ["保留数据项", 2],
|
|
0x6C: ["最大功率限值", 3, 1000],
|
|
0x6E: ["最大功率限值存储值", 3, 1000],
|
|
0x70: ["Boost输入过压保护值", 2, 10],
|
|
0x71: ["Boost输出过压保护值", 2, 10],
|
|
0x72: ["LLC输出过压保护值", 2, 10],
|
|
0x73: ["LLC输出欠压保护值", 2, 10],
|
|
0x74: ["Boost电感过流保护值", 2, 100],
|
|
0x75: ["LLC输出电流均值保护值", 2, 100],
|
|
0x76: ["LLC输出电流峰值保护值", 2, 100],
|
|
0x77: ["保留数据项", 2],
|
|
0x78: ["过载保护值", 3, 1000],
|
|
0x7A: ["过温故障值", 2, 10],
|
|
0x7B: ["过温告警值", 2, 10],
|
|
0x7C: ["过温恢复值", 2, 10],
|
|
0x7D: ["输出继电器故障判断差值", 2, 10],
|
|
0x7E: ["LLC输出电压给定值", 2, 10],
|
|
0x7F: ["Boost输出电压给定值", 2, 10],
|
|
0x80: ["三点法中间阈值", 2, 10],
|
|
0x81: ["浮充电压", 2, 10],
|
|
0x82: ["恒压充电电压", 2, 10],
|
|
0x83: ["llc软起开始电压", 2, 10],
|
|
0x84: ["boost开始运行电压", 2, 10],
|
|
0x85: ["boost停止运行电压", 2, 10],
|
|
0x86: ["绝缘检测正阻抗限值", 3, 1],
|
|
0x88: ["绝缘检测负阻抗限值", 3, 1],
|
|
0x8A: ["抖动频率下限", 2, 10],
|
|
0x8B: ["抖动频率上限", 2, 10],
|
|
0x8C: ["保留地址项", 2],
|
|
0x8D: ["保留地址项", 2],
|
|
0x8E: ["保留地址项", 2],
|
|
0x8F: ["保留地址项", 2],
|
|
|
|
0x100: ["程序版本字符串", 4, 16],
|
|
0x110: ["设备型号字符串", 4, 16],
|
|
0x120: ["保留地址项", 4, 16],
|
|
0x130: ["生产厂家字符串", 4, 8],
|
|
0x138: ["保留地址项", 4, 8],
|
|
0x140: ["保留地址项", 4, 16],
|
|
0x150: ["保留地址项", 4, 16],
|
|
0x160: ["硬件版本字符串", 4, 16],
|
|
0x170: ["设备序列号", 4, 16],
|
|
0x180: ["设备MES码", 4, 16],
|
|
0x190: ["出厂日期批次", 4, 16],
|
|
}
|
|
|
|
MemoryMap_280039 = {
|
|
'image_size': 2*0x030000, # 镜像文件大小
|
|
'app_size': 2*0x004000, # 应用程序大小
|
|
'boot_size': 2*0x014000, # Boot程序大小
|
|
|
|
'boot_addr': 0x000000, # Boot程序地址
|
|
'main_header': 0x006000, # main信息地址
|
|
'back_header': 0x007000, # back信息地址
|
|
'main_info': 0x088000, # main版本地址
|
|
'back_info': 0x007000, # back版本地址
|
|
'main_addr': 0x008000, # main程序地址
|
|
'back_addr': 0x01C000, # back程序地址
|
|
}
|
|
|
|
class LaminaController:
|
|
""" 叠光控制器
|
|
"""
|
|
def __init__(self, com_name="COM16", addr_645=[0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA], addr_modbus=0x01, **kwargs):
|
|
# 初始化串口通信
|
|
if com_name is not None:
|
|
com_config = {}
|
|
com_config['baudrate'] = kwargs['baudrate'] if 'baudrate' in kwargs.keys() else 115200
|
|
com_config['parity'] = kwargs['parity'] if 'parity' in kwargs.keys() else 'N'
|
|
com_config['bytesize'] = kwargs['bytesize'] if 'bytesize' in kwargs.keys() else 8
|
|
com_config['stopbits'] = kwargs['stopbits'] if 'stopbits' in kwargs.keys() else 1
|
|
self.__com = Serial(com_name, timeout=0, **com_config)
|
|
else:
|
|
self.__com = None
|
|
|
|
self.flag_print = kwargs['frame_print'] if 'frame_print' in kwargs.keys() else False
|
|
self.time_out = kwargs['time_out'] if 'time_out' in kwargs.keys() else 1
|
|
self.time_gap = kwargs['time_gap'] if 'time_gap' in kwargs.keys() else 0.01
|
|
self.retry = kwargs['retry'] if 'retry' in kwargs.keys() else 1
|
|
|
|
self.block = {
|
|
'addr' : addr_645,
|
|
'type' : 'modbus',
|
|
'data' : {
|
|
'addr_dev' : addr_modbus,
|
|
'data_define': ParamMap_LaminaController,
|
|
},
|
|
}
|
|
self.output = {
|
|
'result': False,
|
|
'code_func': 0x00,
|
|
}
|
|
self.log = {
|
|
'send': 0,
|
|
'read': 0,
|
|
'keep-fail': 0,
|
|
'record': {
|
|
'config': None,
|
|
'data': None,
|
|
},
|
|
}
|
|
|
|
def __read_frame(self) -> bool:
|
|
""" 使用帧字节超时策略读报文帧, 并进行解析数据, 打印异常 """
|
|
frame_recv = b''
|
|
time_start, time_current, flag_frame = time.time(), time.time(), False
|
|
while (time_current - time_start) < self.time_out:
|
|
time.sleep(self.time_gap)
|
|
bytes_read = self.__com.read_all()
|
|
time_current = time.time()
|
|
if flag_frame and len(bytes_read) == 0:
|
|
break
|
|
elif len(bytes_read):
|
|
flag_frame = True
|
|
frame_recv += bytes_read
|
|
try:
|
|
self.output = function.protocols.check_frame_modbus(frame_recv, self.block['data'])
|
|
if self.flag_print:
|
|
print("Read Frame: ", tools.ByteConv.trans_list_to_str(frame_recv))
|
|
except Exception as ex:
|
|
print("Error Info: ", ex)
|
|
if self.flag_print and frame_recv:
|
|
print("Fail Data: " , tools.ByteConv.trans_list_to_str(frame_recv))
|
|
self.output['result'] = False
|
|
|
|
return self.output['result']
|
|
def __transfer_data(self, frame: bytearray) -> bool:
|
|
""" 串口收发报文, 包含重试逻辑与数据打印 """
|
|
if self.__com is None:
|
|
print(tools.ByteConv.trans_list_to_str(frame))
|
|
return False
|
|
|
|
fail_count = 0
|
|
while fail_count < self.retry:
|
|
frame_discard = self.__com.read_all()
|
|
self.__com.write(frame)
|
|
self.log['send'] += 1
|
|
|
|
if self.flag_print and frame_discard:
|
|
print("Discard Data: " , frame_discard)
|
|
if self.flag_print:
|
|
print("Send Frame: ", tools.ByteConv.trans_list_to_str(frame))
|
|
|
|
time.sleep(10 * self.time_gap)
|
|
if self.__read_frame():
|
|
if (self.flag_print is not None) and 'Regs' in self.output.keys():
|
|
function.protocols.print_display(self.output['Regs'])
|
|
self.log['read'] += 1
|
|
break
|
|
else:
|
|
fail_count += 1
|
|
if fail_count >= self.log['keep-fail']:
|
|
self.log['keep-fail'] = fail_count
|
|
time.sleep(2*self.time_out)
|
|
|
|
return fail_count < self.retry
|
|
|
|
def frame_read(self, daddr=0x60, dlen=0x30) -> bool:
|
|
self.block['data']['type'] = 'read'
|
|
self.block['data']['data_addr'] = daddr
|
|
self.block['data']['data_len'] = dlen
|
|
frame = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
return self.__transfer_data(frame)
|
|
|
|
def frame_write_one(self, daddr=0x85, dval=-900) -> bool:
|
|
self.block['data']['type'] = 'write_one'
|
|
self.block['data']['data_addr'] = daddr
|
|
item_coff = self.block['data']['data_define'][daddr][2] if len(self.block['data']['data_define'][daddr]) > 2 else 1
|
|
self.block['data']['data_val'] = int(dval * item_coff)
|
|
frame = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
return self.__transfer_data(frame)
|
|
|
|
def frame_write_dual(self, daddr=0x91, dval=600) -> bool:
|
|
self.block['data']['type'] = 'write_dual'
|
|
self.block['data']['data_addr'] = daddr
|
|
item_coff = self.block['data']['data_define'][daddr][2] if len(self.block['data']['data_define'][daddr]) > 2 else 1
|
|
self.block['data']['data_val'] = int(dval * item_coff)
|
|
frame = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
return self.__transfer_data(frame)
|
|
|
|
def frame_write_str(self, daddr=0x82, dval=[0x06, 0x05, 0x04, 0x03, 0x02, 0x01]) -> bool:
|
|
self.block['data']['type'] = 'write_str'
|
|
self.block['data']['data_addr'] = daddr
|
|
self.block['data']['data_val'] = dval
|
|
frame = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
return self.__transfer_data(frame)
|
|
|
|
def frame_record(self) -> bool:
|
|
""" 读取录波数据
|
|
"""
|
|
param_saved = self.flag_print, self.retry, self.time_out
|
|
self.flag_print = False
|
|
self.retry = 3
|
|
self.time_out = 1.5
|
|
self.block['data']['file_block_size'] = 240
|
|
# 读取config
|
|
self.block['data']['type'] = 'record_cfg'
|
|
self.block['data']['step'] = 'start'
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
ret, pbar = True, None
|
|
frame_data_cfg = []
|
|
while ret:
|
|
if ret := self.__transfer_data(frame_master):
|
|
frame_data_cfg.append(self.output['record'])
|
|
if self.output['record']['seq'] == 0:
|
|
pbar = tqdm(total=self.output['record']['total'] + 1, desc="Record Config Reading")
|
|
self.block['data']['step'] = 'next'
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
elif (self.output['record']['seq']) >= self.output['record']['total']:
|
|
ret = False
|
|
pbar and pbar.update()
|
|
pbar and pbar.close()
|
|
|
|
# 读取data
|
|
self.block['data']['type'] = 'record_data'
|
|
self.block['data']['step'] = 'start'
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
|
|
ret, pbar = True, None
|
|
frame_data_record = []
|
|
while ret:
|
|
if ret := self.__transfer_data(frame_master):
|
|
frame_data_record.append(self.output['record'])
|
|
if self.output['record']['seq'] == 0:
|
|
pbar = tqdm(total=self.output['record']['total'] + 1, desc="Record Data Reading")
|
|
self.block['data']['step'] = 'next'
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
elif (self.output['record']['seq']) >= self.output['record']['total']:
|
|
ret = False
|
|
pbar and pbar.update()
|
|
pbar and pbar.close()
|
|
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
if (len(frame_data_record) != 32) or (len(frame_data_cfg) != 3):
|
|
print("Operation_Record: 未取得录波数据.")
|
|
return False
|
|
|
|
# 处理配置信息
|
|
data_cfg_bare = b"".join([x['data'] for x in frame_data_cfg])
|
|
config_record = {'LinePos': []}
|
|
pos = 0
|
|
if data_cfg_bare[pos+1] != 0xF1 or data_cfg_bare[pos] != 0xF1:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
len_faultword = (data_cfg_bare[3] * 0x100 + data_cfg_bare[2])
|
|
pos += 2
|
|
config_record['FaultWord'] = []
|
|
for i in range(0, len_faultword, 2):
|
|
faultword = data_cfg_bare[pos+i+1] * 0x100 + data_cfg_bare[pos+i]
|
|
config_record['FaultWord'].append(faultword)
|
|
pos += len_faultword
|
|
config_record['SysStatus'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FaultRecordPosition'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FaultNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['Standard'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF2 or data_cfg_bare[pos] != 0xF2:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['ChannelNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChNum_Alg'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChNum_Dgt'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF3 or data_cfg_bare[pos] != 0xF3:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['ChannelDescription'] = []
|
|
config_record['ChannelCoefficient'] = []
|
|
for i in range(config_record['ChannelNum']):
|
|
len_str = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
ch_desc = []
|
|
for j in range(0, len_str, 2):
|
|
ch_desc.append(data_cfg_bare[pos + j])
|
|
pos += len_str
|
|
ch_coe = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChannelDescription'].append(bytearray(ch_desc).decode())
|
|
config_record['ChannelCoefficient'].append(ch_coe)
|
|
if data_cfg_bare[pos+1] != 0xF4 or data_cfg_bare[pos] != 0xF4:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['SysFreq'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FreqNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['SampleFreq'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['SamplePoint'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['DataType'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['TimeFactor'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF5 or data_cfg_bare[pos] != 0xF5:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
time_stamp = {
|
|
'year': data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos],
|
|
'month': data_cfg_bare[pos+3] * 0x100 + data_cfg_bare[pos+2],
|
|
'day': data_cfg_bare[pos+5] * 0x100 + data_cfg_bare[pos+4],
|
|
'hour': data_cfg_bare[pos+7] * 0x100 + data_cfg_bare[pos+6],
|
|
'minute': data_cfg_bare[pos+9] * 0x100 + data_cfg_bare[pos+8],
|
|
'second': data_cfg_bare[pos+11] * 0x100 + data_cfg_bare[pos+10] +
|
|
(data_cfg_bare[pos+13] * 0x100 + data_cfg_bare[pos+12]) * 0.001,
|
|
}
|
|
config_record['StartTime'] = time_stamp
|
|
pos += 14
|
|
time_stamp = {
|
|
'year': data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos],
|
|
'month': data_cfg_bare[pos+3] * 0x100 + data_cfg_bare[pos+2],
|
|
'day': data_cfg_bare[pos+5] * 0x100 + data_cfg_bare[pos+4],
|
|
'hour': data_cfg_bare[pos+7] * 0x100 + data_cfg_bare[pos+6],
|
|
'minute': data_cfg_bare[pos+9] * 0x100 + data_cfg_bare[pos+8],
|
|
'second': data_cfg_bare[pos+11] * 0x100 + data_cfg_bare[pos+10] +
|
|
(data_cfg_bare[pos+13] * 0x100 + data_cfg_bare[pos+12]) * 0.001,
|
|
}
|
|
config_record['TriggerTime'] = time_stamp
|
|
self.log['record']['config'] = config_record
|
|
self.log['record']['bare_config'] = data_cfg_bare
|
|
|
|
# 处理录波数据
|
|
data_record_bare = b"".join([x['data'] for x in frame_data_record])
|
|
data_record = []
|
|
pos = 0
|
|
while pos < len(data_record_bare):
|
|
record_point = {
|
|
'index': data_record_bare[pos+3] * 0x1000 +
|
|
data_record_bare[pos+2] * 0x100 +
|
|
data_record_bare[pos+1] * 0x10 +
|
|
data_record_bare[pos],
|
|
'timestamp': data_record_bare[pos+7] * 0x1000 +
|
|
data_record_bare[pos+6] * 0x100 +
|
|
data_record_bare[pos+5] * 0x10 +
|
|
data_record_bare[pos + 4],
|
|
'ChAlg': [],
|
|
'ChDgt': [],
|
|
}
|
|
pos += 8
|
|
for i in range(config_record['ChNum_Alg']):
|
|
point_data_alg = data_record_bare[pos+1] * 0x100 + data_record_bare[pos]
|
|
if data_record_bare[pos+1] & 0x80:
|
|
point_data_alg -= 0x10000
|
|
record_point['ChAlg'].append(point_data_alg)
|
|
pos += 2
|
|
for i in range(config_record['ChNum_Dgt']):
|
|
point_data_dgt = (data_record_bare[pos+(i // 8)] & (0x01 << (i % 8))) == (0x01 << (i % 8))
|
|
record_point['ChDgt'].append(point_data_dgt)
|
|
pos += 2
|
|
data_record.append(record_point)
|
|
|
|
self.log['record']['data'] = data_record
|
|
self.log['record']['bare_data'] = data_record_bare
|
|
|
|
return True
|
|
|
|
def frame_update(self, path_bin: Path, makefile: bool = False) -> bool:
|
|
""" 程序升级
|
|
注意: 在使用单板升级测试时, 需要关闭低电压检测功能, 否则无法启动升级流程;
|
|
"""
|
|
if makefile:
|
|
self.block['data']['file'], file_bin = GeneratePackage_DLSP001_p280039(path_bin)
|
|
else:
|
|
self.block['data']['file'] = path_bin.read_bytes()
|
|
self.block['data']['header_offset'] = 184
|
|
self.block['data']['type'] = 'update'
|
|
param_saved = self.flag_print, self.retry, self.time_out
|
|
self.retry = 5
|
|
self.time_out = 0.5
|
|
self.flag_print = False
|
|
|
|
# 启动帧
|
|
self.block['data']['step'] = 'start'
|
|
self.block['data']['index'] = 0
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print('Upgrade Fail: start')
|
|
return False
|
|
self.block["data"]['file_block_size'] = self.output['upgrade']['length']
|
|
|
|
# 避免接收到延迟返回报文
|
|
time.sleep(self.time_out)
|
|
|
|
# 文件传输
|
|
self.retry = 3
|
|
self.time_out = 1.5
|
|
self.block["data"]['step'] = 'trans'
|
|
self.block['data']['index'] = 0
|
|
frame_total = ceil((len(self.block["data"]['file']) - self.block['data']['header_offset']) / self.block["data"]['file_block_size'])
|
|
for idx in tqdm(range(frame_total), desc="File Transmitting"):
|
|
self.block["data"]['index'] = idx
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print(f'Upgrade Fail: trans data in {idx}')
|
|
return False
|
|
|
|
# 结束升级
|
|
self.time_out = 1
|
|
self.block["data"]['step'] = 'end'
|
|
self.block["data"]['index'] += 1
|
|
frame_master = function.protocols.make_frame_modbus(self.block['data'])
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print(f'Upgrade Fail: end')
|
|
return False
|
|
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
return True
|
|
|
|
|
|
class LaminaController_new(DeviceSerial):
|
|
""" 叠光控制器
|
|
"""
|
|
def __init__(self, com_name="COM16", addr_modbus=0x01, type_dev='DLSP001', **kwargs):
|
|
""" 调用超类实现函数初始化 """
|
|
super().__init__(com_name,
|
|
callbacks=(lambda : protocols.make_frame_modbus(self.block),
|
|
lambda frame: protocols.check_frame_modbus(frame, self.block)),
|
|
**kwargs)
|
|
|
|
self.device = type_dev
|
|
match type_dev:
|
|
case 'DLSP001':
|
|
self.make_package = lambda *args, **kwargs: GeneratePackage('DLSP001', *args, **kwargs)
|
|
self.make_image = lambda *args, **kwargs: GenerateImage('DLSP001', *args, **kwargs)
|
|
case _:
|
|
self.make_package = None
|
|
self.make_image = None
|
|
|
|
self.block = {
|
|
'addr_dev' : addr_modbus,
|
|
'data_define': ParamMap_LaminaController,
|
|
}
|
|
|
|
def frame_read(self, daddr=0x60, dlen=0x30) -> bool:
|
|
self.block['type'] = 'read'
|
|
self.block['data_addr'] = daddr
|
|
self.block['data_len'] = dlen
|
|
return self._transfer_data()
|
|
|
|
def frame_write_one(self, daddr=0x85, dval=-900) -> bool:
|
|
self.block['type'] = 'write_one'
|
|
self.block['data_addr'] = daddr
|
|
item_coff = self.block['data_define'][daddr][2] if len(self.block['data_define'][daddr]) > 2 else 1
|
|
self.block['data_val'] = int(dval * item_coff)
|
|
return self._transfer_data()
|
|
|
|
def frame_write_dual(self, daddr=0x91, dval=600) -> bool:
|
|
self.block['type'] = 'write_dual'
|
|
self.block['data_addr'] = daddr
|
|
item_coff = self.block['data_define'][daddr][2] if len(self.block['data_define'][daddr]) > 2 else 1
|
|
self.block['data_val'] = int(dval * item_coff)
|
|
return self._transfer_data()
|
|
|
|
def frame_write_str(self, daddr=0x82, dval=[0x06, 0x05, 0x04, 0x03, 0x02, 0x01]) -> bool:
|
|
self.block['type'] = 'write_str'
|
|
self.block['data_addr'] = daddr
|
|
self.block['data_val'] = dval
|
|
return self._transfer_data()
|
|
|
|
def frame_record(self) -> bool:
|
|
""" 读取录波数据
|
|
"""
|
|
param_saved = self.flag_print, self.retry, self.time_out
|
|
self.flag_print = False
|
|
self.retry = 3
|
|
self.time_out = 1.5
|
|
self.block['file_block_size'] = 240
|
|
# 读取config
|
|
self.block['type'] = 'record_cfg'
|
|
self.block['step'] = 'start'
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
|
|
ret, pbar = True, None
|
|
frame_data_cfg = []
|
|
while ret:
|
|
if ret := self.__transfer_data(frame_master):
|
|
frame_data_cfg.append(self.output['record'])
|
|
if self.output['record']['seq'] == 0:
|
|
pbar = tqdm(total=self.output['record']['total'] + 1, desc="Record Config Reading")
|
|
self.block['step'] = 'next'
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
elif (self.output['record']['seq']) >= self.output['record']['total']:
|
|
ret = False
|
|
pbar and pbar.update()
|
|
pbar and pbar.close()
|
|
|
|
# 读取data
|
|
self.block['type'] = 'record_data'
|
|
self.block['step'] = 'start'
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
|
|
ret, pbar = True, None
|
|
frame_data_record = []
|
|
while ret:
|
|
if ret := self.__transfer_data(frame_master):
|
|
frame_data_record.append(self.output['record'])
|
|
if self.output['record']['seq'] == 0:
|
|
pbar = tqdm(total=self.output['record']['total'] + 1, desc="Record Data Reading")
|
|
self.block['step'] = 'next'
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
elif (self.output['record']['seq']) >= self.output['record']['total']:
|
|
ret = False
|
|
pbar and pbar.update()
|
|
pbar and pbar.close()
|
|
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
if (len(frame_data_record) != 32) or (len(frame_data_cfg) != 3):
|
|
print("Operation_Record: 未取得录波数据.")
|
|
return False
|
|
|
|
# 处理配置信息
|
|
data_cfg_bare = b"".join([x['data'] for x in frame_data_cfg])
|
|
config_record = {'LinePos': []}
|
|
pos = 0
|
|
if data_cfg_bare[pos+1] != 0xF1 or data_cfg_bare[pos] != 0xF1:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
len_faultword = (data_cfg_bare[3] * 0x100 + data_cfg_bare[2])
|
|
pos += 2
|
|
config_record['FaultWord'] = []
|
|
for i in range(0, len_faultword, 2):
|
|
faultword = data_cfg_bare[pos+i+1] * 0x100 + data_cfg_bare[pos+i]
|
|
config_record['FaultWord'].append(faultword)
|
|
pos += len_faultword
|
|
config_record['SysStatus'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FaultRecordPosition'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FaultNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['Standard'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF2 or data_cfg_bare[pos] != 0xF2:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['ChannelNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChNum_Alg'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChNum_Dgt'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF3 or data_cfg_bare[pos] != 0xF3:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['ChannelDescription'] = []
|
|
config_record['ChannelCoefficient'] = []
|
|
for i in range(config_record['ChannelNum']):
|
|
len_str = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
ch_desc = []
|
|
for j in range(0, len_str, 2):
|
|
ch_desc.append(data_cfg_bare[pos + j])
|
|
pos += len_str
|
|
ch_coe = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['ChannelDescription'].append(bytearray(ch_desc).decode())
|
|
config_record['ChannelCoefficient'].append(ch_coe)
|
|
if data_cfg_bare[pos+1] != 0xF4 or data_cfg_bare[pos] != 0xF4:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
config_record['SysFreq'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['FreqNum'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['SampleFreq'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['SamplePoint'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['DataType'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
config_record['TimeFactor'] = data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos]
|
|
pos += 2
|
|
if data_cfg_bare[pos+1] != 0xF5 or data_cfg_bare[pos] != 0xF5:
|
|
Warning("config 配置文件格式异常")
|
|
pos += 2
|
|
config_record['LinePos'].append(pos)
|
|
time_stamp = {
|
|
'year': data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos],
|
|
'month': data_cfg_bare[pos+3] * 0x100 + data_cfg_bare[pos+2],
|
|
'day': data_cfg_bare[pos+5] * 0x100 + data_cfg_bare[pos+4],
|
|
'hour': data_cfg_bare[pos+7] * 0x100 + data_cfg_bare[pos+6],
|
|
'minute': data_cfg_bare[pos+9] * 0x100 + data_cfg_bare[pos+8],
|
|
'second': data_cfg_bare[pos+11] * 0x100 + data_cfg_bare[pos+10] +
|
|
(data_cfg_bare[pos+13] * 0x100 + data_cfg_bare[pos+12]) * 0.001,
|
|
}
|
|
config_record['StartTime'] = time_stamp
|
|
pos += 14
|
|
time_stamp = {
|
|
'year': data_cfg_bare[pos+1] * 0x100 + data_cfg_bare[pos],
|
|
'month': data_cfg_bare[pos+3] * 0x100 + data_cfg_bare[pos+2],
|
|
'day': data_cfg_bare[pos+5] * 0x100 + data_cfg_bare[pos+4],
|
|
'hour': data_cfg_bare[pos+7] * 0x100 + data_cfg_bare[pos+6],
|
|
'minute': data_cfg_bare[pos+9] * 0x100 + data_cfg_bare[pos+8],
|
|
'second': data_cfg_bare[pos+11] * 0x100 + data_cfg_bare[pos+10] +
|
|
(data_cfg_bare[pos+13] * 0x100 + data_cfg_bare[pos+12]) * 0.001,
|
|
}
|
|
config_record['TriggerTime'] = time_stamp
|
|
self.log['record']['config'] = config_record
|
|
self.log['record']['bare_config'] = data_cfg_bare
|
|
|
|
# 处理录波数据
|
|
data_record_bare = b"".join([x['data'] for x in frame_data_record])
|
|
data_record = []
|
|
pos = 0
|
|
while pos < len(data_record_bare):
|
|
record_point = {
|
|
'index': data_record_bare[pos+3] * 0x1000 +
|
|
data_record_bare[pos+2] * 0x100 +
|
|
data_record_bare[pos+1] * 0x10 +
|
|
data_record_bare[pos],
|
|
'timestamp': data_record_bare[pos+7] * 0x1000 +
|
|
data_record_bare[pos+6] * 0x100 +
|
|
data_record_bare[pos+5] * 0x10 +
|
|
data_record_bare[pos + 4],
|
|
'ChAlg': [],
|
|
'ChDgt': [],
|
|
}
|
|
pos += 8
|
|
for i in range(config_record['ChNum_Alg']):
|
|
point_data_alg = data_record_bare[pos+1] * 0x100 + data_record_bare[pos]
|
|
if data_record_bare[pos+1] & 0x80:
|
|
point_data_alg -= 0x10000
|
|
record_point['ChAlg'].append(point_data_alg)
|
|
pos += 2
|
|
for i in range(config_record['ChNum_Dgt']):
|
|
point_data_dgt = (data_record_bare[pos+(i // 8)] & (0x01 << (i % 8))) == (0x01 << (i % 8))
|
|
record_point['ChDgt'].append(point_data_dgt)
|
|
pos += 2
|
|
data_record.append(record_point)
|
|
|
|
self.log['record']['data'] = data_record
|
|
self.log['record']['bare_data'] = data_record_bare
|
|
|
|
return True
|
|
|
|
def frame_update(self, path_bin: Path, makefile: bool = False) -> bool:
|
|
""" 程序升级
|
|
注意: 在使用单板升级测试时, 需要关闭低电压检测功能, 否则无法启动升级流程;
|
|
"""
|
|
if makefile:
|
|
self.block['file'], file_bin = GeneratePackage_DLSP001_p280039(path_bin)
|
|
else:
|
|
self.block['file'] = path_bin.read_bytes()
|
|
self.block['header_offset'] = 184
|
|
self.block['type'] = 'update'
|
|
param_saved = self.flag_print, self.retry, self.time_out
|
|
self.retry = 5
|
|
self.time_out = 0.5
|
|
self.flag_print = False
|
|
|
|
# 启动帧
|
|
self.block['step'] = 'start'
|
|
self.block['index'] = 0
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print('Upgrade Fail: start')
|
|
return False
|
|
self.block["data"]['file_block_size'] = self.output['upgrade']['length']
|
|
|
|
# 避免接收到延迟返回报文
|
|
time.sleep(self.time_out)
|
|
|
|
# 文件传输
|
|
self.retry = 3
|
|
self.time_out = 1.5
|
|
self.block["data"]['step'] = 'trans'
|
|
self.block['index'] = 0
|
|
frame_total = ceil((len(self.block["data"]['file']) - self.block['header_offset']) / self.block["data"]['file_block_size'])
|
|
for idx in tqdm(range(frame_total), desc="File Transmitting"):
|
|
self.block["data"]['index'] = idx
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print(f'Upgrade Fail: trans data in {idx}')
|
|
return False
|
|
|
|
# 结束升级
|
|
self.time_out = 1
|
|
self.block["data"]['step'] = 'end'
|
|
self.block["data"]['index'] += 1
|
|
frame_master = function.protocols.make_frame_modbus(self.block)
|
|
if not self.__transfer_data(frame_master):
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
print(f'Upgrade Fail: end')
|
|
return False
|
|
|
|
self.flag_print, self.retry, self.time_out = param_saved
|
|
return True
|
|
|
|
|
|
def GeneratePackage(type_dev: str, path_hex: Path, **kwargs) -> bytearray:
|
|
""" 生成升级包 """
|
|
config = {
|
|
'prod_type': [0x46, 0x00], # 产品类型
|
|
'method_compress': False, # 文件压缩
|
|
'prog_id': list(type_dev.encode('ascii')), # 程序识别号
|
|
'prog_type': 'app', # 程序类型
|
|
'area_code': [0x00, 0x00], # 地区
|
|
'upgrade_type': [0x00, 0x00], # 升级方式(0-片外缓冲, 1-片内缓冲, 2-升级备份)
|
|
}
|
|
match type_dev:
|
|
case 'DLSP001':
|
|
MemoryMap = MemoryMap_280039
|
|
case _:
|
|
raise Exception("Unknow device.")
|
|
|
|
bin_main = IntelHex.file_IntelHex_to_Bin(path_hex.read_text(), len_max=MemoryMap['app_size'], conv_end=False)
|
|
encrypt_main = file_upgrade.file_encryption(bin_main)
|
|
|
|
info_version = file_upgrade.parser_version_info(bin_main, 0x88000)
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_main)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['file_length'] = ByteConv.conv_int_to_array(len(bin_main))
|
|
config['hex_name'] = list(info_version['name'])[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (main_header:=file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
print("Package generated successfully.")
|
|
print(f"File name: {path_hex.name}")
|
|
print(f"File Info:")
|
|
print(f"\t header_length={len(main_header)}, bin_length={len(bin_main)}[{hex(len(bin_main))}]")
|
|
|
|
# 组装镜像
|
|
Image = [0xFF] * (len(main_header) + len(encrypt_main))
|
|
offset_image = 0
|
|
Image[offset_image: offset_image + len(main_header)] = main_header
|
|
offset_image += len(main_header)
|
|
Image[offset_image: offset_image + len(encrypt_main)] = encrypt_main
|
|
|
|
return bytearray(Image)
|
|
|
|
|
|
def GenerateImage(type_dev: str, path_boot: Path, path_main: Path, path_back: Path, **kwargs) ->bytearray:
|
|
""" 镜像生成 """
|
|
config = {
|
|
'prod_type': [0x46, 0x00], # 产品类型
|
|
'method_compress': False, # 文件压缩
|
|
'prog_id': list(type_dev.encode('ascii')), # 程序识别号
|
|
'prog_type': 'app', # 程序类型
|
|
'area_code': [0x00, 0x00], # 地区
|
|
'upgrade_type': [0x00, 0x00], # 升级方式(0-片外缓冲, 1-片内缓冲, 2-升级备份)
|
|
}
|
|
match type_dev:
|
|
case 'DLSP001':
|
|
MemoryMap = MemoryMap_280039
|
|
case _:
|
|
raise Exception("Unknow device.")
|
|
|
|
bin_boot = IntelHex.file_IntelHex_to_Bin(path_boot.read_text(), len_max=MemoryMap['boot_size'], conv_end=False)
|
|
bin_main = IntelHex.file_IntelHex_to_Bin(path_main.read_text(), len_max=MemoryMap['app_size'], conv_end=False)
|
|
bin_back = IntelHex.file_IntelHex_to_Bin(path_back.read_text(), len_max=MemoryMap['app_size'], conv_end=False)
|
|
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_main)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['upgrade_type'] = [0x00, 0x00] # 主程序-片外缓冲
|
|
config['file_length'] = ByteConv.conv_int_to_array(len(bin_main))
|
|
config['hex_name'] = list(path_main.name.encode())[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (main_header:=file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_back)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['upgrade_type'] = [0x02, 0x00] # 备份程序
|
|
config['file_length'] = ByteConv.conv_int_to_array(len(bin_back))
|
|
config['hex_name'] = list(path_back.name.encode())[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (back_header:=file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
# 组装镜像
|
|
main_header_buffer = bytearray()
|
|
back_header_buffer = bytearray()
|
|
for byte_org in main_header:
|
|
main_header_buffer.extend(bytearray([0x00, byte_org]))
|
|
for byte_org in back_header:
|
|
back_header_buffer.extend(bytearray([0x00, byte_org]))
|
|
Image = [0xFF] * MemoryMap['image_size']
|
|
Image[MemoryMap['boot_addr']: MemoryMap['boot_addr'] + len(bin_boot)] = bin_boot
|
|
Image[MemoryMap['main_addr']: MemoryMap['main_addr'] + len(main_header_buffer)] = main_header_buffer
|
|
Image[MemoryMap['back_addr']: MemoryMap['back_addr'] + len(back_header_buffer)] = back_header_buffer
|
|
Image[MemoryMap['main_header']: MemoryMap['main_header'] + len(bin_main)] = bin_main
|
|
Image[MemoryMap['back_header']: MemoryMap['back_header'] + len(bin_back)] = bin_back
|
|
|
|
# Log打印
|
|
print("Merge Image generated successfully.")
|
|
print(f"Main File:")
|
|
print(f"\t header_length={len(main_header)}, bin_length={len(bin_main)}[{hex(len(bin_main))}]")
|
|
print(f"Back File:")
|
|
print(f"\t header_length={len(back_header)}, bin_length={len(bin_back)}[{hex(len(bin_back))}]")
|
|
|
|
# 额外文件
|
|
if 'output_header' in kwargs.keys() and kwargs['output_header']:
|
|
(path_main.parent / (path_main.stem + '.header')).write_bytes(main_header)
|
|
(path_back.parent / (path_back.stem + '.header')).write_bytes(back_header)
|
|
if 'output_bin' in kwargs.keys() and kwargs['output_bin']:
|
|
(path_main.parent / (path_main.stem + '.bin')).write_bytes(bin_main)
|
|
(path_back.parent / (path_back.stem + '.bin')).write_bytes(bin_back)
|
|
if 'output_encrypt' in kwargs.keys() and kwargs['output_encrypt']:
|
|
main_encrypt = file_upgrade.file_encryption(bin_main)
|
|
back_encrypt = file_upgrade.file_encryption(bin_back)
|
|
(path_main.parent / (path_main.stem + '.encrypt')).write_bytes(main_encrypt)
|
|
(path_back.parent / (path_back.stem + '.encrypt')).write_bytes(back_encrypt)
|
|
|
|
return bytearray(Image)
|
|
|
|
|
|
def GeneratePackage_DLSP001_p280039(path_hex: Path):
|
|
""" 叠光控制器DSP-280039平台版本 生成升级包 """
|
|
config = {
|
|
'prod_type': [0x46, 0x00], # 产品类型
|
|
'method_compress': False, # 文件压缩
|
|
'prog_id': list(b"DLSP001"), # 程序识别号
|
|
'prog_type': 'app', # 程序类型
|
|
'area_code': [0x00, 0x00], # 地区
|
|
'upgrade_type': [0x00, 0x00], # 升级方式(0-片外缓冲, 1-片内缓冲, 2-升级备份)
|
|
}
|
|
|
|
bin_main = tools.IntelHex.file_IntelHex_to_Bin(path_hex.read_text(), len_max=2 * 0x014000, conv_end=False)
|
|
encrypt_main = function.file_upgrade.file_encryption(bin_main)
|
|
|
|
info_version = function.file_upgrade.parser_version_info(bin_main, 0x88000)
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_main)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['file_length'] = tools.ByteConv.conv_int_to_array(len(bin_main))
|
|
config['hex_name'] = list(info_version['name'])[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (main_header:=function.file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
print("Package generated successfully.")
|
|
print(f"File name: {path_hex.name}")
|
|
print(f"File Info:")
|
|
print(f"\t header_length={len(main_header)}, bin_length={len(bin_main)}[{hex(len(bin_main))}]")
|
|
|
|
# 组装镜像
|
|
Image = [0xFF] * (len(main_header) + len(encrypt_main))
|
|
offset_image = 0
|
|
Image[offset_image: offset_image + len(main_header)] = main_header
|
|
offset_image += len(main_header)
|
|
Image[offset_image: offset_image + len(encrypt_main)] = encrypt_main
|
|
|
|
return bytearray(Image), bin_main
|
|
|
|
|
|
def GenerateImage_DLSP001_p280039(path_boot: Path, path_main: Path, path_back: Path):
|
|
""" 叠光适配器-460平台版本 镜像生成 """
|
|
config = {
|
|
'prod_type': [0x46, 0x00], # 产品类型
|
|
'method_compress': False, # 文件压缩
|
|
'prog_id': list(b"DLSP001"), # 程序识别号
|
|
'prog_type': 'app', # 程序类型
|
|
'area_code': [0x00, 0x00], # 地区
|
|
'upgrade_type': [0x00, 0x00], # 升级方式(0-片外缓冲, 1-片内缓冲, 2-升级备份)
|
|
}
|
|
|
|
bin_boot = tools.IntelHex.file_IntelHex_to_Bin(path_boot.read_text(), len_max=2 * 0x004000, conv_end=False)
|
|
bin_main = tools.IntelHex.file_IntelHex_to_Bin(path_main.read_text(), len_max=2 * 0x014000, conv_end=False)
|
|
bin_back = tools.IntelHex.file_IntelHex_to_Bin(path_back.read_text(), len_max=2 * 0x014000, conv_end=False)
|
|
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_main)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['upgrade_type'] = [0x00, 0x00] # 主程序-片外缓冲
|
|
config['file_length'] = tools.ByteConv.conv_int_to_array(len(bin_main))
|
|
config['hex_name'] = list(path_main.name.encode())[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (main_header:=function.file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
md5_ctx = hashlib.md5()
|
|
md5_ctx.update(bin_back)
|
|
config["md5"] = list(md5_ctx.digest())
|
|
config['upgrade_type'] = [0x02, 0x00] # 备份程序
|
|
config['file_length'] = tools.ByteConv.conv_int_to_array(len(bin_back))
|
|
config['hex_name'] = list(path_back.name.encode())[:64]
|
|
config['hex_name'] += [0] * (64 - len(config['hex_name']))
|
|
if (back_header:=function.file_upgrade.build_header_new(config)) is None:
|
|
raise Exception("Header tag oversize. ")
|
|
|
|
main_header_buffer = bytearray()
|
|
for byte_org in main_header:
|
|
main_header_buffer.extend(bytearray([0x00, byte_org]))
|
|
back_header_buffer = bytearray()
|
|
for byte_org in back_header:
|
|
back_header_buffer.extend(bytearray([0x00, byte_org]))
|
|
main_encrypt = function.file_upgrade.file_encryption(bin_main)
|
|
back_encrypt = function.file_upgrade.file_encryption(bin_back)
|
|
|
|
print("Merge Image generated successfully.")
|
|
print(f"Main File:")
|
|
print(f"\t header_length={len(main_header)}, bin_length={len(bin_main)}[{hex(len(bin_main))}]")
|
|
print(f"Back File:")
|
|
print(f"\t header_length={len(back_header)}, bin_length={len(bin_back)}[{hex(len(bin_back))}]")
|
|
|
|
# 组装镜像
|
|
Image = [0xFF] * 2 * 0x030000
|
|
offset_image = 0
|
|
Image[offset_image: offset_image + len(bin_boot)] = bin_boot
|
|
offset_image = 2 * 0x006000
|
|
Image[offset_image: offset_image + len(main_header_buffer)] = main_header_buffer
|
|
offset_image = 2 * 0x007000
|
|
Image[offset_image: offset_image + len(back_header_buffer)] = back_header_buffer
|
|
offset_image = 2 * 0x008000
|
|
Image[offset_image: offset_image + len(bin_main)] = bin_main
|
|
offset_image = 2 * 0x01C000
|
|
Image[offset_image: offset_image + len(bin_back)] = bin_back
|
|
|
|
return bytearray(Image), main_header, back_header
|
|
|