161 lines
6.6 KiB
Python
161 lines
6.6 KiB
Python
import struct
|
|
import uart_group_config as uart
|
|
import time
|
|
import serial
|
|
import menu_utils as utils
|
|
from modbus_tk import modbus_rtu, modbus_tcp
|
|
import json
|
|
from mqtt_device import class_comm_mqtt_interface, class_comm_mqtt_thread
|
|
from comm_protocol_modbus import class_protocol_modbus_rtu, class_protocol_modbus_tcp
|
|
from comm_device import class_comm_device
|
|
from device_conf import class_comm_device_config
|
|
from menu_group import class_menu_group
|
|
from modbus_server import class_modbus_tcp_server
|
|
from comm_modbus_device import class_modbus_comm_device
|
|
import comm_global
|
|
from print_color import *
|
|
from mqtt_object import class_mqtt_info_object_group, class_mqtt_info_object
|
|
import keyboard
|
|
from comm_thread import class_comm_master_thread
|
|
|
|
# 常量
|
|
DEFAULT_COMM_WRITE_TIMEOUT_MS = 500
|
|
DEFAULT_MODBUS_SERVER_IP = "127.0.0.1"
|
|
|
|
# 初始化 MQTT 信息组
|
|
mqtt_info_group = class_mqtt_info_object_group()
|
|
|
|
#初始化 Modbus TCP 服务器
|
|
def initialize_modbus_server(slave_addr, ip, port):
|
|
|
|
return class_modbus_tcp_server(slave_addr=slave_addr, slave_ip=ip, slave_port=port)
|
|
#获取 MQTT 服务器配置
|
|
def get_mqtt_server_config():
|
|
|
|
user_name = utils.dict_or_object_get_attr(uart.mqtt_server, "user_name", "admin")
|
|
password = utils.dict_or_object_get_attr(uart.mqtt_server, "password", "admin")
|
|
server = utils.dict_or_object_get_attr(uart.mqtt_server, "remote", "127.0.0.1")
|
|
port = utils.dict_or_object_get_attr(uart.mqtt_server, "port", 1883)
|
|
return user_name, password, server, port
|
|
#创建并返回通讯主线程列表
|
|
def create_comm_master_thread_list():
|
|
comm_master_thread_list = []
|
|
|
|
for object_config_list in uart.comm_thread_config:
|
|
try:
|
|
protocol_name = utils.dict_or_object_get_attr(object_config_list, "protocol", None)
|
|
mode = utils.dict_or_object_get_attr(object_config_list, "mode", None)
|
|
|
|
_protocol = None
|
|
if protocol_name == "modbus_rtu":
|
|
_protocol = class_protocol_modbus_rtu("modbus_rtu")
|
|
elif protocol_name == "modbus_tcp":
|
|
_protocol = class_protocol_modbus_tcp("modbus_tcp")
|
|
|
|
if _protocol is None or mode is None:
|
|
continue
|
|
|
|
_protocol.open(mode)
|
|
|
|
_device_list = utils.dict_or_object_get_attr(object_config_list, "device_list", None)
|
|
_device_comm_object_list = []
|
|
|
|
if _device_list:
|
|
for device_list_item_dict in _device_list:
|
|
try:
|
|
_unique_name = utils.dict_or_object_get_attr(device_list_item_dict, "unique_name", None)
|
|
_device_name = utils.dict_or_object_get_attr(device_list_item_dict, "device_name", None)
|
|
_comm_addr = utils.dict_or_object_get_attr(device_list_item_dict, "comm_addr", None)
|
|
_device_remap = utils.dict_or_object_get_attr(device_list_item_dict, "device_remap", None)
|
|
|
|
if _unique_name is None or _device_name is None or _comm_addr is None or _device_remap is None:
|
|
continue
|
|
|
|
device_object = __import__(_device_name)
|
|
|
|
config = getattr(device_object, "comm_device_config", None)
|
|
_func_action_process = getattr(device_object, "func_action_process", None)
|
|
_func_alarm_query = getattr(device_object, "func_alarm_query", None)
|
|
|
|
if config:
|
|
_comm_table, _function = config.get_comm_table()
|
|
_alias_table = config.get_alias_table()
|
|
|
|
_mqtt_info_object = mqtt_info_group.create_mqtt_info_object(device_name=_device_name)
|
|
_unique_object = class_modbus_comm_device(
|
|
comm_addr=_comm_addr,
|
|
comm_table=_comm_table,
|
|
device_remap=_device_remap,
|
|
mqtt_thread=global_mqtt_thread,
|
|
protocol=_protocol,
|
|
mqtt_info_object=_mqtt_info_object,
|
|
unique_name=_unique_name,
|
|
action_process_func=_func_action_process,
|
|
request_alarm_func=_func_alarm_query,
|
|
alias_table=_alias_table
|
|
)
|
|
|
|
global_mqtt_thread.add_unique_object(unique_name=_unique_name, unique_object=_unique_object)
|
|
_device_comm_object_list.append(_unique_object)
|
|
except Exception as e:
|
|
print_error_msg(f"Failed to configure device: {_device_name}. Error: {str(e)}")
|
|
|
|
if _device_comm_object_list:
|
|
_comm_thread = class_comm_master_thread(
|
|
device_comm_object_list=_device_comm_object_list,
|
|
thread_name=_unique_name
|
|
)
|
|
comm_master_thread_list.append(_comm_thread)
|
|
except Exception as e:
|
|
print_error_msg(f"Failed to configure communication thread. Error: {str(e)}")
|
|
|
|
return comm_master_thread_list
|
|
|
|
#主函数，初始化并运行应用程序
|
|
def main():
|
|
|
|
_slave_addr = 2
|
|
comm_global.g_key_thread.start()
|
|
|
|
_modbus_tcp_server = initialize_modbus_server(_slave_addr, DEFAULT_MODBUS_SERVER_IP, 502)
|
|
|
|
_user_name, _password, _server, _port = get_mqtt_server_config()
|
|
|
|
# 创建并配置 MQTT 线程
|
|
global global_mqtt_thread
|
|
global_mqtt_thread = class_comm_mqtt_thread()
|
|
global_mqtt_thread.set_mqtt_server(
|
|
server=_server,
|
|
port=_port,
|
|
keep_alive=60,
|
|
user_name=_user_name,
|
|
password=_password
|
|
)
|
|
|
|
# 创建通讯主线程
|
|
comm_master_thread_list = create_comm_master_thread_list()
|
|
|
|
# 启动 MQTT 和通讯主线程
|
|
global_mqtt_thread.start()
|
|
for comm_thread in comm_master_thread_list:
|
|
comm_thread.start()
|
|
|
|
while True:
|
|
# 定期检查 Modbus TCP 连接状态并重连
|
|
if not _modbus_tcp_server.is_connected():
|
|
print("Modbus TCP 服务器断线重连中...")
|
|
_modbus_tcp_server.reconnect()
|
|
time.sleep(1) # 延迟一段时间后再次检查
|
|
time.sleep(10) # 每隔 10 秒检查一次连接状态
|
|
|
|
# 清理并关闭线程
|
|
global_mqtt_thread.close()
|
|
for comm_thread in comm_master_thread_list:
|
|
comm_thread.close()
|
|
for comm_thread in comm_master_thread_list:
|
|
comm_thread.join()
|
|
global_mqtt_thread.join()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|