使用 TinyFSM 和 BehaviorTree.CPP 构建状态机与行为树示例

0. 概述

在现代软件开发中，有限状态机（FSM）和行为树（BT）是两种常用的工具，用于实现复杂的逻辑控制和决策。本文将展示如何结合使用 TinyFSM 和 BehaviorTree.CPP 创建一个简单的示例，实现一个模拟门的开关操作的系统。

本文完整示例代码地址： https://gitee.com/liudegui/fsm_bt_door-example
进一步阅读，C++ 实现一个简单的状态机和行为树结合示例

1. 有限状态机（FSM）原理

有限状态机是一种计算模型，它由一组状态和一组事件组成。每个状态都有一组可能的转换（transition），这些转换由事件触发。FSM 常用于管理系统中的状态变化，比如门的开关状态。

状态机示例（FSM）

在我们的示例中，状态机有两个状态：DoorClosed（门关闭）和 DoorOpened（门打开），以及两个事件：OpenDoor（开门事件）和 CloseDoor（关门事件）。

状态机的状态转换图如下：

 +------------+       OpenDoor       +-----------+
 | DoorClosed | -------------------> | DoorOpened|
 +------------+                      +-----------+
       ^                                  |
       |            CloseDoor              |
       +-----------------------------------+

2. 行为树（BT）原理

行为树是一种结构化的决策模型，通常用于机器人控制和游戏AI。行为树由节点组成，节点可以是控制节点（如选择节点、顺序节点）或执行节点（如动作节点）。行为树的根节点开始执行，并根据树的结构和状态进行决策。

行为树示例（BT）

在我们的示例中，行为树有两个动作节点：OpenDoorAction 和 CloseDoorAction。行为树通过顺序节点依次执行这些动作。

行为树的结构图如下：

 +-----------+
 |  Sequence |
 +-----------+
       |
  +-----------+    +------------+
  | OpenDoor  | -> | CloseDoor  |
  +-----------+    +------------+

3. 结合FSM和BT

我们的示例将FSM和BT结合起来，实现一个简单的系统，用于控制门的开关状态。通过FSM管理门的状态，通过BT执行开门和关门的动作。

项目结构

整个项目的结构如下：

.
├── CMakeLists.txt
├── src
   ├── main.cpp
   ├── door_fsm.hpp
   ├── door_fsm.cpp
   ├── door_behavior_tree.hpp
   └── door_behavior_tree.cpp

4. 代码实现

• FSM实现

door_fsm.hpp 定义了状态和事件：

#ifndef DOOR_FSM_HPP
#define DOOR_FSM_HPP

#include <tinyfsm.hpp>

// 定义事件
struct OpenDoor : tinyfsm::Event {};
struct CloseDoor : tinyfsm::Event {};

// 定义状态
struct DoorClosed : tinyfsm::Fsm<DoorClosed> {
    void entry() override;
    void react(tinyfsm::Event const &) override;
};

struct DoorOpened : tinyfsm::Fsm<DoorOpened> {
    void entry() override;
    void react(tinyfsm::Event const &) override;
};

using DoorFSM = tinyfsm::FsmList<DoorClosed, DoorOpened>;

#endif // DOOR_FSM_HPP

door_fsm.cpp 实现了状态和事件的反应：

#include "door_fsm.hpp"
#include <iostream>

void DoorClosed::entry() {
    std::cout << "Door is now closed." << std::endl;
}

void DoorClosed::react(tinyfsm::Event const & e) {
    if (typeid(e) == typeid(OpenDoor)) {
        transit<DoorOpened>();
    }
}

void DoorOpened::entry() {
    std::cout << "Door is now opened." << std::endl;
}

void DoorOpened::react(tinyfsm::Event const & e) {
    if (typeid(e) == typeid(CloseDoor)) {
        transit<DoorClosed>();
    }
}

template class tinyfsm::Fsm<DoorClosed>;
template class tinyfsm::Fsm<DoorOpened>;

namespace {
    struct InitialStateClosed : DoorClosed {};
}

template<>
void tinyfsm::Fsm<DoorClosed>::set_initial_state() {
    current_state_ptr = &_state_instance<InitialStateClosed>::value;
}

namespace {
    struct InitialStateOpened : DoorOpened {};
}

template<>
void tinyfsm::Fsm<DoorOpened>::set_initial_state() {
    current_state_ptr = &_state_instance<InitialStateOpened>::value;
}

• 行为树实现

door_behavior_tree.hpp 定义了行为树的类：

#ifndef DOOR_BEHAVIOR_TREE_HPP
#define DOOR_BEHAVIOR_TREE_HPP

#include <behaviortree_cpp/bt_factory.h>

class DoorBehaviorTree {
public:
    DoorBehaviorTree();
    void run();
private:
    BT::Tree tree;
};

#endif // DOOR_BEHAVIOR_TREE_HPP

door_behavior_tree.cpp 实现了行为树的节点和行为：

#include "door_behavior_tree.hpp"
#include <iostream>
#include <thread>
#include <chrono>

class OpenDoorAction : public BT::SyncActionNode {
public:
    OpenDoorAction(const std::string& name) : BT::SyncActionNode(name, {}) {}
    BT::NodeStatus tick() override {
        std::cout << "Action: Open the door." << std::endl;
        return BT::NodeStatus::SUCCESS;
    }
};

class CloseDoorAction : public BT::SyncActionNode {
public:
    CloseDoorAction(const std::string& name) : BT::SyncActionNode(name, {}) {}
    BT::NodeStatus tick() override {
        std::cout << "Action: Close the door." << std::endl;
        return BT::NodeStatus::SUCCESS;
    }
};

DoorBehaviorTree::DoorBehaviorTree() {
    BT::BehaviorTreeFactory factory;
    factory.registerNodeType<OpenDoorAction>("OpenDoorAction");
    factory.registerNodeType<CloseDoorAction>("CloseDoorAction");

    tree = factory.createTreeFromText(R"(
        <root BTCPP_format="4">
            <BehaviorTree ID="MainTree">
                <Sequence name="main_sequence">
                    <OpenDoorAction/>
                    <CloseDoorAction/>
                </Sequence>
            </BehaviorTree>
        </root>
    )");
}

void DoorBehaviorTree::run() {
    while (tree.rootNode()->status() == BT::NodeStatus::IDLE || tree.rootNode()->status() == BT::NodeStatus::RUNNING) {
        tree.rootNode()->executeTick();
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

• 主程序

main.cpp 整合了FSM和BT：

#include <iostream>
#include "door_fsm.hpp"
#include "door_behavior_tree.hpp"

int main() {
    DoorFSM::start();

    DoorBehaviorTree behavior_tree;
    behavior_tree.run();

    std::cout << "FSM and Behavior Tree Example with Door" << std::endl;
    return 0;
}

5. 总结

本文展示了如何使用 TinyFSM 和 BehaviorTree.CPP 创建一个简单的系统，实现模拟门的开关操作。通过结合使用 FSM 和 BT，我们可以构建复杂的逻辑控制和决策系统，既可以通过 FSM 管理状态转换，又可以通过 BT 执行具体的操作。

希望这个示例能帮助理解 FSM 和 BT 的基本原理。

6. 参考

https://blog.csdn.net/whahu1989/category_10717968.html