Scala da 5 a 1

Il piano di apprendimento di uno sviluppatore embedded deve rispecchiare la bill of materials. L’abbiamo imparato a nostre spese durante il rollout di un nodo di monitoraggio del suolo alimentato a energia solare costruito su ESP32, backhaul cellulare SIMCom e AWS IoT Core: firmware, hardware, link radio e workflow cloud dovevano venire tutti insieme contemporaneamente, e saltare anche un solo pezzo trasformava una “rapida” modifica al firmware in settimane di debug.

Per mantenere quel piano focalizzato, valutiamo ogni competenza su una scala da 5 a 1 — un framework completamente agnostico rispetto alla tecnologia:

Come applicarla ovunque

1. Definite l’obiettivo finale. Che aspetto ha “pronto al lavoro” o “pronto alla produzione”?
2. Elencate i 5. Il kit di sopravvivenza assoluto.
3. Identificate i 4. Le pratiche che irrobustiscono e scalano la soluzione.
4. Riempite i 3. Strumenti di qualità della vita e ottimizzazioni.
5. Aggiungete i 2 e gli 1. Profondità specializzata per team più grandi o funzionalità avanzate.

Prova rapida che si trasferisce bene

• Front-End Web Dev → 5: HTML/CSS, JS moderno, Git… • 4: React/Vue, TypeScript, Jest, CI/CD… • 3: Storybook, test e2e… • 2: PWA, animazioni… • 1: WebGL, data-viz.
• Data Science / MLOps → 5: Python, NumPy/Pandas, statistica… • 4: TensorFlow/PyTorch, Docker, unit test… • 3: Feature store, MLflow… • 2: Edge inference… • 1: Federated learning.

Valutando l’impatto e la frequenza di ogni argomento, tracciate un percorso chiaro ed evitate il sovraccarico.

Come appaiono i 5 per il nostro stack ESP32 + SIM + AWS

1. Fluidità in C/C++ – il linguaggio di ESP-IDF e degli hook di FreeRTOS.
2. Padronanza di ESP-IDF (o Arduino-ESP32) – API di Wi-Fi, BLE, ADC, deep-sleep.
3. Fondamenti di elettronica – level-shifting degli UART SIM, lettura delle sonde NPK, igiene EMI.
4. Power budgeting e ricarica Li-ion/solare – mantenere in vita una 18650 da 4 Ah attraverso settimane nuvolose.
5. Connettività robusta (Wi-Fi, SIM AT, MQTT/TLS) – convogliare i dati dei sensori in AWS in modo sicuro.

Padroneggiate questi cinque e potete spedire un prototipo funzionale. Salite nei 4 — pipeline CI, FreeRTOS avanzato, OTA, sicurezza — e avrete un prodotto che sopravvive al campo. I 3, 2 e 1 completano il toolkit professionale con dashboard, conformità e profondità specifica del dominio.

L’articolo che segue non è una checklist; è una roadmap sequenziale mappata su scelte hardware reali. Partite dai 5, diplomatevi attraverso i 4, e quando arriverete in territorio 3-a-1 avrete sia la fiducia sia il contesto per applicarli dove contano di più, dalla breadboard alla produzione.

Competenze per sviluppatori embedded

Legenda – Importanza
5 = Indispensabile (irrinunciabile per il lavoro quotidiano)
4 = Molto importante (necessario nella maggior parte dei progetti)
3 = Utile (frequentemente d’aiuto, da imparare presto)
2 = Nice-to-have (da imparare quando il tempo lo permette)
1 = Specializzato / situazionale

Come leggere la tabella

• Partite dai 5: padronanza del linguaggio, SDK del microcontrollore, basi hardware, progettazione del sistema di alimentazione, know-how dei sensori e comunicazioni cellulari fanno la differenza tra successo e fallimento per un dispositivo da campo affidabile.
• Affrontate poi i 4: ambiente di sviluppo, ottimizzazione dei consumi, OTA, RTOS e sicurezza trasformano un prototipo funzionale in un prodotto pronto alla produzione.
• I 3 completano il workflow professionale (CI, unit test, backend cloud, CAD per PCB).
• I 2 e gli 1 aggiungono profondità per team più grandi o funzionalità avanzate e possono essere rimandati se le tempistiche sono strette.
• Usatela come roadmap delle competenze: progredite da sinistra a destra lungo la scala di importanza man mano che il progetto matura.

1 – C/C++

Livello: 1 – Principiante assoluto
– Sintassi e struttura del C: modello di compilazione (sorgente → oggetto → eseguibile), funzione main()
– Tipi di dato base: int, char, float, double, bool
– Variabili e costanti: dichiarazione, inizializzazione, qualificatore const
– Operatori: aritmetici (+, –, *, /, %), assegnazione, incremento/decremento
– Control flow: if/else, switch, cicli for/while/do-while
– I/O semplice: printf, output base su console
– Introduzione ai puntatori: dichiarazione di puntatori, dereferenziazione
– Build e debug: compilare con gcc -o, interpretare gli errori base del compilatore

Livello: 2 – Principiante
– Memoria e puntatori: aritmetica dei puntatori, puntatori vs array, introduzione a malloc/free
– Tipi strutturati: struct, union, typedef
– Basi del preprocessore: #define, #include, include guard
– Classi di storage: auto, static, extern, regole di scope e linkage
– Stringhe e array: char[], funzioni sulle stringhe (strcpy, strlen, ecc.)
– Codice modulare: suddivisione in più file .c/.h, fondamenti di makefile (regole, target)
– Strumenti di debug base: stepping con gdb, breakpoint, ispezione delle variabili

Livello: 3 – Intermedio
– Gestione della memoria dinamica: heap vs stack, pattern comuni di leak, uso di strumenti come Valgrind
– File I/O: fopen/fread/fwrite/fclose, file pointer, gestione degli errori
– Operazioni bitwise: maschere, shift, set/clear di bit, enum e bit-field
– Puntatori a funzione: callback, dispatch table
– Gestione degli errori: codici di ritorno, errno
– Fondamenti di C++: classi e oggetti, costruttori/distruttori, specificatori di accesso
– Basi della STL: std::vector, std::string, uso semplice di std::map e iteratori
– Namespace e organizzazione degli header

Livello: 4 – Avanzato
– Specificità del C embedded: volatile, I/O memory-mapped, const in flash vs RAM
– Linker e build system: linker script custom, posizionamento delle sezioni, flag di ottimizzazione (-O2, -Os), toolchain di cross-compilazione
– Funzionalità C++11/14/17: lambda, auto, range-based for, constexpr, nullptr
– Smart pointer e RAII: unique_ptr, shared_ptr, gestione delle risorse
– Basi dei template: template di funzioni e classi, specializzazione dei template
– Multithreading: std::thread, mutex, condition variable, tipi atomici
– Concetti real-time: interrupt service routine (ISR), sezioni critiche, mitigazione della priority inversion

Livello: 5 – Esperto
– Meta-programmazione avanzata con template: variadic template, SFINAE, type trait
– Modello a oggetti profondo del C++: vtable, layout degli oggetti, considerazioni sull’ABI
– Concorrenza lock-free e a bassa latenza: atomici, memory ordering, algoritmi wait-free
– Interni di compilatore e toolchain: pipeline dei pass di GCC/Clang, scrittura di plugin custom per il compilatore
– Ottimizzazione delle prestazioni: allineamento della cache, branch prediction, profiling approfondito (per esempio gprof, hardware counter)
– Porting bare-metal: implementazione degli stub di newlib, runtime C minimale, codice di bring-up
– Standard e sicurezza: conformità MISRA-C/C++, strumenti di static analysis (Coverity, Cppcheck)
– Contributo a framework: scrittura/ottimizzazione di driver per gli interni di FreeRTOS o ESP-IDF

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

Livello: 1 – Principiante assoluto
– Installare la toolchain ESP-IDF (Python, Git, script ESP-IDF) o il core Arduino-ESP32
– Configurare VS Code (o l’Arduino IDE) per lo sviluppo ESP32
– Compilare e flashare l’esempio “blink”
– Esplorare il layout del progetto (CMakeLists.txt, sdkconfig o platformio.ini)
– Usare i comandi base di idf.py (o Arduino): build, clean, flash, monitor

Livello: 2 – Principiante
– GPIO: configurare i pin, leggere gli ingressi, pilotare LED
– ADC: campionare canali analogici, convertire i valori grezzi in tensione
– UART e I²C: inviare/ricevere stringhe o byte semplici
– Modalità Wi-Fi station: scansione degli AP, connessione, recupero dell’IP
– Periferica BLE: advertising, connessione da un’app sul telefono
– Ritoccare menuconfig (partition table, livello di log) o le impostazioni della scheda Arduino

Livello: 3 – Intermedio
– Task, queue e timer FreeRTOS nel framework ESP-IDF
– API degli eventi Wi-Fi: gestione di connect/disconnect, logica di riconnessione
– BLE client e GATT: scoperta dei servizi, lettura/scrittura delle caratteristiche
– SPI e I²C: integrare e calibrare un sensore reale (per esempio di umidità del suolo)
– Aggiornamenti OTA via HTTP(S): configurare le partizioni, attivare gli aggiornamenti
– Usare esp_timer, logging dettagliato (ESP_LOG*) e codici di errore

Livello: 4 – Avanzato
– Creare componenti riusabili (CMake Component API) o librerie Arduino custom
– Costruire una partition table custom e cambiare partizione a runtime
– Provisioning sicuro: SmartConfig, setup Wi-Fi basato su BLE
– Esempi di BLE avanzato (L2CAP, mesh)
– Ottimizzare SPI DMA e le impostazioni di velocità/timeout del bus I²C
– Integrare mbedTLS per MQTT su TLS
– Automatizzare build/flash/test in CI (GitHub Actions, script CI di ESP-IDF)

Livello: 5 – Esperto
– Contribuire nuovi driver o correggere bug nel core di ESP-IDF (per esempio calibrazione ADC)
– Sviluppare bootloader custom o ottimizzazioni a livello ISR
– Ottimizzare le regioni di heap di FreeRTOS e i parametri dello scheduler
– Implementare secure boot e flash encryption end-to-end
– Eseguire tracing e profiling real-time (ESP-Trace, Perfcnt)
– Progettare workspace CMake multi-progetto
– Fare da mentore ad altri: definire best practice di ESP-IDF e librerie di componenti interne

3 – Fondamenti di FreeRTOS

Livello: 1 – Principiante assoluto
– Capire cos’è un RTOS e perché usarne uno
– Installare FreeRTOS (via ESP-IDF o PlatformIO) e ispezionare l’esempio demo con il task “hello world”
– Imparare l’API base per creare e avviare un singolo task (xTaskCreate, vTaskStartScheduler)
– Esplorare il system tick e come lo scheduler commuta tra i task
– Usare vTaskDelay per bloccare un task per un tempo fisso

Livello: 2 – Principiante
– Creare più task con priorità e dimensioni di stack diverse
– Usare vTaskDelayUntil per il timing periodico dei task
– Capire e applicare le sezioni critiche (taskENTER_CRITICAL / taskEXIT_CRITICAL)
– Imparare gli stati dei task (Running, Ready, Blocked, Suspended)
– Usare vTaskSuspend / vTaskResume per il controllo semplice dei task

Livello: 3 – Intermedio
– Comunicare tra task con le queue (xQueueCreate, xQueueSend, xQueueReceive)
– Sincronizzare i task usando semafori binari e di conteggio (xSemaphoreCreateBinary, xSemaphoreTake)
– Coordinare eventi con gli Event Group (xEventGroupSetBits, xEventGroupWaitBits)
– Usare i software timer (xTimerCreate, callback)
– Rilevare e gestire gli stack overflow

Livello: 4 – Avanzato
– Ottimizzare l’allocazione di memoria: scegliere e configurare gli schemi di heap (heap_1…heap_5) e capire la frammentazione
– Impiegare le task notification come semafori binari leggeri o messaggi dati diretti al task
– Configurare e usare la modalità tickless idle per applicazioni a basso consumo
– Generare e interpretare le statistiche di runtime (vTaskGetRunTimeStats)
– Integrare FreeRTOS+Trace o Percepio Tracealyzer

Livello: 5 – Esperto
– Portare FreeRTOS su hardware custom o modificare il port layer per casi d’uso avanzati
– Implementare e ottimizzare policy dello scheduler custom o hook function (vApplicationIdleHook, vApplicationMallocFailedHook)
– Progettare state machine complesse usando primitive di sincronizzazione avanzate (mutex con priority inheritance, mutex ricorsivi)
– Fare da mentore ai team su best practice, sicurezza (codice conforme a MISRA) e ottimizzazione del comportamento deterministico

4 – Git & GitHub/GitLab

Livello: 1 – Principiante assoluto
– Installare Git; configurare user.name e user.email
– Inizializzare un repo (git init) e clonare repo esistenti (git clone)
– Tracciamento base dei file: git status, git add, git commit
– Vedere la cronologia con git log, ispezionare le modifiche con git diff
– Un semplice .gitignore per escludere file

Livello: 2 – Principiante
– Creare e cambiare branch: git branch, git checkout/git switch
– Setup dei remote: git remote add, git fetch, git pull, git push
– Capire origin/main vs branch locali
– Risolvere semplici conflitti di merge via editor o CLI
– Usare la web UI di GitHub/GitLab per navigare commit e branch

Livello: 3 – Intermedio
– Merge vs rebase: git merge, git rebase; sapere quando usare ciascuno
– Rebase interattivo (git rebase -i) per ripulire i commit
– Tag: creare tag annotated e lightweight; pushare con git push –tags
– Lavorare con le pull request (GitHub) o merge request (GitLab): creare, revisionare, mergiare
– Stub CI base: aggiungere un semplice YAML di GitHub Actions o GitLab CI

Livello: 4 – Avanzato
– Gestire submodule (git submodule) e subtree
– Scrivere hook lato client (pre-commit, pre-push) e semplici hook lato server GitLab/GitHub
– Proteggere i branch e imporre controlli di merge (status check, approvazioni)
– Costruire pipeline CI/CD multi-stadio con caching e artifact
– Usare git bisect per localizzare i bug; cherry-pick di commit specifici

Livello: 5 – Esperto
– Amministrare le impostazioni org di GitLab/GitHub: permessi di utenti/gruppi, branch protetti
– Progettare strategie monorepo; gestire file grandi con Git LFS
– Sviluppare tooling o script Git custom (libgit2, hook, automazione)
– Approfondire gli interni di Git: object storage, packfile, ref, index
– Definire e far rispettare workflow (Gitflow, trunk-based, GitOps); fare da mentore al team sulle best practice

5 – VS Code

Livello: 1 – Principiante assoluto
Argomenti:

• Installare VS Code su Windows, macOS o Linux
• Esplorare la UI: Activity Bar, Side Bar, riquadri dell’editor, Status Bar
• Aprire cartelle e file; editing di testo base (tab, split view)
• Usare il terminale integrato per eseguire comandi shell
• Invocare la Command Palette (Ctrl+Shift+P) per le azioni comuni
• Eseguire semplici Find & Replace (Ctrl+F / Ctrl+H)

Livello: 2 – Principiante
Argomenti:

• Scoprire e installare estensioni: C/C++ (ms-vscode.cpptools), ESP-IDF, Arduino-ESP32, PlatformIO IDE
• Personalizzare le impostazioni User vs Workspace via settings.json
• Usare la vista Source Control integrata: stage, commit, push/pull
• Configurare Task base (tasks.json) per compilare e flashare un “Hello World” su ESP32
• Navigare il codice con le viste Outline e Breadcrumbs
• Inserire e usare semplici snippet di codice

Livello: 3 – Intermedio
Argomenti:

• Configurare IntelliSense: impostare include path e macro in c_cpp_properties.json
• Creare configurazioni di lancio (launch.json) per il debug GDB via OpenOCD o JTAG
• Definire Task compositi: build → flash → monitor → lint
• Lavorare in workspace multi-root (codice + documenti + test)
• Integrare linter e formatter (clang-format, cppcheck) come azioni pre-salvataggio
• Debuggare task FreeRTOS con il thread-aware debugging e la vista Debug
• Usare il pannello Problems e il Test Explorer per gli unit test

Livello: 4 – Avanzato
Argomenti:

• Sfruttare il Remote Development: workspace SSH, WSL e container Docker
• Creare e condividere snippet di codice e template di file custom per ESP-IDF/PlatformIO
• Automatizzare la CI: esportare i Task di VS Code in pipeline GitHub Actions o GitLab CI
• Personalizzare i keybinding e usare Settings Sync per condividere la configurazione tra macchine
• Sviluppare Task Provider riusabili via la VS Code Tasks API
• Usare breakpoint condizionali e a funzione, logpoint ed espressioni di watch

Livello: 5 – Esperto
Argomenti:

• Sviluppare e pubblicare estensioni VS Code complete (TypeScript ed Extension API) per workflow ESP32
• Progettare grandi workspace multi-progetto con configurazioni condivise e versionate
• Ottimizzare le prestazioni dell’IDE: ottimizzare l’attivazione delle estensioni, ridurre tempo di avvio e uso di memoria
• Implementare la distribuzione di impostazioni a livello aziendale (Settings Cycler, deployment basato su GPO)
• Fare da mentore ai colleghi sulle best practice di VS Code e risolvere workflow complessi
• Contribuire alla community di VS Code: scrivere guide, repo di esempio e parlare a meetup o workshop

6 – PlatformIO

Livello: 1 – Principiante assoluto
Argomenti:

• Installare l’estensione PlatformIO IDE in VS Code (o installare PIO Core CLI)
• Creare un nuovo progetto PlatformIO (pio init --board esp32dev)
• Ispezionare la struttura del progetto: cartelle platformio.ini, src/, lib/
• Compilare (pio run) e caricare (pio run --target upload) l’esempio “blink” predefinito
• Aprire il monitor seriale (pio device monitor) per vedere l’output

Livello: 2 – Principiante
Argomenti:

• Usare il Library Manager: pio lib install, pio lib list, aggiungere librerie in platformio.ini
• Configurare ambienti multipli (sezioni env:) per schede o modalità di build diverse
• Impostare build_flags, monitor_speed e upload_speed in platformio.ini
• Eseguire clean build (pio run --target clean) e verbose build (pio run --target verbose)
• Usare l’Unified Debugger (pio debug) per impostare breakpoint e avanzare passo passo nel codice

Livello: 3 – Intermedio
Argomenti:

• Gestire build Debug vs Release e ambienti abilitati all’OTA in un unico platformio.ini
• Integrare gli unit test con il PlatformIO Test Runner e il framework Unity
• Aggiungere static analysis: abilitare cppcheck o clang-tidy via script extra o configurazioni di platformio.ini
• Automatizzare passi custom pre- o post-build usando extra_scripts
• Pubblicare e consumare librerie private attraverso il PlatformIO Registry

Livello: 4 – Avanzato
Argomenti:

• Creare e pubblicare pacchetti Platform e Board custom per uso interno o della community
• Implementare protocolli di upload avanzati (JTAG, OTA, script di upload custom)
• Costruire pipeline CI usando script pio ci per GitHub Actions, GitLab CI o Jenkins
• Generare e automatizzare report di code coverage per gli unit test
• Profilare le dimensioni del firmware e l’uso di RAM tramite la Dashboard di PlatformIO IDE

Livello: 5 – Esperto
Argomenti:

• Contribuire miglioramenti o correzioni a PlatformIO Core e alle Community Platform ufficiali
• Sviluppare plugin PlatformIO custom per estendere le funzionalità di CLI e IDE
• Progettare e mantenere grandi workspace monorepo o multi-progetto usando PIO Projects
• Scrivere hook di build avanzati per integrare toolchain aziendali e workflow di deployment
• Fare da mentore ai team sulle best practice di PlatformIO e risolvere complessi problemi di build/debug cross-platform

7 – Linux CLI / WSL

Livello: 1 – Principiante assoluto
Argomenti:

• Aprire un terminale su Linux o WSL
• Navigare il filesystem: ls, cd, pwd, mkdir
• Visualizzare e ispezionare file: cat, less, head, tail
• Manipolare file: cp, mv, rm, touch
• Editare testo con un editor semplice (nano o vim base)

Livello: 2 – Principiante
Argomenti:

• Permessi e proprietà dei file: chmod, chown, capire i bit rwx
• Wildcard, globbing, piping (|) e redirezione (>, >>, <)
• Cercare testo nei file: basi di grep
• Gestire le variabili d’ambiente e il profilo della shell (.bashrc, .profile)
• Installare e aggiornare pacchetti col package manager della vostra distro (apt, yum, pacman)
• Connettersi a host remoti via ssh e trasferire file con scp

Livello: 3 – Intermedio
Argomenti:

• Scrivere script Bash: shebang, variabili, cicli, condizionali, funzioni
• Elaborazione del testo con find, xargs, awk, sed
• Controllo di processi e job: ps, top/htop, kill, jobs, bg/fg
• Configurare regole udev per gli adattatori USB/JTAG dell’ESP32
• Invocare toolchain di cross-compilazione e build system (make, cmake, idf.py) dalla CLI
• Eseguire OpenOCD dalla riga di comando per flashare e debuggare via JTAG/SWD

Livello: 4 – Avanzato
Argomenti:

• Sviluppare shell script robusti: gestione degli errori, logging, unit test (ShellCheck)
• Automatizzare pipeline complete build–flash–test in shell e integrarle nella CI (GitHub Actions, GitLab CI)
• Containerizzare l’ambiente di build con Docker o Podman; scrivere Dockerfile per build riproducibili
• Debug remoto e sincronizzazione dei file: port forwarding con ssh, rsync, tmux/screen per la persistenza delle sessioni
• Profilare e debuggare strumenti nativi: strace, ltrace, perf

Livello: 5 – Esperto
Argomenti:

• Compilare e mantenere kernel Linux o moduli custom per target embedded
• Progettare e operare CI runner dedicati (bare-metal o containerizzati) ottimizzati per cross-compilazioni embedded
• Implementare tecniche avanzate di caching e build distribuite (ccache, distcc)
• Progettare i propri framework CLI o toolchain, gestire i dotfile tra team (guidati da Git)
• Fare da mentore ad altri sulle best practice per l’uso della shell, workflow basati su terminale e automazione dei task di test hardware e deployment

8 – Framework di unit testing (Unity / CppUTest)

Livello: 1 – Principiante assoluto
Argomenti:

• Capire lo scopo e i benefici dello unit testing
• Installare Unity o CppUTest (via libreria PlatformIO, pacchetto pip o da sorgente)
• Creare un file di test minimale e includere gli header del framework
• Scrivere una semplice funzione di test usando la macro TEST (Unity) o TEST_GROUP/TEST (CppUTest)
• Eseguire il test runner dalla riga di comando e interpretare l’output PASS/FAIL
• Usare le macro di assertion base (per esempio TEST_ASSERT, CHECK_EQUAL)

Livello: 2 – Principiante
Argomenti:

• Organizzare i test in suite o gruppi
• Implementare le funzioni setUp() e tearDown() per le test fixture
• Usare una gamma più ampia di assertion: float, stringhe, confronti di memoria
• Parametrizzare i test o iterare sui dati di test
• Integrare compilazione ed esecuzione dei test nella build PlatformIO o CMake
• Generare semplici dati di code coverage (per esempio via gcov) e vedere le percentuali base di coverage

Livello: 3 – Intermedio
Argomenti:

• Creare stub e fake per le funzioni dipendenti dall’hardware (letture I²C, conversioni ADC)
• Introdurre una libreria di mocking (CppUMock o CMock di Unity) per simulare le dipendenze
• Scrivere test per codice asincrono: simulare callback, interrupt o timer FreeRTOS
• Automatizzare le esecuzioni dei test con shell script o un CI job base
• Raccogliere e analizzare metriche di coverage dettagliate (coverage di branch e funzioni)
• Testare estensivamente le condizioni di confine e di errore

Livello: 4 – Avanzato
Argomenti:

• Sviluppare implementazioni di mock custom per driver di basso livello e astrazioni delle periferiche
• Usare plugin di rilevamento dei memory leak (il MemoryLeak detector di CppUTest)
• Portare il test runner sul dispositivo per unit test on-target
• Scrivere test per le primitive di concorrenza: semafori, queue, task notification in FreeRTOS
• Integrare report di coverage e test in una dashboard CI (output JUnit/XUnit XML)
• Impiegare macro di assertion avanzate e funzionalità di parametrizzazione dei test

Livello: 5 – Esperto
Argomenti:

• Estendere o personalizzare il framework di testing: scrivere plugin, reporter custom o nuove macro di assertion
• Progettare un’infrastruttura di test scalabile su più progetti e piattaforme
• Implementare harness di test hardware-in-the-loop (HIL) o firmware-in-the-loop (FIL) con controllo automatizzato delle fixture
• Fare da mentore ai team su TDD, test design pattern e far rispettare le policy di testing
• Contribuire ai progetti open source Unity o CppUTest (bug fix, nuove funzionalità)
• Ottimizzare l’esecuzione parallela dei test, gli ambienti di test containerizzati e minimizzare l’overhead di runtime dei test

9 – Continuous Integration (GitHub Actions / GitLab CI)

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare cos’è la Continuous Integration (CI) e perché conta (build e test automatizzati)
• Identificare i servizi CI più diffusi: GitHub Actions vs GitLab CI
• Creare il file di configurazione CI più semplice (.github/workflows/ci.yml o .gitlab-ci.yml)
• Aggiungere un job che fa checkout del codice (actions/checkout o git clone) e stampa un messaggio hello
• Attivare il workflow a ogni push sul branch principale e vedere i log base nella web UI

Livello: 2 – Principiante
Argomenti:

• Estendere il job CI per installare le dipendenze (per esempio Python/pip, PlatformIO, ESP-IDF)
• Aggiungere passi di build: compilare il firmware (idf.py build o pio run)
• Eseguire gli unit test via pio test o un test runner custom e interpretare pass/fail
• Imparare a leggere e filtrare l’output dei log per errori e warning
• Fare commit e push delle modifiche per attivare la CI; correggere semplici fallimenti di build

Livello: 3 – Intermedio
Argomenti:

• Suddividere build, test, lint e static analysis in job o stadi separati
• Usare le action integrate (o i template GitLab) per il caching degli artifact della toolchain (actions/cache)
• Implementare una matrix build per testare più schede o versioni della toolchain in parallelo
• Archiviare gli artifact di build (binari del firmware, report di test, dati di coverage) per il download
• Configurare dipendenze tra job ed esecuzione condizionale (needs: in GitHub Actions, stage: in GitLab CI)

Livello: 4 – Avanzato
Argomenti:

• Integrare strumenti di code coverage (gcov, lcov) e pubblicare badge di coverage
• Automatizzare i controlli di dimensione del firmware e uso di memoria; fallire se le soglie vengono superate
• Deployare firmware pronto per l’OTA su un dispositivo di staging via SSH o runner custom
• Gestire in modo sicuro secret e token (GitHub Secrets, variabili CI/CD di GitLab)
• Usare runner self-hosted o container Docker per ambienti di build custom

Livello: 5 – Esperto
Argomenti:

• Sviluppare action CI riusabili custom o immagini Docker ottimizzate per build ESP32
• Progettare pipeline multi-progetto: librerie condivise, gestione dei submodule, trigger cross-repo
• Implementare workflow avanzati: preview dei feature branch, canary deployment, rollback automatici
• Imporre la conformità con policy sui branch protetti, commit firmati e audit log
• Fare da mentore e documentare le best practice CI/CD tra i team; formare sulla risoluzione di fallimenti complessi delle pipeline

10 – Jira & Confluence

Livello: 1 – Principiante assoluto
Argomenti:

• Capire lo scopo dell’issue tracking rispetto alla documentazione
• Registrarsi a Jira Cloud (o connettersi a un’istanza esistente)
• Navigare la UI di Jira: progetti, issue, backlog, board
• Creare una issue base: selezionare progetto, tipo di issue, sommario, descrizione
• Far transitare una issue attraverso un workflow semplice (To Do → In Progress → Done)
• Aggiungere commenti e allegati a una issue
• Registrarsi a Confluence (o accedere allo spazio del vostro team)
• Creare una pagina Confluence: titolo, corpo del testo, salvare e modificare

Livello: 2 – Principiante
Argomenti:

• Lavorare con diversi tipi di issue (Task, Bug, Story, Epic) e campi di priorità
• Usare le board Jira base: Scrum e Kanban, muovere le card tra le colonne
• Filtrare le issue con JQL semplice (per esempio project = “XYZ” AND status = “Open”)
• Configurare semplici notifiche email e osservare le issue
• In Confluence, organizzare le pagine in Space e gerarchie genitore-figlio
• Usare le macro comuni: Code Block, Table, Panel, Image
• Inserire link a issue Jira ed elenchi di issue nelle pagine Confluence

Livello: 3 – Intermedio
Argomenti:

• Personalizzare le schermate delle issue e aggiungere campi custom
• Definire e modificare workflow semplici: stati, transizioni, validatori
• Creare e condividere dashboard con gadget (Filter Results, Burndown Chart)
• Scrivere query JQL avanzate per filtri e board complessi
• Configurare le swimlane delle board per query o assegnatari
• In Confluence, creare e usare Template e Blueprint
• Gestire permessi delle pagine, etichette e restrizioni delle pagine
• Usare le macro Include Page, Excerpt e Page Properties per report dinamici

Livello: 4 – Avanzato
Argomenti:

• Costruire regole di Jira Automation: trigger, condizioni, azioni (per esempio auto-assegnazione, invio di alert)
• Configurare SLA, service desk e tracciare metriche con Jira Service Management
• Progettare board multi-progetto e release cross-project
• Usare Portfolio for Jira (Advanced Roadmaps) per pianificare tempistiche e dipendenze
• In Confluence, creare Blueprint custom e override del tema
• Incorporare contenuti dinamici: grafici da Jira, diagrammi Gliffy, macro Live
• Analizzare le analytics delle pagine e l’attività degli utenti per ottimizzare i contenuti

Livello: 5 – Esperto
Argomenti:

• Amministrare le impostazioni globali di Jira: permessi, schemi dei tipi di issue, schemi dei workflow
• Progettare workflow complessi di livello enterprise con diramazioni, approvazioni e automazione
• Integrare Jira con strumenti esterni (CI/CD, Slack, GitHub) via webhook e app
• Guidare l’implementazione ITSM: change management, workflow di incidenti/problemi
• In Confluence, sviluppare plugin custom o usare ScriptRunner per l’automazione
• Definire template di spazi, look-and-feel globale e schemi di permessi avanzati
• Fare da mentore e formare i team sulle best practice di Jira/Confluence e sulle policy di governance

11 – Elettronica digitale e analogica

Livello: 1 – Principiante assoluto
Argomenti:

• Capire le unità elettriche base: tensione (V), corrente (A), resistenza (Ω), potenza (W)
• Imparare la legge di Ohm (V = I∙R) e i calcoli base serie/parallelo
• Identificare i componenti passivi: resistori, condensatori, induttori
• Usare un multimetro per misurare tensione, corrente e resistenza in semplici circuiti DC
• Leggere e interpretare simboli circuitali e schematici base

Livello: 2 – Principiante
Argomenti:

• Costruire e analizzare reti di resistori in serie e parallelo e partitori di tensione
• Introdurre i condensatori: curve di carica/scarica, costanti di tempo RC, semplici filtri passa-basso/passa-alto
• Capire i livelli logici digitali (TTL vs CMOS) e come si traducono nei GPIO dell’ESP32
• Tecniche di level shifting: partitori resistivi, level shifter basati su MOSFET per i segnali UART
• Usare breadboard e cavetti per prototipare circuiti di interfaccia dei sensori

Livello: 3 – Intermedio
Argomenti:

• Progettare il front-end analogico per i sensori: scegliere e configurare op-amp (invertente, non invertente)
• Implementare amplificatori da strumentazione per segnali differenziali dei sensori (per esempio sonde NPK)
• Interfacciamento con l’ADC: capire fondo scala, risoluzione, frequenza di campionamento e selezione della tensione di riferimento
• Fondamenti di EMI/EMC: condensatori di disaccoppiamento, strategie di messa a terra, regole base di layout
• Analizzare e mitigare il rumore: schermatura, cablaggio a doppino intrecciato, perle di ferrite

Livello: 4 – Avanzato
Argomenti:

• Creare circuiti di misura di precisione: metodi di calibrazione, compensazione della deriva termica
• Progettazione avanzata di filtri: topologie di filtri attivi (Butterworth del secondo ordine, Bessel)
• Progettazione di alimentatori: selezione e layout di convertitori DC-DC, LDO e disaccoppiamento bulk/ceramico
• PCB layout per mixed-signal: masse analogiche/digitali separate, piste a impedenza controllata, messa a terra a stella
• Condurre controlli base di conformità EMI: sondaggio in campo vicino, tecniche di analisi dello spettro

Livello: 5 – Esperto
Argomenti:

• Progettare front-end analogici a basso rumore: soluzioni discrete custom, budget del rumore e selezione dei componenti
• Progettare e integrare IC mixed-signal: ADC/DAC ad alta risoluzione, isolamento digitale e ottimizzazione del timing SPI/I²C
• Sviluppare e validare IC di power management custom o configurazioni PMIC per dispositivi a batteria
• Guidare gli sforzi di certificazione EMI/EMC: scrivere piani di test, interpretare gli standard CE/FCC, pre-compliance testing e remediation
• Fare da mentore e revisionare i design analogici e mixed-signal del team, ottimizzare per producibilità, costo e affidabilità

12 – PCB design (KiCad / Altium)

Livello: 1 – Principiante assoluto
Argomenti:

• Capire cos’è un PCB e perché si usa (vs breadboard o millefori)
• Installare KiCad o Altium Designer ed esplorare la UI
• Creare un nuovo progetto schematico e posizionare componenti base (resistore, LED, connettore)
• Eseguire l’Electrical Rules Check (ERC) per intercettare errori evidenti di netlist
• Generare una netlist e importarla in un PCB layout vuoto
• Posizionare i footprint sul contorno della scheda e instradare semplici piste a singolo strato
• Esportare file Gerber e di foratura base

Livello: 2 – Principiante
Argomenti:

• Costruire e gestire una libreria personale di simboli e footprint
• Definire e applicare design rule: larghezze delle piste, clearance, annular ring
• Usare piani di massa e alimentazione per semplificare il routing e migliorare l’affidabilità
• Aggiungere testo serigrafico, designatori dei componenti e layer meccanici del contorno scheda
• Lavorare con footprint through-hole e surface-mount, capendo le impostazioni di pad e solder mask
• Eseguire il Design Rule Check (DRC) e correggere gli errori comuni di clearance/sovrapposizione
• Generare un pacchetto di fabbricazione completo: Gerber, NC drill, BOM

Livello: 3 – Intermedio
Argomenti:

• Creare schematici multi-foglio (gerarchici) e gestire la connettività delle net
• Definire uno stackup controllato per schede a 4 o 6 layer, incluse le dimensioni dielettriche
• Instradare coppie differenziali e coppie di segnali a lunghezza accoppiata (USB, SPI, linee high-speed)
• Usare la gestione avanzata dei piani: split plane, thermal relief, zone di pour
• Integrare modelli 3D per i controlli del contenitore e delle clearance meccaniche
• Automatizzare la generazione della BOM con campi custom ed esportare in CSV o Excel
• Collaborare via Git (o SVN) sui file di progetto PCB e gestire la cronologia delle versioni

Livello: 4 – Avanzato
Argomenti:

• Design for manufacturability (DFM): pannellizzazione, fiducial, disegni di assemblaggio
• Implementare pratiche di signal integrity high-speed: controllo dell’impedenza, via stitching, percorsi di ritorno
• Creare e riusare template di progetto con design rule e stack di layer a livello aziendale
• Eseguire analisi termiche e di distribuzione della potenza base nello strumento ECAD
• Scrivere ed eseguire script (Python in KiCad o script Altium) per automatizzare i task ripetitivi
• Sviluppare e gestire librerie di componenti centralizzate con stati di ciclo di vita e varianti approvate
• Integrare i dati ECAD col CAD meccanico per l’ingegneria concorrente

Livello: 5 – Esperto
Argomenti:

• Progettare sistemi rigid-flex e multi-scheda (backplane), definire aree di piegatura del flex e rinforzi
• Guidare design review focalizzate su DFM, DFA (assemblaggio) e DFT (test), e fare da mentore ai designer junior
• Sviluppare footprint custom conformi a IPC e creare documentazione di standard di design interni
• Guidare l’integrazione PLM/ERP per la gestione del ciclo di vita dei componenti e i workflow di approvvigionamento
• Pianificare ed eseguire pacchetti di certificazione (UL, CE, FCC) con tutta la documentazione richiesta
• Ottimizzare funzionalità avanzate: via buried/blind, impedenza controllata, design HDI con microvia
• Contribuire o personalizzare plugin dello strumento ECAD e costruire pipeline automatizzate per la validazione dei dati del fabbricante

13 – Power budgeting e ricarica solare-Li-ion

Livello: 1 – Principiante assoluto
Argomenti:

• Capire la relazione tra tensione, corrente e potenza (P = V × I)
• Imparare le caratteristiche base delle batterie Li-ion: tensione nominale (~3,7 V), capacità (mAh/Ah), intervalli di tensione sicuri
• Usare un multimetro per misurare tensione e corrente in semplici circuiti a batteria
• Identificare le rail di alimentazione base su una scheda ESP32 e leggere le loro etichette (5 V, 3,3 V)
• Familiarizzare con un piccolo pannello solare: specifiche di tensione a circuito aperto (Voc) e corrente di cortocircuito (Isc)

Livello: 2 – Principiante
Argomenti:

• Costruire un semplice foglio di calcolo del power budget: elencare ogni sottosistema (ESP32, sensore, radio) con la sua corrente operativa e il duty cycle
• Calcolare gli assorbimenti di corrente medi e di picco; stimare l’autonomia con una data capacità di batteria
• Confrontare regolatori lineari (LDO) vs semplici regolatori switching per scendere a 3,3 V
• Cablare un IC di carica Li-ion base (per esempio MCP73831) su una breadboard e osservare il comportamento del LED di carica
• Misurare l’output del pannello sotto diversi livelli di luce e imparare a leggere le curve del suo datasheet

Livello: 3 – Intermedio
Argomenti:

• Introdurre i concetti di Maximum Power Point Tracking (MPPT): perché l’MPPT migliora la raccolta di energia rispetto all’ombreggiamento passivo
• Selezionare e configurare un controller di carica solare commerciale (per esempio Adafruit Solar LiPo Charger)
• Dimensionare pannello solare e batteria per l’autonomia target e il meteo peggiore; includere margini di sicurezza
• Progettare un circuito a doppio ingresso di alimentazione: batteria più solare, con ORing a ideal-diode o diodi Schottky
• Implementare stati firmware a basso consumo (deep sleep, light sleep) e misurare la corrente quiescente

Livello: 4 – Avanzato
Argomenti:

• Valutare e scegliere tra diversi IC o moduli MPPT per uso embedded (per esempio STSPIN, serie TI BQ)
• Progettare un power tree custom su PCB: convertitori buck/boost, load switch, indicatori di power-good
• Modellare le curve di carica/scarica della batteria e gli effetti termici; simulare in SPICE o foglio di calcolo
• Implementare il power management dinamico nel firmware: adattare la frequenza di campionamento o il duty cycle della radio in base allo SoC della batteria
• Aggiungere protezioni hardware: monitoraggio di sovratensione, sottotensione, sovracorrente e temperatura

Livello: 5 – Esperto
Argomenti:

• Progettare un algoritmo MPPT completamente custom in firmware o FPGA, ottimizzato per i profili solari locali
• Sviluppare o modificare firmware di power-management IC (per esempio per un BMS custom) e ottimizzare per un’efficienza del 98%+
• Guidare il design per l’energy harvesting in ambienti estremi: poca luce, temperature estreme, analisi dell’ombreggiamento parziale
• Integrare diagnostica avanzata della salute della batteria: coulomb counting, impedance tracking, algoritmi predittivi di SoC/SoH
• Fare da mentore ai team sui compromessi dei sistemi di alimentazione, preparare documentazione per le certificazioni di sicurezza UL/IEC e ottimizzare per resa produttiva e affidabilità.

14 – Gestione delle batterie (18650)

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare le specifiche base delle celle Li-ion 18650: tensione nominale, capacità, corrente massima di carica/scarica
• Capire la sicurezza base delle celle: niente cortocircuiti, polarità corretta, evitare la sovra-scarica
• Misurare la tensione della cella con un multimetro; riconoscere i punti di carica piena (4,2 V) vs vuota (≈3,0 V)
• Identificare le funzionalità comuni degli IC di protezione: interruzione per sovratensione, sottotensione, sovracorrente
• Praticare la manipolazione sicura: usare un supporto adeguato, mai forare o schiacciare le celle

Livello: 2 – Principiante
Argomenti:

• Cablare un semplice modulo caricatore singola cella (per esempio TP4056) e monitorare i LED di stato della carica
• Capire il profilo di carica CC-CV: corrente costante fino alla soglia, poi taper a tensione costante
• Aggiungere un PCB di protezione alla cella: imparare come funziona la protezione basata su MOSFET
• Leggere le curve di carica/scarica del datasheet della cella e le linee guida di derating
• Calcolare approssimativamente lo State of Charge (SoC) dalla curva tensione vs SoC

Livello: 3 – Intermedio
Argomenti:

• Introdurre le basi del coulomb counting: misurare la carica in ingresso/uscita via resistore di sense e ADC
• Selezionare e integrare un amplificatore di current-sense (per esempio INA219 o un IC coulomb-counter dedicato)
• Calibrare il vostro sistema di coulomb counting: compensazione di offset, guadagno e deriva
• Combinare SoC basato su tensione e coulomb counting per migliorare l’accuratezza
• Implementare controlli base di salute della batteria: conteggio dei cicli, stima del decadimento della capacità

Livello: 4 – Avanzato
Argomenti:

• Progettare un circuito di carica bilanciata multi-cella (2–4 celle) con resistori di bilanciamento o IC bilanciatore attivo
• Integrare un IC BMS completo (per esempio serie TI BQ769x0): monitoraggio di sovratensione, sottotensione, sovracorrente, temperatura
• Implementare algoritmi di SoC e SoH nel firmware: Kalman filter o coulomb counter adattivo
• Aggiungere rilevamento della temperatura (NTC o digitale) e compensazione per le curve di carica/scarica
• Validare la sicurezza in condizioni di guasto: simulare cortocircuito, sovracorrente, sovratemperatura e registrare gli eventi di guasto

Livello: 5 – Esperto
Argomenti:

• Progettare un firmware BMS custom: algoritmi avanzati di bilanciamento delle celle, profili di carica adattivi
• Ottimizzare l’accuratezza del coulomb counting nel lungo periodo: correzione della deriva, compensazione della temperatura, algoritmi auto-apprendenti
• Guidare gli sforzi di certificazione: documentazione dei test IEC 62133, UL 2054, UN 38.3 e creazione dei piani di test
• Progettare funzionalità di sicurezza ridondanti: monitoraggio a doppio IC, watchdog, stati failsafe hardware
• Fare da mentore e revisionare i design del sottosistema batteria: analisi delle modalità di guasto, producibilità e piani di test di affidabilità

15 – Comunicazioni cellulari (SIMCom AT, PPP, TCP/IP)

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare i concetti cellulari base: GSM vs LTE vs NB-IoT
• Identificare il pinout della SIM card e come inserire/estrarre la SIM
• Alimentare e cablare un modulo SIMCom a un microcontrollore o a un adattatore USB-UART
• Aprire un terminale seriale (minicom, PuTTY) al baud rate corretto
• Inviare semplici comandi AT: AT, ATI, AT+CSQ
• Interpretare le risposte: OK, ERROR e i codici base di qualità del segnale

Livello: 2 – Principiante
Argomenti:

• Controllare la registrazione alla rete: AT+CREG? e AT+CGREG?
• Configurare il contesto PDP: AT+CGDCONT=1,“IP”,""
• Usare PPP per attivare un link IP: scrivere uno script chat e invocare pppd
• Verificare la connettività IP su PPP: fare ping a un host noto o usare uno strumento di test socket
• Inviare e leggere SMS: AT+CMGF=1, AT+CMGS="", AT+CMGR=
• Gestire i codici di errore base: leggere e decodificare +CME ERROR:

Livello: 3 – Intermedio
Argomenti:

• Aprire e gestire socket TCP: AT+CIPSTART=“TCP”,“host”,“port”
• Inviare e ricevere dati sul socket: AT+CIPSEND e AT+CIPRXGET
• Monitorare gli unsolicited result code (URC): +CIPSTATUS, +TCP_CLOSED
• Implementare la logica di riconnessione automatica nel firmware quando il socket o il PPP cade
• Usare le modalità sleep del modulo per il risparmio energetico: AT+CFUN, AT+CSCLK
• Proteggere il link con comandi TLS base se supportati (per esempio AT+SSLOPT)

Livello: 4 – Avanzato
Argomenti:

• Integrare l’attivazione PPP nei task RTOS con callback di evento su connect/disconnect
• Gestire APN multipli e contesti di fallback per la resilienza in roaming
• Eseguire un client MQTT sul socket cellulare usando comandi basati su AT
• Interrogare i dati GNSS/posizione se il modulo li supporta: AT+CGPS=1, AT+CGPSINFO
• Profilare throughput e latenza: misurare le velocità dati e ottimizzare il buffering del firmware
• Diagnosticare problemi RF e di rete usando i comandi estesi di informazione di rete (per esempio AT+QENG)

Livello: 5 – Esperto
Argomenti:

• Sviluppare o ottimizzare una libreria di parsing dei comandi AT con state machine e buffering robusto
• Progettare un demone PPP custom o uno stack IP leggero per sistemi profondamente embedded
• Implementare l’integrazione a livello driver: trasferimenti UART basati su DMA, controllo di flusso hardware
• Supportare modalità dati avanzate: raw socket, UDP multicast/broadcast, modalità dati SMS
• Gestire il provisioning sicuro dei certificati in flash e amministrare le sessioni TLS end-to-end
• Fare da mentore ai team sulle best practice dell’IoT cellulare: ottimizzazione dei costi, conformità normativa e considerazioni sul design di antenne/RF

16 – Protocolli IoT (MQTT / HTTPS)

Livello: 1 – Principiante assoluto
Argomenti:

• Capire cosa sono i protocolli IoT e perché contano per i dispositivi vincolati
• Imparare le basi di MQTT: modello publish/subscribe, ruolo del broker, topic, livelli QoS (0, 1, 2)
• Imparare le basi di HTTPS: richiesta/risposta client–server, principi REST, URL, metodi (GET, POST)
• Installare un client MQTT desktop (MQTT.fx, MQTT Explorer) e connettersi a un broker pubblico (per esempio test.mosquitto.org )
• Usare curl per fare semplici richieste HTTPS GET ad API pubbliche

Livello: 2 – Principiante
Argomenti:

• Scrivere firmware per connettere un ESP32 a un broker MQTT usando una libreria semplice (per esempio PubSubClient per Arduino o esp_mqtt_client per ESP-IDF)
• Pubblicare letture di sensori su un topic di test; sottoscrivere e registrare messaggi da un altro topic
• Costruire payload JSON base e fare parsing del JSON in arrivo nel firmware
• Eseguire richieste HTTPS dall’ESP32: configurare HTTPClient (Arduino) o esp_http_client (ESP-IDF)
• Gestire la validazione dei certificati a livello base (partire in modalità insicura, poi passare alla root CA corretta)

Livello: 3 – Intermedio
Argomenti:

• Implementare la persistenza della sessione MQTT: retained message, clean session = false
• Usare il Last Will and Testament (LWT) di MQTT per segnalare disconnessioni impreviste
• Organizzare gerarchie di topic con wildcard (+, #) per la messaggistica scalabile dei dispositivi
• Gestire i certificati TLS in flash: convertire PEM in DER, incorporarli nella partizione
• Gestire POST HTTPS con body JSON e fare parsing delle risposte JSON; gestire gli header

Livello: 4 – Avanzato
Argomenti:

• Progettare e implementare un’architettura MQTT sicura: certificati client, autenticazione TLS mutua
• Ottimizzare le prestazioni MQTT: publish in batch, usare il QoS appropriatamente, minimizzare l’overhead del keepalive
• Implementare l’autenticazione mutua HTTPS (certificati client) e gestire la rotazione dei certificati
• Integrare MQTT su WebSocket per dashboard basate su browser o reti vincolate
• Costruire un client REST stateful leggero su ESP32 con pattern di retry, backoff e circuit breaker

Livello: 5 – Esperto
Argomenti:

• Progettare un bridge di protocollo custom: tradurre tra CoAP, MQTT e HTTPS per reti IoT eterogenee
• Sviluppare un plugin o estensione interna del broker MQTT per autorizzazione, filtraggio o trasformazione custom
• Prototipare e valutare protocolli IoT alternativi (per esempio MQTT-SN, AMQP, LwM2M) per casi d’uso specializzati
• Guidare audit di sicurezza: threat modeling, valutazioni delle vulnerabilità degli stack di comunicazione IoT
• Fare da mentore ai team sulla progettazione di architetture di messaggistica IoT sicure, resilienti e su larga scala con protocolli ibridi

17 – Basi di sicurezza TLS / mbedTLS

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare i concetti base di crittografia: plaintext vs ciphertext, cifratura simmetrica vs asimmetrica, hashing
• Capire cosa fornisce TLS: confidenzialità, integrità, autenticità
• Studiare il flusso dell’handshake TLS ad alto livello: ClientHello, ServerHello, scambio di chiavi, record layer
• Installare mbedTLS ed esplorare la directory degli esempi programs/ssl
• Compilare ed eseguire gli esempi ssl_client1 e ssl_server2 sul vostro desktop

Livello: 2 – Principiante
Argomenti:

• Configurare mbedTLS via config.h: abilitare solo i moduli che vi servono (SSL/TLS, X.509, primitive crittografiche)
• Generare un certificato self-signed e una chiave con OpenSSL; convertire tra i formati PEM e DER
• Modificare ed eseguire ssl_client2 per eseguire una GET HTTPS contro un server pubblico
• Impostare la versione minima di TLS e scegliere cipher suite base nella configurazione SSL
• Abilitare il debug logging di mbedTLS per tracciare i passi dell’handshake e i codici di errore

Livello: 3 – Intermedio
Argomenti:

• Implementare l’autenticazione PSK (Pre-Shared Key) in mbedTLS per dispositivi vincolati
• Incorporare certificati e chiavi in flash o leggerli da una partizione del filesystem a runtime
• Usare il parser X.509 di mbedTLS per validare i certificati del server contro un bundle di root CA
• Alimentare il generatore di numeri casuali con un TRNG hardware (per esempio esp_hardware_poll dell’ESP32) via mbedtls_ctr_drbg
• Integrare mbedTLS come componente in ESP-IDF e invocare connessioni TLS da un task FreeRTOS

Livello: 4 – Avanzato
Argomenti:

• Implementare TLS mutuo (certificati client-e-server) in un ambiente embedded
• Progettare un meccanismo sicuro di rotazione dei certificati con protezione dal rollback del firmware
• Ottimizzare l’impronta di memoria: disabilitare i moduli inutilizzati, regolare l’uso di heap vs stack in mbedtls_platform_set_calloc_free
• Collegarsi a un acceleratore crittografico hardware (offload RSA/ECC) e registrarlo con il layer PK di mbedTLS
• Archiviare in sicurezza le chiavi private: usare la flash encryption o un secure element esterno (ATECC608A)

Livello: 5 – Esperto
Argomenti:

• Contribuire correzioni o nuove funzionalità al core di mbedTLS (per esempio aggiungere una nuova cipher suite o migliorare il codice a tempo costante)
• Eseguire audit di sicurezza e fuzz testing sull’handshake e sulle primitive crittografiche
• Costruire una configurazione mbedTLS conforme a FIPS 140-2 e documentare la validazione del modulo
• Sviluppare implementazioni resistenti ai side-channel e irrobustire contro attacchi di analisi dei tempi o dei consumi
• Definire e fare da mentore su policy di sicurezza di livello enterprise: threat modeling, gestione del ciclo di vita delle chiavi, processi di divulgazione delle vulnerabilità

18 – Calibrazione e compensazione dei sensori

Livello: 1 – Principiante assoluto
Argomenti:

• Capire cosa significano “calibrazione del sensore” e “compensazione” e perché contano
• Imparare a leggere i valori grezzi dell’ADC da un sensore nel codice (per esempio adc1_get_raw)
• Registrare gli output grezzi del sensore in condizioni ambiente usando print seriale o un semplice data logger
• Familiarizzare con gli standard di riferimento base: resistori fissi noti, tensioni di riferimento note
• Tracciare le letture grezze vs i valori attesi in un foglio di calcolo per vedere errori di linearità o offset

Livello: 2 – Principiante
Argomenti:

• Eseguire una calibrazione a due punti (offset e guadagno): raccogliere letture a due concentrazioni o carichi noti
• Calcolare e implementare una semplice formula di mappatura lineare nel firmware
• Documentare i passi e i risultati della calibrazione: includere le condizioni di test (temperatura, umidità)
• Introdurre le metriche di errore: errore medio, deviazione standard, errore massimo
• Automatizzare la raccolta dei dati di calibrazione con script o semplici comandi shell

Livello: 3 – Intermedio
Argomenti:

• Caratterizzare la risposta del sensore sul suo intero intervallo con dati multi-punto (almeno 5–10 punti)
• Adattare curve di ordine superiore (regressione polinomiale) o segmenti lineari a tratti in uno strumento come Python o Excel
• Implementare la compensazione di temperatura e umidità: leggere i sensori ambientali e applicare formule di correzione
• Validare la compensazione confrontando le letture compensate con strumenti di riferimento in varie condizioni
• Archiviare i coefficienti di calibrazione in memoria non volatile (RTC memory, partizione NVS o flash)

Livello: 4 – Avanzato
Argomenti:

• Sviluppare protocolli di calibrazione robusti: randomizzare l’ordine dei test, controllare le variabili ambientali, registrare i metadati
• Usare tecniche statistiche: rilevamento degli outlier, intervalli di confidenza, studi di ripetibilità/riproducibilità
• Automatizzare le routine di calibrazione sul dispositivo: modalità di calibrazione interattiva con prompt per l’utente
• Implementare routine di auto-calibrazione o auto-zero per rimuovere la deriva durante i deployment lunghi
• Gestire e versionare i dati di calibrazione in un sistema backend o in un database di calibrazione

Livello: 5 – Esperto
Argomenti:

• Progettare algoritmi di compensazione multivariata (per esempio usando sensor fusion o regressori di machine learning per cross-sensitività complesse)
• Progettare e costruire rig di calibrazione automatizzati o fixture di test per la calibrazione di produzione ad alto volume
• Definire e far rispettare standard e procedure di calibrazione (documentazione in stile ISO 17025)
• Monitorare la deriva di calibrazione sul campo e attivare da remoto la ri-calibrazione o gli aggiornamenti firmware
• Fare da mentore e formare il team su concetti avanzati di metrologia; pubblicare linee guida interne di calibrazione e white paper

19 – Data logging e storage OTA

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare cosa significa storage persistente su un ESP32 e perché è utile per il logging o lo staging OTA
• Capire la differenza tra filesystem su flash interna (SPIFFS, LittleFS) e SD card esterne
• Montare SPIFFS in Arduino (SPIFFS.begin()) o ESP-IDF (esp_vfs_spiffs_register)
• Elencare i file, aprire un file in scrittura ("w"), scrivere una riga, chiudere, poi aprire in lettura e stampare il contenuto
• Inizializzare e montare una SD card (Arduino SD.begin(), ESP-IDF esp_vfs_fat_sdspi_mount), aprire un file e fare lettura/scrittura base

Livello: 2 – Principiante
Argomenti:

• Usare la modalità append ("a") per aggiungere nuove voci di log senza sovrascrivere i dati esistenti
• Attraversare le directory: aprire directory, leggere i nomi dei file, filtrare per estensione o timestamp
• Configurare la dimensione della partizione SPIFFS/LittleFS in platformio.ini o sdkconfig, riflashare e verificare
• Esplorare le differenze di LittleFS: mount più veloci, wear leveling integrato, operazioni sui metadati
• Rilevare e gestire gli errori di mount, controllare lo spazio libero prima di scrivere, recuperare un filesystem corrotto

Livello: 3 – Intermedio
Argomenti:

• Implementare la rotazione dei log: quando un file supera una soglia di dimensione o età, chiuderlo e iniziarne uno nuovo; eliminare i log più vecchi
• Registrare dati binari dei sensori efficientemente: serializzare struct o float, scrivere/rileggere in memoria
• Montare e usare FAT su SD con supporto ai nomi lunghi; gestire partizioni SD multiple
• Creare uno strato di astrazione così che il vostro codice possa cambiare tra SPIFFS, LittleFS o SD per configurazione
• Mettere in staging grandi quantità di dati o chunk di firmware in una partizione dedicata “ota_data” usando scritture raw su flash

Livello: 4 – Avanzato
Argomenti:

• Capire e modificare la partition table dell’ESP32: voci factory, ota_0, ota_1, data (spiffs/littlefs)
• Usare le API OTA di ESP-IDF: esp_ota_begin(), esp_ota_write(), esp_ota_end(), esp_ota_set_boot_partition()
• Scaricare e scrivere un’immagine firmware completa nella partizione OTA inattiva, verificarne l’integrità, cambiare boot
• Gestire gli aggiornamenti interrotti: rilevare scritture parziali, fare rollback all’ultimo firmware noto funzionante
• Ottimizzare la resilienza del filesystem: usare operazioni sui file atomiche, strategie di journaling o double-buffering

Livello: 5 – Esperto
Argomenti:

• Progettare layout di partizione custom: partizioni dati multiple, ridimensionamento dinamico, integrazione di flash off-chip
• Implementare filesystem cifrati e/o compressi per proteggere i dati a riposo e ridurre l’usura
• Sviluppare aggiornamenti delta-OTA o basati su patch per minimizzare dimensione del download e tempo di aggiornamento
• Costruire harness di test automatizzati per simulare la corruzione del filesystem e validare i flussi di recupero OTA
• Fare da mentore sulle best practice: allineamento delle partizioni, gestione dell’usura della flash, integrazione del secure boot e gestione completa del ciclo di vita dei dati archiviati e degli aggiornamenti firmware

20 – Flusso di aggiornamento OTA remoto

Livello: 1 – Principiante assoluto
Argomenti:

• Capire cosa sono gli aggiornamenti OTA (Over-The-Air) e perché sono utili
• Esplorare un semplice esempio OTA in Arduino (ArduinoOTA) o ESP-IDF (ota_https_simple)
• Configurare il vostro ambiente di sviluppo per abilitare l’OTA: includere la libreria/componente OTA
• Flashare l’esempio “blink” con OTA abilitato e confermare che pubblicizza un servizio o un endpoint HTTP
• Attivare un aggiornamento OTA manuale da VS Code o dall’Arduino IDE e osservare il riavvio del firmware

Livello: 2 – Principiante
Argomenti:

• Ospitare un binario firmware su un server HTTP(S) locale o un semplice file server
• Scrivere codice firmware per recuperare il manifest di versione o l’URL del binario via HTTP usando HTTPClient o esp_http_client
• Scaricare e applicare l’aggiornamento alla partizione secondaria usando l’API OTA di ESP-IDF (esp_ota_begin, esp_ota_write, esp_ota_end)
• Verificare l’integrità della nuova immagine usando i checksum integrati o gli header HTTP ETag
• Implementare il rollback base: se il nuovo firmware non si avvia o segnala un errore, tornare alla partizione precedente

Livello: 3 – Intermedio
Argomenti:

• Automatizzare i trigger OTA: controllare gli aggiornamenti all’avvio o su timer periodici, confrontare la versione corrente col manifest
• Proteggere il canale di aggiornamento: passare da HTTP a HTTPS, validare i certificati del server, fissare le CA in flash
• Supportare il delta-OTA (diff binari) per ridurre la dimensione del download: integrare e applicare patch anziché immagini complete
• Usare MQTT o MQTT-SN per notificare ai dispositivi gli aggiornamenti disponibili e controllare il rollout per dispositivo o gruppo
• Archiviare i metadati dell’aggiornamento (versione, timestamp, stato) in storage non volatile (NVS) per l’audit

Livello: 4 – Avanzato
Argomenti:

• Integrare con un servizio OTA basato su cloud (per esempio AWS IoT Device Management, Azure IoT Hub) tramite le loro API REST/MQTT
• Implementare staged rollout: distribuire prima a una piccola percentuale di dispositivi, monitorare la salute, poi espandere il rollout
• Progettare uno schema di partizioni A/B con fallback alla golden image e controlli di salute automatizzati all’avvio
• Automatizzare pipeline di compilazione, firma e pubblicazione del firmware in CI/CD; incorporare le firme e verificarle nel dispositivo
• Gestire aggiornamenti multi-componente (bootloader, partition table, applicazione, filesystem) in una singola transazione

Livello: 5 – Esperto
Argomenti:

• Progettare un backend custom di gestione OTA: versioning, gruppi di dispositivi, aggiornamenti differenziali, integrazione della telemetria
• Implementare la sicurezza end-to-end: firma del codice con chiavi asimmetriche, integrazione del secure boot, protezione dal replay
• Ottimizzare i meccanismi di aggiornamento per reti a bassa banda o intermittenti: consegna a chunk, supporto alla ripresa, controllo adattivo della velocità
• Costruire percorsi di aggiornamento ridondanti: server multipli, condivisione peer-to-peer, strategie CDN di fallback
• Fare da mentore ai team sulle best practice: conformità agli standard di settore (per esempio IEC 62443), gestione robusta degli errori e gestione completa del ciclo di vita delle versioni del firmware

21 – Teoria del controllo e della stima

Livello: 1 – Principiante assoluto
Argomenti:

• Afferrare l’idea base di un anello di controllo: setpoint, misura ed errore
• Differenziare sistemi open-loop vs closed-loop
• Implementare un semplice controllore on/off (bang-bang) in pseudocodice o C
• Capire la nozione di risposta del sistema: tempo di salita, sovraelongazione, tempo di assestamento (concettuale)
• Imparare cosa significa “stima”: usare misure rumorose per inferire un valore vero

Livello: 2 – Principiante
Argomenti:

• Derivare e codificare un controllore proporzionale (P): output = Kₚ·errore
• Aggiungere i termini integrale (I) e derivativo (D) per costruire un controllore PID; regolare Kₚ, Kᵢ, K_d per tentativi
• Implementare un filtro passa-basso del primo ordine (discreto) per letture rumorose dei sensori
• Modellare sistemi semplici come equazioni alle differenze (per esempio circuito RC discreto)
• Scrivere un filtro a media mobile o exponential smoothing nel firmware

Livello: 3 – Intermedio
Argomenti:

• Rappresentare i sistemi in forma state-space (ẋ = Ax + Bu; y = Cx + Du) e discretizzare per il firmware
• Progettare e implementare un Kalman filter a tempo discreto per un modello 1D a velocità costante
• Analizzare la stabilità di un sistema controllato da PID con root locus o diagrammi di Bode (MATLAB/Python)
• Implementare anti-windup per il termine I e filtraggio del derivativo in un algoritmo PID
• Incorporare codice di controllo e stima in task FreeRTOS con timing deterministico

Livello: 4 – Avanzato
Argomenti:

• Progettare controllori ottimali a retroazione di stato (LQR) e osservatori di Kalman discreti
• Estendere agli Extended Kalman Filter (EKF) per sistemi non lineari (per esempio cinematica di un semplice robot mobile)
• Eseguire il design nel dominio della frequenza: margine di guadagno e fase, notch filter, regolazione PID via Ziegler–Nichols e metodi a relè
• Codificare un prototipo di model predictive control (MPC) in C o C++, usando un orizzonte piccolo
• Profilare tempo di esecuzione e memoria degli anelli di controllo; ottimizzare per i vincoli real-time

Livello: 5 – Esperto
Argomenti:

• Progettare schemi di controllo non lineare: sliding-mode, controllo adattivo, controllori robusti H∞
• Guidare lo sviluppo di librerie EKF/UKF custom o risolutori MPC per target embedded
• Fare da mentore al team sulla stima avanzata: sensor fusion multi-sensore (IMU + GPS + sonde del suolo) usando tecniche di simultaneous localization and mapping (SLAM)
• Pubblicare linee guida di design interne sulle best practice di controllo/stima e sulla verifica di sicurezza
• Contribuire algoritmi innovativi o miglioramenti a progetti open source di controllo/stima o a paper accademici

22 – Scripting Python / Bash

Livello: 1 – Principiante assoluto
Argomenti:

• Installare Python 3 e pip; verificare con python3 --version e pip3 --version
• Aprire una shell bash; eseguire bash --version
• Creare ed eseguire uno script Python “hello world” (hello.py) e un semplice script bash (hello.sh)
• Aggiungere le righe shebang (#!/usr/bin/env python3 e #!/usr/bin/env bash) e rendere gli script eseguibili (chmod +x)
• Usare comandi bash base: echo, ls, pwd, cd; e print() di Python, semplici assegnazioni di variabili

Livello: 2 – Principiante
Argomenti:

• Tipi di dato Python (int, float, string, list, dict) e control flow (if, for, while); definire funzioni semplici
• Variabili bash, parametri posizionali ($1, $2), regole di quoting, if [ ] base e cicli for
• File I/O: aprire/leggere/scrivere in Python; redirigere (>, >>) e leggere righe in bash (while read)
• Importare e usare i moduli integrati di Python (os, sys); includere script bash helper più piccoli con source
• Gestione base degli errori: try/except di Python; set -e di bash e trap '…' ERR

Livello: 3 – Intermedio
Argomenti:

• Ambienti virtuali Python (python3 -m venv), requirements.txt, installazione di pacchetti di terze parti via pip
• Parsing degli argomenti in bash usando getopts o getopt e scrittura di funzioni bash riusabili
• Costruire script di automazione: invocare make, idf.py o pio da Python (subprocess) o bash
• Usare argparse di Python per interfacce CLI robuste e il modulo logging per log strutturati
• I/O shell avanzato: pipe (|), process substitution (<(), >()), here-doc (<<EOF) e command substitution

Livello: 4 – Avanzato
Argomenti:

• Scrivere unit test Python con pytest o unittest; imporre lo stile con flake8/pylint e aggiungere type hint con mypy
• Irrobustire gli script bash: set -euxo pipefail, validazione dei parametri, funzioni di pulizia con trap, modalità debug (set -x)
• Usare Python per task concorrenti: threading, multiprocessing e strumenti di alto livello come concurrent.futures
• Costruire moduli Python riusabili e installarli via setup.py/pyproject.toml; gestire versioni e dipendenze
• Automatizzare passi CI/CD: scrivere script Python o bash che orchestrano job di GitHub Actions o GitLab CI

Livello: 5 – Esperto
Argomenti:

• Sviluppare e pubblicare strumenti CLI Python standalone usando framework come Click o Typer; pubblicare pacchetti su PyPI
• Progettare grandi framework bash: script modulari, sistemi di plugin, coprocessi, redirezione I/O avanzata
• Profilare e ottimizzare script Python (per esempio cProfile, line_profiler), adottare asyncio per task ad alto throughput
• Integrare gli script coi servizi di sistema: scrivere unit file systemd, script di entry-point per container, automazione Docker-Compose
• Definire e insegnare le best practice di scripting al team: sicurezza (sanitizzazione degli input, evitare injection), documentazione e template di codice manutenibile

23 – Basi di cloud e dashboard

Livello: 1 – Principiante assoluto
Argomenti:

• Afferrare il concetto di piattaforme IoT basate su cloud vs soluzioni on-premise
• Registrarsi per una trial gratuita di AWS IoT Core o Azure IoT Hub
• Navigare il portale AWS IoT o Azure: esplorare la sezione Things/Devices e vedere le dashboard di panoramica
• Installare ed eseguire uno strumento desktop (AWS IoT Explorer o Azure IoT Explorer) per connettersi e inviare un messaggio di telemetria di esempio
• Capire cos’è InfluxDB: installare un’istanza locale InfluxDB 2.x via Docker o binario, eseguire la CLI integrata e scrivere un singolo dato

Livello: 2 – Principiante
Argomenti:

• Registrare un dispositivo (“Thing”) in AWS IoT Core o un dispositivo in Azure IoT Hub; scaricare e ispezionare i certificati generati o i token SAS
• Usare l’AWS IoT SDK (C/Python) o l’Azure Device SDK per pubblicare semplice telemetria JSON via MQTT
• Installare Grafana, aggiungere InfluxDB come data source e creare un pannello time-series base che mostra un campo
• Scrivere dati in InfluxDB dalla riga di comando (usando curl o la CLI Influx) e verificarli nella UI di InfluxDB
• Esplorare i concetti di Grafana: dashboard, pannelli, query, selettore dell’intervallo temporale

Livello: 3 – Intermedio
Argomenti:

• Implementare codice dispositivo in stile produzione: connessioni MQTT persistenti, logica di riconnessione, payload JSON strutturati, gerarchie di topic
• Definire una AWS IoT Rule per inoltrare la telemetria in arrivo a una funzione Lambda, tabella DynamoDB o stream Kinesis
• Configurare task InfluxDB o Telegraf per acquisire e trasformare automaticamente i flussi di dati in arrivo
• Costruire dashboard Grafana multi-pannello usando query Flux o InfluxQL: aggiungere gauge, grafici e pannelli stat
• Configurare semplici regole di alert in Grafana basate su soglie e configurare un canale di notifica email o Slack

Livello: 4 – Avanzato
Argomenti:

• Rafforzare l’autenticazione: restringere le policy IoT in AWS, ottimizzare il RBAC di Azure IoT Hub, ruotare certificati/token SAS secondo programma
• Usare AWS IoT Device Shadow o Azure Digital Twins per sincronizzare lo stato desired/reported tra cloud e dispositivo
• Scalare InfluxDB con retention policy, continuous query o Task e shard group per lo storage a lungo termine
• Implementare il provisioning di Grafana (as code) per gestire dashboard e alert tramite file JSON/YAML in Git
• Integrare Grafana con alert manager esterni o servizi di notifica (PagerDuty, OpsGenie, Microsoft Teams)

Livello: 5 – Esperto
Argomenti:

• Progettare un backbone IoT globale e resiliente: failover multi-regione di AWS IoT Core o Azure IoT Hub, integrazione di edge gateway con Greengrass o Azure IoT Edge
• Automatizzare l’intera infrastruttura: scrivere moduli Terraform o template ARM/Bicep per distribuire risorse IoT, cluster InfluxDB, istanze Grafana e policy IAM
• Ottimizzare l’ingestion di dati ad alto volume: scritture in batch, tecniche di compressione, strategie di backpressure e procedure di backfill
• Progettare e imporre dashboard multi-tenant in Grafana con RBAC granulare e filtraggio delle data source
• Fare da mentore ai team sulle best practice per il controllo dei costi, la conformità di sicurezza (GDPR, HIPAA), le policy di data retention e il monitoraggio operativo dello stack di analytics IoT

24 – Conformità normativa e ambientale

Livello: 1 – Principiante assoluto
Argomenti:

• Imparare perché l’approvazione normativa e i rating ambientali contano per un dispositivo commerciale
• Capire l’ambito del marchio CE (UE) vs la certificazione FCC (USA) vs i codici IP base
• Identificare quali direttive si applicano (per esempio EMC, LVD per la CE; Part 15 per la FCC) e cosa significa un grado IP67
• Trovare e salvare nei preferiti le risorse ufficiali: il database NANDO dell’UE, il portale di autorizzazione delle apparecchiature della FCC

Livello: 2 – Principiante
Argomenti:

• Studiare gli standard essenziali: immunità/emissioni EMC (EN 61326-1 / FCC Part 15 Subpart B), sicurezza (EN 61010‐1)
• Imparare come vengono testati i gradi IP (getto d’acqua, camera di polvere) e cosa significa ogni cifra
• Raccogliere datasheet e dichiarazioni di conformità dei fornitori per ogni modulo o componente
• Documentare il percorso di conformità previsto in un semplice foglio di calcolo o checklist

Livello: 3 – Intermedio
Argomenti:

• Redigere un Technical File (CE) o un piano di test FCC: includere block diagram, schematici, BOM, valutazione dei rischi
• Implementare mitigazioni EMI/EMC base: aggiungere ferriti, choke di modo comune, pour di massa sul PCB
• Eseguire test di pre-compliance interni: sondaggio EMI in campo vicino, test con pistola ESD, controlli base di isolamento
• Preparare la grafica delle etichette del dispositivo: marchio CE, FCC ID, simboli WEEE, avvertenze di uso sicuro

Livello: 4 – Avanzato
Argomenti:

• Gestire il processo di certificazione formale con un Organismo Notificato (CE) o un laboratorio accreditato FCC: presentare campioni, assistere ai test
• Analizzare i report di test, guidare le modifiche al design per risolvere i fallimenti (per esempio modifiche al layout, guarnizioni del contenitore)
• Coordinare test ambientali e meccanici: cicli termici, vibrazioni, test di ingresso per raggiungere il grado IP target
• Assemblare e firmare la Dichiarazione di Conformità (CE) e presentare il FCC Form 731 per l’autorizzazione delle apparecchiature

Livello: 5 – Esperto
Argomenti:

• Definire una strategia di conformità globale che copra CE, FCC, UL/CSA, RoHS, REACH, WEEE e altre secondo necessità
• Progettare hardware e firmware modulari per semplificare i nuovi test e le varianti regionali
• Guidare i programmi di conformità dei fornitori: imporre il change-control dei componenti, auditare il QMS del produttore
• Mantenere e aggiornare i Technical File e gli exhibit FCC attraverso le revisioni del prodotto; gestire gli audit di sorveglianza periodici
• Servire come collegamento principale con gli organismi di regolamentazione, gestire i rilievi di non conformità e le azioni correttive, fare da mentore al team sulle best practice per la gestione normativa continua.

25 – Strumenti di documentazione (Markdown, Doxygen)

Livello: 1 – Principiante assoluto
Argomenti:

• Capire lo scopo della documentazione di progetto: README, riferimenti API, how-to
• Installare un editor Markdown o usare il supporto integrato di VS Code
• Scrivere la sintassi Markdown base: titoli (#–###), grassetto/corsivo, elenchi puntati e numerati
• Inserire link e immagini via Markdown ([testo](url), ![alt](path))
• Visualizzare in anteprima un README.md in VS Code o su GitHub

Livello: 2 – Principiante
Argomenti:

• Creare tabelle, blockquote e blocchi di codice con fence in Markdown
• Usare link relativi e anchor link per documenti multi-pagina
• Installare Doxygen e generare un Doxyfile predefinito
• Annotare il sorgente C/C++ con commenti Doxygen (///, /** ... */) per funzioni e tipi
• Eseguire Doxygen per produrre output HTML e navigare i documenti generati

Livello: 3 – Intermedio
Argomenti:

• Personalizzare le impostazioni del Doxyfile: percorsi di input, EXTRACT_ALL, EXTRACT_PRIVATE, supporto ai diagrammi, formati di output
• Incorporare contenuti Markdown nei commenti Doxygen e includere file Markdown esterni via \include
• Organizzare la documentazione in moduli e gruppi usando i tag @defgroup e @addtogroup
• Integrare l’esecuzione di Doxygen nella vostra build CMake o PlatformIO così che i documenti si aggiornino a ogni build
• Usare le estensioni di VS Code per visualizzare in anteprima commenti Markdown e Doxygen combinati inline

Livello: 4 – Avanzato
Argomenti:

• Estendere Doxygen con filtri di tag custom o pre-processori di input (per esempio script Python)
• Automatizzare le build della documentazione nelle pipeline CI e pubblicare su GitHub Pages, GitLab Pages o Confluence via convertitori
• Generare diagrammi PlantUML o Graphviz dalle annotazioni del codice e includerli nei documenti
• Mantenere metriche di doc-coverage: scrivere script per rilevare funzioni/tipi non documentati e far fallire la CI sotto una soglia
• Definire e pubblicare una style guide per l’uso di Markdown e Doxygen in tutto il team

Livello: 5 – Esperto
Argomenti:

• Sviluppare layout e temi Doxygen custom (XSLT, template CSS/HTML custom) per corrispondere al branding aziendale
• Progettare una pipeline di documentazione ibrida usando Sphinx o MkDocs insieme a Doxygen, con output versionati e ricerca
• Automatizzare l’inclusione di documentazione cross-repository via Git submodule, Doxyfile compositi o linking basato su tag
• Guidare le review della documentazione, imporre gate di qualità CI sui documenti e fare da mentore al team sulle best practice
• Contribuire a strumenti di documentazione open source o creare plugin/estensioni (per esempio per rendering avanzato di diagrammi o esempi di codice live)