Esp idf установка на windows

ESP-IDF Tools Installer for Windows

Download

ESP-IDF Tools Installer for Windows download page: https://dl.espressif.com/dl/esp-idf/

Video with installation of ESP-IDF

How to install the ESP-IDF Toolchain on Windows

Table with downloads

Universal Online Installer

Note: Online Installer is recommended way of the installation.

Version Purpose Size
2.23 — 2023-07-20 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.22 — 2023-07-20 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.21 — 2023-03-31 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.20 — 2023-02-08 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.19 — 2023-02-01 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.18 — 2022-12-23 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.17 — 2022-12-06 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.16 — 2022-08-03 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.15 — 2022-04-20 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.14 — 2022-03-30 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB
2.13 — 2022-02-01 — Online Installer download/mirror Deploy ESP-IDF, Espressif-IDE and support for other languages 4 MB

Espressif-IDE Offline Installer

Version Content Size
Espressif-IDE v2.10.0 and ESP-IDF 5.0.2 download/mirror Espressif-IDE 2.10.0 + JDK 17 + ESP-IDF v5.0.2 1 GB
Espressif-IDE v2.10.0 and ESP-IDF 5.0.1 download/mirror Espressif-IDE 2.10.0 + JDK 17 + ESP-IDF v5.0.1 1 GB
Espressif-IDE v2.9.1 and ESP-IDF 5.0.1 download/mirror Espressif-IDE 2.9.1 + JDK 17 + ESP-IDF v5.0.1 1 GB
Espressif-IDE v2.9.0 and ESP-IDF 5.0.1 download/mirror Espressif-IDE 2.9.0 + JDK 17 + ESP-IDF v5.0.1 1 GB
Espressif-IDE v2.8.1 and ESP-IDF 5.0 download/mirror Espressif-IDE + JDK + ESP-IDF v5.0 1 GB
Espressif-IDE v2.8.1 and ESP-IDF 4.4.4 download/mirror Espressif-IDE + JDK + ESP-IDF v5.0 1 GB
Espressif-IDE v2.8.0 and ESP-IDF 5.0 download/mirror Espressif-IDE + JDK + ESP-IDF v5.0 1 GB
Espressif-IDE v2.8.0 and ESP-IDF 4.4.4 download/mirror Espressif-IDE + JDK + ESP-IDF v5.0 1 GB
Espressif-IDE v2.7.0 and ESP-IDF 5.0 download/mirror Espressif-IDE + JDK + ESP-IDF v5.0 1 GB
Espressif-IDE v2.7.0 and ESP-IDF 4.4.3 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4.3 1 GB
Espressif-IDE v2.6.0 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4.2 1 GB
Espressif-IDE v2.5.0 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4 1 GB
Espressif-IDE v2.4.2 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4 1 GB
Espressif-IDE v2.4.1 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4 1 GB
Espressif-IDE v2.4.0 download/mirror Espressif-IDE + JDK + ESP-IDF v4.4 1 GB

Single ESP-IDF Branch Offline Installer

Version Content Size
ESP-IDF v5.1.1 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2, ESP32-C6, ESP32-H2 880 MB
ESP-IDF v5.1 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2, ESP32-C6, ESP32-H2 780 MB
ESP-IDF v5.0.4 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2 780 MB
ESP-IDF v5.0.3 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2 780 MB
ESP-IDF v5.0.2 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2 780 MB
ESP-IDF v5.0.1 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2 670 MB
ESP-IDF v5.0 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3, ESP32-C2 670 MB
ESP-IDF v4.4.3 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3 600 MB
ESP-IDF v4.4.2 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3 600 MB
ESP-IDF v4.4.1 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3 600 MB
ESP-IDF v4.3.6 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3,
ESP32-C3 570 MB
ESP-IDF v4.3.5 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3,
ESP32-C3 570 MB
ESP-IDF v4.3.4 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3,
ESP32-C3 570 MB
ESP-IDF v4.3.3 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3 570 MB
ESP-IDF v4.2.5 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 376 MB
ESP-IDF v4.2.4 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 376 MB
ESP-IDF v4.2.3 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 376 MB
ESP-IDF v4.1.4 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 353 MB
ESP-IDF v4.1.3 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 353 MB

Signle ESP-IDF Branch Offline Installer — older versions

Version Content Size
ESP-IDF v4.4 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2, ESP32-S3, ESP32-C3 600 MB
ESP-IDF v4.2.2 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 376 MB
ESP-IDF v4.1.2 download/mirror ESP-IDF + Toolchains for ESP32, ESP32-S2 353 MB

Older versions

ESP-IDF Tools Installer Online Offline
2.12 — 2021-11-22 Download 3.2 MB Download 1.7 GB with ESP-IDF 4.3.1, 4.2.2, Eclipse + IDF Plugin v2.2.0
2.11 — 2021-09-23 Download 3.2 MB Download 1.7 GB with ESP-IDF 4.3.1, 4.2.2, Eclipse + IDF Plugin v2.2.0
2.10 — 2021-08-10 Download 3.2 MB Download 1.6 GB with ESP-IDF 4.3, 4.2.2, Eclipse + IDF Plugin v2.1.0
2.9 — 2021-06-15 Download 3.2 MB Download 1.6 GB with ESP-IDF 4.3, 4.2.1, Eclipse + IDF Plugin v2.1.0
2.8 — 2021-05-03 Download 3.2 MB Download 1.3 GB with ESP-IDF 4.2.1, 4.1.1, Eclipse + IDF Plugin v2.1.0
2.7 — 2021-04-08 Download 3.1 MB N/A
2.6 — 2021-03-09 Download 2.1 MB Download 1.2 GB with ESP-IDF 4.2, 4.1.1, Eclipse + IDF Plugin v2.0.0
2.5 — 2021-02-09 Download 19 MB Download 793 MB with ESP-IDF 4.2, 4.1.1

Command-line parameters

Windows Installer esp-idf-tools-setup provides the following command-line parameters:

  • /CHECKPATH=[yes|no] — Check whether the installation path does not contain spaces or special characters or if it’s too long. Set to no to disable checks. Default: yes.
  • /CONFIG=[PATH] — Path to ini configuration file to override default configuration of the installer. Default: config.ini.
  • /GITCLEAN=[yes|no] — Perform git clean and remove untracked directories in Offline mode installation. Default: yes.
  • /GITDEPTH=[number] — Clone repository in shallow mode E.g. 1. Default: empty.
  • /GITRECURSIVE=[yes|no] — Clone recursively all git repository submodules. Default: yes
  • /GITREPO=[URL|PATH] — URL of repository to clone ESP-IDF. Default: https://github.com/espressif/esp-idf.git
  • /GITRESET=[yes|no] — Enable/Disable git reset of repository during installation. Default: yes.
  • /GITSUBMODULEURL=[URL] — Update URL in submodules after cloning to custom URL. Default: ».
  • /GITUSEMIRROR=[yes|no] — Use Git mirror for cloning. Clone non-recursive and update URL of submodules. Default: no.
  • /HELP — Display command line options provided by Inno Setup installer.
  • /IDFDIR=[PATH] — Path to directory where it will be installed. Default: {userdesktop}\esp-idf}
  • /IDFUSEEXISTING=[yes|no] — Indicates whether installer should be initialized in update mode of existing IDF. Default: no.
  • /IDFVERSION=[v4.3|v4.1|master] — Use specific IDF version. E.g. v4.1, v4.2, master. Default: empty, pick the first version in the list.
  • /IDFVERSIONSURL=[URL] — Use URL to download list of IDF versions. Default: https://dl.espressif.com/dl/esp-idf/idf_versions.txt
  • /LOG=[PATH] — Store installation log file in specific directory. Default: empty.
  • /OFFLINE=[yes|no] — Execute installation of Python packages by PIP in offline mode. The same result can be achieved by setting the environment variable PIP_NO_INDEX. Default: no.
  • /USEEMBEDDEDGIT=[yes|no] — Use Embedded Git for the installation. Set to no to enable Git selection screen. Default: yes.
  • /USEEMBEDDEDPYTHON=[yes|no] — Use Embedded Python version for the installation. Set to no to allow Python selection screen in the installer. Default: yes.
  • /PYTHONNOUSERSITE=[yes|no] — Set PYTHONNOUSERSITE variable before launching any Python command to avoid loading Python packages from AppData\Roaming. Default: yes.
  • /PYTHONWHEELSURL=[URL] — Specify URLs to PyPi repositories for resolving binary Python Wheel dependencies. The same result can be achieved by setting the environment variable PIP_EXTRA_INDEX_URL. Default: https://dl.espressif.com/pypi
  • /SKIPSYSTEMCHECK=[yes|no] — Skip System Check page. Default: no.
  • /VERYSILENT /SUPPRESSMSGBOXES /SP- /NOCANCEL — Perform silent installation.

Unattended installation

The unattended installation of IDF can be achieved by following command-line parameters:

esp-idf-tools-setup-x.x.exe /VERYSILENT /SUPPRESSMSGBOXES /SP- /NOCANCEL

The installer detaches its process from the command-line. Waiting for installation to finish could be achieved by following PowerShell script:

esp-idf-tools-setup-x.x.exe /VERYSILENT /SUPPRESSMSGBOXES /SP- /NOCANCEL
$InstallerProcess = Get-Process esp-idf-tools-setup
Wait-Process -Id $InstallerProcess.id

Custom Python and custom location of Python wheels

The IDF installer is using by default embedded Python with reference to Python Wheel mirror.

Following parameters allows to select custom Python and custom location of Python wheels:

esp-idf-tools-setup-x.x.exe /USEEMBEDDEDPYTHON=no /PYTHONWHEELSURL=https://pypi.org/simple/

Manual installation of drivers

The installer takes care of driver installation.

The installation is pefromed by idf-env.exe driver install —espressif —ftdi —silabs —wch.

The tool is downloading and installing following drivers:

  • Espressif JTAG: https://dl.espressif.com/dl/idf-driver/idf-driver-esp32-usb-jtag-2021-07-15.zip
  • FTDI: https://www.ftdichip.com/Driver/CDM/CDM%20v2.12.28%20WHQL%20Certified.zip
  • Silabs: https://www.silabs.com/documents/public/software/CP210x_Universal_Windows_Driver.zip
  • WCH: https://www.wch.cn/downloads/CH341SER_ZIP.html

The recommended tool for adding libusb support to driver (e.g. debugging of Wroower kit):

  • UsbDriverTool

Developer documentation

This directory contains source files required to build the tools installer for Windows.

The installer is built using Inno Setup.

The main source file of the installer is src/InnoSetup/IdfToolsSetup.iss. PascalScript code is split into multiple *.iss files in directory src/InnoSetup.

Some functionality of the installer depends on additional programs:

  • Inno Download Plugin — used to download additional files during the installation.

  • 7-zip — used to extract downloaded IDF archives.

  • cmdlinerunner — a helper DLL used to run external command-line programs from the installer, capture live console output, and get the exit code.

Installation of dependencies via Chocolatey

Run with Administrator privileges:

choco install inno-download-plugin

Building the installer

Building Online Installer on Windows

The minimalistic version of the installer.

.\Build-Installer.ps1 -InstallerType online

Output file: build\esp-idf-tools-setup-online-unsigned.exe

Building Offline Installer on Windows

The version which bundles all packages into one installer file which does not requires internet connection to complete the installation.

.\Build-Installer.ps1 -InstallerType offline

Output file: build\esp-idf-tools-setup-offline-unsigned.exe

Building the installer by GitHub Actions

Build script is stored in .github\workflows

Building the installer in Docker with Linux image

The project contains multi-stage Dockerfile which allows build of the installer even on macOS or Linux. The build is using Wine.

Build the image:

docker build . -t wine-innosetup

Copy installer from the container

docker run --name builder --rm wine-innosetup && docker cp builder:/opt/idf-installer/build/esp-idf-tools-setup-online-unsigned.exe . && docker stop builder

Another option is to execute the build manually:

docker run -it wine-innosetup
.\Build-Installer.ps1 -InstallerType online

Testing the installer in Docker with Linux image

It’s possible to build the installer using Docker with Linux image, but it’s not possible to make full test of the installer. Wine is not working correctly with Windows version of Git. The recommended approach for testing in containers is to use Docker with Windows image.

Windows development env with WSL2 and Windows Docker Containers

The best approach to quickly develop and test all aspects of the build process is to use Windows with WSL2.

Requirements:

  • WSL2 and Ubuntu distribution via Microsoft Store
  • Install Windows Terminal — https://github.com/microsoft/terminal
  • Install Docker and switch container runner to Windows
  • Install Visual Studio Code — install plugin for Inno Setup and Docker
  • Install Inno Setup — choco install innnosetup

The first build of the installer

This step is bootstrapping the whole process. Open Windows Terminal, click + sign and select Ubuntu.

.\Build-Installer -InstallerType online

The setup will download the necessary dependencies and it will build the installer.

Build of offline version of the installer

The offline version is built by setting /DOFFLINE=yes to ISCC on the command-line. To speed up build, it’s possible to redirect stdout of ISCC to the file.

.\Build-Installer.ps1 -InstallerType offline -OfflineBranch v4.4 >out.txt

To speed up development build it’s possible to disable compression which is set by default to lzma.

.\Build-Installer.ps1 -InstallerType offline -Compression none -SignInstaller $false -OfflineBranch v4.4 >out.txt

Build of Espressif-IDE installer which contains also latest stable ESP-IDF:

.\Build-Installer.ps1 -InstallerType espressif-ide -Compression none -SignInstaller $false -OfflineBranch v4.4

Development work in idf_tool_setup.iss

Open Inno Setup and open file src\InnoSetup\IdfToolsSetup.iss. This is the main file of the installer

Press CTRL+F9 to rebuild the whole installer. Inno Setup detects changes only in the main file. If you change anything in include files, you need to explicitly press CTRL+F9 to build and Run.

Press F9 to run the installer.

Additional parameters to speed up development could be passed via Run — Parameters

Manually, step by step

  • Build cmdlinerunner DLL.

    • On Linux/Mac, install mingw-w64 toolchain (i686-w64-mingw32-gcc). Then build the DLL using CMake:
      mkdir -p cmdlinerunner/build
      cd cmdlinerunner/build
      cmake -DCMAKE_TOOLCHAIN_FILE=../toolchain-i686-w64-mingw32.cmake -DCMAKE_BUILD_TYPE=Release ..
      cmake --build .
      

      This will produce cmdlinerunner.dll in the build directory.

    • On Windows, it is possible to build using Visual Studio, with CMake support installed. By default, VS produces build artifacts in some hard to find directory. You can adjust this in CmakeSettings.json file generated by VS.
  • Download 7zip.exe («standalone console version») and put it into unzip directory (to get unzip/7za.exe).

  • Download idf_versions.txt and place it into the current directory. The installer will use it as a fallback, if it can not download idf_versions.txt at run time.

  • Create the dist directory and populate it with the tools which should be bundled with the installer. At the moment the easiest way to obtain it is to use install.sh/install.bat in IDF, and then copy the contents of $HOME/.espressif/dist directory. If the directory is empty, the installer should still work, and the tools will be downloaded during the installation.

  • Build the installer using Inno Setup Compiler: ISCC.exe idf_tools_setup.iss.

Testing of the installer

Development and testing of the installer can be simplified by using command line parameters which can be passed to the installer.

Select Run — Parameters in Inno Setup and add parameters.

Example of parameters:

/SKIPSYSTEMCHECK=yes /IDFVERSIONSURL=https://dl.espressif.com/dl/esp-idf/idf_versions.txt /GITRESET=no /GITREPO=C:/projects/esp-idf /GITRECURSIVE=no

These combinations of parameters will result:

  • SKIPSYSTEMCHECK=yes — The screen with System Check will be skipped.
  • IDFVERSIONURL — idf_versions.txt will be downloaded from localhost:8000
    • it’s possible to add branch name into idf_versions.txt, e.g. feature/win_inst
  • GITRESET=no — Git repository won’t be reset after clone, it can save time and add custom changes in case of the zip archive with repository
  • GITREPO — The version will be cloned from the specific location, e.g. from a local directory
  • GITRECURSIVE=no — The clone of the repo won’t contain modules, it speeds up the cloning process. Use when modules are not necessary.

Documentation of parameters is available in api-guides/tools/idf-windows-installer.rst

Testing installation directly on Windows

Recommendation: For higher level of isolation you can use Docker with Windows containers described in the next chapter.

Test can be executed by following commands which will peform the installation and execute tests by accessing desktop link to PowerShell and CMD:

cd src\PowerShell
.\Install-Idf.ps1 -Installer ..\..\build\esp-tools-setup-online-unsigned.exe -IdfPath C:\idf-test -IdfVersion v4.2

Testing installation in Docker with Windows containers

The testing script is stored in docker-compose.yml. The test performs full silent installation and executes the build of get-started example.

Commands for testing of online and offline installer with support for cache of dist and releases:

cd src\Docker
$env:IDF_VERSION="v4.1"; docker-compose.exe run idf-setup-online-test
$env:IDF_VERSION="release/v4.2"; docker-compose.exe run idf-setup-online-test
$env:IDF_VERSION="master"; docker-compose.exe run idf-setup-online-test

Command for testing offline type of installer which contains everything but kitchen sink.:

$env:IDF_VERSION="v4.2"; docker-compose.exe run idf-setup-offline-test
$env:IDF_VERSION="release/v4.2"; docker-compose.exe run idf-setup-offline-test

The installation log is not displayed immediately on the screen. It’s stored in the file and it’s displayed when the installation finishes.

Recommendation: Use Visual Studio Code with Docker plugin to work with container.
The log file is then accessible under Docker — Containers — Container — Files — Temp — install.txt — right click — Open.

Testing multiple installations at once

Docker compose contains definition of multiple scenarios. The test can be launched by command:

$env:IDF_VERSION="v4.2"; docker-compose up --force-recreate

Note: --force-recreate is necessary otherwise the container will be just resumed from previous state.

Testing the installation in Hyper-V

Docker does not support the test of installation with GUI and enabled Windows Defender. These tests can be executed in Hyper-V available on Windows. Launch Hyper-V Manager, create VM, and connect to it.

Use the following command to copy the installer to Hyper-V machine with the name «win10»:

 Copy-VMFile "win10"  -SourcePath C:\projects\esp-idf\tools\windows\tool_setup\Output\esp-idf-tools-setup-unsigned.exe -DestinationPath "C:\Users\Tester\Desktop\esp-idf-tools-setup-unsigned.exe" -CreateFullPath -FileSource Host -Force

Signing the installer

  • Obtain the signing key (e.g key.pem) and the certificate chain (e.g. certchain.pem). Set the environment variables to point to these files:

    • export KEYFILE=key.pem
    • export CERTCHAIN=certchain.pem
  • Run sign_installer.sh script. This will ask for the key.pem password and produce the signed installer in the Output directory. If you plan to run the script multiple times, you may also set KEYPASSWORD environment variable to the key.pem password, to avoid the prompt.

Contributing L10N

Localization messages for the installer are stored in src/InnoSetup/Languages.

Adding new localization:

  • create issue on GitHub
  • register new language in src/InnoSetup/IdfToolsSetup.iss

Files can be converted to XLIFF using Translate Toolkit — ini2po and po2xliff.

File format is INI in UTF-8 with BOM header. Without BOM header the localization is not correctly displayed. Use VS Code to save the file with BOM header.

Setting up translation environment

python -m pipenv shell
pip install translate-toolkit iniparse

Transforming file for translation

cp file.isl file.ini
ini2po file.ini file.po
po2xliff file.po file.xliff

Processing handback

xliff2po file.xliff file.po
po2ini -t file.ini file.po file.ini
cp file.ini file.isl
  • add BOM header using Save function in Visual Studio Code

In this tutorial, we will show you how to install ESP-IDF in Windows and then configure it with VS Code. The official IoT Development Framework for the ESP32, ESP32-S, and ESP32-C line of SoCs is known as ESP-IDF. It offers an independent SDK for creating any type of generic application on various platforms using C and C++ programming languages. VS Code is a source code editor designed for Windows, macOS, and Linux which is used in building and debugging applications.

We will be required to download and install the latest version of Python in our system in order to work with VS Code. Below we have provided you with a guide to successfully install Python 3.7 or the latest version in Windows operating system.

ESP32 Development board: You can buy from here.

Installing Python in Windows

Click this link. This will download the latest version of Python3 according to the operating system on your computer.

Download Python3 on windows

Now the .exe file will get downloaded in your system. Opening the file prompts the user to Run the following file.

download python

After we click the Run button the following window will appear. Tick “Add Python 3.9 to Path” and then click Install Now.

install python

Your installation will be completed in a few moments.

We will first start by setting up ESP-IDF in Windows.

ESP-IDF Windows Installer Download

Open the following link: (https://docs.espressif.com/projects/esp-idf/en/latest/esp32/get-started/index.html). This opens the official ESP32 getting started webpage by Espressif. Scroll down until you reach the Manual Installation section. Here click ‘Windows Installer.’

ESP-IDF Windows Installer 1

This will open the Standard Setup of Toolchain for Windows webpage. Scroll down until you reach ESP-IDF Tools Installer section. Here, click Windows Installer Download.

ESP-IDF Windows Installer 2

This opens the ESP-IDF Windows Installer Download webpage. You can choose the version of the installer that you want to download. There are options for both online and offline installers.

We will download the Universal Online Installer 2.15 as highlighted below:

ESP-IDF Windows Installer 3

After you click the download button, an .exe file will start downloading.

ESP-IDF Tools Setup Installation

After the download is completed click on it and the setup for ESP-IDF-Tools opens up.

It will first ask you to select the language to use during installation. We choose ‘English.’ Next the license agreement opens. Accept the agreement and click Next to proceed further.

ESP-IDF Windows Installer 4

Next, there is a pre-installation system check. If there is any issue with the system check, you can click the ‘Apply Fixes’ button to resolve it. After the check is compete, click Next.

ESP-IDF Windows Installer 5

Here we will select ‘Download ESP-IDF’ as we want to download a new one.

ESP-IDF Windows Installer 6

Next we select the version of ESP-IDF that we want to install. There are multiple options to choose from as you can see below. Normally, we install the latest version available but in this case we are selecting v4.3.3 which is the current stable release at the moment.

Moreover, choose a directory where ESP-IDF will be installed. Click the Browse button to select your preferred location. We are using the default location.

Click Next to proceed further.

ESP-IDF Windows Installer 7

Next, select the location for the ESP-IDF tools installation. We are using the default location.

ESP-IDF Windows Installer 8

Select the components you want to install and then click Next.

ESP-IDF Windows Installer 9

Now the installation begins. It will take some time for the installation to complete. When the ESP-IDF is completely installed, the following appears. Click the Finish button to exit the setup.

ESP-IDF Windows Installer 10

Now we have three new icons in our desktop that open up the ESP-IDF command prompt, ESP-IDF PowerShell and Espressif-IDE respectively.

ESP-IDF Windows Installer programs

Testing the ESP-IDF Installation

Now let us test our ESP-IDF installation to make sure everything is working properly. Open the ESP-IDF PowerShell and wait for a while until all the variables are properly loaded.

We are in the directory C:\Espressif\frameworks\esp-idf-v4.3.3

Testing ESP-IDF installation with ESP-IDF PowerShell 1

Let us open the explorer of this directory. This has the examples folder that contains various basic examples with ESP-IDF. Let us build one of the examples to test our ESP-IDF installation.

You can see the different examples that are available:

Testing ESP-IDF installation with ESP-IDF PowerShell 2

We will open the get-started folder that contains the three getting started examples.

Testing ESP-IDF installation with ESP-IDF PowerShell 3

Opening the hello_world project directory, you can view different files highlighted in the green box.

Testing ESP-IDF installation with ESP-IDF PowerShell 4

Build Project

Let us build this project. Type idf.py build and press enter. The project starts building.

Testing ESP-IDF installation with ESP-IDF PowerShell 5

It will take some time for the project to build completely for the first time. As our project built successfully as seen by the output in the image below, hence everything is working fine.

Testing ESP-IDF installation with ESP-IDF PowerShell 6

These command prompts (ESP-IDF Command & ESP-IDF PowerShell) are generally very handy to use as they have all the environments variables set up for ESP-IDF.

Installing VS Code

To download and install the visual code editor IDE, click here. The following window appears. We have highlighted the red box which shows “Download for Windows Stable Build.” Click this button to start the download. The drop down menu also allows the user to select the system bit type. Choose according to your system.

However, if you are using another operating system e.g. Linux then click the ‘Download’ button at the top right.

VS Code installation 1

Now your .exe file will start downloading. After the download is complete, click it. The following License Agreement window opens up. Here you will accept the agreement and then press ‘Next.’

VS Code installation 2

You will be asked to specify the location for the installation of the VS Code setup.

VS Code installation 3

Additionally, you can also select additional tasks according to your needs. After that click Next.

VS Code installation 4

Now the setup is ready to install. The red block highlights the options we ticked on our way. Finally, click the “Install” button.

VS Code installation 5

After we click the Finish button, the setup installation completes and launches the VS Code.

VS Code installation 6

The VS Code getting started page will open up.

VS Code installation 7

We have successfully installed Visual Studio Code in our system. Now let us move ahead and install the ESP-IDF extension in our IDE.

Integrating ESP-IDF with VS Code

Go to extensions by pressing Ctrl + Shift + X or click its icon. Type ‘espressif idf’ in the search bar and install it. It will take a few minutes for the installation to complete. Make sure the plugin is enabled.

ESP-IDF in VS Code 1

No go to View > Command Palette (Ctrl + Shift + P). A menu will open. Type ‘ESP-IDF: Configure ESP-IDF extension.’ This will open the following startup page:

We will select the EXPRESS version. It is a simpler and faster option than the ADVANCED.

ESP-IDF in VS Code 2

Now specify the following parameters. We are choosing Github as the download server. For the ESP-IDF version, we select the option of ‘Find ESP-IDF in your system’ as we already have it downloaded in our system. Select the same ESP-IDF and ESP-IDF Tools directory where we previously installed them. Click the Install button to start the process.

ESP-IDF in VS Code 3

It will take some time for the process to complete which happens in three steps, where first the IDF prerequisites are installed, then ESP-IDF is installed and lastly the python virtual environment is set up.

ESP-IDF in VS Code 4
ESP-IDF in VS Code 5

After all three processes are ticked, we have successfully configured the ESP-IDF extension. You can close this window now.

ESP-IDF in VS Code 6

Testing ESP-IDF Extension in VS Code

No go to View > Command Palette (Ctrl + Shift + P). A menu will open. Type ‘ESP-IDF: New Project.’ This will open a new window to add the project details.

Specify the project name and directory. We have named our project ‘esp_test.’ For the ESP-IDF board we have chosen the custom board option. For ESP-IDF target, we have chosen ESP32 module. Click ‘Choose Template’ button to proceed forward.

Note: When naming your project, do not use spaces. It will not work.

ESP-IDF in VS Code New Project 1

In the Extension, select ESP-IDF option:

ESP-IDF in VS Code New Project 2

We will click the ‘sample_project’ under the get-started tab. Now click ‘Create project using template sample_project.’

ESP-IDF in VS Code New Project 3

You will get a notification that the project has been created. To open the project in a new window, click ‘Yes.’

ESP-IDF in VS Code New Project 4

This opens our ESP_TEST project that we created inside the EXPLORER tab. As you can see there are several folders inside our project folder (ESP_TEST). This is the same for every project which you will create through ESP-IDF Explorer. The main folder contains the source code meaning the main.c file will be found here. Inside the main.c we will write our program code.

Go to main > main.c and open it. We will define the functions and the program code here. Here we have written a simple program that prints Hello World as an output:

ESP-IDF in VS Code New Project 5

By default, IntelliSense is present, but the environment may not give any indication if there is a problem. To fix that, go to .vscode > settings.json and set the C_Cpp.intelliSenseEngine to Default. Previously it was set to ‘Tag Parser.’ Now if there is an error in the main.c file, a red wavy line appears beneath that code.

ESP-IDF in VS Code New Project 6

Tools

In the bottom bar of your window you can view the following icons:

ESP-IDF in VS Code New Project 7
  1. ESP-IDF Select Port to use: This allows the user to select the available serial port where their device is connected.
  2. ESP-IDF Select Espressif device target: This allows the user to set the device target.
  3. ESP-IDF Current Project: This selects the current folder.
  4. ESP-IDF SDK Configuration Editor
  5. ESP-IDF Full Clean: This cleans the project whereby the user can build the project from the start.
  6. ESP-IDF Build: This will compile the program code and will help in checking for potential errors.
  7. ESP-IDF Select flash method: This allows the user to select the flash method from JTAG, UART, and DFU.
  8. ESP-IDF flash device: This will download the project in the chip.
  9. ESP-IDF Monitor device: This gives the serial output of the chip.
  10. ESP-IDF Build, Flash, and Monitor
  11. ESP-IDF Open ESP-IDF Terminal: Clicking on this icon opens the terminal. If the terminal was already opened then it refreshes the terminal.
  12. ESP-IDF Execute custom task

Compile Project

Now you can either click the 6th icon (Build) or the 10th icon (Build, Flash and Monitor) to test the above script. We will first open the terminal by clicking the open ESP-IDF terminal icon. This opens the terminal which is very similar to the PowerShell. It has all the variables of the environment already set up.

ESP-IDF in VS Code New Project 8

If you type idf.py in the terminal, the output gives you the various processes that can be performed with this command for example, clean, flash, build etc.

In order to build our project, we will type idf.py build in the terminal. Our project will start building. It will take some time for it to be built completely.

ESP-IDF in VS Code New Project 9

Our project built successfully as seen by the output in the image below, hence ESP-IDF is working fine with VS Code.

ESP-IDF in VS Code New Project 10

To flash the chip and monitor the output, type the following command in the terminal.

idf.py flash monitor

Alternatively, you can just click the flame icon (Build, Flash, and Monitor) that will automatically build, flash and monitor the script.

Here is the result of a successful flashing of the esp32 chip:

ESP32 hello world project flash, build and monitor 1

This is the output we get in the serial monitor for the Hello World script.

ESP32 hello world project flash, build and monitor 2

Where to go next?

  • Getting Started with ESP32 using ESP-IDF
  • ESP32 GPIO with ESP-IDF with LED Blinking example
  • ESP32 Push Button with ESP-IDF (Digital Input)
  • ESP32 ADC with ESP-IDF Measure Analog Inputs
  • ESP32 PWM ESP-IDF LED Brightness Control Example

Bilal

We are a team of experienced Embedded Software Developers with skills in developing Embedded Linux, RTOS, and IoT products from scratch to deployment with a demonstrated history of working in the embedded software industry. Contact us for your projects: admin@esp32tutorials.com

Введение

Почему, ESP32?

Esp32 использует два процессора Xtensa с симметричной адресацией. Это разработка Гарварда, сделанная аж в 1997 году. Заявленная тактовая частота 240/160 МГц.

Частота таймеров 80 МГц

Очень низкое энергопотребление в режиме «глубокого сна» — аж  5-2,5 мкА.

Аналогичные по архитектуре модули STM32, скажем стоят значительно дороже. Да, 400 МГц, да отличная документация. Но, скажем процессор STM32F407 стоит около 1000 рублей на Алиэкспрессе.

И почти нет микропроцессоров, у которых были бы «на борту» Bluetooth и Wi-Fi стоимостью 150-200 рублей.

Удобные для любительской распайки модули с микропроцессором «на борту»

Почему esp-idf VSCode и Eclipse?

https://github.com/espressif/esp-idf

ESP-IDF позиционируется, как Espressif IoT Development Framework — Фреймворк разработки IoT (Интернет Вещей). Плата с процессором Esp32 вполне может стать объектом Интернета Вещей.

А так же, с этим фреймворком легко разрабатывать Bluetooth Low Energy устройства, которыми, скажем, можно легко управлять с мобильного телефона. Подключаться к WiFi и проводной сети Ethernet.

Да, цена входа для непрофессионального разработчика на Arduino IDE, значительно ниже. Для сегмента DIY (Самодельничество, или «сделай сам» (англ. DIY — Do It Yourself), — вид деятельности, при котором люди самостоятельно производят какие-либо изделия для собственного использования), более чем достаточно.

Но всегда же хочется большего, не правда ли? Примитивы FreeRTOS кажутся мне более понятными, логичными и простыми в использовании, чем void setup() и void loop(). Опять же, возможность обращения к LL функциям (Low Level Layer Function)

Так и не понял, можно ли «поднять» BLE GATT Server на Arduino IDE, но во фреймворке esp-idf он пишется почти элементарно.

Часть I. Консоль

Статей о настройке IDE Visual Studio Code и Eclipse под Linux и Windows написано уже много. В принципе, с точностью до небольших деталей, они повторяют друг-друга. Эта заметка не исключение.

Отличие лишь в том, что и Eclipse и Visual Studio Code будут использовать единожды установленные Espressif Framework и набор инструментов — toolchain. Раздражает, что каждая установка плагинов https://github.com/espressif/vscode-esp-idf-extension и https://github.com/espressif/idf-eclipse-plugin «тащит» за собой новую установку пакета ESP-IDF и TOOLCHAIN. Каждая установка в сумме, 3.3 Гб, между прочим.

Linux

Для примера, использую Ubuntu 21.04.

Во-первых, классическое начало для deb систем:

sudo apt update
sudo apt upgrade
sudo apt install python3-pip git cmake ninja-build

Ну или установить cmake и ninja, используя snap

Для полноценной работы esp-idf должны быть установлены git, python3 и pip3. Причём, надо, чтобы python вызывался, как python, а не python3 или python3.9 и т.д. Скажем, в Ubuntu 18.04, 20.10, 21.04 такой команды, как python изначально нет. Есть python3. Так, что надо либо сделать мягкую ссылку:

mkdir ~/.local/bin
ln -sf /usr/bin/python3 ~/.local/bin/python
source ~/.profile

Либо создать Python Virtual Environment (https://docs.python.org/3/tutorial/venv.html)

python3 -m venv ~/python/python3
code ~/python/python3/bin/activate

Последний способ чуть сложнее, но даже в создании мягкой ссылки есть забавный подвох: если Вы не создали каталог ~/.local/bin, то .profile его не «подхватит», потому, что в скрипте профиле есть такой код:

if [ -d "$HOME/.local/bin" ] ; then
	PATH="$PATH:$HOME/.local/bin"
fi

Иными словами, если этот каталог не создан, его в пути и не будет. После создания каталога, нужно вызвать source ~/.profile

Проверим себя. Вызовем из терминала:

$python
Python 3.8.10 (default, Jun  2 2021, 10:49:15)
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> quit()

Всё работает. Скачиваем esp-idf. Предпочитаю установить фреймворк в какой-нибудь подкаталог домашеного каталога, вроде ~/espressif. Фреймворков Esp32, аж целых три — esp-adf, esp-idf, esp-mdf, так что, чтобы не засорять «корневое» пространство пользовательского каталога, сложим их в одну кучу. Имена каталогов верхних уровней не должны содержать пробелов.

mkdir ~/espressif
cd ~/espressif
git clone https://github.com/espressif/esp-idf.git --recursive

Имеет смысл сразу добавить в какой-нибудь из пользовательских .*rc-файлов загрузку переменных окружения esp-idf. Переменные ADF_PATH и MDF_PATH предусмотрены на тот случай, если Вы захотите работать на Esp32 со звуком или создавать самоорганизующиеся сети из нескольких плат Esp32.

Скрипт добавляет алиас idfexp. Так удобнее превращать текущую консоль в среду IDF-разработки, чтобы не набирать, скажем каждый раз ~/espressif/esp-idf/export.sh

# Скрипт для экспорта окружения esp-idf, esp-adf, esp-mdf
#
ESP_PATH="$HOME/espressif"
IDF_TOOLS_PATH="$HOME/.espressif"

if [ -d "$ESP_PATH/esp-idf" ] ; then
	IDF_PATH="$ESP_PATH/esp-idf"
	export IDF_PATH
	if [ -f "$IDF_PATH/export.sh" ] ; then
		alias idfexp="\. $IDF_PATH/export.sh"
	fi
fi

if [ -f "$ESP_PATH/esp-adf" ] ; then
	ADF_PATH="$ESP_PATH/esp-adf"
	export ADF_PATH
fi

if [ -f "$ESP_PATH/esp-mdf" ] ; then
	MDF_PATH="$ESP_PATH/esp-mdf"
	export MDF_PATH
fi

if [ -d "$IDF_TOOLS_PATH" ] ; then
	export IDF_TOOLS_PATH
fi

Можно добавить автоматическую загрузку скрипта через любой актуальный ~/.*rc-файл. Например, добавить в ~/.bashrc (\. необходим, поскольку, разрешения .*rc-файлов 0644):

if [ -f "$HOME/.idfrc" ]; then
       	\. "$HOME/.idfrc" # This load Espressif environment 
fi

Далее, осталось установить набор инструментария для сборки проектов. По умолчанию toolchain будет установлен в ~/.espressif

cd ~/espressif/esp-idf
./install.sh

Если всё прошло удачно, то увидим что-то такое (журнал установки укорочен):

Скрытый текст

$ ./install.sh

WARNING: You are using pip version 21.2.3; however, version 21.2.4 is available. You should consider upgrading via the ‘/home/grandfatherpikhto/.espressif/python_env/idf4.4_py3.8_env/bin/python -m pip install —upgrade pip’ command. All done! You can now run:

. ./export.sh

Обратите внимание, что предлагается обновить venv:

WARNING: You are using pip version 21.2.3; however, version 21.2.4 is available.
You should consider upgrading via the '/home/grandfatherpikhto/.espressif/python_env/idf4.4_py3.8_env/bin/python -m pip install --upgrade pip' command.

Обновляем:

~/.espressif/python_env/idf4.4_py3.8_env/bin/python -m pip install --upgrade pip pip

Размер esp-idf приблизительно 2.2 Гб, toolchain — 1.2 Гб. Ну, так на минуточку:

$du -hs ~/espressif/esp-idf
1.1G    esp-idf
$du -hs ~/.espressif
1.9G    .espressif

После установки toolchain можно вызвать source ~/.idfrc и подгрузить переменные окружения ESP-IDF командой idfexp или

. ~/espressif/esp-idf/export.sh

Если всё пошло правильно, должны увидеть что-то такое:

Скрытый текст

$ idfexp Detecting the Python interpreter Checking «python» … Python 3.8.10 «python» has been detected Adding ESP-IDF tools to PATH… Using Python interpreter in /home/grandfatherpikhto/.espressif/python_env/idf4.4_py3.8_env/bin/python Checking if Python packages are up to date… Python requirements from /home/grandfatherpikhto/espressif/esp-idf/requirements.txt are satisfied. Added the following directories to PATH: /home/grandfatherpikhto/espressif/esp-idf/components/esptool_py/esptool /home/grandfatherpikhto/espressif/esp-idf/components/espcoredump /home/grandfatherpikhto/espressif/esp-idf/components/partition_table /home/grandfatherpikhto/espressif/esp-idf/components/app_update /home/grandfatherpikhto/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin /home/grandfatherpikhto/.espressif/tools/xtensa-esp32s2-elf/esp-2021r1-8.4.0/xtensa-esp32s2-elf/bin /home/grandfatherpikhto/.espressif/tools/xtensa-esp32s3-elf/esp-2021r1-8.4.0/xtensa-esp32s3-elf/bin /home/grandfatherpikhto/.espressif/tools/riscv32-esp-elf/esp-2021r1-8.4.0/riscv32-esp-elf/bin /home/grandfatherpikhto/.espressif/tools/esp32ulp-elf/2.28.51-esp-20191205/esp32ulp-elf-binutils/bin /home/grandfatherpikhto/.espressif/tools/esp32s2ulp-elf/2.28.51-esp-20191205/esp32s2ulp-elf-binutils/bin /home/grandfatherpikhto/.espressif/tools/openocd-esp32/v0.10.0-esp32-20210721/openocd-esp32/bin /home/grandfatherpikhto/.espressif/python_env/idf4.4_py3.8_env/bin /home/grandfatherpikhto/espressif/esp-idf/tools Done! You can now compile ESP-IDF projects. Go to the project directory and run:

idf.py build

В принципе, можно приступить к сборке и прошивке какого-нибудь проекта из каталога ~/espressif/esp-idf/examples, но сначала надо настроить udev — пакет управления устройствами для новых версий ядра Linux.

Ниже привожу «сборную солянку» файла 40-dfuse.rules из правил, которую удалось накопать на форуме Esp32 (https://www.esp32.com/). Думаю, в особых объяснениях этот файл не нуждается. Просто, коллекция idVendor и idProduct различных макетных плат Esp32. Обратите внимание, что расширение файла должно быть именно «rules». Иначе, udev не прочитает правила.

SUBSYSTEMS=="usb", ATTRS{idVendor}=="303a", ATTRS{idProduct}=="00??", GROUP="plugdev", MODE="0666"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6015", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="ea60", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
SUBSYSTEMS=="usb", ATTRS{idVendor}=="067b", ATTRS{idProduct}=="2303", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"

Обновляем правила:

sudo su
cp 40-dfuse.rules /etc/udev/rules.d/
systemctl restart udev.service
udevadm control --reload-rules

Теперь, можно собрать и запустить какой-нибудь простой проект Esp32. Не забудьте подключить макетную плату Esp32 к компьютеру. Если она уже была подключена, отключите и подключите снова. Иначе, правила udev не будут прочитаны для этого устройства.

У вашего покорного слуги наличествует макетная плата ESP32-WROOM. Попробуем собрать и прошить ~/espressif/esp-idf/examples/get-started/hello_world. Обратите внимание, что, в принципе надо указывать порт. Например, idf.py -p /dev/ttyUSB0 flash. Но, на самом деле, это не обязательно. idf.py попробует найти порт, к которому подключено устройство Esp32 и прошьёт первое обнаруженное.

Если всё получилось хорошо, увидим что-то вроде:

Скрытый текст

~/Programs/esp32/hello_world $ idf.py build

Executing action: all (aliases: build)

Running cmake in directory /home/denis/Programs/esp32/hello_world/build

Executing «cmake -G Ninja -DPYTHON_DEPS_CHECKED=1 -DESP_PLATFORM=1 -DCCACHE_ENABLE=0 /home/denis/Programs/esp32/hello_world»…

— IDF_TARGET not set, using default target: esp32

— Found Git: /usr/bin/git (found version «2.32.0»)

— The C compiler identification is GNU 8.4.0

— The CXX compiler identification is GNU 8.4.0

— The ASM compiler identification is GNU

— Found assembler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-gcc

— Detecting C compiler ABI info

— Detecting C compiler ABI info — done

— Check for working C compiler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-gcc — skipped

— Detecting C compile features

— Detecting C compile features — done

— Detecting CXX compiler ABI info

— Detecting CXX compiler ABI info — done

— Check for working CXX compiler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-g++ — skipped

— Detecting CXX compile features

— Detecting CXX compile features — done

— Project is not inside a git repository, or git repository has no commits; will not use ‘git describe’ to determine PROJECT_VER.

— Building ESP-IDF components for target esp32

— Project sdkconfig file /home/denis/Programs/esp32/hello_world/sdkconfig

— Found PythonInterp: /home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python (found version «3.9.6»)

— Found Perl: /usr/bin/perl (found version «5.32.1»)

— App «hello-world» version: 1

— Adding linker script /home/denis/Programs/esp32/hello_world/build/esp-idf/esp_system/ld/memory.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_system/ld/esp32/sections.ld.in

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.api.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.libgcc.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.newlib-data.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.syscalls.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.newlib-funcs.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.newlib-time.ld

— Adding linker script /home/denis/espressif/esp-idf/components/soc/esp32/ld/esp32.peripherals.ld

— Components: app_trace app_update asio bootloader bootloader_support bt cbor cmock coap console cxx driver efuse esp-tls esp32 esp_adc_cal esp_common esp_eth esp_event esp_gdbstub esp_hid esp_http_client esp_http_server esp_https_ota esp_https_server esp_hw_support esp_ipc esp_lcd esp_local_ctrl esp_netif esp_phy esp_pm esp_ringbuf esp_rom esp_serial_slave_link esp_system esp_timer esp_websocket_client esp_wifi espcoredump esptool_py expat fatfs freemodbus freertos hal heap idf_test ieee802154 jsmn json libsodium log lwip main mbedtls mdns mqtt newlib nghttp nvs_flash openssl openthread partition_table perfmon protobuf-c protocomm pthread sdmmc soc spi_flash spiffs tcp_transport tcpip_adapter tinyusb ulp unity usb vfs wear_levelling wifi_provisioning wpa_supplicant xtensa

— Component paths: /home/denis/espressif/esp-idf/components/app_trace /home/denis/espressif/esp-idf/components/app_update /home/denis/espressif/esp-idf/components/asio /home/denis/espressif/esp-idf/components/bootloader /home/denis/espressif/esp-idf/components/bootloader_support /home/denis/espressif/esp-idf/components/bt /home/denis/espressif/esp-idf/components/cbor /home/denis/espressif/esp-idf/components/cmock /home/denis/espressif/esp-idf/components/coap /home/denis/espressif/esp-idf/components/console /home/denis/espressif/esp-idf/components/cxx /home/denis/espressif/esp-idf/components/driver /home/denis/espressif/esp-idf/components/efuse /home/denis/espressif/esp-idf/components/esp-tls /home/denis/espressif/esp-idf/components/esp32 /home/denis/espressif/esp-idf/components/esp_adc_cal /home/denis/espressif/esp-idf/components/esp_common /home/denis/espressif/esp-idf/components/esp_eth /home/denis/espressif/esp-idf/components/esp_event /home/denis/espressif/esp-idf/components/esp_gdbstub /home/denis/espressif/esp-idf/components/esp_hid /home/denis/espressif/esp-idf/components/esp_http_client /home/denis/espressif/esp-idf/components/esp_http_server /home/denis/espressif/esp-idf/components/esp_https_ota /home/denis/espressif/esp-idf/components/esp_https_server /home/denis/espressif/esp-idf/components/esp_hw_support /home/denis/espressif/esp-idf/components/esp_ipc /home/denis/espressif/esp-idf/components/esp_lcd /home/denis/espressif/esp-idf/components/esp_local_ctrl /home/denis/espressif/esp-idf/components/esp_netif /home/denis/espressif/esp-idf/components/esp_phy /home/denis/espressif/esp-idf/components/esp_pm /home/denis/espressif/esp-idf/components/esp_ringbuf /home/denis/espressif/esp-idf/components/esp_rom /home/denis/espressif/esp-idf/components/esp_serial_slave_link /home/denis/espressif/esp-idf/components/esp_system /home/denis/espressif/esp-idf/components/esp_timer /home/denis/espressif/esp-idf/components/esp_websocket_client /home/denis/espressif/esp-idf/components/esp_wifi /home/denis/espressif/esp-idf/components/espcoredump /home/denis/espressif/esp-idf/components/esptool_py /home/denis/espressif/esp-idf/components/expat /home/denis/espressif/esp-idf/components/fatfs /home/denis/espressif/esp-idf/components/freemodbus /home/denis/espressif/esp-idf/components/freertos /home/denis/espressif/esp-idf/components/hal /home/denis/espressif/esp-idf/components/heap /home/denis/espressif/esp-idf/components/idf_test /home/denis/espressif/esp-idf/components/ieee802154 /home/denis/espressif/esp-idf/components/jsmn /home/denis/espressif/esp-idf/components/json /home/denis/espressif/esp-idf/components/libsodium /home/denis/espressif/esp-idf/components/log /home/denis/espressif/esp-idf/components/lwip /home/denis/Programs/esp32/hello_world/main /home/denis/espressif/esp-idf/components/mbedtls /home/denis/espressif/esp-idf/components/mdns /home/denis/espressif/esp-idf/components/mqtt /home/denis/espressif/esp-idf/components/newlib /home/denis/espressif/esp-idf/components/nghttp /home/denis/espressif/esp-idf/components/nvs_flash /home/denis/espressif/esp-idf/components/openssl /home/denis/espressif/esp-idf/components/openthread /home/denis/espressif/esp-idf/components/partition_table /home/denis/espressif/esp-idf/components/perfmon /home/denis/espressif/esp-idf/components/protobuf-c /home/denis/espressif/esp-idf/components/protocomm /home/denis/espressif/esp-idf/components/pthread /home/denis/espressif/esp-idf/components/sdmmc /home/denis/espressif/esp-idf/components/soc /home/denis/espressif/esp-idf/components/spi_flash /home/denis/espressif/esp-idf/components/spiffs /home/denis/espressif/esp-idf/components/tcp_transport /home/denis/espressif/esp-idf/components/tcpip_adapter /home/denis/espressif/esp-idf/components/tinyusb /home/denis/espressif/esp-idf/components/ulp /home/denis/espressif/esp-idf/components/unity /home/denis/espressif/esp-idf/components/usb /home/denis/espressif/esp-idf/components/vfs /home/denis/espressif/esp-idf/components/wear_levelling /home/denis/espressif/esp-idf/components/wifi_provisioning /home/denis/espressif/esp-idf/components/wpa_supplicant /home/denis/espressif/esp-idf/components/xtensa

— Configuring done

— Generating done

— Build files have been written to: /home/denis/Programs/esp32/hello_world/build

Running ninja in directory /home/denis/Programs/esp32/hello_world/build

Executing «ninja all»…

[8/994] Generating ../../partition_table/partition-table.bin

Partition table binary generated. Contents:


ESP-IDF Partition Table

Name, Type, SubType, Offset, Size, Flags

nvs,data,nvs,0x9000,24K,

phy_init,data,phy,0xf000,4K,

factory,app,factory,0x10000,1M,


[210/994] Performing configure step for ‘bootloader’

— Found Git: /usr/bin/git (found version «2.32.0»)

— The C compiler identification is GNU 8.4.0

— The CXX compiler identification is GNU 8.4.0

— The ASM compiler identification is GNU

— Found assembler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-gcc

— Detecting C compiler ABI info

— Detecting C compiler ABI info — done

— Check for working C compiler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-gcc — skipped

— Detecting C compile features

— Detecting C compile features — done

— Detecting CXX compiler ABI info

— Detecting CXX compiler ABI info — done

— Check for working CXX compiler: /home/denis/.espressif/tools/xtensa-esp32-elf/esp-2021r1-8.4.0/xtensa-esp32-elf/bin/xtensa-esp32-elf-g++ — skipped

— Detecting CXX compile features

— Detecting CXX compile features — done

— Building ESP-IDF components for target esp32

— Project sdkconfig file /home/denis/Programs/esp32/hello_world/sdkconfig

— Adding linker script /home/denis/espressif/esp-idf/components/soc/esp32/ld/esp32.peripherals.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.api.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.libgcc.ld

— Adding linker script /home/denis/espressif/esp-idf/components/esp_rom/esp32/ld/esp32.rom.newlib-funcs.ld

— Adding linker script /home/denis/espressif/esp-idf/components/bootloader/subproject/main/ld/esp32/bootloader.ld

— Adding linker script /home/denis/espressif/esp-idf/components/bootloader/subproject/main/ld/esp32/bootloader.rom.ld

— Components: bootloader bootloader_support efuse esp32 esp_common esp_hw_support esp_rom esp_system esptool_py freertos hal log main micro-ecc newlib partition_table soc spi_flash xtensa

— Component paths: /home/denis/espressif/esp-idf/components/bootloader /home/denis/espressif/esp-idf/components/bootloader_support /home/denis/espressif/esp-idf/components/efuse /home/denis/espressif/esp-idf/components/esp32 /home/denis/espressif/esp-idf/components/esp_common /home/denis/espressif/esp-idf/components/esp_hw_support /home/denis/espressif/esp-idf/components/esp_rom /home/denis/espressif/esp-idf/components/esp_system /home/denis/espressif/esp-idf/components/esptool_py /home/denis/espressif/esp-idf/components/freertos /home/denis/espressif/esp-idf/components/hal /home/denis/espressif/esp-idf/components/log /home/denis/espressif/esp-idf/components/bootloader/subproject/main /home/denis/espressif/esp-idf/components/bootloader/subproject/components/micro-ecc /home/denis/espressif/esp-idf/components/newlib /home/denis/espressif/esp-idf/components/partition_table /home/denis/espressif/esp-idf/components/soc /home/denis/espressif/esp-idf/components/spi_flash /home/denis/espressif/esp-idf/components/xtensa

— Configuring done

— Generating done

— Build files have been written to: /home/denis/Programs/esp32/hello_world/build/bootloader

[272/994] Performing build step for ‘bootloader’

[1/95] Generating project_elf_src_esp32.c

[2/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/esp32/esp_efuse_table.c.obj

[3/95] Building C object CMakeFiles/bootloader.elf.dir/project_elf_src_esp32.c.obj

[4/95] Building C object esp-idf/hal/CMakeFiles/__idf_hal.dir/mpu_hal.c.obj

[5/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/lldesc.c.obj

[6/95] Building C object esp-idf/hal/CMakeFiles/__idf_hal.dir/cpu_hal.c.obj

[7/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/adc_periph.c.obj

[8/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/soc_include_legacy_warn.c.obj

[9/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/dac_periph.c.obj

[10/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/i2c_periph.c.obj

[11/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/i2s_periph.c.obj

[12/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/gpio_periph.c.obj

[13/95] Building C object esp-idf/hal/CMakeFiles/__idf_hal.dir/wdt_hal_iram.c.obj

[14/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/interrupts.c.obj

[15/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/lcd_periph.c.obj

[16/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/rmt_periph.c.obj

[17/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/ledc_periph.c.obj

[18/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/mcpwm_periph.c.obj

[19/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/rtc_io_periph.c.obj

[20/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/sdmmc_periph.c.obj

[21/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/pcnt_periph.c.obj

[22/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/sigmadelta_periph.c.obj

[23/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/sdio_slave_periph.c.obj

[24/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/timer_periph.c.obj

[25/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/uart_periph.c.obj

[26/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/spi_periph.c.obj

[27/95] Building C object esp-idf/soc/CMakeFiles/__idf_soc.dir/esp32/touch_sensor_periph.c.obj

[28/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_clock_init.c.obj

[29/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_common_loader.c.obj

[30/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_mem.c.obj

[31/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_common.c.obj

[32/95] Building C object esp-idf/spi_flash/CMakeFiles/__idf_spi_flash.dir/esp32/spi_flash_rom_patch.c.obj

[33/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_random.c.obj

[34/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_random_esp32.c.obj

[35/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_flash.c.obj

[36/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/flash_partitions.c.obj

[37/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/secure_boot.c.obj

[38/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/flash_encrypt.c.obj

[39/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/flash_qio_mode.c.obj

[40/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_efuse_esp32.c.obj

[41/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_utility.c.obj

[42/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_flash_config_esp32.c.obj

[43/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_console_loader.c.obj

[44/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_init.c.obj

[45/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/esp_image_format.c.obj

[46/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_clock_loader.c.obj

[47/95] Building C object esp-idf/micro-ecc/CMakeFiles/__idf_micro-ecc.dir/uECC_verify_antifault.c.obj

[48/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_panic.c.obj

[49/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/bootloader_console.c.obj

[50/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/esp32/esp_efuse_fields.c.obj

[51/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/esp32/bootloader_sha.c.obj

[52/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/esp32/esp_efuse_utility.c.obj

[53/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/src/esp_efuse_api_key_esp32.c.obj

[54/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/src/esp_efuse_api.c.obj

[55/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/src/esp_efuse_fields.c.obj

[56/95] Building C object esp-idf/esp_system/CMakeFiles/__idf_esp_system.dir/esp_err.c.obj

[57/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/compare_set.c.obj

[58/95] Building C object esp-idf/bootloader_support/CMakeFiles/__idf_bootloader_support.dir/src/esp32/bootloader_esp32.c.obj

[59/95] Building C object esp-idf/efuse/CMakeFiles/__idf_efuse.dir/src/esp_efuse_utility.c.obj

[60/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_clk_init.c.obj

[61/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_pm.c.obj

[62/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/cpu_util.c.obj

[63/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_init.c.obj

[64/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/chip_info.c.obj

[65/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_sleep.c.obj

[66/95] Building C object esp-idf/xtensa/CMakeFiles/__idf_xtensa.dir/eri.c.obj

[67/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_wdt.c.obj

[68/95] Building C object esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_crc.c.obj

[69/95] Building C object esp-idf/xtensa/CMakeFiles/__idf_xtensa.dir/xt_trax.c.obj

[70/95] Building ASM object esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_longjmp.S.obj

[71/95] Building C object esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_sys.c.obj

[72/95] Building C object esp-idf/esp_common/CMakeFiles/__idf_esp_common.dir/src/esp_err_to_name.c.obj

[73/95] Building C object esp-idf/esp_rom/CMakeFiles/__idf_esp_rom.dir/patches/esp_rom_uart.c.obj

[74/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_time.c.obj

[75/95] Building C object esp-idf/main/CMakeFiles/__idf_main.dir/bootloader_start.c.obj

[76/95] Building C object esp-idf/log/CMakeFiles/__idf_log.dir/log_noos.c.obj

[77/95] Building C object esp-idf/log/CMakeFiles/__idf_log.dir/log_buffers.c.obj

[78/95] Building C object esp-idf/log/CMakeFiles/__idf_log.dir/log.c.obj

[79/95] Building C object esp-idf/esp_hw_support/CMakeFiles/__idf_esp_hw_support.dir/port/esp32/rtc_clk.c.obj

[80/95] Linking C static library esp-idf/log/liblog.a

[81/95] Linking C static library esp-idf/esp_rom/libesp_rom.a

[82/95] Linking C static library esp-idf/esp_common/libesp_common.a

[83/95] Linking C static library esp-idf/xtensa/libxtensa.a

[84/95] Linking C static library esp-idf/esp_hw_support/libesp_hw_support.a

[85/95] Linking C static library esp-idf/esp_system/libesp_system.a

[86/95] Linking C static library esp-idf/efuse/libefuse.a

[87/95] Linking C static library esp-idf/bootloader_support/libbootloader_support.a

[88/95] Linking C static library esp-idf/spi_flash/libspi_flash.a

[89/95] Linking C static library esp-idf/micro-ecc/libmicro-ecc.a

[90/95] Linking C static library esp-idf/soc/libsoc.a

[91/95] Linking C static library esp-idf/hal/libhal.a

[92/95] Linking C static library esp-idf/main/libmain.a

[93/95] Linking C executable bootloader.elf

[94/95] Generating binary image from built executable

esptool.py v3.2-dev

Merged 1 ELF section

Generated /home/denis/Programs/esp32/hello_world/build/bootloader/bootloader.bin

[95/95] cd /home/denis/Programs/esp32/hello_world/build/bootloader/esp-idf/esptool_py && /home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python /home/denis/espressif/esp-idf/components/partition_table/check_sizes.py —offset 0x8000 bootloader 0x1000 /home/denis/Programs/esp32/hello_world/build/bootloader/bootloader.bin

Bootloader binary size 0x6330 bytes. 0xcd0 bytes (13%) free.

[993/994] Generating binary image from built executable

esptool.py v3.2-dev

Merged 2 ELF sections

Generated /home/denis/Programs/esp32/hello_world/build/hello-world.bin

[994/994] cd /home/denis/Programs/esp32/hello_world/build/esp-idf/esptool_py && /home/denis/.espressif/python_env/idf…32/hello_world/build/partition_table/partition-table.bin /home/denis/Programs/esp32/hello_world/build/hello-world.bin

hello-world.bin binary size 0x28eb0 bytes. Smallest app partition is 0x100000 bytes. 0xd7150 bytes (84%) free.

Project build complete. To flash, run this command:

/home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python ../../../espressif/esp-idf/components/esptool_py/esptool/esptool.py -p (PORT) -b 460800 —before default_reset —after hard_reset —chip esp32 write_flash —flash_mode dio —flash_size detect —flash_freq 40m 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin 0x10000 build/hello-world.bin

or run ‘idf.py -p (PORT) flash’

Теперь, можем прошить полученное приложение на борт процессора esp. Порт, конечно, можно не указывать, но тогда idf.py начнёт перебирать все доступные порты. Лучше, idf.py -p /dev/ttyUSB0 flash

idf.py flash

Скрытый текст

~/Programs/esp32/hello_world $ idf.py -p /dev/ttyUSB0 flash

Executing action: flash

Running ninja in directory /home/denis/Programs/esp32/hello_world/build

Executing «ninja flash»…

[1/5] cd /home/denis/Programs/esp32/hello_world/build/esp-idf/esptool_py && /home/denis/.espressif/python_env/idf4.4_…32/hello_world/build/partition_table/partition-table.bin /home/denis/Programs/esp32/hello_world/build/hello-world.bin

hello-world.bin binary size 0x28eb0 bytes. Smallest app partition is 0x100000 bytes. 0xd7150 bytes (84%) free.

[2/5] Performing build step for ‘bootloader’

[1/1] cd /home/denis/Programs/esp32/hello_world/build/bootloader/esp-idf/esptool_py && /home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python /home/denis/espressif/esp-idf/components/partition_table/check_sizes.py —offset 0x8000 bootloader 0x1000 /home/denis/Programs/esp32/hello_world/build/bootloader/bootloader.bin

Bootloader binary size 0x6330 bytes. 0xcd0 bytes (13%) free.

[2/3] cd /home/denis/espressif/esp-idf/components/esptool_py && /home/denis/.espressif/tools/cmake/3.20.3/bin/cmake -…/denis/Programs/esp32/hello_world/build» -P /home/denis/espressif/esp-idf/components/esptool_py/run_serial_tool.cmake

esptool.py esp32 -p /dev/ttyUSB0 -b 460800 —before=default_reset —after=hard_reset write_flash —flash_mode dio —flash_freq 40m —flash_size 2MB 0x1000 bootloader/bootloader.bin 0x10000 hello-world.bin 0x8000 partition_table/partition-table.bin

esptool.py v3.2-dev

Serial port /dev/ttyUSB0

Connecting….

Chip is ESP32-D0WDQ6 (revision 1)

Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None

Crystal is 40MHz

MAC: 08:3a:f2:a9:a8:c0

Uploading stub…

Running stub…

Stub running…

Changing baud rate to 460800

Changed.

Configuring flash size…

Flash will be erased from 0x00001000 to 0x00007fff…

Flash will be erased from 0x00010000 to 0x00038fff…

Flash will be erased from 0x00008000 to 0x00008fff…

Compressed 25392 bytes to 15839…

Writing at 0x00001000… (100 %)

Wrote 25392 bytes (15839 compressed) at 0x00001000 in 0.7 seconds (effective 297.5 kbit/s)…

Hash of data verified.

Compressed 167600 bytes to 88661…

Writing at 0x00010000… (16 %)

Writing at 0x0001ae43… (33 %)

Writing at 0x000205e9… (50 %)

Writing at 0x00025dcf… (66 %)

Writing at 0x0002e3d4… (83 %)

Writing at 0x000367a3… (100 %)

Wrote 167600 bytes (88661 compressed) at 0x00010000 in 2.3 seconds (effective 593.9 kbit/s)…

Hash of data verified.

Compressed 3072 bytes to 103…

Writing at 0x00008000… (100 %)

Wrote 3072 bytes (103 compressed) at 0x00008000 in 0.0 seconds (effective 546.2 kbit/s)…

Hash of data verified.

Leaving…

Hard resetting via RTS pin…

Done

Осталось запустить мониторинг работы программы:

idf.py -p /dev/ttyUSB0 monitor

Скрытый текст

~/Programs/esp32/hello_world $ idf.py -p /dev/ttyUSB0 monitor 127 ↵

Executing action: monitor

Running idf_monitor in directory /home/denis/Programs/esp32/hello_world

Executing «/home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python /home/denis/espressif/esp-idf/tools/idf_monitor.py -p /dev/ttyUSB0 -b 115200 —toolchain-prefix xtensa-esp32-elf- —target esp32 —revision 0 /home/denis/Programs/esp32/hello_world/build/hello-world.elf -m ‘/home/denis/.espressif/python_env/idf4.4_py3.9_env/bin/python’ ‘/home/denis/espressif/esp-idf/tools/idf.py’ ‘-p’ ‘/dev/ttyUSB0′»…

— 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)

configsip: 0, SPIWP:0xee

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00

mode:DIO, clock div:2

load:0x3fff0030,len:6724

load:0x40078000,len:14780

load:0x40080400,len:3792

0x40080400: _init at ??:?

entry 0x40080694

I (27) boot: ESP-IDF v4.4-dev-2740-gf65c8249af 2nd stage bootloader

I (27) boot: compile time 23:51:51

I (27) boot: chip revision: 1

I (32) boot_comm: chip revision: 1, min. bootloader chip revision: 0

I (39) boot.esp32: SPI Speed : 40MHz

I (43) boot.esp32: SPI Mode : DIO

I (48) boot.esp32: SPI Flash Size : 2MB

I (52) boot: Enabling RNG early entropy source…

I (58) boot: Partition Table:

I (61) boot: ## Label Usage Type ST Offset Length

I (69) boot: 0 nvs WiFi data 01 02 00009000 00006000

I (76) boot: 1 phy_init RF data 01 01 0000f000 00001000

I (84) boot: 2 factory factory app 00 00 00010000 00100000

I (91) boot: End of partition table

I (95) boot_comm: chip revision: 1, min. application chip revision: 0

I (102) esp_image: segment 0: paddr=00010020 vaddr=3f400020 size=07444h ( 29764) map

I (122) esp_image: segment 1: paddr=0001746c vaddr=3ffb0000 size=0236ch ( 9068) load

I (126) esp_image: segment 2: paddr=000197e0 vaddr=40080000 size=06838h ( 26680) load

I (139) esp_image: segment 3: paddr=00020020 vaddr=400d0020 size=147f8h ( 83960) map

I (169) esp_image: segment 4: paddr=00034820 vaddr=40086838 size=04650h ( 18000) load

I (177) esp_image: segment 5: paddr=00038e78 vaddr=50000000 size=00010h ( 16) load

I (183) boot: Loaded app from partition at offset 0x10000

I (183) boot: Disabling RNG early entropy source…

I (198) cpu_start: Pro cpu up.

I (198) cpu_start: Starting app cpu, entry point is 0x40080fc4

0x40080fc4: call_start_cpu1 at /home/denis/espressif/esp-idf/components/esp_system/port/cpu_start.c:156

I (0) cpu_start: App cpu up.

I (212) cpu_start: Pro cpu start user code

I (212) cpu_start: cpu freq: 160000000

I (212) cpu_start: Application information:

I (217) cpu_start: Project name: hello-world

I (222) cpu_start: App version: 1

I (227) cpu_start: Compile time: Aug 24 2021 23:51:46

I (233) cpu_start: ELF file SHA256: e60ccc33c95bd333…

I (239) cpu_start: ESP-IDF: v4.4-dev-2740-gf65c8249af

I (245) heap_init: Initializing. RAM available for dynamic allocation:

I (253) heap_init: At 3FFAE6E0 len 00001920 (6 KiB): DRAM

I (259) heap_init: At 3FFB2C48 len 0002D3B8 (180 KiB): DRAM

I (265) heap_init: At 3FFE0440 len 00003AE0 (14 KiB): D/IRAM

I (271) heap_init: At 3FFE4350 len 0001BCB0 (111 KiB): D/IRAM

I (278) heap_init: At 4008AE88 len 00015178 (84 KiB): IRAM

I (285) spi_flash: detected chip: generic

I (288) spi_flash: flash io: dio

W (292) spi_flash: Detected size(4096k) larger than the size in the binary image header(2048k). Using the size in the binary image header.

I (307) cpu_start: Starting scheduler on PRO CPU.

I (0) cpu_start: Starting scheduler on APP CPU.

Hello world!

This is esp32 chip with 2 CPU core(s), WiFi/BT/BLE, silicon revision 1, 2MB external flash

Minimum free heap size: 294448 bytes

Restarting in 10 seconds…

Restarting in 9 seconds…

Restarting in 8 seconds…

Restarting in 7 seconds…

Restarting in 6 seconds…

Restarting in 5 seconds…

Restarting in 4 seconds…

Restarting in 3 seconds…

Restarting in 2 seconds…

Restarting in 1 seconds…

Restarting in 0 seconds…

Restarting now.

ets Jun 8 2016 00:22:57

Т.е., программа «Здравствуй Мир!» считывает параметры MCU, печатает их и начинает обратный отсчёт с периодом в одну секунду. Когда доходит до нуля, перезагружает процессор.

У утилиты idf.py есть ещё несколько полезных параметров. Вы их можете посмотреть, запустив

idf.py --help

Можете на них взглянуть, хотя, скорее всего, Вы уже установили программу

Скрытый текст

~/Programs/esp32/hello_world $ idf.py —help

Usage: idf.py [OPTIONS] COMMAND1 [ARGS]… [COMMAND2 [ARGS]…]…

ESP-IDF CLI build management tool. For commands that are not known to idf.py an attempt to execute it as a build system target will be

made.

Options:

—version Show IDF version and exit.

—list-targets Print list of supported targets and exit.

-C, —project-dir PATH Project directory.

-B, —build-dir PATH Build directory.

-w, —cmake-warn-uninitialized / -n, —no-warnings

                              Enable CMake uninitialized variable warnings for CMake files inside the project directory. (--no-

                              warnings is now the default, and doesn't need to be specified.) The default value can be set with the

                              IDF_CMAKE_WARN_UNINITIALIZED environment variable.

-v, —verbose Verbose build output.

—preview Enable IDF features that are still in preview.

—ccache / —no-ccache Use ccache in build. Disabled by default. The default value can be set with the IDF_CCACHE_ENABLE

                              environment variable.

-G, —generator [Ninja|Unix Makefiles]

                              CMake generator.

-D, —define-cache-entry TEXT Create a cmake cache entry. This option can be used at most once either globally, or for one subcommand.

-b, —baud INTEGER Baud rate for flashing. The default value can be set with the ESPBAUD environment variable. This option

                              can be used at most once either globally, or for one subcommand.

-p, —port TEXT Serial port. The default value can be set with the ESPPORT environment variable. This option can be used

                              at most once either globally, or for one subcommand.

—help Show this message and exit.

Commands:

add-dependency Add dependency to the manifest file. For now we only support adding dependencies on the default service.

all Aliases: build. Build the project.

app Build only the app.

app-flash Flash the app only.

bootloader Build only bootloader.

bootloader-flash Flash bootloader only.

build-system-targets Print list of build system targets.

clean Delete build output files from the build directory.

confserver Run JSON configuration server.

create-component Create a new component.

create-manifest Create manifest for specified component.

create-project Create a new project.

create-remote-component Register a new component on the component service.

delete-version Delete version in dist directory from the component service.

docs Open web browser with documentation for ESP-IDF

efuse_common_table Generate C-source for IDF’s eFuse fields.

efuse_custom_table Generate C-source for user’s eFuse fields.

encrypted-app-flash Flash the encrypted app only.

encrypted-flash Flash the encrypted project.

erase_flash Erase entire flash chip.

erase_otadata Erase otadata partition.

flash Flash the project.

fullclean Delete the entire build directory contents.

gdb Run the GDB.

gdbgui GDB UI in default browser.

gdbtui GDB TUI mode.

menuconfig Run «menuconfig» project configuration tool.

monitor Display serial output.

openocd Run openocd from current path

pack-component Create component archive.

partition_table Build only partition table.

partition_table-flash Flash partition table only.

post_debug Utility target to read the output of async debug action and stop them.

python-clean Delete generated Python byte code from the IDF directory

read_otadata Read otadata partition.

reconfigure Re-run CMake.

set-target Set the chip target to build.

show_efuse_table Print eFuse table.

size Print basic size information about the app.

size-components Print per-component size information.

size-files Print per-source-file size information.

uf2 Generate the UF2 binary with all the binaries included

uf2-app Generate an UF2 binary for the application only

upload-component Upload component in dist directory to the component service.

upload-component-status Check status of component upload

Windows

Обратите внимание, что %USERPROFILE% (Путь к домашнему каталогу пользователя) не должен содержать пробелов. Иначе, установка инструментария esp-idf просто не запустится. Если путь содержит пробелы, устанавливайте куда-нибудь ещё. Например, на другой диск или в корневой каталог диска C:\

Обычно, git.exe (https://git-scm.com/downloads) устанавливается в каталог %ProgramFiles%/git/bin. python.exe (на момент написания актуальна версия Python3.9 — https://www.python.org/downloads/, Обычно, находится в каталоге %ProgramFiles%/Python39 )

Не стоит устанавливать пакеты ninja и cmake. Пакет установки Windows «вытянет» сам нужные версии и установит их локально.

Необходимо сразу проверить, чтобы git и python были уже прописаны в Path. Можно глобально, можно локально:

Находим в настройках Windows изменение системных/пользовательских переменных среды

Находим в настройках Windows изменение системных/пользовательских переменных среды

Также, под Windows, можно сразу прописать переменную IDF_PATH. Обычно, устанавливаю esp-idf в %USERPROFILE%\espressif. Можно сразу добавить IDF_TOOLS_PATH. По умолчанию, esp-idf toolchain (инструментарий) установится в каталог %USERPROFILE%/.espressif. Для ускорения настройки vscode-esp-idf-extension можно ещё добавить переменную IDF_PATH_ENV_PATH — путь к каталогу, куда устанавливается python venv для работы esp-idf. На данный момент IDF_PYTHON_ENV_PATH=%USERPROFILE%\.espressif\python_env\idf4.4_py3.9_env. Проблема в том, что с каждой новой версией Python и ESP-IDF этот путь будет меняться.

Настраиваем переменные окружения для ESP-IDF, чтобы плагин VSCode мог бы «подхватить» уже настроенный пакет

Настраиваем переменные окружения для ESP-IDF, чтобы плагин VSCode мог бы «подхватить» уже настроенный пакет

Для установки под Windows можно использовать export.bat из Командной Строки (cmd.exe)

mkdir %USERPROFILE%\espressif
cd %USERPROFILE%\espressif
git clone https://github.com/espressif/esp-idf --recursive
.\install.bat

Равно, можно использовать установщик для PowerShell:

cd $env:USERPROFILE
mkdir espressif
git clone https://github.com/espressif/esp-idf.git --recursive
cd .\esp-idf\
.\install.ps1

Если получилось, увидим примерно следующее (вывод сокращён):

Скрытый текст

C:\Users\grand\esp32\hello_world>cd %USERPROFILE%\espressif\esp-idf

C:\Users\grand\espressif\esp-idf>install.bat

Installing ESP-IDF tools

Selected targets are: esp32s2, esp32c3, esp32, esp32s3

Installing tools: xtensa-esp32-elf, xtensa-esp32s2-elf, xtensa-esp32s3-elf, riscv32-esp-elf, esp32ulp-elf, esp32s2ulp-elf, cmake, openocd-esp32, ninja, idf-exe, ccache, dfu-util

Skipping xtensa-esp32-elf@esp-2021r1-8.4.0 (already installed)

Skipping xtensa-esp32s2-elf@esp-2021r1-8.4.0 (already installed)

Skipping xtensa-esp32s3-elf@esp-2021r1-8.4.0 (already installed)

Skipping riscv32-esp-elf@esp-2021r1-8.4.0 (already installed)

Skipping esp32ulp-elf@2.28.51-esp-20191205 (already installed)

Skipping esp32s2ulp-elf@2.28.51-esp-20191205 (already installed)

Skipping cmake@3.20.3 (already installed)

Skipping openocd-esp32@v0.10.0-esp32-20210721 (already installed)

Skipping ninja@1.10.2 (already installed)

Skipping idf-exe@1.0.1 (already installed)

Skipping ccache@4.3 (already installed)

Skipping dfu-util@0.9 (already installed)

Setting up Python environment

Python 3.9.6

pip 21.2.4 from C:\Users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages\pip (python 3.9)

Installing Python packages from C:\Users\grand\espressif\esp-idf\requirements.txt

Looking in indexes: https://pypi.org/simple, https://dl.espressif.com/pypi

Processing c:\users\grand\espressif\esp-idf\tools\kconfig_new\esp-windows-curses

DEPRECATION: A future pip version will change local packages to be built in-place without first copying to a temporary directory. We recommend you use —use-feature=in-tree-build to test your packages with this new behavior before it becomes the default.

pip 21.3 will remove support for this functionality. You can find discussion regarding this at https://github.com/pypa/pip/issues/7555.

Requirement already satisfied: setuptools>=21 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 4)) (57.4.0)

Requirement already satisfied: click>=7.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 8)) (8.0.1)

Requirement already satisfied: pyserial>=3.3 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 9)) (3.5)

Requirement already satisfied: future>=0.15.2 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 10)) (0.18.2)

Requirement already satisfied: cryptography>=2.1.4 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 11)) (3.4.7)

Requirement already satisfied: pyparsing<2.4.0,>=2.0.3 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 12)) (2.3.1)

Requirement already satisfied: pyelftools>=0.22 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 13)) (0.27)

Requirement already satisfied: gdbgui==0.13.2.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (0.13.2.0)

Requirement already satisfied: pygdbmi<=0.9.0.2 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 18)) (0.9.0.2)

Requirement already satisfied: python-socketio<5 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 21)) (4.6.1)

Requirement already satisfied: kconfiglib==13.7.1 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 23)) (13.7.1)

Requirement already satisfied: reedsolo<=1.5.4,>=1.5.3 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 26)) (1.5.4)

Requirement already satisfied: bitstring>=3.1.6 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 27)) (3.1.9)

Requirement already satisfied: ecdsa>=0.16.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 28)) (0.17.0)

Requirement already satisfied: construct==2.10.54 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from -r C:\Users\grand\espressif\esp-idf\requirements.txt (line 32)) (2.10.54)

Requirement already satisfied: Flask-SocketIO<3.0,>=2.9 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (2.9.6)

Requirement already satisfied: gevent<2.0,>=1.2.2 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (1.5.0)

Requirement already satisfied: Flask-Compress<2.0,>=1.4.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (1.10.1)

Requirement already satisfied: Pygments<3.0,>=2.2.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (2.10.0)

Requirement already satisfied: Flask<1.0,>=0.12.2 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (0.12.5)

Requirement already satisfied: colorama in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from click>=7.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 8)) (0.4.4)

Requirement already satisfied: cffi>=1.12 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from cryptography>=2.1.4->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 11)) (1.14.6)

Requirement already satisfied: six>=1.9.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from python-socketio<5->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 21)) (1.16.0)

Requirement already satisfied: python-engineio<4,>=3.13.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from python-socketio<5->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 21)) (3.14.2)

Requirement already satisfied: windows-curses in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from esp-windows-curses==0.1->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 38)) (2.2.0)

Requirement already satisfied: pycparser in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from cffi>=1.12->cryptography>=2.1.4->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 11)) (2.20)

Requirement already satisfied: itsdangerous>=0.21 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from Flask<1.0,>=0.12.2->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (2.0.1)

Requirement already satisfied: Werkzeug<1.0,>=0.7 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from Flask<1.0,>=0.12.2->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (0.16.1)

Requirement already satisfied: Jinja2>=2.4 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from Flask<1.0,>=0.12.2->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (3.0.1)

Requirement already satisfied: brotli in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from Flask-Compress<2.0,>=1.4.0->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (1.0.9)

Requirement already satisfied: greenlet>=0.4.14 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from gevent<2.0,>=1.2.2->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (1.1.1)

Requirement already satisfied: MarkupSafe>=2.0 in c:\users\grand.espressif\python_env\idf4.4_py3.9_env\lib\site-packages (from Jinja2>=2.4->Flask<1.0,>=0.12.2->gdbgui==0.13.2.0->-r C:\Users\grand\espressif\esp-idf\requirements.txt (line 15)) (2.0.1)

Building wheels for collected packages: esp-windows-curses

Building wheel for esp-windows-curses (setup.py) … done

Created wheel for esp-windows-curses: filename=esp_windows_curses-0.1-py3-none-any.whl size=1170 sha256=bdbf62d5861e86804fd97c0398bc76ab1a95cffea827b1215a340c406b564246

Stored in directory: c:\users\grand\appdata\local\pip\cache\wheels\c0\a0\63\a4fd89175a7346f567d984c78f1f3749b6e026098b0098ef22

Successfully built esp-windows-curses

Installing collected packages: esp-windows-curses

Attempting uninstall: esp-windows-curses

Found existing installation: esp-windows-curses 0.1

Uninstalling esp-windows-curses-0.1:

  Successfully uninstalled esp-windows-curses-0.1

Successfully installed esp-windows-curses-0.1

All done! You can now run:

export.bat

Теперь, нужно запустить export.bat:

Скрытый текст

C:\Users\grand\espressif\esp-idf>export.bat Setting IDF_PATH: C:\Users\grand\espressif\esp-idf

Adding ESP-IDF tools to PATH… No directories added to PATH:

C:\Users\grand.espressif\tools\xtensa-esp32-elf\esp-2021r1-8.4.0\xtensa-esp32-elf\bin;C:\Users\grand.espressif\tools\xtensa-esp32s2-elf\esp-2021r1-8.4.0\xtensa-esp32s2-elf\bin;C:\Users\grand.espressif\tools\xtensa-esp32s3-elf\esp-2021r1-8.4.0\xtensa-esp32s3-elf\bin;C:\Users\grand.espressif\tools\riscv32-esp-elf\esp-2021r1-8.4.0\riscv32-esp-elf\bin;C:\Users\grand.espressif\tools\esp32ulp-elf\2.28.51-esp-20191205\esp32ulp-elf-binutils\bin;C:\Users\grand.espressif\tools\esp32s2ulp-elf\2.28.51-esp-20191205\esp32s2ulp-elf-binutils\bin;C:\Users\grand.espressif\tools\cmake\3.20.3\bin;C:\Users\grand.espressif\tools\openocd-esp32\v0.10.0-esp32-20210721\openocd-esp32\bin;C:\Users\grand.espressif\tools\idf-exe\1.0.1;C:\Users\grand.espressif\tools\ccache\4.3\ccache-4.3-windows-64;C:\Users\grand.espressif\tools\dfu-util\0.9\dfu-util-0.9-win64;C:\Users\grand.espressif\python_env\idf4.4_py3.9_env\Scripts;C:\Users\grand\espressif\esp-idf\tools;C:\ActiveTcl\bin;C:\Program Files (x86)\Common Files\Intel\Shared Libraries\redist\intel64\compiler;C:\Program Files\Python39\Scripts;C:\Program Files\Python39;C:\Program Files\Common Files\Oracle\Java\javapath;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0;C:\WINDOWS\System32\OpenSSH;C:\Program Files\NVIDIA Corporation\NVIDIA NvDLISR;C:\Program Files (x86)\Calibre2;C:\Program Files\PuTTY;C:\Program Files\MiKTeX\miktex\bin\x64;C:\Program Files\nodejs;C:\ProgramData\chocolatey\bin;C:\Program Files\Polyspace\R2021a\runtime\win64;C:\Program Files\Polyspace\R2021a\bin;C:\Program Files\Polyspace\R2021a\polyspace\bin;C:\Program Files\Microchip\xc8\v2.31\bin;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\110\Tools\Binn;C:\Program Files (x86)\Microsoft SQL Server\120\Tools\Binn;C:\Program Files\Microsoft SQL Server\120\Tools\Binn;C:\Program Files\Microsoft SQL Server\120\DTS\Binn;C:\Program Files (x86)\Windows Kits\8.1\Windows Performance Toolkit;C:\Utils;C:\Program Files\dotnet;C:\Program Files\Python39;C:\Program Files\Notepad++;C:\Program Files\Git\cmd;C:\Users\grand\AppData\Local\Microsoft\WindowsApps;C:\Program Files\Python39;C:\Program Files\Git\bin;;C:\Users\grand\AppData\Local\Programs\Microsoft VS Code\bin

Checking if Python packages are up to date… Python requirements from C:\Users\grand\espressif\esp-idf\requirements.txt are satisfied.

Done! You can now compile ESP-IDF projects. Go to the project directory and run:

idf.py build

Или, если Вы используете PowerShell:

$env:USERPROFILE\espressif\esp-idf\install.ps1

По умолчанию toolchain установится в %USERPROFILE%\.espressif ($env:USERPROFILE\.espressif)

Не пропускаем предупреждение об обновлении Python Virtual Environment. Обновляем:

$env:USERPROFILE\.espressif\python_env\idf4.4_py3.9_env\Scripts\python.exe -m pip install --upgrade pip

Осталось сделать ярлыки для запуска среды консольной разработки. Открываем в проводнике. Правой кнопкой в проводникеSystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe (расположение по умолчанию). Правой кнопкой мыши вызываем «Создать ярлык». В свойствах ярлыка добавляем: «%SystemRoot%\system32\WindowsPowerShell\v1.0\powershell.exe» -noexit -ExecutionPolicy Bypass -File %USERPROFILE%\espressif\esp-idf\export.ps1. При желании можно поставить какую-нибудь красивую иконку.

Неплохо указать рабочий каталог. Например, «%USERPOFILE%\esp32»

Или тоже самое можно сделать для cmd.exe — правой кнопкой мыши на экране, «Создать ярлык», указать команду: %comspec% /k «%IDF_PATH%\export.bat». И, опять-таки, не забудьте установить путь к рабочему каталогу (Например, %USERPROFILE%\esp32) и можете поменять иконку.

Итак, после запуска консоли, мы получили приглашение к сборке проекта: idf.py build. т.е., если мы находимся в каталоге проекта, то можно его собрать и прошить Можно скопировать из примеров проект «hello world», скажем в каталог %USERPROFILE%\esp32\hello_world:

cd %USERPROFILE%
mkdir esp32
mkdir hello_world
copy  %USERPROFILE%\espressif\esp-idf\examples\get-started\hello_world %USERPROFILE%\esp32
cd .\esp32\hello_world
idf.py build
idf.py flash
idf.py monitor

Команда idf.py build строит проект, idf.py flash — прошивает устройство (плата уже должна быть подключена к компьютеру), idf.py — запускает монитор сообщений платы.

Если всё прошло успешно, увидим что-то вроде:

Скрытый текст

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)

configsip: 0, SPIWP:0xee

clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00

mode:DIO, clock div:2

load:0x3fff0030,len:6388

load:0x40078000,len:14252

load:0x40080400,len:3820

0x40080400: _init at ??:?

entry 0x40080698

I (27) boot: ESP-IDF v4.4-dev-2594-ga20df743f1 2nd stage bootloader

I (27) boot: compile time 23:44:15

I (27) boot: chip revision: 1

I (31) boot_comm: chip revision: 1, min. bootloader chip revision: 0

I (39) boot.esp32: SPI Speed : 40MHz

I (43) boot.esp32: SPI Mode : DIO

I (48) boot.esp32: SPI Flash Size : 2MB

I (52) boot: Enabling RNG early entropy source…

I (58) boot: Partition Table:

I (61) boot: ## Label Usage Type ST Offset Length

I (69) boot: 0 nvs WiFi data 01 02 00009000 00006000

I (76) boot: 1 phy_init RF data 01 01 0000f000 00001000

I (83) boot: 2 factory factory app 00 00 00010000 00100000

I (91) boot: End of partition table

I (95) boot_comm: chip revision: 1, min. application chip revision: 0

I (102) esp_image: segment 0: paddr=00010020 vaddr=3f400020 size=073dch ( 29660) map

I (122) esp_image: segment 1: paddr=00017404 vaddr=3ffb0000 size=0236ch ( 9068) load

I (125) esp_image: segment 2: paddr=00019778 vaddr=40080000 size=068a0h ( 26784) load

I (139) esp_image: segment 3: paddr=00020020 vaddr=400d0020 size=14808h ( 83976) map

I (169) esp_image: segment 4: paddr=00034830 vaddr=400868a0 size=044e0h ( 17632) load

I (177) esp_image: segment 5: paddr=00038d18 vaddr=50000000 size=00010h ( 16) load

I (183) boot: Loaded app from partition at offset 0x10000

I (183) boot: Disabling RNG early entropy source…

I (198) cpu_start: Pro cpu up.

I (198) cpu_start: Starting app cpu, entry point is 0x40080fb4

0x40080fb4: call_start_cpu1 at C:/Users/grand/espressif/esp-idf/components/esp_system/port/cpu_start.c:156

I (185) cpu_start: App cpu up.

I (213) cpu_start: Pro cpu start user code

I (213) cpu_start: cpu freq: 160000000

I (213) cpu_start: Application information:

I (217) cpu_start: Project name: hello-world

I (222) cpu_start: App version: 1

I (227) cpu_start: Compile time: Aug 24 2021 23:44:00

I (233) cpu_start: ELF file SHA256: 64100d65401fe87b…

I (239) cpu_start: ESP-IDF: v4.4-dev-2594-ga20df743f1

I (246) heap_init: Initializing. RAM available for dynamic allocation:

I (253) heap_init: At 3FFAE6E0 len 00001920 (6 KiB): DRAM

I (259) heap_init: At 3FFB2C48 len 0002D3B8 (180 KiB): DRAM

I (265) heap_init: At 3FFE0440 len 00003AE0 (14 KiB): D/IRAM

I (271) heap_init: At 3FFE4350 len 0001BCB0 (111 KiB): D/IRAM

I (278) heap_init: At 4008AD80 len 00015280 (84 KiB): IRAM

I (285) spi_flash: detected chip: generic

I (289) spi_flash: flash io: dio

W (293) spi_flash: Detected size(4096k) larger than the size in the binary image header(2048k). Using the size in the binary image header.

I (307) cpu_start: Starting scheduler on PRO CPU.

I (0) cpu_start: Starting scheduler on APP CPU.

Hello world!

This is esp32 chip with 2 CPU core(s), WiFi/BT/BLE, silicon revision 1, 2MB external flash

Minimum free heap size: 294448 bytes

Restarting in 10 seconds…

C:\Users\grand\esp32\hello_world>

Т.е. выводится информация о процессоре, дальше запускается обратный отсчёт от 10 до 0 и процессор перезапускается.

Сам код программы Вы можете посмотреть в %USERPROFILE%\esp32\hello_world\main\hello_world_main.c

Система мониторинга Esp32 настолько мощная, что в использовании отладчика, как правило нет необходимости. Впрочем, что выгодно отличает Esp32 от собратьев STM32 или ATmega, это дешевизна отладчика. Бюджетная плата FT2232HL обойдётся в районе одной тысячи рублей.

В принципе, если не претендовать на полнофункциональную Интегрированную Среду Разработки, фреймворк готов к работе. Редактировать исходный код примера ~/espressif/esp-idf/examples/get-started/hello_world/main/hello_world_main.c можно хоть при помощи того же notepad++.

В этом нет необходимости. esp-idf прекрасно «сотрудничает» с Visual Studio Code и Eclipse.

Часть II. Установка Visual Studio Code

Если Вы не установили VSCode глобально при помощи какого-нибудь пакетного менеджера, стоит скачать дистрибутив c https://code.visualstudio.com/download.

Под Windows, качаем User/System Installer. Я предпочитаю User Installer, чтобы VSCode установилась в %USERPROFILE%. Увы, здесь трюк с «подхватыванием» переменных окружения из Командной Строки не пройдёт. Поэтому, надо, чтобы были установлены переменные окружения IDF_PATH=%USERPROFILE%\espressif\esp-idf и IDF_PYTHON_ENV_PATH=%USERPROFILE%\.espressif\python_env\idf4.4_py3.9_env

Эту переменную можно скопировать при помощи Ctrl+M, вызвав set в командной строке, после запуска скрипта %USERPROFILE%\espressif\esp-idf\export.bat

Будьте внимательны: обратные слэши в пути!

Для Linux скачиваем, например .tar.gz архив. Или устанавливаем из стандартного пакетного менеджера. Сейчас трудно найти сборку Linux, в которой не было бы в стандартной поставке Visual Studio Code.

Если скачан .tar.gz архив под Linux можем распаковать полученный архив code-stable-x64-xxxxxxxxx-.tar.gz архив куда-нибудь вроде каталога ~/IDE

mkdir ~/IDE
cd ~/IDE
cp ~/Загрузки/code-stable-x64-xxxxx.tar.gz ~/IDE/
tar -zxvf code-stable-x64.tar.gz 

В случае локальной установки, нужно сделать «мягкую» ссылку на ~/IDE/VSCode-linux-x64/bin/code в ~/.local/bin. Причём, ссылка должна быть именно «мягкой», иначе, code при вызове из командной строки будет искать сопутствующие библиотеки в каталоге вызова ~/.local/bin. Теперь, code можно вызвать из терминала из любого каталога.

ln -sf ~/IDE/VSCode-linux-x64/bin/code ~/.local/bin/

Если у вас установлена среда рабочего стола GNOME desktop и вы установились в локальный каталог пользователя, неплохо создать *.desktop файл в каталоге ~/.local/share/applications/vscode.desktop (видит только пользователь) или /usr/share/applications/vscode.desktop. Не забудьте заменить ${HOME} на путь к домашнему каталогу. destop переменных окружения не понимает! Если установка была сделана из пакетного менеджера программ, этого делать не нужно.

[Desktop Entry]
Type=Application
Exec="${HOME}/IDE/VSCode-linux-x64/bin/code" %F
Name=VSCode
GenericName=The Microsoft IDE for C/C++, Javascript, Python e.t.c. development.
Icon=${HOME}/IDE/VSCode-linux-x64/resources/app/resources/linux/code.png
StartupWMClass=code
Terminal=false
Categories=Development;IDE;C/C++;Python;Java;Java Script;Node;NodeJS
MimeType=text/x-c++src;text/x-c++hdr;text/x-xsrc;application/x-designer;

Итак, если всё сделано правильно, то можно из любого каталога из терминала, где был запущен idfexp, запустить code. Важно, что code запускается из терминала, где экспортированы переменные окружения esp-idf.

. ~/espressif/esp-idf/export.sh
code 

или если настроен алиас:

idfexp && code

Далее, установка и настройка VSCode под Linux и Windows не будут отличаться.

Если в среде Linux или Windows настроен русский язык, VSCode запросит установку русскоязычного пакета. Можно установить. Ищем в списке расширений esp-idf и устанавливаем его.

Установка плагина Espressif IDF

Установка плагина Espressif IDF

Далее, нажимаем F1 и ищем команду «>ESP-IDF Настроить расширения ESP-IDF». Если всё было сделано правильно, увидим меню, которое будет предлагать «штатные» пути для установки (плагин будет устанавливать снова окружение eps-idf и инструментарий) и предложит использовать текущую установку esp-idf.

Выбираем «USE EXISTING SETUP»

Выбираем «USE EXISTING SETUP»

Если всё прошло удачно, увидим сообщение, что окружение Espressif IDF настроено:

Расширение Espressif IDF настроено

Расширение Espressif IDF настроено

Можем создавать новый проект. Это можно сделать через меню команд «F1»/«Ctrl+Shift+P»/«>ESP-IDF: Новый проект» или использовать «Ctrl+E N». Все команды плагина esp-idf начинаются на «Ctrl+E» (См. https://github.com/espressif/vscode-esp-idf-extension#Available-commands — список команд)

Создание нового проекта

Создание нового проекта

Будьте внимательны, если Вы укажете неправильный путь к каталогу, проектов, приложение просто выдаст сообщение об ошибке, вместо того, чтобы попытаться создать такой каталог.

Осталось выбрать исходный шаблон. Сойдёт и простейший «template-app». Это уже знакомый нам «Hello World», считывающий параметры чипа, выводящий на экран некоторые из них и запускающий обратный отсчёт на десять секунд с последующей перезагрузкой Esp32.

Выбираем шаблон проекта

Выбираем шаблон проекта

Осталось нажать «Ctrl+E D» (собрать проект, прошить плату и запустить монитор). Видим знакомый журнал работы программы «Hello World!» с обратным отсчётом.

Монитор работы Esp32

Монитор работы Esp32

Выход из монитора, опять таки по сочетанию клавиш «Ctrl+]»

Можно, также создавать проекты, используя в качестве шаблонов, примеры, находящиеся в каталоге ~/espressif/esp-idf/examples. Для этого надо вызвать F1, и найти команду «>ESP-IDF: Показать примеры проектов». Правда, к сожалению, тут доступны далеко не все примеры.

Создание проекта из примера

Создание проекта из примера

Всё. Visual Studio Code — рабочая полноценная IDE для разработки Esp32 приложений. Вы можете использовать, к примеру, F2 для рефакторинга, F12 для перехода к исходному коду включаемых файлов, функций и т.д.

Eclipse

Установка Eclipse под Windows и Linux, вообще, не отличается. Качаем с https://www.eclipse.org/downloads/ установщик Eclipse. Под Windows и Linux должен быть установлен JDK: https://www.oracle.com/ru/java/technologies/javase-jdk16-downloads.html

Запускаем установщик и, если видим в правом верхнем углу восклицательный знак, обновляем установщик.

«Выбираем Eclipse IDE for C/C++ Developers». После установки открываем «Help/Market Place» и ищем «esp-idf». Устанавливаем. После перезагрузки Eclipse вызываем «Help/Download and configure ESP-IDF». Указываем, что используем существующий пакет esp-idf:

Указать путь к esp-idf

Указать путь к esp-idf

Единственная проблема в том, что Eclipse иногда почему-то не подхватывает пути к git или python. Но их несложно прописать вручную:

Указать пути к необходимым файлам (обычно приходится делать это вручную)

Указать пути к необходимым файлам (обычно приходится делать это вручную)

Если текущая среда разработки была интегрирована успешно, можем перейти к «File/New Project/Espressif IDF Project» (ещё можно создавать встраиваемые компоненты IDF)

Если после перехода к экрану нового проекта нажать «Next>» и выбрать «Create a project from using one of the templates», можно создать проект из одного из примеров, находящихся в esp-idf/expamles.

Чтобы собрать проект, необходимо в ESP-IDF тулбаре установить нужную архитектуру процессора (обычно, это esp32, а не esp32s2) и нажатием на шестерёнку настроек в выпадающем списке «on» указать порт прошивки.

Выбираем процессор

Выбираем процессор

Указываем порт прошивки нажатием на шестерёнку около выбранного процессора. Теперь, можно нажать «Run». Если всё прошло удачно, видим процесс прошивки. ESP-IDF Terminal запускается нажатием на иконку монитора на ESP-тулбаре

Включение Espressif IDF монитора

Включение Espressif IDF монитора

Нажатие «Ctrl+]» здесь не работает. Чтобы прекратить мониторинг приложения, нужно просто закрыть монитор.

Мониторинг приложения Espressif на Eclipse

Мониторинг приложения Espressif на Eclipse

Выводы

Espressif IDF — полноценный фреймворк разработки, подключаемый к IDE Visual Studio Code и Eclipse. И, увы, если бы не очень подробная документация и некоторое количество багов, возникающих с выпуском каждой новой версии, она бы вполне могла и должна была претендовать на звание «профессиональной».

Уроки ESP32

Установим программное обеспечение, необходимое для разработки приложений ESP32.

Предыдущий урок     Список уроков     Следующий урок

Официальной программной средой для разработки приложений ESP32 является платформа ESP-IDF (Espressif’s IoT Development Framework). Она представляет собой самодастаточный набор средств для создания программного обеспечения с использованием языков программирования C и C++. ESP-IDF ориентирована на разработку, как общих приложений, так и IoT проектов.

ESP-IDF поддерживает огромное количество программных компонентов, таких как RTOS, драйверы периферийных устройств, сетевой стек, различные протоколы и прочее.

Схематично компоненты ESP-IDF выглядят так.

Компоненты платформы ESP-IDF

Установка ESP-IDF.

Платформа ESP-IDF использует кросс-компиляторы, OpenOCD, CMake и инструмент сборки Ninja. Также требуется Python и Git.

Можно инсталлировать все это отдельно, но для простоты установки компания Espressif Systems разработала инсталлятор, который делает это все в автоматическом режиме. Что немаловажно, кроме собственно установки, инсталлятор задает переменные окружения Windows. Т.е. после завершения установки можно сразу пользоваться средой.

Начнем.

Загружаем файл инсталлятора по этой ссылке.

Открываем.

Инсталлятор

Разрешаем установку всего: Python, Git, ESP-IDF.

Инсталлятор

Инсталлятор

Инсталлятор

Выбираем последнюю версию, задаем рабочую папку.

Инсталлятор

Инсталлятор

Устанавливаем.

Инсталлятор

Процесс длится довольно долго.

Инсталлятор

На рабочем столе появился ярлык.

Ярлык

Уже можно работать. Проверим основные функции.

Запускаем иконку. Открывается интерпретатор командной строки, подготавливается работа с ESP-IDF.

Интерпретатор командной строки

Попробуем компилировать проект примера, например, blink.

Перейдем в папку с проектом blink.

cd examples\get-started\blink

Интерпретатор командной строки

Компилируем проект командой  idf.py build.

В первый раз сборка программы длится довольно долго.

В результате проект компилировался успешно, о чем сообщает надпись Project build complete.

Интерпретатор командной строки

Попробуем загрузить программу в FLASH микроконтроллера.

idf.py –p COM8 flash

COM8 – это номер виртуального COM-порта. Он появляется после установки драйвера конвертера USB-UART. Обычно в отладочных платах ESP32 используется преобразователь интерфейсов CP2102. Предварительно надо установить для него драйвер и посмотреть номер виртуального порта.

Панель управления -> Система -> Диспетчер устройств -> Порты (COM и LPT)

Диспетчер устройств

У меня 8. У вас может быть другой.

И, конечно,  надо подключить к компьютеру плату.

Загрузилось успешно.

Интерпретатор командной строки

Но светодиод не мигает.

Надо исправить одну строчку в исходном тексте программы.

Открываем любым текстовым редактором D:\esp\esp-idf\get-started\blink\main\blink.c.

В строке определяющей номер вывода светодиода ставим 2.

Строку

#define BLINK_GPIO CONFIG_BLINK_GPIO

заменяем на

#define BLINK_GPIO 2

В примере использовалась другая отладочная плата, в которой светодиод подключен к другому выводу.

Заново компилируем и загружаем в FLASH.

Теперь компиляция длится 3 секунды и светодиод замигал.

Проверим еще монитор. Команда

idf.py –p COM8 monitor

Монитор

Плата посылает на компьютер сообщения ”Turning off the Led” и ”Turning on the Led”

Все прекрасно работает. Но пользоваться командной строкой очень неудобно.

Добавим к нашей среде редактор.

Установка и настройка редактора Visual Studio Code (VS Code).

Visual Studio Code – это редактор исходного кода, разработанный Microsoft. Используется для кроссплатформенной разработки приложений.

Существует специальное расширение VS Code для ESP-IDF. По моему опыту и мнению многих других программистов оно не работает нормально. К тому же,  можно вполне обойтись без него.

Устанавливаем  Visual Studio Code по ссылке.

Установка VS Code

Загружаем стабильную версию.

Установка VS Code

Установка VS Code

Установка VS Code

Установка VS Code

Установка VS Code

Было сообщение, что PATH доступно после перезагрузки. Поэтому лучше перезагрузить компьютер.

Запускаем VS  Code.

VS Code

Копируем проект blink.

Я создал папку blink1 в моем рабочем каталоге.

Копировал в нее содержимое каталога blink без папки build.

Каталог blink

Открываем папку blink1 в VS Code.

File -> Open Folder

Открытие каталога

Основной файл blink.c.

Номер вывода светодиода уже изменен.

Откроем терминал и попытаемся компилировать проект.

Terminal -> New Terminal

Открытие терминала

Командой idf.py build.

Получаем сообщение.

Сборка проекта

Терминал не конфигурирован для ESP-IDF.

Создаем пользовательскую конфигурацию.

File -> Preference -> Settings ->User

Пользовательская конфигурация

Features -> Terminal -> Edit in settings.ison

Добавляем следующий блок.

«terminal.integrated.shell.windows» : «cmd.exe»,
        «terminal.integrated.shellArgs.windows» : [
                «/k»,
                «D:/esp/esp-idf/export.bat»
]

Если впереди было что-то еще, то добавляем запятую. У меня файл settings.ison выглядит так.

Файл settings.ison

Сохраняем.

File -> Save

Компилируем.

idf.py build

В первый раз долго, потому что мы удалили папку build.

Теперь компиляция проходит без ошибок.

Сборка проекта

Загружаем программу в FLASH микроконтроллера командой

idf.py –p COM8 flash

Успешно.

Загрузка FLASH

Светодиод мигает.

Проверяем работу монитора.

idf.py –p COM8 monitor

Монитор тоже работает.

Монитор

Набирать директивы в командной строке не очень удобно. Проблему можно решить установкой расширения VsCode Action Buttons.

Нажимаем кнопку Extensions  в левом вертикальном меню.

В поле Search Extensions начинаем набирать название расширения, пока оно не появится в списке.

Расширение VsCode Action Buttons

Устанавливаем.

Дальше Extension settings и Edit in settings.json.

Добавляем блок установки кнопок с названиями Build, FLASH, Monitor.

{
        «actionButtons»: {
                «defaultColor»: «white»,
                «reloadButton»: «Reload»,
                «commands»: [
                        {
                                «name»: «Build»,
                                «color»: «white»,
                                «command»: «idf.py build»
                        },
                        {
                                «name»: «FLASH»,
                                «color»: «white»,
                                «command»: «idf.py -p COM8 flash»
                        },
                        {
                                «name»: «Monitor»,
                                «color»: «white»,
                                «command»: «idf.py -p COM8 monitor»
                        }
                ]
        }
}

Окончательно setting.json у меня выглядит так.

Файл setting.json

Слева внизу появилось новое меню.

Новое меню

Теперь нет необходимости набирать команды. Можно нажимать кнопки.

Еще одно расширение создает дополнительное меню.

Называется Shortcut menu bar.

Расширение Shortcut menu bar

После установки справа вверху появляется меню, конфигурацию которого можно изменять.

Верхнее меню

В зависимости от формата дисплея компьютера иногда панель терминала удобнее разместить не внизу, а справа.

Панель терминала справа

Делается это нажатием правой кнопки мыши по закладке Terminal.

Установка панели терминала справа

Дальше Move Panel Right.

Все. Среда программирования установлена и готова к использованию

В следующем уроке будем разбираться в проекте ESP-IDF.

Предыдущий урок     Список уроков     Следующий урок

Автор публикации


273

Комментарии: 1919Публикации: 197Регистрация: 13-12-2015

В данной статье рассмотрим, как работать с ESP32 под управлением родного фреймворка ESP-IDF.

esp32-video

🔗 Ссылка на видео 🔗

Введение

ESP-IDF — самый близкий к железу по уровню абстракции фреймворк для работы с ESP32.

Многие возразят, что лучше бы использовать Arduino, но это совсем не так.
С Arduino просто нельзя добиться того быстродействия и той гибкости настроек, что обеспечивает нам IDF. Плюсом ещё и возможности урезаются. Это мы рассмотрим в последующих статьях, например про REST API.

Железо

Обзор

У ESP в массовом продакшне представлены 3 группы SoC.

Есть стандартная ESP32, без доп. наименований. Этот чип самый богатый по количеству периферии. Его мы и будем в дальнейшем использовать по умолчанию.

Есть S-серия, например S2, S3. Базируется на том же ядре Xtensa, что и “классическая” ESP32.
Модель S2 имеет одно ядро, при этом она сильно урезана, например лишена Bluetooth.
Чип S3 более интересный, имеет 2 ядра, а также возможность подключить боснословный объём внешней памяти. Но с периферией тоже беда, например нет Ethernet.

Есть C-серия. Она базируется на ядре RISC-V.
Например C3 — вариант интереснее, чем S2, но скуднее, чем обычная серия.
Или C6, чип, находящийся в разработке, весьма интересный, так как поддерживает Wi-Fi 6, вдобавок и IEEE 802.15.4 (Thread, Zigbee, etc.). Идеальный вариант для протокола Matter.

Вот такой зоопарк:

esp32-comparison

Линк на сравнение

Прошивка и отладка

Прошивка осуществляется через обыкновенный USB-UART. Можем взять абсолютно любой.
Пробовал использовать VCP в ST-Link v2.1, но ничего корректно не работает.

При этом есть особенность. ESP32 вводится в режим прошивки с помощью пина BOOT0. Его нужно нажимать вручную. Но можно применить подобную схему, которая встречается в специализированных программаторах:

Введение в ESP-IDF

Доп. линии UART используются для перевода в режим программирования

Внутрисхемную отладку (точки останова и просмотр переменных) можно осуществлять только с помощью программатора USB-JTAG. Можно взять “родной” ESP-Prog, но цена на него неоправданно высокая. Эту тему разберём в дальнейших материалах.

Введение в ESP-IDF

Где купить?

С вопросом о покупке выходим на Aliexpress.

Для меня самым удобным вариантом оказалось исполнение в формате Arduino Uno.

esp32-uno

Для кого-то может подойти и “классический формат” NodeMCU.

esp32-classic

Естественно, модули представлены и самостоятельно, для запайки на свою плату.

esp32-module

ClimateGuard

Отдельно хотелось бы отметить наших хороших друзей — компанию ClimateGuard.
Они разрабатывают и производят электронные модули, а также правильные UART-программаторы и отладочные платы ESP32. Идеальный вариант для прототипирования и внедрения в проекты!
Продукция представлена на OZON, AliExpress, в Амперкоте.

Поддержим отечественного производителя!
Переходите по ссылке и знакомьтесь с продукцией:

https://climateguard.ru/esp32

climateguard

IDF поставляется в формате самостоятельного программного пакета, в котором содержится компилятор, конфигуратор, система отладки и прошивки.

Его можно подключить в виде плагина к Eclipse или VS Code, либо же использовать самостоятельно в своей любимой IDE.

PlatformIO не рассматриваем. Дело в том, что пакеты там обновляются не регулярно. Ещё и система сборки своя.

Установка на Windows

Для виндусятников возьмём самый простой вариант — ESP IDE. Это “родная” среда разработки, основанная на Eclipse.

Переходим на страницу загрузки, качаем онлайн-инсталлятор. Обратите внимание, в путях установки не должно находиться кириллических символов!

Проходим все шаги установки…

idf-install1

Качаем IDF из сети
idf-install2
Выбираем самую стабильную версию
idf-install3
Выставляем пункты в меню

После установки попадаем в обычный Eclipse. Вся дальнейшая работа с ним описана в видео к статье.

esp-ide

Окно Espressif IDE

Установка IDF вручную

Установку будем производить согласно инструкции от JetBrains. Но она не очень корректная, хочется дополнить её своими комментариями.

Первый шаг — скачивание фреймворка из официального репозитория.
В отличие от оригинальной инструкции, где качается ветка master, мы загрузим один из стабильных релизов.

В ветке master ведётся промежуточная разработка, поэтому можно поймать вот такую чепуху, связанную с версиями пакетов:

idf5.0-error

Баги в версии фреймворка 5.0

На момент написания статьи последняя стабильная версия — 4.4.3.
Проверить это можно в двух местах: в документации и в тегах git репозитория.

Введение в ESP-IDF

В левом меню есть выбор версий
Введение в ESP-IDF
Выбираем версию из тэгов

Способов установки 3:

Первый: скачивание напрямую

mkdir -p ~/esp # Создаём директорию в домашней папке
cd ~/esp # Переместимся в неё 
git clone -b v4.4.3 --recursive https://github.com/espressif/esp-idf.git

В данном случае берём ветку (branch) с именем “v4.4.3” — здесь нужно указать необходимую версию. Параметр --recursive указывает, что нужно загрузить все зависимые репозитории (submodules).

Второй: скачивание zip-архива из релиза репозитория. (Располагается внизу)
Третий: скачивание zip-архива с сервера espressif.

Введение в ESP-IDF

Ссылка на сервер указана в описании релиза

В обоих случаях нужно докачать зависимости. В директории со скачанным архивом:

git submodule update --init --recursive

Установка

Перед установкой фреймворка, нужно установить все недостающие пакеты:

Debian-подобные:

sudo apt-get install -y wget flex bison gperf python3 python3-pip python3-setuptools cmake ninja-build ccache libffi-dev libssl-dev dfu-util libusb-1.0-0

Fedora:

sudo dnf -y update && sudo dnf install -y wget flex bison gperf python3 python3-pip python3-setuptools cmake ninja-build ccache dfu-util libusbx

Теперь время запускать установочный скрипт. Он установит все необходимые пакеты и компиляторы. Переходим в директорию с idf, и запускаем.

cd ~/esp/esp-idf
./install.sh

Теперь мы готовы к работе. В любой директории с проектом можем сделать:

. ~/esp/esp-idf/export.sh
idf.py ...

В данном случае запускаем скрипт export, который прописывает пути PATH для текущей сессии терминала (окна, например).

Просто так этим пользоваться скучно, поэтому давайте переходить к работе с IDE.

Программирование

Программирование в IDF осуществляется с помощью языка C. Но есть также враппер под C++, пока в статусе beta.

Создание проекта

Создавать проект с полного нуля нет смысла. Поэтому возьмём готовый шаблон, который содержит правильную структуру и правильные файлы CMake.

Расположен он по пути: .../esp-idf/examples/get-started/sample_project. Копируем к себе и переименовываем.

Введение в ESP-IDF

Запуск проекта

Работать будем в IDE CLion. Запускаем проект.

Введение в ESP-IDF

Открываем как CMake

После запуска, перед началом работы, IDE ничего не знает о путях IDF. Нам нужно рассказать ей об этом. Сразу после запуска откроется окно конфигурации.

Введение в ESP-IDF

Настраиваем тулчейн…
Введение в ESP-IDF
Прикручиваем файл export

Если Wizard не открылся при запуске проекта, то это всегда можно сделать в настройках.

Введение в ESP-IDF

В настройках всё то же самое

Таким образом мы передали в IDE все переменные и пути к IDF.

Введение в ESP-IDF

Структура проекта

Если видим такую структуру проекта, то сделали всё правильно. Можем начинать работу.

Знакомство с системой сборки

Открываем конфигурацию сборки. Видим много-много таргетов.

Введение в ESP-IDF

По факту нам в работе нужны будут только: app, flash, monitor. Всё остальное — либо не сможем использовать, либо является “системным”.

App — сборка “всухую”, без прошивки.
Flash — сборка и прошивка.
Monitor — система отладки.

Остальное разберём позже.

Вся работа при этом происходит через инструмент Build. Кнопки Run и Debug не используем, так как у нас нет оладчика (есть только программатор). А вся работа происходит через инструменты IDF.

Пробуем запустить Target APP:

Введение в ESP-IDF

Если так, то всё в порядке

Знакомство с API

Для работы всё время будем пользоваться документацией.

Для примера попробуем сконфигурировать пин GPIO. Проходим в раздел Peripherals > GPIO. Линк.

Пин настраивается с помощью такой функции:

esp_err_t gpio_config(const gpio_config_t *pGPIOConfig);

В неё нужно передать экземпляр структуры gpio_config_t.

struct gpio_config_t {
    uint64_t pin_bit_mask;        // Маска назначения ног, объединение через лог. "ИЛИ"
    gpio_mode_t mode;             // Режим пина ­— вход или выход
    gpio_pullup_t pull_up_en;     // Включение подтяжки на VCC
    gpio_pulldown_t pull_down_en; // Включение подтяжки на GND
    gpio_int_type_t intr_type;    // Тип входного прерывания
};

Соберём всё вместе, настроим ножку отладочной платы на выход:

#include "driver/gpio.h"

void app_main(void){
    gpio_config_t gpioConfig = {
            .mode = GPIO_MODE_OUTPUT,
            .pin_bit_mask = GPIO_SEL_2,
    };
    gpio_config(&gpioConfig);
}

Особенности RTOS

Программный пакет ESP IDF построен на системе FreeRTOS. Её применение обусловлено наличием двух ядер в чипе.
В любом месте программы мы не можем глобально затормозить систему, как например вызовом HAL_Delay в STM32.
Для этого применяем задержку из API RTOS.

vTaskDelay(1000 / portTICK_PERIOD_MS);   // Задержка в 1000 миллисекунд

Значение делим на portTICK_PERIOD_MS по той причине, что метод vTaskDelay отсчитывает задержку не в миллисекундах, а в тиках операционной системы, которые могут иметь и другую частоту. Для понимания обращайтесь к концепции RTOS.

Не забываем добавить хэдеры для RTOS и для задержек!

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

Можем обернуть всё в удобный define:

#define delay(x) vTaskDelay((x) / portTICK_PERIOD_MS)

Обернём всё в цикл while. В итоге получится:

while (1){
        gpio_set_level(GPIO_NUM_2, 0);
        delay(1000);
        gpio_set_level(GPIO_NUM_2, 1);
        delay(1000);
}

Прошиваемся через Flash, смотрим на результат. Диодик на плате должен мигать. Для своей отладки укажите свой пин, разберётесь. =)

Разрешения для Linux

В Linux присутствуют некоторые политики безопасности, которые запрещают просто так получить доступ к последовательному порту. Поэтому прошить чип просто так не сможем.
Открываем терминал и вписываем:

sudo usermod -aG dialout $USER
sudo newgrp dialout

После этого нужно перезагрузиться, и всё должно работать. Обычного Log Out недостаточно.

Система сборки CMake

В больших проектах принято делить проект на отдельные файлы. У нас есть прекрасный CMake, в него прописываются зависимости сборки.

CMake файлы, к которым у нас есть доступ — фронтенд к внутренней системе CMake у IDF.
Зависимости в ней прописываются через свои константы, они описаны в документации.

.c файлы добавляются через SRCS.
Директории, где лежат .h файлы — через INCLUDE_DIRS.

Обычно я создаю подобную структуру:

Введение в ESP-IDF

Создаём папку Libs, туда раскладываем по папкам пользовательские файлы.

В main/CMakeLists.txt прописываем:

Введение в ESP-IDF

Указываем директории, прикручиваем .c файлы.

В gpio_user.h:

#ifndef MAIN_GPIO_USER_H
#define MAIN_GPIO_USER_H

void gpio_user(void);

#endif //MAIN_GPIO_USER_H

В gpio_user.c:

#include "gpio_user.h"
#include "driver/gpio.h"
#include "hal/gpio_types.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define delay(x) vTaskDelay((x) / portTICK_PERIOD_MS)

void gpio_user(void){
    gpio_config_t gpioConfig = {
            .mode = GPIO_MODE_OUTPUT,
            .pin_bit_mask = GPIO_SEL_2,
    };
    gpio_config(&gpioConfig);
    while (1){
        gpio_set_level(GPIO_NUM_2, 0);
        delay(1000);
        gpio_set_level(GPIO_NUM_2, 1);
        delay(1000);
    }
}

Не забываем вызвать нашу функцию в главном методе. Прошиваемся и любуемся на результат.

Отладка

В самом базовом варианте отладка ESP32 осуществляется с помощью последовательного порта, как и Arduino.

Для этого нужно подключить хэдер:

Данные в последовательный порт можно отправить с помощью обыкновенного printf.
Но, мы воспользуемся функциями библиотечки, которая является по сути над обёрткой над ним.

Методы библиотеки:

ESP_LOGE(tag, format, ...)  // Сообщение уровня Error
ESP_LOGW(tag, format, ...)  // Сообщение уровня Warning
ESP_LOGI(tag, format, ...)  // Сообщение уровня Info
ESP_LOGD(tag, format, ...)  // Сообщение уровня Debug
ESP_LOGV(tag, format, ...)  // Сообщение уровня Verbose

В аргументах мы видим некоторый tag. С помощью него сообщения маркируются в консоли. Это удобно для отладки большой программы, когда есть много библиотек, много файлов, много зон ответственности.

Прошьём тестовый код и посмотрим, как это выглядит в консоли. Для этого нужно запускать сборку с таргетом monitor:

Введение в ESP-IDF

Видим, что сообщения красятся в свои цвета. Видим разные теги. Также видим, что Debug и Verbose не вывелись. Это связано с уровнями логирования. Всего их 5 — в соответствии с форматами отладочных сообщений.

Они выставляются на разных уровнях программы: глобально для всей прошивки, локально для файла, локально для тега. Это нужно, чтобы например спрятать сообщения от конкретных компонентов в консоли.

Для всей прошивки уровень устанавливается в menuconfig.

Для конкретного файла ­— перед объявлением библиотеки нужно объявить макрос:

#define LOG_LOCAL_LEVEL ESP_LOG_WARN
#include "esp_log.h"

Этих уровней маскировки может быть 6, все они описаны в документации:

ESP_LOG_NONE    // Блокируются все сообщения
ESP_LOG_ERROR   // Выводится только уровень Error
ESP_LOG_WARN    // Выводится Error, Warning
ESP_LOG_INFO    // Выводится Info, Error, Warning
ESP_LOG_DEBUG   // Выводится Debug, Info, ... 
ESP_LOG_VERBOSE // Выводится Vebose, Debug, ...

Тут есть небольшой нюанс, как правило уровень выше INFO мы выставить не можем, так заложено по стандарту в menuconfig. Но это сейчас нам не столь интересно, можно изучить самостоятельно. Лучше посмотрим, как уровни отладки влияют на теги.

Для тега есть подобная конструкция:

esp_log_level_set("Some-TAG", ESP_LOG_VERBOSE);
esp_log_level_set(TAG, ESP_LOG_ERROR);

Загрузим подобный пример:

static const char *TAG = "LED1";
esp_log_level_set("LED", ESP_LOG_INFO); // Можно вызывать тег вот так
esp_log_level_set(TAG, ESP_LOG_ERROR);  // А можно и вот так

int i = 0;
int j = 0;
while (1) {
   ESP_LOGI("LED", "%d", i++);    // "Контрольный" info для тега LED
   ESP_LOGI(TAG, "%d", j += 10);  // info для тега LED1 - его не должны увидеть
   ESP_LOGE(TAG, "%d", j += 2);   // error для тега LED1 - его должны увидеть
   delay(1000);
}

В консоли увидим что-то такое:

Введение в ESP-IDF

Из этого можем сделать вывод, что строка INFO для LED1 всё-таки вызывается, но по факту в консоли прячется.

Важно ещё понимать: monitor — таргет блокирующий. Он не остановится пока мы сами того не попросим. Прошивка не начнётся автоматически. Поэтому не забываем останавливать сессию отладки!

Введение в ESP-IDF

Вот сюда тык

Конфигурация чипа

Вся конфигурация чипа происходит через menuconfig. Это и система сборки, и система тактирования, и включение/отключение периферии, и программные настройки (в т.ч. загрузчика).

Просто так запустить этот таргет мы не можем. В CLion консоль сборки односторонняя, т.е. никакое управления мы туда передать не сможем.

Введение в ESP-IDF

При запуске получим вот такую ерунду

Поэтому, порядок действий такой:
Открываем терминал, переходим в директорию с проектом. Ещё проще сделать это из окна IDE — оно сразу откроет нужную папку.

Введение в ESP-IDF

Вспоминаем, где лежит esp-idf и прописываем:

Введение в ESP-IDF

Получится что-то вроде

Теперь запускаем тулзу menuconfig:

Нас встретит вот такое окно, думаю, пояснять тут ничего не нужно, всё предельно интуитивно. Подробнее, конкретно под наше применение, рассмотрим как-нибудь потом.

Введение в ESP-IDF

Вывод

ESP32 — весьма интересная для разработки платформа. А ESP-IDF, нативный для разработки фреймворк, оказывается не сложнее Arduino, но однозначно эффективней.

Я всегда топлю за нативные фреймворки. Надеюсь, эта статья помогла вам в его обуздании.

Мы и далее будем изучать ESP-IDF в рамках блога. Чтобы материалы выходили чаще, можно поддержать проект. Спасибо!

Ну, и как обычно, удачи Вам в освоении нашего нелёгкого ремесла!

  • Eset nod32 antivirus baza noviy skachat besplatno windows 10
  • Etcher скачать для windows торрент
  • Esd версия windows 10 что это
  • Eso программа для windows 10
  • Etcher скачать для windows на русском