This document is intended to help users set up the software environment for development of applications using hardware based on the Espressif ESP32. Through a simple example we would like to illustrate how to use ESP-IDF (Espressif IoT Development Framework), including the menu based configuration, compiling the ESP-IDF and firmware download to ESP32 boards.
The CMake-based build system is currently in preview release. Documentation may have missing gaps, and you may enocunter bugs (please report these). To view documentation for the older GNU Make based build system, switch versions to the ‘latest’ master branch or a stable release.
ESP32 integrates Wi-Fi (2.4 GHz band) and Bluetooth 4.2 solutions on a single chip, along with dual high performance cores, Ultra Low Power co-processor and several peripherals. Powered by 40 nm technology, ESP32 provides a robust, highly integrated platform to meet the continuous demands for efficient power usage, compact design, security, high performance, and reliability.
Espressif provides the basic hardware and software resources that help application developers to build their ideas around the ESP32 series hardware. The software development framework by Espressif is intended for rapidly developing Internet-of-Things (IoT) applications, with Wi-Fi, Bluetooth, power management and several other system features.
What You Need¶
To develop applications for ESP32 you need:
- PC loaded with either Windows, Linux or Mac operating system
- Toolchain to compile code for ESP32
- Build tools CMake and Ninja to build a full Application for ESP32
- ESP-IDF that essentially contains API for ESP32 and scripts to operate the Toolchain
- A text editor to write programs (Projects) in C, e.g. Eclipse
- The ESP32 board itself and a USB cable to connect it to the PC
Development Environment Steps:
- Setup of Toolchain
- Getting ESP-IDF from GitHub
Once the development environment is set up, we will follow these steps to create an ESP-IDF application:
- Configuration of a Project and writing the code
- Compilation of the Project and linking it to build an Application
- Flashing (uploading) the compiled Application to ESP32 over a USB/serial connection
- Monitoring / debugging of the Application output via USB/serial
Development Board Guides¶
If you have one of ESP32 development boards listed below, click on the link for hardware setup:
If you have different board, move to sections below.
The quickest way to start development with ESP32 is by installing a prebuilt toolchain. Pick up your OS below and follow provided instructions.
We are an using
esp subdirectory in your user’s home directory (
~/esp on Linux and Mac OS,
%userprofile%\esp on Windows) to install everything needed for ESP-IDF. You can use any different directory, but will need to adjust the respective commands.
Depending on your experience and preferences, instead of using a prebuilt toolchain, you may want to customize your environment. To set up the system your own way go to section Customized Setup of Toolchain.
Once you are done with setting up the toolchain then go to section Get ESP-IDF.
Besides the toolchain (that contains programs to compile and build the application), you also need ESP32 specific API / libraries. They are provided by Espressif in ESP-IDF repository. To get it, open terminal, navigate to the directory you want to put ESP-IDF, and clone it using
git clone command:
mkdir -p ~/esp cd ~/esp git clone --recursive https://github.com/espressif/esp-idf.git
ESP-IDF will be downloaded into
For Windows Command Prompt users, the equivalent commands are:
mkdir %userprofile%\esp cd %userprofile%\esp git clone --branch feature/cmake --recursive https://github.com/espressif/esp-idf.git
Do not miss the
--recursive option. If you have already cloned ESP-IDF without this option, run another command to get all the submodules:
cd esp-idf git submodule update --init
The CMake-based build system preview uses a different Git branch to the default. This branch is
feature/cmake. If you missed the
--branch option when cloning then you can switch branches on the command line:
cd esp-idf git checkout feature/cmake
Setup Environment Variables¶
ESP-IDF requires two environment variables to be set for normal operation:
IDF_PATHshould be set to the path to the ESP-IDF root directory.
PATHshould include the path to the
toolsdirectory inside the same
These two variables should be set up on your PC, otherwise projects will not build.
Setting may be done manually, each time PC is restarted. Another option is to set them permanently in user profile. To do this, follow instructions specific to Windows , Linux and MacOS in section Add IDF_PATH & idf.py PATH to User Profile.
Start a Project¶
Copy get-started/hello_world to
cd ~/esp cp -r $IDF_PATH/examples/get-started/hello_world .
For Windows Command Prompt users, the equivalent commands are:
cd %userprofile%\esp xcopy /e /i %IDF_PATH%\examples\get-started\hello_world hello_world
You can also find a range of example projects under the examples directory in ESP-IDF. These example project directories can be copied in the same way as presented above, to begin your own projects.
It is also possible to build examples in-place, without copying them first.
The esp-idf build system does not support spaces in the path to either esp-idf or to projects.
You are almost there. To be able to proceed further, connect ESP32 board to PC, check under what serial port the board is visible and verify if serial communication works. If you are not sure how to do it, check instructions in section Establish Serial Connection with ESP32. Note the port number, as it will be required in the next step.
Being in terminal window, go to directory of
hello_world application by typing
cd ~/esp/hello_world. Then start project configuration utility
cd ~/esp/hello_world idf.py menuconfig
For Windows Command Prompt users:
cd %userprofile%\esp\hello_world idf.py menuconfig
If you get an error about
idf.py not being found, check the
tools directory is part of your Path as described above in Setup Environment Variables. If there is no
idf.py in the
tools directory, check you have the correct branch for the CMake preview as shown under Get ESP-IDF.
Windows users, the Python 2.7 installer will try to configure Windows to associate files with a
.py extension with Python 2. If a separate installed program (such as Visual Studio Python Tools) has created an association with a different version of Python, then running
idf.py may not work. You can either run
C:\Python27\python idf.py each time instead, or change the association that Windows uses for
Linux users, if your default version of Python is 3.x then you may need to run
python2 idf.py instead.
If previous steps have been done correctly, the following menu will be displayed:
Here are couple of tips on navigation and use of
- Use up & down arrow keys to navigate the menu.
- Use Enter key to go into a submenu, Escape key to go up a level or exit.
?to see a help screen. Enter key exits the help screen.
- Use Space key, or
Nkeys to enable (Yes) and disable (No) configuration items with checkboxes “
?while highlighting a configuration item displays help about that item.
/to search the configuration items.
If you are Arch Linux user, navigate to
SDK tool configuration and change the name of
Python 2 interpreter from
Build The Project and Flash¶
Now you can build the project. Run:
This command will compile the application and all the ESP-IDF components, generate bootloader, partition table, and application binaries.
$ idf.py build Running cmake in directory /path/to/hello_world/build Executing “cmake -G Ninja –warn-uninitialized /path/to/hello_world”… Warn about uninitialized values. – Found Git: /usr/bin/git (found version “2.17.0”) – Building empty aws_iot component due to configuration – Component names: … – Component paths: …
… (more lines of build system output)
[527/527] Generating hello-world.bin esptool.py v2.3.1
Project build complete. To flash, run this command: ../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash –flash_mode dio –flash_size detect –flash_freq 40m 0x10000 build/hello-world.bin build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin or run ‘idf.py flash’
If there are no errors, the build will finish by generating the firmware binary .bin file.
Flash To A Device¶
Now you can flash the application to the ESP32 board. Run:
idf.py -p PORT flash
Replace PORT with the name of your ESP32 board’s serial port. On Windows, serial ports have names like
COM1. On MacOS, they start with
/dev/cu.. On Linux, they start with
/dev/tty. (See Establish Serial Connection with ESP32 for full details.)
This step will flash the binaries that you just built to your ESP32 board.
idf.py build before
idf.py flash is not actually necessary, the flash step will automatically build the project if required before flashing.
Running esptool.py in directory [...]/esp/hello_world Executing "python [...]/esp-idf/components/esptool_py/esptool/esptool.py -b 460800 write_flash @flash_project_args"... esptool.py -b 460800 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x1000 bootloader/bootloader.bin 0x8000 partition_table/partition-table.bin 0x10000 hello-world.bin esptool.py v2.3.1 Connecting.... Detecting chip type... ESP32 Chip is ESP32D0WDQ6 (revision 1) Features: WiFi, BT, Dual Core Uploading stub... Running stub... Stub running... Changing baud rate to 460800 Changed. Configuring flash size... Auto-detected Flash size: 4MB Flash params set to 0x0220 Compressed 22992 bytes to 13019... Wrote 22992 bytes (13019 compressed) at 0x00001000 in 0.3 seconds (effective 558.9 kbit/s)... Hash of data verified. Compressed 3072 bytes to 82... Wrote 3072 bytes (82 compressed) at 0x00008000 in 0.0 seconds (effective 5789.3 kbit/s)... Hash of data verified. Compressed 136672 bytes to 67544... Wrote 136672 bytes (67544 compressed) at 0x00010000 in 1.9 seconds (effective 567.5 kbit/s)... Hash of data verified. Leaving... Hard resetting via RTS pin...
If there are no issues, at the end of build process, you should see messages describing progress of flashing the project binary image onto the ESP32. Finally, the module will be reset and “hello_world” application will be running there.
To see if “hello_world” application is indeed running, type
idf.py -p PORT monitor. This command is launching IDF Monitor application:
$ idf.py -p /dev/ttyUSB0 monitor Running idf_monitor in directory [...]/esp/hello_world/build Executing "python [...]/esp-idf/tools/idf_monitor.py -b 115200 [...]/esp/hello_world/build/hello-world.elf"... --- idf_monitor on /dev/ttyUSB0 115200 --- --- Quit: Ctrl+] | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H --- ets Jun 8 2016 00:22:57 rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT) ets Jun 8 2016 00:22:57 ...
Several lines below, after start up and diagnostic log, you should see “Hello world!” printed out by the application.
... Hello world! Restarting in 10 seconds... I (211) cpu_start: Starting scheduler on APP CPU. Restarting in 9 seconds... Restarting in 8 seconds... Restarting in 7 seconds...
To exit the monitor use shortcut
If instead of the messages above, you see a random garbage similar to:
e���)(Xn@�y.!��(�PW+)��Hn9a/9�!�t5��P�~�k��e�ea�5�jA ~zY��Y(1�,1�� e���)(Xn@�y.!Dr�zY(�jpi�|�+z5Ymvp
or monitor fails shortly after upload, your board is likely using 26MHz crystal. Most development board designs use 40MHz and the ESP-IDF uses this default value. Exit the monitor, go back to the menuconfig, change ESP32_XTAL_FREQ_SEL to 26MHz, then build and flash the application again. This is found under
idf.py menuconfig under Component config –> ESP32-specific –> Main XTAL frequency.
You can combine building, flashing and monitoring into one step as follows:
idf.py -p PORT flash monitor
Check the section IDF Monitor for handy shortcuts and more details on using the monitor.
Check the section idf.py for a full reference of
idf.py commands and options.
That’s all what you need to get started with ESP32!
Now you are ready to try some other examples, or go right to developing your own applications.
After some time of using ESP-IDF, you may want to update it to take advantage of new features or bug fixes. The simplest way to do so is by deleting existing
esp-idf folder and cloning it again, exactly as when doing initial installation described in sections Get ESP-IDF.
Another solution is to update only what has changed. This method is useful if you have a slow connection to GitHub. To do the update run the following commands:
cd ~/esp/esp-idf git pull git submodule update --init --recursive
For Windows Command Prompt users:
cd %userprofile%\esp\esp-idf git pull git submodule update --init --recursive
git pull command is fetching and merging changes from ESP-IDF repository on GitHub. Then
git submodule update --init --recursive is updating existing submodules or getting a fresh copy of new ones. On GitHub the submodules are represented as links to other repositories and require this additional command to get them onto your PC.
To use a specific release of ESP-IDF, e.g. v2.1, run:
cd ~/esp git clone https://github.com/espressif/esp-idf.git esp-idf-v2.1 cd esp-idf-v2.1/ git checkout v2.1 git submodule update --init --recursive
For Windows Command Prompt users:
cd %userprofile%\esp git clone https://github.com/espressif/esp-idf.git esp-idf-v2.1 cd esp-idf-v2.1/ git checkout v2.1 git submodule update --init --recursive
After that remember to Add IDF_PATH & idf.py PATH to User Profile, so the toolchain scripts know where to find the ESP-IDF in it’s release specific location.
Different versions of ESP-IDF may have different setup or prerequisite requirements, or require different toolchain versions. If you experience any problems, carefully check the Getting Started documentation for the version you are switching to.