Aulas e o jogo de aprendizado

C embarcado que sobrevive

As regras de C que mantêm um chip de 2 KB vivo, cada uma quebrada no Uno e depois corrigida: tipos de largura fixa, volatile, flash, comportamento indefinido e estilo MISRA.

A bancada

Cada aula abre um circuito: um Uno com um botão no pino 2 (interrupção INT0, configurada sem bounce), uma lâmpada vermelha no pino 13 e um botão giratório no A0.

Faça o curso em Embedded C that survives no /learn.

O que cada sketch faz

  • ecdtypes imprime o tamanho de um int (2 bytes), faz overflow de cinco minutos em milissegundos para -27680, dá a volta num contador uint8_t e mede um intervalo atravessando o wrap do millis().
  • ecdvolatile define uma flag pela interrupção do botão que loop() nunca enxerga até a flag ser volatile, e lê um contador de 4 bytes com as interrupções desligadas.
  • ecdflash imprime um texto de ajuda e sua SRAM livre (1485 bytes), lê uma tabela de seno da PROGMEM e recupera 308 bytes quando o texto é envolvido em F().
  • ecdub escreve um elemento além do array, no limite de alarme ao lado, e desloca um 1 para o bit de sinal de um int de 16 bits.
  • ecdheap constrói um log com String até concat() falhar na linha 120, ou num buffer fixo que nunca toca o heap.
  • ecdrules é um interpretador de comandos de aquecedor escrito segundo regras estilo MISRA, dirigido digitando SET e GET no monitor serial.
  • ecdboss é um sketch de telemetria de CubeSat com três bugs para encontrar e corrigir: um overflow, um volatile faltando e um estouro de buffer de um byte.

Por que os bugs são reais aqui

O Uno roda as mesmas instruções AVR que um real roda, compilado pelo clang em -Os com avisos tratados como erros. Então o int realmente tem 16 bits, o volatile faltando realmente deixa a flag num registrador, os literais realmente são copiados para a SRAM, e o heap realmente enche. Onde o compilador já pegaria um bug (um overflow de constantes, um índice constante além do array, um switch de enum que esquece um case) os sketches o escondem atrás de uma variável, como bugs reais se escondem.

Limites honestos

  • Comportamento indefinido depende do compilador e de suas configurações. Os resultados aqui são o que este compilador faz; outro compilador, ou outro nível de otimização, pode fazer algo totalmente diferente, e é esse o ponto.
  • Os números de regras MISRA citados são os da MISRA C:2012. O padrão em si é um documento pago; o curso informa o que cada regra pede, não o seu texto exato.
  • O alocador de heap do Mokxi mescla vizinhos livres e escolhe o melhor encaixe, então a fragmentação é mais branda que com alguns alocadores; ainda assim, o log com String estoura a memória em cerca de dois segundos.

C from zero for the language itself, and Registers and assembly for what the compiler turns it into.