Feeding_control_system/core/system.py

# core/system.py
import threading
import time
import cv2
from config.settings import Settings
from core.state import SystemState
from hardware.relay import RelayController
from hardware.inverter import InverterController
from hardware.transmitter import TransmitterController
from vision.camera import CameraController
from vision.detector import VisionDetector
from feeding.controller import FeedingController


class FeedingControlSystem:
    def __init__(self, settings: Settings):
        self.settings = settings
        self.state = SystemState()

        # 初始化硬件控制器
        self.relay_controller = RelayController(
            host=settings.relay_host,
            port=settings.relay_port
        )

        self.inverter_controller = InverterController(self.relay_controller)
        self.transmitter_controller = TransmitterController(self.relay_controller)

        # 初始化视觉系统
        self.camera_controller = CameraController()
        self.vision_detector = VisionDetector(settings)

        # 初始化下料控制器
        self.feeding_controller = FeedingController(
            self.relay_controller,
            self.inverter_controller,
            self.transmitter_controller,
            self.vision_detector,
            self.camera_controller,
            self.state,
            settings
        )

        # 线程管理
        self.monitor_thread = None
        self.visual_control_thread = None
        self.alignment_check_thread = None

    def initialize(self):
        """初始化系统"""
        print("初始化控制系统...")

        # 设置摄像头配置
        self.camera_controller.set_config(
            camera_type=self.settings.camera_type,
            ip=self.settings.camera_ip,
            port=self.settings.camera_port,
            username=self.settings.camera_username,
            password=self.settings.camera_password,
            channel=self.settings.camera_channel
        )

        # 初始化摄像头
        if not self.camera_controller.setup_capture():
            raise Exception("摄像头初始化失败")

        # 加载视觉模型
        if not self.vision_detector.load_models():
            raise Exception("视觉模型加载失败")

        # 启动系统监控
        self.start_monitoring()

        # 启动视觉控制
        self.start_visual_control()

        # 启动对齐检查
        self.start_alignment_check()

        print("控制系统初始化完成")

    def start_monitoring(self):
        """启动系统监控"""
        self.state.running = True
        self.monitor_thread = threading.Thread(
            target=self._monitor_loop,
            daemon=True
        )
        self.monitor_thread.start()

    def _monitor_loop(self):
        """监控循环"""
        while self.state.running:
            try:
                self.feeding_controller.check_upper_material_request()
                self.feeding_controller.check_arch_blocking()
                time.sleep(1)
            except Exception as e:
                print(f"监控线程错误: {e}")

    def start_visual_control(self):
        """启动视觉控制"""
        self.visual_control_thread = threading.Thread(
            target=self._visual_control_loop,
            daemon=True
        )
        self.visual_control_thread.start()

    def _visual_control_loop(self):
        """视觉控制循环"""
        while self.state.running:
            try:
                current_frame = self.camera_controller.capture_frame()
                if current_frame is not None:
                    # 执行视觉控制逻辑
                    self.feeding_controller.visual_control(current_frame)
                time.sleep(self.settings.visual_check_interval)
            except Exception as e:
                print(f"视觉控制循环错误: {e}")
                time.sleep(self.settings.visual_check_interval)

    def start_alignment_check(self):
        """启动对齐检查"""
        self.alignment_check_thread = threading.Thread(
            target=self._alignment_check_loop,
            daemon=True
        )
        self.alignment_check_thread.start()

    def _alignment_check_loop(self):
        """对齐检查循环"""
        while self.state.running:
            try:
                if self.state.lower_feeding_stage == 4:  # 等待对齐阶段
                    current_frame = self.camera_controller.capture_frame()
                    if current_frame is not None:
                        self.state.vehicle_aligned = self.vision_detector.detect_vehicle_alignment(current_frame)
                        if self.state.vehicle_aligned:
                            print("检测到模具车对齐")
                        else:
                            print("模具车未对齐")
                time.sleep(self.settings.alignment_check_interval)
            except Exception as e:
                print(f"对齐检查循环错误: {e}")
                time.sleep(self.settings.alignment_check_interval)

    def start_lower_feeding(self):
        """启动下料流程"""
        self.feeding_controller.start_feeding()

    def stop(self):
        """停止系统"""
        print("停止控制系统...")
        self.state.running = False

        # 等待线程结束
        if self.monitor_thread:
            self.monitor_thread.join()
        if self.visual_control_thread:
            self.visual_control_thread.join()
        if self.alignment_check_thread:
            self.alignment_check_thread.join()

        # 释放摄像头资源
        self.camera_controller.release()
        print("控制系统已停止")