·Engineering

Shaking Off the Rust: My ESP32 Embedded Roadmap

Overcoming analysis paralysis and diving back into the embedded systems world with ESP-IDF, C/C++, and a clear roadmap for the journey ahead.

Sometimes you just need to get back to the basics.

As I focus full-time on building out Hikmatron Systems—architecting both the hardware and software solutions from the ground up—I realized I needed to reconnect with the very edge of these networks: the microcontrollers. After wrapping up my time working on static verification tools late last year, stepping back into pure embedded C/C++ development meant I had some serious rust to shake off.

The Hardware Dilemma

I looked around my workspace and had plenty of ESP32 boards in different varieties just laying around. But when I went looking for refresher material to get back up to speed, I ran into a roadblock: almost every solid online course uses STM32 as their main reference hardware.

This led to a classic case of engineering analysis paralysis. Do I stick with the ESP32 silicon I already own, or do I pause, order an STM32 board, and jump into the STM32Cube ecosystem?

Both ESP-IDF and CubeIDE run smoothly on my Mac, so the tooling environment wasn't going to make the decision for me. I spent way too much time weighing the pros and cons of each path.

Stopping the Overthinking

Eventually, I just had to stop. In engineering, the fundamental concepts—memory management, hardware registers, and real-time constraints—translate across architectures.

I made a rule for myself: stop overthinking, get on with ESP-IDF, refresh the rusty knowledge, and just start building. The plan is to build real projects, document the high-level journey right here on the blog, and push the actual technical deep-dives and code to my GitHub and upcoming videos.

The Roadmap

I took an ESP32 board and mapped out a simple curriculum to get the basics down first. However, I’m not tiptoeing around the complex stuff. The goal is to dive deep into the fundamentals that I can always come back to later, meaning we are tackling things like Interrupt Service Routines (ISRs) and real-time operating systems early on.

Here is the roadmap I am going to follow (though it may evolve based on factors and roadblocks I encounter during the journey):

  • Episode 01: Environment & Tooling – Setting up the Mac environment, getting comfortable with ESP-IDF, and proving the toolchain works.
  • Episode 02: GPIO & Interrupts (ISRs) – Skipping the basic delays and jumping straight into how the chip reacts to the outside world in real-time.
  • Episode 03: Hardware Timers & PWM – Managing time accurately at the hardware level.
  • Episode 04: Communication Protocols – Talking to external sensors and displays via I2C and SPI.
  • Episode 05: Enter FreeRTOS – Breaking away from bare-metal super-loops to manage tasks, priorities, and the scheduler.
  • Episode 06: Safe Concurrency – Passing data safely between ISRs and FreeRTOS tasks using queues and mutexes.
  • Episode 07: Connectivity – Firing up the Wi-Fi stack and getting data off the board.

What's Next

Having a baseline plan is the most important step to actually getting things done. The technicalities, the screen recordings, and the code walkthroughs will all be documented in video format as I progress through this list.

For now, the analysis paralysis is over, and the environment is set up. Time to build.