modbus_comm.py

# modbus_comm.py - Modbus 通信模块（带信号输出）

from pymodbus.client.serial import ModbusSerialClient
from pymodbus.exceptions import ModbusException
import time
import logging
from datetime import datetime
from PyQt5.QtCore import QThread, pyqtSignal

# ==================== 自定义气体映射 ====================
custom_gas_map = {
    1: "O2",
    2: "CO2",
    3: "CH4",
    4: "H2",
    5: "C2H4",
    6: "CH3OH"  
}

def get_gas_name(gas_id):
    return custom_gas_map.get(gas_id, "Unknown gas")


# ==================== 解析函数 ====================
def parse_unit_and_decimal(value):
    unit_code = (value >> 12) & 0b1111
    decimal_code = (value >> 8) & 0b1111
# 参考手册
    unit_map = {
        0b0000: 'ppm',
        0b0010: '%LEL',
        0b0100: '%VOL',
        0b0110: 'mg/m³',
        0b1000: 'ppb'
    }
    decimal_map = {
        0b0000: 0,
        0b0100: 1,
        0b1000: 2,
        0b1100: 3
    }

    unit = unit_map.get(unit_code, 'Unknown unit')
    decimals = decimal_map.get(decimal_code, 0)
    return {'unit': unit, 'decimals': decimals}


def parse_status(state):
    status_map = {
        0x00: "Preheat",
        0x01: "Normal",
        0x02: "Data error",
        0x03: "Sensor fault",
        0x04: "Warning",
        0x05: "Low report",
        0x06: "High report",
        0x07: "Access fault",
        0x08: "Over range",
        0x09: "Calibration needed",
        0x0A: "Timeout",
        0x0B: "STEL alarm",
        0x0C: "TWA alarm",
        0x0D: "Reserved",
        0x0E: "Reserved",
        0x0F: "Communication fault"
    }
    return status_map.get(state, "Unknown status")



# ==================== 日志配置 ====================
LOG_FILE = "modbus_polling.log"

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler(LOG_FILE, encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)


# ==================== Modbus 通信线程 ====================
class ModbusPoller(QThread):
    # 定义信号：发送解析后的数据
    data_received = pyqtSignal(str, float, float, float)  # gas_name, concentration, temperature, humidity
    status_updated = pyqtSignal(str)  # 状态栏消息
    error_occurred = pyqtSignal(str)  # 错误消息
    myport = 'COM3'
    def __init__(self, port=myport, parent=None):
        super().__init__(parent)
        self.port = port
        self.running = True

    def stop(self):
        self.running = False

    def run(self):
        client = ModbusSerialClient(port=self.port, baudrate=9600, timeout=1, parity='N', stopbits=1, bytesize=8)
        addresses = range(1, 7)
        read_count = 3
        interval = 0.5

        self.status_updated.emit(f"Modbus polling... port: {self.port} target device: 1-6")

        while self.running:
            try:
                if not client.connect():
                    msg = f"Cannot connect to serial port {self.port}"
                    logger.error(msg)
                    self.error_occurred.emit(msg)
                    time.sleep(5)
                    continue

                logger.info("Start new polling loop...")
                self.status_updated.emit("Start new polling loop...")

                for addr in addresses:
                    if not self.running:
                        break
                    gas_name = get_gas_name(addr)
                    logger.info(f"--- Start polling {addr} ({gas_name}) ---")

                    for i in range(read_count):
                        if not self.running:
                            break
                        try:
                            response = client.read_holding_registers(address=0, count=10, slave=addr)
                            if not response.isError() and len(response.registers) >= 10:
                                reg = response.registers
                                rule = reg[0]
                                conc_raw = reg[1]
                                state = reg[5]
                                temp_raw = reg[7]
                                humid_raw = reg[9]

                                parsed = parse_unit_and_decimal(rule)
                                decimals = parsed['decimals']
                                concentration = conc_raw / (10 ** decimals)
                                temperature = temp_raw / 10.0
                                humidity = humid_raw / 10.0 if humid_raw != 0xFFFF else 50.0  # 默认值
                                status_msg = parse_status(state)

                                # 发射数据信号
                                self.data_received.emit(gas_name, concentration, temperature, humidity)

                                logger.info(
                                    f"reg: {response.registers}, " # 寄存器原始数据
                                    # f"[{gas_name}] 浓度:{concentration}{parsed['unit']}, "
                                    # f"状态:{status_msg}, 温度:{temperature}℃, 湿度:{humidity}%"
                                )
                            else:
                                err_msg = f"device {addr} request failed: {response}"
                                logger.warning(err_msg)
                                self.error_occurred.emit(f"device {addr} communication failed")

                        except Exception as e:
                            logger.error(f"read device {addr} failed: {e}")
                            self.error_occurred.emit(f"device {addr} error: {str(e)}")

                        if i < read_count - 1:
                            time.sleep(interval)

                    if not self.running:
                        break

                if self.running:
                    logger.info("This polling loop ends, waiting 2 seconds...")
                    self.status_updated.emit("Waiting for next loop...")
                    time.sleep(2)

            except KeyboardInterrupt:
                logger.info("User interrupt")
                break
            except Exception as e:
                logger.error(f"System exception: {e}")
                self.error_occurred.emit(f"System error: {str(e)}")
                time.sleep(5)
            finally:
                client.close()

        logger.info("Modbus polling stopped")
        self.status_updated.emit("Modbus polling stopped")