suyu
/
suyu_two
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Požadavky na natažení 0 Vydání 0 Wiki Aktivita
综合平台编程器项目的远程存储
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
162 Revize
1 Větev
183 MiB
 
 
 
 
Strom: 3bd8c15835
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „3bd8c15835“
${ noResults }
suyu_two/app/src/infrastructure/plc_communication_service.cpp

1004 řádky
37 KiB
Surový Blame Historie 

  1. #include "plc_communication_service.h"

  2. 

  3. #include "plc_communication_error_classifier.h"

  4. #include "plc_register_repository.h"

  5. 

  6. #include <QModbusDataUnit>

  7. #include <QModbusDevice>

  8. #include <QModbusReply>

  9. #include <QModbusRtuSerialMaster>

  10. #include <QSerialPort>

  11. #include <QVariant>

  12. 

  13. #include <algorithm>

  14. #include <utility>

  15. 

  16. namespace {

  17. 

  18. // 故障恢复时，两次轻量探测之间等待的时间

  19. constexpr int kRecoveryProbeIntervalMs = 2000;

  20. 

  21. // Qt 使用 QString，项目内部错误信息统一使用 UTF-8 std::string

  22. std::string toUtf8(const QString &value)

  23. {

  24.     const QByteArray bytes = value.toUtf8();

  25.     return std::string(bytes.constData(), static_cast<std::size_t>(bytes.size()));

  26. }

  27. 

  28. // M 区在 Modbus 中按线圈读取，D 区按保持寄存器读取

  29. QModbusDataUnit::RegisterType registerType(RegisterArea area)

  30. {

  31.     return area == RegisterArea::M

  32.         ? QModbusDataUnit::Coils : QModbusDataUnit::HoldingRegisters;

  33. }

  34. 

  35. // 只有超时和 PLC 不响应属于可以自动探测恢复的故障

  36. bool isRecoverableTimeout(PlcCommunicationError error)

  37. {

  38.     return error == PlcCommunicationError::PlcNotResponding

  39.         || error == PlcCommunicationError::CommunicationTimeout;

  40. }

  41. 

  42. // Connected 正常轮询，Recovering 正在恢复后的重新首读

  43. bool isReadingState(PlcConnectionState state)

  44. {

  45.     return state == PlcConnectionState::Connected

  46.         || state == PlcConnectionState::Recovering;

  47. }

  48. 

  49. // 排序并去重轮询地址，同时检查地址总量上限

  50. bool normalizePollAddresses(

  51.     const std::vector<RegisterAddress> &addresses,

  52.     std::vector<RegisterAddress> *normalized,

  53.     std::string *error)

  54. {

  55.     // 先复制，后续排序和去重不能改变调用方传入的地址列表

  56.     *normalized = addresses;

  57.     if (std::any_of(

  58.             normalized->cbegin(), normalized->cend(),

  59.             [](const RegisterAddress &address) { return !address.isValid(); }))

  60.     {

  61.         *error = "PLC 轮询地址中包含无效的 M/D 地址";

  62.         return false;

  63.     }

  64.     std::sort(

  65.         normalized->begin(), normalized->end(),

  66.         [](const RegisterAddress &left, const RegisterAddress &right)

  67.         {

  68.             return left.area() == right.area()

  69.                 ? left.index() < right.index()

  70.                 : left.area() == RegisterArea::M;

  71.         });

  72.     normalized->erase(

  73.         std::unique(normalized->begin(), normalized->end()), normalized->end());

  74.     if (normalized->size() > ProjectLimits::kMaximumPollAddresses)

  75.     {

  76.         *error = "PLC 轮询的去重 M/D 地址最多为 256 个";

  77.         return false;

  78.     }

  79.     return true;

  80. }

  81. 

  82. // 判断读块边界是否落在多字范围内部，避免拆开一次多字读取

  83. bool boundaryBelongsToMultiWordRange(

  84.     RegisterArea area,

  85.     int boundary,

  86.     const std::vector<RegisterWordRange> &ranges)

  87. {

  88.     return std::any_of(

  89.         ranges.cbegin(), ranges.cend(),

  90.         [area, boundary](const RegisterWordRange &range)

  91.         {

  92.             return range.start.area() == area

  93.                 && range.start.index() <= boundary

  94.                 && boundary < range.start.index() + range.wordCount - 1;

  95.         });

  96. }

  97. 

  98. // 将地址集合拆成符合 Modbus 单次读取上限的连续读块

  99. bool calculatePollBlocks(

  100.     const std::vector<RegisterAddress> &addresses,

  101.     const std::vector<RegisterWordRange> &multi_word_ranges,

  102.     std::vector<PlcPollBlock> *blocks)

  103. {

  104.     blocks->clear();

  105.     if (addresses.empty())

  106.     {

  107.         blocks->push_back({RegisterArea::M, 0, 1});

  108.         blocks->push_back({RegisterArea::D, 0, 1});

  109.         return true;

  110.     }

  111. 

  112.     // 先处理同一区域内连续地址，再按单次读取上限切分

  113.     std::size_t run_start = 0U;

  114.     while (run_start < addresses.size())

  115.     {

  116.         std::size_t run_end = run_start;

  117.         while (run_end + 1U < addresses.size()

  118.                && addresses[run_end + 1U].area() == addresses[run_start].area()

  119.                && addresses[run_end + 1U].index() == addresses[run_end].index() + 1)

  120.         {

  121.             ++run_end;

  122.         }

  123.         const RegisterArea area = addresses[run_start].area();

  124.         int cursor = addresses[run_start].index();

  125.         const int last = addresses[run_end].index();

  126.         while (cursor <= last)

  127.         {

  128.             int block_end = std::min(

  129.                 cursor + ProjectLimits::kMaximumModbusReadCount - 1, last);

  130.             while (block_end < last

  131.                    && boundaryBelongsToMultiWordRange(

  132.                        area, block_end, multi_word_ranges))

  133.             {

  134.                 --block_end;

  135.             }

  136.             if (block_end < cursor)

  137.             {

  138.                 blocks->clear();

  139.                 return false;

  140.             }

  141.             blocks->push_back({area, cursor, block_end - cursor + 1});

  142.             cursor = block_end + 1;

  143.         }

  144.         run_start = run_end + 1U;

  145.     }

  146.     return true;

  147. }

  148. 

  149. } // namespace

  150. 

  151. // 创建 Qt Modbus 主站，绑定异步信号和 PLC 缓存写入回调

  152. PlcCommunicationService::PlcCommunicationService(

  153.     PlcRegisterRepository &repository,

  154.     QObject *parent)

  155.     : QObject(parent),

  156.       repository_(repository),

  157.       master_(std::make_unique<QModbusRtuSerialMaster>())

  158. {

  159.     // 仓库只负责缓存；写入请求通过这里注入的回调转给通信服务

  160.     repository_.setWriteHandlers(

  161.         [this](const RegisterAddress &address, bool value)

  162.         {

  163.             // PLC 仓库收到 M 写入时转成 Modbus 线圈单写请求

  164.             return sendBitWrite(address, value);

  165.         },

  166.         [this](const RegisterAddress &address, std::int16_t value)

  167.         {

  168.             // PLC 仓库收到单个 D 写入时转成保持寄存器单写请求

  169.             return sendWordWrite(address, value);

  170.         },

  171.         [this](const RegisterAddress &address,

  172.                const std::vector<std::int16_t> &values)

  173.         {

  174.             // PLC 仓库收到连续 D 写入时转成保持寄存器多写请求

  175.             return sendWordsWrite(address, values);

  176.         });

  177.     // 轮询定时器每次只推动一个读块，避免一次压入大量异步请求

  178.     connect(&poll_timer_, &QTimer::timeout, this, &PlcCommunicationService::pollNextBlock);

  179.     recovery_timer_.setSingleShot(true);

  180.     // PLC 超时进入 Faulted 后，由恢复定时器调用轻量探测入口

  181.     connect(

  182.         &recovery_timer_,

  183.         &QTimer::timeout,

  184.         this,

  185.         &PlcCommunicationService::probeRecovery);

  186.     // Qt 串口状态变化是异步通知，所有连接状态都从这里统一处理

  187.     connect(master_.get(), &QModbusClient::stateChanged,

  188.             this,

  189.             [this](QModbusDevice::State device_state)

  190.             {

  191.                 if (device_state == QModbusDevice::ConnectedState)

  192.                 {

  193.                     // 串口连接成功后立即开始轮询，并不代表首读已经完成

  194.                     serial_session_opened_ = true;

  195.                     setState(PlcConnectionState::Connected);

  196.                     poll_timer_.start(configuration_.pollIntervalMs);

  197.                     // 串口连上后立即异步读取第一个 M/D 地址块

  198.                     pollNextBlock();

  199.                 }

  200.                 else if (device_state == QModbusDevice::ConnectingState)

  201.                 {

  202.                     serial_session_opened_ = false;

  203.                     setState(PlcConnectionState::Connecting);

  204.                 }

  205.                 else if (device_state == QModbusDevice::UnconnectedState)

  206.                 {

  207.                     // 主动断开和意外断线要区分，后者需要报告故障

  208.                     if (disconnecting_)

  209.                     {

  210.                         serial_session_opened_ = false;

  211.                     }

  212.                     else if (serial_session_opened_)

  213.                     {

  214.                         handleUnexpectedDisconnect();

  215.                     }

  216.                     else if (state_ != PlcConnectionState::Faulted)

  217.                     {

  218.                         setState(PlcConnectionState::Disconnected);

  219.                     }

  220.                 }

  221.             });

  222.     // Qt 报告底层错误时，转换为项目自己的错误和状态

  223.     connect(master_.get(), &QModbusClient::errorOccurred,

  224.             this,

  225.             [this](QModbusDevice::Error error)

  226.             {

  227.                 if (error != QModbusDevice::NoError)

  228.                 {

  229.                     // 底层 Modbus 错误统一交给项目错误分类和恢复流程

  230.                     handleModbusError(error);

  231.                 }

  232.             });

  233. }

  234. 

  235. // 释放通信服务持有的 Qt 资源

  236. PlcCommunicationService::~PlcCommunicationService() = default;

  237. 

  238. // 校验串口配置并启动一次新的 PLC 异步连接

  239. PlcCommunicationResult PlcCommunicationService::connectDevice(

  240.     const PlcSerialConfiguration &configuration)

  241. {

  242.     const PlcCommunicationResult validation =

  243.         validatePlcSerialConfiguration(configuration);

  244.     if (!validation.succeeded)

  245.     {

  246.         return validation;

  247.     }

  248.     if (state_ == PlcConnectionState::Disconnected

  249.         && master_->state() != QModbusDevice::UnconnectedState)

  250.     {

  251.         closeSerialSession();

  252.     }

  253.     if (master_->state() != QModbusDevice::UnconnectedState)

  254.     {

  255.         return {false, "PLC 连接已经启动，请先断开当前连接"};

  256.     }

  257.     // 每次连接都递增代次；旧连接的异步回复即使晚到也不能污染新缓存

  258.     configuration_ = configuration;

  259.     ++connection_generation_;

  260.     disconnecting_ = false;

  261.     serial_session_opened_ = false;

  262.     received_valid_response_ = false;

  263.     last_error_type_ = PlcCommunicationError::None;

  264.     last_error_.clear();

  265.     // 把项目配置转换成 Qt 串口参数

  266.     master_->setConnectionParameter(

  267.         QModbusDevice::SerialPortNameParameter,

  268.         QString::fromStdString(configuration.portName));

  269.     master_->setConnectionParameter(

  270.         QModbusDevice::SerialBaudRateParameter, configuration.baudRate);

  271.     master_->setConnectionParameter(

  272.         QModbusDevice::SerialDataBitsParameter,

  273.         static_cast<QSerialPort::DataBits>(configuration.dataBits));

  274.     master_->setConnectionParameter(

  275.         QModbusDevice::SerialParityParameter,

  276.         static_cast<QSerialPort::Parity>(configuration.parity));

  277.     master_->setConnectionParameter(

  278.         QModbusDevice::SerialStopBitsParameter,

  279.         static_cast<QSerialPort::StopBits>(configuration.stopBits));

  280.     master_->setTimeout(configuration.responseTimeoutMs);

  281.     master_->setNumberOfRetries(configuration.retries);

  282.     // 新连接必须重新完成完整首读，不能沿用上一条连接的运行资格

  283.     repository_.invalidate();

  284.     updateInitialReadCompleted(false, true);

  285.     rebuildPollBlocks();

  286.     setState(PlcConnectionState::Connecting);

  287.     // 只发起异步串口连接，连接结果由 Qt 状态回调继续推进

  288.     if (!master_->connectDevice())

  289.     {

  290.         if (last_error_.empty())

  291.         {

  292.             const QModbusDevice::Error error = master_->error() == QModbusDevice::NoError

  293.                 ? QModbusDevice::ConnectionError : master_->error();

  294.             // 串口连接请求启动失败也进入统一错误分类和状态更新

  295.             handleModbusError(error);

  296.         }

  297.         return {false, last_error_};

  298.     }

  299.     return {true, {}};

  300. }

  301. 

  302. // 停止定时器、关闭串口并清除本次连接的缓存有效状态

  303. void PlcCommunicationService::disconnectDevice()

  304. {

  305.     // 关闭串口、清除缓存有效标记，防止断开后继续使用旧值

  306.     closeSerialSession();

  307.     repository_.invalidate();

  308.     updateInitialReadCompleted(false, true);

  309.     last_error_type_ = PlcCommunicationError::None;

  310.     last_error_.clear();

  311.     setState(PlcConnectionState::Disconnected);

  312. }

  313. 

  314. // 使用默认的单字范围设置轮询地址

  315. PlcCommunicationResult PlcCommunicationService::setPollAddresses(

  316.     const std::vector<RegisterAddress> &addresses)

  317. {

  318.     return setPollAddresses(addresses, {});

  319. }

  320. 

  321. // 校验并应用地址及多字范围，必要时等待当前异步读请求结束

  322. PlcCommunicationResult PlcCommunicationService::setPollAddresses(

  323.     const std::vector<RegisterAddress> &addresses,

  324.     const std::vector<RegisterWordRange> &multi_word_ranges)

  325. {

  326.     std::vector<RegisterAddress> normalized;

  327.     std::string error;

  328.     if (!normalizePollAddresses(addresses, &normalized, &error))

  329.     {

  330.         return {false, error};

  331.     }

  332.     std::vector<RegisterWordRange> normalized_ranges = multi_word_ranges;

  333.     std::sort(

  334.         normalized_ranges.begin(), normalized_ranges.end(),

  335.         [](const RegisterWordRange &left, const RegisterWordRange &right)

  336.         {

  337.             return left.start.index() == right.start.index()

  338.                 ? left.wordCount < right.wordCount

  339.                 : left.start.index() < right.start.index();

  340.         });

  341.     normalized_ranges.erase(

  342.         std::unique(

  343.             normalized_ranges.begin(), normalized_ranges.end()),

  344.         normalized_ranges.end());

  345.     if (std::any_of(

  346.             normalized_ranges.cbegin(), normalized_ranges.cend(),

  347.             [](const RegisterWordRange &range)

  348.             {

  349.                 return !range.start.isValid()

  350.                     || range.start.area() != RegisterArea::D

  351.                     || range.wordCount < 2 || range.wordCount > 4

  352.                     || range.start.index()

  353.                         > RegisterAddress::kMaximumIndex - range.wordCount + 1;

  354.             }))

  355.     {

  356.         return {false, "多字轮询范围必须是 D 区内连续的 2~4 个字"};

  357.     }

  358.     for (const RegisterWordRange &range : normalized_ranges)

  359.     {

  360.         for (int offset = 0; offset < range.wordCount; ++offset)

  361.         {

  362.             normalized.push_back(RegisterAddress{

  363.                 RegisterArea::D, range.start.index() + offset});

  364.         }

  365.     }

  366.     std::sort(

  367.         normalized.begin(), normalized.end(),

  368.         [](const RegisterAddress &left, const RegisterAddress &right)

  369.         {

  370.             return left.area() == right.area()

  371.                 ? left.index() < right.index()

  372.                 : left.area() == RegisterArea::M;

  373.         });

  374.     normalized.erase(std::unique(normalized.begin(), normalized.end()), normalized.end());

  375.     if (normalized.size() > ProjectLimits::kMaximumPollAddresses)

  376.     {

  377.         return {false, "PLC 轮询的去重 M/D 地址最多为 256 个"};

  378.     }

  379.     std::vector<PlcPollBlock> calculated_blocks;

  380.     if (!calculatePollBlocks(normalized, normalized_ranges, &calculated_blocks))

  381.     {

  382.         return {false, "重叠的多字范围无法在单次 120 字读取边界内完整轮询"};

  383.     }

  384.     if (calculated_blocks.size() > ProjectLimits::kMaximumPollBlocks)

  385.     {

  386.         return {false, "PLC 轮询地址拆分后最多允许 8 个读块"};

  387.     }

  388.     // 当前读请求完成前暂存新集合，避免按半旧半新的地址解析回复

  389.     if (pending_reply_ != nullptr)

  390.     {

  391.         // 当前回复仍在解析旧集合，等它结束后再切换到新集合

  392.         pending_poll_addresses_ = std::move(normalized);

  393.         pending_poll_multi_word_ranges_ = std::move(normalized_ranges);

  394.         poll_update_pending_ = true;

  395.         return {true, {}};

  396.     }

  397.     poll_multi_word_ranges_ = std::move(normalized_ranges);

  398.     applyPollAddresses(normalized);

  399.     return {true, {}};

  400. }

  401. 

  402. // 返回当前 PLC 连接状态

  403. PlcConnectionState PlcCommunicationService::state() const

  404. {

  405.     return state_;

  406. }

  407. 

  408. // 返回当前连接是否已完成全部轮询块的首次读取

  409. bool PlcCommunicationService::initialReadCompleted() const

  410. {

  411.     return initial_read_completed_;

  412. }

  413. 

  414. // 返回最近一次通信错误的统一类型

  415. PlcCommunicationError PlcCommunicationService::lastErrorType() const

  416. {

  417.     return last_error_type_;

  418. }

  419. 

  420. // 返回最近一次通信错误的可读文字

  421. const std::string &PlcCommunicationService::lastError() const

  422. {

  423.     return last_error_;

  424. }

  425. 

  426. // 保存外部回调，在对应通信事件发生时通知调用方

  427. void PlcCommunicationService::setCallbacks(

  428.     std::function<void()> state_changed,

  429.     std::function<void(bool)> initial_read_changed,

  430.     std::function<void()> cache_updated,

  431.     std::function<void()> poll_cycle_completed,

  432.     std::function<void(const std::string &)> error_reported)

  433. {

  434.     // 保存外部通知函数，通信事件发生时再调用对应函数

  435.     state_changed_callback_ = std::move(state_changed); // 通信状态变化时通知外部

  436.     initial_read_changed_callback_ = std::move(initial_read_changed); // 首读资格变化时通知外部

  437.     cache_updated_callback_ = std::move(cache_updated); // PLC 缓存更新后通知外部

  438.     poll_cycle_completed_callback_ = std::move(poll_cycle_completed);

  439.     error_reported_callback_ = std::move(error_reported); // 发生通信错误时通知外部

  440. }

  441. 

  442. // 根据当前地址集合重新生成连续轮询读块

  443. void PlcCommunicationService::rebuildPollBlocks()

  444. {

  445.     std::vector<RegisterAddress> addresses = poll_addresses_;

  446.     if (addresses.empty())

  447.     {

  448.         // 没有指定地址时保留 M0/D0，保证连接后仍能验证设备是否响应

  449.         addresses = {

  450.             RegisterAddress{RegisterArea::M, 0},

  451.             RegisterAddress{RegisterArea::D, 0}};

  452.     }

  453.     std::sort(

  454.         addresses.begin(), addresses.end(),

  455.         [](const RegisterAddress &left, const RegisterAddress &right)

  456.         {

  457.             if (left.area() != right.area())

  458.             {

  459.                 return left.area() == RegisterArea::M;

  460.             }

  461.             return left.index() < right.index();

  462.         });

  463.     addresses.erase(std::unique(addresses.begin(), addresses.end()), addresses.end());

  464.     std::vector<PlcPollBlock> calculated_blocks;

  465.     calculatePollBlocks(addresses, poll_multi_word_ranges_, &calculated_blocks);

  466.     poll_blocks_.clear();

  467.     poll_blocks_.reserve(calculated_blocks.size());

  468.     for (const PlcPollBlock &block : calculated_blocks)

  469.     {

  470.         poll_blocks_.push_back(block);

  471.     }

  472.     next_poll_block_ = 0;

  473.     if (!initial_read_completed_)

  474.     {

  475.         // 地址集合变化或重新连接后，首读资格从头统计

  476.         initial_blocks_read_.assign(poll_blocks_.size(), false);

  477.     }

  478.     else

  479.     {

  480.         initial_blocks_read_.clear();

  481.     }

  482. }

  483. 

  484. // 在没有读请求占用时正式切换到新的轮询地址集合

  485. void PlcCommunicationService::applyPollAddresses(

  486.     const std::vector<RegisterAddress> &addresses)

  487. {

  488.     // 只有在没有读请求占用时，新的地址集合才会真正生效

  489.     poll_addresses_ = addresses;

  490.     rebuildPollBlocks();

  491.     poll_update_pending_ = false;

  492.     pending_poll_addresses_.clear();

  493.     pending_poll_multi_word_ranges_.clear();

  494.     if (isReadingState(state_) && pending_reply_ == nullptr)

  495.     {

  496.         // 新轮询地址生效后立即从第一个读块继续异步轮询

  497.         pollNextBlock();

  498.     }

  499. }

  500. 

  501. // 发送一个异步轮询读请求，并由完成回调推进后续读块

  502. void PlcCommunicationService::pollNextBlock()

  503. {

  504.     if (!isReadingState(state_)

  505.         || pending_reply_ != nullptr || poll_blocks_.empty())

  506.     {

  507.         return;

  508.     }

  509.     // 每次只发一个异步请求，完成回调中再推进到下一个块

  510.     const std::size_t block_index = next_poll_block_;

  511.     const PlcPollBlock block = poll_blocks_.at(block_index);

  512.     next_poll_block_ = (next_poll_block_ + 1U) % poll_blocks_.size();

  513.     QModbusDataUnit request(

  514.         registerType(block.area), block.startAddress, static_cast<quint16>(block.count));

  515.     // 发出当前 M 或 D 地址块的异步 Modbus 读取请求

  516.     QModbusReply *reply = master_->sendReadRequest(request, configuration_.serverAddress);

  517.     if (reply == nullptr)

  518.     {

  519.         // 读请求未能创建时按通信故障撤销首读资格

  520.         handleModbusError(master_->error());

  521.         return;

  522.     }

  523.     pending_reply_ = reply;

  524.     // 把当前连接代次带进回调，防止断线重连后旧回复误更新新连接

  525.     const std::uint64_t generation = connection_generation_;

  526.     connect(reply, &QModbusReply::finished,

  527.             this,

  528.             [this, reply, block, block_index, generation]

  529.             {

  530.                 // 连接已经重建时，直接丢弃旧回复

  531.                 if (generation != connection_generation_)

  532.                 {

  533.                     reply->deleteLater();

  534.                     return;

  535.                 }

  536.                 // 读取完成后解析回复并只用成功读回值更新 PLC 缓存

  537.                 handleReadFinished(reply, block);

  538.                 if (isReadingState(state_)

  539.                     && reply->error() == QModbusDevice::NoError

  540.                     && !poll_update_pending_

  541.                     && block_index < initial_blocks_read_.size())

  542.                 {

  543.                     initial_blocks_read_[block_index] = true;

  544.                     const bool completed = std::all_of(

  545.                         initial_blocks_read_.cbegin(),

  546.                         initial_blocks_read_.cend(),

  547.                         [](bool read) { return read; });

  548.                     // 所有轮询块都成功读过，才授予真机运行资格

  549.                     if (completed && !initial_read_completed_)

  550.                     {

  551.                         updateInitialReadCompleted(true);

  552.                         if (state_ == PlcConnectionState::Recovering)

  553.                         {

  554.                             setState(PlcConnectionState::Connected);

  555.                         }

  556.                     }

  557.                 }

  558.                 const bool poll_cycle_completed = isReadingState(state_)

  559.                     && reply->error() == QModbusDevice::NoError

  560.                     && !poll_update_pending_

  561.                     && next_poll_block_ == 0U;

  562.                 if (pending_reply_ == reply)

  563.                 {

  564.                     // 只有当前指针仍指向本次回复时才清空，避免误清新请求

  565.                     pending_reply_ = nullptr;

  566.                 }

  567.                 reply->deleteLater();

  568.                 if (poll_update_pending_)

  569.                 {

  570.                     const std::vector<RegisterAddress> addresses = pending_poll_addresses_;

  571.                     poll_multi_word_ranges_ = pending_poll_multi_word_ranges_;

  572.                     applyPollAddresses(addresses);

  573.                 }

  574.                 if (poll_cycle_completed)

  575.                 {

  576.                     emit pollCycleCompleted();

  577.                     if (poll_cycle_completed_callback_)

  578.                     {

  579.                         poll_cycle_completed_callback_();

  580.                     }

  581.                 }

  582.             });

  583. }

  584. 

  585. // 对可恢复通信故障发送一个轻量读取请求探测链路

  586. void PlcCommunicationService::probeRecovery()

  587. {

  588.     // 只在可恢复的超时故障中探测；串口拔出等故障不会反复探测

  589.     if (state_ != PlcConnectionState::Faulted

  590.         || !isRecoverableTimeout(last_error_type_))

  591.     {

  592.         return;

  593.     }

  594.     if (master_->state() != QModbusDevice::ConnectedState)

  595.     {

  596.         return;

  597.     }

  598.     if (pending_reply_ != nullptr)

  599.     {

  600.         // 已有读请求在途，稍后再探测，保证同一时间只有一个读回复

  601.         recovery_timer_.start(kRecoveryProbeIntervalMs);

  602.         return;

  603.     }

  604.     if (poll_blocks_.empty())

  605.     {

  606.         return;

  607.     }

  608.     // 恢复探测只读取一个地址，确认链路恢复后再进行完整首读

  609.     const PlcPollBlock block = poll_blocks_.front();

  610.     const QModbusDataUnit request(

  611.         registerType(block.area), block.startAddress, 1);

  612.     QModbusReply *reply = master_->sendReadRequest(request, configuration_.serverAddress);

  613.     if (reply == nullptr)

  614.     {

  615.         handleRecoveryProbeFailure(master_->error());

  616.         return;

  617.     }

  618.     pending_reply_ = reply;

  619.     const std::uint64_t generation = connection_generation_;

  620.     connect(reply, &QModbusReply::finished,

  621.             this,

  622.             [this, reply, generation]

  623.             {

  624.                 if (generation != connection_generation_)

  625.                 {

  626.                     reply->deleteLater();

  627.                     return;

  628.                 }

  629.                 if (pending_reply_ == reply)

  630.                 {

  631.                     pending_reply_ = nullptr;

  632.                 }

  633.                 const QModbusDevice::Error error = reply->error();

  634.                 reply->deleteLater();

  635.                 if (poll_update_pending_)

  636.                 {

  637.                     const std::vector<RegisterAddress> addresses = pending_poll_addresses_;

  638.                     poll_multi_word_ranges_ = pending_poll_multi_word_ranges_;

  639.                     applyPollAddresses(addresses);

  640.                 }

  641.                 if (state_ != PlcConnectionState::Faulted

  642.                     || !isRecoverableTimeout(last_error_type_))

  643.                 {

  644.                     return;

  645.                 }

  646.                 if (error != QModbusDevice::NoError)

  647.                 {

  648.                     handleRecoveryProbeFailure(error);

  649.                     return;

  650.                 }

  651.                 // 单地址探测成功后恢复正常轮询，并重新开始完整首读

  652.                 restoreCommunication();

  653.             });

  654. }

  655. 

  656. // 处理恢复探测错误，并决定立即上报或继续等待探测

  657. void PlcCommunicationService::handleRecoveryProbeFailure(QModbusDevice::Error error)

  658. {

  659.     if (state_ != PlcConnectionState::Faulted

  660.         || !isRecoverableTimeout(last_error_type_))

  661.     {

  662.         return;

  663.     }

  664.     if (error == QModbusDevice::ConnectionError)

  665.     {

  666.         const PlcCommunicationErrorContext context{

  667.             QString::fromStdString(configuration_.portName),

  668.             serial_session_opened_,

  669.             received_valid_response_};

  670.         // 探测阶段发现串口连接已经失效时，转入统一故障处理

  671.         setError(classifyPlcCommunicationError(error, context));

  672.         return;

  673.     }

  674.     recovery_timer_.start(kRecoveryProbeIntervalMs);

  675. }

  676. 

  677. // 探测成功后恢复轮询，并重新开始完整首读

  678. void PlcCommunicationService::restoreCommunication()

  679. {

  680.     // 探测成功只说明链路恢复，仍要重新读取全部读块才能恢复真机资格

  681.     received_valid_response_ = true;

  682.     last_error_type_ = PlcCommunicationError::None;

  683.     last_error_.clear();

  684.     rebuildPollBlocks();

  685.     setState(PlcConnectionState::Recovering);

  686.     poll_timer_.start(configuration_.pollIntervalMs);

  687.     // 恢复后从第一个地址块重新开始完整首读

  688.     pollNextBlock();

  689. }

  690. 

  691. // 处理轮询读回复并更新 PLC 缓存

  692. void PlcCommunicationService::handleReadFinished(

  693.     QModbusReply *reply, PlcPollBlock block)

  694. {

  695.     if (!isReadingState(state_))

  696.     {

  697.         return;

  698.     }

  699.     if (reply->error() != QModbusDevice::NoError)

  700.     {

  701.         // 轮询回复失败时统一记录故障并启动对应恢复路径

  702.         handleModbusError(reply->error());

  703.         return;

  704.     }

  705.     // 只有成功回复才能更新 PLC 缓存；写请求不会直接改缓存

  706.     const QModbusDataUnit result = reply->result();

  707.     for (uint index = 0; index < result.valueCount(); ++index)

  708.     {

  709.         const int address = block.startAddress + static_cast<int>(index);

  710.         if (block.area == RegisterArea::M)

  711.         {

  712.             // M 地址只用成功读回的线圈值刷新缓存

  713.             repository_.updateBit(address, result.value(index) != 0U);

  714.         }

  715.         else

  716.         {

  717.             // D 地址只用成功读回的保持寄存器值刷新缓存

  718.             repository_.updateWord(address, static_cast<std::int16_t>(result.value(index)));

  719.         }

  720.     }

  721.     received_valid_response_ = true;

  722.     last_error_type_ = PlcCommunicationError::None;

  723.     last_error_.clear();

  724.     emit cacheUpdated();

  725.     if (cache_updated_callback_)

  726.     {

  727.         cache_updated_callback_();

  728.     }

  729. }

  730. 

  731. // 发送一个 M 位异步写请求，不直接修改缓存

  732. RegisterWriteResult PlcCommunicationService::sendBitWrite(

  733.     const RegisterAddress &address, bool value)

  734. {

  735.     // 写入只允许在正常 Connected 状态进行，Recovering/Faulted 都拒绝

  736.     if (state_ != PlcConnectionState::Connected)

  737.     {

  738.         return {false, RegisterError::Unavailable};

  739.     }

  740.     if (pending_write_reply_ != nullptr)

  741.     {

  742.         return {false, RegisterError::WriteRejected};

  743.     }

  744.     // M 区对应 Modbus Coils，单次只写一个地址

  745.     QModbusDataUnit unit(QModbusDataUnit::Coils, address.index(), 1);

  746.     unit.setValue(0, value ? 1U : 0U);

  747.     // 异步发送 Modbus 线圈单写，成功后仍等待轮询读回确认

  748.     QModbusReply *reply = master_->sendWriteRequest(unit, configuration_.serverAddress);

  749.     if (reply == nullptr)

  750.     {

  751.         // M 写请求未能创建时进入统一通信故障处理

  752.         handleModbusError(master_->error());

  753.         return {false, RegisterError::WriteRejected};

  754.     }

  755.     pending_write_reply_ = reply;

  756.     // 写回复完成后只处理成功或错误，不直接改缓存；后续轮询负责确认真实值

  757.     connect(reply, &QModbusReply::finished,

  758.             this,

  759.             [this, reply, generation = connection_generation_]

  760.             {

  761.                 if (pending_write_reply_ == reply)

  762.                 {

  763.                     pending_write_reply_ = nullptr;

  764.                 }

  765.                 if (generation != connection_generation_)

  766.                 {

  767.                     reply->deleteLater();

  768.                     return;

  769.                 }

  770.                 if (reply->error() != QModbusDevice::NoError)

  771.                 {

  772.                     // M 异步写回复失败时进入统一通信故障处理

  773.                     handleModbusError(reply->error());

  774.                 }

  775.                 reply->deleteLater();

  776.             });

  777.     return {true, RegisterError::None};

  778. }

  779. 

  780. // 发送一个 D 字异步写请求，不直接修改缓存

  781. RegisterWriteResult PlcCommunicationService::sendWordWrite(

  782.     const RegisterAddress &address, std::int16_t value)

  783. {

  784.     // D 区写入流程与 M 区相同，只是 Modbus 类型不同

  785.     if (state_ != PlcConnectionState::Connected)

  786.     {

  787.         return {false, RegisterError::Unavailable};

  788.     }

  789.     if (pending_write_reply_ != nullptr)

  790.     {

  791.         return {false, RegisterError::WriteRejected};

  792.     }

  793.     // D 区对应 Modbus HoldingRegisters，单次只写一个字

  794.     QModbusDataUnit unit(QModbusDataUnit::HoldingRegisters, address.index(), 1);

  795.     unit.setValue(0, static_cast<quint16>(value));

  796.     // 异步发送保持寄存器单写，成功后不直接修改本地缓存

  797.     QModbusReply *reply = master_->sendWriteRequest(unit, configuration_.serverAddress);

  798.     if (reply == nullptr)

  799.     {

  800.         // 单个 D 写请求未能创建时进入统一通信故障处理

  801.         handleModbusError(master_->error());

  802.         return {false, RegisterError::WriteRejected};

  803.     }

  804.     pending_write_reply_ = reply;

  805.     connect(reply, &QModbusReply::finished,

  806.             this,

  807.             [this, reply, generation = connection_generation_]

  808.             {

  809.                 if (pending_write_reply_ == reply)

  810.                 {

  811.                     pending_write_reply_ = nullptr;

  812.                 }

  813.                 if (generation != connection_generation_)

  814.                 {

  815.                     reply->deleteLater();

  816.                     return;

  817.                 }

  818.                 if (reply->error() != QModbusDevice::NoError)

  819.                 {

  820.                     // 单个 D 异步写回复失败时进入统一通信故障处理

  821.                     handleModbusError(reply->error());

  822.                 }

  823.                 reply->deleteLater();

  824.             });

  825.     return {true, RegisterError::None};

  826. }

  827. 

  828. // 发送一组连续 D 字异步写请求，不直接修改缓存

  829. RegisterWriteResult PlcCommunicationService::sendWordsWrite(

  830.     const RegisterAddress &address,

  831.     const std::vector<std::int16_t> &values)

  832. {

  833.     const int count = static_cast<int>(values.size());

  834.     if (state_ != PlcConnectionState::Connected)

  835.     {

  836.         return {false, RegisterError::Unavailable};

  837.     }

  838.     if (pending_write_reply_ != nullptr

  839.         || !address.isValid() || address.area() != RegisterArea::D

  840.         || count < 2 || count > 4

  841.         || address.index() > RegisterAddress::kMaximumIndex - count + 1)

  842.     {

  843.         return {false, pending_write_reply_ != nullptr

  844.             ? RegisterError::WriteRejected : RegisterError::InvalidAddress};

  845.     }

  846.     QModbusDataUnit unit(QModbusDataUnit::HoldingRegisters, address.index(), count);

  847.     for (int offset = 0; offset < count; ++offset)

  848.     {

  849.         unit.setValue(

  850.             offset, static_cast<quint16>(values[static_cast<std::size_t>(offset)]));

  851.     }

  852.     // 异步发送连续保持寄存器多写，供 32 位和 64 位数值使用

  853.     QModbusReply *reply = master_->sendWriteRequest(unit, configuration_.serverAddress);

  854.     if (reply == nullptr)

  855.     {

  856.         // 连续 D 写请求未能创建时进入统一通信故障处理

  857.         handleModbusError(master_->error());

  858.         return {false, RegisterError::WriteRejected};

  859.     }

  860.     pending_write_reply_ = reply;

  861.     connect(reply, &QModbusReply::finished,

  862.             this,

  863.             [this, reply, generation = connection_generation_]

  864.             {

  865.                 if (pending_write_reply_ == reply)

  866.                 {

  867.                     pending_write_reply_ = nullptr;

  868.                 }

  869.                 if (generation != connection_generation_)

  870.                 {

  871.                     reply->deleteLater();

  872.                     return;

  873.                 }

  874.                 if (reply->error() != QModbusDevice::NoError)

  875.                 {

  876.                     // 连续 D 异步写回复失败时进入统一通信故障处理

  877.                     handleModbusError(reply->error());

  878.                 }

  879.                 reply->deleteLater();

  880.             });

  881.     return {true, RegisterError::None};

  882. }

  883. 

  884. // 更新首读完成标记，并在需要时通知外部观察者

  885. void PlcCommunicationService::updateInitialReadCompleted(

  886.     bool completed, bool force_notification)

  887. {

  888.     if (initial_read_completed_ == completed && !force_notification)

  889.     {

  890.         return;

  891.     }

  892.     // 只有状态真的变化，或调用方明确要求通知时才发出信号

  893.     initial_read_completed_ = completed;

  894.     emit initialReadCompletedChanged(completed);

  895.     if (initial_read_changed_callback_)

  896.     {

  897.         initial_read_changed_callback_(completed);

  898.     }

  899. }

  900. 

  901. // 处理未主动断开时发生的串口连接丢失

  902. void PlcCommunicationService::handleUnexpectedDisconnect()

  903. {

  904.     // 这里表示设备原本连上过，后来串口意外断开

  905.     serial_session_opened_ = false;

  906.     const QString port_name = QString::fromStdString(configuration_.portName).trimmed();

  907.     // 将 USB 串口拔出等异常记录为 Disconnected，交给运行版定时重连

  908.     setError({

  909.         PlcCommunicationError::SerialConnectionLost,

  910.         QStringLiteral(

  911.             "PLC 串口 %1 连接已中断；请检查 USB 转串口是否被拔出或已经失效")

  912.             .arg(port_name)});

  913. }

  914. 

  915. // 过滤重复错误后，分类并保存 Qt Modbus 错误

  916. void PlcCommunicationService::handleModbusError(QModbusDevice::Error error)

  917. {

  918.     // 主动断开、已处理的故障和旧回复错误都不重复上报

  919.     if (disconnecting_

  920.         || (error == QModbusDevice::ReplyAbortedError

  921.             && state_ == PlcConnectionState::Disconnected)

  922.         || (state_ == PlcConnectionState::Disconnected

  923.             && last_error_type_ == PlcCommunicationError::SerialConnectionLost)

  924.         || state_ == PlcConnectionState::Faulted)

  925.     {

  926.         return;

  927.     }

  928.     const PlcCommunicationErrorContext context{

  929.         QString::fromStdString(configuration_.portName),

  930.         serial_session_opened_,

  931.         received_valid_response_};

  932.     // 将 PLC 无响应等错误记录为 Faulted，并启动通信恢复探测

  933.     setError(classifyPlcCommunicationError(error, context));

  934. }

  935. 

  936. // 使旧异步请求失效并关闭当前串口会话

  937. void PlcCommunicationService::closeSerialSession()

  938. {

  939.     // 先递增代次并停止定时器，再断开串口；旧异步回调会因此失效

  940.     ++connection_generation_;

  941.     disconnecting_ = true;

  942.     poll_timer_.stop();

  943.     recovery_timer_.stop();

  944.     pending_reply_ = nullptr;

  945.     pending_write_reply_ = nullptr;

  946.     poll_update_pending_ = false;

  947.     pending_poll_addresses_.clear();

  948.     pending_poll_multi_word_ranges_.clear();

  949.     if (master_->state() != QModbusDevice::UnconnectedState)

  950.     {

  951.         master_->disconnectDevice();

  952.     }

  953.     serial_session_opened_ = false;

  954.     received_valid_response_ = false;

  955.     disconnecting_ = false;

  956. }

  957. 

  958. // 修改连接状态并同步发出 Qt 信号和外部回调

  959. void PlcCommunicationService::setState(PlcConnectionState state)

  960. {

  961.     if (state_ == state)

  962.     {

  963.         return;

  964.     }

  965.     // 状态集中从这里修改，确保 Qt 信号和 std::function 回调同步触发

  966.     state_ = state;

  967.     emit stateChanged();

  968.     if (state_changed_callback_)

  969.     {

  970.         state_changed_callback_();

  971.     }

  972. }

  973. 

  974. // 保存通信故障、撤销首读资格并通知外部观察者

  975. void PlcCommunicationService::setError(const PlcCommunicationFailure &failure)

  976. {

  977.     // 统一保存错误、停止正常轮询、撤销首读资格并通知 UI

  978.     last_error_type_ = failure.type;

  979.     last_error_ = toUtf8(failure.message);

  980.     poll_timer_.stop();

  981.     recovery_timer_.stop();

  982.     // 任意通信故障都会撤销首读资格；恢复后必须重新完整读取

  983.     updateInitialReadCompleted(false);

  984.     const bool disconnected = failure.type == PlcCommunicationError::SerialPortOpenFailed

  985.         || failure.type == PlcCommunicationError::SerialConnectionLost

  986.         || failure.type == PlcCommunicationError::UsbSerialAdapterRemoved;

  987.     if (disconnected)

  988.     {

  989.         closeSerialSession();

  990.     }

  991.     setState(disconnected

  992.         ? PlcConnectionState::Disconnected : PlcConnectionState::Faulted);

  993.     emit communicationError(failure.message);

  994.     if (error_reported_callback_)

  995.     {

  996.         error_reported_callback_(last_error_);

  997.     }

  998.     if (isRecoverableTimeout(failure.type)

  999.         && master_->state() == QModbusDevice::ConnectedState)

  1000.     {

  1001.         recovery_timer_.start(kRecoveryProbeIntervalMs);

  1002.     }

  1003. }