Platform specification

This is the Arduino platform specification, for use with Arduino development software starting from the Arduino IDE 1.5.x series.

Platforms add support for new boards to the Arduino development software. They are installable either via Boards Manager or manual installation to the hardware folder of Arduino's sketchbook folder (AKA "user directory").
A platform may consist of as little as a single configuration file.

Platform installation directories

If the platforms are installed using the Board Manager the installation directory location will be as follow:

{directories.data}/packages/{VENDOR_NAME}/hardware/{ARCHITECTURE}/{VERSION}/...

• {directories.data}

  is the data directory as specified in the configuration file.

• {VENDOR_NAME}

  is the identifier of the vendor/maintainer of the platform.

• {ARCHITECTURE}

  is the architecture of the CPU used in the platform.

• {VERSION}

  is the platform version.

Alternatively, a platform may be manually installed by the user inside the Sketchbook/user directory as follows:

{directories.user}/hardware/{VENDOR_NAME}/{ARCHITECTURE}/...

• {directories.user}

  is the user directory as specified in the configuration file.

• {VENDOR_NAME}

  is the identifier of the vendor/maintainer of the platform.

• {ARCHITECTURE}

  is the architecture of the CPU used in the platform.

A vendor/maintainer may have multiple supported architectures.

Let's see an example, below we have a bunch of platforms downloaded from three hardware vendors

arduino

adafruit

esp32

1{directories.data}/packages/arduino/hardware/avr/1.8.6/...
2{directories.data}/packages/arduino/hardware/esp32/2.0.18-arduino.5/...
3{directories.data}/packages/arduino/hardware/nrf52/1.4.5/...
4{directories.data}/packages/adafruit/hardware/nrf52/1.6.1/...
5{directories.data}/packages/esp32/hardware/esp32/3.0.7/...

In this example three architectures have been installed from the vendor

arduino

avr

esp32

nrf52

adafruit

esp32

nrf52

esp32

esp32

esp32

If the user manually installed the same platforms, they should have unpacked them in the following directories:

1{directories.user}/hardware/arduino/avr/...
2{directories.user}/hardware/arduino/esp32/...
3{directories.user}/hardware/arduino/nrf52/...
4{directories.user}/hardware/adafruit/nrf52/...
5{directories.user}/hardware/esp32/esp32/...

In this latter case the version must be omitted.

Notes about choosing the architecture name

Architecture values are case sensitive (e.g.

AVR

avr

Platform developers should follow the existing architecture name conventions when creating hardware packages, if you need to differentiate your package use the vendor/maintainer folder name to do so.

The architecture name is used to determine the libraries compatibility and to permit referencing resources from another platform of the same architecture. Use of a non-standard architecture name can have a harmful effect.

Architecture configurations

Each architecture must be configured through a set of configuration files:

• platform.txt contains definitions for the CPU architecture used (compiler, build process parameters, tools used for upload, etc.)
• boards.txt contains definitions for the boards (board name, parameters for building and uploading sketches, etc.)
• programmers.txt contains definitions for external programmers (typically used to burn bootloaders or sketches on a blank CPU/board)

Configuration files format

A configuration file is a list of "key=value" properties. The value of a property can be expressed using the value of another property by putting its name inside brackets "{" "}". For example:

1compiler.path=/tools/g++_arm_none_eabi/bin/
2compiler.c.cmd=arm-none-eabi-gcc
3[....]
4recipe.c.o.pattern={compiler.path}{compiler.c.cmd}

In this example the property recipe.c.o.pattern will be set to /tools/g++_arm_none_eabi/bin/arm-none-eabi-gcc, which is the composition of the properties compiler.path and compiler.c.cmd.

Comments

Lines starting with # are treated as comments and will be ignored.

1# Like in this example
2# --------------------
3# I'm a comment!

Automatic property override for specific OS

We can specify an OS-specific value for a property. For example the following file:

1tools.bossac.cmd=bossac
2tools.bossac.cmd.windows=bossac.exe

will set the property tools.bossac.cmd to the value bossac on Linux and macOS and bossac.exe on Windows. Supported suffixes are

.linux

.windows

.macosx

Global Predefined properties

The following automatically generated properties can be used globally in all configuration files:

• {runtime.platform.path}

  : is the absolute path of the board platform folder (i.e. the folder containing boards.txt) unless

  {runtime.use_core_platform_path_for_runtime_platform_path}

  is set to

  true

  in this case, the value is the absolute path of the referenced core platform.

• {runtime.hardware.path}

  : the absolute path of the hardware folder (i.e. the folder containing the board platform folder)

• {runtime.ide.path}

  : the absolute path of the Arduino IDE or Arduino CLI folder

• {runtime.ide.version}

  : the version number of the Arduino IDE as a number (this uses two digits per version number component, and removes the points and leading zeroes, so Arduino IDE 1.8.3 becomes

  01.08.03

  which becomes

  runtime.ide.version=10803

  ). When using Arduino development software other than the Arduino IDE, this is set to a meaningless version number.

• {ide_version}

  : Compatibility alias for

  {runtime.ide.version}

• {runtime.os}

  : the running OS ("linux", "windows", "macosx")

• {software}

  : set to "ARDUINO"

• {name}

  : platform vendor name

• {_id}

  : board ID of the board being compiled for

• {build.fqbn}

  : the FQBN (fully qualified board name) of the board being compiled for. The FQBN follows the format:

  VENDOR:ARCHITECTURE:BOARD_ID[:MENU_ID=OPTION_ID[,MENU2_ID=OPTION_ID ...]]

• {build.source.path}

  : Path to the sketch being compiled. If the sketch is in an unsaved state, it will the path of its temporary folder.

• {build.library_discovery_phase}

  : set to 1 during library discovery and to 0 during normal build. A macro defined with this property can be used to disable the inclusion of heavyweight headers during discovery to reduce compilation time. This property was added in Arduino IDE 1.8.14/Arduino Builder 1.6.0/Arduino CLI 0.12.0. Note: with the same intent,

  -DARDUINO_LIB_DISCOVERY_PHASE

  was added to

  recipe.preproc.macros

  during library discovery in Arduino Builder 1.5.3/Arduino CLI 0.10.0. That flag was replaced by the more flexible

  {build.library_discovery_phase}

  property.

• {compiler.optimization_flags}

  : see "Sketch debugging configuration" for details

• {extra.time.utc}

  : Unix time (seconds since 1970-01-01T00:00:00Z) according to the machine the build is running on

• {extra.time.local}

  : Unix time with local timezone and DST offset

• {extra.time.zone}

  : local timezone offset without the DST component

• {extra.time.dst}

  : local daylight savings time offset

Compatibility notes:

• Versions before Arduino IDE 1.6.0 only used one digit per version number component in

  {runtime.ide.version}

  (so 1.5.9 was

  159

  , not

  10509

  ).

• {runtime.use_core_platform_path_for_runtime_platform_path}

  support is available from Arduino CLI >=1.0.4.

platform.txt

The platform.txt file contains information about a platform's specific aspects (compilers command line flags, paths, system libraries, etc.).

The following meta-data must be defined:

1name=Arduino AVR Boards
2version=1.5.3

The name will be shown as the Arduino IDE's Board menu section title or the Name field of

arduino-cli core list

Build process

The platform.txt file is used to configure the build process. This is done through a list of recipes. Each recipe is a command line expression that explains how to call the compiler (or other tools) for every build step and which parameter should be passed.

The Arduino development software, before starting the build, determines the list of files to compile. The list is composed of:

• the user's Sketch
• source code in the selected board's Core
• source code in the Libraries used in the sketch

A temporary folder is created to store the build artifacts whose path is available through the global property {build.path}. A property {build.project_name} with the name of the project and a property {build.arch} with the name of the architecture is set as well.

• {build.path}

  : The path to the temporary folder to store build artifacts

• {build.project_name}

  : The project name

• {build.arch}

  : The MCU architecture (avr, sam, etc...)

There are some other {build.xxx} properties available, that are explained in the boards.txt section of this guide.

Security credential properties

Some of them allow specifying trusted security credentials (signing and encryption keys) that can be used by a "secure boot" system:

• build.keys.keychain

  : for the directory containing the keys

• build.keys.sign_key

  : for the signing key

• build.keys.encrypt_key

  : for the encryption key

If any of these properties are defined, the others are required.

These properties can be overwritten respectively with

--keys-keychain

--sign-key

--encrypt-key

Recipes to compile source code

We said that the Arduino development software determines a list of files to compile. Each file can be source code written in C (.c files), C++ (.cpp/.cxx/.cc files) or Assembly (.S files). Every language is compiled using its respective recipe:

• recipe.c.o.pattern

  : for C files (.c)

• recipe.cpp.o.pattern

  : for CPP files (.cpp/.cxx/.cc)

• recipe.S.o.pattern

  : for Assembly files (.S)

(an optional

recipe.cxx.o.pattern

recipe.cc.o.pattern

.cxx

.cc

The recipes can be built concatenating the following automatically generated properties (for each file compiled):

• {includes}

  : the list of include paths in the format "-I/include/path -I/another/path...."

• {source_file}

  : the path to the source file

• {object_file}

  : the path to the output file

For example the following is used for AVR:

1## Compiler global definitions
2compiler.path={runtime.ide.path}/tools/avr/bin/
3compiler.c.cmd=avr-gcc
4compiler.c.flags=-c -g -Os -w -ffunction-sections -fdata-sections -MMD
5
6[......]
7
8## Compile c files
9recipe.c.o.pattern="{compiler.path}{compiler.c.cmd}" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {build.extra_flags} {includes} "{source_file}" -o "{object_file}"

Note that some properties, like {build.mcu} for example, are taken from the boards.txt file which is documented later in this specification.

Recipes to build the core.a archive file

The core of the selected board is compiled as described in the previous paragraph, but the object files obtained from the compile are also archived into a static library named core.a using the recipe.ar.pattern.

The recipe can be built concatenating the following automatically generated properties:

• {object_file}

  : the object file to include in the archive

• {archive_file_path}

  : fully qualified archive file (ex. "/path/to/core.a"). This property was added in Arduino IDE 1.6.6/arduino builder 1.0.0-beta12 as a replacement for

  {build.path}/{archive_file}

  .

• {archive_file}

  : the name of the resulting archive (ex. "core.a")

For example, Arduino provides the following for AVR:

1compiler.ar.cmd=avr-ar
2compiler.ar.flags=rcs
3
4[......]
5
6## Create archives
7recipe.ar.pattern="{compiler.path}{compiler.ar.cmd}" {compiler.ar.flags} "{archive_file_path}" "{object_file}"

Recipes for linking

All the artifacts produced by the previous steps (sketch object files, libraries object files and core.a archive) are linked together using the recipe.c.combine.pattern.

The recipe can be built concatenating the following automatically generated properties:

• {object_files}

  : the list of object files to include in the archive ("file1.o file2.o ....")

• {archive_file_path}

  : fully qualified archive file (ex. "/path/to/core.a"). This property was added in Arduino IDE 1.6.6/arduino builder 1.0.0-beta12 as a replacement for

  {build.path}/{archive_file}

  .

• {archive_file}

  : the name of the core archive file (ex. "core.a")

• {compiler.libraries.ldflags}

  : the linking flags for precompiled libraries, which consist of automatically generated

  -L

  flags for the library path and

  -l

  flags for library files, as well as any custom flags provided via the

  ldflags

  field of library.properties. In order to support precompiled libraries, platform.txt must contain a definition of

  compiler.libraries.ldflags

  , to which any automatically generated flags will be appended. Support for precompiled libraries was added in Arduino IDE 1.8.6/arduino-builder 1.4.0.

For example the following is used for AVR:

1compiler.c.elf.flags=-Os -Wl,--gc-sections
2compiler.c.elf.cmd=avr-gcc
3
4compiler.libraries.ldflags=
5
6[......]
7
8## Combine gc-sections, archives, and objects
9recipe.c.combine.pattern="{compiler.path}{compiler.c.elf.cmd}" {compiler.c.elf.flags} -mmcu={build.mcu} -o "{build.path}/{build.project_name}.elf" {object_files} {compiler.libraries.ldflags} "{archive_file_path}" "-L{build.path}" -lm

Recipes for extraction of executable files and other binary data

An arbitrary number of extra steps can be performed at the end of objects linking. These steps can be used to extract binary data used for upload and they are defined by a set of recipes with the following format:

1recipe.objcopy.FILE_EXTENSION_1.pattern=[.....]
2recipe.objcopy.FILE_EXTENSION_2.pattern=[.....]
3[.....]

FILE_EXTENSION_x

.hex

.eep

1recipe.objcopy.eep.pattern=[.....]
2recipe.objcopy.hex.pattern=[.....]

There are no specific properties set by the Arduino development software here.

A full example for the AVR platform can be:

1## Create eeprom
2recipe.objcopy.eep.pattern="{compiler.path}{compiler.objcopy.cmd}" {compiler.objcopy.eep.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.eep"
3
4## Create hex
5recipe.objcopy.hex.pattern="{compiler.path}{compiler.elf2hex.cmd}" {compiler.elf2hex.flags} "{build.path}/{build.project_name}.elf" "{build.path}/{build.project_name}.hex"

Recipes to compute binary sketch size

At the end of the build the Arduino development software shows the final binary sketch size to the user. The size is calculated using the recipe recipe.size.pattern. The output of the command executed using the recipe is parsed through the regular expressions set in the properties:

• recipe.size.regex: Program storage space used.
• recipe.size.regex.data: Dynamic memory used by global variables.

For AVR we have:

1compiler.size.cmd=avr-size
2[....]
3## Compute size
4recipe.size.pattern="{compiler.path}{compiler.size.cmd}" -A "{build.path}/{build.project_name}.hex"
5recipe.size.regex=^(?:\.text|\.data|\.bootloader)\s+([0-9]+).*
6recipe.size.regex.data=^(?:\.data|\.bss|\.noinit)\s+([0-9]+).*

Two properties can be used to define the total available memory:

• {upload.maximum_size}

  : available program storage space

• {upload.maximum_data_size}

  : available dynamic memory for global variables

If the binary sketch size exceeds the value of these properties, the compilation process fails.

This information is displayed in the console output after compiling a sketch, along with the relative memory usage value:

1Sketch uses 924 bytes (2%) of program storage space. Maximum is 32256 bytes.
2Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for local variables. Maximum is 2048 bytes.

Recipes to compute binary sketch size for more complex systems (since Arduino CLI >=0.21.0)

A platform may provide a tool for the specific purpose to analyze the binaries and compute the sketch size and memory usage statistics. This is especially useful for boards with non-trivial memory layouts where the classic reg-exp based approach is not sufficient.

The command line to run is specified with the recipe recipe.advanced_size.pattern.

The expected output from the tool is a JSON object with the following format:

1{
2  "output": "Your sketch uses 2200 bytes of program memory out of 8192 (27%)\nThe static RAM used is 200 bytes (of 2048 max)",
3  "severity": "info",
4  "sections": [
5    { "name": "text", "size": 2200, "max_size": 8192 },
6    { "name": "data", "size": 200, "max_size": 2048 }
7  ]
8}

The meaning of the fields is the following:

• output

  : is a preformatted text that is displayed as-is in console.

• severity

  : indicates the warning level of the output messages, it must be

  info

  ,

  warning

  or

  error

  . Warnings and errors are displayed in red (or in a different color than normal output). Errors will make the build/upload fail.

• sections

  : is an array containing the memory sections and their usage level. This array is used to report memory usage in a machine-readable format if requested by the user. Each item represents a memory section and may contain the following fields

  • name

    : an identifier for the section

  • size

    : the sketch size for the section

  • max_size

    : the maximum size for the section

When the

severity

error

error

1{
2  "output": "Your sketch uses 12200 bytes of program memory out of 8192 (149%))\nThe static RAM used is 200 bytes (of 2048 max)",
3  "severity": "error",
4  "error": "Sketch is too big!",
5  "sections": [
6    { "name": "text", "size": 12200, "max_size": 8192 },
7    { "name": "data", "size": 200, "max_size": 2048 }
8  ]
9}

This means that the

sections

"severity":"error"

If both recipe.size.pattern and recipe.advanced_size.pattern are present then recipe.advanced_size.pattern will be used. Since the recipe.advanced_size.pattern feature is available starting from Arduino CLI>=0.21.0, to maximize backward compatibility, we recommend to provide both recipe.size.pattern and recipe.advanced_size.pattern if possible, so the old versions of the IDE/CLI will continue to work (even with a less detailed memory usage report).

Recipes to export compiled binary

When you do a Sketch > Export compiled Binary in the Arduino IDE, the compiled binary is copied from the build folder to the sketch folder. Two binaries are copied; the standard binary, and a binary that has been merged with the bootloader file (identified by the

.with_bootloader

Two recipes affect how Export compiled Binary works:

• recipe.output.tmp_file: Defines the binary's filename in the build folder.
• recipe.output.save_file: Defines the filename to use when copying the binary file to the sketch folder.

As with other processes, there are pre and post build hooks for Export compiled Binary.

The recipe.hooks.savehex.presavehex.NUMBER.pattern and recipe.hooks.savehex.postsavehex.NUMBER.pattern hooks (but not recipe.output.tmp_file and recipe.output.save_file) can be built concatenating the following automatically generated properties:

• {sketch_path}

  : the absolute path of the sketch folder

Recipe to run the preprocessor

For detecting which libraries to include in the build, and for generating function prototypes, (just) the preprocessor is run. For this, the recipe.preproc.macros recipe exists. This recipe must run the preprocessor on a given source file, writing the preprocessed output to a given output file, and generate (only) preprocessor errors on standard output. This preprocessor run should happen with the same defines and other preprocessor-influencing-options as for normally compiling the source files.

The recipes can be built concatenating other automatically generated properties (for each file compiled):

• {includes}

  : the list of include paths in the format "-I/include/path -I/another/path...."

• {source_file}

  : the path to the source file

• {preprocessed_file_path}

  : the path to the output file

For example the following is used for AVR:

1preproc.macros.flags=-w -x c++ -E -CC
2recipe.preproc.macros="{compiler.path}{compiler.cpp.cmd}" {compiler.cpp.flags} {preproc.macros.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.cpp.extra_flags} {build.extra_flags} {includes} "{source_file}" -o "{preprocessed_file_path}"

Note that the

{preprocessed_file_path}

/dev/null

-MMD

/dev/null.d

{compiler.cpp.flags}

-MMD

-MMD

recipe.preproc.macros

If recipe.preproc.macros is not defined, it is automatically generated from recipe.cpp.o.pattern.

Note that older Arduino IDE versions used the recipe.preproc.includes recipe (which is not documented here) to determine includes. Since Arduino IDE 1.6.7 (arduino-builder 1.2.0) this was changed and recipe.preproc.includes is no longer used.

Pre and post build hooks (since Arduino IDE 1.6.5)

You can specify pre and post actions around each recipe. These are called "hooks". Here is the complete list of available hooks:

• recipe.hooks.prebuild.NUMBER.pattern

  (called before sketch preprocessing and libraries discovery)

• recipe.hooks.sketch.prebuild.NUMBER.pattern

  (called before sketch compilation)

• recipe.hooks.sketch.postbuild.NUMBER.pattern

  (called after sketch compilation)

• recipe.hooks.libraries.prebuild.NUMBER.pattern

  (called before libraries compilation)

• recipe.hooks.libraries.postbuild.NUMBER.pattern

  (called after libraries compilation)

• recipe.hooks.core.prebuild.NUMBER.pattern

  (called before core compilation)

• recipe.hooks.core.postbuild.NUMBER.pattern

  (called after core compilation)

• recipe.hooks.linking.prelink.NUMBER.pattern

  (called before linking)

• recipe.hooks.linking.postlink.NUMBER.pattern

  (called after linking)

• recipe.hooks.objcopy.preobjcopy.NUMBER.pattern

  (called before objcopy recipes execution)

• recipe.hooks.objcopy.postobjcopy.NUMBER.pattern

  (called after objcopy recipes execution)

• recipe.hooks.savehex.presavehex.NUMBER.pattern

  (called before savehex recipe execution)

• recipe.hooks.savehex.postsavehex.NUMBER.pattern

  (called after savehex recipe execution)

Example: you want to execute two commands before sketch compilation and one after linking. You'll add to your platform.txt:

1recipe.hooks.sketch.prebuild.1.pattern=echo sketch compilation started at
2recipe.hooks.sketch.prebuild.2.pattern=date
3
4recipe.hooks.linking.postlink.1.pattern=echo linking is complete

Warning: hooks recipes are sorted before execution. If you need to write more than 10 recipes for a single hook, pad the number with a zero, for example:

1recipe.hooks.sketch.prebuild.01.pattern=echo 1
2recipe.hooks.sketch.prebuild.02.pattern=echo 2
3...
4recipe.hooks.sketch.prebuild.11.pattern=echo 11

Note: all the

pre*

post*

arduino-cli compile

Global platform.txt

Properties defined in a platform.txt created in the hardware subfolder of the Arduino IDE installation folder will be used for all platforms and will override local properties. This feature is currently only available when using the Arduino IDE.

platform.local.txt

Introduced in Arduino IDE 1.5.7. This file can be used to override properties defined in

platform.txt

platform.txt

platform.txt

platform.txt

boards.txt

This file contains definitions and metadata for the boards supported by the platform. Boards are referenced by their short name, the board ID. The settings for a board are defined through a set of properties with keys having the board ID as prefix.

For example, the board ID chosen for the Arduino Uno board is "uno". An extract of the Uno board configuration in boards.txt looks like:

1[......]
2uno.name=Arduino Uno
3uno.build.mcu=atmega328p
4uno.build.f_cpu=16000000L
5uno.build.board=AVR_UNO
6uno.build.core=arduino
7uno.build.variant=standard
8[......]

Note that all the relevant keys start with the board ID uno.xxxxx.

The uno.name property contains the human-friendly name of the board. This is shown in the Board menu of the IDEs, the "Board Name" field of Arduino CLI's text output, or the "name" key of Arduino CLI's JSON output.

The uno.build.board property is used to set a compile-time macro ARDUINO_{build.board} to allow use of conditional code between

#ifdef

ARDUINO_AVR_UNO

The other properties will override the corresponding global properties when the user selects the board. These properties will be globally available, in other configuration files too, without the board ID prefix:

1uno.build.mcu           =>   build.mcu
2uno.build.f_cpu         =>   build.f_cpu
3uno.build.board         =>   build.board
4uno.build.core          =>   build.core
5uno.build.variant       =>   build.variant

This explains the presence of {build.mcu} or {build.board} in the platform.txt recipes: their value is overwritten respectively by {uno.build.mcu} and {uno.build.board} when the Uno board is selected! Moreover the following properties are automatically generated:

• {build.board.platform.path}

  : The path to the selected board's platform. (available since Arduino CLI >=1.0.4)

• {build.core.platform.path}

  : The path to the core's platform. It may differ from the board's platform path because the latter may reference a core from another platform. (available since Arduino CLI >=1.0.4)

• {build.core.path}

  : The path to the selected board's core folder (inside the core platform, for example hardware/arduino/avr/core/arduino)

• {build.system.path}

  : The path to the core platform's system folder if available (for example hardware/arduino/sam/system)

• {build.variant.path}

  : The path to the selected board variant folder (inside the variant platform, for example hardware/arduino/avr/variants/micro)

If the platform supports pluggable discovery it may also declare a set of

upload_port.*

For example we could declare a series of

upload_port.vid

upload_port.pid

1uno.upload_port.0.vid=0x2341
2uno.upload_port.0.pid=0x0043
3uno.upload_port.1.vid=0x2341
4uno.upload_port.1.pid=0x0001
5uno.upload_port.2.vid=0x2A03
6uno.upload_port.2.pid=0x0043
7uno.upload_port.3.vid=0x2341
8uno.upload_port.3.pid=0x0243

In this case we're using the board's USB VID/PID pair to identify it but

upload_port.*

Cores

Cores are placed inside the cores subfolder. Many different cores can be provided within a single platform. For example the following could be a valid platform layout:

• hardware/arduino/avr/cores/

  : Cores folder for "avr" architecture, package "arduino"

• hardware/arduino/avr/cores/arduino

  : the Arduino Core

• hardware/arduino/avr/cores/rtos

  : a hypothetical RTOS Core

The board's property build.core is used to find the core that must be compiled and linked when the board is selected. For example if a board needs the Arduino core the build.core variable should be set to:

1uno.build.core=arduino

or if the RTOS core is needed, to:

1uno.build.core=rtos

In any case the contents of the selected core folder are compiled and the core folder path is added to the include files search path.

ArduinoCore-API

Although much of the implementation of a core is architecture-specific, the standardized core API and the hardware independent components should be the same for every Arduino platform. In order to free platform authors from the burden of individually maintaining duplicates of this common code, Arduino has published it in a dedicated repository from which it may easily be shared by all platforms. In addition to significantly reducing the effort required to write and maintain a core, ArduinoCore-API assists core authors in providing the unprecedented level of portability between platforms that is a hallmark of the Arduino project.

See the arduino/ArduinoCore-API repository for more information.

Core Variants

Sometimes a board needs some tweaking on the default core configuration (different pin mapping is a typical example). A core variant folder is an additional folder that is compiled together with the core and allows platform developers to easily add specific configurations.

Variants must be placed inside the variants folder in the current architecture. For example, Arduino AVR Boards uses:

• hardware/arduino/avr/cores

  : Core folder for "avr" architecture, "arduino" package

• hardware/arduino/avr/cores/arduino

  : The Arduino core

• hardware/arduino/avr/variants/

  : Variant folder for "avr" architecture, "arduino" package

• hardware/arduino/avr/variants/standard

  : ATmega328 based variants

• hardware/arduino/avr/variants/leonardo

  : ATmega32U4 based variants

In this example, the Arduino Uno board needs the standard variant so the build.variant property is set to standard:

1[.....]
2uno.build.core=arduino
3uno.build.variant=standard
4[.....]

instead, the Arduino Leonardo board needs the leonardo variant:

1[.....]
2leonardo.build.core=arduino
3leonardo.build.variant=leonardo
4[.....]

In the example above, both Uno and Leonardo share the same core but use different variants.
In any case, the contents of the selected variant folder path is added to the include search path and its contents are compiled and linked with the sketch.

The parameter build.variant.path is automatically generated.

Board VID/PID

USB vendor IDs (VID) and product IDs (PID) identify USB devices to the computer. If the board uses a unique VID/PID pair, it may be defined in boards.txt:

1uno.vid.0=0x2341
2uno.pid.0=0x0043
3uno.vid.1=0x2341
4uno.pid.1=0x0001

The vid and pid properties end with an arbitrary number, which allows multiple VID/PID pairs to be defined for a board. The snippet above is defining the 2341:0043 and 2341:0001 pairs used by Uno boards.

The Arduino development software uses the vid and pid properties to automatically identify the boards connected to the computer. This convenience feature isn't available for boards that don't present a unique VID/PID pair.

Serial Monitor control signal configuration

Arduino boards that use a USB to TTL serial adapter chip for communication with the computer (e.g., Uno, Nano, Mega) often utilize the DTR (data terminal ready) or RTS (request to send) serial control signals as a mechanism for the Arduino development software to trigger a reset of the primary microcontroller. The adapter's DTR and RTS pins are set

LOW

LOW

This system is also used to reset the microcontroller when Serial Monitor is started. The reset is convenient because it allows viewing all serial output from the time the program starts. In case the reset caused by opening Serial Monitor is not desirable, the control signal assertion behavior of Serial Monitor is configurable via the serial.disableDTR and serial.disableRTS properties. Setting these properties to

true

1[.....]
2uno.serial.disableDTR=true
3uno.serial.disableRTS=true
4[.....]

Hiding boards

Adding a hide property to a board definition causes it to not be shown in the Arduino IDE's Tools > Board menu.

1uno.hide=

The value of the property is ignored; it's the presence or absence of the property that controls the board's visibility.

programmers.txt

This file contains definitions for external programmers. These programmers are used by:

• The Tools > Burn Bootloader feature of the IDEs and

  arduino-cli burn-bootloader

• The Sketch > Upload Using Programmer feature of the IDEs and

  arduino-cli upload --programmer <programmer ID>

programmers.txt works similarly to boards.txt. Programmers are referenced by their short name: the programmer ID. The settings for a programmer are defined through a set of properties with keys that use the programmer ID as prefix.

For example, the programmer ID chosen for the "Arduino as ISP" programmer is "arduinoasisp". The definition of this programmer in programmers.txt looks like:

1[......]
2arduinoasisp.name=Arduino as ISP
3arduinoasisp.protocol=stk500v1
4arduinoasisp.program.speed=19200
5arduinoasisp.program.tool=avrdude
6arduinoasisp.program.extra_params=-P{serial.port} -b{program.speed}
7[......]

These properties can only be used in the recipes of the actions that use the programmer (

erase

bootloader

program

The arduinoasisp.name property defines the human-friendly name of the programmer. This is shown in the Tools > Programmer menu of the IDEs and the output of

arduino-cli upload --programmer list

arduino-cli burn-bootloader --programmer list

In Arduino IDE 1.8.12 and older, all programmers of all installed platforms were made available for use. Starting with Arduino IDE 1.8.13 (and in all relevant versions of other Arduino development tools), only the programmers defined by the board and core platform of the currently selected board are available. For this reason, platforms may now need to define copies of the programmers that were previously assumed to be provided by another platform.

Set a default programmer for a board (since Arduino CLI >=0.35.0, Arduino IDE >=2.3.0)

A default programmer for each board may be specified through the

programmer.default

1BOARD_ID.programmer.default=PROGRAMMER_ID

The default programmer will be selected automatically if the user do not specifiy or select another programmer. This may be useful for boards with an on-board programmer/debugger.

For example if we want to set Atmel ICE as the default programmer for the Arduino UNO we would add the following line to the

boards.txt

1uno.programmer.default=atmel-ice

Tools

The Arduino development software uses external command line tools to upload the compiled sketch to the board or to burn bootloaders using external programmers. For example, avrdude is used for AVR based boards and bossac for SAM based boards, but there is no limit, any command line executable can be used. The command line parameters are specified using recipes in the same way used for platform build process.

Tools are configured inside the platform.txt file. Every Tool is identified by a short name, the Tool ID. A tool can be used for different purposes:

• upload a sketch to the target board (using a bootloader preinstalled on the board)
• program a sketch to the target board using an external programmer
• erase the target board's flash memory using an external programmer
• burn a bootloader into the target board using an external programmer

Each action has its own recipe and its configuration is done through a set of properties having key starting with tools prefix followed by the tool ID and the action:

1[....]
2tools.avrdude.upload.pattern=[......]
3[....]
4tools.avrdude.program.pattern=[......]
5[....]
6tools.avrdude.erase.pattern=[......]
7[....]
8tools.avrdude.bootloader.pattern=[......]
9[.....]

A tool may have some actions not defined (it's not mandatory to define all four actions).
Let's look at how the upload action is defined for avrdude:

1tools.avrdude.path={runtime.tools.avrdude.path}
2tools.avrdude.cmd.path={path}/bin/avrdude
3tools.avrdude.config.path={path}/etc/avrdude.conf
4
5tools.avrdude.upload.pattern="{cmd.path}" "-C{config.path}" -p{build.mcu} -c{upload.port.protocol} -P{upload.port.address} -b{upload.speed} -D "-Uflash:w:{build.path}/{build.project_name}.hex:i"

The tool configuration properties are available globally without the prefix. For example, the tools.avrdude.cmd.path property can be used as {cmd.path} inside the recipe, and the same happens for all the other avrdude configuration variables.

How to retrieve tools path via

{runtime.tools.*}

properties

A {runtime.tools.TOOLNAME.path} and {runtime.tools.TOOLNAME-TOOLVERSION.path} property is generated for the tools provided by the current platform and for any other platform installed via Boards Manager.

See

{runtime.tools.*.path}

Environment variables

All the tools launched to compile or upload a sketch will have the following environment variable set:

ARDUINO_USER_AGENT

"arduino-cli/0.21.0"

"arduino-cli/0.21.0 ArduinoIDE/2.0.0-rc1"

Pluggable discovery

Discovery tools are a special kind of tool used to find supported boards. A platform must declare one or more Pluggable Discoveries in its

platform.txt

builtin

There are two different syntaxes to declare discoveries. If the platform uses just one discovery:

1pluggable_discovery.required=VENDOR_ID:DISCOVERY_NAME

instead if it needs multiple discoveries:

1pluggable_discovery.required.0=VENDOR_ID:DISCOVERY_0_NAME
2pluggable_discovery.required.1=VENDOR_ID:DISCOVERY_1_NAME

A platform that supports only boards connected via serial ports can easily use the

builtin

serial-discovery

1pluggable_discovery.required=builtin:serial-discovery

if it also supports boards connected via the network, it can use the

builtin

mdns-discovery

1pluggable_discovery.required.0=builtin:serial-discovery
2pluggable_discovery.required.1=builtin:mdns-discovery

Since the above syntax requires specifying a discovery via the

discoveryDependencies

1pluggable_discovery.DISCOVERY_ID.pattern=DISCOVERY_RECIPE

DISCOVERY_ID

DISCOVERY_RECIPE

1## Teensy Ports Discovery
2pluggable_discovery.teensy.pattern="{runtime.tools.teensy_ports.path}/hardware/tools/teensy_ports" -J2

We strongly recommend using this syntax only for development purposes and not on released platforms.

For backward compatibility, if a platform does not declare any discovery (using the

pluggable_discovery.*

platform.txt

builtin:serial-discovery

builtin:mdns-discovery

For detailed information, see the Pluggable Discovery specification.

Pluggable monitor

Monitor tools are a special kind of tool used to let the user communicate with the supported boards.

A platform must declare one or more Pluggable Monitor in its

platform.txt

The following directive is used to bind a specific monitor tool to a specific port protocol:

1pluggable_monitor.required.PROTOCOL=VENDOR_ID:MONITOR_NAME

where

PROTOCOL

VENDOR_ID:MONITOR_NAME

The platform can support as many protocols as needed:

1pluggable_monitor.required.PROTOCOL1=VENDOR_ID:MONITOR_NAME1
2pluggable_monitor.required.PROTOCOL2=VENDOR_ID:MONITOR_NAME2
3...

The above syntax requires specifying a monitor tool via the

monitorDependencies

1pluggable_monitor.pattern.PROTOCOL=MONITOR_RECIPE

where

MONITOR_RECIPE

PROTOCOL

1pluggable_monitor.pattern.custom-ble="{runtime.tools.my-ble-monitor.path}/my-ble-monitor" -H

in this case the platform provides a new hypothetical

custom-ble

my-ble-monitor

-H

monitorDependencies

We strongly recommend using this syntax only for development purposes and not on released platforms.

Built-in monitors

If a platform supports only boards connected via serial ports it can easily use the

builtin:serial-monitor

1pluggable_monitor.required.serial=builtin:serial-monitor

Backward compatibility

For backward compatibility, if a platform does not declare any discovery or monitor tool (using the

pluggable_discovery.*

pluggable_monitor.*

platform.txt

builtin:serial-monitor

builtin

For detailed information, see the Pluggable Monitor specification.

Port configuration

Each pluggable monitor has its own default settings that can be overridden using the following board properties:

1BOARD_ID.monitor_port.PROTOCOL.SETTING_NAME=SETTING_VALUE

where:

• BOARD_ID

  is the board identifier

• PROTOCOL

  is the port protocol

• SETTING_NAME

  and

  SETTING_VALUE

  are the port setting and the desired value

For example, let's suppose that a board needs the

baudrate

serial

9600

boards.txt

1myboard.monitor_port.serial.baudrate=9600

The settings available in a specific pluggable monitor can be queried directly from it.

Legacy

serial.disableRTS

and

serial.disableDTR

properties

In the old Arduino IDE (<=1.8.x) we used the properties:

1BOARD_ID.serial.disableRTS=true
2BOARD_ID.serial.disableDTR=true

to disable RTS and DTR when opening the serial monitor. To keep backward compatibilty the properties above are automatically converted to the corresponding pluggable monitor properties:

1BOARD_ID.monitor_port.serial.rts=off
2BOARD_ID.monitor_port.serial.dtr=off

Verbose parameter

It is possible for the user to enable verbosity from the Preferences panel of the IDEs or Arduino CLI's

--verbose

1tools.avrdude.upload.params.verbose=-v -v -v -v
2tools.avrdude.upload.params.quiet=-q -q
3tools.avrdude.upload.pattern="{cmd.path}" "-C{config.path}" {upload.verbose} -p{build.mcu} -c{upload.protocol} -P{serial.port} -b{upload.speed} -D "-Uflash:w:{build.path}/{build.project_name}.hex:i"

In this example if the user enables verbose mode, then {upload.params.verbose} is used in {upload.verbose}:

1tools.avrdude.upload.params.verbose    =>    upload.verbose

If the user didn't enable verbose mode, then {upload.params.quiet} is used in {upload.verbose}:

1tools.avrdude.upload.params.quiet      =>    upload.verbose

Sketch upload configuration

The Upload action is triggered when the user clicks on the "Upload" button on the IDE toolbar or uses

arduino-cli upload

The upload.tool.<protocol_name> property determines the tool to be used for upload. A specific upload.tool.<protocol_name> property should be defined for every board in boards.txt:

1[......]
2uno.upload.tool.serial=avrdude
3[......]
4leonardo.upload.tool.serial=avrdude
5leonardo.upload.tool.network=arduino_ota
6[......]

Multiple protocols can be defined for each board. When the user tries to upload using a protocol not supported by the board, it will fallback to

default

1[......]
2uno.upload.tool.default=avrdude
3[......]
4leonardo.upload.tool.default=avrdude
5leonardo.upload.tool.network=arduino_ota
6[......]

default

openocd

For backward compatibility with IDE 1.8.15 and older the previous syntax is still supported:

1uno.upload.tool=avrdude

The previous syntax is equivalent to:

1uno.upload.tool.default=avrdude

Other upload parameters can also be defined for the board. For example, in the Arduino AVR Boards boards.txt we have:

1[.....]
2uno.name=Arduino Uno
3uno.upload.tool.serial=avrdude
4uno.upload.protocol=arduino
5uno.upload.maximum_size=32256
6uno.upload.speed=115200
7[.....]
8leonardo.name=Arduino Leonardo
9leonardo.upload.tool.serial=avrdude
10leonardo.upload.protocol=avr109
11leonardo.upload.maximum_size=28672
12leonardo.upload.speed=57600
13leonardo.upload.use_1200bps_touch=true
14leonardo.upload.wait_for_upload_port=true
15[.....]

Most {upload.XXXX} variables are used later in the avrdude upload recipe in platform.txt:

1[.....]
2tools.avrdude.upload.pattern="{cmd.path}" "-C{config.path}" {upload.verbose} -p{build.mcu} -c{upload.port.protocol} -P{upload.port.address} -b{upload.speed} -D "-Uflash:w:{build.path}/{build.project_name}.hex:i"
3[.....]

If necessary the same property can be defined multiple times for different protocols:

1leonardo.upload.serial.speed=57600
2leonardo.upload.network.speed=19200

The two above properties will be available as {upload.speed}, the value will depend on the protocol used to upload.

Properties from pluggable discovery

If a platform supports pluggable discovery it can also use the port's properties returned by a discovery. For example, the following port metadata coming from a pluggable discovery:

1{
2      "eventType": "add",
3      "port": {
4        "address": "/dev/ttyACM0",
5        "label": "ttyACM0",
6        "protocol": "serial",
7        "protocolLabel": "Serial Port (USB)",
8        "properties": {
9          "pid": "0x804e",
10          "vid": "0x2341",
11          "serialNumber": "EBEABFD6514D32364E202020FF10181E",
12          "name": "ttyACM0"
13        }
14      }
15    }

will be available on the recipe as the variables:

1{upload.port.address} = /dev/ttyACM0
2{upload.port.label} = ttyACM0
3{upload.port.protocol} = serial
4{upload.port.protocolLabel} = Serial Port (USB)
5{upload.port.properties.pid} = 0x8043
6{upload.port.properties.vid} = 0x2341
7{upload.port.properties.serialNumber} = EBEABFD6514D32364E202020FF10181E
8{upload.port.properties.name} = ttyACM0
9{serial.port} = /dev/ttyACM0                # for backward compatibility
10{serial.port.file} = ttyACM0                # only because protocol=serial

Here another example:

1{
2      "eventType": "add",
3      "port": {
4        "address": "192.168.1.232",
5        "label": "SSH on my-board (192.168.1.232)",
6        "protocol": "ssh",
7        "protocolLabel": "SSH Network port",
8        "properties": {
9          "macprefix": "AA:BB:CC",
10          "macaddress": "AA:BB:CC:DD:EE:FF"
11        }
12      }
13    }

that is translated to:

1{upload.port.address} = 192.168.1.232
2{upload.port.label} = SSH on my-board (192.168.1.232)
3{upload.port.protocol} = ssh
4{upload.port.protocolLabel} = SSH Network port
5{upload.port.properties.macprefix} = AA:BB:CC
6{upload.port.properties.macaddress} = AA:BB:CC:DD:EE:FF
7{serial.port} = 192.168.1.232                  # for backward compatibility

This configuration, together with protocol selection, allows to remove the hardcoded

network_pattern

1tools.bossac.upload.network_pattern="{runtime.tools.arduinoOTA.path}/bin/arduinoOTA"
2                                -address {serial.port} -port 65280
3                                -sketch "{build.path}/{build.project_name}.bin"

with:

1tools.arduino_ota.upload.pattern="{runtime.tools.arduinoOTA.path}/bin/arduinoOTA"
2                            -address {upload.port.address} -port 65280
3                            -sketch "{build.path}/{build.project_name}.bin"

User provided fields

Some upload recipes might require custom fields that must be provided by the user, like username and password to upload over the network. In this case the recipe must use the special placeholder {upload.field.FIELD_NAME}, where FIELD_NAME must be declared separately in the recipe using the following format:

1tools.UPLOAD_RECIPE_ID.upload.field.FIELD_NAME=FIELD_LABEL
2tools.UPLOAD_RECIPE_ID.upload.field.FIELD_NAME.secret=true

FIELD_LABEL is the label shown in the graphical prompt where the user is asked to enter the value for the field.

The optional secret property should be set to

true

Let's see a complete example:

1tools.arduino_ota.upload.field.username=Username
2tools.arduino_ota.upload.field.password=Password
3tools.arduino_ota.upload.field.password.secret=true
4tools.arduino_ota.upload.pattern="{runtime.tools.arduinoOTA.path}/bin/arduinoOTA" -address {upload.port.address} -port 65280 -username "{upload.field.username} -password "{upload.field.password}" -sketch "{build.path}/{build.project_name}.bin"

If a FIELD_LABEL is longer than 50 characters it will be truncated to 49 characters and an ellipsis (

…

1tools.arduino_ota.upload.field.some_field=This is a really long label that ideally must never be set by any platform

will be shown to the user as:

1This is a really long label that ideally must nev…

Upload verification

Upload verification can be enabled via the Arduino IDE's File > Preferences > Verify code after upload or

arduino-cli upload --verify

tools.TOOL_ID.ACTION.params.verify defines the value of the ACTION.verify property when verification is enabled and tools.TOOL_ID.ACTION.params.noverify the value when verification is disabled.

The {ACTION.verify} property is only defined for the

upload

program

upload.tool

Prior to Arduino IDE 1.6.9, tools.TOOL_ID.ACTION.params.verify/noverify were not supported and

{upload.verify}

true

false

{program.verify}

1[.....]
2tools.avrdude.upload.verify=
3[.....]
4tools.avrdude.program.verify=
5[.....]

These definitions are overridden with the value defined by tools.TOOL_ID.ACTION.params.verify/noverify when a modern version of Arduino development software is in use.

1200 bps bootloader reset

Some Arduino boards use a dedicated USB-to-serial chip, that takes care of restarting the main MCU (starting the bootloader) when the serial port is opened. However, boards that have a native USB connection (such as the Leonardo or Zero) will have to disconnect from USB when rebooting into the bootloader (after which the bootloader reconnects to USB and offers a new serial port for uploading). After the upload is complete, the bootloader disconnects from USB again, starts the sketch, which then reconnects to USB. Because of these reconnections, the standard restart-on-serial open will not work, since that would cause the serial port to disappear and be closed again. Instead, the sketch running on these boards interprets a bitrate of 1200 bps as a signal the bootloader should be started.

To let the Arduino development software perform these steps, two board properties can be set to

true

• use_1200bps_touch

  causes the selected serial port to be briefly opened at 1200 bps (8N1) before starting the upload.

• wait_for_upload_port

  causes the upload procedure to wait for the serial port to (re)appear before and after the upload. This is only used when

  use_1200bps_touch

  is also set. When set, after doing the 1200 bps touch, the development software will wait for a new serial port to appear and use that as the port for uploads. Alternatively, if the original port does not disappear within a few seconds, the upload continues with the original port (which can be the case if the board was already put into bootloader manually, or the the disconnect and reconnect was missed). Additionally, after the upload is complete, the IDE again waits for a new port to appear (or the originally selected port to be present).

Note that the IDE implementation of this 1200 bps touch has some peculiarities, and the newer

arduino-cli

Upload Using Programmer by default

If the upload.protocol property is not defined for a board, the Arduino IDE's "Upload" process will use the same behavior as "Upload Using Programmer". This is convenient for boards which only support uploading via programmer.

Serial port

The full path (e.g.,

/dev/ttyACM0

arduino-cli upload

--port

The file component of the port's path (e.g.,

ttyACM0

For backward compatibility with IDE 1.8.15 and older the old property serial.port is still available and is identical to {upload.port.address}. Instead serial.port.file is identical to {upload.port.label} and available only if protocol in use is serial.

Upload using an external programmer

The

program

arduino-cli upload --programmer <programmer ID>

The program.tool property determines the tool to be used for this action. This property is typically defined for each programmer in programmers.txt and uses the same syntax as the

upload

1[......]
2usbasp.program.tool.serial=avrdude
3[......]
4arduinoasisp.program.tool.serial=avrdude
5[......]
6arduinoisp.program.tool.default=avrdude
7[......]

For backward compatibility with IDE 1.8.15 and older the previous syntax is still supported:

1[......]
2usbasp.program.tool=avrdude
3[......]
4arduinoasisp.program.tool=avrdude
5[......]

This action can use the same upload verification preference system as the

upload

When using the Arduino IDE, if the selected programmer is from a different platform than the board, the

program

Burn Bootloader

The

erase

bootloader

arduino-cli burn-bootloader

"Burn Bootloader" is unique in that it uses two actions, which are executed in sequence:

1. erase

   is typically used to erase the microcontroller's flash memory and set the configuration fuses according to the properties defined in the board definition

2. bootloader

   is used to flash the bootloader to the board

The bootloader.tool property determines the tool to be used for the

erase

bootloader

upload

1[......]
2uno.bootloader.tool.serial=avrdude
3[......]
4leonardo.bootloader.tool.serial=avrdude
5leonardo.bootloader.tool.network=arduino_ota
6[......]
7duemilanove.bootloader.tool.default=avrdude
8[......]

For backward compatibility with IDE 1.8.15 and older the previous syntax is still supported:

1[......]
2uno.bootloader.tool=avrdude
3[......]
4leonardo.bootloader.tool=avrdude
5[......]

When using the Arduino IDE, if the board uses a core reference, the platform.txt of the core platform is not used at all in defining the recipes for

erase

bootloader

Sketch debugging configuration

Starting from Arduino CLI 0.9.0 / Arduino IDE 2.x, sketch debugging support is available for platforms.

The debug action is triggered when the user clicks the Debug button in the Arduino IDE or runs the

arduino-cli debug

Since opening a debug session requires the orchestration of numerous tools, the CLI/IDE will take care of that duty: differently from the upload actions, there is no need for the platform to provide debug recipes, the only requirement is to provide some debug configuration directives.

Debugger configuration directives

All the debug directives are grouped under the

debug.*

• debug.executable

  : is the absolute path to the compiled binary of the sketch

• debug.toolchain

  : is a unique identifier of the required toolchain, currently we support

  gcc

  (and compatible) only

• debug.toolchain.path

  : is the absolute path to the toolchain directory

• debug.toolchain.prefix

  : is the prefix of the toolchain (for example

  arm-none-eabi-

  )

• debug.server

  : is a unique identifier of the required debug server, currently we support only

  openocd

• debug.svd_file

  : is the absolute path to the SVD descriptor.

If the

debug.executable

OpenOCD server specific configurations:

• debug.server.openocd.path

  : is the absolute path to the OpenOCD directory

• debug.server.openocd.scripts_dir

  : is the absolute path to the OpenOCD scripts directory

• debug.server.openocd.scripts.N

  : is a list of OpenOCD script files to run, where N is a number (a sequence of non-consecutive numbers is allowed)

• debug.server.openocd.script

  : if there is only one OpenOCD script to run, this directive con be used instead of the

  debug.server.openocd.scripts.N

  (this directive is ignored if

  debug.server.openocd.scripts.N

  is present)

Custom config for Cortext-debug plugin for Arduino IDE

The Arduino IDE uses cortex-debug plugin to start a debugging session. The IDE creates a

launch.json

launch.json

debug.cortex-debug.custom.*

launch.json

For example the following directives:

1debug.cortex-debug.custom.postAttachCommands.0=set remote hardware-watchpoint-limit 2
2debug.cortex-debug.custom.postAttachCommands.1=monitor reset halt
3debug.cortex-debug.custom.postAttachCommands.2=monitor gdb_sync
4debug.cortex-debug.custom.postAttachCommands.3=thb setup
5debug.cortex-debug.custom.postAttachCommands.4=c
6debug.cortex-debug.custom.overrideRestartCommands.0=monitor reset halt
7debug.cortex-debug.custom.overrideRestartCommands.1=monitor gdb_sync
8debug.cortex-debug.custom.overrideRestartCommands.2=thb setup
9debug.cortex-debug.custom.overrideRestartCommands.3=c

will result in the following JSON to be merged in the Arduino IDE generated

launch.json

1{
2  "overrideRestartCommands": ["monitor reset halt", "monitor gdb_sync", "thb setup", "c"],
3  "postAttachCommands": [
4    "set remote hardware-watchpoint-limit 2",
5    "monitor reset halt",
6    "monitor gdb_sync",
7    "thb setup",
8    "c"
9  ]
10}

All the values are converted by default to a string in the resulting JSON. If another type is needed the value can be prefixed with the tags

[boolean]

[number]

[string]

[object]

1debug.cortex-debug.custom.aBoolean=[boolean]true
2debug.cortex-debug.custom.aNumber=[number]10
3debug.cortex-debug.custom.anotherNumber=[number]10.20
4debug.cortex-debug.custom.anObject=[object]{"key":"value", "boolean":true}
5debug.cortex-debug.custom.anotherObject.key=value
6debug.cortex-debug.custom.anotherObject.boolean=[boolean]true

will result in the following JSON:

1{
2  "aBoolean": true,
3  "aNumber": 10,
4  "anotherNumber": 10.2,
5  "anObject": {
6    "boolean": true,
7    "key": "value"
8  },
9  "anotherObject": {
10    "boolean": true,
11    "key": "value"
12  }
13}

Additional debugger config selection via

debug.additional_config

directive.

It is possible to use any sub-tree of the platform configuration to override the debugger configuration using the directive

debug.additional_config=CONFIG_PREFIX

CONFIG_PREFIX.*

debug.*

This change allows a more convenient rationalization and selection of the configs to apply to the debugger. For example, we could factor common parts of a configuration in the platform.txt file:

1# CONFIG 1
2debug-overrides.esp32.cortex-debug.custom.name=Arduino on ESP32
3debug-overrides.esp32.cortex-debug.custom.request=attach
4debug-overrides.esp32.cortex-debug.custom.postAttachCommands.0=set remote hardware-watchpoint-limit 2
5debug-overrides.esp32.cortex-debug.custom.postAttachCommands.1=monitor reset halt
6debug-overrides.esp32.cortex-debug.custom.postAttachCommands.2=monitor gdb_sync
7debug-overrides.esp32.cortex-debug.custom.postAttachCommands.3=thb setup
8debug-overrides.esp32.cortex-debug.custom.postAttachCommands.4=c
9debug-overrides.esp32.cortex-debug.custom.overrideRestartCommands.0=monitor reset halt
10debug-overrides.esp32.cortex-debug.custom.overrideRestartCommands.1=monitor gdb_sync
11debug-overrides.esp32.cortex-debug.custom.overrideRestartCommands.2=thb setup
12debug-overrides.esp32.cortex-debug.custom.overrideRestartCommands.3=c
13
14# CONFIG 2
15debug-overrides.esp32s2.cortex-debug.custom.name=Arduino on ESP32-S2
16debug-overrides.esp32s2.cortex-debug.custom.request=attach
17debug-overrides.esp32s2.cortex-debug.custom.postAttachCommands.0=set remote hardware-watchpoint-limit 2
18debug-overrides.esp32s2.cortex-debug.custom.postAttachCommands.1=monitor reset halt
19debug-overrides.esp32s2.cortex-debug.custom.postAttachCommands.2=monitor gdb_sync
20debug-overrides.esp32s2.cortex-debug.custom.postAttachCommands.3=thb setup
21debug-overrides.esp32s2.cortex-debug.custom.postAttachCommands.4=c
22debug-overrides.esp32s2.cortex-debug.custom.overrideRestartCommands.0=monitor reset halt
23debug-overrides.esp32s2.cortex-debug.custom.overrideRestartCommands.1=monitor gdb_sync
24debug-overrides.esp32s2.cortex-debug.custom.overrideRestartCommands.2=thb setup
25debug-overrides.esp32s2.cortex-debug.custom.overrideRestartCommands.3=c

and choose which one to use depending on the board in the boards.txt file:

1myboard.name=My Board with esp32
2myboard.debug.additional_config=debug-overrides.esp32
3
4anotherboard.name=My Board with esp32s2
5anotherboard.debug.additional_config=debug-overrides.esp32s2
6...

Another possibility is to compose the configuration using another variable present in the board configuration, for example if in the

platform.txt

1debug.additional_config=debug-overrides.{build.mcu}

we may use the

build.mcu

1myboard.name=My Board with esp32
2myboard.build.mcu=esp32
3...
4
5anotherboard.name=My Board with esp32s2
6anotherboard.build.mcu=esp32s2
7...

Optimization level for debugging

The compiler optimization level that is appropriate for normal usage will often not provide a good experience while debugging. For this reason, it may be helpful to use different compiler flags when compiling a sketch for use with the debugger. The flags for use when compiling for debugging can be defined via the compiler.optimization_flags.debug property, and those for normal use via the compiler.optimization_flags.release property. The compiler.optimization_flags property will be defined according to one or the other depending on the Arduino Pro IDE's Sketch > Optimize for Debugging setting or

arduino-cli compile

--optimize-for-debug

Custom board options

It can sometimes be useful to provide user selectable configuration options for a specific board. For example, a board could be provided in two or more variants with different microcontrollers, or may have different crystal speed based on the board model, and so on...

When using Arduino CLI, the option can be selected via the FQBN, or using the

--board-options

In the Arduino IDE the options add extra menu items under the "Tools" menu.

In Arduino Web Editor, the options are displayed in the "Flavours" menu.

Let's see an example of how a custom option is implemented. The board used in the example is the Arduino Duemilanove. This board was produced in two models, one with an ATmega168 microcontroller and another with an ATmega328P.
We are going then to define a custom option, using the "cpu" MENU_ID, that allows the user to choose between the two different microcontrollers.

We must first define a set of menu.MENU_ID=Text properties. Text is what is displayed on the GUI for every custom menu we are going to create and must be declared at the beginning of the boards.txt file:

1menu.cpu=Processor
2[.....]

in this case, the menu name is "Processor".
Now let's add, always in the boards.txt file, the default configuration (common to all processors) for the duemilanove board:

1menu.cpu=Processor
2[.....]
3duemilanove.name=Arduino Duemilanove
4duemilanove.upload.tool=avrdude
5duemilanove.upload.protocol=arduino
6duemilanove.build.f_cpu=16000000L
7duemilanove.build.board=AVR_DUEMILANOVE
8duemilanove.build.core=arduino
9duemilanove.build.variant=standard
10[.....]

Now let's define the possible values of the "cpu" option:

1[.....]
2duemilanove.menu.cpu.atmega328=ATmega328P
3[.....]
4duemilanove.menu.cpu.atmega168=ATmega168
5[.....]

We have defined two values: "atmega328" and "atmega168".
Note that the property keys must follow the format BOARD_ID.menu.MENU_ID.OPTION_ID=Text, where Text is what is displayed under the "Processor" menu in the IDE's GUI.
Finally, the specific configuration for each option value:

1[.....]
2## Arduino Duemilanove w/ ATmega328P
3duemilanove.menu.cpu.atmega328=ATmega328P
4duemilanove.menu.cpu.atmega328.upload.maximum_size=30720
5duemilanove.menu.cpu.atmega328.upload.speed=57600
6duemilanove.menu.cpu.atmega328.build.mcu=atmega328p
7
8## Arduino Duemilanove w/ ATmega168
9duemilanove.menu.cpu.atmega168=ATmega168
10duemilanove.menu.cpu.atmega168.upload.maximum_size=14336
11duemilanove.menu.cpu.atmega168.upload.speed=19200
12duemilanove.menu.cpu.atmega168.build.mcu=atmega168
13[.....]

Note that when the user selects an option value, all the "sub properties" of that value are copied in the global configuration. For example, when the user selects "ATmega168" from the "Processor" menu, or uses the FQBN

arduino:avr:duemilanove:cpu=atmega168

1duemilanove.menu.cpu.atmega168.upload.maximum_size     =>   upload.maximum_size
2duemilanove.menu.cpu.atmega168.upload.speed            =>   upload.speed
3duemilanove.menu.cpu.atmega168.build.mcu               =>   build.mcu

There is no limit to the number of custom menus that can be defined.

Referencing another core, variant or tool

The Arduino platform referencing system allows using components of other platforms in cases where it would otherwise be necessary to duplicate those components. This feature allows us to reduce the minimum set of files needed to define a new "hardware" to just the boards.txt file.

Core reference

Inside the boards.txt we can define a board that uses a core provided by another vendor/maintainer using the syntax VENDOR_ID:CORE_ID. For example, if we want to define a board that uses the "arduino" core from the "arduino" vendor we should write:

1[....]
2myboard.name=My Wonderful Arduino Compatible board
3myboard.build.core=arduino:arduino
4[....]

Note that we don't need to specify any architecture since the same architecture of "myboard" is used, so we just say "arduino:arduino" instead of "arduino:avr:arduino".

The platform.txt settings are inherited from the referenced core platform, thus there is no need to provide a platform.txt unless there are some specific properties that need to be overridden.

The bundled libraries from the referenced platform are used, thus there is no need for the referencing platform to bundle those libraries. If libraries are provided, the list of available libraries is the sum of the two libraries, where the referencing platform has priority over the referenced platform.

The programmers from the referenced platform are made available, thus there is no need for the referencing platform to define those programmers. If the referencing platform does provide its own programmer definitions, the list of available programmer is the sum of the programmers of the two platforms. In Arduino IDE 1.8.12 and older, all programmers of all installed platforms were made available.

Variant reference

In the same way we can use a variant defined on another platform using the syntax VENDOR_ID:VARIANT_ID:

1[....]
2myboard.build.variant=arduino:standard
3[....]

Note that, unlike core references, other resources (platform.txt, bundled libraries, programmers) are not inherited from the referenced platform.

Tool references

Tool recipes defined in the platform.txt of other platforms can also be referenced using the syntax VENDOR_ID:TOOL_ID:

1[....]
2myboard.upload.tool=arduino:avrdude
3myboard.bootloader.tool=arduino:avrdude
4[....]

When using Arduino CLI or Arduino IDE 2.x (but not Arduino IDE 1.x), properties used in the referenced tool recipe may be overridden in the referencing platform's platform.txt.

Note that, unlike core references, referencing a tool recipe does not result in any other resources being inherited from the referenced platform.

Platform Terminology

Because boards can reference cores, variants and tools in different platforms, this means that a single build or upload can use data from up to four different platforms. To keep this clear, the following terminology is used:

• The "board platform" is the platform that defines the currently selected board (e.g. the platform that contains the board.txt the board is defined in.
• The "core platform" is the the platform that contains the core to be used.
• The "variant platform" is the platform that contains the variant to be used.
• The "tool platform" is the platform that contains the tool used for the current operation.

In the most common case: a board platform without any references, all of these will refer to the same platform.

Note that the above terminology is not in widespread use, but was invented for clarity within this document. In the actual Arduino CLI code, the "board platform" is called

targetPlatform

actualPlatform

boards.local.txt

Introduced in Arduino IDE 1.6.6. This file can be used to override properties defined in

boards.txt

boards.txt

boards.txt

Platform bundled libraries

Arduino libraries placed in the platform's

libraries

These are often architecture-specific libraries (e.g., SPI, Wire) which must be implemented differently for each architecture.

Platform bundled libraries may be used to provide specialized versions of libraries which use the dependency resolution system to override built-in libraries.

For more information, see the Arduino library specification.

keywords.txt

As of Arduino IDE 1.6.6, per-platform keywords can be defined by adding a keywords.txt file to the platform's architecture folder. These keywords are only highlighted in the Arduino IDE when one of the boards of that platform are selected. This file follows the same format as the keywords.txt used in libraries.

Post-install script

After Boards Manager finishes installation of a platform, it checks for the presence of a script named:

• post_install.bat

  - when running on Windows

• post_install.sh

  - when running on any non-Windows operating system

If present, the script is executed.

This script may be used to configure the user's system for the platform, such as installing drivers.

The circumstances under which the post-install script will run are different depending on which Arduino development software is in use:

• Arduino IDE 1.x: runs the script when the installed platform is signed with Arduino's private key.
• Arduino IDE 2.x: runs the script for any installed platform.
• Arduino CLI: (since 0.12.0) runs the script for any installed platform when Arduino CLI is in "interactive" mode. This behavior can be configured

Pre-uninstall script

Before Boards Manager starts uninstalling a platform, it checks for the presence of a script named:

• pre_uninstall.bat

  - when running on Windows

• pre_uninstall.sh

  - when running on any non-Windows operating system

If present, the script is executed.

This script may be used to configure the user's system for the removal of drivers, stopping background programs and execute any action that should be performed before the platform files are removed.

The circumstances under which the pre-uninstall script will run are different depending on which Arduino development software is in use:

• Arduino CLI: runs the script for any installed platform when Arduino CLI is in "interactive" mode. This behavior can be configured