Desen­volve­dor de soft­ware é um ser muito ansioso. Quer logo colo­car a mão na massa. E depois de 2.000 lin­has de código ele resolve começar os testes. O código nem com­pila. E quando ele se prepara para cor­ri­gir o prob­lema, percebe que o código está um caos total. Funções com mais de 200 lin­has e mais de 5 if’s anin­hados. O que pare­cia ser fácil no começo (e pode­ria ter sido) já não é mais. Tudo porque ele não tinha um plano. Nunca comece nada sem um plano, prin­ci­pal­mente quando se trata de desen­volvi­mento de soft­ware. E uma boa estratég­ica é o uso de design pat­terns.

Design pat­terns, ou padrões de pro­jeto, são soluções para prob­le­mas nor­mal­mente encon­tra­dos em pro­je­tos de soft­ware. São inde­pen­dentes de lin­guagem, e ofer­e­cem uma descrição ou tem­plate de como resolver deter­mi­nado prob­lema. Um design pat­tern muito con­hecido e uti­lizado no desen­volvi­mento de soft­ware para sis­temas embar­ca­dos é a Máquina De Esta­dos Finita, ou Finite State Machine (FSM), a qual chamare­mos aqui ape­nas de máquina de estados.

Pelas ações lis­tadas acima, podemos iden­ti­ficar basi­ca­mente os esta­dos abaixo, na ordem em que são exe­cu­ta­dos:

1. Aguardando veículo no loop A.
2. Aguardando usuário pres­sionar o botão para emi­tir ticket.
3. Aguardando veiculo sair do loop A.
4. Aguardando veiculo pas­sar pelo loop B.
   

O impor­tante aqui é perce­ber que, para qual­quer um dos esta­dos acima, depen­dendo da entrada, a saida será difer­ente. Por exem­plo, se você esta no estado 2 e recebe como entrada o botão pres­sion­ado você vai para o estado 3. Porém, se ao invés do botão pres­sion­ado você rece­ber como entrada a saida de veiculo do loop A (usuário deu ré e desis­tiu de esta­cionar), você deve voltar para o estado 1.

Este é um exem­plo sim­ples de apli­cação onde cabe per­feita­mente a imple­men­tação de uma máquina de esta­dos. Além desta, exis­tem muitas out­ras apli­cações, como por exem­plo inter­pre­ta­dores de comando, proces­sadores de lin­guagem, trata­mento de pro­to­co­los de comu­ni­cação, etc.

Agora que con­hece­mos um pouco da teo­ria, vamos à prática.

Imple­men­tação

Um prob­lema que resolvo fre­quente­mente com máquina de esta­dos são roti­nas de trata­mento de pro­to­co­los de comu­ni­cação.

No nosso exem­plo, o pro­to­colo de comu­ni­cação tem o seguinte formato:

|STX|QTD_DADOS|DADOS|CHK|ETX|

STX       (1 Byte)  -> Ini­cio da trans­mis­são (0x02)
QTD_DADOS (1 Byte)  -> Quan­ti­dade de dados
DADOS     (N Bytes) -> Dados
CHK       (1 Byte)  -> Check­sum da trans­mis­são
ETX       (1 Byte)  -> Fim da trans­mis­são (0x03)

Vamos imple­men­tar aqui dois mod­e­los difer­entes, um com switch/case e outro com pon­teiro para função.

Imple­men­tação 1: Switch/case

Esta imple­men­tação é sim­ples e com­posta de ape­nas uma função, lis­tada abaixo:

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

/* possiveis estados */
typedef enum {
    ST_STX = 0, ST_QTD, ST_DATA, ST_CHK, ST_ETX
} States;
 
/* maquina de estados */
void handleRx(unsigned char *data, int qtd)
{
    static States state = ST_STX;
    static unsigned char buffer[MAX_BUFFER];
    static int indBuffer = 0, qtdBuffer = 0;
    static unsigned char chkBuffer = 0;
    int i;
 
    for (i = 0; i < qtd; i++) {
 
        switch (state) {
 
            case ST_STX:
                if (data[i] == STX) {
                    indBuffer = qtdBuffer = 0;
                    chkBuffer = 0;
                    state = ST_QTD;
                }
                break;
 
            case ST_QTD:
                qtdBuffer = data[i];
                state = ST_DATA;
                break;
 
            case ST_DATA:
                buffer[indBuffer++] = data[i];
                chkBuffer ^= data[i];
                if (--qtdBuffer == 0) {
                    state = ST_CHK;
                }
                break;
 
            case ST_CHK:
                if (data[i] == chkBuffer) {
                    state = ST_ETX;
                }
                else {
                    state = ST_STX;
                }
                break;
 
            case ST_ETX:
                if (data[i] == ETX) {
                    handlePackage(buffer,
                        indBuffer);
                }
                state = ST_STX;
                break;
        }
    }
}

O uso da máquina de esta­dos é sim­ples. Basta chamar a função han­dleRx() para cada stream rece­bido do buffer de comu­ni­cação. Veja que ela pos­sui algu­mas var­iáveis sta­tic para que seja pos­sivel armazenar seu estado atual. O código-fonte com­pleto desta imple­men­tação pode ser baix­ado aqui.

Imple­men­tação 2: Pon­teiros de função

Nesta forma de imple­men­tação da máquina de esta­dos, cada ação é imple­men­tada através de uma função. Veja um tre­cho da imple­men­tação abaixo:

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

/* possiveis estados */
typedef enum {
    ST_STX = 0, ST_QTD, ST_DATA, ST_CHK, ST_ETX
} States;
 
struct StateMachine {
    States state;
    unsigned char buffer[MAX_BUFFER];
    unsigned char chkBuffer;
    int indBuffer;
    int qtdBuffer;
    Action action[5];
} sm;
 
void stSTX(unsigned char data)
{
    if (data == STX) {
        sm.indBuffer = sm.qtdBuffer = 0;
        sm.chkBuffer = 0;
        sm.state = ST_QTD;
    }
}
 
void stQtd(unsigned char data)
{
    sm.qtdBuffer = data;
    sm.state = ST_DATA;
}
 
void stData(unsigned char data)
{
    sm.buffer[sm.indBuffer++] = data;
    sm.chkBuffer ^= data;
    if (--sm.qtdBuffer == 0) {
        sm.state = ST_CHK;
    }
}
 
void stChk(unsigned char data)
{
    if (data == sm.chkBuffer) {
        sm.state = ST_ETX;
    }
    else {
        sm.state = ST_STX;
    }
}
 
void stETX(unsigned char data)
{
    if (data == ETX) {
        handlePackage(sm.buffer, sm.indBuffer);
    }
    sm.state = ST_STX;
}
 
void handleRx(unsigned char *data, int qtd)
{
    int i;
 
    for (i = 0; i < qtd; i++)
        sm.action[sm.state](data[i]);
}

A forma de usar a máquina de esta­dos con­tinua a mesma. Basta chamar a função han­dleRx() para cada stream rece­bido do buffer de comu­ni­cação. Mas veja que a função diminuiu para ape­nas 2 lin­has! O estado atual da máquina de esta­dos fica armazenado na estru­tura StateMa­chine. E cada tre­cho de código den­tro de um case, no exem­plo ante­rior, se trans­for­mou em uma função neste exem­plo. O código ficou muito mais mod­u­lar e de fácil manutenção. Os fontes desta imple­men­tação tam­bém estão disponíveis aqui.

Um abraço a todos,

Ser­gio Prado

Sem posts relacionados.