c語言循環隊列及簡易FSM框架--Apple的學習筆記 一，前言 二，主題 三，代碼 四，小結

一，前言

之前上下位機用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語言就是算法和數據結構，數據結構定義的不同，實現同樣的功能，他的算法也會不同。設計成哪種需要看具體情況，可能是精簡代碼實現，也可能做成框架可移植性強的，又可設計成運行速度快的。但是我手裏積累的庫或設計方式越多，代表將來我用的時候選擇就越多，今天又學習到一招，哈哈~