The ESP32 Programming has taken the world of IoT by storm, offering a powerful blend of performance and versatility. This low-cost microcontroller features built-in Wi-Fi and Bluetooth capabilities, making it a favorite among hobbyists and professionals alike. With its dual-core architecture and ample GPIO pins, the ESP32 opens up endless possibilities for innovative projects.

Programming the ESP32 can be both exciting and challenging. Whether someone is building a smart home device or experimenting with robotics, understanding the fundamentals of ESP32 programming is crucial. This article will guide readers through the essentials, from setting up the development environment to exploring advanced features, ensuring they can unleash the full potential of this remarkable chip. At WizzDev, our developers primarily leverage Espressif’s ESP-IDF framework in C/C++ for ESP32 projects, but we also bring extensive expertise in STM32, NXP i.MX RT series, Raspberry Pi (including OTA updates), and other embedded platforms to deliver the right solution for each application.

Overview Of ESP32 Programming

ESP32 programming offers a straightforward approach for users interested in building applications with this versatile microcontroller, primarily through Espressif’s component-based ESP-IDF framework in C/C++, which gives full access to Wi-Fi, Bluetooth, peripheral drivers and power-management APIs. At WizzDev, our developers work extensively with ESP-IDF to implement features like Wi-Fi (AP and Station), BLE, HTTPS/MQTT cloud communication, REST-style HTTP servers, OTA updates over BLE/Wi-Fi, and direct hardware control of sensors, displays, motors and more.

PlatformIO

PlatformIO provides an integrated development ecosystem with advanced features like automatic dependency resolution and management via its Library Manager, which detects and installs needed libraries from the PlatformIO Registry or VCS repositories during build or test sessions. It supports over 1,000 boards, 40+ development platforms, and 20+ frameworks through its cross-platform build system, offering zero-config debugging with support for popular debugging probes and multi-architecture projects. Developers configure project environments in a simple platformio.ini file, enabling fine-grained control over build flags, library dependency modes, and platform-specific settings. PlatformIO integrates seamlessly with version control systems (e.g., Git) and CI/CD pipelines, facilitating team collaboration, remote development, and continuous integration workflows suitable for larger embedded projects 

MicroPython

MicroPython provides a lightweight Python 3.4–3.8 implementation optimized for microcontrollers, allowing developers to write scripts that run directly on the ESP32. With its built-in REPL (read–eval–print loop), users can interactively test commands and functions over a serial USB or WebREPL session, accelerating prototyping and debugging. Core hardware-specific modules—such as machine for GPIO, ADC, PWM; network for Wi-Fi and ESP-NOW; and esp32 for heap inspection and deepsleep management—enable direct access to peripherals with concise Python syntax. As a practical learning tool, WizzDev’s blog series “ESP32 WiFi communication in MicroPython” demonstrates using MicroPython to configure STA/AP modes, build web servers with picoweb, and integrate cloud connectivity via urequests. However, for production-grade firmware requiring fine-grained timing, OTA updates, and low-level power management, WizzDev relies on Espressif’s ESP-IDF framework in C/C++, ensuring maximum performance and stability.

Features and Capabilities

MicroPython on ESP32 supports a subset of Python 3.4 (with selected syntax from 3.5–3.8) and includes frozen modules to embed libraries into firmware, reducing RAM usage and improving startup times. For concurrency, MicroPython provides uasyncio, a minimalist asynchronous I/O scheduler modeled after CPython’s asyncio, enabling cooperative multitasking for network I/O, sensor polling, and other tasks without native threads. Tasks can be created via uasyncio.create_task(), sleep or yield control using await uasyncio.sleep_ms(), and schedule timers or interrupts for real-time responsiveness. Power management APIs exposed through the machine module allow entry into light and deep sleep modes (machine.lightsleep(), machine.deepsleep()), automatically restarting from flash with a minimal bootloader and extending battery life in portable designs. While MicroPython simplifies development and educational use, its interpreter overhead and limited code optimization mean that timing-sensitive or memory-intensive tasks may still require a native C/C++ implementation under ESP-IDF. Underlying this capability is the ESP32’s built-in FreeRTOS real-time operating system, which provides preemptive, priority-based multitasking across both CPU cores. 

FreeRTOS

FreeRTOS lets you define multiple tasks—each with its own stack and priority level—and manages context switches, ensuring that high-priority operations (e.g. handling a BLE event or a time-critical sensor read) preempt lower-priority ones. Inter-task communication primitives like queues, semaphores and mutexes simplify sharing data safely between tasks, while software timers and event groups let you schedule operations or react to asynchronous events without blocking. This RTOS foundation is what makes the ESP32 ideal for applications that must juggle networking, sensor processing, display updates and low-power sleep modes all at once.

 

Development Steps

  1. Set up the environment: In VS Code, install the Espressif ESP-IDF or PlatformIO extension to configure the toolchain, board definitions, libraries and debugger.
  2. Connect the ESP32: Plug the board into your PC via USB, install CP210x/CH340 drivers if prompted, then select the correct serial port in your IDE.
  3. Scaffold and write code: Run idf.py create-project <name> or pio project init –board <board_id>, then implement your logic using ESP-IDF APIs (e.g. driver/gpio.h, esp_wifi.h) or Arduino-ESP32 cores.
  4. Upload the code: Build and flash with idf.py build && idf.py -p <PORT> flash or upload via pio run -t upload.
  5. Test the application: Open the serial monitor (idf.py monitor or pio device monitor) to view logs and verify functionality.

Effective ESP32 programming centers around understanding its environment and adapting to specific project needs. By utilizing the right tools and libraries, developers can create functional and engaging applications across various domains, from simple sensors to complex automation systems.

Getting Started With ESP32

The ESP32 is a versatile microcontroller that can be programmed using different environments and languages, each suited to specific needs. At WizzDev, we leverage several ESP32 development frameworks in our projects, choosing the right tool for the job. Below is an overview of the primary programming options for ESP32 and how WizzDev uses them in practice:

  • ESP-IDF (C/C++): This is Espressif’s official IoT Development Framework for the ESP32. WizzDev’s developers primarily use ESP-IDF for production firmware development, writing code in C or C++. This low-level SDK gives us full control over the hardware and utilizes the ESP32’s built-in FreeRTOS real-time operating system. ESP-IDF provides robust APIs for Wi-Fi, Bluetooth, peripherals, and more, making it ideal for professional and scalable IoT applications. We favor ESP-IDF in production because it produces efficient, reliable code and is maintained by the chip manufacturer (Espressif).
  • MicroPython (Python): MicroPython is a lean Python 3 implementation that runs directly on microcontrollers like the ESP32. WizzDev often uses MicroPython on the ESP32 for rapid prototyping and demos. Writing Python allows for very quick development cycles – you can test ideas and sensor interactions without a full compile cycle. For example, our internal IoT Starter kit projects use MicroPython to quickly connect sensors and send data to the cloud. This environment is excellent for proof-of-concept work or educational purposes. However, because Python is an interpreted language, it’s generally used by WizzDev in early-stage development or niche use-cases rather than in performance-critical production firmware.
  • PlatformIO (VS Code Integration): PlatformIO is an open-source development toolset and plugin (commonly used with Visual Studio Code) that can build and flash ESP32 code using various frameworks (including Arduino or ESP-IDF). It isn’t a framework itself, but rather a convenient IDE and build system. Some WizzDev developers use Visual Studio Code with the PlatformIO extension (or Espressif’s own VS Code extension) to streamline development. This provides features like intelligent code completion, debugging, and easy library management. When using PlatformIO, we still program the ESP32 with our framework of choice (for example, writing C++ code against ESP-IDF libraries) – PlatformIO just helps organize and deploy the project. In summary, PlatformIO is a productivity tool; whether we use it or not, the actual code running on the ESP32 is written in ESP-IDF C/C++ according to the project’s needs.

By selecting the appropriate environment, we ensure that our development process at WizzDev is efficient and that the final IoT product meets performance and reliability requirements. For production firmware on ESP32 we rely on the ESP-IDF SDK, while for quick iteration or demos we might leverage higher-level approaches like MicroPython. Arduino tends to stay in the realm of hobby projects or one-off demos, and PlatformIO is used as needed to aid development but is not a substitute for the underlying frameworks. This strategy lets us build prototypes quickly and then refine them into robust solutions using the best tools available.

FAQ

Which programming languages and environments does WizzDev use for ESP32 development?

We primarily use C/C++ for ESP32 development, utilizing Espressif’s ESP-IDF framework for most production projects. This gives us low-level access and high performance. While the Arduino environment (which uses C++ with Arduino libraries) is popular in the ESP32 community, WizzDev generally doesn’t use the Arduino IDE in our professional workflows. Instead, we go with more advanced toolchains (ESP-IDF, and sometimes PlatformIO as the IDE) to develop our firmware.

Does WizzDev use the Arduino IDE for ESP32 projects?

Typically, no. Within WizzDev, the Arduino IDE is not part of our standard development process for ESP32. We find that the Arduino-based approach, although easy to start with, is limiting for complex or large-scale projects. Our engineers prefer to work with tools like Visual Studio Code along with ESP-IDF (or integrate ESP-IDF into PlatformIO). This doesn’t mean Arduino isn’t useful – it’s great for hobbyists or quick tests – but for our production work we need the capabilities of the official ESP-IDF SDK. In short, we might experiment with Arduino libraries occasionally, but we do not rely on the Arduino IDE for any real development work at WizzDev.

When do you choose MicroPython instead of C/C++ on the ESP32?

We choose MicroPython on the ESP32 when we want to accelerate development and testing. If we’re in an early prototype phase or doing a live demo, writing code in Python lets us iterate much faster. For example, if we need to quickly connect a sensor and push data to an AWS cloud service, a few dozen lines of MicroPython can achieve that without worrying about the entire build process. WizzDev has used MicroPython for our IoT demo kits and internal proofs-of-concept because it’s so convenient for trying out ideas. However, MicroPython does have limitations: it’s not as efficient as C/C++ and it may not utilize all low-level features of the ESP32. So for deployment in a resource-constrained or performance-critical scenario, we would translate that Python prototype into C/C++ using ESP-IDF. In summary, MicroPython is a tool in our toolbox for speed and flexibility during prototyping, but we pivot to native C/C++ for the final implementation if the project demands it.

What development tools do WizzDev engineers use to program the ESP32?

Our team uses a professional-grade toolchain. For C/C++ development with ESP-IDF, we often use Visual Studio Code as our editor, combined with either Espressif’s official VS Code extension or the PlatformIO extension to manage the project. These tools provide syntax highlighting, debugging support, and easy uploading of firmware. Some developers also use command-line tools provided by Espressif (like idf.py or CMake) for building and flashing, especially if automated as part of continuous integration. For MicroPython projects, simple IDEs or editors like Thonny, or even command-line tools, can be used to write Python code and transfer scripts to the device. The key point is that WizzDev’s workflow is centered on efficient, professional development practices – using source control, reproducible builds, and testing. Whether we use PlatformIO or another IDE, the focus is on the ESP32 code itself (in ESP-IDF or MicroPython) and delivering a reliable firmware.

Is the Arduino framework ever used in WizzDev’s production devices?

Generally, no – we do not ship products running code built with the Arduino framework. The Arduino core for ESP32 is built on ESP-IDF under the hood, but it abstracts many details and is aimed at simplicity over fine-tuned control. For production devices, WizzDev sticks with the native ESP-IDF API to ensure we can optimize every aspect of the firmware (performance, memory usage, power management, etc.). We also take advantage of ESP-IDF’s built-in support for advanced features like secure boot, OTA updates, and integration with manufacturing tools – features that are harder to manage in the Arduino environment. That said, understanding the Arduino framework can sometimes be useful (for instance, to quickly prototype with an existing Arduino library or to review community examples), but any such prototype would be rewritten using ESP-IDF for the final product. Our clients depend on us for robust, maintainable code, and for that reason we choose the tools and frameworks that best meet those professional standards.