基于真值表的有限状态机实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
static volatile Uint32 fsm_tmr[STATE_CNT+1] = {0};

void fsm_timer_init(void)
{
    MemSet((Uint16 *)fsm_tmr, 0, sizeof(fsm_tmr));
}

void fsm_set_timer(Uint16 index, Uint32 tout)
{
    fsm_tmr[index] = tout;
}

Uint32 fsm_get_timer(Uint16 index)
{
    return fsm_tmr[index];
}


Uint16 fsm_chk_timer(Uint16 index)
{
    return (!fsm_tmr[index]);
}

void fsm_1ms_irq(void)
{
    Uint16 j;

    for(j = 0; j < STATE_CNT+1; j++)
	{
        if(fsm_tmr[j])
        {
            fsm_tmr[j]--;
        }
	}
}

typedef enum
{
    STARTUP,
    INIT,
    STANDBY,
    CHARG,
    SHUTDOWN,
    STATE_CNT
}FSM_STATE;

Uint16 jump_matrix[STARTUP][INIT];
Uint16 fsm_state_min_time[FSM_STATE] = {200, 200, 200, 200, 200};

#define MATRIX_INIT(cond,dly) (((!!(cond))<<15) | (dly))

void update_matrix(void)
{
    jump_matrix[STARTUP][INIT] = MATRIX_INIT(1,0);
    jump_matrix[INIT][STANDBY] = MATRIX_INIT(1,0);
    jump_matrix[INIT][SHUTDOWN] = MATRIX_INIT(1,0);
}

typedef struct
{
    (void)(*entry_ev)(void);
    (void)(*during_ev)(void);
    (void)(*exit_ev)(void);
    
}FSM_EV;

FSM_EV ev_list[STATE_CNT] = 
{
    .[INIT] = {},
    .[STANDBY] = {}
};

typedef struct
{
    FSM_STATE state;
    Uint16 (*matrix)[STATE_CNT][STATE_CNT];
    FSM_EV *event;
    (void)(*state_change_notification)(FSM_STATE, FSM_STATE);
}FSM_INS;

FSM_INS fsm;

void fsm_state_change_notification(FSM_STATE prev_state, FSM_STATE curr_state)
{
}

void fsm_init(void)
{
    fsm.state = STARTUP;
    fsm.matrix = jump_matrix;
    fsm.event = ev_list;
    fsm.state_change_notification = fsm_state_change_notification;
}

void fsm_run(void)
{
    Uint16 i;

    update_matrix();
    
    (fsm.event[fsm.state]->state_ev)();
    
    for(i = 0; i < STATE_CNT; i++)
    {
        //lookup table
        if(fsm.matrx[fsm.state][i] & 0x8000)
        {
            if(fsm_chk_timer(i) && fsm_chk_timer(STATE_CNT))
            {
                //(fsm.event[fsm.state]->exit_ev)();
                (fsm.event[fsm.state]->state_change_notification)(fsm.state, i);
                fsm.state = i;
                
                fsm_timer_init();

                fsm_set_timer(STATE_CNT, fsm_state_min_time[fsm.state]*MS_T);
                
                //(fsm.event_list[fsm.state]->entry_ev)();

                //(fsm.event_list[fsm.state]->during_ev)();
                break;
            }
        }
        else
        {
            fsm_set_timer(i, fsm.matrx[fsm.state][i]&0x7FFF);
        }
    } 
}