neulab/tldr huggingface dataset:
Olimex
┌──────────────────────────┬──────────────────┬──────────┬───────────────┬───────────┬───────┬───────┐
│Name                      │ Platform         │ Debug    │ MCU           │ Frequency │ Flash │ RAM   │
├──────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_olimex_e407 │ platform_ststm32 │ External │ STM32F407ZGT6 │ 168MHz    │ 1MB   │ 128KB │
├──────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_olimex_h407 │ platform_ststm32 │ External │ STM32F407ZGT6 │ 168MHz    │ 1MB   │ 128KB │
└──────────────────────────┴──────────────────┴──────────┴───────────────┴───────────┴───────┴───────┘
Piconomix
┌────────────────────────────────┬──────────────────┬──────────┬─────────────┬───────────┬───────┬──────┐
│Name                            │ Platform         │ Debug    │ MCU         │ Frequency │ Flash │ RAM  │
├────────────────────────────────┼──────────────────┼──────────┼─────────────┼───────────┼───────┼──────┤
│board_ststm32_piconomix_px_her0 │ platform_ststm32 │ External │ STM32L072RB │ 32MHz     │ 128KB │ 20KB │
└────────────────────────────────┴──────────────────┴──────────┴─────────────┴───────────┴───────┴──────┘
RushUp
┌────────────────────────┬──────────────────┬──────────┬───────────────┬───────────┬───────┬──────┐
│Name                    │ Platform         │ Debug    │ MCU           │ Frequency │ Flash │ RAM  │
├────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼──────┤
│board_ststm32_cloud_jam │ platform_ststm32 │ On-board │ STM32F401RET6 │ 84MHz     │ 512KB │ 96KB │
└────────────────────────┴──────────────────┴──────────┴───────────────┴───────────┴───────┴──────┘
ESP8266 Non-OS SDK Configuration projectconf_env_framework = esp8266-nonos-sdk
The non-OS SDK provides a set of application programming interfaces (APIs) for core ESP8266 functionalities such as data reception/transmission over Wi-Fi, TCP/IP stack functions, hardware interface functions and basic system management functions.
Examples • ESP8266 Non-OS SDK for Espressif 8266
Platforms ┌───────────────────────┬─────────────────────────────┐ │Name                   │ Description                 │ └───────────────────────┴─────────────────────────────┘
│platform_espressif8266 │ Espressif Systems is a      │ │                       │ privately held fabless      │ │                       │ semiconductor company. They │ │                       │ provide wireless            │ │                       │ communications and Wi-Fi    │ │                       │ chips which are widely used │ │                       │ in mobile devices and the   │ │                       │ Internet of Things          │ │                       │ applications.               │ └───────────────────────┴─────────────────────────────┘
4D Systems
┌────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                        │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_gen4iod │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 512KB │ 80KB │
└────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
Adafruit
┌───────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                       │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├───────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_huzzah │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└───────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
Doit
┌────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                            │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espmxdevkit │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espduino    │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
DycodeX
┌─────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                         │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├─────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espectro │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└─────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
ESPert
┌─────────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                                 │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├─────────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espresso_lite_v1 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├─────────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espresso_lite_v2 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└─────────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
ESPino
┌───────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                       │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├───────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_espino │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└───────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
Espressif
┌─────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                             │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp_wroom_02 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 2MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp12e       │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp01_1m     │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp01        │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 512KB │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp07        │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_esp8285      │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_phoenix_v1   │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_phoenix_v2   │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_wifinfo      │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
└─────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
Heltec
┌──────────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                                  │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├──────────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_heltec_wifi_kit_8 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└──────────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
ITEAD
┌─────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                             │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_sonoff_basic │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_sonoff_s20   │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_sonoff_sv    │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_sonoff_th    │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 1MB   │ 80KB │
└─────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
NodeMCU
┌──────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                          │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├──────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_nodemcu   │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├──────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_nodemcuv2 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└──────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
WEMOS
┌────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                            │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_d1          │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_d1_mini     │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
├────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_d1_mini_pro │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 16MB  │ 80KB │
└────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
XinaBox
┌─────────────────────────────────┬────────────────────────┬───────┬─────────┬───────────┬───────┬──────┐
│Name                             │ Platform               │ Debug │ MCU     │ Frequency │ Flash │ RAM  │
├─────────────────────────────────┼────────────────────────┼───────┼─────────┼───────────┼───────┼──────┤
│board_espressif8266_xinabox_cw01 │ platform_espressif8266 │ No    │ ESP8266 │ 80MHz     │ 4MB   │ 80KB │
└─────────────────────────────────┴────────────────────────┴───────┴─────────┴───────────┴───────┴──────┘
ESP-IDF Configuration projectconf_env_framework = espidf
Espressif IoT Development Framework. Official development framework for ESP32.
Tutorials • tutorial_espressif32_espidf_debugging_unit_testing_analysis
Configuration NOTE: Starting with ESP-IDF v4.0, a CMake-based build system is used. Different configuration steps are required for ESP-IDF v3.x due to a legacy build system based on GNU Make.
• Configuration for 4.0
• Configuration for 3.0, 3.1, 3.2, 3.3
Each release of platform_espressif32 platform uses a specific version of ESP-IDF.  The latest version of the platform only supports the latest stable version of the framework.
WARNING: ESP-IDF v4.0 projects are not backwards-compatible with ESP-IDF v3.x projects in terms of project configuration process.
Configuration for 4.0 • Project Structure
• ESP-IDF components
• ULP coprocessor programming
• Limitations
The general project configuration (default optimization level, bootloader configuration partition tables, etc) is set in a single file called sdkconfig in the root folder of the project. This configuration file can be modified via a special target called menuconfig (PlatformIO v4.3.0 greater is required):
platformio run -t menuconfig
WARNING: ESP-IDF requires some extra tools to be installed in your system in order to build firmware for supported chips. Most of these tools are available in PlatformIO ecosystem as standalone packages, but in order to use configuration tool called menuconfig several additional packages need to be installed on Linux-based systems:
libncurses5-dev flex bison
More details about required packages can be found in the official ESP-IDF documentation - Standard Setup of Toolchain for Linux.
Project Structure The ESP-IDF framework requires an unusual project structure because most of the framework configuration is performed by the native for the ESP-IDF build system called CMake.
A typical PlatformIO project for the ESP-IDF framework must have the following structure:
project_dir ├── include ├── src │    ├── CMakeLists.txt │    └── main.c ├── CMakeLists.txt └── platformio.ini
TIP: It's also possible to use the default ESP-IDF project structure with main folder.  To specify main as the folder with source files use projectconf_pio_src_dir option, for example:
[platformio] src_dir = main
[env:esp32dev] platform = espressif32 framework = espidf board = esp32dev
Besides the files related to PlatformIO project, there are several additional ESP-IDF-specific files: the main CMakeLists.txt, project-specific CMakeLists.txt in projectconf_pio_src_dir and optional default configuration file sdkconfig.defaults.  CMakeLists.txt files enable features supported by the ESP-IDF's build system, e.g.  ULP configuration, adding extra components, etc. A typical CMakeLists.txt file in the root folder has the following content:
# The following lines of boilerplate have to be in your project's CMakeLists # in this exact order for cmake to work correctly cmake_minimum_required(VERSION 3.16.0)
include($ENV{IDF_PATH}/tools/cmake/project.cmake) project(project-name)
The second CMakeLists.txt in projectconf_pio_src_dir is responsible for controlling the build process of the component and its integration into the overall project. The minimal component CMakeLists.txt file simply registers the component to the build system using idf_component_register:
idf_component_register(SRCS "foo.c" "bar.c")
The files specified using idf_component_register are used ONLY for generating build configurations, but it's highly recommended to specify all application source files in order to keep the project compatible with the usual ESP-IDF workflow.
WARNING: By default PlatformIO expects source files to be located in the src folder. At the same time, the default location for source files within the ESP-IDF build system is a special folder with the name main. Renaming the main component may require users to manually specify additional dependencies:
idf_component_register(SRCS "main.c" REQUIRES idf::mbedtls)
More details in the official ESP-IDF documentation - Renaming main component.
Due to the current limitations of CMake file-based API, there is no way of generating build configuration for source files written in various programming languages if they are not specified in idf_component_register command. If your project contains libraries written in languages that differ from the language used for the main application you need to create an empty file with the desired extension (e.g. *.cpp for C++) in order to force CMake generate build configuration for this language.
NOTE: Build configuration generated for source files specified in idf_component_register is also used as the base build environment for project sources (including libraries).
ESP-IDF components ESP-IDF modules as modular pieces of standalone code might be useful for structuring reusable code or including third party components that aren’t part of ESP-IDF.
These components contain either a single CMakeLists.txt file which controls the build process of the component and its integration into the overall project. An optional Kconfig file defines the component configuration options that can be set via menuconfig. Some components may also include Kconfig.projbuild and project_include.cmake files, which are special files for overriding parts of the project. All valid components will be compiled as static libraries and linked to the final firmware. There are two possible ways of adding extra components to PlatformIO project:
• By adding a new component to an optional folder called components in the root of your project. This folder will be automatically scanned for valid components.
• Using EXTRA_COMPONENT_DIRS option in the root CMakeLists.txt file. This option represents a list of extra directories to search for components.
An example of specifying esp-aws-iot as an extra component:
# The following lines of boilerplate have to be in your project's CMakeLists # in this exact order for cmake to work correctly cmake_minimum_required(VERSION 3.16)
include($ENV{IDF_PATH}/tools/cmake/project.cmake) list(APPEND EXTRA_COMPONENT_DIRS esp-aws-iot) project(subscribe_publish)
WARNING: Since projectconf_pio_src_dir is also passed to CMake as an extra component, you should only append to EXTRA_COMPONENT_DIRS variable in order not to override the default package.
Since the build may not work correctly if the full path to sources is greater than 250 characters (see CMAKE_OBJECT_PATH_MAX) it might be a good idea to keep modules close to the project files.
ULP coprocessor programming If you want to take measurements using ADC, internal temperature sensor or external I2C sensors, while the main processors are in deep sleep mode you need to use ULP coprocessor. At the moment ULP can be used only with the ESP-IDF.
All ULP code, usually written in assembly in files with .S extension, must be placed into a separate directory with the name ulp in the root folder of your project. So your project structure should look like this:
project_dir ├── include ├── src │    ├── CMakeLists.txt │    └── main.c ├── ulp │    └── ulp_code.S ├── CMakeLists.txt └── platformio.ini
Since PlatformIO uses the code model generated by CMake it's mandatory to specify ULP source files in CMakeLists.txt as well. An example of typical CMakeLists.txt for ULP:
idf_component_register(SRCS "ulp_adc_example_main.c") # # ULP support additions to component CMakeLists.txt. # # 1. The ULP app name must be "ulp_main" set(ulp_app_name ulp_main) # # 2. Specify all assembly source files. #    Paths are relative because ULP files are placed into a special directory "ulp" #    in the root of the project set(ulp_s_sources "../ulp/adc.S") # # 3. List all the component source files which include automatically #    generated ULP export file, ${ulp_app_name}.h: set(ulp_exp_dep_srcs "ulp_adc_example_main.c") # # 4. Call function to build ULP binary and embed in project using the argument #    values above. ulp_embed_binary(${ulp_app_name} ${ulp_s_sources} ${ulp_exp_dep_srcs})
See full examples with ULP coprocessor programming:
• https://github.com/platformio/platform-espressif32/tree/develop/examples/espidf-ulp-adc
• https://github.com/platformio/platform-espressif32/tree/develop/examples/espidf-ulp-pulse
More details are located in the official ESP-IDF documentation - ULP coprocessor programming.
Limitations At the moment several limitations are present:
• No whitespace characters allowed in project paths.
• The src_filter option cannot be used.
Configuration for 3.0, 3.1, 3.2, 3.3 Support for ESP-IDF v3.x is considered obsolete and is not available in the latest platform releases. Please check the platform release notes to figure out what version of the platform should be installed to use required ESP-IDF version, for example:
[env:esp32dev] ; v1.10.0 is the last version that supports ESP-IDF v3.3 platform = espressif32@1.10.0 framework = espidf board = esp32dev
Project Structure Due to limited support of GNU Make build system used in ESP-IDF v3.x, the project configuration depends on a pregenerated file sdkconfig.h which contains a list of macro definitions CONFIG_*. These definitions describe project settings that will be used for preparing a proper build environment. You can use the default sdkconfig.h shipped with the platform or generate a custom one using native ESP-IDF build environment.
A typical PlatformIO project for ESP-IDF v3.x must have the following structure:
project_dir ├── include ├── lib │   └── README ├── test ├── src │    ├── sdkconfig.h │    └── main.c └── platformio.ini
Enable C++ exceptions to enable C++ exceptions for ESP-IDF add -D PIO_FRAMEWORK_ESP_IDF_ENABLE_EXCEPTIONS to projectconf_build_flags of projectconf.
See project example with enabled exceptions.
ULP coprocessor programming To use ULP in your project you need to make sure that it's enabled in the sdkconfig.h configuration file. The following two lines must be added:
#define CONFIG_ULP_COPROC_ENABLED 1 #define CONFIG_ULP_COPROC_RESERVE_MEM 1024
Usually CONFIG_ULP_COPROC_RESERVE_MEM is already defined in the default sdkconfig.h with value 0. You can modify this value to meet your requirements.
All ULP code, usually written in assembly in files with .S extension, must be placed into a separate directory with the name ulp in the root folder of your project.  So your project structure should look like this:
project_dir ├── include ├── lib │   └── README ├── test ├── src │    ├── main.c │    └── sdkconfig.h ├── ulp │    └── ulp_code.S └── platformio.ini
See full examples with ULP coprocessor programming for ESP-IDF v3.x:
• https://github.com/platformio/platform-espressif32/tree/v1.10.0/examples/espidf-ulp-adc
• https://github.com/platformio/platform-espressif32/tree/v1.10.0/examples/espidf-ulp-pulse
┌─────────────────────────────────┬──────────────────────┬───────┬───────────┬───────┬───────┐
│Name                             │ Platform             │ MCU   │ Frequency │ Flash │ RAM   │
├─────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_esp-wrover-kit │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└─────────────────────────────────┴──────────────────────┴───────┴───────────┴───────┴───────┘
┌──────────────────────────────────────────────────┬──────────────────────┬───────┬───────────┬───────┬────────┐
│Name                                              │ Platform             │ MCU   │ Frequency │ Flash │ RAM    │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_esp32cam                        │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_az-delivery-devkit-v4           │ platform_espressif32 │ ESP32 │ 240MHz    │ 16MB  │ 520KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_featheresp32                    │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_d-duino-32                      │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_esp32doit-devkit-v1             │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_pocket_32                       │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_fm-devkit                       │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
├──────────────────────────────────────────────────┼──────────────────────┼───────┼───────────┼───────┼────────┤
│board_espressif32_esp32vn-iot-uno                 │ platform_espressif32 │ ESP32 │ 240MHz    │ 4MB   │ 320KB  │
└──────────────────────────────────────────────────┴──────────────────────┴───────┴───────────┴───────┴────────┘
Examples • ESP-IDF for Espressif 32
Platforms ┌─────────────────────┬─────────────────────────────┐ │Name                 │ Description                 │ ├─────────────────────┼─────────────────────────────┤ │platform_espressif32 │ Espressif Systems is a      │ │                     │ privately held fabless      │ │                     │ semiconductor company. They │ │                     │ provide wireless            │ │                     │ communications and Wi-Fi    │ │                     │ chips which are widely used │ │                     │ in mobile devices and the   │ │                     │ Internet of Things          │ │                     │ applications.               │ └─────────────────────┴─────────────────────────────┘
AZ-Delivery
┌────────────────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                                    │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├────────────────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_az-delivery-devkit-v4 │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 16MB  │ 520KB │
└────────────────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Adafruit
┌───────────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                           │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├───────────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_featheresp32 │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└───────────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
Aiyarafun
┌──────────────────────────┬──────────────────────┬──────────┬───────┬───────────┬───────┬───────┐
│Name                      │ Platform             │ Debug    │ MCU   │ Frequency │ Flash │ RAM   │
├──────────────────────────┼──────────────────────┼──────────┼───────┼───────────┼───────┼───────┤
│board_espressif32_node32s │ platform_espressif32 │ External │ ESP32 │ 240MHz    │ 4MB   │ 320KB │
└──────────────────────────┴──────────────────────┴──────────┴───────┴───────────┴───────┴───────┘
┌───────────────────────────────────────┬──────────────────────┬──────┬───────────┬───────┬─────┐
│Name                                   │ Platform             │ MCU  │ Frequency │ Flash │ RAM │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-bit      │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-bit-mic  │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-go       │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-one-dock │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maixduino     │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-MF1           │ platform_kendryte210 │ K210 │ 400MHz    │ 16MB  │ 6MB │
└───────────────────────────────────────┴──────────────────────┴──────┴───────────┴───────┴─────┘
Examples • Kendryte FreeRTOS SDK for Kendryte K210
Platforms ┌─────────────────────┬───────────────────────────┐ │Name                 │ Description               │ ├─────────────────────┼───────────────────────────┤ │platform_kendryte210 │ Kendryte K210 is an AI    │ │                     │ capable RISCV64 dual core │ │                     │ SoC.                      │ └─────────────────────┴───────────────────────────┘
Sipeed
┌───────────────────────────────────────┬──────────────────────┬──────────┬──────┬───────────┬───────┬─────┐
│Name                                   │ Platform             │ Debug    │ MCU  │ Frequency │ Flash │ RAM │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-bit      │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-bit-mic  │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-go       │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maix-one-dock │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-maixduino     │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
├───────────────────────────────────────┼──────────────────────┼──────────┼──────┼───────────┼───────┼─────┤
│board_kendryte210_sipeed-MF1           │ platform_kendryte210 │ External │ K210 │ 400MHz    │ 16MB  │ 6MB │
└───────────────────────────────────────┴──────────────────────┴──────────┴──────┴───────────┴───────┴─────┘
Kendryte Standalone SDK Configuration projectconf_env_framework = kendryte-standalone-sdk
Kendryte Standalone SDK without OS support
Examples • Kendryte Standalone SDK for Kendryte K210
libOpenCM3 Configuration projectconf_env_framework = libopencm3
The libOpenCM3 framework aims to create a free/libre/open-source firmware library for various ARM Cortex-M0(+)/M3/M4 microcontrollers, including ST STM32, Ti Tiva and Stellaris, NXP LPC 11xx, 13xx, 15xx, 17xx parts, Atmel SAM3, Energy Micro EFM32 and others.
┌─────────────────────────────┬──────────────────┬─────────────────┬───────────┬───────┬───────┐
│Name                         │ Platform         │ MCU             │ Frequency │ Flash │ RAM   │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_ststm32_nucleo_f103rb  │ platform_ststm32 │ STM32F103RBT6   │ 72MHz     │ 128KB │ 20KB  │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_f303vc   │ platform_ststm32 │ STM32F303VCT6   │ 72MHz     │ 256KB │ 48KB  │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_f407vg   │ platform_ststm32 │ STM32F407VGT6   │ 168MHz    │ 1MB   │ 128KB │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_l152rb   │ platform_ststm32 │ STM32L152RBT6   │ 32MHz     │ 128KB │ 16KB  │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_titiva_lplm4f120h5qr   │ platform_titiva  │ LPLM4F120H5QR   │ 80MHz     │ 256KB │ 32KB  │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_titiva_lptm4c1230c3pm  │ platform_titiva  │ LPTM4C1230C3PM  │ 80MHz     │ 256KB │ 32KB  │
├─────────────────────────────┼──────────────────┼─────────────────┼───────────┼───────┼───────┤
│board_titiva_lptm4c1294ncpdt │ platform_titiva  │ LPTM4C1294NCPDT │ 120MHz    │ 1MB   │ 256KB │
└─────────────────────────────┴──────────────────┴─────────────────┴───────────┴───────┴───────┘
│board_ststm32_genericSTM32F103ZE   │ platform_ststm32 │ STM32F103ZET6 │ 72MHz     │ 512KB │ 64KB  │
└───────────────────────────────────┴──────────────────┴───────────────┴───────────┴───────┴───────┘
Examples • libOpenCM3 for ST STM32
• libOpenCM3 for TI TIVA
Platforms ┌─────────────────┬─────────────────────────────┐ │Name             │ Description                 │ ├─────────────────┼─────────────────────────────┤ │platform_ststm32 │ The STM32 family of 32-bit  │ │                 │ Flash MCUs based on the ARM │ │                 │ Cortex-M processor is       │ │                 │ designed to offer new       │ │                 │ degrees of freedom to MCU   │ │                 │ users. It offers a 32-bit   │ │                 │ product range that combines │ │                 │ very high performance,      │ │                 │ real-time capabilities,     │ │                 │ digital signal processing,  │ │                 │ and low-power, low-voltage  │ │                 │ operation, while            │ │                 │ maintaining full            │ │                 │ integration and ease of     │ │                 │ development.                │ ├─────────────────┼─────────────────────────────┤ │platform_titiva  │ Texas Instruments TM4C12x   │ │                 │ MCUs offer the industrys    │ │                 │ most popular ARM Cortex-M4  │ │                 │ core with scalable memory   │ │                 │ and package options,        │ │                 │ unparalleled connectivity   │ │                 │ peripherals, advanced       │ │                 │ application functions,      │ │                 │ industry-leading analog     │ │                 │ integration, and extensive  │ │                 │ software solutions.         │ └─────────────────┴─────────────────────────────┘
Olimex
┌────────────────────────┬──────────────────┬──────────┬───────────────┬───────────┬───────┬──────┐
│Name                    │ Platform         │ Debug    │ MCU           │ Frequency │ Flash │ RAM  │
├────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼──────┤
│board_ststm32_olimexino │ platform_ststm32 │ External │ STM32F103RBT6 │ 72MHz     │ 128KB │ 20KB │
└────────────────────────┴──────────────────┴──────────┴───────────────┴───────────┴───────┴──────┘
ST
┌────────────────────────────┬──────────────────┬──────────┬───────────────┬───────────┬───────┬───────┐
│Name                        │ Platform         │ Debug    │ MCU           │ Frequency │ Flash │ RAM   │
├────────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_nucleo_f103rb │ platform_ststm32 │ On-board │ STM32F103RBT6 │ 72MHz     │ 128KB │ 20KB  │
├────────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_f303vc  │ platform_ststm32 │ On-board │ STM32F303VCT6 │ 72MHz     │ 256KB │ 48KB  │
├────────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_f407vg  │ platform_ststm32 │ On-board │ STM32F407VGT6 │ 168MHz    │ 1MB   │ 128KB │
├────────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_disco_l152rb  │ platform_ststm32 │ On-board │ STM32L152RBT6 │ 32MHz     │ 128KB │ 16KB  │
└────────────────────────────┴──────────────────┴──────────┴───────────────┴───────────┴───────┴───────┘
TI
┌─────────────────────────────┬─────────────────┬──────────┬─────────────────┬───────────┬───────┬───────┐
│Name                         │ Platform        │ Debug    │ MCU             │ Frequency │ Flash │ RAM   │
├─────────────────────────────┼─────────────────┼──────────┼─────────────────┼───────────┼───────┼───────┤
│board_titiva_lplm4f120h5qr   │ platform_titiva │ On-board │ LPLM4F120H5QR   │ 80MHz     │ 256KB │ 32KB  │
├─────────────────────────────┼─────────────────┼──────────┼─────────────────┼───────────┼───────┼───────┤
│board_titiva_lptm4c1230c3pm  │ platform_titiva │ On-board │ LPTM4C1230C3PM  │ 80MHz     │ 256KB │ 32KB  │
└─────────────────────────────┴─────────────────┴──────────┴─────────────────┴───────────┴───────┴───────┘
│board_titiva_lptm4c1294ncpdt │ platform_titiva │ On-board │ LPTM4C1294NCPDT │ 120MHz    │ 1MB   │ 256KB │
└─────────────────────────────┴─────────────────┴──────────┴─────────────────┴───────────┴───────┴───────┘
Mbed Configuration projectconf_env_framework = mbed
The mbed framework The mbed SDK has been designed to provide enough hardware abstraction to be intuitive and concise, yet powerful enough to build complex projects. It is built on the low-level ARM CMSIS APIs, allowing you to code down to the metal if needed. In addition to RTOS, USB and Networking libraries, a cookbook of hundreds of reusable peripheral and module libraries have been built on top of the SDK by the mbed Developer Community.
Configuration • Configuration system
• Mbed lib and Mbed OS 5
• Build profiles
• Ignoring particular components
• Custom Targets
Configuration system PlatformIO allows you to customize mbed OS compile time configuration parameters using mbed_app.json manifest. It should be placed into the root of your project and located on the same level as projectconf.
Configuration is defined using JSON.  Some examples of configuration parameters:
• The sampling period for a data acquisition application.
• The default stack size for a newly created OS thread.
• The receive buffer size of a serial communication library.
• The flash and RAM memory size of a target board.
See more details in the official ARM Mbed OS Configuration System.
A few PlatformIO-ready projects based on ARM mbed OS which use mbed_app.json;
• Freescale Kinetis: mbed-rtos-tls-client
• ST STM32: mbed-rtos-mesh-minimal
Mbed lib and Mbed OS 5 PlatformIO allows compiling projects with or without Mbed OS. By default, project is built without the OS feature. Most of the framework functionality requires the OS to be enabled. To add the OS feature you can use a special macro definition that needs be added to projectconf_build_flags of projectconf:
┌────────────────────────────────┬────────────────────────┐ │Name                            │ Description            │ ├────────────────────────────────┼────────────────────────┤ │PIO_FRAMEWORK_MBED_RTOS_PRESENT │ Build the project with │ │                                │ enabled rtos           │ └────────────────────────────────┴────────────────────────┘
An example of projectconf with enabled rtos
[env:wizwiki_w7500p] platform = wiznet7500 framework = mbed board = wizwiki_w7500p build_flags = -D PIO_FRAMEWORK_MBED_RTOS_PRESENT
Build profiles By default, PlatformIO builds your project using develop profile which provides optimized firmware size with full error information and allows MCU to go to sleep mode. In the case when default build profile is not suitable for your project there two other profiles release and debug that can be enabled using special macro definitions. You can change build profile projectconf_build_flags of projectconf:
┌───────────────────────────┬───────────────────────────┐ │Name                       │ Description               │ ├───────────────────────────┼───────────────────────────┤ │MBED_BUILD_PROFILE_RELEASE │ Release profile (smallest │ │                           │ firmware, minimal error   │ │                           │ info)                     │ ├───────────────────────────┼───────────────────────────┤ │MBED_BUILD_PROFILE_DEBUG   │ Debug profile (largest    │ │                           │ firmware, disabled sleep  │ │                           │ mode)                     │ └───────────────────────────┴───────────────────────────┘
More information about differences between build profiles can be found on the official page ARM Mbed OS Build Profiles.
Ignoring particular components In case you don't need all parts of the framework or you want to reduce the compilation time, you can explicitly exclude folders with redundant sources. For example, to remove cellular, mbedtls and nanostack features from the build process, navigate to projectconf_pio_packages_dir and create a new file framework-mbed/features/.mbedignore with the following contents:
cellular/* mbedtls/* nanostack/*
If you want to exclude the entire folder, simply create .mbedignore file and add only one symbol * to this file.
Custom Targets In case when your board is not officially supported by Mbed you can manually add custom board definitions to your project. First of all, you need to create a special file custom_targets.json in the root folder of your project where you describe your board, for example here is the configuration for NUCLEO-F401RE board:
{ "NUCLEO_F401RE": { "inherits": ["FAMILY_STM32"], "supported_form_factors": ["ARDUINO", "MORPHO"], "core": "Cortex-M4F", "extra_labels_add": ["STM32F4", "STM32F401xE", "STM32F401RE"], "config": { "clock_source": { "help": "Mask value : USE_PLL_HSE_EXTC | USE_PLL_HSE_XTAL (need HW patch) | USE_PLL_HSI", "value": "USE_PLL_HSE_EXTC|USE_PLL_HSI", "macro_name": "CLOCK_SOURCE" } }, "detect_code": ["0720"], "macros_add": ["USB_STM_HAL", "USBHOST_OTHER"], "device_has_add": [ "SERIAL_ASYNCH", "FLASH", "MPU" ], "release_versions": ["2", "5"], "device_name": "STM32F401RE" } }
Secondly, you need to add code specific to your target to the src folder of your project.  Usually, it's a good idea to isolate this code in a separate folder and add the path to this folder to projectconf_build_flags of projectconf:
[env:my_custom_board] platform = nxplpc framework = mbed board = my_custom_board build_flags = -I$PROJECT_SRC_DIR/MY_CUSTOM_BOARD_TARGET
Next, you need to inform PlatformIO that there is a new custom board. To do this, you can create boards directory in the root folder of your project and add a board manifest file with your board name, e.g. my_custom_board.json as described here board_creating
After these steps, your project structure should look like this:
project_dir ├── include ├── boards │    └── my_custom_board.json ├── src │    ├── main.cpp │    └── MY_CUSTOM_BOARD_TARGET │         ├── pinNames.h │         └── pinNames.c ├── custom_targets.json └── platformio.ini
More information about adding custom targets can be found on the official page Adding and configuring targets.
See full examples with a custom board:
• https://github.com/platformio/platform-nxplpc/tree/develop/examples/mbed-custom-target
Examples • Mbed for Atmel SAM
• Mbed for Freescale Kinetis
• Mbed for Maxim 32
• Mbed for Nordic nRF51
• Mbed for Nordic nRF52
• Mbed for NXP i.MX RT
• Mbed for NXP LPC
• Mbed for RISC-V GAP
• Mbed for Silicon Labs EFM32
• Mbed for ST STM32
• Mbed for Teensy
• Mbed for WIZNet W7500
│platform_ststm32          │ The STM32 family of 32-bit  │ │                          │ Flash MCUs based on the ARM │ │                          │ Cortex-M processor is       │ │                          │ designed to offer new       │ │                          │ degrees of freedom to MCU   │ │                          │ users. It offers a 32-bit   │ │                          │ product range that combines │ │                          │ very high performance,      │ │                          │ real-time capabilities,     │ │                          │ digital signal processing,  │ │                          │ and low-power, low-voltage  │ │                          │ operation, while            │ │                          │ maintaining full            │ │                          │ integration and ease of     │ │                          │ development.                │ ├──────────────────────────┼─────────────────────────────┤ │platform_teensy           │ Teensy is a complete        │ │                          │ USB-based microcontroller   │ │                          │ development system, in a    │ │                          │ very small footprint,       │ │                          │ capable of implementing     │ │                          │ many types of projects. All │ │                          │ programming is done via the │ │                          │ USB port. No special        │ │                          │ programmer is needed, only  │ │                          │ a standard USB cable and a  │ │                          │ PC or Macintosh with a USB  │ │                          │ port.                       │ ├──────────────────────────┼─────────────────────────────┤ │platform_wiznet7500       │ The IOP (Internet Offload   │ │                          │ Processor) W7500 is the     │ │                          │ one-chip solution which     │ │                          │ integrates an ARM           │ │                          │ Cortex-M0, 128KB Flash and  │ │                          │ hardwired TCP/IP core for   │ │                          │ various embedded            │ │                          │ application platform        │ │                          │ especially requiring        │ │                          │ Internet of things          │ └──────────────────────────┴─────────────────────────────┘
96Boards
┌──────────────────────────┬──────────────────┬──────────┬───────────────┬───────────┬───────┬───────┐
│Name                      │ Platform         │ Debug    │ MCU           │ Frequency │ Flash │ RAM   │
├──────────────────────────┼──────────────────┼──────────┼───────────────┼───────────┼───────┼───────┤
│board_ststm32_b96b_f446ve │ platform_ststm32 │ On-board │ STM32F446VET6 │ 168MHz    │ 512KB │ 128KB │
└──────────────────────────┴──────────────────┴──────────┴───────────────┴───────────┴───────┴───────┘
AppNearMe
┌───────────────────────────┬─────────────────┬───────┬──────────┬───────────┬───────┬──────┐
│Name                       │ Platform        │ Debug │ MCU      │ Frequency │ Flash │ RAM  │
├───────────────────────────┼─────────────────┼───────┼──────────┼───────────┼───────┼──────┤
│board_nxplpc_micronfcboard │ platform_nxplpc │ No    │ LPC11U34 │ 48MHz     │ 48KB  │ 10KB │
└───────────────────────────┴─────────────────┴───────┴──────────┴───────────┴───────┴──────┘