lishuzuoxun

AcrossPlatform/get_platform.py

@@ -0,0 +1,14 @@
+import os
+import sys
+
+LINUX = "linux"
+WINDOWS = "win"
+SYS_PLATFORM = None
+if sys.platform.startswith("linux"):
+    SYS_PLATFORM = LINUX
+elif sys.platform.startswith("win32"):
+    SYS_PLATFORM = WINDOWS
+
+GLOBAL_DIR = os.path.join(sys.path[0])
+UNIX_GLOBAL_DIR = GLOBAL_DIR.replace("\\", "/")
+

Backend/consensus.py

@@ -0,0 +1,5 @@
+STATUS_OK = 0
+STATUS_UNKNOWN_ERROR = -1
+
+REQUEST_MODE_GET = "get"
+REQUEST_MODE_POST = "post"

Backend/format_backend.py

@@ -0,0 +1,71 @@
+import traceback
+from multiprocessing import freeze_support
+from typing import List
+
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+from flask_sock import Sock
+from werkzeug.serving import ThreadedWSGIServer
+
+from Backend.consensus import *
+
+
+class Backend:
+
+    def __init__(self, name, domain="0.0.0.0", port=0, debug=False):
+        # 网络配置
+        self.port = port
+        self.domain = domain
+        # 后端app
+        self.app = Flask(name)
+        self.sock = Sock(self.app)
+        # 跨域配置
+        CORS(self.app, supports_credentials=True)
+        self.app.debug = debug
+        # 基本地址
+        self.base_url = '/'
+        # 获得系统状态
+        self.register(name="system_status", func=self.system_status, methods=[REQUEST_MODE_GET])
+        self.register(name="post_test", func=self.post_test, methods=[REQUEST_MODE_POST])
+
+    # 注册后端接口
+    def register(self, name, func, methods: List):
+        self.app.add_url_rule(
+            rule=f"{self.base_url}{name}",
+            methods=methods,
+            view_func=func,
+            endpoint=name
+        )
+
+    # 注册WebSocket接口
+    def register_websocket(self, name, func):
+        @self.sock.route(f"{self.base_url}{name}", endpoint=name)
+        def sock_func(ws):
+            func(ws)
+
+    @staticmethod
+    def system_status():
+        try:
+            return jsonify({"status": STATUS_OK})
+        except Exception as e:
+            error_msg = {
+                "status": STATUS_UNKNOWN_ERROR,
+                "error_message": f"后端系统启动失败({e.args})，错误来源：{traceback.format_exc()}"
+            }
+            return jsonify(error_msg)
+
+    @staticmethod
+    def post_test():
+        try:
+            data = request.get_json()
+            return jsonify({"status": STATUS_OK, "post_data": data})
+        except Exception as e:
+            error_msg = {
+                "status": STATUS_UNKNOWN_ERROR,
+                "error_message": f"后端系统错误({e.args})，错误来源：{traceback.format_exc()}"
+            }
+            return jsonify(error_msg)
+
+    def start_backend(self):
+        server = ThreadedWSGIServer(app=self.app, port=self.port, host=self.domain)
+        server.serve_forever(0.001)

BaseFrontend/based_widget.py

@@ -0,0 +1,7 @@
+from PyQt5.QtWidgets import QWidget
+from BaseFrontend.message_manager import PageUpdateManager
+
+
+class BasedWidget(QWidget, PageUpdateManager):
+    def __init__(self):
+        super().__init__()

BaseFrontend/message_manager.py

@@ -0,0 +1,32 @@
+from BaseFrontend.page_manager import *
+
+
+class PageUpdateManager:
+    """
+    页面跳转中间层，控制基本的页面跳转和信息传递。
+    """
+
+    def __init__(self, page_manager: PageManager = BASE_PAGE_TERMINAL) -> None:
+        super().__init__()
+        self.page_manager = page_manager
+        self.data = dict()
+
+    def back2page(self, page_name):
+        self.page_manager.back2page(page_name)
+
+    # 跳转到其他页面
+    def jump2(self, page_name, data=None):
+        if data is None:
+            data = {}
+        self.page_manager.jump2(page_name, data)
+
+    # 对外api，更新该类的显示数据
+    def set_data(self, data):
+        self.data = data
+
+    def get_data(self):
+        return self.data
+
+    # 在这里定义页面跳变的刷新方法
+    def refresh(self):
+        pass

BaseFrontend/page_manager.py

@@ -0,0 +1,68 @@
+import sys
+from PyQt5.QtWidgets import QMainWindow, QStackedWidget, QApplication
+
+
+class PageManager(QMainWindow):
+    """
+    页面管理器。通过向该管理器中注册界面，在界面中实现跳转到其他界面，并且传输数据。
+    """
+
+    def __init__(self):
+        super().__init__()
+        # 页面栈
+        self.page_stack = QStackedWidget(self)
+        self.page_stack.setStyleSheet(
+            "background-color: #ffffff;"
+            "border:none;"
+        )
+        # 页面序号字典
+        self.page_dict = dict()
+
+    # 向管理器中增加一个界面
+    def add_page(self, page_name, page):
+        """
+        向页面管理器中增加一个新的界面
+        :param page_name: 该页面的名称
+        :param page: 该页面对象
+        :return:
+        """
+        # 注册该界面
+        self.page_stack.addWidget(page)
+        self.page_dict[page_name] = page
+
+    # 启动ui界面
+    def start_ui(self):
+        """
+        启动UI
+        :return:
+        """
+        self.setCentralWidget(self.page_stack)
+        self.showMaximized()
+        # self.showFullScreen()  # 设置窗口全屏显示
+
+    def jump2(self, page_name, data):
+        """
+        用于其他页面中请求跳转到其他界面
+        :param page_name: 目标跳转界面名称
+        :param data: 附带的页面数据
+        :return:
+        """
+        page = self.page_dict[page_name]
+        # 更新页面数据
+        page.set_data(data)
+        page.refresh()
+        # 执行页面跳转
+        self.page_stack.setCurrentWidget(page)
+
+    def back2page(self, page_name):
+        pre_page = self.page_dict[page_name]
+        # 执行页面跳转
+        self.page_stack.setCurrentWidget(pre_page)
+
+
+APP = QApplication(sys.argv)
+BASE_PAGE_TERMINAL = PageManager()  # 终端页面管理器
+
+
+def keep_ui():
+    sys.exit(APP.exec_())

BaseFrontendManager/based_widget.py

@@ -0,0 +1,7 @@
+from PyQt5.QtWidgets import QWidget
+from BaseFrontend.message_manager import PageUpdateManager
+
+
+class BasedWidget(QWidget, PageUpdateManager):
+    def __init__(self):
+        super().__init__()

BaseFrontendManager/message_manager.py

@@ -0,0 +1,32 @@
+from BaseFrontendManager.page_manager import *
+
+
+class PageUpdateManager:
+    """
+    页面跳转中间层，控制基本的页面跳转和信息传递。
+    """
+
+    def __init__(self, page_manager: PageManager = BASE_PAGE_MANAGER) -> None:
+        super().__init__()
+        self.page_manager = page_manager
+        self.data = dict()
+
+    def back2page(self, page_name):
+        self.page_manager.back2page(page_name)
+
+    # 跳转到其他页面
+    def jump2(self, page_name, data=None):
+        if data is None:
+            data = {}
+        self.page_manager.jump2(page_name, data)
+
+    # 对外api，更新该类的显示数据
+    def set_data(self, data):
+        self.data = data
+
+    def get_data(self):
+        return self.data
+
+    # 在这里定义页面跳变的刷新方法
+    def refresh(self):
+        pass

BaseFrontendManager/page_manager.py

@@ -0,0 +1,197 @@
+import sys
+from PyQt5.QtWidgets import *
+from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtGui import QIcon
+from LSZXPagesManagerLibrary.consensus import *
+
+
+class PageSwitcher(QMainWindow):
+    """
+    页面管理器。通过向该管理器中注册界面，在界面中实现跳转到其他界面，并且传输数据。
+    """
+
+    def __init__(self):
+        super().__init__()
+        # 页面序号字典
+        self.page_dict = dict()
+        # 页面栈
+        self.tag_buttons = []
+        self.logo = self._init_logo_widget()
+        # 创建顶部按钮布局
+        self.top_layout = QHBoxLayout()
+        # 创建页面切换容器
+        self.stacked_widget = QStackedWidget()
+
+        self.wifi_widget = self.init_wifi_widget()
+        self.wifi_disconnect_widget = self.init_wifi_disconnect_widget()
+        self.wifi_stacked_widget = QStackedWidget()
+        self.wifi_stacked_widget.addWidget(self.wifi_widget)
+        self.wifi_stacked_widget.addWidget(self.wifi_disconnect_widget)
+        self.empty = QFrame()
+
+        self.wifi_layout = QVBoxLayout()
+        self.wifi_layout.addWidget(self.empty, 6)
+        self.wifi_layout.addWidget(self.wifi_stacked_widget, 12)
+        self.wifi_layout.addWidget(self.empty, 82)
+
+        self.center_layout = QHBoxLayout()
+        self.center_layout.addWidget(self.stacked_widget, 94)
+        self.center_layout.addLayout(self.wifi_layout, 6)
+        # 主布局
+        self.main_layout = QVBoxLayout()
+        self.main_layout.addLayout(self.top_layout)
+        self.main_layout.addLayout(self.center_layout)
+        # 创建一个中心部件，并设置布局
+        self.central_widget = QWidget()
+        self.central_widget.setLayout(self.main_layout)
+        self.central_widget.setStyleSheet(
+            "background-color: #ffffff;"
+            "border:none;"
+        )
+
+    # 向管理器中增加一个界面
+    # 添加页面（page_widget）、添加按钮（page_name）、把按钮和页面绑定关联，点击按钮时切换页面
+    def add_page(self, page_widget, page_name):
+        self.stacked_widget.addWidget(page_widget)
+
+        tag_button = self.create_button(page_name)
+        self.tag_buttons.append(tag_button)
+        # 初始化时设置第一个按钮样式
+        first_button = self.tag_buttons[0]
+        self.change_button_style(first_button)
+
+        tag_button.mousePressEvent = lambda event, lbl=tag_button: self.clicked_reaction(event, lbl)
+        self.top_layout.addWidget(tag_button, 15)
+        self.top_layout.addWidget(self.logo, 10)
+
+    # 启动ui界面
+    def start_ui(self):
+        """
+        启动UI
+        :return:
+        """
+        self.setCentralWidget(self.central_widget)
+        self.showMaximized()
+        # self.showFullScreen()  # 设置窗口全屏显示
+
+    # 按钮点击事件绑定切换后的页面
+    def clicked_reaction(self, event, label):
+        index = self.tag_buttons.index(label)
+        self.stacked_widget.setCurrentIndex(index)
+        for button in self.tag_buttons:
+            self.button_style(button)
+        self.change_button_style(label)
+
+    def handleCurrentChanged(self, index):
+        if index == 4:  # 页面 2 的索引为 1
+            for button in self.tag_buttons:
+                button.hide()
+        else:
+            for button in self.tag_buttons:
+                button.show()
+
+    # 顶部按钮
+    def create_button(self, text):
+        button = QLabel(text)
+        button.setAlignment(Qt.AlignCenter)
+        self.button_style(button)
+        return button
+
+    def button_style(self, button):
+        button.setStyleSheet(
+            "font: 600 30px \"Microsoft YaHei UI\";"
+            "letter-spacing: 4px;"
+            "padding-top: 10px;"
+            "padding-bottom: 10px;"
+            "margin-left: 6px;"
+            "margin-right: 6px;"
+        )
+
+    def change_button_style(self, button):
+        button.setStyleSheet(
+            "font: 600 30px \"Microsoft YaHei UI\";"
+            "letter-spacing: 4px;"
+            "padding-top: 10px;"
+            "padding-bottom: 10px;"
+            "margin-left: 6px;"
+            "margin-right: 6px;"
+            "color: #409eff;"
+        )
+
+    def jump2(self, page_name, data):
+        """
+        用于其他页面中请求跳转到其他界面
+        :param page_name: 目标跳转界面名称
+        :param data: 附带的页面数据
+        :return:
+        """
+        page = self.page_dict[page_name]
+        # 更新页面数据
+        page.set_data(data)
+        page.refresh()
+        # 执行页面跳转
+        self.stacked_widget.setCurrentWidget(page)
+
+    def back2page(self, page_name):
+        pre_page = self.page_dict[page_name]
+        # 执行页面跳转
+        self.stacked_widget.setCurrentWidget(pre_page)
+
+    @staticmethod
+    def _init_logo_widget():
+        logo = QLabel()
+        logo.setStyleSheet(
+            "border-image: url(assets/horizontal_logo.png);"
+            "background-size: contain;"
+            "background-repeat: no-repeat;"
+            "background-position: center;"
+            "padding-top: 10px;"
+            "padding-bottom: 10px;"
+        )
+        logo.setAlignment(Qt.AlignCenter)
+        logo.setScaledContents(True)
+        return logo
+
+    @staticmethod
+    def init_wifi_widget():
+        wifi_frame = QPushButton()
+        icon = QIcon("assets/wifi.png")
+        wifi_frame.setIconSize(QSize(70, 70))
+        wifi_frame.setIcon(icon)
+        wifi_frame.setStyleSheet(
+            "background-color: qlineargradient("
+            "spread: pad,"
+            "x1: 0,"
+            "y1: 0,"
+            "x2: 1,"
+            "y2: 1,"
+            "stop: 0 rgba(113, 183, 255, 255),"
+            "stop: 1 rgba(79, 149, 224, 255),"
+            "stop: 2 rgba(56, 147, 242, 255));"
+            "border-style: none;"
+            "border-radius: 50%;"
+            "height: 100px;"
+        )
+        return wifi_frame
+
+    @staticmethod
+    def init_wifi_disconnect_widget():
+        wifi_disconnect_widget = QPushButton()
+        icon = QIcon("assets/wifi.png")
+        wifi_disconnect_widget.setIconSize(QSize(70, 70))
+        wifi_disconnect_widget.setIcon(icon)
+        wifi_disconnect_widget.setStyleSheet(
+            "background-color: #c2c2c3;"
+            "border-style: none;"
+            "border-radius: 50%;"
+            "height: 100px;"
+        )
+        return wifi_disconnect_widget
+
+
+APP = QApplication(sys.argv)
+BASE_PAGE_MANAGER = PageSwitcher()  # 管理端页面管理器
+
+
+def keep_ui():
+    sys.exit(APP.exec_())

BaseStation/base_station.py

@@ -0,0 +1,124 @@
+import threading
+import time
+import traceback
+
+import requests
+
+from LSZXBackend.general import *
+from LSZXNetWork.network import Network
+from DeviceDefine.consensus import UNKNOWN
+
+import UWB
+import UWB.positioning_standalone
+import UWB.positioning_standalone_v2
+import UWB.positioning_cluster
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+
+
+class BaseStation:
+    def __init__(
+            self, master_mode=True,
+            positioning=True, multi_positioning_mode=True, device_type=UNKNOWN
+    ):
+        self.positioning = None
+        self.connection = Network(master_mode=master_mode, device_type=device_type)
+        self.multi_positioning_mode = multi_positioning_mode
+        self.positioning = UWB.positioning_standalone_v2.Positioning()
+        self.positioning.start()
+        self.positioning.resume()
+
+        self.send_information_signal = threading.Event()
+        threading.Thread(target=self.send_information).start()
+
+        self.HrBo_info = {}
+        self.connection.connect2wifi("LiShuZuoXun-DISPLAY")
+
+    # 获取hrbo信息
+    def get_information(self):
+        while True:
+            try:
+                HrBo_info = self.positioning.get_data()
+                # 长时间未更新，判定为离场
+                temp = self.HrBo_info.copy()
+                # print(self.HrBo_info)
+                for k, v in temp.items():
+                    this_time = time.time()
+                    if this_time - v['record_time'] > 60:
+                        del self.HrBo_info[k]
+                if HrBo_info:
+                    # print(HrBo_info)
+
+                    p_id = HrBo_info["tag_id"]
+
+                    if p_id not in self.HrBo_info:
+                        self.HrBo_info[p_id] = {}
+                    if HrBo_info[HR] and HrBo_info[BO]:
+                        if 180 > HrBo_info[HR] > 130:
+                            hr_c = 'Y'
+                        elif HrBo_info[HR] > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= HrBo_info[BO] < 88:
+                            bo_c = 'Y'
+                        elif HrBo_info[BO] < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        if HrBo_info[HR] < 65:
+                            HrBo_info[HR] = 85
+                        if HrBo_info[BO] < 80:
+                            HrBo_info[BO] = 80
+
+                        if HrBo_info[BO] > 100:
+                            HrBo_info[BO] = 97
+                        if HrBo_info[HR] > 180:
+                            HrBo_info[HR] = 177
+                        self.HrBo_info[p_id]['hr'] = {'hr': HrBo_info[HR], 'color': hr_c}
+                        self.HrBo_info[p_id]['bo'] = {'bo': "{:.2%}".format(HrBo_info[BO] / 100), 'color': bo_c}
+                        self.HrBo_info[p_id]['normal'] = True
+                    else:
+                        self.HrBo_info[p_id]['hr'] = '-'
+                        self.HrBo_info[p_id]['bo'] = '-'
+                        self.HrBo_info[p_id]['normal'] = True
+                    self.HrBo_info[p_id]['record_time'] = HrBo_info['record_time']
+                    # self.send_information_signal.set()
+                    # time.sleep(1)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_information(self):
+        while True:
+            try:
+                time.sleep(0.5)
+                # self.send_information_signal.wait()
+                # self.send_information_signal.clear()
+                manager_ip_list = self.connection.get_manager()
+                # print(manager_ip_list)
+                print(len(self.HrBo_info), self.HrBo_info)
+                ip = self.connection.get_self_ip()
+                _ip = ip.split('.')[2]
+                if manager_ip_list and _ip == '138':
+                    broadcast_pkg = {
+                        "data": self.HrBo_info, 'ip': ip
+                    }
+                    for manage_ip in manager_ip_list:
+                        try:
+                            requests.post(url=f"http://{manage_ip}:{MANAGER}/totals_HrBoInfo_server",
+                                          json=broadcast_pkg, timeout=0.1)
+                        except:
+                            continue
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

BaseStation/base_station_pyqt.py

@@ -0,0 +1,118 @@
+from LSZXBackend.general import *
+from LSZXNetWork.lszx_network import *
+from DeviceDefine.consensus import UNKNOWN
+
+import UWB
+import UWB.positioning_standalone
+import UWB.positioning_standalone_v2
+import UWB.positioning_cluster
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+video_path = os.path.join(GLOBAL_DIR, "LSZXVideo", "Video")
+
+
+# 基站 收集人员hrbo信息
+class BaseStation:
+    def __init__(
+            self, master_mode=True,
+            positioning=True, multi_positioning_mode=True, device_type=UNKNOWN
+    ):
+        self.positioning = None
+        self.connection = Network(master_mode=master_mode, device_type=device_type)
+        self.multi_positioning_mode = multi_positioning_mode
+        self.positioning = UWB.positioning_standalone_v2.Positioning()
+        self.positioning.start()
+        self.positioning.resume()
+
+        self.server = Server(ip="0.0.0.0", port=server_port, file_port=server_file_port, cache_path=video_path)
+        self.client = Client(ip="0.0.0.0")
+
+        self.send_information_signal = threading.Event()
+        threading.Thread(target=self.send_information).start()
+
+        self.HrBo_info = {}
+        self.connection.connect2wifi("LiShuZuoXun-DISPLAY")
+
+    # 获取hrbo信息
+    def get_information(self):
+        while True:
+            try:
+                HrBo_info = self.positioning.get_data()
+                # 长时间未更新，判定为离场
+                temp = self.HrBo_info.copy()
+                # print(self.HrBo_info)
+                for k, v in temp.items():
+                    this_time = time.time()
+                    if this_time - v['record_time'] > 60:
+                        del self.HrBo_info[k]
+                if HrBo_info:
+                    # print(HrBo_info)
+
+                    p_id = HrBo_info["tag_id"]
+
+                    if p_id not in self.HrBo_info:
+                        self.HrBo_info[p_id] = {}
+                    if HrBo_info[HR] and HrBo_info[BO]:
+                        if 180 > HrBo_info[HR] > 130:
+                            hr_c = 'Y'
+                        elif HrBo_info[HR] > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= HrBo_info[BO] < 88:
+                            bo_c = 'Y'
+                        elif HrBo_info[BO] < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        if HrBo_info[HR] < 65:
+                            HrBo_info[HR] = 85
+                        if HrBo_info[BO] < 80:
+                            HrBo_info[BO] = 80
+
+                        if HrBo_info[BO] > 100:
+                            HrBo_info[BO] = 97
+                        if HrBo_info[HR] > 180:
+                            HrBo_info[HR] = 177
+                        self.HrBo_info[p_id]['hr'] = {'hr': HrBo_info[HR], 'color': hr_c}
+                        self.HrBo_info[p_id]['bo'] = {'bo': "{:.2%}".format(HrBo_info[BO] / 100), 'color': bo_c}
+                        self.HrBo_info[p_id]['normal'] = True
+                    else:
+                        self.HrBo_info[p_id]['hr'] = '-'
+                        self.HrBo_info[p_id]['bo'] = '-'
+                        self.HrBo_info[p_id]['normal'] = True
+                    self.HrBo_info[p_id]['record_time'] = HrBo_info['record_time']
+                    # self.send_information_signal.set()
+                    # time.sleep(1)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_information(self):
+        while True:
+            try:
+                time.sleep(0.5)
+                ip = self.connection.get_self_ip()
+                broadcast_pkg = [{
+                    "data": self.HrBo_info, 'ip': ip, 'data_type': 'hrbo_data'
+                }]
+                print(broadcast_pkg)
+                # 发送成绩信息
+                address_list = []
+                pkg_list = []
+                for manage_ip in self.connection.get_manager():
+                    address_list.append((manage_ip, server_port))
+                    pkg_list.append(broadcast_pkg)
+                self.client.distributed_send(address_list, pkg_list)
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

BaseStation/fake_examine_info.py

@@ -0,0 +1,135 @@
+import time
+import threading
+import traceback
+import random
+from copy import deepcopy
+
+import requests
+
+from LSZXBackend.general import *
+from DeviceDefine.consensus import *
+
+
+class BaseStation:
+    def __init__(self):
+        self.ip = '127.0.0.1'
+        self.situp = {'count': 0, 'time': time.time(), 'name': '人员1', 'id': 1, 'hr': 85, 'bo': 92, 'normal': True, 'h_time':time.time()}
+        self.pullup = {'count': 0, 'time': time.time(), 'name': '人员2', 'id': 2, 'hr': 85, 'bo': 92, 'normal': True, 'h_time':time.time()}
+        self.runaround = {'count': 0.0, 'time': time.time(), 'name': '人员3', 'id': 3, 'hr': 85, 'bo': 92, 'normal': True, 'h_time':time.time()}
+        self.pushup = {'count': 0, 'time': time.time(), 'name': '人员4', 'id': 4, 'hr': 85, 'bo': 92, 'normal': True, 'h_time':time.time()}
+        self.running = []
+        self.finish_num = 0
+        threading.Thread(target=self.running_info).start()
+        self.fake_info = {SITUP: self.situp, PULLUP: self.pullup, PUSHUP: self.pushup, RUNAROUND: self.runaround,
+                          RUNNING: self.running, 'time': time.time()}
+        threading.Thread(target=self.send_info).start()
+
+    def send_info(self):
+        while True:
+            try:
+                this_time = time.time()
+                if this_time - self.situp['time'] >= 1.2:
+                    self.situp['count'] += 1
+                    if this_time - self.situp['h_time'] > 5:
+                        self.situp['hr'] = random.randint(72, 132)
+                        self.situp['bo'] = random.randint(88, 97)
+                        self.situp['h_time'] = this_time
+                    self.situp['time'] = this_time
+                if this_time - self.pullup['time'] >= 1.8:
+                    self.pullup['count'] += 1
+                    if this_time - self.pullup['h_time'] > 5:
+                        self.pullup['hr'] = random.randint(72, 132)
+                        self.pullup['bo'] = random.randint(88, 97)
+                        self.pullup['h_time'] = this_time
+                    self.pullup['time'] = this_time
+                if this_time - self.pushup['time'] > 1.5:
+                    self.pushup['count'] += 1
+                    if this_time - self.pushup['h_time'] > 5:
+                        self.pushup['hr'] = random.randint(72, 132)
+                        self.pushup['bo'] = random.randint(88, 97)
+                        self.pushup['h_time'] = this_time
+                    self.pushup['time'] = this_time
+                self.runaround['count'] = this_time - self.runaround['time']
+                if this_time - self.runaround['h_time'] > 5:
+                    self.runaround['hr'] = random.randint(72, 132)
+                    self.runaround['bo'] = random.randint(88, 97)
+                    self.runaround['h_time'] = this_time
+
+                if self.situp['count'] == 89:
+                    self.situp['count'] = 0
+                if self.pullup['count'] == 17:
+                    self.pullup['count'] = 0
+                if self.pushup['count'] == 67:
+                    self.pushup['count'] = 0
+                if self.runaround['count'] > 25:
+                    self.runaround['count'] = 0
+                    self.runaround['time'] = this_time
+
+                for i in self.running:
+                    count = this_time - i['time']
+                    if i['finish'] != '已完成':
+                        i['count'] = count
+                        if count > i['c_time']:
+                            i['round'] += 1
+                            i['c_time'] = i['c_time'] + 240
+                    if count > i['final_time']:
+                        i['finish'] = '已完成'
+                        self.finish_num += 1
+                    if this_time - i['h_time'] > 5:
+                        i['hr'] = random.randint(72, 132)
+                        i['bo'] = random.randint(88, 97)
+                        i['h_time'] = this_time
+                if self.finish_num >= 10:
+                    self.finish_num = 0
+                    threading.Thread(target=self.running_info).start()
+
+                self.fake_info['time'] = this_time
+                broadcast_pkg = {
+                    DATA: self.fake_info, 'ip': self.ip
+                }
+                print(broadcast_pkg)
+                try:
+                    requests.post(url=f"http://{self.ip}:{34567}/totals_synchronization_server",
+                                  json=broadcast_pkg, timeout=1)
+                except:
+                    print(traceback.format_exc())
+                    continue
+                time.sleep(0.4)
+            except:
+                print(traceback.format_exc())
+
+    def running_info(self):
+        try:
+            self.running = []
+            _rank = [random.randint(720, 800) for _ in range(10)]
+            _rank.sort()
+            rank_list = deepcopy(_rank)
+            while len(self.running) < 10:
+                try:
+                    rank = random.choice(_rank)
+                    self.running.append({
+                        'id': len(self.running) + 5,
+                        'name': '人员' + str(len(self.running) + 1),
+                        'hr': 85,
+                        'bo': 92,
+                        'count': 0.0,
+                        'time': time.time(),
+                        'normal': True,
+                        'round': 0,
+                        'finish': '已开始',
+                        'rank': rank_list.index(rank) + 1,
+                        'final_time': rank,
+                        'c_time': rank / 3,
+                        'h_time': time.time()
+                    })
+                    _rank.remove(rank)
+                except IndexError:
+                    break
+            self.fake_info = {SITUP: self.situp, PULLUP: self.pullup, PUSHUP: self.pushup, RUNAROUND: self.runaround,
+                              RUNNING: self.running, 'time': time.time()}
+        except:
+            print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()

BaseStation/fake_examine_info_pyqt.py

@@ -0,0 +1,142 @@
+import random
+from copy import deepcopy
+
+import requests
+
+from LSZXBackend.general import *
+from LSZXNetWork.lszx_network import *
+video_path = os.path.join(GLOBAL_DIR, "LSZXVideo", "Video")
+
+
+# 模拟大屏数据
+class BaseStation:
+    def __init__(self):
+        self.ip = '127.0.0.1'
+        self.situp = {'count': 0, 'time': time.time(), 'name': '人员1', 'id': 1, 'hr': 85, 'bo': 92, 'normal': True,
+                      'h_time': time.time()}
+        self.pullup = {'count': 0, 'time': time.time(), 'name': '人员2', 'id': 2, 'hr': 85, 'bo': 92, 'normal': True,
+                       'h_time': time.time()}
+        self.runaround = {'count': 0.0, 'time': time.time(), 'name': '人员3', 'id': 3, 'hr': 85, 'bo': 92, 'normal': True,
+                          'h_time': time.time()}
+        self.pushup = {'count': 0, 'time': time.time(), 'name': '人员4', 'id': 4, 'hr': 85, 'bo': 92, 'normal': True,
+                       'h_time': time.time()}
+        self.running = []
+        self.finish_num = 0
+        threading.Thread(target=self.running_info).start()
+        self.fake_info = {SITUP: self.situp, PULLUP: self.pullup, PUSHUP: self.pushup, RUNAROUND: self.runaround,
+                          RUNNING: self.running, 'time': time.time()}
+
+        self.server = Server(ip="0.0.0.0", port=server_port, file_port=server_file_port, cache_path=video_path)
+        self.client = Client(ip="0.0.0.0")
+
+        threading.Thread(target=self.send_info).start()
+
+    def send_info(self):
+        while True:
+            try:
+                this_time = time.time()
+                if this_time - self.situp['time'] >= 1.2:
+                    self.situp['count'] += 1
+                    if this_time - self.situp['h_time'] > 5:
+                        self.situp['hr'] = random.randint(72, 132)
+                        self.situp['bo'] = random.randint(88, 97)
+                        self.situp['h_time'] = this_time
+                    self.situp['time'] = this_time
+                if this_time - self.pullup['time'] >= 1.8:
+                    self.pullup['count'] += 1
+                    if this_time - self.pullup['h_time'] > 5:
+                        self.pullup['hr'] = random.randint(72, 132)
+                        self.pullup['bo'] = random.randint(88, 97)
+                        self.pullup['h_time'] = this_time
+                    self.pullup['time'] = this_time
+                if this_time - self.pushup['time'] > 1.5:
+                    self.pushup['count'] += 1
+                    if this_time - self.pushup['h_time'] > 5:
+                        self.pushup['hr'] = random.randint(72, 132)
+                        self.pushup['bo'] = random.randint(88, 97)
+                        self.pushup['h_time'] = this_time
+                    self.pushup['time'] = this_time
+                self.runaround['count'] = this_time - self.runaround['time']
+                if this_time - self.runaround['h_time'] > 5:
+                    self.runaround['hr'] = random.randint(72, 132)
+                    self.runaround['bo'] = random.randint(88, 97)
+                    self.runaround['h_time'] = this_time
+
+                if self.situp['count'] == 89:
+                    self.situp['count'] = 0
+                if self.pullup['count'] == 17:
+                    self.pullup['count'] = 0
+                if self.pushup['count'] == 67:
+                    self.pushup['count'] = 0
+                if self.runaround['count'] > 25:
+                    self.runaround['count'] = 0
+                    self.runaround['time'] = this_time
+
+                for i in self.running:
+                    count = this_time - i['time']
+                    if i['finish'] != '已完成':
+                        i['count'] = count
+                        if count > i['c_time']:
+                            i['round'] += 1
+                            i['c_time'] = i['c_time'] + 240
+                    if count > i['final_time']:
+                        i['finish'] = '已完成'
+                        self.finish_num += 1
+                    if this_time - i['h_time'] > 5:
+                        i['hr'] = random.randint(72, 132)
+                        i['bo'] = random.randint(88, 97)
+                        i['h_time'] = this_time
+                if self.finish_num >= 10:
+                    self.finish_num = 0
+                    threading.Thread(target=self.running_info).start()
+
+                self.fake_info['time'] = this_time
+                broadcast_pkg = {
+                    DATA: self.fake_info, 'ip': self.ip
+                }
+                print(broadcast_pkg)
+
+                address_list = []
+                pkg_list = []
+                address_list.append((self.ip, server_port))
+                pkg_list.append([{'data': broadcast_pkg, 'data_type': 'totals_data'}])
+                self.client.distributed_send(address_list, pkg_list)
+                time.sleep(0.4)
+            except:
+                print(traceback.format_exc())
+
+    def running_info(self):
+        try:
+            self.running = []
+            _rank = [random.randint(720, 800) for _ in range(10)]
+            _rank.sort()
+            rank_list = deepcopy(_rank)
+            while len(self.running) < 10:
+                try:
+                    rank = random.choice(_rank)
+                    self.running.append({
+                        'id': len(self.running) + 5,
+                        'name': '人员' + str(len(self.running) + 1),
+                        'hr': 85,
+                        'bo': 92,
+                        'count': 0.0,
+                        'time': time.time(),
+                        'normal': True,
+                        'round': 0,
+                        'finish': '已开始',
+                        'rank': rank_list.index(rank) + 1,
+                        'final_time': rank,
+                        'c_time': rank / 3,
+                        'h_time': time.time()
+                    })
+                    _rank.remove(rank)
+                except IndexError:
+                    break
+            self.fake_info = {SITUP: self.situp, PULLUP: self.pullup, PUSHUP: self.pushup, RUNAROUND: self.runaround,
+                              RUNNING: self.running, 'time': time.time()}
+        except:
+            print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()

BaseStation/fake_hrbo_data.py

@@ -0,0 +1,117 @@
+import threading
+import time
+import traceback
+
+import requests
+
+from LSZXBackend.general import *
+from LSZXNetWork.network import Network
+from DeviceDefine.consensus import UNKNOWN, SLAVER
+
+import UWB
+import UWB.positioning_standalone
+import UWB.positioning_standalone_v2
+import UWB.positioning_cluster
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+
+
+class BaseStation:
+    def __init__(
+            self, master_mode=True,
+            positioning=True, multi_positioning_mode=True, device_type=UNKNOWN
+    ):
+        # self.positioning = None
+        self.connection = Network(master_mode=master_mode, device_type=device_type)
+        self.multi_positioning_mode = multi_positioning_mode
+        # self.positioning = UWB.positioning_standalone_v2.Positioning()
+        # self.positioning.start()
+        # self.positioning.resume()
+
+        self.send_information_signal = threading.Event()
+        threading.Thread(target=self.send_fake_information).start()
+
+        self.HrBo_info = {}
+        self.connection.connect2wifi("LiShuZuoXun-DISPLAY")
+
+    # 获取hrbo信息  ··
+    def get_information(self):
+        while True:
+            try:
+                # HrBo_info = self.positioning.get_data()
+                # HrBo_info = {'tag_id': '320110F39011', 'hr': 225, 'bo': 76, 'record_time': time.time()}  # 新2
+                HrBo_info = {'tag_id': '320110f392b7', 'hr': 188, 'bo': 82, 'record_time': time.time()}  # 新34
+                # 长时间未更新，判定为离场
+                temp = self.HrBo_info.copy()
+                for k, v in temp.items():
+                    this_time = time.time()
+                    if this_time - v['record_time'] > 60:
+                        del self.HrBo_info[k]
+                if HrBo_info:
+                    p_id = HrBo_info["tag_id"]
+                    if p_id not in self.HrBo_info:
+                        self.HrBo_info[p_id] = {}
+                    if HrBo_info[HR] and HrBo_info[BO]:
+                        if 180 > HrBo_info[HR] > 140:
+                            hr_c = 'Y'
+                        elif HrBo_info[HR] > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= HrBo_info[BO] < 88:
+                            bo_c = 'Y'
+                        elif HrBo_info[BO] < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        self.HrBo_info[p_id]['hr'] = {'hr': HrBo_info[HR], 'color': hr_c}
+                        self.HrBo_info[p_id]['bo'] = {'bo': "{:.2%}".format(HrBo_info[BO] / 100), 'color': bo_c}
+                        if HrBo_info[HR] >= 180 or HrBo_info[BO] <= 85:
+                            self.HrBo_info[p_id]['normal'] = False
+                        else:
+                            self.HrBo_info[p_id]['normal'] = True
+                    else:
+                        self.HrBo_info[p_id]['hr'] = '-'
+                        self.HrBo_info[p_id]['bo'] = '-'
+                        self.HrBo_info[p_id]['normal'] = True
+                    self.HrBo_info[p_id]['record_time'] = HrBo_info['record_time']
+                    # self.send_information_signal.set()
+                time.sleep(0.5)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_fake_information(self):
+        while True:
+            try:
+                time.sleep(0.5)
+                # self.send_information_signal.wait()
+                # self.send_information_signal.clear()
+                manager_ip_list = self.connection.get_manager()
+                ip = self.connection.get_self_ip()
+                _ip = ip.split('.')[2]
+                print(self.HrBo_info)
+                if manager_ip_list and _ip == '138':
+                    broadcast_pkg = {
+                        "data": self.HrBo_info, 'ip': ip
+                    }
+                    for manage_ip in manager_ip_list:
+                        try:
+                            print(manage_ip)
+                            requests.post(url=f"http://{manage_ip}:{MANAGER}/totals_HrBoInfo_server",
+                                          json=broadcast_pkg, timeout=1)
+                        except:
+                            print(1111111111111)
+                            continue
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

BaseStation/fake_hrbo_data_pyqt.py

@@ -0,0 +1,108 @@
+from LSZXBackend.general import *
+from LSZXNetWork.lszx_network import *
+from DeviceDefine.consensus import UNKNOWN
+
+import UWB
+import UWB.positioning_standalone
+import UWB.positioning_standalone_v2
+import UWB.positioning_cluster
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+video_path = os.path.join(GLOBAL_DIR, "LSZXVideo", "Video")
+
+# 基站 收集人员hrbo信息
+class BaseStation:
+    def __init__(
+            self, master_mode=True,
+            positioning=True, multi_positioning_mode=True, device_type=UNKNOWN
+    ):
+        self.positioning = None
+        self.connection = Network(master_mode=master_mode, device_type=device_type)
+        self.multi_positioning_mode = multi_positioning_mode
+        self.positioning = UWB.positioning_standalone_v2.Positioning()
+        self.positioning.start()
+        self.positioning.resume()
+
+        self.server = Server(ip="0.0.0.0", port=server_port, file_port=server_file_port, cache_path=video_path)
+        self.client = Client(ip="0.0.0.0")
+
+        self.send_information_signal = threading.Event()
+        threading.Thread(target=self.send_fake_information).start()
+
+        self.HrBo_info = {}
+        self.connection.connect2wifi("LiShuZuoXun-DISPLAY")
+
+    # 获取hrbo信息  ··
+    def get_information(self):
+        while True:
+            try:
+                # HrBo_info = self.positioning.get_data()
+                HrBo_info = {'tag_id': '320110f392b7', 'hr': 188, 'bo': 82, 'record_time': time.time()}  # 新34
+                # 长时间未更新，判定为离场
+                temp = self.HrBo_info.copy()
+                for k, v in temp.items():
+                    this_time = time.time()
+                    if this_time - v['record_time'] > 60:
+                        del self.HrBo_info[k]
+                if HrBo_info:
+                    p_id = HrBo_info["tag_id"]
+                    if p_id not in self.HrBo_info:
+                        self.HrBo_info[p_id] = {}
+                    if HrBo_info[HR] and HrBo_info[BO]:
+                        if 180 > HrBo_info[HR] > 140:
+                            hr_c = 'Y'
+                        elif HrBo_info[HR] > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= HrBo_info[BO] < 88:
+                            bo_c = 'Y'
+                        elif HrBo_info[BO] < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        self.HrBo_info[p_id]['hr'] = {'hr': HrBo_info[HR], 'color': hr_c}
+                        self.HrBo_info[p_id]['bo'] = {'bo': "{:.2%}".format(HrBo_info[BO] / 100), 'color': bo_c}
+                        if HrBo_info[HR] >= 180 or HrBo_info[BO] <= 85:
+                            self.HrBo_info[p_id]['normal'] = False
+                        else:
+                            self.HrBo_info[p_id]['normal'] = True
+                    else:
+                        self.HrBo_info[p_id]['hr'] = '-'
+                        self.HrBo_info[p_id]['bo'] = '-'
+                        self.HrBo_info[p_id]['normal'] = True
+                    self.HrBo_info[p_id]['record_time'] = HrBo_info['record_time']
+                    # self.send_information_signal.set()
+                time.sleep(0.5)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_fake_information(self):
+        while True:
+            try:
+                time.sleep(0.5)
+                ip = self.connection.get_self_ip()
+                broadcast_pkg = [{
+                    "data": self.HrBo_info, 'ip': ip, 'data_type': 'hrbo_data'
+                }]
+                print(broadcast_pkg)
+                # 发送成绩信息
+                address_list = []
+                pkg_list = []
+                for manage_ip in self.connection.get_manager():
+                    address_list.append((manage_ip, server_port))
+                    pkg_list.append(broadcast_pkg)
+                self.client.distributed_send(address_list, pkg_list)
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

BaseStation/fake_hrbo_info.py

@@ -0,0 +1,88 @@
+import os
+import threading
+import time
+import traceback
+import random
+
+import pandas as pd
+import requests
+
+from AcrossPlatform.get_platform import *
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+
+
+class BaseStation:
+    def __init__(self):
+
+        self.send_information_signal = threading.Event()
+        threading.Thread(target=self.send_fake_information).start()
+
+        file_path = os.path.join(GLOBAL_DIR, 'BaseStation', 'PERSON.xlsx')
+        sheet_name = 'PERSON'
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+
+        column_name = 'band_id'
+        column_data = df[column_name].tolist()
+        self.HrBo_info = {}
+        for i in column_data:
+            hr = 85
+            self.HrBo_info[i] = {'hr': {'hr': hr, 'color': 'G'}, 'bo': {'bo': "{:.2%}".format(94 / 100), 'color': 'G'},
+                                 'normal': True, 'record_time': time.time()}
+        self.ip = '127.0.0.1'
+
+    # 获取hrbo信息
+    def get_information(self):
+        while True:
+            try:
+                this_time = time.time()
+                for k, v in self.HrBo_info.items():
+                    if this_time - v['record_time'] > 15:
+                        hr = random.randint(72, 145)
+                        bo = random.randint(83, 97)
+                        v['record_time'] = this_time
+
+                        if 180 >= hr > 140:
+                            hr_c = 'Y'
+                        elif hr > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= bo < 88:
+                            bo_c = 'Y'
+                        elif bo < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        v['hr'] = {'hr': hr, 'color': hr_c}
+                        v['bo'] = {'bo': "{:.2%}".format(bo / 100), 'color': bo_c}
+                time.sleep(0.5)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_fake_information(self):
+        while True:
+            try:
+                time.sleep(0.5)
+                print(self.HrBo_info)
+                broadcast_pkg = {
+                    "data": self.HrBo_info, 'ip': self.ip
+                }
+                try:
+                    requests.post(url=f"http://{self.ip}:{34567}/totals_HrBoInfo_server",
+                                  json=broadcast_pkg, timeout=1)
+                except:
+                    print(traceback.format_exc())
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

BaseStation/fake_hrbo_info_pyqt.py

@@ -0,0 +1,91 @@
+import random
+
+import pandas as pd
+
+from LSZXBackend.general import *
+from LSZXNetWork.lszx_network import *
+
+MAX_HR = "max_hr"
+MIN_BO = "min_bo"
+HR = "hr"
+BO = "bo"
+video_path = os.path.join(GLOBAL_DIR, "LSZXVideo", "Video")
+
+
+# 模拟收集人员hrbo信息
+class BaseStation:
+    def __init__(self):
+
+        self.send_information_signal = threading.Event()
+
+        file_path = os.path.join(GLOBAL_DIR, 'BaseStation', 'PERSON.xlsx')
+        sheet_name = 'PERSON'
+        df = pd.read_excel(file_path, sheet_name=sheet_name)
+        column_name = 'band_id'
+        column_data = df[column_name].tolist() if not df[column_name].empty else []
+        self.HrBo_info = {}
+        for i in column_data:
+            hr = 85
+            self.HrBo_info[i] = {'hr': {'hr': hr, 'color': 'G'}, 'bo': {'bo': "{:.2%}".format(94 / 100), 'color': 'G'},
+                                 'normal': True, 'record_time': time.time()}
+        self.ip = '127.0.0.1'
+
+        self.server = Server(ip="0.0.0.0", port=server_port, file_port=server_file_port, cache_path=video_path)
+        self.client = Client(ip="0.0.0.0")
+
+        threading.Thread(target=self.send_fake_information).start()
+
+    # 获取hrbo信息
+    def get_information(self):
+        while True:
+            try:
+                this_time = time.time()
+                for k, v in self.HrBo_info.items():
+                    if this_time - v['record_time'] > 15:
+                        hr = random.randint(72, 145)
+                        bo = random.randint(83, 97)
+                        v['record_time'] = this_time
+
+                        if 180 >= hr > 140:
+                            hr_c = 'Y'
+                        elif hr > 180:
+                            hr_c = 'R'
+                        else:
+                            hr_c = 'G'
+
+                        if 80 <= bo < 88:
+                            bo_c = 'Y'
+                        elif bo < 80:
+                            bo_c = 'R'
+                        else:
+                            bo_c = 'G'
+
+                        v['hr'] = {'hr': hr, 'color': hr_c}
+                        v['bo'] = {'bo': "{:.2%}".format(bo / 100), 'color': bo_c}
+                time.sleep(0.5)
+            except Exception as e:
+                print(traceback.format_exc())
+
+    # 发送hrbo信息给管理端
+    def send_fake_information(self):
+        while True:
+            try:
+
+                time.sleep(0.5)
+                broadcast_pkg = [{
+                    "data": self.HrBo_info, 'ip': self.ip, 'data_type': 'hrbo_data'
+                }]
+                print(broadcast_pkg)
+                # 发送成绩信息
+                address_list = []
+                pkg_list = []
+                address_list.append((self.ip, server_port))
+                pkg_list.append(broadcast_pkg)
+                self.client.distributed_send(address_list, pkg_list)
+            except Exception as e:
+                print(traceback.format_exc())
+
+
+if __name__ == '__main__':
+    basestation = BaseStation()
+    threading.Thread(target=basestation.get_information).start()

Database/manager_database.py

@@ -0,0 +1,557 @@
+# 作训系统管理界面数据
+import os
+import sqlite3
+import traceback
+
+import pandas as pd
+
+from AcrossPlatform.get_platform import GLOBAL_DIR
+from SQLDataBase.sql_server import SQLServer
+
+MANAGER_DIR = os.path.join(GLOBAL_DIR, "Manager")
+MANAGER_DATABASE = "Manager.db"
+
+# 人员特征
+ID = "id"
+NAME = "name"
+BAND_ID = "band_id"
+CLASS = "class"
+GENDER = "gender"
+AGE = "age"
+HEIGHT = "height"
+WEIGHT = "weight"
+BMI = "bmi"
+PBF = "pbf"
+PERSON_FEATURE_LIST = [
+    ID, NAME, BAND_ID, CLASS, GENDER, AGE, HEIGHT, WEIGHT, BMI, PBF
+]
+PERSON_TABLE_COLUMNS = ["人员编号", "姓名", "手环", "所在班", "性别", "年龄", "身高", "体重", "BMI", "PBF"]
+
+# 成绩特征
+PULLUP_COUNT = "pullup_count"
+PULLUP_SCORE = "pullup_score"
+HANGING_COUNT = "hanging_count"
+HANGING_SCORE = "hanging_score"
+PUSHUP_COUNT = "pushup_count"
+PUSHUP_SCORE = "pushup_score"
+SITUP_COUNT = "situp_count"
+SITUP_SCORE = "situp_score"
+RUNNING_COUNT = "running_count"
+RUNNING_SCORE = "running_score"
+RUN_BF_COUNT = "run_bf_count"
+RUN_BF_SCORE = "run_bf_score"
+FINAL_SCORE = "final_score"
+SCORE_FEATURE_LIST = [
+    ID, NAME, CLASS, GENDER, AGE, HEIGHT, WEIGHT, PULLUP_COUNT, PULLUP_SCORE, HANGING_COUNT, HANGING_SCORE,
+    PUSHUP_COUNT, PUSHUP_SCORE, SITUP_COUNT, SITUP_SCORE, RUNNING_COUNT, RUNNING_SCORE, RUN_BF_COUNT,
+    RUN_BF_SCORE, FINAL_SCORE
+]
+SCORE_TABLE_COLUMNS = [
+    "人员编号", "姓名", "所在班", "性别", "年龄", "身高", "体重", "引体向上个数", "引体向上成绩", "曲臂悬垂时间（秒）",
+    "曲臂悬垂成绩", "俯卧撑个数", "俯卧撑成绩", "仰卧起坐个数", "仰卧起坐成绩", "长跑时间（秒）", "长跑成绩",
+    "蛇形跑时间（秒）", "蛇形跑成绩", "最终成绩"
+]
+
+# 数据库状态
+ID_ERROR = 1
+UNKNOWN_ERROR = -1
+OK = 0
+NO_OBJ = 2
+
+
+class ManagerDatabase:
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.database = SQLServer(server_dir=MANAGER_DIR, server_name=MANAGER_DATABASE)
+        self._create_info_table()
+        self._create_score_table()
+
+    def _create_info_table(self):
+        sql = "CREATE TABLE IF NOT EXISTS PERSON (" \
+              "id CHAR(100) PRIMARY KEY," \
+              "name CHAR(100)," \
+              "band_id TEXT," \
+              "class TEXT," \
+              "gender CHAR(5)," \
+              "age INT," \
+              "height INT," \
+              "weight INT," \
+              "bmi float," \
+              "pbf float" \
+              ");"
+        self.database.execute(sql)
+
+    def _create_score_table(self):
+        sql = "CREATE TABLE IF NOT EXISTS SCORE (" \
+              "id CHAR(100) PRIMARY KEY," \
+              "name CHAR(100)," \
+              "class TEXT," \
+              "gender CHAR(5)," \
+              "age INT," \
+              "height INT," \
+              "weight INT," \
+              "pullup_count INT," \
+              "pullup_score float," \
+              "hanging_count INT," \
+              "hanging_score float," \
+              "pushup_count INT," \
+              "pushup_score float," \
+              "situp_count INT," \
+              "situp_score float," \
+              "running_count INT," \
+              "running_score float," \
+              "run_bf_count float," \
+              "run_bf_score float," \
+              "final_score float" \
+              ");"
+        self.database.execute(sql)
+
+    # 插入信息
+    def insert_a_info(self, data):
+        format_data = [data.get(column) for column in PERSON_FEATURE_LIST]
+        sql = "INSERT INTO PERSON ({}) VALUES ({});".format(
+            ", ".join(PERSON_FEATURE_LIST),
+            ", ".join(["?" for _ in PERSON_FEATURE_LIST])
+        )
+        format_data1 = [data.get(column) for column in SCORE_FEATURE_LIST]
+        sql1 = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        try:
+            self.database.execute(sql, format_data)
+            self.database.execute(sql1, format_data1)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+        except Exception as e:
+            print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+            return UNKNOWN_ERROR
+
+    # 从Excel导入一个数据
+    def insert_many_person_from_xlsx(self, xlsx_file_name):
+        df = pd.read_excel(xlsx_file_name)
+        df = df[PERSON_TABLE_COLUMNS]
+        data = df.values.tolist()
+        sql = "INSERT INTO PERSON ({}) VALUES ({});".format(
+            ", ".join(PERSON_FEATURE_LIST),
+            ", ".join(["?" for _ in PERSON_FEATURE_LIST])
+        )
+        sql2 = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        format_dir = [{PERSON_FEATURE_LIST[col]: row[col] for col in range(len(row))} for row in data]
+        try:
+            self.database.executemany(sql, data)
+            format_data = [[row.get(sfl) for sfl in SCORE_FEATURE_LIST] for row in format_dir]
+            self.database.executemany(sql2, format_data)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+
+    # 从json导入一个数据
+    def insert_many_person_from_json(self, data):
+        sql = "INSERT INTO PERSON ({}) VALUES ({});".format(
+            ", ".join(PERSON_FEATURE_LIST),
+            ", ".join(["?" for _ in PERSON_FEATURE_LIST])
+        )
+        sql2 = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        try:
+            format_data = [[row[pfl] for pfl in PERSON_FEATURE_LIST] for row in data]
+            self.database.executemany(sql, format_data)
+            format_data = [[row.get(sfl) for sfl in SCORE_FEATURE_LIST] for row in data]
+            self.database.executemany(sql2, format_data)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+
+    # 删除人员信息
+    def delete_a_person(self, _id):
+        sql = "SELECT * FROM PERSON WHERE id = ?"
+        person = self.database.execute(sql, (_id,))
+        if person:
+            sql = "DELETE FROM PERSON WHERE id = ?"
+            sql1 = "DELETE FROM SCORE WHERE id = ?"
+            try:
+                self.database.execute(sql, (_id,))
+                self.database.execute(sql1, (_id,))
+                self.database.commit()
+                return OK
+            except Exception as e:
+                print(e)
+                return UNKNOWN_ERROR
+        else:
+            return NO_OBJ
+
+    # 删除所有人员信息
+    def delete_all_person(self):
+        sql = "DELETE FROM PERSON"
+        sql1 = "DELETE FROM SCORE"
+        try:
+            self.database.execute(sql)
+            self.database.execute(sql1)
+            self.database.commit()
+            return OK
+        except Exception as e:
+            print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+            return UNKNOWN_ERROR
+
+    # 获得某个人员的信息
+    def select_a_person(self, _id):
+        sql = "SELECT {} FROM PERSON WHERE id = ?;".format(", ".join(PERSON_FEATURE_LIST))
+        data = self.database.execute(sql, (_id,))
+        result = []
+        for row in data:
+            r = {
+                PERSON_FEATURE_LIST[i]: row[i]
+                for i in range(len(PERSON_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 获得某个人员的信息
+    def select_a_person_from_band(self, band_id):
+        sql = "SELECT {} FROM PERSON WHERE band_id = ?;".format(", ".join(PERSON_FEATURE_LIST))
+        data = self.database.execute(sql, (band_id,))
+        result = []
+        for row in data:
+            r = {
+                PERSON_FEATURE_LIST[i]: row[i]
+                for i in range(len(PERSON_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 获取所有班级
+    def get_all_class(self):
+        sql = "SELECT DISTINCT class FROM PERSON"
+        data = self.database.execute(sql)
+        class_list = [row[0] for row in data]
+        return class_list
+
+    # 获取一个班级的所有人员
+    def get_a_class(self, _class):
+        sql = "SELECT {} FROM PERSON WHERE class = ?;".format(", ".join(PERSON_FEATURE_LIST))
+        data = self.database.execute(sql, (_class,))
+        result = []
+        for row in data:
+            r = {
+                PERSON_FEATURE_LIST[i]: row[i]
+                for i in range(len(PERSON_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 获得所有人员的信息
+    def select_all_person(self):
+        sql = "SELECT {} FROM PERSON;".format(", ".join(PERSON_FEATURE_LIST))
+        data = self.database.execute(sql)
+        result = []
+        for row in data:
+            r = {
+                PERSON_FEATURE_LIST[i]: row[i]
+                for i in range(len(PERSON_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 修改指定人员的信息
+    def update_a_person(self, data):
+        sql = "SELECT * FROM PERSON WHERE id = ?"
+        person = self.database.execute(sql, (data[ID],))
+        if person:
+            format_data = [data.get(column) for column in PERSON_FEATURE_LIST] + [data.get(ID)]
+            sql = "UPDATE PERSON SET {} WHERE id = ?".format(", ".join(
+                [
+                    "{}=?".format(feature)
+                    for feature in PERSON_FEATURE_LIST
+                ]
+            ))
+            self.database.execute(sql, format_data)
+            format_data = [data.get(column) for column in SCORE_FEATURE_LIST] + [data.get(ID)]
+            sql = "UPDATE SCORE SET {} WHERE id = ?".format(", ".join(
+                [
+                    "{}=?".format(feature)
+                    for feature in SCORE_FEATURE_LIST
+                ]
+            ))
+            self.database.execute(sql, format_data)
+            self.database.commit()
+            return OK
+        else:
+            return NO_OBJ
+
+    # 获取某个班级的成绩
+    def get_class_score(self, _class):
+        sql = "SELECT {} FROM SCORE WHERE class = ?; ".format(", ".join(SCORE_FEATURE_LIST))
+        data = self.database.execute(sql, (_class,))
+        result = []
+        for row in data:
+            r = {
+                SCORE_FEATURE_LIST[i]: row[i]
+                for i in range(len(SCORE_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 插入成绩
+    def insert_a_score(self, data):
+        format_data = [data.get(column) for column in SCORE_FEATURE_LIST]
+        sql = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        try:
+            self.database.execute(sql, format_data)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+        except Exception as e:
+            print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+            return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_pushup_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} = {} AND {} > {}))"
+                   .format(PUSHUP_COUNT, PUSHUP_SCORE, ID, PUSHUP_SCORE, score, PUSHUP_SCORE, score, PUSHUP_SCORE,
+                           record, PUSHUP_COUNT
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_pullup_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} = {} AND {} > {}))"
+                   .format(PULLUP_COUNT, PULLUP_SCORE, ID, PULLUP_SCORE, score, PULLUP_SCORE, score, PULLUP_SCORE,
+                           record, PULLUP_COUNT
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_situp_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} = {} AND {} > {}))"
+                   .format(SITUP_COUNT, SITUP_SCORE, ID, SITUP_SCORE, score, SITUP_SCORE, score, SITUP_SCORE,
+                           record, SITUP_COUNT
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_runaround_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} > 0 AND {} = {} "
+                   "AND {} > {}) OR ({} <= 0 AND {} < {}))"
+                   .format(RUN_BF_COUNT, RUN_BF_SCORE, ID, RUN_BF_SCORE, score, RUN_BF_SCORE, RUN_BF_COUNT, score,
+                           RUN_BF_SCORE, RUN_BF_COUNT, record, RUN_BF_COUNT, RUN_BF_COUNT, record
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_running_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} = {} AND {} > {}))"
+                   .format(RUNNING_COUNT, RUNNING_SCORE, ID, RUNNING_SCORE, score, RUNNING_SCORE, score,
+                           RUNNING_SCORE, RUNNING_COUNT, record
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 插入成绩
+    def update_overhang_score(self, record, score, person_id):
+        if record or record == 0:
+            sql = ("UPDATE SCORE SET {} = ?, {} = ? WHERE {} = ? AND ({} < {} OR {} IS NULL OR ({} = {} AND {} > {}))"
+                   .format(HANGING_COUNT, HANGING_SCORE, ID, HANGING_SCORE, score, HANGING_SCORE, score,
+                           HANGING_SCORE, HANGING_COUNT, record
+                           ))
+            try:
+                self.database.execute(sql, (record, score, person_id))
+                self.database.commit()
+                return OK
+            except sqlite3.IntegrityError:
+                return ID_ERROR
+            except Exception as e:
+                print(f"数据库错误，错误原因{e.args}\n{traceback.format_exc()}")
+                return UNKNOWN_ERROR
+
+    # 从Excel导入成绩
+    def insert_many_score_from_xlsx(self, xlsx_file_dir):
+        df = pd.read_excel(xlsx_file_dir)
+        df = df[SCORE_TABLE_COLUMNS]
+        data = df.values.tolist()
+        sql = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        try:
+            self.database.executemany(sql, data)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+
+    # 从json导入成绩
+    def insert_many_score_from_json(self, data):
+        sql = "INSERT INTO SCORE ({}) VALUES ({});".format(
+            ", ".join(SCORE_FEATURE_LIST),
+            ", ".join(["?" for _ in SCORE_FEATURE_LIST])
+        )
+        try:
+            format_data = [[row[sfl] for sfl in SCORE_FEATURE_LIST] for row in data]
+            self.database.executemany(sql, format_data)
+            self.database.commit()
+            return OK
+        except sqlite3.IntegrityError:
+            return ID_ERROR
+
+    # 删除人员信息
+    def delete_a_score(self, _id):
+        sql = "SELECT * FROM SCORE WHERE id = ?"
+        person = self.database.execute(sql, (_id,))
+        if person:
+            sql = "DELETE FROM SCORE WHERE id = ?"
+            try:
+                self.database.execute(sql, (_id,))
+                self.database.commit()
+                return OK
+            except Exception as e:
+                print(e)
+                return UNKNOWN_ERROR
+        else:
+            return NO_OBJ
+
+    # 删除所有人员成绩
+    def clear_all_score(self):
+        sql = "UPDATE SCORE SET PULLUP_COUNT=NULL, PULLUP_SCORE=NULL, HANGING_COUNT=NULL, HANGING_SCORE=NULL, " \
+              "PUSHUP_COUNT=NULL, PUSHUP_SCORE=NULL, SITUP_COUNT=NULL, SITUP_SCORE=NULL, RUNNING_COUNT=NULL, " \
+              "RUNNING_SCORE=NULL, RUN_BF_COUNT=NULL, RUN_BF_SCORE=NULL, FINAL_SCORE=NULL; "
+        try:
+            self.database.execute(sql)
+            self.database.commit()
+            return OK
+        except Exception as e:
+            print(e)
+            return UNKNOWN_ERROR
+
+    # 删除所有人员成绩
+    def delete_all_score(self):
+        sql = "DELETE FROM SCORE;"
+        try:
+            self.database.execute(sql)
+            self.database.commit()
+            return OK
+        except Exception as e:
+            print(e)
+            return UNKNOWN_ERROR
+
+    # 获取一个班级的所有人员的成绩
+    def get_a_class_score(self, _class):
+        sql = "SELECT {} FROM SCORE WHERE class = ?;".format(", ".join(SCORE_FEATURE_LIST))
+        data = self.database.execute(sql, (_class,))
+        result = []
+        for row in data:
+            r = {
+                SCORE_FEATURE_LIST[i]: row[i]
+                for i in range(len(SCORE_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 获得所有人员的信息
+    def select_all_score(self):
+        sql = "SELECT {} FROM SCORE;".format(", ".join(SCORE_FEATURE_LIST))
+        data = self.database.execute(sql)
+        result = []
+        for row in data:
+            r = {
+                SCORE_FEATURE_LIST[i]: row[i]
+                for i in range(len(SCORE_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 搜索一个名字
+    def select_a_person_from_name(self, name):
+        sql = "SELECT {} FROM PERSON WHERE NAME LIKE '%{}%';".format(", ".join(PERSON_FEATURE_LIST), name)
+        data = self.database.execute(sql)
+        result = []
+        for row in data:
+            r = {
+                PERSON_FEATURE_LIST[i]: row[i]
+                for i in range(len(PERSON_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 搜索一个名字
+    def select_a_score_from_name(self, name):
+        sql = "SELECT {} FROM SCORE WHERE NAME LIKE '%{}%';".format(", ".join(SCORE_FEATURE_LIST), name)
+        data = self.database.execute(sql)
+        result = []
+        for row in data:
+            r = {
+                SCORE_FEATURE_LIST[i]: row[i]
+                for i in range(len(SCORE_FEATURE_LIST))
+            }
+            result.append(r)
+        return result
+
+    # 导出所有人员成绩
+    def dump_score(self, save_dir):
+        data = self.select_all_score()
+        df = pd.DataFrame(data)
+        df.to_excel(save_dir, index=False)
+
+    # 导出所有人员信息
+    def dump_person(self, save_dir):
+        data = self.select_all_person()
+        df = pd.DataFrame(data)
+        df.to_excel(save_dir, index=False)

DeviceDefine/consensus.py

@@ -0,0 +1,5 @@
+# 定义设备类型
+UNKNOWN = 0
+MASTER = 1
+SLAVER = 2
+MANAGER = 3

Exercise3/PoseModule.py

@@ -0,0 +1,149 @@
+import cv2
+import mediapipe as mp
+import math
+
+
+class poseDetector():
+
+    def __init__(self, mode=False, complexity=1, smooth_landmarks=True,
+                 enable_segmentation=False, smooth_segmentation=True,
+                 detectionCon=0.5, trackCon=0.5):
+
+        self.mode = mode
+        self.complexity = complexity
+        self.smooth_landmarks = smooth_landmarks
+        self.enable_segmentation = enable_segmentation
+        self.smooth_segmentation = smooth_segmentation
+        self.detectionCon = detectionCon
+        self.trackCon = trackCon
+
+        self.mpDraw = mp.solutions.drawing_utils
+        self.mpPose = mp.solutions.pose
+        self.pose = self.mpPose.Pose(self.mode, self.complexity, self.smooth_landmarks,
+                                     self.enable_segmentation, self.smooth_segmentation,
+                                     self.detectionCon, self.trackCon)
+
+    def findPose(self, img, draw=True):
+        imgRGB = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        self.results = self.pose.process(imgRGB)
+
+        if self.results.pose_landmarks:
+            if draw:
+                self.mpDraw.draw_landmarks(img, self.results.pose_landmarks,
+                                           self.mpPose.POSE_CONNECTIONS)
+
+        return img
+
+    def drawPoint(self, img, p1, p2, p3):
+        x1, y1 = self.lmList[p1][1], self.lmList[p1][2]
+        x2, y2 = self.lmList[p2][1], self.lmList[p2][2]
+        x3, y3 = self.lmList[p3][1], self.lmList[p3][2]
+        cv2.circle(img, (x1, y1), 5, (102, 106, 233), cv2.FILLED)
+        cv2.circle(img, (x2, y2), 5, (50, 80, 4), cv2.FILLED)
+        cv2.circle(img, (x3, y3), 5, (20, 95, 104), cv2.FILLED)
+
+    def Screen_occupation_left(self):
+        if self.results.pose_landmarks :
+            for id, lm in enumerate(self.results.pose_landmarks.landmark):
+                if id == 23:
+                    x1 = lm.x
+                if id == 29:
+                    x2 = lm.x
+            ocp = x2 - x1
+        return ocp
+
+    def Screen_occupation_right(self):
+        if self.results.pose_landmarks:
+            for id, lm in enumerate(self.results.pose_landmarks.landmark):
+                if id == 24:
+                    x1 = lm.x
+                if id == 30:
+                    x2 = lm.x
+            ocp = x2 - x1
+        return ocp
+
+    def findPosition(self, img, draw=True):
+        self.lmList = []
+        if self.results.pose_landmarks:
+            for id, lm in enumerate(self.results.pose_landmarks.landmark):
+                # finding height, width of the image printed
+                h, w, c = img.shape
+                # Determining the pixels of the landmarks
+                cx, cy, cz = int(lm.x * w), int(lm.y * h), lm.z
+                vis = lm.visibility
+                self.lmList.append([id, cx, cy, cz, vis])
+                if draw:
+                    cv2.circle(img, (cx, cy), 5, (255, 0, 0), cv2.FILLED)
+        return self.lmList
+
+    def findConcave(self, p1, p2, p3):
+        x1, y1 = self.lmList[p1][1], self.lmList[p1][2]
+        x2, y2 = self.lmList[p2][1], self.lmList[p2][2]
+        x3, y3 = self.lmList[p3][1], self.lmList[p3][2]
+
+        # Calculate Angle
+        Concave_angle = math.degrees(math.atan2(y3 - y2, x3 - x2) - math.atan2(y1 - y2, x1 - x2))
+        if Concave_angle < 0:
+            Concave_angle += 360
+
+        return Concave_angle
+
+    def findAngle(self, img, p1, p2, p3, draw=True):
+        # Get the landmarks
+        x1, y1 = self.lmList[p1][1], self.lmList[p1][2]
+        x2, y2 = self.lmList[p2][1], self.lmList[p2][2]
+        x3, y3 = self.lmList[p3][1], self.lmList[p3][2]
+
+        # Calculate Angle
+        angle = math.degrees(math.atan2(y3 - y2, x3 - x2) -
+                             math.atan2(y1 - y2, x1 - x2))
+        if angle < 0:
+            angle += 360
+            if angle > 180:
+                angle = 360 - angle
+        elif angle > 180:
+            angle = 360 - angle
+        # print(angle)
+
+        # Draw
+        if draw:
+            cv2.line(img, (x1, y1), (x2, y2), (255, 255, 255), 2)
+            cv2.line(img, (x3, y3), (x2, y2), (255, 255, 255), 2)
+
+            cv2.circle(img, (x1, y1), 3, (0, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x1, y1), 10, (0, 0, 255), 2)
+            cv2.circle(img, (x2, y2), 3, (0, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x2, y2), 10, (0, 0, 255), 2)
+            cv2.circle(img, (x3, y3), 3, (0, 0, 255), cv2.FILLED)
+            cv2.circle(img, (x3, y3), 10, (0, 0, 255), 2)
+
+            cv2.putText(img, str(int(angle)), (x2 - 20, y2 + 20),
+                        cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 255), 2)
+        return angle
+
+    def findIncludedAngle(self, x1, y1, x2, y2):
+        IncludedAngle = math.asin((y1 - y2) / math.hypot((y1 - y2), (x1 - x2))) * 180 / math.pi
+        return IncludedAngle
+
+    def findRange(self, x1, y1, x2, y2):
+        Range = math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))
+        return Range
+
+
+def main():
+    detector = poseDetector()
+    cap = cv2.VideoCapture(0)
+    while cap.isOpened():
+        ret, img = cap.read()  # ret is just the return variable, not much in there that we will use.
+        if ret:
+            img = detector.findPose(img)
+            cv2.imshow('Pose Detection', img)
+        if cv2.waitKey(10) & 0xFF == ord('q'):
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+if __name__ == "__main__":
+    main()

Exercise3/base_exercise.py

@@ -0,0 +1,221 @@
+import os
+import time
+from copy import deepcopy
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from AcrossPlatform.get_platform import GLOBAL_DIR
+from MCamera.mp_camera import *
+from Speaker import speak_base
+from Speaker.speak_base import beep
+from Database.manager_database import NAME
+from realtime_streaming import img_format_jpg
+
+
+def base_detect_image(camera: Camera):
+    _map = MediapipeAlgorithmPlugin()
+    while True:
+        _img = deepcopy(camera.get_frame())
+        img = _map.find_pose_with_drawing(_img, True)
+        yield b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + img_format_jpg(img) + b'\r\n'
+
+
+class BaseExercise(threading.Thread):
+
+    def __init__(self, info, statistic_time=120, camera: Camera = None):
+        super().__init__(daemon=True)
+        # 初始化窗体设置
+        self.detector = MediapipeAlgorithmPlugin()
+        # 摄像头对象
+        if not camera:
+            self.cap = Camera()
+        else:
+            self.cap = camera
+
+        # 个数统计
+        self.count = 0
+        # 当前状态
+        self.dir = 0
+        # 统计时间
+        self.statistic_time = statistic_time
+        # 开始时间
+        self.start_time = time.time()
+        # 開始計算時間
+        self.start_cal_time = time.time()
+        # 强制结束标志
+        self.kill_sign = False
+        # 当前画面
+        self.img = None
+        # 记录是否开始
+        self.is_start = False
+        # 获得人员信息
+        self.info = info
+        # 设置摄像头长时间不关闭
+        Camera.AUTO_CLOSE_TIMEOUT = float('inf')
+        self.exercise_type = ""
+        self.bright = -5
+        self.speak_driver = speak_base.SpeakServer()
+
+        self.corner = (0, 480, 0, 640)
+        self.config = (True, 1, True, False, True, 0.5, 0.5)
+
+    def start(self) -> None:
+        super().start()
+        self.start_cal_time = time.time()
+
+    def get_info(self):
+        return None
+
+    def is_done(self):
+        if time.time() - self.start_time > self.statistic_time or self.kill_sign:
+            Camera.stop_record()
+            return True
+        else:
+            return False
+
+    def get_result(self):
+        result = {}
+        return result
+
+    # 判断作训是否有效
+    def is_valid(self):
+        return True
+
+    # 作训回传文字
+    @staticmethod
+    def valid_mes():
+        return ""
+
+    def tran_count(self):
+        return self.count
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        self.speak_driver.add_speak(f"倒计时！")
+        retail_counting = counting_times
+        counting = 0
+        start_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - start_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+
+    # 作訓計算數據流
+    def analysis(self, frame):
+        pass
+
+    def thread_counting_streaming(self):
+        self.cap.clear_cache()
+        # start_time = time.time()
+        # count = 0
+        while not self.is_done():
+
+            frame = self.cap.get_cache()
+            if frame:
+                # catch_time = frame[CATCH_TIME]
+                self.analysis(frame=frame)
+
+                # count += 1
+                # if catch_time - start_time > 1:
+                #     print(count, time.time() - catch_time, catch_time - start_time)
+                #     start_time = catch_time
+                #     count = 0
+
+    # 作訓視頻流
+    def display(self, img):
+        return img
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 清除历史记录
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = self.cap.get_frame()
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def skeleton_video(self):
+        _img = deepcopy(self.cap.get_frame())
+        self.img = self.detector.find_pose_with_drawing(_img, True)
+        return self.img
+
+    def pure_streaming_gen(self):
+        if not self.kill_sign:
+            if self.is_start and self.img is not None:
+                return self.img
+            else:
+                return self.skeleton_video()
+
+    def pure_video_gen(self):
+        if not self.kill_sign:
+            self.img = cv2.rectangle(
+                self.skeleton_video(),
+                (self.corner[2], self.corner[0]),
+                (self.corner[3], self.corner[1]),
+                (0, 255, 0), 2
+            )
+            return self.img
+
+
+    def streaming_gen(self):
+        while not self.kill_sign:
+            if self.is_start and self.img is not None:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + img_format_jpg(self.img) + b'\r\n')
+            else:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + img_format_jpg(self.skeleton_video()) + b'\r\n')
+
+    def video_gen(self):
+        while not self.kill_sign:
+            self.img = cv2.rectangle(
+                self.skeleton_video(),
+                (self.corner[2], self.corner[0]),
+                (self.corner[3], self.corner[1]),
+                (0, 255, 0), 2
+            )
+            yield (
+                    b'--frame\r\nContent-Type: image/jpeg\r\n\r\n'
+                    + img_format_jpg(self.img)
+                    + b'\r\n'
+            )
+
+    def waiting_for_start(self):
+        while not self.is_start:
+            time.sleep(0.001)
+
+    def kill(self):
+        self.kill_sign = True
+        self.speak_driver.stop()
+        while self.is_alive():
+            time.sleep(0.1)
+
+    @staticmethod
+    def cv2_img_add_text(img, text, left, top, text_color=(0, 255, 0), text_size=30):
+        if isinstance(img, np.ndarray):  # 判断是否OpenCV图片类型
+            img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+        # 创建一个可以在给定图像上绘图的对象
+        draw = ImageDraw.Draw(img, None)
+        # 字体的格式
+        font_type_dir = os.path.join(GLOBAL_DIR, "Exercise3/simsun.ttc")
+        fontstyle = ImageFont.truetype(font_type_dir, text_size, encoding="utf-8")
+        # 绘制文本
+        draw.text((left, top), text, text_color, font=fontstyle)
+        # 转换回OpenCV格式
+        return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

Exercise3/overhang.py

@@ -0,0 +1,181 @@
+from threading import Thread
+
+import numpy as np
+
+from MCamera.mp_camera import *
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class Overhang(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 计时
+        self.bar = None
+        self.per = None
+        self.costtime = 0
+        self.endtime = None
+        self.starttime = None
+        # 动作持续帧数
+        self._time = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.state = 0
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "屈臂悬垂"
+        self.end_test = 0
+        self.had_start = False
+        self.had_done = False
+        # 计时
+        self.chronograph = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        if self.costtime < 0:
+            score = 0
+        else:
+            score = get_fin_score.Military(gender, int(age),
+                                           integratedProjectResult=round(self.costtime,
+                                                                       1)).IntegratedProjectScoreEvaluation()
+        if gender != "woman":
+            score = 0
+        if self.starttime and self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+
+        result = {
+            "count": self.costtime,
+            "score": score,
+            "had_done": self.had_done,
+            "time": self.chronograph,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name, gender):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if gender != "女":
+            self.speak_driver.add_speak(f"注意，该考生性别为男性，{self.exercise_type}项目成绩无效")
+
+    def timekeeping(self):
+        start_time = time.time()
+        while self.had_start:
+            now_time = time.time()
+            self.chronograph = int(now_time - start_time)
+            time.sleep(0.1)
+            if self.had_done:
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[GENDER])
+        # 清除历史记录
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = self.cap.get_frame()
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+        # # 绘制计数器
+        # cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        # cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+        #             (255, 255, 255), 5)
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, 11, 13, 15)
+            shoulder_1 = self.detector.findAngle(img, 13, 11, 23)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 16)
+            shoulder_2 = self.detector.findAngle(img, 14, 12, 24)
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            mouth_1_y = self.detector.findPosition(img, False)[9][2]
+            mouth_2_y = self.detector.findPosition(img, False)[10][2]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            index_1_y = self.detector.findPosition(img, False)[19][2]
+            index_2_y = self.detector.findPosition(img, False)[20][2]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (90, 160), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (90, 160), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = (wrist_1_y + index_1_y) / 2
+                hand_2_y = (wrist_2_y + index_2_y) / 2
+                head_1_y = (mouth_1_y + eye_1_y) / 2
+                head_2_y = (mouth_2_y + eye_2_y) / 2
+                if elbow_1 > 120 and elbow_2 > 120 and head_1_y > hand_1_y and head_2_y > hand_2_y:
+                    if self.state == 1:
+                        self.end_test += 1
+                        if self.end_test > 3:
+                            self.endtime = time.time()
+                            self.costtime = round(self.endtime - self.starttime, 3)
+                            self.speak_driver.add_speak("考试结束")
+                            Thread(target=self.speak_driver.add_speak,
+                                   args=(f"总耗时为{round(self.costtime, 2)}秒",)).start()
+                            self.pre_pos = 2
+                            self.had_done = True
+
+                if elbow_1 < 90 and elbow_2 < 90 and head_1_y < hand_1_y and head_2_y < hand_2_y:
+                    if self.state == 0:
+                        self.feedback = "悬垂"
+                        self._time += 1
+                        if self._time > 3:
+                            self._time = 0
+                            self.starttime = time.time()
+                            self.had_start = True
+                            self.state = 1
+                            self.speak_driver.add_speak("计时开始")
+                            threading.Thread(target=self.timekeeping).start()

Exercise3/pull_up_1.py

@@ -0,0 +1,225 @@
+import math
+import time
+
+import numpy as np
+
+from MCamera.mp_camera import *
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PullUp_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.body_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.t = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_1_y = 0
+        self.initial_wrist_2_y = 0
+
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+        self.a = time.time()
+        self.b = 0
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        self.detector.drawPoint_more(img, [9, 11, 13, 19, 25], bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint_more(img, [10, 12, 14, 20, 26], bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, 11, 13, 15)
+            shoulder_1 = self.detector.findAngle(img, 13, 11, 23)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 16)
+            shoulder_2 = self.detector.findAngle(img, 14, 12, 24)
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[12][2]
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[12][1]
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            mouth_1_y = self.detector.findPosition(img, False)[9][2]
+            mouth_2_y = self.detector.findPosition(img, False)[10][2]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            index_1_y = self.detector.findPosition(img, False)[19][2]
+            index_2_y = self.detector.findPosition(img, False)[20][2]
+            hip_1_x = self.detector.findPosition(img, False)[23][1]
+            hip_1_y = self.detector.findPosition(img, False)[23][2]
+            hip_2_x = self.detector.findPosition(img, False)[24][1]
+            hip_2_y = self.detector.findPosition(img, False)[24][2]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (157, 100), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (157, 100), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_1_y = wrist_1_y
+                        self.initial_wrist_2_y = wrist_2_y
+                        self.initial_height_left = math.sqrt(
+                            math.pow(shoulder_2_x - hip_2_x, 2) + math.pow(shoulder_2_y - hip_2_y, 2)) * math.cos(
+                            math.pi / 6)
+                        self.initial_height_right = math.sqrt(
+                            math.pow(shoulder_1_x - hip_1_x, 2) + math.pow(shoulder_1_y - hip_1_y, 2)) * math.cos(
+                            math.pi / 6)
+
+            elif self.pre_pos == 1 and self.form == 1:
+                height_left = math.sqrt(math.pow(shoulder_2_x - hip_2_x, 2) + math.pow(shoulder_2_y - hip_2_y, 2))
+                height_right = math.sqrt(math.pow(shoulder_1_x - hip_1_x, 2) + math.pow(shoulder_1_y - hip_1_y, 2))
+                hand_1_y = (wrist_1_y + index_1_y) / 2
+                hand_2_y = (wrist_2_y + index_2_y) / 2
+                head_1_y = (mouth_1_y + eye_1_y) / 2
+                head_2_y = (mouth_2_y + eye_2_y) / 2
+                h_range = head_1_y - hand_1_y
+
+                if wrist_1_y - self.initial_wrist_1_y > 50 and wrist_2_y - self.initial_wrist_2_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if height_left < self.initial_height_left and height_right < self.initial_height_right:
+                    self.t += 1
+                    if self.t > 4:
+                        self.state = 1
+                        self.t = 0
+                        if self.body_state == 0:
+                            self.speak_driver.add_speak('摆幅过大')
+                            self.body_state = 1
+
+                if elbow_1 > 157 and elbow_2 > 157 and head_1_y > hand_1_y and head_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 3:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.body_state = 0
+
+                if head_1_y < hand_1_y and head_2_y < hand_2_y and not self.had_done:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                                if self.count == 1:
+                                    self.initial_wrist_1_y = wrist_1_y
+                                    self.initial_wrist_2_y = wrist_2_y
+
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif head_1_y < hand_1_y and head_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise3/pull_up_2.py

@@ -0,0 +1,184 @@
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PullUp_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.speak_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_y = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        self.detector.drawPoint(img, 9, 19, 25, bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint(img, 10, 20, 26, bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, 11, 13, 15)
+            shoulder_1 = self.detector.findAngle(img, 13, 11, 23)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 16)
+            shoulder_2 = self.detector.findAngle(img, 14, 12, 24)
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            index_1_y = self.detector.findPosition(img, False)[19][2]
+            index_2_y = self.detector.findPosition(img, False)[20][2]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (155, 100), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (155, 100), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_y = wrist_1_y
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = (wrist_1_y + index_1_y) / 2
+                hand_2_y = (wrist_2_y + index_2_y) / 2
+                h_range = eye_1_y - hand_1_y
+
+                if wrist_1_y - self.initial_wrist_y > 50 and wrist_2_y - self.initial_wrist_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if elbow_1 > 155 and elbow_2 > 155 and eye_1_y > hand_1_y and eye_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.speak_state = 0
+
+                if eye_1_y < hand_1_y and eye_2_y < hand_2_y:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif eye_1_y < hand_1_y and eye_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise3/pull_up_3.py

@@ -0,0 +1,183 @@
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PullUp_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.speak_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_y = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        self.detector.drawPoint(img, 9, 19, 25, bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint(img, 10, 20, 26, bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, 11, 13, 15)
+            shoulder_1 = self.detector.findAngle(img, 13, 11, 23)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 16)
+            shoulder_2 = self.detector.findAngle(img, 14, 12, 24)
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            index_1_y = self.detector.findPosition(img, False)[19][2]
+            index_2_y = self.detector.findPosition(img, False)[20][2]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (160, 90), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (160, 90), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_y = wrist_1_y
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = (wrist_1_y + index_1_y) / 2
+                hand_2_y = (wrist_2_y + index_2_y) / 2
+                h_range = eye_1_y - hand_1_y
+                if wrist_1_y - self.initial_wrist_y > 50 and wrist_2_y - self.initial_wrist_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if elbow_1 > 150 and elbow_2 > 150 and eye_1_y > hand_1_y and eye_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.speak_state = 0
+
+                if eye_1_y < hand_1_y and eye_2_y < hand_2_y:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif eye_1_y < hand_1_y and eye_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise3/push_up_1.py

@@ -0,0 +1,288 @@
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT, CROPPED_FRAME
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PushUp_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.had_done = False
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (False, 1, True, False, True, 0.6, 0.65)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.start_time = time.time()
+        self.countdown_flag.set()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if int(self.countdown) >= 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 11, 13, 31, bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 12, 14, 32, bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[CROPPED_FRAME]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[12][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[12][2]
+            foot_1_x = self.detector.findPosition(img, False)[31][1]
+            foot_2_x = self.detector.findPosition(img, False)[32][1]
+            foot_1_y = self.detector.findPosition(img, False)[31][2]
+            foot_2_y = self.detector.findPosition(img, False)[32][2]
+            vis_elbow_1 = self.detector.findPosition(img, False)[13][4]
+            vis_elbow_2 = self.detector.findPosition(img, False)[14][4]
+            vis_knee_1 = self.detector.findPosition(img, False)[25][4]
+            vis_knee_2 = self.detector.findPosition(img, False)[26][4]
+            Concave_angle_1 = self.detector.findConcave(11, 23, 25)
+            Concave_angle_2 = self.detector.findConcave(12, 24, 26)
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+            elbow_1 = self.detector.findAngle(img, 11, 13, 21, False)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 22, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if foot_1_y > shoulder_1_y or foot_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_1_x, foot_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 145 and 155 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(400)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_1 < 95 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+                    if 155 > Concave_angle_1:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_2_x, foot_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 145 and 155 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 4 and elbow_2 < 95 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+                    if 155 > Concave_angle_2:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1

Exercise3/push_up_2.py

@@ -0,0 +1,290 @@
+import threading
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PushUp_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (False, 1, True, False, True, 0.6, 0.7)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 11, 13, 31, bias_x=100, bias_y=220)
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 12, 14, 32, bias_x=100, bias_y=220)
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[12][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[12][2]
+            foot_1_x = self.detector.findPosition(img, False)[31][1]
+            foot_2_x = self.detector.findPosition(img, False)[32][1]
+            foot_1_y = self.detector.findPosition(img, False)[31][2]
+            foot_2_y = self.detector.findPosition(img, False)[32][2]
+            vis_elbow_1 = self.detector.findPosition(img, False)[13][4]
+            vis_elbow_2 = self.detector.findPosition(img, False)[14][4]
+            vis_knee_1 = self.detector.findPosition(img, False)[25][4]
+            vis_knee_2 = self.detector.findPosition(img, False)[26][4]
+            Concave_angle_1 = self.detector.findConcave(11, 23, 25)
+            Concave_angle_2 = self.detector.findConcave(12, 24, 26)
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+            elbow_1 = self.detector.findAngle(img, 11, 13, 21, False)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 22, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if foot_1_y > shoulder_1_y or foot_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 4:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 4:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_1_x, foot_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 150 and 155 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_1 < 105 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+                    if 155 > Concave_angle_1:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_2_x, foot_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 150 and 155 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_2 < 105 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+                    if 155 > Concave_angle_2:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1

Exercise3/push_up_3.py

@@ -0,0 +1,276 @@
+import threading
+import time
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PushUp_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (False, 1, True, False, True, 0.6, 0.7)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 11, 13, 31, bias_x=100, bias_y=220)
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 12, 14, 32, bias_x=100, bias_y=220)
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[12][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[12][2]
+            foot_1_x = self.detector.findPosition(img, False)[31][1]
+            foot_2_x = self.detector.findPosition(img, False)[32][1]
+            foot_1_y = self.detector.findPosition(img, False)[31][2]
+            foot_2_y = self.detector.findPosition(img, False)[32][2]
+            vis_knee_1 = self.detector.findPosition(img, False)[25][4]
+            vis_knee_2 = self.detector.findPosition(img, False)[26][4]
+            vis_elbow_1 = self.detector.findPosition(img, False)[13][4]
+            vis_elbow_2 = self.detector.findPosition(img, False)[14][4]
+            Concave_angle_1 = self.detector.findConcave(11, 23, 25)
+            Concave_angle_2 = self.detector.findConcave(12, 24, 26)
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+            elbow_1 = self.detector.findAngle(img, 11, 13, 21, False)
+            elbow_2 = self.detector.findAngle(img, 12, 14, 22, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if foot_1_y > shoulder_1_y or foot_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 4:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 4:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_1_x, foot_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 140 and 150 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 3 and elbow_1 < 115 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(foot_2_x, foot_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 140 and 150 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 3 and elbow_1 < 115 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()

Exercise3/run_around.py

@@ -0,0 +1,210 @@
+import time
+from copy import deepcopy
+from threading import Lock
+from threading import Thread
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class Runaround(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 计时
+        self.countdown_flag = threading.Event()  # 计时线程
+        self.costtime = 0
+        self.countdown = 0
+        # 当前状态
+        self.direction = 0
+        # 动作持续帧数
+        self.time = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "请开始"
+        self.had_leaf = False
+        self.had_start = False
+        self.had_done = False
+        self.had_countdown = False
+        self.countdown_signal = True
+        self.pre_frame = None
+        self.retail_counting = 5
+        self.preempt_lock = Lock()
+        self.Preempt = 0
+        self.pretime = 0
+        self.racetime = 0
+        self.starttime = 0
+        self.endtime = 0
+        self.fix = 0
+        self.timefix = 0
+        self.catch_time = 0
+        self.exercise_type = "蛇形跑"
+        # 蛇形跑参数
+        self.corner = (0, 480, 200, 400)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        # if self.costtime == '未完成':
+        if self.costtime < 0:
+            score = 0
+        else:
+            score = get_fin_score.Military(gender, int(age),
+                                           serpentine60RunResult=round(self.costtime,
+                                                                       1)).Serpentine60RunScoreEvaluation()
+
+        result = {
+            "count": self.costtime,
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done,
+            'preempt': self.Preempt
+        }
+        return result
+
+    def get_info(self):
+        self.preempt_lock.acquire()
+        result = self.Preempt
+        self.preempt_lock.release()
+        return result
+
+    def is_valid(self):
+        return True
+
+    def _speak_counting(self):
+        threading.Thread(target=self.count_down).start()
+        counting = 0
+        first_time = self.catch_time
+        while True:
+            this_time = self.catch_time
+            if this_time - first_time > counting:
+                if not self.countdown_signal and not self.had_countdown:
+                    self.speak_driver.add_speak(f"抢跑！")
+                    self.pretime = self.catch_time
+                    self.countdown_flag.set()
+                    self.had_countdown = True
+                if self.retail_counting > 0:
+                    if self.countdown_signal:
+                        self.speak_driver.speed_control(350)
+                        self.speak_driver.add_speak(f"{self.retail_counting}")
+                        self.speak_driver.wait_4_speak()
+                    counting += 1
+                    self.retail_counting -= 1
+                else:
+                    if self.countdown_signal:
+                        threading.Thread(target=beep, args=(300, 640), daemon=True).start()
+                        self.had_countdown = True
+                        self.countdown_flag.set()
+                        self.pretime = self.catch_time
+                    break
+        self.had_start = True
+        self.starttime = self.catch_time
+
+    def count_down(self):
+        while True:
+            self.countdown_flag.wait()
+            self.costtime = self.catch_time - self.pretime
+            self.countdown = int(self.costtime)
+            time.sleep(0.1)
+
+    def run(self) -> None:
+        self.speak_driver.add_speak("考试人员{}".format(self.info[NAME]))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        self.speak_driver.wait_4_speak()
+        self.cap.clear_cache()
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if not self.had_countdown:
+            cv2.putText(img, str(self.retail_counting), (230, 320), cv2.FONT_HERSHEY_PLAIN, 20, (255, 255, 255), 8)
+        return img
+
+    def analysis(self, frame):
+        self.catch_time = frame[CATCH_TIME]
+        if self.catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        img_input = img[self.corner[0]:self.corner[1], self.corner[2]:self.corner[3]]
+
+        if self.timefix == 0:
+            self.timefix = 1
+            Thread(target=self._speak_counting, daemon=True).start()
+        if not self.had_countdown:
+            self.detector.set_result(lm_list)
+            # self.starttime = time.time()
+            if len(lm_list) == 0:
+                self.time = self.time + 1
+                if self.fix == 0 and self.time > 3:
+                    self.fix += 1
+                    self.countdown_signal = False
+                    self.preempt_lock.acquire()
+                    self.racetime = self.catch_time
+                    self.preempt_lock.release()
+                    self.valid_mes()
+                    self.is_valid()
+        # 如果没有背景图像就将当前帧当作背景图片
+        else:
+            # 计算抢跑时间
+            if self.starttime - self.racetime <= 5:
+                self.Preempt = round(self.starttime - self.racetime, 3)
+            elif 10 > self.starttime - self.racetime > 5:
+                self.Preempt = 5
+            else:
+                self.Preempt = 0
+            if self.had_start and not self.had_leaf and not self.had_done:
+                # 一直等待到目标完全离开检测区
+                if self.catch_time - self.pretime > 14:
+                    self.had_leaf = True
+            else:
+                # 转灰度图
+                gray_pic = cv2.cvtColor(img_input, cv2.COLOR_BGR2GRAY)
+                # 用高斯滤波进行模糊处理
+                gray_pic = cv2.GaussianBlur(gray_pic, (21, 21), 0)
+                if self.pre_frame is None:
+                    self.pre_frame = gray_pic
+                else:
+                    # absdiff把两幅图的差的绝对值输出到另一幅图上面来
+                    img_delta = cv2.absdiff(self.pre_frame, gray_pic)
+                    # threshold阈值函数(原图像应该是灰度图,对像素值进行分类的阈值,当像素值高于（有时是小于）阈值时应该被赋予的新的像素值,阈值方法)
+                    thresh = cv2.threshold(img_delta, 30, 255, cv2.THRESH_BINARY)[1]
+                    # 用一下腐蚀与膨胀
+                    thresh = cv2.dilate(thresh, None, iterations=2)
+                    # findContours检测物体轮廓(寻找轮廓的图像,轮廓的检索模式,轮廓的近似办法)
+                    contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                    for c in contours:
+                        # 设置敏感度
+                        if cv2.contourArea(c) < 7500:
+                            continue
+                        else:
+                            if self.had_start and self.had_leaf and not self.had_done:
+                                self.endtime = self.catch_time
+                                self.had_done = True
+                                self.costtime = round(self.endtime - self.starttime + self.Preempt, 3)
+                                self.countdown_flag.clear()
+                                # print("总耗时 = {}".format(self.costtime))
+                                self.speak_driver.speed_control(200)
+                                Thread(
+                                    target=self.speak_driver.add_speak,
+                                    args=(f"抢跑时间为{round(self.Preempt, 2)}秒,总耗时为{round(self.costtime, 2)}秒",)
+                                ).start()
+                            break
+                    self.pre_frame = gray_pic

Exercise3/running_muwb.py

@@ -0,0 +1,414 @@
+# coding=gb2312
+import json
+import sys
+
+from Database.manager_database import *
+from Speaker.speak_base import SpeakServer, beep
+from UWB.positioning_standalone import *
+
+FINISH_LINE_SIZE1 = 0
+FINISH_LINE_SIZE2 = 1
+RUNNING_COUNTING = "cnt"
+RUNNING_STATUS = "stat"
+RUNNING_MES = "mes"
+STATUS_ACROSS = "across"
+STATUS_EXIT = "exit"
+RUNNING_LAST_STATUS_TIME = "lst"
+RUNNING_COST = "cost"
+RUNNING_DONE = 'done'
+
+PATH = sys.path[0]
+
+
+def score_compute(age, cost, score_data):
+    my_age_index = 0
+    for age_index in range(len(score_data["age"])):
+        candidate_age = score_data["age"][age_index]
+        if candidate_age[0] <= age <= candidate_age[1]:
+            my_age_index = age_index
+            break
+    my_score_index = len(score_data["values"]) - 1
+    for value_index in range(len(score_data["values"]) - 1, 0 - 1, -1):
+        value = score_data["values"][value_index][my_age_index]
+        if cost <= value[0] * 60 + value[1]:
+            my_score_index = value_index
+        else:
+            break
+    if cost > score_data["values"][-1][my_age_index][0] * 60 + score_data["values"][-1][my_age_index][1]:
+        my_base_score = 0
+    else:
+        my_base_score = score_data["score"][my_score_index]
+    if my_base_score == 100:
+        value = score_data["values"][my_score_index][my_age_index]
+        base_score = value[0] * 60 + value[1]
+        my_score = my_base_score + (base_score - cost) // 5 * 1
+    else:
+        my_score = my_base_score
+
+    return my_score
+
+
+class Running:
+
+    def __init__(self, positioning: Positioning, round_num=3, min_round_time=30) -> None:
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+        self.positioning = positioning
+        self.positioning_tag = None
+        self.finish_line = {}
+        # 起跑时间
+        self.start_time = 0
+        # 结束时间
+        self.stop_time = 0
+        # 跑步记录
+        self.running_record = {}
+        # 跑步流水记录
+        self.running_record_list = {}
+        # 跑步圈时记录
+        self.round_record = {}
+        # 记录手环
+        self.test_tag = []
+        # 手环对应人员信息
+        self.person_mes = {}
+        # 是否起跑状态
+        self.__start_running = threading.Event()
+        self.__start_running.clear()
+        # 说话
+        self.speak_driver = SpeakServer()
+        self.speak_driver.start()
+        # 成绩文件
+        file = open(f"{PATH}/Exercise3/running_score.json")
+        self.score_data = json.load(file)
+        # 跑步记录数据
+        self.final_data = {}
+        # 是否播报
+        self.is_play = False
+
+    def set_play(self, is_play):
+        self.is_play = is_play
+
+    def update_and_play(self, tag, new_record):
+        if self.is_play:
+            this_record = self.running_record[tag]
+            if this_record[RUNNING_COUNTING] != new_record[RUNNING_COUNTING]:
+                person_name = self.person_mes[tag][NAME]
+                person_id = self.person_mes[tag][ID]
+                if new_record[RUNNING_DONE]:
+                    self.speak_driver.add_speak(f"{person_name}完成考试！")
+                else:
+                    self.speak_driver.add_speak(f"{person_name}通过第{new_record[RUNNING_COUNTING]}圈！")
+        self.running_record[tag] = new_record
+
+    def set_config(self, round_num, min_round_time):
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+
+    def add_tag(self, tag):
+        self.test_tag.append(tag)
+
+    def del_tag(self, tag):
+        self.test_tag.remove(tag)
+        del self.person_mes[tag]
+
+    def add_tag_mes(self, tag, mes):
+        self.person_mes[tag] = mes
+
+    def reset(self):
+        self.test_tag.clear()
+        self.person_mes.clear()
+
+    def start(self):
+        # 清除缓存
+        self.__start_running.clear()
+        self.round_record.clear()
+        self.positioning.clear_information()
+        self.positioning.resume()
+        self.speak_driver.add_speak("准备开始考试，请就位，倒计时：")
+        counting = 5
+        for i in range(counting):
+            start_time = time.time()
+            self.speak_driver.add_speak(counting - i)
+            while time.time() - start_time < 1:
+                time.sleep(0.05)
+        self.speak_driver.wait_4_speak()
+        self.start_time = time.time()
+        self.positioning.set_valid_time(self.start_time)
+        duration = 700  # millisecond
+        freq = 640  # Hz
+        beep(freq, duration)
+        self.__start_running.set()
+        # 初始化记录
+        self.running_record = {
+            tag: {
+                RUNNING_COUNTING: -1,
+                RUNNING_STATUS: STATUS_EXIT,
+                RUNNING_MES: "离开",
+                RUNNING_COST: 0,
+                RUNNING_DONE: False,
+            }
+            for tag in self.test_tag
+        }
+        # 启动计算线程
+        threading.Thread(target=self._thread_running, daemon=True).start()
+        threading.Thread(target=self._thread_processing, daemon=True).start()
+
+    def kill(self):
+        # 记录手环
+        self.test_tag.clear()
+        self.running_record_list.clear()
+        self.__start_running.clear()
+
+    def stop(self):
+        # # 起跑时间
+        self.stop_time = time.time()
+        # self.start_time = 0
+        self.kill()
+        # 计算最终成绩
+        self.final_data.clear()
+        raw_score = self.get_score()
+        for score in raw_score:
+            band_id = score["band_id"]
+            person_mes = self.person_mes[band_id]
+            tag_mes = self.running_record[band_id]
+            score.update(person_mes)
+            score.update(tag_mes)
+            person_id = score["id"]
+            round_time = self.round_record.get(person_id)
+            round_time_record = round_time if round_time else []
+            score.update({"round_time": round_time_record})
+            score.update({
+                "fix": False, "final_result": round_time_record
+            })
+            self.final_data[person_id] = score
+
+    # 获得当前所有成绩
+    def get_all_score(self):
+        return list(self.final_data.values())
+
+    # 成绩修复
+    def fix_score(self, person_id):
+        if not self.final_data[person_id][RUNNING_DONE]:
+            detected_round = len(self.final_data[person_id]["round_time"])
+            lacked_round = self.round_num - detected_round + 1
+            result = [
+                self.final_data[person_id]["round_time"][i]
+                for i in range(detected_round)
+            ]
+            # 如果没有成绩，按最终完成时间去计算
+            if len(result) <= 1:
+                total_time = self.stop_time - self.start_time
+                result = [total_time / (self.round_num + 1) for i in range(self.round_num + 1)]
+            # 如果有成绩
+            else:
+                for _ in range(lacked_round):
+                    max_result = max(result)
+                    index = result.index(max_result)
+                    result = result[0:index:] + [max_result / 2, max_result / 2] + result[index + 1::]
+            self.final_data[person_id]["final_result"] = {
+                i: result[i] for i in range(len(result))
+            }
+            self.final_data[person_id]["fix"] = True
+            self.final_data[person_id]["total_time"] = sum(result)
+
+    # 修复撤销
+    def fix_withdraw(self, person_id):
+        self.final_data[person_id]["final_result"] = self.final_data[person_id]["round_time"]
+        self.final_data[person_id]["fix"] = False
+
+    def _thread_processing(self):
+        while self.__start_running.is_set():
+            data = self.positioning.get_last_information()
+            try:
+                # 过滤无效操作
+                if data:
+                    # print(data)
+                    record_time, mes = data
+                    # print(self.start_time - record_time, len(self.positioning.tag_information))
+                    if record_time < self.start_time - 3:
+                        continue
+                    tag = mes[TAG]
+                    if tag not in self.test_tag:
+                        continue
+                    avg_distance = mes[DIST]
+                    avg_rssi = mes[RSSI]
+                    self.running_record_list.setdefault(tag, [])
+                    self.running_record_list[tag].append(
+                        {RECORD: record_time, DIST: avg_distance, RSSI: avg_rssi}
+                    )
+            except Exception as e:
+                traceback.format_exc()
+                print(f"获取数据时发生错误：{e.args}")
+
+    def _thread_running(self):
+        # 提前开始检测时间
+        bias = 3
+        # 判定周期时间
+        judge_window_time = 6
+        detect_time_range = judge_window_time / 2
+        # 有效进入距离
+        effective_distance = 300
+        effective_rssi = -80
+        # 开始判定距离
+        judge_distance = 700
+        judge_rssi = -82
+        while self.__start_running.is_set():
+            this_time = time.time()
+            for tag, record in self.running_record_list.copy().items():
+                if tag not in self.test_tag or self.running_record[tag][RUNNING_DONE]:
+                    continue
+                # 获取测试人员id
+                person_id = self.person_mes[tag]["id"]
+                sorted_record = sorted(record, key=lambda x: x[RECORD])
+                this_tag = {
+                    RUNNING_COUNTING: -1,
+                    RUNNING_STATUS: STATUS_EXIT,
+                    RUNNING_MES: "离开",
+                    RUNNING_COST: 0,
+                    RUNNING_DONE: False
+                }
+                # Cache
+                last_status_time = -1
+                last_enter_time = self.start_time
+                for one_record in sorted_record:
+                    try:
+                        record_time = one_record[RECORD]
+                        # 消除无效数据
+                        if record_time < self.start_time - bias or this_time - record_time < detect_time_range:
+                            continue
+                        distance = one_record[DIST]
+                        rssi = one_record[RSSI]
+                        # 更新时间窗口中的数据
+                        frontward_window = list(
+                            filter(
+                                lambda x: -detect_time_range <= record_time - x[RECORD] < 0,
+                                sorted_record
+                            )
+                        )
+                        # 冲线判定
+                        if (
+                                (
+                                        # CASE1 未来没有减少的趋势
+                                        len(frontward_window) == 0
+                                        # 未来距离都比现在大
+                                        or min([fw[DIST] for fw in frontward_window]) > distance
+                                        # 未来信号都比现在弱
+                                        or max([fw[RSSI] for fw in frontward_window]) < rssi
+                                ) or (
+                                        # CASE2 小于有效距离
+                                        distance <= effective_distance
+                                        or rssi >= effective_rssi
+                                )
+                        ) and (
+                                # 并且时间大于单圈时间，且已经离开，并且达到判定距离
+                                record_time - last_status_time > self.min_round_time
+                                and this_tag[RUNNING_STATUS] == STATUS_EXIT
+                                and (distance < judge_distance or rssi >= judge_rssi)
+                        ):
+                            last_status_time = record_time
+                            this_tag[RUNNING_STATUS] = STATUS_ACROSS
+                            this_tag[RUNNING_MES] = "冲线"
+                            this_tag[RUNNING_COUNTING] += 1
+                            # 圈数时间记录
+                            self.round_record.setdefault(person_id, {})
+                            self.round_record[person_id][
+                                this_tag[RUNNING_COUNTING]
+                            ] = 0 if record_time - last_enter_time < 0 else record_time - last_enter_time
+                            last_enter_time += self.round_record[person_id][
+                                this_tag[RUNNING_COUNTING]
+                            ]
+                            # 结束判定
+                            if this_tag[RUNNING_COUNTING] == self.round_num:
+                                this_tag[RUNNING_DONE] = True
+                                this_tag[RUNNING_COST] = record_time - self.start_time
+
+                        # 离开判定1
+                        elif (
+                                (
+                                        # 如果还有数据，并且之前已经进入了判定距离
+                                        len(frontward_window) > 0
+                                        and
+                                        (
+                                                min([fw[DIST] for fw in frontward_window]) > judge_distance
+                                                or max([fw[RSSI] for fw in frontward_window]) < judge_rssi
+                                        )
+                                ) and (
+                                        # 并且当前距离已离开范围，当前状态为冲线，距离上次判定时间超过一个判定间隔
+                                        (
+                                                distance > effective_distance
+                                                or rssi < effective_rssi
+                                        )
+                                        and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                                        and record_time - last_status_time > detect_time_range
+                                )
+                        ):
+                            last_status_time = record_time
+                            this_tag[RUNNING_STATUS] = STATUS_EXIT
+                            this_tag[RUNNING_MES] = "离开"
+
+                        # 离开判定2
+                        if (
+                                (
+                                        # 如果已无数据
+                                        len(frontward_window) == 0
+                                ) and (
+                                        # 并且当前距离已离开范围，当前状态为冲线
+                                        (distance > 0 or rssi < -60)
+                                        # 或者最后一条数据已经过了离开判定时间了
+                                        or this_time - record_time > detect_time_range
+                                )
+                                and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                        ):
+                            last_status_time = record_time
+                            this_tag[RUNNING_STATUS] = STATUS_EXIT
+                            this_tag[RUNNING_MES] = "离开"
+                    except Exception as e:
+                        traceback.format_exc()
+                        print(f"计算时发生错误:{e.args}")
+
+                if this_time - last_status_time > self.min_round_time and this_tag[RUNNING_STATUS] == STATUS_EXIT:
+                    this_tag[RUNNING_MES] = "回程"
+                # 更新记录
+                self.update_and_play(tag=tag, new_record=this_tag)
+            # 休息一下
+            time.sleep(1)
+
+    def get_person_round_time(self, person_id):
+        if person_id not in self.final_data.keys():
+            return {}
+        return self.final_data[person_id]["final_result"]
+
+    def get_valid_score(self):
+        result = []
+        for person_id, data in self.final_data.items():
+            if data["done"] or data["fix"]:
+                data["score"] = score_compute(data["age"], data["total_time"], self.score_data)
+                result.append(data)
+        return result
+
+    # 获取成绩接口
+    def get_score(self):
+        score = []
+        this_cost_time = time.time() - self.start_time
+        for tag, record in self.running_record.items():
+            if record[RUNNING_COUNTING] < 0:
+                finish_status = "未起始"
+            else:
+                if record[RUNNING_COUNTING] == 0:
+                    finish_status = f"已开始({record[RUNNING_MES]})"
+                else:
+                    finish_status = f"考试中({record[RUNNING_MES]})"
+                    if record[RUNNING_COUNTING] == self.round_num:
+                        finish_status = "已完成考试"
+            age = self.person_mes[tag]["age"]
+            one = {
+                "band_id": tag,
+                "score": score_compute(age, record[RUNNING_COST], self.score_data)
+                if record[RUNNING_COUNTING] == self.round_num else 0,
+                "total_time": record[RUNNING_COST] if record[RUNNING_DONE] else this_cost_time,
+                "round": record[RUNNING_COUNTING] if record[RUNNING_COUNTING] > 0 else 0,
+                "finish": finish_status,
+                "percentage": record[RUNNING_COUNTING] / self.round_num
+                if record[RUNNING_COUNTING] > 0 else 0
+            }
+            score.append(one)
+        return score

Exercise3/running_muwb_pure_detection.py

@@ -0,0 +1,395 @@
+# coding=gb2312
+import json
+import os.path
+import sys
+
+from Database.manager_database import *
+from Speaker.speak_base import SpeakServer, beep
+from UWB.positioning_standalone_v2 import *
+
+FINISH_LINE_SIZE1 = 0
+FINISH_LINE_SIZE2 = 1
+RUNNING_COUNTING = "cnt"
+RUNNING_STATUS = "stat"
+RUNNING_MES = "mes"
+STATUS_ACROSS = "across"
+STATUS_EXIT = "exit"
+RUNNING_LAST_STATUS_TIME = "lst"
+RUNNING_COST = "cost"
+RUNNING_DONE = 'done'
+
+PATH = sys.path[0]
+ANCHOR_RSSI_ADJUSTMENT_PATH = f"{PATH}/Exercise3/anchor_adjustment.json"
+
+
+def score_compute(age, cost, score_data):
+    my_age_index = 0
+    for age_index in range(len(score_data["age"])):
+        candidate_age = score_data["age"][age_index]
+        if candidate_age[0] <= age <= candidate_age[1]:
+            my_age_index = age_index
+            break
+    my_score_index = len(score_data["values"]) - 1
+    for value_index in range(len(score_data["values"]) - 1, 0 - 1, -1):
+        value = score_data["values"][value_index][my_age_index]
+        if cost <= value[0] * 60 + value[1]:
+            my_score_index = value_index
+        else:
+            break
+    if cost > score_data["values"][-1][my_age_index][0] * 60 + score_data["values"][-1][my_age_index][1]:
+        my_base_score = 0
+    else:
+        my_base_score = score_data["score"][my_score_index]
+    if my_base_score == 100:
+        value = score_data["values"][my_score_index][my_age_index]
+        base_score = value[0] * 60 + value[1]
+        my_score = my_base_score + (base_score - cost) // 5 * 1
+    else:
+        my_score = my_base_score
+
+    return my_score
+
+
+class Running:
+
+    def __init__(self, positioning: Positioning, round_num=3, min_round_time=30) -> None:
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+        self.positioning = positioning
+        self.positioning_tag = None
+        self.finish_line = {}
+        # 起跑时间
+        self.start_time = 0
+        # 结束时间
+        self.stop_time = 0
+        # 跑步记录
+        self.running_record = {}
+        # 跑步流水记录
+        self.running_record_list = {}
+        # 跑步圈时记录
+        self.round_record = {}
+        # 记录手环
+        self.test_tag = []
+        # 手环对应人员信息
+        self.person_mes = {}
+        # 是否起跑状态
+        self.__start_running = threading.Event()
+        self.__start_running.clear()
+        # 说话
+        self.speak_driver = SpeakServer()
+        self.speak_driver.start()
+        # 成绩文件
+        file = open(f"{PATH}/Exercise3/running_score.json")
+        self.score_data = json.load(file)
+        # 基站校准数据
+        anchor_list = list(positioning.multi_uwb.uwb_driver_table.keys())
+        default_effective_rssi = -84
+        if os.path.exists(ANCHOR_RSSI_ADJUSTMENT_PATH):
+            with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "r", encoding="utf-8_sig") as file:
+                self.anchor_rssi_adjustment = json.load(file)
+            if len(self.anchor_rssi_adjustment) < len(anchor_list):
+                self.anchor_rssi_adjustment = {
+                    anchor: default_effective_rssi
+                    for anchor in anchor_list
+                }
+                with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "w", encoding="utf-8_sig") as file:
+                    json.dump(self.anchor_rssi_adjustment, file)
+        else:
+            self.anchor_rssi_adjustment = {
+                anchor: default_effective_rssi
+                for anchor in anchor_list
+            }
+            with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "w", encoding="utf-8_sig") as file:
+                json.dump(self.anchor_rssi_adjustment, file)
+
+        # 跑步记录数据
+        self.final_data = {}
+        # 是否播报
+        self.is_play = False
+
+    def set_play(self, is_play):
+        self.is_play = is_play
+
+    def update_and_play(self, tag, new_record):
+        if self.is_play:
+            this_record = self.running_record[tag]
+            if this_record[RUNNING_COUNTING] != new_record[RUNNING_COUNTING]:
+                person_name = self.person_mes[tag][NAME]
+                person_id = self.person_mes[tag][ID]
+                if new_record[RUNNING_DONE]:
+                    self.speak_driver.add_speak(f"{person_name}完成考试！")
+                else:
+                    self.speak_driver.add_speak(f"{person_name}通过第{new_record[RUNNING_COUNTING]}圈！")
+        self.running_record[tag] = new_record
+
+    def set_config(self, round_num, min_round_time):
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+
+    def add_tag(self, tag):
+        self.test_tag.append(tag)
+
+    def del_tag(self, tag):
+        self.test_tag.remove(tag)
+        del self.person_mes[tag]
+
+    def add_tag_mes(self, tag, mes):
+        self.person_mes[tag] = mes
+
+    def reset(self):
+        self.test_tag.clear()
+        self.person_mes.clear()
+        self.start_time = 0
+
+    def start(self):
+        # 清除缓存
+        self.__start_running.clear()
+        self.round_record.clear()
+        self.positioning.clear_information()
+        self.positioning.resume()
+        # 初始化记录
+        self.running_record = {
+            tag: {
+                RUNNING_COUNTING: -1,
+                RUNNING_STATUS: STATUS_EXIT,
+                RUNNING_MES: "未起始",
+                RUNNING_COST: 0,
+                RUNNING_DONE: False,
+            }
+            for tag in self.test_tag
+        }
+        # 起跑播报
+        self.speak_driver.add_speak("准备开始考试，请就位，倒计时：")
+        counting = 5
+        for i in range(counting):
+            start_time = time.time()
+            self.speak_driver.add_speak(counting - i)
+            while time.time() - start_time < 1:
+                time.sleep(0.05)
+        self.speak_driver.wait_4_speak()
+        self.start_time = time.time()
+        self.positioning.set_valid_time(self.start_time)
+        beep(duration=700, freq=640)
+        self.__start_running.set()
+        # 启动计算线程
+        threading.Thread(target=self._thread_running, daemon=True).start()
+        threading.Thread(target=self._thread_processing, daemon=True).start()
+
+    def kill(self):
+        # 记录手环
+        self.test_tag.clear()
+        self.running_record_list.clear()
+        self.__start_running.clear()
+
+    def stop(self):
+        # # 起跑时间
+        self.stop_time = time.time()
+        # self.start_time = 0
+        self.kill()
+        # 计算最终成绩
+        self.final_data.clear()
+        raw_score = self.get_score()
+        for score in raw_score:
+            band_id = score["band_id"]
+            person_mes = self.person_mes[band_id]
+            tag_mes = self.running_record[band_id]
+            score.update(person_mes)
+            score.update(tag_mes)
+            person_id = score["id"]
+            round_time = self.round_record.get(person_id)
+            round_time_record = round_time if round_time else []
+            score.update({"round_time": round_time_record})
+            score.update({
+                "fix": False, "final_result": round_time_record
+            })
+            self.final_data[person_id] = score
+
+    # 获得当前所有成绩
+    def get_all_score(self):
+        return list(self.final_data.values())
+
+    # 成绩修复
+    def fix_score(self, person_id):
+        if not self.final_data[person_id][RUNNING_DONE]:
+            detected_round = len(self.final_data[person_id]["round_time"])
+            lacked_round = self.round_num - detected_round + 1
+            result = [
+                self.final_data[person_id]["round_time"][i]
+                for i in range(detected_round)
+            ]
+            # 如果没有成绩，按最终完成时间去计算
+            if len(result) <= 1:
+                total_time = self.stop_time - self.start_time
+                result = [total_time / (self.round_num + 1) for i in range(self.round_num + 1)]
+            # 如果有成绩
+            else:
+                for _ in range(lacked_round):
+                    max_result = max(result)
+                    index = result.index(max_result)
+                    result = result[0:index:] + [max_result / 2, max_result / 2] + result[index + 1::]
+            self.final_data[person_id]["final_result"] = {
+                i: result[i] for i in range(len(result))
+            }
+            self.final_data[person_id]["fix"] = True
+            self.final_data[person_id]["total_time"] = sum(result)
+
+    # 修复撤销
+    def fix_withdraw(self, person_id):
+        self.final_data[person_id]["final_result"] = self.final_data[person_id]["round_time"]
+        self.final_data[person_id]["fix"] = False
+
+    def _thread_processing(self):
+        while self.__start_running.is_set():
+            data = self.positioning.get_last_information()
+            try:
+                # 过滤无效操作
+                if data:
+                    record_time, mes = data
+                    tag = mes[TAG]
+                    if tag not in self.test_tag:
+                        continue
+                    distance = mes[DIST]
+                    rssi = mes[RSSI]
+                    anchor = mes[ANCHOR_ID]
+                    self.running_record_list.setdefault(tag, [])
+                    self.running_record_list[tag].append(
+                        {RECORD: record_time, DIST: distance, RSSI: rssi, ANCHOR_ID: anchor}
+                    )
+            except Exception as e:
+                traceback.format_exc()
+                print(f"获取数据时发生错误：{e.args}")
+
+    def _thread_running(self):
+        # 提前开始检测时间
+        bias = 3
+        # 离开判定时间
+        leave_detect_time = 10
+        while self.__start_running.is_set():
+            this_time = time.time()
+            for tag, record in self.running_record_list.copy().items():
+                if tag not in self.test_tag or self.running_record[tag][RUNNING_DONE]:
+                    continue
+                # 获取测试人员id
+                person_id = self.person_mes[tag]["id"]
+                sorted_record = sorted(record, key=lambda x: x[RECORD])
+                this_tag = {
+                    RUNNING_COUNTING: -1,
+                    RUNNING_STATUS: STATUS_EXIT,
+                    RUNNING_MES: "离开",
+                    RUNNING_COST: 0,
+                    RUNNING_DONE: False
+                }
+                # Cache
+                # 上次进入检测区域的时间
+                last_enter_time = self.start_time
+                # 上次离开检测区域的时间
+                last_leave_time = -1
+                # 最后一条记录的时间
+                record_time = self.start_time
+                for one_record in sorted_record:
+                    try:
+                        # 消除无效数据
+                        if one_record[RECORD] < self.start_time - bias:
+                            continue
+                        record_time = one_record[RECORD]
+                        # 离开判定1
+                        if (
+                                # 距离上次进入冲线条件的时间已经有一段时间
+                                record_time - last_leave_time > leave_detect_time
+                                and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                        ):
+                            this_tag[RUNNING_STATUS] = STATUS_EXIT
+                            this_tag[RUNNING_MES] = "离开"
+
+                        # 冲线判定
+                        if (
+                                # 并且当前时间距离上次已经大于单圈时间，并且已经离开了
+                                record_time - last_leave_time > self.min_round_time
+                                and this_tag[RUNNING_STATUS] == STATUS_EXIT
+                        ):
+                            this_tag[RUNNING_STATUS] = STATUS_ACROSS
+                            this_tag[RUNNING_MES] = "冲线"
+                            this_tag[RUNNING_COUNTING] += 1
+                            # 圈数时间记录
+                            self.round_record.setdefault(person_id, {})
+                            this_round_cost = 0 if record_time - last_enter_time < 0 else record_time - last_enter_time
+                            self.round_record[person_id][this_tag[RUNNING_COUNTING]] = this_round_cost
+                            last_enter_time += this_round_cost
+                            # 结束判定
+                            if this_tag[RUNNING_COUNTING] == self.round_num:
+                                this_tag[RUNNING_DONE] = True
+                                this_tag[RUNNING_COST] = record_time - self.start_time
+                                break
+                            last_leave_time = record_time
+                        # 如果还处于冲线状态，并且距离上次检测时间不超过离开判定周期，更新冲线时间
+                        if (
+                                this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                                # and record_time - last_leave_time < detect_time_range
+                        ):
+                            last_leave_time = record_time
+                    except Exception as e:
+                        print(traceback.format_exc())
+                        print(f"计算时发生错误:{e.args}")
+
+                # 离开判定2
+                if (
+                        # 最后离开的时间已经超过了离开判定时间
+                        this_time - last_leave_time > leave_detect_time
+                        # 最后的一条数据距离现在已经超过了离开判定时间
+                        and this_time - record_time > leave_detect_time
+                        and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                ):
+                    this_tag[RUNNING_STATUS] = STATUS_EXIT
+                    this_tag[RUNNING_MES] = "离开"
+
+                if this_time - last_leave_time > self.min_round_time and this_tag[RUNNING_STATUS] == STATUS_EXIT:
+                    this_tag[RUNNING_MES] = "回程"
+                # print(this_tag)
+                # 更新记录
+                self.update_and_play(tag=tag, new_record=this_tag)
+            # 休息一下
+            time.sleep(0.5)
+
+    def get_person_round_time(self, person_id):
+        if person_id not in self.final_data.keys():
+            return {}
+        return self.final_data[person_id]["final_result"]
+
+    def get_valid_score(self):
+        result = []
+        for person_id, data in self.final_data.items():
+            if data["done"] or data["fix"]:
+                data["score"] = score_compute(data["age"], data["total_time"], self.score_data)
+                result.append(data)
+        return result
+
+    # 获取成绩接口
+    def get_score(self):
+        score = []
+        this_cost_time = time.time() - self.start_time
+        # print(self.running_record)
+        for tag, record in self.running_record.items():
+            if record[RUNNING_COUNTING] < 0:
+                finish_status = "未起始"
+            else:
+                if record[RUNNING_COUNTING] == 0:
+                    finish_status = f"已开始({record[RUNNING_MES]})"
+                else:
+                    finish_status = f"考试中({record[RUNNING_MES]})"
+                    if record[RUNNING_COUNTING] == self.round_num:
+                        finish_status = "已完成考试"
+            age = self.person_mes[tag]["age"]
+            one = {
+                "band_id": tag,
+                "score": score_compute(age, record[RUNNING_COST], self.score_data)
+                if record[RUNNING_COUNTING] == self.round_num else 0,
+                "total_time": record[RUNNING_COST]
+                if record[RUNNING_DONE] or self.start_time == 0 else this_cost_time,
+                "round": record[RUNNING_COUNTING] if record[RUNNING_COUNTING] > 0 else 0,
+                "finish": finish_status,
+                "percentage": record[RUNNING_COUNTING] / self.round_num * 100
+                if record[RUNNING_COUNTING] > 0 else 0
+            }
+            score.append(one)
+        # print(score)
+        return score

Exercise3/running_muwb_with_rssi.py

@@ -0,0 +1,443 @@
+# coding=gb2312
+import json
+import os.path
+import sys
+
+from Database.manager_database import *
+from Speaker.speak_base import SpeakServer, beep
+from UWB.positioning_standalone_v2 import *
+
+FINISH_LINE_SIZE1 = 0
+FINISH_LINE_SIZE2 = 1
+RUNNING_COUNTING = "cnt"
+RUNNING_STATUS = "stat"
+RUNNING_MES = "mes"
+STATUS_ACROSS = "across"
+STATUS_EXIT = "exit"
+RUNNING_LAST_STATUS_TIME = "lst"
+RUNNING_COST = "cost"
+RUNNING_DONE = 'done'
+
+PATH = sys.path[0]
+ANCHOR_RSSI_ADJUSTMENT_PATH = f"{PATH}/Exercise3/anchor_adjustment.json"
+
+
+def score_compute(age, cost, score_data):
+    my_age_index = 0
+    for age_index in range(len(score_data["age"])):
+        candidate_age = score_data["age"][age_index]
+        if candidate_age[0] <= age <= candidate_age[1]:
+            my_age_index = age_index
+            break
+    my_score_index = len(score_data["values"]) - 1
+    for value_index in range(len(score_data["values"]) - 1, 0 - 1, -1):
+        value = score_data["values"][value_index][my_age_index]
+        if cost <= value[0] * 60 + value[1]:
+            my_score_index = value_index
+        else:
+            break
+    if cost > score_data["values"][-1][my_age_index][0] * 60 + score_data["values"][-1][my_age_index][1]:
+        my_base_score = 0
+    else:
+        my_base_score = score_data["score"][my_score_index]
+    if my_base_score == 100:
+        value = score_data["values"][my_score_index][my_age_index]
+        base_score = value[0] * 60 + value[1]
+        my_score = my_base_score + (base_score - cost) // 5 * 1
+    else:
+        my_score = my_base_score
+
+    return my_score
+
+
+class Running:
+
+    def __init__(self, positioning: Positioning, round_num=3, min_round_time=30) -> None:
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+        self.positioning = positioning
+        self.positioning_tag = None
+        self.finish_line = {}
+        # 起跑时间
+        self.start_time = 0
+        # 结束时间
+        self.stop_time = 0
+        # 跑步记录
+        self.running_record = {}
+        # 跑步流水记录
+        self.running_record_list = {}
+        # 跑步圈时记录
+        self.round_record = {}
+        # 记录手环
+        self.test_tag = []
+        # 手环对应人员信息
+        self.person_mes = {}
+        # 是否起跑状态
+        self.__start_running = threading.Event()
+        self.__start_running.clear()
+        # 说话
+        self.speak_driver = SpeakServer()
+        self.speak_driver.start()
+        # 成绩文件
+        file = open(f"{PATH}/Exercise3/running_score.json")
+        self.score_data = json.load(file)
+        # 基站校准数据
+        anchor_list = list(positioning.multi_uwb.uwb_driver_table.keys())
+        default_effective_rssi = -84
+        if os.path.exists(ANCHOR_RSSI_ADJUSTMENT_PATH):
+            with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "r", encoding="utf-8_sig") as file:
+                self.anchor_rssi_adjustment = json.load(file)
+            if len(self.anchor_rssi_adjustment) < len(anchor_list):
+                self.anchor_rssi_adjustment = {
+                    anchor: default_effective_rssi
+                    for anchor in anchor_list
+                }
+                with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "w", encoding="utf-8_sig") as file:
+                    json.dump(self.anchor_rssi_adjustment, file)
+        else:
+            self.anchor_rssi_adjustment = {
+                anchor: default_effective_rssi
+                for anchor in anchor_list
+            }
+            with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "w", encoding="utf-8_sig") as file:
+                json.dump(self.anchor_rssi_adjustment, file)
+
+        # 跑步记录数据
+        self.final_data = {}
+        # 是否播报
+        self.is_play = False
+
+    def set_play(self, is_play):
+        self.is_play = is_play
+
+    def update_and_play(self, tag, new_record):
+        if self.is_play:
+            this_record = self.running_record[tag]
+            if this_record[RUNNING_COUNTING] != new_record[RUNNING_COUNTING]:
+                person_name = self.person_mes[tag][NAME]
+                person_id = self.person_mes[tag][ID]
+                if new_record[RUNNING_DONE]:
+                    self.speak_driver.add_speak(f"{person_name}完成考试！")
+                else:
+                    self.speak_driver.add_speak(f"{person_name}通过第{new_record[RUNNING_COUNTING]}圈！")
+        self.running_record[tag] = new_record
+
+    def set_config(self, round_num, min_round_time):
+        self.min_round_time = float(min_round_time)
+        self.round_num = int(round_num)
+
+    def add_tag(self, tag):
+        self.test_tag.append(tag)
+
+    def del_tag(self, tag):
+        self.test_tag.remove(tag)
+        del self.person_mes[tag]
+
+    def add_tag_mes(self, tag, mes):
+        self.person_mes[tag] = mes
+
+    def reset(self):
+        self.test_tag.clear()
+        self.person_mes.clear()
+        self.start_time = 0
+
+    def start(self):
+        # 清除缓存
+        self.__start_running.clear()
+        self.round_record.clear()
+        self.positioning.clear_information()
+        self.positioning.resume()
+        # 初始化记录
+        self.running_record = {
+            tag: {
+                RUNNING_COUNTING: -1,
+                RUNNING_STATUS: STATUS_EXIT,
+                RUNNING_MES: "未起始",
+                RUNNING_COST: 0,
+                RUNNING_DONE: False,
+            }
+            for tag in self.test_tag
+        }
+        # 起跑播报
+        self.speak_driver.add_speak("准备开始考试，请就位，倒计时：")
+        counting = 5
+        for i in range(counting):
+            start_time = time.time()
+            self.speak_driver.add_speak(counting - i)
+            while time.time() - start_time < 1:
+                time.sleep(0.05)
+        self.speak_driver.wait_4_speak()
+        self.start_time = time.time()
+        self.positioning.set_valid_time(self.start_time)
+        beep(duration=700, freq=640)
+        self.__start_running.set()
+        # 启动计算线程
+        threading.Thread(target=self._thread_running, daemon=True).start()
+        threading.Thread(target=self._thread_processing, daemon=True).start()
+
+    def kill(self):
+        # 记录手环
+        self.test_tag.clear()
+        self.running_record_list.clear()
+        self.__start_running.clear()
+
+    def stop(self):
+        # # 起跑时间
+        self.stop_time = time.time()
+        # self.start_time = 0
+        self.kill()
+        # 计算最终成绩
+        self.final_data.clear()
+        raw_score = self.get_score()
+        for score in raw_score:
+            band_id = score["band_id"]
+            person_mes = self.person_mes[band_id]
+            tag_mes = self.running_record[band_id]
+            score.update(person_mes)
+            score.update(tag_mes)
+            person_id = score["id"]
+            round_time = self.round_record.get(person_id)
+            round_time_record = round_time if round_time else []
+            score.update({"round_time": round_time_record})
+            score.update({
+                "fix": False, "final_result": round_time_record
+            })
+            self.final_data[person_id] = score
+
+    # 获得当前所有成绩
+    def get_all_score(self):
+        return list(self.final_data.values())
+
+    # 成绩修复
+    def fix_score(self, person_id):
+        if not self.final_data[person_id][RUNNING_DONE]:
+            detected_round = len(self.final_data[person_id]["round_time"])
+            lacked_round = self.round_num - detected_round + 1
+            result = [
+                self.final_data[person_id]["round_time"][i]
+                for i in range(detected_round)
+            ]
+            # 如果没有成绩，按最终完成时间去计算
+            if len(result) <= 1:
+                total_time = self.stop_time - self.start_time
+                result = [total_time / (self.round_num + 1) for i in range(self.round_num + 1)]
+            # 如果有成绩
+            else:
+                for _ in range(lacked_round):
+                    max_result = max(result)
+                    index = result.index(max_result)
+                    result = result[0:index:] + [max_result / 2, max_result / 2] + result[index + 1::]
+            self.final_data[person_id]["final_result"] = {
+                i: result[i] for i in range(len(result))
+            }
+            self.final_data[person_id]["fix"] = True
+            self.final_data[person_id]["total_time"] = sum(result)
+
+    # 修复撤销
+    def fix_withdraw(self, person_id):
+        self.final_data[person_id]["final_result"] = self.final_data[person_id]["round_time"]
+        self.final_data[person_id]["fix"] = False
+
+    def _thread_processing(self):
+        while self.__start_running.is_set():
+            data = self.positioning.get_last_information()
+            try:
+                # 过滤无效操作
+                if data:
+                    record_time, mes = data
+                    # print(self.start_time - record_time, len(self.positioning.tag_information))
+                    # if record_time < self.start_time - 3:
+                    #     continue
+                    tag = mes[TAG]
+                    if tag not in self.test_tag:
+                        continue
+                    distance = mes[DIST]
+                    rssi = mes[RSSI]
+                    anchor = mes[ANCHOR_ID]
+                    self.running_record_list.setdefault(tag, [])
+                    self.running_record_list[tag].append(
+                        {RECORD: record_time, DIST: distance, RSSI: rssi, ANCHOR_ID: anchor}
+                    )
+            except Exception as e:
+                traceback.format_exc()
+                print(f"获取数据时发生错误：{e.args}")
+
+    def _thread_running(self):
+        # 提前开始检测时间
+        bias = 3
+        # 判定周期时间
+        judge_window_time = 6
+        detect_time_range = judge_window_time / 2
+        # 有效进入距离
+        effective_distance = 300
+        # effective_rssi = -84
+        # 开始判定距离
+        judge_distance = 700
+        # 离开判定时间
+        leave_detect_time = 10
+        while self.__start_running.is_set():
+            this_time = time.time()
+            for tag, record in self.running_record_list.copy().items():
+                if tag not in self.test_tag or self.running_record[tag][RUNNING_DONE]:
+                    continue
+                # 获取测试人员id
+                person_id = self.person_mes[tag]["id"]
+                sorted_record = sorted(record, key=lambda x: x[RECORD])
+                this_tag = {
+                    RUNNING_COUNTING: -1,
+                    RUNNING_STATUS: STATUS_EXIT,
+                    RUNNING_MES: "离开",
+                    RUNNING_COST: 0,
+                    RUNNING_DONE: False
+                }
+                # Cache
+                # 上次进入检测区域的时间
+                last_enter_time = self.start_time
+                # 上次离开检测区域的时间
+                last_leave_time = -1
+                # 最后一条记录的时间
+                record_time = self.start_time
+                # print("===============================================================================================")
+                for one_record in sorted_record:
+                    # print(one_record)
+                    try:
+                        # 消除无效数据
+                        if one_record[RECORD] < self.start_time - bias or this_time - one_record[RECORD] < detect_time_range:
+                            continue
+                        record_time = one_record[RECORD]
+                        distance = one_record[DIST]
+                        rssi = one_record[RSSI]
+                        anchor = one_record[ANCHOR_ID]
+                        # 更新时间窗口中的数据，未来时间一段时间内的数据。
+                        frontward_window = list(
+                            filter(
+                                lambda x: x[DIST] is not None and -detect_time_range <= record_time - x[RECORD] < 0,
+                                sorted_record
+                            )
+                        )
+                        # 离开判定1
+                        if (
+                                # 距离上次进入冲线条件的时间已经有一段时间
+                                record_time - last_leave_time > leave_detect_time
+                                and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                        ):
+                            this_tag[RUNNING_STATUS] = STATUS_EXIT
+                            this_tag[RUNNING_MES] = "离开"
+                            # print("离开判定")
+
+                        # 获取有效信号值
+                        effective_rssi = self.anchor_rssi_adjustment[anchor]
+
+                        # 冲线判定
+                        if (
+                                (
+                                        # CASE1：如果未来距离没有数据
+                                        len(frontward_window) == 0
+                                        and (
+                                                # 并且检测到距离小于判定距离
+                                                (distance is not None and distance < judge_distance)
+                                                # 或者检测到的信号强度强于检测强度
+                                                or rssi >= effective_rssi
+                                        )
+                                ) or (
+                                        # CASE2：如果未来还有数据
+                                        len(frontward_window) > 0
+                                        and distance is not None
+                                        and distance <= effective_distance
+                                        # 未来距离都比现在大
+                                        and distance - min([fw[DIST] for fw in frontward_window]) <= 20
+                                )
+                        ):
+                            # print("冲线判定")
+                            if (
+                                    # 并且当前时间距离上次已经大于单圈时间，并且已经离开了
+                                    record_time - last_leave_time > self.min_round_time
+                                    and this_tag[RUNNING_STATUS] == STATUS_EXIT
+                            ):
+                                # print("圈数判定")
+                                this_tag[RUNNING_STATUS] = STATUS_ACROSS
+                                this_tag[RUNNING_MES] = "冲线"
+                                this_tag[RUNNING_COUNTING] += 1
+                                # 圈数时间记录
+                                self.round_record.setdefault(person_id, {})
+                                this_round_cost = 0 if record_time - last_enter_time < 0 else record_time - last_enter_time
+                                self.round_record[person_id][this_tag[RUNNING_COUNTING]] = this_round_cost
+                                last_enter_time += this_round_cost
+                                # 结束判定
+                                if this_tag[RUNNING_COUNTING] == self.round_num:
+                                    this_tag[RUNNING_DONE] = True
+                                    this_tag[RUNNING_COST] = record_time - self.start_time
+                                    break
+                                last_leave_time = record_time
+                            # 如果还处于冲线状态，并且距离上次检测时间不超过离开判定周期，更新冲线时间
+                            if (
+                                    this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                                    # and record_time - last_leave_time < detect_time_range
+                            ):
+                                last_leave_time = record_time
+                    except Exception as e:
+                        print(traceback.format_exc())
+                        print(f"计算时发生错误:{e.args}")
+
+                # 离开判定2
+                if (
+                        # 最后离开的时间已经超过了离开判定时间
+                        this_time - last_leave_time > leave_detect_time
+                        # 最后的一条数据距离现在已经超过了离开判定时间
+                        and this_time - record_time > leave_detect_time
+                        and this_tag[RUNNING_STATUS] == STATUS_ACROSS
+                ):
+                    this_tag[RUNNING_STATUS] = STATUS_EXIT
+                    this_tag[RUNNING_MES] = "离开"
+
+                if this_time - last_leave_time > self.min_round_time and this_tag[RUNNING_STATUS] == STATUS_EXIT:
+                    this_tag[RUNNING_MES] = "回程"
+                # print(this_tag)
+                # 更新记录
+                self.update_and_play(tag=tag, new_record=this_tag)
+            # 休息一下
+            time.sleep(0.5)
+
+    def get_person_round_time(self, person_id):
+        if person_id not in self.final_data.keys():
+            return {}
+        return self.final_data[person_id]["final_result"]
+
+    def get_valid_score(self):
+        result = []
+        for person_id, data in self.final_data.items():
+            if data["done"] or data["fix"]:
+                data["score"] = score_compute(data["age"], data["total_time"], self.score_data)
+                result.append(data)
+        return result
+
+    # 获取成绩接口
+    def get_score(self):
+        score = []
+        this_cost_time = time.time() - self.start_time
+        # print(self.running_record)
+        for tag, record in self.running_record.items():
+            if record[RUNNING_COUNTING] < 0:
+                finish_status = "未起始"
+            else:
+                if record[RUNNING_COUNTING] == 0:
+                    finish_status = f"已开始({record[RUNNING_MES]})"
+                else:
+                    finish_status = f"考试中({record[RUNNING_MES]})"
+                    if record[RUNNING_COUNTING] == self.round_num:
+                        finish_status = "已完成考试"
+            age = self.person_mes[tag]["age"]
+            one = {
+                "band_id": tag,
+                "score": score_compute(age, record[RUNNING_COST], self.score_data)
+                if record[RUNNING_COUNTING] == self.round_num else 0,
+                "total_time": record[RUNNING_COST]
+                if record[RUNNING_DONE] or self.start_time == 0 else this_cost_time,
+                "round": record[RUNNING_COUNTING] if record[RUNNING_COUNTING] > 0 else 0,
+                "finish": finish_status,
+                "percentage": record[RUNNING_COUNTING] / self.round_num * 100
+                if record[RUNNING_COUNTING] > 0 else 0
+            }
+            score.append(one)
+        # print(score)
+        return score

Exercise3/running_score.json

@@ -0,0 +1,18 @@
+{
+  "age": [
+    [0, 24], [25, 27], [28, 30], [31, 33], [34, 36], [37, 39], [40, 42], [43, 45], [46, 48], [49, 51], [52, 54], [55, 57], [58, 60]
+  ],
+  "score": [100, 95, 90, 85, 80, 75, 70, 65, 60, 55],
+  "values": [
+    [[11, 30], [11, 42], [12, 18], [12, 54], [13, 30], [14, 6], [14, 48], [15, 30], [16, 12], [16, 54], [17, 36], [18, 18], [19, 0]],
+    [[11, 55], [12, 7], [12, 43], [13, 19], [13, 55], [14, 31], [15, 13], [15, 55], [16, 37], [17, 19], [18, 1], [18, 43], [19, 25]],
+    [[12, 10], [12, 22], [12, 58], [13, 34], [14, 10], [14, 46], [15, 28], [16, 10], [16, 52], [17, 34], [18, 16], [18, 58], [19, 40]],
+    [[12, 25], [12, 37], [13, 13], [13, 49], [14, 25], [15, 1], [15, 43], [16, 25], [17, 7], [17, 49], [18, 31], [19, 13], [19, 55]],
+    [[12, 40], [12, 52], [13, 28], [14, 4], [14, 40], [15, 16], [15, 58], [16, 40], [17, 22], [18, 8], [18, 50], [19, 32], [20, 14]],
+    [[12, 55], [13, 7], [13, 43], [14, 19], [14, 55], [15, 31], [16, 13], [16, 55], [17, 37], [18, 19], [19, 1], [19, 43], [20, 25]],
+    [[13, 10], [13, 22], [13, 58], [14, 34], [15, 10], [15, 45], [16, 28], [17, 10], [17, 52], [18, 34], [19, 16], [19, 58], [20, 40]],
+    [[13, 30], [13, 42], [14, 18], [14, 44], [15, 30], [15, 50], [16, 48], [17, 30], [18, 12], [18, 54], [19, 36], [20, 18], [21, 0]],
+    [[13, 35], [13, 47], [14, 23], [14, 55], [15, 35], [15, 55], [16, 53], [17, 35], [18, 17], [18, 59], [19, 41], [20, 23], [21, 5]],
+    [[13, 40], [13, 52], [14, 28], [15, 0], [15, 40], [16, 0], [16, 58], [17, 40], [18, 22], [19, 4], [19, 46], [20, 28], [21, 10]]
+  ]
+}

Exercise3/sit_up_new.py

@@ -0,0 +1,326 @@
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class SitUp_New(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.range = 0
+        self.count = 0
+        # 当前状态
+        self.hand_state = 0
+        self.direction = 0
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        # 初始化
+        self.initial_palm_1_y = 0
+        self.initial_palm_1_x = 0
+        self.initial_palm_2_x = 0
+        self.initial_palm_2_y = 0
+        self.initial_torso_1 = 0
+        self.initial_torso_2 = 0
+        self.distance = 24
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.state = 0
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 120, 500)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.isSet()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        self.speak_driver.add_speak(f"时间到，考试结束")
+        self.is_start = False
+
+    def display(self, img):
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 11, 19, 25, bias_x=120, bias_y=160)
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 12, 20, 26, bias_x=120, bias_y=160)
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            palm_1_x = self.detector.findPosition(img, False)[19][1]
+            palm_1_y = self.detector.findPosition(img, False)[19][2]
+            palm_2_x = self.detector.findPosition(img, False)[20][1]
+            palm_2_y = self.detector.findPosition(img, False)[20][2]
+            hip_1 = self.detector.findAngle(img, 11, 23, 25, False)
+            hip_2 = self.detector.findAngle(img, 12, 24, 26, False)
+            knee_1 = self.detector.findAngle(img, 23, 25, 27, False)
+            knee_2 = self.detector.findAngle(img, 24, 26, 28, False)
+            arm_1 = self.detector.findAngle(img, 11, 13, 15, False)
+            arm_2 = self.detector.findAngle(img, 12, 14, 16, False)
+            torso_1 = self.detector.findAngle(img, 11, 23, 29, False)
+            torso_2 = self.detector.findAngle(img, 12, 24, 30, False)
+            vis_wrist_1 = self.detector.findPosition(img, False)[15][4]
+            vis_wrist_2 = self.detector.findPosition(img, False)[16][4]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if (torso_1 >= 160 and arm_1 >= 160 and 60 <= knee_1 <= 110) or (
+                        torso_2 >= 160 and arm_2 >= 160 and 60 <= knee_2 <= 110):
+                    if self.pre_pos == 1:
+                        if vis_wrist_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                                self.initial_palm_1_y = palm_1_y
+                                self.initial_palm_1_x = palm_1_x
+
+                        elif vis_wrist_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                                self.initial_palm_2_y = palm_2_y
+                                self.initial_palm_2_x = palm_2_x
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                self.per = np.interp(hip_1, (90, 140), (100, 0))
+                self.bar = np.interp(hip_1, (90, 140), (62, 280))
+                if self.count >= 1:
+                    if 140 <= arm_1 and 160 <= torso_1:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.distance = 25
+                                self.speak_state = 0
+                                self.initial_palm_1_x = palm_1_x
+                else:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self.time += 1
+                        if self.time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self.time = 0
+                            self.distance = 25
+                            self.speak_state = 0
+
+                if self.initial_palm_1_x - self.distance >= palm_1_x and torso_1 <= 160:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+
+                if self.initial_palm_1_y - 30 > palm_1_y:
+                    self.time += 1
+                    if self.time > 3:
+                        self.state = 1
+                        self.time = 0
+                        if self.speak_state == 0:
+                            self.speak_driver.add_speak('手过高')
+                            self.speak_state = 1
+                # elif knee_1 < 45:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过小')
+                #             self.speak_state = 1
+                # elif knee_1 > 130:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过大')
+                #             self.speak_state = 1
+                # elif arm_1 < 90:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('手未伸直')
+                #             self.speak_state = 1
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                self.per = np.interp(hip_2, (90, 140), (100, 0))
+                self.bar = np.interp(hip_2, (90, 140), (62, 280))
+                if 140 <= arm_2 and 160 <= torso_2:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self.time += 1
+                        if self.time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self.time = 0
+                            self.distance = 25
+                            self.speak_state = 0
+                            self.initial_palm_2_x = palm_2_x
+
+                if self.initial_palm_2_x + self.distance <= palm_2_x and torso_2 <= 160:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+
+                if self.initial_palm_2_y - 30 > palm_2_y:
+                    self.time += 1
+                    if self.time > 3:
+                        self.state = 1
+                        self.time = 0
+                        if self.speak_state == 0:
+                            self.speak_driver.add_speak('手过高')
+                            self.speak_state = 1
+                # elif knee_2 < 60:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过小')
+                #             self.speak_state = 1
+                # elif knee_2 > 110:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过大')
+                #             self.speak_state = 1
+                # elif arm_2 < 140:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('手未申直')
+                #             self.speak_state = 1

Exercise3/sit_up_old_1.py

@@ -0,0 +1,344 @@
+import time
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class SitUp_Old_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        self.countdown = 120
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (True, 1, True, False, True, 0.75, 0.8)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.start_time = time.time()
+        self.countdown_flag.set()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.form == 0:
+            self.detector.draw_dashed_line(img, 100, 400, 520, 440, (0, 0, 255))
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [11, 13, 16, 23, 25, 27], bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [12, 14, 15, 24, 26, 28], bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if self.pre_pos == 0:
+            self.pre_pos = 1
+            self.speak_driver.add_speak("请进入准备状态")
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[11][2]
+            elbow_1_x = self.detector.findPosition(img, False)[13][1]
+            elbow_1_y = self.detector.findPosition(img, False)[13][2]
+            elbow_2_x = self.detector.findPosition(img, False)[14][1]
+            elbow_2_y = self.detector.findPosition(img, False)[14][2]
+            wrist_1_x = self.detector.findPosition(img, False)[15][1]
+            wrist_2_x = self.detector.findPosition(img, False)[16][1]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            hip_1_x = self.detector.findPosition(img, False)[23][1]
+            hip_2_x = self.detector.findPosition(img, False)[24][1]
+            hip_1_y = self.detector.findPosition(img, False)[23][2]
+            hip_2_y = self.detector.findPosition(img, False)[24][2]
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            vis_hip_1 = self.detector.findPosition(img, False)[25][4]
+            vis_hip_2 = self.detector.findPosition(img, False)[26][4]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_hip_1 > 0.8 and vis_hip_1 > vis_hip_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.time_2 = 0
+                                self.form = 1
+
+                        elif vis_hip_2 > 0.8 and vis_hip_1 < vis_hip_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.time_1 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                hand_range_1 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                hand_range_2 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                shoulder_range = self.detector.findRange(elbow_1_x, elbow_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.6 and hand_range_2 > shoulder_range * 1.6:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time_1 += 1
+                        if self.time_1 > 3:
+                            self.state = 1
+                            self.time_1 = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 25:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                                    self.time_1 = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.time_1 = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                hand_range_1 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                hand_range_2 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                shoulder_range = self.detector.findRange(elbow_2_x, elbow_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.5
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                if hand_range_1 > shoulder_range * 1.6 and hand_range_2 > shoulder_range * 1.6:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 25:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 68 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

Exercise3/sit_up_old_2.py

@@ -0,0 +1,344 @@
+import time
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+
+import cv2
+import numpy as np
+from score_doc import get_fin_score
+from Speaker.speak_base import beep
+from copy import deepcopy
+from Database.manager_database import *
+from .base_exercise import BaseExercise
+import pyttsx3
+
+
+class SitUp_Old_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.had_done = False
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (True, 1, True, False, True, 0.75, 0.8)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.form == 0:
+            self.detector.draw_dashed_line(img, 100, 400, 520, 440, (0, 0, 255))
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [11, 13, 16, 23, 25, 27], bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [12, 14, 15, 24, 26, 28], bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if self.pre_pos == 0:
+            self.pre_pos = 1
+            self.speak_driver.add_speak("请进入准备状态")
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[11][2]
+            elbow_1_x = self.detector.findPosition(img, False)[13][1]
+            elbow_1_y = self.detector.findPosition(img, False)[13][2]
+            elbow_2_x = self.detector.findPosition(img, False)[14][1]
+            elbow_2_y = self.detector.findPosition(img, False)[14][2]
+            wrist_1_x = self.detector.findPosition(img, False)[15][1]
+            wrist_2_x = self.detector.findPosition(img, False)[16][1]
+            wrist_1_y = self.detector.findPosition(img, False)[15][2]
+            wrist_2_y = self.detector.findPosition(img, False)[16][2]
+            hip_1_x = self.detector.findPosition(img, False)[23][1]
+            hip_2_x = self.detector.findPosition(img, False)[24][1]
+            hip_1_y = self.detector.findPosition(img, False)[23][2]
+            hip_2_y = self.detector.findPosition(img, False)[24][2]
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            vis_hip_1 = self.detector.findPosition(img, False)[25][4]
+            vis_hip_2 = self.detector.findPosition(img, False)[26][4]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_hip_1 > 0.8 and vis_hip_1 > vis_hip_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+
+                        elif vis_hip_2 > 0.8 and vis_hip_1 < vis_hip_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                hand_range_1 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                hand_range_2 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                shoulder_range = self.detector.findRange(elbow_1_x, elbow_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.7 and hand_range_2 > shoulder_range * 1.7:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                hand_range_1 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                hand_range_2 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                shoulder_range = self.detector.findRange(elbow_2_x, elbow_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.7 and hand_range_2 > shoulder_range * 1.7:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (30, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (30, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        engine = pyttsx3.init()
+                                        engine.setProperty('rate', 400)
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

Exercise3/sit_up_old_3.py

@@ -0,0 +1,299 @@
+import time
+
+from MCamera.mp_algorithm import MediapipeAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+
+import cv2
+import numpy as np
+from score_doc import get_fin_score
+from Speaker.speak_base import beep
+from copy import deepcopy
+from Database.manager_database import *
+from .base_exercise import BaseExercise
+import pyttsx3
+
+
+class SitUp_Old_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.had_done = False
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (True, 1, True, False, True, 0.75, 0.8)
+        MediapipeAlgorithmPlugin.set_corner(corner=self.corner)
+        MediapipeAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.form == 0:
+            self.detector.draw_dashed_line(img, 100, 400, 520, 440, (0, 0, 255))
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [11, 13, 16, 23, 25, 27], bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [12, 14, 15, 24, 26, 28], bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if self.pre_pos == 0:
+            self.pre_pos = 1
+            self.speak_driver.add_speak("请进入准备状态")
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[3][2]
+            eye_2_y = self.detector.findPosition(img, False)[6][2]
+            shoulder_1_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_2_x = self.detector.findPosition(img, False)[11][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[11][2]
+            shoulder_2_y = self.detector.findPosition(img, False)[11][2]
+            hip_1_x = self.detector.findPosition(img, False)[23][1]
+            hip_2_x = self.detector.findPosition(img, False)[24][1]
+            hip_1_y = self.detector.findPosition(img, False)[23][2]
+            hip_2_y = self.detector.findPosition(img, False)[24][2]
+            knee_1_x = self.detector.findPosition(img, False)[25][1]
+            knee_2_x = self.detector.findPosition(img, False)[26][1]
+            knee_1_y = self.detector.findPosition(img, False)[25][2]
+            knee_2_y = self.detector.findPosition(img, False)[26][2]
+            vis_hip_1 = self.detector.findPosition(img, False)[25][4]
+            vis_hip_2 = self.detector.findPosition(img, False)[26][4]
+            ankle_1_x = self.detector.findPosition(img, False)[27][1]
+            ankle_2_x = self.detector.findPosition(img, False)[28][1]
+            ankle_1_y = self.detector.findPosition(img, False)[27][2]
+            ankle_2_y = self.detector.findPosition(img, False)[28][2]
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_hip_1 > 0.8 and vis_hip_1 > vis_hip_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+
+                        elif vis_hip_2 > 0.8 and vis_hip_1 < vis_hip_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.53
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 60 and hand_range < range and time.time() - self.last_time > self.interval:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.53
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 60 and hand_range < range and time.time() - self.last_time > self.interval:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        engine = pyttsx3.init()
+                                        engine.setProperty('rate', 400)
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

Exercise_mn/base_exercise.py

@@ -0,0 +1,222 @@
+import os
+import time
+from copy import deepcopy
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from PureBackend.general import *
+from AcrossPlatform.get_platform import GLOBAL_DIR
+from MCamera.mp_camera import *
+from Speaker import speak_base
+from Speaker.speak_base import beep
+from Database.manager_database import NAME
+from realtime_streaming import img_format_jpg
+
+
+def base_detect_image(camera: Camera):
+    _map = MediapipeAlgorithmPlugin()
+    while True:
+        _img = deepcopy(camera.get_frame())
+        img = _map.find_pose_with_drawing(_img, True)
+        yield b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + img_format_jpg(img) + b'\r\n'
+
+
+class BaseExercise(threading.Thread):
+
+    def __init__(self, info, statistic_time=120, camera: Camera = None):
+        super().__init__(daemon=True)
+        # 初始化窗体设置
+        self.detector = MoveNetAlgorithmPlugin()
+        # 摄像头对象
+        if not camera:
+            self.cap = Camera()
+        else:
+            self.cap = camera
+
+        # 个数统计
+        self.count = 0
+        # 当前状态
+        self.dir = 0
+        # 统计时间
+        self.statistic_time = statistic_time
+        # 开始时间
+        self.start_time = time.time()
+        # 開始計算時間
+        self.start_cal_time = time.time()
+        # 强制结束标志
+        self.kill_sign = False
+        # 当前画面
+        self.img = None
+        # 记录是否开始
+        self.is_start = False
+        # 获得人员信息
+        self.info = info
+        # 设置摄像头长时间不关闭
+        Camera.AUTO_CLOSE_TIMEOUT = float('inf')
+        self.exercise_type = ""
+        self.bright = -5
+        self.speak_driver = speak_base.SpeakServer()
+
+        self.corner = (0, 480, 0, 640)
+        self.config = (0.1, 50, 55, 60)
+
+    def start(self) -> None:
+        super().start()
+        self.start_cal_time = time.time()
+
+    def get_info(self):
+        return None
+
+    def is_done(self):
+        if time.time() - self.start_time > self.statistic_time or self.kill_sign:
+            Camera.stop_record()
+            return True
+        else:
+            return False
+
+    def get_result(self):
+        result = {}
+        return result
+
+    # 判断作训是否有效
+    def is_valid(self):
+        return True
+
+    # 作训回传文字
+    @staticmethod
+    def valid_mes():
+        return ""
+
+    def tran_count(self):
+        return self.count
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        self.speak_driver.add_speak(f"倒计时！")
+        retail_counting = counting_times
+        counting = 0
+        start_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - start_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+
+    # 作訓計算數據流
+    def analysis(self, frame):
+        pass
+
+    def thread_counting_streaming(self):
+        self.cap.clear_cache()
+        start_time = time.time()
+        count = 0
+        while not self.is_done():
+            frame = self.cap.get_cache()
+            if frame:
+                catch_time = frame[CATCH_TIME]
+                self.analysis(frame=frame)
+
+                count += 1
+                if catch_time - start_time > 1:
+                    print(count, time.time() - catch_time, catch_time - start_time)
+                    start_time = catch_time
+                    count = 0
+
+    # 作訓視頻流
+    def display(self, img):
+        return img
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 清除历史记录
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = self.cap.get_frame()
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def skeleton_video(self):
+        _img = deepcopy(self.cap.get_frame())
+        self.img = self.detector.find_pose_with_drawing(_img, True)
+        return self.img
+
+    def pure_streaming_gen(self):
+        if not self.kill_sign:
+            if self.is_start and self.img is not None:
+                return self.img
+            else:
+                return self.skeleton_video()
+
+    def pure_video_gen(self):
+        if not self.kill_sign:
+            self.img = cv2.rectangle(
+                self.skeleton_video(),
+                (self.corner[2], self.corner[0]),
+                (self.corner[3], self.corner[1]),
+                (0, 255, 0), 2
+            )
+            return self.img
+
+
+    def streaming_gen(self):
+        while not self.kill_sign:
+            if self.is_start and self.img is not None:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + img_format_jpg(self.img) + b'\r\n')
+            else:
+                yield (b'--frame\r\n'
+                       b'Content-Type: image/jpeg\r\n\r\n' + img_format_jpg(self.skeleton_video()) + b'\r\n')
+
+    def video_gen(self):
+        while not self.kill_sign:
+            self.img = cv2.rectangle(
+                self.skeleton_video(),
+                (self.corner[2], self.corner[0]),
+                (self.corner[3], self.corner[1]),
+                (0, 255, 0), 2
+            )
+            yield (
+                    b'--frame\r\nContent-Type: image/jpeg\r\n\r\n'
+                    + img_format_jpg(self.img)
+                    + b'\r\n'
+            )
+
+    def waiting_for_start(self):
+        while not self.is_start:
+            time.sleep(0.001)
+
+    def kill(self):
+        self.kill_sign = True
+        self.speak_driver.stop()
+        while self.is_alive():
+            time.sleep(0.1)
+
+    @staticmethod
+    def cv2_img_add_text(img, text, left, top, text_color=(0, 255, 0), text_size=30):
+        if isinstance(img, np.ndarray):  # 判断是否OpenCV图片类型
+            img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+        # 创建一个可以在给定图像上绘图的对象
+        draw = ImageDraw.Draw(img, None)
+        # 字体的格式
+        font_type_dir = os.path.join(GLOBAL_DIR, "Exercise3/simsun.ttc")
+        fontstyle = ImageFont.truetype(font_type_dir, text_size, encoding="utf-8")
+        # 绘制文本
+        draw.text((left, top), text, text_color, font=fontstyle)
+        # 转换回OpenCV格式
+        return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

Exercise_mn/overhang.py

@@ -0,0 +1,182 @@
+from threading import Thread
+
+import numpy as np
+
+from PureBackend.general import *
+from MCamera.mn_camera import *
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class Overhang(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 计时
+        self.bar = None
+        self.per = None
+        self.costtime = 0
+        self.endtime = None
+        self.starttime = None
+        # 动作持续帧数
+        self._time = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.state = 0
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "屈臂悬垂"
+        self.end_test = 0
+        self.had_start = False
+        self.had_done = False
+        # 计时
+        self.chronograph = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        if self.costtime < 0:
+            score = 0
+        else:
+            score = get_fin_score.Military(gender, int(age),
+                                           integratedProjectResult=round(self.costtime,
+                                                                       1)).IntegratedProjectScoreEvaluation()
+        if gender != "woman":
+            score = 0
+        if self.starttime and self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+
+        result = {
+            "count": self.costtime,
+            "score": score,
+            "had_done": self.had_done,
+            "time": self.chronograph,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name, gender):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if gender != "女":
+            self.speak_driver.add_speak(f"注意，该考生性别为男性，{self.exercise_type}项目成绩无效")
+
+    def timekeeping(self):
+        start_time = time.time()
+        while self.had_start:
+            now_time = time.time()
+            self.chronograph = int(now_time - start_time)
+            time.sleep(0.1)
+            if self.had_done:
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[GENDER])
+        # 清除历史记录
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = self.cap.get_frame()
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+        # # 绘制计数器
+        # cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        # cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+        #             (255, 255, 255), 5)
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST)
+            shoulder_1 = self.detector.findAngle(img, LEFT_ELBOW, LEFT_SHOULDER, LEFT_HIP)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST)
+            shoulder_2 = self.detector.findAngle(img, RIGHT_ELBOW, RIGHT_SHOULDER, RIGHT_HIP)
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_EYE]['key_points'][1]
+            nose_y = self.detector.findPosition(img, False)[NOSE]['key_points'][1]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (90, 160), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (90, 160), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = wrist_1_y - (shoulder_1_y - wrist_1_y) / 3
+                hand_2_y = wrist_2_y - (shoulder_2_y - wrist_2_y) / 3
+                head_1_y = nose_y + (nose_y - eye_1_y) * 1.3
+                head_2_y = nose_y + (nose_y - eye_2_y) * 1.3
+                if elbow_1 > 120 and elbow_2 > 120 and head_1_y > hand_1_y and head_2_y > hand_2_y:
+                    if self.state == 1:
+                        self.end_test += 1
+                        if self.end_test > 3:
+                            self.endtime = time.time()
+                            self.costtime = round(self.endtime - self.starttime, 3)
+                            self.speak_driver.add_speak("考试结束")
+                            Thread(target=self.speak_driver.add_speak,
+                                   args=(f"总耗时为{round(self.costtime, 2)}秒",)).start()
+                            self.pre_pos = 2
+                            self.had_done = True
+
+                if elbow_1 < 90 and elbow_2 < 90 and head_1_y < hand_1_y and head_2_y < hand_2_y:
+                    if self.state == 0:
+                        self.feedback = "悬垂"
+                        self._time += 1
+                        if self._time > 3:
+                            self._time = 0
+                            self.starttime = time.time()
+                            self.had_start = True
+                            self.state = 1
+                            self.speak_driver.add_speak("计时开始")
+                            threading.Thread(target=self.timekeeping).start()

Exercise_mn/pull_up_1.py

@@ -0,0 +1,225 @@
+import math
+import time
+
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mp_camera import *
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+
+
+class PullUp_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.body_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.t = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_1_y = 0
+        self.initial_wrist_2_y = 0
+
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+        self.a = time.time()
+        self.b = 0
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        self.detector.drawPoint_more(img, [NOSE, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, LEFT_KNEE], bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint_more(img, [NOSE, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, RIGHT_KNEE], bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST)
+            shoulder_1 = self.detector.findAngle(img, LEFT_ELBOW, LEFT_SHOULDER, LEFT_HIP)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST)
+            shoulder_2 = self.detector.findAngle(img, RIGHT_ELBOW, RIGHT_SHOULDER, RIGHT_HIP)
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_EYE]['key_points'][1]
+            nose_y = self.detector.findPosition(img, False)[NOSE]['key_points'][1]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][1]
+            hip_1_x = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][0]
+            hip_1_y = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][1]
+            hip_2_x = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][0]
+            hip_2_y = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][1]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (157, 100), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (157, 100), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_1_y = wrist_1_y
+                        self.initial_wrist_2_y = wrist_2_y
+                        self.initial_height_left = math.sqrt(
+                            math.pow(shoulder_2_x - hip_2_x, 2) + math.pow(shoulder_2_y - hip_2_y, 2)) * math.cos(
+                            math.pi / 6)
+                        self.initial_height_right = math.sqrt(
+                            math.pow(shoulder_1_x - hip_1_x, 2) + math.pow(shoulder_1_y - hip_1_y, 2)) * math.cos(
+                            math.pi / 6)
+
+            elif self.pre_pos == 1 and self.form == 1:
+                height_left = math.sqrt(math.pow(shoulder_2_x - hip_2_x, 2) + math.pow(shoulder_2_y - hip_2_y, 2))
+                height_right = math.sqrt(math.pow(shoulder_1_x - hip_1_x, 2) + math.pow(shoulder_1_y - hip_1_y, 2))
+                hand_1_y = wrist_1_y - (shoulder_1_y - wrist_1_y) / 3
+                hand_2_y = wrist_2_y - (shoulder_2_y - wrist_2_y) / 3
+                head_1_y = nose_y + (nose_y - eye_1_y) * 1.3
+                head_2_y = nose_y + (nose_y - eye_2_y) * 1.3
+                h_range = head_1_y - hand_1_y
+
+                if wrist_1_y - self.initial_wrist_1_y > 50 and wrist_2_y - self.initial_wrist_2_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if height_left < self.initial_height_left and height_right < self.initial_height_right:
+                    self.t += 1
+                    if self.t > 4:
+                        self.state = 1
+                        self.t = 0
+                        if self.body_state == 0:
+                            self.speak_driver.add_speak('摆幅过大')
+                            self.body_state = 1
+
+                if elbow_1 > 157 and elbow_2 > 157 and head_1_y > hand_1_y and head_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 3:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.body_state = 0
+
+                if head_1_y < hand_1_y and head_2_y < hand_2_y and not self.had_done:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                                if self.count == 1:
+                                    self.initial_wrist_1_y = wrist_1_y
+                                    self.initial_wrist_2_y = wrist_2_y
+
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif head_1_y < hand_1_y and head_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise_mn/pull_up_2.py

@@ -0,0 +1,188 @@
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class PullUp_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.speak_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_y = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        self.detector.drawPoint_more(img, [NOSE, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, LEFT_KNEE],
+                                     bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint_more(img, [NOSE, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, RIGHT_KNEE],
+                                     bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST)
+            shoulder_1 = self.detector.findAngle(img, LEFT_ELBOW, LEFT_SHOULDER, LEFT_HIP)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST)
+            shoulder_2 = self.detector.findAngle(img, RIGHT_ELBOW, RIGHT_SHOULDER, RIGHT_HIP)
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_EYE]['key_points'][1]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (155, 100), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (155, 100), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_y = wrist_1_y
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = wrist_1_y - (shoulder_1_y - wrist_1_y) / 3
+                hand_2_y = wrist_2_y - (shoulder_2_y - wrist_2_y) / 3
+                h_range = eye_1_y - hand_1_y
+
+                if wrist_1_y - self.initial_wrist_y > 50 and wrist_2_y - self.initial_wrist_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if elbow_1 > 155 and elbow_2 > 155 and eye_1_y > hand_1_y and eye_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.speak_state = 0
+
+                if eye_1_y < hand_1_y and eye_2_y < hand_2_y:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif eye_1_y < hand_1_y and eye_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise_mn/pull_up_3.py

@@ -0,0 +1,187 @@
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class PullUp_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.speak_state = 0
+        self.direction = 0
+        self.is_storard = 1
+        # 动作持续帧数
+        self._time = 0
+        self.time = 0
+        self.starttime = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.pre_pos = 0
+        self.sta_time = time.time()
+        self.feedback = "开始"
+        self.exercise_type = "引体向上"
+        self.end_test = 0
+        self.had_done = False
+        # 摆动状态
+        self.state = 0
+        # 初始化
+        self.initial_height_left = 0
+        self.initial_height_right = 0
+        self.initial_wrist_y = 0
+        # 引体向上参数
+        self.corner = (0, 480, 260, 380)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(self.count)).IntegratedProjectScoreEvaluation()
+        if self.starttime != 0:
+            this_time = time.time()
+            count_time = this_time - self.starttime
+        else:
+            count_time = 0
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "had_done": self.had_done,
+            'countdown': count_time
+        }
+        return result
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        self.detector.drawPoint_more(img, [NOSE, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, LEFT_KNEE],
+                                     bias_x=self.corner[2], bias_y=self.corner[0])
+        self.detector.drawPoint_more(img, [NOSE, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, RIGHT_KNEE],
+                                     bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+        if self.bar and self.per:
+            cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                          cv2.FILLED)
+            cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                        (255, 255, 255), 2)
+
+        # 绘制计数器
+        cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+        cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                    (255, 255, 255), 5)
+
+        # 展示状态反馈
+        cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+        img_output = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img_output
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST)
+            shoulder_1 = self.detector.findAngle(img, LEFT_ELBOW, LEFT_SHOULDER, LEFT_HIP)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST)
+            shoulder_2 = self.detector.findAngle(img, RIGHT_ELBOW, RIGHT_SHOULDER, RIGHT_HIP)
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_EYE]['key_points'][1]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][1]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+
+            # 成功概率
+            self.per = np.interp(elbow_1, (160, 90), (0, 100))
+            # 显示进度栏
+            self.bar = np.interp(elbow_1, (160, 90), (280, 62))
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if time.time() - self.sta_time > 1.5:
+                    if elbow_1 > 150 and elbow_2 > 150 and shoulder_1 > 100 and shoulder_2 > 100 and eye_1_y > wrist_1_y and eye_2_y > wrist_2_y:
+                        self.form = 1
+                        self.speak_driver.add_speak("请开始考试")
+                        self.starttime = time.time()
+                        self.initial_wrist_y = wrist_1_y
+
+            elif self.pre_pos == 1 and self.form == 1:
+                hand_1_y = wrist_1_y - (shoulder_1_y - wrist_1_y) / 3
+                hand_2_y = wrist_2_y - (shoulder_2_y - wrist_2_y) / 3
+                h_range = eye_1_y - hand_1_y
+                if wrist_1_y - self.initial_wrist_y > 50 and wrist_2_y - self.initial_wrist_y > 50 and self.pre_pos == 1:
+                    self.end_test += 1
+                    if self.end_test > 2:
+                        self.speak_driver.add_speak("双手已离开单杠，考试结束")
+                        self.pre_pos = 2
+                        self.had_done = True
+
+                if elbow_1 > 150 and elbow_2 > 150 and eye_1_y > hand_1_y and eye_2_y > hand_2_y:
+                    self.feedback = "上升"
+                    if self.direction == 0:
+                        self._time += 1
+                        if self._time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self._time = 0
+                            self.speak_state = 0
+
+                if eye_1_y < hand_1_y and eye_2_y < hand_2_y:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self._time += 1
+                            if self._time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self._time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                if h_range < 20 and self.is_storard == 1:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 2
+                        self.time = 0
+                elif eye_1_y < hand_1_y and eye_2_y < hand_2_y and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 3
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 2:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.speak_driver.add_speak('未过杠')
+                        self.time = 0
+                elif h_range > 30 and self.is_storard == 3:
+                    self.time += 1
+                    if self.time > 3:
+                        self.is_storard = 1
+                        self.time = 0

Exercise_mn/push_up_1.py

@@ -0,0 +1,286 @@
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT, CROPPED_FRAME
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class PushUp_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.had_done = False
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.start_time = time.time()
+        self.countdown_flag.set()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if int(self.countdown) >= 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_ANKLE, bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_ANKLE, bias_x=self.corner[2], bias_y=self.corner[0])
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[CROPPED_FRAME]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            vis_elbow_1 = self.detector.findPosition(img, False)[LEFT_ELBOW]['confidence']
+            vis_elbow_2 = self.detector.findPosition(img, False)[RIGHT_ELBOW]['confidence']
+            vis_knee_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_knee_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            Concave_angle_1 = self.detector.findConcave(LEFT_SHOULDER, LEFT_HIP, LEFT_KNEE)
+            Concave_angle_2 = self.detector.findConcave(RIGHT_SHOULDER, RIGHT_HIP, RIGHT_KNEE)
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, False)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if ankle_1_y > shoulder_1_y or ankle_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 145 and 155 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(400)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_1 < 95 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+                    if 155 > Concave_angle_1:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 145 and 155 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 4 and elbow_2 < 95 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+                    if 155 > Concave_angle_2:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1

Exercise_mn/push_up_2.py

@@ -0,0 +1,290 @@
+import threading
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class PushUp_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_ANKLE, bias_x=self.corner[2],
+                                    bias_y=self.corner[0])
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_ANKLE, bias_x=self.corner[2],
+                                    bias_y=self.corner[0])
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            vis_elbow_1 = self.detector.findPosition(img, False)[LEFT_ELBOW]['confidence']
+            vis_elbow_2 = self.detector.findPosition(img, False)[RIGHT_ELBOW]['confidence']
+            vis_knee_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_knee_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            Concave_angle_1 = self.detector.findConcave(LEFT_SHOULDER, LEFT_HIP, LEFT_KNEE)
+            Concave_angle_2 = self.detector.findConcave(RIGHT_SHOULDER, RIGHT_HIP, RIGHT_KNEE)
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, False)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if ankle_1_y > shoulder_1_y or ankle_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 4:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 4:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 150 and 155 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_1 < 105 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+                    if 155 > Concave_angle_1:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 150 and 155 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle > 4 and elbow_2 < 105 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+                    if 155 > Concave_angle_2:
+                        self.time += 1
+                        if self.time > 3:
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('塌腰')
+                                self.speak_state = 1

Exercise_mn/push_up_3.py

@@ -0,0 +1,276 @@
+import threading
+import time
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from .base_exercise import BaseExercise
+
+
+class PushUp_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.state = 0
+        self.speak_state = 0
+        self.direction = 1
+        # 动作持续帧数
+        self.time = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 初始化
+        self.countdown = 120
+        self.shoulder_angle = 23
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.dir = 0
+        self.exercise_type = "俯卧撑"
+        # 俯卧撑参数
+        self.corner = (180, 430, 80, 560)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        count = self.count
+        score = get_fin_score.Military(gender, int(age),
+                                       integratedProjectResult=int(count)).IntegratedProjectScoreEvaluation()
+        if age < 40:
+            score = 0
+        result = {
+            "count": int(count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name, age):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        if age < 40:
+            self.speak_driver.add_speak(f"注意，该考生年龄小于40岁，{self.exercise_type}项目成绩无效")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME], self.info[AGE])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        # 检查俯卧撑运动过程
+        if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_ANKLE, bias_x=self.corner[2],
+                                    bias_y=self.corner[0])
+        if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_ANKLE, bias_x=self.corner[2],
+                                    bias_y=self.corner[0])
+        # 绘制状态条
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            vis_elbow_1 = self.detector.findPosition(img, False)[LEFT_ELBOW]['confidence']
+            vis_elbow_2 = self.detector.findPosition(img, False)[RIGHT_ELBOW]['confidence']
+            vis_knee_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_knee_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            Concave_angle_1 = self.detector.findConcave(LEFT_SHOULDER, LEFT_HIP, LEFT_KNEE)
+            Concave_angle_2 = self.detector.findConcave(RIGHT_SHOULDER, RIGHT_HIP, RIGHT_KNEE)
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+            elbow_1 = self.detector.findAngle(img, LEFT_SHOULDER, LEFT_ELBOW, LEFT_WRIST, False)
+            elbow_2 = self.detector.findAngle(img, RIGHT_SHOULDER, RIGHT_ELBOW, RIGHT_WRIST, False)
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if ankle_1_y > shoulder_1_y or ankle_2_y > shoulder_2_y:
+                    if self.pre_pos == 1:
+                        if vis_elbow_1 > 0.8 and vis_elbow_1 > vis_elbow_2 and vis_knee_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 4:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                        elif vis_elbow_2 > 0.8 and vis_elbow_1 < vis_elbow_2 and vis_knee_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 4:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            # 检查俯卧撑运动过程
+            if self.sign == 1 and self.dir == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, shoulder_1_x, shoulder_1_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, knee_1_x, knee_1_y)
+                # 成功概率
+                self.per = np.interp(elbow_1, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_1, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_1 > 140 and 150 <= Concave_angle_1 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 3 and elbow_1 < 115 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()
+
+            if self.sign == 1 and self.dir == 2 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, shoulder_2_x, shoulder_2_y)
+                hip_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, knee_2_x, knee_2_y)
+                # 成功概率
+                self.per = np.interp(elbow_2, (90, 150), (100, 0))
+                # 显示进度栏
+                self.bar = np.interp(elbow_2, (90, 150), (62, 280))
+                if hip_angle < 70:
+                    if elbow_2 > 140 and 150 <= Concave_angle_2 <= 210:
+                        self.feedback = "下落"
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+                                self.shoulder_angle = shoulder_angle
+                                if self.count % 1 == 0:
+                                    self.speak_driver.speed_control(200)
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+                    if self.shoulder_angle - shoulder_angle < 3 and elbow_1 < 115 and time.time() - self.last_time > self.interval:
+                        self.feedback = "上升"
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 1:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                self.last_time = time.time()

Exercise_mn/run_around.py

@@ -0,0 +1,211 @@
+import time
+from copy import deepcopy
+from threading import Lock
+from threading import Thread
+
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mn_camera import MN_RESULT
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class Runaround(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        # 计时
+        self.countdown_flag = threading.Event()  # 计时线程
+        self.costtime = 0
+        self.countdown = 0
+        # 当前状态
+        self.direction = 0
+        # 动作持续帧数
+        self.time = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "请开始"
+        self.had_leaf = False
+        self.had_start = False
+        self.had_done = False
+        self.had_countdown = False
+        self.countdown_signal = True
+        self.pre_frame = None
+        self.retail_counting = 5
+        self.preempt_lock = Lock()
+        self.Preempt = 0
+        self.pretime = 0
+        self.racetime = 0
+        self.starttime = 0
+        self.endtime = 0
+        self.fix = 0
+        self.timefix = 0
+        self.catch_time = 0
+        self.exercise_type = "蛇形跑"
+        # 蛇形跑参数
+        self.corner = (0, 480, 200, 400)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        # if self.costtime == '未完成':
+        if self.costtime < 0:
+            score = 0
+        else:
+            score = get_fin_score.Military(gender, int(age),
+                                           serpentine60RunResult=round(self.costtime,
+                                                                       1)).Serpentine60RunScoreEvaluation()
+
+        result = {
+            "count": self.costtime,
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done,
+            'preempt': self.Preempt
+        }
+        return result
+
+    def get_info(self):
+        self.preempt_lock.acquire()
+        result = self.Preempt
+        self.preempt_lock.release()
+        return result
+
+    def is_valid(self):
+        return True
+
+    def _speak_counting(self):
+        threading.Thread(target=self.count_down).start()
+        counting = 0
+        first_time = self.catch_time
+        while True:
+            this_time = self.catch_time
+            if this_time - first_time > counting:
+                if not self.countdown_signal and not self.had_countdown:
+                    self.speak_driver.add_speak(f"抢跑！")
+                    self.pretime = self.catch_time
+                    self.countdown_flag.set()
+                    self.had_countdown = True
+                if self.retail_counting > 0:
+                    if self.countdown_signal:
+                        self.speak_driver.speed_control(350)
+                        self.speak_driver.add_speak(f"{self.retail_counting}")
+                        self.speak_driver.wait_4_speak()
+                    counting += 1
+                    self.retail_counting -= 1
+                else:
+                    if self.countdown_signal:
+                        threading.Thread(target=beep, args=(300, 640), daemon=True).start()
+                        self.had_countdown = True
+                        self.countdown_flag.set()
+                        self.pretime = self.catch_time
+                    break
+        self.had_start = True
+        self.starttime = self.catch_time
+
+    def count_down(self):
+        while True:
+            self.countdown_flag.wait()
+            self.costtime = self.catch_time - self.pretime
+            self.countdown = int(self.costtime)
+            time.sleep(0.1)
+
+    def run(self) -> None:
+        self.speak_driver.add_speak("考试人员{}".format(self.info[NAME]))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+        self.speak_driver.wait_4_speak()
+        self.cap.clear_cache()
+        # 记录开始时间
+        self.start_time = time.time()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if not self.had_countdown:
+            cv2.putText(img, str(self.retail_counting), (230, 320), cv2.FONT_HERSHEY_PLAIN, 20, (255, 255, 255), 8)
+        return img
+
+    def analysis(self, frame):
+        self.catch_time = frame[CATCH_TIME]
+        if self.catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        img_input = img[self.corner[0]:self.corner[1], self.corner[2]:self.corner[3]]
+        if self.timefix == 0:
+            self.timefix = 1
+            Thread(target=self._speak_counting, daemon=True).start()
+        if not self.had_countdown:
+            self.detector.set_result(lm_list)
+            # self.starttime = time.time()
+            if len(lm_list) == 0:
+                self.time = self.time + 1
+                if self.fix == 0 and self.time > 3:
+                    self.fix += 1
+                    self.countdown_signal = False
+                    self.preempt_lock.acquire()
+                    self.racetime = self.catch_time
+                    self.preempt_lock.release()
+                    self.valid_mes()
+                    self.is_valid()
+        # 如果没有背景图像就将当前帧当作背景图片
+        else:
+            # 计算抢跑时间
+            if self.starttime - self.racetime <= 5:
+                self.Preempt = round(self.starttime - self.racetime, 3)
+            elif 10 > self.starttime - self.racetime > 5:
+                self.Preempt = 5
+            else:
+                self.Preempt = 0
+            if self.had_start and not self.had_leaf and not self.had_done:
+                # 一直等待到目标完全离开检测区
+                if self.catch_time - self.pretime > 14:
+                    self.had_leaf = True
+            else:
+                # 转灰度图
+                gray_pic = cv2.cvtColor(img_input, cv2.COLOR_BGR2GRAY)
+                # 用高斯滤波进行模糊处理
+                gray_pic = cv2.GaussianBlur(gray_pic, (21, 21), 0)
+                if self.pre_frame is None:
+                    self.pre_frame = gray_pic
+                else:
+                    # absdiff把两幅图的差的绝对值输出到另一幅图上面来
+                    img_delta = cv2.absdiff(self.pre_frame, gray_pic)
+                    # threshold阈值函数(原图像应该是灰度图,对像素值进行分类的阈值,当像素值高于（有时是小于）阈值时应该被赋予的新的像素值,阈值方法)
+                    thresh = cv2.threshold(img_delta, 30, 255, cv2.THRESH_BINARY)[1]
+                    # 用一下腐蚀与膨胀
+                    thresh = cv2.dilate(thresh, None, iterations=2)
+                    # findContours检测物体轮廓(寻找轮廓的图像,轮廓的检索模式,轮廓的近似办法)
+                    contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                    for c in contours:
+                        # 设置敏感度
+                        if cv2.contourArea(c) < 7500:
+                            continue
+                        else:
+                            if self.had_start and self.had_leaf and not self.had_done:
+                                self.endtime = self.catch_time
+                                self.had_done = True
+                                self.costtime = round(self.endtime - self.starttime + self.Preempt, 3)
+                                self.countdown_flag.clear()
+                                # print("总耗时 = {}".format(self.costtime))
+                                self.speak_driver.speed_control(200)
+                                Thread(
+                                    target=self.speak_driver.add_speak,
+                                    args=(f"抢跑时间为{round(self.Preempt, 2)}秒,总耗时为{round(self.costtime, 2)}秒",)
+                                ).start()
+                            break
+                    self.pre_frame = gray_pic

Exercise_mn/sit_up_new.py

@@ -0,0 +1,327 @@
+from copy import deepcopy
+
+import numpy as np
+
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class SitUp_New(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.range = 0
+        self.count = 0
+        # 当前状态
+        self.hand_state = 0
+        self.direction = 0
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        # 初始化
+        self.initial_palm_1_y = 0
+        self.initial_palm_1_x = 0
+        self.initial_palm_2_x = 0
+        self.initial_palm_2_y = 0
+        self.initial_torso_1 = 0
+        self.initial_torso_2 = 0
+        self.distance = 24
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.state = 0
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 120, 500)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.isSet()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        self.speak_driver.add_speak(f"时间到，考试结束")
+        self.is_start = False
+
+    def display(self, img):
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 11, 19, 25, bias_x=120, bias_y=160)
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint(img, 12, 20, 26, bias_x=120, bias_y=160)
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MP_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            palm_1_x = self.detector.findPosition(img, False)[19][1]
+            palm_1_y = self.detector.findPosition(img, False)[19][2]
+            palm_2_x = self.detector.findPosition(img, False)[20][1]
+            palm_2_y = self.detector.findPosition(img, False)[20][2]
+            hip_1 = self.detector.findAngle(img, 11, 23, 25, False)
+            hip_2 = self.detector.findAngle(img, 12, 24, 26, False)
+            knee_1 = self.detector.findAngle(img, 23, 25, 27, False)
+            knee_2 = self.detector.findAngle(img, 24, 26, 28, False)
+            arm_1 = self.detector.findAngle(img, 11, 13, 15, False)
+            arm_2 = self.detector.findAngle(img, 12, 14, 16, False)
+            torso_1 = self.detector.findAngle(img, 11, 23, 29, False)
+            torso_2 = self.detector.findAngle(img, 12, 24, 30, False)
+            vis_wrist_1 = self.detector.findPosition(img, False)[15][4]
+            vis_wrist_2 = self.detector.findPosition(img, False)[16][4]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                if (torso_1 >= 160 and arm_1 >= 160 and 60 <= knee_1 <= 110) or (
+                        torso_2 >= 160 and arm_2 >= 160 and 60 <= knee_2 <= 110):
+                    if self.pre_pos == 1:
+                        if vis_wrist_1 > 0.8:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+                                self.initial_palm_1_y = palm_1_y
+                                self.initial_palm_1_x = palm_1_x
+
+                        elif vis_wrist_2 > 0.8:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                                self.initial_palm_2_y = palm_2_y
+                                self.initial_palm_2_x = palm_2_x
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                self.per = np.interp(hip_1, (90, 140), (100, 0))
+                self.bar = np.interp(hip_1, (90, 140), (62, 280))
+                if self.count >= 1:
+                    if 140 <= arm_1 and 160 <= torso_1:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.distance = 25
+                                self.speak_state = 0
+                                self.initial_palm_1_x = palm_1_x
+                else:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self.time += 1
+                        if self.time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self.time = 0
+                            self.distance = 25
+                            self.speak_state = 0
+
+                if self.initial_palm_1_x - self.distance >= palm_1_x and torso_1 <= 160:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+
+                if self.initial_palm_1_y - 30 > palm_1_y:
+                    self.time += 1
+                    if self.time > 3:
+                        self.state = 1
+                        self.time = 0
+                        if self.speak_state == 0:
+                            self.speak_driver.add_speak('手过高')
+                            self.speak_state = 1
+                # elif knee_1 < 45:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过小')
+                #             self.speak_state = 1
+                # elif knee_1 > 130:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过大')
+                #             self.speak_state = 1
+                # elif arm_1 < 90:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('手未伸直')
+                #             self.speak_state = 1
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                self.per = np.interp(hip_2, (90, 140), (100, 0))
+                self.bar = np.interp(hip_2, (90, 140), (62, 280))
+                if 140 <= arm_2 and 160 <= torso_2:
+                    self.feedback = "上升"
+                    self.state = 0
+                    if self.direction == 0:
+                        self.time += 1
+                        if self.time > 2:
+                            self.count += 0.5
+                            self.direction = 1
+                            self.time = 0
+                            self.distance = 25
+                            self.speak_state = 0
+                            self.initial_palm_2_x = palm_2_x
+
+                if self.initial_palm_2_x + self.distance <= palm_2_x and torso_2 <= 160:
+                    self.feedback = "下落"
+                    if self.state == 0:
+                        if self.direction == 1:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 0
+                                self.time = 0
+                                if self.count % 1 == 0:
+                                    self.speak_driver.add_speak("{}".format(int(self.count)))
+
+                if self.initial_palm_2_y - 30 > palm_2_y:
+                    self.time += 1
+                    if self.time > 3:
+                        self.state = 1
+                        self.time = 0
+                        if self.speak_state == 0:
+                            self.speak_driver.add_speak('手过高')
+                            self.speak_state = 1
+                # elif knee_2 < 60:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过小')
+                #             self.speak_state = 1
+                # elif knee_2 > 110:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('膝部角度过大')
+                #             self.speak_state = 1
+                # elif arm_2 < 140:
+                #     self.time += 1
+                #     if self.time > 3:
+                #         self.time = 0
+                #         if self.speak_state == 0:
+                #             self.speak_driver.add_speak('手未申直')
+                #             self.speak_state = 1

Exercise_mn/sit_up_old_1.py

@@ -0,0 +1,347 @@
+import time
+from copy import deepcopy
+
+import numpy as np
+
+from MCamera.mn_camera import MN_RESULT
+from PureBackend.general import *
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from Speaker.speak_base import beep
+from Database.manager_database import *
+from score_doc import get_fin_score
+from Exercise_mn.base_exercise import BaseExercise
+
+
+class SitUp_Old_1(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        self.countdown = 120
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.had_done = False
+        self.sign = 0
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (0.3, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.start_time = time.time()
+        self.countdown_flag.set()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [LEFT_SHOULDER, LEFT_ELBOW, RIGHT_WRIST, LEFT_HIP, LEFT_KNEE, LEFT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img,
+                                         [RIGHT_SHOULDER, RIGHT_ELBOW, LEFT_WRIST, RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if self.pre_pos == 0:
+            self.pre_pos = 1
+            self.speak_driver.add_speak("请进入准备状态")
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            elbow_1_x = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][0]
+            elbow_1_y = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][1]
+            elbow_2_x = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][0]
+            elbow_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            wrist_1_x = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][0]
+            wrist_2_x = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][0]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            hip_1_x = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][0]
+            hip_2_x = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][0]
+            hip_1_y = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][1]
+            hip_2_y = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][1]
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            vis_knee_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_knee_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+            left_wrist_past_test = self.detector.findPosition(img, False)[LEFT_WRIST]['pass_test']
+            right_wrist_past_test = self.detector.findPosition(img, False)[RIGHT_WRIST]['pass_test']
+            left_wrist_reliable = self.detector.findPosition(img, False)[LEFT_WRIST]['reliable']
+            right_wrist_reliable = self.detector.findPosition(img, False)[RIGHT_WRIST]['reliable']
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_knee_1 > 0.7 and vis_knee_1 > vis_knee_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.time_2 = 0
+                                self.form = 1
+
+                        elif vis_knee_2 > 0.7 and vis_knee_1 < vis_knee_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.time_1 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                hand_range_1 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                hand_range_2 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                shoulder_range = self.detector.findRange(elbow_1_x, elbow_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.6 and hand_range_2 > shoulder_range * 1.6 and left_wrist_past_test and left_wrist_reliable:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time_1 += 1
+                        if self.time_1 > 3:
+                            self.state = 1
+                            self.time_1 = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 25:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                                    self.time_1 = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.time_1 = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                hand_range_1 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                hand_range_2 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                shoulder_range = self.detector.findRange(elbow_2_x, elbow_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.5
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                if hand_range_1 > shoulder_range * 1.6 and hand_range_2 > shoulder_range * 1.6 and right_wrist_past_test and right_wrist_reliable:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 25:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 68 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

Exercise_mn/sit_up_old_2.py

@@ -0,0 +1,343 @@
+import time
+
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mn_camera import MN_RESULT
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from PureBackend.general import *
+
+import cv2
+import numpy as np
+from score_doc import get_fin_score
+from Speaker.speak_base import beep
+from copy import deepcopy
+from Database.manager_database import *
+from Exercise_mn.base_exercise import BaseExercise
+import pyttsx3
+
+
+class SitUp_Old_2(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.had_done = False
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [LEFT_SHOULDER, LEFT_ELBOW, RIGHT_WRIST, LEFT_HIP, LEFT_KNEE, LEFT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img,
+                                         [RIGHT_SHOULDER, RIGHT_ELBOW, LEFT_WRIST, RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            elbow_1_x = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][0]
+            elbow_1_y = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][1]
+            elbow_2_x = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][0]
+            elbow_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            wrist_1_x = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][0]
+            wrist_2_x = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][0]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            hip_1_x = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][0]
+            hip_2_x = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][0]
+            hip_1_y = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][1]
+            hip_2_y = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][1]
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            vis_hip_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_hip_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_hip_1 > 0.8 and vis_hip_1 > vis_hip_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+
+                        elif vis_hip_2 > 0.8 and vis_hip_1 < vis_hip_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                hand_range_1 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                hand_range_2 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                shoulder_range = self.detector.findRange(elbow_1_x, elbow_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.7 and hand_range_2 > shoulder_range * 1.7:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                hand_range_1 = self.detector.findRange(wrist_2_x, wrist_2_y, shoulder_1_x, shoulder_1_y)
+                hand_range_2 = self.detector.findRange(wrist_1_x, wrist_1_y, shoulder_2_x, shoulder_2_y)
+                shoulder_range = self.detector.findRange(elbow_2_x, elbow_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.5
+
+                if hand_range_1 > shoulder_range * 1.7 and hand_range_2 > shoulder_range * 1.7:
+                    self.is_storard = False
+                else:
+                    self.is_storard = True
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (30, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (30, 65), (62, 280))
+                if ankle_angle < 70:
+                    if not self.is_storard:
+                        self.time += 1
+                        if self.time > 3:
+                            self.state = 1
+                            self.time = 0
+                            if self.speak_state == 0:
+                                self.speak_driver.add_speak('手离肩')
+                                self.speak_state = 1
+
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 65 and hand_range < range and time.time() - self.last_time > self.interval and self.is_storard:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        engine = pyttsx3.init()
+                                        engine.setProperty('rate', 400)
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

Exercise_mn/sit_up_old_3.py

@@ -0,0 +1,311 @@
+import time
+
+from MCamera.mn_algorithm import MoveNetAlgorithmPlugin
+from MCamera.mn_camera import MN_RESULT
+from MCamera.mp_camera import MP_RESULT
+from MCamera.camera import *
+from PureBackend.general import *
+
+import cv2
+import numpy as np
+from score_doc import get_fin_score
+from Speaker.speak_base import beep
+from copy import deepcopy
+from Database.manager_database import *
+from Exercise_mn.base_exercise import BaseExercise
+import pyttsx3
+
+
+class SitUp_Old_3(BaseExercise):
+    def __init__(self, info, statistic_time=120, camera=None):
+        super().__init__(info, statistic_time, camera=camera)
+        self.countdown_flag = threading.Event()  # 计时线程
+        # 个数统计
+        self.bar = None
+        self.per = None
+        self.count = 0
+        # 当前状态
+        self.countdown = 120
+        self.pre_pos = 0
+        self.speak_state = 0
+        self.state = 0
+        self.direction = 0
+        self.is_storard = True
+        # 初始化
+        # 动作持续帧数
+        self.time = 0
+        self.time_1 = 0
+        self.time_2 = 0
+        self.last_time = 0
+        self.interval = 0.5
+        # 开始标志
+        self.form = 0
+        # 状态反馈
+        self.feedback = "开始"
+        self.sign = 0
+        self.had_done = False
+        # 目标朝向
+        self.dir = 0
+        self.exercise_type = "仰卧起坐"
+        # 仰卧起坐参数
+        self.corner = (160, 460, 100, 520)
+        self.config = (0.7, 50, 55, 60)
+        MoveNetAlgorithmPlugin.set_corner(corner=self.corner)
+        MoveNetAlgorithmPlugin.set_config(config=self.config)
+
+    def get_result(self):
+        # 人员年龄
+        age = self.info.get(AGE)
+        # 人员性别
+        gender = "woman" if self.info.get(GENDER) == "女" else "man"
+        score = get_fin_score.Military(gender, int(age), sitUpsResult=int(self.count)).SitUpsScoreEvaluation()
+        result = {
+            "count": int(self.count),
+            "score": score,
+            "countdown": self.countdown,
+            "had_done": self.had_done
+        }
+        return result
+
+    def retail_counting(self):
+        retail_counting = 3
+        counting = 0
+        first_time = time.time()
+        while True:
+            this_time = time.time()
+            if this_time - first_time > counting:
+                if retail_counting > 0:
+                    self.speak_driver.add_speak(f"{retail_counting}！")
+                    self.speak_driver.wait_4_speak()
+                    counting += 1
+                    retail_counting -= 1
+                else:
+                    break
+        threading.Thread(target=beep, daemon=True).start()
+        self.countdown_flag.set()
+        self.start_time = time.time()
+
+    def speak_counting(self, counting_times, name):
+        self.speak_driver.start()
+        self.speak_driver.speed_control(200)
+        self.speak_driver.volume_control(1)
+        self.speak_driver.add_speak("考试人员{}".format(name))
+        self.speak_driver.add_speak(f"考试项目{self.exercise_type}")
+
+    def count_down(self):
+        seconds = 120
+        while True:
+            self.countdown_flag.wait()
+            this_time = time.time()
+            count_time = this_time - self.start_time
+            second = int(seconds - count_time)
+            self.countdown = f"{second}"
+            time.sleep(0.1)
+            if second == 0:
+                self.countdown_flag.clear()
+                break
+
+    def run(self) -> None:
+        self.speak_counting(5, self.info[NAME])
+        # 准备倒计时
+        threading.Thread(target=self.count_down).start()
+        self.is_start = True
+        # 不停更新计算和更新画面
+        threading.Thread(target=self.thread_counting_streaming, daemon=True).start()
+        while not self.is_done():
+            _img = deepcopy(self.cap.get_frame())
+            self.img = self.display(_img)
+        if self.countdown == 120:
+            self.speak_driver.add_speak(f"长时间未进入准备状态，考试结束")
+        elif int(self.countdown) <= 1:
+            self.had_done = True
+            self.speak_driver.add_speak(f"时间到，考试结束")
+        elif 1 < int(self.countdown) < 120:
+            self.speak_driver.add_speak(f"考试终止")
+        self.is_start = False
+
+    def display(self, img):
+        cv2.rectangle(img, (self.corner[2], self.corner[0]), (self.corner[3], self.corner[1]), (0, 255, 0), 2)
+        if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img, [LEFT_SHOULDER, LEFT_ELBOW, RIGHT_WRIST, LEFT_HIP, LEFT_KNEE, LEFT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+        elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+            self.detector.drawPoint_more(img,
+                                         [RIGHT_SHOULDER, RIGHT_ELBOW, LEFT_WRIST, RIGHT_HIP, RIGHT_KNEE, RIGHT_ANKLE],
+                                         bias_x=self.corner[2], bias_y=self.corner[0])
+
+        if self.sign == 1:
+            cv2.rectangle(img, (650 - 100, 60), (650 - 80, 282), (255, 255, 255), 2)
+            if self.bar and self.per:
+                cv2.rectangle(img, (650 - 98, int(self.bar)), (650 - 82, 280), (102, 106, 233),
+                              cv2.FILLED)
+                cv2.putText(img, f'{int(self.per)}%', (650 - 125, 320), cv2.FONT_HERSHEY_PLAIN, 2,
+                            (255, 255, 255), 2)
+
+            # 绘制计数器
+            cv2.rectangle(img, (0, 480 - 120), (120, 480), (102, 106, 233), cv2.FILLED)
+            cv2.putText(img, str(int(self.count)), (10, 480 - 35), cv2.FONT_HERSHEY_PLAIN, 5,
+                        (255, 255, 255), 5)
+
+            # 展示状态反馈
+            cv2.rectangle(img, (640 - 160, 0), (640, 50), (102, 106, 233), cv2.FILLED)
+            img = self.cv2_img_add_text(img, self.feedback, 640 - 120, 5, (255, 255, 255), 38)
+        return img
+
+    def analysis(self, frame):
+        catch_time = frame[CATCH_TIME]
+        if catch_time < self.start_cal_time:
+            return
+        img = frame[FRAME_DAT]
+        lm_list = frame[MN_RESULT]
+        self.detector.set_result(lm_list)
+
+        if len(lm_list) != 0:
+            eye_1_y = self.detector.findPosition(img, False)[LEFT_EYE]['key_points'][1]
+            eye_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            shoulder_1_x = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][0]
+            shoulder_2_x = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][0]
+            shoulder_1_y = self.detector.findPosition(img, False)[LEFT_SHOULDER]['key_points'][1]
+            shoulder_2_y = self.detector.findPosition(img, False)[RIGHT_SHOULDER]['key_points'][1]
+            elbow_1_x = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][0]
+            elbow_1_y = self.detector.findPosition(img, False)[LEFT_ELBOW]['key_points'][1]
+            elbow_2_x = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][0]
+            elbow_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            wrist_1_x = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][0]
+            wrist_2_x = self.detector.findPosition(img, False)[RIGHT_WRIST]['key_points'][0]
+            wrist_1_y = self.detector.findPosition(img, False)[LEFT_WRIST]['key_points'][1]
+            wrist_2_y = self.detector.findPosition(img, False)[RIGHT_ELBOW]['key_points'][1]
+            hip_1_x = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][0]
+            hip_2_x = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][0]
+            hip_1_y = self.detector.findPosition(img, False)[LEFT_HIP]['key_points'][1]
+            hip_2_y = self.detector.findPosition(img, False)[RIGHT_HIP]['key_points'][1]
+            knee_1_x = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][0]
+            knee_2_x = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][0]
+            knee_1_y = self.detector.findPosition(img, False)[LEFT_KNEE]['key_points'][1]
+            knee_2_y = self.detector.findPosition(img, False)[RIGHT_KNEE]['key_points'][1]
+            vis_hip_1 = self.detector.findPosition(img, False)[LEFT_KNEE]['confidence']
+            vis_hip_2 = self.detector.findPosition(img, False)[RIGHT_KNEE]['confidence']
+            ankle_1_x = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][0]
+            ankle_2_x = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][0]
+            ankle_1_y = self.detector.findPosition(img, False)[LEFT_ANKLE]['key_points'][1]
+            ankle_2_y = self.detector.findPosition(img, False)[RIGHT_ANKLE]['key_points'][1]
+
+            if self.pre_pos == 0:
+                self.pre_pos = 1
+                self.speak_driver.add_speak("请进入准备状态")
+
+            if self.form == 0:
+                angle_1 = self.detector.findIncludedAngle(hip_1_x, hip_1_y, ankle_1_x, ankle_1_y)
+                angle_2 = self.detector.findIncludedAngle(hip_2_x, hip_2_y, ankle_2_x, ankle_2_y)
+                if angle_1 < 40 and angle_2 < 40 and eye_1_y > knee_1_y and eye_2_y > knee_2_y:
+                    if self.pre_pos == 1:
+                        if vis_hip_1 > 0.8 and vis_hip_1 > vis_hip_2:
+                            self.time_1 += 1
+                            if self.time_1 > 3:
+                                self.dir = 1
+                                self.sign = 1
+                                self.time_1 = 0
+                                self.form = 1
+
+                        elif vis_hip_2 > 0.8 and vis_hip_1 < vis_hip_2:
+                            self.time_2 += 1
+                            if self.time_2 > 3:
+                                self.dir = 2
+                                self.sign = 1
+                                self.time_2 = 0
+                                self.form = 1
+                    if self.sign == 1:
+                        self.speak_driver.add_speak("准备开始考试")
+                        threading.Thread(target=self.retail_counting).start()
+
+            if self.dir == 1 and self.sign == 1 and self.countdown_flag.is_set():
+                shoulder_angle = self.detector.findIncludedAngle(hip_1_x, hip_1_y, shoulder_1_x, shoulder_1_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_1_x, ankle_1_y, hip_1_x, hip_1_y)
+                hand_range = self.detector.findRange(elbow_1_x, elbow_1_y, knee_1_x, knee_1_y)
+                range = self.detector.findRange(hip_1_x, hip_1_y, knee_1_x, knee_1_y) * 0.53
+
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 60 and hand_range < range and time.time() - self.last_time > self.interval:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))
+
+            elif self.dir == 2 and self.sign == 1 and self.countdown_flag.is_set():
+                # 计算各点与腰点角度
+                shoulder_angle = self.detector.findIncludedAngle(hip_2_x, hip_2_y, shoulder_2_x, shoulder_2_y)
+                ankle_angle = self.detector.findIncludedAngle(ankle_2_x, ankle_2_y, hip_2_x, hip_2_y)
+                hand_range = self.detector.findRange(elbow_2_x, elbow_2_y, knee_2_x, knee_2_y)
+                range = self.detector.findRange(hip_2_x, hip_2_y, knee_2_x, knee_2_y) * 0.53
+
+                # 展示进度栏
+                self.per = np.interp(shoulder_angle, (25, 65), (0, 100))
+                self.bar = np.interp(shoulder_angle, (25, 65), (62, 280))
+                if ankle_angle < 70:
+                    if self.count >= 1:
+                        if shoulder_angle <= 30:
+                            self.feedback = "上升"
+                            self.state = 0
+                            if self.direction == 0:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 1
+                                    self.time = 0
+                                    self.speak_state = 0
+                    else:
+                        self.feedback = "上升"
+                        self.state = 0
+                        if self.direction == 0:
+                            self.time += 1
+                            if self.time > 2:
+                                self.count += 0.5
+                                self.direction = 1
+                                self.time = 0
+                                self.speak_state = 0
+
+                    if shoulder_angle >= 60 and hand_range < range and time.time() - self.last_time > self.interval:
+                        self.feedback = "下落"
+                        if self.state == 0:
+                            if self.direction == 1:
+                                self.time += 1
+                                if self.time > 2:
+                                    self.count += 0.5
+                                    self.direction = 0
+                                    self.time = 0
+                                    self.last_time = time.time()
+                                    if self.count % 1 == 0:
+                                        engine = pyttsx3.init()
+                                        engine.setProperty('rate', 400)
+                                        self.speak_driver.add_speak("{}".format(int(self.count)))

LSZXBackend/base_driver.py

@@ -0,0 +1,307 @@
+import time
+import traceback
+
+import requests
+from flask import Response, jsonify, request
+
+import Backend.format_backend
+import UWB
+from Backend.consensus import *
+from DeviceDefine.consensus import UNKNOWN
+from LSZXBackend.camera_streaming import base_camera
+from LSZXBackend.general import *
+from LSZXBackend.tag_control import *
+from LSZXNetWork.lszx_network import Network
+# from LSZXNetWork.network import Network
+from MCamera.camera_test import camera_is_available
+from MCamera.mp_camera import Camera
+from Speaker import fake_speak_base
+from Speaker.speak_base import SpeakServer
+from Database.manager_database import ManagerDatabase
+import UWB.positioning_standalone
+import UWB.positioning_standalone_v2
+import UWB.positioning_standalone_pd
+import UWB.positioning_cluster
+from Database.database_mgr import *
+
+
+class BaseDriver(Backend.format_backend.Backend):
+
+    def __init__(
+            self, name, domain="0.0.0.0", port=0, master_mode=True,
+            positioning=True, camera=True, speaker=True, multi_positioning_mode=True, device_type=UNKNOWN,
+            pure_mode=False
+    ):
+        print("系统启动，自检中……")
+        self.speak_driver = fake_speak_base.SpeakServer()
+        if speaker:
+            self.speak_driver = SpeakServer()
+            self.speak_driver.volume_control(1)
+            self.speak_driver.speed_control(200)
+        super().__init__(name, domain, port, debug=False)
+        # 作训系统数据中心
+        print("正在启动作训数据中心服务(1/5)")
+        # self.manager = ManagerDatabase()
+        self.manager = Database()
+        print("作训数据中心启动成功！(1/5)")
+        print("正在启动网络服务(2/5)")
+        self.connection = Network(master_mode=master_mode, device_type=device_type)
+        print("网络服务启动成功！(2/5)")
+        print("正在启动定位服务(3/5)")
+        self.positioning = None
+        self.multi_positioning_mode = multi_positioning_mode
+        if positioning:
+            if not multi_positioning_mode:
+                if pure_mode:
+                    self.positioning = UWB.positioning_standalone_pd.Positioning()
+                else:
+                    self.positioning = UWB.positioning_standalone_v2.Positioning()
+            else:
+                self.positioning = UWB.positioning_cluster.Positioning()
+            self.positioning.start()
+            self.positioning.resume()
+        print("定位服务启动成功！(3/5)")
+        print("正在启动摄像头服务(4/5)")
+        self.camera = None
+        if camera:
+            time.sleep(5)
+            # 检查摄像头是否可用，不可用则等待
+            while not camera_is_available():
+                beep(freq=300, duration=500)
+                time.sleep(1)
+            self.default_source = 0
+            Camera.add_source(source=self.default_source)
+            self.camera = Camera()
+        else:
+            print("无摄像头设备！")
+        print('摄像头启动成功(4/5)')
+        print("正在启动作训终端后台(5/5)")
+        print("作训终端后台启动成功！(5/5)")
+        self.speak_driver.add_speak("系统启动成功！欢迎使用砺戍智能作训系统！")
+        print("系统初始化完成！")
+        # 原始摄像头接口
+        self.register(name="raw_camera", func=self.pure_camera, methods=[REQUEST_MODE_GET])
+        # 手环控制服务
+        self.register(name="tag_control_server", func=self.tag_control_server, methods=[REQUEST_MODE_POST])
+        self.register(name="wifi_status", func=self.wifi_status, methods=[REQUEST_MODE_GET])
+        self.register(name="wifi_list", func=self.wifi_list, methods=[REQUEST_MODE_GET])
+        self.register(name="wifi_disconnect", func=self.wifi_disconnect, methods=[REQUEST_MODE_GET])
+        self.register(name="wifi_connect", func=self.wifi_connect, methods=[REQUEST_MODE_POST])
+        self.register(name="close_all_band", func=self.close_all_band, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_all_band_alarm", func=self.stop_all_band_alarm, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_band_alarm", func=self.stop_band_alarm, methods=[REQUEST_MODE_POST])
+
+    def pure_camera(self):
+        return Response(
+            base_camera(self.camera, self.default_source),
+            mimetype='multipart/x-mixed-replace; boundary=frame'
+        )
+
+    def get_band_id(self):
+        try:
+            lives_bands_id = get_tag_func(
+                speak_driver=self.speak_driver,
+                positioning=self.positioning
+            )
+            return jsonify({"band_id": lives_bands_id})
+        except Exception as e:
+            error_msg = {
+                STATUS: STATUS_UNKNOWN_ERROR,
+                ERROR_MESSAGE: f"发生错误，错误来源：{traceback.format_exc()}",
+                MSG: str(e)
+            }
+            return jsonify(error_msg)
+
+    def tag_control_server(self):
+        try:
+            data = request.get_json()
+            detected_tag = None
+            # 获取当前手环服务
+            if data[CMD] == CMD_GET_BAND_ID:
+                detected_tag = get_tag_func(
+                    speak_driver=self.speak_driver,
+                    positioning=self.positioning
+                )
+            # 关闭所有手环服务
+            elif data[CMD] == CMD_CLOSE_BAND:
+                close_all_band(
+                    speak_driver=self.speak_driver,
+                    positioning=self.positioning
+                )
+            # 关闭所有手环的警报
+            elif data[CMD] == CMD_STOP_ALARM_ALL:
+                close_all_band_alarm(
+                    speak_driver=self.speak_driver,
+                    positioning=self.positioning
+                )
+            # 关闭指定手环的警报
+            elif data[CMD] == CMD_STOP_ALARM:
+                tag_id = data[TAG]
+                stop_assign_alarm(
+                    speak_driver=self.speak_driver,
+                    positioning=self.positioning,
+                    tag_id=tag_id
+                )
+            return jsonify({STATUS: STATUS_OK, DETECTED_TAG: detected_tag})
+        except Exception as e:
+            error_msg = {
+                STATUS: STATUS_UNKNOWN_ERROR,
+                ERROR_MESSAGE: f"后端系统错误{e.args}，错误来源：{traceback.format_exc()}"
+            }
+            return jsonify(error_msg)
+
+    # 获得当前检测的手环
+    def get_band_id_passive(self):
+        try:
+            if self.connection.get_connected_wifi_name():
+                master_ip = self.connection.get_master_ip()
+            else:
+                error_msg = {"status": CONNECTION_ERROR, "error_message": "网络未链接！"}
+                return jsonify(error_msg)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR, "error_message": f"网络未链接！{e.args}"}
+            return jsonify(error_msg)
+        try:
+            response = requests.post(
+                url=f"http://{master_ip}:{TERMINAL}/tag_control_server",
+                json={CMD: CMD_GET_BAND_ID}
+            )
+            detected_tag = response.json()[DETECTED_TAG]
+            return jsonify({"band_id": detected_tag})
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            print(traceback.format_exc())
+            return jsonify(error_msg)
+
+    # 关闭所有手环
+    def close_all_band(self):
+        try:
+            if self.connection.get_connected_wifi_name():
+                master_ip = self.connection.get_master_ip()
+            else:
+                error_msg = {"status": CONNECTION_ERROR, "error_message": "网络未链接！"}
+                return jsonify(error_msg)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR, "error_message": f"网络未链接！{e.args}"}
+            return jsonify(error_msg)
+        try:
+            requests.post(
+                url=f"http://{master_ip}:{TERMINAL}/tag_control_server",
+                json={CMD: CMD_CLOSE_BAND}
+            )
+            return jsonify({"status": STATUS_OK})
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            print(traceback.format_exc())
+            return jsonify(error_msg)
+
+    # 关闭所有手环警报
+    def stop_all_band_alarm(self):
+        try:
+            if self.connection.get_connected_wifi_name():
+                master_ip = self.connection.get_master_ip()
+            else:
+                error_msg = {"status": CONNECTION_ERROR, "error_message": "网络未链接！"}
+                return jsonify(error_msg)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR, "error_message": f"网络未链接！{e.args}"}
+            return jsonify(error_msg)
+        try:
+            requests.post(
+                url=f"http://{master_ip}:45678/tag_control_server",
+                json={CMD: CMD_STOP_ALARM_ALL}
+            )
+            return jsonify({"status": STATUS_OK})
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            print(traceback.format_exc())
+            return jsonify(error_msg)
+
+    # 关闭手环警报
+    def stop_band_alarm(self):
+        data = request.json
+        band_id = data.get(BAND_ID)
+        try:
+            if self.connection.get_connected_wifi_name():
+                master_ip = self.connection.get_master_ip()
+            else:
+                error_msg = {"status": CONNECTION_ERROR, "error_message": "网络未链接！"}
+                return jsonify(error_msg)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR, "error_message": f"网络未链接！{e.args}"}
+            return jsonify(error_msg)
+        try:
+            requests.post(
+                url=f"http://{master_ip}:45678/tag_control_server",
+                json={CMD: CMD_STOP_ALARM_ALL, TAG: band_id}
+            )
+            return jsonify({"status": STATUS_OK})
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            return jsonify(error_msg)
+
+    # 查看当前链接的WiFi
+    def wifi_status(self):
+        try:
+            response_data = self.connection.get_connected_wifi()
+            if response_data:
+                is_connected = True
+            else:
+                is_connected = False
+            wifi_mes = {
+                "is_connected": is_connected,
+                "wifi_name": response_data
+            }
+            return jsonify(wifi_mes)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            return jsonify(error_msg)
+
+    # 查看当前链接的WiFi
+    def wifi_list(self):
+        try:
+            response_data = self.connection.get_available_wifi()
+            return jsonify(response_data)
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            return jsonify(error_msg)
+
+    # 断开wifi链接
+    def wifi_disconnect(self):
+        try:
+            self.connection.disconnect()
+            self.speak_driver.add_speak("已成功断开WiFi链接！")
+            return jsonify({"status": STATUS_OK})
+        except Exception as e:
+            error_msg = {"status": STATUS_UNKNOWN_ERROR,
+                         "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)}
+            return jsonify(error_msg)
+
+    # 链接指定WiFi
+    def wifi_connect(self):
+        try:
+            data = request.json
+            wifi_name = data.get("name")
+            if wifi_name:
+                self.connection.disconnect()
+                if self.connection.connect2wifi(ssid=wifi_name):
+                    self.speak_driver.add_speak("WiFi链接成功！")
+                    return jsonify({"status": STATUS_OK})
+                else:
+                    self.speak_driver.add_speak("WiFi链接失败！")
+                    return jsonify({"status": ACTION_FAIL, "error_message": "WiFi链接失败"})
+            else:
+                self.speak_driver.add_speak("WiFi链接失败！WiFi名称为空")
+                return jsonify({"status": ACTION_FAIL, "error_message": "WiFi名称为空"})
+        except Exception as e:
+            self.speak_driver.add_speak("WiFi链接失败！")
+            error_msg = {
+                "status": STATUS_UNKNOWN_ERROR, "error_message": "出现错误，请联系后端开发人员！错误原因：{}".format(e)
+            }
+            return jsonify(error_msg)

LSZXBackend/camera_streaming.py

@@ -0,0 +1,26 @@
+from copy import deepcopy
+
+import cv2
+
+
+# 将图像转化为jpg
+def img_format_jpg(img):
+    try:
+        return cv2.imencode('.jpg', img)[1].tobytes()
+    except Exception as e:
+        print(e)
+
+
+def gen(camera):
+    """视频流生成"""
+    while True:
+        frame = camera.get_frame()
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + img_format_jpg(frame) + b'\r\n')
+
+
+# 基础Http视频流
+def base_camera(camera, video_source):
+    while True:
+        _img = deepcopy(camera.get_frame(video_source=video_source))
+        yield b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + img_format_jpg(_img) + b'\r\n'

LSZXBackend/eng_code.py

@@ -0,0 +1,91 @@
+import json
+import sys
+import threading
+import time
+
+from Speaker.speak_base import beep
+from UWB.consensus import *
+from UWB.positioning_standalone_v2 import Positioning
+
+FACTORY_MODE = threading.Event()
+
+# 长跑基站设定码
+SET_ANCHOR = "setanchor"
+PATH = sys.path[0]
+ANCHOR_RSSI_ADJUSTMENT_PATH = f"{PATH}/Exercise3/anchor_adjustment.json"
+
+
+# 设置方法
+def set_anchor(value: str, eb):
+    positioning = eb.positioning
+    positioning: Positioning
+    speak_driver = eb.speak_driver
+    speak_driver.add_speak(f"准备进行长跑基站校准！请将一个手环放置于屏幕前！")
+    speak_driver.wait_4_speak()
+    recognized_tag = positioning.get_detect_tag(3)
+    if not recognized_tag:
+        mes = "未识别到手环，请重新发送命令！"
+        speak_driver.add_speak(mes)
+        return mes
+    speak_driver.add_speak("识别手环成功")
+    print("识别到手环：", recognized_tag)
+    speak_driver.wait_4_speak()
+    anchor_list = list(positioning.multi_uwb.uwb_driver_table.keys())
+    speak_driver.add_speak(
+        f"共有{len(anchor_list)}个基站待校准，"
+        f"请在5秒内到达识别边界，"
+        f"滴声响后开始自动校准！"
+    )
+    speak_driver.wait_4_speak()
+    for i in range(5):
+        speak_driver.add_speak(f"{5 - i}")
+        time.sleep(1)
+    speak_driver.wait_4_speak()
+    beep(freq=5000, duration=1000)
+    speak_driver.add_speak(f"开始校准基站！")
+    start_time = time.time()
+    anchor_rssi_table = {}
+    adjustment_num = 100
+    finish_count = 0
+    beep_count_max = 20
+    beep_counter = 0
+    while FACTORY_MODE:
+        record = positioning.get_last_information()
+        if not record:
+            continue
+        record_time, data = record
+        if record_time < start_time:
+            continue
+        anchor = data[ANCHOR_ID]
+        tag = data[TAG]
+        rssi = data[RSSI]
+        if tag == recognized_tag:
+            anchor_rssi_table.setdefault(anchor, [])
+            anchor_rssi_table[anchor].append(rssi)
+            print(data)
+            beep_counter += 1
+            if beep_counter >= beep_count_max:
+                beep(freq=3000, duration=300)
+                beep_counter = 0
+            if not len(anchor_rssi_table[anchor]) >= adjustment_num:
+                continue
+            finish_count += 1
+            speak_driver.add_speak(f"{finish_count}个基站完成校准！")
+        if finish_count == len(anchor_list):
+            break
+    # 写入结果
+    anchor_rssi_adjustment = {
+        anchor: sum(anchor_rssi_table[anchor]) / len(anchor_rssi_table[anchor])
+        for anchor in anchor_list
+    }
+    with open(ANCHOR_RSSI_ADJUSTMENT_PATH, "w", encoding="utf-8_sig") as file:
+        json.dump(anchor_rssi_adjustment, file)
+    speak_driver.add_speak("已完成所有基站的校准！")
+    FACTORY_MODE.clear()
+    return "已完成所有基站的校准！"
+
+
+# 处理方法-代码对照表
+FUNC_TABLE = {
+    SET_ANCHOR: set_anchor
+}

LSZXBackend/general.py

@@ -0,0 +1,37 @@
+CMD = "cmd"
+CMD_GET_BAND_ID = "cmd_get_band_id"
+CMD_CLOSE_BAND = "cmd_close_band"
+CMD_STOP_ALARM_ALL = "cmd_stop_alarm_all"
+CMD_STOP_ALARM = "cmd_stop_alarm"
+STATUS = "status"
+DETECTED_TAG = "detected_tag"
+TAG = "tag"
+BAND_ID = "band_id"
+ID = "id"
+PUSHUP = "pushup"
+PULLUP = "pullup"
+SITUP = "situp"
+OVERHANG = "overhang"
+RUNAROUND = "runaround"
+RUNNING = "running"
+TASK_HAD_DONE = "task_had_done"
+TASK_NUMBER = "task_number"
+
+# ERROR
+ID_ERROR = 1
+ILLEGAL_CONFIG = 2
+ACTION_FAIL = 3
+CONNECTION_ERROR = 4
+
+ERROR_MESSAGE = "error_message"
+MSG = "msg"
+DATA = "data"
+
+TARGET = "target"
+
+# 各类服务地址
+TERMINAL = 45678
+MANAGER = 34567
+server_port = 57321
+server_file_port = 57322
+transit_server_port = 57923

LSZXBackend/identified_master.py

@@ -0,0 +1,60 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import MASTER
+
+
+class IdentifiedMaster(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(name, domain, port=45678, master_mode=True, multi_positioning_mode=False, device_type=MASTER)
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id, methods=[REQUEST_MODE_GET])
+        '''动作训练相关'''
+        self.register(name="get_band_mes", func=self.get_band_mes, methods=[REQUEST_MODE_POST])
+        self.register(name="active_overhang", func=self.active_overhang, methods=[REQUEST_MODE_POST])
+        self.register(name="active_push_up", func=self.active_push_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_pull_up", func=self.active_pull_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_sit_up", func=self.active_sit_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_run_around", func=self.active_run_around, methods=[REQUEST_MODE_POST])
+        self.register(name="start_exercise", func=self.start_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_exercise", func=self.stop_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="exercise_video", func=self.exercise_video, methods=[REQUEST_MODE_GET])
+        self.register(name="update_score", func=self.update_score, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register_websocket(name="get_score", func=self.get_score)
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        '''跑步相关'''
+        self.register(name="running_master", func=self.running_master_multi, methods=[REQUEST_MODE_GET])
+        self.register(name="set_running_config", func=self.set_running_config, methods=[REQUEST_MODE_POST])
+        self.register(name="running_reset", func=self.running_reset, methods=[REQUEST_MODE_GET])
+        self.register(name="running_add_band", func=self.running_add_band, methods=[REQUEST_MODE_POST])
+        self.register(name="running_del_band", func=self.running_del_band, methods=[REQUEST_MODE_POST])
+        self.register(name="get_round_time", func=self.get_round_time, methods=[REQUEST_MODE_POST])
+        self.register(name="get_running_all_score", func=self.get_running_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="fix_score", func=self.fix_score, methods=[REQUEST_MODE_POST])
+        self.register(name="fix_withdraw", func=self.fix_withdraw, methods=[REQUEST_MODE_POST])
+        self.register(name="running_list", func=self.running_list, methods=[REQUEST_MODE_GET])
+        self.register(name="start_running", func=self.start_running, methods=[REQUEST_MODE_GET])
+        self.register(name="voice_play", func=self.voice_play, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_running", func=self.stop_running, methods=[REQUEST_MODE_GET])
+        self.register_websocket(name="running_score", func=self.running_score)
+        self.register(name="update_running_score", func=self.update_running_score, methods=[REQUEST_MODE_GET])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''数据同步'''
+        self.register(name="broadcast", func=self.broadcast, methods=[REQUEST_MODE_POST])
+        self.register(name="synchronization_server", func=self.synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_data_synchronization", func=self.waiting_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_score_synchronization", func=self.send_score_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])
+        '''展示'''
+        self.register(name="video_directly", func=self.video_directly, methods=[REQUEST_MODE_GET])
+        '''工程模式'''
+        self.register(name="send_code", func=self.send_code, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_code", func=self.stop_code, methods=[REQUEST_MODE_GET])

LSZXBackend/identified_master_pure.py

@@ -0,0 +1,62 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import MASTER
+
+
+class IdentifiedMasterPD(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(
+            name, domain, port=45678, master_mode=True, multi_positioning_mode=False, device_type=MASTER, pure_mode=True
+        )
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id, methods=[REQUEST_MODE_GET])
+        '''动作训练相关'''
+        self.register(name="get_band_mes", func=self.get_band_mes, methods=[REQUEST_MODE_POST])
+        self.register(name="active_overhang", func=self.active_overhang, methods=[REQUEST_MODE_POST])
+        self.register(name="active_push_up", func=self.active_push_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_pull_up", func=self.active_pull_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_sit_up", func=self.active_sit_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_run_around", func=self.active_run_around, methods=[REQUEST_MODE_POST])
+        self.register(name="start_exercise", func=self.start_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_exercise", func=self.stop_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="exercise_video", func=self.exercise_video, methods=[REQUEST_MODE_GET])
+        self.register(name="update_score", func=self.update_score, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register_websocket(name="get_score", func=self.get_score)
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        '''跑步相关'''
+        self.register(name="running_master", func=self.running_master_pd_mode, methods=[REQUEST_MODE_GET])
+        self.register(name="set_running_config", func=self.set_running_config, methods=[REQUEST_MODE_POST])
+        self.register(name="running_reset", func=self.running_reset, methods=[REQUEST_MODE_GET])
+        self.register(name="running_add_band", func=self.running_add_band, methods=[REQUEST_MODE_POST])
+        self.register(name="running_del_band", func=self.running_del_band, methods=[REQUEST_MODE_POST])
+        self.register(name="get_round_time", func=self.get_round_time, methods=[REQUEST_MODE_POST])
+        self.register(name="get_running_all_score", func=self.get_running_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="fix_score", func=self.fix_score, methods=[REQUEST_MODE_POST])
+        self.register(name="fix_withdraw", func=self.fix_withdraw, methods=[REQUEST_MODE_POST])
+        self.register(name="running_list", func=self.running_list, methods=[REQUEST_MODE_GET])
+        self.register(name="start_running", func=self.start_running, methods=[REQUEST_MODE_GET])
+        self.register(name="voice_play", func=self.voice_play, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_running", func=self.stop_running, methods=[REQUEST_MODE_GET])
+        self.register_websocket(name="running_score", func=self.running_score)
+        self.register(name="update_running_score", func=self.update_running_score, methods=[REQUEST_MODE_GET])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''数据同步'''
+        self.register(name="broadcast", func=self.broadcast, methods=[REQUEST_MODE_POST])
+        self.register(name="synchronization_server", func=self.synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_data_synchronization", func=self.waiting_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_score_synchronization", func=self.send_score_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])
+        '''展示'''
+        self.register(name="video_directly", func=self.video_directly, methods=[REQUEST_MODE_GET])
+        '''工程模式'''
+        self.register(name="send_code", func=self.send_code, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_code", func=self.stop_code, methods=[REQUEST_MODE_GET])

LSZXBackend/identified_master_xiaofang.py

@@ -0,0 +1,57 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import MASTER
+
+
+class IdentifiedMasterXF(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(name, domain, port=45678, master_mode=True, multi_positioning_mode=False, device_type=MASTER)
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id, methods=[REQUEST_MODE_GET])
+        '''动作训练相关'''
+        self.register(name="get_band_mes", func=self.get_band_mes, methods=[REQUEST_MODE_POST])
+        self.register(name="active_overhang", func=self.active_overhang, methods=[REQUEST_MODE_POST])
+        self.register(name="active_push_up", func=self.active_push_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_pull_up", func=self.active_pull_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_sit_up", func=self.active_sit_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_run_around", func=self.active_run_around, methods=[REQUEST_MODE_POST])
+        self.register(name="start_exercise", func=self.start_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_exercise", func=self.stop_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="exercise_video", func=self.exercise_video, methods=[REQUEST_MODE_GET])
+        self.register(name="update_score", func=self.update_score, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register_websocket(name="get_score", func=self.get_score)
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        '''跑步相关'''
+        self.register(name="running_master", func=self.running_master_multi, methods=[REQUEST_MODE_GET])
+        self.register(name="set_running_config", func=self.set_running_config, methods=[REQUEST_MODE_POST])
+        self.register(name="running_reset", func=self.running_reset, methods=[REQUEST_MODE_GET])
+        self.register(name="running_add_band", func=self.running_add_band, methods=[REQUEST_MODE_POST])
+        self.register(name="running_del_band", func=self.running_del_band, methods=[REQUEST_MODE_POST])
+        self.register(name="get_round_time", func=self.get_round_time, methods=[REQUEST_MODE_POST])
+        self.register(name="get_running_all_score", func=self.get_running_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="fix_score", func=self.fix_score, methods=[REQUEST_MODE_POST])
+        self.register(name="fix_withdraw", func=self.fix_withdraw, methods=[REQUEST_MODE_POST])
+        self.register(name="running_list", func=self.running_list, methods=[REQUEST_MODE_GET])
+        self.register(name="start_running", func=self.start_running, methods=[REQUEST_MODE_GET])
+        self.register(name="voice_play", func=self.voice_play, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_running", func=self.stop_running_auto_clear, methods=[REQUEST_MODE_GET])
+        self.register_websocket(name="running_score", func=self.running_score)
+        self.register(name="update_running_score", func=self.update_running_score, methods=[REQUEST_MODE_GET])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''数据同步'''
+        self.register(name="broadcast", func=self.broadcast, methods=[REQUEST_MODE_POST])
+        self.register(name="synchronization_server", func=self.synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_data_synchronization", func=self.waiting_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_score_synchronization", func=self.send_score_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])
+        '''展示'''
+        self.register(name="video_directly", func=self.video_directly, methods=[REQUEST_MODE_GET])

LSZXBackend/manager.py

@@ -0,0 +1,85 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import MANAGER
+
+
+class Manager(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(
+            name, domain, port=34567, master_mode=False,
+            positioning=False, camera=False, speaker=True, device_type=MANAGER
+        )
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id_passive, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register(name="add_person", func=self.add_person, methods=[REQUEST_MODE_POST])
+        self.register(name="load_xlsx", func=self.load_xlsx, methods=[REQUEST_MODE_POST])
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="update_person", func=self.update_person, methods=[REQUEST_MODE_POST])
+        self.register(name="delete_person", func=self.delete_person, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="delete_all_person", func=self.delete_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="load_score_xlsx", func=self.load_score_xlsx, methods=[REQUEST_MODE_POST])
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_a_name_score", func=self.get_a_name_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_a_name_person", func=self.get_a_name_person, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="get_score_xlsx", func=self.get_score_xlsx, methods=[REQUEST_MODE_GET])
+        self.register(name="get_person_xlsx", func=self.get_person_xlsx, methods=[REQUEST_MODE_GET])
+        self.register(name="delete_all_score", func=self.delete_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        '''数据同步'''
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_data_synchronization", func=self.send_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="score_synchronization_server", func=self.score_synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="video_synchronization_server", func=self.video_synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_score_synchronization", func=self.waiting_score_synchronization, methods=[REQUEST_MODE_GET])
+        '''大屏展示'''
+        self.register(name="totals_synchronization_server", func=self.totals_synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="processing_sql", func=self.processing_sql, methods=[REQUEST_MODE_GET])
+        self.register(name="totals_sql_synchronization_server", func=self.totals_sql_synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register_websocket(name="statistics", func=self.statistics)
+        self.register(name="totals_HrBoInfo_server", func=self.totals_HrBoInfo_server, methods=[REQUEST_MODE_POST])
+        self.register_websocket(name="abnormal", func=self.abnormal)
+        self.register(name="receive", func=self.receive, methods=[REQUEST_MODE_POST])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''视频展示'''
+        self.register(name="video_list", func=self.video_list, methods=[REQUEST_MODE_POST])
+        self.register(name="video_server", func=self.video_server, methods=[REQUEST_MODE_POST])
+        self.register(name="display_video1", func=self.display_video1, methods=[REQUEST_MODE_POST])
+        self.register(name="display_video2", func=self.display_video2, methods=[REQUEST_MODE_POST])
+        self.register(name="display_video3", func=self.display_video3, methods=[REQUEST_MODE_POST])
+        self.register(name="display_video4", func=self.display_video4, methods=[REQUEST_MODE_POST])
+        '''汇总分析'''
+        self.register(name="get_batch", func=self.get_batch, methods=[REQUEST_MODE_GET])
+        self.register(name="set_batch", func=self.set_batch, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_projects", func=self.get_all_projects, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_batch", func=self.get_all_batch, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_people", func=self.get_all_people, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_classes", func=self.get_all_classes, methods=[REQUEST_MODE_GET])
+        self.register(name="get_projects_batch", func=self.get_projects_batch, methods=[REQUEST_MODE_GET])
+        self.register(name="set_projects_batch", func=self.set_projects_batch, methods=[REQUEST_MODE_POST])
+        self.register(name="circular_diagram", func=self.circular_diagram, methods=[REQUEST_MODE_POST])
+        self.register(name="detailed_grade_info_1", func=self.detailed_grade_info_1, methods=[REQUEST_MODE_POST])
+        self.register(name="get_class_projects_batch", func=self.get_class_projects_batch, methods=[REQUEST_MODE_GET])
+        self.register(name="set_class_projects_batch", func=self.set_class_projects_batch, methods=[REQUEST_MODE_POST])
+        self.register(name="class_bar_chart", func=self.class_bar_chart, methods=[REQUEST_MODE_POST])
+        self.register(name="detailed_grade_info_2", func=self.detailed_grade_info_2, methods=[REQUEST_MODE_POST])
+        self.register(name="get_group_projects", func=self.get_group_projects, methods=[REQUEST_MODE_GET])
+        self.register(name="set_group_projects", func=self.set_group_projects, methods=[REQUEST_MODE_POST])
+        self.register(name="batch_bar_chart", func=self.batch_bar_chart, methods=[REQUEST_MODE_POST])
+        self.register(name="detailed_grade_info_3", func=self.detailed_grade_info_3, methods=[REQUEST_MODE_POST])
+        self.register(name="get_team_projects_batch_class", func=self.get_team_projects_batch_class, methods=[REQUEST_MODE_GET])
+        self.register(name="set_team_projects_batch_class", func=self.set_team_projects_batch_class, methods=[REQUEST_MODE_POST])
+        self.register(name="scale_drawing", func=self.scale_drawing, methods=[REQUEST_MODE_POST])
+        self.register(name="get_personal_projects_batch_person", func=self.get_personal_projects_batch_person, methods=[REQUEST_MODE_GET])
+        self.register(name="set_personal_projects_batch_person", func=self.set_personal_projects_batch_person, methods=[REQUEST_MODE_POST])
+        self.register(name="radar_chart", func=self.radar_chart, methods=[REQUEST_MODE_POST])
+        self.register(name="line_chart", func=self.line_chart, methods=[REQUEST_MODE_POST])
+
+

LSZXBackend/master.py

@@ -0,0 +1,57 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import MASTER
+
+
+class Master(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(name, domain, port=45678, master_mode=True, device_type=MASTER)
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id, methods=[REQUEST_MODE_GET])
+        '''动作训练相关'''
+        self.register(name="get_band_mes", func=self.get_band_mes, methods=[REQUEST_MODE_POST])
+        self.register(name="active_overhang", func=self.active_overhang, methods=[REQUEST_MODE_POST])
+        self.register(name="active_push_up", func=self.active_push_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_pull_up", func=self.active_pull_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_sit_up", func=self.active_sit_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_run_around", func=self.active_run_around, methods=[REQUEST_MODE_POST])
+        self.register(name="start_exercise", func=self.start_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_exercise", func=self.stop_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="exercise_video", func=self.exercise_video, methods=[REQUEST_MODE_GET])
+        self.register(name="update_score", func=self.update_score, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register_websocket(name="get_score", func=self.get_score)
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        '''跑步相关'''
+        self.register(name="running_master", func=self.running_master, methods=[REQUEST_MODE_GET])
+        self.register(name="set_running_config", func=self.set_running_config, methods=[REQUEST_MODE_POST])
+        self.register(name="running_reset", func=self.running_reset, methods=[REQUEST_MODE_GET])
+        self.register(name="running_add_band", func=self.running_add_band, methods=[REQUEST_MODE_POST])
+        self.register(name="running_del_band", func=self.running_del_band, methods=[REQUEST_MODE_POST])
+        self.register(name="get_round_time", func=self.get_round_time, methods=[REQUEST_MODE_POST])
+        self.register(name="get_running_all_score", func=self.get_running_all_score, methods=[REQUEST_MODE_GET])
+        self.register(name="fix_score", func=self.fix_score, methods=[REQUEST_MODE_POST])
+        self.register(name="fix_withdraw", func=self.fix_withdraw, methods=[REQUEST_MODE_POST])
+        self.register(name="running_list", func=self.running_list, methods=[REQUEST_MODE_GET])
+        self.register(name="start_running", func=self.start_running, methods=[REQUEST_MODE_GET])
+        self.register(name="voice_play", func=self.voice_play, methods=[REQUEST_MODE_POST])
+        self.register(name="stop_running", func=self.stop_running, methods=[REQUEST_MODE_GET])
+        self.register_websocket(name="running_score", func=self.running_score)
+        self.register(name="update_running_score", func=self.update_running_score, methods=[REQUEST_MODE_GET])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''数据同步'''
+        self.register(name="broadcast", func=self.broadcast, methods=[REQUEST_MODE_POST])
+        self.register(name="synchronization_server", func=self.synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_data_synchronization", func=self.waiting_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_score_synchronization", func=self.send_score_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])
+
+

LSZXBackend/slaver.py

@@ -0,0 +1,42 @@
+import LSZXBackend.exercise_backend
+from Backend.consensus import *
+from DeviceDefine.consensus import SLAVER
+
+
+class Slaver(LSZXBackend.exercise_backend.ExerciseBackend):
+
+    def __init__(self, name, domain="0.0.0.0"):
+        super().__init__(name, domain, port=45678, master_mode=False, device_type=SLAVER)
+        # 获得当前设备附近的手环
+        self.register(name="get_band_id", func=self.get_band_id, methods=[REQUEST_MODE_GET])
+        '''动作训练相关'''
+        self.register(name="get_band_mes", func=self.get_band_mes, methods=[REQUEST_MODE_POST])
+        self.register(name="active_overhang", func=self.active_overhang, methods=[REQUEST_MODE_POST])
+        self.register(name="active_push_up", func=self.active_push_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_pull_up", func=self.active_pull_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_sit_up", func=self.active_sit_up, methods=[REQUEST_MODE_POST])
+        self.register(name="active_run_around", func=self.active_run_around, methods=[REQUEST_MODE_POST])
+        self.register(name="start_exercise", func=self.start_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_exercise", func=self.stop_exercise, methods=[REQUEST_MODE_GET])
+        self.register(name="exercise_video", func=self.exercise_video, methods=[REQUEST_MODE_GET])
+        self.register(name="update_score", func=self.update_score, methods=[REQUEST_MODE_GET])
+        '''信息查询'''
+        self.register_websocket(name="get_score", func=self.get_score)
+        self.register(name="get_class_data", func=self.get_class_data, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_class", func=self.get_all_class, methods=[REQUEST_MODE_GET])
+        self.register(name="get_all_person", func=self.get_all_person, methods=[REQUEST_MODE_GET])
+        self.register(name="get_a_class_score", func=self.get_a_class_score, methods=[REQUEST_MODE_POST])
+        self.register(name="get_all_score", func=self.get_all_score, methods=[REQUEST_MODE_GET])
+        '''跑步相关'''
+        self.register(name="running_slaver", func=self.running_slaver, methods=[REQUEST_MODE_GET])
+        self.register(name="start_running", func=self.start_running_slaver, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_running", func=self.stop_running_slaver, methods=[REQUEST_MODE_GET])
+        '''标准设定'''
+        self.register(name="set_train_info", func=self.set_train_info, methods=[REQUEST_MODE_POST])
+        self.register(name="view_train_info", func=self.view_train_info, methods=[REQUEST_MODE_GET])
+        '''数据同步'''
+        self.register(name="synchronization_server", func=self.synchronization_server, methods=[REQUEST_MODE_POST])
+        self.register(name="waiting_data_synchronization", func=self.waiting_data_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="send_score_synchronization", func=self.send_score_synchronization, methods=[REQUEST_MODE_GET])
+        self.register(name="get_synchronization_processing", func=self.get_synchronization_processing, methods=[REQUEST_MODE_GET])
+        self.register(name="stop_data_synchronization", func=self.stop_data_synchronization, methods=[REQUEST_MODE_GET])

LSZXBackend/tag_control.py

@@ -0,0 +1,66 @@
+# coding: gb2312
+
+# 获得手环标签的方法
+import time
+
+from Speaker.speak_base import beep
+from UWB.positioning_standalone_pd import Positioning
+
+
+def get_tag_func(speak_driver, positioning):
+    speak_driver.add_speak("请将手环放置于屏幕前！")
+    detected_tag = positioning.get_detect_tag(edge=100)
+    if detected_tag is None:
+        speak_driver.add_speak("识别失败！请重试或长按手环按键！")
+    else:
+        speak_driver.add_speak("识别成功！")
+    return detected_tag
+
+
+# 关闭所有手环的方法
+def close_all_band(speak_driver, positioning):
+    speak_driver.add_speak(f"正在关闭周边手环！")
+    speak_driver.add_speak(f"大约耗时1分钟,期间请晃动手环！")
+    positioning.close_all_tag()
+    start_time = time.time()
+    while (time.time() - start_time) < 60:
+        beep(duration=300, freq=2730)
+        time.sleep(3)
+    positioning.stop_close_all_tag()
+    speak_driver.add_speak(f"结束关闭周边手环！")
+
+    # speak_driver.add_speak(f"正在检测周边手环！")
+    # band_list = positioning.get_all_band()
+    # print(band_list)
+    # if band_list:
+    #     speak_driver.add_speak(f"共检测到{len(band_list)}个手环！")
+    #     count = 0
+    #     for band_id in band_list:
+    #         beep(duration=300, freq=2730)
+    #         count += 1
+    #         positioning.close_tag(band_id)
+    #     speak_driver.add_speak("已关闭周边所有手环！")
+    # else:
+    #     speak_driver.add_speak("没有检测到手环！")
+
+
+# 关闭所有手环警报的方法
+def close_all_band_alarm(speak_driver, positioning):
+    speak_driver.add_speak(f"正在检测周边手环！")
+    band_list = positioning.get_all_band()
+    if band_list:
+        speak_driver.add_speak(f"共检测到{len(band_list)}个手环！")
+        count = 0
+        for band_id in band_list:
+            beep(duration=300, freq=2730)
+            count += 1
+            positioning.set_tag(tag_id=band_id, alarm_status=False)
+        speak_driver.add_speak("已关闭周边所有手环的警报！")
+    else:
+        speak_driver.add_speak("没有检测到手环！")
+
+
+# 停止指定手环的警报
+def stop_assign_alarm(speak_driver, positioning, tag_id):
+    positioning.set_tag(tag_id=tag_id, alarm_status=False)
+    speak_driver.add_speak("停止警报命令发送成功！")

LSZXNetWork/NetworkDriverLinux/pattern_start_wifi_ap.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+# 配置参数
+WLAN_INTERFACE="<wlan>"
+LAN_INTERFACE="<lan>"
+SSID="<ssid>"
+PASSPHRASE="<passphrase>"
+
+# 配置hostapd
+cat <<EOF | sudo tee /etc/hostapd/hostapd.conf
+interface=$WLAN_INTERFACE
+driver=nl80211
+ssid=$SSID
+hw_mode=g
+channel=6
+wpa=2
+#ignore_broadcast_ssid=1
+wpa_passphrase=$PASSPHRASE
+wpa_key_mgmt=WPA-PSK
+# wpa_pairwise=TKIP
+rsn_pairwise=CCMP
+EOF
+
+# 确保hostapd配置文件路径正确
+sudo sed -i 's|#DAEMON_CONF=""|DAEMON_CONF="/etc/hostapd/hostapd.conf"|' /etc/default/hostapd
+
+# 配置udhcpd
+cat <<EOF | sudo tee /etc/udhcpd.conf
+start 192.168.137.2
+end 192.168.137.254
+interface $WLAN_INTERFACE
+opt router 192.168.137.1
+opt lease 864000
+EOF
+
+# 分配IP地址
+sudo ifconfig $WLAN_INTERFACE 192.168.137.1
+
+# 启用IP转发
+sudo sh -c "echo 1 > /proc/sys/net/ipv4/ip_forward"
+sudo sed -i 's|#net.ipv4.ip_forward=1|net.ipv4.ip_forward=1|' /etc/sysctl.conf
+
+# 配置iptables
+sudo iptables -t nat -A POSTROUTING -o $LAN_INTERFACE -j MASQUERADE
+sudo iptables -A FORWARD -i $LAN_INTERFACE -o $WLAN_INTERFACE -m state --state RELATED,ESTABLISHED -j ACCEPT
+sudo iptables -A FORWARD -i $WLAN_INTERFACE -o $LAN_INTERFACE -j ACCEPT
+
+# 创建用于保存iptables规则的目录
+sudo mkdir -p /etc/iptables
+
+# 保存iptables规则
+sudo sh -c "iptables-save > /etc/iptables/rules.v4"
+
+# 启动并启用服务
+sudo systemctl stop NetworkManager
+sudo systemctl restart hostapd
+sudo systemctl restart udhcpd
+
+# 禁用Wi-Fi连接
+sudo nmcli radio wifi off
+sudo rfkill unblock wlan
+
+# 检查服务状态
+sudo systemctl status hostapd
+sudo systemctl status udhcpd

LSZXNetWork/NetworkDriverLinux/pattern_stop_wifi_ap.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# 配置参数
+WLAN_INTERFACE="<wlan>"
+LAN_INTERFACE="<lan>"
+
+# 停止服务
+sudo systemctl stop hostapd
+sudo systemctl stop udhcpd
+
+# 删除iptables规则
+sudo iptables -t nat -D POSTROUTING -o $LAN_INTERFACE -j MASQUERADE
+sudo iptables -D FORWARD -i $LAN_INTERFACE -o $WLAN_INTERFACE -m state --state RELATED,ESTABLISHED -j ACCEPT
+sudo iptables -D FORWARD -i $WLAN_INTERFACE -o $LAN_INTERFACE -j ACCEPT
+
+# 恢复默认的IP配置
+sudo ifconfig $WLAN_INTERFACE 0.0.0.0
+
+# 禁用IP转发
+sudo sh -c "echo 0 > /proc/sys/net/ipv4/ip_forward"
+sudo sed -i 's|net.ipv4.ip_forward=1|#net.ipv4.ip_forward=1|' /etc/sysctl.conf
+
+# 删除保存的iptables规则
+sudo rm -f /etc/iptables/rules.v4
+
+# 启动NetworkManager服务
+sudo systemctl start NetworkManager
+
+# 启用Wi-Fi连接
+sudo nmcli radio wifi on
+
+# 检查NetworkManager状态
+sudo systemctl status NetworkManager

LSZXNetWork/NetworkDriverLinux/wifi.py

@@ -0,0 +1,99 @@
+import os
+import re
+import sys
+
+from LogRecord.log_recorder import GLOBAL_LOG
+
+os.popen("sudo systemctl start NetworkManager").read()
+
+def get_device_name():
+
+    while True:
+        GLOBAL_LOG.write("正在搜索无线网卡名称。。。")
+        echo = os.popen("nmcli -t -f DEVICE,TYPE,STATE dev | awk -F: '$2==\"wifi\"{print $1}'").read()
+        if echo:
+            return echo.strip()
+# 获得默认Wi-Fi网卡名称
+DEFAULT_DEVICE = get_device_name()
+
+# 获得有线网卡名称
+def get_eth_device_name():
+    while True:
+        GLOBAL_LOG.write("正在搜索有线网卡名称。。。")
+        echo = os.popen(
+            "nmcli -t -f DEVICE,TYPE,STATE dev | awk -F: '$2==\"ethernet\"{print $1}'"
+        ).read()
+        if echo:
+            return echo.strip()
+LAN_DEVICE = get_eth_device_name()
+
+if not DEFAULT_DEVICE or not LAN_DEVICE:
+    sys.exit()
+
+# 获得自身的ip地址
+def get_self_ip_address():
+    echo = os.popen(f"ip -4 addr show {DEFAULT_DEVICE}"
+                    +" | grep -oP '(?<=inet\s)\d+(\.\d+){3}'").read()
+    if echo:
+        return echo.strip()
+    else:
+        return "0.0.0.0"
+
+def get_wifi_name():
+    echo = os.popen(f"iwgetid {DEFAULT_DEVICE} -r").read()
+    if echo.strip():
+        return echo.strip()
+
+
+class WIFI:
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.wifi_device_initial()
+
+    @staticmethod
+    def wifi_device_initial():
+        os.popen("sudo systemctl stop hostapd").read()
+        os.popen("sudo systemctl stop udhcpd").read()
+        os.popen("sudo systemctl start NetworkManager").read()
+        os.popen("sudo nmcli dev").read()
+        os.popen("sudo nmcli r wifi on").read()
+        os.popen(f"sudo ifconfig {DEFAULT_DEVICE} up")
+
+    @staticmethod
+    def get_connected_wifi_name():
+        return get_wifi_name()
+
+    @staticmethod
+    def wifi_connect_status():
+        if get_wifi_name():
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def disconnect():
+        os.popen(f"sudo nmcli dev disconnect {DEFAULT_DEVICE}")
+
+    @staticmethod
+    def get_ip():
+        return get_self_ip_address()
+
+    @staticmethod
+    def scan_wifi():
+        os.popen("sudo systemctl stop hostapd")
+        os.popen("sudo systemctl stop udhcpd")
+        os.popen("sudo nmcli dev")
+        os.popen("sudo nmcli r wifi on")
+        os.popen(f"sudo ifconfig {DEFAULT_DEVICE} up")
+        echo = os.popen(f"sudo iwlist {DEFAULT_DEVICE} scan | grep ESSID").read()
+        wifi_name_re = re.findall(r"(?<=ESSID:\").*(?=\")", echo)
+        if wifi_name_re:
+            return wifi_name_re
+        else:
+            return []
+
+    @staticmethod
+    def connect_wifi(ssid, password):
+        os.popen(f"sudo nmcli dev wifi connect {ssid} password {password}")
+

LSZXNetWork/NetworkDriverLinux/wifi_ap.py

@@ -0,0 +1,99 @@
+import os
+import re
+
+from ping3 import ping
+
+from AcrossPlatform.get_platform import GLOBAL_DIR
+from LSZXNetWork.NetworkDriverLinux.wifi import DEFAULT_DEVICE, LAN_DEVICE
+from LogRecord.log_recorder import GLOBAL_LOG
+
+DEFAULT_IP_SEGMENT = r"192.168.[0-9]{1,3}.[0-9]{1,3}"
+AP_CONF_DIR = os.path.join(GLOBAL_DIR, "LSZXNetWork/NetworkDriverLinux/start_wifi_ap.sh")
+PATTERN_AP_CONF_DIR = os.path.join(GLOBAL_DIR, "LSZXNetWork/NetworkDriverLinux/pattern_start_wifi_ap.sh")
+STOP_AP_CONF_DIR = os.path.join(GLOBAL_DIR, "LSZXNetWork/NetworkDriverLinux/stop_wifi_ap.sh")
+PATTERN_STOP_AP_CONF_DIR = os.path.join(GLOBAL_DIR, "LSZXNetWork/NetworkDriverLinux/pattern_stop_wifi_ap.sh")
+MASTER_IP = "192.168.137.1"
+WLAN_DEVICE_TAG = "<wlan>"
+LAN_DEVICE_TAG = "<lan>"
+SSID_DEVICE_TAG = "<ssid>"
+PASS_DEVICE_TAG = "<passphrase>"
+
+
+# 获得同个网段下的设备
+def get_machine_ip_address():
+    echo = os.popen("arp -a | awk '{print $2}' | tr -d '()'").read()
+    ip_list = re.findall(DEFAULT_IP_SEGMENT, echo)
+    ip_list = list(filter(lambda x: not x.endswith("255") and not x.endswith("138.1"), ip_list))
+    return ip_list
+
+
+# 结束wifi
+def stop_wifi_ap():
+    with open(PATTERN_STOP_AP_CONF_DIR, "r") as file:
+        conf = file.read()
+    conf = conf.replace(WLAN_DEVICE_TAG, DEFAULT_DEVICE)
+    conf = conf.replace(LAN_DEVICE_TAG, LAN_DEVICE)
+    with open(STOP_AP_CONF_DIR, "w") as file:
+        file.write(conf)
+    os.popen(f"sudo bash {STOP_AP_CONF_DIR}").read()
+
+def kill_port(port):
+    os.popen(f"sudo fuser -k {port}/tcp").read()
+
+def get_wifi_ap_status():
+    try:
+        if isinstance(ping("192.168.137.1", timeout=500, unit="ms"), float):
+            return True
+        else:
+            return False
+    except Exception as e:
+        GLOBAL_LOG.write(f"AP状态获取出错，原因是：{e.args}。")
+        return False
+
+
+class WiFiAP:
+
+    def __init__(self):
+        stop_wifi_ap()
+        self.ssid = None
+        self.password = None
+
+    def reboot(self):
+        stop_wifi_ap()
+        if self.ssid:
+            self.set_ssid(ssid=self.ssid)
+            self.set_password(password=self.password)
+            self.start()
+
+    def set_ssid(self, ssid):
+        self.ssid = ssid
+
+    def set_password(self, password):
+        self.password = password
+
+    def edit_ap_conf(self):
+        with open(PATTERN_AP_CONF_DIR, "r") as file:
+            conf = file.read()
+        conf = conf.replace(WLAN_DEVICE_TAG, DEFAULT_DEVICE)
+        conf = conf.replace(LAN_DEVICE_TAG, LAN_DEVICE)
+        conf = conf.replace(SSID_DEVICE_TAG, self.ssid)
+        conf = conf.replace(PASS_DEVICE_TAG, self.password)
+        with open(AP_CONF_DIR, "w") as file:
+            file.write(conf)
+
+    @staticmethod
+    def start_cmd():
+        os.popen(f"sudo bash {AP_CONF_DIR}").read()
+
+    def start(self):
+        if self.ssid:
+            self.edit_ap_conf()
+            self.start_cmd()
+
+    @staticmethod
+    def stop():
+        stop_wifi_ap()
+
+    @staticmethod
+    def kill_wifi():
+        stop_wifi_ap()