原创 状态机与函数指针

状态图－－一个图的数据结构！
1.while + switch;
2.状态机：就是指定系统的所有可能的状态及状态间跳转的条件，然后设一个初始状态输入给这台机器，机器就会自动运转，或最后处于终止状态，或在某一个状态不断循环。
游戏中状态切换是很频繁的。 可能以前要切换状态就是if~else，或者设标志，但这些都不太结构化， 如果把它严格的设为一种标准的状态机，会清楚的多。

比如控制一扇门的运动， 初始时门是关的， 当有力作用在门上时， 门开始慢慢打开，力的作用完后，门渐渐停止不动， 当有反向的力时，门又渐渐关上， 知道回到初始关的状态。 这个你会怎么来编程实现呢。 似乎很麻烦， 的确，没有状态机的思想时会很烦，设很多标志，一堆if条件。
用状态机的话，不只是代码更清晰， 关键是更符合逻辑和自然规律， 不同状态不同处理， 满足条件则跳转到相关状态。

伪码如下：
enum 
{  
 CLOSED, // 关上状态  
 CLOSING, // 正在关状态  
 OPENED, // 打开状态  
 OPENING, // 正在开的状态  
}doorState = CLOSED; // 初始为关  
 
Update()  
{  
     switch(doorState)  
     case CLOSED:  
          if (有人推门)  
               doorState = OPENING; // 跳转到正在开状态  
     break;  
     case OPENING:  
          door.Rotation += DeltaAngle; // 门的旋转量递增  
          if (门的速度为零) / / 力的作用已去  
               doorState = OPENED; // 跳转到开状态  
    break;  
    case OPENED:  
         if (有人关门)  
              doorState = CLOSING;  
   break;  
   case CLOSING:  
         door.Rotation -= DeltaAngle; // 门的旋转量递减  
         if (门的旋转角度减为零)  
              doorState = CLOSED; // 门已关上  
    break;   
}  
 
// 而绘制代码几乎不用怎么变, 门就是会严格按照状态机的指示去运动， 该停就会停  
Render()  
{  
     RotateView(door.Rotation);  
     DrawDoor(door.Position);  
} 

就说一个基本游戏的运转: （用到了一个状态然后还有子状态）
UpdateGame()  
BEGIN;  
   switch(gameState)  
   case 等待选择菜单: //它有三个子状态。  
   if (选择菜单项 ＝＝ 开始)  
   {  
       游戏初始；  
      gameState = 开始游戏  
   }  
   if (选择菜单项 ＝＝ 选项)  
      gameState = 设置  
   if (选择菜单项 ＝＝ 退出)  
       gameState = 退出  
 
 case 开始：  
   
 游戏运行；  
 if (用户按退出键)  
 gameState = 等待选择菜单 ;  
 ...其他的状态跳转处理;  
 case 退出:  
 释放资源；  
 退出；  
 case 设置:  
 分别处理不同的选项， 跳转不同的子状态；  
 case .... // 其他状态的处理  
   
END; 

某一个状态可以包含更多的子状态， 这样最好是同一层次的状态设为一个枚举, 并分到另一个switch处例如 enum STATES{state1, state2, state3}; state2又包含若干状态
则再定义enum SUB_STATE2{sub_state2_1, sub_state2_2, sub_state2_3,};想很多基本的渲染效果， 如淡入淡出， 闪烁等等， 用状态的思想会事半功倍， 思路也更清晰。其实像Opengl, Direct3D这样的渲染引擎本身就是状态机， 当你设置渲染的状态， 这台机器就保持这个状态进行渲染工作，如保持光照位置，保持片元颜色， 直到你再次改变它的状态。

总之， 用状态机的角度去看待问题， 往往能把比较复杂的系统分解为能单独处理的众多子状态， 处理也会得心应手。希望大家多用它， 很好的东西。

 用C语言实现一个状态机，很简单，和大家分享
用nRF24L01组建了一个简单的网络，做的一个小的状态机，网络中三个节点，开始拓扑为网状，后来为星型。

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h>  
 
 
//Finite state machine declaration  
//state declaration 
#define IDLE 0 //idle state in rx mode 
#define M_BROADCAST 1 //broadcast state in tx mode,broadcast to be a master point 
#define M_WAIT_BROADCAST_ACK 2 //wait for broadcast ack state in rx mode,wait for the point ack in a specific time window 
#define M_WAIT_COMMAND 3 //wait for command state,wait for PC command via UART 
#define M_BROADCAST_CANCEL 4 //broadcast cancel state,broadcast to cancel master point 
 
#define S_BROADCAST_ACK 5 //slave mode,send back self physical address 
#define S_WAIT_COMMAND 6 //slave mode, wait for command from the master point  
 
//state transition trig  
//used in master mode  
int isReqBeMaster = 0;//Is PC request the point to be master?  
int isTimeout = 0;//Is time out?  
int isReqCancelMaster = 0;//Is request to cancel master?  
//used in slave mode  
int isRxBroadcast = 0;//Is there a point broadcast to be master?  
int isRxBroadcastCancel = 0;//Is receive broadcast cancel master?  
 
typedef struct fsmtag  
{  
    int state; //state  
    int timeouttime; //time out time in milliseconds  
}fsm;  
 
//function prototype  
 
int main()  
{  
    fsm f;  
 
    f.state = IDLE;  
    f.timeouttime = 0;  
 
    while(1)  
    {  
        switch(f.state)  
        {  
        case IDLE:  
            puts("IDLE\nWait for isReqBeMaster(1/0) isRxBroadcast(1/0):");  
            scanf("%d %d",&isReqBeMaster,&isRxBroadcast);  
            if(isReqBeMaster)  
            {  
                f.state = M_BROADCAST;  
                break;  
            }  
            else if(isRxBroadcast)  
            {  
                f.state = S_BROADCAST_ACK;  
                break;  
            }  
            else 
                break;  
        case M_BROADCAST:  
            puts("M_BROADCAST\nBroadcasting...\n");  
            f.state = M_WAIT_BROADCAST_ACK;  
        case M_WAIT_BROADCAST_ACK:  
            puts("M_WAIT_BROADCAST_ACK\nWaiting for isTimeout(1/0):");  
            scanf("%d",&isTimeout);  
            if(isTimeout)  
            {  
                f.state = M_WAIT_COMMAND;  
                break;  
            }  
            else 
                break;  
        case M_WAIT_COMMAND:  
            puts("M_WAIT_COMMAND\nWaiting for isReqCancelMaster(1/0):");  
            scanf("%d",&isReqCancelMaster);  
            if(isReqCancelMaster)  
            {  
                f.state = IDLE;  
                break;  
            }  
            else 
                break;  
        //Slave mode routine  
        case S_BROADCAST_ACK:  
            puts("S_BROADCAST_ACK\nAcking...\n");  
            f.state = S_WAIT_COMMAND;  
            break;  
        case S_WAIT_COMMAND:  
            puts("S_WAIT_COMMAND\nWaiting for isRxBroadcastCancel(1/0):");  
            scanf("%d",&isRxBroadcastCancel);  
            if(isRxBroadcastCancel)  
            {  
                f.state = IDLE;  
                break;  
            }  
            else 
                break;  
        default:  
            puts("default");  
            printf("%d\n",rand());  
            f.state = IDLE;  
        }  
    }  
      
    return 0;  
} 

 --------------------------------------------
              当前状态   s0        s1        s2     | 事件
              --------------------------------------------
                       a0/s0      --       a0/s0   |  e0
              --------------------------------------------
                       a1/s1      --        --     |  e1
              --------------------------------------------
                       a2/s2     a2/s2      --     |  e2
              --------------------------------------------

               表1 图2状态机实例的二维表格表示(动作/下一状态)

    图2为一个状态机实例的状态转移图，它的含义是：
        在s0状态，如果发生e0事件，那么就执行a0动作，并保持状态不变；
                 如果发生e1事件，那么就执行a1动作，并将状态转移到s1态；
                 如果发生e2事件，那么就执行a2动作，并将状态转移到s2态；
        在s1状态，如果发生e2事件，那么就执行a2动作，并将状态转移到s2态；
        在s2状态，如果发生e0事件，那么就执行a0动作，并将状态转移到s0态；
    有限状态机不仅能够用状态转移图表示，还可以用二维的表格代表。一般将当前状态号写在横行上，将事件写在纵列上，如表1所示。其中“--”表示空(不执行动作，也不进行状态转移)，“an/sn”表示执行动作an,同时将下一状态设置为sn。表1和图2表示的含义是完全相同的。
    观察表1可知，状态机可以用两种方法实现：竖着写(在状态中判断事件)和横着写(在事件中判断状态)。这两种实现在本质上是完全等效的，但在实际操作中，效果却截然不同。

==================================
竖着写(在状态中判断事件)C代码片段
==================================
    cur_state = nxt_state;
    switch(cur_state){                  //在当前状态中判断事件
        case s0:                        //在s0状态
            if(e0_event){               //如果发生e0事件，那么就执行a0动作，并保持状态不变；
                执行a0动作;
                //nxt_state = s0;       //因为状态号是自身，所以可以删除此句，以提高运行速度。
            }
            else if(e1_event){          //如果发生e1事件，那么就执行a1动作，并将状态转移到s1态；
                执行a1动作;
                nxt_state = s1;
            }
            else if(e2_event){          //如果发生e2事件，那么就执行a2动作，并将状态转移到s2态；
                执行a2动作;
                nxt_state = s2;
            }
            break;
        case s1:                        //在s1状态
            if(e2_event){               //如果发生e2事件，那么就执行a2动作，并将状态转移到s2态；
                执行a2动作;
                nxt_state = s2;
            }
            break;
        case s2:                        //在s2状态
            if(e0_event){               //如果发生e0事件，那么就执行a0动作，并将状态转移到s0态；
                执行a0动作;
                nxt_state = s0;
            }
    }

 #include <stdio.h>   
#include <stdlib.h>   
#include <string.h>    
typedef enum{     
       STATE0 = 0,     
       STATE1,     
       STATE2,     
       STATE3,  
       STATE4,//password pass     
       //...ADD here    
}STATE;    
typedef enum{     
       INPUT1 = '2',   
       INPUT2 = '4',   
       INPUT3 = '7',  
         INPUT4 = '9',    
}INPUT;    
int main()    
{          char ch;     
       STATE current_state = STATE0;     
    while(1){     
    printf("请输入数字进行解码:");    
    while((ch = getchar()) != '\n'){   
            if((ch < '0') || (ch > '9')){    
                   printf("非数字，请重新输入!\n");   
                   break;   
            }     
                     switch(current_state){     
                            case STATE0:     
                                   if(ch == '2')   current_state = STATE1;  
                        break;     
                 case STATE1:   
                        if(ch == '4')   current_state = STATE2;  
                        break;     
                 case STATE2:    
                        if(ch == '7')   current_state = STATE3;    
                        break;   
                 case STATE3:     
                        if(ch == '9')   current_state = STATE4;    
                        break;     
                 default:     
                        current_state = STATE0;     
                        break;   
                     }  
 
              }  
 
              if(current_state == STATE4){     
                     printf("Correct, lock is open!\n");  
                     break;   
              }else    
                     printf("Wrong, unlocked!\n");   
       }      
    return 0;  
 
}