feat:修正一些错误逻辑

config/app_config.json

@@ -8,7 +8,7 @@
             "enable_camera": false
         },
         "base_url": "http://localhost:8084",
-        "mode": "api"
+        "mode": "standalone"
     },
     "apis": {
         "get_tray_info": "/apjt/xcsc/tpda/getByTp_note/",
@@ -79,5 +79,8 @@
             "stop_bits": 1,
             "timeout": 1
         }
+    },
+    "electricity": {
+        "auto_start": true
     }
 }

dao/electricity_dao.py

@@ -0,0 +1,124 @@
+import logging
+from datetime import datetime
+from utils.sql_utils import SQLUtils
+
+class ElectricityDAO:
+    """电力消耗数据访问对象"""
+    
+    def __init__(self):
+        """初始化数据访问对象"""
+        self.db = SQLUtils('sqlite', database='db/jtDB.db')
+    
+    def __del__(self):
+        """析构函数，确保数据库连接关闭"""
+        if hasattr(self, 'db'):
+            self.db.close()
+    
+    def create_table_if_not_exists(self):
+        """创建电力消耗表（如果不存在）"""
+        try:
+            sql = """
+            CREATE TABLE IF NOT EXISTS wsbz_electricity_consumption (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                sync_time TIMESTAMP,
+                electricity_number REAL
+            )
+            """
+            self.db.execute_query(sql)
+            logging.info("电力消耗表检查/创建成功")
+            return True
+        except Exception as e:
+            logging.error(f"创建电力消耗表失败: {str(e)}")
+            return False
+    
+    def save_electricity_data(self, electricity_number):
+        """保存电力消耗数据
+        
+        Args:
+            electricity_number: 电力消耗数值
+            
+        Returns:
+            bool: 保存是否成功
+        """
+        try:
+            current_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            sql = """
+            INSERT INTO wsbz_electricity_consumption (
+                sync_time, electricity_number
+            ) VALUES (?, ?)
+            """
+            params = (current_time, electricity_number)
+            
+            self.db.execute_update(sql, params)
+            logging.info(f"保存电力消耗数据成功: {electricity_number}")
+            return True
+        except Exception as e:
+            logging.error(f"保存电力消耗数据失败: {str(e)}")
+            return False
+    
+    def get_latest_electricity_data(self):
+        """获取最新的电力消耗数据
+        
+        Returns:
+            dict: 最新的电力消耗数据，未找到则返回None
+        """
+        try:
+            sql = """
+            SELECT id, sync_time, electricity_number
+            FROM wsbz_electricity_consumption
+            ORDER BY id DESC
+            LIMIT 1
+            """
+            
+            self.db.cursor.execute(sql)
+            row = self.db.cursor.fetchone()
+            
+            if row:
+                data = {
+                    'id': row[0],
+                    'sync_time': row[1],
+                    'electricity_number': row[2]
+                }
+                return data
+            else:
+                return None
+        except Exception as e:
+            logging.error(f"获取最新电力消耗数据失败: {str(e)}")
+            return None
+    
+    def get_electricity_data_by_date_range(self, start_date, end_date):
+        """根据日期范围获取电力消耗数据
+        
+        Args:
+            start_date: 开始日期（YYYY-MM-DD格式）
+            end_date: 结束日期（YYYY-MM-DD格式）
+            
+        Returns:
+            list: 电力消耗数据列表
+        """
+        try:
+            sql = """
+            SELECT id, sync_time, electricity_number
+            FROM wsbz_electricity_consumption
+            WHERE sync_time BETWEEN ? AND ?
+            ORDER BY sync_time
+            """
+            params = (f"{start_date} 00:00:00", f"{end_date} 23:59:59")
+            
+            self.db.cursor.execute(sql, params)
+            results = self.db.cursor.fetchall()
+            
+            data_list = []
+            for row in results:
+                data = {
+                    'id': row[0],
+                    'sync_time': row[1],
+                    'electricity_number': row[2]
+                }
+                data_list.append(data)
+            
+            return data_list
+        except Exception as e:
+            logging.error(f"获取电力消耗数据失败: {str(e)}")
+            return [] 

db/schema.sql

@@ -55,25 +55,23 @@ SET enum_values = '["A区", "B区", "C区", "D区"]'
 WHERE name = 'fzd' AND is_deleted = FALSE;
 
 -- 包装记录表
-drop table if exists wsbz_inspection_pack_data;
+DROP TABLE IF EXISTS wsbz_inspection_pack_data;
-create table if not exists wsbz_inspection_pack_data
+CREATE TABLE IF NOT EXISTS wsbz_inspection_pack_data
 (
-    --订单号
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
-    order_id        VARCHAR(50),
+    order_id        VARCHAR(50) NOT NULL,
-    --材质
+    tray_id         VARCHAR(50) NOT NULL,
-    material        VARCHAR(50),
+    gc_note         VARCHAR(50),
-    --规格
-    spec            VARCHAR(50),
-    --包装号
-    tray_id         VARCHAR(50),
-    --轴包装号
     axis_package_id VARCHAR(50),
+    weight          REAL,
+    net_weight      REAL,
+    pack_time       TIMESTAMP,
     create_time     TIMESTAMP   NOT NULL,
     create_by       VARCHAR(50) NOT NULL,
     update_time     TIMESTAMP,
     update_by       VARCHAR(50),
-    is_deleted      BOOLEAN
+    is_deleted      BOOLEAN DEFAULT FALSE
-);
+)
 
 -- 创建托盘类型配置表
 CREATE TABLE IF NOT EXISTS pallet_types (

from pymodbus.py

@@ -2,14 +2,14 @@ from pymodbus.client import ModbusTcpClient
 import time
 client = ModbusTcpClient('localhost', port=5020)
 client.connect()
-client.write_registers(address=11, values=[2242])
+client.write_registers(address=11, values=[2248])
 client.write_registers(address=13, values=[0])
 
 client.write_registers(address=21, values=[0])
 time.sleep(2)
 # client.write_registers(address=21, values=[1])
 
-client.write_registers(address=20, values=[0])
+# client.write_registers(address=30, values=[25])
 # client.write_registers(address=5, values=[16])
 # 贴标完成
 # client.write_registers(address=24, values=[1])s

main.py

@@ -134,6 +134,12 @@ def main():
         # 键盘监听器配置信息
         enable_keyboard_listener = config.get_value('serial.keyboard.enabled', False)
         logging.info(f"配置信息 - 启用串口: {enable_serial_ports}, 启用键盘监听: {enable_keyboard_listener}")
+        
+        # 初始化电力监控器
+        from utils.electricity_monitor import ElectricityMonitor
+        electricity_monitor = ElectricityMonitor.get_instance()
+        electricity_monitor.start()
+        logging.info("电力监控器已启动")
 
         # 设置中文翻译器
         translator = QTranslator(app)
@@ -200,6 +206,15 @@ def main():
         from utils.sql_utils import SQLUtils
         SQLUtils.close_all_connections()
         
+        # 停止电力监控器
+        try:
+            from utils.electricity_monitor import ElectricityMonitor
+            electricity_monitor = ElectricityMonitor.get_instance()
+            electricity_monitor.stop()
+            logging.info("电力监控器已停止")
+        except Exception as e:
+            logging.error(f"停止电力监控器时发生错误: {e}")
+        
         sys.exit(exit_code)
         
     except Exception as e:

ui/electricity_settings_ui.py

@@ -0,0 +1,231 @@
+from PySide6.QtWidgets import (
+    QWidget, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, 
+    QFormLayout, QSpinBox, QGroupBox, QFrame
+)
+from PySide6.QtCore import Qt, Signal, QTimer
+from PySide6.QtGui import QFont
+from datetime import datetime, timedelta
+from utils.electricity_monitor import ElectricityMonitor
+from dao.electricity_dao import ElectricityDAO
+import logging
+
+class ElectricitySettingsUI(QWidget):
+    """电力监控设置UI组件"""
+    
+    # 定义信号
+    settings_changed = Signal()
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.parent = parent
+        self.electricity_monitor = ElectricityMonitor.get_instance()
+        self.electricity_dao = ElectricityDAO()
+        
+        # 确保电力消耗表已创建
+        self.electricity_dao.create_table_if_not_exists()
+        
+        self.init_ui()
+        
+        # 创建定时器，用于更新UI
+        self.update_timer = QTimer(self)
+        self.update_timer.timeout.connect(self.update_status)
+        self.update_timer.start(1000)  # 每秒更新一次
+        
+        # 初始更新状态
+        self.update_status()
+    
+    def init_ui(self):
+        """初始化UI"""
+        # 设置字体
+        self.title_font = QFont("微软雅黑", 14, QFont.Bold)
+        self.normal_font = QFont("微软雅黑", 10)
+        self.small_font = QFont("微软雅黑", 9)
+        
+        # 创建主布局
+        main_layout = QVBoxLayout(self)
+        main_layout.setContentsMargins(20, 20, 20, 20)
+        main_layout.setSpacing(15)
+        
+        # 创建标题
+        title_label = QLabel("电力监控设置")
+        title_label.setFont(self.title_font)
+        title_label.setAlignment(Qt.AlignCenter)
+        title_label.setStyleSheet("color: #1a237e; margin-bottom: 10px;")
+        main_layout.addWidget(title_label)
+        
+        # 创建状态组
+        status_group = QGroupBox("监控状态")
+        status_group.setFont(self.normal_font)
+        status_layout = QFormLayout()
+        
+        # 监控状态
+        self.status_label = QLabel("未知")
+        self.status_label.setFont(self.normal_font)
+        status_layout.addRow("监控状态:", self.status_label)
+        
+        # 当前电量
+        self.electricity_label = QLabel("--")
+        self.electricity_label.setFont(self.normal_font)
+        status_layout.addRow("当前电量:", self.electricity_label)
+        
+        # 上次监听时间
+        self.last_time_label = QLabel("--")
+        self.last_time_label.setFont(self.normal_font)
+        status_layout.addRow("上次监听时间:", self.last_time_label)
+        
+        # 下次监听时间
+        self.next_time_label = QLabel("--")
+        self.next_time_label.setFont(self.normal_font)
+        status_layout.addRow("下次监听时间:", self.next_time_label)
+        
+        status_group.setLayout(status_layout)
+        main_layout.addWidget(status_group)
+        
+        # 创建设置组
+        settings_group = QGroupBox("监控设置")
+        settings_group.setFont(self.normal_font)
+        settings_layout = QFormLayout()
+        
+        # 监听间隔
+        self.interval_spinbox = QSpinBox()
+        self.interval_spinbox.setFont(self.normal_font)
+        self.interval_spinbox.setRange(1, 60)  # 1-60分钟
+        self.interval_spinbox.setValue(self.electricity_monitor.interval_minutes)  # 使用当前设置的值
+        self.interval_spinbox.setSuffix(" 分钟")
+        self.interval_spinbox.valueChanged.connect(self.on_interval_changed)
+        settings_layout.addRow("监听间隔:", self.interval_spinbox)
+        
+        settings_group.setLayout(settings_layout)
+        main_layout.addWidget(settings_group)
+        
+        # 创建按钮组
+        button_layout = QHBoxLayout()
+        button_layout.setSpacing(20)
+        
+        # 开始监听按钮
+        self.start_button = QPushButton("开始监听")
+        self.start_button.setFont(self.normal_font)
+        self.start_button.setMinimumHeight(40)
+        self.start_button.setStyleSheet("background-color: #4CAF50; color: white;")
+        self.start_button.clicked.connect(self.start_monitoring)
+        button_layout.addWidget(self.start_button)
+        
+        # 暂停监听按钮
+        self.stop_button = QPushButton("暂停监听")
+        self.stop_button.setFont(self.normal_font)
+        self.stop_button.setMinimumHeight(40)
+        self.stop_button.setStyleSheet("background-color: #F44336; color: white;")
+        self.stop_button.clicked.connect(self.stop_monitoring)
+        button_layout.addWidget(self.stop_button)
+        
+        main_layout.addLayout(button_layout)
+        
+        # 添加分隔线
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setFrameShadow(QFrame.Sunken)
+        main_layout.addWidget(separator)
+        
+        # 添加历史数据标签
+        history_label = QLabel("历史数据")
+        history_label.setFont(self.title_font)
+        history_label.setAlignment(Qt.AlignCenter)
+        history_label.setStyleSheet("color: #1a237e; margin: 10px 0;")
+        main_layout.addWidget(history_label)
+        
+        # 占位符，用于未来扩展
+        placeholder = QLabel("历史数据功能将在未来版本中提供")
+        placeholder.setFont(self.normal_font)
+        placeholder.setAlignment(Qt.AlignCenter)
+        placeholder.setStyleSheet("color: #888888; padding: 20px;")
+        main_layout.addWidget(placeholder)
+        
+        # 添加弹性空间
+        main_layout.addStretch(1)
+    
+    def update_status(self):
+        """更新状态显示"""
+        try:
+            # 检查监控器状态
+            is_monitoring = self.electricity_monitor.is_monitoring()
+            
+            # 更新状态标签
+            if is_monitoring:
+                self.status_label.setText("正在监听")
+                self.status_label.setStyleSheet("color: green; font-weight: bold;")
+                self.start_button.setEnabled(False)
+                self.stop_button.setEnabled(True)
+            else:
+                self.status_label.setText("已暂停")
+                self.status_label.setStyleSheet("color: red; font-weight: bold;")
+                self.start_button.setEnabled(True)
+                self.stop_button.setEnabled(False)
+            
+            # 获取最新电力数据
+            latest_data = self.electricity_dao.get_latest_electricity_data()
+            if latest_data:
+                self.electricity_label.setText(str(latest_data['electricity_number']))
+                self.last_time_label.setText(latest_data['sync_time'])
+                
+                # 计算下次监听时间
+                if is_monitoring:
+                    next_time = self.electricity_monitor.get_next_read_time()
+                    if next_time:
+                        self.next_time_label.setText(next_time.strftime('%Y-%m-%d %H:%M:%S'))
+                    else:
+                        self.next_time_label.setText("计算中...")
+                else:
+                    self.next_time_label.setText("监听已暂停")
+            else:
+                self.electricity_label.setText("--")
+                self.last_time_label.setText("--")
+                if is_monitoring:
+                    self.next_time_label.setText("等待首次读取...")
+                else:
+                    self.next_time_label.setText("监听已暂停")
+            
+        except Exception as e:
+            logging.error(f"更新电力监控状态时发生错误: {str(e)}")
+    
+    def on_interval_changed(self, value):
+        """监听间隔变更处理
+        
+        Args:
+            value: 新的间隔值（分钟）
+        """
+        try:
+            # 更新监控器间隔
+            self.electricity_monitor.set_interval(value)
+            
+            # 发出设置变更信号
+            self.settings_changed.emit()
+        except Exception as e:
+            logging.error(f"设置电力监控间隔时发生错误: {str(e)}")
+    
+    def start_monitoring(self):
+        """开始监听"""
+        try:
+            # 启动电力监控器
+            self.electricity_monitor.start()
+            
+            # 更新UI
+            self.update_status()
+            
+            # 发出设置变更信号
+            self.settings_changed.emit()
+        except Exception as e:
+            logging.error(f"启动电力监控时发生错误: {str(e)}")
+    
+    def stop_monitoring(self):
+        """暂停监听"""
+        try:
+            # 停止电力监控器
+            self.electricity_monitor.stop()
+            
+            # 更新UI
+            self.update_status()
+            
+            # 发出设置变更信号
+            self.settings_changed.emit()
+        except Exception as e:
+            logging.error(f"停止电力监控时发生错误: {str(e)}") 

utils/electricity_monitor.py

@@ -0,0 +1,193 @@
+import logging
+import time
+from threading import Thread, Event
+from PySide6.QtCore import QTimer
+from utils.modbus_utils import ModbusUtils
+from utils.modbus_monitor import RegisterHandler
+from dao.electricity_dao import ElectricityDAO
+from utils.config_loader import ConfigLoader
+
+class ElectricityHandler(RegisterHandler):
+    """电力消耗寄存器处理器"""
+    
+    def __init__(self):
+        """初始化处理器"""
+        self.dao = ElectricityDAO()
+        # 确保表已创建
+        self.dao.create_table_if_not_exists()
+    
+    def handle_change(self, value):
+        """处理寄存器值变化
+        
+        Args:
+            value: 寄存器值
+        """
+        try:
+            # 保存电力消耗数据
+            self.dao.save_electricity_data(value)
+            logging.info(f"已记录电力消耗数据: {value}")
+        except Exception as e:
+            logging.error(f"处理电力消耗数据时发生错误: {str(e)}")
+
+
+class ElectricityMonitor:
+    """电力消耗监控器"""
+    
+    _instance = None
+    
+    @classmethod
+    def get_instance(cls):
+        """获取单例实例"""
+        if cls._instance is None:
+            cls._instance = ElectricityMonitor()
+        return cls._instance
+    
+    def __init__(self):
+        """初始化电力监控器"""
+        if ElectricityMonitor._instance:
+            raise Exception("ElectricityMonitor is a singleton class.")
+        
+        self.modbus = ModbusUtils()
+        self.dao = ElectricityDAO()
+        self.config = ConfigLoader.get_instance()
+        
+        # 确保表已创建
+        self.dao.create_table_if_not_exists()
+        
+        # 创建定时器
+        self.timer = None
+        self.client = None
+        self.stop_event = Event()
+        self.monitor_thread = None
+        
+        # 电力寄存器地址
+        self.electricity_register = 30
+        
+        # 从配置中读取监听间隔（分钟）
+        self.interval_minutes = self.config.get_value('electricity.interval_minutes', 1)
+        
+        # 从配置中读取是否自动启动
+        self.auto_start = self.config.get_value('electricity.auto_start', True)
+        
+        # 上次读取时间
+        self.last_read_time = None
+        
+        # 如果配置为自动启动，则启动监控
+        if self.auto_start:
+            self.start()
+    
+    def start(self):
+        """启动监控"""
+        if self.timer and self.timer.isActive():
+            logging.warning("电力监控器已经在运行中")
+            return
+        
+        # 创建并启动定时器，每分钟读取一次
+        self.timer = QTimer()
+        self.timer.timeout.connect(self._read_electricity_data)
+        self.timer.start(self.interval_minutes * 60000)  # 转换为毫秒
+        
+        # 立即执行一次读取
+        self._read_electricity_data()
+        
+        # 更新配置
+        self.config.set_value('electricity.auto_start', True)
+        
+        logging.info(f"电力监控器已启动，每{self.interval_minutes}分钟读取一次寄存器30的数据")
+    
+    def stop(self):
+        """停止监控"""
+        if self.timer:
+            self.timer.stop()
+        
+        if self.client:
+            self.modbus.close_client(self.client)
+            self.client = None
+        
+        # 更新配置
+        self.config.set_value('electricity.auto_start', False)
+        
+        logging.info("电力监控器已停止")
+    
+    def set_interval(self, minutes):
+        """设置监听间隔
+        
+        Args:
+            minutes: 间隔分钟数
+        """
+        if minutes < 1:
+            minutes = 1
+        
+        self.interval_minutes = minutes
+        
+        # 更新配置
+        self.config.set_value('electricity.interval_minutes', minutes)
+        
+        # 如果定时器正在运行，则更新间隔
+        if self.timer and self.timer.isActive():
+            self.timer.setInterval(minutes * 60000)  # 转换为毫秒
+            logging.info(f"电力监控间隔已更新为{minutes}分钟")
+    
+    def is_monitoring(self):
+        """检查是否正在监控
+        
+        Returns:
+            bool: 是否正在监控
+        """
+        return self.timer is not None and self.timer.isActive()
+    
+    def get_last_read_time(self):
+        """获取上次读取时间
+        
+        Returns:
+            datetime: 上次读取时间，如果未读取过则返回None
+        """
+        return self.last_read_time
+    
+    def get_next_read_time(self):
+        """获取下次读取时间
+        
+        Returns:
+            datetime: 下次读取时间，如果未在监控则返回None
+        """
+        if not self.is_monitoring() or not self.last_read_time:
+            return None
+        
+        from datetime import datetime, timedelta
+        return self.last_read_time + timedelta(minutes=self.interval_minutes)
+    
+    def _read_electricity_data(self):
+        """读取电力消耗数据"""
+        try:
+            # 如果客户端未连接，则创建连接
+            if not self.client:
+                self.client = self.modbus.get_client()
+                if not self.client:
+                    logging.error("无法连接到Modbus服务器，电力数据读取失败")
+                    return
+            
+            # 读取寄存器30的值
+            result = self.modbus.read_holding_register(self.client, self.electricity_register)
+            if result is None or len(result) == 0:
+                logging.warning(f"读取寄存器D{self.electricity_register}失败")
+                return
+            
+            # 获取电力消耗值
+            electricity_value = result[0]
+            
+            # 保存到数据库
+            success = self.dao.save_electricity_data(electricity_value)
+            if success:
+                logging.info(f"已记录电力消耗数据: {electricity_value}")
+                # 更新上次读取时间
+                from datetime import datetime
+                self.last_read_time = datetime.now()
+            else:
+                logging.error("保存电力消耗数据失败")
+                
+        except Exception as e:
+            logging.error(f"读取或保存电力消耗数据时发生错误: {str(e)}")
+            # 关闭连接，下次重新尝试
+            if self.client:
+                self.modbus.close_client(self.client)
+                self.client = None 

utils/init_db.py

@@ -35,6 +35,17 @@ def init_database():
         """
         db.execute_query(create_user_table_sql)
         
+        # 创建电力消耗表
+        create_electricity_table_sql = """
+        CREATE TABLE IF NOT EXISTS wsbz_electricity_consumption (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            sync_time TIMESTAMP,
+            electricity_number REAL
+        );
+        """
+        db.execute_query(create_electricity_table_sql)
+        logging.info("已创建电力消耗表")
+        
         # 获取当前时间
         current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
         

utils/modbus_monitor.py

@@ -77,7 +77,7 @@ class ModbusMonitor(QObject):
     def _initialize_registers(self):
         """初始化要监控的寄存器列表"""
         # 默认监控的寄存器地址
-        register_addresses = [5, 6, 11, 13, 20, 21, 22, 23, 24]
+        register_addresses = [5, 6, 11, 13, 20, 21, 22, 23, 24, 30]  # 添加寄存器30用于电力监控
         for address in register_addresses:
             self.registers[address] = RegisterValue(address)
     

widgets/login_widget.py

@@ -38,7 +38,7 @@ def get_user_info(user_id):
             return result
         # 始终使用SQLite数据源获取用户信息
         db = SQLUtils(source_name='sqlite')
-        db.execute_query("SELECT username,  corp_id as corp_name, corp_id FROM wsbz_user WHERE username = ?", (user_id,))
+        db.execute_query("SELECT userid, username,  corp_id as corp_name, corp_id FROM wsbz_user WHERE username = ?", (user_id,))
         result = db.fetchone()
         db.close()
         if result:

widgets/main_window.py

@@ -21,6 +21,7 @@ from utils.register_handlers import (
     UnloadingLevelHandler,
     UnloadingPositionHandler
 )
+from utils.electricity_monitor import ElectricityHandler
 # 导入PySide6
 from PySide6.QtWidgets import (
     QWidget, QMessageBox, QTableWidgetItem, QStackedWidget, QLabel, QMainWindow,
@@ -1562,26 +1563,33 @@ class MainWindow(MainWindowUI):
         
     def _register_modbus_handlers(self):
         """注册寄存器处理器"""
-
+        # 获取Modbus监控器实例
+        monitor = get_modbus_monitor()
+        
         # 注册D6处理器，处理NG信号
-        self.modbus_monitor.register_handler(6, NGHandler(self.machine_handlers.handle_ng))
+        monitor.register_handler(6, NGHandler(self.machine_handlers.handle_ng))
 
         # 注册D11处理器，处理称重数据
-        self.modbus_monitor.register_handler(11, WeightDataHandler(self.machine_handlers.handle_weight_data))
+        monitor.register_handler(11, WeightDataHandler(self.machine_handlers.handle_weight_data))
         
         # 注册D13处理器，处理贴标信号
-        self.modbus_monitor.register_handler(13, LabelSignalHandler(self.machine_handlers.handle_label_signal))
+        monitor.register_handler(13, LabelSignalHandler(self.machine_handlers.handle_label_signal))
         
         # 注册D20-D24处理器，处理各种状态信息
-        self.modbus_monitor.register_handler(20, LoadingFeedbackHandler(self.handle_loading_feedback))
+        monitor.register_handler(20, LoadingFeedbackHandler(self.handle_loading_feedback))
-        self.modbus_monitor.register_handler(21, UnloadingFeedbackHandler(self.handle_unloading_feedback))
+        monitor.register_handler(21, UnloadingFeedbackHandler(self.handle_unloading_feedback))
-        self.modbus_monitor.register_handler(22, Error1Handler(self.machine_handlers.handle_error_1))
+        monitor.register_handler(22, Error1Handler(self.machine_handlers.handle_error_1))
-        self.modbus_monitor.register_handler(23, Error2Handler(self.machine_handlers.handle_error_2))
+        monitor.register_handler(23, Error2Handler(self.machine_handlers.handle_error_2))
-        self.modbus_monitor.register_handler(24, Error3Handler(self.machine_handlers.handle_error_3))
+        monitor.register_handler(24, Error3Handler(self.machine_handlers.handle_error_3))
         
         # 注册下料层数和位置处理器
-        self.modbus_monitor.register_handler(4, UnloadingLevelHandler(self.handle_unloading_level))
+        monitor.register_handler(4, UnloadingLevelHandler(self.handle_unloading_level))
-        self.modbus_monitor.register_handler(5, UnloadingPositionHandler(self.handle_unloading_position))
+        monitor.register_handler(5, UnloadingPositionHandler(self.handle_unloading_position))
+        
+        # 注册电力消耗处理器
+        monitor.register_handler(30, ElectricityHandler())
+        
+        logging.info("已注册所有Modbus寄存器处理器")
         
     def _connect_modbus_signals(self):
         """连接Modbus信号槽"""
@@ -1804,7 +1812,7 @@ class MainWindow(MainWindowUI):
                     QMessageBox.warning(self, f"提示", response.get("message",{}))
                 
                 # 保存贴标数据到数据库
-                self.save_inspection_data(self._current_order_code, gc_note, tray_id, 11, 11, str(axios_num), "pass")
+            self.save_inspection_data(self._current_order_code, gc_note, tray_id, 11, 11, str(axios_num), "pass")
 
             # 重新连接信号
             self.process_table.cellChanged.connect(self.handle_inspection_cell_changed)

widgets/settings_window.py

@@ -3,6 +3,7 @@ from PySide6.QtCore import Signal
 from PySide6.QtWidgets import QDialog, QVBoxLayout, QDialogButtonBox
 from widgets.serial_settings_widget import SerialSettingsWidget
 from widgets.settings_widget import SettingsWidget
+from ui.electricity_settings_ui import ElectricitySettingsUI
 
 class SettingsWindow(QDialog):
     """设置窗口，直接使用SettingsWidget中的标签页"""
@@ -31,6 +32,10 @@ class SettingsWindow(QDialog):
         self.serial_settings = SerialSettingsWidget(self)
         self.settings_widget.tab_widget.addTab(self.serial_settings, "串口设置")
         
+        # 添加电力监控设置到标签页
+        self.electricity_settings = ElectricitySettingsUI(self)
+        self.settings_widget.tab_widget.addTab(self.electricity_settings, "电力监控")
+        
         # 添加按钮
         self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
         self.button_box.accepted.connect(self.accept)
@@ -39,6 +44,7 @@ class SettingsWindow(QDialog):
         
         # 连接信号
         self.serial_settings.settings_changed.connect(self.settings_changed.emit)
+        self.electricity_settings.settings_changed.connect(self.settings_changed.emit)
         
         logging.info("SettingsWindow初始化完成")