Projetando uma Máquina de Estados: Do Requisito ao Diagrama
Introdução
No primeiro artigo desta série, vimos como uma máquina de estados finitos (FSM) pode ajudar a organizar o comportamento de um sistema embarcado. A partir de um exemplo simples, um LED controlado por um botão, conhecemos os conceitos de estado, evento e transição.
Mas conhecer esses conceitos não significa que já sabemos projetar uma máquina de estados.
Antes de escrever código ou desenhar setas entre estados, precisamos responder a algumas perguntas: em que situações o sistema pode estar? O que pode acontecer durante a execução? Quais eventos disparam mudanças de estado? Existem condições que precisam ser satisfeitas para que uma transição seja permitida? E, principalmente, o que deve acontecer nas situações que não são tão evidentes?
Essas perguntas fazem parte do processo de projeto. Quando respondidas adequadamente, elas permitem construir um modelo que pode ser analisado, discutido e testado antes mesmo de começarmos a implementação.
Neste artigo, vamos percorrer esse processo utilizando como exemplo uma porta automática. Começaremos pelos requisitos e avançaremos gradualmente até um diagrama que representa o comportamento esperado do equipamento. Ao longo do caminho, veremos como variáveis, condições de guarda, ações e diferentes formas de representar as saídas ajudam a descrever situações que uma FSM básica não consegue expressar sem multiplicar estados.
A ideia é simples: antes de decidir como programar um sistema, precisamos compreender e definir como ele deve se comportar.
2.1. Antes do código, vem o comportamento
Imagine que precisamos desenvolver o firmware de uma porta automática para a entrada de uma loja.
O requisito inicial poderia ser descrito assim, em seis itens:
R1. A porta permanece fechada até receber um comando de abertura.
R2. Ao abrir, o motor movimenta a porta até que o sensor indique que ela está totalmente aberta.
R3. Aberta, a porta pode receber um comando de fechamento, desde que não haja obstáculo na passagem.
R4. Durante o fechamento, um obstáculo ou um novo comando de abertura faz a porta interromper o movimento e voltar a abrir.
R5. Uma falha no motor interrompe o movimento e leva o sistema a um estado de falha.
R6. O sistema só sai da falha por um comando de reset, depois que a falha tiver sido resolvida.
Embora pareçam simples, esses requisitos já descrevem vários comportamentos diferentes.
A porta pode estar fechada, abrindo, aberta ou fechando. Também pode ocorrer uma falha que impeça a continuação da operação normal.
Além disso, existem situações que precisam ser consideradas: o que acontece quando chega um comando de abertura durante a movimentação? O que ocorre se o comando de fechamento for recebido enquanto há um obstáculo na passagem? E como o sistema deve se comportar depois de uma falha?
Observe que ainda não precisamos decidir como o firmware será implementado.
Neste momento, nosso objetivo é transformar a descrição em uma representação do comportamento.
Esse processo é coerente com o artigo do Barr Group sobre implementação de máquinas de estados em C e C++, que defende deixar a estrutura de estados e eventos visível no código, em vez de escondida em condicionais espalhadas [1].
2.2. Identificando os estados
O primeiro passo é identificar as diferentes situações em que o sistema pode se encontrar.
Para a porta automática, podemos definir cinco estados:
| Estado | Significado |
| CLOSED | A porta está fechada e aguarda um comando de abertura. |
| OPENING | O motor está movimentando a porta no sentido de abertura. |
| OPEN | A porta está completamente aberta. |
| CLOSING | O motor está movimentando a porta no sentido de fechamento. |
| FAULT | Foi detectada uma falha que impede a operação normal. |
Por que precisamos de cinco estados, e não apenas dois, como OPEN e CLOSED?
Porque a porta não passa instantaneamente de uma posição à outra. Durante a movimentação, o controlador precisa comandar o motor, acompanhar os sensores e reagir a situações como a detecção de um obstáculo ou uma falha.
Representar OPENING e CLOSING como estados distintos permite definir comportamentos específicos para cada direção do movimento.
Por exemplo, se o sensor de obstáculo for acionado durante o fechamento, o controlador deverá interromper o movimento e iniciar a abertura. Já durante a abertura, o mesmo evento não exige reação: a porta continua abrindo, o que já libera a passagem.
A escolha dos estados depende, portanto, das diferenças de comportamento que precisamos representar.
Uma orientação prática é evitar dois extremos. Se criarmos poucos estados, podemos acabar escondendo diferenças importantes em variáveis e condicionais. Se criarmos estados demais, o modelo se torna desnecessariamente complicado.
Um estado deve representar uma situação que tenha significado para o comportamento do sistema, e não apenas uma etapa arbitrária do código.
Também convém separar estados de ações. OPENING representa uma situação do sistema; start_opening representa uma ação que pode ser executada ao entrar nesse estado.
Essa distinção vai fazer diferença quando chegarmos à implementação.
2.3. Identificando os eventos
Depois de identificar os estados, precisamos determinar o que pode acontecer durante a operação.
Na nossa porta automática, os principais eventos são:
| Evento | Origem ou significado |
| OPEN_COMMAND | Foi solicitado que a porta abra. |
| OPEN_LIMIT | O sensor indica que a porta chegou à posição totalmente aberta. |
| CLOSE_COMMAND | Foi solicitado o fechamento da porta. |
| CLOSED_LIMIT | O sensor indica que a porta chegou à posição totalmente fechada. |
| OBSTACLE_DETECTED | O sensor de segurança detectou um obstáculo na passagem. |
| MOTOR_FAULT | Foi detectada uma falha no acionamento ou na supervisão do motor. |
| RESET | Foi solicitado o retorno à operação normal após uma falha. |
Esses eventos representam ocorrências, e não situações permanentes. OPEN_LIMIT, por exemplo, indica que o sensor sinalizou a chegada à posição aberta. Já OPEN representa o estado em que o controlador considera que a porta está aberta.
Repare também que a descrição de OBSTACLE_DETECTED não menciona em que momento o obstáculo aparece. O evento diz apenas o que aconteceu; o que fazer com ele depende do estado em que a máquina está, exatamente como vimos no primeiro artigo.
No firmware real, os eventos podem ter diferentes origens. Um comando pode vir de um botão ou de outro controlador. Um evento de posição pode ser gerado pela leitura de um sensor. Uma falha pode ser identificada por uma rotina de diagnóstico.
Independentemente da origem, o modelo da máquina deve tratar os eventos de forma coerente.
Também não precisamos representar cada leitura de sensor como um evento separado. Basta identificar as ocorrências que realmente influenciam o comportamento.
A distinção entre o sinal físico, o evento interpretado e o estado resultante vai reaparecer quando começarmos a implementar a máquina em C.
2.4. Definindo as transições
Agora que conhecemos os estados e os eventos, podemos estabelecer as regras que conectam uns aos outros.
Uma transição responde essencialmente a três perguntas:
- Qual evento dispara a transição?
- Em que estado a máquina precisa estar?
- Para qual estado a máquina deve seguir?
Para a porta automática, algumas transições são diretas.
Quando a porta está fechada e recebe um comando de abertura, ela passa para OPENING. Ao atingir a posição aberta, passa para OPEN. Se receber um comando de fechamento nas condições apropriadas, passa para CLOSING. Ao atingir a posição fechada, retorna para CLOSED. Durante o fechamento, tanto um obstáculo quanto um novo comando de abertura fazem a porta voltar a abrir.
Podemos representar essas regras em uma tabela:
| Estado atual | Evento | Próximo estado |
| CLOSED | OPEN_COMMAND | OPENING |
| OPENING | OPEN_LIMIT | OPEN |
| OPEN | CLOSE_COMMAND | CLOSING, se autorizado |
| CLOSING | CLOSED_LIMIT | CLOSED |
| CLOSING | OBSTACLE_DETECTED | OPENING |
| CLOSING | OPEN_COMMAND | OPENING |
| OPENING | MOTOR_FAULT | FAULT |
| CLOSING | MOTOR_FAULT | FAULT |
| FAULT | RESET | OPENING, se a falha estiver resolvida |
Esta primeira tabela é propositalmente simples: ainda faltam condições e ações, que veremos nas próximas seções. Mesmo assim, ela já mostra que a resposta a um evento depende do estado atual. MOTOR_FAULT leva a FAULT durante a abertura e o fechamento, mas não tem efeito nos outros estados. A última linha também chama atenção: depois de uma falha, a porta vai para OPENING, e não para CLOSED. A justificativa vem no modelo completo, na seção 2.12.
Isso nos leva a uma decisão de projeto fundamental: o comportamento precisa estar definido para os eventos relevantes em cada estado.
Isso não obriga todo estado a tratar todos os eventos possíveis. Um comando de fechamento recebido enquanto a porta está fechada pode simplesmente ser ignorado. O importante é que essa escolha seja consciente, e não resultado de uma omissão no modelo.
Até aqui, estamos trabalhando com a estrutura básica de uma FSM: estados, eventos e transições. Entretanto, logo aparece uma necessidade adicional.
A porta não pode iniciar o fechamento apenas porque recebeu um comando. Ela também precisa verificar se a passagem está livre.
Como representar essa condição?
2.5. Quando estado e evento não são suficientes
Considere esta regra:
Ao receber um comando de fechamento, a porta deverá iniciar o movimento somente se não houver nenhum obstáculo na passagem.
A transição depende de duas informações diferentes:
- O estado atual e o evento recebido.
- Uma condição que precisa ser verdadeira para permitir a transição.
Uma máquina clássica, em sua definição mais simples, determina o próximo estado a partir do estado atual e da entrada. Na prática, muitos sistemas precisam considerar também dados de contexto, como valores de sensores, contadores e resultados de operações anteriores.
Quando ampliamos a máquina dessa maneira, encontramos o conceito de máquina de estados finitos estendida, ou EFSM (Extended Finite State Machine). A nomenclatura e o escopo exato podem variar entre fontes e ferramentas, mas a distinção é útil para compreender a evolução do modelo [1].
A ideia é acrescentar dados de contexto, condições que dependem deles e ações capazes de ler e alterar esses dados, sem abandonar a estrutura básica de estados e transições. A Figura 1 resume essa progressão:
Vale um esclarecimento sobre as saídas. No primeiro artigo, apresentamos a FSM pela definição do NIST, que não menciona saídas. Existem, porém, máquinas de estados finitos com saída, como os modelos clássicos de Moore e Mealy, que veremos mais adiante, e são elas que interessam no firmware. Por isso, na Figura 1, a FSM básica já aparece com saídas. O que a máquina estendida acrescenta são os dados e as regras que dependem deles.
Essa representação não é uma classificação universal rígida. Para os objetivos desta série, ela serve para separar didaticamente o modelo mais simples da máquina que utiliza dados de contexto e condições de transição.
Essa ampliação é bastante natural em sistemas embarcados. Um controlador de motor, por exemplo, pode precisar considerar a temperatura, a corrente medida, o número de tentativas de inicialização ou a presença de uma condição de segurança antes de permitir determinada operação.
Essas informações não precisam necessariamente se transformar em novos estados. Muitas vezes, faz mais sentido armazená-las em variáveis e utilizá-las nas condições que controlam as transições.
2.6. Variáveis de contexto: a memória da máquina
O estado diz em que situação a porta está. Algumas decisões, porém, dependem de informações que o estado não guarda. Para elas, o modelo usa variáveis de contexto:
bool passage_clear;
bool fault_cleared;
Variáveis de contexto do controlador da porta.
- passage_clear: a passagem está livre?
- fault_cleared: a causa da falha foi resolvida?
Essas variáveis não são novos estados. CLOSING diz o que a porta está fazendo; passage_clear guarda uma informação do sensor de segurança, que vale em qualquer estado.
O mesmo sensor aparece de duas formas no modelo. Quando um obstáculo surge, a mudança do sinal vira o evento OBSTACLE_DETECTED. O nível atual do sinal, que diz se a passagem está livre agora, fica em passage_clear.
Uma regra prática: use um estado quando o comportamento muda; use uma variável quando só é preciso lembrar uma informação.
Nem sempre há uma única resposta certa, mas evite criar estados apenas para guardar dados [3].
2.7. Condições de guarda (guards): o que autoriza uma transição
Uma condição de guarda, ou guard, é uma expressão lógica que determina se uma transição pode ser executada.
No caso da porta, não basta que o evento CLOSE_COMMAND ocorra. A passagem também precisa estar livre.
Podemos representar a regra assim:
CLOSE_COMMAND [passage_clear]
Os colchetes indicam a condição que precisa ser verdadeira para permitir a transição.
Uma notação mais completa, que utilizaremos como referência nos próximos artigos, é a mesma adotada no capítulo sobre variáveis do guia [3]:
EVENTO [CONDIÇÃO] / AÇÃO
A Figura 2 mostra essa notação aplicada à porta:
A leitura é:
Quando ocorrer CLOSE_COMMAND, se passage_clear for verdadeiro, execute start_closing e avance para o estado CLOSING. Na seção 2.9, veremos um lugar melhor para essa ação.
Se a condição de guarda for falsa, essa transição não será executada. No nosso exemplo, a porta permanece aberta.
O cuidado é não transformar guards em substitutos de todos os estados. Se um conjunto de condições começar a se tornar muito complexo, talvez seja melhor rever a organização do modelo e identificar estados que representem diferenças reais de comportamento.
2.8. Ações (actions): o que o sistema faz durante uma transição
Até aqui, definimos quando a máquina muda de estado, mas ainda não descrevemos completamente o que precisa ser executado.
No caso da porta, a transição para OPENING deve provocar o início do movimento de abertura. A passagem para CLOSING deve iniciar o movimento de fechamento. A detecção de um obstáculo durante o fechamento precisa interromper esse movimento e comandar a abertura.
Essas operações são chamadas de ações (actions).
Alguns exemplos são:
OPEN_COMMAND / start_opening
OPEN_LIMIT / stop_motor
CLOSED_LIMIT / stop_motor
A diferença é a seguinte:
- Estado: representa a situação do sistema.
- Evento: indica o que aconteceu.
- Guard: determina se a transição está autorizada.
- Ação: representa uma operação executada pela máquina.
- Transição: define a mudança de um estado para outro.
Essa separação ajuda a evitar que o diagrama se transforme em uma sequência de comandos de baixo nível.
As ações podem executar operações de hardware, atualizar dados, registrar uma falha ou solicitar algum processamento externo. Em uma implementação real, precisamos definir com cuidado quais ações são apropriadas para cada contexto de execução.
Por enquanto, basta compreender que uma transição não precisa apenas selecionar o próximo estado: ela também pode provocar operações associadas à mudança de comportamento.
Repare, porém, que stop_motor já aparece em duas transições, e apareceria em outras tantas se considerássemos as falhas. A próxima seção mostra uma forma de evitar essa repetição.
2.9. Ações de entrada e saída (entry e exit): o ciclo de vida do estado
Além das ações associadas às transições, podemos definir operações executadas quando um estado é ativado ou desativado.
Essas operações são conhecidas como entry e exit.
- Entry: executada quando a máquina entra em um estado.
- Exit: executada quando a máquina sai de um estado.
Nem toda representação formal de FSM exige esses mecanismos, mas eles são bastante úteis em implementações de software e em notações modernas de máquinas de estados, como a UML [1][4].
Na porta automática, podemos definir:
OPENING
entry / start_opening
exit / stop_motor
Ações de entrada e saída do estado OPENING.
Ao entrar em OPENING, o controlador inicia a abertura; ao sair, interrompe o movimento, qualquer que seja o comportamento seguinte. Essa abordagem ajuda a manter certas operações próximas do estado a que pertencem.
Por exemplo, quando a porta sai de OPENING porque atingiu o limite de abertura, a ação de saída interrompe o motor. Se sair desse mesmo estado devido a uma falha, a operação de parada também será executada.
Isso evita duplicar a mesma operação em diversas transições. Por isso, no modelo completo da porta, as operações do motor ficarão nas ações de entrada e saída, e as transições guardarão apenas as ações que pertencem a uma ocorrência específica.
Ainda assim, ações de entrada e saída não se confundem com ações de transição. Uma ação de transição pertence à ocorrência específica que dispara a transição; uma ação de entrada ou saída pertence ao ciclo de vida do estado.
A ordem em que essas ações são executadas também precisa ser definida. Na convenção da UML, a saída do estado de origem ocorre primeiro, seguida da ação de transição e, por fim, da entrada no estado de destino [4]. A Figura 3 mostra essa sequência quando um obstáculo é detectado durante o fechamento: o controlador para o motor (exit), sinaliza o obstáculo (ação da transição) e inicia a abertura (entry de OPENING).
Quando introduzirmos estados hierárquicos no artigo 4, veremos que a ordem de entrada e saída exige cuidados adicionais. Por enquanto, basta compreender a finalidade de cada mecanismo.
2.10. Moore e Mealy: onde ficam as saídas?
Agora que conhecemos as ações de transição e as ações de entrada e saída, podemos introduzir duas formas clássicas de relacionar os estados, as entradas e as saídas de uma máquina.
As máquinas de Moore e Mealy são modelos clássicos de máquinas de estados com saída, descritos no Dictionary of Algorithms and Data Structures do NIST e explorados no contexto de sistemas embarcados no material de Jonathan Valvano e Ramesh Yerraballi. A principal diferença está em quais informações determinam a saída [2][5].
Máquina de Moore
Na máquina de Moore, a saída depende apenas do estado atual.
Podemos representar essa relação assim:
Saída = f(Estado)
No controlador da porta, o comando do motor pode ser definido a partir do estado, como mostra a Figura 4:
Máquina de Mealy
Na máquina de Mealy, a saída depende do estado atual e da entrada recebida:
Saída = f(Estado, Entrada)
No mesmo controlador, a ação signal_obstacle é um bom exemplo. O aviso é gerado quando o evento OBSTACLE_DETECTED ocorre durante o fechamento.
A saída depende tanto do contexto (a porta está fechando?) quanto do evento recebido.
A diferença pode ser resumida assim:
| Modelo | A saída depende de | Exemplo |
| Moore | Estado atual | Motor comandado para abrir enquanto a máquina está em OPENING. |
| Mealy | Estado atual e entrada | Aviso gerado quando OBSTACLE_DETECTED ocorre em CLOSING. |
Essa explicação é suficiente para o objetivo desta série. Não precisamos aprofundar a teoria formal de circuitos sequenciais ou a síntese lógica para utilizar esses conceitos no projeto de firmware.
Na prática, as máquinas de estados de software costumam combinar os dois estilos, e o exemplo da porta automática faz exatamente isso. Escolher onde colocar cada ação é uma decisão de projeto: comportamentos que pertencem a uma situação ficam no estado; reações a uma ocorrência específica ficam na transição.
2.11. O diagrama como ferramenta de projeto
Com estados, eventos, transições, condições e ações definidos, podemos montar o diagrama da máquina.
Mas o diagrama não deve ser encarado apenas como uma ilustração para acompanhar o código. Ele funciona como uma ferramenta para avaliar o projeto.
Ao desenhar as transições, podemos identificar problemas que talvez passassem despercebidos durante a implementação. Na minha experiência, é nessa etapa, com o diagrama na mesa, que aparece a maior parte das lacunas do requisito. Lembro de uma revisão em que bastou desenhar o diagrama de um alimentador de peças para descobrir que ninguém tinha definido o que fazer com um comando de parada durante a calibração. O código tratava o caso de um jeito; o manual do operador, de outro.
Por exemplo:
- Estados sem saída. Existe algum estado do qual a máquina não consegue sair? Isso é intencional ou um erro de modelagem?
- Transições ausentes. O que acontece se um comando de fechamento for recebido durante a abertura? A máquina deve ignorá-lo, inverter o movimento ou concluir primeiro a abertura? Nenhum dos requisitos R1 a R6 responde a essa pergunta.
- Condições não especificadas. O que acontece quando o guard de uma transição é falso?
- Falhas sem recuperação. Depois de entrar em FAULT, existe alguma condição segura para retornar à operação normal?
- Comportamentos conflitantes. Duas regras podem permitir resultados diferentes para a mesma combinação de estado e evento? Se isso for possível, como a escolha deve ser feita?
- Coerência com o mundo físico. O estado em que a máquina se encontra corresponde sempre à situação real do equipamento? Isso vale para o estado inicial e também para os estados alcançados depois de uma falha.
- Não é necessário que todo evento provoque uma transição em todos os estados. O importante é distinguir os casos em que o evento deve ser ignorado daqueles em que ainda falta definir o comportamento.
Também precisamos verificar se as transições fazem sentido do ponto de vista físico. Um diagrama pode estar logicamente consistente e ainda permitir uma operação insegura se os requisitos estiverem incompletos.
A principal vantagem do diagrama aparece justamente nessa etapa: podemos discutir as regras e identificar lacunas sem depender dos detalhes do código.
2.12. Do requisito ao modelo completo: a porta automática
Vamos reunir as decisões tomadas ao longo do artigo.
Requisitos
Os requisitos são os seis da seção 2.1, de R1 a R6.
Estados, eventos e contexto
Estados
CLOSED
OPENING
OPEN
CLOSING
FAULT
Eventos
OPEN_COMMAND
OPEN_LIMIT
CLOSE_COMMAND
CLOSED_LIMIT
OBSTACLE_DETECTED
MOTOR_FAULT
RESET
Contexto
passage_clear
fault_cleared
Diagrama resultante
A Figura 5 reúne todas as decisões. As operações do motor estão nas ações de entrada e saída dos estados, e as transições carregam apenas os eventos, os guards e as ações próprias de cada ocorrência.
Duas ações aparecem só no diagrama. Ao entrar em FAULT, disable_motor desabilita o motor: ao contrário de apenas pará-lo, isso o impede de responder a novos comandos. Ao sair de FAULT pelo RESET, clear_fault limpa o registro da falha e libera o motor.
Uma decisão merece destaque: depois de uma falha, o comando RESET leva a porta para OPENING, e não para CLOSED.
A falha pode acontecer com a porta parada a meio caminho. Se o reset levasse a máquina direto para CLOSED, o firmware passaria a considerar a porta fechada sem que ela estivesse. Ao seguir para OPENING, a porta se move até o fim de curso de abertura, uma posição conhecida e confirmada por sensor. Em uma porta de passagem de pessoas, abrir também é a reação mais segura. É exatamente o tipo de problema que a pergunta sobre coerência com o mundo físico, na seção anterior, ajuda a encontrar.
Este modelo, como todos os exemplos desta série, é uma simplificação, feita para manter o diagrama legível. Um projeto real precisaria especificar, entre outros pontos, como o controlador se comporta quando recebe comandos incompatíveis com o estado atual, como trata falhas em estados que não estão representados aqui e quais mecanismos de segurança precisam atuar independentemente da FSM.
O objetivo, porém, foi alcançado: transformamos um requisito textual em uma representação explícita do comportamento esperado.
Podemos agora revisar as transições, discutir se estão completas e testar sequências de eventos antes de decidir como escrever o código.
Essa é a contribuição central do projeto de uma FSM: o modelo torna as regras do sistema visíveis antes que elas sejam incorporadas à implementação.
Conclusão
Projetar uma máquina de estados começa muito antes da escolha da estrutura de código. Precisamos entender o requisito, identificar as situações do sistema, determinar os eventos relevantes e definir as transições que representam o comportamento esperado.
À medida que o problema se torna mais realista, outros elementos aparecem naturalmente. Variáveis permitem armazenar informações de contexto, guards restringem a execução das transições e ações representam as operações que acompanham o comportamento. As ações de entrada e saída ajudam a organizar o que acontece quando a máquina entra ou sai de um estado, e os modelos de Moore e Mealy nos dão um vocabulário para decidir onde cada saída deve ficar.
Também vimos que um diagrama bem construído é mais do que documentação. Ele ajuda a descobrir requisitos ausentes, transições conflitantes e situações para as quais ainda não definimos uma resposta.
No próximo artigo, vamos transformar esse modelo em código C. Começaremos pela implementação direta com switch-case, uma abordagem simples e bastante comum, e veremos como representar estados, eventos, transições e ações no firmware.
A intenção não é escrever código para depois tentar entender o comportamento, mas fazer o caminho inverso: partir de um comportamento que conseguimos explicar e projetá-lo de forma que a implementação preserve essa lógica.
E você, costuma desenhar a máquina antes de programar, ou o diagrama nasce depois do código? Deixe sua resposta nos comentários.
Referências
[1] Barr Group — How to Code a State Machine in C or C++
Sem indicação de autor. Discute a identificação de estados, a implementação de máquinas reativas e o uso de máquinas estendidas, guards e ações de entrada e saída.
https://barrgroup.com/embedded-systems/how-to/coding-state-machines
[2] Black, Paul E. — Moore Machine; Mealy Machine; Finite State Machine
Dictionary of Algorithms and Data Structures, National Institute of Standards and Technology (NIST). Verbetes com as definições das máquinas de Moore e Mealy e a definição formal de FSM.
https://xlinux.nist.gov/dads/HTML/mooreMachine.html
https://xlinux.nist.gov/dads/HTML/mealyMachine.html
https://xlinux.nist.gov/dads/HTML/finiteStateMachine.html
[3] Mülder, Andreas — The Complete Guide to State Machines (statecharts.online), cap. 2: States, Transitions, and Events; cap. 3: Variables in State Machines
Material introdutório sobre estados, eventos, transições, guards, ações e utilização de variáveis para representar contexto.
https://statecharts.online/chapters/02-states-transitions-and-events.html
https://statecharts.online/chapters/03-variables.html
[4] Object Management Group (OMG) — Unified Modeling Language (UML), versão 2.5.1
Especificação de referência para a notação UML de máquinas de estados, incluindo a execução de transições e das ações de entrada e saída.
https://www.omg.org/spec/UML/2.5.1/
[5] Valvano, Jonathan W.; Yerraballi, Ramesh — Chapter 5: Finite State Machines
Material didático da University of Texas at Austin sobre FSMs em sistemas embarcados, incluindo diagramas de estados e a diferença entre Moore e Mealy.
https://users.ece.utexas.edu/~valvano/Volume1/IntroToEmbSys/Ch5_FiniteStateMachines.html
Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.
