diff --git a/hvs_service2/config.py b/hvs_service2/config.py new file mode 100644 index 0000000..7635e7b --- /dev/null +++ b/hvs_service2/config.py @@ -0,0 +1,42 @@ +import json + +# MQTT配置 +BROKER = "127.0.0.1" +MQTT_PORT = 1883 +USER = "test" +PWD = "test" + +# Modbus配置 +TIMEOUT = 0.5 +BYTESIZE = 8 +PARITY = 'N' +STOPBITS = 1 + +# 读取间隔(秒) +READ_INTERVAL = 1 + +# MQTT主题 +DEVICE_STATUS_TOPIC = "device/status" +DEVICE_CONTROL_TOPIC = "device/control" +DEVICE_HVS_CONTROL_TOPIC = "device/hvs/control" +DEVICE_API_TOPIC = "api/devices/hvs/response" +SERVICE_STATUS_TOPIC = "service/status" + +# 寄存器配置 - 根据实际设备修改 +INPUT_REGISTERS = { + "start_address": 0, + "count": 5 +} + +COIL_REGISTERS = { + "start_address": 0, + "count": 10 +} + +CONFIG_FILE = "/home/admin/.config/cpy/hvs.json" + +try: + with open(CONFIG_FILE, "r") as f: + config = json.load(f) +except FileNotFoundError: + config = {} diff --git a/hvs_service2/hvs.py b/hvs_service2/hvs.py new file mode 100644 index 0000000..e48dd5f --- /dev/null +++ b/hvs_service2/hvs.py @@ -0,0 +1,281 @@ +import time +import json +import logging +from datetime import datetime +from concurrent.futures import ThreadPoolExecutor +from modbus_client import ModbusClient +from mqtt_client import mqtt_client +from config import * +from tcp_io_module import TcpIoModule +import threading +import socket + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +UDP_PORT = 62000 + +class HvService: + def __init__(self): + # 记录服务启动时间 + self.start_time = time.time() + + # 创建线程池用于异步发布消息 + self.executor = ThreadPoolExecutor(max_workers=5) + + # 初始化Modbus客户端 + self.modbus_client = ModbusClient() + + # 初始化MQTT客户端 + self.mqtt_client = mqtt_client + + # 设备列表 + self.hvs_devices = [] + + # 上次发布服务状态的时间 + self.last_service_status_time = 0 + + self.xray_on = [False, False] + self.last_hvs_update_time = 0 + + self.exit_flag = False + self.loop_thread = None + + # UDP socket,监听62000端口 + self.udp_socket = None + self.udp_thread = None + + def handle_hvs_control_message(self, topic, payload): + """异步处理设备控制消息""" + if topic == DEVICE_HVS_CONTROL_TOPIC: + print(f"handle_hvs_control_message: {topic, payload}") + self.executor.submit(self._process_hvs_control_message, payload) + elif topic == DEVICE_CONTROL_TOPIC: + dev_code = payload.get("device_code") + if "HVS" in dev_code : + print(f"handle_hvs_control_message: {topic, payload}") + dev_id = int(dev_code.split('#')[0]) + command = payload.get("command") + if command == "set_status": + value = 1 if payload.get('status') else 0 + newpayload = { + "command" : 'hv_switch', + 'device_id' : dev_id, + 'device_code' : dev_code, + 'value' : value + } + self.executor.submit(self._process_hvs_control_message, newpayload) + + def _process_hvs_control_message(self, payload): + """处理设备控制消息""" + try: + logger.info(f"接收到控制消息: {payload}") + command = payload.get("command") + value = payload.get("value") + device_code = payload.get("device_code") + slave_id = payload.get("device_id") + if not device_code: + logger.error("控制消息缺少device_code") + return + + # 使用设备管理器控制设备 + if command == "hv_switch": + if value == 1: + self.modbus_client.write_coil(slave_id, 0x00, True) + else: + self.modbus_client.write_coil(slave_id, 0x00, False) + + except Exception as e: + logger.error(f"处理控制消息失败: {e}") + + def start(self): + # 创建线程 + self.loop_thread = threading.Thread(target=self.loop) + self.loop_thread.daemon = True + self.loop_thread.start() + + # 启动UDP监听线程 + self.udp_thread = threading.Thread(target=self._udp_listen) + self.udp_thread.daemon = True + self.udp_thread.start() + + def stop(self): + if not self.loop_thread: + return + """停止服务""" + self.exit_flag = True + self.loop_thread.join() + if self.udp_thread: + self.udp_thread.join() + self.executor.shutdown(wait=True) + + def _udp_listen(self): + """UDP监听线程,监听62000端口""" + self.udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + self.udp_socket.bind(("0.0.0.0", UDP_PORT)) + self.udp_socket.settimeout(1.0) + logger.info(f"UDP监听已启动,端口: {UDP_PORT}") + while not self.exit_flag: + try: + data, addr = self.udp_socket.recvfrom(4096) + self.handle_udp_message(data, addr) + except socket.timeout: + continue + except OSError as e: + if not self.exit_flag: + logger.error(f"UDP接收数据失败: {e}") + self.udp_socket.close() + + def handle_udp_message(self, data, addr): + """处理UDP消息(留空,由外部实现)""" + try: + data = json.loads(data.decode()) + logger.info(f"收到UDP消息: {data}") + except json.JSONDecodeError: + logger.error("UDP消息不是JSON格式") + + def loop(self): + """启动服务""" + try: + # 连接Modbus + if not self.modbus_client.connect(): + logger.error("Modbus连接失败,程序退出") + return + print("Modbus连接成功") + + # 订阅MQTT主题 + self.mqtt_client.subscribe(DEVICE_CONTROL_TOPIC, self.handle_hvs_control_message) + self.mqtt_client.subscribe(DEVICE_HVS_CONTROL_TOPIC, self.handle_hvs_control_message) + + while not self.mqtt_client.is_connected: + time.sleep(1) + logger.info("waiting for mqtt conn...") + + logger.info("Modbus和MQTT连接成功,开始定时读取和发布数据...") + + self.hvs_devices = config.get("devices", []) + + if not self.hvs_devices or len(self.hvs_devices) == 0: + logger.error("未找到HVS设备,程序退出") + return + + logger.info(f"找到 {len(self.hvs_devices)} 个HVS设备") + + logger.info(f"hvs_devices: {json.dumps(self.hvs_devices, ensure_ascii=False)}") + + # 主循环 + while self.exit_flag == False: + # 计算当前时间 + current_time = time.time() + + # 定期发布服务状态 (每10秒) + if current_time - self.last_service_status_time >= 3: + self._publish_service_status(current_time) + # continue + # 读取并发布所有HVS设备数据 + self.read_and_publish_devices_data() + + # 等待指定间隔 + time.sleep(READ_INTERVAL) + + except KeyboardInterrupt: + logger.info("程序收到中断信号,正在退出...") + finally: + # 清理资源 + self.modbus_client.disconnect() + logger.info("程序已退出") + + def _publish_service_status(self, current_time): + """发布服务状态""" + # 计算运行时间 + running_time = current_time - self.start_time + + # 准备服务状态消息 + service_message = { + "service_name": "modbus_service", + "status": { + "available": True, + "running_time": running_time + } + } + + # 发布消息 + self.mqtt_client.publish(SERVICE_STATUS_TOPIC, service_message) + logger.debug(f"成功发布服务状态到 {SERVICE_STATUS_TOPIC}: {service_message}") + self.last_service_status_time = current_time + + def read_and_publish_devices_data(self): + """读取并发布所有设备数据""" + # 确保Modbus连接正常 + if not self.modbus_client._ensure_connection(): + logger.error(f"无法连接到Modbus设备,跳过读取设备 {hvs_device.get('code')}") + return + + for hvs_device in self.hvs_devices: + try: + slave_id = int(hvs_device.get('address')) + logger.info(f"开始读取设备 {hvs_device.get('code')} (从站ID: {slave_id}) 数据") + + + # 读取输入寄存器 + input_regs = self.modbus_client.read_input_registers( + slave_id=slave_id, + address=INPUT_REGISTERS["start_address"], + count=INPUT_REGISTERS["count"] + ) + if input_regs is None: + hvs_device["error_count"] = hvs_device.get("error_count", 10) + 1 + else: + hvs_device["error_count"] = 0 + + # 短暂延迟,避免总线冲突 + time.sleep(0.1) + + # 读取线圈 + coils = self.modbus_client.read_coils( + slave_id=slave_id, + address=COIL_REGISTERS["start_address"], + count=COIL_REGISTERS["count"] + ) + if coils is None: + hvs_device["error_count"] = hvs_device.get("error_count", 10) + 1 + else: + hvs_device["error_count"] = 0 + + if coils is not None: + # print("coils:", coils) + if coils[2]: + self.xray_on[slave_id - 1] = True + else: + self.xray_on[slave_id - 1] = False + # print(f"slave_id: {slave_id}, xray_on: {self.xray_on[slave_id - 1]}") + self.last_hvs_update_time = time.time() + + # 设备间添加延迟,避免总线冲突 + time.sleep(0.1) + + # 准备发布的数据 + + data = { + "device_id": hvs_device.get('id'), + "device_code": hvs_device.get('code'), + "timestamp": datetime.now().isoformat(), + "status": { + "online": hvs_device.get("error_count", 10) < 5, + "voltage": input_regs[0] / 100.0 if input_regs and len(input_regs) > 0 else None, + "current": input_regs[1] / 1000.0 if input_regs and len(input_regs) > 1 else None, + "current_filament": input_regs[2] / 1000.0 if input_regs and len(input_regs) > 2 else None, + "internal_temperature": input_regs[3] / 100.0 if input_regs and len(input_regs) > 3 else None, + "fault_status": input_regs[4] if input_regs and len(input_regs) > 4 else None, + "switch_status": coils[0] if coils and len(coils) > 0 else None, + "xray_status": coils[2] if coils and len(coils) > 2 else None + } + } + # 发布数据 + self.mqtt_client.publish(DEVICE_STATUS_TOPIC, data) + if hvs_device.get("error_count", 10) > 5: + logger.error(f"设备 {hvs_device.get('code')} 数据发布失败,错误次数超过5次") + else: + logger.info(f"成功发布设备数据: {data}") + except Exception as e: + logger.error(f"处理设备 {hvs_device.get('code')} 数据失败: {e}") \ No newline at end of file diff --git a/hvs_service2/hvs.service b/hvs_service2/hvs.service new file mode 100644 index 0000000..8432835 --- /dev/null +++ b/hvs_service2/hvs.service @@ -0,0 +1,18 @@ +[Unit] +Description=Hvs Service +After=emqx.service +Wants=network-online.target + +[Service] +Type=simple +User=root +Group=root +WorkingDirectory=/home/admin/CPY/CPY_AdminPlatform_V3.5/hvs_service +ExecStart=/home/admin/CPY/venv/bin/python /home/admin/CPY/CPY_AdminPlatform_V3.5/hvs_service/main.py +Restart=always +RestartSec=10s +StartLimitBurst=5 +Environment=PYTHONUNBUFFERED=1 + +[Install] +WantedBy=multi-user.target \ No newline at end of file diff --git a/hvs_service2/main.py b/hvs_service2/main.py new file mode 100644 index 0000000..2d141d3 --- /dev/null +++ b/hvs_service2/main.py @@ -0,0 +1,59 @@ +import time +import os + +from config import * +from tcp_io_module import TcpIoModule +from hvs import HvService +from mqtt_client import mqtt_client + +# pinctrl set 26 op pn dl + +def main(): + #通过pinctrl打开电源 + os.system("pinctrl set 26 op pn dl") + + io_module = TcpIoModule(host='192.168.8.211', port=502) + io_module.start() + + hv_service = HvService() + hv_service.start() + + light_state = False + light_new_state = False + + light_state_update_time = 0.0 + xray_off_time = 0.0 + + while True: + try: + if time.time() - hv_service.last_hvs_update_time > 5.0: + hv_service.xray_on = [False, False] + if hv_service.xray_on[0] or hv_service.xray_on[1]: + light_new_state = True + else: + if light_new_state == True: + xray_off_time = time.time() + light_new_state = False + + if light_state != light_new_state and time.time() - light_state_update_time > 2 and time.time() - xray_off_time > 2: +# if light_new_state == False: +# if time.time() - xray_off_time > 12.0: +# light_state = light_new_state +# else: +# light_state = light_new_state + light_state = light_new_state + io_module.control_light(8, light_state) + mqtt_client.control_xray_light(light_state) + light_state_update_time = time.time() + + time.sleep(0.1) + except KeyboardInterrupt: + print("程序收到中断信号,正在退出...") + io_module.stop() + hv_service.stop() + mqtt_client.stop() + break + +if __name__ == "__main__": + main() + diff --git a/hvs_service2/modbus_client.py b/hvs_service2/modbus_client.py new file mode 100644 index 0000000..1b19960 --- /dev/null +++ b/hvs_service2/modbus_client.py @@ -0,0 +1,231 @@ +import logging +import threading +from pymodbus.client import ModbusSerialClient +from pymodbus.exceptions import ModbusException, ConnectionException +import time +from config import * + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +RETRIES = 2 +RECONNECT_INTERVAL = 0.1 # 优化重连间隔时间(秒) + +class ModbusClient: + def __init__(self): + self.client = None + #使用普通锁 + self.serial_lock = threading.Lock() + + try: + port = config.get("interface", {}).get("port", "/dev/ttyModbus") + if port: + self.port = port + except: + pass + + try: + baudrate = config.get("interface", {}).get("baudrate", 115200) + if baudrate: + self.baudrate = baudrate + except: + pass + + def acquire_lock(self): + self.serial_lock.acquire() + + def release_lock(self): + self.serial_lock.release() + + def connect(self): + """建立Modbus RTU连接""" + try: + # 连接操作也需要写锁保护 + self.acquire_lock() + if self.client: + try: + self.client.close() + except: + pass + finally: + self.client = None + try: + self.client = ModbusSerialClient( + port=self.port, + baudrate=self.baudrate, + bytesize=BYTESIZE, + parity=PARITY, + stopbits=STOPBITS, + timeout=TIMEOUT + ) + + if self.client.connect(): + logger.info(f"成功连接到Modbus串口: {self.port}") + return True + else: + logger.error(f"Modbus串口连接失败: {self.port}") + return False + finally: + self.release_lock() + except Exception as e: + logger.error(f"Modbus连接异常: {str(e)}") + + return False + + def disconnect(self): + """断开Modbus连接""" + try: + self.acquire_lock() + try: + if self.client: + self.client.close() + logger.info("已断开Modbus连接") + finally: + self.client = None + self.release_lock() + except Exception as e: + logger.error(f"断开连接异常: {str(e)}") + + + def read_input_registers(self, slave_id, address, count): + """读取输入寄存器,包含重试机制和线程锁保护""" + + # 先确保连接正常,减少锁内操作 + if self.client is None or not self.client.is_socket_open(): + logger.error(f"无法确保Modbus连接,无法读取输入寄存器 (从站{slave_id}, 地址{address})") + return None + + try: + # 只在实际读写操作时使用锁,减少锁持有时间 + self.acquire_lock() + try: + response = self.client.read_input_registers( + address=address, + count=count, + device_id=slave_id + ) + finally: + self.release_lock() + + # 检查响应 + if response.isError(): + logger.error(f"读取输入寄存器错误: 从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES}, 错误: {response}") + # 非致命错误不立即重连,仅在最后一次尝试失败后重连 + + logger.debug(f"成功读取输入寄存器: 从站{slave_id}, 地址{address}, 值: {response.registers}") + return response.registers + except ModbusException as e: + logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + except Exception as e: + logger.error(f"读取输入寄存器异常: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + return None + + def read_coils(self, slave_id, address, count): + """读取线圈状态,包含重试机制和线程锁保护""" + + # 先确保连接正常,减少锁内操作 + if self.client is None or not self.client.is_socket_open(): + logger.error(f"无法确保Modbus连接,无法读取线圈 (从站{slave_id}, 地址{address})") + return None + + try: + # 只在实际读写操作时使用锁,减少锁持有时间 + self.acquire_lock() + try: + response = self.client.read_coils( + address=address, + count=count, + device_id=slave_id + ) + finally: + self.release_lock() + + # 检查响应 + if response.isError(): + logger.error(f"读取线圈错误: 从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES}, 错误: {response}") + + logger.debug(f"成功读取线圈: 从站{slave_id}, 地址{address}, 值: {response.bits[:count]}") + return response.bits[:count] + except ModbusException as e: + logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + except Exception as e: + logger.error(f"读取线圈异常: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + return None + def _ensure_connection(self) -> bool: + """确保Modbus连接正常 + + Returns: + bool: 连接是否正常 + """ + self.acquire_lock() + try: + if self.client and self.client.is_socket_open(): + return True + return self.connect() + finally: + self.release_lock() + + def write_coil(self, slave_id: int, address: int, value: bool) -> bool: + """写入线圈状态,带重试机制和线程锁保护 + + Args: + slave_id: 从站地址 + address: 线圈地址 + value: 线圈状态(True/False) + + Returns: + bool: 写入是否成功 + """ + # 先确保连接正常,减少锁内操作 + if not self._ensure_connection(): + logger.error(f"无法确保Modbus连接,无法写入线圈 (从站{slave_id}, 地址{address})") + return False + + for attempt in range(RETRIES): + try: + # 只在实际写操作时使用锁,减少锁持有时间 + self.acquire_lock() + response = None + try: + logger.debug(f"发送写入线圈请求: 从站{slave_id}, 地址{address}, 状态{value}") + response = self.client.write_coil(address, value, device_id=slave_id) + finally: + self.release_lock() + + if response: + # 检查响应 + if response.isError(): + logger.error(f"写入线圈错误响应: 从站{slave_id}, 地址{address} (尝试{attempt+1}/{RETRIES})") + # 非致命错误不立即重连,仅在最后一次尝试失败后重连 + if attempt < RETRIES - 1: + time.sleep(0.05) # 使用更短的延迟 + continue + else: + logger.debug(f"接收到写入线圈响应: 长度{len(response.encode())}字节, 内容{response.encode().hex()}") + + # 快速释放锁,减少其他操作等待时间 + + logger.info(f"成功写入线圈 {address}: {value} (尝试{attempt+1}/{RETRIES})") + return True + except ConnectionException as e: + logger.error(f"连接中断错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + self.connected = False # 修正变量名 + if attempt < RETRIES - 1: + time.sleep(0.05) + except ModbusException as e: + logger.error(f"Modbus协议错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + if attempt < RETRIES - 1: + time.sleep(0.05) + except Exception as e: + logger.error(f"写入线圈未知错误: {str(e)} (从站{slave_id}, 地址{address}, 尝试{attempt+1}/{RETRIES})") + + if attempt < RETRIES - 1: + time.sleep(0.05) + + logger.error(f"所有{RETRIES}次写入线圈尝试均失败: 从站{slave_id}, 地址{address}") + return False diff --git a/hvs_service2/mqtt_client.py b/hvs_service2/mqtt_client.py new file mode 100644 index 0000000..c349f1c --- /dev/null +++ b/hvs_service2/mqtt_client.py @@ -0,0 +1,175 @@ +import paho.mqtt.client as mqtt +import json +import socket +import logging +from datetime import datetime +import time +import socket +from threading import Timer +from config import * +from typing import Dict, Any, List, Optional, Callable +import requests + +logger = logging.getLogger(__name__) + +class MQTTClient(): + def __init__(self, broker: str, port: int = 1883, client_id: str = None): + self.client = mqtt.Client(client_id = 'hv_service_' + self.random_string(6)) # 创建本地客户端 + self.client.username_pw_set(USER,PWD) + self.broker = broker + self.port = port + self.callbacks: Dict[str, Callable] = {} + self.received_messages = {} + self.message_events = {} + + self.is_connected = False + + # 设置回调函数 + self.client.on_connect = self._on_connect + self.client.on_message = self._on_message + self.client.on_disconnect = self._on_disconnect + + Timer(1, self.connTimerHandler).start() + + def random_string(self, length=6): + """生成随机字符串""" + import random + import string + return ''.join(random.choices(string.ascii_letters + string.digits, k=length)) + + def stop(self): + """停止服务""" + self.client.loop_stop() + self.client.disconnect() + + def checkLocalServer(self): + host = '127.0.0.1' + port = 1883 + timeout = 1 + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(timeout) + try: + result = sock.connect_ex((host, port)) + if result == 0: + return True + else: + return False + except Exception as e: + print(e) + return False + finally: + sock.close() + + def connTimerHandler(self): + print("mqtt conn timer handler") + if self.checkLocalServer(): + self.client.connect(BROKER, MQTT_PORT) # 连接本地 MQTT 服务器 + self.client.loop_start() # 开始循环以处理网络流量 + else: + print("local mqtt brokeris not ready") + + Timer(1, self.connTimerHandler).start() + + def connect(self): + """连接到MQTT代理并处理连接错误""" + try: + self.client.connect(self.broker, self.port) + self.client.loop_start() + logger.info(f"成功连接到MQTT代理: {self.broker}:{self.port}") + return True + except socket.gaierror: + logger.error(f"MQTT代理地址解析失败: {self.broker}") + except ConnectionRefusedError: + logger.error(f"MQTT代理拒绝连接: {self.broker}:{self.port}") + except Exception as e: + logger.error(f"MQTT连接失败: {str(e)}") + return False + + def disconnect(self): + """断开MQTT连接""" + self.client.loop_stop() + self.client.disconnect() + + def subscribe(self, topic: str, callback: Callable): + """订阅主题并设置回调函数""" + self.callbacks[topic] = callback + + def publish(self, topic: str, message: Dict[str, Any]): + """发布消息到指定主题""" + payload = json.dumps(message) + self.client.publish(topic, payload) + + + def control_xray_light(self, value): + msg = { + "device_code" : "1#ALU", + "command" : "set_status", + "status" : value + } + # print("publish", DEVICE_CONTROL_TOPIC, msg) + self.publish(DEVICE_CONTROL_TOPIC, msg) # 发布数据到本地 + + def _on_connect(self, client, userdata, flags, rc): + """连接回调""" + print(f"已连接到MQTT代理: {self.broker}") + for topic in self.callbacks: + self.client.subscribe(topic) + self.is_connected = True + + def _on_message(self, client, userdata, msg): + """消息接收回调""" + print("mqtt msg:", msg.topic, msg.payload) + topic = msg.topic + try: + payload = json.loads(msg.payload.decode()) + if topic in self.callbacks: + self.callbacks[topic](topic, payload) + + # 存储接收到的消息 + self.received_messages[topic] = msg + + # 触发等待事件 + if topic in self.message_events: + event = self.message_events.pop(topic) + event.set() + + except json.JSONDecodeError: + print(f"无法解析消息: {msg.payload}") + + def _on_disconnect(self, client, userdata, rc): + """断开连接回调""" + print(f"已断开与MQTT代理的连接: {self.broker}") + self.is_connected= False + + def wait_for_message(self, topic: str, timeout: float = 5.0) -> Optional[mqtt.MQTTMessage]: + """等待接收指定主题的消息 + + Args: + topic: 要等待的主题 + timeout: 超时时间(秒) + + Returns: + 接收到的消息对象,如果超时则返回None + """ + import threading + + # 检查是否已经有缓存的消息 + if topic in self.received_messages: + return self.received_messages.pop(topic) + + # 创建事件对象 + event = threading.Event() + self.message_events[topic] = event + + # 等待事件触发或超时 + event.wait(timeout) + + # 移除事件对象 + if topic in self.message_events: + self.message_events.pop(topic) + + # 返回接收到的消息 + return self.received_messages.pop(topic, None) + + +mqtt_client = MQTTClient(broker=BROKER, port=MQTT_PORT) \ No newline at end of file diff --git a/hvs_service2/requirements.txt b/hvs_service2/requirements.txt new file mode 100644 index 0000000..5fbe897 --- /dev/null +++ b/hvs_service2/requirements.txt @@ -0,0 +1,2 @@ +pymodbus>=3.5.0 +paho-mqtt>=2.1.0 \ No newline at end of file diff --git a/hvs_service2/tcp_io_module.py b/hvs_service2/tcp_io_module.py new file mode 100644 index 0000000..60e2b5d --- /dev/null +++ b/hvs_service2/tcp_io_module.py @@ -0,0 +1,209 @@ +import time +import threading +from pymodbus.client import ModbusTcpClient +class TcpIoModule(): + def __init__(self, host='localhost', port=502, timeout=3, retry_interval=1, max_retries=0): + + """ + 初始化TCP IO模块 + :param host: 服务器IP地址 + :param port: 服务器端口 + :param timeout: 超时时间(秒) + :param retry_interval: 重连间隔(秒) + :param max_retries: 最大重连次数,0表示无限重试 + """ + self.host = host + self.port = port + self.timeout = timeout + self.retry_interval = retry_interval + self.max_retries = max_retries + self.client = None + self.is_connected = False + self.is_running = False + self.read_thread = None + self.register_values = {} + self.reconnect_count = 0 + self.reconnect_lock = threading.Lock() + self.button_states = [False] * 10 + + def _connect(self): + """ + 连接到Modbus服务器 + :return: 是否连接成功 + """ + try: + if self.client: + self.client.close() + self.client = ModbusTcpClient(host=self.host, port=self.port, timeout=self.timeout) + self.is_connected = self.client.connect() + if self.is_connected: + print(f"成功连接到Modbus服务器: {self.host}:{self.port}") + self.reconnect_count = 0 + else: + print(f"连接Modbus服务器失败: {self.host}:{self.port}") + return self.is_connected + except Exception as e: + print(f"连接失败: {e}") + self.is_connected = False + return False + + def start(self): + """ + 启动Modbus客户端,开始读取寄存器 + :return: 是否启动成功 + """ + + + self.is_running = True + self.read_thread = threading.Thread(target=self._read_data_loop) + self.read_thread.daemon = True + self.read_thread.start() + return True + + def stop(self): + """ + 停止Modbus客户端 + """ + self.is_running = False + if self.read_thread and self.read_thread.is_alive(): + self.read_thread.join(timeout=1.0) + if self.client: + self.client.close() + self.is_connected = False + print("Modbus客户端已停止") + + def _read_data_loop(self): + """ + 循环读取寄存器的内部方法 + """ + while self.is_running: + if not self.is_connected: + # 连接断开,尝试重连 + with self.reconnect_lock: + if not self.is_connected and self._auto_reconnect(): + print("连成功") + time.sleep(0.5) + continue + + try: + # 这里实现读取寄存器的逻辑 + self.read_data() + time.sleep(0.1) # 每秒读取一次 + except Exception as e: + print(f"读取寄存器出错: {e}") + # 读取错误可能是连接问题,标记为断开以便重连 + self.is_connected = False + time.sleep(0.5) + + def _auto_reconnect(self): + """ + 自动重连机制 + :return: 是否重连成功 + """ + # 只尝试一次重连,避免长时间持有锁 + if self.is_running and (self.max_retries == 0 or self.reconnect_count < self.max_retries): + self.reconnect_count += 1 + + if self._connect(): + return True + + return False + + def read_data(self): + """ + 读取寄存器的方法 + """ + try: + # 读取输入寄存器,起始地址为0,读取10个寄存器 + response = self.client.read_discrete_inputs(address=0, count= 4) + if not response.isError(): + for idx, bit in enumerate(response.bits): + if idx == 3: + # 检测下降沿:从抬起(True)变为按下(False) + previous_state = self.button_states[idx] + current_state = bit + + # 更新当前状态 + self.button_states[idx] = current_state + + # 下降沿检测 + if previous_state == True and current_state == False: + self.control_stop() + print("=================control_stop") + + else: + if bit: + print(f"寄存器 {idx} 的值是 {bit}") + self.button_states[idx] = True + + elif self.button_states[idx]: + self.button_states[idx] = False + if idx == 0: + self.control_start() + print("=================control_start") + elif idx == 1: + self.control_pause() + print("=================control_pause") + elif idx == 2: + self.control_reset() + print("=================control_reset") + + else: + print(f"读取寄存器出错: {response}") + self.is_connected = False + except Exception as e: + print(f"读取寄存器出错: {e}") + self.is_connected = False + + def control_start(self): + self.control_light(9, True) + """ + 控制设备启动 + """ + + def control_pause(self): + self.control_light(9, False) + """ + 控制设备暂停 + """ + + def control_reset(self): + """ + 控制设备复位 + """ + + def control_stop(self): + self.control_light(9, False) + """ + 控制设备停止 + """ + + def control_light(self, index, value): + try: + self.client.write_coil(index, value) + except Exception as e: + print(f"写入线圈出错: {e}") + self.is_connected = False + + def get_register_value(self, register_address): + """ + 获取指定寄存器的值 + :param register_address: 寄存器地址 + :return: 寄存器值或None(如果不存在) + """ + return self.register_values.get(register_address) + +if __name__ == '__main__': + # 示例用法 + modbus_client = TcpIoModule(host='192.168.8.211', port=502) + if modbus_client.start(): + print("Modbus客户端已启动") + try: + while True: + time.sleep(1) + except KeyboardInterrupt: + print("停止Modbus客户端") + modbus_client.stop() + else: + print("Modbus客户端启动失败") + diff --git a/scanner_service/Manager/mwmotor_manager.py b/scanner_service/Manager/mwmotor_manager.py index d17c423..b468676 100644 --- a/scanner_service/Manager/mwmotor_manager.py +++ b/scanner_service/Manager/mwmotor_manager.py @@ -5,6 +5,7 @@ import threading import subprocess import re import json +from copy import deepcopy from config import * from PySide6.QtCore import * from PySide6.QtNetwork import QUdpSocket, QHostAddress @@ -211,7 +212,9 @@ class MotorManager(QObject): if 'daq_power' in data: self.scanner(index).daq_info['power'] = data['daq_power'] if 'filament_info' in data: - self.scanner(index).daq_info['filament_info'] = data['filament_info'] + filament_info = deepcopy(data['filament_info']) + filament_info['id'] = data['id'] + self.udp_socket.writeDatagram(json.dumps(filament_info).encode() , "127.0.0.1", 62000) if 'motor_power' in data: self.scanner(index).motor_power = data['motor_power']