Aulas e o jogo de aprendizado

C multiarquivo: headers, macros e compilações

O que acontece entre apertar Rodar e um programa no chip, e cada armadilha no caminho de um arquivo a cinquenta.

Como funciona

Multi-file C: headers, macros and builds follows C do zero. Seis aulas rodam na bancada de código: um Arduino Uno com uma lâmpada vermelha no pino 13, amarela no 12, verde no 11 e um botão no pino 2. O projeto passa para um ESP32-C3.

Cada aula abre um sketch de um arquivo funcionando. Você roda, lê o monitor serial e depois o expande: você mesmo adiciona o segundo e o terceiro arquivo pela barra de abas (fuel.cpp, rover.h, telemetry.cpp, config.h), e as verificações leem o que a placa imprime assim que seus arquivos compilam e linkam. Várias etapas pedem que você quebre a compilação de propósito primeiro, para conhecer cada erro do linker sabendo exatamente o que o causou.

As aulas

  1. Muitos arquivos, um programa: pré-processar, compilar cada arquivo por conta própria, linkar. Declarações versus definições, um segundo arquivo, e o undefined symbol que aparece quando dois arquivos não concordam.
  2. Headers e guards: um rover dividido em rover.h e rover.cpp, o que um #include realmente cola, um header lido duas vezes e a guard que impede isso, e por que o corpo de uma função num header precisa de inline.
  3. Macros e suas armadilhas: um quadrado que esquece os parênteses, um máximo que lê um sensor duas vezes, # e do { } while (0), e quando uma função faz o trabalho melhor.
  4. Compilação condicional: #if e #ifdef, linhas de depuração que não custam nada quando desligadas, um portão de versão, o chip para o qual a compilação é feita, e um padrão que um projeto pode sobrescrever.
  5. extern e static: ligação e tempo de vida. Uma global que outro arquivo alcança com extern, static em nível de arquivo que mantém um nome privado, e uma static local que lembra.
  6. Flags de compilação: um sketch que lê sua própria compilação (-std, -mmcu, -Os, -fno-exceptions), um header de configuração no lugar de flags -D, e o linker jogando fora código que nada chama, medido no log de compilação.

O projeto: uma base de código para duas placas

Um farol que compila sem mudanças para o Uno e o ESP32-C3. O mesmo arquivo imprime int is 2 bytes num e int is 4 bytes no outro, e a mesma soma dá 0 no Uno e 65536 no C3. Você torna a soma portátil com uint16_t, move cada diferença de placa para um board.h com guard, e depois o torna seu: uma terceira placa, uma flag de recurso, ou um header de depuração.

O que as placas fazem diferente

  • O compilador do Uno define __AVR__ e o do C3 define __riscv. O curso testa esses, porque o compilador os define em toda compilação; os nomes próprios da compilação do Arduino, como ARDUINO_AVR_UNO, vêm por cima.
  • Um int tem 2 bytes no Uno e 4 no C3, um ponteiro o mesmo, e um double tem só 4 bytes no Uno.
  • No Uno uma string é copiada para a RAM na inicialização, então texto custa RAM além de flash. O log de compilação mostra os dois.
  • O Rodar do Mokxi, como a IDE do Arduino, usa um conjunto fixo de flags de compilador (-Os, C++17, sem exceções). Projetos definem suas próprias opções num header de configuração incluído primeiro, o que funciona igual com qualquer ferramenta de compilação.

Depois deste curso

C++ moderno para microcontroladores substitui muitas dessas macros por constexpr, enum class e templates, e Ponteiros e memória em C se aprofunda no que o linker coloca em cada lugar na RAM.