stage_one

This commit is contained in:
2025-12-12 18:00:14 +08:00
parent dc4ef9002e
commit b8b9679bc8
55 changed files with 6541 additions and 459 deletions

View File

@ -77,20 +77,20 @@ class FeedingController:
current_time = time.time()
# 检查下料斗破拱(只有在下料过程中才检查)
# if self.state.lower_feeding_stage in [1, 2, 3]: # 在所有下料阶段检查
# lower_weight = self.transmitter_controller.read_data(2)
# if lower_weight is not None:
# # 检查重量变化是否过慢小于0.1kg变化且时间超过10秒
# if (abs(lower_weight - self.state.last_lower_weight) < 0.1) and \
# (current_time - self.state.last_weight_time) > 10:
# print("下料斗可能堵塞,启动破拱")
# self.state._lower_is_arch_=True
# self.relay_controller.control(self.relay_controller.BREAK_ARCH_LOWER, 'open')
# time.sleep(2)
# self.relay_controller.control(self.relay_controller.BREAK_ARCH_LOWER, 'close')
# self.state._lower_is_arch_=False
if self.state.lower_feeding_stage in [1, 2, 3]: # 在所有下料阶段检查
lower_weight = self.transmitter_controller.read_data(2)
if lower_weight is not None:
# 检查重量变化是否过慢小于0.1kg变化且时间超过10秒
if (abs(lower_weight - self.state.last_lower_weight) < 10) and \
(current_time - self.state.last_weight_time) > 1:
print("下料斗可能堵塞,启动破拱")
self.state._lower_is_arch_=True
self.relay_controller.control(self.relay_controller.BREAK_ARCH_LOWER, 'open')
time.sleep(2)
self.relay_controller.control(self.relay_controller.BREAK_ARCH_LOWER, 'close')
self.state._lower_is_arch_=False
# self.state.last_lower_weight = lower_weight
self.state.last_lower_weight = lower_weight
# 检查上料斗破拱(在上料斗向下料斗下料时检查)
if self.state._feed_status == FeedStatus.FUpperToLower: # 在任何阶段都可能需要上料斗破拱
@ -98,8 +98,8 @@ class FeedingController:
upper_weight = self.transmitter_controller.read_data(1)
if upper_weight is not None:
# 检查重量变化是否过慢小于0.1kg变化且时间超过10秒,觉得有点小。改成
if (abs(upper_weight - self.state.last_upper_weight) < 100) and \
(current_time - self.state.last_weight_time) > 5:
if (abs(upper_weight - self.state.last_upper_weight) < 25) and \
(current_time - self.state.last_weight_time) > 1:
print("上料斗可能堵塞,启动破拱")
self.state._upper_is_arch_=True
self.relay_controller.control(self.relay_controller.BREAK_ARCH_UPPER, 'open')
@ -119,58 +119,85 @@ class FeedingController:
视觉控制主逻辑
"""
# 检测是否溢料
self.state.overflow_detected = self.vision_detector.detect_overflow(current_frame)
# print('视觉控制线程启用中...')
# self.state.overflow_detected = self.vision_detector.detect_overflow(current_frame)
overflow=self.state.overflow_detected in ["大堆料", "小堆料"]
current_angle = self.vision_detector.detect_angle(image=current_frame)
current_angle =self.vision_detector.detect_angle(image=current_frame)
if current_angle is None:
print("无法获取当前角度,跳过本次调整")
return
self.state.last_angle = current_angle
self.state._lower_angle=current_angle
print(f"当前角度: {current_angle:.2f}°, 溢料状态: {overflow}, 溢料返回: {self.state.overflow_detected}")
return
print(f"当前角度: {current_angle:.2f}°")
# return
if self.state.overflow_detected!="浇筑满":
if current_angle is None:
print("无法获取当前角度,跳过本次调整")
return
print(f"当前角度: {current_angle:.2f}°, 溢料状态: {overflow}, 控制模式: {self.state.angle_control_mode}")
# print(f"当前角度: {current_angle:.2f}°, 溢料状态: {overflow}, 控制模式: {self.state.angle_control_mode}")
# 状态机控制逻辑
if self.state.angle_control_mode == "normal":
# 正常模式大于app_set_config.angle_threshold=60度
if overflow and current_angle > app_set_config.angle_threshold:
# 检测到堆料且角度过大,进入角度减小模式
print("检测到堆料且角度过大,关闭出砼门开始减小角度")
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
if overflow:
# if current_angle > app_set_config.angle_threshold:
# # 检测到堆料且角度过大,进入角度减小模式
# print("检测到堆料且角度过大,关闭出砼门开始减小角度")
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
self.state.angle_control_mode = "reducing"
else:
else:
# 保持正常开门 30
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
if current_angle >app_set_config.target_angle:
# 角度已降至目标范围,关闭出砼门
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
else:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
print(f'当前重量:{self.state._mould_finish_weight:.2f}kg, 目标重量:{self.state._mould_need_weight:.2f}kg')
if self.state._mould_need_weight>0:
if self.state._mould_finish_weight/self.state._mould_need_weight>=0.8:
print(f"完成重量占比{self.state._mould_finish_weight/self.state._mould_need_weight:.2f},半开出砼门")
#半开出砼门
if current_angle >app_set_config.target_angle:
# 角度已降至目标范围,关闭出砼门
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
time.sleep(0.3)
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
else:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
time.sleep(0.32)
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
else:
#全开砼门
if current_angle > app_set_config.angle_threshold:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
elif self.state.angle_control_mode == "reducing":
# 角度减小模式
if current_angle <= app_set_config.target_angle + app_set_config.angle_tolerance:
# 角度已达到目标范围
if overflow:
# 仍有堆料,进入维持模式
print(f"角度已降至{current_angle:.2f}°,仍有堆料,进入维持模式")
self.state.angle_control_mode = "maintaining"
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open') # 先打开门
if overflow:
if current_angle <= app_set_config.target_angle:
# 角度已达到目标范围
# 仍有堆料,进入维持模式
print(f"角度已降至{current_angle:.2f}°,仍有堆料,进入维持模式")
if current_angle<=app_set_config.min_angle:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
time.sleep(0.1)
self.state.angle_control_mode = "maintaining"
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
else:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
# time.sleep(0.05)
# 先打开门
else:
# 无堆料,恢复正常模式
print(f"角度已降至{current_angle:.2f}°,无堆料,恢复正常模式")
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
self.state.angle_control_mode = "normal"
elif self.state.angle_control_mode == "maintaining":
@ -178,8 +205,8 @@ class FeedingController:
if not overflow:
# 堆料已消除,恢复正常模式
print("堆料已消除,恢复正常模式")
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
self.state.angle_control_mode = "normal"
else:
# 继续维持角度控制
@ -198,7 +225,7 @@ class FeedingController:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
self.state.angle_control_mode = "normal"
else:
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control_lower_close()
@ -207,12 +234,13 @@ class FeedingController:
用于维持模式的脉冲控制
保持角度在目标范围内
"""
print("执行维持脉冲控制")
# 关门1秒
print("进入维持模式")
# 关门时间
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'open')
time.sleep(1.0)
# 开门1秒
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
time.sleep(0.2)
# 开门时间
self.relay_controller.control(self.relay_controller.DOOR_LOWER_CLOSE, 'close')
time.sleep(1.0)
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
time.sleep(0.25)
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')

View File

@ -2,9 +2,10 @@ from enum import IntEnum
from core.state import FeedStatus
from service.mould_service import MouldService
from busisness.blls import ArtifactBll
from busisness.models import ArtifactInfoModel
from busisness.models import ArtifactInfoModel,ArtifactInfo
import time
from datetime import datetime
from hardware.RFID.rfid_service import rfid_service
from config.settings import app_set_config
class FeedingProcess:
@ -19,7 +20,7 @@ class FeedingProcess:
self.vision_detector = vision_detector
self.camera_controller = camera_controller
self.state = state
self.state._feed_status = FeedStatus.FCheckM
self.state._feed_status = FeedStatus.FNone
#标志位用,是否是第一次运行
self.is_first_flag=True
@ -28,143 +29,36 @@ class FeedingProcess:
loc_state=self.state
loc_state._upper_weight=self.transmitter_controller.read_data(1)
loc_state._lower_weight=self.transmitter_controller.read_data(2)
# loc_state._upper_volume=round(loc_state._upper_weight/self.state.density,1)
"""开始生产管片"""
if loc_state._feed_status == FeedStatus.FNone:
# loc_state._feed_status = FeedStatus.FCheckM
return
elif loc_state._feed_status == FeedStatus.FCheckM:
"""开始生产管片"""
loc_state.lower_feeding_stage = 4
# if app_set_config.debug_feeding:
# loc_state._feed_status = FeedStatus.FApiCheck
if self.state.vehicle_aligned:
loc_state._feed_status = FeedStatus.FApiCheck
print("检查模车")
print("---------------初始化数据------------------")
loc_state._mould_need_weight= 1200
loc_state._feed_status = FeedStatus.FFeed
return
elif loc_state._feed_status == FeedStatus.FApiCheck:
print("生产已开始")
# time.sleep(2)
loc_modules = self.mould_service.get_not_pour_artifacts()
if loc_modules:
# 取第一个未浇筑的管片
#后续放入队列处理
loc_module = loc_modules[0]
#API
loc_module.Source = 1
loc_module.BeginTime=datetime.now()
self.artifact_bll.insert_artifact_task(loc_module)
loc_state.current_artifact = loc_module
loc_state._mould_need_weight=loc_module.BetonVolume*self.state.density
print(f"已获取到未浇筑的管片:{loc_module.MouldCode}")
# self.artifact_bll.finish_artifact_task(loc_state.current_artifact.ArtifactID,1.92)
loc_state._feed_status = FeedStatus.FCheckGB
else:
#未读取到AIP接口数据.
print("未获取到未浇筑的管片")
loc_artifacting_task=self.artifact_bll.get_artifacting_task()
if loc_artifacting_task:
loc_state.current_artifact = loc_artifacting_task
loc_state._mould_need_weight=loc_artifacting_task.BetonVolume*self.state.density
loc_state._feed_status = FeedStatus.FCheckGB
else:
self.state.current_artifact = None
return
elif loc_state._feed_status == FeedStatus.FRFID:
print("生产已检查RFID")
#RFID格式模具编号,分块号,尺寸规格,方量
rfid_info =''
loc_MouldCode='SHZB1-4'
loc_SizeSpecification='6600*1200'
loc_BlockNumber='B1'
loc.BetonVolume=1.56
if self.state.current_artifact:
#检测是否和RFID识别的管理一致
loc_state._feed_status = FeedStatus.FCheckGB
else:
#以RFID为准
loc_module= ArtifactInfoModel()
loc_module.MouldCode=loc_MouldCode
loc_module.SizeSpecification=loc_SizeSpecification
loc_module.BlockNumber=loc_BlockNumber
loc_module.BetonVolume=loc.BetonVolume
self.state.current_artifact = loc_module
#确认是否保存到数据库
loc_state._feed_status = FeedStatus.FCheckGB
return
elif loc_state._feed_status == FeedStatus.FCheckGB:
print("检查盖板对齐,")
# time.sleep(5)
loc_state._feed_status = FeedStatus.FUpperToLower
#计算本次生产需要的总重量
print(f"本次生产需要的总重量:{self.state._mould_need_weight}")
return
elif loc_state._feed_status == FeedStatus.FUpperToLower:
print("上料斗向下料斗转移")
elif loc_state._feed_status == FeedStatus.FFeed:
print("----------------下料------------------")
loc_state.mould_vibrate_time=time.time()
loc_state._mould_frequency=app_set_config.frequencies[0]
loc_state._mould_vibrate_status=1
#上料斗重量
loc_state.initial_upper_weight=loc_state._upper_weight
#下料斗重量
loc_state.initial_lower_weight=loc_state._lower_weight
#需要的总重量
# loc_state._mould_need_weight=loc_state.current_artifact.BetonVolume*loc_state.density
if loc_state._mould_need_weight > loc_state.initial_upper_weight + loc_state.initial_lower_weight:
# 等待上料斗重量增加(多久不够报警可能出现F块不足的情况)
print('重量不够,需要增加')
return
if loc_state._mould_need_weight>loc_state.initial_lower_weight:
if self.state._upper_door_position != 'over_lower':
#是否需要等待上料斗下料,如果下料斗够重量,则不需要等待
return
else:
# 需要等待上料斗下料
# 最后一块进行尾数控制
# 最后一块F块前面多要0.25,0.3F块直接下料先多下0.3后续)
# loc_FWeight=0.3*loc_state.density
# loc_feed_weight=loc_state.need_total_weight-loc_state.initial_lower_weight-loc_FWeight
self.transfer_material_from_upper_to_lower(loc_state,loc_state.initial_upper_weight,loc_state.initial_lower_weight)
#完成了上料斗重量转移才进入下料斗
#测试返回
# loc_state._feed_status = FeedStatus.FFeed1
loc_state._feed_status = FeedStatus.FNone
# time.sleep(10)
return
elif loc_state._feed_status == FeedStatus.FFeed1:
#下料
# self._start_feeding_stage()
self.feeding_stage_one(loc_state)
print("下料1")
return
elif loc_state._feed_status == FeedStatus.FFeed2:
#上料
# self._start_feeding_stage()
self.feeding_stage_two(loc_state)
print("下料2")
return
elif loc_state._feed_status == FeedStatus.FFeed3:
#下料
# self._start_feeding_stage()
self.feeding_stage_three(loc_state)
print("下料3")
loc_state.initial_lower_weight=loc_state._lower_weight
self.feeding_stage(loc_state)
# if loc_state._mould_need_weight>loc_state.initial_lower_weight:
# self.transfer_material_from_upper_to_lower(loc_state,loc_state.initial_upper_weight,loc_state.initial_lower_weight)
# loc_state._feed_status = FeedStatus.FFeed1
# else:
# loc_state._feed_status = FeedStatus.FFeed1
return
elif loc_state._feed_status == FeedStatus.FFinished:
"""完成当前批次下料"""
print("当前批次下料完成,关闭出砼门")
if loc_state.overflow_detected=="浇筑满":
self.inverter_controller.control('stop')
loc_state._mould_vibrate_status=0
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
self.relay_controller.control_upper_close()
#更新数据库状态
self.artifact_bll.finish_artifact_task(loc_state.current_artifact.ArtifactID,loc_state._mould_finish_weight/loc_state.density)
loc_state._feed_status = FeedStatus.FCheckM
print("振捣完成")
print("关闭所有网络继电器")
self.relay_controller.close_all()
return
def _start_feeding_stage(self):
@ -177,31 +71,37 @@ class FeedingProcess:
"""target_upper_weight转移后剩下的上料斗重量"""
# 如果低于单次,全部卸掉
_max_lower_weight=app_set_config.max_lower_volume*self.state.density
_max_lower_weight=app_set_config.max_lower_volume*loc_state.density
# if (initial_lower_weight+feed_weight>_max_lower_weight):
feed_weight=_max_lower_weight-initial_lower_weight
target_upper_weight=initial_upper_weight-feed_weight
target_upper_weight = max(target_upper_weight, 0)
# 确保下料斗出砼门关闭
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
# self.relay_controller.control_lower_close()
# 确保下料斗出砼门关闭,同步关5秒
self.relay_controller.control_lower_close()
# 打开上料斗出砼门
# self.relay_controller.control_upper_open()
#一直打开3秒
self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'open')
time.sleep(3)
loc_state._upper_door_closed=False
# 等待物料流入下料斗,基于上料斗重量变化控制
import time
start_time = time.time()
# timeout = 30 # 30秒超时
while loc_state.running:
# self.relay_controller.control_upper_open_sync()
self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'close')
current_upper_weight = self.transmitter_controller.read_data(1)
# 如果无法读取重量,继续尝试
if current_upper_weight is None:
print("无法读取上料斗重量,继续尝试...")
time.sleep(1)
continue
loc_state._upper_weight=current_upper_weight
loc_state._upper_volume=round(loc_state._upper_weight/self.state.density,1)
print(f"上料斗当前重量: {current_upper_weight:.2f}kg")
# 如果达到目标重量,则关闭上料斗出砼门
@ -209,187 +109,59 @@ class FeedingProcess:
print(f"达到目标重量,当前重量: {current_upper_weight:.2f}kg")
print(f"花费时间 {time.time() - start_time:.2f}")
break
elif time.time() - start_time > 25: # 如果25秒后重量变化过小
weight_change = initial_upper_weight - current_upper_weight
if weight_change < 100: # 如果重量变化小于100kg
#需要增加报警处理
print("重量变化过小,可能存在堵塞")
time.sleep(1)
# 关闭上料斗出砼门
# time.sleep(1)
# self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'open')
# time.sleep(0.2)
loc_state._upper_door_closed=True
# 关闭上料斗出砼门d
self.relay_controller.control_upper_close()
#测试用
print("上料斗下料完成")
def wait_for_vehicle_alignment(self):
"""等待模具车对齐"""
print("等待模具车对齐...")
self.state.lower_feeding_stage = 4
import time
while self.state.lower_feeding_stage == 4 and self.state.running:
if self.state.vehicle_aligned:
print("模具车已对齐,开始下料")
self.state.lower_feeding_stage = 1
# self.feeding_stage_one()
break
time.sleep(app_set_config.alignment_check_interval)
def feeding_stage_one(self,loc_state):
def feeding_stage(self,loc_state):
"""第一阶段下料:下料斗向模具车下料(低速)"""
print("开始第一阶段下料:下料斗低速下料")
if self.is_first_flag:
# self.inverter_controller.set_frequency(app_set_config.frequencies[0])
# self.inverter_controller.control('start')
loc_state._mould_frequency=app_set_config.frequencies[0]
loc_state._mould_vibrate_status=1
print("开始下料")
# self.relay_controller.control
first_finish_weight=0
while True:
current_weight = loc_state._lower_weight
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
first_finish_weight=loc_state._mould_finish_weight
if current_weight<100:
#关5秒
self.relay_controller.control_lower_close()
break
# 确保上料斗出砼门关闭
# self.relay_controller.control(self.relay_controller.DOOR_UPPER_CLOSE, 'close')
# 打开下料斗出砼门
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
loc_cur_weight = loc_state._lower_weight
if loc_cur_weight is None:
#报警处理
print("无法获取初始重量,取消下料")
# self.finish_feeding_process()
return
loc_state.initial_lower_weight=loc_cur_weight
self.is_first_flag=False
time.sleep(1)
start_time = time.time()
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = loc_state._mould_need_weight/3
# or (time.time() - start_time) > 30
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFeed2
loc_state.lower_feeding_stage = 2
self.is_first_flag=True
return
else:
time.sleep(1)
def feeding_stage_two(self,loc_state):
"""第二阶段下料:下料斗向模具车下料(中速)"""
if self.is_first_flag:
print("开始第二阶段下料:下料斗中速下料")
# self.inverter_controller.set_frequency(app_set_config.frequencies[1])
# self.inverter_controller.control('start')
# 保持下料斗出砼门打开
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# 确保上料斗出砼门关闭
self.relay_controller.control_upper_close()
loc_state._mould_frequency=app_set_config.frequencies[1]
loc_state._mould_vibrate_status=1
# loc_cur_weight = self.transmitter_controller.read_data(2)
# if loc_cur_weight is None:
# #报警处理
# print("无法获取初始重量,取消下料")
# # self.finish_feeding_process()
# return
# loc_state.initial_lower_weight=loc_cur_weight
self.is_first_flag=False
start_time = time.time()
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = (loc_state._mould_need_weight/3)*2
# or (time.time() - start_time) > 30
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFeed3
loc_state.lower_feeding_stage = 3
self.is_first_flag=True
return
else:
time.sleep(1)
def feeding_stage_three(self,loc_state):
"""第三阶段下料:下料斗向模具车下料(高速)"""
if self.is_first_flag:
print("开始第三阶段下料:下料斗高速下料")
# self.inverter_controller.set_frequency(app_set_config.frequencies[2])
#打开上料斗出砼门
self.relay_controller.control_upper_open_sync(5)
while True:
loc_state._mould_frequency=app_set_config.frequencies[2]
# 保持下料斗出砼门打开
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# 确保上料斗出砼门关闭
self.relay_controller.control_upper_close()
self.is_first_flag=False
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = loc_state._mould_need_weight
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFinished
loc_state.lower_feeding_stage = 5
self.is_first_flag=True
return
else:
time.sleep(1)
if loc_state._upper_weight<3000:
#关5秒
self.relay_controller.control_upper_close()
break
loc_state.initial_lower_weight=loc_state.lower_weight
while True:
current_weight = loc_state._lower_weight
loc_state._mould_finish_weight=first_finish_weight+loc_state.initial_lower_weight-current_weight
if current_weight<100:
#关5秒
self.relay_controller.control_lower_close()
break
time.sleep(1)
def finish_current_batch(self):
"""完成当前批次下料"""
print("当前批次下料完成,关闭出砼门")
self.inverter_controller.control('stop')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_1, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_2, 'close')
# 增加三阶段下料轮次计数
self.state.lower_feeding_cycle += 1
# 检查是否完成两轮三阶段下料
if self.state.lower_feeding_cycle >= self.state.upper_feeding_max:
print("完成两轮三阶段下料5吨下料任务完成")
self.finish_feeding_process()
return
# 如果只完成一轮三阶段下料,进行第二次上料
print("第一轮三阶段下料完成,准备第二次上料")
# 上料斗第二次向下料斗下料
try:
self.transfer_material_from_upper_to_lower()
except Exception as e:
print(f"第二次上料失败: {e}")
print("停止下料流程")
self.finish_feeding_process() # 出现严重错误时结束整个流程
return
# 继续等待当前模具车对齐(不需要重新等待对齐,因为是同一辆模具车)
print("第二次上料完成,继续三阶段下料")
self.state.lower_feeding_stage = 1 # 直接进入第一阶段下料
self.feeding_stage_one() # 开始第二轮第一阶段下料
def finish_feeding_process(self):
"""完成整个下料流程"""
print("整个下料流程完成")
self.state.lower_feeding_stage = 0
self.state.lower_feeding_cycle = 0
self.state.upper_feeding_count = 0
# self.return_upper_door_to_default()
def return_upper_door_to_default(self):
"""上料斗回到默认位置(搅拌楼下接料位置)"""
print("上料斗回到默认位置")
self.relay_controller.control(self.relay_controller.UPPER_TO_JBL, 'open')
# self.relay_controller.control(self.relay_controller.UPPER_TO_JBL, 'open')
self.state._upper_door_position = 'default'

450
feeding/processbak_copy Normal file
View File

@ -0,0 +1,450 @@
from enum import IntEnum
from core.state import FeedStatus
from service.mould_service import MouldService
from busisness.blls import ArtifactBll
from busisness.models import ArtifactInfoModel,ArtifactInfo
import time
from datetime import datetime
from hardware.RFID.rfid_service import rfid_service
from config.settings import app_set_config
class FeedingProcess22:
def __init__(self, relay_controller, inverter_controller,
transmitter_controller, vision_detector,
camera_controller, state):
self.relay_controller = relay_controller
self.artifact_bll = ArtifactBll()
self.mould_service = MouldService()
self.inverter_controller = inverter_controller
self.transmitter_controller = transmitter_controller
self.vision_detector = vision_detector
self.camera_controller = camera_controller
self.state = state
self.state._feed_status = FeedStatus.FCheckM
#标志位用,是否是第一次运行
self.is_first_flag=True
#RFID服务
self.rfid_service=rfid_service()
# self.rfid_service.callback_signal.connect(self._rfid_callback)
self.rfid_flag_succ=False
self.rfid_data=''
# self.rfid_service.start_receiver(self._rfid_callback)
def _rfid_callback(self,status,data):
try:
if status==1:
#成功读取到RFID标签
#检查标识是否符号要求
if data:
loc_array=data.split(',')
if len(loc_array)==4:
if self.state.current_artifact is None or loc_array[0]!=self.state.current_artifact.MouldCode:
self.rfid_flag_succ=True
self.state.current_artifact={
'MouldCode':loc_array[0],
'BlockNumber':loc_array[1],
'SizeSpecification':loc_array[2],
'BetonVolume':float(loc_array[3])
}
print(f"RFID-生产模具车号:{loc_array[0]}")
else:
print("RFID-生产模具车号与当前模具车号一致")
else:
print("RFID标签格式错误")
print(f"成功读取到RFID标签:{data}")
else:
self.rfid_flag_succ=False
print("读取RFID标签失败")
except Exception as e:
print(f"RFID回调处理异常: {e}")
#读取失败
def start_feeding(self):
loc_state=self.state
loc_state._upper_weight=self.transmitter_controller.read_data(1)
loc_state._lower_weight=self.transmitter_controller.read_data(2)
loc_state._upper_volume=round(loc_state._upper_weight/self.state.density,1)
"""开始生产管片"""
if loc_state._feed_status == FeedStatus.FNone:
# loc_state._feed_status = FeedStatus.FCheckM
return
elif loc_state._feed_status == FeedStatus.FCheckM:
"""开始生产管片"""
print("检查盖板对齐,")
loc_state.lower_feeding_stage = 4
self.rfid_flag_succ=False
# if app_set_config.debug_feeding:
# loc_state._feed_status = FeedStatus.FApiCheck
if self.state.vehicle_aligned:
loc_state._feed_status = FeedStatus.FApiCheck
print("检查模车")
return
elif loc_state._feed_status == FeedStatus.FApiCheck:
print("————————————————生产已开始————————————————————")
# time.sleep(2)
#模拟数据
module_obj=ArtifactInfoModel()
module_obj.ArtifactID="GR2B13082624F"
module_obj.MouldCode="SHR2B2-4"
module_obj.BetonVolume=1.9
loc_modules=[module_obj]
# loc_modules =self.mould_service.get_not_pour_artifacts()
if loc_modules and loc_modules[0].ArtifactID :
# 取第一个未浇筑的管片
#后续放入队列处理
loc_module = loc_modules[0]
#API
loc_module.Source = 1
loc_module.BeginTime=datetime.now()
# self.artifact_bll.insert_artifact_task(loc_module)
loc_state.current_artifact = loc_module
loc_state._mould_need_weight=loc_module.BetonVolume*self.state.density
print(f"已获取到未浇筑的管片:{loc_module.MouldCode}")
# self.artifact_bll.finish_artifact_task(loc_state.current_artifact.ArtifactID,1.92)
loc_state._feed_status = FeedStatus.FCheckGB
else:
#未读取到AIP接口数据.
print("未获取到未浇筑的管片")
loc_artifacting_task=self.artifact_bll.get_artifacting_task()
if loc_artifacting_task:
loc_state.current_artifact = loc_artifacting_task
loc_state._mould_need_weight=loc_artifacting_task.BetonVolume*self.state.density
loc_state._feed_status = FeedStatus.FCheckGB
else:
loc_state.current_artifact = None
return
elif loc_state._feed_status == FeedStatus.FRFID:
print("检查RFID")
#RFID格式模具编号,分块号,尺寸规格,方量
while loc_state.running:
if self.rfid_flag_succ:
loc_state._feed_status = FeedStatus.FCheckGB
break
else:
time.sleep(1)
return
elif loc_state._feed_status == FeedStatus.FCheckGB:
# print("检查盖板对齐,")
# time.sleep(5)
loc_state._feed_status = FeedStatus.FUpperToLower
#计算本次生产需要的总重量
print(f"本次生产需要的总重量:{self.state._mould_need_weight}")
return
elif loc_state._feed_status == FeedStatus.FUpperToLower:
print("上料斗向下料斗转移")
#上料斗重量
loc_state.initial_upper_weight=loc_state._upper_weight
#下料斗重量
loc_state.initial_lower_weight=loc_state._lower_weight
#需要的总重量
# loc_state._mould_need_weight=loc_state.current_artifact.BetonVolume*loc_state.density
if loc_state._mould_need_weight > loc_state.initial_upper_weight + loc_state.initial_lower_weight:
# 等待上料斗重量增加(多久不够报警可能出现F块不足的情况)
print('重量不够,需要增加')
return
if loc_state._mould_need_weight>loc_state.initial_lower_weight:
if self.state._upper_door_position != 'over_lower':
#是否需要等待上料斗下料,如果下料斗够重量,则不需要等待
return
else:
# 需要等待上料斗下料
# 最后一块进行尾数控制
# 最后一块F块前面多要0.25,0.3F块直接下料先多下0.3后续)
# loc_FWeight=0.3*loc_state.density
# loc_feed_weight=loc_state.need_total_weight-loc_state.initial_lower_weight-loc_FWeight
self.transfer_material_from_upper_to_lower(loc_state,loc_state.initial_upper_weight,loc_state.initial_lower_weight)
#完成了上料斗重量转移才进入下料斗
#测试返回
loc_state._feed_status = FeedStatus.FFeed1
# loc_state._feed_status = FeedStatus.FNone
else:
loc_state._feed_status = FeedStatus.FFeed1
# time.sleep(10)
return
elif loc_state._feed_status == FeedStatus.FFeed1:
#下料
# self._start_feeding_stage()
self.feeding_stage_one(loc_state)
print("下料1")
return
elif loc_state._feed_status == FeedStatus.FFeed2:
#上料
# self._start_feeding_stage()
self.feeding_stage_two(loc_state)
print("下料2")
return
elif loc_state._feed_status == FeedStatus.FFeed3:
#下料
# self._start_feeding_stage()
self.feeding_stage_three(loc_state)
print("下料3")
return
elif loc_state._feed_status == FeedStatus.FFinished:
"""完成当前批次下料"""
print("当前批次下料完成,关闭出砼门")
if loc_state.overflow_detected=="浇筑满":
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'close')
# self.relay_controller.control_upper_close()
#更新数据库状态
# self.artifact_bll.finish_artifact_task(loc_state.current_artifact.ArtifactID,loc_state._mould_finish_weight/loc_state.density)
print("浇筑完成")
# loc_state._feed_status = FeedStatus.FCheckM
# if loc_state.mould_vibrate_time>0:
# while True:
# if loc_state.mould_vibrate_time-time.time()>=5*60:
# self.inverter_controller.control('stop')
# loc_state._mould_vibrate_status=0
# break
# time.sleep(1)
print("振捣完成")
return
def _start_feeding_stage(self):
"""启动指定下料阶段"""
"""开始分步下料"""
print("开始分步下料过程")
self.transfer_material_from_upper_to_lower()
def transfer_material_from_upper_to_lower(self,loc_state,initial_upper_weight,initial_lower_weight):
"""target_upper_weight转移后剩下的上料斗重量"""
# 如果低于单次,全部卸掉
_max_lower_weight=app_set_config.max_lower_volume*loc_state.density
# if (initial_lower_weight+feed_weight>_max_lower_weight):
feed_weight=_max_lower_weight-initial_lower_weight
target_upper_weight=initial_upper_weight-feed_weight
target_upper_weight = max(target_upper_weight, 0)
# 确保下料斗出砼门关闭
self.relay_controller.control_lower_close()
# 打开上料斗出砼门
# self.relay_controller.control_upper_open()
self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'open')
time.sleep(3)
loc_state._upper_door_closed=False
# 等待物料流入下料斗,基于上料斗重量变化控制
start_time = time.time()
# timeout = 30 # 30秒超时
while loc_state.running:
# self.relay_controller.control_upper_open_sync()
self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'close')
current_upper_weight = self.transmitter_controller.read_data(1)
# 如果无法读取重量,继续尝试
if current_upper_weight is None:
print("无法读取上料斗重量,继续尝试...")
time.sleep(1)
continue
loc_state._upper_weight=current_upper_weight
loc_state._upper_volume=round(loc_state._upper_weight/self.state.density,1)
print(f"上料斗当前重量: {current_upper_weight:.2f}kg")
# 如果达到目标重量,则关闭上料斗出砼门
if current_upper_weight <= target_upper_weight + 50: # 允许50kg的误差范围
print(f"达到目标重量,当前重量: {current_upper_weight:.2f}kg")
print(f"花费时间 {time.time() - start_time:.2f}秒")
break
elif time.time() - start_time > 25: # 如果25秒后重量变化过小
weight_change = initial_upper_weight - current_upper_weight
if weight_change < 100: # 如果重量变化小于100kg
#需要增加报警处理
print("重量变化过小,可能存在堵塞")
time.sleep(1)
self.relay_controller.control(self.relay_controller.DOOR_UPPER_OPEN, 'open')
time.sleep(0.2)
loc_state._upper_door_closed=True
# 关闭上料斗出砼门
self.relay_controller.control_upper_close()
#测试用
print("上料斗下料完成")
def wait_for_vehicle_alignment(self):
"""等待模具车对齐"""
print("等待模具车对齐...")
self.state.lower_feeding_stage = 4
import time
while self.state.lower_feeding_stage == 4 and self.state.running:
if self.state.vehicle_aligned:
print("模具车已对齐,开始下料")
self.state.lower_feeding_stage = 1
# self.feeding_stage_one()
break
time.sleep(app_set_config.alignment_check_interval)
def feeding_stage_one(self,loc_state):
"""第一阶段下料:下料斗向模具车下料(低速)"""
print("开始第一阶段下料:下料斗低速下料")
if self.is_first_flag:
# self.inverter_controller.set_frequency(app_set_config.frequencies[0])
# self.inverter_controller.control('start')
loc_state.mould_vibrate_time=time()
loc_state._mould_frequency=app_set_config.frequencies[0]
loc_state._mould_vibrate_status=1
# 确保上料斗出砼门关闭
# self.relay_controller.control(self.relay_controller.DOOR_UPPER_CLOSE, 'close')
# 打开下料斗出砼门
self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
loc_cur_weight = loc_state._lower_weight
if loc_cur_weight is None:
#报警处理
print("无法获取初始重量,取消下料")
# self.finish_feeding_process()
return
loc_state.initial_lower_weight=loc_cur_weight
self.is_first_flag=False
start_time = time.time()
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = loc_state._mould_need_weight/3
# or (time.time() - start_time) > 30
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFeed2
loc_state.lower_feeding_stage = 2
self.is_first_flag=True
return
else:
time.sleep(1)
def feeding_stage_two(self,loc_state):
"""第二阶段下料:下料斗向模具车下料(中速)"""
if self.is_first_flag:
print("开始第二阶段下料:下料斗中速下料")
# self.inverter_controller.set_frequency(app_set_config.frequencies[1])
# self.inverter_controller.control('start')
# 保持下料斗出砼门打开
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# 确保上料斗出砼门关闭
self.relay_controller.control_upper_close()
loc_state._mould_frequency=app_set_config.frequencies[1]
loc_state._mould_vibrate_status=1
# loc_cur_weight = self.transmitter_controller.read_data(2)
# if loc_cur_weight is None:
# #报警处理
# print("无法获取初始重量,取消下料")
# # self.finish_feeding_process()
# return
# loc_state.initial_lower_weight=loc_cur_weight
self.is_first_flag=False
start_time = time.time()
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = (loc_state._mould_need_weight/3)*2
# or (time.time() - start_time) > 30
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFeed3
loc_state.lower_feeding_stage = 3
self.is_first_flag=True
return
else:
time.sleep(1)
def feeding_stage_three(self,loc_state):
"""第三阶段下料:下料斗向模具车下料(高速)"""
if self.is_first_flag:
print("开始第三阶段下料:下料斗高速下料")
# self.inverter_controller.set_frequency(app_set_config.frequencies[2])
# self.inverter_controller.control('start')
loc_state._mould_frequency=app_set_config.frequencies[2]
# 保持下料斗出砼门打开
# self.relay_controller.control(self.relay_controller.DOOR_LOWER_OPEN, 'open')
# 确保上料斗出砼门关闭
self.relay_controller.control_upper_close()
self.is_first_flag=False
current_weight = loc_state._lower_weight
if current_weight is None:
#报警处理
print("无法获取当前重量,取消下料")
# self.finish_feeding_process()
return
loc_state._mould_finish_weight=loc_state.initial_lower_weight-current_weight
target_weight = loc_state._mould_need_weight
if (current_weight is not None and loc_state._mould_finish_weight >= target_weight):
loc_state._feed_status = FeedStatus.FFinished
loc_state.lower_feeding_stage = 5
self.is_first_flag=True
return
else:
time.sleep(1)
def finish_current_batch(self):
"""完成当前批次下料"""
print("当前批次下料完成,关闭出砼门")
# self.inverter_controller.control('stop')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_1, 'close')
self.relay_controller.control(self.relay_controller.DOOR_LOWER_2, 'close')
# 增加三阶段下料轮次计数
self.state.lower_feeding_cycle += 1
# 检查是否完成两轮三阶段下料
if self.state.lower_feeding_cycle >= self.state.upper_feeding_max:
print("完成两轮三阶段下料5吨下料任务完成")
self.finish_feeding_process()
return
# 如果只完成一轮三阶段下料,进行第二次上料
print("第一轮三阶段下料完成,准备第二次上料")
# 上料斗第二次向下料斗下料
try:
self.transfer_material_from_upper_to_lower()
except Exception as e:
print(f"第二次上料失败: {e}")
print("停止下料流程")
self.finish_feeding_process() # 出现严重错误时结束整个流程
return
# 继续等待当前模具车对齐(不需要重新等待对齐,因为是同一辆模具车)
print("第二次上料完成,继续三阶段下料")
self.state.lower_feeding_stage = 1 # 直接进入第一阶段下料
self.feeding_stage_one() # 开始第二轮第一阶段下料
def finish_feeding_process(self):
"""完成整个下料流程"""
print("整个下料流程完成")
self.state.lower_feeding_stage = 0
self.state.lower_feeding_cycle = 0
self.state.upper_feeding_count = 0
# self.return_upper_door_to_default()
def return_upper_door_to_default(self):
"""上料斗回到默认位置(搅拌楼下接料位置)"""
print("上料斗回到默认位置")
self.relay_controller.control(self.relay_controller.UPPER_TO_JBL, 'open')
self.state._upper_door_position = 'default'