Rust+Slint 实现ModbusTCP主机调试助手源码分享

Rust+Slint 实现ModbusTCP主机调试助手源码分享

• 一、效果展示
• 二、源码分享
• • 1、工程结构
  • 2、comm_log.rs
  • 3、data_model.rs
  • 4、modbus_client.rs
  • 5、modbus_types.rs
  • 6、statistics.rs
  • 7、main.rs
  • 8、build.rs
  • 9、main.slint
  • 10、Cargo.toml
• 三、实现原理
• • 1、UI 与逻辑分离：Slint + Rust 回调机制
  • 2、连接层：TCP 与 RTU 的统一封装
  • 3、协议层：功能码与数据模型
  • 4、数据模型层：多格式解析
  • 5、通信日志与统计
  • 6、异步运行时与线程模型
  • 7、构建流程

一、效果展示

二、源码分享

1、工程结构

2、comm_log.rs

use chrono::Local;

/// 通信日志条目
#[derive(Debug, Clone)]
pub struct LogEntryData {
pub timestamp: String,
pub direction: i32, // 0=TX, 1=RX, 2=ERROR
pub raw_text: String,
}

/// 通信日志管理器
#[derive(Clone)]
pub struct CommLog {
entries: Vec<LogEntryData>,
max_entries: usize,
}

impl CommLog {
pub fn new() -> Self {
Self {
entries: Vec::new(),
max_entries: 5000,
}
}

/// 记录发送数据
pub fn log_tx(&mut self, description: &str) {
self.add_entry(0, description);
}

/// 记录接收数据
pub fn log_rx(&mut self, description: &str) {
self.add_entry(1, description);
}

/// 记录错误
pub fn log_error(&mut self, description: &str) {
self.add_entry(2, description);
}

fn add_entry(&mut self, direction: i32, text: &str) {
let entry = LogEntryData {
timestamp: Local::now().format("%H:%M:%S%.3f").to_string(),
direction,
raw_text: text.to_string(),
};

self.entries.push(entry);

// 限制日志条目数
if self.entries.len() > self.max_entries {
self.entries.drain(0..self.entries.len() – self.max_entries);
}
}

/// 获取所有条目
pub fn entries(&self) -> &[LogEntryData] {
&self.entries
}

/// 清空日志
pub fn clear(&mut self) {
self.entries.clear();
}

/// 格式化原始字节为十六进制字符串
pub fn format_bytes(data: &[u8]) -> String {
data.iter()
.map(|b| format!("{:02X}", b))
.collect::<Vec<_>>()
.join(" ")
}
}

3、data_model.rs

use crate::modbus_types::{FunctionCode, ReadResult};

/// 寄存器数据模型
#[derive(Clone)]
pub struct RegisterModel {
/// 原始值
pub raw_values: Vec<u16>,
/// 起始地址
pub start_address: u16,
/// 当前功能码
pub function_code: FunctionCode,
/// 线圈数据（用于线圈/离散输入模式）
pub coil_values: Vec<bool>,
}

impl RegisterModel {
pub fn new() -> Self {
Self {
raw_values: Vec::new(),
start_address: 0,
function_code: FunctionCode::ReadHoldingRegisters,
coil_values: Vec::new(),
}
}

/// 从读取结果更新
pub fn update_from_result(&mut self, result: &ReadResult, start_addr: u16, fc: FunctionCode) {
self.start_address = start_addr;
self.function_code = fc;

match result {
ReadResult::Registers(regs) => {
self.raw_values = regs.clone();
self.coil_values.clear();
}
ReadResult::Coils(coils) => {
self.coil_values = coils.clone();
self.raw_values.clear();
}
}
}

/// 转换为 Slint 显示模型
pub fn to_slint_rows(&self) -> Vec<slint::ModelRc<slint::SharedString>> {
// 这个函数返回的是每列的数据
// 但更好的方式是返回 RegisterRow 结构体数组
// 实际上我们应该直接生成 Slint 的 RegisterRow
Vec::new()
}

/// 生成 Slint RegisterRow 数组
pub fn to_register_rows(&self) -> Vec<slint::SharedString> {
// 这个函数只是为了辅助，实际逻辑在 generate_rows 中
Vec::new()
}

/// 生成用于 Slint 的行数据
/// 返回 Vec<(address, unsigned, signed, hex, binary, float, ascii)>
pub fn generate_rows(&self) -> Vec<(i32, String, String, String, String, String, String)> {
if self.function_code.is_coil() {
// 线圈模式
return self.coil_values.iter().enumerate().map(|(i, &coil)| {
let addr = self.start_address + i as u16;
let val = if coil { 1u16 } else { 0u16 };
(
addr as i32,
val.to_string(),
val.to_string(),
format!("{:04X}", val),
format!("{:016b}", val),
"-".to_string(),
if coil { "ON" } else { "OFF" }.to_string(),
)
}).collect();
}

// 寄存器模式
self.raw_values.iter().enumerate().map(|(i, &raw)| {
let addr = self.start_address + i as u16;
let unsigned_val = raw;
let signed_val = raw as i16;
let hex_val = format!("{:04X}", raw);
let binary_val = format!("{:016b}", raw);

// IEEE 754 浮点（需要两个寄存器）
let float_val = if i + 1 < self.raw_values.len() {
let next_raw = self.raw_values[i + 1];
let bits = ((raw as u32) << 16) | (next_raw as u32);
let float = f32::from_bits(bits);
if float.is_finite() && float.abs() < 1e10 && (float == 0.0 || float.abs() >= 1e-10) {
format!("{:.4}", float)
} else {
format!("{:e}", float)
}
} else {
"-".to_string()
};

// ASCII
let ascii_val = {
let hi = (raw >> 8) as u8;
let lo = (raw & 0xFF) as u8;
let hi_char = if hi >= 0x20 && hi <= 0x7E { hi as char } else { '.' };
let lo_char = if lo >= 0x20 && lo <= 0x7E { lo as char } else { '.' };
format!("{}{}", hi_char, lo_char)
};

(
addr as i32,
unsigned_val.to_string(),
signed_val.to_string(),
hex_val,
binary_val,
float_val,
ascii_val,
)
}).collect()
}

/// 清空数据
pub fn clear(&mut self) {
self.raw_values.clear();
self.coil_values.clear();
self.start_address = 0;
}
}

/// 格式转换工具
pub mod format_utils {
/// u16 转无符号字符串
pub fn to_unsigned(value: u16) -> String {
value.to_string()
}

/// u16 转有符号字符串
pub fn to_signed(value: u16) -> String {
(value as i16).to_string()
}

/// u16 转十六进制
pub fn to_hex(value: u16) -> String {
format!("{:04X}", value)
}

/// u16 转二进制
pub fn to_binary(value: u16) -> String {
format!("{:016b}", value)
}

/// 两个 u16 转 IEEE 754 浮点
pub fn to_float(high: u16, low: u16) -> f32 {
let bits = ((high as u32) << 16) | (low as u32);
f32::from_bits(bits)
}

/// f32 转两个 u16 寄存器
pub fn from_float(value: f32) -> (u16, u16) {
let bits = value.to_bits();
let high = (bits >> 16) as u16;
let low = bits as u16;
(high, low)
}

/// u16 转 ASCII
pub fn to_ascii(value: u16) -> String {
let hi = (value >> 8) as u8;
let lo = (value & 0xFF) as u8;
let hi_char = if hi >= 0x20 && hi <= 0x7E { hi as char } else { '.' };
let lo_char = if lo >= 0x20 && lo <= 0x7E { lo as char } else { '.' };
format!("{}{}", hi_char, lo_char)
}

/// 解析字符串为 u16（支持十进制和十六进制）
pub fn parse_value(s: &str) -> Result<u16, String> {
let s = s.trim();
if s.starts_with("0x") || s.starts_with("0X") {
u16::from_str_radix(&s[2..], 16).map_err(|e| format!("无效的十六进制: {}", e))
} else if s.starts_with("0b") || s.starts_with("0B") {
u16::from_str_radix(&s[2..], 2).map_err(|e| format!("无效的二进制: {}", e))
} else {
s.parse::<u16>().map_err(|e| format!("无效的十进制: {}", e))
}
}
}

4、modbus_client.rs

use std::net::SocketAddr;
use std::str::FromStr;
use tokio_modbus::prelude::*;
use tokio_modbus::client::{self, Context};

use crate::modbus_types::*;

/// 统一的 Modbus 客户端封装
pub struct ModbusClientWrapper {
ctx: Context,
mode: String,
}

impl ModbusClientWrapper {
/// 连接 TCP
pub async fn connect_tcp(ip: &str, port: u16, slave_id: u8) -> Result<Self, ModbusAppError> {
let addr_str = format!("{}:{}", ip, port);
let socket_addr = SocketAddr::from_str(&addr_str)
.map_err(|e| ModbusAppError::ConnectionError(format!("无效的地址: {}", e)))?;

let slave = Slave(slave_id);
let ctx = client::tcp::connect_slave(socket_addr, slave)
.await
.map_err(|e| ModbusAppError::ConnectionError(e.to_string()))?;

Ok(Self {
ctx,
mode: format!("TCP {}:{}", ip, port),
})
}

/// 连接 RTU
pub async fn connect_rtu(
port_name: &str,
baud_rate: u32,
data_bits: u8,
stop_bits: u8,
parity: ParityMode,
slave_id: u8,
) -> Result<Self, ModbusAppError> {
let parity_mode = match parity {
ParityMode::None => tokio_serial::Parity::None,
ParityMode::Even => tokio_serial::Parity::Even,
ParityMode::Odd => tokio_serial::Parity::Odd,
};

let data_bits_mode = match data_bits {
5 => tokio_serial::DataBits::Five,
6 => tokio_serial::DataBits::Six,
7 => tokio_serial::DataBits::Seven,
_ => tokio_serial::DataBits::Eight,
};

let stop_bits_mode = match stop_bits {
1 => tokio_serial::StopBits::One,
_ => tokio_serial::StopBits::Two,
};

let builder = tokio_serial::new(port_name, baud_rate)
.data_bits(data_bits_mode)
.stop_bits(stop_bits_mode)
.parity(parity_mode);

let serial_port = tokio_serial::SerialStream::open(&builder)
.map_err(|e| ModbusAppError::ConnectionError(format!("串口打开失败: {}", e)))?;

let slave = Slave(slave_id);
let ctx = client::rtu::attach_slave(serial_port, slave);

Ok(Self {
ctx,
mode: format!("RTU {} {}-{}{}{}", port_name, baud_rate, data_bits, stop_bits, parity),
})
}

/// 读取线圈 (FC 01)
pub async fn read_coils(&mut self, addr: u16, cnt: u16) -> Result<Vec<bool>, ModbusAppError> {
self.ctx
.read_coils(addr, cnt)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 读取离散输入 (FC 02)
pub async fn read_discrete_inputs(&mut self, addr: u16, cnt: u16) -> Result<Vec<bool>, ModbusAppError> {
self.ctx
.read_discrete_inputs(addr, cnt)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 读取保持寄存器 (FC 03)
pub async fn read_holding_registers(&mut self, addr: u16, cnt: u16) -> Result<Vec<u16>, ModbusAppError> {
self.ctx
.read_holding_registers(addr, cnt)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 读取输入寄存器 (FC 04)
pub async fn read_input_registers(&mut self, addr: u16, cnt: u16) -> Result<Vec<u16>, ModbusAppError> {
self.ctx
.read_input_registers(addr, cnt)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 写单个线圈 (FC 05)
pub async fn write_single_coil(&mut self, addr: u16, value: bool) -> Result<(), ModbusAppError> {
self.ctx
.write_single_coil(addr, value)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 写单个寄存器 (FC 06)
pub async fn write_single_register(&mut self, addr: u16, value: u16) -> Result<(), ModbusAppError> {
self.ctx
.write_single_register(addr, value)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 写多个线圈 (FC 15)
pub async fn write_multiple_coils(&mut self, addr: u16, values: &[bool]) -> Result<(), ModbusAppError> {
self.ctx
.write_multiple_coils(addr, values)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 写多个寄存器 (FC 16)
pub async fn write_multiple_registers(&mut self, addr: u16, values: &[u16]) -> Result<(), ModbusAppError> {
self.ctx
.write_multiple_registers(addr, values)
.await
.map_err(|e| ModbusAppError::ProtocolError(e.to_string()))?
.map_err(|e| ModbusAppError::ProtocolError(format!("异常: {:?}", e)))
}

/// 执行读取请求
pub async fn execute_read(&mut self, req: &ReadRequest) -> Result<ReadResult, ModbusAppError> {
match req.function_code {
FunctionCode::ReadCoils => {
let coils = self.read_coils(req.start_address, req.quantity).await?;
Ok(ReadResult::Coils(coils))
}
FunctionCode::ReadDiscreteInputs => {
let inputs = self.read_discrete_inputs(req.start_address, req.quantity).await?;
Ok(ReadResult::Coils(inputs))
}
FunctionCode::ReadHoldingRegisters => {
let regs = self.read_holding_registers(req.start_address, req.quantity).await?;
Ok(ReadResult::Registers(regs))
}
FunctionCode::ReadInputRegisters => {
let regs = self.read_input_registers(req.start_address, req.quantity).await?;
Ok(ReadResult::Registers(regs))
}
_ => Err(ModbusAppError::InvalidParam("不是读取功能码".to_string())),
}
}

/// 执行写入请求
pub async fn execute_write(&mut self, req: &WriteRequest) -> Result<(), ModbusAppError> {
match req.function_code {
FunctionCode::WriteSingleCoil => {
let value = req.values.first().copied().unwrap_or(0) != 0;
self.write_single_coil(req.address, value).await
}
FunctionCode::WriteSingleRegister => {
let value = req.values.first().copied().unwrap_or(0);
self.write_single_register(req.address, value).await
}
FunctionCode::WriteMultipleCoils => {
let values: Vec<bool> = req.values.iter().map(|&v| v != 0).collect();
self.write_multiple_coils(req.address, &values).await
}
FunctionCode::WriteMultipleRegisters => {
self.write_multiple_registers(req.address, &req.values).await
}
_ => Err(ModbusAppError::InvalidParam("不是写入功能码".to_string())),
}
}

/// 获取连接描述
pub fn connection_description(&self) -> &str {
&self.mode
}
}

5、modbus_types.rs

use thiserror::Error;

/// Modbus 功能码
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum FunctionCode {
ReadCoils = 0x01,
ReadDiscreteInputs = 0x02,
ReadHoldingRegisters = 0x03,
ReadInputRegisters = 0x04,
WriteSingleCoil = 0x05,
WriteSingleRegister = 0x06,
WriteMultipleCoils = 0x0F,
WriteMultipleRegisters = 0x10,
}

impl FunctionCode {
pub fn from_u8(v: u8) -> Option<Self> {
match v {
0x01 => Some(Self::ReadCoils),
0x02 => Some(Self::ReadDiscreteInputs),
0x03 => Some(Self::ReadHoldingRegisters),
0x04 => Some(Self::ReadInputRegisters),
0x05 => Some(Self::WriteSingleCoil),
0x06 => Some(Self::WriteSingleRegister),
0x0F => Some(Self::WriteMultipleCoils),
0x10 => Some(Self::WriteMultipleRegisters),
_ => None,
}
}

pub fn is_read(&self) -> bool {
matches!(
self,
Self::ReadCoils
| Self::ReadDiscreteInputs
| Self::ReadHoldingRegisters
| Self::ReadInputRegisters
)
}

pub fn is_coil(&self) -> bool {
matches!(self, Self::ReadCoils | Self::ReadDiscreteInputs | Self::WriteSingleCoil | Self::WriteMultipleCoils)
}

pub fn display_name(&self) -> &'static str {
match self {
Self::ReadCoils => "01 读线圈 (Read Coils)",
Self::ReadDiscreteInputs => "02 读离散输入 (Read Discrete Inputs)",
Self::ReadHoldingRegisters => "03 读保持寄存器 (Read Holding Registers)",
Self::ReadInputRegisters => "04 读输入寄存器 (Read Input Registers)",
Self::WriteSingleCoil => "05 写单个线圈 (Write Single Coil)",
Self::WriteSingleRegister => "06 写单个寄存器 (Write Single Register)",
Self::WriteMultipleCoils => "15 写多个线圈 (Write Multiple Coils)",
Self::WriteMultipleRegisters => "16 写多个寄存器 (Write Multiple Registers)",
}
}

/// 用于 ComboBox 显示
pub fn short_name(&self) -> &'static str {
match self {
Self::ReadCoils => "01 – Read Coils",
Self::ReadDiscreteInputs => "02 – Read Discrete Inputs",
Self::ReadHoldingRegisters => "03 – Read Holding Registers",
Self::ReadInputRegisters => "04 – Read Input Registers",
Self::WriteSingleCoil => "05 – Write Single Coil",
Self::WriteSingleRegister => "06 – Write Single Register",
Self::WriteMultipleCoils => "15 – Write Multiple Coils",
Self::WriteMultipleRegisters => "16 – Write Multiple Registers",
}
}
}

/// 连接模式
#[derive(Debug, Clone)]
pub enum ConnectionMode {
Tcp {
ip: String,
port: u16,
},
Rtu {
port: String,
baud_rate: u32,
data_bits: u8,
stop_bits: u8,
parity: ParityMode,
},
}

/// 校验模式
#[derive(Debug, Clone, Copy)]
pub enum ParityMode {
None,
Even,
Odd,
}

impl std::fmt::Display for ParityMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
ParityMode::None => write!(f, "N"),
ParityMode::Even => write!(f, "E"),
ParityMode::Odd => write!(f, "O"),
}
}
}

/// Modbus 错误类型
#[derive(Debug, Error)]
pub enum ModbusAppError {
#[error("连接错误: {0}")]
ConnectionError(String),

#[error("通信超时")]
Timeout,

#[error("协议错误: {0}")]
ProtocolError(String),

#[error("IO 错误: {0}")]
IoError(#[from] std::io::Error),

#[error("未连接")]
NotConnected,

#[error("参数错误: {0}")]
InvalidParam(String),
}

/// 读取结果
#[derive(Debug, Clone)]
pub enum ReadResult {
Registers(Vec<u16>),
Coils(Vec<bool>),
}

/// 读取请求参数
#[derive(Debug, Clone)]
pub struct ReadRequest {
pub function_code: FunctionCode,
pub slave_id: u8,
pub start_address: u16,
pub quantity: u16,
}

/// 写入请求参数
#[derive(Debug, Clone)]
pub struct WriteRequest {
pub function_code: FunctionCode,
pub slave_id: u8,
pub address: u16,
pub values: Vec<u16>,
}

6、statistics.rs

/// 通信统计
#[derive(Clone)]
pub struct CommStatistics {
pub tx_count: i32,
pub rx_count: i32,
pub error_count: i32,
pub last_error: String,
}

impl CommStatistics {
pub fn new() -> Self {
Self {
tx_count: 0,
rx_count: 0,
error_count: 0,
last_error: String::new(),
}
}

pub fn record_tx(&mut self) {
self.tx_count += 1;
}

pub fn record_rx(&mut self) {
self.rx_count += 1;
}

pub fn record_error(&mut self, error: &str) {
self.error_count += 1;
self.last_error = error.to_string();
}

pub fn reset(&mut self) {
self.tx_count = 0;
self.rx_count = 0;
self.error_count = 0;
self.last_error.clear();
}
}

7、main.rs

slint::include_modules!();

mod modbus_types;
mod modbus_client;
mod data_model;
mod comm_log;
mod statistics;

use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use tokio::sync::Mutex as TokioMutex;

use modbus_types::*;
use modbus_client::ModbusClientWrapper;
use data_model::RegisterModel;
use comm_log::CommLog;
use statistics::CommStatistics;

/// 应用全局状态
struct AppState {
client: Arc<TokioMutex<Option<ModbusClientWrapper>>>,
model: Arc<TokioMutex<RegisterModel>>,
log: Arc<TokioMutex<CommLog>>,
stats: Arc<TokioMutex<CommStatistics>>,
poll_cancel: Arc<AtomicBool>,
}

impl AppState {
fn new() -> Self {
Self {
client: Arc::new(TokioMutex::new(None)),
model: Arc::new(TokioMutex::new(RegisterModel::new())),
log: Arc::new(TokioMutex::new(CommLog::new())),
stats: Arc::new(TokioMutex::new(CommStatistics::new())),
poll_cancel: Arc::new(AtomicBool::new(false)),
}
}
}

/// 将寄存器数据更新到 UI
fn update_ui_registers(ui: &MainWindow, model: &RegisterModel, stats: &CommStatistics) {
let rows = model.generate_rows();
let slint_rows: Vec<RegisterRow> = rows
.into_iter()
.map(|(addr, unsigned, signed, hex, binary, float, ascii)| RegisterRow {
address: addr,
value_unsigned: unsigned.into(),
value_signed: signed.into(),
value_hex: hex.into(),
value_binary: binary.into(),
value_float: float.into(),
value_ascii: ascii.into(),
})
.collect();

ui.set_registers(slint::ModelRc::new(slint::VecModel::from(slint_rows)));
ui.set_tx_count(stats.tx_count);
ui.set_rx_count(stats.rx_count);
ui.set_error_count(stats.error_count);
ui.set_last_error(stats.last_error.clone().into());
}

/// 将日志更新到 UI
fn update_ui_log(ui: &MainWindow, log: &CommLog) {
let entries: Vec<LogEntry> = log
.entries()
.iter()
.map(|e| LogEntry {
timestamp: e.timestamp.clone().into(),
direction: e.direction,
raw_text: e.raw_text.clone().into(),
})
.collect();

ui.set_log_entries(slint::ModelRc::new(slint::VecModel::from(entries)));
}

fn main() {
env_logger::init();
log::info!("Modbus 调试助手启动");

let runtime = tokio::runtime::Runtime::new().expect("Failed to create tokio runtime");
let _enter = runtime.enter();

let ui = MainWindow::new().expect("Failed to create main window");
let state = AppState::new();

// 功能码选项（共享给对话框）
let read_fc_choices: Vec<slint::SharedString> = vec![
"01 – Read Coils".into(),
"02 – Read Discrete Inputs".into(),
"03 – Read Holding Registers".into(),
"04 – Read Input Registers".into(),
];

let write_fc_choices: Vec<slint::SharedString> = vec![
"05 – Write Single Coil".into(),
"06 – Write Single Register".into(),
"15 – Write Multiple Coils".into(),
"16 – Write Multiple Registers".into(),
];

let rtu_baud_rates: Vec<slint::SharedString> = vec![
"1200".into(), "2400".into(), "4800".into(), "9600".into(),
"19200".into(), "38400".into(), "57600".into(), "115200".into(),
];

let rtu_data_bits: Vec<slint::SharedString> = vec![
"5".into(), "6".into(), "7".into(), "8".into(),
];

let rtu_stop_bits: Vec<slint::SharedString> = vec![
"1".into(), "2".into(),
];

let rtu_parity: Vec<slint::SharedString> = vec![
"None".into(), "Even".into(), "Odd".into(),
];

// ===== 注册回调 =====
register_toolbar_callbacks(&ui, &state);
register_cell_edit_callback(&ui, &state);

// 存储对话框需要的选项数据
let read_fc_for_dialog = read_fc_choices.clone();
let write_fc_for_dialog = write_fc_choices.clone();
let baud_rates_for_dialog = rtu_baud_rates.clone();
let data_bits_for_dialog = rtu_data_bits.clone();
let stop_bits_for_dialog = rtu_stop_bits.clone();
let parity_for_dialog = rtu_parity.clone();

// 连接按钮回调 → 显示连接方式选择对话框
{
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();
let read_fcs = read_fc_for_dialog.clone();
let write_fcs = write_fc_for_dialog.clone();
let baud_rates = baud_rates_for_dialog.clone();
let data_bits_list = data_bits_for_dialog.clone();
let stop_bits_list = stop_bits_for_dialog.clone();
let parity_list = parity_for_dialog.clone();

ui.on_on_connect(move || {
show_connection_dialog(
&ui_weak,
&state_client,
&state_log,
&state_stats,
&read_fcs,
&write_fcs,
&baud_rates,
&data_bits_list,
&stop_bits_list,
&parity_list,
);
});
}

// 断开连接
{
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();
let poll_cancel = state.poll_cancel.clone();

ui.on_on_disconnect(move || {
let ui_weak = ui_weak.clone();
let client = state_client.clone();
let log = state_log.clone();
let stats = state_stats.clone();
let poll_cancel = poll_cancel.clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
// 停止轮询
poll_cancel.store(true, Ordering::SeqCst);

// 清空客户端
if let Ok(mut guard) = client.try_lock() {
*guard = None;
}

ui.set_connected(false);
ui.set_connection_mode("".into());
ui.set_connection_info("".into());
ui.set_polling(false);

if let Ok(mut log_guard) = log.try_lock() {
log_guard.log_error("已断开连接");
update_ui_log(&ui, &log_guard);
}
}
})
.ok();
});
}

// 读取
{
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_model = state.model.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();
let read_fcs = read_fc_for_dialog.clone();

ui.on_on_read(move || {
let ui_weak = ui_weak.clone();
let client = state_client.clone();
let model = state_model.clone();
let log = state_log.clone();
let stats = state_stats.clone();
let fc_choices = read_fcs.clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
show_read_dialog(&ui, &client, &model, &log, &stats, &fc_choices);
}
})
.ok();
});
}

// 写入
{
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();
let write_fcs = write_fc_for_dialog.clone();

ui.on_on_write(move || {
let ui_weak = ui_weak.clone();
let client = state_client.clone();
let log = state_log.clone();
let stats = state_stats.clone();
let fc_choices = write_fcs.clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
show_write_dialog(&ui, &client, &log, &stats, &fc_choices);
}
})
.ok();
});
}

// 自动轮询
{
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_model = state.model.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();
let poll_cancel = state.poll_cancel.clone();

ui.on_on_poll_toggle(move || {
let ui_weak = ui_weak.clone();
let client = state_client.clone();
let model = state_model.clone();
let log = state_log.clone();
let stats = state_stats.clone();
let poll_cancel = poll_cancel.clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
let is_polling = ui.get_polling();

if is_polling {
// 停止轮询
poll_cancel.store(true, Ordering::SeqCst);
ui.set_polling(false);
} else {
// 启动轮询
poll_cancel.store(false, Ordering::SeqCst);
ui.set_polling(true);

let ui_weak2 = ui.as_weak();
let client2 = client.clone();
let model2 = model.clone();
let log2 = log.clone();
let stats2 = stats.clone();
let poll_cancel2 = poll_cancel.clone();

tokio::spawn(async move {
start_polling(
ui_weak2,
client2,
model2,
log2,
stats2,
poll_cancel2,
)
.await;
});
}
}
})
.ok();
});
}

// 清空日志
{
let ui_weak = ui.as_weak();
let state_log = state.log.clone();

ui.on_on_clear_log(move || {
let ui_weak = ui_weak.clone();
let log = state_log.clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
if let Ok(mut log_guard) = log.try_lock() {
log_guard.clear();
update_ui_log(&ui, &log_guard);
}
}
})
.ok();
});
}

log::info!("UI 初始化完成，启动事件循环");
ui.run().expect("Failed to run event loop");
}

// ============================================================
// 回调注册
// ============================================================

fn register_toolbar_callbacks(_ui: &MainWindow, _state: &AppState) {
// 工具栏回调在 main() 中单独注册，因为它们需要更多上下文
}

fn register_cell_edit_callback(ui: &MainWindow, state: &AppState) {
let ui_weak = ui.as_weak();
let state_client = state.client.clone();
let state_log = state.log.clone();
let state_stats = state.stats.clone();

ui.on_on_cell_edit(move |address, value| {
let ui_weak = ui_weak.clone();
let client = state_client.clone();
let log = state_log.clone();
let stats = state_stats.clone();
let value_str = value.to_string();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
let addr = address as u16;

// 解析值
let parsed = data_model::format_utils::parse_value(&value_str);
let val = match parsed {
Ok(v) => v,
Err(e) => {
if let Ok(mut log_guard) = log.try_lock() {
log_guard.log_error(&format!("写入失败: {}", e));
update_ui_log(&ui, &log_guard);
}
return;
}
};

let client_clone = client.clone();
let log_clone = log.clone();
let stats_clone = stats.clone();
let ui_weak2 = ui.as_weak();

tokio::spawn(async move {
let mut guard = client_clone.lock().await;
if let Some(ref mut c) = *guard {
let req = WriteRequest {
function_code: FunctionCode::WriteSingleRegister,
slave_id: 1,
address: addr,
values: vec![val],
};

let mut log_guard = log_clone.lock().await;
log_guard.log_tx(&format!(
"FC06 写寄存器 地址={} 值={}",
addr, val
));
drop(log_guard);

match c.execute_write(&req).await {
Ok(()) => {
if let Ok(mut stats_guard) = stats_clone.try_lock() {
stats_guard.record_tx();
stats_guard.record_rx();
}
let mut log_guard = log_clone.lock().await;
log_guard.log_rx("写入成功");
let log_snapshot = (*log_guard).clone();
drop(log_guard);
slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak2.upgrade() {
update_ui_log(&ui, &log_snapshot);
}
})
.ok();
}
Err(e) => {
if let Ok(mut stats_guard) = stats_clone.try_lock() {
stats_guard.record_error(&e.to_string());
}
let mut log_guard = log_clone.lock().await;
log_guard.log_error(&format!("写入失败: {}", e));
let log_snapshot = (*log_guard).clone();
drop(log_guard);
slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak2.upgrade() {
update_ui_log(&ui, &log_snapshot);
}
})
.ok();
}
}
}
});
}
})
.ok();
});
}

// ============================================================
// 连接对话框
// ============================================================

fn show_connection_dialog(
ui_weak: &slint::Weak<MainWindow>,
client: &Arc<TokioMutex<Option<ModbusClientWrapper>>>,
log: &Arc<TokioMutex<CommLog>>,
_stats: &Arc<TokioMutex<CommStatistics>>,
_read_fcs: &[slint::SharedString],
_write_fcs: &[slint::SharedString],
_baud_rates: &[slint::SharedString],
_data_bits_list: &[slint::SharedString],
_stop_bits_list: &[slint::SharedString],
_parity_list: &[slint::SharedString],
) {
// 为了简单起见，先显示 TCP 连接对话框
// 后续可以增加选择对话框让用户选择 TCP 或 RTU
let dialog = TcpSetupDialog::new().expect("Failed to create TCP dialog");
dialog.set_ip_address("127.0.0.1".into());
dialog.set_port(502);
dialog.set_slave_id(1);

let ui_weak = ui_weak.clone();
let client = client.clone();
let log = log.clone();

dialog.on_on_confirm({
let dialog = dialog.as_weak();
let ui_weak = ui_weak.clone();
let client = client.clone();
let log = log.clone();

move || {
if let Some(dlg) = dialog.upgrade() {
let ip = dlg.get_ip_address().to_string();
let port = dlg.get_port() as u16;
let slave_id = dlg.get_slave_id() as u8;

let ui_weak = ui_weak.clone();
let client = client.clone();
let log = log.clone();

let dialog_weak = dialog.clone();
tokio::spawn(async move {
let result = ModbusClientWrapper::connect_tcp(&ip, port, slave_id).await;

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
match result {
Ok(c) => {
tokio::spawn(async move {
let mut guard = client.lock().await;
*guard = Some(c);
});

ui.set_connected(true);
ui.set_connection_mode("TCP".into());
ui.set_connection_info(
format!("{}:{}", ip, port).into(),
);
ui.set_slave_id(slave_id as i32);

if let Ok(mut log_guard) = log.try_lock() {
log_guard.log_tx(&format!(
"TCP 连接成功 {}:{}",
ip, port
));
update_ui_log(&ui, &log_guard);
}
}
Err(e) => {
let err_msg = e.to_string();
ui.set_last_error(err_msg.clone().into());

if let Ok(mut log_guard) = log.try_lock() {
log_guard
.log_error(&format!("TCP 连接失败: {}", err_msg));
update_ui_log(&ui, &log_guard);
}
}
}
}
})
.ok();

// 关闭对话框
if let Some(dlg) = dialog_weak.upgrade() {
let _ = dlg.hide();
}
});
}
}
});

dialog.on_on_cancel({
let dialog = dialog.as_weak();
move || {
if let Some(dlg) = dialog.upgrade() {
let _ = dlg.hide();
}
}
});

dialog.show().expect("Failed to show TCP dialog");
}

// ============================================================
// 读取对话框
// ============================================================

fn show_read_dialog(
ui: &MainWindow,
client: &Arc<TokioMutex<Option<ModbusClientWrapper>>>,
model: &Arc<TokioMutex<RegisterModel>>,
log: &Arc<TokioMutex<CommLog>>,
stats: &Arc<TokioMutex<CommStatistics>>,
fc_choices: &[slint::SharedString],
) {
let dialog = ReadSetupDialog::new().expect("Failed to create read dialog");
dialog.set_function_codes(slint::ModelRc::new(slint::VecModel::from(
fc_choices.to_vec(),
)));
dialog.set_function_index(2); // 默认 Read Holding Registers
dialog.set_slave_id(ui.get_slave_id());
dialog.set_start_address(0);
dialog.set_quantity(10);

let ui_weak = ui.as_weak();
let client = client.clone();
let model = model.clone();
let log = log.clone();
let stats = stats.clone();

dialog.on_on_confirm({
let dialog = dialog.as_weak();
let ui_weak = ui_weak.clone();
let client = client.clone();
let model = model.clone();
let log = log.clone();
let stats = stats.clone();

move || {
if let Some(dlg) = dialog.upgrade() {
let fc_index = dlg.get_function_index() as u8;
let slave_id = dlg.get_slave_id() as u8;
let start_addr = dlg.get_start_address() as u16;
let quantity = dlg.get_quantity() as u16;

let function_code = match fc_index {
0 => FunctionCode::ReadCoils,
1 => FunctionCode::ReadDiscreteInputs,
2 => FunctionCode::ReadHoldingRegisters,
3 => FunctionCode::ReadInputRegisters,
_ => FunctionCode::ReadHoldingRegisters,
};

let req = ReadRequest {
function_code,
slave_id,
start_address: start_addr,
quantity,
};

let ui_weak = ui_weak.clone();
let client = client.clone();
let model = model.clone();
let log = log.clone();
let stats = stats.clone();
let dialog_weak = dialog.clone();

tokio::spawn(async move {
let mut guard = client.lock().await;
if let Some(ref mut c) = *guard {
// 记录发送
{
let mut log_guard = log.lock().await;
log_guard.log_tx(&format!(
"FC{:02X} 读取 从站={} 地址={} 数量={}",
function_code as u8, slave_id, start_addr, quantity
));
}

let result = c.execute_read(&req).await;

// 记录接收/错误
{
let mut log_guard = log.lock().await;
match &result {
Ok(_) => log_guard.log_rx("读取成功"),
Err(e) => log_guard.log_error(&format!("读取失败: {}", e)),
}
}

// 更新状态
{
let mut stats_guard = stats.try_lock().unwrap();
stats_guard.record_tx();
match &result {
Ok(_) => stats_guard.record_rx(),
Err(e) => stats_guard.record_error(&e.to_string()),
}
}

// 更新模型
if let Ok(ref read_result) = result {
model
.try_lock().unwrap()
.update_from_result(read_result, start_addr, function_code);
}

// 更新 UI
let model_snapshot = model.try_lock().unwrap().clone();
let stats_snapshot = stats.try_lock().unwrap().clone();

slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
update_ui_registers(&ui, &model_snapshot, &stats_snapshot);

let log_guard = log.try_lock();
if let Ok(log_guard) = log_guard {
update_ui_log(&ui, &log_guard);
}

ui.set_function_code(function_code as i32);
}
})
.ok();
} else {
slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak.upgrade() {
ui.set_last_error("未连接到设备".into());
}
})
.ok();
}

if let Some(dlg) = dialog_weak.upgrade() {
let _ = dlg.hide();
}
});
}
}
});

dialog.on_on_cancel({
let dialog = dialog.as_weak();
move || {
if let Some(dlg) = dialog.upgrade() {
let _ = dlg.hide();
}
}
});

dialog.show().expect("Failed to show read dialog");
}