Arduino Core for STM32

https://github.com/stm32duino/arduino_core_stm32
Admin
Arduino Core for STM32 provides support for STM32 microcontrollers in the Arduino IDE 2.x, enabling...
Tokens:1,275,805
Snippets:7,930
Trust Score:9.8
Update:9 hours ago
Show doc for...
Tokens:
Raw
### Start rpc demo server

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/linux_rpc_demo/README.md

Starts the linux_rpc_demod-shared server with sudo and the required LD_LIBRARY_PATH.

```bash
$ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build-openamp/usr/local/bin/linux_rpc_demod-shared
```

--------------------------------

### Minimal Arduino main.cpp with Arduino.h include

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/ide/PlatformIO.md

Place this file in src/main.cpp. It explicitly includes the Arduino API and provides empty setup() and loop() functions as a starting point.

```cpp
#include <Arduino.h>

void setup() {
}

void loop() {
}
```

--------------------------------

### cmake_easy_setup.py usage

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_cmake/Quickstart-guide

Shows the command-line options for the quickstart script. Use -s and -b to generate a CMakeLists.txt for a sketch, or -o (optionally -b) to generate a placeholder file. The --board option expects the board codename (e.g., NUCLEO_F207ZG), not the display name.

```text
usage: cmake_easy_setup.py [-h] [--cli CLI] [--board BOARD] [--fire] (--output OUTPUT | --sketch SKETCH)

optional arguments:
  -h, --help            show this help message and exit
  --cli CLI, -x CLI     path to arduino-cli
  --board BOARD, -b BOARD
                        board name
  --fire                launch the build immediately (use with caution!)
  --output OUTPUT, -o OUTPUT
                        output file (CMake) with placeholders
  --sketch SKETCH, -s SKETCH
                        output a file (CMake) filled given a sketch folder
```

--------------------------------

### Build libmetal library with cmake

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/linux_rpc_demo/README.md

Installs libsysfs and libhugetlbfs devel packages first. Creates a build directory and installs libmetal to the specified DESTDIR.

```bash
$ mkdir -p build-libmetal
        $ cd build-libmetal
        $ cmake <libmetal_source>
        $ make VERBOSE=1 DESTDIR=<libmetal_install> install
```

--------------------------------

### CMake build configuration for load_fw example

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/load_fw/CMakeLists.txt

Configures include and link directories, collects linker options and dependencies, then builds the load_fw executable with static linking when WITH_STATIC_LIB is enabled. Uses APP_EXTRA_C_FLAGS, APP_INC_DIRS, APP_LIB_DIRS, and APP_LINKER_OPT from the project. Links against open_amp-static and xilpm, and installs the output to CMAKE_INSTALL_BINDIR.

```CMake
collector_list (_app_extra_c_flags APP_EXTRA_C_FLAGS)
set (_cflags "${CMAKE_C_FLAGS} ${_app_extra_c_flags}")
set (_fw_dir "${APPS_SHARE_DIR}")

collector_list (_list PROJECT_INC_DIRS)
collector_list (_app_list APP_INC_DIRS)
include_directories (${_list} ${_app_list} ${CMAKE_CURRENT_SOURCE_DIR})

collector_list (_list PROJECT_LIB_DIRS)
collector_list (_app_list APP_LIB_DIRS)
link_directories (${_list} ${_app_list})

get_property (_linker_opt GLOBAL PROPERTY APP_LINKER_OPT)
collect (PROJECT_LIB_DEPS xilpm)
collector_list (_deps PROJECT_LIB_DEPS)

set (OPENAMP_LIB open_amp)

foreach (_app load_fw)
  collector_list (_sources APP_COMMON_SOURCES)
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/mem_image_store.c")
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/zynqmp_apu_lcm_rproc_example.c")
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/zynqmp_rpu_lcm_rproc_example.c")
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/platform_info.c")
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/${_app}.c")

  if (WITH_STATIC_LIB)
    add_executable (${_app}.out ${_sources})
    set_source_files_properties(${_sources} PROPERTIES COMPILE_FLAGS "${_cflags}")

    target_link_libraries(${_app}.out -Wl,-Map=${_app}.map -Wl,--gc-sections -T"${CMAKE_CURRENT_SOURCE_DIR}/lscript.ld" -Wl,--start-group ${OPENAMP_LIB}-static ${_deps} -Wl,--end-group)

    install (TARGETS ${_app}.out RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  endif (WITH_STATIC_LIB)
endforeach(_app)
```

--------------------------------

### Build for Linux Host

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/libmetal/README.md

Clone the libmetal repository, create a build directory, configure with CMake, and install. Use DESTDIR to specify the install location.

```shell
 $ git clone https://github.com/OpenAMP/libmetal.git
 $ mkdir -p libmetal/<build directory>
 $ cd libmetal/<build directory>
 $ cmake ..
 $ make VERBOSE=1 DESTDIR=<libmetal install location> install
```

--------------------------------

### Example for Nucleo_L476RG: redefine startup file

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/customization/Custom-definitions.md

Example of redefining CMSIS_STARTUP_FILE for the Nucleo_L476RG board using build_opt.h.

```console
-DCMSIS_STARTUP_FILE=\"startup_stm32l476xx.s\"
```

--------------------------------

### Full PWM Configuration Example

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/HardwareTimer-library

Configures a PWM output on a channel with a 10 ms overflow (100000 microseconds) and 50% duty cycle. The prescaler is computed automatically when using MICROSEC_FORMAT. Attaches update and compare callbacks, then starts the timer.

```C++
    MyTim->setMode(channel, TIMER_OUTPUT_COMPARE_PWM1, pin);
    // MyTim->setPrescaleFactor(8); // Due to setOverflow with MICROSEC_FORMAT, prescaler   will be computed automatically based on timer input clock
    MyTim->setOverflow(100000, MICROSEC_FORMAT); // 10000 microseconds = 10 milliseconds
    MyTim->setCaptureCompare(channel, 50, PERCENT_COMPARE_FORMAT); // 50%
    MyTim->attachInterrupt(Update_IT_callback);
    MyTim->attachInterrupt(channel, Compare_IT_callback);
    MyTim->resume();
```

--------------------------------

### Build with CMake or Ninja

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_cmake/Quickstart-guide

Two equivalent commands to run the build step after configuration. Use either one; CMake will automatically re-run configuration if needed.

```sh
# Run either of these commands, they have the same effect
cmake --build [build folder]
ninja # from inside the build folder
```

--------------------------------

### Verify PlatformIO Core installation

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/ide/PlatformIO.md

Run this command to confirm that PlatformIO Core is installed and accessible from the command line.

```console
pio --version
```

--------------------------------

### Full PWM configuration example

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/HardwareTimer-library.md

Configures a channel in PWM1 mode, sets overflow to 100 ms, sets a 50% duty cycle, attaches update and compare callbacks, and starts the timer. The prescaler is computed automatically by setOverflow.

```C++
    timer.setMode(channel, TIMER_OUTPUT_COMPARE_PWM1, pin);
    // timer.setPrescaleFactor(8); // setOverflow computes the prescaler automatically.
    timer.setOverflow(100000, MICROSEC_FORMAT); // 100000 microseconds = 100 milliseconds
    timer.setCaptureCompare(channel, 50, PERCENT_COMPARE_FORMAT); // 50%
    timer.attachInterrupt(Update_IT_callback);
    timer.attachInterrupt(channel, Compare_IT_callback);
    timer.resume();
```

--------------------------------

### Example for Nucleo L476RG: Custom startup file in variant

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_custom/Custom-definitions

Example of setting the custom startup file flag for the Nucleo L476RG board in boards.txt.

```text
Nucleo_64.menu.pnum.NUCLEO_L476RG.build.startup_file=-DCUSTOM_STARTUP_FILE
```

--------------------------------

### CMakeLists.txt for OpenAMP examples with WITH_LOAD_FW option

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/CMakeLists.txt

Configures example subdirectories for the OpenAMP apps. The WITH_LOAD_FW option (default OFF) controls inclusion of the load_fw example. For microblaze machines, only the echo example is built; otherwise echo, nocopy_echo, rpmsg_sample_echo, and matrix_multiply are added, with load_fw added if WITH_LOAD_FW is ON, and rpc_demo/linux_rpc_demo added if WITH_PROXY_APPS is set.

```cmake
option (WITH_LOAD_FW "Include loading firmware example" OFF)

if (MACHINE MATCHES ".*microblaze.*")
add_subdirectory (echo)
else ()
add_subdirectory (echo)
add_subdirectory (nocopy_echo)
add_subdirectory (rpmsg_sample_echo)
add_subdirectory (matrix_multiply)
if (WITH_LOAD_FW)
  add_subdirectory (load_fw)
endif (WITH_LOAD_FW)
if (WITH_PROXY_APPS)
add_subdirectory (rpc_demo)
add_subdirectory (linux_rpc_demo)
endif (WITH_PROXY_APPS)
endif (MACHINE MATCHES ".*microblaze.*")
```

--------------------------------

### Set up and build documentation with MkDocs

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/Documentation-workflow.md

Creates a persistent virtual environment and installs documentation dependencies from requirements-docs.txt, then builds the site with --strict. Reuse the environment in later sessions; rerun the pip install command whenever requirements-docs.txt changes.

```bash
python3 -m venv "$HOME/.venvs/stm32duino-docs"
"$HOME/.venvs/stm32duino-docs/bin/python" -m pip install -r requirements-docs.txt
"$HOME/.venvs/stm32duino-docs/bin/mkdocs" build --strict
```

--------------------------------

### ADC setup and read example

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/API

Shows ADC pin setup with pinMode(pin, INPUT_ANALOG) and reading via analogRead(pin). Requires an ADC-capable pin (e.g., PA0).

```C
pinMode(pin, INPUT_ANALOG);
```

```C
uint16_t adc_value = analogRead(pin);
```

--------------------------------

### Baremetal Toolchain File Example

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/libmetal/README.md

Example CMake toolchain file for building libmetal on baremetal (e.g., ARM Cortex-R5). Set CMAKE_SYSTEM_PROCESSOR, MACHINE, CROSS_PREFIX, and compiler flags. Includes cross-generic-gcc.

```cmake
    set (CMAKE_SYSTEM_PROCESSOR "arm"              CACHE STRING "")
    set (MACHINE "zynqmp_r5" CACHE STRING "")

    set (CROSS_PREFIX           "armr5-none-eabi-" CACHE STRING "")
    set (CMAKE_C_FLAGS          "-mfloat-abi=soft -mcpu=cortex-r5 -Wall -Werror -Wextra \
       -flto -Os -I/ws/xsdk/r5_0_bsp/psu_cortexr5_0/include" CACHE STRING "")

    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto")
    SET(CMAKE_AR  "gcc-ar" CACHE STRING "")
    SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qcs <TARGET> <LINK_FLAGS> <OBJECTS>")
    SET(CMAKE_C_ARCHIVE_FINISH   true)

    include (cross-generic-gcc)
```

--------------------------------

### Compile OpenAMP library for MicroBlaze

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/machine/microblaze_generic/README.md

Commands to build the OpenAMP library for the MicroBlaze design. Creates a build-openamp directory, sets BSP, runs cmake with the toolchain file and include/library paths, then installs. The library is built in build/usr/local/lib, headers in build/usr/local/include, and the application executable in build/usr/local/bin.

```shell
    $ mkdir -p build-openamp
    $ cd build-openamp
    $ BSP="/path/to/your_MicroBlaze_design_BSP/dir"

    $ cmake <openamp_source> -DCMAKE_TOOLCHAIN_FILE=<toolchain_file> \
        -DCMAKE_INCLUDE_PATH="$LIBMETAL/include;$BSP/include" \
        -DCMAKE_LIBRARY_PATH="$LIBMETAL/lib/;BSP/lib"  -DWITH_APPS=on
    $ make VERBOSE=1 DESTDIR=$(pwd) install
```

--------------------------------

### Compile OpenAMP library with CMake

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/README.md

Commands to build and install the OpenAMP library for the generic baremetal platform. Creates a build directory, configures with the toolchain file, and installs to the current directory.

```bash
    $ mkdir -p build-openamp
    $ cd build-openamp
    $ cmake <openamp_source> -DCMAKE_TOOLCHAIN_FILE=<toolchain_file>
    $ make VERBOSE=1 DESTDIR=$(pwd) install
```

--------------------------------

### CMakeLists.txt: Collect dependencies and locate xil library

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/libmetal/examples/system/freertos/zynqmp_r5/CMakeLists.txt

Configures the ZynqMP R5 FreeRTOS example build by collecting required libraries (freertos, metal, xil, c, m) and locating the external 'xil' library. Fails with a FATAL_ERROR if the library is not found, suggesting the -DCMAKE_LIBRARY_PATH option. Adds the zynqmp_amp_demo subdirectory.

```cmake
collect(PROJECT_LIB_DEPS freertos)
collect(PROJECT_LIB_DEPS metal)
collect(PROJECT_LIB_DEPS xil)
collect(PROJECT_LIB_DEPS c)
collect(PROJECT_LIB_DEPS m)

set (_lib "xil")
find_library (_lib_path ${_lib})
if (NOT _lib_path)
  message ( "external library ${_lib_path} not found" )
  message ( "hint: you may need to pass -DCMAKE_LIBRARY_PATH=<path>" )
  message ( FATAL_ERROR "library ${_lib} is required to build the examples" )
endif (NOT _lib_path)
get_filename_component (_lib_path ${_lib_path} DIRECTORY)
collect (PROJECT_LIB_DIRS ${_lib_path})

add_subdirectory(zynqmp_amp_demo)
```

--------------------------------

### Compile libmetal for MicroBlaze

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/machine/microblaze_generic/README.md

Commands to build the libmetal library for the MicroBlaze design. Creates a build-libmetal directory, sets BSP to your MicroBlaze design BSP directory, runs cmake with the toolchain file and library path, then installs to the specified destination.

```shell
    $ mkdir -p build-libmetal
    $ cd build-libmetal
    $ BSP="/path/to/your_MicroBlaze_design_BSP/dir"
    $ cmake <libmetal_source> -DCMAKE_TOOLCHAIN_FILE=<toolchain_file> \
            -DCMAKE_LIBRARY_PATH=$BSP/lib
    $ make VERBOSE=1 DESTDIR=<libmetal_install> install
```

--------------------------------

### Pointer-based HardwareTimer creation in setup()

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/HardwareTimer-library.md

If the timer must be created inside setup(), store it in a pointer so it remains alive after setup() returns. Do not delete the object while the timer is in use.

```C++
HardwareTimer *timer;

void setup() {
    timer = new HardwareTimer(TIM3);
}
```

--------------------------------

### Board codename example from boards.txt

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/cmake/STM32duino-CMake-Build-System.md

Shows the codename NUCLEO_F207ZG used in the setup script, as opposed to the display name 'Nucleo F207ZG'.

```text
Nucleo_144.menu.pnum.NUCLEO_F207ZG=Nucleo F207ZG
Nucleo_144.menu.pnum.NUCLEO_F207ZG.node=NODE_F207ZG
```

--------------------------------

### Include EEPROM library and setup sketch

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/libraries/EEPROM/README.md

Adds the EEPROM library header to a sketch. The setup() and loop() functions are empty placeholders for user code.

```Arduino
#include <EEPROM.h>

void setup(){

}

void loop(){

}

```

--------------------------------

### Sample Microblaze DTSI with reserved-memory and UIO nodes

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/machine/microblaze_generic/README.md

Device tree overlay example for ZynqMP MPSoC to reserve memory for MicroBlaze text/data and vrings, and to define UIO nodes for vring, shared memory, and IPI. Required for running the MicroBlaze echo server from PS DDR and a Linux echo client on APU.

```dts
	/ {
		reserved-memory {
			#address-cells = <2>;
			#size-cells = <2>;
			ranges;
			rproc_0_reserved: rproc@3ed000000 {
				no-map;
				reg = <0x0 0x3ed00000 0x0 0x1000000>;
			};
			microblaze_text_data: microblaze:@70000000 {
				no-map;
				reg = <0x0 0x70000000 0x0 0x80000>;
			};
		};

		amba {
			vring: vring@0 {
				compatible = "vring_uio";
				reg = <0x0 0x3ed40000 0x0 0x40000>;
			};
			shm0: shm@0 {
				compatible = "shm_uio";
				reg = <0x0 0x3ed20000 0x0 0x0100000>;
			};
			shm1: shm@1 {
				compatible = "shm_uio";
				reg = <0x0 0x3ee40000 0x0 0x0100000>;
			};
			ipi0: ipi@0 {
				compatible = "ipi_uio";
				reg = <0x0 0xff340000 0x0 0x1000>;
				interrupt-parent = <&gic>;
				interrupts = <0 29 4>;
			};
		};
	};
```

--------------------------------

### Configure CMake with Ninja generator

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_cmake/Quickstart-guide

Runs the CMake configure step to generate Ninja build files in a dedicated out-of-source build folder. Replace [source folder] and [build folder] with your actual paths.

```sh
cmake -S [source folder] -B [build folder] -G Ninja
```

--------------------------------

### Start Timer with resume()

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/HardwareTimer-library

Starts the timer. All channels of the same timer start simultaneously because there is only one counter per timer.

```C++
    MyTim->resume();
```

--------------------------------

### Build libmetal on Linux host

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/README.md

Build libmetal on a Linux host after installing libsysfs devel and libhugetlbfs devel packages. The install directory is used later when building OpenAMP.

```bash
        $ mkdir -p build-libmetal
        $ cd build-libmetal
        $ cmake <libmetal_source>
        $ make VERBOSE=1 DESTDIR=<libmetal_install> install
```

--------------------------------

### Example for Nucleo L476RG: Redefine startup file

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_custom/Custom-definitions

Example of redefining the startup file for the Nucleo L476RG board. The file name must match the device startup file.

```C
-DCMSIS_STARTUP_FILE=\"startup_stm32l476xx.s\
```

--------------------------------

### Alternate timebase callback simple example

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/HardwareTimer-library

Configures HardwareTimer TIM1 to execute a callback at a regular interval, toggling the built-in LED. The timer is paused, set to a 500000 microsecond overflow period, and resumed after attaching the interrupt and refreshing. After setup, the loop is empty and CPU load only occurs during callback executions.

```C++
HardwareTimer timer1(TIM1);

void timerCallback() {
  // Toggle led pin.
  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  timer1.pause();
  timer1.setOverflow(500000, MICROSEC_FORMAT);  //set the period
  timer1.attachInterrupt(timerCallback);
  timer1.refresh();
  timer1.resume();
}

void loop() {
  // nothing to do
}
```

--------------------------------

### Example sketch folder structure

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/cmake/STM32duino-CMake-Build-System.md

Shows the expected layout with Blink.ino, CMakeLists.txt, and a build directory.

```text
Blink/
|-- Blink.ino
|-- CMakeLists.txt
`-- build/
```

--------------------------------

### CMakeLists.txt for OpenAMP echo examples (rpmsg-echo-ping and rpmsg-echo)

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/echo/CMakeLists.txt

Build configuration for the OpenAMP echo examples. It defines compile flags, collects include/link directories, and creates executables for both 'rpmsg-echo-ping' and 'rpmsg-echo' apps. Supports building with shared or static libraries; for non-Linux systems, it generates a .out executable with linker map and garbage collection flags.

```cmake
set (_cflags "${CMAKE_C_FLAGS} ${APP_EXTRA_C_FLAGS} -fdata-sections -ffunction-sections")
set (_fw_dir "${APPS_SHARE_DIR}")

collector_list (_list PROJECT_INC_DIRS)
collector_list (_app_list APP_INC_DIRS)
include_directories (${_list} ${_app_list} ${CMAKE_CURRENT_SOURCE_DIR})

collector_list (_list PROJECT_LIB_DIRS)
collector_list (_app_list APP_LIB_DIRS)
link_directories (${_list} ${_app_list})

get_property (_linker_opt GLOBAL PROPERTY APP_LINKER_OPT)
collector_list (_deps PROJECT_LIB_DEPS)

set (OPENAMP_LIB open_amp)

foreach (_app rpmsg-echo-ping rpmsg-echo)
  collector_list (_sources APP_COMMON_SOURCES)
  if (${_app} STREQUAL "rpmsg-echo-ping")
    list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/rpmsg-ping.c")
  elseif (${_app} STREQUAL "rpmsg-echo")
    list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/rpmsg-echo.c")
  endif (${_app} STREQUAL "rpmsg-echo-ping")

  if (WITH_SHARED_LIB)
    add_executable (${_app}-shared ${_sources})
    target_link_libraries (${_app}-shared ${OPENAMP_LIB}-shared ${_deps})
    install (TARGETS ${_app}-shared RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  endif (WITH_SHARED_LIB)

  if (WITH_STATIC_LIB)
    if (${PROJECT_SYSTEM} STREQUAL "linux")
      add_executable (${_app}-static ${_sources})
      target_link_libraries (${_app}-static ${OPENAMP_LIB}-static ${_deps})
      install (TARGETS ${_app}-static RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    else (${PROJECT_SYSTEM})
      add_executable (${_app}.out ${_sources})
      set_source_files_properties(${_sources} PROPERTIES COMPILE_FLAGS "${_cflags}")

      target_link_libraries(${_app}.out -Wl,-Map=${_app}.map -Wl,--gc-sections ${_linker_opt} -Wl,--start-group ${OPENAMP_LIB}-static ${_deps} -Wl,--end-group)

      install (TARGETS ${_app}.out RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    endif (${PROJECT_SYSTEM} STREQUAL "linux" )
  endif (WITH_STATIC_LIB)
endforeach(_app)
```

--------------------------------

### CMake toolchain file for building libmetal for MicroBlaze

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/machine/microblaze_generic/README.md

Example toolchain file for compiling libmetal for a generic baremetal MicroBlaze platform. Set BSP to your MicroBlaze design BSP directory. Uses microblaze-xilinx-elf- cross prefix and includes flags like -mlittle-endian and -mxl-soft-mul.

```cmake
    set (BSP  "/path/to/your_MicroBlaze_design_BSP/dir" CACHE STRING "")
    set (CMAKE_SYSTEM_PROCESSOR           "microblaze"  CACHE STRING "")
    set (MACHINE           "microblaze_generic"         CACHE STRING "")
    set (CROSS_PREFIX          "microblaze-xilinx-elf-" CACHE STRING "")
    set (CMAKE_C_FLAGS "-g -mlittle-endian -mxl-soft-mul -Wall -Werror \
                   "-Wextra -flto -Os -I${BSP}/include" CACHE STRING "")
    link_directories( ${BSP}/lib )
    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto")
    SET(CMAKE_AR  "gcc-ar" CACHE STRING "")
    SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qcs <TARGET> <LINK_FLAGS> <OBJECTS>")
    SET(CMAKE_C_ARCHIVE_FINISH   true)
    include (cross-generic-gcc)
```

--------------------------------

### Specify AStyle installation directory

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/Astyle.md

Use when AStyle is not in PATH. Provide the directory containing the executable.

```console
python3 CI/astyle/astyle.py -p /path/to/astyle-directory
```

--------------------------------

### Install AStyle 3.1 on Debian/Ubuntu

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/Astyle.md

Install AStyle 3.1 using the system package manager. Only use this command when the configured repository provides version 3.1; newer versions are incompatible with the STM32duino style configuration.

```console
sudo apt install astyle
```

--------------------------------

### CMakeLists.txt for linux_rpc_demo OpenAMP example

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/linux_rpc_demo/CMakeLists.txt

Build script for the OpenAMP linux_rpc_demo example. It configures include/link directories, builds executables for each app in app_list (linux_rpc_demod and linux_rpc_demo on Linux), and supports both shared and static library builds. For static builds on non-Linux systems, it links with the linker options and generates a map file.

```cmake
set (_cflags "${CMAKE_C_FLAGS} ${APP_EXTRA_C_FLAGS}")
set (_fw_dir "${APPS_SHARE_DIR}")

collector_list (_list PROJECT_INC_DIRS)
collector_list (_app_list APP_INC_DIRS)
include_directories (${_list} ${_app_list} ${CMAKE_CURRENT_SOURCE_DIR})

collector_list (_list PROJECT_LIB_DIRS)
collector_list (_app_list APP_LIB_DIRS)
link_directories (${_list} ${_app_list})

get_property (_linker_opt GLOBAL PROPERTY APP_LINKER_LARGE_TEXT_OPT)
if (NOT _linker_opt)
  get_property (_linker_opt GLOBAL PROPERTY APP_LINKER_OPT)
endif (NOT _linker_opt)
collector_list (_deps PROJECT_LIB_DEPS)

set (OPENAMP_LIB open_amp)

if (${PROJECT_SYSTEM} STREQUAL "linux")
  set (app_list linux_rpc_demod linux_rpc_demo)
endif (${PROJECT_SYSTEM} STREQUAL "linux")

foreach (_app ${app_list})
  collector_list (_sources APP_COMMON_SOURCES)
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/${_app}.c")

  if (WITH_SHARED_LIB)
    add_executable (${_app}-shared ${_sources})
    target_link_libraries (${_app}-shared ${OPENAMP_LIB}-shared ${_deps})
    install (TARGETS ${_app}-shared RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  endif (WITH_SHARED_LIB)

  if (WITH_STATIC_LIB)
    if (${PROJECT_SYSTEM} STREQUAL "linux")
      add_executable (${_app}-static ${_sources})
      target_link_libraries (${_app}-static ${OPENAMP_LIB}-static ${_deps})
      install (TARGETS ${_app}-static RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    else (${PROJECT_SYSTEM})
      add_executable (${_app}.out ${_sources})
      set_source_files_properties(${_sources} PROPERTIES COMPILE_FLAGS "${_cflags}")

      target_link_libraries(${_app}.out -Wl,-Map=${_app}.map -Wl,--gc-sections ${_linker_opt} -Wl,--start-group ${OPENAMP_LIB}-static ${_deps} -Wl,--end-group)
      install (TARGETS ${_app}.out RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    endif (${PROJECT_SYSTEM} STREQUAL "linux" )
  endif (WITH_STATIC_LIB)
endforeach(_app)
```

--------------------------------

### CMake toolchain file for building OpenAMP for MicroBlaze

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/machine/microblaze_generic/README.md

Example toolchain file for compiling OpenAMP for a generic baremetal MicroBlaze platform. Set BSP to your MicroBlaze design BSP directory. Includes -DRPMSG_NO_IPI and -DUNDEFINE_FILE_OPS flags, and links against -lxil, -lc, -lm, and -lmetal.

```cmake
    set (BSP  "/path/to/your_MicroBlaze_design_BSP/dir" CACHE STRING "")
    set (CMAKE_SYSTEM_PROCESSOR           "microblaze"  CACHE STRING "")
    set (MACHINE           "microblaze_generic"         CACHE STRING "")
    set (CROSS_PREFIX          "microblaze-xilinx-elf-" CACHE STRING "")
    set (CMAKE_C_FLAGS "-g -mlittle-endian -Wall -Wextra -flto -Os \
            -DUNDEFINE_FILE_OPS -DRPMSG_NO_IPI -I${LIBMETAL}/include \
            -I${BSP}/include" CACHE STRING "")

    set (PLATFORM_LIB_DEPS     "-lxil -lc -lm -lmetal " CACHE STRING "")
    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -flto")
    SET(CMAKE_AR  "gcc-ar" CACHE STRING "")
    SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qcs <TARGET> <LINK_FLAGS> <OBJECTS>")
    SET(CMAKE_C_ARCHIVE_FINISH   true)
    link_directories(${LIBMETAL}/include/ ${LIBMETAL}/lib/)
    set (CMAKE_FIND_ROOT_PATH ${LIBMETAL}/lib  ${BSP}/lib )
    include (cross-generic-gcc)
```

--------------------------------

### CMake build script for matrix_multiply examples

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/matrix_multiply/CMakeLists.txt

CMake configuration for building the matrix_multiply and matrix_multiplyd OpenAMP example applications. It collects include/link directories and sources, then creates executables for shared and static library variants. For non-Linux systems with static libraries, it links with --gc-sections and generates a .map file.

```cmake
set (_cflags "${CMAKE_C_FLAGS} ${APP_EXTRA_C_FLAGS} -fdata-sections -ffunction-sections")
set (_fw_dir "${APPS_SHARE_DIR}")

collector_list (_list PROJECT_INC_DIRS)
collector_list (_app_list APP_INC_DIRS)
include_directories (${_list} ${_app_list} ${CMAKE_CURRENT_SOURCE_DIR})

collector_list (_list PROJECT_LIB_DIRS)
collector_list (_app_list APP_LIB_DIRS)
link_directories (${_list} ${_app_list})

get_property (_linker_opt GLOBAL PROPERTY APP_LINKER_OPT)
collector_list (_deps PROJECT_LIB_DEPS)

set (OPENAMP_LIB open_amp)
foreach (_app matrix_multiply matrix_multiplyd)
  collector_list (_sources APP_COMMON_SOURCES)
  list (APPEND _sources "${CMAKE_CURRENT_SOURCE_DIR}/${_app}.c")
  
  if (WITH_SHARED_LIB)
    add_executable (${_app}-shared ${_sources})
    target_link_libraries (${_app}-shared ${OPENAMP_LIB}-shared ${_deps})
    install (TARGETS ${_app}-shared RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
  endif (WITH_SHARED_LIB)

  if (WITH_STATIC_LIB)
    if (${PROJECT_SYSTEM} STREQUAL "linux")
      add_executable (${_app}-static ${_sources})
      target_link_libraries (${_app}-static ${OPENAMP_LIB}-static ${_deps})
      install (TARGETS ${_app}-static RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    else (${PROJECT_SYSTEM})
      add_executable (${_app}.out ${_sources})
      set_source_files_properties(${_sources} PROPERTIES COMPILE_FLAGS "${_cflags}")

      target_link_libraries(${_app}.out -Wl,-Map=${_app}.map -Wl,--gc-sections ${_linker_opt} -Wl,--start-group ${OPENAMP_LIB}-static ${_deps} -Wl,--end-group)
  
      install (TARGETS ${_app}.out RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
    endif (${PROJECT_SYSTEM} STREQUAL "linux" )
  endif (WITH_STATIC_LIB)
endforeach(_app)
```

--------------------------------

### Hardware CS pin example with SPIClass constructor

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/API

Shows how to create an SPI instance with a hardware CS pin using the alternative SPIClass constructor. The SSEL pin must be a hardware CS pin; chip select is then managed by the SPI peripheral. Note the example references an undefined 'settings' variable and calls SPI_3.end() without parentheses.

```C++
#include <SPI.h>
//            MOSI  MISO  SCLK   SSEL
SPIClass SPI_3(PC12, PC11, PC10, PC9);

void setup() {
  SPI_3.begin(); // Enable the SPI_3 instance with default SPISsettings
  SPI_3.beginTransaction(settings); // Configure the SPI_3 instance with other settings
  SPI_3.transfer(0x52); // Transfers data to the first device
  SPI_3.end() //SPI_3 instance is disabled
}
```

--------------------------------

### Run proxy_app with options

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/docs/apps/rpc_demo/README.md

Run the proxy_app demo after Linux boots. It loads the remoteproc and proxy rpmsg modules, outputs messages from the other processor, sends console input back, and unloads modules on exit.

```bash
# proxy_app [-m REMOTEPROC_MODULE] [-f PATH_OF_THE_RPC_DEMO_FIRMWARE]
```

--------------------------------

### SubGhz.SPI.beginTransaction()

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/libraries/SubGhz/README.md

Starts an SPI transaction using the SubGhz SPI object. Pass SubGhz.spi_settings to get the correct settings and maximum speed.

```APIDOC
## SubGhz.SPI.beginTransaction()

### Description
Starts an SPI transaction using the SubGhz SPI object. Pass SubGhz.spi_settings to get the correct settings and maximum speed.

### Method
beginTransaction

### Parameters
- **settings** (SPISettings) - Optional - Use SubGhz.spi_settings for correct settings and maximum speed.

```

--------------------------------

### Build and upload with explicit environment

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/ide/PlatformIO.md

Use these commands when more than one environment is defined. The -e flag selects the environment explicitly.

```console
pio run -e my_board
pio run -e my_board --target upload
```

--------------------------------

### Run rpmsg echo demo

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/README.md

Start the echo test server and then run the echo test client. Requires the OpenAMP and libmetal libraries to be built with -DWITH_APPS=ON. The server waits for messages and the client sends one message.

```bash
    # Start echo test server to wait for message to echo
    $ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build/usr/local/bin/rpmsg-echo-shared
    # Run echo test to send message to echo test server
    $ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build/usr/local/bin/rpmsg-echo-ping-shared 1
```

--------------------------------

### OpenOCD executable path variable

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_dev/How-to-debug

Eclipse global variable expression for the OpenOCD executable path when installed per the GNU MCU plug-in guide. The 'Actual executable' field shows the resolved full path.

```plaintext
${openocd_path}/${openocd_executable}
```

--------------------------------

### CMake configuration for BareMinimum sketch

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/CI/build/examples/BareMinimum/CMakeLists.txt

Autogenerated CMakeLists.txt for building a BareMinimum sketch with STM32 core. Sets up environment, board selection, and build configuration. Includes optional early return when imported from main CMakeLists.txt.

```cmake
# This file was autogenerated by cmake\scripts\cmake_easy_setup.py.
# Use it in your CMake configuration by `include()`'ing it.
# You can also copy it in your sketch's folder and edit it to fit your project.

cmake_minimum_required(VERSION 3.21)

# STEP 1: set up bases of environment
# -----------------------------------------------------------------------------

file(REAL_PATH "../../../../" CORE_PATH EXPAND_TILDE)
file(TO_CMAKE_PATH "${CORE_PATH}" CORE_PATH)

if(NOT DEFINED BOARDNAME)
  MESSAGE(STATUS "BOARDNAME is not defined set it to NUCLEO_F103RB")
  set(BOARDNAME "NUCLEO_F103RB")
endif()

list(APPEND CMAKE_MODULE_PATH ${CORE_PATH}/cmake)
set(CMAKE_TOOLCHAIN_FILE toolchain)


# You may remove this block when using this file as the sketch's CMakeLists.txt
if (NOT ${CMAKE_PARENT_LIST_FILE} STREQUAL ${CMAKE_CURRENT_LIST_FILE})
    # When we are imported from the main CMakeLists.txt, we should stop here
    # not to interfere with the true build config.
    return()
endif()

project("BareMinimum_project")

# STEP 2: configure the build
# -----------------------------------------------------------------------------
include(set_board)
set_board("${BOARDNAME}")

include(overall_settings)
overall_settings()

include(build_sketch)
build_sketch(TARGET "BareMinimum"
  SOURCES
  BareMinimum.ino
  DEPENDS
  CMSIS_DSP
  EEPROM
  IWatchdog
  Servo
  SoftwareSerial
  SPI
  Wire
  I3C
)
```

--------------------------------

### Build OpenAMP library on Linux host

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/README.md

Build the OpenAMP library on a Linux host, linking against the previously built libmetal. The optional -DWITH_APPS=ON flag builds demonstration applications. Outputs go to build/usr/local/lib, include, and bin directories.

```bash
        $ mkdir -p build-openamp
        $ cd build-openamp
        $ cmake <openamp_source> -DCMAKE_INCLUDE_PATH=<libmetal_built_include_dir> \
              -DCMAKE_LIBRARY_PATH=<libmetal_built_lib_dir> [-DWITH_APPS=ON]
        $ make VERBOSE=1 DESTDIR=$(pwd) install
```

--------------------------------

### CMakeLists.txt for ZynqMP R5 AMP Demo

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/libmetal/examples/system/freertos/zynqmp_r5/zynqmp_amp_demo/CMakeLists.txt

Build configuration for the ZynqMP R5 AMP demo. Sets up include and library directories, defines the linker script and source files, creates the executable libmetal_amp_demod.elf, applies compile options if PROJECT_EC_FLAGS is set, links with the specified linker options, and installs the target to bin.

```CMake
collector_list  (_list PROJECT_INC_DIRS)
include_directories (${_list} ${CMAKE_CURRENT_SOURCE_DIR})

collector_list  (_list PROJECT_LIB_DIRS)
link_directories (${_list})

collector_list (_deps PROJECT_LIB_DEPS)

set (_linker_script ${CMAKE_CURRENT_SOURCE_DIR}/lscript.ld)

set (_src_common ${CMAKE_CURRENT_SOURCE_DIR}/init_${PROJECT_SYSTEM}.c)
set (_app0 libmetal_amp_demod)
set (_src0 ${CMAKE_CURRENT_SOURCE_DIR}/${_app0}.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/sys_init.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/shmem_demod.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/shmem_atomic_demod.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/ipi_shmem_demod.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/ipi_latency_demod.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/shmem_latency_demod.c)
list(APPEND _src0 ${CMAKE_CURRENT_SOURCE_DIR}/shmem_throughput_demod.c)

get_property (_linker_options GLOBAL PROPERTY TEST_LINKER_OPTIONS)
add_executable (${_app0}.elf ${_src0})
if (PROJECT_EC_FLAGS)
  string(REPLACE " " ";" _ec_flgs ${PROJECT_EC_FLAGS})
  target_compile_options (${_app0}.elf PUBLIC ${_ec_flgs})
endif (PROJECT_EC_FLAGS)
target_link_libraries(${_app0}.elf -Wl,-Map=${_app0}.map -Wl,--gc-sections -T\"${_linker_script}\" -Wl,--start-group ${_deps} -Wl,--end-group)
install (TARGETS ${_app0}.elf RUNTIME DESTINATION bin)

# vim: expandtab:ts=2:sw=2:smartindent
```

--------------------------------

### Declare and use a second I2C port with TwoWire

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/API

Declares a TwoWire object for a second I2C port before setup(), then initializes it and performs a transmission. The example uses pins PB3 (SDA) and PB10 (SCL).

```C++
#include <Wire.h>
//            SDA  SCL
TwoWire Wire2(PB3, PB10);

void setup() {
  Wire2.begin(); 
}

void loop() {
  Wire2.beginTransmission(0x71);
  Wire2.write('v');
  Wire2.endTransmission();
  delay(1000);
}
```

--------------------------------

### StartMeasurementSimplified(OperatingMode, void(*)(void))

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_libs/_dedicated/VL53L0X

Starts the measurement indicated by the operating mode. A callback function must be provided for interrupt-based measurements.

```APIDOC
## StartMeasurementSimplified(OperatingMode, void(*)(void))

### Description
Starts the measurement indicated by the operating mode. A callback function must be provided for interrupt-based measurements.

### Parameters
- **operatingMode** (OperatingMode) - Required - Specifies requested measure (range_single_shot_polling, range_continuous_polling, range_continuous_interrupt, range_continuous_polling_low_threshold, range_continuous_polling_high_threshold, range_continuous_polling_out_of_window, range_continuous_interrupt_low_threshold, range_continuous_interrupt_high_threshold, range_continuous_interrupt_out_of_window)
- **callback** (void(*)(void)) - Required - Pointer to callback function. Must be not NULL in case of interrupt measure

### Returns
- **int** - 0 on Success, error code otherwise
```

--------------------------------

### Run rpmsg echo demo with nocopy API

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/README.md

Start the echo test server using the nocopy API and then run the corresponding client. Requires the OpenAMP and libmetal libraries to be built with -DWITH_APPS=ON. The server waits for messages and the client sends one message.

```bash
    # Start echo test server to wait for message to echo
    $ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build/usr/local/bin/rpmsg-nocopy-echo-shared
    # Run echo test to send message to echo test server
    $ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build/usr/local/bin/rpmsg-nocopy-ping-shared 1
```

--------------------------------

### Using a second I2C port with TwoWire

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/libraries/built-in/I2C-library.md

Declare a TwoWire object with custom SDA and SCL pins before setup() to use a second I2C port. The example uses PB3 (SDA) and PB10 (SCL) and communicates with device address 0x71.

```C++
#include <Wire.h>
//            SDA  SCL
TwoWire Wire2(PB3, PB10);

void setup() {
  Wire2.begin();
}

void loop() {
  Wire2.beginTransmission(0x71);
  Wire2.write('v');
  Wire2.endTransmission();
  delay(1000);
}
```

--------------------------------

### Run rpc demo client

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/system/Middlewares/OpenAMP/open-amp/apps/examples/linux_rpc_demo/README.md

Runs the linux_rpc_demo-shared client with sudo and the required LD_LIBRARY_PATH. Inputs entered on the master side are printed on the remote side via rpmsg calls.

```bash
$ sudo LD_LIBRARY_PATH=<openamp_built>/usr/local/lib:<libmetal_built>/usr/local/lib \
       build-openamp/usr/local/bin/linux_rpc_demo-shared 1
```

--------------------------------

### Custom assert_failed implementation at sketch level

Source: https://github.com/stm32duino/arduino_core_stm32/wiki/_custom/HAL-configuration

Redefines the WEAK `assert_failed` function to print the assertion location and continue. The example calls `assert_param(LED_BUILTIN == 0)` in `setup()` to trigger the assertion if the condition fails. Requires core version higher than 2.7.1 and `USE_FULL_ASSERT` defined in `build_opt.h`.

```C++
extern "C" void assert_failed(uint8_t *file, uint32_t line) {
  // Custom code
  printf("Assert failed: %s (%lu)\n", (char *)file, line);
}

// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin LED_BUILTIN as an output.
  assert_param(LED_BUILTIN == 0);
  pinMode(LED_BUILTIN, OUTPUT);
}
```

--------------------------------

### Compile with arduino-cli

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/customization/Custom-board-based-on-a-core.md

Compile a sketch using the reported FQBN.

```console
arduino-cli compile --fqbn <vendor>:<architecture>:<board> <sketch-directory>
```

--------------------------------

### Initialize a new PlatformIO project

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/ide/PlatformIO.md

Creates a new PlatformIO project with the specified board. Replace <platformio-board-id> with the identifier from the PlatformIO STM32 board list. The command generates a platformio.ini file and the standard project directories.

```console
pio project init --board <platformio-board-id>
```

--------------------------------

### Initialize SPI and Read Register via SubGhz

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/libraries/SubGhz/README.md

Basic example of initializing the SubGhz radio and SPI bus, then reading a register (SUBGHZ_LSYNCRH) using an SPI command. The radio starts in sleep mode with its busy signal active, so the code waits for it to wake up before transferring. The final 'value' variable holds the register value read.

```C++
  // initialize SPI:
  SubGhz.SPI.begin();

  // clear reset to
  SubGhz.setResetActive(false);

  // Start SPI transaction and wait for the radio to wake up (it starts
  // in sleep mode with its busy signal active).
  SubGhz.SPI.beginTransaction(SubGhz.spi_settings);
  SubGhz.setNssActive(true);
  while (SubGhz.isBusy()) /* wait */;

  // Write a command and read the result
  SubGhz.SPI.transfer(0x1D); // Write command: Read_Register()
  SubGhz.SPI.transfer(0x07); // Write MSB of register address: SUBGHZ_LSYNCRH
  SubGhz.SPI.transfer(0x40); // Write LSB of register address: SUBGHZ_LSYNCRH
  uint8_t status = SubGhz.SPI.transfer(0x0);  // Read status
  uint8_t value = SubGhz.SPI.transfer(0x0);  // Read register value

  // End transaction
  SubGhz.setNssActive(false);
  SubGhz.SPI.endTransaction();

  // value now has the register value read

```

--------------------------------

### Build, upload, and monitor commands

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/ide/PlatformIO.md

Run these commands from the project directory to build, upload, and open the serial monitor. The same operations are available through the PlatformIO panel in Visual Studio Code.

```console
pio run
pio run --target upload
pio device monitor
```

--------------------------------

### Format all matching files with AStyle

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/Astyle.md

Run from the repository root. Formats files in place, so review changes before committing.

```console
python3 CI/astyle/astyle.py -r .
```

--------------------------------

### Start st-util GDB server

Source: https://github.com/stm32duino/arduino_core_stm32/blob/main/docs/development/debug/command-line-gdb.md

Command to start the st-util GDB server. The default server address is localhost:4242.

```sh
st-util
```
Tokens:
Raw