Boost状态机--中级篇

已于 2022-06-29 17:53:15 修改
阅读量1w 收藏 25
点赞数 5
分类专栏： 其他 文章标签： boost 状态机
于 2016-04-11 16:16:24 首次发布

原文见http://www.cs.washington.edu/research/projects/uns/F9/src/boost_1_37_0/libs/statechart/doc/tutorial.html

原文以Camera为例，讲解了Boost状态机模型的使用方法；而本文的主要：

  • 对原文中的Camera模型略加修改与完善；
  • 写出了完整代码；可编译运行；
  • 演示各个对象（事件对象和状态对象）的生命周期；
  • 更清晰的模块化各个组件（事件、状态）； 故可以当作一个简单的代码框架;
另外：这里只涵盖了中级topics，对于高级内容，后续再写。
Camera的按键：
  • 配置键(Config Button)：  按此键会产生一个EvConfig事件，EvConfig事件用于在空闲状态（Idle）和配置状态(Configuring)之间切换；
  • 快门键(Shutter Button)： 可以半按(半按时产生一个EvShutterHalf事件)、全按（全按时产生一个EvShutterFull事件）以及释放（释放时产生一个EvShutterRelease事件）；
Camera的状态：
为了提高模块化（不同模块之间松耦合，不同team可以同时开发），将Camera分为两个大的状态：
  • 非拍摄状态（NotShooting）：  包含两个子状态，空闲状态（Idle）和配置状态（Configuring）；EvConfig事件用于二者之间的切换；
  • 拍摄状态（Shooting）：       包含对焦状态（Focusing）、聚焦状态（Focused）和照片存储状态（Storing）；
Camera工作过程：
  • Camera初始状态是NotShooting，NotShooting的初始状态是Idle，所以Camera启动时会自动进入Idle状态；
  • 处于Idle状态时，若User按下Config Button（产生一个EvConfig事件），Camera进入配置状态（Configuring）；反之，处于Configuring状态时，若User按下Config Button，Camera进入Idle状态并启用省电模式（powerSavingMode）；
  • 处于NotShooting（Idle或Configuring）状态时，若用户半按快门键（产生一个EvShutterHalf事件）并且电量充足（isBatteryLow为非）Camera进入对焦状态（Focusing），镜头前后移动以自动对焦；
  • 处于Focusing状态时，若自动对焦成功，Camera显示聚焦的物体（displayFocused），并在自己内部产生一个EvInFocus事件，然后Camera进入聚焦状态（Focused）；
  • 处于Focused状态时，User全按快门（产生一个EvShutterFull事件），若内存充足则分配内存（allocMem）并进入照片存储状态（Storing）；若内存不足则停在Foused状态；
事件的延迟处理：
在Camera的工作过程中，当Camera处于Focusing状态时User全按快门（产生一个EvShutterFull事件），由于对焦尚未完成，不能立即处理EvShutterFull事件。若丢弃此事件，那么在对焦完成后（进入Focused状态），User不得不再全按一次快门，造成不必要的麻烦；一个解决方案是延迟处理这个事件，其过程是这样的：
  • 当Camera处于Focusing状态User全按快门时，产生一个EvShutterFull事件，拷贝此事件（拷贝构造函数）；
  • 把事件的拷贝放入一个单独的queue中；
  • 销毁原EvShutterFull事件（析构函数）；
  • 当Camera离开Focusing状态进入Focused状态时，从queue中取出事件（EvShutterFull的拷贝）并处理；
  • 销毁EvShutterFull事件的拷贝（析构函数）；
这一切都是通过一个deferral完成的；
完整的状态图：

代码：

[root@localhost camera]# tree
.
├── bin
├── Makefile
└── src
    ├── camera
    │   ├── camera.cpp
    │   └── camera.hpp
    ├── event
    │   ├── events.cpp
    │   └── events.hpp
    └── state
        ├── istate.hpp
        ├── notshoot
        │   ├── configuring.cpp
        │   ├── configuring.hpp
        │   ├── idle.cpp
        │   ├── idle.hpp
        │   ├── notshooting.cpp
        │   └── notshooting.hpp
        └── shoot
            ├── focused.cpp
            ├── focused.hpp
            ├── focusing.cpp
            ├── focusing.hpp
            ├── shooting.cpp
            ├── shooting.hpp
            ├── storing.cpp
            └── storing.hpp

Makefile

INCLUDES=

LIBLINKS=

SOURCES=                                     \
    src/camera/camera.cpp                    \
    src/event/*.cpp                          \
    src/state/notshoot/idle.cpp              \
    src/state/notshoot/notshooting.cpp       \
    src/state/notshoot/configuring.cpp       \
    src/state/shoot/shooting.cpp             \
    src/state/shoot/focusing.cpp             \
    src/state/shoot/focused.cpp              \
    src/state/shoot/storing.cpp              \

EXE=bin/run


all: clean build

build:
        mkdir -p bin
        g++ -g -o $(EXE) $(INCLUDES) $(SOURCES) $(LIBLINKS)

clean:
        rm -f $(EXE)

test:
        ./$(EXE)

src/event/events.hpp

#ifndef __EVENTS_HPP__
#define __EVENTS_HPP__

#include <boost/statechart/event.hpp>

using namespace boost::statechart;

class EvConfig : public event< EvConfig >
{
  public:
    EvConfig();
    ~EvConfig();
};

class EvShutterHalf : public event< EvShutterHalf >
{
  public:
    EvShutterHalf();
    ~EvShutterHalf();
};

class EvShutterFull : public event< EvShutterFull >
{
  public:
    EvShutterFull();
    EvShutterFull(const EvShutterFull & other);
    ~EvShutterFull();
};

class EvShutterRelease : public event< EvShutterRelease >
{
  public:
    EvShutterRelease();
    ~EvShutterRelease();
};

class EvInFocus : public event< EvInFocus >
{
  public:
    EvInFocus();
    ~EvInFocus();
};
class EvStored : public event< EvStored >
{
  public:
    EvStored();
    ~EvStored();
};

#endif

src/event/events.cpp

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

using namespace std;

//============EvConfig============//
EvConfig::EvConfig()
{
  cout<<"Construct EvConfig"<<endl;
}
EvConfig::~EvConfig()
{
  cout<<"Destruct EvConfig"<<endl;
}

//============EvShutterHalf============//
EvShutterHalf::EvShutterHalf()
{
  cout<<"Construct EvShutterHalf"<<endl;
}
EvShutterHalf::~EvShutterHalf()
{
  cout<<"Destruct EvShutterHalf"<<endl;
}

//============EvShutterFull============//
EvShutterFull::EvShutterFull()
{
  cout<<"Construct EvShutterFull"<<endl;
}
EvShutterFull::EvShutterFull(const EvShutterFull & other)
{
  cout<<"Copy Construct EvShutterFull"<<endl;
}

EvShutterFull::~EvShutterFull()
{
  cout<<"Destruct EvShutterFull"<<endl;
}

//============EvShutterRelease============//
EvShutterRelease::EvShutterRelease()
{
  cout<<"Construct EvShutterRelease"<<endl;
}
EvShutterRelease::~EvShutterRelease()
{
  cout<<"Destruct EvShutterRelease"<<endl;
}


//============EvInFocus============//
EvInFocus::EvInFocus()
{
  cout<<"Construct EvInFocus"<<endl;
}
EvInFocus::~EvInFocus()
{
  cout<<"Destruct EvInFocus"<<endl;
}


//============EvStored============//
EvStored::EvStored()
{
  cout<<"Construct EvStored"<<endl;
}
EvStored::~EvStored()
{
  cout<<"Destruct EvStored"<<endl;
}

src/camera/camera.hpp

#ifndef __CAMERA_HPP__
#define __CAMERA_HPP__

#include <boost/statechart/state_machine.hpp>
#include "../event/events.hpp"

using namespace boost::statechart;
using namespace std;

//Yuanguo: forward declaration
class NotShooting;

class Camera : public state_machine< Camera, NotShooting >
{
  public:
    Camera();
    ~Camera();
    bool isMemAvail() const;
    bool isBatteryLow() const;

    string getCurState() const;

    //transition actions
    void displayFocused(const EvInFocus & evInFocus);
    void allocMem(const EvShutterFull & evShutterFull);
    void powerSavingMode(const EvConfig & evConfig);
};

#endif

src/camera/camera.cpp

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

#include "../state/istate.hpp"
//Yuanguo: although the full definition of the initial state "NotShooting" is not needed when
//declare Camera (thus only forward declaration is needed), the full definition of the states
//are necessary for
//       camera.initiate();
//thus, include NotShooting and its inner states definition here;
#include "../state/notshoot/notshooting.hpp"
#include "../state/notshoot/idle.hpp"
#include "../state/shoot/shooting.hpp"

using namespace std;

Camera::Camera()
{
  cout<<"Construct Camera"<<endl;
}

Camera::~Camera()
{
  cout<<"Destruct Camera"<<endl;
}

bool Camera::isMemAvail() const
{
  return true;
}

bool Camera::isBatteryLow() const
{
  return false;
}

string Camera::getCurState() const
{
  return string("CurrentState ------> ") + state_cast< const IState & >().getStateName();
}

void Camera::displayFocused(const EvInFocus & evInFocus)
{
  cout<<"[Transition Action]: Camera focused on objects"<<endl;
}

void Camera::allocMem(const EvShutterFull & evShutterFull)
{
  cout<<"[Transition Action]: Memory allocated for storing the picture"<<endl;
}

void Camera::powerSavingMode(const EvConfig & evConfig)
{
  cout<<"[Transition Action]: Camera goes into Power Saving Mode"<<endl;
}

int main()
{
  Camera camera;

  camera.initiate();
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvConfig());  //模拟按Config键
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvConfig());  //<span style="font-family: Arial, Helvetica, sans-serif;">模拟按Config键</span>
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvShutterHalf());  //模拟半按快门
  cout<<camera.getCurState()<<endl;

  cout<<"Press Shutter Full before focused"<<endl;
  camera.process_event(EvShutterFull());  //在对焦完成之前，模拟全按快门
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvInFocus());      //模拟对焦完成事件
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvShutterRelease()); //模拟释放快门
  cout<<camera.getCurState()<<endl;

  camera.process_event(EvStored());         //模拟存储完成
  cout<<camera.getCurState()<<endl;

  return 0;
}

src/state/istate.hpp

#ifndef __ISTATE_HPP__
#define __ISTATE_HPP__

#include <string>
using namespace std;

class IState {
    public:
        virtual string getStateName() const = 0;
};

#endif

src/state/notshoot/notshooting.hpp

#ifndef __NOTSHOOTING_HPP__
#define __NOTSHOOTING_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>

#include "../istate.hpp"
#include "../../event/events.hpp"

//Yuanguo: NotShooting is the initial state of Camera, and Camera is the context of NotShooting, so
//  1. forward declaration of NotShooting is needed when defining Camera, see camera.hpp;
//  2. full definition of Camera is needed when defining NotShooting, thus include camera.hpp here;
#include "../../camera/camera.hpp"

using namespace boost::statechart;

//Yuanguo: forward declaration;
class Idle;

class NotShooting : public simple_state< NotShooting, Camera, Idle >, public IState
{
  public:
    typedef custom_reaction< EvShutterHalf > reactions;

    NotShooting();
    ~NotShooting();
    string getStateName() const;
    result react(const EvShutterHalf & evShutterHalf);
};

#endif

src/state/notshoot/notshooting.cpp

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

//Yuanguo:
//We need a full definition of Shooting in line
//      return transit<Shooting>();
//Focusing is the initial state of Shooting, thus we have to include focusing.hpp
//here, otherwise, compiler will complain about error like
//      incomplete type 'boost::statechart::simple_state ...
//      ... MostDerived = NotShooting, Context = Camera ....'
//inclusion of non-initial states of Shooting is not necessary;
#include "../shoot/shooting.hpp"
#include "../shoot/focusing.hpp"

using namespace std;

NotShooting::NotShooting()
{
  cout<<"Enter NotShooting"<<endl;
}

NotShooting::~NotShooting()
{
  cout<<"Exit NotShooting"<<endl;
}

string NotShooting::getStateName() const
{
  return string("NotShooting");
}

result NotShooting::react(const EvShutterHalf & evShutterHalf)
{
  cout<<"NotShooting::react(const EvShutterHalf & evShutterHalf), ";
  if( context< Camera >().isBatteryLow() )
  {
    cout<<"Guard: isBatteryLow() is true"<<endl;
    //Yuanguo: We cannot react to the event ourselves, so we forward it
    //to our outer state (this is also the default if a state
    //defines no reaction for a given event).
    return forward_event();
  }
  else
  {
    cout<<"Guard: isBatteryLow() is false"<<endl;
    return transit<Shooting>();  //no transition action
  }
}

src/state/notshoot/idle.hpp

#ifndef __IDLE_HPP__
#define __IDLE_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>

#include "../istate.hpp"
#include "../../event/events.hpp"

//Yuanguo: Idle is the initial state of NotShooting, and NotShooting is the context of Idle, so
//  1. forward declaration of Idle is needed when defining NotShooting, see notshooting.hpp;
//  2. full definition of NotShooting is needed when defining Idle, thus include notshooting.hpp here;
#include "notshooting.hpp"

using namespace boost::statechart;

class Idle : public simple_state< Idle, NotShooting >, public IState
{
  public:
    typedef custom_reaction< EvConfig > reactions;

    Idle();
    ~Idle();
    string getStateName() const;
    result react(const EvConfig & evConfig);
};

#endif

src/state/notshoot/idle.cpp

#include <iostream>
#include "configuring.hpp"
#include "idle.hpp"

using namespace std;

Idle::Idle()
{
  cout<<"Enter Idle"<<endl;
}

Idle::~Idle()
{
  cout<<"Exit Idle"<<endl;
}

string Idle::getStateName() const
{
  return string("Idle");
}

result Idle::react(const EvConfig & evConfig)
{
  cout<<"Idle::react(const EvConfig & evConfig)"<<endl;
  return transit<Configuring>(); //no transition action
}


src/state/notshoot/configuring.hpp

#ifndef __CONFIGURING_HPP__
#define __CONFIGURING_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/transition.hpp>

#include "../../event/events.hpp"
#include "../istate.hpp"

//Yuanguo: NotShooting is the context of Configuring, so
//   full definition of NotShooting is needed when defining Configuring, thus include notshooting.hpp here;
#include "notshooting.hpp"

//Yuanguo: full definition of Idle is needed in line
//      typedef transition< EvConfig, Idle >
#include "idle.hpp"

using namespace boost::statechart;

class Configuring : public simple_state< Configuring, NotShooting >, public IState
{
  public:
    //Yuanguo: a short way for:
    //      typedef custom_reaction< EvConfig > reactions;
    //      result react( const EvConfig & evConfig)
    //      {
    //        return transit< Idle >(&Camera::powerSavingMode, evConfig);  //transition action is Camera::powerSavingMode()
    //      }
    typedef transition< EvConfig, Idle, Camera, &Camera::powerSavingMode > reactions;  //transition action is Camera::powerSavingMode()

    Configuring();
    ~Configuring();
    string getStateName() const;
};

#endif


src/state/notshoot/configuring.cpp

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

using namespace std;

Configuring::Configuring()
{
  cout<<"Enter Configuring"<<endl;
}

Configuring::~Configuring()
{
  cout<<"Exit Configuring"<<endl;
}

string Configuring::getStateName() const
{
  return string("Configuring");
}

src/state/shoot/shooting.hpp

#ifndef __SHOOTING_HPP__
#define __SHOOTING_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>
#include <boost/statechart/transition.hpp>

#include "../istate.hpp"
#include "../../event/events.hpp"

//Yuanguo: Camera is the context of Shooting, so
//  full definition of Camera is needed when defining Shooting, thus include camera.hpp here;
#include "../../camera/camera.hpp"

using namespace boost::statechart;

//Yuanguo: forward declaration
class Focusing;

class Shooting : public simple_state< Shooting, Camera, Focusing >, public IState
{
  public:
    typedef custom_reaction< EvShutterRelease > reactions;

    Shooting();
    ~Shooting();
    string getStateName() const;
    result react(const EvShutterRelease & evShutterRelease);
};

#endif

src/state/shoot/shooting.cpp

#include <iostream>

#include "shooting.hpp"
//Yuanguo:
//We need a full definition of NotShooting in line
//      return transit< NotShooting >();
//Idle is the initial state of NotShooting, thus we have to include idle.hpp
//here, otherwise, compiler will complain about error like
//      incomplete type 'boost::statechart::simple_state ...
//      ... MostDerived = NotShooting, Context = Camera ....'
//inclusion of non-initial states of NotShooting is not necessary;
#include "../notshoot/notshooting.hpp"
#include "../notshoot/idle.hpp"

using namespace std;

Shooting::Shooting()
{
  cout<<"Enter Shooting"<<endl;
}

Shooting::~Shooting()
{
  cout<<"Exit Shooting"<<endl;
}

string Shooting::getStateName() const
{
  return string("Shooting");
}

result Shooting::react(const EvShutterRelease & evShutterRelease)
{
  cout<<"Shooting::react(const EvShutterRelease & evShutterRelease)"<<endl;
  return transit< NotShooting >();
}

src/state/shoot/focusing.hpp

#ifndef __FOCUSING_HPP__
#define __FOCUSING_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>
#include <boost/mpl/list.hpp>
#include <boost/statechart/deferral.hpp>

#include "../../event/events.hpp"
#include "../istate.hpp"

//Yuanguo: Shooting is the context of Focusing, so
//   full definition of Shooting is needed when defining Focusing, thus include
//   shooting.hpp here;
#include "shooting.hpp"

using namespace boost::statechart;

class Focusing : public simple_state< Focusing, Shooting >, public IState
{
  public:
    //Yuanguo:
    //if the user fully press shutter when the camera is still in focusing (has
    //not focused yet), we defer the event until focused.
    //that means:
    //when an event of EvShutterFull comes:
    //    copy the EvShutterFull event by copy-constructor;
    //    put the copy in a separated queue;
    //    destruct the EvShutterFull event;
    //when camera exits Focusing state (e.g. gets into Focused state):
    //    let Focused state process the events in the queue;
    //    empty the queue and destruct the copied events;
    typedef boost::mpl::list<
      custom_reaction< EvInFocus >,
      deferral< EvShutterFull > > reactions;

    Focusing();
    ~Focusing();
    string getStateName() const;
    result react(const EvInFocus & evInFocus);
};

#endif


src/state/shoot/focusing.cpp

#include <iostream>
#include "focusing.hpp"
#include "focused.hpp"
#include "../../camera/camera.hpp"

using namespace std;

Focusing::Focusing()
{
  cout<<"Enter Focusing"<<endl;
}
Focusing::~Focusing()
{
  cout<<"Exit Focusing"<<endl;
}
string Focusing::getStateName() const
{
  return string("Focusing");
}
result Focusing::react(const EvInFocus & evInFocus)
{
  cout<<"Focusing::react(const EvInFocus & evInFocus)"<<endl;
  return transit< Focused >(&Camera::displayFocused, evInFocus); //transition action is Camera::displayFocused()
}

src/state/shoot/focused.hpp

#ifndef __FOCUSED_HPP__
#define __FOCUSED_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>

#include "../../event/events.hpp"
#include "../istate.hpp"

//Yuanguo: Shooting is the context of Focused, so
//   full definition of Shooting is needed when defining Focused, thus include shooting.hpp here;
#include "shooting.hpp"

class Focused : public simple_state< Focused, Shooting >, public IState
{
  public:
    typedef custom_reaction < EvShutterFull > reactions;

    Focused();
    ~Focused();
    string getStateName() const;
    result react(const EvShutterFull & evShutterFull );
};

#endif

src/state/shoot/focused.cpp

#include <iostream>
#include "focused.hpp"
#include "storing.hpp"
#include "../../camera/camera.hpp"

using namespace std;

Focused::Focused()
{
  cout<<"Enter Focused"<<endl;
}
Focused::~Focused()
{
  cout<<"Exit Focused"<<endl;
}
string Focused::getStateName() const
{
  return string("Focused");
}
result Focused::react(const EvShutterFull & evShutterFull )
{
  cout<<"Focused::react(const EvShutterFull & evShutterFull ), ";
  if( context< Camera >().isMemAvail() )
  {
    cout<<"Guard: isMemAvail() is true"<<endl;
    return transit<Storing>(&Camera::allocMem, evShutterFull); //transition action is Camera::allocMem()
  }
  else
  {
    cout<<"Guard: isMemAvail() is false"<<endl;
    //Yuanguo: Indicate that the event can be discarded. So, the
    // dispatch algorithm will stop looking for a reaction
    // and the machine remains in the Focused state.
    return discard_event();
  }
}

src/state/shoot/storing.hpp

#ifndef __STORING_HPP__
#define __STORING_HPP__

#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/custom_reaction.hpp>
#include <boost/statechart/deferral.hpp>
#include <boost/mpl/list.hpp>

#include "../../event/events.hpp"
#include "../istate.hpp"

//Yuanguo: Shooting is the context of Storing, so
//   full definition of Shooting is needed when defining Storing, thus include shooting.hpp here;
#include "shooting.hpp"

using namespace boost::statechart;

class Storing : public simple_state< Storing, Shooting >, public IState
{
  public:
    //Yuanguo: we have multiple reactions for different events;
    typedef boost::mpl::list<
      custom_reaction < EvStored >,
      custom_reaction < EvShutterRelease > > reactions;

    Storing();
    ~Storing();
    string getStateName() const;
    result react(const EvStored & evStored);
    result react(const EvShutterRelease & evShutterRelease);
};

#endif

src/state/shoot/storing.cpp

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

//Yuanguo:
//We need a full definition of NotShooting in line
//      return transit< NotShooting >();
//Idle is the initial state of NotShooting, thus we have to include idle.hpp
//here, otherwise, compiler will complain about error like
//      incomplete type 'boost::statechart::simple_state ...
//      ... MostDerived = NotShooting, Context = Camera ....'
//inclusion of non-initial states of NotShooting is not necessary;
#include "../notshoot/notshooting.hpp"
#include "../notshoot/idle.hpp"

using namespace std;

Storing::Storing()
{
  cout<<"Enter Storing"<<endl;
}
Storing::~Storing()
{
  cout<<"Exit Storing"<<endl;
}
string Storing::getStateName() const
{
  return string("Storing");
}
result Storing::react(const EvStored & evStored)
{
  cout<<"Storing::react(const EvStored & evStored)"<<endl;
  //Yuanguo: goto NotShooting when storing is finished;
  return transit< NotShooting >();
}
result Storing::react(const EvShutterRelease & evShutterRelease)
{
  cout<<"Storing::react(const EvShutterRelease & evShutterRelease)"<<endl;
  cout<<"Discard EvShutterRelease"<<endl;
  //Yuanguo: Don't go to NotShooting until storing is finished, even if the user
  //releases the shutter
  return discard_event();
}

测试（注意事件和状态对象的生命周期）：

[root@localhost camera]# make; make test
rm -f bin/run
mkdir -p bin
g++ -g -o bin/run  src/camera/camera.cpp src/event/*.cpp src/state/notshoot/idle.cpp src/state/notshoot/notshooting.cpp src/state/notshoot/configuring.cpp src/state/shoot/shooting.cpp src/state/shoot/focusing.cpp src/state/shoot/focused.cpp src/state/shoot/storing.cpp
./bin/run
Construct Camera
Enter NotShooting
Enter Idle
CurrentState ------> Idle                  //初始时进入Idle状态
Construct EvConfig                         //模拟按Config键，用于Idle到Configuring的切换
Idle::react(const EvConfig & evConfig)     //处理EvConfig事件
Exit Idle                                  
Enter Configuring                          
Destruct EvConfig                          //在进入“下一个状态”后，销毁事件
CurrentState ------> Configuring
Construct EvConfig                         //再此模拟按Config键，用于Configuring到Idle的切换
Exit Configuring                           
[Transition Action]: Camera goes into Power Saving Mode      //transition action在退出“前一个状态”之后，进入“后一个状态”之前执行
Enter Idle
Destruct EvConfig
CurrentState ------> Idle
Construct EvShutterHalf                     //模拟半按快门
NotShooting::react(const EvShutterHalf & evShutterHalf), Guard: isBatteryLow() is false  //处理EvShutterHalf事件
Exit Idle
Exit NotShooting
Enter Shooting
Enter Focusing
Destruct EvShutterHalf
CurrentState ------> Focusing               //进入对焦状态
Press Shutter Full before focused           //模拟提前全按快门
Construct EvShutterFull                     //<span style="font-family: Arial, Helvetica, sans-serif;">在对焦完成之前按快门，构造EvShutterFull事件</span>
Copy Construct EvShutterFull                //拷贝EvShutterFull事件并放入queue
Destruct EvShutterFull                      //销毁原EvShutterFull对象
CurrentState ------> Focusing
Construct EvInFocus                         //模拟对焦完成
Focusing::react(const EvInFocus & evInFocus)
Exit Focusing
[Transition Action]: Camera focused on objects //transition action在退出“前一个状态”之后，进入“后一个状态”之前执行
</span>Enter Focused                                   
Focused::react(const EvShutterFull & evShutterFull ), Guard: isMemAvail() is true    //进入“后一个状态”时，立即处理被延迟的事件
Exit Focused                                 //处理被延迟的EvShutterFull事件，导致Camera退出Focused状态
[Transition Action]: Memory allocated for storing the picture
Enter Storing
Destruct EvShutterFull                       //销毁EvShutterFull的拷贝
Destruct EvInFocus                           
CurrentState ------> Storing
Construct EvShutterRelease                   //模拟释放快门
Storing::react(const EvShutterRelease & evShutterRelease)
Discard EvShutterRelease                     //EvShutterRelease被丢弃，因为storing还未完成
Destruct EvShutterRelease
CurrentState ------> Storing                 //仍然处于Storing状态
Construct EvStored                           //模拟storing完成事件
Storing::react(const EvStored & evStored)
Exit Storing                                 //storing完成，退出Storing状态
Exit Shooting                                //层层退出外围状态（这里只有一层），直到“前一个状态”和“后一个状态”的“最小公共外围状态”
Enter NotShooting
Enter Idle                                   //层层进入“后一个状态”（这里只有一层）
Destruct EvStored
CurrentState ------> Idle                    
Destruct Camera                              //销毁状态机时，层层退出所有状态；
Exit Idle
Exit NotShooting
[root@localhost camera]#

[总结1]  reaction的实现方式有以下几种：

a. transition

typedef boost::statechart::transition< Event1, NextState1, optional Transition-Action > reactions;

特点：1. 不需要自定义react函数，系统自动生成（自动生成的react函数做的事情可能就是：调用Transistion-Action然后转向NextState1）；2. 因为react函数是自动生成的，Event1发生时，只能转向NextState1，而不能根据guard，转向不同的state；

b. 自定义reaction

	typedef boost::statechart::custom_reaction< Event1 > reactions;
	boost::statechart::result react( const Event1 & evt)  
	{
		if(guard1)
		{
			// transiting to next state will destruct current state object (similar to delete this!),
			// so transit() should be only called in return statement.
			return transit< NextState1 >(optional Transition-Action, args);
		}
		else if(guard2)
		{
			return transit< NextState2 >(optional Transition-Action, args);
		}
		else //guard3
		{
			return transit< NextState3 >(optional Transition-Action, args);   
		}		
	}


特点：可以根据guard，转向不同的state；

注意：转向下一个state， transit<NextState>(...)，意味着当前state被析构，所以这个语句应该是最后执行，即return语句；

c. defered events

typedef boost::statechart::deferral< Event1 > reactions;


特点：不需要定义react函数，系统也不会生成，因为当前state根本不会处理这个Event1。在当前state，若有Event1发生，则Event1被存起来，等到当前state退出的时候，把保存的Event1添加到main queue中（相当于Event1这时候才发生），由next state处理（当然，next state应该也可以defer它）。

d. 多个reactions

  typdef mpl::list<
    boost::statechart::transition< Event1, NextState1, Optional-Transition-Action >,
	boost::statechart::custom_reaction< Event2 >,
	boost::statechart::deferral< Event3 >
  > reactions;

  boost::statechart::result react( const Event2 & evt) 
  {
  ....
  }
  //Event1和Event3不需要定义react;


特点：这不算是一种新的reaction类型，只是上面几种的组合。通过它，一个state就可以响应多个event。

[总结2] forward_event

a. 如果state为某个event定义了reaction： 如果在某种情况下，本state不能处理这个event（例如，isBatteryLow=true的时候，无法处理EvShutterHalf事件），它可以通过forward_event抛给外围状态。

b. 如果state没有为某个event定义reaction：如果状态机处于这个state，并且这个event发生了，那么这个event被自动forward到它的外围state。例如：Camera处于Idle状态，EvShutterHalf事件发生了，但Idle状态没有定义这个事件的reaction，所以，被forward到Idle的外围状态NotShooting。

[总结3] discard_event

当状态机处于某个state，事件event发生了，但在某种情况下，不应该转移到别的state而应该保持在当前状态（例如，Camera处于Focused状态，EvShutterFull发生了，但是isMemAvail=false，即没有足够的存储来存照片，所以还应该保持在Focused状态）。这时，有两种选择：1. transit<CurrentState>()，即：退出CurrentState，然后重入——要求enter和exit(即CurrentState的构造和析构)是空的；2. discard_event。显然，2更高效。

[总结4] transition action的执行环境

class State_D: public simple_state< State_D, State_C >, public IState  
{  
  public:  
    typedef custom_reaction< Ev > reactions;  
  
    State_D() {}  
    ~State_D() {}  
      
    result react(const Ev & evt)
    {
        return transit<State_X>(t, evt);
    }  
};


从State_D转向State_X的过程是：

  1. ~State_D()
  2. ~State_C()
  3. ~State_B()
  4. ~State_A()
  5. t()
  6. State_X()，进而 State_Y(), State_Z();
也就是说，先层层退出当前State，直到当前State和目标State的 最内公共Context； 在 最内公共Context中执行transition action；然后，层层进入目标State。

for_tech
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
动态规划与贪心，动态规划核心思想
Spidy_harker的博客
10-03 1264
贪心： 决策者当前的做出决策不会影响到后续的决策选择，那么每一步都做出最优的决策则可使得全局达到最优的情况。 以下我们来看一个例子： 决策者要从状态A到达状态G，状态A经过决策b可以到达状态B，经过决策c可以到达状态C，以此类推，具体情况见下图。（边代表决策，节点代表状态） 观察此图可以发现一个很重要的点：状态B/C都可以到达状态E/F，即不管你选择决策b到达状态B，还是决策c到达状态C，都可以从状态B/C做出同等的代价e/f到达状态E/F，即当前的决策不会影响到后续的决策。 那么决策者可以在每一步的决策
boost::sml 状态机
weixin_45591821的博客
03-22 741
boost::sml
Boost库中的状态机管理：BoostStateChart学习整理
最新发布
weixin_44897472的博客
04-26 1246
Boost中管理状态机的相关库，statechartstate或以及事件event。作为载体，state作为内容，event作为事件传输介质。状态：对象在其生命周期内，所处于的运动和发展阶段。例如：人可以处于工作中这个状态，也可以处于娱乐中状态。状态应该有上下文环境。例如：人处于工作中状态，要属于职业生涯状态而不能是退休状态，也必须是活着的，而不能是死亡的状态。状态可以有子状态。例如：工作中状态，可以有开会中，会客中，被训斥中等子状态。状态机：由许多相关状态构成的集合。
转载了一篇关于boost状态机使用教程
weixin_43818541的博客
09-03 2139
链接: 原博客. 讲解的比较清晰！！！！收藏了 1 简单状态机 简单状态机按照如下工作流程： 它包括一个初始化伪状态，一个正常状态和一个结束状态。如下代码是上述图表中流程的一种实现。 #include #include <boost/msm/back/state_machine.hpp> #include <boost/msm/front/state_machine_def.hpp> #include <boost/msm/front/functor_row.hpp>
boost-serialization-examples
05-15
Boost序列化示例 简而言之，序列化就是将任何数据结构转换为一种格式，该格式允许将数据写入支持文件（文件，套接字等）。 Boost提供了一个序列化库，该库带有针对POD和stl类型的开箱即用的序列化，但是它易于使用...
boost-note-win.exe
04-24
BoostNote Windows Install package, 开源的多平台Markdown编辑器，目前因为官网下载太慢了，一度失去了使用的兴趣，但是还是禁不住诱惑，实在太好用了，分享给大家，希望大家喜欢。
boost-build-package-manager：用于管理软件包的Boost.Build模块
02-04
"boost-build-package-manager"是这个系统的一个扩展模块，专门用于管理软件包，使得在Boost.Build环境中更加方便地安装、更新和使用第三方库。 这个模块的核心目标是解决在大型项目中管理和维护众多依赖关系的问题...
4-Switch Buck-Boost Bi-directional DC-DC Converter
05-23
buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boost buck-boostDC-DC buck-boostDC-DC buck-boost buck-boost ...
boost-and-buck.zip_Boost_buck_buck-boost电路
07-15
在电子工程领域，Boost、Buck以及Buck-Boost转换器是电源管理中常见的DC-DC转换电路。这些电路主要用于调整直流电压的等级，以适应不同的电源需求。下面将详细介绍这三个概念及其工作原理。 首先，Boost电路（升压...
processEvents()函数
热门推荐
xi__q的专栏
03-08 2万+
在使用Qt的过程中，经常会碰到需要运行耗时的逻辑代码的时候，一般都采用多线程进行处理，这样可以保证主线程（界面）不会被占用，导致用户操作无效，出现等待无响应现象。 Qt本身提供一个函数QApplication::processEvents()来处理。 下面采用示例来进行解释processEvents函数的功能 MainWindow::MainWindow(QWidget *parent) ...
boost 里面有状态机了,如何将数据传递到当前Boost元状态机（MSM）子状态
weixin_29447549的博客
12-30 316
In the following example, while the current execution is still in substate1, I want to pass data to substate1 continuously and then send Event3 or Event1 based on the data. Looks like MSM supports onl...
Boost 的事件管理架構：Signal / Slot
小胖SUN
01-09 1107
Boost 的事件管理架構：Signal / Slot（上） 这篇文章写的很好，但国内需要翻墙才能看到，故转载至此，方便大家 转载：http://kheresy.wordpress.com/2011/04/07/boost_signals_part1/   隔了很久了，不過這篇也是之前 Boost C++ Libraries 系列文章的一部分；而這一篇要介紹的，則是 Boost 裡面的
Boost的状态机库教程(3)
Living And Programing
10-20 5097
1.2 增加动作    此时我们将只用一种动作：transitions，我们在下面的代码中插入了黑体的部分。  #include   // ...  struct Stopped; struct Active : sc::simple_state {   
boost 里面有状态机了_Boost的状态机库教程(1)
weixin_29048309的博客
12-30 609
介绍Boost状态机库一个应用程序框架，你可以用它将UML状态图快速的转换为可执行的c++代码，而不需要任何的代码生成器。它支持几乎所有的UML特征，可以直接了当的转换，并且转换后的c++代码就像对状态机进行一次文本描述一样具体可读性。如何阅读这个教程这个教程是以线性阅读的方式进行的章节设计。如果你是第一次看这个教程的话，你可以从头开始读，到你觉得了解的东西对你手头的任务来说已经足够时就停止。具体...
第二章 状态机思维和状态机变量
dong_wenbo的博客
05-24 1024
 2.1初始化项目 react-native init 项目名称  ---- 初始化一个RN项目 npm list ---- 查看init命令都下载了哪些依赖包 package.json文件 ---- 记载着当前初始化项目中React框架与React Native框架的版本号 rninit工具 ---- 帮助开发者初始化一个以前版本的RN项目 npm install -g rninit ...
boost 里面有状态机了_一个很有代表性的boost状态机实例
weixin_39612499的博客
12-30 161
#include #include #include #include #include namespace sc = boost::statechart;struct Event1 : sc::event{};struct Event2 : sc::event{};struct SimpleState1;struct StateMachine1 : sc::state_machine{State...
boost 状态机--简介
u010217394的博客
12-25 233
原文：The Boost Statechart Library 译者：penghuster 简介 Boost 状态图库是一个无需代码生成器就可以快速转换 UML 状态图表伪可执行的 C++ 代码框架。由于几乎支持所有 UML的特性直接转换，故所产生的C++代码十分接近于状态表的原文文字描述。 如何阅读此教程 该教程内容设计为逐步深入。读者可以从合适位置开始读，直到对于解决你的任务为止。特别地：...
boost、buck-boost电路分析
07-28
对于boost和buck-boost电路的分析，我可以给你一些基本的介绍。 Boost电路是一种DC-DC变换器，它能将输入电压增加到比输入电压更高的输出电压。Boost电路通常由一个开关管、一个电感和一个输出电容组成。当开关管导通时，电感储存能量；当开关管截止时，储存的能量通过输出电容释放，从而使输出电压增加。Boost电路常用于需要输出电压大于输入电压的应用，如电动汽车、太阳能系统等。 Buck-boost电路也是一种DC-DC变换器，它可以实现输入电压的升降转换。与Boost电路不同的是，Buck-boost电路既可以将输入电压升高到更高的输出电压，也可以将输入电压降低到更低的输出电压。Buck-boost电路通常由一个开关管、一个电感和一个输出电容组成。通过控制开关管的导通和截止状态，可以实现输入电压的升降转换。Buck-boost电路常用于需要输出电压可调性的应用，如手机充电器、LED驱动器等。 对于这两种电路，你可以进一步研究它们的工作原理、控制方法和性能参数等方面的内容，以更深入地了解它们的分析和应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值