Escala 5‑a‑1

El plan de aprendizaje de un desarrollador embebido tiene que reflejar la lista de materiales. Lo aprendimos a la mala al desplegar un nodo de monitoreo de suelo alimentado por energía solar construido sobre ESP32, backhaul celular SIMCom y AWS IoT Core: firmware, hardware, enlaces de radio y flujos de nube tuvieron que encajar todos a la vez, y omitir una sola pieza convirtió un ajuste de firmware «rápido» en semanas de depuración.

Para mantener ese plan enfocado, calificamos cada competencia en una escala de 5 a 1 —un marco completamente agnóstico de la tecnología:

Cómo aplicarlo en cualquier lugar

1. Define el objetivo final. ¿Cómo se ve “listo para trabajar” o “listo para producción”?
2. Lista los 5s. Kit de supervivencia absoluto.
3. Identifica los 4s. Prácticas que endurecen y escalan la solución.
4. Completa los 3s. Herramientas y optimizaciones de calidad de vida.
5. Añade los 2s y 1s. Profundidad especializada para equipos más grandes o funcionalidades avanzadas.

Prueba rápida de que funciona en cualquier lado

• Desarrollo web front‑end → 5s: HTML/CSS, JS moderno, Git… • 4s: React/Vue, TypeScript, Jest, CI/CD… • 3s: Storybook, pruebas e2e… • 2s: PWAs, animaciones… • 1s: WebGL, visualización de datos.
• Data Science / MLOps → 5s: Python, NumPy/Pandas, estadística… • 4s: TensorFlow/PyTorch, Docker, pruebas unitarias… • 3s: Feature stores, MLflow… • 2s: Inferencia en edge… • 1s: Aprendizaje federado.

Al calificar el impacto y la frecuencia de cada tema, trazas un camino claro y evitas el agobio.

Cómo se ven los 5s para nuestro stack ESP32 + SIM + AWS

1. Fluidez en C/C++ – el lenguaje de ESP‑IDF y los hooks de FreeRTOS.
2. Dominio de ESP‑IDF (o Arduino‑ESP32) – APIs de Wi‑Fi, BLE, ADC y deep‑sleep.
3. Fundamentos de electrónica – adaptación de niveles de UART del SIM, lectura de sondas NPK, higiene EMI.
4. Presupuesto de potencia y carga Li‑ion/solar – mantener una 18650 de 4 Ah viva durante semanas nubladas.
5. Conectividad robusta (Wi‑Fi, AT SIM, MQTT/TLS) – canalizar datos de sensores de forma segura hacia AWS.

Domina estos cinco y puedes lanzar un prototipo funcional. Sube a los 4s —pipelines de CI, FreeRTOS avanzado, OTA, seguridad— y tendrás un producto que sobrevive en campo. Los 3s, 2s y 1s completan el toolkit profesional con dashboards, cumplimiento y profundidad específica del dominio.

El artículo que sigue no es una checklist; es una hoja de ruta secuencial mapeada a decisiones reales de hardware. Empieza con los 5s, avanza por los 4s, y cuando llegues al territorio 3‑a‑1 tendrás tanto la confianza como el contexto para aplicarlos donde más importa, de la protoboard a producción.

Skillsets para desarrolladores embebidos

Leyenda – Importancia
5 = Indispensable (necesario para el trabajo diario)
4 = Muy importante (necesario en la mayoría de proyectos)
3 = Útil (frecuentemente útil, aprender pronto)
2 = Deseable (aprender cuando el tiempo lo permita)
1 = Especializado / situacional

Cómo leer la tabla

• Empieza por los 5s: dominio del lenguaje, SDK del microcontrolador, bases de hardware, diseño del sistema de potencia, conocimiento de sensores y comunicaciones celulares son decisivos para un dispositivo de campo confiable.
• Aborda los 4s a continuación: entorno de desarrollo, optimización de potencia, OTA, RTOS y seguridad convierten un prototipo funcional en un producto listo para producción.
• Los 3s completan el flujo de trabajo profesional (CI, pruebas unitarias, backends en la nube, CAD de PCB).
• Los 2s y 1s añaden profundidad para equipos más grandes o funcionalidades avanzadas y pueden posponerse si el calendario es ajustado.
• Úsala como una hoja de ruta de habilidades: avanza de izquierda a derecha por la escala de importancia mientras el proyecto madura.

1 – C/C++

Nivel: 1 – Absolute Beginner
– Sintaxis y estructura de C: modelo de compilación (fuente → objeto → ejecutable), función main()
– Tipos de datos básicos: int, char, float, double, bool
– Variables y constantes: declaración, inicialización, calificador const
– Operadores: aritméticos (+, –, *, /, %), asignación, incremento/decremento
– Flujo de control: if/else, switch, bucles for/while/do-while
– E/S simple: printf, salida básica por consola
– Introducción a punteros: declaración de punteros, desreferenciación
– Compilación y depuración: compilar con gcc -o, interpretar errores básicos del compilador

Nivel: 2 – Beginner
– Memoria y punteros: aritmética de punteros, punteros vs. arrays, introducción a malloc/free
– Tipos estructurados: struct, union, typedef
– Conceptos básicos del preprocesador: #define, #include, include guards
– Clases de almacenamiento: auto, static, extern, reglas de alcance y enlace
– Cadenas y arrays: char[], funciones de cadenas (strcpy, strlen, etc.)
– Código modular: dividir en múltiples archivos .c/.h, fundamentos de makefiles (reglas, targets)
– Herramientas básicas de depuración: pasos con gdb, breakpoints, inspección de variables

Nivel: 3 – Intermediate
– Gestión dinámica de memoria: heap vs. stack, patrones comunes de fugas, uso de herramientas como Valgrind
– E/S de archivos: fopen/fread/fwrite/fclose, punteros de archivo, manejo de errores
– Operaciones a nivel de bits: máscaras, desplazamientos, set/clear de bits, enum y bit-fields
– Punteros a funciones: callbacks, tablas de despacho
– Manejo de errores: códigos de retorno, errno
– Fundamentos de C++: clases y objetos, constructores/destructores, especificadores de acceso
– Bases de STL: std::vector, std::string, uso simple de std::map e iteradores
– Namespaces y organización de headers

Nivel: 4 – Advanced
– C específico para embebidos: volatile, E/S mapeada en memoria, const en flash vs. RAM
– Linker y sistema de build: linker scripts personalizados, colocación de secciones, flags de optimización (-O2, -Os), toolchains de cross-compilación
– Características de C++11/14/17: lambdas, auto, range-based for, constexpr, nullptr
– Smart pointers y RAII: unique_ptr, shared_ptr, gestión de recursos
– Bases de templates: templates de funciones y clases, especialización de templates
– Multithreading: std::thread, mutexes, variables de condición, tipos atómicos
– Conceptos de tiempo real: rutinas de servicio de interrupción (ISRs), secciones críticas, mitigación de inversión de prioridad

Nivel: 5 – Expert
– Meta-programación avanzada con templates: templates variádicos, SFINAE, type traits
– Modelo de objetos C++ avanzado: vtables, layout de objetos, consideraciones de ABI
– Concurrencia lock-free y de baja latencia: atómicos, ordenamientos de memoria, algoritmos wait-free
– Internos del compilador y toolchain: pipelines de pasos de GCC/Clang, escribir plugins de compilador personalizados
– Optimización de rendimiento: alineación de caché, predicción de saltos, perfilado en profundidad (ej. gprof, contadores de hardware)
– Porting bare-metal: implementar stubs de newlib, runtime mínimo en C, código de bring-up
– Estándares y seguridad: cumplimiento MISRA-C/C++, herramientas de análisis estático (Coverity, Cppcheck)
– Contribución a frameworks: escribir/optimizar drivers para los internos de FreeRTOS o ESP-IDF

2 – ESP-IDF (native) or Arduino-ESP32

Nivel: 1 – Absolute Beginner
– Instalar toolchain de ESP-IDF (Python, Git, scripts de ESP-IDF) o Arduino-ESP32 core
– Configurar VS Code (o Arduino IDE) para desarrollo con ESP32
– Compilar y flashear el ejemplo “blink”
– Explorar estructura del proyecto (CMakeLists.txt, sdkconfig o platformio.ini)
– Usar comandos básicos de idf.py (o Arduino): build, clean, flash, monitor

Nivel: 2 – Beginner
– GPIO: configurar pines, leer entradas, controlar LEDs
– ADC: muestrear canales analógicos, convertir valores raw a voltaje
– UART e I²C: enviar/recibir cadenas o bytes simples
– Modo estación Wi-Fi: escanear APs, conectar, obtener IP
– BLE peripheral: anunciar, conectar desde app de teléfono
– Ajustar menuconfig (tabla de particiones, nivel de log) o configuraciones de placa de Arduino

Nivel: 3 – Intermediate
– Tareas, colas y timers de FreeRTOS dentro del marco de ESP-IDF
– API de eventos Wi-Fi: manejar conexión/desconexión, lógica de reconexión
– Cliente BLE y GATT: descubrir servicios, leer/escribir características
– SPI e I²C: integrar y calibrar un sensor real (ej. humedad de suelo)
– Actualizaciones OTA por HTTP(S): configurar particiones, disparar actualizaciones
– Usar esp_timer, logging detallado (ESP_LOG*) y códigos de error

Nivel: 4 – Advanced
– Crear componentes reutilizables (CMake Component API) o bibliotecas personalizadas de Arduino
– Construir una tabla de particiones personalizada y cambiar particiones en tiempo de ejecución
– Aprovisionamiento seguro: SmartConfig, configuración de Wi-Fi basada en BLE
– Ejemplos avanzados de BLE (L2CAP, mesh)
– Optimizar SPI DMA y ajustes de velocidad/timeout del bus I²C
– Integrar mbedTLS para MQTT sobre TLS
– Automatizar build/flash/tests en CI (GitHub Actions, scripts de CI de ESP-IDF)

Nivel: 5 – Expert
– Contribuir nuevos drivers o corregir errores en el núcleo de ESP-IDF (ej. calibración de ADC)
– Desarrollar bootloader personalizado u optimizaciones a nivel de ISR
– Afinar regiones de heap de FreeRTOS y parámetros del scheduler
– Implementar secure boot y cifrado de flash de extremo a extremo
– Realizar tracing y perfilado en tiempo real (ESP-Trace, Perfcnt)
– Arquitectar workspaces CMake multi-proyecto
– Mentorizar a otros: definir mejores prácticas de ESP-IDF y bibliotecas internas de componentes

3 – FreeRTOS Fundamentals

Nivel: 1 – Absolute Beginner
– Entender qué es un RTOS y por qué usarlo
– Instalar FreeRTOS (vía ESP-IDF o PlatformIO) e inspeccionar el ejemplo demo “hello world” de tareas
– Aprender la API básica para crear e iniciar una sola tarea (xTaskCreate, vTaskStartScheduler)
– Explorar el tick del sistema y cómo el scheduler cambia entre tareas
– Usar vTaskDelay para bloquear una tarea durante un tiempo fijo

Nivel: 2 – Beginner
– Crear múltiples tareas con diferentes prioridades y tamaños de stack
– Usar vTaskDelayUntil para temporización periódica de tareas
– Entender y aplicar secciones críticas (taskENTER_CRITICAL / taskEXIT_CRITICAL)
– Conocer los estados de tareas (Running, Ready, Blocked, Suspended)
– Usar vTaskSuspend / vTaskResume para control simple de tareas

Nivel: 3 – Intermediate
– Comunicar tareas mediante colas (xQueueCreate, xQueueSend, xQueueReceive)
– Sincronizar tareas usando semáforos binarios y de conteo (xSemaphoreCreateBinary, xSemaphoreTake)
– Coordinar eventos con Event Groups (xEventGroupSetBits, xEventGroupWaitBits)
– Usar timers de software (xTimerCreate, callback)
– Detectar y manejar desbordamientos de stack

Nivel: 4 – Advanced
– Optimizar asignación de memoria: elegir y configurar esquemas de heap (heap_1…heap_5) y entender la fragmentación
– Emplear notificaciones de tareas como semáforos binarios ligeros o mensajes directos a tareas
– Configurar y usar tickless idle mode para aplicaciones de bajo consumo
– Generar e interpretar estadísticas de tiempo de ejecución (vTaskGetRunTimeStats)
– Integrar FreeRTOS+Trace o Percepio Tracealyzer

Nivel: 5 – Expert
– Portar FreeRTOS a hardware personalizado o modificar la capa de port para casos de uso avanzados
– Implementar y afinar políticas de scheduler personalizadas o funciones hook (vApplicationIdleHook, vApplicationMallocFailedHook)
– Diseñar máquinas de estados complejas usando primitivas de sincronización avanzadas (mutexes con herencia de prioridad, mutexes recursivos)
– Mentorizar equipos sobre mejores prácticas, seguridad (código MISRA-compliant) y afinamiento de comportamiento determinista

4 – Git & GitHub/GitLab

Nivel: 1 – Absolute Beginner
– Instalar Git; configurar user.name y user.email
– Inicializar un repo (git init) y clonar repos existentes (git clone)
– Seguimiento básico de archivos: git status, git add, git commit
– Ver historial con git log, inspeccionar cambios con git diff
– .gitignore simple para excluir archivos

Nivel: 2 – Beginner
– Crear y cambiar de rama: git branch, git checkout/git switch
– Configuración de remoto: git remote add, git fetch, git pull, git push
– Entender origin/main vs ramas locales
– Resolver conflictos de merge simples vía editor o CLI
– Usar la interfaz web de GitHub/GitLab para explorar commits y ramas

Nivel: 3 – Intermediate
– Merge vs rebase: git merge, git rebase; saber cuándo usar cada uno
– Rebase interactivo (git rebase -i) para limpiar commits
– Etiquetado: crear tags anotados y ligeros; subir con git push –tags
– Trabajar con pull requests (GitHub) o merge requests (GitLab): crear, revisar, mergear
– Stub básico de CI: añadir un YAML simple de GitHub Actions o GitLab CI

Nivel: 4 – Advanced
– Gestionar submódulos (git submodule) y subtrees
– Escribir hooks cliente (pre-commit, pre-push) y hooks simples servidor de GitLab/GitHub
– Proteger ramas y forzar checks de merge (status checks, aprobaciones)
– Construir pipelines CI/CD multi-etapa con caché y artefactos
– Usar git bisect para localizar errores; cherry-pick de commits específicos

Nivel: 5 – Expert
– Administrar configuraciones de organización en GitLab/GitHub: permisos de usuario/grupo, ramas protegidas
– Arquitectar estrategias de monorepo; gestionar archivos grandes con Git LFS
– Desarrollar herramientas o scripts personalizados de Git (libgit2, hooks, automatización)
– Inmersión profunda en los internos de Git: almacenamiento de objetos, packfiles, refs, index
– Definir y hacer cumplir flujos de trabajo (Gitflow, trunk-based, GitOps); mentorizar al equipo sobre mejores prácticas

5 – VS Code

Nivel: 1 – Absolute Beginner
Temas:

• Instalar VS Code en Windows, macOS o Linux
• Explorar la interfaz: Activity Bar, Side Bar, Editor Panes, Status Bar
• Abrir carpetas y archivos; edición de texto básica (pestañas, vistas divididas)
• Usar la terminal integrada para ejecutar comandos de shell
• Invocar la Command Palette (Ctrl+Shift+P) para acciones comunes
• Realizar búsquedas y reemplazos simples (Ctrl+F / Ctrl+H)

Nivel: 2 – Beginner
Temas:

• Descubrir e instalar extensiones: C/C++ (ms-vscode.cpptools), ESP-IDF, Arduino-ESP32, PlatformIO IDE
• Personalizar configuraciones de Usuario vs Workspace vía settings.json
• Usar la vista de Source Control integrada: stage, commit, push/pull
• Configurar Tasks básicos (tasks.json) para compilar y flashear un “Hello World” de ESP32
• Navegar código con Outline y Breadcrumbs
• Insertar y usar snippets de código simples

Nivel: 3 – Intermediate
Temas:

• Configurar IntelliSense: establecer include paths y macros en c_cpp_properties.json
• Crear configuraciones de lanzamiento (launch.json) para depuración GDB vía OpenOCD o JTAG
• Definir Tasks compuestos: build → flash → monitor → lint
• Trabajar en workspaces multi-root (código + docs + tests)
• Integrar linters y formateadores (clang-format, cppcheck) como acciones pre-guardado
• Depurar tareas de FreeRTOS con debugging thread-aware y la vista Debug
• Usar el panel Problems y Test Explorer para pruebas unitarias

Nivel: 4 – Advanced
Temas:

• Aprovechar Remote Development: SSH, WSL y workspaces en contenedores Docker
• Crear y compartir snippets de código personalizados y plantillas de archivo para ESP-IDF/PlatformIO
• Automatizar CI: exportar Tasks de VS Code a pipelines de GitHub Actions o GitLab CI
• Personalizar keybindings y usar Settings Sync para compartir configuración entre máquinas
• Desarrollar Task Providers reutilizables vía la VS Code Tasks API
• Usar breakpoints condicionales y de función, logpoints y expresiones de watch

Nivel: 5 – Expert
Temas:

• Desarrollar y publicar extensiones completas de VS Code (TypeScript y Extension API) para flujos de ESP32
• Arquitectar workspaces grandes multi-proyecto con configuraciones compartidas y versionadas
• Optimizar rendimiento del IDE: afinar activación de extensiones, reducir tiempo de inicio y uso de memoria
• Implementar distribución corporativa de configuraciones (Settings Cycler, despliegue basado en GPO)
• Mentorizar al equipo sobre mejores prácticas de VS Code y solucionar flujos complejos
• Contribuir a la comunidad de VS Code: escribir guías, repos de ejemplos y hablar en meetups o talleres

6 – PlatformIO

Nivel: 1 – Absolute Beginner
Temas:

• Instalar la extensión PlatformIO IDE en VS Code (o instalar PIO Core CLI)
• Crear un nuevo proyecto de PlatformIO (pio init --board esp32dev)
• Inspeccionar estructura del proyecto: platformio.ini, src/, lib/
• Compilar (pio run) y subir (pio run --target upload) el ejemplo “blink” por defecto
• Abrir el monitor serie (pio device monitor) para ver la salida

Nivel: 2 – Beginner
Temas:

• Usar el Library Manager: pio lib install, pio lib list, añadir bibliotecas en platformio.ini
• Configurar múltiples entornos (env: sections) para diferentes placas o modos de build
• Establecer build_flags, monitor_speed y upload_speed en platformio.ini
• Ejecutar builds limpios (pio run --target clean) y builds verbose (pio run --target verbose)
• Usar el Unified Debugger (pio debug) para poner breakpoints y avanzar paso a paso

Nivel: 3 – Intermediate
Temas:

• Gestionar builds Debug vs Release y entornos habilitados para OTA en un solo platformio.ini
• Integrar pruebas unitarias con PlatformIO Test Runner y el framework Unity
• Añadir análisis estático: habilitar cppcheck o clang-tidy vía extra scripts o configs de platformio.ini
• Automatizar pasos pre/post build personalizados usando extra_scripts
• Publicar y consumir bibliotecas privadas a través del PlatformIO Registry

Nivel: 4 – Advanced
Temas:

• Crear y publicar paquetes personalizados de Platforms y Boards para uso interno o comunitario
• Implementar protocolos de upload avanzados (JTAG, OTA, scripts de upload personalizados)
• Construir pipelines de CI usando scripts pio ci para GitHub Actions, GitLab CI o Jenkins
• Generar y automatizar reportes de cobertura de código para pruebas unitarias
• Perfilar tamaño de firmware y uso de RAM vía el PlatformIO IDE Dashboard

Nivel: 5 – Expert
Temas:

• Contribuir mejoras o correcciones a PlatformIO Core y a Platforms comunitarias oficiales
• Desarrollar plugins personalizados de PlatformIO para extender funcionalidades de CLI e IDE
• Arquitectar y mantener workspaces grandes de monorepo o multi-proyecto usando PIO Projects
• Escribir hooks de build avanzados para integrar toolchains corporativos y flujos de despliegue
• Mentorizar equipos sobre mejores prácticas de PlatformIO y solucionar problemas complejos de build/debug multiplataforma

7 – Linux CLI / WSL

Nivel: 1 – Absolute Beginner
Temas:

• Abrir una terminal en Linux o WSL
• Navegar el sistema de archivos: ls, cd, pwd, mkdir
• Ver e inspeccionar archivos: cat, less, head, tail
• Manipular archivos: cp, mv, rm, touch
• Editar texto con un editor simple (nano o vim básico)

Nivel: 2 – Beginner
Temas:

• Permisos y propiedad de archivos: chmod, chown, entender los bits rwx
• Wildcards, globbing, pipes (|) y redirección (>, >>, <)
• Buscar texto en archivos: conceptos básicos de grep
• Gestionar variables de entorno y el perfil del shell (.bashrc, .profile)
• Instalar y actualizar paquetes con el gestor de paquetes de tu distro (apt, yum, pacman)
• Conectarse a hosts remotos vía ssh y transferir archivos con scp

Nivel: 3 – Intermediate
Temas:

• Escribir scripts Bash: shebang, variables, bucles, condicionales, funciones
• Procesamiento de texto con find, xargs, awk, sed
• Control de procesos y trabajos: ps, top/htop, kill, jobs, bg/fg
• Configurar reglas udev para adaptadores USB/JTAG de ESP32
• Invocar toolchains de cross-compilación y sistemas de build (make, cmake, idf.py) desde CLI
• Ejecutar OpenOCD desde la línea de comandos para flashear y depurar vía JTAG/SWD

Nivel: 4 – Advanced
Temas:

• Desarrollar scripts shell robustos: manejo de errores, logging, pruebas unitarias (ShellCheck)
• Automatizar pipelines completos de build–flash–test en shell e integrar en CI (GitHub Actions, GitLab CI)
• Contenerizar el entorno de build con Docker o Podman; escribir Dockerfiles para builds reproducibles
• Depuración remota y sincronización de archivos: port forwarding con ssh, rsync, tmux/screen para persistencia de sesión
• Perfilar y depurar herramientas nativas: strace, ltrace, perf

Nivel: 5 – Expert
Temas:

• Compilar y mantener kernels o módulos Linux personalizados para targets embebidos
• Arquitectar y operar runners de CI dedicados (bare-metal o contenedorizados) optimizados para cross-compilaciones embebidas
• Implementar técnicas avanzadas de caché y builds distribuidos (ccache, distcc)
• Diseñar frameworks CLI o toolchains propios, gestionar dotfiles entre equipos (Git-driven)
• Mentorizar a otros en mejores prácticas de shell, flujos de trabajo basados en terminal y automatización de pruebas y despliegue de hardware

8 – Unit‑Testing Framework (Unity / CppUTest)

Nivel: 1 – Absolute Beginner
Temas:

• Entender el propósito y beneficios de las pruebas unitarias
• Instalar Unity o CppUTest (vía biblioteca de PlatformIO, paquete pip o desde fuente)
• Crear un archivo de prueba mínimo e incluir los headers del framework
• Escribir una función de prueba simple usando la macro TEST (Unity) o TEST_GROUP/TEST (CppUTest)
• Ejecutar el test runner desde la línea de comandos e interpretar salida PASS/FAIL
• Usar macros de aserción básicas (ej. TEST_ASSERT, CHECK_EQUAL)

Nivel: 2 – Beginner
Temas:

• Organizar pruebas en suites o grupos
• Implementar funciones setUp() y tearDown() para fixtures de prueba
• Usar un rango más amplio de aserciones: floats, cadenas, comparaciones de memoria
• Parametrizar pruebas o iterar sobre datos de prueba
• Integrar compilación y ejecución de pruebas en tu build de PlatformIO o CMake
• Generar datos simples de cobertura de código (ej. vía gcov) y ver porcentajes básicos de cobertura

Nivel: 3 – Intermediate
Temas:

• Crear stubs y fakes para funciones dependientes de hardware (lecturas I²C, conversiones ADC)
• Introducir una biblioteca de mocking (CppUMock o CMock de Unity) para simular dependencias
• Escribir pruebas para código asíncrono: simular callbacks, interrupciones o timers de FreeRTOS
• Automatizar ejecución de pruebas con scripts shell o un trabajo básico de CI
• Recopilar y analizar métricas detalladas de cobertura (branch, function coverage)
• Probar extensivamente condiciones de frontera y de error

Nivel: 4 – Advanced
Temas:

• Desarrollar implementaciones de mock personalizadas para drivers de bajo nivel y abstracciones de periféricos
• Usar plugins de detección de fugas de memoria (MemoryLeak detector de CppUTest)
• Portar el test runner al dispositivo para pruebas unitarias on-target
• Escribir pruebas para primitivas de concurrencia: semáforos, colas, notificaciones de tareas en FreeRTOS
• Integrar reportes de cobertura y pruebas en un dashboard de CI (salida JUnit/XUnit XML)
• Emplear macros de aserción avanzadas y características de parametrización de pruebas

Nivel: 5 – Expert
Temas:

• Extender o personalizar el framework de pruebas: escribir plugins, reporters personalizados o nuevas macros de aserción
• Arquitectar una infraestructura de pruebas escalable entre múltiples proyectos y plataformas
• Implementar harnesses de hardware-in-the-loop (HIL) o firmware-in-the-loop (FIL) con control automatizado de fixtures
• Mentorizar equipos en TDD, patrones de diseño de pruebas y hacer cumplir políticas de testing
• Contribuir a proyectos open-source de Unity o CppUTest (correcciones de errores, nuevas características)
• Optimizar ejecución paralela de pruebas, entornos de prueba contenedorizados y minimizar overhead de tiempo de ejecución

9 – Continuous Integration (GitHub Actions / GitLab CI)

Nivel: 1 – Absolute Beginner
Temas:

• Aprender qué es Continuous Integration (CI) y por qué importa (build y test automatizados)
• Identificar servicios populares de CI: GitHub Actions vs GitLab CI
• Crear el archivo de configuración de CI más simple (.github/workflows/ci.yml o .gitlab-ci.yml)
• Añadir un trabajo que haga checkout del código (actions/checkout o git clone) e imprima un mensaje de hola
• Disparar el workflow en cada push a main y ver logs básicos en la interfaz web

Nivel: 2 – Beginner
Temas:

• Extender el trabajo de CI para instalar dependencias (ej. Python/pip, PlatformIO, ESP-IDF)
• Añadir pasos de build: compilar el firmware (idf.py build o pio run)
• Ejecutar pruebas unitarias vía pio test o un test runner personalizado e interpretar pass/fail
• Aprender a leer y filtrar la salida de logs en busca de errores y advertencias
• Hacer commit y push de cambios para disparar CI; corregir fallos de build simples

Nivel: 3 – Intermediate
Temas:

• Dividir build, test, lint y análisis estático en jobs o stages separados
• Usar actions integradas (o plantillas de GitLab) para cachear artefactos de toolchain (actions/cache)
• Implementar un build matrix para probar múltiples placas o versiones de toolchain en paralelo
• Archivar artefactos de build (binarios de firmware, reportes de pruebas, datos de cobertura) para descarga
• Configurar dependencias entre jobs y ejecución condicional (needs: en GitHub Actions, stage: en GitLab CI)

Nivel: 4 – Advanced
Temas:

• Integrar herramientas de cobertura de código (gcov, lcov) y publicar badges de cobertura
• Automatizar comprobaciones de tamaño y uso de memoria del firmware; fallar si se superan umbrales
• Desplegar firmware listo para OTA a un dispositivo de staging vía SSH o runner personalizado
• Gestionar secretos y tokens de forma segura (GitHub Secrets, GitLab CI/CD variables)
• Usar self-hosted runners o contenedores Docker para entornos de build personalizados

Nivel: 5 – Expert
Temas:

• Desarrollar actions reutilizables personalizadas o imágenes Docker optimizadas para builds de ESP32
• Arquitectar pipelines multi-proyecto: bibliotecas compartidas, manejo de submódulos, triggers cross-repo
• Implementar workflows avanzados: previews de ramas feature, despliegues canary, rollback automático
• Hacer cumplir el cumplimiento con políticas de ramas protegidas, commits firmados y logs de auditoría
• Mentorizar y documentar mejores prácticas de CI/CD entre equipos; capacitar en solución de fallos complejos de pipeline

10 – Jira & Confluence

Nivel: 1 – Absolute Beginner
Temas:

• Entender el propósito del seguimiento de issues vs. documentación
• Registrarse en Jira Cloud (o conectar a una instancia existente)
• Navegar la interfaz de Jira: proyectos, issues, backlog, board
• Crear una issue básica: seleccionar proyecto, tipo, resumen, descripción
• Transicionar una issue a través de un workflow simple (To Do → In Progress → Done)
• Añadir comentarios y adjuntos a una issue
• Registrarse en Confluence (o acceder al espacio del equipo)
• Crear una página de Confluence: título, cuerpo de texto, guardar y editar

Nivel: 2 – Beginner
Temas:

• Trabajar con diferentes tipos de issue (Task, Bug, Story, Epic) y campos de prioridad
• Usar boards básicos de Jira: Scrum y Kanban, mover tarjetas entre columnas
• Filtrar issues con JQL simple (ej. project = “XYZ” AND status = “Open”)
• Configurar notificaciones por correo simples y vigilar issues
• En Confluence, organizar páginas en Spaces y jerarquías padre-hijo
• Usar macros comunes: Code Block, Table, Panel, Image
• Insertar enlaces a issues de Jira y listas de issues en páginas de Confluence

Nivel: 3 – Intermediate
Temas:

• Personalizar pantallas de issue y añadir campos personalizados
• Definir y modificar workflows simples: estados, transiciones, validadores
• Crear y compartir dashboards con gadgets (Filter Results, Burndown Chart)
• Escribir consultas JQL avanzadas para filtros y boards complejos
• Configurar swimlanes de board por consultas o asignados
• En Confluence, crear y usar Templates y Blueprints
• Gestionar permisos de página, labels y restricciones de página
• Usar macros Include Page, Excerpt y Page Properties para reportes dinámicos

Nivel: 4 – Advanced
Temas:

• Construir reglas de Jira Automation: triggers, condiciones, acciones (ej. auto-asignar, enviar alertas)
• Configurar SLAs, service desks y rastrear métricas con Jira Service Management
• Arquitectar boards multi-proyecto y releases cross-project
• Usar Portfolio for Jira (Advanced Roadmaps) para planificar timelines y dependencias
• En Confluence, crear Blueprints y Theme overrides personalizados
• Incrustar contenido dinámico: gráficos de Jira, diagramas Gliffy, macros Live
• Analizar analytics de páginas y actividad de usuarios para optimizar contenido

Nivel: 5 – Expert
Temas:

• Administrar configuraciones globales de Jira: permisos, esquemas de tipos de issue, esquemas de workflow
• Diseñar workflows complejos de nivel empresarial con ramificaciones, aprobaciones y automatización
• Integrar Jira con herramientas externas (CI/CD, Slack, GitHub) vía webhooks y apps
• Liderar implementación ITSM: change management, workflows de incident/problem
• En Confluence, desarrollar plugins personalizados o usar ScriptRunner para automatización
• Definir plantillas de espacio, look-and-feel global y esquemas avanzados de permisos
• Mentorizar y capacitar equipos en mejores prácticas y políticas de gobernanza de Jira/Confluence

11 – Digital & Analog Electronics

Nivel: 1 – Absolute Beginner
Temas:

• Entender unidades eléctricas básicas: voltaje (V), corriente (A), resistencia (Ω), potencia (W)
• Aprender la Ley de Ohm (V = I∙R) y cálculos básicos de series/paralelo
• Identificar componentes pasivos: resistencias, condensadores, inductores
• Usar un multímetro para medir voltaje, corriente y resistencia en circuitos DC simples
• Leer e interpretar símbolos de circuitos y esquemas básicos

Nivel: 2 – Beginner
Temas:

• Construir y analizar redes de resistencias en serie y paralelo y divisores de voltaje
• Introducir condensadores: curvas de carga/descarga, constantes de tiempo RC, filtros simples pasa-bajo/pasa-alto
• Entender niveles de lógica digital (TTL vs. CMOS) y cómo se traducen a GPIO de ESP32
• Técnicas de adaptación de niveles: divisores resistivos, level shifters basados en MOSFET para señales UART
• Usar protoboards y cables jumper para prototipar circuitos de interfaz de sensores

Nivel: 3 – Intermediate
Temas:

• Diseñar front-end analógico para sensores: elegir y configurar op-amps (inversor, no inversor)
• Implementar amplificadores de instrumentación para señales diferenciales de sensores (ej. sondas NPK)
• Interfaz con ADC: entender rango de escala completa, resolución, tasa de muestreo y selección de voltaje de referencia
• Fundamentos de EMI/EMC: condensadores de desacoplo, estrategias de tierra, reglas básicas de layout
• Analizar y mitigar ruido: blindaje, cableado trenzado, ferrites

Nivel: 4 – Advanced
Temas:

• Crear circuitos de medición de precisión: métodos de calibración, compensación de deriva térmica
• Diseño avanzado de filtros: topologías de filtros activos (Butterworth de segundo orden, Bessel)
• Diseño de fuentes de alimentación: selección y layout de convertidores DC-DC, LDOs y desacoplo bulk/cerámico
• Layout de PCB para señal mixta: tierras analógicas/digital separadas, trazas de impedancia controlada, tierra en estrella
• Realizar comprobaciones básicas de cumplimiento EMI: sonda de campo cercano, técnicas de análisis espectral

Nivel: 5 – Expert
Temas:

• Arquitectar front-ends analógicos de bajo ruido: soluciones discretas personalizadas, presupuesto de ruido y selección de componentes
• Diseñar e integrar ICs de señal mixta: ADCs/DACs de alta resolución, aislamiento digital y optimización de timing SPI/I²C
• Desarrollar y validar configuraciones de PMICs o ICs de gestión de potencia personalizados para dispositivos a batería
• Liderar esfuerzos de certificación EMI/EMC: redacción de planes de prueba, interpretación de normas CE/FCC, pre-compliance testing y remediación
• Mentorizar y revisar diseños analógicos y de señal mixta del equipo, optimizar para manufacturabilidad, costo y fiabilidad

12 – PCB Design (KiCad / Altium)

Nivel: 1 – Absolute Beginner
Temas:

• Entender qué es una PCB y por qué se usa (vs. protoboard o perfboard)
• Instalar KiCad o Altium Designer y explorar la interfaz
• Crear un nuevo proyecto esquemático y colocar componentes básicos (resistencia, LED, conector)
• Ejecutar Electrical Rules Check (ERC) para detectar errores obvios de netlist
• Generar una netlist e importarla a un layout de PCB en blanco
• Colocar footprints en el contorno de la placa y rutear trazas simples de una sola capa
• Exportar archivos Gerber y drill básicos

Nivel: 2 – Beginner
Temas:

• Construir y gestionar una biblioteca personalizada de símbolos y footprints
• Definir y aplicar reglas de diseño: anchos de traza, clearances, anillos de perforación
• Usar planos de tierra y de potencia para simplificar el ruteo y mejorar la fiabilidad
• Añadir texto de serigrafía, designadores de componentes y capas mecánicas del contorno de la placa
• Trabajar con footprints through-hole y surface-mount, entendiendo configuraciones de pad y soldermask
• Ejecutar Design Rule Check (DRC) y corregir errores comunes de clearance/overlap
• Generar un paquete de fabricación completo: Gerbers, taladrado NC, BOM

Nivel: 3 – Intermediate
Temas:

• Crear esquemáticos multi-hoja (jerárquicos) y gestionar la conectividad de nets
• Definir un stackup controlado para placas de 4 o 6 capas, incluyendo espesores de dieléctrico
• Rutear pares diferenciales y pares de señales igualadas en longitud (USB, SPI, líneas de alta velocidad)
• Usar gestión avanzada de planos: planos divididos, thermal reliefs, zonas de pour
• Integrar modelos 3D para comprobaciones de carcasa y clearances mecánicas
• Automatizar generación de BOM con campos personalizados y exportar a CSV o Excel
• Colaborar vía Git (o SVN) en archivos de proyecto de PCB y gestionar historial de versiones

Nivel: 4 – Advanced
Temas:

• Diseño para manufacturabilidad (DFM): panelización, fiduciales, dibujos de ensamblaje
• Implementar prácticas de integridad de señal de alta velocidad: control de impedancia, vías de stitching, caminos de retorno
• Crear y reutilizar plantillas de proyecto con reglas de diseño y stacks de capas corporativos
• Realizar análisis térmicos y de distribución de potencia básicos dentro de la herramienta ECAD
• Escribir y ejecutar scripts (Python en KiCad o scripts de Altium) para automatizar tareas repetitivas
• Desarrollar y gestionar bibliotecas de componentes centralizadas con estados de ciclo de vida y variantes aprobadas
• Integrar datos ECAD con CAD mecánico para ingeniería concurrente

Nivel: 5 – Expert
Temas:

• Arquitectar sistemas rigid-flex y multi-placa (backplane), definir áreas de flexión y rigidizadores
• Liderar design reviews enfocados en DFM, DFA (ensamblaje) y DFT (test), y mentorizar a diseñadores junior
• Desarrollar footprints personalizados conformes a IPC y crear documentación de estándares internos de diseño
• Guiar la integración PLM/ERP para gestión del ciclo de vida de partes y flujos de compras
• Planificar y ejecutar paquetes de certificación (UL, CE, FCC) con toda la documentación requerida
• Optimizar características avanzadas: vías ciegas/enterradas, impedancia controlada, diseños HDI con microvías
• Contribuir o personalizar plugins de herramientas ECAD y construir pipelines automatizados para validación de datos de fabricantes

13 – Power‑Budgeting & Solar‑Li‑ion Charging

Nivel: 1 – Absolute Beginner
Temas:

• Entender la relación entre voltaje, corriente y potencia (P = V × I)
• Aprender características básicas de baterías Li-ion: voltaje nominal (~3.7 V), capacidad (mAh/Ah), rangos de voltaje seguro
• Usar un multímetro para medir voltaje y corriente en circuitos simples alimentados por batería
• Identificar rails de potencia básicas en una placa ESP32 y leer sus etiquetas (5 V, 3.3 V)
• Familiarizarse con un panel solar pequeño: especificaciones de voltaje en circuito abierto (Voc) y corriente de cortocircuito (Isc)

Nivel: 2 – Beginner
Temas:

• Construir una hoja de cálculo simple de presupuesto de potencia: listar cada subsistema (ESP32, sensor, radio) con su corriente de operación y duty cycle
• Calcular corrientes medias y pico; estimar autonomía con una capacidad de batería dada
• Comparar reguladores lineales (LDOs) vs. reguladores switching simples para reducir a 3.3 V
• Cablear un IC básico de carga Li-ion (ej. MCP73831) en protoboard y observar el comportamiento del LED de carga
• Medir la salida del panel bajo diferentes niveles de luz y aprender a leer las curvas de su datasheet

Nivel: 3 – Intermediate
Temas:

• Introducir conceptos de Maximum Power Point Tracking (MPPT): por qué MPPT mejora la recolección de energía vs. sombreado pasivo
• Seleccionar y configurar un controlador de carga solar comercial (ej. Adafruit Solar LiPo Charger)
• Dimensionar el panel solar y la batería para autonomía objetivo y peor caso meteorológico; incluir márgenes de seguridad
• Diseñar un circuito de doble entrada de potencia: batería más solar, con ORing de diodo ideal o diodos Schottky
• Implementar estados de firmware de bajo consumo (deep sleep, light sleep) y medir corriente en reposo

Nivel: 4 – Advanced
Temas:

• Evaluar y elegir entre diferentes ICs o módulos MPPT para uso embebido (ej. STSPIN, serie TI BQ)
• Diseñar árbol de potencia de PCB personalizado: convertidores buck/boost, load switches, indicadores power-good
• Modelar curvas de carga/descarga de la batería y efectos térmicos; simular en SPICE o hoja de cálculo
• Implementar gestión dinámica de potencia en firmware: adaptar tasa de muestreo o duty cycle de radio según SoC de la batería
• Añadir protecciones de hardware: sobre-tensión, sub-tensión, sobre-corriente y monitoreo de temperatura

Nivel: 5 – Expert
Temas:

• Arquitectar un algoritmo MPPT completamente personalizado en firmware o FPGA, afinado para perfiles solares locales
• Desarrollar o modificar firmware de PMIC (ej. para un BMS personalizado) y optimizar para eficiencia > 98 %
• Liderar diseño de energy harvesting en ambientes extremos: baja luz, temperaturas extremas, análisis de sombreado parcial
• Integrar diagnósticos avanzados de salud de batería: conteo de culombios, seguimiento de impedancia, algoritmos predictivos de SoC/SoH
• Mentorizar equipos en trade-offs de sistemas de potencia, preparar documentación para certificaciones de seguridad UL/IEC y optimizar para yield y fiabilidad de manufactura.

14 – Battery Management (18650)

Nivel: 1 – Absolute Beginner
Temas:

• Aprender especificaciones básicas de celdas Li-ion 18650: voltaje nominal, capacidad, corriente máxima de carga/descarga
• Entender seguridad básica de la celda: sin cortocircuitos, polaridad correcta, evitar sobre-descarga
• Medir voltaje de celda con multímetro; reconocer puntos de lleno (4.2 V) y vacío (≈3.0 V)
• Identificar características comunes de ICs de protección: corte por sobre-tensión, sub-tensión, sobre-corriente
• Practicar manejo seguro: usar portapilas adecuado, nunca perforar o aplastar celdas

Nivel: 2 – Beginner
Temas:

• Cablear un módulo cargador de celda simple (ej. TP4056) y monitorear LEDs de estado de carga
• Entender perfil de carga CC-CV: corriente constante hasta umbral, luego reducción de voltaje constante
• Añadir una PCB de protección a la celda: entender cómo funciona la protección basada en MOSFET
• Leer curvas de carga/descarga del datasheet de la celda y guías de derating
• Calcular State of Charge (SoC) aproximado a partir de la curva de voltaje vs. SoC

Nivel: 3 – Intermediate
Temas:

• Introducir conceptos básicos de conteo de culombios: medir carga entrante/saliente vía resistencia de sensado de corriente y ADC
• Seleccionar e integrar un amplificador de sensado de corriente (ej. INA219 o IC contador de culombios dedicado)
• Calibrar el sistema de conteo de culombios: offset, ganancia y compensación de deriva
• Combinar SoC basado en voltaje y conteo de culombios para mejorar precisión
• Implementar comprobaciones básicas de salud de batería: conteo de ciclos, estimación de desgaste de capacidad

Nivel: 4 – Advanced
Temas:

• Diseñar un circuito de carga balanceada multi-celda (2–4 celdas) con resistencias de balanceo o IC balanceador activo
• Integrar un IC BMS completo (ej. serie TI BQ769x0): sobre-tensión, sub-tensión, sobre-corriente, monitoreo de temperatura
• Implementar algoritmos de SoC y SoH en firmware: filtro de Kalman o contador de culombios adaptativo
• Añadir sensado de temperatura (NTC o digital) y compensación para curvas de carga/descarga
• Validar seguridad bajo condiciones de falla: simular corto, sobre-corriente, sobre-temperatura y registrar eventos de falla

Nivel: 5 – Expert
Temas:

• Arquitectar firmware de BMS personalizado: algoritmos avanzados de balanceo de celdas, perfiles de carga adaptativos
• Optimizar precisión de conteo de culombios a largo plazo: corrección de deriva, compensación de temperatura, algoritmos auto-aprendizaje
• Liderar esfuerzos de certificación: documentación y creación de planes de prueba IEC 62133, UL 2054, UN 38.3

15 – Cellular Comms (SIMCom AT, PPP, TCP/IP)

Nivel: 1 – Absolute Beginner
Temas:

• Aprender conceptos básicos de celular: GSM vs LTE vs NB-IoT
• Identificar pinout de la tarjeta SIM y cómo insertar/expulsar la SIM
• Alimentar y cablear un módulo SIMCom a un microcontrolador o adaptador USB-a-UART
• Abrir un terminal serie (minicom, PuTTY) a la velocidad en baudios correcta
• Enviar comandos AT simples: AT, ATI, AT+CSQ
• Interpretar respuestas: OK, ERROR y códigos básicos de calidad de señal

Nivel: 2 – Beginner
Temas:

• Comprobar registro en red: AT+CREG? y AT+CGREG?
• Configurar contexto PDP: AT+CGDCONT=1,”IP”,””
• Usar PPP para levantar un enlace IP: escribir un chat script e invocar pppd
• Verificar conectividad IP sobre PPP: hacer ping a un host conocido o usar una herramienta de test de sockets
• Enviar y leer SMS: AT+CMGF=1, AT+CMGS=””, AT+CMGR=
• Manejar códigos de error básicos: leer y decodificar +CME ERROR:

Nivel: 3 – Intermediate
Temas:

• Abrir y gestionar sockets TCP: AT+CIPSTART=”TCP”,”host”,”port”
• Enviar y recibir datos sobre el socket: AT+CIPSEND y AT+CIPRXGET
• Monitorear unsolicited result codes (URCs): +CIPSTATUS, +TCP_CLOSED
• Implementar lógica automática de reconexión en firmware cuando cae el socket o PPP
• Usar modos de sueño del módulo para ahorro de energía: AT+CFUN, AT+CSCLK
• Asegurar el enlace con comandos básicos de TLS si están soportados (ej. AT+SSLOPT)

Nivel: 4 – Advanced
Temas:

• Integrar el levantamiento de PPP en tareas de RTOS con callbacks de eventos en conexión/desconexión
• Gestionar múltiples APNs y contextos de fallback para resiliencia en roaming
• Ejecutar un cliente MQTT sobre el socket celular usando comandos basados en AT
• Consultar datos GNSS/ubicación si el módulo lo soporta: AT+CGPS=1, AT+CGPSINFO
• Perfilar throughput y latencia: medir tasas de datos y optimizar buffering de firmware
• Diagnosticar problemas de RF y red usando comandos extendidos de info de red (ej. AT+QENG)

Nivel: 5 – Expert
Temas:

• Desarrollar u optimizar una biblioteca parser de comandos AT con máquinas de estados y buffering robusto
• Diseñar un daemon PPP personalizado o stack IP ligero para sistemas profundamente embebidos
• Implementar integración a nivel de driver: transferencias UART basadas en DMA, control de flujo por hardware
• Soportar modos de datos avanzados: raw sockets, multicast/broadcast UDP, modo datos SMS
• Manejar aprovisionamiento seguro de certificados en flash y gestionar sesiones TLS de extremo a extremo
• Mentorizar equipos sobre mejores prácticas de IoT celular: optimización de costos, cumplimiento normativo y consideraciones de diseño de antena/RF

16 – IoT Protocols (MQTT / HTTPS)

Nivel: 1 – Absolute Beginner
Temas:

• Entender qué son los protocolos IoT y por qué importan para dispositivos restringidos
• Aprender conceptos básicos de MQTT: modelo public/subscribe, rol del broker, topics, niveles QoS (0, 1, 2)
• Aprender conceptos básicos de HTTPS: petición/respuesta cliente-servidor, principios REST, URLs, métodos (GET, POST)
• Instalar un cliente MQTT de escritorio (MQTT.fx, MQTT Explorer) y conectar a un broker público (ej. test.mosquitto.org )
• Usar curl para hacer peticiones HTTPS GET simples a APIs públicas

Nivel: 2 – Beginner
Temas:

• Escribir firmware para conectar un ESP32 a un broker MQTT usando una biblioteca simple (ej. PubSubClient para Arduino o esp_mqtt_client para ESP-IDF)
• Publicar lecturas de sensores a un topic de prueba; suscribirse y registrar mensajes de otro topic
• Construir payloads JSON básicos y parsear JSON entrante en firmware
• Realizar peticiones HTTPS desde ESP32: configurar HTTPClient (Arduino) o esp_http_client (ESP-IDF)
• Manejar validación de certificados a nivel básico (usar modo inseguro para empezar, luego cambiar a root CA adecuada)

Nivel: 3 – Intermediate
Temas:

• Implementar persistencia de sesión MQTT: mensajes retenidos, clean session = false
• Usar Last Will and Testament (LWT) de MQTT para señalar desconexiones inesperadas
• Organizar jerarquías de topics con wildcards (+, #) para mensajería escalable de dispositivos
• Gestionar certificados TLS en flash: convertir PEM a DER, embeber en partición
• Manejar HTTPS POST con cuerpos JSON y parsear respuestas JSON; gestionar headers

Nivel: 4 – Advanced
Temas:

• Diseñar e implementar una arquitectura MQTT segura: certificados de cliente, autenticación TLS mutua
• Optimizar rendimiento de MQTT: publicaciones agrupadas, uso apropiado de QoS, minimizar overhead de keepalive
• Implementar autenticación mutua HTTPS (certificados de cliente) y gestionar rotación de certificados
• Integrar MQTT sobre WebSockets para dashboards basados en navegador o redes restringidas
• Construir un cliente REST stateful ligero en ESP32 con retry, backoff y patrones de circuit breaker

Nivel: 5 – Expert
Temas:

• Arquitectar un puente de protocolos personalizado: traducir entre CoAP, MQTT y HTTPS para redes IoT heterogéneas
• Desarrollar un plugin o extensión de broker MQTT interno para autorización, filtrado o transformación personalizados
• Prototipar y evaluar protocolos IoT alternativos (ej. MQTT-SN, AMQP, LwM2M) para casos de uso especializados
• Liderar auditorías de seguridad: threat modeling, evaluaciones de vulnerabilidades de stacks de comunicación IoT
• Mentorizar equipos en diseño de arquitecturas de mensajería IoT grandes, seguras y resilientes con protocolos híbridos

17 – TLS / mbedTLS Security Basics

Nivel: 1 – Absolute Beginner
Temas:

• Aprender conceptos básicos de criptografía: texto plano vs. cifrado, cifrado simétrico vs. asimétrico, hashing
• Entender qué proporciona TLS: confidencialidad, integridad, autenticidad
• Estudiar el flujo de handshake TLS de alto nivel: ClientHello, ServerHello, intercambio de claves, record layer
• Instalar mbedTLS y explorar el directorio de ejemplos programs/ssl
• Compilar y ejecutar los ejemplos ssl_client1 y ssl_server2 en tu escritorio

Nivel: 2 – Beginner
Temas:

• Configurar mbedTLS vía config.h: habilitar solo los módulos necesarios (SSL/TLS, X.509, primitivas criptográficas)
• Generar un certificado y clave auto-firmados con OpenSSL; convertir entre formatos PEM y DER
• Modificar y ejecutar ssl_client2 para realizar un HTTPS GET contra un servidor público
• Establecer versión mínima de TLS y elegir suites de cifrado básicas en la configuración SSL
• Habilitar logging de depuración de mbedTLS para trazar pasos del handshake y códigos de error

Nivel: 3 – Intermediate
Temas:

• Implementar autenticación PSK (Pre-Shared Key) en mbedTLS para dispositivos restringidos
• Embeber certificados y claves en flash o leerlos desde una partición de filesystem en tiempo de ejecución
• Usar el parser X.509 de mbedTLS para validar certificados de servidor contra un bundle de root CA
• Sembrar el generador de números aleatorios con un TRNG de hardware (ej. esp_hardware_poll del ESP32) vía mbedtls_ctr_drbg
• Integrar mbedTLS como componente en ESP-IDF e invocar conexiones TLS desde una tarea de FreeRTOS

Nivel: 4 – Advanced
Temas:

• Implementar TLS mutuo (certificados de cliente y servidor) en un entorno embebido
• Diseñar un mecanismo seguro de rotación de certificados con protección de rollback de firmware
• Optimizar huella de memoria: deshabilitar módulos no usados, afinar uso de heap vs. stack en mbedtls_platform_set_calloc_free
• Conectar con un acelerador criptográfico de hardware (offload RSA/ECC) y registrarlo con la capa PK de mbedTLS
• Almacenar claves privadas de forma segura: usar cifrado de flash o un elemento seguro externo (ATECC608A)

Nivel: 5 – Expert
Temas:

• Contribuir correcciones o nuevas características al núcleo de mbedTLS (ej. añadir una nueva suite de cifrado o mejorar código constant-time)
• Realizar auditorías de seguridad y fuzz testing sobre el handshake y primitivas criptográficas
• Construir una configuración de mbedTLS conforme a FIPS 140-2 y documentar la validación de módulos
• Desarrollar implementaciones resistentes a side-channel y endurecer contra ataques de timing o análisis de potencia
• Definir y mentorizar sobre políticas de seguridad de nivel empresarial: threat modeling, gestión del ciclo de vida de claves, procesos de divulgación de vulnerabilidades

18 – Sensor Calibration & Compensation

Nivel: 1 – Absolute Beginner
Temas:

• Entender qué significan “calibración de sensor” y “compensación” y por qué importan
• Aprender a leer valores ADC raw de un sensor en código (ej. adc1_get_raw)
• Registrar salidas raw del sensor en condiciones ambientales usando print serie o un logger simple
• Familiarizarse con estándares de referencia básicos: resistencias fijas conocidas, voltajes de referencia conocidos
• Graficar lecturas raw vs. valores esperados en una hoja de cálculo para ver linealidad u errores de offset

Nivel: 2 – Beginner
Temas:

• Realizar una calibración de dos puntos (offset y ganancia): recopilar lecturas en dos concentraciones o cargas conocidas
• Calcular e implementar una fórmula simple de mapeo lineal en firmware
• Documentar pasos y resultados de calibración: incluir condiciones de prueba (temperatura, humedad)
• Introducir métricas de error: error medio, desviación estándar, error máximo
• Automatizar recolección de datos de calibración con scripts o comandos shell simples

Nivel: 3 – Intermediate
Temas:

• Caracterizar la respuesta del sensor en todo su rango con datos multipunto (al menos 5–10 puntos)
• Ajustar curvas de orden superior (regresión polinomial) o segmentos lineales por tramos en una herramienta como Python o Excel
• Implementar compensación de temperatura y humedad: leer sensores ambientales y aplicar fórmulas de corrección
• Validar compensación comparando lecturas compensadas contra instrumentos de referencia en diversas condiciones
• Almacenar coeficientes de calibración en memoria no volátil (memoria RTC, partición NVS o flash)

Nivel: 4 – Advanced
Temas:

• Desarrollar protocolos de calibración robustos: randomizar orden de prueba, controlar variables ambientales, registrar metadatos
• Usar técnicas estadísticas: detección de outliers, intervalos de confianza, estudios de repetibilidad/reproducibilidad
• Automatizar rutinas de calibración en el dispositivo: modo de calibración interactivo con prompts de usuario
• Implementar rutinas de auto-calibración o auto-zero para eliminar deriva durante despliegues prolongados
• Gestionar y versionar datos de calibración en un backend o base de datos de calibración

Nivel: 5 – Expert
Temas:

• Arquitectar algoritmos de compensación multivariante (ej. usando sensor fusion o regresores de machine learning para sensibilidades cruzadas complejas)
• Diseñar y construir rigs o fixtures de calibración automatizados para calibración en alto volumen de producción
• Definir y hacer cumplir estándares y procedimientos de calibración (documentación estilo ISO 17025)
• Monitorear deriva de calibración en campo y disparar remotamente recalibración o actualizaciones de firmware
• Mentorizar y capacitar al equipo en conceptos avanzados de metrología; publicar guías internas de calibración y white papers

19 – Data Logging & OTA Storage

Nivel: 1 – Absolute Beginner
Temas:

• Aprender qué significa almacenamiento persistente en un ESP32 y por qué es útil para logging o staging OTA
• Entender la diferencia entre filesystems de flash interna (SPIFFS, LittleFS) y tarjetas SD externas
• Montar SPIFFS en Arduino (SPIFFS.begin()) o ESP-IDF (esp_vfs_spiffs_register)
• Listar archivos, abrir un archivo para escritura ("w"), escribir una línea, cerrar, luego abrir para lectura e imprimir contenido
• Inicializar y montar una tarjeta SD (Arduino SD.begin(), ESP-IDF esp_vfs_fat_sdspi_mount), abrir un archivo y hacer lectura/escritura básica

Nivel: 2 – Beginner
Temas:

• Usar modo append ("a") para añadir nuevas entradas de log sin sobrescribir datos existentes
• Recorrer directorios: abrir directorios, leer nombres de archivos, filtrar por extensión o timestamp
• Configurar tamaño de partición SPIFFS/LittleFS en platformio.ini o sdkconfig, reflashear y verificar
• Explorar diferencias de LittleFS: montajes más rápidos, wear leveling integrado, operaciones de metadatos
• Detectar y manejar errores de montaje, comprobar espacio libre antes de escribir, recuperar un filesystem corrupto

Nivel: 3 – Intermediate
Temas:

• Implementar rotación de logs: cuando un archivo supera un umbral de tamaño o edad, cerrarlo e iniciar uno nuevo; eliminar logs más antiguos
• Registrar datos binarios de sensores eficientemente: serializar structs o floats, escribir/leer de vuelta a memoria
• Montar y usar FAT en SD con soporte de nombres largos; gestionar múltiples particiones SD
• Crear una capa de abstracción para que tu código pueda cambiar entre SPIFFS, LittleFS o SD por configuración
• Almacenar grandes datos o chunks de firmware en una partición dedicada “ota_data” usando escrituras raw de flash

Nivel: 4 – Advanced
Temas:

• Entender y editar la tabla de particiones del ESP32: entradas factory, ota_0, ota_1, data (spiffs/littlefs)
• Usar APIs OTA de ESP-IDF: esp_ota_begin(), esp_ota_write(), esp_ota_end(), esp_ota_set_boot_partition()
• Descargar y escribir una imagen de firmware completa a la partición OTA inactiva, verificar su integridad, cambiar boot
• Manejar actualizaciones interrumpidas: detectar escrituras parciales, volver al último firmware conocido bueno
• Optimizar resiliencia del filesystem: usar operaciones de archivo atómicas, estrategias de journaling o doble buffer

Nivel: 5 – Expert
Temas:

• Diseñar layouts de particiones personalizados: múltiples particiones de datos, redimensionamiento dinámico, integración de flash externa
• Implementar filesystems cifrados y/o comprimidos para asegurar datos en reposo y reducir desgaste
• Desarrollar actualizaciones delta-OTA o basadas en parches para minimizar tamaño de descarga y tiempo de actualización
• Construir harnesses de prueba automatizados para simular corrupción de filesystem y validar flujos de recuperación OTA
• Mentorizar sobre mejores prácticas: alineación de particiones, gestión de desgaste de flash, integración de secure boot y gestión completa del ciclo de vida de datos almacenados y actualizaciones de firmware

20 – Remote OTA Update Flow

Nivel: 1 – Absolute Beginner
Temas:

• Entender qué son las actualizaciones OTA (Over-The-Air) y por qué son útiles
• Explorar un ejemplo simple de OTA en Arduino (ArduinoOTA) o ESP-IDF (ota_https_simple)
• Configurar tu entorno de desarrollo para habilitar OTA: incluir la biblioteca/componente OTA
• Flashear el ejemplo “blink” con OTA habilitado y confirmar que anuncia un servicio o endpoint HTTP
• Disparar una actualización OTA manual desde VS Code o Arduino IDE y observar el reinicio del firmware

Nivel: 2 – Beginner
Temas:

• Alojar un binario de firmware en un servidor HTTP(S) local o servidor de archivos simple
• Escribir código de firmware para obtener el manifiesto de versión o URL del binario por HTTP usando HTTPClient o esp_http_client
• Descargar y aplicar la actualización a la partición secundaria usando la API OTA de ESP-IDF (esp_ota_begin, esp_ota_write, esp_ota_end)
• Verificar la integridad de la nueva imagen usando checksums integrados o headers HTTP ETag
• Implementar rollback básico: si el nuevo firmware no arranca o señala un error, revertir a la partición anterior

Nivel: 3 – Intermediate
Temas:

• Automatizar disparadores OTA: comprobar actualizaciones al arrancar o en timers periódicos, comparar versión actual con manifiesto
• Asegurar el canal de actualización: cambiar de HTTP a HTTPS, validar certificados de servidor, fijar CAs en flash
• Soportar delta-OTA (diferencias binarias) para reducir tamaño de descarga: integrar y aplicar parches en lugar de imágenes completas
• Usar MQTT o MQTT-SN para notificar a dispositivos de actualizaciones disponibles y controlar el despliegue por dispositivo o grupo
• Almacenar metadatos de actualización (versión, timestamp, estado) en almacenamiento no volátil (NVS) para auditoría

Nivel: 4 – Advanced
Temas:

• Integrar con un servicio OTA basado en nube (ej. AWS IoT Device Management, Azure IoT Hub) vía sus APIs REST/MQTT
• Implementar despliegues escalonados: lanzar primero a un pequeño porcentaje de dispositivos, monitorear salud, luego expandir
• Diseñar un esquema de particiones A/B con imagen golden fallback y health checks automatizados al inicio
• Automatizar pipelines de build, firma y publicación de firmware en CI/CD; embeber firmas y verificar en dispositivo
• Manejar actualizaciones multi-componente (bootloader, tabla de particiones, aplicación, filesystem) en una sola transacción

Nivel: 5 – Expert
Temas:

• Arquitectar un backend de gestión OTA personalizado: versionado, grupos de dispositivos, actualizaciones diferenciales, integración de telemetría
• Implementar seguridad de extremo a extremo: firma de código con claves asimétricas, integración de secure boot, protección contra replay
• Optimizar mecanismos de actualización para redes de bajo ancho de banda o intermitentes: entrega por chunks, soporte de reanudación, control adaptativo de tasa
• Construir caminos de actualización redundantes: múltiples servidores, compartición peer-to-peer, estrategias de fallback CDN
• Mentorizar equipos sobre mejores prácticas: cumplimiento con estándares de la industria (ej. IEC 62443), manejo robusto de errores y gestión completa del ciclo de vida de versiones de firmware

21 – Control & Estimation Theory

Nivel: 1 – Absolute Beginner
Temas:

• Comprender la idea básica de un lazo de control: setpoint, medición y error
• Diferenciar sistemas de lazo abierto vs. lazo cerrado
• Implementar un controlador simple on/off (bang-bang) en pseudocódigo o C
• Entender la noción de respuesta del sistema: rise time, overshoot, settling time (conceptual)
• Aprender qué significa “estimación”: usar mediciones ruidosas para inferir un valor verdadero

Nivel: 2 – Beginner
Temas:

• Derivar y codificar un controlador proporcional (P): output = Kₚ·error
• Añadir términos integral (I) y derivativo (D) para construir un controlador PID; sintonizar Kₚ, Kᵢ, K_d a prueba
• Implementar un filtro pasa-bajo de primer orden (discreto) para lecturas ruidosas de sensores
• Modelar sistemas simples como ecuaciones en diferencias (ej. circuito RC discreto)
• Escribir un filtro de media móvil o suavizado exponencial en firmware

Nivel: 3 – Intermediate
Temas:

• Representar sistemas en forma de espacio de estados (ẋ = Ax + Bu; y = Cx + Du) y discretizar para firmware
• Diseñar e implementar un filtro de Kalman discreto para un modelo 1D de velocidad constante
• Analizar estabilidad de un sistema controlado por PID con root locus o diagramas de Bode (MATLAB/Python)
• Implementar anti-windup para el término I y filtrado derivativo en un algoritmo PID
• Embeber código de control y estimación en tareas de FreeRTOS con temporización determinista

Nivel: 4 – Advanced
Temas:

• Diseñar controladores óptimos por retroalimentación de estados (LQR) y observadores de Kalman discretos
• Extender a Extended Kalman Filters (EKF) para sistemas no lineales (ej. cinemática simple de robot móvil)
• Realizar diseño en dominio de frecuencia: margen de ganancia y fase, notch filters, sintonización PID vía Ziegler–Nichols y métodos de relay
• Codificar un prototipo de model predictive control (MPC) en C o C++, usando un horizonte pequeño
• Perfilar tiempo de ejecución y memoria de lazos de control; optimizar para restricciones de tiempo real

Nivel: 5 – Expert
Temas:

• Arquitectar esquemas de control no lineal: sliding-mode, control adaptativo, controladores robustos H∞
• Liderar desarrollo de bibliotecas personalizadas EKF/UKF o solvers MPC para targets embebidos
• Mentorizar al equipo en estimación avanzada: fusión multi-sensor (IMU + GPS + sondas de suelo) usando técnicas de simultaneous localization and mapping (SLAM)
• Publicar guías internas de diseño sobre mejores prácticas y verificación de seguridad de control/estimación
• Contribuir algoritmos novedosos o mejoras de vuelta a proyectos open-source de control/estimación o papers académicos

22 – Python / Bash Scripting

Nivel: 1 – Absolute Beginner
Temas:

• Instalar Python 3 y pip; verificar con python3 --version y pip3 --version
• Abrir un shell bash; ejecutar bash --version
• Crear y ejecutar un script “hello world” en Python (hello.py) y un script bash simple (hello.sh)
• Añadir líneas shebang (#!/usr/bin/env python3 y #!/usr/bin/env bash) y hacer scripts ejecutables (chmod +x)
• Usar comandos bash básicos: echo, ls, pwd, cd; y print() de Python, asignaciones simples de variables

Nivel: 2 – Beginner
Temas:

• Tipos de datos de Python (int, float, string, list, dict) y flujo de control (if, for, while); definir funciones simples
• Variables de bash, parámetros posicionales ($1, $2), reglas de quoting, if [ ] básico y bucles for
• E/S de archivos: open/read/write en Python; redirección (>, >>) y lectura de líneas en bash (while read)
• Importar y usar módulos integrados de Python (os, sys); source de scripts bash auxiliares con source
• Manejo básico de errores: try/except en Python; set -e y trap '…' ERR en bash

Nivel: 3 – Intermediate
Temas:

• Entornos virtuales de Python (python3 -m venv), requirements.txt, instalar paquetes de terceros vía pip
• Parseo de argumentos en bash usando getopts o getopt y escribir funciones bash reutilizables
• Scripts de automatización de build: invocar make, idf.py o pio desde Python (subprocess) o bash
• Usar argparse de Python para interfaces CLI robustas y módulo logging para logs estructurados
• E/S avanzada de shell: pipes (|), process substitution (<(), >()), here-docs (<<EOF) y command substitution

Nivel: 4 – Advanced
Temas:

• Escribir pruebas unitarias en Python con pytest o unittest; hacer cumplir estilo con flake8/pylint y añadir type hints con mypy
• Endurecer scripts bash: set -euxo pipefail, validación de parámetros, funciones de limpieza con trap, modo debug (set -x)
• Usar Python para tareas concurrentes: threading, multiprocessing y herramientas de alto nivel como concurrent.futures
• Construir módulos Python reutilizables e instalarlos vía setup.py/pyproject.toml; gestionar versiones y dependencias
• Automatizar pasos de CI/CD: escribir scripts Python o bash que orquesten jobs de GitHub Actions o GitLab CI

Nivel: 5 – Expert
Temas:

• Desarrollar y publicar herramientas CLI independientes en Python usando frameworks como Click o Typer; publicar paquetes en PyPI
• Arquitectar frameworks grandes de bash: scripts modulares, sistemas de plugins, coprocesos, redirección I/O avanzada
• Perfilar y optimizar scripts Python (ej. cProfile, line_profiler), adoptar asyncio para tareas de alto throughput
• Integrar scripts con servicios del sistema: escribir unit files de systemd, scripts de entry-point de contenedores, automatización de Docker-Compose
• Definir y enseñar al equipo mejores prácticas de scripting: seguridad (sanitización de entrada, evitar inyección), documentación y plantillas de código mantenible

23 – Cloud & Dashboard Basics

Nivel: 1 – Absolute Beginner
Temas:

• Comprender el concepto de plataformas IoT en la nube vs. soluciones on-premise
• Registrarse en una prueba gratuita de AWS IoT Core o Azure IoT Hub
• Navegar el portal de AWS IoT o Azure: explorar la sección Things/Devices y ver los dashboards de overview
• Instalar y ejecutar una herramienta de escritorio (AWS IoT Explorer o Azure IoT Explorer) para conectar y enviar un mensaje de telemetría de ejemplo
• Entender qué es InfluxDB: instalar una instancia local de InfluxDB 2.x vía Docker o binario, ejecutar la CLI integrada y escribir un punto de datos

Nivel: 2 – Beginner
Temas:

• Registrar un dispositivo (“Thing”) en AWS IoT Core o un dispositivo en Azure IoT Hub; descargar e inspeccionar los certificados generados o tokens SAS
• Usar el SDK de AWS IoT (C/Python) o el Azure Device SDK para publicar telemetría JSON simple sobre MQTT
• Instalar Grafana, añadir InfluxDB como fuente de datos y crear un panel básico de series temporales mostrando un campo
• Escribir datos en InfluxDB desde la línea de comandos (usando curl o la CLI de Influx) y verificarlos en la UI de InfluxDB
• Explorar conceptos de Grafana: dashboards, paneles, consultas, selector de rango de tiempo

Nivel: 3 – Intermediate
Temas:

• Implementar código de dispositivo de estilo producción: conexiones MQTT persistentes, lógica de reconexión, payloads JSON estructurados, jerarquías de topics
• Definir una regla de AWS IoT para reenviar telemetría entrante a una función Lambda, tabla DynamoDB o stream Kinesis
• Configurar tareas de InfluxDB o Telegraf para ingerir y transformar streams de datos entrantes automáticamente
• Construir dashboards de Grafana multi-panel usando consultas Flux o InfluxQL: añadir gauges, gráficos y paneles stat
• Configurar reglas de alerta simples en Grafana basadas en umbrales y configurar un canal de notificación por email o Slack

Nivel: 4 – Advanced
Temas:

• Endurecer autenticación: restringir políticas de IoT en AWS, afinar RBAC de Azure IoT Hub, rotar certificados/tokens SAS programáticamente
• Usar AWS IoT Device Shadows o Azure Digital Twins para sincronizar estado desired/reported entre nube y dispositivo
• Escalar InfluxDB con políticas de retención, continuous queries o Tasks, y shard groups para almacenamiento a largo plazo
• Implementar provisioning de Grafana como código para gestionar dashboards y alertas mediante archivos JSON/YAML en Git
• Integrar Grafana con gestores de alertas externos o servicios de notificación (PagerDuty, OpsGenie, Microsoft Teams)

Nivel: 5 – Expert
Temas:

• Arquitectar una backbone IoT global y resiliente: failover multi-región de AWS IoT Core o Azure IoT Hub, integración de edge-gateway con Greengrass o Azure IoT Edge
• Automatizar toda la infraestructura: escribir módulos de Terraform o plantillas ARM/Bicep para desplegar recursos IoT, clústeres de InfluxDB, instancias de Grafana y políticas IAM
• Optimizar ingesta de alto volumen: escrituras agrupadas, técnicas de compresión, estrategias de backpressure y procedimientos de backfill
• Diseñar y hacer cumplir dashboards multi-tenant en Grafana con RBAC granular y filtrado de fuentes de datos
• Mentorizar equipos sobre mejores prácticas de control de costos, cumplimiento de seguridad (GDPR, HIPAA), políticas de retención de datos y monitoreo operativo del stack de analytics IoT

24 – Regulatory & Environmental Compliance

Nivel: 1 – Absolute Beginner
Temas:

• Aprender por qué importan la aprobación regulatoria y las clasificaciones ambientales para un dispositivo comercial
• Entender el alcance del marcado CE (UE) vs. certificación FCC (EE.UU.) vs. códigos IP básicos
• Identificar qué directivas aplican (ej. EMC, LVD para CE; Part 15 para FCC) y qué significa una clasificación IP67
• Buscar y guardar recursos oficiales: base de datos NANDO de la UE, portal de autorización de equipos de la FCC

Nivel: 2 – Beginner
Temas:

• Estudiar estándares esenciales: inmunidad/emisiones EMC (EN 61326-1 / FCC Part 15 Subpart B), seguridad (EN 61010‐1)
• Aprender cómo se prueban las clasificaciones IP (chorro de agua, cámara de polvo) y qué significa cada dígito
• Recopilar datasheets y declaraciones de conformidad de proveedores para cada módulo o componente
• Documentar la ruta de cumplimiento esperada en una hoja de cálculo o checklist simple

Nivel: 3 – Intermediate
Temas:

• Redactar un Technical File (CE) o plan de pruebas FCC: incluir diagramas de bloques, esquemas, BOM, evaluación de riesgos
• Implementar mitigación básica de EMI/EMC: añadir ferritas, choques de modo común, pours de tierra en PCB
• Realizar pruebas pre-compliance internas: sonda de campo cercano, pruebas con pistola ESD, comprobaciones básicas de aislamiento
• Preparar artwork de etiquetado del dispositivo: marca CE, FCC ID, símbolos WEEE, advertencias de uso seguro

Nivel: 4 – Advanced
Temas:

• Gestionar el proceso formal de certificación con un Organismo Notificado (CE) o laboratorio acreditado por la FCC: enviar muestras, presenciar pruebas
• Analizar reportes de prueba, impulsar cambios de diseño para resolver fallos (ej. modificaciones de layout, sellos de carcasa)
• Coordinar pruebas ambientales y mecánicas: ciclo térmico, vibración, pruebas de ingreso para alcanzar la clasificación IP objetivo
• Ensamblar y firmar la Declaración de Conformidad (CE) y presentar el Formulario 731 de la FCC para autorización de equipos

Nivel: 5 – Expert
Temas:

• Definir una estrategia global de cumplimiento que abarque CE, FCC, UL/CSA, RoHS, REACH, WEEE y otros según sea necesario
• Arquitectar hardware y firmware modulares para simplificar re-pruebas y variantes regionales
• Liderar programas de cumplimiento de proveedores: hacer cumplir control de cambios de componentes, auditar QMS del fabricante
• Mantener y actualizar Technical Files y exhibiciones de la FCC a lo largo de revisiones de producto; gestionar auditorías de vigilancia periódicas
• Servir como enlace principal con organismos reguladores, manejar hallazgos de no-conformidad y acciones correctivas, mentorizar al equipo sobre mejores prácticas de stewardship regulatorio continuo.

25 – Documentation Tooling (Markdown, Doxygen)

Nivel: 1 – Absolute Beginner
Temas:

• Entender el propósito de la documentación de proyecto: READMEs, referencias de API, how-tos
• Instalar un editor de Markdown o usar el soporte integrado de VS Code
• Escribir sintaxis básica de Markdown: encabezados (#–###), negrita/cursiva, listas con viñetas y numeradas
• Insertar enlaces e imágenes vía Markdown ([texto](url), ![alt](ruta))
• Previsualizar un README.md en VS Code o en GitHub

Nivel: 2 – Beginner
Temas:

• Crear tablas, blockquotes y bloques de código cercados en Markdown
• Usar enlaces relativos y enlaces ancla para documentación multi-página
• Instalar Doxygen y generar un Doxyfile por defecto
• Anotar código C/C++ con comentarios Doxygen (///, /** ... */) para funciones y tipos
• Ejecutar Doxygen para producir salida HTML y explorar la documentación generada

Nivel: 3 – Intermediate
Temas:

• Personalizar configuraciones de Doxyfile: rutas de entrada, EXTRACT_ALL, EXTRACT_PRIVATE, soporte de diagramas, formatos de salida
• Embeber contenido Markdown en comentarios Doxygen e incluir archivos Markdown externos vía \include
• Organizar documentación en módulos y grupos usando tags @defgroup y @addtogroup
• Integrar la ejecución de Doxygen en tu build de CMake o PlatformIO para que la documentación se actualice con cada build
• Usar extensiones de VS Code para previsualizar combinaciones de Markdown y comentarios Doxygen inline

Nivel: 4 – Advanced
Temas:

• Extender Doxygen con filtros de tags personalizados o pre-procesadores de entrada (ej. scripts Python)
• Automatizar builds de documentación en pipelines de CI y publicar en GitHub Pages, GitLab Pages o Confluence vía conversores
• Generar diagramas PlantUML o Graphviz a partir de anotaciones de código e incluirlos en la documentación
• Mantener métricas de doc-coverage: escribir scripts para detectar funciones/tipos sin documentar y fallar CI si están por debajo de un umbral
• Definir y publicar una guía de estilo para uso de Markdown y Doxygen en el equipo

Nivel: 5 – Expert
Temas:

• Desarrollar layouts y temas personalizados de Doxygen (XSLT, plantillas CSS/HTML personalizadas) para coincidir con la identidad corporativa
• Arquitectar un pipeline híbrido de documentación usando Sphinx o MkDocs junto con Doxygen, con salidas versionadas y búsqueda
• Automatizar la inclusión de documentación cross-repositorio vía Git submodules, Doxyfiles compuestos o enlazado basado en tags
• Liderar revisiones de documentación, hacer cumplir quality gates de CI en documentación y mentorizar al equipo en mejores prácticas
• Contribuir a herramientas de documentación open-source o autorizar plugins/extensiones (ej. para renderizado avanzado de diagramas o ejemplos de código en vivo)