Machine Translated by Google

Máquinas de Estados Finitos

Escrito e ilustrado por James Trevelyan, Escola de Engenharia Mecânica, com base em palestras de Peter Kovesi, Escola
de Ciência da Computação e Engenharia de Software.

A Finite State Machine (FSM) é um conceito abstrato que nos ajuda a analisar um sistema de controle mecatrônico de forma
estruturada. Ao mesmo tempo, também é uma ferramenta de design útil que nos permite abordar o design de maneira
sistemática. É particularmente útil para lógica sequencial e funções de controle. As máquinas de estado finito são
amplamente utilizadas no projeto de software, lógica, CLPs, controles eletrônicos e mecanismos.
Máquinas de estado finito de software encontram aplicações em inteligência artificial, reconhecimento de padrões, lingüística
e até mesmo em modelos de comportamento humano, embora algumas pessoas digam que seu uso é equivocado.

Índice
Definindo Estados ....................................... ................................................ .........................................2 Diagrama de
Transição de Estado.... ................................................ ................................................ ....................2 Eventos Transitórios e
Persistentes............................ ................................................ .........................................4 Exercícios
1...... ................................................ ................................................ .........................................5 Exercício
2 .......... ................................................ ................................................ .......................5 Exemplo de toca-
fitas ............ ................................................ ................................................ .............5 Exercício
3 .............................. ................................................ ................................................ ..........6 Exercício
4 ..................................... ................................................ ................................................ .....6 Exercício
5 ....................................... ................................................ ................................................ ....7 Técnicas de
Decomposição ...................................... ................................................ .........................7
Temporizador ....................... ................................................ ................................................ .............................7
Selecione .............. ................................................ ................................................ ................................8 Ações de
prelúdio e poslúdio ........... ................................................ ................................................ ....8 Esquemas de
Implementação de Hardware ...................................... ................................................ ................8 Tabelas de Transição de
Estado .............................. ................................................ .........................................10 Exercício
6 . ................................................ ................................................ .........................................10 Criando e projetando
máquinas de estado finito.. ................................................ .........................................11 Implementando Máquinas de
Estado Finito em Software..... ................................................ .........................12
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 2

Definindo Estados

Uma máquina de estado finito é simplesmente uma máquina que possui um número finito de estados. Precisamos contrastar isso com
máquinas que podem ter um número infinito de estados. Por exemplo, um sensor que pode ler a temperatura de um processo produzindo uma
tensão analógica é um exemplo de uma máquina com um número infinito de estados. O número de possíveis tensões de saída é infinito.
Por outro lado, o sensor de temperatura que apenas indica se a temperatura está muito alta ou muito baixa possui dois estados de saída. Muitos
sistemas mecatrônicos têm elementos de ambos: algumas partes têm um número infinito de estados, enquanto outras partes operam como
máquinas de estado finito com um número limitado de estados possíveis.

Um toca-fitas, por exemplo, pode estar em um dos vários estados "operacionais" discretos:

Parar: a fita é parada

Reproduzir: a fita passa lentamente pela cabeça de 'leitura' a uma velocidade constante, a fita é pressionada contra a
cabeça de leitura.

Rebobinar: a fita se move rapidamente para trás, não necessariamente em velocidade constante, a fita não é
pressionada contra o cabeçote de leitura.

avanço rápido: a fita avança rapidamente, não necessariamente em velocidade constante, a fita não é pressionada
contra o cabeçote de leitura.

Pausa: o movimento da fita no modo de reprodução é interrompido temporariamente, mas a fita permanece
pressionada contra a cabeça de leitura.

Gravação: a fita passa lentamente pela cabeça de 'leitura' em velocidade constante, a fita é pressionada contra
a cabeça de leitura, mas a bobina de 'gravação' é energizada alterando os padrões magnéticos armazenados na
camada superficial da fita. Possivelmente, uma cabeça de 'apagar' separada também é energizada.

Certos eventos fazem com que uma máquina transfira de um estado para outro. Por exemplo, quando o toca-fitas está rebobinando uma fita, ele
passará do estado "rebobinar" para o estado "parar" quando um sensor indicar que a fita chegou ao fim.

A primeira etapa no projeto ou análise de uma máquina de estado finito é encontrar todos os estados possíveis em que ela pode estar. Isso
não é tão fácil quanto parece. Uma porta automática é um bom exemplo. Pode ser "aberto" ou "fechado".
No entanto, ele não muda entre os estados "aberto" e "fechado" instantaneamente: ele passa por alguns outros estados para conseguir
isso. Se olharmos atentamente para uma porta automática típica, podemos observar dois estados intermediários. De "fechado" passa
para um estado de "abertura" no qual o motor abre a porta a uma velocidade constante. Pouco antes de atingir a posição totalmente aberta, ela
passa para um estado de "abertura lenta" em que o motor gira mais devagar para que a porta não bata no final do trilho. Após um curto
período de tempo, ele transfere para o estado "aberto" e permanece lá até que o botão "fechar" seja pressionado ou talvez um temporizador
automático produza um sinal iniciando uma sequência semelhante de estados para fechar a porta.

Às vezes é possível identificar estados que realmente não existem ou não são necessários. Chamamos esses estados "redundantes".
É preciso prática e é melhor aprender com a experiência.

Diagrama de Transição de Estado

O segundo passo é desenhar um diagrama de transição de estado. Este diagrama mostra as relações entre cada estado. Ele mostra como a
máquina transfere de um estado para outro em resposta a eventos. É possível ler o diagrama para revelar a sequência de estados e eventos
que definem o funcionamento da máquina
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 3

comportamento. Um diagrama de transição de estado é uma ferramenta de projeto inestimável e um meio de comunicar o projeto
do sistema de controle a outras pessoas.

Vamos pegar um simples interruptor de luz como exemplo para começar. Existem dois estados: "ligado" e "desligado". Existem dois
eventos possíveis: levantar a alavanca do interruptor para cima e pressionar a alavanca do interruptor para baixo com o movimento do dedo.
(Observe que observamos a convenção britânica e australiana: o interruptor está para cima na posição "desligado" e para baixo na posição
"ligado").

O diagrama de estado se parece com isso.

Figura 1: Diagrama de estado para interruptor de luz elétrica simples

Observe que incluímos todos os eventos possíveis em ambos os estados. Pressionar o interruptor para baixo na posição "ligado" não
produz nenhuma mudança de estado, mas ainda mostramos uma seta que retorna ao estado "ligado". Um diagrama de estado que
mostra todas as combinações possíveis de estado e evento é chamado de diagrama de estado exaustivo. Na maioria das vezes,
mostramos apenas eventos que realmente causam transições de estado. Se fôssemos mostrar todas as possíveis transições de
estado e eventos, poderíamos acabar com um diagrama muito complicado de ler. No entanto, para sistemas críticos de segurança em que
a confiabilidade é muito importante, precisamos analisar todos os eventos possíveis em todos os estados.

Observe também que o termo "pressionar a chave para baixo" ou "levantar a chave" implica um evento discreto quando a força do
dedo supera a pressão da mola e faz com que a chave se mova repentinamente para sua posição final. O estado elétrico da chave só
muda quando a pressão da mola é superada e ocorre o movimento final brusco. Se o dedo exercer força insuficiente, a alavanca do
interruptor se move, mas não o suficiente para causar uma transição de estado.

Agora vamos pegar um tipo diferente de interruptor de luz. Um interruptor de luz de botão é pressionado para acender a luz e pressionado
novamente para desligar a luz. Mais uma vez, a transição de estado ocorre apenas quando a pressão da mola mecânica atinge um
determinado ponto crítico. Neste exemplo, há apenas um evento: pressionar o botão do interruptor. Observe que o mesmo evento
causa uma transição em ambas as direções!
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 4

Figura 2: Interruptor de luz do botão de pressão usando eventos "push" transitórios.

Eventos transitórios e persistentes

Agora precisamos distinguir entre eventos "estáticos" e "transitórios". Um evento transitório acontece em um instante de tempo
infinitamente curto. O evento estático é persistente por um tempo finito. Vamos olhar para este diagrama simples de estado de botão
novamente, assumindo que o evento "push" existe por um período de tempo finito. Assim que o evento push ocorre, há uma transição de
estado de "off" para "on". No entanto, o evento push ainda persiste.
Agora que estamos no estado "ligado", o evento push causa uma transição imediata para o estado "desligado". Assim, nossa máquina de
estados entrará em um loop infinito, oscilando de um estado para o outro, até o final do evento "push". Isso geralmente é conhecido como
uma condição de "corrida".

Podemos superar esse problema introduzindo estados adicionais. O diagrama de estado imediatamente abaixo mostra como isso
pode ser feito. Introduzimos os estados "off wait" e "on wait" e introduzimos um evento "release". O evento "push" é sempre seguido por um
evento "release".

Figura 3: Diagrama de estado expandido para interruptor de luz de botão usando

eventos persistentes "push" e "release".

Para evitar esse tipo de problema, devemos declarar os eventos como transitórios ou estáticos (persistentes ou transitórios).
Observe que podemos introduzir um pequeno diagrama de "subestado" que transforma um par de eventos persistentes, como "push" e
"release", em um evento transitório "push once". No diagrama abaixo, há uma transição imediata de "on" para "off". A existência
do estado "ligado" é, portanto, transitória, e isso se torna o evento transitório que pode ser usado no diagrama de estado simples
mostrado na figura 3.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 5

Figura 4: Diagrama de subestado que converte eventos persistentes de "push" e "release" em um evento
transitório "on" determinado pela duração do estado "on". Como o estado mudará imediatamente
(incondicionalmente) de "ligado" para "desligado", o estado "ligado" deve ser transitório.

Exercícios 1

Defina o diagrama de transição de estado para o botão "fechar" em uma janela típica na tela do computador. No meu
computador, o botão muda de aparência assim que pressiono o botão do mouse com o ponteiro sobre o botão. No entanto, a
janela não fecha imediatamente. A janela só fecha se eu soltar o botão do mouse com a seta ainda sobre o botão. Se eu
arrastar o ponteiro para longe do botão, mantendo o botão do mouse pressionado, o botão "fechar" da janela simplesmente
muda sua aparência de volta para a posição "para cima" e a janela permanece aberta. Desenhe um diagrama de transição
de estado para representar esse comportamento.

Note que não existe uma única resposta certa. Um diagrama de transição de estado representa a maneira de uma pessoa ver
o projeto de uma máquina de estado finito. Diferentes pessoas podem conceber o mesmo projeto usando diferentes diagramas
de transição de estado.

Exercício 2

Desmonta uma velha caneta de botão: daquelas com um botão na ponta que você aperta para fazer aparecer a ponta esférica
na outra ponta e aperta de novo para que ela desapareça. Este é um exemplo mecânico de uma máquina de dois estados.
Desenhe o diagrama de transição de estado e faça esboços para mostrar como o mecanismo implementa o diagrama de
transição de estado.

Exemplo de toca-fitas
Agora, como um exemplo final trabalhado, vamos retornar ao toca-fitas.

Definiremos o seguinte conjunto de controles para uma versão em inglês:

"Parar", "Reproduzir", "Inverter direção", "Rebobinar", "Avanço rápido"

A máquina inicia no estado "parado". Quando pressionamos o botão "play" (gerando assim um evento transitório "play") a
máquina passa para o estado "play".

Nesta fase, temos que fazer uma pausa em nossa análise e perceber que existem dois possíveis estados de "jogo". A
máquina pode reproduzir a fita para frente ou para trás, dependendo de qual lado da fita queremos ouvir. Portanto,
precisamos definir dois estados de jogo: "jogar lado A" e "jogar lado B". Se o seu toca-fitas for parecido com o meu, a direção
da reprodução depende da reprodução anterior
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 6

direção antes de pressionarmos o botão de parada. Portanto, também precisamos de dois estados de "parada": "parada A"
e "parada B" para que a máquina possa lembrar qual lado da fita estava tocando por último.

Da mesma forma, o estado "rebobinar" depende de qual lado da fita estamos tocando.

Podemos resolver esse problema de duas maneiras. Podemos introduzir um segundo diagrama de estado para definir
a direção na qual estamos tocando a fita ou podemos simplesmente ter um estado separado para cada tipo de operação
quando tocamos diferentes lados da fita. Ambas as alternativas fornecem interpretações igualmente válidas do
comportamento da máquina.

Figura 5: Diagrama de transição de estado para toca-fitas simples

Exercício 3

Modifique o diagrama de transição de estado da figura 3 para permitir que o evento "direção reversa" altere a direção
da fita enquanto a fita está parada.

Exercício 4

Modifique o diagrama de transição de estado da figura 3 para permitir que o botão de "direção reversa" altere a direção
da fita e inicie a reprodução da fita na nova direção, caso ela tenha sido interrompida.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 7

Exercício 5

Examine um toca-fitas real, seja de vídeo ou de áudio. Determine os estados operacionais e desenhe um diagrama de transição
de estado para descrever a resposta da máquina aos diferentes controles (supondo que os controles de botão gerem
eventos transitórios). Se possível, remova a tampa e examine o toca-fitas em seus diferentes estados e observe cuidadosamente
como as partes mecânicas funcionam. (Se você não tiver acesso a um toca-fitas, faça o mesmo exercício para um toca-CD.)

Técnicas de Decomposição

Esses exemplos demonstram que os diagramas de transição de estado para máquinas relativamente simples podem se tornar
bastante complexos. É útil decompor máquinas mais complexas em uma série de máquinas de estado independentes mais
simples, cada uma com seu próprio diagrama de transição de estado. Isso é análogo à maneira como decompomos o software em
módulos de nível superior e módulos de nível inferior para ocultar a complexidade.

Cronômetro

Apenas como exemplo, podemos decompor um timer usado de várias maneiras em máquinas de estado típicas.

Figura 6: Diagrama de transição para a máquina de estado do temporizador. A máquina inicia no

estado "expirado". O tempo de contagem regressiva T é transferido para um registrador de contagem
regressiva t quando o timer é definido com o evento "start". No estado "contagem regressiva", o
registro de contagem regressiva diminui gradualmente em ÿT a cada "tick". A maioria das máquinas
de estado é sincronizada com um relógio externo e é executada uma vez a cada "tick" do relógio.
(Os eventos transitórios duram apenas um tique) O cronômetro passa para o estado "tocando"
quando o cronômetro de contagem regressiva chega a zero. Ele permanecerá neste estado até que
o sinal de "confirmação" seja recebido.

Observe como as ações executadas ao longo dos arcos de transição de estado são definidas após
o '/' após o evento que aciona o arco.

Até onde sabemos, não existe uma maneira padrão de representar várias máquinas de estado finito que operam
simultaneamente, exceto pela definição de uma tabela de transição de estado completa para todo o grupo de máquinas. Isso pode
gerar uma enorme complexidade. Um diagrama de transição de estado resume uma tabela de transição de estado em forma
gráfica. A UML (linguagem de modelagem universal) é amplamente usada por engenheiros de software, mas não pode
acomodar facilmente várias máquinas de estado. Esta é uma questão prática de engenharia que precisa ser abordada. Enquanto
isso, o melhor que podemos fazer é desenhar diagramas de transição de estado claramente com notas explicativas para mostrar
como diferentes máquinas de estado interagem.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 8

Selecione

Outro exemplo simples que vale a pena explorar é o mecanismo de seleção típico usado em software de computador. Um
único clique do mouse seleciona qualquer objeto que foi selecionado anteriormente e seleciona o objeto sobre o qual o ponteiro
do mouse foi colocado. Se ocorrer outro clique em um curto espaço de tempo, o sistema iniciará o aplicativo que manipula
o objeto selecionado.

Figura 7: Diagrama de transição de estado para seleção de clique único ou clique duplo. Existem estados redundantes?

Ações de prelúdio e poslúdio

Outra maneira de descrever as ações que ocorrem ao longo dos arcos de transição de estado é introduzir o conceito
de ações "prelúdio" e "pós-lúdio".

Nos dois exemplos anteriores, vemos que certas ações precisam ser executadas quando um determinado estado é
inserido. Ao entrarmos no estado "wait1" (acima), desmarcamos todos os outros objetos e definimos o valor do temporizador T.
Estas são as ações de "prelúdio" para o estado "wait1". Iniciar o aplicativo que manipula o objeto selecionado é então a
ação "prelúdio" do estado "objeto aberto". Observe que saímos desse estado voltando imediatamente para o estado "start". As
ações de postlúdio são executadas quando saímos de um estado. No entanto, as ações de pós-lúdio tendem a ser menos usadas
do que as ações de prelúdio porque normalmente existem vários caminhos ao sair de um determinado estado, cada um com
diferentes ações de pós-lúdio.

Os diagramas de transição de estado têm suas limitações. O pacote de software Visual Studio, por exemplo, tem nada menos
que 150 eventos de menu iniciando apenas no estado de inicialização. Esse tipo de máquina de estado é muito complexo
para representar com diagramas de transição de estado convencionais. A decomposição em grupos de estados é essencial.

Esquemas de Implementação de Hardware

Existem duas implementações de hardware clássicas ligeiramente diferentes de máquinas de estado finito. Técnicas de
software modernas nos permitem implementar máquinas de estado altamente complicadas usando arranjos de portas
programáveis em campo (FPGAs) e circuitos integrados de escala muito grande (VLSI). Os circuitos do processador central
para computadores são grandes máquinas de estado finito. No entanto, as mesmas tecnologias nos permitem projetar
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 9

máquinas para aplicações específicas. Circuitos integrados de aplicação específica (ASICs) são mais baratos para produzir em massa
do que FPGAs, mas os últimos têm custos de configuração muito mais baixos para pequenas execuções de produção.

Figura 8: Arquitetura da máquina Moore. As entradas i0, i1, i2… são capturadas em cada pulso de clock e, junto com os valores de
estado s0, s1, s2… formam entradas para lógica combinacional que calcula os novos valores de estado s0', s1', s2'… Os novos valores de
estado tornam-se o estado real quando eles são travados no início do próximo pulso de clock. A lógica de saída calcula os valores
de saída o0, o1, o2... a partir dos valores de estado.

A arquitetura da máquina Moore é mostrada na figura 8. Ela consiste em um latch de entrada, lógica de combinação, memória de estado e
lógica de saída. Um relógio externo sincroniza o latch de entrada, a memória de estado e a lógica de saída: as saídas aparecem
imediatamente após cada pulso de clock e permanecem inalteradas até o próximo pulso de clock.
As limitações práticas na velocidade da lógica de combinação significam que um tempo pequeno, mas finito, decorre entre a
apresentação dos sinais de entrada imediatamente após o pulso de clock e a chegada do próximo valor de estado nas entradas da
memória de estado. Os sinais de saída são calculados a partir do valor do estado.

Figura 9: Implementação da máquina Mealy. As entradas i0, i1, i2… são capturadas em cada pulso de clock e, junto com os valores de
estado s0, s1, s2… formam entradas para a lógica combinacional que calcula os valores de saída o0, o1, o2… e os novos valores de
estado s0', s1 ', s2'… Os novos valores de estado tornam-se o estado real quando são travados no início do próximo pulso de clock.

A máquina de Mealy tem uma estrutura quase idêntica, exceto que as saídas são calculadas a partir da lógica de combinação
ao mesmo tempo que o próximo valor do estado. A máquina de Moore requer pelo menos tantos estados quantas forem as combinações
de saída possíveis. No entanto, a máquina de Mealy requer menos estados.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 10

Também é importante observar que a máquina de estado do temporizador não pode ser facilmente representada, a menos que consideremos que
cada valor possível do temporizador é um estado adicional por si só. Na prática, é claro, essas máquinas de estado geralmente são representadas
por software implementado em um microprocessador, e não por dispositivos de hardware binários.

Tabelas de transição de estado

Como a máquina de estado opera em pulsos de clock espaçados no tempo ÿt numerado k=0, 1, 2, 3, … k, k+1, k+2, … podemos representar o
estado atual como Sk e a entrada atual como Ik e a saída atual como Ok.

O estado atual é calculado a partir do estado anterior e dos valores de entrada atuais:

Sk = fs(Sk-1, Ik) onde fs é conhecida como a função de transição de estado. Isso também é escrito como fs:SxIÿS.

Os valores de saída são calculados de forma semelhante:

Ok = fo(Sk-1, Ik) onde fo é conhecido como a função de saída.

Isso também é escrito como fo:SÿO (no caso da máquina de Moore) ou fo:SxIÿO (no caso da máquina de Mealy).

Podemos definir um estado e um alfabeto de entrada, geralmente um alfabeto binário (0, 1) e, em seguida, definir fs e fo na forma de uma tabela
de consulta ou tabela de transição de estado, como mostra o exemplo a seguir.

Exercício 6

O que a seguinte máquina de estado finito representa? Existe um único valor de entrada (0 ou 1) e um único valor de saída (0 ou 1). Em cada
arco de transição de estado, os valores de entrada e os valores de saída aparecem como entrada/saída.

Figura 10: O que é essa máquina de estado finito?

Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 11

Representar estados com dois bits binários:

s0 0 0

s1 0 1

s2 10

Em seguida, preencha a seguinte tabela de transição de estado. As duas primeiras linhas foram preenchidas para você...

Estado atual Entrada Novo estado Saída

Bit de estado 0 Bit de estado 1 Bit de estado 0 Bit de estado 1

i0 o0

0 0 1 1 0 0

0 0 0 0 1 0

0 1 0

0 1 1

1 0 0

1 0 1

Dica: faça uma sequência de entrada como 00111001000011110000 e calcule as mudanças de estado e os valores de saída.

Criando e projetando máquinas de estado finito

Circuitos lógicos, circuitos integrados de aplicação específica, PLCs, software de computador, hardware pneumático, dispositivos
e mecanismos fluídicos fornecem maneiras convenientes de implementar máquinas de estado finito. Existem muitas ferramentas de
projeto especialmente para as máquinas de estado mais complexas, como as encontradas em circuitos integrados de larga
escala e centrais telefônicas.

Ferramentas de software como o Simulink do MATLAB e outras linguagens de simulação de eventos discretos são muito úteis para
modelar máquinas de estado finito. Se você seguir procedimentos de projeto cuidadosos, a simulação não será necessária,
exceto para os projetos mais complexos.

Neste curso, muitos projetos exigirão que você implemente máquinas de estado finito em software e as notas a seguir
fornecem algumas orientações úteis sobre como fazer isso de forma confiável.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 12

Implementando máquinas de estado finito em software

Máquinas de estado finito de software podem fornecer um código altamente confiável seguindo certas diretrizes. Os fluxogramas a seguir
ilustram como o código deve ser estruturado. Essa estrutura pode ser acomodada em praticamente qualquer linguagem de programação.

Figura 11: Implementação da Finite State Machine em software: fluxograma geral.

Na figura 11 podemos ver que o código está estruturado na forma de uma instrução "switch" (em C, C++ ou Java) com um caso para cada
estado. Uma estrutura "case" deve ser usada no LabVIEW. Observe que também há um estado padrão para cobrir o caso de um valor
desconhecido para a variável "estado". Isso pode acontecer se houver um erro no código, então o código padrão é simplesmente usado para
detectar o fato de que esse tipo de erro ocorreu.
Nunca use um caso padrão para valores de estado legítimos. Isso é codificação preguiçosa e leva a desastres.

As variáveis locais "oldstate" e "newstate" são usadas no código para cada estado para detectar as condições sob as quais o prelúdio ou as

ações obscenas posteriores devem ser executadas. Isso é mostrado no fluxograma a seguir.
Observe que os valores de "state" e "oldstate" devem ser retidos entre execuções sucessivas do código.
Eles não podem ser alocados para armazenamento local temporário, a menos que seja garantido que o armazenamento seja preservado.

A última seção do código é o código de verificação. Este código é incluído para garantir que o módulo funcione corretamente. O código de
máquina de estado finito geralmente é crítico para todos os outros aspectos do software operacional, portanto, é essencial confirmar se ele
funciona corretamente. O código de verificação, pelo menos, registrará cada mudança de estado em um arquivo de log ou alguma outra
forma de armazenamento permanente. No caso de uma aplicação de alta confiabilidade, o código de verificação pode incorporar uma tabela
de transição de estado que defina todas as transições de estado legítimas para que possa sinalizar um erro se ocorrer uma transição de estado
ilegítimo. Observe que gravar dados em um arquivo de log pode ser demorado, pelo menos em alguns aplicativos em tempo real, e notas
separadas fornecem algumas técnicas úteis para registrar dados de maneira eficiente em termos de tempo e espaço.
Machine Translated by Google

Sistemas Mecatrônicos 210 Máquinas de Estados Finitos página 13

Figura 12: Modelo de fluxograma para cada estado

O código para cada estado segue um modelo e consiste em quatro seções separadas. No início, o código verifica se o valor
do estado foi alterado na última vez em que o código foi executado e, em caso afirmativo, executa ações de prelúdio,
como inicializar os valores do cronômetro. Da mesma forma, no final, o código executa ações de postlúdio se o estado
estiver prestes a ser alterado. Entre o código executa ações específicas para este estado particular e nenhum outro
estado. Esse é o recurso mais importante do modelo de código. Por ter um código separado para cada estado distinto, as
alterações podem ser feitas em um estado sem a preocupação de que essas alterações possam ter efeitos colaterais nos
outros estados. Depois disso, o código verifica se o estado deve ser alterado e, em caso afirmativo, define o novo
valor de estado na variável "newstate".