kaspar/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2025-12-15 17:43:51 +01:00
Code Releases Activity

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

Browse Source
This commit is contained in:
crasbe 2025-03-29 23:35:58 +01:00
parent 9fbb80a3e0
commit b6931afd15
47 changed files with 319 additions and 1128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
boards/nucleo-c031c6/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-C031C6 is `nucleo-c031c6`.

3
boards/nucleo-c071rb/doc.md
View File

@ -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.

40
boards/nucleo-f030r8/doc.md
View File

@ -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
The ST Nucleo-F030R8 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F030R8 is `nucleo-f030r8`.

18
boards/nucleo-f031k6/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F031K6 is `nucleo-f031k6`.

18
boards/nucleo-f042k6/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F042K6 is `nucleo-f042k6`.

40
boards/nucleo-f070rb/doc.md
View File

@ -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
The ST Nucleo-F070RB 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F070RB is `nucleo-f070rb`.

40
boards/nucleo-f072rb/doc.md
View File

@ -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
The ST Nucleo-F072RB 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F072RB is `nucleo-f072rb`.

40
boards/nucleo-f091rc/doc.md
View File

@ -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
The ST Nucleo-F091RC 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F091RC is `nucleo-f091rc`.

40
boards/nucleo-f103rb/doc.md
View File

@ -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
The ST Nucleo-F103RB 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:
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F103RB is `nucleo-f103rb`.

43
boards/nucleo-f207zg/doc.md
View File

@ -5,8 +5,10 @@
## Overview
The Nucleo-F207ZG is a board from ST's Nucleo family supporting a ARM
Cortex-M3
STM32F207ZG microcontroller with 128KiB of SRAM and 1MiB of ROM Flash.
Cortex-M3 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
The ST Nucleo-F207ZG board includes an on-board ST-LINK V2-1 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F207ZG is `nucleo-f207zg`.

38
boards/nucleo-f302r8/doc.md
View File

@ -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
The ST Nucleo-F302R8 board includes an on-board ST-LINK V2-1 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F302R8 is `nucleo-f302r8`.

39
boards/nucleo-f303k8/doc.md
View File

@ -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
The ST Nucleo-F303K8 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F303K8 is `nucleo-f303k8`.

41
boards/nucleo-f303re/doc.md
View File

@ -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
### Flashing the Board Using OpenOCD
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F303RE is `nucleo-f303re`.

42
boards/nucleo-f303ze/doc.md
View File

@ -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
### Flashing the Board Using OpenOCD
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F303ZE is `nucleo-f303ze`.

49
boards/nucleo-f334r8/doc.md
View File

@ -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
The ST Nucleo-F334R8 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F334R8 is `nucleo-f334r8`.

42
boards/nucleo-f401re/doc.md
View File

@ -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
The ST Nucleo-F401RE 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
```
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.
A detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F401RE is `nucleo-f401re`.
## Issues with old Hardware Revisions

44
boards/nucleo-f410rb/doc.md
View File

@ -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
The ST Nucleo-F410RB board includes an on-board ST-LINK V2 programmer. The
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F401RB is `nucleo-f401rb`.

42
boards/nucleo-f411re/doc.md
View File

@ -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
The ST Nucleo-F411RE board includes an on-board ST-LINK V2-1 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F411RE is `nucleo-f411re`.

19
boards/nucleo-f412zg/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F412ZG is `nucleo-f412zg`.

18
boards/nucleo-f413zh/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F413ZH is `nucleo-f413zh`.

36
boards/nucleo-f429zi/doc.md
View File

@ -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
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F429ZI is `nucleo-f429zi`.

28
boards/nucleo-f439zi/doc.md
View File

@ -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
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F439ZI is `nucleo-f439zi`.

41
boards/nucleo-f446re/doc.md
View File

@ -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
The ST Nucleo-F446RE 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F446RE is `nucleo-f446re`.

41
boards/nucleo-f446ze/doc.md
View File

@ -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
The ST Nucleo-F446ZE 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F446ZE is `nucleo-f446ze`.

26
boards/nucleo-f722ze/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F722ZE is `nucleo-f722ze`.

18
boards/nucleo-f746zg/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F746ZG is `nucleo-f746zg`.

18
boards/nucleo-f767zi/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-F767ZI is `nucleo-f767zi`.

20
boards/nucleo-g070rb/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-G070RB is `nucleo-g070rb`.

20
boards/nucleo-g071rb/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-G071RB is `nucleo-g071rb`.

42
boards/nucleo-g431rb/doc.md
View File

@ -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
The ST Nucleo-G431RB 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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-G431RB is `nucleo-g431rb`.

43
boards/nucleo-g474re/doc.md
View File

@ -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
### Flashing the Board Using OpenOCD
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-G474RE is `nucleo-g474re`.

3
boards/nucleo-l011k4/doc.md
View File

@ -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%

3
boards/nucleo-l031k6/doc.md
View File

@ -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%

20
boards/nucleo-l053r8/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L053R8 is `nucleo-l053r8`.

19
boards/nucleo-l073rz/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L073RZ is `nucleo-l073rz`.

32
boards/nucleo-l152re/doc.md
View File

@ -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
For using the Nucleo-L152RE board we strongly recommend the usage of the [GNU
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).
A detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L152RE is `nucleo-l152re`.
## Using UART

18
boards/nucleo-l412kb/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L412KB is `nucleo-l412kb`.

18
boards/nucleo-l432kc/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L432KC is `nucleo-l432kc`.

18
boards/nucleo-l433rc/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L433RC is `nucleo-l433rc`.

18
boards/nucleo-l452re/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L452RE is `nucleo-l452re`.

43
boards/nucleo-l476rg/doc.md
View File

@ -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
The ST Nucleo-L476RG 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L476RG is `nucleo-l476rg`.

18
boards/nucleo-l496zg/doc.md
View File

@ -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.
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-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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L496ZG is `nucleo-l496zg`.

46
boards/nucleo-l4r5zi/doc.md
View File

@ -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
The ST Nucleo-L4R5ZI board includes an on-board ST-LINK programmer and can be
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L4R5ZI is `nucleo-l4r5zi`.

71
boards/nucleo-l552ze-q/doc.md
View File

@ -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
The ST Nucleo-L552ZE-Q board includes an on-board ST-LINK programmer and can be
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-L552ZE-Q is `nucleo-l552ze-q`.

23
boards/nucleo-u575zi-q/doc.md
View File

@ -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
The ST Nucleo-U575ZI-Q board includes an on-board ST-LINK programmer and can be
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
```
A detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-U575ZI-Q is `nucleo-u575zi-q`.
## Accessing RIOT shell

41
boards/nucleo-wl55jc/doc.md
View File

@ -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
The ST Nucleo-wl55jc 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
```
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 detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the Nucleo-WL55JC is `nucleo-wl55jc`.

47
boards/p-nucleo-wb55/doc.md
View File

@ -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
The ST p-nucleo-wb55 board includes an on-board ST-LINK programmer and can be
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
```
A detailed description about the flashing process can be found on the
[guides page](https://guide.riot-os.org/board_specific/stm32/).
The board name for the P-Nucleo-WB55 is `p-nucleo-wb55`.
## User Interface