boards/nucleo-*: migrate to Flashing Guide, point to common doc

2025-12-16 18:13:49 +01:00 · 2025-03-29 23:35:58 +01:00 · 2025-03-29 23:35:58 +01:00 · b6931afd15
commit b6931afd15
parent 9fbb80a3e0
47 changed files with 319 additions and 1128 deletions
--- a/boards/nucleo-c031c6/doc.md
+++ b/boards/nucleo-c031c6/doc.md
@ -7,6 +7,9 @@
 The Nucleo-C031C6 is a board from ST's Nucleo family supporting a ARM
 Cortex-M0+ STM32C031C6 microcontroller with 12KiB of RAM and 32KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-c031c6.svg "Pinout for the Nucleo-C031C6 (from STM user manual UM2953, https://www.st.com/resource/en/user_manual/um2953-stm32-nucleo64-board-mb1717-stmicroelectronics.pdf, page 19)" width=50%
@ -33,17 +36,8 @@ Cortex-M0+ STM32C031C6 microcontroller with 12KiB of RAM and 32KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0223-stm32-cortexm0-mcus-programming-manual-stmicroelectronics.pdf) |
 | Board Manual   | [Board Manual](https://www.st.com/resource/en/user_manual/um2953-stm32-nucleo64-board-mb1717-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-C031C6 is `nucleo-c031c6`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-c031c6 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-c071rb/doc.md
+++ b/boards/nucleo-c071rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-C071RB is a board from ST's Nucleo family supporting a ARM
 Cortex-M0+ STM32C071RB microcontroller with 24KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
 See Board Manual referenced below, section 7 pages 19-21.
--- a/boards/nucleo-f030r8/doc.md
+++ b/boards/nucleo-f030r8/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F030R8 is a board from ST's Nucleo family supporting a ARM Cortex-M0
 STM32F030R8 microcontroller with 8KiB of RAM and 64KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F030R8](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -52,37 +55,8 @@ STM32F030R8 microcontroller with 8KiB of RAM and 64KiB of Flash.
 |        | Timer     | 3 16 bit timers       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F030R8 board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F030R8 is `nucleo-f030r8`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f030r8 flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f030r8 debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f030r8 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F030R8 board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f031k6/doc.md
+++ b/boards/nucleo-f031k6/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F031K6 is a board from ST's Nucleo family supporting ARM Cortex-M0
 STM32F031K6 microcontroller with 4KiB of RAM and 32KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-f031k6-and-more.svg "Pinout for the Nucleo-F031K6 (from ST User Manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 31)" width=25%
@ -34,15 +37,8 @@ STM32F031K6 microcontroller with 4KiB of RAM and 32KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0215-stm32f0-series-cortexm0-programming-manual-stmicroelectronics.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F031K6 is `nucleo-f031k6`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f031k6 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-f042k6/doc.md
+++ b/boards/nucleo-f042k6/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F042K6 is a board from ST's Nucleo family supporting ARM Cortex-M0
 STM32F042K6 microcontroller with 6KiB of RAM and 32KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-f031k6-and-more.svg "Pinout for the Nucleo-F042K6 (from ST User Manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 31)" width=25%
@ -34,15 +37,8 @@ STM32F042K6 microcontroller with 6KiB of RAM and 32KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0215-stm32f0-series-cortexm0-programming-manual-stmicroelectronics.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F042K6 is `nucleo-f042k6`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f042k6 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-f070rb/doc.md
+++ b/boards/nucleo-f070rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F070RB is a board from ST's Nucleo family supporting a ARM Cortex-M0
 STM32F070RB microcontroller with 16KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F070RB](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -53,37 +56,8 @@ STM32F070RB microcontroller with 16KiB of RAM and 128KiB of Flash.
 |        | Timer     | 3 16 bit timers       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F070RB board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F070RB is `nucleo-f070rb`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f070rb flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f070rb debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f070rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F070RB board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f072rb/doc.md
+++ b/boards/nucleo-f072rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F072RB is a board from ST's Nucleo family supporting a ARM Cortex-M0
 STM32F072RB microcontroller with 16KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F072RB](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -55,37 +58,8 @@ STM32F072RB microcontroller with 16KiB of RAM and 128KiB of Flash.
 |        | Timer     | 1 32 bit timers (TIM1)        | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F072RB board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F072RB is `nucleo-f072rb`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f072rb flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f072rb debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f072rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F072RB board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f091rc/doc.md
+++ b/boards/nucleo-f091rc/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F091RC is a board from ST's Nucleo family supporting a ARM Cortex-M0
 STM32F091RC microcontroller with 32KiB of RAM and 256KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F091RC](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -68,37 +71,8 @@ document for the pin mapping as implemenented in `boards/nucleo-f091/include/per
 |        | Timer     | full      | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F091RC board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F091RC is `nucleo-f091rc`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f091rc flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f091rc debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f091rc PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F091RC board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f103rb/doc.md
+++ b/boards/nucleo-f103rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F103RB is a board from ST's Nucleo family supporting a ARM Cortex-M3
 STM32F103RB microcontroller with 20KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F103RB](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -51,37 +54,8 @@ STM32F103RB microcontroller with 20KiB of RAM and 128KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | 2 16 bit timers (TIM2 and TIM3)       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F103RB board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F103RB is `nucleo-f103rb`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing:
 ```
 make BOARD=nucleo-f103rb flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f103rb debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f103rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F103RB board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f207zg/doc.md
+++ b/boards/nucleo-f207zg/doc.md
@ -5,8 +5,10 @@
 ## Overview
 The Nucleo-F207ZG is a board from ST's Nucleo family supporting a ARM
-Cortex-M3
+Cortex-M3 STM32F207ZG microcontroller with 128KiB of SRAM and 1MiB of ROM Flash.
-STM32F207ZG microcontroller with 128KiB of SRAM and 1MiB of ROM Flash.
+
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
@ -54,37 +56,8 @@ STM32F207ZG microcontroller with 128KiB of SRAM and 1MiB of ROM Flash.
 |        | USB       | no        | |
 |        | Timer     | 2 32 bit timers       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F207ZG board includes an on-board ST-LINK V2-1 programmer. The
+The board name for the Nucleo-F207ZG is `nucleo-f207zg`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f207zg flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f207zg debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f207zg PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F207ZG board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f302r8/doc.md
+++ b/boards/nucleo-f302r8/doc.md
@ -9,6 +9,9 @@ is a board from ST's Nucleo family supporting a ARM Cortex-M4
 [STM32F302R8](http://www.st.com/en/microcontrollers/stm32f302r8.html)
 microcontroller with 16KiB of RAM and 64KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![nucleo image](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -55,35 +58,8 @@ microcontroller with 16KiB of RAM and 64KiB of Flash.
 |        | Timer     | one 32 timer (TIM2)   | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F302R8 board includes an on-board ST-LINK V2-1 programmer.
+The board name for the Nucleo-F302R8 is `nucleo-f302r8`.
 The easiest way to program the board is to use OpenOCD. Once you have
 installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
 for installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f302r8 flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f302r8 debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f302r8 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F302R8 board we strongly recommend the usage of
 the [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded) toolchain.
--- a/boards/nucleo-f303k8/doc.md
+++ b/boards/nucleo-f303k8/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F303K8 is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F303K8 microcontroller with 12KiB of RAM and 64KiB of ROM.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Hardware
 ![nucleo image](https://www.st.com/bin/ecommerce/api/image.PF262496.en.feature-description-include-personalized-no-cpn-medium.jpg)
@ -48,36 +51,8 @@ STM32F303K8 microcontroller with 12KiB of RAM and 64KiB of ROM.
 |        | Timer     | one 32 timer  | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F303K8 board includes an on-board ST-LINK V2 programmer.
+The board name for the Nucleo-F303K8 is `nucleo-f303k8`.
 The easiest way to program the board is to use OpenOCD. Once you have
 installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
 for installation instructions), you can flash the board simply by typing.
 ```
 BOARD=nucleo-f303k8 make flash
 ```
 and debug via GDB by simply typing
 ```
 BOARD=nucleo-f303k8 make debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f303k8 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F303K8 board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f303re/doc.md
+++ b/boards/nucleo-f303re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F303RE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F303RE microcontroller with 64KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F303RE](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -53,38 +56,8 @@ STM32F303RE microcontroller with 64KiB of RAM and 512KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | one 32 timer  | |
 ## Flashing the Board
-## Flashing the device
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-### Flashing the Board Using OpenOCD
+The board name for the Nucleo-F303RE is `nucleo-f303re`.
 The ST Nucleo-F303RE board includes an on-board ST-LINK V2 programmer.
 The easiest way to program the board is to use OpenOCD. Once you have
 installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
 for installation instructions), you can flash the board simply by typing.
 ```
 BOARD=nucleo-f303re make flash
 ```
 and debug via GDB by simply typing
 ```
 BOARD=nucleo-f303re make debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f303re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F303RE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f303ze/doc.md
+++ b/boards/nucleo-f303ze/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F303ZE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F303ZE microcontroller with 64KiB of RAM and 512KiB of ROM.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
 ![Nucleo144 F303ZE](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo144-board.png)
@ -52,39 +55,8 @@ STM32F303ZE microcontroller with 64KiB of RAM and 512KiB of ROM.
 |        | USB       | no        | |
 |        | Timer     | one 32 timer  | |
 ## Flashing the Board
-## Flashing the device
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-### Flashing the Board Using OpenOCD
+The board name for the Nucleo-F303ZE is `nucleo-f303ze`.
 The ST Nucleo-F303ZE board includes an on-board ST-LINK V2 programmer.
 The easiest way to program the board is to use OpenOCD. Once you have
 installed OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD)
 for installation instructions), you can flash the board simply by typing.
 ```
 BOARD=nucleo-f303ze make flash
 ```
 and debug via GDB by simply typing
 ```
 BOARD=nucleo-f303ze make debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f303ze PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F303ZE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f334r8/doc.md
+++ b/boards/nucleo-f334r8/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F334R8 is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F334R8 microcontroller with 12KiB of RAM and 64KiB or Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F334R8](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -53,46 +56,8 @@ STM32F334R8 microcontroller with 12KiB of RAM and 64KiB or Flash.
 |        | Timer     | one 32 timer      | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F334R8 board includes an on-board ST-LINK V2 programmer.
+The board name for the Nucleo-F334R8 is `nucleo-f334r8`.
 The easiest way to program the board is to use OpenOCD. Once you have
 installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 BOARD=nucleo-f334r8 make flash
 ```
 and debug via GDB by simply typing
 ```
 BOARD=nucleo-f334r8 make debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f334r8 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller USART2.
 The default baud rate is 115200.
 ## Supported Toolchains
 For using the ST Nucleo-F334R8 board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f401re/doc.md
+++ b/boards/nucleo-f401re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F401RE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F401RE microcontroller with 96KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F401RE](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -51,42 +54,11 @@ STM32F401RE microcontroller with 96KiB of RAM and 512KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | 2 32 bit timers       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F401RE board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F401RE is `nucleo-f401re`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f401re flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f401re debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f401re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F401RE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
 ## Issues with old Hardware Revisions
--- a/boards/nucleo-f410rb/doc.md
+++ b/boards/nucleo-f410rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F410RB is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F410RB microcontroller with 32KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F410RB](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -50,41 +53,8 @@ STM32F410RB microcontroller with 32KiB of RAM and 128KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | 2 32 bit timers       | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F410RB board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F401RB is `nucleo-f401rb`.
 easiest way to program the board is to use OpenOCD. You need OpenOCD in
 version
 0.10 minimum. Once you have installed OpenOCD (look
 [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for installation
 instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f410rb flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f410rb debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f410rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F410RB board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f411re/doc.md
+++ b/boards/nucleo-f411re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F411RE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F411RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F411RE](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -51,39 +54,8 @@ STM32F411RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | 1 32 bit timer (TIM5)     | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F411RE board includes an on-board ST-LINK V2-1 programmer. The
+The board name for the Nucleo-F411RE is `nucleo-f411re`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f411re flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f411re debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f411re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F411RE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f412zg/doc.md
+++ b/boards/nucleo-f412zg/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F412ZG is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32F412ZG microcontroller with 256KiB of RAM and 1MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f412zg-and-f413zh.svg "Pinout for the Nucleo-F412ZG (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 34)" width=50%
@ -33,16 +36,8 @@ STM32F412ZG microcontroller with 256KiB of RAM and 1MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F412ZG is `nucleo-f412zg`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f412zg PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw
 -link007.html).
--- a/boards/nucleo-f413zh/doc.md
+++ b/boards/nucleo-f413zh/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F413ZH is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32F413ZH microcontroller with 320KiB of RAM and 1.5MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f412zg-and-f413zh.svg "Pinout for the nucleo-f413zh (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 34)" width=50%
@ -34,15 +37,8 @@ STM32F413ZH microcontroller with 320KiB of RAM and 1.5MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F413ZH is `nucleo-f413zh`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f413zh PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-f429zi/doc.md
+++ b/boards/nucleo-f429zi/doc.md
@ -7,7 +7,10 @@
 The Nucleo-F429ZI is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32F429ZI microcontroller with 256KiB of RAM and 2MiB of Flash.
-##Hardware
+You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
 ![Nucleo144 F429ZI](https://www.st.com/bin/ecommerce/api/image.PF262637.en.feature-description-include-personalized-no-cpn-medium.jpg)
@ -38,31 +41,8 @@ STM32F429ZI microcontroller with 256KiB of RAM and 2MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using ST-LINK Removable Media
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-On-board ST-LINK programmer provides via composite USB device removable media.
+The board name for the Nucleo-F429ZI is `nucleo-f429zi`.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f429zi PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller USART3.
 The default baud rate is 115200.
 If a physical connection to USART3 is needed, connect UART interface to pins
 PD8 (USART3 TX) and PD9 (USART3 RX).
@note Accordingly to the [MCU Datasheet](https://www.st.com/resource/en/datasheet/stm32f429zi.pdf)
 PD8 and PD9 pins are 5V tolerant (see table 10, page 62).
--- a/boards/nucleo-f439zi/doc.md
+++ b/boards/nucleo-f439zi/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F439ZI is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32F439ZI microcontroller with, 256KiB of RAM and 2MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f207zg-and-more.svg "Pinout for the Nucleo-F439ZI (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 32)" width=50%
@ -34,25 +37,8 @@ STM32F439ZI microcontroller with, 256KiB of RAM and 2MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using ST-LINK Removable Media
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-On-board ST-LINK programmer provides via composite USB device removable media.
+The board name for the Nucleo-F439ZI is `nucleo-f439zi`.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f439zi PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller USART3.
 The default baud rate is 115200.
--- a/boards/nucleo-f446re/doc.md
+++ b/boards/nucleo-f446re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F446RE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F446RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 F446RE](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -52,38 +55,8 @@ STM32F446RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 |        | USB       | no        | |
 |        | Timer     | one 32 bit timer      | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F446RE board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F446RE is `nucleo-f446re`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f446re flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f446re debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f446re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F446RE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f446ze/doc.md
+++ b/boards/nucleo-f446ze/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F446ZE is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32F446ZE microcontroller with 128KiB of RAM and 512KiB of ROM Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
 ![Nucleo144 F446ZE](https://raw.githubusercontent.com/wiki/RIOT-OS/RIOT/images/nucleo144-board.png)
@ -52,38 +55,8 @@ STM32F446ZE microcontroller with 128KiB of RAM and 512KiB of ROM Flash.
 |        | USB       | no        | |
 |        | Timer     | one 32 bit timer      | |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-F446ZE board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-F446ZE is `nucleo-f446ze`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-f446ze flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-f446ze debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f446ze PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER requires ST-LINK firmware 2.37.26 or newer. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-F446ZE board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-f722ze/doc.md
+++ b/boards/nucleo-f722ze/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F722ZE is a board from ST's Nucleo family supporting ARM Cortex-M7
 STM32F722ZE microcontroller with 256KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f446ze-and-f722ze.svg "Pinout for the Nucleo-F722ZE (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 35)" width=50%
@ -34,23 +37,8 @@ STM32F722ZE microcontroller with 256KiB of RAM and 512KiB of Flash.
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F722ZE is `nucleo-f722ze`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f722ze PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller USART3.
 The default baud rate is 115200.
--- a/boards/nucleo-f746zg/doc.md
+++ b/boards/nucleo-f746zg/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F746ZG is a board from ST's Nucleo family supporting ARM Cortex-M7
 STM32F746ZG microcontroller with 320KiB of RAM and 1 MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f207zg-and-more.svg "Pinout for the Nucleo-F746ZG (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 32)" width=50%
@ -34,15 +37,8 @@ STM32F746ZG microcontroller with 320KiB of RAM and 1 MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0253-stm32f7-series-and-stm32h7-series-cortexm7-processor-programming-manual-stmicroelectronics.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F746ZG is `nucleo-f746zg`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f746zg PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-f767zi/doc.md
+++ b/boards/nucleo-f767zi/doc.md
@ -7,6 +7,9 @@
 The Nucleo-F767ZI is a board from ST's Nucleo family supporting ARM Cortex-M7
 STM32F767ZI microcontroller with 512KiB of RAM and 2 MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-f207zg-and-more.svg "Pinout for the Nucleo-F767ZI (from STM user manual, UM1974, http://www.st.com/resource/en/user_manual/dm00244518.pdf, page 32)" width=50%
@ -34,15 +37,8 @@ STM32F767ZI microcontroller with 512KiB of RAM and 2 MiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0253-stm32f7-series-and-stm32h7-series-cortexm7-processor-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00244518-stm32-nucleo-144-boards-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-F767ZI is `nucleo-f767zi`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-f767zi PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-g070rb/doc.md
+++ b/boards/nucleo-g070rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-G070RB is a board from ST's Nucleo family supporting a ARM
 Cortex-M0+ STM32G070RB microcontroller with 36KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-g070rb-and-g071rb.svg "Pinout for the Nucleo-G070RG (from STM user manual UM2324, https://www.st.com/resource/en/user_manual/um2324-stm32-nucleo64-boards-mb1360-stmicroelectronics.pdf, page 34)" width=50%
@ -31,17 +34,8 @@ Cortex-M0+ STM32G070RB microcontroller with 36KiB of RAM and 128KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0223-stm32-cortexm0-mcus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2324-stm32-nucleo64-boards-mb1360-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-G070RB is `nucleo-g070rb`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-g070rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-g071rb/doc.md
+++ b/boards/nucleo-g071rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-G071RB is a board from ST's Nucleo family supporting a ARM
 Cortex-M0+ STM32G071RB microcontroller with 36KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-g070rb-and-g071rb.svg "Pinout for the Nucleo-G071RG (from STM user manual UM2324, https://www.st.com/resource/en/user_manual/um2324-stm32-nucleo64-boards-mb1360-stmicroelectronics.pdf, page 34)" width=50%
@ -31,17 +34,8 @@ Cortex-M0+ STM32G071RB microcontroller with 36KiB of RAM and 128KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0223-stm32-cortexm0-mcus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2324-stm32-nucleo64-boards-mb1360-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-G071RB is `nucleo-g071rb`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-g071rb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-g431rb/doc.md
+++ b/boards/nucleo-g431rb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-G431RB is a board from ST's Nucleo family supporting a ARM
 Cortex-M4 STM32G431RB microcontroller with 32KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-g431rb-and-more.svg "Pinout for the Nucleo-G431RB (from STM user manual UM2505, https://www.st.com/resource/en/user_manual/um2505-stm32g4-nucleo64-boards-mb1367-stmicroelectronics.pdf, page 29)" width=50%
@ -31,39 +34,8 @@ Cortex-M4 STM32G431RB microcontroller with 32KiB of RAM and 128KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2505-stm32g4-nucleo64-boards-mb1367-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-G431RB board includes an on-board ST-LINK V3 programmer. The
+The board name for the Nucleo-G431RB is `nucleo-g431rb`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-g431rb flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-g431rb debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-g431re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-G431RB board we recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-g474re/doc.md
+++ b/boards/nucleo-g474re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-G474RE is a board from ST's Nucleo family supporting a ARM
 Cortex-M4 STM32G474RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-g431rb-and-more.svg "Pinout for the Nucleo-G4741RE (from STM user manual UM2505, https://www.st.com/resource/en/user_manual/um2505-stm32g4-nucleo64-boards-mb1367-stmicroelectronics.pdf, page 29)" width=50%
@ -32,40 +35,8 @@ Cortex-M4 STM32G474RE microcontroller with 128KiB of RAM and 512KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2505-stm32g4-nucleo64-boards-mb1367-stmicroelectronics.pdf)|
 ## Flashing the Board
-## Flashing the device
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-### Flashing the Board Using OpenOCD
+The board name for the Nucleo-G474RE is `nucleo-g474re`.
 The ST Nucleo-G474RE board includes an on-board ST-LINK V3 programmer. The
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-g474re flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-g474re debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-g474re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-G474RE board we recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-l011k4/doc.md
+++ b/boards/nucleo-l011k4/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L011K4 is a board from ST's Nucleo family supporting ARM-Cortex-M0+
 STM32L011K4 microcontroller with 2KiB of RAM and 16KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-l432kc-and-more.svg "Pinout for the Nucleo-L011K4 (from STM user manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 32)" width=25%
--- a/boards/nucleo-l031k6/doc.md
+++ b/boards/nucleo-l031k6/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L031K6 is a board from ST's Nucleo family supporting ARM Cortex-M0
 STM32L031K6T6 microcontroller with 8KiB of RAM and 32KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-l432kc-and-more.svg "Pinout for the Nucleo-L031K6 (from STM user manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 32)" width=25%
--- a/boards/nucleo-l053r8/doc.md
+++ b/boards/nucleo-l053r8/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L053R8 is a board from ST's Nucleo family supporting a ARM
 Cortex-M0+ STM32L053R8 microcontroller with 8KiB of RAM and 32KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-l053r8.svg "Pinout for the Nucleo-L053r8 (from STM user manual UM1724, http://www.st.com/resource/en/user_manual/dm00105823.pdf, page 33)" width=50%
@ -32,17 +35,8 @@ Cortex-M0+ STM32L053R8 microcontroller with 8KiB of RAM and 32KiB of Flash.
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um1724-stm32-nucleo64-boards-mb1136-stmicroelectronics.pdf)|
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L053R8 is `nucleo-l053r8`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l053r8 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l073rz/doc.md
+++ b/boards/nucleo-l073rz/doc.md
@ -2,12 +2,14 @@
@ingroup     boards_common_nucleo64
@brief       Support for the STM32 Nucleo-L073RZ
 ## Overview
 The Nucleo-L073RZ is a board from ST's Nucleo family supporting ARM Cortex-M0
 STM32L073RZT6 microcontroller with 20KiB of RAM and 192KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-l073rz.svg "Pinout for the Nucleo-L073RZ (from STM user manual UM1724, http://www.st.com/resource/en/user_manual/dm00105823.pdf, page 33)" width=50%
@ -34,15 +36,8 @@ STM32L073RZT6 microcontroller with 20KiB of RAM and 192KiB of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0223-stm32-cortexm0-mcus-programming-manual-stmicroelectronics.pdf) |
 | Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/DM00105823.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L073RZ is `nucleo-l073rz`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l073rz PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l152re/doc.md
+++ b/boards/nucleo-l152re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L152RE is a board from ST's Nucleo family supporting a ARM
 Cortex-M3 STM32L152RE microcontroller with 80KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo64 L152RE](http://www.open-electronics.org/wp-content/uploads/2015/08/Figura2-500x467.png)
@ -51,32 +54,11 @@ Cortex-M3 STM32L152RE microcontroller with 80KiB of RAM and 512KiB of Flash.
 | Color  | green |
 | Pin    | PA5   |
 ## Flashing the Board
-## Supported Toolchains
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-For using the Nucleo-L152RE board we strongly recommend the usage of the [GNU
+The board name for the Nucleo-L152RE is `nucleo-l152re`.
 Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
 ## Flashing the device
 ### Flashing the Board Using OpenOCD
 Please use an OpenOCD version checked out after Jan. 26th 2015. Building
 instructions can be found [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD).
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l152re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Using UART
--- a/boards/nucleo-l412kb/doc.md
+++ b/boards/nucleo-l412kb/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L412KB is a board from ST's Nucleo family supporting ARM-Cortex-M4
 STM32L412KB microcontroller with 40KiB of RAM and 128KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-l432kc-and-more.svg "Pinout for the Nucleo-L412KB (from STM user manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 32)" width=25%
@ -34,15 +37,8 @@ STM32L412KB microcontroller with 40KiB of RAM and 128KiB of Flash.
 | Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L412KB is `nucleo-l412kb`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l412kb PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l432kc/doc.md
+++ b/boards/nucleo-l432kc/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L432KC is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32L432KCU6 microcontroller with 64KiB of RAM and 256KiB of Flash.
 You can find general information about the Nucleo32 boards on the
@ref boards_common_nucleo32 page.
 ## Pinout
@image html pinouts/nucleo-l432kc-and-more.svg "Pinout for the Nucleo-L432KC (from STM user manual, UM1956, https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf, page 32)" width=25%
@ -34,15 +37,8 @@ STM32L432KCU6 microcontroller with 64KiB of RAM and 256KiB of Flash.
 | Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um1956-stm32-nucleo32-boards-mb1180-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L432KC is `nucleo-l432kc`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l432kc PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l433rc/doc.md
+++ b/boards/nucleo-l433rc/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L433RC is a board from ST's Nucleo family supporting a ARM
 Cortex-M4 STM32L433RC microcontroller with 64KiB of RAM and 256KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ### Hardware
 ![Nucleo64 L433RC](https://www.st.com/bin/ecommerce/api/image.PF264788.en.feature-description-include-personalized-no-cpn-large.jpg)
@ -38,15 +41,8 @@ Cortex-M4 STM32L433RC microcontroller with 64KiB of RAM and 256KiB of Flash.
 | Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual   | [Board Manual](http://www.st.com/resource/en/user_manual/um2206-stm32-nucleo64p-boards-mb1319-stmicroelectronics.pdf) |
-### Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L433RC is `nucleo-l433rc`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l433rc PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l452re/doc.md
+++ b/boards/nucleo-l452re/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L452RE is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32L452RE microcontroller with 160KiB of RAM and 512KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-l452re.svg "Pinout for the Nucleo-L452RE (from STM board manual UM1724, http://www.st.com/resource/en/user_manual/dm00105823.pdf, page 34)" width=50%
@ -34,15 +37,8 @@ STM32L452RE microcontroller with 160KiB of RAM and 512KiB of Flash.
 | Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual   | [Board Manual](https://www.st.com/resource/en/user_manual/um1724-stm32-nucleo64-boards-mb1136-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L452RE is `nucleo-l452re`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l452re PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
--- a/boards/nucleo-l476rg/doc.md
+++ b/boards/nucleo-l476rg/doc.md
@ -2,12 +2,14 @@
@ingroup     boards_common_nucleo64
@brief       Support for the STM32 Nucleo-L476RG
 ## Overview
 The Nucleo-L476RG is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32L476RG microcontroller with 128KiB of RAM and 1MiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Pinout
@image html pinouts/nucleo-l476rg.svg "Pinout for the Nucleo-L476RG (from STM user manual UM1724, http://www.st.com/resource/en/user_manual/dm00105823.pdf, page 35)" width=50%
@ -35,39 +37,8 @@ STM32L476RG microcontroller with 128KiB of RAM and 1MiB of Flash.
 | Programming Manual | [Programming Manual](http://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual   | [Board Manual](https://www.st.com/content/ccc/resource/technical/document/user_manual/98/2e/fa/4b/e0/82/43/b7/DM00105823.pdf/files/DM00105823.pdf/jcr:content/translations/en.DM00105823.pdf) |
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-L476RG board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-L476RG is `nucleo-l476rg`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-l476rg flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-l476rg debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l476rg PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-L476RG board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-l496zg/doc.md
+++ b/boards/nucleo-l496zg/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L496ZG is a board from ST's Nucleo family supporting ARM Cortex-M4
 STM32L496ZG ultra-low-pawer microcontroller with 320KiB of RAM and 1 MiB of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Pinout
@image html pinouts/nucleo-l496zg.svg "Pinout for the Nucleo-L496ZG (from STM user manual, UM2179, https://www.st.com/resource/en/user_manual/um2179-stm32-nucleo144-boards-mb1312-stmicroelectronics.pdf, page 31)" width=55%
@ -33,15 +36,8 @@ STM32L496ZG ultra-low-pawer microcontroller with 320KiB of RAM and 1 MiB of Flas
 | Programming Manual | [Programming Manual](https://www.st.com/content/ccc/resource/technical/document/programming_manual/6c/3a/cb/e7/e4/ea/44/9b/DM00046982.pdf/files/DM00046982.pdf/jcr:content/translations/en.DM00046982.pdf) |
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2179-stm32-nucleo144-boards-mb1312-stmicroelectronics.pdf) |
-## Flashing the Board Using ST-LINK Removable Media
+## Flashing the Board
-On-board ST-LINK programmer provides via composite USB device removable media.
+A detailed description about the flashing process can be found on the
-Copying the HEX file causes reprogramming of the board. This task
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-could be performed manually; however, the cpy2remed (copy to removable
+The board name for the Nucleo-L496ZG is `nucleo-l496zg`.
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l496zg PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
      can be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html
--- a/boards/nucleo-l4r5zi/doc.md
+++ b/boards/nucleo-l4r5zi/doc.md
@ -7,6 +7,9 @@
 The Nucleo-L4R5ZI is a board from ST's Nucleo family supporting a ARM Cortex-M4
 STM32L4R5ZI microcontroller with 640KiB of RAM and 2MiB of ROM Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
 ![Nucleo144 L4R5ZI](https://www.st.com/bin/ecommerce/api/image.PF264781.en.feature-description-include-personalized-no-cpn-large.jpg)
@ -37,43 +40,8 @@ STM32L4R5ZI microcontroller with 640KiB of RAM and 2MiB of ROM Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0214-stm32-cortexm4-mcus-and-mpus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/um2179-stm32-nucleo144-boards-mb1312-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-L4R5ZI board includes an on-board ST-LINK programmer and can be
+The board name for the Nucleo-L4R5ZI is `nucleo-l4r5zi`.
 flashed using OpenOCD.
@note The latest release of OpenOCD doesn't contain support for this board,
 so a recent development version (including  http://openocd.zylin.com/#/c/4777)
 must be built from source to be able to flash this board.
 To flash this board, just use the following command:
 ```
 make BOARD=nucleo-l4r5zi flash -C examples/basic/hello-world
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l4r5zi PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller LPUART1.
 The default baud rate is 115 200.
 Use the `term` target to open a terminal:
    make BOARD=nucleo-l4r5zi -C examples/basic/hello-world term
--- a/boards/nucleo-l552ze-q/doc.md
+++ b/boards/nucleo-l552ze-q/doc.md
@ -8,6 +8,9 @@ The Nucleo-L552ZE-Q is a board from ST's Nucleo family supporting ARM Cortex-M33
 STM32L552ZE ultra-low-pawer microcontroller with TrustZone, 256KiB of RAM and 512KiB
 of Flash.
 You can find general information about the Nucleo144 boards on the
@ref boards_common_nucleo144 page.
 ## Hardware
 ![Nucleo144 L552ZE-Q](https://www.st.com/bin/ecommerce/api/image.PF267817.en.feature-description-include-personalized-no-cpn-large.jpg)
@ -33,68 +36,8 @@ of Flash.
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0264-stm32-cortexm33-mcus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/dm00615305-stm32l5-nucleo-144-board-mb1361-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-L552ZE-Q board includes an on-board ST-LINK programmer and can be
+The board name for the Nucleo-L552ZE-Q is `nucleo-l552ze-q`.
 flashed using OpenOCD.
@note The upstream version of OpenOCD doesn't contain yet support for this board,
 so the source code version from http://openocd.zylin.com/#/c/5510
 must be built to be able to flash this board (adapt the configure command with
 your preferred installation directory):
 ```
 $ git clone https://git.code.sf.net/p/openocd/code openocd
 $ cd openocd
 $ git fetch http://openocd.zylin.com/openocd refs/changes/10/5510/5 && git checkout FETCH_HEAD
 $ ./bootstrap
 $ ./configure --prefix=<installation directory>
 $ make -j
 $ sudo make install
 ```
 Once the patched OpenOCD is built and installed, you can flash the board simply
 by typing
 ```
 make BOARD=nucleo-l552ze-q flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-l552ze-q debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-l552ze-q PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. ST-LINK is connected to the
 microcontroller LPUART1.
 The default baud rate is 115 200.
 If a physical connection to LPUART1 is needed, connect UART interface to pins
 PG7 (LPUART1 TX) and PG8 (LPUART1 RX).
@note Accordingly to the [MCU Datasheet](https://www.st.com/resource/en/datasheet/stm32l552ze.pdf)
 PG7 and PG8 pins are 5V tolerant (see table 21, page 108).
 ## Supported Toolchains
 For using the ST Nucleo-L552ZE-Q board we recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/nucleo-u575zi-q/doc.md
+++ b/boards/nucleo-u575zi-q/doc.md
@ -8,6 +8,9 @@ The Nucleo-U575ZI-Q is a board from ST's Nucleo family supporting the ARM Cortex
 STM32U575ZIT6Q ultra-low-power microcontroller with TrustZone, 768KiB of RAM and 2MiB
 of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![Nucleo144 U575ZI-Q](https://www.st.com/bin/ecommerce/api/image.PF271812.en.fea
@ -33,23 +36,11 @@ ture-description-include-personalized-no-cpn-medium.jpg)
 | Programming Manual | [Programming Manual](https://www.st.com/resource/en/programming_manual/pm0264-stm32-cortexm33-mcus-programming-manual-stmicroelectronics.pdf)|
 | Board Manual | [Board Manual](https://www.st.com/resource/en/user_manual/um2861-stm32u5-nucleo144-board-mb1549-stmicroelectronics.pdf)|
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-U575ZI-Q board includes an on-board ST-LINK programmer and can be
+The board name for the Nucleo-U575ZI-Q is `nucleo-u575zi-q`.
 flashed using OpenOCD.
 Once OpenOCD is installed, you can flash the board simply by typing
 ```
 make BOARD=nucleo-u575zi-q flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-u575zi-q debug
 ```
 ## Accessing RIOT shell
--- a/boards/nucleo-wl55jc/doc.md
+++ b/boards/nucleo-wl55jc/doc.md
@ -8,6 +8,9 @@ The Nucleo-W55JC is a board from ST's Nucleo family supporting ARM dual-core
 Cortex-M4/M0 STM ultra-low-power microcontroller with ultra-low-power LPWAN
 radio solution, 64KiB of RAM and 256KiB of Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ### MCU
@ -34,38 +37,8 @@ radio solution, 64KiB of RAM and 256KiB of Flash.
 | Board Schematic | [Board Schematic](https://www.st.com/resource/en/user_manual/dm00622917-stm32wl-nucleo64-board-mb1389-stmicroelectronics.pdf) |
 | Additional Reference | [Developing LoRaWAN Application](https://www.st.com/resource/en/application_note/dm00660451-how-to-build-a-lora-application-with-stm32cubewl-stmicroelectronics.pdf)
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST Nucleo-wl55jc board includes an on-board ST-LINK V2 programmer. The
+The board name for the Nucleo-WL55JC is `nucleo-wl55jc`.
 easiest way to program the board is to use OpenOCD. Once you have installed
 OpenOCD (look [here](https://github.com/RIOT-OS/RIOT/wiki/OpenOCD) for
 installation instructions), you can flash the board simply by typing
 ```
 make BOARD=nucleo-wl55jc flash
 ```
 and debug via GDB by simply typing
 ```
 make BOARD=nucleo-wl55jc debug
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task
 could be performed manually; however, the cpy2remed (copy to removable
 media) PROGRAMMER script does this automatically. To program board in
 this manner, use the command:
 ```
 make BOARD=nucleo-wl55jc PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/stsw-link007.html).
 ## Supported Toolchains
 For using the ST Nucleo-wl55jc board we strongly recommend the usage of the
 [GNU Tools for ARM Embedded Processors](https://launchpad.net/gcc-arm-embedded)
 toolchain.
--- a/boards/p-nucleo-wb55/doc.md
+++ b/boards/p-nucleo-wb55/doc.md
@ -10,6 +10,9 @@ Bluetooth® Low Energy (BLE) SIG specification v5.0 and with IEEE
 802.15.4-2011 board. It integrates an ARM Cortex-M4 STM32WB55RG microcontroller
 with 256KB of RAM and 1MB of ROM Flash.
 You can find general information about the Nucleo64 boards on the
@ref boards_common_nucleo64 page.
 ## Hardware
 ![st-nucleo-wb55](https://miro.medium.com/max/700/1*9OG-4Ix4EzHX9uBpMve2IA.jpeg)
@ -45,47 +48,11 @@ with 256KB of RAM and 1MB of ROM Flash.
 [Reference Manual]: https://www.st.com/resource/en/reference_manual/rm0434-multiprotocol-wireless-32bit-mcu-armbased-cortexm4-with-fpu-bluetooth-lowenergy-and-802154-radio-solution-stmicroelectronics.pdf
 [User Manual]: https://www.st.com/content/ccc/resource/technical/document/user_manual/group1/13/58/22/1a/f2/ff/43/5c/DM00517423/files/DM00517423.pdf/jcr:content/translations/en.DM00517423.pdf
-## Flashing the device
+## Flashing the Board
-### Flashing the Board Using OpenOCD
+A detailed description about the flashing process can be found on the
-
+[guides page](https://guide.riot-os.org/board_specific/stm32/).
-The ST p-nucleo-wb55 board includes an on-board ST-LINK programmer and can be
+The board name for the P-Nucleo-WB55 is `p-nucleo-wb55`.
 flashed using OpenOCD (use version 0.11.0 at least).
 To flash this board, just use the following command:
 ```
 make BOARD=p-nucleo-wb55 flash -C examples/basic/hello-world
 ```
 ### Flashing the Board Using ST-LINK Removable Media
 On-board ST-LINK programmer provides via composite USB device removable media.
 Copying the HEX file causes reprogramming of the board. This task could be
 performed manually; however, the cpy2remed (copy to removable media) PROGRAMMER
 script does this automatically. To program board in this manner, use the command:
 ```
 make BOARD=p-nucleo-wb55 PROGRAMMER=cpy2remed flash
 ```
@note This PROGRAMMER was tested using ST-LINK firmware 2.37.26. Firmware updates
 could be found on [this STM webpage](https://www.st.com/en/development-tools/sts
 -link007.html).
 ## Accessing RIOT shell
 Default RIOT shell access utilize VCP (Virtual COM Port) via USB interface,
 provided by integrated ST-LINK programmer. In default configuration ST-LINK
 is connected to the microcontroller USART1. For more details See table 7,
 page 33 in board User Manual.
 The default baud rate is 115 200.
 Use the `term` target to open a terminal:
 ```
 make BOARD=p-nucleo-wb55 -C examples/basic/hello-world term
 ```
 ## User Interface