一，前言
之前上下位机用RTT，也就是循环队列，这个时候我突然想不明白循环队列和普通FIFO队列的区别。后来再仔细想下其实要看对象结构体如何设计。循环队列主要就是有头和尾可以连接起来。另外思考了用链表的FIFO和用双链表的FIFO及用数组的FIFO或循环队列有什么区别，大家感兴趣可以自己想下。
二，主题
我主要在思考及查看别人关于循环队列的设计时，突然看到了一个简易FSM框架，condition作为了数组的参数。其中也用到了循环队列。此FSM吸引我的就是事件队列作为触发条件的设计，这还是第一次看到，他这样设计的原因是task间会打断，导致状态机乱序。不过我之前用的状态机好像都在同一个task中，所以不会遇到这样的情景，算是学习了。
三，代码
我看到的参考代码是一段段的，我整合后，编译通过，简单验证通过。
#include <stdio.h>
#include <stdlib.h>
#define QMAX 10
#define true 1
#define false 0
typedef unsigned char bool;
typedef int State; /*状态*/
typedef int Condition;/*事件*/
#define STATES 4 /*总共状态的数量的数量*/
#define STATE_1 0 /*3个有效状态*/
#define STATE_2 1
#define STATE_3 2
#define STATE_TRAP 3 /*陷阱状态：在陷阱状态中，不论遇到怎样的输入都不能跳出*/
#define STATE_INTRANSACTION 4
#define CONDITIONS 2 /*触发事件的数量*/
#define CONDITION_1 0 /*2个触发输入事件*/
#define CONDITION_2 1
/*触发函数：现在的状态及输入*/
typedef void (*ActionType)(State nowstate, Condition toggleEvent);
/*状态转移结构体：下一个状态，触发函数*/
typedef struct
{
State next;
ActionType action;
}Trasition,*pTrasition;
/*其中的动作，由用户自己完成，在这里仅定义一条输出语句*/
void action_1(State nowstate, Condition toggleEvent)
{
printf("Action 1 triggered.\n");
}
void action_2(State nowstate, Condition toggleEvent)
{
printf("Action 2 triggered.\n");
}
void action_3(State nowstate, Condition toggleEvent)
{
printf("Action 3 triggered.\n");
}
void action_trap(State nowstate, Condition toggleEvent)
{
printf("Action trap triggered.\n");
}
/*根据状态转移图写出：各状态迁移结构*/
// (s1-> c1/a1->s2)
Trasition t1 = {
STATE_2,
action_1 /*st1 转移函数*/
};
// (s2, c2, s3, a2)
Trasition t2 = {
STATE_3,
action_2
};
// (s3, c1, s2, a3)
Trasition t3 = {
STATE_2,
action_3
};
// (s, c, trap, a1)
Trasition tt = {
STATE_TRAP,
action_trap
};
pTrasition transition_table[STATES][CONDITIONS]={
&t1,&tt,
&tt,&t2,
&t3,&tt,
&tt,&tt
};
#define E_OK 0
#define E_NO_DATA 1 /*队列空*/
#define E_OVERFLOW 2 /*队列满*/
typedef struct /*触发事件队列*/
{
Condition queue[QMAX];
int head;
int tail;
bool overflow;
} ConditionQueue, * pConditionQueue;
int push(ConditionQueue * queue, Condition c)
{
unsigned int flags;
//Irq_Save(flags);
if ((queue->head == queue->tail + 1) || ((queue->head == 0) && (queue->tail == 0)))
{
queue->overflow = true;
//Irq_Restore(flags);
return E_OVERFLOW; /*队列满直接退出*/
}
else
{
queue->queue[queue->tail] = c;
queue->tail = (queue->tail + 1) % QMAX;
//Irq_Restore(flags);
}
return E_OK;
}
int poll(ConditionQueue * queue, Condition * c)/**c就是要响应的触发事件*/
{
unsigned int flags;
//Irq_Save(flags);
if (queue->head == queue->tail)
{
//Irq_Restore(flags); /*队列空直接退出*/
return E_NO_DATA;
}
else
{
*c = queue->queue[queue->head];
queue->overflow = false;
queue->head = (queue->head + 1) % QMAX;
//Irq_Restore(flags);
}
return E_OK;
}
typedef struct /*总的状态机结构体*/
{
State current;
bool inTransaction; /*是否正在跳转*/
ConditionQueue queue;/*触发事件队列*/
} StateMachine, * pStateMachine;
static State __step(pStateMachine machine, Condition condition)/*正常的状体迁移流程*/
{
State current = machine -> current;
pTrasition t = transition_table[current][condition];
(*(t->action))(current, condition);
current = t->next;
machine->current = current;
return current;
}
State step(pStateMachine machine, Condition condition)/*加入队列保护的状态机*/
{
Condition next_condition;
State current;
int status;
if (machine->inTransaction)/*正在转移，只是将新事件添加到队列中单不发生迁移*/
{
push(&(machine->queue), condition);
return STATE_INTRANSACTION;
}
else
{
machine->inTransaction = true;
current = __step(machine, condition);
status = poll(&(machine->queue), &next_condition);/*POLL函数的参数 &next_condition就是从队列中取出的新事件*/
while(status == E_OK) //若队列非空依次处理队列中的时间
{
__step(machine, next_condition);
status = poll(&(machine->queue), &next_condition);
}
machine->inTransaction = false;
return current;
}
}
void initialize(pStateMachine machine, State s)
{
machine->current = s;
machine->inTransaction = false;
machine->queue.head = 0;
machine->queue.tail = 0;
machine->queue.overflow = false;
}
unsigned char cnt;
#define fsme_usr_log(...) printf(__VA_ARGS__);
int main()
{
StateMachine sm;
initialize(&sm,STATE_1);
fsme_usr_log("\rFSM '%s' is running", "mytest");
while(cnt<10)
{
step(&sm,CONDITION_1);
step(&sm,CONDITION_2);
cnt++;
}
return 0;
}
四，小结
最近主要在看各种代码，吸收别人的优秀设计思想，同时也自己深入思考我会怎么设计，说白了c语言就是算法和数据结构，数据结构定义的不同，实现同样的功能，他的算法也会不同。设计成哪种需要看具体情况，可能是精简代码实现，也可能做成框架可移植性强的，又可设计成运行速度快的。但是我手里积累的库或设计方式越多，代表将来我用的时候选择就越多，今天又学习到一招，哈哈~
