Este contenido aún no está disponible en español y se muestra en inglés.

Mastering the Embedded IoT Developer’s Toolkit

• • What the 5s look like for our ESP32 + SIM + AWS stack
• Skillsets for Embedded Developers
  • 1 – C/C++
  • 2 – ESP-IDF (native) or Arduino-ESP32
  • 3  –  FreeRTOS Fundamentals
  • 4 – Git & GitHub/GitLab
  • 5 – VS Code
  • 6 – PlatformIO
  • 7 – Linux CLI / WSL
  • 8 – Unit‑Testing Framework (Unity / CppUTest)
  • 9 – Continuous Integration (GitHub Actions / GitLab CI)
  • 10 – Jira & Confluence
  • 11 – Digital & Analog Electronics
  • 12 – PCB Design (KiCad / Altium)
  • 13 – Power‑Budgeting & Solar‑Li‑ion Charging
  • 14 – Battery Management (18650)
  • 15 – Cellular Comms (SIMCom AT, PPP, TCP/IP)
  • 16 – IoT Protocols (MQTT / HTTPS)
  • 17 – TLS / mbedTLS Security Basics
  • 18 – Sensor Calibration & Compensation
  • 19 – Data Logging & OTA Storage
  • 20 – Remote OTA Update Flow
  • 21 – Control & Estimation Theory
  • 22 – Python / Bash Scripting
  • 23 – Cloud & Dashboard Basics
  • 24 – Regulatory & Environmental Compliance
  • 25 – Documentation Tooling (Markdown, Doxygen)

5-to-1 Scale

In today’s hyper‑connected world, an embedded developer must juggle firmware, hardware, radio links, and cloud workflows—all at once. Skip even one piece and that “quick” firmware tweak can snowball into weeks of debugging. We learned this the hard way while rolling out a solar‑powered soil‑monitoring node built on ESP32, SIMCom cellular back‑haul, and AWS IoT Core. The experience made one truth crystal‑clear: your learning plan has to mirror your bill of materials.

To keep that plan focused, we grade every competency on a 5‑to‑1 scale—a framework that is completely technology‑agnostic:

Level

What it means

Why it matters

5 = Must‑have

Core language, essential tooling, fundamental concepts

You can’t ship without these

4 = Optimizers

CI/CD, automated testing, security hardening, performance tuning

Turn prototypes into robust products

3 = Workflow boosters

Dashboards, advanced debugging, cloud ops

Streamline day‑to‑day development

2 = Nice‑to‑haves

Specialized features you’ll want later

Add polish when time allows

1 = Specialties

Deep dives for niche domains or future scaling

Tackle when the use‑case demands it

How to apply it anywhere

1. Define the end goal. What does “job‑ready” or “production‑ready” look like?
2. List the 5s. Absolute survival kit.
3. Identify the 4s. Practices that harden and scale the solution.
4. Fill in the 3s. Quality‑of‑life tools and optimizations.
5. Add the 2s and 1s. Specialized depth for bigger teams or advanced features.

Quick proof that it travels well

• Front‑End Web Dev → 5s: HTML/CSS, modern JS, Git… • 4s: React/Vue, TypeScript, Jest, CI/CD… • 3s: Storybook, e2e tests… • 2s: PWAs, animations… • 1s: WebGL, data‑viz.
• Data Science / MLOps → 5s: Python, NumPy/Pandas, stats… • 4s: TensorFlow/PyTorch, Docker, unit tests… • 3s: Feature stores, MLflow… • 2s: Edge inference… • 1s: Federated learning.

By rating each topic’s impact and frequency, you carve out a clear path and avoid overwhelm.

What the 5s look like for our ESP32 + SIM + AWS stack

1. C/C++ fluency – the language of ESP‑IDF and FreeRTOS hooks.
2. ESP‑IDF (or Arduino‑ESP32) mastery – Wi‑Fi, BLE, ADC, deep‑sleep APIs.
3. Electronics fundamentals – level‑shifting SIM UARTs, reading NPK probes, EMI hygiene.
4. Power‑budgeting & Li‑ion/solar charging – keeping a 4 Ah 18650 alive through cloudy weeks.
5. Robust connectivity (Wi‑Fi, SIM AT, MQTT/TLS) – piping sensor data securely into AWS.

Master these five and you can ship a functional prototype. Climb into the 4s—CI pipelines, advanced FreeRTOS, OTA, security—and you’ll have a product that survives the field. The 3s, 2s, and 1s complete the professional toolkit with dashboards, compliance, and domain‑specific depth.

The article that follows is not a checklist; it’s a sequential roadmap mapped to real hardware choices. Start with the 5s, graduate through the 4s, and by the time you dip into 3‑to‑1 territory you’ll have both the confidence and the context to apply them where they matter most. Dive in and let the toolkit carry you from breadboard to production—and beyond.

Skillsets for Embedded Developers

Legend – Importance
5 = Indispensable (must‑have for day‑to‑day work)
4 = Very important (needed on most projects)
3 = Useful (frequently helpful, learn soon)
2 = Nice‑to‑have (learn when time allows)
1 = Specialised / situational

Skill / Tool

Why it matters for an ESP32‑based soil‑measurement product

Importance

1

C / C++

Primary languages for ESP‑IDF, Arduino core and peripheral drivers.

5

2

ESP‑IDF (native) or Arduino‑ESP32

Gives direct access to Wi‑Fi, BLE, GPIO, ADC, UART, I²C and FreeRTOS APIs.

5

3

FreeRTOS fundamentals

Task scheduling, watchdogs, queues and power‑efficient sleep modes.

4

4

Git & GitHub / GitLab

Version control, code review and CI hooks.

5

5

VS Code

Lightweight cross‑platform IDE with strong ESP‑IDF & PlatformIO extensions.

4

6

PlatformIO

Builds, flashes, unit‑tests and static‑analyses embedded projects from VS Code.

4

7

Linux CLI / WSL

Toolchains, build scripts, OpenOCD debugging and containerised CI runners.

3

8

Unit‑testing framework (Unity / CppUTest)

Regression tests for sensor math, comms parsers, battery‑state logic.

3

9

Continuous Integration (GitHub Actions / GitLab CI)

Automates build, test, lint and firmware‑size checks on every push.

3

10

Jira (issues) & Confluence (docs)

Tracks tasks, bugs, requirements and design notes in a team.

3

11

Digital & Analog Electronics

Reading NPK sensor outputs, level‑shifting SIM module UART, EMI mitigation.

5

12

PCB design (KiCad / Altium)

Custom board to host ESP32, NPK interface, Li‑ion charger and solar MPPT.

4

13

Power‑budgeting & Solar‑Li‑ion charging

Sizing panel, charge IC, converters and low‑power firmware states.

5

14

Battery management (18650 safety & coulomb counting)

Protects against over‑/under‑voltage and provides SoC estimate.

4

15

Cellular comms (SIMCom AT commands, PPP, TCP/IP)

Brings cloud connectivity when Wi‑Fi is absent in the field.

5

16

IoT protocols (MQTT / HTTPS)

Lightweight, secure data uplink to server or cloud.

4

17

TLS / mbedTLS security basics

Encrypts data and authenticates device to cloud endpoints.

4

18

Sensor calibration & compensation

Temperature / humidity influencers on NPK readings; field calibration curves.

5

19

Data logging & OTA storage (SPIFFS, LittleFS, SD)

Local backup during connectivity loss; firmware update staging.

3

20

Remote OTA update flow

Keeps thousands of deployed units maintainable.

4

21

Control‑ & Estimation theory

Optional—helps with advanced filtering (Kalman, PID) or adaptive sampling.

2

22

Python / Bash scripting

Log parsing, production‑line flashing, test automation.

3

23

Cloud & dashboard basics (AWS IoT Core, Azure IoT, InfluxDB + Grafana)

Stores, visualises and alerts on soil metrics.

3

24

Regulatory & environmental compliance (CE, FCC, IP‑rating)

Ensures legal deployment and field robustness.

3

25

Documentation tooling (Markdown, Doxygen)

Generates maintainable API and HW design docs.

3

How to read the table

• Start with the 5s: language proficiency, microcontroller SDK, hardware basics, power‑system design, sensor know‑how and cellular comms are make‑or‑break for a reliable field device.
• Tackle the 4s next: development environment, power optimisation, OTA, RTOS and security turn a functional prototype into a production‑ready product.
• 3s round out professional workflow (CI, unit tests, cloud back‑ends, PCB CAD).
• 2s and 1s add depth for larger teams or advanced features and can be postponed if schedule is tight.
• Use this as a skills roadmap: progress left‑to‑right across the importance scale while the project matures.

1 – C/C++

Level: 1 – Absolute Beginner
– C syntax & structure: compilation model (source → object → executable), main() function
– Basic data types: int, char, float, double, bool
– Variables & constants: declaration, initialization, const qualifier
– Operators: arithmetic (+, –, *, /, %), assignment, increment/decrement
– Control flow: if/else, switch, for/while/do-while loops
– Simple I/O: printf, basic console output
– Introduction to pointers: pointer declaration, dereference
– Building & debugging: compile with gcc -o, interpret basic compiler errors

Level: 2 – Beginner
– Memory & pointers: pointer arithmetic, pointers vs. arrays, introduction to malloc/free
– Structured types: struct, union, typedef
– Preprocessor basics: #define, #include, include guards
– Storage classes: auto, static, extern, scope & linkage rules
– Strings & arrays: char[], string functions (strcpy, strlen, etc.)
– Modular code: splitting into multiple .c/.h files, makefile fundamentals (rules, targets)
– Basic debugging tools: gdb stepping, breakpoints, inspecting variables

Level: 3 – Intermediate
– Dynamic memory management: heap vs. stack, common leak patterns, using tools like Valgrind
– File I/O: fopen/fread/fwrite/fclose, file pointers, error handling
– Bitwise operations: masks, shifts, setting/clearing bits, enum and bit-fields
– Function pointers: callbacks, dispatch tables
– Error handling: return-codes, errno
– C++ fundamentals: classes & objects, constructors/destructors, access specifiers
– STL basics: std::vector, std::string, simple use of std::map and iterators
– Namespaces & header organization

Level: 4 – Advanced
– Embedded C specifics: volatile, memory-mapped I/O, const in flash vs. RAM
– Linker & build system: custom linker scripts, section placement, optimization flags (-O2, -Os), cross-compilation toolchains
– C++11/14/17 features: lambdas, auto, range-based for, constexpr, nullptr
– Smart pointers & RAII: unique_ptr, shared_ptr, resource management
– Templates basics: function & class templates, template specialization
– Multithreading: std::thread, mutexes, condition variables, atomic types
– Real-time concepts: interrupt service routines (ISRs), critical sections, priority inversion mitigation

Level: 5 – Expert
– Advanced template meta-programming: variadic templates, SFINAE, type traits
– Deep C++ object model: vtables, object layout, ABI considerations
– Lock-free & low-latency concurrency: atomics, memory orderings, wait-free algorithms
– Compiler & toolchain internals: GCC/Clang pass pipelines, writing custom compiler plugins
– Performance tuning: cache alignment, branch prediction, in-depth profiling (e.g. gprof, hardware counters)
– Bare-metal porting: implementing newlib stubs, minimal C runtime, bring-up code
– Standards & safety: MISRA-C/C++ compliance, static analysis tools (Coverity, Cppcheck)
– Framework contribution: writing/optimizing drivers for FreeRTOS or ESP-IDF internals

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

Level: 1 – Absolute Beginner
– Install ESP-IDF toolchain (Python, Git, ESP-IDF scripts) or Arduino-ESP32 core
– Set up VS Code (or Arduino IDE) for ESP32 development
– Build & flash the “blink” example
– Explore project layout (CMakeLists.txt, sdkconfig or platformio.ini)
– Use basic idf.py (or Arduino) commands: build, clean, flash, monitor

Level: 2 – Beginner
– GPIO: configure pins, read inputs, drive LEDs
– ADC: sample analog channels, convert raw values to voltage
– UART & I²C: send/receive simple strings or bytes
– Wi-Fi station mode: scan APs, connect, retrieve IP
– BLE peripheral: advertise, connect from a phone app
– Tweak menuconfig (partition table, log level) or Arduino board settings

Level: 3 – Intermediate
– FreeRTOS tasks, queues & timers within ESP-IDF framework
– Wi-Fi events API: handle connect/disconnect, reconnection logic
– BLE client & GATT: discover services, read/write characteristics
– SPI & I²C: integrate and calibrate a real sensor (e.g. soil-moisture)
– HTTP(S) OTA updates: set up partitions, trigger updates
– Use esp_timer, detailed logging (ESP_LOG*) and error codes

Level: 4 – Advanced
– Create reusable components (CMake Component API) or custom Arduino libraries
– Build a custom partition table & switch partitions at runtime
– Secure provisioning: SmartConfig, BLE-based Wi-Fi setup
– Advanced BLE (L2CAP, mesh) examples
– Optimize SPI DMA & I²C bus speed/timeout settings
– Integrate mbedTLS for MQTT over TLS
– Automate build/flash/tests in CI (GitHub Actions, ESP-IDF CI scripts)

Level: 5 – Expert
– Contribute new drivers or fix bugs in ESP-IDF core (e.g. ADC calibration)
– Develop custom bootloader or ISR-level optimizations
– Fine-tune FreeRTOS heap regions & scheduler parameters
– Implement secure boot & flash encryption end-to-end
– Perform real-time tracing and profiling (ESP-Trace, Perfcnt)
– Architect multi-project CMake workspaces
– Mentor others: define ESP-IDF best practices and internal component libraries

3  –  FreeRTOS Fundamentals

Level: 1 – Absolute Beginner
– Understand what an RTOS is and why you’d use one
– Install FreeRTOS (via ESP-IDF or PlatformIO) and inspect the demo “hello world” task example
– Learn the basic API for creating and starting a single task (xTaskCreate, vTaskStartScheduler)
– Explore the system tick and how the scheduler switches between tasks
– Use vTaskDelay to block a task for a fixed time

Level: 2 – Beginner
– Create multiple tasks with different priorities and stack sizes
– Use vTaskDelayUntil for periodic task timing
– Understand and apply critical sections (taskENTER_CRITICAL / taskEXIT_CRITICAL)
– Learn about task states (Running, Ready, Blocked, Suspended)
– Use vTaskSuspend / vTaskResume for simple task control

Level: 3 – Intermediate
– Communicate between tasks with queues (xQueueCreate, xQueueSend, xQueueReceive)
– Synchronize tasks using binary and counting semaphores (xSemaphoreCreateBinary, xSemaphoreTake)
– Coordinate events with Event Groups (xEventGroupSetBits, xEventGroupWaitBits)
– Use software timers (xTimerCreate, callback)
– Detect and handle stack overflows

Level: 4 – Advanced
– Optimize memory allocation: choose and configure heap schemes (heap_1…heap_5) and understand fragmentation
– Employ task notifications as lightweight binary semaphores or direct-to-task data messages
– Configure and use tickless idle mode for low-power applications
– Generate and interpret run-time statistics (vTaskGetRunTimeStats)
– Integrate FreeRTOS+Trace or Percepio Tracealyzer

Level: 5 – Expert
– Port FreeRTOS to custom hardware or modify the port layer for advanced use cases
– Implement and tune custom scheduler policies or hook functions (vApplicationIdleHook, vApplicationMallocFailedHook)
– Design complex state machines using advanced synchronization primitives (mutexes with priority inheritance, recursive mutexes)
– Mentor teams on best practices, safety (MISRA-compliant code), and deterministic behavior tuning

4 – Git & GitHub/GitLab

Level: 1 – Absolute Beginner
– Install Git; configure user.name and user.email
– Initialize a repo (git init) and clone existing repos (git clone)
– Basic file tracking: git status, git add, git commit
– View history with git log, inspect changes with git diff
– Simple .gitignore to exclude files

Level: 2 – Beginner
– Create and switch branches: git branch, git checkout/git switch
– Remote setup: git remote add, git fetch, git pull, git push
– Understand origin/main vs local branches
– Resolve simple merge conflicts via editor or CLI
– Use GitHub/GitLab web UI to browse commits and branches

Level: 3 – Intermediate
– Merge vs rebase: git merge, git rebase; know when to use each
– Interactive rebase (git rebase -i) for cleaning up commits
– Tagging: create annotated and lightweight tags; push with git push –tags
– Work with pull requests (GitHub) or merge requests (GitLab): create, review, merge
– Basic CI stub: add a simple GitHub Actions or GitLab CI YAML

Level: 4 – Advanced
– Manage submodules (git submodule) and subtrees
– Write client-side hooks (pre-commit, pre-push) and simple server-side GitLab/GitHub hooks
– Protect branches and enforce merge checks (status checks, approvals)
– Build multi-stage CI/CD pipelines with caching and artifacts
– Use git bisect to locate bugs; cherry-pick specific commits

Level: 5 – Expert
– Administer GitLab/GitHub org settings: user/group permissions, protected branches
– Architect monorepo strategies; manage large files with Git LFS
– Develop custom Git tooling or scripts (libgit2, hooks, automation)
– Deep-dive into Git internals: object storage, packfiles, refs, index
– Define and enforce workflows (Gitflow, trunk-based, GitOps); mentor team on best practices

5 – VS Code

Level: 1 – Absolute Beginner
Topics:

• Install VS Code on Windows, macOS or Linux
• Explore the UI: Activity Bar, Side Bar, Editor Panes, Status Bar
• Open folders and files; basic text editing (tabs, split views)
• Use the integrated terminal to run shell commands
• Invoke the Command Palette (Ctrl+Shift+P) for common actions
• Perform simple Find & Replace (Ctrl+F / Ctrl+H)

Level: 2 – Beginner
Topics:

• Discover & install extensions: C/C++ (ms-vscode.cpptools), ESP-IDF, Arduino-ESP32, PlatformIO IDE
• Customize User vs Workspace settings via settings.json
• Use built-in Source Control view: stage, commit, push/pull
• Configure basic Tasks (tasks.json) to build and flash an ESP32 “Hello World”
• Navigate code with Outline and Breadcrumbs views
• Insert and use simple code snippets

Level: 3 – Intermediate
Topics:

• Configure IntelliSense: set include paths and macros in c_cpp_properties.json
• Create launch configurations (launch.json) for GDB debugging via OpenOCD or JTAG
• Define composite Tasks: build → flash → monitor → lint
• Work in multi-root workspaces (code + docs + tests)
• Integrate linters & formatters (clang-format, cppcheck) as pre-save actions
• Debug FreeRTOS tasks with thread-aware debugging and the Debug view
• Use the Problems panel and Test Explorer for unit tests

Level: 4 – Advanced
Topics:

• Leverage Remote Development: SSH, WSL, and Docker container workspaces
• Create and share custom code snippets & file templates for ESP-IDF/PlatformIO
• Automate CI: export VS Code Tasks to GitHub Actions or GitLab CI pipelines
• Customize keybindings and use Settings Sync to share configuration across machines
• Develop reusable Task Providers via the VS Code Tasks API
• Use conditional and function breakpoints, logpoints, and watch expressions

Level: 5 – Expert
Topics:

• Develop and publish full-fledged VS Code extensions (TypeScript & Extension API) for ESP32 workflows
• Architect large multi-project workspaces with shared, versioned configurations
• Optimize IDE performance: fine-tune extension activation, reduce startup time and memory usage
• Implement corporate-wide settings distribution (Settings Cycler, GPO-based deployment)
• Mentor teammates on VS Code best practices and troubleshoot complex workflows
• Contribute to the VS Code community: write guides, sample repos, and speak at meetups or workshops

6 – PlatformIO

Level: 1 – Absolute Beginner
Topics:

• Install PlatformIO IDE extension in VS Code (or install PIO Core CLI)
• Create a new PlatformIO project (pio init --board esp32dev)
• Inspect project structure: platformio.ini, src/, lib/ folders
• Build (pio run) and upload (pio run --target upload) the default “blink” example
• Open serial monitor (pio device monitor) to view output

Level: 2 – Beginner
Topics:

• Use the Library Manager: pio lib install, pio lib list, add libraries in platformio.ini
• Configure multiple environments (env: sections) for different boards or build modes
• Set build_flags, monitor_speed, and upload_speed in platformio.ini
• Run clean builds (pio run --target clean) and verbose builds (pio run --target verbose)
• Use the Unified Debugger (pio debug) to set breakpoints and step through code

Level: 3 – Intermediate
Topics:

• Manage Debug vs Release builds and OTA-enabled environments in one platformio.ini
• Integrate unit tests with the PlatformIO Test Runner and Unity framework
• Add static analysis: enable cppcheck or clang-tidy via extra scripts or platformio.ini configs
• Automate custom pre- or post-build steps using extra_scripts
• Publish and consume private libraries through the PlatformIO Registry

Level: 4 – Advanced
Topics:

• Create and publish custom Platforms and Boards packages for internal or community use
• Implement advanced upload protocols (JTAG, OTA, custom upload scripts)
• Build CI pipelines using pio ci scripts for GitHub Actions, GitLab CI, or Jenkins
• Generate and automate code coverage reports for unit tests
• Profile firmware size and RAM usage via the PlatformIO IDE Dashboard

Level: 5 – Expert
Topics:

• Contribute enhancements or fixes to PlatformIO Core and official Community Platforms
• Develop custom PlatformIO plugins to extend CLI and IDE features
• Architect and maintain large monorepo or multi-project workspaces using PIO Projects
• Write advanced build hooks to integrate corporate toolchains and deployment workflows
• Mentor teams on PlatformIO best practices and troubleshoot complex cross-platform build/debug issues

7 – Linux CLI / WSL

Level: 1 – Absolute Beginner
Topics:

• Open a terminal on Linux or WSL
• Navigate the filesystem: ls, cd, pwd, mkdir
• View and inspect files: cat, less, head, tail
• Manipulate files: cp, mv, rm, touch
• Edit text with a simple editor (nano or basic vim)

Level: 2 – Beginner
Topics:

• File permissions and ownership: chmod, chown, understanding rwx bits
• Wildcards, globbing, piping (|) and redirection (>, >>, <)
• Search text in files: grep basics
• Manage environment variables and your shell profile (.bashrc, .profile)
• Install and update packages with your distro’s package manager (apt, yum, pacman)
• Connect to remote hosts via ssh and transfer files with scp

Level: 3 – Intermediate
Topics:

• Write Bash scripts: shebang, variables, loops, conditionals, functions
• Text processing with find, xargs, awk, sed
• Process and job control: ps, top/htop, kill, jobs, bg/fg
• Configure udev rules for ESP32 USB/JTAG adapters
• Invoke cross-compilation toolchains and build systems (make, cmake, idf.py) from the CLI
• Run OpenOCD from the command line to flash and debug via JTAG/SWD

Level: 4 – Advanced
Topics:

• Develop robust shell scripts: error handling, logging, unit tests (ShellCheck)
• Automate full build–flash–test pipelines in shell and integrate into CI (GitHub Actions, GitLab CI)
• Containerize your build environment with Docker or Podman; write Dockerfiles for reproducible builds
• Remote debugging and file sync: ssh port forwarding, rsync, tmux/screen for session persistence
• Profile and debug native tools: strace, ltrace, perf

Level: 5 – Expert
Topics:

• Build and maintain custom Linux kernels or modules for embedded targets
• Architect and operate dedicated CI runners (bare-metal or containerized) optimized for embedded cross-compiles
• Implement advanced caching and distributed build techniques (ccache, distcc)
• Design your own CLI frameworks or toolchains, manage dotfiles across teams (Git-driven)
• Mentor others in best practices for shell usage, terminal-based workflows, and automation of hardware test & deployment tasks

8 – Unit‑Testing Framework (Unity / CppUTest)

Level: 1 – Absolute Beginner
Topics:

• Understand the purpose and benefits of unit testing
• Install Unity or CppUTest (via PlatformIO library, pip package, or from source)
• Create a minimal test file and include the framework headers
• Write a simple test function using the TEST macro (Unity) or TEST_GROUP/TEST (CppUTest)
• Run the test runner from the command line and interpret PASS/FAIL output
• Use basic assertion macros (e.g. TEST_ASSERT, CHECK_EQUAL)

Level: 2 – Beginner
Topics:

• Organize tests into suites or groups
• Implement setUp() and tearDown() functions for test fixtures
• Use a wider range of assertions: floats, strings, memory comparisons
• Parameterize tests or loop over test data
• Integrate test compilation and execution into your PlatformIO or CMake build
• Generate simple code-coverage data (e.g. via gcov) and view basic coverage percentages

Level: 3 – Intermediate
Topics:

• Create stubs and fakes for hardware-dependent functions (I²C reads, ADC conversions)
• Introduce a mocking library (CppUMock or Unity’s CMock) to simulate dependencies
• Write tests for asynchronous code: simulate callbacks, interrupts, or FreeRTOS timers
• Automate test runs with shell scripts or a basic CI job
• Collect and analyze detailed coverage metrics (branch, function coverage)
• Test boundary and error conditions extensively

Level: 4 – Advanced
Topics:

• Develop custom mock implementations for low-level drivers and peripheral abstractions
• Use memory-leak detection plugins (CppUTest MemoryLeak detector)
• Port the test runner onto the device for on-target unit tests
• Write tests for concurrency primitives: semaphores, queues, task notifications in FreeRTOS
• Integrate coverage and test reports into a CI dashboard (JUnit/XUnit XML output)
• Employ advanced assertion macros and test parameterization features

Level: 5 – Expert
Topics:

• Extend or customize the testing framework: write plugins, custom reporters, or new assertion macros
• Architect a scalable test infrastructure across multiple projects and platforms
• Implement hardware-in-the-loop (HIL) or firmware-in-the-loop (FIL) test harnesses with automated fixture control
• Mentor teams on TDD, test design patterns, and enforce testing policies
• Contribute to Unity or CppUTest open-source projects (bug fixes, new features)
• Optimize parallel test execution, containerized test environments, and minimize test runtime overhead

9 – Continuous Integration (GitHub Actions / GitLab CI)

Level: 1 – Absolute Beginner
Topics:

• Learn what Continuous Integration (CI) is and why it matters (automated build & test)
• Identify popular CI services: GitHub Actions vs. GitLab CI
• Create the simplest CI config file (.github/workflows/ci.yml or .gitlab-ci.yml)
• Add a job that checks out code (actions/checkout or git clone) and prints a hello message
• Trigger the workflow on every push to the main branch and view basic logs in the web UI

Level: 2 – Beginner
Topics:

• Extend the CI job to install dependencies (e.g. Python/pip, PlatformIO, ESP-IDF)
• Add build steps: compile the firmware (idf.py build or pio run)
• Run unit tests via pio test or custom test runner and interpret pass/fail
• Learn to read and filter log output for errors and warnings
• Commit and push changes to trigger CI; fix simple build failures

Level: 3 – Intermediate
Topics:

• Split build, test, lint, and static-analysis into separate jobs or stages
• Use built-in actions (or GitLab templates) for caching toolchain artifacts (actions/cache)
• Implement a matrix build to test multiple boards or toolchain versions in parallel
• Archive build artifacts (firmware binaries, test reports, coverage data) for download
• Configure job dependencies and conditional execution (needs: in GitHub Actions, stage: in GitLab CI)

Level: 4 – Advanced
Topics:

• Integrate code-coverage tools (gcov, lcov) and publish coverage badges
• Automate firmware size and memory usage checks; fail if thresholds exceeded
• Deploy OTA-ready firmware to a staging device via SSH or custom runner
• Securely manage secrets and tokens (GitHub Secrets, GitLab CI/CD variables)
• Use self-hosted runners or Docker containers for custom build environments

Level: 5 – Expert
Topics:

• Develop custom reusable CI actions or Docker images optimized for ESP32 builds
• Architect multi-project pipelines: shared libraries, submodule handling, cross-repo triggers
• Implement advanced workflows: feature-branch previews, canary deployments, automatic rollbacks
• Enforce compliance with protected-branch policies, signed commits, and audit logs
• Mentor and document CI/CD best practices across teams; train on troubleshooting complex pipeline failures

10 – Jira & Confluence

Level: 1 – Absolute Beginner
Topics:

• Understand the purpose of issue tracking vs. documentation
• Sign up for Jira Cloud (or connect to existing instance)
• Navigate the Jira UI: projects, issues, backlog, board
• Create a basic issue: select project, issue type, summary, description
• Transition an issue through a simple workflow (To Do → In Progress → Done)
• Add comments and attachments to an issue
• Sign up for Confluence (or access your team’s space)
• Create a Confluence page: title, body text, save and edit

Level: 2 – Beginner
Topics:

• Work with different issue types (Task, Bug, Story, Epic) and priority fields
• Use basic Jira boards: Scrum and Kanban, move cards across columns
• Filter issues with simple JQL (e.g. project = “XYZ” AND status = “Open”)
• Configure simple email notifications and watch issues
• In Confluence, organize pages into Spaces and parent-child hierarchies
• Use common macros: Code Block, Table, Panel, Image
• Insert Jira issue links and issue lists into Confluence pages

Level: 3 – Intermediate
Topics:

• Customize issue screens and add custom fields
• Define and modify simple workflows: statuses, transitions, validators
• Create and share dashboards with gadgets (Filter Results, Burndown Chart)
• Write advanced JQL queries for complex filters and boards
• Configure board swimlanes by queries or assignees
• In Confluence, create and use Templates and Blueprints
• Manage page permissions, labels, and page restrictions
• Use Include Page, Excerpt, and Page Properties macros for dynamic reports

Level: 4 – Advanced
Topics:

• Build Jira Automation rules: triggers, conditions, actions (e.g. auto-assign, send alerts)
• Set up SLAs, service desks, and track metrics with Jira Service Management
• Architect multi-project boards and cross-project releases
• Use Portfolio for Jira (Advanced Roadmaps) to plan timelines and dependencies
• In Confluence, create custom Blueprints and Theme overrides
• Embed dynamic content: charts from Jira, Gliffy diagrams, Live macros
• Analyze page analytics and user activity to optimize content

Level: 5 – Expert
Topics:

• Administer global Jira settings: permissions, issue type schemes, workflow schemes
• Design complex, enterprise-grade workflows with branching, approvals, and automation
• Integrate Jira with external tools (CI/CD, Slack, GitHub) via webhooks and apps
• Lead ITSM implementation: change management, incident/problem workflows
• In Confluence, develop custom plugins or use ScriptRunner for automation
• Define space templates, global look-and-feel, and advanced permission schemes
• Mentor and train teams on Jira/Confluence best practices and governance policies

11 – Digital & Analog Electronics

Level: 1 – Absolute Beginner
Topics:

• Understand basic electrical units: voltage (V), current (A), resistance (Ω), power (W)
• Learn Ohm’s Law (V = I∙R) and basic series/parallel calculations
• Identify passive components: resistors, capacitors, inductors
• Use a multimeter to measure voltage, current, and resistance in simple DC circuits
• Read and interpret basic circuit symbols and schematics

Level: 2 – Beginner
Topics:

• Build and analyze series and parallel resistor networks and voltage dividers
• Introduce capacitors: charging/discharging curves, RC time constants, simple low-pass/high-pass filters
• Understand digital logic levels (TTL vs. CMOS) and how they translate to ESP32 GPIO
• Level shifting techniques: resistor dividers, MOSFET‐based level shifters for UART signals
• Use breadboards and jumper wires to prototype sensor interface circuits

Level: 3 – Intermediate
Topics:

• Design analog front‐end for sensors: choosing and configuring op-amps (inverting, non-inverting)
• Implement instrumentation amplifiers for differential sensor signals (e.g. NPK probes)
• ADC interfacing: understand full‐scale range, resolution, sampling rate, and reference voltage selection
• EMI/EMC fundamentals: decoupling capacitors, grounding strategies, basic layout rules
• Analyze and mitigate noise: shielding, twisted-pair wiring, ferrite beads

Level: 4 – Advanced
Topics:

• Create precision measurement circuits: calibration methods, temperature drift compensation
• Advanced filter design: active filter topologies (second‐order Butterworth, Bessel)
• Power‐supply design: selecting and laying out DC-DC converters, LDOs, and bulk/ceramic decoupling
• PCB layout for mixed-signal: separate analog/digital grounds, controlled impedance traces, star grounding
• Conduct basic EMI compliance checks: near-field probing, spectrum analysis techniques

Level: 5 – Expert
Topics:

• Architect low-noise analog front-ends: custom discrete solutions, noise budgeting, and component selection
• Design and integrate mixed-signal ICs: high-resolution ADCs/DACs, digital isolation, and SPI/I²C timing optimization
• Develop and validate custom power management ICs or PMIC configurations for battery‐powered devices
• Lead EMI/EMC certification efforts: writing test plans, interpreting CE/FCC standards, pre-compliance testing, and remediation
• Mentor and review team’s analog & mixed‐signal designs, optimize for manufacturability, cost, and reliability

12 – PCB Design (KiCad / Altium)

Level: 1 – Absolute Beginner
Topics:

• Understand what a PCB is and why it’s used (vs. breadboard or perfboard)
• Install KiCad or Altium Designer and explore the UI
• Create a new schematic project and place basic components (resistor, LED, connector)
• Run Electrical Rules Check (ERC) to catch obvious netlist errors
• Generate a netlist and import it into a blank PCB layout
• Place footprints on the board outline and route simple single‐layer traces
• Export basic Gerber and drill files

Level: 2 – Beginner
Topics:

• Build and manage a personal library of symbols and footprints
• Define and apply design rules: trace widths, clearances, annular rings
• Use ground and power planes to simplify routing and improve reliability
• Add silkscreen text, component designators, and board outline mechanical layers
• Work with through‐hole and surface‐mount footprints, understanding pad and solder mask settings
• Run Design Rule Check (DRC) and fix common clearance/overlap errors
• Generate a complete fabrication package: Gerbers, NC drill, BOM

Level: 3 – Intermediate
Topics:

• Create multi‐sheet (hierarchical) schematics and manage net connectivity
• Define a controlled stackup for 4- or 6-layer boards, including dielectric thicknesses
• Route differential pairs and length‐matched signal pairs (USB, SPI, high‐speed lines)
• Use advanced plane management: split planes, thermal reliefs, pour zones
• Integrate 3D models for enclosure and mechanical clearance checks
• Automate BOM generation with custom fields and export to CSV or Excel
• Collaborate via Git (or SVN) on PCB project files and manage version history

Level: 4 – Advanced
Topics:

• Design for manufacturability (DFM): panelization, fiducials, assembly drawings
• Implement high‐speed signal integrity practices: impedance control, via stitching, return paths
• Create and reuse project templates with company‐wide design rules and layer stacks
• Perform basic thermal and power‐distribution analyses within the ECAD tool
• Write and run scripts (Python in KiCad or Altium scripts) to automate repetitive tasks
• Develop and manage centralized component libraries with lifecycle states and approved variants
• Integrate ECAD data with mechanical CAD for concurrent engineering

Level: 5 – Expert
Topics:

• Architect rigid-flex and multi‐board (backplane) systems, define flex bend areas and stiffeners
• Lead design reviews focusing on DFM, DFA (assembly), and DFT (test), and mentor junior designers
• Develop custom IPC-compliant footprints and create in-house design standards documentation
• Guide PLM/ERP integration for part lifecycle management and procurement workflows
• Plan and execute certification packages (UL, CE, FCC) with all required documentation
• Optimize advanced features: buried/blind vias, controlled impedance, microvia HDI designs
• Contribute or customize ECAD tool plugins and build automated pipelines for fabricator data validation

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

Level: 1 – Absolute Beginner
Topics:

• Understand the relationship between voltage, current, and power (P = V × I)
• Learn basic Li-ion battery characteristics: nominal voltage (~3.7 V), capacity (mAh/Ah), safe voltage ranges
• Use a multimeter to measure voltage and current in simple battery-powered circuits
• Identify basic power rails on an ESP32 board and read their labels (5 V, 3.3 V)
• Get familiar with a small solar panel: open-circuit voltage (Voc) and short-circuit current (Isc) specs

Level: 2 – Beginner
Topics:

• Build a simple power-budget spreadsheet: list each subsystem (ESP32, sensor, radio) with its operating current and duty cycle
• Calculate average and peak current draws; estimate runtime on a given battery capacity
• Compare linear regulators (LDOs) vs. simple switching regulators for stepping down to 3.3 V
• Wire a basic Li-ion charge IC (e.g. MCP73831) on a breadboard and observe charge LED behavior
• Measure panel output under different light levels and learn how to read its datasheet curves

Level: 3 – Intermediate
Topics:

• Introduce Maximum Power Point Tracking (MPPT) concepts: why MPPT improves energy harvest vs passive shading
• Select and configure an off-the-shelf solar charge controller (e.g. Adafruit Solar LiPo Charger)
• Size the solar panel and battery for target runtime and worst‐case weather; include safety margins
• Design a dual-power-input circuit: battery plus solar, with ideal-diode ORing or Schottky diodes
• Implement low-power firmware states (deep sleep, light sleep) and measure quiescent current

Level: 4 – Advanced
Topics:

• Evaluate and choose between different MPPT ICs or modules for embedded use (e.g. STSPIN, TI BQ series)
• Design custom PCB power tree: buck/boost converters, load switches, power-good indicators
• Model battery charge/discharge curves and thermal effects; simulate in SPICE or spreadsheet
• Implement dynamic power management in firmware: adapt sampling rate or radio duty cycle based on battery SoC
• Add hardware protections: over-voltage, under-voltage, over-current and temperature monitoring

Level: 5 – Expert
Topics:

• Architect a fully custom MPPT algorithm in firmware or FPGA, tune for local solar profiles
• Develop or modify power-management IC firmware (e.g. for a custom BMS) and optimize for 98%+ efficiency
• Lead design for extreme-environment energy harvesting: low-light, temperature extremes, partial shading analysis
• Integrate advanced battery‐health diagnostics: coulomb counting, impedance tracking, predictive SoC/SoH algorithms
• Mentor teams in power-system trade-offs, prepare documentation for UL/IEC safety certifications, and optimize for manufacturing yield and reliability.

14 – Battery Management (18650)

Level: 1 – Absolute Beginner
Topics:

• Learn basic 18650 Li-ion cell specifications: nominal voltage, capacity, max charge/discharge current
• Understand basic cell safety: no short circuits, proper polarity, avoid over-discharge
• Measure cell voltage with a multimeter; recognize full (4.2 V) vs empty (≈3.0 V) points
• Identify common protection IC features: over-voltage, under-voltage, over-current cut-off
• Practice safe handling: use a proper holder, never puncture or crush cells

Level: 2 – Beginner
Topics:

• Wire a simple single-cell charger module (e.g. TP4056) and monitor charge status LEDs
• Understand CC-CV charging profile: constant-current until threshold, then constant-voltage taper
• Add a protection PCB to the cell: learn how MOSFET-based protection works
• Read cell datasheet charge/discharge curves and derating guidelines
• Calculate State of Charge (SoC) roughly from voltage vs SoC curve

Level: 3 – Intermediate
Topics:

• Introduce coulomb-counting basics: measure charge in/out via current sense resistor and ADC
• Select and integrate a current-sense amplifier (e.g. INA219 or dedicated coulomb-counter IC)
• Calibrate your coulomb-counting system: offset, gain, and drift compensation
• Combine voltage-based SoC and coulomb-counting to improve accuracy
• Implement basic battery health checks: cycle count, capacity fade estimation

Level: 4 – Advanced
Topics:

• Design a multi-cell (2–4 cells) balance-charge circuit with cell-balancing resistors or active balancer IC
• Integrate a full BMS IC (e.g. TI BQ769x0 series): over-voltage, under-voltage, over-current, temperature monitoring
• Implement in-firmware SoC and SoH algorithms: Kalman filter or adaptive Coulomb counter
• Add temperature sensing (NTC or digital) and compensation for charge/discharge curves
• Validate safety under fault conditions: simulate short, over-current, over-temperature, and log fault events

Level: 5 – Expert
Topics:

• Architect a custom BMS firmware: advanced cell balancing algorithms, adaptive charge profiles
• Optimize Coulomb-counting accuracy over long-term: drift correction, temperature compensation, self-learning algorithms
• Lead certification efforts: IEC 62133, UL 2054, UN 38.3 testing documentation and test plan creation
• Design redundant safety features: dual-IC monitoring, watchdogs, hardware failsafe states
• Mentor and review battery subsystem designs: failure-mode analysis, manufacturability, and reliability testing plans

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

Level: 1 – Absolute Beginner
Topics:

• Learn basic cellular concepts: GSM vs LTE vs NB-IoT
• Identify SIM card pinout and how to insert/eject the SIM
• Power and wire a SIMCom module to a microcontroller or USB-to-UART adapter
• Open a serial terminal (minicom, PuTTY) at the correct baud rate
• Send simple AT commands: AT, ATI, AT+CSQ
• Interpret responses: OK, ERROR, and basic signal quality codes

Level: 2 – Beginner
Topics:

• Check network registration: AT+CREG? and AT+CGREG?
• Configure PDP context: AT+CGDCONT=1,”IP”,””
• Use PPP to bring up an IP link: write a chat script and invoke pppd
• Verify IP connectivity over PPP: ping a known host or use a socket test tool
• Send and read SMS: AT+CMGF=1, AT+CMGS=””, AT+CMGR=
• Handle basic error codes: read and decode +CME ERROR:

Level: 3 – Intermediate
Topics:

• Open and manage TCP sockets: AT+CIPSTART=”TCP”,”host”,”port”
• Send and receive data over the socket: AT+CIPSEND and AT+CIPRXGET
• Monitor unsolicited result codes (URCs): +CIPSTATUS, +TCP_CLOSED
• Implement automatic reconnect logic in firmware when socket or PPP drops
• Use module sleep modes for power saving: AT+CFUN, AT+CSCLK
• Secure the link with basic TLS commands if supported (e.g. AT+SSLOPT)

Level: 4 – Advanced
Topics:

• Integrate PPP bring-up in RTOS tasks with event callbacks on connect/disconnect
• Manage multiple APNs and fallback contexts for roaming resilience
• Run an MQTT client over the cellular socket using AT-based commands
• Query GNSS/location data if the module supports it: AT+CGPS=1, AT+CGPSINFO
• Profile throughput and latency: measure data rates and optimize firmware buffering
• Diagnose RF and network issues using extended network info commands (e.g. AT+QENG)

Level: 5 – Expert
Topics:

• Develop or optimize an AT-command parser library with state machines and robust buffering
• Design a custom PPP daemon or lightweight IP stack for deeply embedded systems
• Implement driver-level integration: DMA-based UART transfers, hardware flow control
• Support advanced data modes: raw sockets, UDP multicast/broadcast, SMS data mode
• Handle secure certificate provisioning in flash and manage TLS sessions end-to-end
• Mentor teams on cellular IoT best practices: cost optimization, regulatory compliance, and antenna/RF design considerations

16 – IoT Protocols (MQTT / HTTPS)

Level: 1 – Absolute Beginner
Topics:

• Understand what IoT protocols are and why they matter for constrained devices
• Learn basics of MQTT: publish/subscribe model, broker role, topics, QoS levels (0, 1, 2)
• Learn basics of HTTPS: client–server request/response, REST principles, URLs, methods (GET, POST)
• Install a desktop MQTT client (MQTT.fx, MQTT Explorer) and connect to a public broker (e.g., test.mosquitto.org )
• Use curl to make simple HTTPS GET requests to public APIs

Level: 2 – Beginner
Topics:

• Write firmware to connect an ESP32 to an MQTT broker using a simple library (e.g., PubSubClient for Arduino or esp_mqtt_client for ESP-IDF)
• Publish sensor readings to a test topic; subscribe and log messages from another topic
• Construct basic JSON payloads and parse incoming JSON in firmware
• Perform HTTPS requests from ESP32: set up HTTPClient (Arduino) or esp_http_client (ESP-IDF)
• Handle certificate validation at a basic level (use insecure mode to start, then switch to proper root CA)

Level: 3 – Intermediate
Topics:

• Implement MQTT session persistence: retain messages, clean session = false
• Use MQTT Last Will and Testament (LWT) to signal unexpected disconnects
• Organize topic hierarchies with wildcards (+, #) for scalable device messaging
• Manage TLS certificates in flash: convert PEM to DER, embed in partition
• Handle HTTPS POST with JSON bodies and parse JSON responses; manage headers

Level: 4 – Advanced
Topics:

• Design and implement a secure MQTT architecture: client certificates, mutual TLS authentication
• Optimize MQTT performance: batch publishes, use QoS appropriately, minimize keepalive overhead
• Implement HTTPS mutual authentication (client certs) and manage certificate rotation
• Integrate MQTT over WebSockets for browser-based dashboards or constrained networks
• Build a lightweight stateful REST client on ESP32 with retry, backoff, and circuit breaker patterns

Level: 5 – Expert
Topics:

• Architect a custom protocol bridge: translate between CoAP, MQTT, and HTTPS for heterogeneous IoT networks
• Develop an in-house MQTT broker plugin or extension for custom authorization, filtering, or transformation
• Prototype and evaluate alternative IoT protocols (e.g., MQTT-SN, AMQP, LwM2M) for specialized use cases
• Lead security audits: threat modeling, vulnerability assessments of IoT communication stacks
• Mentor teams on designing large-scale, secure, and resilient IoT messaging architectures with hybrid protocols

17 – TLS / mbedTLS Security Basics

Level: 1 – Absolute Beginner
Topics:

• Learn basic cryptography concepts: plaintext vs ciphertext, symmetric vs asymmetric encryption, hashing
• Understand what TLS provides: confidentiality, integrity, authenticity
• Study the high-level TLS handshake flow: ClientHello, ServerHello, key exchange, record layer
• Install mbedTLS and explore the programs/ssl example directory
• Build and run the ssl_client1 and ssl_server2 examples on your desktop

Level: 2 – Beginner
Topics:

• Configure mbedTLS via config.h: enable only the modules you need (SSL/TLS, X.509, crypto primitives)
• Generate a self-signed certificate and key with OpenSSL; convert between PEM and DER formats
• Modify and run ssl_client2 to perform an HTTPS GET against a public server
• Set minimum TLS version and choose basic cipher suites in the SSL configuration
• Enable mbedTLS debug logging to trace handshake steps and error codes

Level: 3 – Intermediate
Topics:

• Implement PSK (Pre-Shared Key) authentication in mbedTLS for constrained devices
• Embed certificates and keys in flash or read them from a filesystem partition at runtime
• Use the mbedTLS X.509 parser to validate server certificates against a root CA bundle
• Seed the random-number generator with a hardware TRNG (e.g., ESP32’s esp_hardware_poll) via mbedtls_ctr_drbg
• Integrate mbedTLS as a component in ESP-IDF and invoke TLS connects from a FreeRTOS task

Level: 4 – Advanced
Topics:

• Implement mutual TLS (client-and-server certificates) in an embedded environment
• Design a secure certificate-rotation mechanism with firmware rollback protection
• Optimize memory footprint: disable unused modules, tune heap versus stack usage in mbedtls_platform_set_calloc_free
• Hook into a hardware crypto accelerator (RSA/ECC offload) and register it with the mbedTLS PK layer
• Securely store private keys: use flash encryption or an external secure element (ATECC608A)

Level: 5 – Expert
Topics:

• Contribute fixes or new features to the mbedTLS core (e.g., add a new cipher suite or improve constant-time code)
• Perform security audits and fuzz testing on the handshake and crypto primitives
• Build a FIPS 140-2–compliant mbedTLS configuration and document module validation
• Develop side-channel–resistant implementations and harden against timing or power analysis attacks
• Define and mentor on enterprise‐grade security policies: threat modeling, key‐lifecycle management, vulnerability disclosure processes

18 – Sensor Calibration & Compensation

Level: 1 – Absolute Beginner
Topics:

• Understand what “sensor calibration” and “compensation” mean and why they matter
• Learn how to read raw ADC values from a sensor in code (e.g. adc1_get_raw)
• Log raw sensor outputs at ambient conditions using serial print or a simple data logger
• Familiarize with basic reference standards: known fixed resistors, known reference voltages
• Plot raw readings vs expected values in a spreadsheet to see linearity or offset errors

Level: 2 – Beginner
Topics:

• Perform a two-point (offset & gain) calibration: collect readings at two known concentrations or loads
• Calculate and implement a simple linear mapping formula in firmware
• Document calibration steps and results: include test conditions (temperature, humidity)
• Introduce error metrics: mean error, standard deviation, max error
• Automate calibration data collection with scripts or simple shell commands

Level: 3 – Intermediate
Topics:

• Characterize sensor response over its full range with multi-point data (at least 5–10 points)
• Fit higher-order curves (polynomial regression) or piecewise linear segments in a tool like Python or Excel
• Implement temperature and humidity compensation: read environmental sensors and apply correction formulas
• Validate compensation by comparing compensated readings against reference instruments across conditions
• Store calibration coefficients in non-volatile memory (RTC memory, NVS partition, or flash)

Level: 4 – Advanced
Topics:

• Develop robust calibration protocols: randomize test order, control environmental variables, log metadata
• Use statistical techniques: outlier detection, confidence intervals, repeatability/reproducibility studies
• Automate calibration routines on the device: interactive calibration mode with user prompts
• Implement self-calibration or auto-zero routines to remove drift during long deployments
• Manage and version calibration data in a backend system or calibration database

Level: 5 – Expert
Topics:

• Architect multivariate compensation algorithms (e.g. using sensor fusion or machine-learning regressors for complex cross-sensitivities)
• Design and build automated calibration rigs or test fixtures for high-volume production calibration
• Define and enforce calibration standards and procedures (ISO 17025-style documentation)
• Monitor in-field calibration drift and remotely trigger re-calibration or firmware updates
• Mentor and train team on advanced metrology concepts; publish internal calibration guidelines and white papers

19 – Data Logging & OTA Storage

Level: 1 – Absolute Beginner
Topics:

• Learn what persistent storage on an ESP32 means and why it’s useful for logging or OTA staging
• Understand the difference between internal flash file systems (SPIFFS, LittleFS) and external SD cards
• Mount SPIFFS in Arduino (SPIFFS.begin()) or ESP-IDF (esp_vfs_spiffs_register)
• List files, open a file for write ("w"), write a line, close, then open for read and print contents
• Initialize and mount an SD card (Arduino SD.begin(), ESP-IDF esp_vfs_fat_sdspi_mount), open a file and do basic read/write

Level: 2 – Beginner
Topics:

• Use append mode ("a") to add new log entries without overwriting existing data
• Traverse directories: open directories, read file names, filter by extension or timestamp
• Configure SPIFFS/LittleFS partition size in platformio.ini or sdkconfig, reflash and verify
• Explore LittleFS differences: faster mounts, built-in wear leveling, metadata operations
• Detect and handle mount errors, check free space before writing, recover a corrupted file system

Level: 3 – Intermediate
Topics:

• Implement log rotation: when a file exceeds a size or age threshold, close it and start a new one; delete oldest logs
• Log binary sensor data efficiently: serialize structs or floats, write/read back into memory
• Mount and use FAT on SD with long-filename support; manage multiple SD partitions
• Create an abstraction layer so your code can switch between SPIFFS, LittleFS or SD by configuration
• Stage large data or firmware chunks in a dedicated “ota_data” partition using raw flash writes

Level: 4 – Advanced
Topics:

• Understand and edit the ESP32 partition table: factory, ota_0, ota_1, data (spiffs/littlefs) entries
• Use ESP-IDF’s OTA APIs: esp_ota_begin(), esp_ota_write(), esp_ota_end(), esp_ota_set_boot_partition()
• Download and write a full firmware image to the inactive OTA partition, verify its integrity, switch boot
• Handle interrupted updates: detect partial writes, roll back to last known-good firmware
• Optimize file-system resilience: use atomic file operations, journaling strategies or double‐buffering

Level: 5 – Expert
Topics:

• Design custom partition layouts: multiple data partitions, dynamic resizing, off-chip flash integration
• Implement encrypted and/or compressed file systems to secure data at rest and reduce wear
• Develop delta-OTA or patch-based updates to minimize download size and update time
• Build automated test harnesses for simulating file-system corruption and validating OTA recovery flows
• Mentor on best practices: partition alignment, flash-wear management, secure-boot integration and full lifecycle management of stored data and firmware updates

20 – Remote OTA Update Flow

Level: 1 – Absolute Beginner
Topics:

• Understand what OTA (Over-The-Air) updates are and why they’re useful
• Explore a simple OTA example in Arduino (ArduinoOTA) or ESP-IDF (ota_https_simple)
• Configure your development environment to enable OTA: include the OTA library/component
• Flash the “blink” example with OTA enabled and confirm it advertises a service or HTTP endpoint
• Trigger a manual OTA update from VS Code or the Arduino IDE and watch the firmware restart

Level: 2 – Beginner
Topics:

• Host a firmware binary on a local HTTP(S) server or simple file server
• Write firmware code to fetch the version manifest or binary URL over HTTP using HTTPClient or esp_http_client
• Download and apply the update to the secondary partition using the ESP-IDF OTA API (esp_ota_begin, esp_ota_write, esp_ota_end)
• Verify the new image’s integrity using built-in checksums or HTTP ETag headers
• Implement basic rollback: if the new firmware fails to boot or signals an error, revert to the previous partition

Level: 3 – Intermediate
Topics:

• Automate OTA triggers: check for updates at boot or on periodic timers, compare current version to manifest
• Secure the update channel: switch from HTTP to HTTPS, validate server certificates, pin CAs in flash
• Support delta-OTA (binary diffs) to reduce download size: integrate and apply patches rather than full images
• Use MQTT or MQTT-SN to notify devices of available updates and control rollout per device or group
• Store update metadata (version, timestamp, status) in non-volatile storage (NVS) for audit

Level: 4 – Advanced
Topics:

• Integrate with a cloud-based OTA service (e.g., AWS IoT Device Management, Azure IoT Hub) via their REST/MQTT APIs
• Implement staged rollouts: roll out to a small percentage of devices first, monitor health, then expand rollout
• Design an A/B partition scheme with golden image fallback and automated health checks on startup
• Automate firmware building, signing, and publishing pipelines in CI/CD; embed signatures and verify in-device
• Handle multi-component updates (bootloader, partition table, application, filesystem) in a single transaction

Level: 5 – Expert
Topics:

• Architect a custom OTA management backend: versioning, device groups, differential updates, telemetry integration
• Implement end-to-end security: code signing with asymmetric keys, secure boot integration, replay protection
• Optimize update mechanisms for low-bandwidth or intermittent networks: chunked delivery, resume support, adaptive rate control
• Build redundant update paths: multiple servers, peer-to-peer sharing, fallback CDN strategies
• Mentor teams on best practices: compliance with industry standards (e.g., IEC 62443), robust error-handling, and full lifecycle management of firmware versions

21 – Control & Estimation Theory

Level: 1 – Absolute Beginner
Topics:

• Grasp the basic idea of a control loop: setpoint, measurement and error
• Differentiate open-loop vs closed-loop systems
• Implement a simple on/off (bang-bang) controller in pseudocode or C
• Understand the notion of system response: rise time, overshoot, settling time (conceptual)
• Learn what “estimation” means: using noisy measurements to infer a true value

Level: 2 – Beginner
Topics:

• Derive and code a proportional (P) controller: output = Kₚ·error
• Add integral (I) and derivative (D) terms to build a PID controller; tune Kₚ, Kᵢ, K_d by trial
• Implement a first-order low-pass filter (discrete) for noisy sensor readings
• Model simple systems as difference equations (e.g. discrete RC circuit)
• Write a moving-average filter or exponential smoothing in firmware

Level: 3 – Intermediate
Topics:

• Represent systems in state-space form (ẋ = Ax + Bu; y = Cx + Du) and discretize for firmware
• Design and implement a discrete-time Kalman filter for a 1D constant-velocity model
• Analyze stability of a PID-controlled system with root locus or Bode plots (MATLAB/Python)
• Implement anti-windup for the I-term and derivative filtering in a PID algorithm
• Embed control & estimation code into FreeRTOS tasks with deterministic timing

Level: 4 – Advanced
Topics:

• Design optimal state-feedback controllers (LQR) and discrete Kalman observers
• Extend to Extended Kalman Filters (EKF) for nonlinear systems (e.g. simple mobile robot kinematics)
• Perform frequency-domain design: gain & phase margin, notch filters, PID tuning via Ziegler–Nichols and relay methods
• Code a model predictive control (MPC) prototype in C or C++, using a small horizon
• Profile execution time and memory of control loops; optimize for real-time constraints

Level: 5 – Expert
Topics:

• Architect nonlinear control schemes: sliding-mode, adaptive control, robust H∞ controllers
• Lead development of custom EKF/UKF libraries or MPC solvers for embedded targets
• Mentor team on advanced estimation: multi-sensor fusion (IMU + GPS + soil probes) using simultaneous localization and mapping (SLAM) techniques
• Publish internal design guidelines on control/estimation best practices and safety verification
• Contribute novel algorithms or improvements back to open-source control/estimation projects or academic papers

22 – Python / Bash Scripting

Level: 1 – Absolute Beginner
Topics:

• Install Python 3 and pip; verify with python3 --version and pip3 --version
• Open a bash shell; run bash --version
• Create and run a “hello world” Python script (hello.py) and a simple bash script (hello.sh)
• Add shebang lines (#!/usr/bin/env python3 and #!/usr/bin/env bash) and make scripts executable (chmod +x)
• Use basic bash commands: echo, ls, pwd, cd; and Python’s print(), simple variable assignments

Level: 2 – Beginner
Topics:

• Python data types (int, float, string, list, dict) and control flow (if, for, while); define simple functions
• Bash variables, positional parameters ($1, $2), quoting rules, basic if [ ] and for loops
• File I/O: open/read/write in Python; redirect (>, >>) and read lines in bash (while read)
• Import and use Python’s built-in modules (os, sys); source smaller bash helper scripts with source
• Basic error handling: Python try/except; bash set -e and trap '…' ERR

Level: 3 – Intermediate
Topics:

• Python virtual environments (python3 -m venv), requirements.txt, installing third-party packages via pip
• Bash argument parsing using getopts or getopt and writing reusable bash functions
• Build automation scripts: invoke make, idf.py, or pio from Python (subprocess) or bash
• Use Python’s argparse for robust CLI interfaces and logging module for structured logs
• Advanced shell I/O: pipes (|), process substitution (<(), >()), here-docs (<<EOF) and command substitution

Level: 4 – Advanced
Topics:

• Write Python unit tests with pytest or unittest; enforce style with flake8/pylint and add type hints with mypy
• Harden bash scripts: set -euxo pipefail, parameter validation, trap cleanup functions, debug mode (set -x)
• Use Python for concurrent tasks: threading, multiprocessing, and high-level tools like concurrent.futures
• Build reusable Python modules and install them via setup.py/pyproject.toml; manage versions and dependencies
• Automate CI/CD steps: write Python or bash scripts that orchestrate GitHub Actions or GitLab CI jobs

Level: 5 – Expert
Topics:

• Develop and publish standalone Python CLI tools using frameworks like Click or Typer; publish packages to PyPI
• Architect large bash frameworks: modular scripts, plugin systems, coprocesses, advanced I/O redirection
• Profile and optimize Python scripts (e.g., cProfile, line_profiler), adopt asyncio for high-throughput tasks
• Integrate scripts with system services: write systemd unit files, container entry-point scripts, Docker-Compose automation
• Define and teach team best practices for scripting: security (input sanitization, avoiding injection), documentation, and maintainable code templates

23 – Cloud & Dashboard Basics

Level: 1 – Absolute Beginner
Topics:

• Grasp the concept of cloud-based IoT platforms vs on-premise solutions
• Sign up for a free AWS IoT Core trial or Azure IoT Hub trial account
• Navigate the AWS IoT or Azure portal: explore the Things/Devices section and view the overview dashboards
• Install and run a desktop tool (AWS IoT Explorer or Azure IoT Explorer) to connect and send a sample telemetry message
• Understand what InfluxDB is: install a local InfluxDB 2.x instance via Docker or binary, run the built-in CLI, and write a single data point

Level: 2 – Beginner
Topics:

• Register a device (“Thing”) in AWS IoT Core or a device in Azure IoT Hub; download and inspect the generated certificates or SAS tokens
• Use the AWS IoT SDK (C/Python) or Azure Device SDK to publish simple JSON telemetry over MQTT
• Install Grafana, add InfluxDB as a data source, and create a basic time-series panel displaying one field
• Write data into InfluxDB from the command line (using curl or the Influx CLI) and verify it in the InfluxDB UI
• Explore Grafana concepts: dashboards, panels, queries, time-range picker

Level: 3 – Intermediate
Topics:

• Implement production-style device code: persistent MQTT connections, reconnect logic, structured JSON payloads, topic hierarchies
• Define an AWS IoT Rule to forward incoming telemetry to a Lambda function, DynamoDB table, or Kinesis stream
• Configure InfluxDB tasks or Telegraf to ingest and transform incoming data streams automatically
• Build multi-panel Grafana dashboards using Flux or InfluxQL queries: add gauges, graphs, and stat panels
• Set up simple alert rules in Grafana based on thresholds, and configure an email or Slack notification channel

Level: 4 – Advanced
Topics:

• Harden authentication: lock down IoT policies in AWS, fine-tune Azure IoT Hub RBAC, rotate certificates/SAS tokens on schedule
• Use AWS IoT Device Shadows or Azure Digital Twins to synchronize desired/reported state between cloud and device
• Scale InfluxDB with retention policies, continuous queries or Tasks, and shard groups for long-term storage
• Implement Grafana provisioning (as code) to manage dashboards and alerts through JSON/YAML files in Git
• Integrate Grafana with external alert managers or notification services (PagerDuty, OpsGenie, Microsoft Teams)

Level: 5 – Expert
Topics:

• Architect a global, resilient IoT backbone: multi-region AWS IoT Core or Azure IoT Hub failover, edge-gateway integration with Greengrass or Azure IoT Edge
• Automate entire infrastructure: write Terraform modules or ARM/Bicep templates to deploy IoT resources, InfluxDB clusters, Grafana instances, and IAM policies
• Optimize high-volume data ingestion: batch writes, compression techniques, backpressure strategies, and backfill procedures
• Design and enforce multi-tenant dashboards in Grafana with granular RBAC and data-source filtering
• Mentor teams on best practices for cost control, security compliance (GDPR, HIPAA), data retention policies, and operational monitoring of the IoT analytics stack

24 – Regulatory & Environmental Compliance

Level: 1 – Absolute Beginner
Topics:

• Learn why regulatory approval and environmental ratings matter for a commercial device
• Understand the scope of CE marking (EU) vs FCC certification (US) vs basic IP codes
• Identify which directives apply (e.g. EMC, LVD for CE; Part 15 for FCC) and what an IP67 rating signifies
• Find and bookmark official resources: EU’s NANDO database, FCC equipment authorization portal

Level: 2 – Beginner
Topics:

• Study the essential standards: EMC immunity/emissions (EN 61326-1 / FCC Part 15 Subpart B), safety (EN 61010‐1)
• Learn how IP ratings are tested (water jet, dust chamber) and what each digit means
• Gather datasheets and supplier declarations of conformity for each module or component
• Document the expected compliance path in a simple spreadsheet or checklist

Level: 3 – Intermediate
Topics:

• Draft a Technical File (CE) or FCC test plan: include block diagrams, schematics, BOM, risk assessment
• Implement basic EMI/EMC mitigation: add ferrites, common-mode chokes, PCB ground pours
• Perform in-house pre-compliance tests: near-field EMI probing, ESD gun testing, basic insulation checks
• Prepare device labeling artwork: CE mark, FCC ID, WEEE symbols, safe use warnings

Level: 4 – Advanced
Topics:

• Manage the formal certification process with a Notified Body (CE) or FCC-accredited lab: submit samples, witness testing
• Analyze test reports, drive design changes to resolve failures (e.g. layout modifications, enclosure seals)
• Coordinate environmental and mechanical tests: thermal cycling, vibration, ingress testing to achieve the target IP rating
• Assemble and sign the Declaration of Conformity (CE) and file FCC Form 731 for equipment authorization

Level: 5 – Expert
Topics:

• Define a global compliance strategy spanning CE, FCC, UL/CSA, RoHS, REACH, WEEE and others as needed
• Architect modular hardware and firmware to simplify re-testing and regional variants
• Lead supplier compliance programs: enforce component change-control, audit manufacturer QMS
• Maintain and update Technical Files and FCC exhibits across product revisions; manage periodic surveillance audits
• Serve as the primary liaison with regulatory bodies, handle non-compliance findings and corrective actions, mentor the team on best practices for ongoing regulatory stewardship.

25 – Documentation Tooling (Markdown, Doxygen)

Level: 1 – Absolute Beginner
Topics:

• Understand the purpose of project documentation: READMEs, API references, how-tos
• Install a Markdown editor or use VS Code’s built-in support
• Write basic Markdown syntax: headers (#–###), bold/italic, bullet & numbered lists
• Insert links and images via Markdown ([text](url), ![alt](path))
• Preview a README.md in VS Code or on GitHub

Level: 2 – Beginner
Topics:

• Create tables, blockquotes, and fenced code blocks in Markdown
• Use relative links and anchor links for multi-page docs
• Install Doxygen and generate a default Doxyfile
• Annotate C/C++ source with Doxygen comments (///, /** ... */) for functions and types
• Run Doxygen to produce HTML output and browse the generated docs

Level: 3 – Intermediate
Topics:

• Customize Doxyfile settings: input paths, EXTRACT_ALL, EXTRACT_PRIVATE, diagram support, output formats
• Embed Markdown content in Doxygen comments and include external Markdown files via \include
• Organize documentation into modules and groups using @defgroup and @addtogroup tags
• Integrate the Doxygen run into your CMake or PlatformIO build so docs update with each build
• Use VS Code extensions to preview combined Markdown and Doxygen comments inline

Level: 4 – Advanced
Topics:

• Extend Doxygen with custom tag filters or input pre-processors (e.g. Python scripts)
• Automate documentation builds in CI pipelines and publish to GitHub Pages, GitLab Pages or Confluence via converters
• Generate PlantUML or Graphviz diagrams from code annotations and include them in the docs
• Maintain doc-coverage metrics: write scripts to detect undocumented functions/types and fail CI if below a threshold
• Define and publish a style guide for Markdown and Doxygen usage across the team

Level: 5 – Expert
Topics:

• Develop custom Doxygen layouts and themes (XSLT, custom CSS/HTML templates) to match corporate branding
• Architect a hybrid documentation pipeline using Sphinx or MkDocs alongside Doxygen, with versioned outputs and search
• Automate cross-repository documentation inclusion via Git submodules, composite Doxyfiles or tag-based linking
• Lead documentation reviews, enforce CI quality gates on docs, and mentor the team in best practices
• Contribute to open-source documentation tools or author plugins/extensions (e.g., for advanced diagram rendering or live code examples)