315 lines
9.5 KiB
Python
315 lines
9.5 KiB
Python
# cpydaq模块使用示例
|
|
import gc
|
|
import pyb
|
|
import cpydaq
|
|
import time
|
|
import urandom
|
|
|
|
CPY_PROT_CMD_HEARTBEAT = 0x01
|
|
CPY_PROT_CMD_VERSION = 0x02
|
|
CPY_PROT_CMD_PARAM_READ = 0x03
|
|
CPY_PROT_CMD_PARAM_WRITE = 0x04
|
|
CPY_PROT_CMD_SAMPLE_LEN = 0x05
|
|
CPY_PROT_CMD_SAMPLE_DATA = 0x06
|
|
CPY_PROT_CMD_IAP = 0x07
|
|
CPY_PROT_CMD_BOOT_BLOCKING = 0x08
|
|
CPY_PROT_CMD_JUMP_APP = 0x09
|
|
CPY_PROT_CMD_RESET = 0x0A
|
|
CPY_PROT_CMD_OTP_READ = 0x0B
|
|
CPY_PROT_CMD_OTP_WRITE = 0x0C
|
|
CPY_PROT_CMD_RESET_FACTORY = 0x0D
|
|
|
|
CPY_PROT_CMD_ACK = 0x80
|
|
CPY_PROT_CMD_ERROR = 0xC0
|
|
|
|
max_packet_len = 16 * 1024
|
|
|
|
relay_pin = pyb.Pin(pyb.Pin.cpu.E1, pyb.Pin.OUT)
|
|
sample_pin = pyb.Pin(pyb.Pin.cpu.E0, pyb.Pin.OUT)
|
|
pwr_pin = pyb.Pin(pyb.Pin.cpu.C11, pyb.Pin.OUT)
|
|
|
|
relay_pin.value(1)
|
|
sample_pin.value(1)
|
|
pwr_pin.value(0)
|
|
|
|
def daq_set_relay(state):
|
|
if state:
|
|
relay_pin.value(0)
|
|
else:
|
|
relay_pin.value(1)
|
|
|
|
def daq_set_sample(state):
|
|
if state:
|
|
sample_pin.value(0)
|
|
else:
|
|
sample_pin.value(1)
|
|
|
|
def daq_set_power(state):
|
|
if state:
|
|
pwr_pin.value(0)
|
|
else:
|
|
pwr_pin.value(1)
|
|
|
|
def daq_sample_by_time(timeout=1000):
|
|
daq_set_sample(True)
|
|
time.sleep_ms(timeout)
|
|
daq_set_sample(False)
|
|
|
|
def daq_init():
|
|
cpydaq.init(max_packet_len)
|
|
|
|
def daq_check_recv(timeout):
|
|
start_time = time.ticks_ms()
|
|
while True:
|
|
time.sleep_ms(2)
|
|
response = cpydaq.check_recv()
|
|
if response is not None:
|
|
return response
|
|
if time.ticks_ms() > timeout + start_time:
|
|
return None
|
|
|
|
def daq_exec_cmd(cmd, data=None, timeout=1000):
|
|
# 完全重写函数,确保不使用任何可能导致关键字参数混淆的语法
|
|
if data is None:
|
|
send_data = b"\x00\x00\x00\x00"
|
|
else:
|
|
send_data = data
|
|
# 调用cpydaq.start_recv() - 不传递任何参数
|
|
cpydaq.start_recv()
|
|
# 调用cpydaq.send_packet() - 只传递位置参数
|
|
cpydaq.send_packet(cmd, send_data)
|
|
# 调用daq_check_recv() - 只传递位置参数
|
|
response = daq_check_recv(timeout)
|
|
|
|
return response
|
|
|
|
def daq_read_version(timeout=100):
|
|
response = daq_exec_cmd(CPY_PROT_CMD_VERSION, None, timeout)
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_VERSION | CPY_PROT_CMD_ACK:
|
|
ver = recv_data.decode()
|
|
print(ver)
|
|
return ver
|
|
else:
|
|
return None
|
|
|
|
def daq_reset_factory(timeout=100):
|
|
response = daq_exec_cmd(CPY_PROT_CMD_RESET_FACTORY, None, timeout)
|
|
return response
|
|
|
|
def daq_read_param(timeout=100):
|
|
param = {}
|
|
response = daq_exec_cmd(CPY_PROT_CMD_PARAM_READ, None, timeout)
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_PARAM_READ | CPY_PROT_CMD_ACK:
|
|
param["usAdcPeriod"] = int.from_bytes(recv_data[0:2], "little")
|
|
param["usAdcinterval"] = int.from_bytes(recv_data[2:4], "little")
|
|
param["ucUseEncoder"] = recv_data[4]
|
|
param["ucAverageCount"] = recv_data[5]
|
|
return param
|
|
else:
|
|
return None
|
|
|
|
def daq_read_otp(timeout=100):
|
|
info = {}
|
|
response = daq_exec_cmd(CPY_PROT_CMD_OTP_READ, None, timeout)
|
|
if response is None:
|
|
return {}
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_OTP_READ | CPY_PROT_CMD_ACK and len(recv_data) == 96:
|
|
try:
|
|
data = bytearray(recv_data)
|
|
# print(data.hex())
|
|
#去除0x00和0xFF
|
|
for i in range(len(data)):
|
|
if data[i] == 0x00 or data[i] == 0xFF:
|
|
data[i] = 0x20
|
|
info["model"] = data[0:32].decode().strip()
|
|
info["date"] = data[32:64].decode().strip()
|
|
info["sn"] = data[64:96].decode().strip()
|
|
return info
|
|
except:
|
|
return {}
|
|
else:
|
|
return {}
|
|
|
|
def daq_write_otp(info, timeout=100):
|
|
data = bytearray()
|
|
|
|
# 处理model字段
|
|
model_bytes = info["model"].encode()[:32] # 最多32字节
|
|
data.extend(model_bytes)
|
|
data.extend(b"\x00" * (32 - len(model_bytes))) # 不足32字节用0x00填充
|
|
|
|
# 处理date字段
|
|
date_bytes = info["date"].encode()[:32]
|
|
data.extend(date_bytes)
|
|
data.extend(b"\x00" * (32 - len(date_bytes)))
|
|
|
|
# 处理sn字段
|
|
sn_bytes = info["sn"].encode()[:32]
|
|
data.extend(sn_bytes)
|
|
data.extend(b"\x00" * (32 - len(sn_bytes)))
|
|
|
|
# print(data.hex())
|
|
response = daq_exec_cmd(CPY_PROT_CMD_OTP_WRITE, data, timeout)
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_OTP_WRITE | CPY_PROT_CMD_ACK:
|
|
return True
|
|
else:
|
|
print(f"写入OTP失败, 响应: {recv_data.decode()}")
|
|
return False
|
|
|
|
def daq_write_param(param, timeout=100):
|
|
data = bytearray()
|
|
data.extend(param["usAdcPeriod"].to_bytes(2, "little"))
|
|
data.extend(param["usAdcinterval"].to_bytes(2, "little"))
|
|
data.append(param["ucUseEncoder"])
|
|
data.append(param["ucAverageCount"])
|
|
|
|
#打印hex data
|
|
print(f"发送参数:{data.hex()}")
|
|
|
|
response = daq_exec_cmd(CPY_PROT_CMD_PARAM_WRITE, data, timeout)
|
|
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd = response[0]
|
|
if recv_cmd == CPY_PROT_CMD_PARAM_WRITE | CPY_PROT_CMD_ACK:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def daq_set_default_param():
|
|
# 创建参数字典
|
|
param = {}
|
|
param["usAdcPeriod"] = 1000
|
|
param["usAdcinterval"] = 40
|
|
param["ucUseEncoder"] = 1
|
|
param["ucAverageCount"] = 5
|
|
# 明确使用位置参数调用daq_write_param,不使用任何关键字参数
|
|
return daq_write_param(param)
|
|
|
|
def daq_set_timer_sample_param():
|
|
# 创建参数字典
|
|
param = {}
|
|
param["usAdcPeriod"] = 1000
|
|
param["usAdcinterval"] = 40
|
|
param["ucUseEncoder"] = 0
|
|
param["ucAverageCount"] = 5
|
|
# 明确使用位置参数调用daq_write_param,不使用任何关键字参数
|
|
return daq_write_param(param)
|
|
|
|
def daq_otp_test():
|
|
info = {}
|
|
info['model']='TGX-DAQ-01-RS485'
|
|
info['date']='2026/02/28'
|
|
info['sn']='1001'
|
|
daq_write_otp(info)
|
|
info = daq_read_otp()
|
|
print(info)
|
|
|
|
def daq_check_is_online():
|
|
start_time = time.ticks_ms()
|
|
response = daq_exec_cmd(CPY_PROT_CMD_HEARTBEAT, None, 10)
|
|
if response is None:
|
|
print("超时未收到响应")
|
|
return None
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_HEARTBEAT | CPY_PROT_CMD_ACK:
|
|
#recv_data[0:4]表示时间
|
|
#recv_data[4:6]表示温度
|
|
# tim_ms = int.from_bytes(recv_data[0:4], "little")
|
|
temp = int.from_bytes(recv_data[4:6], "little")
|
|
# print(f"时间: {tim_ms}ms, 温度: {temp / 10.0:.1f}°C")
|
|
# print(f'used time {time.ticks_ms() - start_time}ms')
|
|
return temp
|
|
else:
|
|
print(f"收到错误响应: 命令=0x{recv_cmd:02X}, 数据{len(recv_data)}")
|
|
return None
|
|
|
|
def daq_reset():
|
|
response = daq_exec_cmd(CPY_PROT_CMD_RESET, None, 100)
|
|
if response is None:
|
|
print("超时未收到响应")
|
|
return False
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
if recv_cmd == CPY_PROT_CMD_RESET | CPY_PROT_CMD_ACK:
|
|
return True
|
|
else:
|
|
print(f"收到错误响应: 命令=0x{recv_cmd:02X}, 数据{len(recv_data)}")
|
|
return False
|
|
|
|
def daq_blocking_bootloader(block):
|
|
data = bytearray()
|
|
if block:
|
|
data.append(0x01)
|
|
else:
|
|
data.append(0x00)
|
|
response = daq_exec_cmd(CPY_PROT_CMD_BOOT_BLOCKING, data, 100)
|
|
if response is None:
|
|
return False
|
|
else:
|
|
recv_cmd = response[0]
|
|
if recv_cmd == CPY_PROT_CMD_BOOT_BLOCKING | CPY_PROT_CMD_ACK:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def daq_get_sample_len(timeout=100):
|
|
response = daq_exec_cmd(CPY_PROT_CMD_SAMPLE_LEN, None, timeout)
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd = response[0]
|
|
if recv_cmd == CPY_PROT_CMD_SAMPLE_LEN | CPY_PROT_CMD_ACK:
|
|
return int.from_bytes(response[1][0:2], "little")
|
|
else:
|
|
return None
|
|
|
|
def daq_get_sample_data(timeout=100):
|
|
response = daq_exec_cmd(CPY_PROT_CMD_SAMPLE_DATA, None, timeout)
|
|
if response is None:
|
|
return None
|
|
else:
|
|
recv_cmd = response[0]
|
|
if recv_cmd == CPY_PROT_CMD_SAMPLE_DATA | CPY_PROT_CMD_ACK:
|
|
return response[1]
|
|
else:
|
|
return None
|
|
|
|
#压力测试
|
|
def daq_pressure_test():
|
|
count = 0
|
|
for i in range(1000):
|
|
payload_len = i + 1
|
|
payload = bytes([urandom.randint(0, 255) for _ in range(payload_len)])
|
|
|
|
response = daq_exec_cmd(CPY_PROT_CMD_HEARTBEAT, payload)
|
|
|
|
if response is None:
|
|
break
|
|
else:
|
|
recv_cmd, recv_data = response
|
|
#print(f"接收成功: 命令=0x{recv_cmd:02X}, 数据{len(recv_data)}")
|
|
count += 1
|
|
|
|
#手动触发垃圾回收
|
|
gc.collect()
|
|
gc.collect()
|
|
print(f"发送{i + 1}条心跳包 成功接收{count}条响应")
|
|
|