Aulas e o jogo de aprendizado

Concorrência: tarefas, corridas e async

Como um chip pequeno faz muitas coisas ao mesmo tempo, ensinado em um Raspberry Pi Pico em MicroPython, com cada corrida medida de verdade.

Comece o curso. É um curso avançado: você deve estar confortável com funções, listas e globais em Python.

A caixa

Cada aula usa um circuito:

  • Um Raspberry Pi Pico rodando o firmware oficial do MicroPython.
  • Um botão no GP15 e um LED no GP14.
  • Um potenciômetro no GP26, o primeiro pino ADC.
  • Um componente de relógio no GP16 que tiqueja 1.000 vezes por segundo, no lugar de um sensor de roda, então as interrupções chegam com regularidade enquanto o programa faz outro trabalho.

Aula por aula

  1. Fazendo duas coisas. Por que um único sleep() deixa um botão surdo, e o superloop que resolve: marcas de tempo, ticks_diff, prazos que nunca atrasam e um botão com debounce.
  2. Corridas de interrupção. Uma interrupção de pino conta a roda. Coloque 1,8 ms de suavização do potenciômetro entre ler e zerar a contagem, e um contador árbitro mostra tiques desaparecendo, enquanto as leituras de velocidade parecem perfeitamente bem.
  3. Seções críticas. Encolher a janela e por que isso só torna o bug mais raro. machine.disable_irq() e enable_irq() a fecham de vez. Depois, a regra que os handlers pesados seguem: nada de nova memória, mostrado por um MemoryError real, e micropython.schedule para tirar a parte pesada de lá.
  4. Corrotinas. Geradores como tarefas que pausam, um escalonador round-robin à mão, depois um em que as tarefas entregam quanto tempo dormir: o motor dentro de todo event loop.
  5. asyncio no MicroPython. Tarefas com async e await, o erro bloqueante que congela todas (medido como um heartbeat atrasado), e uma interrupção hard acordando uma tarefa por meio de ThreadSafeFlag.
  6. Filas. Um buffer circular que uma interrupção pode encher sem alocar, o bounce de contato gravado borda a borda, um consumidor lento demais para acompanhar, lotes, e uma classe de fila com contrapressão, já que o asyncio do MicroPython não tem Queue.
  7. Chefe: uma caixa multi-sensor responsiva.

O gran final

A caixa vigia a roda, o botão e o knob ao mesmo tempo. Uma interrupção hard conta os tiques e uma tarefa os coleta numa seção crítica, o knob é suavizado em fatias que nunca monopolizam o chip, o botão acorda sua tarefa por meio de uma flag, um alarme e um heartbeat rápido disparam em excesso de velocidade, e uma tarefa watchdog mede o pior atraso. O último passo é uma revisão de projeto: para cada variável compartilhada, diga quem escreve, quem lê e por que ela é segura.

Como o motor do Pico é diferente

O Pico inicia o firmware real do MicroPython v1.29 num RP2040 simulado, então interrupções, o heap travado e o asyncio se comportam como numa placa de verdade. O que é diferente:

  • É exato. O simulador é determinístico, então uma corrida perde o mesmo número de ticks a cada execução. No hardware a contagem oscila, e é isso que torna as corridas tão difíceis de capturar. As aulas avisam isso onde importa.
  • Um núcleo. O núcleo 1 não é simulado, então _thread para a placa. O curso cobre concorrência em um núcleo, interrupções e tarefas cooperativas, que é o que a maioria dos firmwares usa.
  • Sem PIO ou DMA nas aulas. Tudo é feito pela CPU e suas interrupções.
  • O curso é só para o Pico. O mesmo código MicroPython roda em um ESP32 com números de pinos diferentes.

Para onde ir agora

Jogos em MicroPython numa telinha é a forma suave de continuar na mesma placa. RTOS e temporização leva o multitarefa preemptivo mais longe.