Escala 5 a 1

O plano de aprendizagem de um programador embebido tem de espelhar a lista de materiais. Aprendemo-lo da forma difícil ao implementar um nó de monitorização de solo alimentado a energia solar, construído sobre ESP32, back-haul celular SIMCom e AWS IoT Core: firmware, hardware, ligações de rádio e workflows de cloud tiveram todos de se juntar ao mesmo tempo, e saltar uma única peça transformou um ajuste de firmware “rápido” em semanas de depuração.

Para manter esse plano focado, classificamos cada competência numa escala de 5 a 1 — um framework completamente agnóstico de tecnologia:

Como aplicá-la em qualquer lado

1. Defina o objetivo final. Como é “pronto para o trabalho” ou “pronto para produção”?
2. Liste os 5s. O kit de sobrevivência absoluto.
3. Identifique os 4s. Práticas que blindam e escalam a solução.
4. Preencha os 3s. Ferramentas de qualidade de vida e otimizações.
5. Adicione os 2s e 1s. Profundidade especializada para equipas maiores ou funcionalidades avançadas.

Prova rápida de que viaja bem

• Front-End Web Dev → 5s: HTML/CSS, JS moderno, Git… • 4s: React/Vue, TypeScript, Jest, CI/CD… • 3s: Storybook, testes e2e… • 2s: PWAs, animações… • 1s: WebGL, data-viz.
• Data Science / MLOps → 5s: Python, NumPy/Pandas, estatística… • 4s: TensorFlow/PyTorch, Docker, testes unitários… • 3s: Feature stores, MLflow… • 2s: Inferência edge… • 1s: Federated learning.

Ao classificar o impacto e a frequência de cada tópico, define um caminho claro e evita a sobrecarga.

Como são os 5s para a nossa stack ESP32 + SIM + AWS

1. Fluência em C/C++ – a linguagem do ESP-IDF e dos hooks do FreeRTOS.
2. Domínio do ESP-IDF (ou Arduino-ESP32) – APIs de Wi-Fi, BLE, ADC e deep-sleep.
3. Fundamentos de eletrónica – level-shifting de UARTs SIM, leitura de sondas NPK, higiene de EMI.
4. Orçamentação de energia e carregamento Li-ion/solar – manter uma 18650 de 4 Ah viva durante semanas nubladas.
5. Conectividade robusta (Wi-Fi, SIM AT, MQTT/TLS) – canalizar dados de sensores de forma segura para a AWS.

Domine estes cinco e consegue lançar um protótipo funcional. Suba aos 4s — pipelines de CI, FreeRTOS avançado, OTA, segurança — e terá um produto que sobrevive ao campo. Os 3s, 2s e 1s completam o toolkit profissional com dashboards, conformidade e profundidade específica de domínio.

O artigo que se segue não é uma checklist; é um roadmap sequencial mapeado a escolhas de hardware reais. Comece pelos 5s, avance pelos 4s, e quando entrar em território de 3 a 1 terá tanto a confiança como o contexto para os aplicar onde mais importam, da breadboard à produção.

Competências para Programadores Embebidos

Legenda – Importância
5 = Indispensável (obrigatório para o trabalho do dia a dia)
4 = Muito importante (necessário na maioria dos projetos)
3 = Útil (ajuda frequente, aprender em breve)
2 = Nice-to-have (aprender quando o tempo permitir)
1 = Especializado / situacional

Como ler a tabela

• Comece pelos 5s: proficiência na linguagem, SDK do microcontrolador, fundamentos de hardware, design do sistema de energia, know-how de sensores e comunicações celulares são decisivos para um dispositivo de campo fiável.
• Ataque os 4s a seguir: ambiente de desenvolvimento, otimização de energia, OTA, RTOS e segurança transformam um protótipo funcional num produto pronto para produção.
• Os 3s completam o workflow profissional (CI, testes unitários, back-ends cloud, CAD de PCB).
• Os 2s e 1s acrescentam profundidade para equipas maiores ou funcionalidades avançadas e podem ser adiados se o prazo apertar.
• Use isto como um roadmap de competências: avance da esquerda para a direita na escala de importância à medida que o projeto amadurece.

1 – C/C++

Nível: 1 – Principiante Absoluto
– Sintaxe e estrutura de C: modelo de compilação (source → object → executável), função main()
– Tipos de dados básicos: int, char, float, double, bool
– Variáveis e constantes: declaração, inicialização, qualificador const
– Operadores: aritméticos (+, –, *, /, %), atribuição, incremento/decremento
– Controlo de fluxo: if/else, switch, ciclos for/while/do-while
– I/O simples: printf, saída básica para consola
– Introdução a ponteiros: declaração de ponteiros, desreferenciação
– Build e depuração: compilar com gcc -o, interpretar erros básicos do compilador

Nível: 2 – Principiante
– Memória e ponteiros: aritmética de ponteiros, ponteiros vs. arrays, introdução a malloc/free
– Tipos estruturados: struct, union, typedef
– Fundamentos do pré-processador: #define, #include, include guards
– Classes de armazenamento: auto, static, extern, regras de âmbito e linkage
– Strings e arrays: char[], funções de strings (strcpy, strlen, etc.)
– Código modular: divisão em múltiplos ficheiros .c/.h, fundamentos de makefile (regras, targets)
– Ferramentas básicas de depuração: stepping no gdb, breakpoints, inspeção de variáveis

Nível: 3 – Intermédio
– Gestão de memória dinâmica: heap vs. stack, padrões comuns de leak, uso de ferramentas como o Valgrind
– I/O de ficheiros: fopen/fread/fwrite/fclose, ponteiros de ficheiro, tratamento de erros
– Operações bitwise: máscaras, shifts, set/clear de bits, enum e bit-fields
– Ponteiros de função: callbacks, tabelas de dispatch
– Tratamento de erros: códigos de retorno, errno
– Fundamentos de C++: classes e objetos, construtores/destrutores, especificadores de acesso
– Fundamentos da STL: std::vector, std::string, uso simples de std::map e iteradores
– Namespaces e organização de headers

Nível: 4 – Avançado
– Especificidades de C embebido: volatile, I/O mapeado em memória, const em flash vs. RAM
– Linker e sistema de build: linker scripts personalizados, colocação de secções, flags de otimização (-O2, -Os), toolchains de cross-compilação
– Funcionalidades de C++11/14/17: lambdas, auto, range-based for, constexpr, nullptr
– Smart pointers e RAII: unique_ptr, shared_ptr, gestão de recursos
– Fundamentos de templates: templates de função e de classe, especialização de templates
– Multithreading: std::thread, mutexes, variáveis de condição, tipos atómicos
– Conceitos de tempo real: interrupt service routines (ISRs), secções críticas, mitigação de inversão de prioridade

Nível: 5 – Especialista
– Metaprogramação avançada de templates: templates variádicos, SFINAE, type traits
– Modelo de objetos de C++ em profundidade: vtables, layout de objetos, considerações de ABI
– Concorrência lock-free e de baixa latência: atómicas, ordenações de memória, algoritmos wait-free
– Internos de compilador e toolchain: pipelines de passes do GCC/Clang, escrita de plugins de compilador personalizados
– Otimização de desempenho: alinhamento de cache, branch prediction, profiling em profundidade (por ex. gprof, contadores de hardware)
– Porting bare-metal: implementação de stubs newlib, runtime C mínimo, código de bring-up
– Normas e segurança: conformidade MISRA-C/C++, ferramentas de análise estática (Coverity, Cppcheck)
– Contribuição para frameworks: escrita/otimização de drivers para os internos do FreeRTOS ou ESP-IDF

2 – ESP-IDF (nativo) ou Arduino-ESP32

Nível: 1 – Principiante Absoluto
– Instalar a toolchain ESP-IDF (Python, Git, scripts ESP-IDF) ou o core Arduino-ESP32
– Configurar o VS Code (ou Arduino IDE) para desenvolvimento ESP32
– Compilar e flashar o exemplo “blink”
– Explorar a estrutura do projeto (CMakeLists.txt, sdkconfig ou platformio.ini)
– Usar comandos básicos do idf.py (ou Arduino): build, clean, flash, monitor

Nível: 2 – Principiante
– GPIO: configurar pinos, ler entradas, controlar LEDs
– ADC: amostrar canais analógicos, converter valores raw para tensão
– UART e I²C: enviar/receber strings ou bytes simples
– Modo Wi-Fi station: fazer scan de APs, ligar, obter IP
– Periférico BLE: fazer advertise, ligar a partir de uma app de telemóvel
– Ajustar o menuconfig (tabela de partições, nível de log) ou as definições de placa do Arduino

Nível: 3 – Intermédio
– Tasks, queues e timers do FreeRTOS no framework ESP-IDF
– API de eventos Wi-Fi: tratar connect/disconnect, lógica de reconexão
– Cliente BLE e GATT: descobrir serviços, ler/escrever characteristics
– SPI e I²C: integrar e calibrar um sensor real (por ex. humidade do solo)
– Atualizações OTA por HTTP(S): configurar partições, desencadear atualizações
– Usar esp_timer, logging detalhado (ESP_LOG*) e códigos de erro

Nível: 4 – Avançado
– Criar componentes reutilizáveis (CMake Component API) ou bibliotecas Arduino personalizadas
– Construir uma tabela de partições personalizada e trocar partições em runtime
– Provisionamento seguro: SmartConfig, configuração de Wi-Fi via BLE
– Exemplos avançados de BLE (L2CAP, mesh)
– Otimizar definições de velocidade/timeout dos barramentos SPI DMA e I²C
– Integrar mbedTLS para MQTT sobre TLS
– Automatizar build/flash/testes em CI (GitHub Actions, scripts de CI do ESP-IDF)

Nível: 5 – Especialista
– Contribuir novos drivers ou corrigir bugs no core do ESP-IDF (por ex. calibração do ADC)
– Desenvolver bootloader personalizado ou otimizações ao nível de ISR
– Afinar regiões de heap do FreeRTOS e parâmetros do scheduler
– Implementar secure boot e encriptação de flash de ponta a ponta
– Fazer tracing e profiling em tempo real (ESP-Trace, Perfcnt)
– Arquitetar workspaces CMake multi-projeto
– Mentorar outros: definir boas práticas de ESP-IDF e bibliotecas de componentes internas

3 – Fundamentos de FreeRTOS

Nível: 1 – Principiante Absoluto
– Perceber o que é um RTOS e porque usaria um
– Instalar o FreeRTOS (via ESP-IDF ou PlatformIO) e inspecionar o exemplo demo de task “hello world”
– Aprender a API básica para criar e arrancar uma única task (xTaskCreate, vTaskStartScheduler)
– Explorar o tick de sistema e como o scheduler alterna entre tasks
– Usar vTaskDelay para bloquear uma task por um tempo fixo

Nível: 2 – Principiante
– Criar múltiplas tasks com diferentes prioridades e tamanhos de stack
– Usar vTaskDelayUntil para temporização periódica de tasks
– Compreender e aplicar secções críticas (taskENTER_CRITICAL / taskEXIT_CRITICAL)
– Aprender os estados das tasks (Running, Ready, Blocked, Suspended)
– Usar vTaskSuspend / vTaskResume para controlo simples de tasks

Nível: 3 – Intermédio
– Comunicar entre tasks com queues (xQueueCreate, xQueueSend, xQueueReceive)
– Sincronizar tasks com semáforos binários e contadores (xSemaphoreCreateBinary, xSemaphoreTake)
– Coordenar eventos com Event Groups (xEventGroupSetBits, xEventGroupWaitBits)
– Usar software timers (xTimerCreate, callback)
– Detetar e tratar stack overflows

Nível: 4 – Avançado
– Otimizar a alocação de memória: escolher e configurar esquemas de heap (heap_1…heap_5) e compreender a fragmentação
– Empregar task notifications como semáforos binários leves ou mensagens de dados diretas para a task
– Configurar e usar o modo tickless idle para aplicações de baixo consumo
– Gerar e interpretar estatísticas de runtime (vTaskGetRunTimeStats)
– Integrar FreeRTOS+Trace ou Percepio Tracealyzer

Nível: 5 – Especialista
– Portar o FreeRTOS para hardware personalizado ou modificar a camada de port para casos de uso avançados
– Implementar e afinar políticas de scheduler personalizadas ou hook functions (vApplicationIdleHook, vApplicationMallocFailedHook)
– Desenhar máquinas de estado complexas com primitivas avançadas de sincronização (mutexes com herança de prioridade, mutexes recursivos)
– Mentorar equipas em boas práticas, segurança (código conforme MISRA) e afinação de comportamento determinístico

4 – Git & GitHub/GitLab

Nível: 1 – Principiante Absoluto
– Instalar o Git; configurar user.name e user.email
– Inicializar um repositório (git init) e clonar repositórios existentes (git clone)
– Tracking básico de ficheiros: git status, git add, git commit
– Ver o histórico com git log, inspecionar alterações com git diff
– .gitignore simples para excluir ficheiros

Nível: 2 – Principiante
– Criar e trocar branches: git branch, git checkout/git switch
– Configuração de remotes: git remote add, git fetch, git pull, git push
– Compreender origin/main vs branches locais
– Resolver conflitos de merge simples via editor ou CLI
– Usar a web UI do GitHub/GitLab para navegar commits e branches

Nível: 3 – Intermédio
– Merge vs rebase: git merge, git rebase; saber quando usar cada um
– Rebase interativo (git rebase -i) para limpar commits
– Tagging: criar tags anotadas e leves; enviar com git push –tags
– Trabalhar com pull requests (GitHub) ou merge requests (GitLab): criar, rever, fazer merge
– Stub básico de CI: adicionar um YAML simples de GitHub Actions ou GitLab CI

Nível: 4 – Avançado
– Gerir submódulos (git submodule) e subtrees
– Escrever hooks do lado do cliente (pre-commit, pre-push) e hooks simples do lado do servidor GitLab/GitHub
– Proteger branches e impor verificações de merge (status checks, aprovações)
– Construir pipelines de CI/CD multi-stage com caching e artifacts
– Usar git bisect para localizar bugs; cherry-pick de commits específicos

Nível: 5 – Especialista
– Administrar definições de organização GitLab/GitHub: permissões de utilizador/grupo, branches protegidos
– Arquitetar estratégias de monorepo; gerir ficheiros grandes com Git LFS
– Desenvolver ferramentas ou scripts Git personalizados (libgit2, hooks, automação)
– Mergulho profundo nos internos do Git: object storage, packfiles, refs, index
– Definir e impor workflows (Gitflow, trunk-based, GitOps); mentorar a equipa em boas práticas

5 – VS Code

Nível: 1 – Principiante Absoluto
Tópicos:

• Instalar o VS Code no Windows, macOS ou Linux
• Explorar a UI: Activity Bar, Side Bar, Editor Panes, Status Bar
• Abrir pastas e ficheiros; edição básica de texto (tabs, split views)
• Usar o terminal integrado para correr comandos shell
• Invocar a Command Palette (Ctrl+Shift+P) para ações comuns
• Fazer Find & Replace simples (Ctrl+F / Ctrl+H)

Nível: 2 – Principiante
Tópicos:

• Descobrir e instalar extensões: C/C++ (ms-vscode.cpptools), ESP-IDF, Arduino-ESP32, PlatformIO IDE
• Personalizar definições de User vs Workspace via settings.json
• Usar a vista integrada de Source Control: stage, commit, push/pull
• Configurar Tasks básicas (tasks.json) para compilar e flashar um “Hello World” no ESP32
• Navegar código com as vistas Outline e Breadcrumbs
• Inserir e usar code snippets simples

Nível: 3 – Intermédio
Tópicos:

• Configurar o IntelliSense: definir include paths e macros em c_cpp_properties.json
• Criar configurações de launch (launch.json) para depuração GDB via OpenOCD ou JTAG
• Definir Tasks compostas: build → flash → monitor → lint
• Trabalhar em workspaces multi-root (código + docs + testes)
• Integrar linters e formatters (clang-format, cppcheck) como ações pré-gravação
• Depurar tasks FreeRTOS com depuração thread-aware e a vista Debug
• Usar o painel Problems e o Test Explorer para testes unitários

Nível: 4 – Avançado
Tópicos:

• Aproveitar o Remote Development: workspaces SSH, WSL e contentores Docker
• Criar e partilhar code snippets e templates de ficheiros personalizados para ESP-IDF/PlatformIO
• Automatizar CI: exportar VS Code Tasks para pipelines de GitHub Actions ou GitLab CI
• Personalizar keybindings e usar o Settings Sync para partilhar configuração entre máquinas
• Desenvolver Task Providers reutilizáveis via a VS Code Tasks API
• Usar breakpoints condicionais e de função, logpoints e watch expressions

Nível: 5 – Especialista
Tópicos:

• Desenvolver e publicar extensões completas de VS Code (TypeScript e Extension API) para workflows ESP32
• Arquitetar grandes workspaces multi-projeto com configurações partilhadas e versionadas
• Otimizar o desempenho do IDE: afinar a ativação de extensões, reduzir o tempo de arranque e o uso de memória
• Implementar distribuição de definições à escala empresarial (Settings Cycler, deployment baseado em GPO)
• Mentorar colegas em boas práticas de VS Code e resolver workflows complexos
• Contribuir para a comunidade VS Code: escrever guias, repositórios de exemplo e falar em meetups ou workshops

6 – PlatformIO

Nível: 1 – Principiante Absoluto
Tópicos:

• Instalar a extensão PlatformIO IDE no VS Code (ou instalar o PIO Core CLI)
• Criar um novo projeto PlatformIO (pio init --board esp32dev)
• Inspecionar a estrutura do projeto: platformio.ini, pastas src/, lib/
• Compilar (pio run) e enviar (pio run --target upload) o exemplo “blink” padrão
• Abrir o monitor série (pio device monitor) para ver a saída

Nível: 2 – Principiante
Tópicos:

• Usar o Library Manager: pio lib install, pio lib list, adicionar bibliotecas no platformio.ini
• Configurar múltiplos environments (secções env:) para diferentes placas ou modos de build
• Definir build_flags, monitor_speed e upload_speed no platformio.ini
• Correr clean builds (pio run --target clean) e verbose builds (pio run --target verbose)
• Usar o Unified Debugger (pio debug) para definir breakpoints e percorrer o código

Nível: 3 – Intermédio
Tópicos:

• Gerir builds Debug vs Release e environments com OTA num único platformio.ini
• Integrar testes unitários com o PlatformIO Test Runner e o framework Unity
• Adicionar análise estática: ativar cppcheck ou clang-tidy via scripts extra ou configurações do platformio.ini
• Automatizar passos personalizados de pré- ou pós-build usando extra_scripts
• Publicar e consumir bibliotecas privadas através do PlatformIO Registry

Nível: 4 – Avançado
Tópicos:

• Criar e publicar pacotes personalizados de Platforms e Boards para uso interno ou da comunidade
• Implementar protocolos avançados de upload (JTAG, OTA, scripts de upload personalizados)
• Construir pipelines de CI usando scripts pio ci para GitHub Actions, GitLab CI ou Jenkins
• Gerar e automatizar relatórios de cobertura de código para testes unitários
• Analisar o tamanho do firmware e o uso de RAM via o Dashboard do PlatformIO IDE

Nível: 5 – Especialista
Tópicos:

• Contribuir melhorias ou correções para o PlatformIO Core e as Community Platforms oficiais
• Desenvolver plugins personalizados de PlatformIO para estender funcionalidades do CLI e do IDE
• Arquitetar e manter grandes workspaces monorepo ou multi-projeto usando PIO Projects
• Escrever build hooks avançados para integrar toolchains empresariais e workflows de deployment
• Mentorar equipas em boas práticas de PlatformIO e resolver problemas complexos de build/debug multiplataforma

7 – Linux CLI / WSL

Nível: 1 – Principiante Absoluto
Tópicos:

• Abrir um terminal no Linux ou WSL
• Navegar o filesystem: ls, cd, pwd, mkdir
• Ver e inspecionar ficheiros: cat, less, head, tail
• Manipular ficheiros: cp, mv, rm, touch
• Editar texto com um editor simples (nano ou vim básico)

Nível: 2 – Principiante
Tópicos:

• Permissões e propriedade de ficheiros: chmod, chown, compreender os bits rwx
• Wildcards, globbing, piping (|) e redirecionamento (>, >>, <)
• Pesquisar texto em ficheiros: fundamentos do grep
• Gerir variáveis de ambiente e o perfil da shell (.bashrc, .profile)
• Instalar e atualizar pacotes com o gestor de pacotes da sua distribuição (apt, yum, pacman)
• Ligar a hosts remotos via ssh e transferir ficheiros com scp

Nível: 3 – Intermédio
Tópicos:

• Escrever scripts Bash: shebang, variáveis, ciclos, condicionais, funções
• Processamento de texto com find, xargs, awk, sed
• Controlo de processos e jobs: ps, top/htop, kill, jobs, bg/fg
• Configurar regras udev para adaptadores ESP32 USB/JTAG
• Invocar toolchains de cross-compilação e sistemas de build (make, cmake, idf.py) a partir do CLI
• Correr o OpenOCD a partir da linha de comandos para flashar e depurar via JTAG/SWD

Nível: 4 – Avançado
Tópicos:

• Desenvolver shell scripts robustos: tratamento de erros, logging, testes unitários (ShellCheck)
• Automatizar pipelines completos de build–flash–test em shell e integrar em CI (GitHub Actions, GitLab CI)
• Containerizar o seu ambiente de build com Docker ou Podman; escrever Dockerfiles para builds reproduzíveis
• Depuração remota e sincronização de ficheiros: ssh port forwarding, rsync, tmux/screen para persistência de sessão
• Analisar e depurar ferramentas nativas: strace, ltrace, perf

Nível: 5 – Especialista
Tópicos:

• Compilar e manter kernels ou módulos Linux personalizados para alvos embebidos
• Arquitetar e operar runners de CI dedicados (bare-metal ou containerizados) otimizados para cross-compilação embebida
• Implementar técnicas avançadas de caching e build distribuído (ccache, distcc)
• Desenhar os seus próprios frameworks ou toolchains de CLI, gerir dotfiles entre equipas (com Git)
• Mentorar outros em boas práticas de uso da shell, workflows baseados em terminal e automação de tarefas de teste e deployment de hardware

8 – Framework de Testes Unitários (Unity / CppUTest)

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o propósito e os benefícios dos testes unitários
• Instalar o Unity ou CppUTest (via biblioteca PlatformIO, pacote pip, ou a partir do source)
• Criar um ficheiro de teste mínimo e incluir os headers do framework
• Escrever uma função de teste simples usando a macro TEST (Unity) ou TEST_GROUP/TEST (CppUTest)
• Correr o test runner a partir da linha de comandos e interpretar a saída PASS/FAIL
• Usar macros básicas de asserção (por ex. TEST_ASSERT, CHECK_EQUAL)

Nível: 2 – Principiante
Tópicos:

• Organizar testes em suites ou grupos
• Implementar funções setUp() e tearDown() para test fixtures
• Usar uma gama mais ampla de asserções: floats, strings, comparações de memória
• Parametrizar testes ou iterar sobre dados de teste
• Integrar a compilação e execução de testes no seu build PlatformIO ou CMake
• Gerar dados simples de cobertura de código (por ex. via gcov) e ver percentagens básicas de cobertura

Nível: 3 – Intermédio
Tópicos:

• Criar stubs e fakes para funções dependentes de hardware (leituras I²C, conversões ADC)
• Introduzir uma biblioteca de mocking (CppUMock ou CMock do Unity) para simular dependências
• Escrever testes para código assíncrono: simular callbacks, interrupções ou timers do FreeRTOS
• Automatizar execuções de testes com shell scripts ou um job básico de CI
• Recolher e analisar métricas detalhadas de cobertura (cobertura de branches, de funções)
• Testar exaustivamente condições de fronteira e de erro

Nível: 4 – Avançado
Tópicos:

• Desenvolver implementações de mock personalizadas para drivers de baixo nível e abstrações de periféricos
• Usar plugins de deteção de memory leaks (CppUTest MemoryLeak detector)
• Portar o test runner para o dispositivo para testes unitários on-target
• Escrever testes para primitivas de concorrência: semáforos, queues, task notifications no FreeRTOS
• Integrar relatórios de cobertura e de testes num dashboard de CI (saída XML JUnit/XUnit)
• Empregar macros avançadas de asserção e funcionalidades de parametrização de testes

Nível: 5 – Especialista
Tópicos:

• Estender ou personalizar o framework de testes: escrever plugins, reporters personalizados ou novas macros de asserção
• Arquitetar uma infraestrutura de testes escalável entre múltiplos projetos e plataformas
• Implementar harnesses de teste hardware-in-the-loop (HIL) ou firmware-in-the-loop (FIL) com controlo automatizado de fixtures
• Mentorar equipas em TDD, padrões de design de testes e impor políticas de testes
• Contribuir para os projetos open-source Unity ou CppUTest (correções de bugs, novas funcionalidades)
• Otimizar a execução paralela de testes, ambientes de teste containerizados e minimizar o overhead de runtime dos testes

9 – Integração Contínua (GitHub Actions / GitLab CI)

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender o que é Integração Contínua (CI) e porque importa (build e teste automatizados)
• Identificar serviços populares de CI: GitHub Actions vs. GitLab CI
• Criar o ficheiro de configuração de CI mais simples (.github/workflows/ci.yml ou .gitlab-ci.yml)
• Adicionar um job que faz checkout do código (actions/checkout ou git clone) e imprime uma mensagem hello
• Desencadear o workflow em cada push para o branch principal e ver logs básicos na web UI

Nível: 2 – Principiante
Tópicos:

• Estender o job de CI para instalar dependências (por ex. Python/pip, PlatformIO, ESP-IDF)
• Adicionar passos de build: compilar o firmware (idf.py build ou pio run)
• Correr testes unitários via pio test ou test runner personalizado e interpretar pass/fail
• Aprender a ler e filtrar a saída de logs para erros e warnings
• Fazer commit e push de alterações para desencadear o CI; corrigir falhas simples de build

Nível: 3 – Intermédio
Tópicos:

• Dividir build, teste, lint e análise estática em jobs ou stages separados
• Usar ações integradas (ou templates GitLab) para caching de artifacts da toolchain (actions/cache)
• Implementar um matrix build para testar múltiplas placas ou versões de toolchain em paralelo
• Arquivar artifacts de build (binários de firmware, relatórios de teste, dados de cobertura) para download
• Configurar dependências de jobs e execução condicional (needs: no GitHub Actions, stage: no GitLab CI)

Nível: 4 – Avançado
Tópicos:

• Integrar ferramentas de cobertura de código (gcov, lcov) e publicar badges de cobertura
• Automatizar verificações de tamanho de firmware e uso de memória; falhar se os limiares forem excedidos
• Fazer deploy de firmware pronto para OTA num dispositivo de staging via SSH ou runner personalizado
• Gerir secrets e tokens de forma segura (GitHub Secrets, variáveis de CI/CD do GitLab)
• Usar runners self-hosted ou contentores Docker para ambientes de build personalizados

Nível: 5 – Especialista
Tópicos:

• Desenvolver ações de CI reutilizáveis ou imagens Docker otimizadas para builds de ESP32
• Arquitetar pipelines multi-projeto: bibliotecas partilhadas, gestão de submódulos, triggers cross-repo
• Implementar workflows avançados: previews de feature branches, canary deployments, rollbacks automáticos
• Impor conformidade com políticas de branches protegidos, commits assinados e logs de auditoria
• Mentorar e documentar boas práticas de CI/CD entre equipas; formar na resolução de falhas complexas de pipeline

10 – Jira & Confluence

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o propósito do tracking de issues vs. documentação
• Registar-se no Jira Cloud (ou ligar a uma instância existente)
• Navegar a UI do Jira: projetos, issues, backlog, board
• Criar uma issue básica: selecionar projeto, tipo de issue, resumo, descrição
• Transitar uma issue através de um workflow simples (To Do → In Progress → Done)
• Adicionar comentários e anexos a uma issue
• Registar-se no Confluence (ou aceder ao espaço da sua equipa)
• Criar uma página Confluence: título, corpo de texto, guardar e editar

Nível: 2 – Principiante
Tópicos:

• Trabalhar com diferentes tipos de issue (Task, Bug, Story, Epic) e campos de prioridade
• Usar boards básicos do Jira: Scrum e Kanban, mover cartões entre colunas
• Filtrar issues com JQL simples (por ex. project = “XYZ” AND status = “Open”)
• Configurar notificações simples por email e seguir issues
• No Confluence, organizar páginas em Spaces e hierarquias pai-filho
• Usar macros comuns: Code Block, Table, Panel, Image
• Inserir links de issues do Jira e listas de issues em páginas Confluence

Nível: 3 – Intermédio
Tópicos:

• Personalizar ecrãs de issues e adicionar campos personalizados
• Definir e modificar workflows simples: estados, transições, validadores
• Criar e partilhar dashboards com gadgets (Filter Results, Burndown Chart)
• Escrever queries JQL avançadas para filtros e boards complexos
• Configurar swimlanes de boards por queries ou responsáveis
• No Confluence, criar e usar Templates e Blueprints
• Gerir permissões de páginas, etiquetas e restrições de páginas
• Usar as macros Include Page, Excerpt e Page Properties para relatórios dinâmicos

Nível: 4 – Avançado
Tópicos:

• Construir regras de Jira Automation: triggers, condições, ações (por ex. auto-atribuição, envio de alertas)
• Configurar SLAs, service desks e acompanhar métricas com o Jira Service Management
• Arquitetar boards multi-projeto e releases transversais a projetos
• Usar o Portfolio for Jira (Advanced Roadmaps) para planear cronogramas e dependências
• No Confluence, criar Blueprints personalizados e overrides de tema
• Incorporar conteúdo dinâmico: gráficos do Jira, diagramas Gliffy, Live macros
• Analisar analytics de páginas e atividade de utilizadores para otimizar o conteúdo

Nível: 5 – Especialista
Tópicos:

• Administrar definições globais do Jira: permissões, esquemas de tipos de issue, esquemas de workflow
• Desenhar workflows complexos de nível empresarial com ramificação, aprovações e automação
• Integrar o Jira com ferramentas externas (CI/CD, Slack, GitHub) via webhooks e apps
• Liderar a implementação de ITSM: gestão de mudanças, workflows de incidentes/problemas
• No Confluence, desenvolver plugins personalizados ou usar o ScriptRunner para automação
• Definir templates de espaços, look-and-feel global e esquemas avançados de permissões
• Mentorar e formar equipas em boas práticas de Jira/Confluence e políticas de governação

11 – Eletrónica Digital e Analógica

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender as unidades elétricas básicas: tensão (V), corrente (A), resistência (Ω), potência (W)
• Aprender a Lei de Ohm (V = I∙R) e cálculos básicos de série/paralelo
• Identificar componentes passivos: resistências, condensadores, indutores
• Usar um multímetro para medir tensão, corrente e resistência em circuitos DC simples
• Ler e interpretar símbolos básicos de circuitos e esquemas

Nível: 2 – Principiante
Tópicos:

• Construir e analisar redes de resistências em série e paralelo e divisores de tensão
• Introduzir condensadores: curvas de carga/descarga, constantes de tempo RC, filtros simples passa-baixo/passa-alto
• Compreender níveis lógicos digitais (TTL vs. CMOS) e como se traduzem para os GPIO do ESP32
• Técnicas de level shifting: divisores resistivos, level shifters baseados em MOSFET para sinais UART
• Usar breadboards e fios jumper para prototipar circuitos de interface com sensores

Nível: 3 – Intermédio
Tópicos:

• Desenhar o front-end analógico para sensores: escolher e configurar op-amps (inversor, não-inversor)
• Implementar amplificadores de instrumentação para sinais diferenciais de sensores (por ex. sondas NPK)
• Interface com ADC: compreender gama de fundo de escala, resolução, taxa de amostragem e seleção da tensão de referência
• Fundamentos de EMI/EMC: condensadores de desacoplamento, estratégias de grounding, regras básicas de layout
• Analisar e mitigar ruído: blindagem, cablagem de par trançado, contas de ferrite

Nível: 4 – Avançado
Tópicos:

• Criar circuitos de medição de precisão: métodos de calibração, compensação de deriva térmica
• Design avançado de filtros: topologias de filtros ativos (Butterworth de segunda ordem, Bessel)
• Design de fontes de alimentação: selecionar e fazer layout de conversores DC-DC, LDOs e desacoplamento bulk/cerâmico
• Layout de PCB para sinal misto: massas analógica/digital separadas, pistas de impedância controlada, grounding em estrela
• Conduzir verificações básicas de conformidade EMI: sondagem de campo próximo, técnicas de análise de espetro

Nível: 5 – Especialista
Tópicos:

• Arquitetar front-ends analógicos de baixo ruído: soluções discretas personalizadas, orçamentação de ruído e seleção de componentes
• Desenhar e integrar ICs de sinal misto: ADCs/DACs de alta resolução, isolamento digital e otimização de timing SPI/I²C
• Desenvolver e validar ICs de gestão de energia personalizados ou configurações de PMIC para dispositivos alimentados a bateria
• Liderar esforços de certificação EMI/EMC: escrever planos de teste, interpretar normas CE/FCC, testes de pré-conformidade e remediação
• Mentorar e rever os designs analógicos e de sinal misto da equipa, otimizar para fabricabilidade, custo e fiabilidade

12 – Design de PCB (KiCad / Altium)

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o que é uma PCB e porque é usada (vs. breadboard ou perfboard)
• Instalar o KiCad ou Altium Designer e explorar a UI
• Criar um novo projeto de esquema e colocar componentes básicos (resistência, LED, conector)
• Correr o Electrical Rules Check (ERC) para apanhar erros óbvios de netlist
• Gerar uma netlist e importá-la para um layout de PCB em branco
• Colocar footprints no contorno da placa e encaminhar pistas simples de camada única
• Exportar ficheiros básicos Gerber e de furação

Nível: 2 – Principiante
Tópicos:

• Construir e gerir uma biblioteca pessoal de símbolos e footprints
• Definir e aplicar regras de design: larguras de pista, clearances, anéis anulares
• Usar planos de massa e de alimentação para simplificar o routing e melhorar a fiabilidade
• Adicionar texto de silkscreen, designadores de componentes e camadas mecânicas de contorno da placa
• Trabalhar com footprints through-hole e de montagem em superfície, compreendendo definições de pads e solder mask
• Correr o Design Rule Check (DRC) e corrigir erros comuns de clearance/sobreposição
• Gerar um pacote completo de fabrico: Gerbers, NC drill, BOM

Nível: 3 – Intermédio
Tópicos:

• Criar esquemas multi-folha (hierárquicos) e gerir a conetividade de nets
• Definir um stackup controlado para placas de 4 ou 6 camadas, incluindo espessuras dielétricas
• Encaminhar pares diferenciais e pares de sinal com comprimento igualado (USB, SPI, linhas de alta velocidade)
• Usar gestão avançada de planos: split planes, thermal reliefs, zonas de pour
• Integrar modelos 3D para verificações de caixa e clearances mecânicos
• Automatizar a geração de BOM com campos personalizados e exportar para CSV ou Excel
• Colaborar via Git (ou SVN) em ficheiros de projeto de PCB e gerir o histórico de versões

Nível: 4 – Avançado
Tópicos:

• Design para fabricabilidade (DFM): panelização, fiducials, desenhos de montagem
• Implementar práticas de integridade de sinal de alta velocidade: controlo de impedância, via stitching, caminhos de retorno
• Criar e reutilizar templates de projeto com regras de design e stacks de camadas à escala da empresa
• Realizar análises básicas térmicas e de distribuição de energia dentro da ferramenta ECAD
• Escrever e correr scripts (Python no KiCad ou scripts Altium) para automatizar tarefas repetitivas
• Desenvolver e gerir bibliotecas de componentes centralizadas com estados de ciclo de vida e variantes aprovadas
• Integrar dados ECAD com CAD mecânico para engenharia concorrente

Nível: 5 – Especialista
Tópicos:

• Arquitetar sistemas rigid-flex e multi-placa (backplane), definir áreas de dobra flex e reforços
• Liderar design reviews com foco em DFM, DFA (montagem) e DFT (teste), e mentorar designers juniores
• Desenvolver footprints personalizados conformes com IPC e criar documentação de normas de design internas
• Orientar a integração PLM/ERP para gestão do ciclo de vida de peças e workflows de procurement
• Planear e executar pacotes de certificação (UL, CE, FCC) com toda a documentação necessária
• Otimizar funcionalidades avançadas: vias enterradas/cegas, impedância controlada, designs HDI com microvias
• Contribuir ou personalizar plugins de ferramentas ECAD e construir pipelines automatizados para validação de dados do fabricante

13 – Orçamentação de Energia e Carregamento Solar-Li-ion

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender a relação entre tensão, corrente e potência (P = V × I)
• Aprender as características básicas de baterias Li-ion: tensão nominal (~3,7 V), capacidade (mAh/Ah), gamas de tensão seguras
• Usar um multímetro para medir tensão e corrente em circuitos simples alimentados a bateria
• Identificar rails de alimentação básicos numa placa ESP32 e ler os seus rótulos (5 V, 3,3 V)
• Familiarizar-se com um pequeno painel solar: especificações de tensão de circuito aberto (Voc) e corrente de curto-circuito (Isc)

Nível: 2 – Principiante
Tópicos:

• Construir uma folha de cálculo simples de orçamento de energia: listar cada subsistema (ESP32, sensor, rádio) com a sua corrente de operação e duty cycle
• Calcular consumos de corrente médios e de pico; estimar a autonomia para uma dada capacidade de bateria
• Comparar reguladores lineares (LDOs) vs. reguladores comutados simples para baixar para 3,3 V
• Ligar um IC básico de carga Li-ion (por ex. MCP73831) numa breadboard e observar o comportamento do LED de carga
• Medir a saída do painel sob diferentes níveis de luz e aprender a ler as curvas do seu datasheet

Nível: 3 – Intermédio
Tópicos:

• Introduzir conceitos de Maximum Power Point Tracking (MPPT): porque o MPPT melhora a captação de energia vs sombreamento passivo
• Selecionar e configurar um controlador de carga solar comercial (por ex. Adafruit Solar LiPo Charger)
• Dimensionar o painel solar e a bateria para a autonomia alvo e o pior caso meteorológico; incluir margens de segurança
• Desenhar um circuito de dupla entrada de energia: bateria mais solar, com ORing de díodo ideal ou díodos Schottky
• Implementar estados de firmware de baixo consumo (deep sleep, light sleep) e medir a corrente quiescente

Nível: 4 – Avançado
Tópicos:

• Avaliar e escolher entre diferentes ICs ou módulos MPPT para uso embebido (por ex. STSPIN, série TI BQ)
• Desenhar uma árvore de energia de PCB personalizada: conversores buck/boost, load switches, indicadores power-good
• Modelar curvas de carga/descarga da bateria e efeitos térmicos; simular em SPICE ou folha de cálculo
• Implementar gestão dinâmica de energia em firmware: adaptar a taxa de amostragem ou o duty cycle do rádio com base no SoC da bateria
• Adicionar proteções de hardware: monitorização de sobretensão, subtensão, sobrecorrente e temperatura

Nível: 5 – Especialista
Tópicos:

• Arquitetar um algoritmo MPPT totalmente personalizado em firmware ou FPGA, afinado para perfis solares locais
• Desenvolver ou modificar firmware de IC de gestão de energia (por ex. para um BMS personalizado) e otimizar para eficiência de 98%+
• Liderar o design de energy harvesting para ambientes extremos: pouca luz, temperaturas extremas, análise de sombreamento parcial
• Integrar diagnósticos avançados de saúde da bateria: coulomb counting, impedance tracking, algoritmos preditivos de SoC/SoH
• Mentorar equipas em trade-offs de sistemas de energia, preparar documentação para certificações de segurança UL/IEC e otimizar para rendimento de fabrico e fiabilidade.

14 – Gestão de Bateria (18650)

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender as especificações básicas de células Li-ion 18650: tensão nominal, capacidade, corrente máxima de carga/descarga
• Compreender a segurança básica de células: sem curtos-circuitos, polaridade correta, evitar descarga excessiva
• Medir a tensão da célula com um multímetro; reconhecer os pontos de cheia (4,2 V) vs. vazia (≈3,0 V)
• Identificar funcionalidades comuns de ICs de proteção: corte por sobretensão, subtensão, sobrecorrente
• Praticar manuseamento seguro: usar um suporte adequado, nunca perfurar ou esmagar células

Nível: 2 – Principiante
Tópicos:

• Ligar um módulo carregador simples de célula única (por ex. TP4056) e monitorizar os LEDs de estado de carga
• Compreender o perfil de carga CC-CV: corrente constante até ao limiar, depois taper de tensão constante
• Adicionar uma PCB de proteção à célula: aprender como funciona a proteção baseada em MOSFET
• Ler curvas de carga/descarga do datasheet da célula e orientações de derating
• Calcular o State of Charge (SoC) aproximadamente a partir da curva tensão vs SoC

Nível: 3 – Intermédio
Tópicos:

• Introduzir fundamentos de coulomb-counting: medir carga de entrada/saída via resistor de sense de corrente e ADC
• Selecionar e integrar um amplificador de current-sense (por ex. INA219 ou IC coulomb-counter dedicado)
• Calibrar o seu sistema de coulomb-counting: compensação de offset, ganho e deriva
• Combinar SoC baseado em tensão e coulomb-counting para melhorar a precisão
• Implementar verificações básicas de saúde da bateria: contagem de ciclos, estimativa de perda de capacidade

Nível: 4 – Avançado
Tópicos:

• Desenhar um circuito de carga balanceada multi-célula (2–4 células) com resistências de balanceamento ou IC balancer ativo
• Integrar um IC BMS completo (por ex. série TI BQ769x0): monitorização de sobretensão, subtensão, sobrecorrente e temperatura
• Implementar algoritmos de SoC e SoH em firmware: filtro de Kalman ou contador Coulomb adaptativo
• Adicionar sensorização de temperatura (NTC ou digital) e compensação das curvas de carga/descarga
• Validar a segurança sob condições de falha: simular curto, sobrecorrente, sobretemperatura e registar eventos de falha

Nível: 5 – Especialista
Tópicos:

• Arquitetar um firmware de BMS personalizado: algoritmos avançados de balanceamento de células, perfis de carga adaptativos
• Otimizar a precisão do Coulomb-counting a longo prazo: correção de deriva, compensação de temperatura, algoritmos de auto-aprendizagem
• Liderar esforços de certificação: IEC 62133, UL 2054, documentação de testes UN 38.3 e criação de planos de teste
• Desenhar funcionalidades de segurança redundantes: monitorização dual-IC, watchdogs, estados failsafe de hardware
• Mentorar e rever designs de subsistemas de bateria: análise de modos de falha, fabricabilidade e planos de testes de fiabilidade

15 – Comunicações Celulares (SIMCom AT, PPP, TCP/IP)

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender conceitos básicos de celular: GSM vs LTE vs NB-IoT
• Identificar o pinout do cartão SIM e como inserir/ejetar o SIM
• Alimentar e ligar um módulo SIMCom a um microcontrolador ou adaptador USB-para-UART
• Abrir um terminal série (minicom, PuTTY) na baud rate correta
• Enviar comandos AT simples: AT, ATI, AT+CSQ
• Interpretar respostas: OK, ERROR e códigos básicos de qualidade de sinal

Nível: 2 – Principiante
Tópicos:

• Verificar o registo na rede: AT+CREG? e AT+CGREG?
• Configurar o contexto PDP: AT+CGDCONT=1,”IP”,””
• Usar PPP para estabelecer uma ligação IP: escrever um chat script e invocar o pppd
• Verificar a conetividade IP sobre PPP: fazer ping a um host conhecido ou usar uma ferramenta de teste de sockets
• Enviar e ler SMS: AT+CMGF=1, AT+CMGS=””, AT+CMGR=
• Tratar códigos de erro básicos: ler e descodificar +CME ERROR:

Nível: 3 – Intermédio
Tópicos:

• Abrir e gerir sockets TCP: AT+CIPSTART=”TCP”,”host”,”port”
• Enviar e receber dados sobre o socket: AT+CIPSEND e AT+CIPRXGET
• Monitorizar unsolicited result codes (URCs): +CIPSTATUS, +TCP_CLOSED
• Implementar lógica de reconexão automática em firmware quando o socket ou o PPP cai
• Usar os modos de sleep do módulo para poupança de energia: AT+CFUN, AT+CSCLK
• Proteger a ligação com comandos TLS básicos se suportados (por ex. AT+SSLOPT)

Nível: 4 – Avançado
Tópicos:

• Integrar o bring-up de PPP em tasks RTOS com callbacks de eventos em connect/disconnect
• Gerir múltiplos APNs e contextos de fallback para resiliência em roaming
• Correr um cliente MQTT sobre o socket celular usando comandos AT
• Consultar dados GNSS/localização se o módulo os suportar: AT+CGPS=1, AT+CGPSINFO
• Analisar throughput e latência: medir taxas de dados e otimizar o buffering do firmware
• Diagnosticar problemas de RF e de rede usando comandos estendidos de informação de rede (por ex. AT+QENG)

Nível: 5 – Especialista
Tópicos:

• Desenvolver ou otimizar uma biblioteca de parsing de comandos AT com máquinas de estado e buffering robusto
• Desenhar um daemon PPP personalizado ou um stack IP leve para sistemas profundamente embebidos
• Implementar integração ao nível do driver: transferências UART baseadas em DMA, controlo de fluxo por hardware
• Suportar modos de dados avançados: raw sockets, UDP multicast/broadcast, modo de dados SMS
• Tratar o provisionamento seguro de certificados em flash e gerir sessões TLS de ponta a ponta
• Mentorar equipas em boas práticas de IoT celular: otimização de custos, conformidade regulamentar e considerações de design de antena/RF

16 – Protocolos IoT (MQTT / HTTPS)

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o que são protocolos IoT e porque importam para dispositivos com recursos limitados
• Aprender os fundamentos de MQTT: modelo publish/subscribe, papel do broker, tópicos, níveis de QoS (0, 1, 2)
• Aprender os fundamentos de HTTPS: pedido/resposta cliente–servidor, princípios REST, URLs, métodos (GET, POST)
• Instalar um cliente MQTT de desktop (MQTT.fx, MQTT Explorer) e ligar a um broker público (por ex., test.mosquitto.org )
• Usar o curl para fazer pedidos HTTPS GET simples a APIs públicas

Nível: 2 – Principiante
Tópicos:

• Escrever firmware para ligar um ESP32 a um broker MQTT usando uma biblioteca simples (por ex., PubSubClient para Arduino ou esp_mqtt_client para ESP-IDF)
• Publicar leituras de sensores num tópico de teste; subscrever e registar mensagens de outro tópico
• Construir payloads JSON básicos e fazer parsing de JSON recebido no firmware
• Fazer pedidos HTTPS a partir do ESP32: configurar o HTTPClient (Arduino) ou o esp_http_client (ESP-IDF)
• Tratar a validação de certificados a um nível básico (começar em modo inseguro, depois mudar para root CA adequado)

Nível: 3 – Intermédio
Tópicos:

• Implementar persistência de sessão MQTT: retain messages, clean session = false
• Usar o MQTT Last Will and Testament (LWT) para sinalizar desconexões inesperadas
• Organizar hierarquias de tópicos com wildcards (+, #) para mensagens de dispositivos escaláveis
• Gerir certificados TLS em flash: converter PEM para DER, incorporar numa partição
• Tratar HTTPS POST com corpos JSON e fazer parsing de respostas JSON; gerir headers

Nível: 4 – Avançado
Tópicos:

• Desenhar e implementar uma arquitetura MQTT segura: certificados de cliente, autenticação TLS mútua
• Otimizar o desempenho MQTT: publicações em lote, usar QoS adequadamente, minimizar o overhead de keepalive
• Implementar autenticação mútua HTTPS (certificados de cliente) e gerir a rotação de certificados
• Integrar MQTT sobre WebSockets para dashboards baseados em browser ou redes limitadas
• Construir um cliente REST leve com estado no ESP32 com padrões de retry, backoff e circuit breaker

Nível: 5 – Especialista
Tópicos:

• Arquitetar uma ponte de protocolos personalizada: traduzir entre CoAP, MQTT e HTTPS para redes IoT heterogéneas
• Desenvolver um plugin ou extensão de broker MQTT interno para autorização, filtragem ou transformação personalizadas
• Prototipar e avaliar protocolos IoT alternativos (por ex., MQTT-SN, AMQP, LwM2M) para casos de uso especializados
• Liderar auditorias de segurança: threat modeling, avaliações de vulnerabilidade de stacks de comunicação IoT
• Mentorar equipas no design de arquiteturas de mensagens IoT seguras, resilientes e de grande escala com protocolos híbridos

17 – Fundamentos de Segurança TLS / mbedTLS

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender conceitos básicos de criptografia: plaintext vs ciphertext, encriptação simétrica vs assimétrica, hashing
• Compreender o que o TLS fornece: confidencialidade, integridade, autenticidade
• Estudar o fluxo de handshake TLS a alto nível: ClientHello, ServerHello, key exchange, record layer
• Instalar o mbedTLS e explorar a diretoria de exemplos programs/ssl
• Compilar e correr os exemplos ssl_client1 e ssl_server2 no seu desktop

Nível: 2 – Principiante
Tópicos:

• Configurar o mbedTLS via config.h: ativar apenas os módulos de que precisa (SSL/TLS, X.509, primitivas cripto)
• Gerar um certificado autoassinado e chave com o OpenSSL; converter entre formatos PEM e DER
• Modificar e correr o ssl_client2 para fazer um HTTPS GET contra um servidor público
• Definir a versão mínima de TLS e escolher cipher suites básicas na configuração SSL
• Ativar o debug logging do mbedTLS para rastrear os passos do handshake e códigos de erro

Nível: 3 – Intermédio
Tópicos:

• Implementar autenticação PSK (Pre-Shared Key) no mbedTLS para dispositivos com recursos limitados
• Incorporar certificados e chaves em flash ou lê-los de uma partição de filesystem em runtime
• Usar o parser X.509 do mbedTLS para validar certificados de servidor contra um bundle de root CA
• Alimentar o gerador de números aleatórios com um TRNG de hardware (por ex., esp_hardware_poll do ESP32) via mbedtls_ctr_drbg
• Integrar o mbedTLS como componente no ESP-IDF e invocar ligações TLS a partir de uma task FreeRTOS

Nível: 4 – Avançado
Tópicos:

• Implementar TLS mútuo (certificados de cliente e servidor) num ambiente embebido
• Desenhar um mecanismo seguro de rotação de certificados com proteção de rollback de firmware
• Otimizar o footprint de memória: desativar módulos não usados, afinar o uso de heap versus stack em mbedtls_platform_set_calloc_free
• Ligar-se a um acelerador cripto de hardware (offload RSA/ECC) e registá-lo na camada PK do mbedTLS
• Armazenar chaves privadas de forma segura: usar encriptação de flash ou um secure element externo (ATECC608A)

Nível: 5 – Especialista
Tópicos:

• Contribuir correções ou novas funcionalidades para o core do mbedTLS (por ex., adicionar uma nova cipher suite ou melhorar código de tempo constante)
• Realizar auditorias de segurança e fuzz testing no handshake e nas primitivas cripto
• Construir uma configuração mbedTLS conforme com FIPS 140-2 e documentar a validação do módulo
• Desenvolver implementações resistentes a side-channel e blindar contra ataques de análise de timing ou de potência
• Definir e mentorar políticas de segurança de nível empresarial: threat modeling, gestão do ciclo de vida de chaves, processos de divulgação de vulnerabilidades

18 – Calibração e Compensação de Sensores

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o que significam “calibração de sensor” e “compensação” e porque importam
• Aprender a ler valores raw do ADC de um sensor em código (por ex. adc1_get_raw)
• Registar saídas raw do sensor em condições ambiente usando serial print ou um data logger simples
• Familiarizar-se com padrões de referência básicos: resistências fixas conhecidas, tensões de referência conhecidas
• Traçar leituras raw vs valores esperados numa folha de cálculo para ver erros de linearidade ou offset

Nível: 2 – Principiante
Tópicos:

• Realizar uma calibração de dois pontos (offset e ganho): recolher leituras em duas concentrações ou cargas conhecidas
• Calcular e implementar uma fórmula simples de mapeamento linear no firmware
• Documentar os passos e resultados da calibração: incluir as condições de teste (temperatura, humidade)
• Introduzir métricas de erro: erro médio, desvio padrão, erro máximo
• Automatizar a recolha de dados de calibração com scripts ou comandos shell simples

Nível: 3 – Intermédio
Tópicos:

• Caracterizar a resposta do sensor em toda a sua gama com dados multiponto (pelo menos 5–10 pontos)
• Ajustar curvas de ordem superior (regressão polinomial) ou segmentos lineares por partes numa ferramenta como Python ou Excel
• Implementar compensação de temperatura e humidade: ler sensores ambientais e aplicar fórmulas de correção
• Validar a compensação comparando leituras compensadas com instrumentos de referência ao longo das condições
• Guardar coeficientes de calibração em memória não volátil (memória RTC, partição NVS, ou flash)

Nível: 4 – Avançado
Tópicos:

• Desenvolver protocolos robustos de calibração: aleatorizar a ordem dos testes, controlar variáveis ambientais, registar metadados
• Usar técnicas estatísticas: deteção de outliers, intervalos de confiança, estudos de repetibilidade/reprodutibilidade
• Automatizar rotinas de calibração no dispositivo: modo de calibração interativo com prompts ao utilizador
• Implementar rotinas de auto-calibração ou auto-zero para remover deriva durante implementações longas
• Gerir e versionar dados de calibração num sistema backend ou base de dados de calibração

Nível: 5 – Especialista
Tópicos:

• Arquitetar algoritmos de compensação multivariada (por ex. usando fusão de sensores ou regressores de machine learning para sensibilidades cruzadas complexas)
• Desenhar e construir rigs de calibração automatizados ou fixtures de teste para calibração de produção de alto volume
• Definir e impor normas e procedimentos de calibração (documentação ao estilo ISO 17025)
• Monitorizar a deriva de calibração em campo e desencadear remotamente recalibração ou atualizações de firmware
• Mentorar e formar a equipa em conceitos avançados de metrologia; publicar diretrizes de calibração internas e white papers

19 – Registo de Dados e Armazenamento OTA

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender o que significa armazenamento persistente num ESP32 e porque é útil para logging ou staging OTA
• Compreender a diferença entre filesystems de flash interna (SPIFFS, LittleFS) e cartões SD externos
• Montar SPIFFS no Arduino (SPIFFS.begin()) ou ESP-IDF (esp_vfs_spiffs_register)
• Listar ficheiros, abrir um ficheiro para escrita ("w"), escrever uma linha, fechar, depois abrir para leitura e imprimir o conteúdo
• Inicializar e montar um cartão SD (Arduino SD.begin(), ESP-IDF esp_vfs_fat_sdspi_mount), abrir um ficheiro e fazer leitura/escrita básica

Nível: 2 – Principiante
Tópicos:

• Usar o modo append ("a") para adicionar novas entradas de log sem sobrescrever dados existentes
• Percorrer diretorias: abrir diretorias, ler nomes de ficheiros, filtrar por extensão ou timestamp
• Configurar o tamanho da partição SPIFFS/LittleFS no platformio.ini ou sdkconfig, reflahar e verificar
• Explorar as diferenças do LittleFS: montagens mais rápidas, wear leveling integrado, operações de metadados
• Detetar e tratar erros de montagem, verificar o espaço livre antes de escrever, recuperar um filesystem corrompido

Nível: 3 – Intermédio
Tópicos:

• Implementar rotação de logs: quando um ficheiro excede um limiar de tamanho ou idade, fechá-lo e começar um novo; apagar os logs mais antigos
• Registar dados binários de sensores de forma eficiente: serializar structs ou floats, escrever/ler de volta para memória
• Montar e usar FAT em SD com suporte de nomes longos; gerir múltiplas partições SD
• Criar uma camada de abstração para que o seu código possa alternar entre SPIFFS, LittleFS ou SD por configuração
• Fazer staging de grandes blocos de dados ou firmware numa partição dedicada “ota_data” usando escritas raw em flash

Nível: 4 – Avançado
Tópicos:

• Compreender e editar a tabela de partições do ESP32: entradas factory, ota_0, ota_1, data (spiffs/littlefs)
• Usar as APIs OTA do ESP-IDF: esp_ota_begin(), esp_ota_write(), esp_ota_end(), esp_ota_set_boot_partition()
• Descarregar e escrever uma imagem completa de firmware na partição OTA inativa, verificar a sua integridade, trocar o boot
• Tratar atualizações interrompidas: detetar escritas parciais, fazer rollback para o último firmware conhecido como bom
• Otimizar a resiliência do filesystem: usar operações de ficheiro atómicas, estratégias de journaling ou double-buffering

Nível: 5 – Especialista
Tópicos:

• Desenhar layouts de partições personalizados: múltiplas partições de dados, redimensionamento dinâmico, integração de flash off-chip
• Implementar filesystems encriptados e/ou comprimidos para proteger dados em repouso e reduzir o desgaste
• Desenvolver atualizações delta-OTA ou baseadas em patches para minimizar o tamanho do download e o tempo de atualização
• Construir harnesses de teste automatizados para simular corrupção do filesystem e validar fluxos de recuperação OTA
• Mentorar em boas práticas: alinhamento de partições, gestão de desgaste da flash, integração de secure boot e gestão do ciclo de vida completo de dados armazenados e atualizações de firmware

20 – Fluxo de Atualização OTA Remota

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o que são atualizações OTA (Over-The-Air) e porque são úteis
• Explorar um exemplo simples de OTA no Arduino (ArduinoOTA) ou ESP-IDF (ota_https_simple)
• Configurar o seu ambiente de desenvolvimento para ativar OTA: incluir a biblioteca/componente OTA
• Flashar o exemplo “blink” com OTA ativado e confirmar que anuncia um serviço ou endpoint HTTP
• Desencadear uma atualização OTA manual a partir do VS Code ou do Arduino IDE e ver o firmware reiniciar

Nível: 2 – Principiante
Tópicos:

• Alojar um binário de firmware num servidor HTTP(S) local ou servidor de ficheiros simples
• Escrever código de firmware para obter o manifest de versão ou o URL do binário por HTTP usando HTTPClient ou esp_http_client
• Descarregar e aplicar a atualização na partição secundária usando a API OTA do ESP-IDF (esp_ota_begin, esp_ota_write, esp_ota_end)
• Verificar a integridade da nova imagem usando checksums integrados ou headers HTTP ETag
• Implementar rollback básico: se o novo firmware falhar o arranque ou sinalizar um erro, reverter para a partição anterior

Nível: 3 – Intermédio
Tópicos:

• Automatizar triggers de OTA: verificar atualizações no arranque ou em timers periódicos, comparar a versão atual com o manifest
• Proteger o canal de atualização: mudar de HTTP para HTTPS, validar certificados de servidor, fixar CAs em flash
• Suportar delta-OTA (diffs binários) para reduzir o tamanho do download: integrar e aplicar patches em vez de imagens completas
• Usar MQTT ou MQTT-SN para notificar os dispositivos de atualizações disponíveis e controlar o rollout por dispositivo ou grupo
• Guardar metadados de atualização (versão, timestamp, estado) em armazenamento não volátil (NVS) para auditoria

Nível: 4 – Avançado
Tópicos:

• Integrar com um serviço OTA baseado em cloud (por ex., AWS IoT Device Management, Azure IoT Hub) via as suas APIs REST/MQTT
• Implementar rollouts faseados: lançar primeiro para uma pequena percentagem de dispositivos, monitorizar a saúde, depois expandir o rollout
• Desenhar um esquema de partições A/B com fallback para golden image e verificações de saúde automatizadas no arranque
• Automatizar pipelines de compilação, assinatura e publicação de firmware em CI/CD; incorporar assinaturas e verificar no dispositivo
• Tratar atualizações multi-componente (bootloader, tabela de partições, aplicação, filesystem) numa única transação

Nível: 5 – Especialista
Tópicos:

• Arquitetar um backend personalizado de gestão de OTA: versionamento, grupos de dispositivos, atualizações diferenciais, integração de telemetria
• Implementar segurança de ponta a ponta: assinatura de código com chaves assimétricas, integração de secure boot, proteção contra replay
• Otimizar mecanismos de atualização para redes de baixa largura de banda ou intermitentes: entrega em chunks, suporte de resume, controlo adaptativo de taxa
• Construir caminhos de atualização redundantes: múltiplos servidores, partilha peer-to-peer, estratégias de CDN de fallback
• Mentorar equipas em boas práticas: conformidade com normas da indústria (por ex., IEC 62443), tratamento robusto de erros e gestão do ciclo de vida completo de versões de firmware

21 – Teoria de Controlo e Estimação

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender a ideia básica de um loop de controlo: setpoint, medição e erro
• Diferenciar sistemas de malha aberta vs malha fechada
• Implementar um controlador simples on/off (bang-bang) em pseudocódigo ou C
• Compreender a noção de resposta do sistema: tempo de subida, overshoot, tempo de estabelecimento (conceptual)
• Aprender o que significa “estimação”: usar medições ruidosas para inferir um valor verdadeiro

Nível: 2 – Principiante
Tópicos:

• Derivar e codificar um controlador proporcional (P): saída = Kₚ·erro
• Adicionar termos integral (I) e derivativo (D) para construir um controlador PID; afinar Kₚ, Kᵢ, K_d por tentativa
• Implementar um filtro passa-baixo de primeira ordem (discreto) para leituras ruidosas de sensores
• Modelar sistemas simples como equações de diferenças (por ex. circuito RC discreto)
• Escrever um filtro de média móvel ou suavização exponencial em firmware

Nível: 3 – Intermédio
Tópicos:

• Representar sistemas na forma de espaço de estados (ẋ = Ax + Bu; y = Cx + Du) e discretizar para firmware
• Desenhar e implementar um filtro de Kalman de tempo discreto para um modelo 1D de velocidade constante
• Analisar a estabilidade de um sistema controlado por PID com root locus ou diagramas de Bode (MATLAB/Python)
• Implementar anti-windup para o termo I e filtragem derivativa num algoritmo PID
• Incorporar código de controlo e estimação em tasks FreeRTOS com temporização determinística

Nível: 4 – Avançado
Tópicos:

• Desenhar controladores ótimos de realimentação de estado (LQR) e observadores de Kalman discretos
• Estender a Extended Kalman Filters (EKF) para sistemas não lineares (por ex. cinemática simples de robô móvel)
• Realizar design no domínio da frequência: margem de ganho e de fase, filtros notch, afinação de PID via métodos de Ziegler–Nichols e de relé
• Codificar um protótipo de model predictive control (MPC) em C ou C++, usando um horizonte pequeno
• Analisar o tempo de execução e a memória dos loops de controlo; otimizar para restrições de tempo real

Nível: 5 – Especialista
Tópicos:

• Arquitetar esquemas de controlo não linear: sliding-mode, controlo adaptativo, controladores robustos H∞
• Liderar o desenvolvimento de bibliotecas EKF/UKF personalizadas ou solvers MPC para alvos embebidos
• Mentorar a equipa em estimação avançada: fusão multi-sensor (IMU + GPS + sondas de solo) usando técnicas de simultaneous localization and mapping (SLAM)
• Publicar diretrizes internas de design sobre boas práticas de controlo/estimação e verificação de segurança
• Contribuir algoritmos novos ou melhorias de volta para projetos open-source de controlo/estimação ou artigos académicos

22 – Python / Bash Scripting

Nível: 1 – Principiante Absoluto
Tópicos:

• Instalar Python 3 e pip; verificar com python3 --version e pip3 --version
• Abrir uma shell bash; correr bash --version
• Criar e correr um script Python “hello world” (hello.py) e um script bash simples (hello.sh)
• Adicionar linhas de shebang (#!/usr/bin/env python3 e #!/usr/bin/env bash) e tornar os scripts executáveis (chmod +x)
• Usar comandos bash básicos: echo, ls, pwd, cd; e o print() do Python, atribuições simples de variáveis

Nível: 2 – Principiante
Tópicos:

• Tipos de dados Python (int, float, string, list, dict) e controlo de fluxo (if, for, while); definir funções simples
• Variáveis bash, parâmetros posicionais ($1, $2), regras de quoting, if [ ] básico e ciclos for
• I/O de ficheiros: abrir/ler/escrever em Python; redirecionar (>, >>) e ler linhas em bash (while read)
• Importar e usar módulos integrados do Python (os, sys); carregar scripts bash auxiliares mais pequenos com source
• Tratamento básico de erros: try/except do Python; set -e e trap '…' ERR do bash

Nível: 3 – Intermédio
Tópicos:

• Ambientes virtuais Python (python3 -m venv), requirements.txt, instalar pacotes de terceiros via pip
• Parsing de argumentos bash usando getopts ou getopt e escrita de funções bash reutilizáveis
• Construir scripts de automação: invocar make, idf.py ou pio a partir de Python (subprocess) ou bash
• Usar o argparse do Python para interfaces CLI robustas e o módulo logging para logs estruturados
• I/O avançado de shell: pipes (|), process substitution (<(), >()), here-docs (<<EOF) e substituição de comandos

Nível: 4 – Avançado
Tópicos:

• Escrever testes unitários Python com pytest ou unittest; impor estilo com flake8/pylint e adicionar type hints com mypy
• Blindar scripts bash: set -euxo pipefail, validação de parâmetros, funções de cleanup com trap, modo debug (set -x)
• Usar Python para tarefas concorrentes: threading, multiprocessing e ferramentas de alto nível como concurrent.futures
• Construir módulos Python reutilizáveis e instalá-los via setup.py/pyproject.toml; gerir versões e dependências
• Automatizar passos de CI/CD: escrever scripts Python ou bash que orquestram jobs de GitHub Actions ou GitLab CI

Nível: 5 – Especialista
Tópicos:

• Desenvolver e publicar ferramentas CLI Python autónomas usando frameworks como Click ou Typer; publicar pacotes no PyPI
• Arquitetar grandes frameworks bash: scripts modulares, sistemas de plugins, coprocessos, redirecionamento avançado de I/O
• Analisar e otimizar scripts Python (por ex., cProfile, line_profiler), adotar asyncio para tarefas de alto throughput
• Integrar scripts com serviços do sistema: escrever ficheiros unit do systemd, scripts de entry-point de contentores, automação Docker-Compose
• Definir e ensinar boas práticas de scripting à equipa: segurança (sanitização de input, evitar injeção), documentação e templates de código sustentável

23 – Fundamentos de Cloud e Dashboards

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o conceito de plataformas IoT baseadas em cloud vs soluções on-premise
• Registar-se numa conta trial gratuita do AWS IoT Core ou do Azure IoT Hub
• Navegar o portal AWS IoT ou Azure: explorar a secção Things/Devices e ver os dashboards de visão geral
• Instalar e correr uma ferramenta de desktop (AWS IoT Explorer ou Azure IoT Explorer) para ligar e enviar uma mensagem de telemetria de exemplo
• Compreender o que é o InfluxDB: instalar uma instância local de InfluxDB 2.x via Docker ou binário, correr o CLI integrado e escrever um único ponto de dados

Nível: 2 – Principiante
Tópicos:

• Registar um dispositivo (“Thing”) no AWS IoT Core ou um dispositivo no Azure IoT Hub; descarregar e inspecionar os certificados gerados ou tokens SAS
• Usar o AWS IoT SDK (C/Python) ou o Azure Device SDK para publicar telemetria JSON simples sobre MQTT
• Instalar o Grafana, adicionar o InfluxDB como data source e criar um painel básico de séries temporais a mostrar um campo
• Escrever dados no InfluxDB a partir da linha de comandos (usando curl ou o Influx CLI) e verificá-los na UI do InfluxDB
• Explorar conceitos do Grafana: dashboards, painéis, queries, seletor de intervalo de tempo

Nível: 3 – Intermédio
Tópicos:

• Implementar código de dispositivo em estilo de produção: ligações MQTT persistentes, lógica de reconexão, payloads JSON estruturados, hierarquias de tópicos
• Definir uma AWS IoT Rule para encaminhar a telemetria recebida para uma função Lambda, tabela DynamoDB ou stream Kinesis
• Configurar tasks do InfluxDB ou Telegraf para ingerir e transformar streams de dados recebidos automaticamente
• Construir dashboards Grafana multi-painel usando queries Flux ou InfluxQL: adicionar gauges, gráficos e painéis stat
• Configurar regras simples de alerta no Grafana baseadas em limiares e configurar um canal de notificação por email ou Slack

Nível: 4 – Avançado
Tópicos:

• Blindar a autenticação: restringir as políticas IoT na AWS, afinar o RBAC do Azure IoT Hub, rodar certificados/tokens SAS em calendário
• Usar AWS IoT Device Shadows ou Azure Digital Twins para sincronizar o estado desejado/reportado entre cloud e dispositivo
• Escalar o InfluxDB com políticas de retenção, continuous queries ou Tasks e shard groups para armazenamento de longo prazo
• Implementar provisioning do Grafana (como código) para gerir dashboards e alertas através de ficheiros JSON/YAML em Git
• Integrar o Grafana com gestores de alertas externos ou serviços de notificação (PagerDuty, OpsGenie, Microsoft Teams)

Nível: 5 – Especialista
Tópicos:

• Arquitetar uma backbone IoT global e resiliente: failover multi-região do AWS IoT Core ou Azure IoT Hub, integração de edge-gateway com Greengrass ou Azure IoT Edge
• Automatizar toda a infraestrutura: escrever módulos Terraform ou templates ARM/Bicep para implementar recursos IoT, clusters InfluxDB, instâncias Grafana e políticas IAM
• Otimizar a ingestão de dados de alto volume: escritas em lote, técnicas de compressão, estratégias de backpressure e procedimentos de backfill
• Desenhar e impor dashboards multi-tenant no Grafana com RBAC granular e filtragem de data sources
• Mentorar equipas em boas práticas de controlo de custos, conformidade de segurança (GDPR, HIPAA), políticas de retenção de dados e monitorização operacional do stack de analytics IoT

24 – Conformidade Regulamentar e Ambiental

Nível: 1 – Principiante Absoluto
Tópicos:

• Aprender porque a aprovação regulamentar e as classificações ambientais importam para um dispositivo comercial
• Compreender o âmbito da marcação CE (UE) vs certificação FCC (EUA) vs códigos IP básicos
• Identificar que diretivas se aplicam (por ex. EMC, LVD para CE; Part 15 para FCC) e o que significa uma classificação IP67
• Encontrar e guardar recursos oficiais: base de dados NANDO da UE, portal de autorização de equipamento da FCC

Nível: 2 – Principiante
Tópicos:

• Estudar as normas essenciais: imunidade/emissões EMC (EN 61326-1 / FCC Part 15 Subpart B), segurança (EN 61010‐1)
• Aprender como as classificações IP são testadas (jato de água, câmara de pó) e o que significa cada dígito
• Reunir datasheets e declarações de conformidade dos fornecedores para cada módulo ou componente
• Documentar o caminho de conformidade esperado numa folha de cálculo ou checklist simples

Nível: 3 – Intermédio
Tópicos:

• Redigir um Ficheiro Técnico (CE) ou plano de testes FCC: incluir diagramas de blocos, esquemas, BOM, avaliação de riscos
• Implementar mitigação básica de EMI/EMC: adicionar ferrites, chokes de modo comum, ground pours na PCB
• Realizar testes internos de pré-conformidade: sondagem EMI de campo próximo, testes com pistola ESD, verificações básicas de isolamento
• Preparar a arte de rotulagem do dispositivo: marca CE, FCC ID, símbolos WEEE, avisos de uso seguro

Nível: 4 – Avançado
Tópicos:

• Gerir o processo formal de certificação com um Organismo Notificado (CE) ou laboratório acreditado FCC: submeter amostras, testemunhar testes
• Analisar relatórios de testes, conduzir alterações de design para resolver falhas (por ex. modificações de layout, vedações da caixa)
• Coordenar testes ambientais e mecânicos: ciclos térmicos, vibração, testes de ingresso para atingir a classificação IP alvo
• Montar e assinar a Declaração de Conformidade (CE) e submeter o Formulário FCC 731 para autorização de equipamento

Nível: 5 – Especialista
Tópicos:

• Definir uma estratégia global de conformidade abrangendo CE, FCC, UL/CSA, RoHS, REACH, WEEE e outras conforme necessário
• Arquitetar hardware e firmware modulares para simplificar re-testes e variantes regionais
• Liderar programas de conformidade de fornecedores: impor controlo de alterações de componentes, auditar o QMS do fabricante
• Manter e atualizar Ficheiros Técnicos e exibições FCC ao longo das revisões do produto; gerir auditorias periódicas de vigilância
• Servir como o elo principal com os organismos reguladores, tratar constatações de não conformidade e ações corretivas, mentorar a equipa em boas práticas de gestão regulamentar contínua.

25 – Ferramentas de Documentação (Markdown, Doxygen)

Nível: 1 – Principiante Absoluto
Tópicos:

• Compreender o propósito da documentação de projeto: READMEs, referências de API, how-tos
• Instalar um editor de Markdown ou usar o suporte integrado do VS Code
• Escrever sintaxe básica de Markdown: cabeçalhos (#–###), negrito/itálico, listas com marcadores e numeradas
• Inserir links e imagens via Markdown ([text](url), ![alt](path))
• Pré-visualizar um README.md no VS Code ou no GitHub

Nível: 2 – Principiante
Tópicos:

• Criar tabelas, blockquotes e blocos de código cercados em Markdown
• Usar links relativos e links de âncora para documentação multi-página
• Instalar o Doxygen e gerar um Doxyfile padrão
• Anotar o source C/C++ com comentários Doxygen (///, /** ... */) para funções e tipos
• Correr o Doxygen para produzir saída HTML e navegar a documentação gerada

Nível: 3 – Intermédio
Tópicos:

• Personalizar definições do Doxyfile: caminhos de input, EXTRACT_ALL, EXTRACT_PRIVATE, suporte de diagramas, formatos de saída
• Incorporar conteúdo Markdown em comentários Doxygen e incluir ficheiros Markdown externos via \include
• Organizar a documentação em módulos e grupos usando as tags @defgroup e @addtogroup
• Integrar a execução do Doxygen no seu build CMake ou PlatformIO para que a documentação atualize a cada build
• Usar extensões do VS Code para pré-visualizar comentários combinados de Markdown e Doxygen inline

Nível: 4 – Avançado
Tópicos:

• Estender o Doxygen com filtros de tags personalizados ou pré-processadores de input (por ex. scripts Python)
• Automatizar builds de documentação em pipelines de CI e publicar no GitHub Pages, GitLab Pages ou Confluence via conversores
• Gerar diagramas PlantUML ou Graphviz a partir de anotações de código e incluí-los na documentação
• Manter métricas de cobertura de documentação: escrever scripts para detetar funções/tipos não documentados e falhar o CI se abaixo de um limiar
• Definir e publicar um guia de estilo para uso de Markdown e Doxygen em toda a equipa

Nível: 5 – Especialista
Tópicos:

• Desenvolver layouts e temas personalizados de Doxygen (XSLT, templates CSS/HTML personalizados) para corresponder ao branding empresarial
• Arquitetar um pipeline híbrido de documentação usando Sphinx ou MkDocs juntamente com Doxygen, com saídas versionadas e pesquisa
• Automatizar a inclusão de documentação entre repositórios via submódulos Git, Doxyfiles compostos ou linking baseado em tags
• Liderar revisões de documentação, impor quality gates de CI na documentação e mentorar a equipa em boas práticas
• Contribuir para ferramentas open-source de documentação ou criar plugins/extensões (por ex., para renderização avançada de diagramas ou exemplos de código ao vivo)