gitea/AIO
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完善耐久采集

Browse Source
This commit is contained in:
gitea
2025-04-07 10:38:59 +08:00
parent 671db5b1db
commit 6e547ca6a3
16 changed files with 341 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
codes/common/clibs.py
View File

@ -1,5 +1,6 @@
import os
import os.path
import time
import threading
import sqlite3
from PySide6.QtCore import Signal, QThread
@ -82,19 +83,41 @@ class LoggerHandler(QThread):
raise Exception()
def detect_db_size():
@db_lock
def release_memory():
line_number = 20000
leftover = 4000 # 200s
cursor.execute("SELECT COUNT(id) FROM logs")
len_records = cursor.fetchone()[0]
if len_records > line_number:
del_num = len_records - leftover + 1
cursor.execute(f"DELETE FROM logs WHERE id < {del_num}")
cursor.execute(f"UPDATE logs SET id=(id-{del_num - 1}) WHERE id > {del_num - 1}")
cursor.execute(f"UPDATE sqlite_sequence SET seq = {leftover + 1} WHERE name = 'logs' ")
cursor.execute("VACUUM")
while True:
release_memory()
time.sleep(INTERVAL*10)
PREFIX = "resources/assets" # for pyinstaller
# PREFIX = "assets" # for local testing
log_path = f"{PREFIX}/logs"
# log_path = f"{PREFIX}/logs"
lock = threading.Lock()
running = [0, 0, 0, 0, 0, 0, 0] # 制动数据/转矩数据/激光数据/精度数据/制动自动化/转矩自动化/耐久数据采集
stop_flag = False
functions = ["制动数据处理", "转矩数据处理", "激光数据处理", "精度数据处理", "制动自动化测试", "转矩自动化测试", "耐久数据采集"]
levels = ["DEBUG", "INFO", "WARNING", "ERROR"]
ip_addr, ssh_port, socket_port, xService_port, external_port, modbus_port, upgrade_port = "", 22, 5050, 6666, 8080, 502, 4567
username, password = "luoshi", "luoshi2019"
INTERVAL, RADIAN, MAX_FRAME_SIZE, MAX_LOG_NUMBER, CYCLE = 1, 57.3, 1024, 10, 300
username, password = "luoshi", "123456"
INTERVAL, RADIAN, MAX_FRAME_SIZE, MAX_LOG_NUMBER, CYCLE = 1, 57.3, 1024, 10, 30
c_md, c_hr, c_ec, c_pd, conn, cursor, search_records, logger, count = None, None, None, None, None, None, None, None, 0
status = {"mysql": 0, "hmi": 0, "md": 0, "ec": 0}
c_joint_vel, c_servo_trq, c_sensor_trq, c_estimate_trans_trq, c_safety_estop = 1, 2, 3, 4, 3 # 各个指标所在列
init_logdb()
t = threading.Thread(target=detect_db_size)
t.daemon = True
t.start()

166
codes/common/openapi.py
View File

@ -21,20 +21,19 @@ class ModbusRequest(QThread):
self.ip = ip
self.port = port
self.c = None
self.logger = clibs.logger
def net_conn(self):
self.logger("INFO", "openapi", f"Modbus 正在连接中，需要配置设备，这可能需要一点时间......", "blue")
clibs.logger("INFO", "openapi", f"Modbus 正在连接中，需要配置设备，这可能需要一点时间......", "blue")
RobotInit.modbus_init()
self.c = ModbusTcpClient(host=self.ip, port=self.port)
if self.c.connect():
self.logger("INFO", "openapi", f"Modbus connection({clibs.ip_addr}:{clibs.modbus_port}) success!", "green")
clibs.logger("INFO", "openapi", f"Modbus connection({clibs.ip_addr}:{clibs.modbus_port}) success!", "green")
else:
self.logger("ERROR", "openapi", f"Modbus connection({clibs.ip_addr}:{clibs.modbus_port}) failed!", "red")
clibs.logger("ERROR", "openapi", f"Modbus connection({clibs.ip_addr}:{clibs.modbus_port}) failed!", "red")
def close(self):
self.c.close()
self.logger("INFO", "openapi", f"modbus: 关闭 Modbus 连接成功", "green")
clibs.logger("INFO", "openapi", f"modbus: 关闭 Modbus 连接成功", "green")
def __reg_high_pulse(self, addr: int) -> None:
self.c.write_register(addr, 0)
@ -45,71 +44,71 @@ class ModbusRequest(QThread):
def r_clear_alarm(self): # OK
self.__reg_high_pulse(40000)
self.logger("DEBUG", "openapi", "modbus: 40000-010 执行清除告警信息")
clibs.logger("DEBUG", "openapi", "modbus: 40000-010 执行清除告警信息")
def r_reset_estop(self): # OK
self.__reg_high_pulse(40001)
self.logger("DEBUG", "openapi", "modbus: 40001-010 执行复位急停状态(非软急停)")
clibs.logger("DEBUG", "openapi", "modbus: 40001-010 执行复位急停状态(非软急停)")
def r_reset_estop_clear_alarm(self): # OK
self.__reg_high_pulse(40002)
self.logger("DEBUG", "openapi", "modbus: 40002-010 执行复位急停状态(非软急停)，并清除告警信息")
clibs.logger("DEBUG", "openapi", "modbus: 40002-010 执行复位急停状态(非软急停)，并清除告警信息")
def r_motor_off(self): # OK
self.__reg_high_pulse(40003)
self.logger("DEBUG", "openapi", "modbus: 40003-010 执行机器人下电")
clibs.logger("DEBUG", "openapi", "modbus: 40003-010 执行机器人下电")
def r_motor_on(self): # OK
self.__reg_high_pulse(40004)
self.logger("DEBUG", "openapi", "modbus: 40004-010 执行机器人上电")
clibs.logger("DEBUG", "openapi", "modbus: 40004-010 执行机器人上电")
def r_motoron_pp2main_start(self): # OK
self.__reg_high_pulse(40005)
self.logger("DEBUG", "openapi", "modbus: 40005-010 执行机器人上电/pp2main/开始运行程序，需自动模式执行，若运行失败，可清除告警后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40005-010 执行机器人上电/pp2main/开始运行程序，需自动模式执行，若运行失败，可清除告警后再次尝试")
def r_motoron_start(self): # OK
self.__reg_high_pulse(40006)
self.logger("DEBUG", "openapi", "modbus: 40006-010 执行机器人上电/开始运行程序，需自动模式执行，若运行失败，可清除告警、执行pp2main后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40006-010 执行机器人上电/开始运行程序，需自动模式执行，若运行失败，可清除告警、执行pp2main后再次尝试")
def r_pulse_motoroff(self): # OK
self.__reg_high_pulse(40007)
self.logger("DEBUG", "openapi", "modbus: 40007-010 执行机器人停止，并下电，手动模式下可停止程序运行，但不能下电，若运行失败，可清除告警后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40007-010 执行机器人停止，并下电，手动模式下可停止程序运行，但不能下电，若运行失败，可清除告警后再次尝试")
def r_pp2main(self): # OK
self.__reg_high_pulse(40008)
self.logger("DEBUG", "openapi", "modbus: 40008-010 执行机器人 pp2main，需自动模式执行，若运行失败，可清除告警后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40008-010 执行机器人 pp2main，需自动模式执行，若运行失败，可清除告警后再次尝试")
def r_program_start(self): # OK
self.__reg_high_pulse(40009)
self.logger("DEBUG", "openapi", "modbus: 40009-010 执行机器人默认程序运行，需有 pp2main 前置操作，若运行失败，可清除告警后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40009-010 执行机器人默认程序运行，需有 pp2main 前置操作，若运行失败，可清除告警后再次尝试")
def r_program_stop(self): # OK
self.__reg_high_pulse(40010)
self.logger("DEBUG", "openapi", "modbus: 40010-010 执行机器人默认程序停止，需有 pp2main 前置操作，若运行失败，可清除告警后再次尝试")
clibs.logger("DEBUG", "openapi", "modbus: 40010-010 执行机器人默认程序停止，需有 pp2main 前置操作，若运行失败，可清除告警后再次尝试")
def r_reduced_mode(self, action: int): # OK
self.c.write_register(40011, action)
actions = "进入" if action == 1 else "退出"
self.logger("DEBUG", "openapi", f"modbus: 40011-{action} 执行机器人{actions}缩减模式")
clibs.logger("DEBUG", "openapi", f"modbus: 40011-{action} 执行机器人{actions}缩减模式")
time.sleep(clibs.INTERVAL)
def r_soft_estop(self, action: int): # OK
self.c.write_register(40012, action)
actions = "解除" if action == 1 else "触发"
self.logger("DEBUG", "openapi", f"modbus: 40012-{action} 执行{actions}急停动作")
clibs.logger("DEBUG", "openapi", f"modbus: 40012-{action} 执行{actions}急停动作")
time.sleep(clibs.INTERVAL)
def r_switch_auto_motoron(self): # OK
self.__reg_high_pulse(40013)
self.logger("DEBUG", "openapi", "modbus: 40013-010 执行切换为自动模式，并上电，初始状态 !!不能是!! 手动上电模式")
clibs.logger("DEBUG", "openapi", "modbus: 40013-010 执行切换为自动模式，并上电，初始状态 !!不能是!! 手动上电模式")
def r_switch_auto(self): # OK
self.__reg_high_pulse(40014)
self.logger("DEBUG", "openapi", "modbus: 40014-010 执行切换为自动模式")
clibs.logger("DEBUG", "openapi", "modbus: 40014-010 执行切换为自动模式")
def r_switch_manual(self): # OK
self.__reg_high_pulse(40015)
self.logger("DEBUG", "openapi", "modbus: 40015-010 执行切换为手动模式")
clibs.logger("DEBUG", "openapi", "modbus: 40015-010 执行切换为手动模式")
def r_switch_safe_region01(self, action: bool): # OK | 上升沿打开，下降沿关闭
if action:
@ -121,7 +120,7 @@ class ModbusRequest(QThread):
time.sleep(clibs.INTERVAL)
self.c.write_register(40016, False)
actions = "打开" if action else "关闭"
self.logger("DEBUG", "openapi", f"modbus: 40016-{action} 执行{actions}安全区 safe region 01")
clibs.logger("DEBUG", "openapi", f"modbus: 40016-{action} 执行{actions}安全区 safe region 01")
time.sleep(clibs.INTERVAL)
def r_switch_safe_region02(self, action: bool): # OK | 上升沿打开，下降沿关闭
@ -134,7 +133,7 @@ class ModbusRequest(QThread):
time.sleep(clibs.INTERVAL)
self.c.write_register(40017, False)
actions = "打开" if action else "关闭"
self.logger("DEBUG", "openapi", f"modbus: 40017-{action} 执行{actions}安全区 safe region 02")
clibs.logger("DEBUG", "openapi", f"modbus: 40017-{action} 执行{actions}安全区 safe region 02")
time.sleep(clibs.INTERVAL)
def r_switch_safe_region03(self, action: bool): # OK | 上升沿打开，下降沿关闭
@ -147,150 +146,150 @@ class ModbusRequest(QThread):
time.sleep(clibs.INTERVAL)
self.c.write_register(40018, False)
actions = "打开" if action else "关闭"
self.logger("DEBUG", "openapi", f"modbus: 40018-{action} 执行{actions}安全区 safe region 03")
clibs.logger("DEBUG", "openapi", f"modbus: 40018-{action} 执行{actions}安全区 safe region 03")
time.sleep(clibs.INTERVAL)
def write_act(self, number):
self.c.write_register(40100, number)
self.logger("DEBUG", "openapi", f"modbus: 40100 将 {number} 写入")
clibs.logger("DEBUG", "openapi", f"modbus: 40100 将 {number} 写入")
def write_probe(self, probe):
self.c.write_register(40101, probe)
self.logger("DEBUG", "openapi", f"modbus: 40101 将 {probe} 写入")
clibs.logger("DEBUG", "openapi", f"modbus: 40101 将 {probe} 写入")
def write_pon(self, pon):
self.c.write_register(40102, pon)
self.logger("DEBUG", "openapi", f"modbus: 40102 将 {pon} 写入")
clibs.logger("DEBUG", "openapi", f"modbus: 40102 将 {pon} 写入")
def write_axis(self, axis):
result = self.c.convert_to_registers(int(axis), self.c.DATATYPE.INT32, "little")
self.c.write_registers(40103, result)
self.logger("DEBUG", "openapi", f"modbus: 40103 将 {axis} 写入")
clibs.logger("DEBUG", "openapi", f"modbus: 40103 将 {axis} 写入")
def write_speed_max(self, speed):
result = self.c.convert_to_registers(float(speed), self.c.DATATYPE.FLOAT32, "little")
self.c.write_registers(40105, result)
self.logger("DEBUG", "openapi", f"modbus: 40105 将 {speed} 写入")
clibs.logger("DEBUG", "openapi", f"modbus: 40105 将 {speed} 写入")
def r_write_signals(self, addr: int, value): # OK | 40100 - 40109: signal_0 ~ signal_9
if -1 < addr < 10 and addr.is_integer():
self.c.write_register(40100+addr, value)
self.logger("DEBUG", "openapi", f"modbus: {40100+addr}-{value} 将寄存器 signal_{addr} 赋值为 {value}")
clibs.logger("DEBUG", "openapi", f"modbus: {40100+addr}-{value} 将寄存器 signal_{addr} 赋值为 {value}")
else:
self.logger("INFO", "openapi", f"modbus: {40100+addr}-{value} 地址错误，无法赋值！", "red")
clibs.logger("INFO", "openapi", f"modbus: {40100+addr}-{value} 地址错误，无法赋值！", "red")
@property
def w_alarm_state(self): # OK
res = self.c.read_holding_registers(40500, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40500 获取告警状态，结果为 {res} :--: 0 表示无告警,，1 表示有告警")
clibs.logger("DEBUG", "openapi", f"modbus: 40500 获取告警状态，结果为 {res} :--: 0 表示无告警,，1 表示有告警")
return res
@property
def w_collision_alarm_state(self): # OK
res = self.c.read_holding_registers(40501, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40501 获取碰撞告警状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
clibs.logger("DEBUG", "openapi", f"modbus: 40501 获取碰撞告警状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
return res
@property
def w_collision_open_state(self): # OK
res = self.c.read_holding_registers(40502, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40502 获取碰撞检测开启状态，结果为 {res} :--: 0 表示关闭，1 表示开启")
clibs.logger("DEBUG", "openapi", f"modbus: 40502 获取碰撞检测开启状态，结果为 {res} :--: 0 表示关闭，1 表示开启")
return res
@property
def w_controller_is_running(self): # OK
res = self.c.read_holding_registers(40503, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40503 获取控制器运行状态，结果为 {res} :--: 0 表示运行异常，1 表示运行正常")
clibs.logger("DEBUG", "openapi", f"modbus: 40503 获取控制器运行状态，结果为 {res} :--: 0 表示运行异常，1 表示运行正常")
return res
@property
def w_encoder_low_battery(self): # OK
res = self.c.read_holding_registers(40504, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40504 获取编码器低电压状态，结果为 {res} :--: 0 表示非低电压，1 表示低电压 需关注")
clibs.logger("DEBUG", "openapi", f"modbus: 40504 获取编码器低电压状态，结果为 {res} :--: 0 表示非低电压，1 表示低电压 需关注")
return res
@property
def w_estop_state(self): # OK
res = self.c.read_holding_registers(40505, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40505 获取机器人急停状态(非软急停)，结果为 {res} :--: 0 表示未触发，1 表示已触发")
clibs.logger("DEBUG", "openapi", f"modbus: 40505 获取机器人急停状态(非软急停)，结果为 {res} :--: 0 表示未触发，1 表示已触发")
return res
@property
def w_motor_state(self): # OK
res = self.c.read_holding_registers(40506, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40506 获取机器人上电状态，结果为 {res} :--: 0 表示未上电，1 表示已上电")
clibs.logger("DEBUG", "openapi", f"modbus: 40506 获取机器人上电状态，结果为 {res} :--: 0 表示未上电，1 表示已上电")
return res
@property
def w_operation_mode(self): # OK
res = self.c.read_holding_registers(40507, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40507 获取机器人操作模式，结果为 {res} :--: 0 表示手动模式，1 表示自动模式")
clibs.logger("DEBUG", "openapi", f"modbus: 40507 获取机器人操作模式，结果为 {res} :--: 0 表示手动模式，1 表示自动模式")
return res
@property
def w_program_state(self): # OK
res = self.c.read_holding_registers(40508, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40508 获取程序的运行状态，结果为 {res} :--: 0 表示未运行，1 表示正在运行")
clibs.logger("DEBUG", "openapi", f"modbus: 40508 获取程序的运行状态，结果为 {res} :--: 0 表示未运行，1 表示正在运行")
return res
@property
def w_program_not_run(self): # OK
res = self.c.read_holding_registers(40509, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40509 判定程序为未运行状态，结果为 {res} :--: 0 表示正在运行，1 表示未运行")
clibs.logger("DEBUG", "openapi", f"modbus: 40509 判定程序为未运行状态，结果为 {res} :--: 0 表示正在运行，1 表示未运行")
return res
@property
def w_program_reset(self): # OK
res = self.c.read_holding_registers(40510, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40510 判定程序指针为 pp2main 状态，结果为 {res} :--: 0 表示指针不在 main 函数，1 表示指针在 main 函数")
clibs.logger("DEBUG", "openapi", f"modbus: 40510 判定程序指针为 pp2main 状态，结果为 {res} :--: 0 表示指针不在 main 函数，1 表示指针在 main 函数")
return res
@property
def w_reduce_mode_state(self): # OK
res = self.c.read_holding_registers(40511, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40511 获取机器人缩减模式状态，结果为 {res} :--: 0 表示非缩减模式，1 表示缩减模式")
clibs.logger("DEBUG", "openapi", f"modbus: 40511 获取机器人缩减模式状态，结果为 {res} :--: 0 表示非缩减模式，1 表示缩减模式")
return res
@property
def w_robot_is_busy(self): # OK
res = self.c.read_holding_registers(40512, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40512 获取机器人是否处于 busy 状态，结果为 {res} :--: 0 表示未处于 busy 状态，1 表示处于 busy 状态")
clibs.logger("DEBUG", "openapi", f"modbus: 40512 获取机器人是否处于 busy 状态，结果为 {res} :--: 0 表示未处于 busy 状态，1 表示处于 busy 状态")
return res
@property
def w_robot_is_moving(self): # OK
res = self.c.read_holding_registers(40513, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40513 获取机器人是否处于运动状态，结果为 {res} :--: 0 表示未运动，1 表示正在运动")
clibs.logger("DEBUG", "openapi", f"modbus: 40513 获取机器人是否处于运动状态，结果为 {res} :--: 0 表示未运动，1 表示正在运动")
return res
@property
def w_safe_door_state(self): # OK
res = self.c.read_holding_registers(40514, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40514 获取机器人是否处于安全门打开状态，需自动模式下执行，结果为 {res} :--: 0 表示未触发安全门，1 表示已触发安全门")
clibs.logger("DEBUG", "openapi", f"modbus: 40514 获取机器人是否处于安全门打开状态，需自动模式下执行，结果为 {res} :--: 0 表示未触发安全门，1 表示已触发安全门")
return res
@property
def w_safe_region01_trig_state(self): # OK
res = self.c.read_holding_registers(40515, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40515 获取安全区域 safe region01 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
clibs.logger("DEBUG", "openapi", f"modbus: 40515 获取安全区域 safe region01 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
return res
@property
def w_safe_region02_trig_state(self): # OK
res = self.c.read_holding_registers(40516, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40516 获取安全区域 safe region02 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
clibs.logger("DEBUG", "openapi", f"modbus: 40516 获取安全区域 safe region02 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
return res
@property
def w_safe_region03_trig_state(self): # OK
res = self.c.read_holding_registers(40517, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40517 获取安全区域 safe region03 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
clibs.logger("DEBUG", "openapi", f"modbus: 40517 获取安全区域 safe region03 的触发状态，结果为 {res} :--: 0 表示未触发，1 表示已触发")
return res
@property
def w_soft_estop_state(self): # OK
res = self.c.read_holding_registers(40518, count=1).registers[0]
self.logger("DEBUG", "openapi", f"modbus: 40518 获取机器人软急停状态，结果为 {res} :--: 0 表示未触发软急停，1 表示已触发软急停")
clibs.logger("DEBUG", "openapi", f"modbus: 40518 获取机器人软急停状态，结果为 {res} :--: 0 表示未触发软急停，1 表示已触发软急停")
return res
def io_write_coils(self, addr, action): # OK | 名字叫写线圈，其实是写 modbus 的 discrete inputs(DI)
@ -298,17 +297,17 @@ class ModbusRequest(QThread):
# e.g. io_write_coils(1, 1)
# e.g. io_write_coils(0, [1, 1, 1])
self.c.write_coils(addr, action)
self.logger("DEBUG", "openapi", f"modbus: 执行给 DI 地址 {addr} 赋值为 {action}，可根据情况传递列表，实现一次性赋值多个")
clibs.logger("DEBUG", "openapi", f"modbus: 执行给 DI 地址 {addr} 赋值为 {action}，可根据情况传递列表，实现一次性赋值多个")
time.sleep(clibs.INTERVAL)
def io_read_coils(self): # OK | 读 modbus 的 16 个 discrete inputs(DI)
res = self.c.read_coils(0, count=16).bits
self.logger("DEBUG", "openapi", f"modbus: 执行读取所有 DI 的结果为 {res}")
clibs.logger("DEBUG", "openapi", f"modbus: 执行读取所有 DI 的结果为 {res}")
return res
def io_read_discretes(self): # OK | 读 modbus 的 coil outputs(DO)
res = self.c.read_discrete_inputs(0, count=16).bits
self.logger("DEBUG", "openapi", f"modbus: 执行读取所有 DO 的结果为 {res}")
clibs.logger("DEBUG", "openapi", f"modbus: 执行读取所有 DO 的结果为 {res}")
return res
def read_ready_to_go(self):
@ -346,7 +345,6 @@ class HmiRequest(QThread):
self.__half_pkg_flag = False
self.__is_first_frame = True
self.__is_debug = True
self.logger = clibs.logger
def net_conn(self):
self.__socket_conn()
@ -360,7 +358,7 @@ class HmiRequest(QThread):
def close(self):
self.c.close()
self.c_xs.close()
self.logger("INFO", "openapi", f"hmi: 关闭 Socket 连接成功", "green")
clibs.logger("INFO", "openapi", f"hmi: 关闭 Socket 连接成功", "green")
def __socket_conn(self):
# self.close()
@ -377,9 +375,9 @@ class HmiRequest(QThread):
_ = self.execution("controller.heart")
time.sleep(clibs.INTERVAL/4)
clibs.status["hmi"] = 1
self.logger("INFO", "openapi", "hmi: HMI connection success...", "green")
clibs.logger("INFO", "openapi", "hmi: HMI connection success...", "green")
except Exception:
self.logger("ERROR", "openapi", f"hmi: HMI connection failed...", "red")
clibs.logger("ERROR", "openapi", f"hmi: HMI connection failed...", "red")
@staticmethod
def package(cmd):
@ -410,7 +408,7 @@ class HmiRequest(QThread):
callback = key.data
callback(key.fileobj, mask)
except Exception as err:
self.logger("DEBUG", "openapi", f"hmi: 老协议解包报错 err = {err}")
clibs.logger("DEBUG", "openapi", f"hmi: 老协议解包报错 err = {err}")
def __get_headers(self, index, data):
if index + 8 < len(data):
@ -423,7 +421,7 @@ class HmiRequest(QThread):
else:
# print("hr-get_headers: 解包数据有误，需要确认！")
# print(data)
self.logger("ERROR", "openapi", f"hmi: 解包数据有误，需要确认，最后一个数据包如下 {data}", "red")
clibs.logger("ERROR", "openapi", f"hmi: 解包数据有误，需要确认，最后一个数据包如下 {data}", "red")
else:
self.__half_pkg = data[index:]
self.__half_pkg_flag = True
@ -451,7 +449,7 @@ class HmiRequest(QThread):
if len(data[self.__index:]) >= pkg_value:
self.__response = data[self.__index:self.__index + pkg_value]
self.__index += pkg_value
self.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
clibs.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
self.__response = b""
self.__leftovers = 0
self.__is_first_frame = True
@ -499,7 +497,7 @@ class HmiRequest(QThread):
if self.__valid_data_length == 0:
# with open(f"{clibs.log_path}/response.txt", mode="a", encoding="utf-8") as f_res:
# f_res.write(f"{json.loads(self.__response.decode())}" + "\n")
self.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
clibs.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
self.__response = b""
self.__is_first_frame = True
continue # 此时应该重新 get_headers
@ -529,7 +527,7 @@ class HmiRequest(QThread):
self.__response += data[:self.__leftovers]
self.__index = self.__leftovers
self.__leftovers = 0
self.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
clibs.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
self.__response = b""
self.__is_first_frame = True
elif len(data) < self.__leftovers:
@ -584,7 +582,7 @@ class HmiRequest(QThread):
self.__half_frm_flag = -1
if self.__valid_data_length == 0:
self.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
clibs.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
self.__response = b""
self.__is_first_frame = True
continue
@ -612,7 +610,7 @@ class HmiRequest(QThread):
self.__index += frm_value
self.__valid_data_length -= frm_value
if self.__valid_data_length == 0:
self.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
clibs.logger("DEBUG", "openapi", str(json.loads(self.__response.decode())))
self.__response = b""
self.__is_first_frame = True
continue
@ -646,7 +644,7 @@ class HmiRequest(QThread):
# if self.__valid_data_length < 0 or self.__leftovers > 1024:
# print(f"data = {data}")
# raise Exception("DataError")
self.logger("ERROR", "openapi", "hmi: will never be here", "red")
clibs.logger("ERROR", "openapi", "hmi: will never be here", "red")
@staticmethod
def package_xs(cmd):
@ -672,7 +670,7 @@ class HmiRequest(QThread):
callback = key.data
callback(key.fileobj, mask)
except Exception as err:
self.logger("DEBUG", "openapi", f"hmi: xService解包报错 err = {err}")
clibs.logger("DEBUG", "openapi", f"hmi: xService解包报错 err = {err}")
def get_response_xs(self, data):
char, response = "", self.__response_xs
@ -680,7 +678,7 @@ class HmiRequest(QThread):
if char != "\r":
response = "".join([response, char])
else:
self.logger("DEBUG", "openapi", response)
clibs.logger("DEBUG", "openapi", response)
self.response_xs = response
response = ""
else:
@ -704,7 +702,7 @@ class HmiRequest(QThread):
if flag is True:
return records
else:
self.logger("ERROR", "openapi", f"hmi: {time_delay}s内无法找到请求 {msg_id} 的响应！", "red")
clibs.logger("ERROR", "openapi", f"hmi: {time_delay}s内无法找到请求 {msg_id} 的响应！", "red")
def execution(self, command, **kwargs):
req = None
@ -716,7 +714,7 @@ class HmiRequest(QThread):
flag = req["p_type"]
del req["p_type"]
except Exception as err:
self.logger("ERROR", "openapi", f"hmi: 暂不支持 {command} 功能，或确认该功能存在...<br>err = {err}", "red")
clibs.logger("ERROR", "openapi", f"hmi: 暂不支持 {command} 功能，或确认该功能存在...<br>err = {err}", "red")
match command:
case "state.set_tp_mode" | "overview.set_autoload" | "overview.reload" | "rl_task.pp_to_main" | "rl_task.run" | "rl_task.stop" | "rl_task.set_run_params" | "diagnosis.set_params" | "diagnosis.open" | "drag.set_params" | "controller.set_params" | "collision.set_state" | "collision.set_params" | "move.set_quickstop_distance" | "move.set_params" | "move.set_monitor_cfg" | "modbus.get_values" | "modbus.set_params" | "system_io.update_configuration" | "diagnosis.get_params" | "jog.set_params" | "jog.start" | "move.stop" | "move.quick_turn" | "move.set_quickturn_pos" | "soft_limit.set_params" | "fieldbus_device.set_params" | "socket.set_params" | "diagnosis.save" | "register.set_value":
@ -733,18 +731,18 @@ class HmiRequest(QThread):
try:
self.c.send(self.package(cmd))
time.sleep(clibs.INTERVAL/4) # 这里一定是要等几百毫秒的，避免多指令同一时间发送，导致xCore不响应
self.logger("DEBUG", "openapi", f"hmi: 老协议请求发送成功 {cmd}")
clibs.logger("DEBUG", "openapi", f"hmi: 老协议请求发送成功 {cmd}")
except Exception as err:
if "controller.heart" in cmd:
raise Exception()
self.logger("ERROR", "openapi", f"hmi: 老协议请求发送失败 {cmd}，报错信息 {err}", "red")
clibs.logger("ERROR", "openapi", f"hmi: 老协议请求发送失败 {cmd}，报错信息 {err}", "red")
elif flag == 1:
try:
self.c_xs.send(self.package_xs(req))
time.sleep(clibs.INTERVAL/4)
self.logger("DEBUG", "openapi", f"hmi: xService请求发送成功 {req}")
clibs.logger("DEBUG", "openapi", f"hmi: xService请求发送成功 {req}")
except Exception as err:
self.logger("ERROR", "openapi", f"hr: xService请求发送失败 {req} 报错信息 {err}", "red")
clibs.logger("ERROR", "openapi", f"hr: xService请求发送失败 {req} 报错信息 {err}", "red")
return req["id"]
@ -762,7 +760,7 @@ class HmiRequest(QThread):
case "off":
self.execution("state.switch_motor_off")
case _:
self.logger("ERROR", "openapi", f"hmi: switch_motor_state 参数错误 {state}， 非法参数，只接受 on/off", "red")
clibs.logger("ERROR", "openapi", f"hmi: switch_motor_state 参数错误 {state}， 非法参数，只接受 on/off", "red")
def switch_operation_mode(self, mode: str): # OK
"""
@ -776,7 +774,7 @@ class HmiRequest(QThread):
case "manual":
self.execution("state.switch_manual")
case _:
self.logger("ERROR", "openapi", f"hmi: switch_operation_mode 参数错误 {mode}，非法参数，只接受 auto/manual", "red")
clibs.logger("ERROR", "openapi", f"hmi: switch_operation_mode 参数错误 {mode}，非法参数，只接受 auto/manual", "red")
def reload_project(self, prj_name: str, tasks: list): # OK
"""
@ -842,7 +840,7 @@ class HmiRequest(QThread):
:return: None
"""
self.execution("controller.reboot")
self.logger("INFO", "openapi", f"hmi: 控制器重启中，重连预计需要等待 100s 左右...")
clibs.logger("INFO", "openapi", f"hmi: 控制器重启中，重连预计需要等待 100s 左右...")
ts = time.time()
time.sleep(30)
while True:
@ -857,7 +855,7 @@ class HmiRequest(QThread):
break
time.sleep(2)
else:
self.logger("INFO", "openapi", "hr: HMI 重新连接成功...", "green")
clibs.logger("INFO", "openapi", "hr: HMI 重新连接成功...", "green")
break
def reload_io(self):
@ -1483,7 +1481,7 @@ class HmiRequest(QThread):
case "without":
self.execution("state.set_tp_mode", tp_mode="without")
case _:
self.logger("ERROR", "openapi", f"hmi: switch_tp_mode 参数错误{mode}， 非法参数，只接受 with/without", "red")
clibs.logger("ERROR", "openapi", f"hmi: switch_tp_mode 参数错误{mode}， 非法参数，只接受 with/without", "red")
@property
def get_tp_mode(self): # OK
@ -1745,7 +1743,6 @@ class ExternalCommunication(QThread):
self.port = int(port)
self.suffix = "\r"
self.exec_desc = " :--: 返回 true 表示执行成功，false 失败"
self.logger = clibs.logger
def net_conn(self):
clibs.c_hr.execution("socket.set_params", enable=False, ip="0.0.0.0", port=str(self.port), suffix="\r", type=1)
@ -1756,14 +1753,14 @@ class ExternalCommunication(QThread):
self.c.settimeout(clibs.INTERVAL*3)
try:
self.c.connect((self.ip, self.port))
self.logger("INFO", "openapi", f"ec: 外部通信连接成功...", "green")
clibs.logger("INFO", "openapi", f"ec: 外部通信连接成功...", "green")
# return self.c
except Exception as err:
self.logger("ERROR", "openapi", f"ec: 外部通信连接失败... {err}", "red")
clibs.logger("ERROR", "openapi", f"ec: 外部通信连接失败... {err}", "red")
def close(self):
self.c.close()
self.logger("INFO", "openapi", f"ec: 关闭外部通信连接成功", "green")
clibs.logger("INFO", "openapi", f"ec: 关闭外部通信连接成功", "green")
@clibs.db_lock
def sr_string(self, directive, interval=clibs.INTERVAL/2):
@ -2022,7 +2019,7 @@ class ExternalCommunication(QThread):
self.s_string(directive)
time.sleep(clibs.INTERVAL/2)
result = self.r_string(directive).strip()
self.logger("DEBUG", "openapi", f"ec: 执行{description}指令是 {directive}，返回值为 {result}{more_desc}")
clibs.logger("DEBUG", "openapi", f"ec: 执行{description}指令是 {directive}，返回值为 {result}{more_desc}")
return result
@ -2034,7 +2031,6 @@ class PreDos(object):
self.ssh_port = ssh_port
self.username = username
self.password = password
self.logger = clibs.logger
def __ssh2server(self):
try:
@ -2043,7 +2039,7 @@ class PreDos(object):
self.__ssh.connect(hostname=self.ip, port=self.ssh_port, username=self.username, password=self.password)
self.__sftp = self.__ssh.open_sftp()
except Exception as err:
self.logger("ERROR", "openapi", f"predos: SSH 无法连接到 {self.ip}:{self.ssh_port}，需检查网络连通性或者登录信息是否正确 {err}", "red")
clibs.logger("ERROR", "openapi", f"predos: SSH 无法连接到 {self.ip}:{self.ssh_port}，需检查网络连通性或者登录信息是否正确 {err}", "red")
def push_prj_to_server(self, prj_file):
# prj_file：本地工程完整路径