#!/usr/bin/env python # -*- coding: utf-8 -*- import socket import binascii import time import threading import struct from pymodbus.client import ModbusTcpClient from pymodbus.exceptions import ModbusException class FeedingControlSystem: def __init__(self, relay_host='192.168.0.18', relay_port=50000): # 网络继电器配置 (作为Modbus TCP转RS485网关) self.relay_host = relay_host self.relay_port = relay_port # 创建网络继电器的Modbus TCP客户端 self.relay_modbus_client = ModbusTcpClient(relay_host, port=relay_port) # 定义继电器DO端口映射 self.DOOR_UPPER = 'door_upper' # DO0 - 上料斗滑动门 self.DOOR_LOWER_1 = 'door_lower_1' # DO1 - 出砼门控制1 self.DOOR_LOWER_2 = 'door_lower_2' # DO2 - 出砼门控制2 self.BREAK_ARCH_UPPER = 'break_arch_upper' # DO3 - 上料斗破拱 self.BREAK_ARCH_LOWER = 'break_arch_lower' # DO4 - 下料斗破拱 # 继电器控制命令 (原始Socket方式) self.relay_commands = { self.DOOR_UPPER: {'open': '00000000000601050000FF00', 'close': '000000000006010500000000'}, self.DOOR_LOWER_1: {'open': '00000000000601050001FF00', 'close': '000000000006010500010000'}, self.DOOR_LOWER_2: {'open': '00000000000601050002FF00', 'close': '000000000006010500020000'}, self.BREAK_ARCH_UPPER: {'open': '00000000000601050003FF00', 'close': '000000000006010500030000'}, self.BREAK_ARCH_LOWER: {'open': '00000000000601050004FF00', 'close': '000000000006010500040000'} } # 读取状态命令 self.read_status_command = '000000000006010100000008' # 设备位映射 self.device_bit_map = { self.DOOR_UPPER: 0, self.DOOR_LOWER_1: 1, self.DOOR_LOWER_2: 2, self.BREAK_ARCH_UPPER: 3, self.BREAK_ARCH_LOWER: 4 } # 变频器配置 (通过网络继电器转发) self.inverter_config = { 'slave_id': 1, # 变频器从机地址 'frequency_register': 0x01, # 频率设置寄存器 'start_register': 0x00, # 启动命令寄存器 'stop_register': 0x01 # 停止命令寄存器 } # 变送器配置 (通过网络继电器转发) self.transmitter_config = { 1: { # 上料斗变送器 'slave_id': 1, # 从机地址 'weight_register': 0x00, # 重量寄存器地址 'register_count': 2 # 读取寄存器数量 }, 2: { # 下料斗变送器 'slave_id': 2, # 从机地址 'weight_register': 0x00, # 重量寄存器地址 'register_count': 2 # 读取寄存器数量 } } # 系统状态 self._running = False self._monitor_thread = None self.min_required_weight = 50 # 最小需要重量(kg) # 状态标志 self.upper_door_position = 'default' # default, to_mixer, returning self.lower_feeding_stage = 0 # 0:未下料, 1:第一阶段, 2:第二阶段, 3:第三阶段 self.last_upper_weight = 0 self.last_lower_weight = 0 self.last_weight_time = time.time() # 添加权重读取错误计数 self.upper_weight_error_count = 0 self.lower_weight_error_count = 0 self.max_error_count = 3 # 最大连续错误次数 def send_relay_command(self, command_hex): """发送命令到网络继电器 (原始Socket方式)""" try: byte_data = binascii.unhexlify(command_hex) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.connect((self.relay_host, self.relay_port)) sock.send(byte_data) response = sock.recv(1024) print(f"收到继电器响应: {binascii.hexlify(response)}") return response except Exception as e: print(f"继电器通信错误: {e}") return None def get_relay_status(self): """获取继电器状态""" response = self.send_relay_command(self.read_status_command) status_dict = {} if response and len(response) >= 10: status_byte = response[9] status_bin = f"{status_byte:08b}"[::-1] for key, bit_index in self.device_bit_map.items(): status_dict[key] = status_bin[bit_index] == '1' else: print("读取继电器状态失败或响应无效") return status_dict def control_relay(self, device, action): """控制继电器开关""" if device in self.relay_commands and action in self.relay_commands[device]: print(f"控制继电器 {device} {action}") self.send_relay_command(self.relay_commands[device][action]) time.sleep(0.1) else: print(f"无效的继电器设备或动作: {device}, {action}") def read_transmitter_data_via_relay(self, transmitter_id): """通过网络继电器读取变送器数据 (Modbus TCP转RS485)""" try: # 获取变送器配置 if transmitter_id not in self.transmitter_config: print(f"无效的变送器ID: {transmitter_id}") return None config = self.transmitter_config[transmitter_id] # 连接网络继电器的Modbus服务 if not self.relay_modbus_client.connect(): print("无法连接到网络继电器Modbus服务") return None # 通过网络继电器读取变送器数据 result = self.relay_modbus_client.read_holding_registers( address=config['weight_register'], count=config['register_count'], slave=config['slave_id'] ) if isinstance(result, Exception): print(f"读取变送器 {transmitter_id} 数据失败: {result}") return None # 解析重量数据 (假设是32位浮点数，由两个16位寄存器组成) if config['register_count'] == 2: # 组合两个寄存器为32位浮点数 (大端序) weight_bytes = struct.pack('>HH', result.registers[0], result.registers[1]) weight = struct.unpack('>f', weight_bytes)[0] elif config['register_count'] == 1: # 单个寄存器直接作为整数 weight = float(result.registers[0]) else: print(f"不支持的寄存器数量: {config['register_count']}") return None print(f"变送器 {transmitter_id} 读取重量: {weight}kg") # 重置错误计数 if transmitter_id == 1: self.upper_weight_error_count = 0 else: self.lower_weight_error_count = 0 return weight except ModbusException as e: print(f"变送器 {transmitter_id} Modbus通信错误: {e}") return None except Exception as e: print(f"变送器 {transmitter_id} 数据解析错误: {e}") return None finally: self.relay_modbus_client.close() def set_inverter_frequency_via_relay(self, frequency): """通过网络继电器设置变频器频率""" try: # 连接网络继电器的Modbus服务 if not self.relay_modbus_client.connect(): print("无法连接到网络继电器Modbus服务") return False # 写入频率值 (假设频率值需要转换为Hz*10) result = self.relay_modbus_client.write_register( self.inverter_config['frequency_register'], int(frequency * 10), slave=self.inverter_config['slave_id'] ) if isinstance(result, Exception): print(f"设置变频器频率失败: {result}") return False print(f"设置变频器频率为 {frequency}Hz") return True except ModbusException as e: print(f"变频器Modbus通信错误: {e}") return False finally: self.relay_modbus_client.close() def control_inverter_via_relay(self, action): """通过网络继电器控制变频器启停""" try: if not self.relay_modbus_client.connect(): print("无法连接到网络继电器Modbus服务") return False if action == 'start': result = self.relay_modbus_client.write_register( self.inverter_config['start_register'], 1, slave=self.inverter_config['slave_id'] ) print("启动变频器") elif action == 'stop': result = self.relay_modbus_client.write_register( self.inverter_config['stop_register'], 1, slave=self.inverter_config['slave_id'] ) print("停止变频器") else: print(f"无效的变频器操作: {action}") return False if isinstance(result, Exception): print(f"控制变频器失败: {result}") return False return True except ModbusException as e: print(f"变频器控制错误: {e}") return False finally: self.relay_modbus_client.close() def read_transmitter_data(self, transmitter_id): """读取变送器数据 (按需读取，仅在下料时)""" return self.read_transmitter_data_via_relay(transmitter_id) def set_inverter_frequency(self, frequency): """设置变频器频率""" return self.set_inverter_frequency_via_relay(frequency) def control_inverter(self, action): """控制变频器启停""" return self.control_inverter_via_relay(action) def check_upper_material_request(self): """检查是否需要向上料斗要料""" current_weight = self.read_transmitter_data(1) # 如果读取失败，增加错误计数 if current_weight is None: self.upper_weight_error_count += 1 print(f"上料斗重量读取失败，错误计数: {self.upper_weight_error_count}") # 如果连续错误次数超过阈值，触发报警但不自动要料 if self.upper_weight_error_count >= self.max_error_count: print("警告：上料斗重量传感器连续读取失败，请检查设备连接") return False # 读取失败时不触发要料 # 重置错误计数 self.upper_weight_error_count = 0 if current_weight < self.min_required_weight: print("上料斗重量不足，通知搅拌楼要料") self.move_upper_door_to_mixer() return True return False def move_upper_door_to_mixer(self): """移动上料斗到搅拌楼出砼口""" print("移动上料斗到搅拌楼出砼口") self.control_relay(self.DOOR_UPPER, 'open') self.upper_door_position = 'to_mixer' def return_upper_door(self): """返回上料斗""" print("上料斗返回原位") self.control_relay(self.DOOR_UPPER, 'close') self.upper_door_position = 'default' def start_lower_feeding(self): """开始下料过程""" if self.lower_feeding_stage != 0: print("下料已在进行中") return print("开始三阶段下料过程") self.lower_feeding_stage = 1 self.feeding_stage_one() def feeding_stage_one(self): """第一阶段下料""" print("开始第一阶段下料 (1/3)") # 设置变频器频率 (假设第一阶段频率为30Hz) self.set_inverter_frequency(30.0) self.control_inverter('start') # 控制出砼门 self.control_relay(self.DOOR_LOWER_1, 'open') self.control_relay(self.DOOR_LOWER_2, 'open') # 监控下料过程 start_time = time.time() initial_weight = self.read_transmitter_data(2) # 如果初始重量读取失败，使用默认值或取消操作 if initial_weight is None: print("无法获取初始重量，取消下料操作") self.finish_feeding() return target_weight = initial_weight + 33.3 # 假设每阶段下料1/3 while self.lower_feeding_stage == 1: current_weight = self.read_transmitter_data(2) # 如果读取失败，增加错误计数并检查是否超过阈值 if current_weight is None: self.lower_weight_error_count += 1 if self.lower_weight_error_count >= self.max_error_count: print("下料斗重量传感器连续读取失败，停止下料") self.finish_feeding() return else: self.lower_weight_error_count = 0 # 重置错误计数 # 检查是否达到目标重量或超时 if (current_weight is not None and current_weight >= target_weight) or (time.time() - start_time) > 30: self.lower_feeding_stage = 2 self.feeding_stage_two() break time.sleep(2) # 每2秒读取一次 def feeding_stage_two(self): """第二阶段下料""" print("开始第二阶段下料 (2/3)") # 调整变频器频率 (假设第二阶段频率为40Hz) self.set_inverter_frequency(40.0) start_time = time.time() initial_weight = self.read_transmitter_data(2) # 如果初始重量读取失败，使用默认值或取消操作 if initial_weight is None: print("无法获取初始重量，取消下料操作") self.finish_feeding() return target_weight = initial_weight + 33.3 while self.lower_feeding_stage == 2: current_weight = self.read_transmitter_data(2) # 如果读取失败，增加错误计数并检查是否超过阈值 if current_weight is None: self.lower_weight_error_count += 1 if self.lower_weight_error_count >= self.max_error_count: print("下料斗重量传感器连续读取失败，停止下料") self.finish_feeding() return else: self.lower_weight_error_count = 0 # 重置错误计数 if (current_weight is not None and current_weight >= target_weight) or (time.time() - start_time) > 30: self.lower_feeding_stage = 3 self.feeding_stage_three() break time.sleep(2) # 每2秒读取一次 def feeding_stage_three(self): """第三阶段下料""" print("开始第三阶段下料 (3/3)") # 调整变频器频率 (假设第三阶段频率为50Hz) self.set_inverter_frequency(50.0) start_time = time.time() initial_weight = self.read_transmitter_data(2) # 如果初始重量读取失败，使用默认值或取消操作 if initial_weight is None: print("无法获取初始重量，取消下料操作") self.finish_feeding() return target_weight = initial_weight + 33.3 while self.lower_feeding_stage == 3: current_weight = self.read_transmitter_data(2) # 如果读取失败，增加错误计数并检查是否超过阈值 if current_weight is None: self.lower_weight_error_count += 1 if self.lower_weight_error_count >= self.max_error_count: print("下料斗重量传感器连续读取失败，停止下料") self.finish_feeding() return else: self.lower_weight_error_count = 0 # 重置错误计数 if (current_weight is not None and current_weight >= target_weight) or (time.time() - start_time) > 30: self.lower_feeding_stage = 0 self.finish_feeding() break time.sleep(2) # 每2秒读取一次 def finish_feeding(self): """完成下料""" print("下料完成，关闭出砼门") self.control_inverter('stop') self.control_relay(self.DOOR_LOWER_1, 'close') self.control_relay(self.DOOR_LOWER_2, 'close') def handle_overflow_control(self, overflow_detected, door_opening_large): """处理溢料控制""" if overflow_detected and door_opening_large: print("检测到溢料且出砼门开口较大，调小出砼门") # 通过重复开关控制角度 self.control_relay(self.DOOR_LOWER_1, 'close') time.sleep(0.1) self.control_relay(self.DOOR_LOWER_1, 'open') time.sleep(0.1) def check_arch_blocking(self): """检查是否需要破拱 (按需读取)""" current_time = time.time() # 检查上料斗 (按需读取) upper_weight = self.read_transmitter_data(1) if upper_weight is not None: # 只有在成功读取重量时才检查堵塞 if (abs(upper_weight - self.last_upper_weight) < 0.1) and \ (current_time - self.last_weight_time) > 10: print("上料斗可能堵塞，启动破拱") self.control_relay(self.BREAK_ARCH_UPPER, 'open') time.sleep(2) self.control_relay(self.BREAK_ARCH_UPPER, 'close') # 检查下料斗 (按需读取) lower_weight = self.read_transmitter_data(2) if lower_weight is not None: # 只有在成功读取重量时才检查堵塞 if (abs(lower_weight - self.last_lower_weight) < 0.1) and \ (current_time - self.last_weight_time) > 10: print("下料斗可能堵塞，启动破拱") self.control_relay(self.BREAK_ARCH_LOWER, 'open') time.sleep(2) self.control_relay(self.BREAK_ARCH_LOWER, 'close') # 更新重量记录（只有在成功读取时才更新） if upper_weight is not None: self.last_upper_weight = upper_weight if lower_weight is not None: self.last_lower_weight = lower_weight if upper_weight is not None or lower_weight is not None: self.last_weight_time = current_time def monitor_system(self): """监控系统状态""" while self._running: try: # 检查是否需要要料 self.check_upper_material_request() # 检查破拱 (按需读取) self.check_arch_blocking() time.sleep(1) except Exception as e: print(f"监控线程错误: {e}") def start(self): """启动系统""" if self._running: print("系统已在运行") return print("启动控制系统") self._running = True self._monitor_thread = threading.Thread(target=self.monitor_system, daemon=True) self._monitor_thread.start() def stop(self): """停止系统""" if not self._running: print("系统未在运行") return print("停止控制系统") self._running = False if self._monitor_thread is not None: self._monitor_thread.join() print("控制系统已停止") # 使用示例 if __name__ == "__main__": system = FeedingControlSystem(relay_host='192.168.0.18', relay_port=50000) # 启动系统监控 system.start() # 模拟操作 try: # 检查是否需要要料 system.check_upper_material_request() # 开始下料 system.start_lower_feeding() # 运行一段时间 time.sleep(60) except KeyboardInterrupt: print("程序被中断") finally: system.stop()