suyu
/
suyu_two
1
0
Fork 0
Código Issues 0 Pull requests 0 Versões 0 Wiki Atividade
综合平台编程器项目的远程存储
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
157 Commits
1 Branch
183 MiB
 
 
 
 
Tag: 240ce7ac03
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 240ce7ac03
${ noResults }
suyu_two/app/tests/runtime_mode_service_tests.cpp

490 linhas
19 KiB
Original Anotar Histórico 

  1. #include "services/runtime_mode_service.h"

  2. #include "services/logic_editor_service.h"

  3. #include "services/offline_simulation_service.h"

  4. #include "services/project_service.h"

  5. #include "domain/active_register_repository.h"

  6. #include "domain/project_storage.h"

  7. #include "domain/register_repository.h"

  8. #include "domain/virtual_register_repository.h"

  9. #include "support/test_support.h"

  10. 

  11. #include <functional>

  12. #include <iostream>

  13. #include <stdexcept>

  14. #include <string>

  15. #include <utility>

  16. 

  17. namespace {

  18. 

  19. using TestProjectStorage = TestSupport::InMemoryProjectStorage;

  20. 

  21. class ReadyPlcGateway final : public PlcCommunicationGateway

  22. {

  23. public:

  24.     PlcCommunicationResult connectDevice(const PlcSerialConfiguration &) override

  25.     {

  26.         connection_state = PlcConnectionState::Connected;

  27.         if (state_changed)

  28.         {

  29.             state_changed();

  30.         }

  31.         return {true, {}};

  32.     }

  33. 

  34.     void disconnectDevice() override

  35.     {

  36.         connection_state = PlcConnectionState::Disconnected;

  37.         initial_read = false;

  38.     }

  39. 

  40.     PlcCommunicationResult setPollAddresses(

  41.         const std::vector<RegisterAddress> &addresses) override

  42.     {

  43.         return setPollAddresses(addresses, {});

  44.     }

  45. 

  46.     PlcCommunicationResult setPollAddresses(

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

  48.         const std::vector<RegisterWordRange> &ranges) override

  49.     {

  50.         if (reject_poll_configuration)

  51.         {

  52.             return {false, "poll configuration rejected"};

  53.         }

  54.         poll_addresses = addresses;

  55.         poll_ranges = ranges;

  56.         return {true, {}};

  57.     }

  58.     PlcConnectionState state() const override { return connection_state; }

  59.     bool initialReadCompleted() const override { return initial_read; }

  60.     PlcCommunicationError lastErrorType() const override

  61.     {

  62.         return PlcCommunicationError::None;

  63.     }

  64.     const std::string &lastError() const override { return last_error; }

  65. 

  66.     void setCallbacks(

  67.         std::function<void()> state_callback,

  68.         std::function<void(bool)> initial_callback,

  69.         std::function<void()> cache_callback,

  70.         std::function<void()> poll_cycle_callback,

  71.         std::function<void(const std::string &)> error_callback) override

  72.     {

  73.         state_changed = std::move(state_callback);

  74.         initial_read_changed = std::move(initial_callback);

  75.         cache_updated = std::move(cache_callback);

  76.         poll_cycle_completed = std::move(poll_cycle_callback);

  77.         error_reported = std::move(error_callback);

  78.     }

  79. 

  80.     void completeInitialRead()

  81.     {

  82.         initial_read = true;

  83.         if (initial_read_changed)

  84.         {

  85.             initial_read_changed(true);

  86.         }

  87.     }

  88. 

  89.     void completePollCycle()

  90.     {

  91.         if (poll_cycle_completed)

  92.         {

  93.             poll_cycle_completed();

  94.         }

  95.     }

  96. 

  97.     const std::vector<RegisterAddress> &pollAddresses() const

  98.     {

  99.         return poll_addresses;

  100.     }

  101. 

  102.     const std::vector<RegisterWordRange> &pollRanges() const

  103.     {

  104.         return poll_ranges;

  105.     }

  106. 

  107.     bool reject_poll_configuration = false;

  108. 

  109. private:

  110.     PlcConnectionState connection_state = PlcConnectionState::Disconnected;

  111.     bool initial_read = false;

  112.     std::string last_error;

  113.     std::function<void()> state_changed;

  114.     std::function<void(bool)> initial_read_changed;

  115.     std::function<void()> cache_updated;

  116.     std::function<void()> poll_cycle_completed;

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

  118.     std::vector<RegisterAddress> poll_addresses;

  119.     std::vector<RegisterWordRange> poll_ranges;

  120. };

  121. 

  122. using TestSupport::require;

  123. 

  124. void setConditionPath(LadderRung *rung, LogicNode node)

  125. {

  126.     for (int column = 0;

  127.          column < ProjectLimits::kMaximumConditionColumns;

  128.          ++column)

  129.     {

  130.         rung->cells.push_back({

  131.             rung->id + "-cell-" + std::to_string(column),

  132.             column == 0 ? LadderCellKind::Node : LadderCellKind::Wire,

  133.             column == 0 ? std::optional<LogicNode>{node} : std::nullopt});

  134.     }

  135. }

  136. 

  137. void testModeTransitions()

  138. {

  139.     // 验证服务将 PLC 首读状态与领域模式切换规则正确组合

  140.     TestProjectStorage storage;

  141.     ProjectService project_service(storage, defaultProjectLimitSettings());

  142.     VirtualRegisterRepository virtual_repository;

  143.     VirtualRegisterRepository plc_repository;

  144.     ActiveRegisterRepository active_repository(virtual_repository);

  145.     OfflineSimulationService simulation_service(virtual_repository);

  146.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  147.     LogicEditorService logic_editor_service(project_service);

  148.     ReadyPlcGateway gateway;

  149.     RuntimeModeService service(

  150.         project_service,

  151.         logic_editor_service,

  152.         simulation_service,

  153.         online_monitor_service);

  154.     service.configurePlc(

  155.         gateway, active_repository, virtual_repository, plc_repository);

  156. 

  157.     Project &project = project_service.editProject();

  158.     HmiPage page;

  159.     page.id = "runtime-page";

  160.     page.name = "Runtime";

  161.     HmiControl int32_display;

  162.     int32_display.id = "runtime-int32";

  163.     int32_display.type = HmiControlType::NumericDisplay;

  164.     int32_display.bounds = {0, 0, 100, 40};

  165.     int32_display.binding = RegisterAddress{RegisterArea::D, 50};

  166.     int32_display.dataType = RegisterDataType::Int32;

  167.     page.controls.push_back(int32_display);

  168.     HmiControl double_display = int32_display;

  169.     double_display.id = "runtime-double";

  170.     double_display.bounds = {120, 0, 100, 40};

  171.     double_display.binding = RegisterAddress{RegisterArea::D, 60};

  172.     double_display.dataType = RegisterDataType::Float64;

  173.     page.controls.push_back(double_display);

  174.     HmiControl double_status = int32_display;

  175.     double_status.id = "runtime-double-status";

  176.     double_status.type = HmiControlType::StatusText;

  177.     double_status.bounds = {240, 0, 140, 40};

  178.     double_status.binding = RegisterAddress{RegisterArea::D, 70};

  179.     double_status.dataType = RegisterDataType::Float64;

  180.     double_status.statusText = HmiStatusWordTextConfig{{

  181.         {std::nullopt, 0.0, "Low"},

  182.         {0.0, std::nullopt, "High"}}};

  183.     page.controls.push_back(double_status);

  184.     HmiControl gated_button;

  185.     gated_button.id = "runtime-gated-button";

  186.     gated_button.type = HmiControlType::Button;

  187.     gated_button.bounds = {400, 0, 120, 40};

  188.     gated_button.binding = RegisterAddress{RegisterArea::M, 30};

  189.     gated_button.buttonEnableCondition = HmiButtonWordEnableCondition{

  190.         RegisterAddress{RegisterArea::D, 80},

  191.         RegisterDataType::Int32,

  192.         HmiButtonConditionOperator::GreaterThanOrEqual,

  193.         1.0};

  194.     page.controls.push_back(gated_button);

  195.     project.initialHmiPageId = page.id;

  196.     project.hmiPages.push_back(page);

  197.     project.alarmDefinitions.push_back(

  198.         {"alarm-m", {RegisterArea::M, 12}, AlarmCondition::MOn, 0, "M alarm"});

  199.     project.alarmDefinitions.push_back(

  200.         {"alarm-d", {RegisterArea::D, 34}, AlarmCondition::DHigh, 100, "D alarm"});

  201.     project.registerComments = {

  202.         {RegisterAddress{RegisterArea::M, 3999}, "只用于说明"},

  203.         {RegisterAddress{RegisterArea::D, 3999}, "只用于说明"}};

  204. 

  205.     ControlLogic logic;

  206.     logic.id = "poll-logic";

  207.     logic.name = "Poll logic";

  208.     LogicNode edge;

  209.     edge.id = "poll-edge";

  210.     edge.config = EdgeContactNodeConfig{

  211.         RegisterAddress{RegisterArea::M, 20}, EdgeMode::Rising};

  212.     LogicNode edge_coil;

  213.     edge_coil.id = "poll-edge-coil";

  214.     edge_coil.config = CoilNodeConfig{

  215.         RegisterAddress{RegisterArea::M, 21}, CoilMode::Normal};

  216.     LadderRung edge_rung;

  217.     edge_rung.id = "poll-edge-rung";

  218.     edge_rung.name = "Poll edge";

  219.     setConditionPath(&edge_rung, edge);

  220.     edge_rung.output = edge_coil;

  221.     logic.rungs.push_back(edge_rung);

  222.     LogicNode comparison;

  223.     comparison.id = "poll-comparison";

  224.     comparison.config = CompareNodeConfig{

  225.         RegisterAddress{RegisterArea::D, 35}, ComparisonOperator::GreaterThan, 0};

  226.     LogicNode comparison_coil;

  227.     comparison_coil.id = "poll-comparison-coil";

  228.     comparison_coil.config = CoilNodeConfig{

  229.         RegisterAddress{RegisterArea::M, 22}, CoilMode::Normal};

  230.     LadderRung comparison_rung;

  231.     comparison_rung.id = "poll-comparison-rung";

  232.     comparison_rung.name = "Poll comparison";

  233.     setConditionPath(&comparison_rung, comparison);

  234.     comparison_rung.output = comparison_coil;

  235.     logic.rungs.push_back(comparison_rung);

  236.     LogicNode move_input;

  237.     move_input.id = "poll-move-input";

  238.     move_input.config = ContactNodeConfig{

  239.         RegisterAddress{RegisterArea::M, 27}, ContactMode::NormallyOpen};

  240.     LogicNode move_output;

  241.     move_output.id = "poll-move";

  242.     move_output.config = MoveNodeConfig{

  243.         WordOperand{

  244.             WordOperandKind::Register,

  245.             RegisterAddress{RegisterArea::D, 38},

  246.             0},

  247.         RegisterAddress{RegisterArea::D, 39}};

  248.     LadderRung move_rung;

  249.     move_rung.id = "poll-move-rung";

  250.     move_rung.name = "Poll MOVE";

  251.     setConditionPath(&move_rung, move_input);

  252.     move_rung.output = move_output;

  253.     logic.rungs.push_back(move_rung);

  254.     LogicNode add_input;

  255.     add_input.id = "poll-add-input";

  256.     add_input.config = ContactNodeConfig{

  257.         RegisterAddress{RegisterArea::M, 28}, ContactMode::NormallyOpen};

  258.     LogicNode add_output;

  259.     add_output.id = "poll-add";

  260.     add_output.config = ArithmeticNodeConfig{

  261.         ArithmeticOperation::Add,

  262.         WordOperand{

  263.             WordOperandKind::Register,

  264.             RegisterAddress{RegisterArea::D, 40},

  265.             0},

  266.         WordOperand{

  267.             WordOperandKind::Constant,

  268.             RegisterAddress{RegisterArea::D, 0},

  269.             1},

  270.         RegisterAddress{RegisterArea::D, 41}};

  271.     LadderRung add_rung;

  272.     add_rung.id = "poll-add-rung";

  273.     add_rung.name = "Poll ADD";

  274.     setConditionPath(&add_rung, add_input);

  275.     add_rung.output = add_output;

  276.     logic.rungs.push_back(add_rung);

  277.     project.controlLogics.push_back(logic);

  278. 

  279.     require(service.mode() == ApplicationMode::Editing,

  280.             "service must start in editing mode");

  281.     require(service.policy().allowsProjectEditing,

  282.             "editing mode must allow project editing");

  283. 

  284.     require(service.enterOfflineRunning().succeeded,

  285.             "editing mode must enter offline running");

  286.     require(service.simulationState() == SimulationState::Running,

  287.             "offline mode must start the software executor");

  288.     require(service.policy().usesVirtualRegisters,

  289.             "offline running must use virtual registers");

  290.     require(service.enterOnlineRunning().error

  291.                 == ModeTransitionError::MustReturnToEditing,

  292.             "running modes must not switch directly");

  293. 

  294.     require(service.enterEditing().succeeded,

  295.             "offline running must return to editing");

  296.     require(service.simulationState() == SimulationState::Stopped,

  297.             "returning to editing must stop the software executor first");

  298.     require(service.enterOnlineRunning().error

  299.                 == ModeTransitionError::InitialPlcReadRequired,

  300.             "online running must require an initial PLC read");

  301. 

  302.     require(service.connectPlc(

  303.                 {"COM9", 1, 9600, 8, 2, 1, 1000, 2, 200}).succeeded,

  304.             "PLC connection must be established before its initial read can complete");

  305.     require(gateway.pollAddresses()

  306.                 == std::vector<RegisterAddress>({

  307.                     {RegisterArea::M, 12}, {RegisterArea::M, 20},

  308.                     {RegisterArea::M, 21}, {RegisterArea::M, 22},

  309.                     {RegisterArea::M, 27}, {RegisterArea::M, 28},

  310.                     {RegisterArea::M, 30},

  311.                     {RegisterArea::D, 34}, {RegisterArea::D, 35},

  312.                     {RegisterArea::D, 38}, {RegisterArea::D, 39},

  313.                     {RegisterArea::D, 40}, {RegisterArea::D, 41},

  314.                     {RegisterArea::D, 50}, {RegisterArea::D, 51},

  315.                     {RegisterArea::D, 60}, {RegisterArea::D, 61},

  316.                     {RegisterArea::D, 62}, {RegisterArea::D, 63},

  317.                     {RegisterArea::D, 70}, {RegisterArea::D, 71},

  318.                     {RegisterArea::D, 72}, {RegisterArea::D, 73},

  319.                     {RegisterArea::D, 80}, {RegisterArea::D, 81}})

  320.                 && gateway.pollRanges()

  321.                     == std::vector<RegisterWordRange>({

  322.                         {{RegisterArea::D, 50}, 2},

  323.                         {{RegisterArea::D, 60}, 4},

  324.                         {{RegisterArea::D, 70}, 4},

  325.                         {{RegisterArea::D, 80}, 2}}),

  326.             "instructions and multi-word status text must be fully polled while comments stay metadata-only");

  327.     gateway.completeInitialRead();

  328.     require(service.initialPlcReadCompleted(),

  329.             "service must retain the initial PLC read state");

  330.     plc_repository.writeBit({RegisterArea::M, 20}, true);

  331.     require(service.enterOnlineRunning().succeeded,

  332.             "online running must start after an initial PLC read");

  333.     require(service.simulationState() == SimulationState::Stopped,

  334.             "online running must keep the offline executor stopped");

  335.     require(service.onlineLogicMonitorService().state()

  336.                 == OnlineLogicMonitorState::Running,

  337.             "online running must start the local read-only trace executor");

  338.     require(!plc_repository.readBit({RegisterArea::M, 21}).value,

  339.             "the local trace output must not change the PLC source repository");

  340.     require(service.policy().usesPlcRegisters,

  341.             "online running must use PLC registers");

  342.     require(service.policy().runsLogicExecutor,

  343.             "online running must advertise the local read-only trace executor");

  344.     const std::uint64_t scan_count = service.onlineLogicMonitorService()

  345.         .successfulScanCount();

  346.     gateway.completePollCycle();

  347.     require(service.onlineLogicMonitorService().successfulScanCount()

  348.                 == scan_count + 1U,

  349.             "a completed PLC poll cycle must trigger one new local trace scan");

  350. }

  351. 

  352. void testMonitorPollRangeRollback()

  353. {

  354.     TestProjectStorage storage;

  355.     ProjectService project_service(storage, defaultProjectLimitSettings());

  356.     VirtualRegisterRepository virtual_repository;

  357.     VirtualRegisterRepository plc_repository;

  358.     ActiveRegisterRepository active_repository(virtual_repository);

  359.     OfflineSimulationService simulation_service(virtual_repository);

  360.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  361.     LogicEditorService logic_editor_service(project_service);

  362.     ReadyPlcGateway gateway;

  363.     RuntimeModeService service(

  364.         project_service,

  365.         logic_editor_service,

  366.         simulation_service,

  367.         online_monitor_service);

  368.     service.configurePlc(

  369.         gateway, active_repository, virtual_repository, plc_repository);

  370. 

  371.     gateway.reject_poll_configuration = true;

  372.     const PlcCommunicationResult rejected = service.setMonitorAddresses(

  373.         {{RegisterArea::D, 100}, {RegisterArea::D, 101},

  374.          {RegisterArea::D, 102}, {RegisterArea::D, 103}},

  375.         {{{RegisterArea::D, 100}, 4}});

  376.     require(!rejected.succeeded,

  377.             "a gateway-rejected Double monitor range must fail atomically");

  378. 

  379.     gateway.reject_poll_configuration = false;

  380.     require(service.refreshPlcPollAddresses().succeeded

  381.                 && gateway.pollAddresses().empty()

  382.                 && gateway.pollRanges().empty(),

  383.             "a rejected monitor candidate must not remain in runtime poll state");

  384. }

  385. 

  386. void testDisconnectedOutputBlocksOfflineAndOnlineRuntime()

  387. {

  388.     TestProjectStorage storage;

  389.     ProjectService project_service(storage, defaultProjectLimitSettings());

  390.     VirtualRegisterRepository virtual_repository;

  391.     VirtualRegisterRepository plc_repository;

  392.     ActiveRegisterRepository active_repository(virtual_repository);

  393.     OfflineSimulationService simulation_service(virtual_repository);

  394.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  395.     LogicEditorService logic_editor_service(project_service);

  396.     ReadyPlcGateway gateway;

  397.     RuntimeModeService service(

  398.         project_service,

  399.         logic_editor_service,

  400.         simulation_service,

  401.         online_monitor_service);

  402.     service.configurePlc(

  403.         gateway, active_repository, virtual_repository, plc_repository);

  404. 

  405.     ControlLogic logic;

  406.     logic.id = "broken-logic";

  407.     logic.name = "断路逻辑";

  408.     LadderRung rung;

  409.     rung.id = "broken-rung";

  410.     rung.name = "行 1";

  411.     for (int column = 0;

  412.          column < ProjectLimits::kMaximumConditionColumns;

  413.          ++column)

  414.     {

  415.         rung.cells.push_back({

  416.             "broken-cell-" + std::to_string(column),

  417.             LadderCellKind::Gap,

  418.             std::nullopt});

  419.     }

  420.     rung.output = LogicNode{

  421.         "broken-output",

  422.         CoilNodeConfig{

  423.             RegisterAddress{RegisterArea::M, 60}, CoilMode::Normal},

  424.         true};

  425.     logic.rungs.push_back(rung);

  426.     LadderRung unused;

  427.     unused.id = "unused-rung";

  428.     unused.name = "行 2";

  429.     for (int column = 0;

  430.          column < ProjectLimits::kMaximumConditionColumns;

  431.          ++column)

  432.     {

  433.         unused.cells.push_back({

  434.             "unused-cell-" + std::to_string(column),

  435.             column >= 3 && column <= 5

  436.                 ? LadderCellKind::Wire : LadderCellKind::Gap,

  437.             std::nullopt});

  438.     }

  439.     logic.rungs.push_back(unused);

  440.     project_service.editProject().controlLogics.push_back(logic);

  441.     logic_editor_service.clearHistory();

  442. 

  443.     const ModeTransitionResult offline = service.enterOfflineRunning();

  444.     require(

  445.         !offline.succeeded

  446.             && offline.error == ModeTransitionError::ProjectNotReady

  447.             && offline.detail.find("断路逻辑") != std::string::npos

  448.             && offline.detail.find("第 11 列") != std::string::npos

  449.             && offline.detail.find("第 1 列") != std::string::npos

  450.             && service.mode() == ApplicationMode::Editing

  451.             && simulation_service.state() == SimulationState::Stopped

  452.             && service.lastSyntaxCheck().changed

  453.             && service.lastSyntaxCheck().removedWireCells == 3U

  454.             && logic_editor_service.findCell(

  455.                 "broken-logic", "unused-rung", 3)->kind

  456.                 == LadderCellKind::Gap

  457.             && logic_editor_service.canUndo(),

  458.         "runtime preflight must normalize unused lines before rejecting a broken output");

  459. 

  460.     require(service.connectPlc(

  461.                 {"COM9", 1, 9600, 8, 2, 1, 1000, 2, 200}).succeeded,

  462.             "the online connectivity check requires a ready PLC cache");

  463.     gateway.completeInitialRead();

  464.     const ModeTransitionResult online = service.enterOnlineRunning();

  465.     require(

  466.         !online.succeeded

  467.             && online.error == ModeTransitionError::ProjectNotReady

  468.             && online.detail == offline.detail

  469.             && service.mode() == ApplicationMode::Editing

  470.             && online_monitor_service.state()

  471.                 == OnlineLogicMonitorState::Stopped

  472.             && !service.lastSyntaxCheck().changed

  473.             && logic_editor_service.undo().succeeded

  474.             && logic_editor_service.findCell(

  475.                 "broken-logic", "unused-rung", 3)->kind

  476.                 == LadderCellKind::Wire,

  477.         "the same disconnected output validation must block online runtime");

  478. }

  479. 

  480. } // namespace

  481. 

  482. int main()

  483. {

  484.     return TestSupport::runTestSuite("runtime mode service tests", {

  485.         {"testModeTransitions", testModeTransitions},

  486.         {"testMonitorPollRangeRollback", testMonitorPollRangeRollback},

  487.         {"testDisconnectedOutputBlocksOfflineAndOnlineRuntime", testDisconnectedOutputBlocksOfflineAndOnlineRuntime},

  488.     });

  489. }