import serial import time import threading from typing import Optional, List, Dict, Any, Union, Tuple from protocol.HART import universal, common, tools from protocol.HART._parsing import parse from protocol.HART._unpacker import Unpacker BurstModeON = 1 # 突发模式开启 BurstModeOFF = 0 # 突发模式关闭 PrimaryMasterMode = 1 # 主要模式 SecondaryMasterMode = 0 # 次要副主站模式 class HARTCommunication: """ HART协议通信类，使用COM7端口，1200波特率，奇校验 """ def __init__(self, port='COM7', baudrate=1200, parity=serial.PARITY_ODD, timeout=3): """ 初始化HART通信类 Args: port (str): 串口端口号，默认为'COM7' baudrate (int): 波特率，默认为1200 parity (int): 校验方式，默认为奇校验 timeout (float): 超时时间，单位秒 """ self.port = port self.baudrate = baudrate self.parity = parity self.timeout = timeout self.serialConnection: Optional[serial.Serial] = None self.deviceAddress: Optional[bytes] = None self.comm_lock = threading.RLock() self.masterMode = PrimaryMasterMode # 默认为主要主站 self.burstMode = BurstModeOFF # 默认关闭突发模式 def connect(self) -> bool: """ 建立串口连接 Returns: bool: 连接是否成功 """ try: self.serialConnection = serial.Serial( port=self.port, baudrate=self.baudrate, parity=self.parity, stopbits=1, bytesize=8, timeout=self.timeout, write_timeout = 3, xonxoff = True ) return True except Exception as e: print(f"连接失败: {e}") return False def disconnect(self): """ 断开串口连接 """ if self.serialConnection and self.serialConnection.is_open: self.serialConnection.close() def sendCommand(self, command_bytes: bytes) -> Union[List[Dict[str, Any]], Dict[str, str]]: """ 发送HART命令 Args: command_bytes (bytes): 要发送的命令字节 Returns: Union[List[Dict[str, Any]], Dict[str, str]]: 解析后的响应数据列表或错误字典 """ if not self.serialConnection or not self.serialConnection.is_open: raise ConnectionError("串口未连接") with self.comm_lock: try: # 发送命令前清空缓冲区，防止旧数据干扰 self.serialConnection.reset_input_buffer() self.serialConnection.reset_output_buffer() self.serialConnection.write(command_bytes) self.serialConnection.flush() # 等待数据完全发出 print(f"发送命令: {command_bytes.hex()}") # 等待响应 time.sleep(1) # 使用Unpacker解析响应 unpacker = Unpacker(self.serialConnection) msgList: List[Dict[str, Any]] = [] for msg in unpacker: msgList.append(dict(msg)) if not msgList: return {"error": "设备无响应或响应超时"} return msgList except Exception as e: print(f"发送命令失败: {e}") return {"error": f"发送命令失败: {e}"} def sendCommandWithRetry(self, command_bytes: bytes, max_retries=3) -> Union[List[Dict[str, Any]], Dict[str, str]]: """ 发送HART命令（带重试和自动重连机制） Args: command_bytes (bytes): 要发送的命令字节 max_retries (int): 最大重试次数 Returns: Union[List[Dict[str, Any]], Dict[str, str]]: 解析后的响应数据或错误字典 """ for attempt in range(max_retries): try: result = self.sendCommand(command_bytes) if isinstance(result, list) and result: # 成功并且有数据 return result # 处理失败情况 error_info = result if isinstance(result, dict) else {"error": "未知错误"} print(f"第{attempt + 1}次尝试失败，响应: {error_info.get('error', 'N/A')}，重试中...") # 如果是超时或无响应，则尝试重连 if error_info.get("error") == "设备无响应或响应超时": print("检测到设备无响应，正在尝试重新连接串口...") self.disconnect() time.sleep(0.1) if not self.connect(): print("重新连接失败，放弃重试。") return {"error": "重新连接串口失败"} print("串口重新连接成功。") time.sleep(0.2) except Exception as e: print(f"第{attempt + 1}次尝试发生异常: {e}") if attempt == max_retries - 1: return {"error": f"重试{max_retries}次后仍然失败: {e}"} # 发生异常时也尝试重连 print("发生异常，正在尝试重新连接串口...") self.disconnect() time.sleep(0.5) if not self.connect(): print("重新连接失败，放弃重试。") return {"error": "重新连接串口失败"} print("串口重新连接成功。") time.sleep(1) return {"error": f"重试{max_retries}次后仍然失败"} def readUniqueId(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_unique_identifier(self.deviceAddress) deviceInfo = self.sendCommandWithRetry(command) if isinstance(deviceInfo, list): for msg in deviceInfo: if isinstance(msg, dict): manufacturer_id = msg.get('manufacturer_id') manufacturer_device_type = msg.get('manufacturer_device_type') device_id = msg.get('device_id') if all(v is not None for v in [manufacturer_id, manufacturer_device_type, device_id]): assert manufacturer_id is not None and manufacturer_device_type is not None and device_id is not None expandedDeviceType = (manufacturer_id << 8) | manufacturer_device_type self.buildHartAddress(expandedDeviceType=expandedDeviceType, deviceId=device_id, isLongFrame=True) if self.deviceAddress: print(f"Rebuilt long address: {self.deviceAddress.hex()}") else: print("Warning: Could not rebuild long address from message, missing required keys.") else: print(f"Warning: Expected a dict but got {type(msg)}. Cannot process for long address.") return deviceInfo def readPrimaryVariable(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_primary_variable(self.deviceAddress) return self.sendCommandWithRetry(command) def readLoopCurrentAndPercent(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_loop_current_and_percent(self.deviceAddress) return self.sendCommandWithRetry(command) def readDynamicVariablesAndLoopCurrent(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_dynamic_variables_and_loop_current(self.deviceAddress) return self.sendCommandWithRetry(command) def readMessage(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_message(self.deviceAddress) return self.sendCommandWithRetry(command) def readTagDescriptorDate(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_tag_descriptor_date(self.deviceAddress) return self.sendCommandWithRetry(command) def readPrimaryVariableInformation(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_primary_variable_information(self.deviceAddress) return self.sendCommandWithRetry(command) def readOutputInformation(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_output_information(self.deviceAddress) return self.sendCommandWithRetry(command) def readFinalAssemblyNumber(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.read_final_assembly_number(self.deviceAddress) return self.sendCommandWithRetry(command) # ========== 校准功能 ==========\\n def calibrate4mA(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.calibrate_4ma(self.deviceAddress) return self.sendCommandWithRetry(command) def calibrate20mA(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.calibrate_20ma(self.deviceAddress) return self.sendCommandWithRetry(command) def calibrateZeroPoint(self): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.calibrate_zero_point(self.deviceAddress) return self.sendCommandWithRetry(command) # ========== 量程和输出设置 ==========\\n def writePrimaryVariableDamping(self, dampingTime: float): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_primary_variable_damping(self.deviceAddress, dampingTime) return self.sendCommandWithRetry(command) def writePrimaryVariableRange(self, unitsCode: int, upperRange: float, lowerRange: float): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_primary_variable_range(self.deviceAddress, unitsCode, upperRange, lowerRange) return self.sendCommandWithRetry(command) def writePrimaryVariableUnits(self, unitsCode: int): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_primary_variable_units(self.deviceAddress, unitsCode) return self.sendCommandWithRetry(command) def writePrimaryVariableOutputFunction(self, transferFunctionCode: int): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_primary_variable_output_function(self.deviceAddress, transferFunctionCode) return self.sendCommandWithRetry(command) # ========== 电流微调功能 ==========\\n def trimLoopCurrent4mA(self, measuredCurrent: float): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.trim_loop_current_4ma(self.deviceAddress, measuredCurrent) return self.sendCommandWithRetry(command) def trimLoopCurrent20mA(self, measuredCurrent: float): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.trim_loop_current_20ma(self.deviceAddress, measuredCurrent) return self.sendCommandWithRetry(command) def setFixedCurrentOutput(self, enable: bool, currentValue: float = 0.0): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.set_fixed_current_output(self.deviceAddress, enable, currentValue) return self.sendCommandWithRetry(command) # ========== 突发模式和主站模式设置 ==========\\n def setBurstMode(self, enable: bool, burstMessageCommand: int = 1): self.burstMode = BurstModeON if enable else BurstModeOFF if self.deviceAddress: self._rebuildCurrentAddress() return {"burst_mode": self.burstMode, "burst_message_command": burstMessageCommand} def setMasterMode(self, isPrimaryMaster: bool): self.masterMode = PrimaryMasterMode if isPrimaryMaster else SecondaryMasterMode if self.deviceAddress: self._rebuildCurrentAddress() return {"master_mode": self.masterMode} def _rebuildCurrentAddress(self): if self.deviceAddress is None: return if len(self.deviceAddress) == 5: # 长帧地址 byte0 = self.deviceAddress[0] expandedDeviceType = ((byte0 & 0x3F) << 8) | self.deviceAddress[1] deviceId = (self.deviceAddress[2] << 16) | (self.deviceAddress[3] << 8) | self.deviceAddress[4] self.buildHartAddress(expandedDeviceType=expandedDeviceType, deviceId=deviceId, isLongFrame=True) else: # 短帧地址 pollingAddress = self.deviceAddress[0] & 0x3F self.buildHartAddress(pollingAddress=pollingAddress, isLongFrame=False) # ========== 实用工具方法 ==========\\n def getDeviceStatus(self): if not self.deviceAddress: return {"error": "设备地址未设置"} return self.readUniqueId() def isConnected(self) -> bool: return self.serialConnection is not None and self.serialConnection.is_open def getCurrentAddress(self) -> Optional[bytes]: return self.deviceAddress def setDeviceAddress(self, address: bytes): self.deviceAddress = address def writeMessage(self, message: str): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_message(self.deviceAddress, message) return self.sendCommandWithRetry(command, max_retries=1) def writeTagDescriptorDate(self, tag: str, descriptor: str, date: Tuple[int, int, int]): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_tag_descriptor_date(self.deviceAddress, tag, descriptor, date) return self.sendCommandWithRetry(command, max_retries=1) def writeFinalAssemblyNumber(self, number: int): if self.deviceAddress is None: raise ValueError("设备地址未设置") command = universal.write_final_assembly_number(self.deviceAddress, number) return self.sendCommandWithRetry(command, max_retries=1) def write_polling_address(self, new_polling_address: int): """ 修改设备的轮询地址 (Command 6) Args: new_polling_address (int): 新的轮询地址 (0-63) """ if self.deviceAddress is None: raise ValueError("设备地址未设置") if not (0 <= new_polling_address <= 63): raise ValueError("轮询地址必须在0-63范围内") command = universal.write_polling_address(self.deviceAddress, new_polling_address) result = self.sendCommandWithRetry(command) # The response should contain the new polling address if isinstance(result, list) and result and result[0].get('polling_address') == new_polling_address: print(f"轮询地址成功修改为: {new_polling_address}") # Update the internal address to the new one self.buildHartAddress(pollingAddress=new_polling_address, isLongFrame=False) return result else: error_msg = f"修改轮询地址失败. 响应: {result}" print(error_msg) raise Exception(error_msg) def scanForDevice(self) -> Optional[Dict[str, Any]]: if not self.serialConnection: raise ConnectionError("串口未连接") print("开始扫描设备...") original_timeout = self.serialConnection.timeout try: self.serialConnection.timeout = 0.5 for addr in range(64): print(f"正在尝试轮询地址: {addr}") self.buildHartAddress(pollingAddress=addr, isLongFrame=False) try: if self.deviceAddress is None: continue command = universal.read_unique_identifier(self.deviceAddress) device_info_list = self.sendCommandWithRetry(command, max_retries=1) if isinstance(device_info_list, list) and device_info_list: print(f"在地址 {addr} 找到设备: {device_info_list[0]}") return {"address": addr, "device_info": device_info_list[0]} except Exception as e: print(f"地址 {addr} 扫描异常: {e}") continue finally: if self.serialConnection: self.serialConnection.timeout = original_timeout print("扫描完成，未找到设备。") return None def buildHartAddress(self, expandedDeviceType: Optional[int] = None, deviceId: Optional[int] = None, pollingAddress: int = 0, isLongFrame: bool = False): master = self.masterMode burstMode = self.burstMode if isLongFrame: if expandedDeviceType is None or deviceId is None: raise ValueError("长帧格式需要提供expandedDeviceType和deviceId参数") if not (0 <= deviceId <= 0xFFFFFF): raise ValueError("设备ID必须在0-16777215范围内") byte0 = (master << 7) | (burstMode << 6) | ((expandedDeviceType >> 8) & 0x3F) byte1 = expandedDeviceType & 0xFF byte2 = (deviceId >> 16) & 0xFF byte3 = (deviceId >> 8) & 0xFF byte4 = deviceId & 0xFF self.deviceAddress = bytes([byte0, byte1, byte2, byte3, byte4]) else: if not (0 <= pollingAddress <= 63): raise ValueError("轮询地址必须在0-63范围内") self.deviceAddress = bytes([(master << 7) | (burstMode << 6) | (pollingAddress & 0x3F)]) return self.deviceAddress if __name__ == '__main__': hart = HARTCommunication() if hart.connect(): print("=== HART通信类功能演示 ===") address = hart.buildHartAddress(pollingAddress=0, isLongFrame=False) print(f"设备地址: {address.hex()}") print("\n--- 读取设备信息 ---") device_info = hart.readUniqueId() if isinstance(device_info, list): for msg in device_info: print(f"设备信息: {msg}") # print("\n--- 读取主变量 ---") # primary_var = hart.readPrimaryVariable() # if isinstance(primary_var, list): # for msg in primary_var: # print(f"主变量: {msg}") testMEs: List[Dict[str, Any]] | Dict[str, str] = hart.writePrimaryVariableDamping(1) if isinstance(testMEs, list): for msg in testMEs: print(f"信息: {msg}") testMEs1: List[Dict[str, Any]] | Dict[str, str] = hart.readOutputInformation() if isinstance(testMEs1, list): for msg in testMEs1: print(f"信息: {msg}") testMEs1: List[Dict[str, Any]] | Dict[str, str] = hart.readOutputInformation() if isinstance(testMEs1, list): for msg in testMEs1: print(f"信息: {msg}") hart.disconnect() print("\n连接已断开") else: print("连接失败")