层次状态机的实现 c语言

最新推荐文章于 2024-06-10 10:02:59 发布
最新推荐文章于 2024-06-10 10:02:59 发布
阅读量3.7k 收藏 7
点赞数 1
分类专栏： 数据结构
层次状态机的实现  2006-03-14 15:56:47

分类：

 

本文讲述层次状态机实现形式中的行为继承。从行为继承与类继承之间的OO类相似来看，一个成功的层次状态机应该能够模拟下列属于C++对象模型。

²        使用和维护简单

²        应允许转态机拓扑容易改变，不应要求转换连接的人工代码，所需要的修改限制在代码的一个地方。

²        提供好的运行-时间效率和小的存储。

²        遵守C++中的“零额外开销”原则。

为了满足上面的要求，层次状态机的实现着重于下面的主要元素：

²        完全支持行为继承的层次关系

²        用状态进入和退出动作实现有保证得初始化和清除

²        通过类继承支持规定的状态模型

1.      基本要素

(1)     状态：在层次状态的情形下，状态处理器必须返回朝状态，这导致层次状态处理特征标记的递归定义。构造这种特征标记在C++是不可能的，于是定义下面宏来近似：

typedef void (* QPseudoState)(QEVENT const *pEvent);

typedef QPseudoState (* QState)(QEVENT const *pEvent);

(2)     进入/退出动作和初始状态：这些元素是状态专有的特征，在转态中他们被定义，而特别的是与到达状态所进过的路径无关。保留信号的转态定义为：

typedef enum tagQSIG

{

            Q_EMPTY_SIG = 1,

            Q_INIT_SIG,

            Q_ENTRY_SIG,

            Q_EXIT_SIG,

            Q_USER_SIG,

} QSIG;

状态处理机可以用一般的switch语句规定适当的用例处理这些信号，可以自由的执行相应信号的操作。

(3)     状态转换：状态处理机用Q_TRAN实现状态转换，并且在原状态的上下文中执行动作，即：改变状态之前调用Q_TRAN（和UML规定不一致）。

#define Q_TRAN(target_) Q_TranDyc((QState)(target_))

(4)     Top状态和初始伪状态：每个层次状态机都有一个Top状态，包括整个状态的所有其它元素。Top状态没有超状态，用户也不能覆盖；Top状态的唯一目的是提供状态层次的最高的根，使最高处理器能返回Top; Top状态唯一能订制的是初始化。初始化伪状态处理机仅规定初始化转换，必须指明被窃套的Top状态的状态机的缺省状态。

 

2.         实现代码：

(1)         头文件代码：

#ifndef STATE_INHERIT_H

#define STATE_INHERIT_H

 

typedef unsigned short QSIG;

// Define the signal of state machine

enum

{

    Q_EMPTY_SIG = 0,

    Q_INIT_SIG = 1,

    Q_ENTRY_SIG,

    Q_EXIT_SIG,

    Q_USER_SIG

};

 

// Define the signal of state machine

typedef struct tagQEVENT

{

  QSIG sig;

  unsigned char *pEvent1;

  unsigned char *pEvent2;

  // TODO: add fields to the event

} QEVENT;

 

// define state data type

typedef void (* QPseudoState)(QEVENT const *pEvent);

typedef QPseudoState (* QState)(QEVENT const *pEvent);

typedef QPseudoState QSTATE;

 

#define Q_TRIGGER(state, sig) \

   (QState)(*(state))((QEVENT*)&pkgStdEvt[sig])

 

// define a transation that don't change the state,

// just treat the pEvent with the target state.

// this is used by concurrent state

#define Q_INIT(target_) Init_((QState)(target_));

#define Q_TRAN(target_) Q_TranDyc((QState)(target_));

 

void Init_(QState target);

void Q_Init(QSTATE target);

void Q_Initial(QEVENT const* pQevt);

void Q_Dispatch(QEVENT const* pQevt);

void Q_TranDyc(QState target);

 

 

#endif //STATE_INHERIT_H

(2)         实体代码：

#include

#include

#include "state_inherit.h"

 

static QState srcState;         // source state

static QState actState;         // active state

static QEVENT const pkgStdEvt[] =

{

   {Q_EMPTY_SIG, 0, 0},

   {Q_INIT_SIG, 0, 0},

   {Q_ENTRY_SIG, 0, 0},

   {Q_EXIT_SIG, 0, 0}

};

 

void Q_Initial(QEVENT const* pQevt)

{

    printf("Top_Init;");

}

 

void Q_Dispatch(QEVENT const* pQevt)

{

    for (srcState = actState; srcState;

         srcState = (QState)(*srcState)(pQevt))

    {}

}

void Init_(QState target)

{

    actState = target;

}

 

void Q_Init(QSTATE target)

{

    register QState s;

 

    actState = (QState)target;

    srcState = (QState)Q_Initial;

 

    s = actState;                               // save actState in a temporary

    (*(QPseudoState)srcState)((QEVENT*)0);      // top-most initial tran.

                                    // initial transition must go one level deep

 

    s = actState;                                     // update the temporary

    Q_TRIGGER(s, Q_ENTRY_SIG);           // enter the state

    while (0 == Q_TRIGGER(s, Q_INIT_SIG))

    {

        // init handled

        // initial transition must go one level deep

        s = actState;

        Q_TRIGGER(s, Q_ENTRY_SIG);       // enter the substate

    }

}

 

void Q_TranDyc(QState target)

{

    QState entry[8], p, q, s, *e, *lca;

 

    for (s = actState; s != srcState; )

    {

        QState t;

        t = Q_TRIGGER(s, Q_EXIT_SIG);

        if (t)

        {

            // exit action unhandled, t points to superstate

            s = t;

        }

        else

        {

           // exit action handled, elicit superstate

            s = Q_TRIGGER(s, Q_EMPTY_SIG);

        }

    }

 

    *(e = &entry[0]) = 0;

    *(++e) = target;                              // assume entry to target

 

    // (a) check source == target (transition to self)

    if (srcState == target)

    {

        Q_TRIGGER(srcState, Q_EXIT_SIG);            // exit source

        goto inLCA;

    }

    // (b) check source == target->super

    p = Q_TRIGGER(target, Q_EMPTY_SIG);

    if (srcState == p) goto inLCA;

    //(c) check source->super == target->super (most common)

    q = Q_TRIGGER(srcState, Q_EMPTY_SIG);

    if (q == p)

    {

        Q_TRIGGER(srcState, Q_EXIT_SIG);            // exit source

        goto inLCA;

    }

    // (d) check source->super == target

    if (q == target)

    {

        Q_TRIGGER(srcState, Q_EXIT_SIG);           // exit source

        --e;                                     // not enter the LCA

        goto inLCA;

    }

    // (e) check rest of source == target->super->super... hierarchy

    *(++e) = p;

    for (s = Q_TRIGGER(p, Q_EMPTY_SIG); s; s = Q_TRIGGER(s, Q_EMPTY_SIG))

    {

        if (srcState == s)

        {

            goto inLCA;

        }

        *(++e) = s;

    }

    Q_TRIGGER(srcState, Q_EXIT_SIG);                // exit source

    // (f) check rest of source->super == target->super->super...

    for (lca = e; *lca; --lca)

    {

        if (q == *lca)

        {

            e = lca - 1;                      // do not enter the LCA

            goto inLCA;

        }

    }

    // (g) check each srcState->super->super..for each target...

    for (s = q; s; s = Q_TRIGGER(s, Q_EMPTY_SIG))

    {

        for (lca = e; *lca; --lca)

        {

            if (s == *lca)

            {

                e = lca - 1;                           // do not enter the LCA

                goto inLCA;

            }

        }

        Q_TRIGGER(s, Q_EXIT_SIG);                        // exit s

    }

    assert(0);                                         // malformed HSM

    inLCA:         // now we are in the LCA of srcState and target

    assert(e < &entry[sizeof(entry) / sizeof(*entry)]); // entry fits

    while (s = *e--)

    {

        // retrace the entry path in reverse order

        Q_TRIGGER(s, Q_ENTRY_SIG);                       // enter s

    }

    actState = target;                   // update current state

    while (0 == Q_TRIGGER(target, Q_INIT_SIG))

    {

        // initial transition must go one level deep

        assert(target == Q_TRIGGER(actState, Q_EMPTY_SIG));

        target = actState;

        Q_TRIGGER(target, Q_ENTRY_SIG);                // enter target

    }

3.         范例：

(1)         范例状态图

(2)         范例代码

#include

#include "state_inherit.h"

 

QSTATE s0(QEVENT const *e);

QSTATE s1(QEVENT const *e);

QSTATE s2(QEVENT const *e);

QSTATE s11(QEVENT const *e);

QSTATE s21(QEVENT const *e);

QSTATE s211(QEVENT const *e);

QSTATE Q_Top(QEVENT const *e);

static void Initial(QEVENT const *e);

static bool bFoo;

 

enum QSignals {

   A_SIG = Q_USER_SIG,

   B_SIG, C_SIG, D_SIG, E_SIG, F_SIG, G_SIG, H_SIG

};

 

static const QEVENT testQEvt[] =

{

   {A_SIG, 0, 0}, {B_SIG, 0, 0}, {C_SIG, 0, 0}, {D_SIG, 0, 0},

   {E_SIG, 0, 0}, {F_SIG, 0, 0}, {G_SIG, 0, 0}, {H_SIG, 0, 0}

};

 

int main()

{

   printf("Hiberarchy state machine testing\n");

 

   Initial(0);       // trigger initial transition

   for (;;)

   {

      char c;

      printf("\nSignal<-");

      c = getc(stdin);

      getc(stdin);              // discard '\n'

      if (c < 'a' || 'h' < c) {

         return 0;

      }

      Q_Dispatch(&testQEvt[c - 'a']); // dispatch

   }

   return 0;

}

 

static QSTATE Q_Top(QEVENT const *e)

{

    return 0;

}

 

void Initial(QEVENT const *e)

{

   bFoo = false;

   Q_Init((QSTATE)s0);

}

 

QSTATE s0(QEVENT const *e) {

    if (e != NULL)

    {

       switch (e->sig)

       {

       case Q_ENTRY_SIG: printf("s0-ENTRY;"); return 0;

       case Q_EXIT_SIG: printf("s0-EXIT;");  return 0;

       case Q_INIT_SIG: printf("s0-INIT;"); Q_INIT(s1); return 0;

       case E_SIG:      printf("s0-E;"); Q_TRAN(s211);  return 0;

       }

    }

   return (QSTATE)Q_Top;

}

 

QSTATE s1(QEVENT const *e) {

   switch (e->sig) {

   case Q_ENTRY_SIG: printf("s1-ENTRY;"); return 0;

   case Q_EXIT_SIG: printf("s1-EXIT;");   return 0;

   case Q_INIT_SIG: printf("s1-INIT;");Q_INIT(s11); return 0;

   case A_SIG:      printf("s1-A;");   Q_TRAN(s1);  return 0;

   case B_SIG:      printf("s1-B;");   Q_TRAN(s11); return 0;

   case C_SIG:      printf("s1-C;");   Q_TRAN(s2);  return 0;

   case D_SIG:      printf("s1-D;");   Q_TRAN(s0);  return 0;

   case F_SIG:      printf("s1-F;");   Q_TRAN(s211);return 0;

   }

   return (QSTATE)s0;

}

 

QSTATE s11(QEVENT const *e) {

   switch (e->sig) {

   case Q_ENTRY_SIG: printf("s11-ENTRY;"); return 0;

   case Q_EXIT_SIG:  printf("s11-EXIT;");  return 0;

   case G_SIG:  printf("s11-G;"); Q_TRAN(s211); return 0;

   case H_SIG:                 // internal transition with a guard

      if (bFoo)

      {                      // test the guard condition

         printf("s11-H;");

         bFoo = false;

         return 0;

      }

      break;

   }

   return (QSTATE)s1;

}

 

QSTATE s2( QEVENT const *e) {

   switch (e->sig) {

   case Q_ENTRY_SIG: printf("s2-ENTRY;"); return 0;

   case Q_EXIT_SIG: printf("s2-EXIT;");   return 0;

   case Q_INIT_SIG: printf("s2-INIT;");Q_INIT(s21); return 0;

   case C_SIG:      printf("s2-C;");   Q_TRAN(s1);  return 0;

   case F_SIG:      printf("s2-F;");   Q_TRAN(s11); return 0;

   }

   return (QSTATE)s0;

}

 

QSTATE s21(QEVENT const *e) {

   switch (e->sig) {

   case Q_ENTRY_SIG: printf("s21-ENTRY;"); return 0;

   case Q_EXIT_SIG: printf("s21-EXIT;");   return 0;

   case Q_INIT_SIG:printf("s21-INIT;");Q_INIT(s211);return 0;

   case B_SIG:     printf("s21-C;");   Q_TRAN(s211);return 0;

   case H_SIG:                     // self transition with a guard

      if (!bFoo)

      {            // test the guard condition

         printf("s21-H;");

         bFoo = true;

         Q_TRAN(s21);                   // self transition

         return 0;

      }

      break;                     //break to return the superstate

   }

   return (QSTATE)s2;

}

 

QSTATE s211(QEVENT const *e) {

   switch (e->sig) {

   case Q_ENTRY_SIG: printf("s211-ENTRY;"); return 0;

   case Q_EXIT_SIG:  printf("s211-EXIT;");  return 0;

   case D_SIG: printf("s211-D;"); Q_TRAN(s21); return 0;

   case G_SIG: printf("s211-G;"); Q_TRAN(s0);  return 0;

   }

   return (QSTATE)s21;

}

(3)         输出结果：

Hiberarchy state machine testing

Top_Init;s0-ENTRY;s0-INIT;s1-ENTRY;s1-INIT;s11-ENTRY;

Signal<-a

s1-A;s11-EXIT;s1-EXIT;s1-ENTRY;s1-INIT;s11-ENTRY;

Signal<-e

s0-E;s11-EXIT;s1-EXIT;s2-ENTRY;s21-ENTRY;s211-ENTRY;

Signal<-e

s0-E;s211-EXIT;s21-EXIT;s2-EXIT;s2-ENTRY;s21-ENTRY;s211-ENTRY;

Signal<-a

 

Signal<-h

s21-H;s211-EXIT;s21-EXIT;s21-ENTRY;s21-INIT;s211-ENTRY;

Signal<-h

 

Signal<-x

 

说明：上面功能都是通过C语言实现的，大家可以将其用C++实现，共享一下。

二宝妈妈的自我修炼
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
简单层次状态机的C语言实现
u013574576的博客
02-09 5759
简单层次状态机的C语言实现 一年前同学推荐开个博客，还确实有写博客的想法，当时正在过年，可能吃的太好了吧，反正后来这事就不了了之。临近年关，突然又想起来这事。工作两年多来也积累了不少东西，不过一直苦于没有时间静下心来总结，正好最近有时间把自己的成长过程记录下，作为写博客的一个开端，万事开头难，能不能坚持下去以后再说，先开个头。好了废话少说，开始正题。 程序员一般都不会对状态机陌生，典型应用如通信数...
状态机的C语言经典实现
12-08
本文将深入探讨有限状态机（FSM）的C语言实现，以及如何通过通用化代码来提高可读性、可移植性和调试效率。 首先，我们需要理解状态机的基本概念。状态机由一组状态和一些转换规则构成，每个状态对应系统的一种行为...
层次状态机-HSM代码解析
weixin_50977817的博客
03-26 1741
有限状态机在学习和工作中经常能够遇到，前面的文章也有使用到。但是对于层次状态机网上的学习资源却很少，导致一直不理解这个工作机制，后面偶然在GitHub看到一篇文章，深入学习后发现层次状态机太实用了，如果将其在项目上结合，肯定能够创造出一个比较好的代码框架。
层次状态机(HSM)用c语言的实现[收集].pdf
10-12
层次状态机(HSM)用c语言的实现[收集].pdf
探索轻量级的C语言实现：UML状态机框架
gitblog_00099的博客
06-10 405
探索轻量级的C语言实现：UML状态机框架 项目地址:https://gitcode.com/kiishor/UML-State-Machine-in-C 在嵌入式开发的世界里，每一个字节都至关重要，而对复杂系统行为的精确控制同样不可或缺。今天，我们将一起深入了解一个名为“UML State Machine in C”的开源项目，它是为那些寻求高效、简洁解决方案的工程师们量身定制的一把钥匙。 项目介...
HFSM，多层次状态机
ceciyang的专栏
12-11 6594
最近和一个同事讨论状态机的问题，记录一下。 我们知道状态机是AI（当然，不光是AI了）中常用的一种架构，有很多中实现方式，总体来说对于表达简单逻辑，还是很有帮助的，而且实现简单，甚至用一个switch-case就可以了，但在实践中状态机有一个致命的缺点，当状态一旦多了之后，它的跳转就会变的不可维护，假设有n个状态的话，那我们就需要维护最多n*n的跳转链接（因为状态机允许自己跳转自己），而且对
层次状态机
热门推荐
自由的天空
11-30 1万+
出处：http://xlambda.com/blog/2014/11/04/hierarchical-state-machine/ 计算机程序是写给人看的，只是顺便能运行。 —— 《计算机程序的构造和解释》 [1] FSM 在计算机领域，FSM(有限状态机)是一个在自动机理论和程序设计实践中很常见的术语，简单来说，有限状态机表示的是系统根不同输入/不
状态机实现c语言多级菜单,在C语言中实现分层状态机
weixin_35214204的博客
05-18 919
有几种方法可以解决这个问题。这里有一个:编辑——添加了通用层次结构typedef unsigned op_code_type;typedef void (*dispatch_type)(op_code_type);typedef struct hierarchy_stack hierarchy_stack;struct hierarchy_stack {dispatch_type func;hie...
C语言状态机
08-14
层次状态机是FSM的一种扩展形式，允许状态之间形成层次结构，从而能够更高效地管理和组织复杂的状态机。 - **概念**：HSM允许定义多个子状态机，这些子状态机可以在更高层次的状态下组合使用。 - **编程方法**：...
c语言实现状态机.zip
最新发布
06-13
实际应用中，状态机可能会变得更加复杂，包括多个并发状态、条件转移、历史状态等特性，但这些基本元素会构成任何状态机实现的基础。通过理解和熟练掌握这些概念，你可以构建出适应各种需求的状态机系统。
c语言状态机资料.rar_FSM c++_c_c层次状态机_lionmss_状态机
07-14
本文的重点就在于，怎样利用状态机原理进行程序...然后引出本文的重点 HSM（层次状态机）的概念和设计方法。为了使本文既可以 作为设计方法的参考，又可以作为实现方法的参考，本文会给出 FSM 和 HSM 的 C 语言实现。
StateMachineCompiler for C 根据状态表生成【层次状态机】【C代码】
09-24
Python实现，根据状态表生成C代码的【层次状态机】，亦可退化成【平面状态机】。使用C模拟C++的一些特性。 2009.12.3: 里面有readme，在研究之前先读一下。 对于号称“专业研究。。。”的fazai001（无激发）同学，本人表示不屑。 压缩包内有现成的例子，使用如下： 安装python2.5.2 在该目录的cmd下，运行python smc.sm watch.sm 生成两个目录，以及gen_xxx.c, gen_xxx.h几只文件 用vc6创建空的工程，加入gen_xxx.c, watch_hsm.c等三支文件就可以编译运行了 完整的状态机转换图在watch.sm文件中。
UML层次状态机详解
01-18
用UML图详细介绍各类层次状态机的原理和实现方法，适合对UML和状态机有兴趣的朋友
分层状态机
10-31
多层状态机，创建一个C#工程就可以运行，具体看打印，有兴趣的可以研究下
层次式状态机
04-17
层次式状态机缺乏资料介绍，给大家分享一下关于这方面的文章摘要
C语言编写的状态机源代码，包括四种典型实现方式
08-12
C语言编写的状态机源代码，包括四种典型实现方式。 状态机编程的经典参考资料。
基于C语言的最优HSM状态机架构实现
李肖遥的专栏
10-17 1015
关注、星标公众号，直达精彩内容来源：小鱼儿飞丫飞整理：技术让梦想更伟大 | 李肖遥前言：本框架实现的目的是在基于51单片机为控制芯片的产品内，因为51单片机的内存和堆栈比较有限，此框架比较...
c语言状态机_「编程之美」用C语言实现状态机(超实用)
weixin_39549899的博客
11-29 420
关于状态机，基础的知识点可以自行理解，讲解的很多，这里主要是想写一个有限状态机FSM通用的写法，目的在于更好理解，移植，节省代码阅读与调试时间，体现出编程之美。传统的实现方案if...else : 搞一大堆if else, 一个函数写很长很长......swich...case : 也搞一大堆一个函数写很长很长...... 先来看看最近做的一个项目，无线通信协议实现的状态机是什么样子的： 有三种...
分层有限状态机的C++实现
weixin_34306593的博客
10-20 757
为了方便我的游戏开发，写了这么一个通用的分层有限状态机。希望在其稳定以后，可以作为一个组件加入到我的游戏引擎当中。 目前使用了std::function来调用回调函数，在未来可能会用委托机制代替。 第一版仅仅是为了快速开发出来使用，在未来会对性能和易用性改进。 代码下载：http://download.csdn.net/detail/vvsxr/8060377...
C语言实现状态机设计与应用
本文将深入探讨有限状态机（FSM）和层次状态机（HSM）的概念，并提供C语言中的设计和实现方法。 ### 有限状态机(FSM)概念 有限状态机是一种数学模型，用于描述一个系统随时间变化的行为。它由以下几个要素构成： ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值