Fundamentos · 11 min de leitura

Máquina de estados no Arduino: guia de enum, switch-case e millis()

Guia de máquina de estados no Arduino: estados com enum e switch-case, transições, estados temporizados com millis, semáforo, menu, máquina de lavar e código para o Pico.

Uma máquina de estados no Arduino é um jeito de escrever código em que você divide o programa em estados separados e fica em apenas um deles de cada vez. Um semáforo está no estado “vermelho”, “amarelo” ou “verde”; uma máquina de lavar está “enchendo”, “lavando” ou “centrifugando”. Em cada estado fica claro o que fazer e em qual condição passar para o próximo estado. No Arduino você monta isso com um enum, um switch-case e millis(). O resultado é um código que executa várias tarefas ao mesmo tempo sem delay(), fácil de ler e de ampliar.

Neste guia, primeiro vamos ver as ideias de estados, transições e ações, como desenhar um diagrama de estados e a máquina mais simples, de dois estados. Depois vamos escrever um semáforo com botão de pedestre, um menu de configurações navegado com dois botões e uma simulação de máquina de lavar que pausa quando a tampa abre. Você também vai aprender a rodar várias máquinas de estados no mesmo loop(), ações de entrada, erros comuns e como a mesma estrutura é escrita em MicroPython no Raspberry Pi Pico.

O que é uma máquina de estados?

Uma máquina de estados (máquina de estados finitos, FSM) tem quatro partes. Os estados são o conjunto limitado de situações em que o sistema pode estar. As transições levam de um estado a outro, e as condições ou eventos decidem quando isso acontece: um botão pressionado, um valor de sensor passando de um limite ou um tempo que se esgota. As ações são o trabalho feito ao entrar em um estado ou enquanto se permanece nele: acender um LED, ligar um motor, escrever em um display. A cada ciclo do loop() o programa faz só uma pergunta: “Em que estado estou e a condição para sair dele já foi atendida?” Assim ele nunca fica esperando em lugar nenhum e, em vez de ifs aninhados e centenas de variáveis de flag, você tem uma estrutura organizada em torno de uma única variável de estado.

ConceitoSignificadoExemplo do semáforo
EstadoA situação atual do sistemaKIRMIZI (vermelho), KIRMIZI_SARI (vermelho-amarelo), YESIL (verde), SARI (amarelo)
TransiçãoPassar de um estado para outroDe YESIL para SARI
Condição ou eventoO que dispara a transiçãoPassaram 10 segundos ou o botão de pedestre foi pressionado
Ação de entradaTrabalho feito uma vez ao entrar em um estadoAcender o LED verde, apagar os outros
Ação dentro do estadoTrabalho feito continuamente enquanto se está no estadoMonitorar o botão de pedestre

Por que uma máquina de estados em vez de delay()?

Quando você escreve delay(5000), o Arduino não faz nada por cinco segundos: um botão pressionado passa despercebido, os sensores não são lidos, o display não é atualizado. Em programas pequenos que fazem uma única tarefa isso não tem problema, mas no momento em que você acrescenta uma segunda tarefa o código começa a desandar. Uma máquina de estados nunca espera; cada estado pergunta “quanto tempo passou desde que entrei?” com millis() e, se o tempo não acabou, volta na hora para o loop(). Como o loop roda milhares de vezes por segundo, as outras tarefas, como botões, sensores e displays, continuam funcionando sem interrupção. Explicamos em detalhes o básico da temporização com millis() no artigo millis em vez de delay no Arduino.

CaracterísticaCódigo com delay()Máquina de estados
Os botões são lidos durante a espera?NãoSim
Várias tarefas ao mesmo tempoDifícil, o código fica bagunçadoFácil, cada tarefa na sua própria máquina
Adicionar um novo estadoVocê reescreve todo o fluxoVocê adiciona um novo case
DepuraçãoNão dá para saber onde o programa estáBasta escrever o nome do estado no Monitor Serial
MemóriaPoucaPouca (uma variável e uma marcação de tempo)

Sua primeira máquina de estados com enum e switch-case

Um enum permite dar nomes aos estados em vez de números. A linha enum Durum { YANIK, SONUK }; (aceso, apagado) define um novo tipo que, para o compilador, guarda os valores 0 e 1, mas tem nomes com significado para você. A variável de estado é desse tipo, e o switch-case executa um bloco separado para cada estado. No exemplo abaixo, o LED integrado do Uno (D13) fica aceso por 200 ms e apagado por 1,8 segundo. Daria para fazer isso com delay também, mas nessa estrutura o loop() nunca espera, e você pode acrescentar no final quantas outras tarefas quiser.

C++ (Arduino IDE)
1// En basit durum makinesi: farklı sürelerde yanıp sönen LED
2// Simplest state machine: an LED with different on/off times
3const int LED_PIN = 13;
4
5enum Durum { YANIK, SONUK };            // durumlar / states
6Durum durum = SONUK;
7unsigned long durumBaslangic = 0;        // duruma giriş zamanı / time the state began
8
9void setup() {
10  pinMode(LED_PIN, OUTPUT);
11}
12
13void loop() {
14  unsigned long gecen = millis() - durumBaslangic;   // durumda geçen süre / time in state
15
16  switch (durum) {
17    case YANIK:
18      if (gecen >= 200) {                // 200 ms yandıktan sonra / after 200 ms on
19        digitalWrite(LED_PIN, LOW);
20        durum = SONUK;
21        durumBaslangic = millis();
22      }
23      break;
24    case SONUK:
25      if (gecen >= 1800) {               // 1,8 sn söndükten sonra / after 1.8 s off
26        digitalWrite(LED_PIN, HIGH);
27        durum = YANIK;
28        durumBaslangic = millis();
29      }
30      break;
31  }
32  // loop asla beklemez; buraya başka işler eklenebilir
33  // loop never blocks; other tasks can be added here
34}
Coloque a definição do enum bem no topo do arquivo, antes das suas funções. A Arduino IDE gera os protótipos das funções automaticamente; se o enum for definido depois de uma função que o usa como parâmetro, você pode receber o erro “was not declared in this scope” (não declarado neste escopo). Também não esqueça o break no fim de cada case; caso contrário, o programa executa também o código do estado seguinte.

Como desenhar um diagrama de estados

Desenhar a máquina de estados no papel antes de escrever o código elimina a maioria dos bugs antes mesmo de começar. No diagrama, cada estado é um círculo ou uma caixa de cantos arredondados e cada transição é uma seta. Sobre a seta você escreve a condição da transição e, se precisar, a ação depois de uma barra, como “10 s / acender amarelo”. O estado inicial é indicado por uma seta curta que vem do nada. Com o diagrama pronto, faça estas perguntas para cada estado: Existe uma saída deste estado? Se duas condições forem verdadeiras ao mesmo tempo, qual vem primeiro? O que acontece em um evento inesperado (a tampa abrir, um erro de sensor)? Transformar o diagrama em uma tabela torna a escrita do código um trabalho quase mecânico.

  1. Liste todos os estados do sistema e dê a cada um nome curto, em letras maiúsculas.
  2. Escolha o estado inicial; o Arduino estará nesse estado ao ligar ou reiniciar.
  3. Escreva as condições de saída de cada estado: tempo, botão, sensor ou outro evento.
  4. Acrescente o estado de destino de cada transição e qualquer ação a ser feita durante ela.
  5. Defina a ação de entrada de cada estado: quais saídas ficam ligadas e quais desligadas?
  6. Anote à parte as regras comuns que valem em todos os estados (parada de emergência, abertura da tampa).
  7. Transforme o diagrama em uma tabela de transições como a de baixo e escreva cada linha como um if dentro de um case.
EstadoCondiçãoPróximo estadoAção de entrada
KIRMIZIPassaram 5 sKIRMIZI_SARIVermelho aceso, pedido de pedestre apagado
KIRMIZI_SARIPassaram 1,5 sYESILVermelho e amarelo acesos
YESILPassaram 10 s, ou 4 s se houver pedidoSARIVerde aceso
SARIPassaram 2 sKIRMIZIAmarelo aceso

Exemplo 1: semáforo com botão de pedestre

A sequência clássica do semáforo é vermelho, vermelho-amarelo, verde e amarelo. Vamos acrescentar um botão de pedestre: se um pedestre apertar o botão enquanto o sinal estiver verde, o verde é encurtado, desde que já esteja aceso há pelo menos 4 segundos, e o semáforo passa para o amarelo. Escrito com delay, esse comportamento é quase impossível, porque não dá para ler o botão enquanto se espera no verde. Em uma máquina de estados o botão é lido a cada ciclo do loop e o pedido fica guardado em uma variável. Se você nunca montou o circuito básico do semáforo, dê uma olhada antes no artigo semáforo com Arduino.

LEDs vermelho, amarelo e verde
Os exemplos do semáforo, do menu e da máquina de lavar usam os mesmos três LEDs e dois botões.
ComponentePino do Arduino UnoObservação
LED vermelhoD8Com resistor de 220 Ω, perna curta no GND
LED amareloD9Com resistor de 220 Ω
LED verdeD10Com resistor de 220 Ω (pino com PWM)
BuzzerD11Só no exemplo da máquina de lavar
Botão 1D2Outro terminal no GND, INPUT_PULLUP
Botão 2D3Outro terminal no GND, INPUT_PULLUP
C++ (Arduino IDE)
1// Yaya butonlu trafik lambası durum makinesi / traffic light with pedestrian button
2const int KIRMIZI_LED = 8, SARI_LED = 9, YESIL_LED = 10, YAYA_BUTON = 2;
3
4enum Durum { KIRMIZI, KIRMIZI_SARI, YESIL, SARI };
5Durum durum = KIRMIZI;
6unsigned long durumBaslangic = 0;
7bool yayaIstegi = false;
8
9void lambalar(bool k, bool s, bool y) {
10  digitalWrite(KIRMIZI_LED, k);
11  digitalWrite(SARI_LED, s);
12  digitalWrite(YESIL_LED, y);
13}
14
15// Durum değiştir + giriş eylemi / change state + entry action
16void durumDegistir(Durum yeni) {
17  durum = yeni;
18  durumBaslangic = millis();
19  switch (yeni) {
20    case KIRMIZI:      lambalar(1, 0, 0); yayaIstegi = false; break;  // yayalar geçer / pedestrians cross
21    case KIRMIZI_SARI: lambalar(1, 1, 0); break;
22    case YESIL:        lambalar(0, 0, 1); break;
23    case SARI:         lambalar(0, 1, 0); break;
24  }
25}
26
27void setup() {
28  pinMode(KIRMIZI_LED, OUTPUT);
29  pinMode(SARI_LED, OUTPUT);
30  pinMode(YESIL_LED, OUTPUT);
31  pinMode(YAYA_BUTON, INPUT_PULLUP);
32  durumDegistir(KIRMIZI);
33}
34
35void loop() {
36  if (digitalRead(YAYA_BUTON) == LOW) yayaIstegi = true;   // isteği hatırla / remember the request
37
38  unsigned long gecen = millis() - durumBaslangic;
39  switch (durum) {
40    case KIRMIZI:
41      if (gecen >= 5000) durumDegistir(KIRMIZI_SARI);
42      break;
43    case KIRMIZI_SARI:
44      if (gecen >= 1500) durumDegistir(YESIL);
45      break;
46    case YESIL:
47      // En az 4 sn yeşil; yaya isterse kısalır, yoksa 10 sn
48      // At least 4 s green; shortened on request, otherwise 10 s
49      if ((yayaIstegi && gecen >= 4000) || gecen >= 10000) durumDegistir(SARI);
50      break;
51    case SARI:
52      if (gecen >= 2000) durumDegistir(KIRMIZI);
53      break;
54  }
55}

A parte mais importante deste código é a função durumDegistir() (mudar estado). Três coisas acontecem ao passar para um estado: a variável de estado é atualizada, a marcação de tempo é zerada e a ação de entrada daquele estado é executada uma vez. Fazer todas as transições passarem por essa única função elimina bugs do tipo “esqueci de zerar o temporizador”. O pedido de pedestre é apagado ao entrar no estado KIRMIZI, porque é nesse momento que os pedestres atravessam de qualquer forma. Se quiser calcular os resistores dos LEDs, use a ferramenta Resistor para LED.

Exemplo 2: menu de configurações com dois botões

Menus são o uso mais natural de uma máquina de estados: a página mostrada na tela é um estado e os botões disparam as transições. No exemplo abaixo, o botão em D2 significa “próximo” ou “aumentar valor” e o D3 significa “OK”. No menu principal você alterna entre as opções de brilho e velocidade; aperte OK para entrar na página de ajuste, mude o valor com D2 e saia com OK. Ao mesmo tempo, uma segunda máquina de estados, independente, faz o LED em D10 piscar com o brilho e a velocidade escolhidos. O LED não engasga nem por um instante enquanto você navega pelo menu.

Botão de pressão
Os botões são ligados com INPUT_PULLUP; o pino lê LOW quando pressionado.
C++ (Arduino IDE)
1// İki butonlu menü + bağımsız LED makinesi / two-button menu + independent LED machine
2// D2: ileri / değer artır, D3: tamam, D10: LED (PWM)
3const int ILERI_PIN = 2, TAMAM_PIN = 3, LED_PIN = 10;
4
5enum MenuDurum { MENU_PARLAKLIK, MENU_HIZ, AYAR_PARLAKLIK, AYAR_HIZ };
6MenuDurum menu = MENU_PARLAKLIK;
7int parlaklik = 153;    // 51..255
8int hizMs = 500;        // yanıp sönme yarım periyodu / blink half period
9
10struct Buton {
11  uint8_t pin;
12  bool kararli;               // kararlı seviye / debounced level
13  bool sonOkuma;
14  unsigned long sonDegisim;
15};
16Buton ileri = {ILERI_PIN, HIGH, HIGH, 0};
17Buton tamam = {TAMAM_PIN, HIGH, HIGH, 0};
18
19// Yalnız basma anında bir kez true döner / true once, on the press edge only
20bool basildi(Buton &b) {
21  bool okuma = digitalRead(b.pin);
22  if (okuma != b.sonOkuma) {
23    b.sonOkuma = okuma;
24    b.sonDegisim = millis();
25  }
26  if (millis() - b.sonDegisim > 30 && okuma != b.kararli) {   // 30 ms debounce
27    b.kararli = okuma;
28    return okuma == LOW;
29  }
30  return false;
31}
32
33void menuYaz() {
34  switch (menu) {
35    case MENU_PARLAKLIK: Serial.println(F("> Parlaklik ayari (D3: sec)")); break;
36    case MENU_HIZ:       Serial.println(F("> Hiz ayari (D3: sec)")); break;
37    case AYAR_PARLAKLIK: Serial.print(F("Parlaklik: ")); Serial.println(parlaklik); break;
38    case AYAR_HIZ:       Serial.print(F("Hiz (ms): ")); Serial.println(hizMs); break;
39  }
40}
41
42void menuGuncelle() {                       // 1. durum makinesi / machine 1
43  bool i = basildi(ileri);
44  bool t = basildi(tamam);
45  if (!i && !t) return;
46
47  switch (menu) {
48    case MENU_PARLAKLIK:
49      if (t) menu = AYAR_PARLAKLIK;
50      else menu = MENU_HIZ;
51      break;
52    case MENU_HIZ:
53      if (t) menu = AYAR_HIZ;
54      else menu = MENU_PARLAKLIK;
55      break;
56    case AYAR_PARLAKLIK:
57      if (t) menu = MENU_PARLAKLIK;          // kaydet ve çık / save and exit
58      else parlaklik = (parlaklik >= 255) ? 51 : parlaklik + 51;
59      break;
60    case AYAR_HIZ:
61      if (t) menu = MENU_HIZ;
62      else hizMs = (hizMs >= 1000) ? 100 : hizMs + 100;
63      break;
64  }
65  menuYaz();
66}
67
68void ledGuncelle() {                         // 2. durum makinesi / machine 2
69  static bool yanik = false;
70  static unsigned long son = 0;
71  if (millis() - son >= (unsigned long)hizMs) {
72    son = millis();
73    yanik = !yanik;
74    analogWrite(LED_PIN, yanik ? parlaklik : 0);
75  }
76}
77
78void setup() {
79  Serial.begin(9600);
80  pinMode(ILERI_PIN, INPUT_PULLUP);
81  pinMode(TAMAM_PIN, INPUT_PULLUP);
82  pinMode(LED_PIN, OUTPUT);
83  menuYaz();
84}
85
86void loop() {
87  menuGuncelle();      // ikisi de beklemeden sırayla çalışır
88  ledGuncelle();       // both run in turn without blocking
89}

Ao ler botões, você precisa observar o momento do aperto, não o nível. Se agíssemos enquanto digitalRead() retornasse LOW, o menu avançaria centenas de vezes em um só aperto. A função basildi() (pressionado) guarda o último nível estável de cada botão, aplica um debounce de 30 ms e retorna true uma única vez, na mudança de HIGH para LOW. Você encontra os detalhes da ligação do botão e do repique no artigo como ligar um botão. Para mostrar o menu em um display LCD I2C em vez do Monitor Serial, basta mudar a função menuYaz(); a máquina de estados continua a mesma.

EstadoD2 (próximo)D3 (OK)
MENU_PARLAKLIKIr para MENU_HIZEntrar em AYAR_PARLAKLIK
MENU_HIZIr para MENU_PARLAKLIKEntrar em AYAR_HIZ
AYAR_PARLAKLIKAumentar o brilho em 51 (volta a 51 depois de 255)Salvar, voltar para MENU_PARLAKLIK
AYAR_HIZAumentar o tempo em 100 ms (volta a 100 depois de 1000)Salvar, voltar para MENU_HIZ

Exemplo 3: máquina de lavar

Aparelhos reais geralmente seguem um programa passo a passo e reagem a eventos inesperados. Na nossa simulação de máquina de lavar, ao apertar o botão de início em D2 a máquina enche de água, lava, esvazia, centrifuga e termina com um bipe, nessa ordem. A válvula de água, o motor e a bomba são representados por três LEDs. No estado de lavagem o motor gira por 2 segundos e para por 2 segundos; é um pequeno padrão baseado em tempo dentro do estado. O mais importante: se a chave da tampa em D3 abrir, a máquina pausa em qualquer passo em que estiver e, quando a tampa fecha, continua de onde parou, com o tempo restante.

C++ (Arduino IDE)
1// Çamaşır makinesi durum makinesi (LED'lerle benzetim) / washing machine simulation
2// D8: su vanası, D9: motor, D10: pompa, D11: buzzer, D2: başlat, D3: kapak anahtarı
3const int VANA = 8, MOTOR = 9, POMPA = 10, BUZZER = 11, BASLA = 2, KAPAK = 3;
4
5enum Program { BEKLEME, SU_ALMA, YIKAMA, BOSALTMA, SIKMA, BITTI, DURAKLATILDI };
6const char *const adlar[] = {"BEKLEME", "SU ALMA", "YIKAMA", "BOSALTMA", "SIKMA", "BITTI", "DURAKLATILDI"};
7
8Program durum = BEKLEME;
9Program oncekiDurum = BEKLEME;       // duraklatmadan dönmek için / to resume after pause
10unsigned long durumBaslangic = 0;
11unsigned long kalanGecen = 0;        // duraklatıldığında geçen süre / time spent before pause
12
13const unsigned long SURE_SU = 5000, SURE_YIKAMA = 12000, SURE_BOSALTMA = 4000, SURE_SIKMA = 6000;
14
15void cikislar(bool vana, bool motor, bool pompa) {
16  digitalWrite(VANA, vana);
17  digitalWrite(MOTOR, motor);
18  digitalWrite(POMPA, pompa);
19}
20
21void gir(Program yeni) {                             // giriş eylemleri / entry actions
22  durum = yeni;
23  durumBaslangic = millis();
24  Serial.print(F("Durum: "));
25  Serial.println(adlar[yeni]);
26  switch (yeni) {
27    case BEKLEME:      cikislar(0, 0, 0); break;
28    case SU_ALMA:      cikislar(1, 0, 0); break;
29    case YIKAMA:       cikislar(0, 1, 0); break;
30    case BOSALTMA:     cikislar(0, 0, 1); break;
31    case SIKMA:        cikislar(0, 1, 1); break;
32    case BITTI:        cikislar(0, 0, 0); tone(BUZZER, 2000, 800); break;
33    case DURAKLATILDI: cikislar(0, 0, 0); break;
34  }
35}
36
37bool calisiyor() {
38  return durum == SU_ALMA || durum == YIKAMA || durum == BOSALTMA || durum == SIKMA;
39}
40
41void setup() {
42  Serial.begin(9600);
43  pinMode(VANA, OUTPUT);
44  pinMode(MOTOR, OUTPUT);
45  pinMode(POMPA, OUTPUT);
46  pinMode(BUZZER, OUTPUT);
47  pinMode(BASLA, INPUT_PULLUP);
48  pinMode(KAPAK, INPUT_PULLUP);      // kapak kapalı = LOW / lid closed = LOW
49  gir(BEKLEME);
50}
51
52void loop() {
53  static bool oncekiBasla = HIGH;
54  bool basla = digitalRead(BASLA);
55  bool baslaBasildi = (oncekiBasla == HIGH && basla == LOW);   // basma anı / press edge
56  oncekiBasla = basla;
57  bool kapakAcik = digitalRead(KAPAK) == HIGH;
58
59  // Her çalışma durumu için ortak kural: kapak açılırsa duraklat
60  // Common rule for every running state: pause if the lid opens
61  if (calisiyor() && kapakAcik) {
62    oncekiDurum = durum;
63    kalanGecen = millis() - durumBaslangic;
64    gir(DURAKLATILDI);
65    return;
66  }
67
68  unsigned long gecen = millis() - durumBaslangic;
69  switch (durum) {
70    case BEKLEME:
71      if (baslaBasildi && !kapakAcik) gir(SU_ALMA);
72      break;
73    case SU_ALMA:
74      if (gecen >= SURE_SU) gir(YIKAMA);
75      break;
76    case YIKAMA:
77      digitalWrite(MOTOR, (gecen / 2000) % 2 == 0);  // 2 sn çalış, 2 sn dur / 2 s on, 2 s off
78      if (gecen >= SURE_YIKAMA) gir(BOSALTMA);
79      break;
80    case BOSALTMA:
81      if (gecen >= SURE_BOSALTMA) gir(SIKMA);
82      break;
83    case SIKMA:
84      if (gecen >= SURE_SIKMA) gir(BITTI);
85      break;
86    case BITTI:
87      if (gecen >= 3000) gir(BEKLEME);
88      break;
89    case DURAKLATILDI:
90      if (!kapakAcik) {
91        gir(oncekiDurum);                            // kaldığı yere dön / resume
92        durumBaslangic = millis() - kalanGecen;      // kalan süreyi koru / keep remaining time
93      }
94      break;
95  }
96}

A pausa mostra duas técnicas poderosas de máquina de estados. A primeira é uma regra comum: a verificação da tampa é feita em um só lugar, antes do switch, para todos os estados de funcionamento; ela não é escrita em cada case separadamente. A segunda é lembrar o estado anterior: a variável oncekiDurum guarda de qual passo a máquina saiu, e kalanGecen quanto tempo já tinha sido gasto nele. Quando a tampa fecha, a máquina volta ao mesmo estado e a marcação de tempo é recuada pelo tempo já decorrido, para que o passo não recomece do zero. Em um aparelho real, um módulo relé aciona a válvula, o motor e a bomba no lugar dos LEDs.

Este exemplo é só uma simulação com LEDs. Não tente substituir a placa de controle de uma máquina de lavar, aquecedor ou bomba de verdade que funcione na tensão da rede elétrica; a tensão da rede é perigosa para a vida e também traz risco de incêndio.

Rodando várias máquinas de estados ao mesmo tempo

Como você viu no exemplo do menu, cada tarefa independente pode ser sua própria máquina de estados. Uma boa organização é colocar cada máquina em sua própria função e simplesmente chamar essas funções em sequência dentro do loop(): trafikGuncelle(), butonGuncelle(), ekranGuncelle() e assim por diante. Como nenhuma função espera, o loop dá uma volta a cada poucos microssegundos e todas as máquinas parecem rodar ao mesmo tempo. As máquinas se comunicam por variáveis compartilhadas: a máquina do menu altera hizMs e a máquina do LED lê esse valor. Essa é a forma mais simples de fazer multitarefa em um Arduino sem um sistema operacional de verdade. Uma máquina não deve mudar diretamente o estado de outra; em vez disso, ela deve deixar uma variável de pedido, como acontece com o pedido de pedestre.

  • Use uma variável de estado e uma marcação de tempo por máquina; não compartilhe entre máquinas.
  • Manter a variável de estado como static dentro da função ou em uma struct própria daquela máquina evita conflitos de nomes.
  • Deixe que a máquina que trata um pedido (como yayaIstegi) seja a que o apaga.
  • Ao depurar, escreva o nome do estado no Monitor Serial a cada mudança de estado; você vai ver na hora onde o programa trava.

Máquinas de estados em MicroPython no Raspberry Pi Pico

O MicroPython não tem enum; você define os estados como números constantes ou strings. Graças aos dicionários do Python, é muito fácil escrever a máquina de estados totalmente orientada por tabelas: as luzes, a duração e o próximo estado de cada estado ficam em dicionários separados, e o laço decide consultando essas tabelas. Para adicionar um novo estado, você acrescenta uma linha às tabelas, não ao código. Para a temporização, você usa time.ticks_ms() e time.ticks_diff(); o ticks_diff dá a diferença correta mesmo quando o contador dá a volta. No código abaixo, os LEDs estão em GP13 (vermelho), GP12 (amarelo) e GP11 (verde), e o botão de pedestre está em GP4. Se você está começando com MicroPython, comece pelo artigo fundamentos de MicroPython.

MicroPython
1# Raspberry Pi Pico MicroPython: tablo tabanlı trafik lambası durum makinesi
2# Table-driven traffic light state machine
3from machine import Pin
4import time
5
6kirmizi = Pin(13, Pin.OUT)
7sari = Pin(12, Pin.OUT)
8yesil = Pin(11, Pin.OUT)
9buton = Pin(4, Pin.IN, Pin.PULL_UP)
10
11KIRMIZI, KIRMIZI_SARI, YESIL, SARI = 0, 1, 2, 3      # durumlar / states
12ADLAR = ("KIRMIZI", "KIRMIZI_SARI", "YESIL", "SARI")
13LAMBALAR = {KIRMIZI: (1, 0, 0), KIRMIZI_SARI: (1, 1, 0), YESIL: (0, 0, 1), SARI: (0, 1, 0)}
14SURE = {KIRMIZI: 5000, KIRMIZI_SARI: 1500, YESIL: 10000, SARI: 2000}
15SONRAKI = {KIRMIZI: KIRMIZI_SARI, KIRMIZI_SARI: YESIL, YESIL: SARI, SARI: KIRMIZI}
16
17durum = KIRMIZI
18baslangic = time.ticks_ms()
19yaya_istegi = False
20
21def gir(yeni):
22    global durum, baslangic, yaya_istegi
23    durum = yeni
24    baslangic = time.ticks_ms()
25    k, s, y = LAMBALAR[yeni]
26    kirmizi.value(k)
27    sari.value(s)
28    yesil.value(y)
29    if yeni == KIRMIZI:
30        yaya_istegi = False          # yayalar geçer / pedestrians cross
31    print("durum:", ADLAR[yeni])
32
33gir(KIRMIZI)
34while True:
35    if buton.value() == 0:
36        yaya_istegi = True
37    gecen = time.ticks_diff(time.ticks_ms(), baslangic)   # taşmaya dayanıklı / overflow safe
38    sure = SURE[durum]
39    if durum == YESIL and yaya_istegi:
40        sure = 4000
41    if gecen >= sure:
42        gir(SONRAKI[durum])
43    time.sleep_ms(10)

Erros comuns e como resolver

ErroSintomaSolução
delay() dentro de um estadoOs botões e as outras máquinas travamVerifique o tempo decorrido com millis() em vez de esperar
Esquecer o breakO código de um estado executa também o do seguinteTermine todo case com break
Não zerar a marcação de tempoO novo estado termina na hora ou nuncaFaça todas as transições por uma única função durumDegistir()
Olhar o nível do botãoUm aperto causa várias transiçõesCapture o momento do aperto e aplique debounce
Executar a ação de entrada repetidamente dentro do estadoO Monitor Serial lota, o buzzer apita sem pararMova o que deve ser feito uma vez para a ação de entrada
Um estado sem saídaO programa fica preso em um estado para sempreConfira se pelo menos uma seta sai de cada estado no diagrama
Escrever a comparação do millis() com somaA temporização falha depois de 49,7 diasUse sempre a forma millis() - start >= duration (com subtração)
Se o número de estados começar a passar de 8–10, pense em dividir a máquina: por exemplo, na máquina de lavar, “seleção do programa” e “execução do programa” poderiam ser duas máquinas separadas. Máquinas pequenas que conversam por variáveis de pedido são muito mais fáceis de entender do que uma máquina gigante.

Ideias de projetos com máquinas de estados

  • Cofre com senha: uma fechadura com teclado matricial e servo, com os estados KILITLI (trancado), SIFRE_GIRILIYOR (digitando a senha), ACIK (aberto) e ALARM; uma senha errada faz o buzzer tocar no estado ALARM.
  • Jogo da memória Simon: um jogo que mostra uma sequência de LEDs ao jogador e monitora os botões, com os estados GOSTER (mostrar), BEKLE (esperar), KONTROL (verificar) e KAYBETTIN (perdeu).
  • Luz de escada inteligente: iluminação com os estados BOS (ocioso), YANIYOR (aceso) e SONUYOR (apagando) que acende ao detectar movimento e apaga devagar quando o tempo acaba.
  • Teste de reação: um jogo com os estados HAZIR (pronto), RASTGELE_BEKLE (espera aleatória), OLC (medir) e SONUC (resultado) que mede o tempo de reação em milissegundos.
  • Robô que recebe comandos pela serial: um veículo com os estados DUR (parar), ILERI (frente), DON (virar) e ENGEL (obstáculo) que reage a sensores e comandos ao mesmo tempo.

Uma máquina de estados transforma cada projeto Arduino que você escreve em um código mais organizado, que responde mais rápido e cresce com mais facilidade. No app BlueGrays você encontra projetos como semáforo, controle de LED com botão, contador com display de 7 segmentos, fechadura com senha no teclado matricial, o jogo Simon e um semáforo de quatro modos com o Raspberry Pi Pico, cada um com esquema do circuito e código passo a passo; aplique neles a estrutura de máquina de estados deste guia.

Perguntas frequentes

O que é uma máquina de estados no Arduino?

Uma máquina de estados é uma estrutura de código que divide o programa em um número limitado de estados e fica em apenas um deles de cada vez. Em cada estado fica claro o que fazer e em qual condição passar para outro estado. No Arduino ela costuma ser escrita com enum, switch-case e millis().

Como usar enum no Arduino?

Você define assim: enum Durum { BEKLE, CALIS, BITTI }; e cria uma variável com Durum durum = BEKLE;. O compilador transforma os nomes em números como 0, 1, 2, mas no código você usa nomes com significado. A definição do enum precisa ficar no topo do arquivo, antes das funções.

Como escrever uma máquina de estados com switch-case?

Coloque a variável de estado em switch(durum) e escreva um bloco case para cada estado. Em cada bloco, verifique a condição de saída daquele estado e mude o estado se ela for atendida. Não esqueça de colocar break no fim de cada case.

Como esperar no Arduino sem usar delay?

Guarde em uma variável o momento em que você entra em um estado com millis() e verifique a condição millis() - start >= duration a cada ciclo do loop. Se o tempo não acabou, o loop segue na hora, então as outras tarefas não ficam travadas. Esse método também funciona corretamente quando o millis() estoura.

O Arduino consegue fazer várias coisas ao mesmo tempo?

O Arduino Uno tem um único núcleo, então ele não faz as coisas realmente ao mesmo tempo, mas com máquinas de estados sem bloqueio ele as executa em sequência milhares de vezes por segundo, de modo que parecem simultâneas. Basta colocar cada tarefa em sua própria função e chamá-las em sequência dentro do loop().

Como escrever uma máquina de estados em MicroPython?

O MicroPython não tem enum, então os estados são definidos como números constantes. Uma estrutura orientada por tabelas, que guarda em dicionários a duração, as saídas e o próximo estado de cada estado, é muito prática. Para a temporização, você usa time.ticks_ms() e time.ticks_diff().

Ver todos os projetos
Semáforo
AR-3Iniciante

Semáforo

Uma pequena versão do semáforo que você vê na rua todos os dias. O vermelho fica aceso por dois segundos, o amarelo acende por um instante, o verde fica aceso por dois segundos e depois volta ao…

4.8(137)
440
Ligar e desligar um LED com botão
AR-10Iniciante

Ligar e desligar um LED com botão

Pressione o botão uma vez para acender a luz e outra vez para apagar, como o interruptor do seu quarto.

4.7(103)
177
Semáforo com ESP32
ES-5Iniciante

Semáforo com ESP32

Simulação de um semáforo real com 3 LEDs: vermelho, amarelo e verde. Os tempos se aproximam da lógica real: vermelho longo, amarelo curto e verde longo. Um exemplo clássico de controle sequencial de GPIOs.

4.4(22)
45
Raspberry Pi Pico: semáforo (3 LEDs em sequência)
PI-4Iniciante

Raspberry Pi Pico: semáforo (3 LEDs em sequência)

Simulamos um semáforo real com LEDs vermelho, amarelo e verde — o primeiro projeto com 3 LEDs da série Pico! Verde por 4 segundos: "siga"; amarelo por 1,5 segundo: "prepare-se"; vermelho por 3 segundos: "pare"; e vermelho+amarelo por 1 segundo: "saída" (padrão de semáforo europeu). Aprenda definição de funções (def all_off()), lógica de máquina de estados (sequência) e sincronização de vários GPIOs.

4.0(1)
12
Raspberry Pi Pico: semáforo com 4 modos selecionados por botão (máquina de estados)
PI-12Intermediário

Raspberry Pi Pico: semáforo com 4 modos selecionados por botão (máquina de estados)

Com um único botão, você alterna entre 4 modos de semáforo: ciclo normal (vermelho, amarelo e verde em sequência), só vermelho (parada), amarelo piscante (atenção ou modo noturno) e desligado (manutenção). Você aprende a usar uma máquina de estados, em que a variável mode define o comportamento, e a girar entre os modos com (mode + 1) % 4. O Raspberry Pi Pico mantém as luzes funcionando sem perder nenhum toque no botão.

5.0(1)
16
Contador com display de 7 segmentos e botões
AR-43Avançado
Premium

Contador com display de 7 segmentos e botões

Um contador simples com três botões: ao pressionar um deles, o algarismo no display aumenta em um; com outro, diminui em um; e o terceiro zera a contagem.

4.6(35)
47
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75
Jogo da memória com Arduino (4 LEDs + 4 botões + buzzer)
AR-93Avançado
Premium

Jogo da memória com Arduino (4 LEDs + 4 botões + buzzer)

Você confia na sua memória? Quatro LEDs coloridos acendem em sequência, cada um tocando sua própria nota, e você repete a mesma ordem apertando os botões.

4.8(46)
69