core/app_controller.py - master - DimerTrue/ecg_gui

core/app_controller.py
137 строк5 KB
dimer
test build
29 июл 2026, 10:52
29 июл 2026, 10:52b04ab63
# app_controller.py
from core.app_logger import AppLogger

logger = AppLogger.get_logger(__name__)

import queue
import threading
from typing import List, Any
import serial
from dataclasses import dataclass

from modbus_device.device.manager import DeviceConfig
from core.modbus_worker import ModbusWorker
from core.data_logger import DataLogger


@dataclass
class ApplicationState:
    """Состояние приложения, доступное для GUI"""

    devices: List[DeviceConfig]
    ser: Any
    com_port: Any
    read_queues: List[queue.Queue]
    write_queues: List[queue.Queue]
    message_queues: List[queue.Queue]


class AppController:
    """Координатор приложения, управляет потоками и очередями"""

    def __init__(self, stop_event: threading.Event):
        self.stop_event = stop_event
        self._worker: ModbusWorker | None = None
        self._data_logger: DataLogger | None = None
        self._state: ApplicationState | None = None
        self.ser: serial.Serial | None = None

    def start_system(
        self,
        ser: Any,
        devices: List[DeviceConfig],
    ) -> ApplicationState:
        """Запускает систему и возвращает состояние для GUI"""
        logger.info("Запуск системы...")

        com_port = None

        if isinstance(ser, serial.Serial):
            logger.info(f"Инициализация порта: {ser.port}, скорость: {ser.baudrate}")
            com_port = ser.port
            self.ser = ser

        device_count = len(devices)
        logger.info(
            f"Конфигурация устройств: количество={device_count}, IDs={[d.id for d in devices]}"
        )

        # Создаем очереди
        # Очередь для отправки данных в GUI от ModbusWorker
        read_queues = [queue.Queue(maxsize=100) for _ in range(device_count)]

        # Очередь для отправки данных в ModbusWorker от GUI
        write_queues = [queue.Queue(maxsize=100) for _ in range(device_count)]

        # Очередь для обмена сообщениями между GUI и ModbusWorker
        message_queues = [queue.Queue(maxsize=100) for _ in range(device_count)]

        # Очередь для логгирования данных от ModbusWorker
        data_logger_queues = [queue.Queue(maxsize=100) for _ in range(device_count)]

        device_ids = [device.id for device in devices]
        devices_type = [device.simulator for device in devices]

        # Создаем логгер данных
        self._data_logger = DataLogger(
            device_ids=device_ids,
            devices_types=devices_type,
            data_queues=data_logger_queues,
            stop_event=self.stop_event,
        )
        self._data_logger.start()

        # Создаем и запускаем воркер
        logger.debug("Запуск потока ModbusWorker")

        self._worker = ModbusWorker(
            ser=ser,
            devices=devices,
            read_data_queues=read_queues,
            write_data_queues=write_queues,
            message_queues=message_queues,
            data_logger_queues=data_logger_queues,
            stop_event=self.stop_event,
            data_logger=self._data_logger,
        )
        self._worker.start()

        # Сохраняем состояние
        self._state = ApplicationState(
            devices=devices,
            ser=ser,
            com_port=com_port,
            read_queues=read_queues,
            write_queues=write_queues,
            message_queues=message_queues,
        )

        logger.info("Система успешно запущена")

        return self._state

    def shutdown(self):
        logger.info("Начало процедуры завершения работы...")

        if self._worker:
            logger.debug("Остановка ModbusWorker...")
            self.stop_event.set()  # Убедись, что сигнал остановки подается здесь или в main
            self._worker.join(timeout=2.0)
            if self._worker.is_alive():
                logger.warning("ModbusWorker не завершился вовремя!")

        if self.ser:
            try:
                logger.debug(f"Закрытие порта {self.ser.port}")
                self.ser.close()
            except Exception as e:
                logger.error(f"Ошибка при закрытии порта: {e}")

        if self._data_logger:
            logger.debug("Остановка DataLogger...")
            self._data_logger.stop()
            self._data_logger.join(timeout=2.0)
            if self._data_logger.is_alive():
                logger.warning("DataLogger не завершился вовремя!")

        logger.info("Приложение полностью остановлено")