v0.1.7.2(2024/06/30)

1. 初步完成NB4h_R580_3BH7.zip工程的设计
2. 重新研究了解包操作，重新实现了一版
3. 修改openapi.pi中excution为execution函数
4. 增减了解包原理性文档

aio/code/automatic_test/btn_functions.py

@@ -15,7 +15,7 @@ def validate_resp(_id, response, w2t):
 
 
 def execution(cmd, hr, w2t, **kwargs):
-    _id = hr.excution(cmd, **kwargs)
+    _id = hr.execution(cmd, **kwargs)
     _msg = hr.get_from_id(_id)
     if not _msg:
         w2t(f"无法获取{_id}请求的响应信息", 0, 6, 'red', tab_name='Automatic Test')

aio/code/automatic_test/do_current.py

@@ -7,9 +7,6 @@ from json import loads
 
 
 def traversal_files(path, w2t):
-    # 功能：以列表的形式分别返回指定路径下的文件和文件夹，不包含子目录
-    # 参数：路径
-    # 返回值：路径下的文件夹列表 路径下的文件列表
     if not exists(path):
         msg = f'数据文件夹{path}不存在，请确认后重试......'
         w2t(msg, 0, 1, 'red', tab_name='Automatic Test')
@@ -26,33 +23,29 @@ def traversal_files(path, w2t):
 
 
 def check_files(data_dirs, data_files, w2t):
-    if len(data_dirs) != 0 or len(data_files) != 5:
-        w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下五个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
-        w2t('   1. configs.xlsx\n    2. reach33/reach66/reach100_xxxx.xlsx\n    3. xxxx.zip', 0, 1, 'red', tab_name='Automatic Test')
+    if len(data_dirs) != 0 or len(data_files) != 3:
+        w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下三个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
+        w2t('   1. configs.xlsx\n    2. T_电机电流.xlsx\n    3. xxxx.zip', 0, 1, 'red', tab_name='Automatic Test')
 
-    config_file = reach33 = reach66 = reach100 = prj_file = None
+    config_file = current_file = prj_file = None
     for data_file in data_files:
         filename = data_file.split('\\')[-1]
         if filename == 'configs.xlsx':
             config_file = data_file
-        elif filename.startswith('reach33_') and filename.endswith('.xlsx'):
-            reach33 = data_file
-        elif filename.startswith('reach66_') and filename.endswith('.xlsx'):
-            reach66 = data_file
-        elif filename.startswith('reach100_') and filename.endswith('.xlsx'):
-            reach100 = data_file
+        elif filename == 'T_电机电流.xlsx':
+            current_file = data_file
         elif filename.endswith('.zip'):
             prj_file = data_file
         else:
-            w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下五个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
-            w2t('    1. configs.xlsx\n    2. reach33/reach66/reach100_xxxx.xlsx\n    3. xxxx.zip', 0, 2, 'red', tab_name='Automatic Test')
+            w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下三个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
+            w2t('   1. configs.xlsx\n    2. T_电机电流.xlsx\n    3. xxxx.zip', 0, 1, 'red', tab_name='Automatic Test')
 
-    if config_file and reach33 and reach66 and reach100 and prj_file:
+    if config_file and current_file and prj_file:
         w2t("数据目录合规性检查结束，未发现问题......", tab_name='Automatic Test')
-        return config_file, reach33, reach66, reach100, prj_file
+        return config_file, current_file, prj_file
     else:
-        w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下五个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
-        w2t('    1. configs.xlsx\n    2. reach33/reach66/reach100_xxxx.xlsx\n    3. xxxx.zip', 0, 1, 'red', tab_name='Automatic Test')
+        w2t('初始路径下不允许有文件夹，且初始路径下只能存在如下三个文件，确认后重新运行！', 0, 0, 'red', tab_name='Automatic Test')
+        w2t('   1. configs.xlsx\n    2. T_电机电流.xlsx\n    3. xxxx.zip', 0, 1, 'red', tab_name='Automatic Test')
 
 
 def prj_to_xcore(prj_file):
@@ -105,7 +98,7 @@ def validate_resp(_id, response, w2t):
 
 
 def execution(cmd, hr, w2t, **kwargs):
-    _id = hr.excution(cmd, **kwargs)
+    _id = hr.execution(cmd, **kwargs)
     _msg = hr.get_from_id(_id)
     if not _msg:
         w2t(f"无法获取{_id}请求的响应信息", 0, 6, 'red', tab_name='Automatic Test')
@@ -116,38 +109,54 @@ def execution(cmd, hr, w2t, **kwargs):
 
 
 def run_rl(hr, w2t):
-    # prj_path = 'target/_build/target.prj'
-    # _response = execution('overview.reload', hr, w2t, prj_path=prj_path, tasks=['Durable_Test_Com', 'Mechanical_Test_Com'])
-    # print(f"reload prj: {_response}")
-    # # _response = execution('overview.get_cur_prj', hr, w2t)
-    # # print(f"get cur prj name: {_response}")
-    # _response = execution('rl_task.pp_to_main', hr, w2t, tasks=['Mechanical_Test_Com'])
-    # print(f"set pp2main of prj: {_response}")
-    #
-    # _response = execution('state.switch_auto', hr, w2t)
-    # _response = execution('state.switch_motor_on', hr, w2t)
-    #
-    # _response = execution('rl_task.run', hr, w2t, tasks=['Mechanical_Test_Com'])
-    # print(f"run prj: {_response}")
-    # sleep(10)
-    #
-    # _response = execution('state.switch_motor_off', hr, w2t)
-    # _response = execution('state.switch_manual', hr, w2t)
+    prj_path = 'target/_build/target.prj'
+    _response = execution('overview.reload', hr, w2t, prj_path=prj_path, tasks=['brake', 'current'])
+    print(f"reload prj: {_response}")
+    _response = execution('overview.get_cur_prj', hr, w2t)
+    print(f"get cur prj name: {_response}")
+    _response = execution('rl_task.pp_to_main', hr, w2t, tasks=['brake'])
+    print(f"set pp2main of prj: {_response}")
+
+    _response = execution('state.switch_auto', hr, w2t)
+    _response = execution('state.switch_motor_on', hr, w2t)
 
     _response = execution('diagnosis.open', hr, w2t, open=True, display_open=True)
     print(f"打开诊断: {_response}")
     # _response = execution('diagnosis.get_params', hr, w2t)
     # print(f"显示诊断状态: {_response}")
     display_pdo_params = [
-        {"name": "device_servo_trq_feedback", "channel": 0}
+        {"name": "hw_joint_vel_feedback", "channel": 0},
+        {"name": "hw_joint_vel_feedback", "channel": 1},
+        {"name": "hw_joint_vel_feedback", "channel": 2},
+        {"name": "hw_joint_vel_feedback", "channel": 3},
+        {"name": "hw_joint_vel_feedback", "channel": 4},
+        {"name": "hw_joint_vel_feedback", "channel": 5},
+        {"name": "device_servo_trq_feedback", "channel": 0},
+        {"name": "device_servo_trq_feedback", "channel": 1},
+        {"name": "device_servo_trq_feedback", "channel": 2},
+        {"name": "device_servo_trq_feedback", "channel": 3},
+        {"name": "device_servo_trq_feedback", "channel": 4},
+        {"name": "device_servo_trq_feedback", "channel": 5},
+        {"name": "device_safety_estop", "channel": 0},
+        {"name": "device_safety_estop", "channel": 0},
+        {"name": "device_safety_estop", "channel": 0},
+        {"name": "device_safety_estop", "channel": 0},
+        {"name": "device_safety_estop", "channel": 0},
+        {"name": "device_safety_estop", "channel": 0},
     ]
     _response = execution('diagnosis.set_params', hr, w2t, display_pdo_params=display_pdo_params)
     print(f"执行采样: {_response}")
-    sleep(5)
+
+    _response = execution('rl_task.run', hr, w2t, tasks=['brake'])
+    print(f"run prj: {_response}")
+    sleep(10)
 
     _response = execution('diagnosis.open', hr, w2t, open=False, display_open=False)
     print(f"关闭诊断: {_response}")
-    # sleep(1)
+
+    _response = execution('state.switch_motor_off', hr, w2t)
+    _response = execution('state.switch_manual', hr, w2t)
+
     for _msg in hr.c_msg:
         if 'diagnosis.result' in _msg:
             print(_msg)
@@ -160,14 +169,11 @@ def run_rl(hr, w2t):
             #             break
 
 
-    else:
-        sleep(1)
+def main(path, hr, w2t):
 
-
-def main(path, hr, loadsel, w2t):
     data_dirs, data_files = traversal_files(path, w2t)
-    config_file, reach33, reach66, reach100, prj_file = check_files(data_dirs, data_files, w2t)
-    # prj_to_xcore(prj_file)
+    config_file, current_file, prj_file = check_files(data_dirs, data_files, w2t)
+    prj_to_xcore(prj_file)
     run_rl(hr, w2t)
 
 

aio/code/automatic_test/openapi.py

@@ -4,6 +4,7 @@ from threading import Thread
 import selectors
 from time import time, sleep
 from os.path import dirname
+from binascii import b2a_hex, a2b_hex
 
 MAX_FRAME_SIZE = 1024
 setdefaulttimeout(2)
@@ -25,6 +26,10 @@ class HmiRequest(object):
         self.response_xs = ''
         self.t_bool = True
         self.tab_name = 'Automatic Test'
+        self.pkg_size = 0
+        self.broke = 0
+        self.half = 0
+        self.half_length = 0
 
         self.sock_conn()
         self.t_heartbeat = Thread(target=self.heartbeat)
@@ -55,14 +60,20 @@ class HmiRequest(object):
                 self.w2t("Connection success", 0, 0, 'green', tab_name=self.tab_name)
                 with open(f"{current_path}/../../assets/templates/heartbeat", "w", encoding='utf-8') as f_hb:
                     f_hb.write('1')
-
+                # print(f"打开诊断:")
+                # self.execution('diagnosis.open', open=True, display_open=True)
+                # display_pdo_params = []
+                # print(f"执行采样")
+                # self.execution('diagnosis.set_params', display_pdo_params=display_pdo_params)
+                # print(f"关闭诊断")
+                # self.execution('diagnosis.open', open=False, display_open=False)
             except Exception as Err:
                 self.w2t("Connection failed...", 0, 0, 'red', tab_name=self.tab_name)
                 with open(f"{current_path}/../../assets/templates/heartbeat", "w", encoding='utf-8') as f_hb:
                     f_hb.write('0')
 
     def header_check(self, index, data):
-        try:
+        if index + 8 < len(data):
             _frame_size = int.from_bytes(data[index:index+2], byteorder='big')
             _pkg_size = int.from_bytes(data[index+2:index+6], byteorder='big')
             _protocol = int.from_bytes(data[index+6:index+7], byteorder='big')
@@ -71,16 +82,31 @@ class HmiRequest(object):
             if _reserved == 0 and _protocol == 2:
                 return index+8, _frame_size, _pkg_size
             else:
-                print("数据有误，需要确认")
-                return 'DATA ERR'
-        except Exception as Err:
-            print(f"Err = {Err}")
-            print("无法读取数据，需要确认")
-            return 'DATA READ ERR'
+                print(data)
+                print("head check 数据有误，需要确认")
+                self.w2t("", 0, 1, 'red', 'Automatic Test')
+        else:
+            self.half_length = len(data)-index
+            if self.half_length == 1:
+                self.half = a2b_hex(str(hex(data[-1]))[2:].rjust(1, '0'))
+            else:
+                self.half = data[index:]
+
+            print(f"in head check half data: {self.half}")
+            print(f"in head check length: {self.half_length}")
+            print(f"in head check data: {data}")
+
+            self.broke = 100
+            index += MAX_FRAME_SIZE
+            return index, 0, 0
+        # except Exception as Err:
+        #     print(data)
+        #     print(f"Err = {Err}")
+        #     print("无法读取数据，需要确认")
 
     def heartbeat(self):
         while self.t_bool:
-            _id = self.excution('controller.heart')
+            _id = self.execution('controller.heart')
             _flag = '0' if self.get_from_id(_id) is None else '1'
             print(f"hb = {_flag}", end=' ')
             with open(f"{current_path}/../../assets/templates/heartbeat", "w", encoding='utf-8') as f_hb:
@@ -103,55 +129,191 @@ class HmiRequest(object):
                 messages.pop()
 
     def get_response(self, data):
-        _index = 0
+        # 流式获取单次请求的响应
+        if self.broke == 100:
+            print("*****************************************")
+            print(f"half data: {self.half}")
+            _half_1 = self.half
+            if self.half_length == 7:
+                _half_2 = a2b_hex(str(hex(data[0]))[2:].rjust(1, '0'))
+            else:
+                _half_2 = data[:8-self.half_length]
+            _full = _half_1 + _half_2
+            print(f"full data: {_full}")
+            _frame_size = _full[:2]
+            _frame_size = int.from_bytes(_full[:2], byteorder='big')
+            _pkg_size = int.from_bytes(_full[2:6], byteorder='big')
+            _protocol = int.from_bytes(_full[6:7], byteorder='big')
+            _reserved = int.from_bytes(_full[7:8], byteorder='big')
+            if _reserved != 0 or _protocol != 2:
+                print(data)
+                print("数据有误，需要确认")
+                self.w2t("", 0, 1, 'red', 'Automatic Test')
+            self.pkg_size = _pkg_size
+            _index = 8 - self.half_length
+        else:
+            _index = 0
+
         while _index < len(data):
+            # flag 为 0，则说明是一次新的请求对应的一次新的相应，也就是需要首次解包
             if self.flag == 0:
-                _index, _frame_size, _pkg_size = self.header_check(_index, data)
-                if _pkg_size <= len(data) - _index:
-                    # 说明剩余部分的数据正好就是完整的包数据
-                    self.response = data[_index:_index+_pkg_size].decode()
+                if self.broke == 100:
+                    self.broke = 0
+                else:
+                    _index, _frame_size, self.pkg_size = self.header_check(_index, data)
+                    if _index > MAX_FRAME_SIZE:
+                        break
+                # 详见解包原理数据.txt，self.pkg_size 永远是除了当前data之外剩余未处理的数据大小
+                print(f"INIT pkg size = {self.pkg_size}")
+                if self.pkg_size <= len(data) - _index:
+                    # 说明剩余部分的数据就在当前data内，没有被分割
+                    self.response = data[_index:_index+self.pkg_size].decode()
                     self.msg_storage(flag=0, response=self.response)
-                    _index += _pkg_size
+                    _index += self.pkg_size
+                    print(f"in flag=0 if data = {data}")
+                    print(f"in flag=0 if index = {_index}")
+                    print(f"in flag=0 if pkg size = {self.pkg_size}")
+                    print(f"in flag=0 if leftover = {self.leftover}")
                     self.flag = 0
                     self.response = ''
                     self.leftover = 0
-                elif _pkg_size > len(data) - _index:
-                    # 说有有分包的情况发生了，需要flag=1的处理
+                elif self.pkg_size > len(data) - _index:
+                    # 执行到这里说明该data是首包，且有有分包的情况发生了也就是该响应数据量稍微比较大
+                    # 分散在了相邻的两个及以上的data中，需要flag=1的处理
                     self.flag = 1
                     self.response = data[_index:].decode()
-                    self.leftover = _frame_size - 6 - (len(data) - _index)  # 其实就是常量 2，其中 6 就是六个字节的包头
+                    self.leftover = _frame_size - 6 - (len(data) - _index)  # 这里的 _index 不一定是 0
+                    self.pkg_size -= (len(data) - _index)  # 详见解包原理数据.txt，self.pkg_size
+                    print(f"in flag=0 else data = {data}")
+                    print(f"in flag=0 else index = {_index}")
+                    print(f"in flag=0 else pkg size = {self.pkg_size}")
+                    print(f"in flag=0 else leftover = {self.leftover}")
                     break
-
             elif self.flag == 1:
-                # 处理完之后，将flag重置为0
-                _index = self.leftover
-                self.response += data[:_index].decode()
-                _index += 2
+                # 继续处理之前为接收完的数据，处理完之后将flag重置为0
+                # !!!需要注意的是，包头/帧头也是有可能被分割开的!!!但是目前该程序未实现此种情况!!!
+                if self.broke == 1:
+                    self.leftover = int.from_bytes(int(self.half).to_bytes(1, byteorder='big') + data[0:1], byteorder='big')
+                    _index = 1
+                    self.broke = 0
+                    print(f"broke 1 leftover: {self.leftover}")
+                if self.broke == 2:
+                    self.leftover = int.from_bytes(data[:2], byteorder='big')
+                    print(f"broke 2 leftover: {self.leftover}")
+                    _index = 2
+                    self.broke = 0
+                while self.pkg_size > 0:
+                    print(f"flag = 1 INIT _index = {_index}")
+                    if _index + self.leftover <= len(data):
+                        self.response += data[_index:_index + self.leftover].decode()
+                        self.pkg_size -= self.leftover
+                        if self.pkg_size == 0:
+                            self.msg_storage(flag=0, response=self.response)
+                            _index += self.leftover
+                            print(f"break _index = {_index}")
+                            print(data)
+                            self.flag = 0
+                            self.response = ''
+                            self.leftover = 0
+                            self.pkg_size = 0
+                            break
 
-                _frame_size = int.from_bytes(data[_index - 2:_index], byteorder='big')
-                if _frame_size == 0:
+                        _index += self.leftover
+                        if _index+2 <= len(data):
+                            self.leftover = int.from_bytes(data[_index:_index+2], byteorder='big')
+                            _index += 2
+                        else:
+                            self.leftover = 4096
+                            if _index == len(data) -1:
+                                self.broke = 1
+                                self.half = data[-1]
+                                print(f"half = {self.half}")
+                                print('+++++++++++++++++++++')
+                                _index += MAX_FRAME_SIZE
+                            elif _index == len(data):
+                                _index += MAX_FRAME_SIZE
+                                self.broke = 2
+                        print(f"in if data = {data}")
+                        print(f"in if index = {_index}")
+                        print(f"in if pkg size = {self.pkg_size}")
+                        print(f"in if leftover = {self.leftover}")
+                        if self.leftover > 1024:
+                            print('============================')
+                    else:
+                        self.response += data[_index:].decode()
+                        self.leftover -= (len(data) - _index)
+                        self.pkg_size -= (len(data) - _index)
+                        # if self.pkg_size == 0:
+                        #     self.msg_storage(flag=0, response=self.response)
+                        #     _index += MAX_FRAME_SIZE
+                        #     self.flag = 0
+                        #     self.response = ''
+                        #     self.leftover = 0
+                        #     break
+
+                        _index += MAX_FRAME_SIZE
+                        print(f"in else data = {data}")
+                        print(f"in else index = {_index}")
+                        print(f"in else pkg size = {self.pkg_size}")
+                        print(f"in else leftover = {self.leftover}")
+                        if self.leftover > 1024:
+                            print('============================')
+                        break
+                else:
                     self.msg_storage(flag=0, response=self.response)
                     self.flag = 0
                     self.response = ''
                     self.leftover = 0
-                    break
-
-                if _frame_size == MAX_FRAME_SIZE:
-                    self.leftover = MAX_FRAME_SIZE - (len(data) - _index)
-                    self.response += data[_index:].decode()
-                    break
-                else:
-                    if _index+_frame_size <= MAX_FRAME_SIZE:
-                        self.response += data[_index:_index+_frame_size].decode()
-                        self.msg_storage(flag=0, response=self.response)
-                        self.flag = 0
-                        self.response = ''
-                        self.leftover = 0
-                        break
-                    else:
-                        self.response += data[_index:].decode()
-                        self.leftover = _index + _frame_size - MAX_FRAME_SIZE
-                        break
+                    _index -= 2
+        # _index = 0
+        # while _index < len(data):
+        #     if self.flag == 0:
+        #         _index, _frame_size, _pkg_size = self.header_check(_index, data)
+        #         if _pkg_size <= len(data) - _index:
+        #             # 说明剩余部分的数据正好就是完整的包数据
+        #             self.response = data[_index:_index+_pkg_size].decode()
+        #             self.msg_storage(flag=0, response=self.response)
+        #             _index += _pkg_size
+        #             self.flag = 0
+        #             self.response = ''
+        #             self.leftover = 0
+        #         elif _pkg_size > len(data) - _index:
+        #             # 说有有分包的情况发生了，需要flag=1的处理
+        #             self.flag = 1
+        #             self.response = data[_index:].decode()
+        #             self.leftover = _frame_size - 6 - (len(data) - _index)  # 其实就是常量 2，其中 6 就是六个字节的包头
+        #             break
+        #
+        #     elif self.flag == 1:
+        #         # 处理完之后，将flag重置为0
+        #         _index = self.leftover
+        #         self.response += data[:_index].decode()
+        #         _index += 2
+        #
+        #         _frame_size = int.from_bytes(data[_index - 2:_index], byteorder='big')
+        #         if _frame_size == 0:
+        #             self.msg_storage(flag=0, response=self.response)
+        #             self.flag = 0
+        #             self.response = ''
+        #             self.leftover = 0
+        #             break
+        #
+        #         if _frame_size == MAX_FRAME_SIZE:
+        #             self.leftover = MAX_FRAME_SIZE - (len(data) - _index)
+        #             self.response += data[_index:].decode()
+        #             break
+        #         else:
+        #             if _index+_frame_size <= MAX_FRAME_SIZE:
+        #                 self.response += data[_index:_index+_frame_size].decode()
+        #                 self.msg_storage(flag=0, response=self.response)
+        #                 self.flag = 0
+        #                 self.response = ''
+        #                 self.leftover = 0
+        #                 break
+        #             else:
+        #                 self.response += data[_index:].decode()
+        #                 self.leftover = _index + _frame_size - MAX_FRAME_SIZE
+        #                 break
 
     def get_response_xs(self, data):
         if self.flag_xs == 0:
@@ -213,7 +375,7 @@ class HmiRequest(object):
         def to_read(conn):
             data = conn.recv(MAX_FRAME_SIZE)
             if data:
-                # print(data)
+                print(data)
                 self.get_response(data)
             else:
                 print('closing', sock)
@@ -254,7 +416,7 @@ class HmiRequest(object):
         _id = f"{command}-{_now}"
         return _id
 
-    def excution(self, command, flg=0, **kwargs):
+    def execution(self, command, flg=0, **kwargs):
         if flg == 0:  # for old protocols
             req = None
             try:
@@ -287,7 +449,7 @@ class HmiRequest(object):
             cmd = dumps(req, separators=(',', ':'))
             try:
                 self.c.send(self.package(cmd))
-                sleep(2)
+                sleep(1)
             except Exception as Err:
                 self.w2t(f"{cmd}\n请求发送失败...{Err}", 0, 0, 'red', tab_name=self.tab_name)