Feeding_control_system/vision/visual_callback_dq.py

from pickle import FALSE
from cv2.gapi import ov
from config.settings import app_set_config
from hardware.relay import RelayController
from hardware.transmitter import TransmitterController
import time
import threading
from datetime import datetime
import logging
import queue
from hardware.upper_plc import OmronFinsPollingService
from vision.muju_cls.muju_utils import run_stable_classification_loop

class VisualCallback:
    # 类变量，用于存储实例引用，实现单例检测
    _instance = None
    _lock = threading.Lock()
    
    def __new__(cls):
        """检测实例是否存在，实现单例模式"""
        with cls._lock:
            if cls._instance is None:
                cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self):
        """初始化视觉回调处理器"""
        # 避免重复初始化
        if hasattr(self, '_initialized') and self._initialized:
            return
        
        self.relay_controller = RelayController()
        self.transmitter_controller = TransmitterController(self.relay_controller)
        
        # 线程安全的参数传递
        self._new_data_available = threading.Event()
        self._is_processing = threading.Lock()
        self._stop_event = threading.Event()
        
        # 添加下料斗门控制锁，防止两个线程同时控制
        self._door_control_lock = threading.Lock()
        # 记录当前控制门的线程名称，用于调试
        self._current_controlling_thread = None
        #是否启动后的第一个模具
        self._is_first_module=True
        self.init_val()
        # self._setup_logging_2()
        #F块完成重量的70%，控制夹脚，F块多于这个比例就没有记录了（注意）
        self._max_f_angle_ratio=0.7
        #完成多少，调整角度比例 ，多于0.8就没记录了（注意）
        self._max_angle_radio=0.8

        #重量大于95%，停留时间2秒，其他的1秒
        self._weight_ratio_955=0.955
        #完成多少，忽略未浇筑满
        self._max_ignore_radio=0.5

        self._mould_accept_aligned=None
        self._mould_before_aligned=False
        #模具开始浇筑时间   
        self._time_mould_begin=''
        #模具结束浇筑时间
        self._time_mould_end=''

        # self.db_queue=queue.Queue()
        
        # self.plc_data=5
        self.plc_service = OmronFinsPollingService("192.168.250.233") 
        self.plc_service.register_data_callback(self.on_plc_update)
        # self.plc_service.register_status_callback(self.on_status_change)
        self.plc_service.start_polling(interval=2.0)

         # 创建并启动单个持续运行的线程
        self.callback_thread = threading.Thread(
            target=self._run_thread_loop, 
            daemon=True
        )
        self.callback_thread.start()

        self.feed_thread = threading.Thread(
            target=self._run_feed, 
            daemon=True
        )
        self.feed_thread.start()

        """启动系统监控"""
        self.monitor_thread = threading.Thread(
            target=self._monitor_loop,
            daemon=True,
            name='monitor'
        )
        self.monitor_thread.start()

        """启动数据库监控"""
        # self.db_thread = threading.Thread(
        #     target=self._monitor_db_loop,
        #     daemon=True,
        #     name='db_monitor'
        # )
        # self.db_thread.start()

        
    
    def init_val(self):
         #初始化值
        """初始化视觉回调处理器"""
        self.angle_mode = "normal"
        self.overflow = False
        self.is_start_visual=False
        
        # 线程安全的参数传递
        self._current_angle = None
        self._overflow_detected = None
        # 新增标志位：指示safe_control_lower_close是否正在执行
        self._is_safe_closing = False

        self._is_feed_start=True
        #未浇筑满时间，用于确定是否进入未浇筑满
        self._before_finish_time=None
        #进入未浇筑满状态标志位
        self._is_before_finish=False
        #是否浇筑满标志位
        self._is_finish=False
        #浇筑完成比例（重量）
        self._is_finish_ratio=0

        #下料阶段，汇总时用枚举
        self._is_feed_stage=0
        #振动相关参数
        self._last_arch_one_weight=0
        self._last_arch_two_weight=0
        self._last_arch_three_weight=0
        self._last_arch_four_weight=0
        self._last_arch_five_weight=0
        self._last_arch_time=0
        #是否为F块
        self._is_small_f=None
        #采集数据用，下料重量=之前下的重量+最后一阶段(下-->模具车)重量差
        #记录最后一次下料斗到模具车前的重量
        self._finish_weight=0

        #记录最后一次下料斗到车初始重量
        self._inital_finish_lweight=0
        #记录视觉停止下料时的重量（计算后面加了多少）
        self._last_lower_weight=0

        # 初始化控制间隔和堆料状态跟踪属性
        self._last_overflow_state = False
        self._last_control_time = 0
        self._is_running=True
        self._initialized = True
        self.plc_data=None

  
    def angle_visual_callback(self, current_angle, overflow_detected, mould_aligned):
        """
        视觉控制主逻辑，供外部推送数据
        使用单个持续运行的线程，通过参数设置传递数据
        如果线程正在处理数据，则丢弃此次推送
        """
        #print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} 收到推送数据")
        # 尝试获取处理锁，若失败则说明正在处理，丢弃数据
        if not self._is_processing.acquire(blocking=False):
            print("回调线程仍在执行，丢弃此次推送数据")
            return
        
        try:
            # 更新参数
            
            if overflow_detected is not None:
                # print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} 收到溢料:{overflow_detected}")
                self._overflow_detected = overflow_detected       
            if current_angle is not None:
                #print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} 收到角度:{current_angle}")
                self._current_angle = current_angle
            if mould_aligned is not None:
                #print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} 收到对齐:{mould_aligned}")
                self._mould_accept_aligned=mould_aligned
            # 通知线程有新数据可用
            self._new_data_available.set()
        finally:
            # 释放处理锁
            self._is_processing.release()

    def _monitor_loop(self):
        """监控循环"""
        while self._is_running:
            try:
                current_time = time.time()           
                # 检查下料斗破拱（只有在下料过程中才检查）
                if self._is_feed_stage==1:  # 下料斗--》模具车
                    _arch_weight = self.transmitter_controller.read_data(2)
                    if _arch_weight is not None and _arch_weight>0:
                        # 检查重量变化是否过慢
                        _weight_changed=abs(_arch_weight - self._last_arch_one_weight)
                        #_last_arch_one_weight默认为0，一开始就进入振动
                        print(f'---------------第一阶段，重量变化:{_weight_changed}------------------')
                        if (_weight_changed< 200) and \
                                (current_time - self._last_arch_time) >= 2:
                            self._last_arch_time = current_time
                            print('---------------------第一阶段振动5秒（小于200KG）-----------------')
                            self.relay_controller.control_arch_lower_open_sync(5)  
                            self._last_arch_one_weight = _arch_weight 
                            continue                   
                        self._last_arch_one_weight = _arch_weight
                       
                elif self._is_feed_stage==2:    #上料斗到下料斗，料多，谨慎振动
                    _arch_weight = self.transmitter_controller.read_data(1)
                    if _arch_weight is not None and _arch_weight>0:
                        # 检查重量变化是否过慢
                        _weight_changed=abs(_arch_weight - self._last_arch_two_weight)
                        print(f'---------------第二阶段，重量变化:{_weight_changed}------------------')
                        if (_weight_changed < 100) and \
                                (current_time - self._last_arch_time) >= 2:
                            self._last_arch_time = current_time
                            print('---------------------第二阶段振动3秒-----------------')
                            self.relay_controller.control_arch_upper_open_sync(3)
                            self._last_arch_two_weight = _arch_weight
                            continue
                        self._last_arch_two_weight = _arch_weight
                elif self._is_feed_stage==3:    #第二次下料斗-》模具车
                    _arch_weight = self.transmitter_controller.read_data(2)
                    if _arch_weight is not None and _arch_weight>0:
                         #刚开始不需要振动，料太多
                        if self._last_arch_three_weight>0:
                            _weight_changed=abs(_arch_weight - self._last_arch_three_weight)
                            # 检查重量变化是否过慢
                            print(f'---------------第三阶段，重量变化:{_weight_changed}------------------')
                            if (_weight_changed < 100) and \
                                    (current_time - self._last_arch_time) >= 2:
                                self._last_arch_time = current_time
                                print('---------------------第三阶段振动5秒(小于100KG）-----------------')
                                self.relay_controller.control_arch_lower_open_sync(5)
                                self._last_arch_three_weight = _arch_weight
                                continue
                        self._last_arch_three_weight = _arch_weight

                elif self._is_feed_stage==4:    #上料斗--》下料斗
                    _arch_weight = self.transmitter_controller.read_data(1)
                    if _arch_weight is not None and _arch_weight>0:
                        # 检查重量变化是否过慢
                        _weight_changed=abs(_arch_weight - self._last_arch_four_weight)
                        print(f'---------------第二阶段，重量变化:{_weight_changed}------------------')
                        if (_weight_changed < 200) and \
                                (current_time - self._last_arch_time) > 2:
                            self._last_arch_time = current_time
                            print('---------------------第四阶段振动5秒-----------------')
                            self.relay_controller.control_arch_upper_open_sync(5)
                            self._last_arch_four_weight = _arch_weight
                            continue
                        self._last_arch_four_weight = _arch_weight
                elif self._is_feed_stage==5:    #下料斗->模具车
                    _arch_weight = self.transmitter_controller.read_data(2)
                    if _arch_weight is not None and _arch_weight>0:
                        if self._last_arch_five_weight>0:
                            _weight_changed=abs(_arch_weight - self._last_arch_five_weight)
                            print(f'---------------第五阶段，重量变化:{_weight_changed}------------------')
                            _min_arch_weight=20
                            if self._is_finish_ratio<self._max_angle_radio:
                                _min_arch_weight=50                  
                            if (_weight_changed < _min_arch_weight) and \
                                    (current_time - self._last_arch_time) >= 2:
                                self._last_arch_time = current_time
                                print(f'---------------------第五阶段振动3秒(小于{_min_arch_weight}kg)）-----------------')
                                self.relay_controller.control_arch_lower_open_sync(3)
                                self._last_arch_five_weight = _arch_weight
                                continue
                        self._last_arch_five_weight = _arch_weight
                      
                # 更新最后读取时间
                self._last_arch_time = current_time
                time.sleep(2)
            except Exception as e:
                print(f"监控线程错误: {e}")

    def _aligned_get_times(self,flag):
         """
         获取对齐,1为对齐，0为未对齐
         """
         _current_times=time.time()
         _temp_aligned_count=0
         if flag==1:
            while time.time()-_current_times<=2:
                 print(f'-------------{self._mould_accept_aligned}-----------------')
                 if self._mould_accept_aligned=='盖板对齐':
                     _temp_aligned_count=_temp_aligned_count+1
                 else:
                     _temp_aligned_count=0
                 print(f'-------------{datetime.now().strftime("%H:%M:%S")} 盖板对齐,次数：{_temp_aligned_count}-----------------')
                 time.sleep(0.2)
            self._mould_accept_aligned=''
            if _temp_aligned_count>=8:
                return True
            else:
                return False
         elif flag==2:
            while time.time()-_current_times<=5:
               
                 if self._mould_accept_aligned=='盖板未对齐':
                     _temp_aligned_count=_temp_aligned_count+1
                 else:
                     _temp_aligned_count=0
                 print(f'-------------{datetime.now().strftime("%H:%M:%S")} 盖板未对齐,次数：{_temp_aligned_count}-----------------')

                 time.sleep(0.2)
          
            self._mould_accept_aligned=''
            if _temp_aligned_count>=20:
                return True
            else:
                return False
         

    def _run_thread_loop(self):
        """
        接受视觉回调数据
        线程主循环，持续运行
        等待新数据，然后调用处理方法
        """
        while not self._stop_event.is_set():
            # 等待新数据可用
            self._new_data_available.wait()
            
            # 重置事件
            self._new_data_available.clear()
            
            # 获取当前参数（使用临时变量避免被其他线程修改）
            current_angle = self._current_angle
            overflow_detected = self._overflow_detected
            self._is_feed_start=True

            if self.is_start_visual:
                # 处理数据
                self._process_angle_callback(current_angle, overflow_detected)
            time.sleep(0.1)
    
    def _run_feed(self):

        while True:
            # print("------------已启动----------------")
            if self._is_feed_start:
                
                # if self.plc_data==5:
                #_is_finish_ratio完成 比例，根据重量过滤一下
                
                if self._is_first_module and self._overflow_detected=='未堆料':
                    #第一次打开 ，未堆料，检测对齐
                    _is_aligned=self._aligned_get_times(1)
                    if _is_aligned:
                        print('------------进入第一块111111-------------')
                        self._is_first_module=False
                        self._mould_before_aligned=True
                        # self.is_start_visual=True
                        self.run_feed_all()
                elif self._is_finish and self._is_finish_ratio>=0.7:                        
                    #后续流程--》检查到未对齐，--》后又对齐+未堆料
                    print('------------------进入连续块检测------------------')
                    if self._mould_before_aligned:
                        #未对齐，检测对齐
                        _is_not_aligned=self._aligned_get_times(2)
                        if _is_not_aligned:
                            #标志位
                            self._mould_before_aligned=False
                            print('------------连续盖板未对齐-------------')
                    else:
                            _is_aligned=self._aligned_get_times(1)   
                            if _is_aligned and self._overflow_detected=='未堆料':
                                print('------------连续盖板已对齐-------------')
                                self._mould_before_aligned=True
                                print('-----------进入连续块111111-----------')
                                # self.is_start_visual=True
                                if self._last_lower_weight>0:
                                    _current_weight=self.transmitter_controller.read_data(2)
                                    if _current_weight is not None:
                                        with open('weight.txt', 'a') as f:
                                            f.write(f"{self._last_lower_weight-_current_weight}\n")
                                self.init_val()
                                self.run_feed_all()
            
                # else:
                #     print("-----------上料斗未就位----------------")
                #     print("---------3--上料斗未就位----------------")
              
            time.sleep(0.2)

    def safe_control_lower_close(self,duration=3):
                """线程安全的下料斗关闭方法"""
                thread_name = threading.current_thread().name
               # print(f"[{thread_name}] 尝试关闭下料斗...")
                # 设置标志位，指示正在执行安全关闭操作
                self._is_safe_closing = True
                try:
                    with self._door_control_lock:
                        self._current_controlling_thread = thread_name
                        #print(f"[{thread_name}] 获得下料斗控制权，执行关闭操作")
                        self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
                        self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
                        time.sleep(duration)
                        self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
                        self._current_controlling_thread = None
                        #print(f"[{thread_name}] 释放下料斗控制权")
                finally:
                    # 无论成功失败，都要重置标志位
                    self._is_safe_closing = False
    
    def close_lower_door_visual(self):
        """关闭下料斗门"""
        self.is_start_visual=False
        time.sleep(0.5)                
        self.safe_control_lower_close()

    def _visual_close(self):
        self.is_start_visual=False
        self._is_finish=True
        self._is_feed_stage=0
        print(f'--------进入关闭(浇筑满)-----------')
        self.safe_control_lower_close(3)
        print(f'--------关闭完成-----------')
        # try:
        #     self.db_queue.put_nowait({
        #         "f":self._is_small_f,
        #         "Status": 3
        #     })
        # except queue.Full:
        #     print("数据库队列已满，无法添加数据")
        #记录重量
        _current_weight=self.transmitter_controller.read_data(2)
        if _current_weight is not None:
            self._last_lower_weight=_current_weight
            self._finish_weight= self._finish_weight+(self._inital_finish_lweight-_current_weight)
            with open('weight.txt', 'a') as f:
                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                if self._is_small_f:
                    f.write(f"{self._time_mould_begin},{timestamp},F,{self._finish_weight}\n")
                else:
                    f.write(f"{self._time_mould_begin},{timestamp},B,{self._finish_weight}\n")
             

    def run_feed_all(self):
        """
        全流程下料：包括判断模具类型
        """
        _is_f= run_stable_classification_loop()
        print(f'------------已判断出模具类型: {_is_f}-------------')
        if _is_f is not None:
            if _is_f=='模具车1':
                self._is_small_f=True
                print('-------------F块模具--------------')
                print('-------------F块模具--------------')
                print('-------------F块模具--------------')
                self.run_feed_f()
            elif _is_f=='模具车2':
                self._is_small_f=False
                self.run_feed()
                print('-------------其他模具---------------')

        if self._is_small_f is None:
            print('-----------未判断出模具类型--------------')
            return
    
    def run_feed_f(self):
        """第一阶段下料：下料斗向模具车下料（低速）"""
        print("--------------------开始下料（F块）--------------------")
        self._time_mould_begin=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        # loc_relay=self.relay_controller
        loc_mitter=self.transmitter_controller
        max_weight_none=5
        cur_weight_none=0
        initial_lower_weight=loc_mitter.read_data(2)
        if initial_lower_weight is None:
            print("-----f上料斗重量异常-----")
            return
        first_finish_weight=0
        self._finish_weight=first_finish_weight
        self._inital_finish_lweight=initial_lower_weight
        need_total_weight=0.54*2416
        if initial_lower_weight>100:
            if not self._is_finish:
                self.is_start_visual=True
                initial_lower_weight=loc_mitter.read_data(2)
                if initial_lower_weight is None:
                    print("-----f上料斗重量异常2-----")
                    return
                self._is_feed_stage=5
                while not self._is_finish:
                    current_weight = loc_mitter.read_data(2)
                    if current_weight is None:
                        cur_weight_none+=1
                        if cur_weight_none>max_weight_none:
                            #如果重量连续5次为None，认为下料斗未就位，跳出循环
                            print('------------f下到模具车,下料斗重量异常----------------')
                            print('------------f下到模具车,下料斗重量异常----------------')
                            self.close_lower_door_visual()
                            return
                            #视觉处理关闭，异常的话重量没有生效
                        continue
                    cur_weight_none=0
                    first_finish_weight=initial_lower_weight-current_weight
                    self._is_finish_ratio=(first_finish_weight)/need_total_weight
                    print(f'------------已下料比例: {self._is_finish_ratio}-------------')
                    if self._is_finish_ratio>self._max_f_angle_ratio:
                        #关5秒
                        #大于0.7后不再检测了，直接交给视觉控制夹脚
                        # print(f'------------已下料比例: {self._is_finish_ratio}-------------')
                        break
                        
                    # print(f'------------已下料: {first_finish_weight+second_finish_weight}kg-------------')
                    time.sleep(1)
        # initial_lower_weight=_current_lower_weight
        print(f'------------已下料（F）: {first_finish_weight}kg-------------')
        print(f'------------已下料（F）: {first_finish_weight}kg-------------')
 
        print(f'------------已完成-------------')


    def run_feed(self):
        """第一阶段下料：下料斗向模具车下料（低速）"""
        print("--------------------开始下料（普通块）--------------------")
        self._time_mould_begin=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        loc_relay=self.relay_controller
        loc_mitter=self.transmitter_controller
        max_weight_none=5
        cur_weight_none=0

        initial_lower_weight=loc_mitter.read_data(2)
        # initial_upper_weight=loc_mitter.read_data(1)
        if initial_lower_weight is None:
            print("---------------下料斗重量异常----------------")
            return
        first_finish_weight=0
        need_total_weight=1.91*2416
        # start_time=None
        self.is_start_visual=True
        if initial_lower_weight>100:
            #下料斗的料全部下完
            self._is_feed_stage=1
            while not self._is_finish:          
                current_weight = loc_mitter.read_data(2)
                if current_weight is None:
                    cur_weight_none+=1
                    if cur_weight_none>max_weight_none:
                        print("-----------下料斗重量异常(第一次下到模具车)--------------")
                        self.close_lower_door_visual()
                        return
                    continue
                cur_weight_none=0
                if current_weight<250 and current_weight>0:
                    self.close_lower_door_visual()
                    break
                time.sleep(1)
        _current_lower_weight=loc_mitter.read_data(2)
        if _current_lower_weight is None:
            print("-------下料斗重量异常---------")
            return
        first_finish_weight=initial_lower_weight-_current_lower_weight
        # initial_lower_weight=_current_lower_weight
        print(f'------------已下料（第一次）: {first_finish_weight}kg-------------')
        print(f'------------已下料（第一次）: {first_finish_weight}kg-------------')
        self._is_feed_stage=0

        while self.plc_data!=5:
            print('------------上料斗未就位----------------')
            print('------------上料斗未就位----------------')
            time.sleep(1)

        if self.plc_data==5:
            print(f'------------上料斗向下料斗转移(留3000KG）-------------')
            #打开上料斗出砼门，开5就，开三分之一下
          
            loc_relay.control_upper_open_sync(6)
            self._is_feed_stage=2
            loc_time_count=1
            upper_open_time=time.time()
           
            while not self._is_finish:
                current_upper_weight = loc_mitter.read_data(1)
                if current_upper_weight is None:
                    cur_weight_none+=1
                    if cur_weight_none>max_weight_none:
                        #如果重量连续5次为None，认为上料斗未就位，跳出循环
                        print('------------第一次上到下,上料斗重量异常----------------')
                        print('------------第一次上到下,上料斗重量异常----------------')
                        loc_relay.control_upper_close_sync(5+loc_time_count)
                        return
                    continue
                cur_weight_none=0
                _two_lower_weight=loc_mitter.read_data(2)
                if _two_lower_weight is None:
                     _two_lower_weight=0
                if (current_upper_weight<3000 and current_upper_weight>0) or _two_lower_weight>3200:
                    #关5秒,loc_time_count多关一秒
                    loc_relay.control_upper_close_sync(5+loc_time_count)
                    break
                else:
                    if time.time()-upper_open_time>5:
                        if loc_time_count<6:
                            upper_open_time=time.time()
                            loc_relay.control_upper_open_sync(0.8)
                            loc_time_count=loc_time_count+0.8
                    else:
                        time.sleep(0.5)
            else:
                 loc_relay.control_upper_close_sync(6+loc_time_count)
        
        self.is_start_visual=True
        initial_lower_weight=loc_mitter.read_data(2)
        if initial_lower_weight is None:
            print("-------下料斗重量异常(第二次下料到模具车)---------")
            return
        self._is_feed_stage=3
        while not self._is_finish:
            current_weight = loc_mitter.read_data(2)
            if current_weight is None:
                cur_weight_none+=1
                if cur_weight_none>max_weight_none:
                    print("-------下料斗重量异常(第二次下料到模具车)---------")
                    self.close_lower_door_visual()
                    return
                continue
            cur_weight_none=0
            # second_finish_weight=initial_lower_weight-current_weight
            if current_weight<250:
                self.close_lower_door_visual()
                break
            # print(f'------------已下料: {first_finish_weight+second_finish_weight}kg-------------')
            time.sleep(1)
        _current_lower_weight=loc_mitter.read_data(2)
        if _current_lower_weight is None:
            print("-------下料斗重量异常(第二次下到模)---------")
            return
        first_finish_weight=first_finish_weight+initial_lower_weight-_current_lower_weight
        print(f'------------已下料（第二次）: {first_finish_weight}kg-------------')
        print(f'------------已下料（第二次）: {first_finish_weight}kg-------------')
        
        self._is_feed_stage=0
        if self.plc_data==5:
            #第二次上料斗向下料斗转移
            loc_relay.control_upper_open_sync(12)
            loc_time_count=1
            upper_open_time=time.time()
            upper_open_time_2=None
            #第二次到下料斗还需要的量
            #loc_left_need_weight=need_total_weight-first_finish_weight
            # initial_upper_weight=loc_mitter.read_data(1)
            # start_time=None
            self._is_feed_stage=4
            while not self._is_finish:
               # print(f'------------上料斗向下料斗转移22222-------------')
                current_upper_weight = loc_mitter.read_data(1)
                if current_upper_weight is None:
                    cur_weight_none+=1
                    if cur_weight_none>max_weight_none:
                        #如果重量连续5次为None，认为上料斗未就位，跳出循环
                        print('------------第二次上到下,上料斗重量异常----------------')
                        print('------------第二次上到下,上料斗重量异常----------------')
                        loc_relay.control_upper_close_sync(15)
                        break
                    continue
                cur_weight_none=0
                if (current_upper_weight<600 and current_upper_weight>0) or upper_open_time_2 is not None: 
                    if upper_open_time_2 is None:
                        upper_open_time_2=time.time()
                    if current_upper_weight<400 or time.time()-upper_open_time_2>5:
                        loc_relay.control_arch_upper_open_async(5) 
                        # loc_relay.control_arch_upper_open() 
                        loc_relay.control_upper_open_sync(5)
                            # start_time=None
                        #5秒后关闭
                        loc_relay.control_upper_close_after()#control_upper_close_sync(8+loc_time_count)
                        break
                    time.sleep(1)
                else:
                    if time.time()-upper_open_time>2:
                        # if loc_time_count<6:
                        upper_open_time=time.time()
                        loc_relay.control_upper_open_sync(1.2)
                        loc_time_count=loc_time_count+1
                    else:
                        time.sleep(0.5)
            else:
                 loc_relay.control_upper_close_sync(15)
            # time.sleep(0.4)
        
        #第三次下料斗转移到模具车
        if not self._is_finish:
            self.is_start_visual=True
            initial_lower_weight=loc_mitter.read_data(2)
            self._finish_weight=first_finish_weight
            self._inital_finish_lweight=initial_lower_weight
            if initial_lower_weight is None:
                print("-------下料斗重量异常(第三次下到模具车)---------")
                return
            self._is_feed_stage=5
            while not self._is_finish:
                current_weight = loc_mitter.read_data(2)
                if current_weight is None:
                    cur_weight_none+=1
                    if cur_weight_none>max_weight_none:
                        #重量异常退出
                        print('------------第三次下到模具车,下料斗重量异常----------------')
                        self.close_lower_door_visual()
                        return           
                    continue
                cur_weight_none=0
                second_finish_weight=initial_lower_weight-current_weight
                self._is_finish_ratio=(second_finish_weight+first_finish_weight)/need_total_weight
                print(f'------------已下料比例: {self._is_finish_ratio}-------------')
                if self._is_finish_ratio>=1:
                    #关5秒
                    # print(f'------------已下料比例: {self._is_finish_ratio}-------------')
                    break
                    
                # print(f'------------已下料: {first_finish_weight+second_finish_weight}kg-------------')
                time.sleep(1)
            
        # _current_lower_weight=loc_mitter.read_data(2)
        # first_finish_weight=first_finish_weight+initial_lower_weight-_current_lower_weight
        # print(f'------------已下料: {first_finish_weight}kg-------------')
        # print(f'------------已下料: {first_finish_weight}kg-------------')


        print(f'------------已完成-------------')

    def _process_angle_callback(self, current_angle, overflow_detected):
        """
        实时精细控制 - 基于PID思想，无固定间隔
        """
        try:
            # 记录控制时间戳（用于微分计算，而非限制）
            current_time = time.time()
            # 确保所有PID相关属性都被正确初始化
            if not hasattr(self, '_last_control_time'):
                self._last_control_time = current_time
            if not hasattr(self, '_last_error'):
                self._last_error = 0
            if not hasattr(self, '_error_integral'):
                self._error_integral = 0
            
            # print(f"{self.angle_mode}")
            self.overflow = overflow_detected in ["大堆料", "小堆料"]
            
            if current_angle is None:
                return
                
            print(f"{datetime.now().strftime('%H:%M:%S.%f')[:-3]} 角度11: {current_angle:.2f}°,{overflow_detected}")
            
            if overflow_detected == "未浇筑满" or self._is_before_finish:
                 if self._before_finish_time is None:
                    self._before_finish_time=current_time
                    self.safe_control_lower_close(3)
                    print('-----------------关闭（未浇筑满）--------------------')
                    # time.sleep(3)               
                 else:
                    if overflow_detected=='浇筑满':
                        self._visual_close()
                        return
                        # print(f'--------已关闭已关闭-----------')
                    elif overflow_detected=="大堆料":
                        print(f'--------未浇筑满，大堆料-----------')
                        self._pulse_control('open',0.3)
                        time.sleep(0.3)
                        self._pulse_control('close',0.4)   
                        print(f'--------比例：{self._is_finish_ratio}-----------')
                        if self._is_finish_ratio>= self._weight_ratio_955:
                            time.sleep(2)
                        else:
                            time.sleep(1)
                        self._is_before_finish=True  
                    else:   
                        # self._pulse_control('open',0.5)
                        # time.sleep(0.3)
                        # self._pulse_control('close',0.6) 
                        # print(f'--------比例：{self._is_finish_ratio}-----------')  
                        self._pulse_control('open',0.6)
                        time.sleep(0.3)
                        self._pulse_control('close',0.7)   
                        if self._is_finish_ratio>= self._weight_ratio_955:
                            time.sleep(2)
                        else:
                            time.sleep(1)
                        self._is_before_finish=True           
                 if self._is_finish_ratio<=self._max_ignore_radio:
                    #如果重量未达到最大忽略角度，需要跳出
                    self._is_before_finish=False
                 return
            elif overflow_detected == "浇筑满":
                self._visual_close()
                return
            else:
                self._before_finish_time=None
                if self._is_finish_ratio>=self._max_angle_radio or (self._is_finish_ratio>self._max_f_angle_ratio and self._is_small_f):
                     if overflow_detected == "大堆料":
                        TARGET_ANGLE = 5.0  # 大堆料时控制在15度左右
                     elif overflow_detected == "小堆料":
                        TARGET_ANGLE = 15.0  # 小堆料时控制在35度左右
                     else:
                        TARGET_ANGLE = 35.0  # 12.25由25--》35
                else:
                    if self._is_feed_stage==1 or self._is_feed_stage==3:
                         #根据溢料状态动态调整目标角度
                        if overflow_detected == "大堆料":
                            TARGET_ANGLE = 15.0  # 大堆料时控制在15度左右
                        elif overflow_detected == "小堆料":
                            TARGET_ANGLE = 45.0  # 小堆料时控制在35度左右
                        else:
                            TARGET_ANGLE = 55.0  # 未溢料时开到最大56度
                    else:
                            #根据溢料状态动态调整目标角度
                        if overflow_detected == "大堆料":
                            TARGET_ANGLE = 15.0  # 大堆料时控制在15度左右
                        elif overflow_detected == "小堆料":
                            TARGET_ANGLE = 25.0  # 小堆料时控制在35度左右
                        else:
                            TARGET_ANGLE = 45.0  # 未溢料时开到最大56度
            
            # 确保目标角度在硬件范围内（5-56度）
            TARGET_ANGLE = max(5.0, min(56.0, TARGET_ANGLE))
            
            # PID控制参数
            KP = 0.2    # 比例系数
            KI = 0  # 积分系数  
            KD = 0  # 微分系数
            # KP = 0.15    # 比例系数
            # KI = 0.008   # 积分系数  
            # KD = 0.08   # 微分系数
            # if TARGET_ANGLE <= 25.0:
            #     KP, KI, KD = 0.18, 0.008, 0.08  # 小角度，强控制
            # elif TARGET_ANGLE <= 40.0:
            #     KP, KI, KD = 0.15, 0.01, 0.06   # 中角度
            # else:
            #     KP, KI, KD = 0.12, 0.012, 0.04  # 大角度，温和控制
            # 计算误差
            error = current_angle - TARGET_ANGLE
            dt = current_time - self._last_control_time
            
            # 积分项（抗饱和）
            self._error_integral += error * dt
            self._error_integral = max(min(self._error_integral, 50), -50)  # 积分限幅
            
            # 微分项
            error_derivative = (error - self._last_error) / dt if dt > 0 else 0
            
            # PID输出
            pid_output = (KP * error + KI * self._error_integral + KD * error_derivative)
            print(f"📊 PID计算: 误差={error:.2f}°, 积分={self._error_integral:.2f}, "
          f"微分={error_derivative:.2f}, 输出={pid_output:.2f}")
            # 更新历史值
            self._last_error = error
            self._last_control_time = current_time
            
            # 状态机 + PID控制
           
            if self.angle_mode == "normal":
                self._normal_mode_advanced(current_angle, pid_output,TARGET_ANGLE)
                
            elif self.angle_mode == "reducing":
                self._reducing_mode_advanced(current_angle, pid_output, TARGET_ANGLE)
                
            elif self.angle_mode == "maintaining":
                self._maintaining_mode_advanced(current_angle, pid_output, TARGET_ANGLE)

        except Exception as e:
            print(f"处理视觉回调时发生异常: {e}")

    def _normal_mode_advanced(self, current_angle, pid_output,target_angle):
        """高级正常模式控制"""
        if self.overflow:
            self.angle_mode = "reducing"
            print("检测到溢料，切换到减小模式")
            return

         # 🎯 修复1: 添加强制控制机制
   

        # 基于PID输出的智能控制
        control_threshold = 2  # 从2.0减小到0.5，提高灵敏度
        
        if abs(pid_output) > control_threshold:
            if pid_output > 0:
                # 需要减小角度（关门）
                pulse_time = min(0.3, pid_output * 0.1)
                self._pulse_control("close", pulse_time)
                print(f"正常模式: 角度偏高{pid_output:.1f}，关门{pulse_time:.2f}秒")
            else:
                # 需要增大角度（开门）
                pulse_time = min(0.3, abs(pid_output) * 0.1)
                self._pulse_control("open", pulse_time)
                print(f"正常模式: 角度偏低{abs(pid_output):.1f}，开门{pulse_time:.2f}秒")
        else:
            # 在死区内，保持静止
            error = current_angle - target_angle
            abs_error = abs(error)
            
            # 强制控制：如果误差超过5度，强制控制
            if abs_error > 5:
                if error > 0:  # 当前角度 > 目标角度，需要关门
                    pulse_time=0.1  # 根据误差计算脉冲时间
                    self._pulse_control("close", pulse_time)
                    print(f"🚨 强制关门: 误差{abs_error:.1f}°过大，脉冲{pulse_time:.3f}s")
                else:  # 当前角度 < 目标角度，需要开门
                    pulse_time =0.1
                    self._pulse_control("open", pulse_time)
                    print(f"🚨 强制开门: 误差{abs_error:.1f}°过大，脉冲{pulse_time:.3f}s")
                return
            else:
                self._stop_door()
                print(f"正常模式: 角度在目标范围内，保持静止")

    def _reducing_mode_advanced(self, current_angle, pid_output, target_angle):
        """高级减小模式控制"""
        if not self.overflow:
            if current_angle <= target_angle + 5.0:
                self.angle_mode = "normal"
                print("溢料消除且角度合适，返回正常模式")
            else:
                # 缓慢恢复
                self._pulse_control("close", 0.1)
            return
            
        # 有溢料，积极减小角度
        if current_angle > target_angle:
            # 使用PID输出计算控制量
            pulse_time = min(0.5, max(0.1, pid_output * 0.15))
            self._pulse_control("close", pulse_time)
            print(f"减小模式: 积极关门{pulse_time:.2f}秒，PID输出:{pid_output:.1f}")
        else:
            self.angle_mode = "maintaining"
            print("角度已达标，进入维持模式")

    def _maintaining_mode_advanced(self, current_angle, pid_output, target_angle):
        """高级维持模式控制"""
        if not self.overflow:
            self.angle_mode = "normal"
            print("溢料消除，返回正常模式")
            return
            
        # 精确维持控制
        dead_zone = 1.5  # 更小的死区
        
        if abs(pid_output) > dead_zone:
            pulse_time = min(0.2, abs(pid_output) * 0.05)  # 更精细的控制
            
            if pid_output > 0:
                self._pulse_control("close", pulse_time)
                print(f"维持模式: 微调关门{pulse_time:.2f}秒")
            else:
                self._pulse_control("open", pulse_time)
                print(f"维持模式: 微调开门{pulse_time:.2f}秒")
        else:
            self._stop_door()
            print("维持模式: 角度精确控制中")

    def _pulse_control(self, action, duration):
        """统一的脉冲控制方法"""
        # 检查是否正在执行safe_control_lower_close，如果是则跳过relay操作
        if self._is_safe_closing:
            thread_name = threading.current_thread().name
            print(f"[{thread_name}] safe_control_lower_close正在执行，跳过脉冲控制 {action}")
            return
            
        if duration <= 0:
            return
            
        thread_name = threading.current_thread().name
        print(f"[{thread_name}] 尝试脉冲控制 {action}，时长 {duration:.2f}秒...")
        
        with self._door_control_lock:
            self._current_controlling_thread = thread_name
            print(f"[{thread_name}] 获得下料斗控制权，执行脉冲控制")
            
            if action == "open":
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
                time.sleep(duration)
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
                print(f"[{thread_name}] 开门脉冲: {duration:.2f}秒")
            else:  # close
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
                time.sleep(duration)
                self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
                print(f"[{thread_name}] 关门脉冲: {duration:.2f}秒")
            
            self._current_controlling_thread = None
            print(f"[{thread_name}] 释放下料斗控制权")

    def _stop_door(self):
        """停止门运动"""
        # 检查是否正在执行safe_control_lower_close，如果是则跳过relay操作
        if self._is_safe_closing:
            thread_name = threading.current_thread().name
            print(f"[{thread_name}] safe_control_lower_close正在执行，跳过停止门运动操作")
            return
            
        thread_name = threading.current_thread().name
        print(f"[{thread_name}] 尝试停止门运动...")
        
        with self._door_control_lock:
            self._current_controlling_thread = thread_name
            print(f"[{thread_name}] 获得下料斗控制权，执行停止操作")
            self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
            self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
            self._current_controlling_thread = None
            print(f"[{thread_name}] 释放下料斗控制权")
    
    def _open_door(self, duration=0.5):
        """打开门"""
        self._pulse_control("open", 0.3)
    
    def _close_door(self, duration=0.5):
        """关闭门"""
        self._pulse_control("close", 1)

    def on_plc_update(self,data: int, binary: str):
        #4即将振捣室5振捣室   64即将搅拌楼  66到达搅拌楼
        # print(f"[数据回调] 数值: 0x{data:02X} | 十进制: {data:3d} | 二进制: {binary}")
        self.plc_data=data

    @classmethod
    def instance_exists(cls):
        """检测实例是否存在"""
        return cls._instance is not None
    
    def shutdown(self):
        """关闭线程，清理资源"""
        # 设置停止事件
        self._stop_event.set()
        # 唤醒线程以便它能检测到停止事件
        self._new_data_available.set()

        self._is_running=False
        self._is_finish=True
        self.is_start_visual=False
        # #关闭下料斗
        # self.safe_control_lower_close()
        if self.plc_service:
            self.plc_service.stop_polling()
        # 等待线程结束
        if self.callback_thread.is_alive():
            self.callback_thread.join(timeout=1.0)

        if self.feed_thread.is_alive():
            self.feed_thread.join(timeout=1.0)
            
        if self.monitor_thread.is_alive():
            self.monitor_thread.join(timeout=1.0)
        
        # self.relay_controller._close_lower_5s

    def __del__(self):
        """析构函数，确保线程安全关闭"""
        self.shutdown()

# 创建默认实例
# visual_callback_instance = VisualCallback()

# 兼容层，保持原来的函数调用方式可用
# def angle_visual_callback(current_angle, overflow_detected):
#     """
#     兼容旧版本的函数调用方式
#     将调用转发到默认实例的angle_visual_callback方法
#     """
#     visual_callback_instance.angle_visual_callback(current_angle, overflow_detected)