In this guide, you’ll find the Nucleo-F103RB pinout diagram, its datasheet and schematic diagram, and every pin group explained with its default pins, its AFIO remaps, and its gotchas. Without further ado, let’s get right into it!
The Nucleo-F103RB is ST’s official Nucleo-64 board for the STM32F103RB, a 72MHz Arm Cortex-M3 (no FPU) with 128KB Flash and 20KB RAM, from the same STM32F1 family as the Blue Pill. It gives you 51 GPIO pins on the Arduino Uno and ST Morpho headers and an on-board ST-LINK debugger, but many of its pins are not 5V-tolerant, and several Arduino functions only work after an AFIO remap.
Nucleo-F103RB Pinout Diagram
Here is a detailed Nucleo-F103RB Pinout Diagram with colored labels and legends to help you easily identify the functionalities that each pin can perform. This first diagram covers the Arduino Uno V3 headers (CN5, CN6, CN8 and CN9), which is where most shields and jumper wires go.
Each row shows the header pin number, the Arduino name (D0–D15, A0–A5), the STM32 GPIO name and its functions, color-coded by peripheral. A function with a small superscript R (like I2C1_SCLR on D15) is only available after an AFIO remap, which we explain below. The filled dot marks a 5v-tolerant pin, the hollow square marks a 3.3v-only pin, the dashed lines mark pins that aren’t connected by default, and the numbered badges point to the notes at the bottom of the diagram.
Nucleo-F103RB Morpho CN7 Pinout
The left ST Morpho header CN7 is a 2×19 male header. Odd pins (1, 3, 5…37) are on the outer column, and even pins are on the inner column, with pin 1 at the top, next to the ST-LINK part of the board.
Nucleo-F103RB Morpho CN10 Pinout
The right ST Morpho header CN10 is also 2×19, but here the odd pins are on the inner column. It carries the peripherals that the Arduino headers don’t have, like the USB and CAN pins (PA11/PA12), SPI2, I2C2_SDA (PB11) and the BOOT1 pin (PB2).
Every Arduino header signal is also present on the Morpho headers (for example, D13/PA5 is also CN10-11), so the Morpho headers are a superset: all 51 GPIOs of the STM32F103RB are on CN7 and CN10, and 46 of them are connected by default.
Buy a Nucleo-F103RB: If you don’t have one yet, you can get the official ST board from Amazon or AliExpress. It comes with the ST-LINK debugger on board, so you can start programming it right away.
Download Nucleo-F103RB Pinout Diagrams (Full Resolution)
All 3 Nucleo-F103RB pinout diagrams (Arduino headers, CN7 and CN10 morpho) in full resolution (5120×2800 px WebP), in one ZIP file. Print them, zoom in, or keep them next to your bench. Please consider supporting my work if it helped you.
Nucleo-F103RB Datasheet
This development board is built around the STM32F103RBT6 microcontroller (LQFP64 package). Here are the official Nucleo-F103RB datasheet and documents you’ll need for it, all linked to ST’s own servers so you always get the latest revision:
| Document | ID | Revision | What you’ll use it for | Link |
|---|---|---|---|---|
| STM32F103x8/xB datasheet | DS5319 | Rev 20 (Jul 2025) | Pin definitions with the Default/Remap columns, 5v-tolerant (FT) pins, electrical limits | |
| STM32F101xx–F107xx reference manual | RM0008 | Rev 21 (Feb 2021) | Registers, and the AFIO remap tables (section 9.3) | |
| STM32 Nucleo-64 boards (MB1136) user manual | UM1724 | Rev 17 (Sep 2025) | Board pinout tables, jumpers, solder bridges, power options | |
| STM32 Nucleo-64 boards data brief | DB2196 | Rev 23 (Oct 2026) | One-page board summary and order codes | |
| STM32F101x8/B, F102x8/B, F103x8/B errata sheet | ES096 | Rev 15 (Mar 2022) | Known silicon limitations, including the PB5 and I2C ones below | |
| MB1136 board schematic | MB1136 C-05 | Rev C-05 | Full board circuit (see the next section) |
Which document do I need? The datasheet for pin functions and electrical limits, the reference manual for registers and the AFIO remaps, and the UM1724 user manual for jumpers, solder bridges, and the header map. The board documents are on the official NUCLEO-F103RB product page, and the chip documents on the STM32F103RB product page.
Note: UM1724 Table 12 lists I2C1 on D14/D15 and PWM on D3, D5, D6 and D9 without saying that each of them needs an AFIO remap on the F103. The DS5319 datasheet (Table 5, Default and Remap columns) is the one to trust, and our diagrams follow it.
Nucleo-F103RB Schematic
The Nucleo-F103RB schematic is shown below; it is the latest revision, and the current F103RB product is built on it.
Here are its 4 schematic sheets; click a page to view it full screen.
Official source: MB1136 C-05 schematic (PDF) from the NUCLEO-F103RB product page (CAD Resources). Here’s what to look at on each sheet:
- Power path (sheet 1): USB 5v (U5V) goes through a power switch that the ST-LINK turns on only after the PC grants 300mA. VIN (7v–12v) feeds the LD1117S50 5v regulator, and jumper JP5 picks U5V or E5V. The 5v rail then feeds the LD39050PU33R 3.3v regulator (500mA) that powers the MCU.
- Solder bridges (sheet 2): SB13/SB14 route PA2/PA3 to the ST-LINK Virtual COM port, SB62/SB63 (open) keep them off D1/D0, SB51/SB56 put PC0/PC1 on A5/A4, and SB21 connects LD2 to PA5. Note that PB2 (BOOT1) has no resistor on this sheet, so it floats.
- Clocks (sheet 2): there’s no 8MHz crystal on the MCU side. X3 is not fitted, and the ST-LINK feeds an 8MHz MCO clock into PD0-OSC_IN (SB16, SB50). The 32.768kHz crystal X2 sits on PC14/PC15 for the RTC.
- ST-LINK/V2-1 (sheet 3): a separate STM32F103CBT6 does the SWD debugging (PA13/PA14, PB3 SWO, NRST), the USB mass-storage flashing, and the Virtual COM port. Removing the two CN2 jumpers frees it to debug an external board on CN4.
- Extension connectors (sheet 4): the Arduino (CN5/CN6/CN8/CN9) and Morpho (CN7/CN10) headers, with every solder-bridge option drawn next to the pin it changes. PB11 reaches CN10-18 here as a normal I/O (C25/C26 are not fitted).
Nucleo-F103RB Specs
The Nucleo-F103RB combines a 72MHz STM32F103RBT6 with the standard Nucleo-64 board (MB1136 rev C). Here are its specifications, including the board-level parts that chip-only spec lists usually skip.

Get a Nucleo-F103RB: The official ST board is the one I recommend. Grab it from Amazon or AliExpress.
| Item | Nucleo-F103RB |
|---|---|
| MCU | STM32F103RBT6, LQFP64 |
| Core | Arm Cortex-M3, up to 72MHz, 1.25 DMIPS/MHz, single-cycle multiply and hardware divide, no FPU |
| Memory | 128KB Flash, 20KB SRAM |
| Logic level | 3.3v (only some pins are 5v tolerant, see below) |
| GPIO pins | 51 on the Morpho headers (46 connected by default), 22 on the Arduino headers (20 connected by default) |
| Board supply | USB 5v (300mA), VIN 7v–12v, E5V 4.75v–5.25v, or 3.3v direct |
| 5v regulator | LD1117S50: 800mA at 7v in, 450mA at 7v–9v, 250mA at 9v–12v |
| 3.3v regulator | LD39050PU33R, 500mA |
| Clocks | 8MHz MCO from the ST-LINK into PD0-OSC_IN (HSE bypass), 32.768kHz LSE crystal (X2); X3 HSE crystal not fitted |
| Debugger | On-board ST-LINK/V2-1 (snap-off): SWD, drag-and-drop flashing, Virtual COM port on USART2 |
| USB connector | Mini-B (CN1), for the ST-LINK only |
| Headers | Arduino Uno V3 (CN5, CN6, CN8, CN9) + two 2×19 ST Morpho headers (CN7, CN10) |
| User I/O | LD2 green LED (PA5), B1 user button (PC13), B2 reset button |
| Low power (MCU) | Stop 14µA (low-power regulator), Standby 2µA, VBAT 1.4µA with the RTC on (typical, from DS5319) |
| PCB | MB1136 rev C (current production C-05), the same PCB as the Nucleo-F401RE, F411RE and F446RE |
Nucleo-F103RB Specifications Summary
- The Nucleo-F103RB runs the STM32F103RBT6 (Cortex-M3, no FPU) at up to 72MHz with 128KB Flash and 20KB RAM.
- All 51 GPIOs are on the Morpho headers; the Arduino headers carry 22 of them (D0/D1 are disconnected by default).
- Not 5v tolerant: PA0–PA7, PB0, PB1, PB5, PC0–PC5, PC13–PC15 and PD0/PD1. On the Arduino headers, that’s A0–A5, D0, D1, D4, D11, D12 and D13.
- It has 2x 12-bit ADCs (1µs conversion) sharing 16 external channels; 9 ADC pins are on the Arduino headers (A0–A5, D11–D13).
- There is no DAC, no I²S and no SDIO on the STM32F103RB.
- 16 Arduino pins can output PWM, but D3, D4, D5, D6 and D9 only after an AFIO timer remap.
- It has 3 USARTs. USART2 on PA2/PA3 is the ST-LINK Virtual COM port, not D0/D1.
- The default I2C1 pins are PB6 (D10, SCL) and PB7 (CN7-21, SDA). D15/D14 (PB8/PB9) are I2C1 only after the I2C1 remap.
- The default SPI pins are D13 (SCK), D12 (MISO), D11 (MOSI) on SPI1.
- USB 2.0 FS (device only) and bxCAN share PA11/PA12 on CN10 and can’t be used at the same time.
- The user LED LD2 is on PA5 (D13), and the user button B1 is on PC13.
- VIN accepts 7v–12v, and the 3.3v regulator gives up to 500mA.
Nucleo-F103RB Peripherals: MCU vs On the Headers
The STM32F103RB has more peripherals than the Arduino headers can show. This table tells you what the chip has and where you can actually reach it on the board.
| Peripheral | STM32F103RB (LQFP64) | On the Arduino headers | On the Morpho headers |
|---|---|---|---|
| ADC | 2x 12-bit, 1µs, 16 external channels | 9 pins (A0–A5, D11–D13) | 14 pins by default, 16 after SB62/SB63 |
| DAC | None | – | – |
| Timers | TIM1 (advanced), TIM2/TIM3/TIM4 (16-bit, 4 channels each) | 16 PWM pins (5 need a remap) | 27 PWM pins |
| USART | USART1, USART2, USART3 | USART1 (D8/D2), USART3_TX (D6); USART2 only after SB62/SB63 | all three |
| SPI | SPI1, SPI2 (18Mbit/s, no I²S) | SPI1 on D13/D12/D11, or D3/D5/D4 after a remap | SPI1, SPI2 |
| I²C | I2C1, I2C2 | I2C1 on D15/D14 (remap) or SCL on D10; I2C2_SCL on D6 | both |
| CAN | 1x bxCAN 2.0B active | D15/D14 after the CAN remap | PA11/PA12 (default) |
| USB | 1x USB 2.0 FS device | – | PA11 (DM), PA12 (DP) |
| Others | 7-channel DMA, RTC, CRC, 96-bit unique ID | – | – |
Nucleo-F103RB Quick Pin Selection Guide
Not sure which pin to use? Here are the Nucleo-F103RB pins I’d pick first for each job, and why.
| Use case | Recommended pins | Why |
|---|---|---|
| Serial to the PC | USART2 (PA2/PA3) via USB | Already wired to the ST-LINK Virtual COM port; Serial in Arduino |
| Serial to a module (GPS, Bluetooth…) | USART1: D8 (TX), D2 (RX) | Default pins, no remap, 5v tolerant |
| I2C sensors and displays | D15 (SCL), D14 (SDA) with the I2C1 remap | The Arduino SCL/SDA spot; STM32duino and CubeMX set the remap for you |
| SPI devices | D13 (SCK), D12 (MISO), D11 (MOSI), D10 (CS) | The default SPI pins (SPI1), no remap |
| PWM without remaps | D2, D7, D8 (TIM1), D10, D14, D15 (TIM4), D11, D12, A3 (TIM3) | Default timer channels, so no conflicts to manage |
| Analog inputs | A0, A1, A2, A3, A4, A5 | 0v–3.3v only, never 5v |
| 5v logic inputs | D2, D3, D5–D10, D14, D15 | These are the 5v-tolerant (FT) Arduino pins |
| CAN or USB device | PA11, PA12 on CN10 | Default pins for both (one at a time) |
| On-board LED / button | PA5 (LD2), PC13 (B1) | LED_BUILTIN and USER_BTN in Arduino |
| Safest general GPIO | D2, D7, D8 and the Morpho-only PC6–PC12, PD2, PB12–PB15 | 5v tolerant, no board load, no debug or boot role |
Nucleo-F103RB Pins to Use With Caution
| Pin | Reason | What to do |
|---|---|---|
| A0–A5, D0, D1, D4, D11–D13 (and PB1, PC2–PC5) | Not 5v tolerant (4.0v absolute max) | Keep them at 0v–3.3v; use a divider or a level shifter for 5v signals |
| PB5 (D4) | Not 5v tolerant, and the ES096 errata blocks its TIM3_CH2 and SPI1_MOSI outputs while I2C1 is clocked | Use D11 for TIM3_CH2 PWM, and SPI1 on its default pins |
| PC7 (D9) | PWM only with the TIM3 full remap, which takes TIM3 off D11, D12 and A3 | Use D10 or D7 for PWM instead |
| PA5 (D13) | Drives LED LD2 (via SB21) | Expect the LED load on SPI SCK; open SB21 for a clean signal |
| PA2, PA3 (D1, D0) | Wired to the ST-LINK Virtual COM port, disconnected from D0/D1 | Use USART1 for header serial, or close SB62/SB63 and open SB13/SB14 |
| PA13, PA14 | SWD pins of the ST-LINK | Don’t reuse them, or you lose debugging |
| PB3 (D3), PB4 (D5), PA15 | JTAG pins (JTDO/SWO, NJTRST, JTDI) after reset | Disable JTAG (keep SWD) to use them |
| PB2 | BOOT1, and it floats on this board | Tie it to GND when you use the system bootloader |
| PC13, PC14, PC15 | Backup-domain pins: 3mA sink max, 2MHz max, never a current source | Use them for inputs only; PC14/PC15 are taken by X2 |
| PD0, PD1 | PD0 gets the 8MHz MCO; both are GPIO only after the PD01 remap, and never EXTI on this package | Leave them alone unless you switch to HSI |
| PC0, PC1 (A5, A4) | Not I2C | Use D15/D14 for I2C, or change SB46/SB51/SB52/SB56 |
Nucleo-F103RB Pins Functions
The 51 GPIO pins of the Nucleo-F103RB are divided into the following groups based on the hardware functionality they’re used for. Most pins have several functions, so one pin can belong to more than one group.
- Power Pins: VIN, 5V, 3V3, IOREF, E5V, U5V, AVDD, VBAT, GND
- 51x Digital GPIO Pins (22 on the Arduino headers), 29 of them 5v tolerant
- 16x External Interrupt Lines
- 16x ADC Analog Input Pins (9 on the Arduino headers)
- 27x PWM Pins (16 on the Arduino headers)
- 3x UART Ports
- 2x I2C Buses
- 2x SPI Ports
- 1x CAN and 1x USB Device (Morpho, or CAN on D15/D14 after a remap)
- Debug (SWD) & Boot Pins
Before we discuss each pin group one by one, there’s one STM32F1 feature you need to understand, because it changes how several Arduino pins behave: the AFIO remap.
Nucleo-F103RB AFIO Remap: Default vs Remapped Pins
On the Nucleo-F103RB, every peripheral has one default set of pins, plus up to three remap options that move it to other pins. Unlike the newer STM32F4 Nucleo boards, the STM32F1 has no per-pin alternate-function numbers: you pick a mapping per peripheral in the AFIO_MAPR register, and a remap moves all of that peripheral’s pins at once.
That’s why the diagrams mark some functions with a superscript R. These are the remaps that matter on the Arduino headers (RM0008 section 9.3, DS5319 Table 5):
| Peripheral | Default Pins | Remapped Pins | HAL Macro |
|---|---|---|---|
| I2C1 | SCL PB6 (D10), SDA PB7 (CN7-21) | SCL PB8 (D15), SDA PB9 (D14) | __HAL_AFIO_REMAP_I2C1_ENABLE() |
| SPI1 | D13, D12, D11, NSS A2 (PA4) | SCK D3, MISO D5, MOSI D4, NSS PA15 | __HAL_AFIO_REMAP_SPI1_ENABLE() |
| USART1 | TX D8 (PA9), RX D2 (PA10) | TX D10 (PB6), RX PB7 | __HAL_AFIO_REMAP_USART1_ENABLE() |
| USART3 | TX D6 (PB10), RX PB11 | Partial: TX PC10, RX PC11 (CN7-1/2) | __HAL_AFIO_REMAP_USART3_PARTIAL() |
| TIM2 | CH1 A0, CH2 A1, CH3 PA2, CH4 PA3 | Partial 1: CH1 PA15, CH2 D3. Partial 2: CH3 D6, CH4 PB11. Full: all four | __HAL_AFIO_REMAP_TIM2_ENABLE() (full) |
| TIM3 | CH1 D12, CH2 D11, CH3 A3, CH4 PB1 | Partial: CH1 D5, CH2 D4. Full: PC6, PC7 (D9), PC8, PC9 | __HAL_AFIO_REMAP_TIM3_PARTIAL() / _ENABLE() |
| CAN | RX PA11, TX PA12 | RX PB8 (D15), TX PB9 (D14) | __HAL_AFIO_REMAP_CAN1_2() |
| JTAG | PA15, PB3, PB4 are JTAG pins | JTAG off, SWD on: frees PA15, PB3 (D3), PB4 (D5) | __HAL_AFIO_REMAP_SWJ_NOJTAG() |
If you configure the pins in STM32CubeMX (or CubeIDE), it writes these remap calls for you when you pick a remapped pin, and the STM32duino Arduino core applies them automatically too. You only write them yourself with bare HAL or register code. Here’s a short example that puts I2C1 on D15/D14 and frees D3/D5 from JTAG:
|
1 2 3 4 5 6 7 8 9 10 11 |
__HAL_RCC_AFIO_CLK_ENABLE(); // the AFIO clock must be on first __HAL_RCC_GPIOB_CLK_ENABLE(); __HAL_AFIO_REMAP_SWJ_NOJTAG(); // JTAG off, SWD on: frees PA15, PB3 (D3), PB4 (D5) __HAL_AFIO_REMAP_I2C1_ENABLE(); // I2C1: SCL -> PB8 (D15), SDA -> PB9 (D14) GPIO_InitTypeDef gpio = {0}; gpio.Pin = GPIO_PIN_8 | GPIO_PIN_9; // D15, D14 gpio.Mode = GPIO_MODE_AF_OD; // open-drain alternate function for I2C gpio.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &gpio); // then MX_I2C1_Init() / HAL_I2C_Init() as usual |
Note: A remap is all-or-nothing per peripheral, so it can take a function away from another pin. The TIM3 partial remap gives D4/D5 PWM but removes it from D11/D12, the TIM3 full remap gives D9 PWM but removes it from D11, D12 and A3, and the TIM2 partial 1 or full remap gives D3 PWM but removes it from A0/A1. Plan your PWM pins with the table in the PWM section.
Nucleo-F103RB Power Pins
The Nucleo-F103RB can be powered from the USB connector (5v, 300mA), the VIN pin (7v–12v), the E5V pin (4.75v–5.25v) or directly from 3.3v. The power pins are highlighted in red in the pinout diagrams.

| Pin | Header Pins | Range | Notes |
|---|---|---|---|
| VIN | CN6-8, CN7-24 | 7v–12v in | LD1117 5v regulator: 800mA at 7v, 450mA at 7v–9v, 250mA at 9v–12v. Set JP5 to E5V |
| E5V | CN7-6 | 4.75v–5.25v in | 500mA max. Set JP5 to E5V |
| U5V | CN10-8 | 5v | From the ST-LINK USB connector |
| 5V | CN6-5, CN7-18 | 5v out | Limited by the source you power the board from |
| 3V3 | CN6-4, CN7-16 | 3.3v out / in | 500mA regulator; use it as an input only with SB2 and SB12 open |
| IOREF | CN6-2, CN7-12 | 3.3v | Tells shields the I/O level |
| AVDD / AREF | CN10-7, CN5-8 | = VDD | Tied to 3.3v by SB57; open it for an external reference |
| VBAT | CN7-33 | = VDD | Tied to VDD by SB45; open it to run the RTC from a coin cell |
| GND | CN6-6/7, CN5-7, CN7-8/19/20/22, CN10-9/20/32 | 0v | All grounds are common |
When you power the board from USB, the ST-LINK asks the PC for 300mA, and that’s the budget for the board plus any shield. If the PC refuses, the red LD3 LED stays off and the MCU isn’t powered. If your project needs more, power it from VIN or E5V: move JP5 to E5V, apply the external power, check that LD3 is on, and only then plug in the USB cable for debugging.
Note: Do not feed 5v into the 3V3 pin, and don’t connect two power sources to the same rail at the same time. If you want to supply the board with 3.3v directly, open SB2 (and SB12), otherwise you back-feed the on-board regulator and the unpowered ST-LINK holds the MCU in reset.
Nucleo-F103RB GPIO Pins
The Nucleo-F103RB has 51 GPIO pins on its Morpho headers, and 22 of them are also on the Arduino headers (D0–D15, A0–A5). They work at 3.3v, but unlike the F4 Nucleo boards, only 29 of them are 5v tolerant.

Each GPIO can be an input (floating, pull-up or pull-down), a push-pull or open-drain output, an analog pin or an alternate function. The internal pull-up/pull-down resistors are about 40kΩ. Here are the electrical limits from the DS5319 datasheet:
- Absolute max current per pin: ±25mA. Keep it under ±8mA for guaranteed logic levels (up to ±20mA with relaxed output levels).
- Total current for all pins: 150mA into VDD and out of VSS.
- PC13, PC14 and PC15: 3mA sink max at up to 2MHz, never as a current source (so no LEDs).
- A 5v-tolerant pin still outputs only 3.3v. Driving a 5v input that needs a high level above 3.3v takes an open-drain output with a pull-up to 5v, or a level shifter.
Which Nucleo-F103RB Pins Are 5v Tolerant?
Only 29 of the 51 GPIOs. On the Nucleo-F103RB, the 3.3v-only pins (I/O level “–” in DS5319 Table 5) are PA0–PA7, PB0, PB1, PB5, PC0–PC5, PC13–PC15 and PD0/PD1. On the Arduino headers that means A0–A5, D0, D1, D4, D11, D12 and D13: every analog-capable pin, plus D4. The 5v-tolerant (FT) Arduino pins are D2, D3, D5–D10, D14 and D15.
| Port | 5v Tolerant (FT) | 3.3v Only |
|---|---|---|
| Port A | PA8–PA15 | PA0–PA7 |
| Port B | PB2–PB4, PB6–PB15 | PB0, PB1, PB5 |
| Port C | PC6–PC12 | PC0–PC5, PC13–PC15 |
| Port D | PD2 | PD0, PD1 |
Note: A 3.3v-only pin has a 4.0v absolute maximum, so a 5v sensor output on A0–A5 can damage the MCU. This is the biggest difference from the Nucleo-F446RE and the other F4 Nucleo-64 boards, where almost every pin is 5v tolerant. Even FT pins are 5v tolerant only while the board is powered and the pin isn’t in analog mode.
Learn more in our STM32 GPIO Tutorial series.
Also Read
Nucleo-F103RB Interrupt Pins
Almost every GPIO pin on the Nucleo-F103RB can be an external interrupt source. The STM32F103RB has 16 EXTI lines for the pins, one per pin number, so PA0, PB0 and PC0 all share EXTI0 and only one of them can use it at a time.
| EXTI Line | Pins That Can Use It | Interrupt Vector |
|---|---|---|
| EXTI0 – EXTI4 | Px0 – Px4 (one port each) | EXTI0_IRQn … EXTI4_IRQn (one each) |
| EXTI5 – EXTI9 | Px5 – Px9 | EXTI9_5_IRQn (shared) |
| EXTI10 – EXTI15 | Px10 – Px15 (B1 = PC13 on EXTI13) | EXTI15_10_IRQn (shared) |
The user button B1 on PC13 is the easiest pin to try an interrupt with: it has an external pull-up and reads LOW when pressed, so set a falling-edge trigger. In Arduino, attachInterrupt(digitalPinToInterrupt(pin), isr, FALLING) works on any pin.
Note: On the 64-pin STM32F103RB, PD0 and PD1 can’t generate EXTI interrupts even after the PD01 remap (RM0008 section 9.3.2). The only wake-up pin from Standby is PA0 (A0), so B1 can wake the MCU from Stop mode with its EXTI interrupt, but not from Standby.
Learn more in our STM32 External Interrupt Tutorial.
Also Read
Nucleo-F103RB ADC Pins
The Nucleo-F103RB has 2x 12-bit ADCs (ADC1 and ADC2) sharing 16 external channels, and 9 of them are on the Arduino headers: A0–A5 plus D11, D12 and D13. The ADC reference is VDDA (3.3v) on this board, so the input range is 0v to 3.3v.

| Arduino Pin | GPIO | ADC Channel | Header Pins |
|---|---|---|---|
| A0 | PA0 | ADC12_IN0 | CN8-1, CN7-28 |
| A1 | PA1 | ADC12_IN1 | CN8-2, CN7-30 |
| A2 | PA4 | ADC12_IN4 | CN8-3, CN7-32 |
| A3 | PB0 | ADC12_IN8 | CN8-4, CN7-34 |
| A4 | PC1 | ADC12_IN11 | CN8-5, CN7-36 |
| A5 | PC0 | ADC12_IN10 | CN8-6, CN7-38 |
| D11 | PA7 | ADC12_IN7 | CN5-4, CN10-15 |
| D12 | PA6 | ADC12_IN6 | CN5-5, CN10-13 |
| D13 | PA5 | ADC12_IN5 | CN5-6, CN10-11 |
| – | PB1 | ADC12_IN9 | CN10-24 |
| – | PC2 | ADC12_IN12 | CN7-35 |
| – | PC3 | ADC12_IN13 | CN7-37 |
| – | PC4 | ADC12_IN14 | CN10-34 |
| – | PC5 | ADC12_IN15 | CN10-6 |
A conversion takes 1µs at the maximum 14MHz ADC clock. With a 72MHz system clock, the closest ADC prescaler gives 12MHz, so plan for a bit more than 1µs per sample. The two ADCs can run in dual mode and sample two channels at the same instant, which is handy for current and voltage measurements. PA2 and PA3 (ADC12_IN2/IN3) are analog pins too, but they’re taken by the Virtual COM port.
Note: Every ADC pin on this board is also a 3.3v-only pin, so never apply 5v to A0–A5 or D11–D13, not even as a digital input. Use a voltage divider to measure higher voltages.
There are so many sensors that we can read with the ADC pins, which include: potentiometers, LDRs, analog temperature sensors (LM35, NTC thermistors), current sensors (ACS712), joysticks, soil moisture sensors, and much more.
Learn more in our STM32 ADC Tutorial series.
Also Read
Nucleo-F103RB PWM Pins
The Nucleo-F103RB has 16 PWM pins on the Arduino headers and 27 in total across the Morpho headers. 11 of the Arduino PWM pins work on the default mapping (D2, D7, D8, D10, D11, D12, D14, D15, A0, A1 and A3), while D3, D4, D5, D6 and D9 need a timer remap. D13 has no PWM. The PWM pins are highlighted in orange in the pinout diagrams.

| Arduino Pin | GPIO | Timer Channel | Mapping Needed | What It Costs |
|---|---|---|---|---|
| A0 / A1 | PA0 / PA1 | TIM2_CH1 / CH2 | Default | Lost with the TIM2 partial 1 or full remap |
| A3 | PB0 | TIM3_CH3 | Default (or TIM3 partial) | Lost with the TIM3 full remap |
| D2 / D7 / D8 | PA10 / PA8 / PA9 | TIM1_CH3 / CH1 / CH2 | Default | – |
| D3 | PB3 | TIM2_CH2 | TIM2 partial 1 or fullR + JTAG off | A1 loses TIM2_CH2 |
| D4 | PB5 | TIM3_CH2 | TIM3 partialR | D11 loses TIM3_CH2; no output while I2C1 is clocked (errata) |
| D5 | PB4 | TIM3_CH1 | TIM3 partialR + JTAG off | D12 loses TIM3_CH1 |
| D6 | PB10 | TIM2_CH3 | TIM2 partial 2 or fullR | – |
| D9 | PC7 | TIM3_CH2 | TIM3 fullR | D11, D12 and A3 lose TIM3 |
| D10 | PB6 | TIM4_CH1 | Default | – |
| D11 / D12 | PA7 / PA6 | TIM3_CH2 / CH1 | Default | Lost with any TIM3 remap |
| D14 / D15 | PB9 / PB8 | TIM4_CH4 / CH3 | Default | – |
So D3 and D6 together need the TIM2 full remap (and A0/A1 lose PWM), and D9 can’t be used as PWM together with D11/D12, because they’re all on TIM3. All four timers are 16-bit, and pins on the same timer share its frequency. In STM32duino, the Servo library uses TIM4 (D10, D14, D15) and tone() uses TIM3 (D11, D12, A3), so avoid analogWrite() on those pins while you use them.
There are so many things that we can control with PWM, which include: LED dimming, DC motor speed (with a driver), servo motors, buzzers, ESCs for brushless motors, and much more.
Calculate your timer settings with this STM32 PWM Calculator.
Learn more in our STM32 PWM Tutorial series.
Also Read
Nucleo-F103RB UART Pins
The Nucleo-F103RB has 3 USARTs: USART1, USART2 and USART3. USART2 (PA2/PA3) is wired to the ST-LINK Virtual COM port, so it reaches your PC through the USB cable, not the D0/D1 pins.

Nucleo-F103RB Default Serial (USART2): PA2 (TX) and PA3 (RX), to the PC over USB.
| UART | TX Pins | RX Pins | Note |
|---|---|---|---|
| USART1 | D8 (PA9), D10 (PB6)R | D2 (PA10), PB7 (CN7-21)R | Best choice for a header UART; also the bootloader port |
| USART2 | PA2 (D1 after SB62) | PA3 (D0 after SB63) | ST-LINK Virtual COM port |
| USART3 | D6 (PB10), PC10 (CN7-1)R | PB11 (CN10-18), PC11 (CN7-2)R | PC10/PC11 can feed a second VCP on CN3 |
Why Doesn’t Serial Work on Nucleo-F103RB D0/D1?
Because D0 and D1 are not connected by default. On the Nucleo-F103RB, USART2 (PA2/PA3) goes to the ST-LINK through SB13/SB14, and SB62/SB63, which would connect it to D1/D0, are open. So Serial already talks to your PC over USB, and a shield that uses D0/D1 for serial gets nothing.
- Easiest fix: move the module to USART1 on D8 (TX) and D2 (RX). In Arduino: HardwareSerial Serial1(PA10, PA9);.
- If the shield must use D0/D1: open SB13/SB14 and close SB62/SB63. You lose the USB Virtual COM port when you do this.
Note: ES096 (section 2.3.10): if TIM1_CH2 PWM is enabled while USART1 transmits on PA9 (D8), PA9 can send garbage. Don’t use D8 as a TIM1 PWM pin and as USART1_TX at the same time.
There are so many modules that we can interface with the UART pins, which include: GPS modules, Bluetooth modules (HC-05), ESP8266/ESP32 Wi-Fi modules, GSM modules, RS485 transceivers, fingerprint sensors, and much more.
Learn more in our STM32 UART Tutorial series.
Also Read
Nucleo-F103RB I2C Pins
The Nucleo-F103RB has 2x I2C buses. The default I2C1 pins are PB6 (D10, SCL) and PB7 (CN7-21, SDA). The Arduino SCL/SDA pins D15 (PB8) and D14 (PB9) become I2C1 only after the I2C1 remap.

Nucleo-F103RB I2C1 Pins on the Arduino Header: D15 = PB8 (SCL) and D14 = PB9 (SDA), with the I2C1 remap enabled.
| I2C Bus | SCL Pins | SDA Pins | Note |
|---|---|---|---|
| I2C1 (default) | D10 (PB6) | PB7 (CN7-21) | No remap needed; SDA is on the Morpho header only |
| I2C1 (remap) | D15 (PB8) | D14 (PB9) | Wire in STM32duino, remap applied automatically |
| I2C2 | D6 (PB10) | PB11 (CN10-18) | No remap; SDA on the Morpho header only |
Why Doesn’t I2C Work on Nucleo-F103RB D14/D15?
Because PB8/PB9 aren’t I2C pins until you enable the I2C1 remap. On the Nucleo-F103RB, D15/D14 default to TIM4 channels, and I2C1 sits on PB6/PB7. Enable the AFIO clock and call __HAL_AFIO_REMAP_I2C1_ENABLE() (CubeMX does it when you pick PB8/PB9), and add pull-up resistors, since the board has none. Users hit exactly this on the PlatformIO forum and the Mbed forum.
Are Nucleo-F103RB A4/A5 I2C Pins?
No. On the Nucleo-F103RB, A4 and A5 are PC1 and PC0, which are ADC inputs with no I2C function. Uno shields that expect I2C on A4/A5 need either jumper wires to D14/D15, or a solder-bridge change: open SB51/SB56 and close SB46/SB52 to put PB9/PB8 on A4/A5, then enable the I2C1 remap.
Note: Add 4.7kΩ pull-ups to 3.3v unless your module already has them. If the bus stays BUSY after power-up or an ESD hit, it’s the ES096 “analog filter lock” erratum (section 2.8.7): apply ST’s GPIO toggle + software reset recovery sequence before initializing I2C.
There are so many modules and sensors that we can interface with the I2C bus, which include: OLED displays (SSD1306), I2C LCDs, RTC modules (DS3231), IMUs (MPU6050), BME280 sensors, EEPROMs, and much more.
Learn more in our STM32 I2C Tutorial series.
Also Read
Nucleo-F103RB SPI Pins
The Nucleo-F103RB has 2x SPI ports (SPI1 and SPI2), up to 18Mbit/s, with no I²S. The default SPI1 pins are D13 (SCK), D12 (MISO) and D11 (MOSI), just like on an Arduino Uno, and they need no remap.

Nucleo-F103RB Default SPI1 Pins: D13 = PA5 (SCK), D12 = PA6 (MISO), D11 = PA7 (MOSI), and any GPIO (usually D10) as CS.
| SPI Port | SCK | MISO | MOSI | NSS |
|---|---|---|---|---|
| SPI1 (default) | D13 (PA5) | D12 (PA6) | D11 (PA7) | A2 (PA4) |
| SPI1 (remap) | D3 (PB3) | D5 (PB4) | D4 (PB5) | PA15 (CN7-17) |
| SPI2 | PB13 (CN10-30) | PB14 (CN10-28) | PB15 (CN10-26) | PB12 (CN10-16) |
The SPI1 remap also needs JTAG disabled, because PB3, PB4 and PA15 are JTAG pins after reset. SPI2 is on the Morpho header only.
Note: ES096 (section 2.3.7): remapped SPI1 in master mode conflicts with I2C1, because PB5 (MOSI on D4) is also the I2C1 SMBA pin. If you need I2C1 and SPI1 together, keep SPI1 on its default pins D13/D12/D11. And D13 also drives the LED LD2, so it flickers during SPI transfers.
There are so many modules that we can interface with the SPI bus, which include: TFT displays (ILI9341, ST7735), SD card modules, nRF24L01 radios, MAX7219 LED drivers, W5500 Ethernet modules, and much more.
Learn more in our STM32 SPI Tutorial series.
Also Read
Nucleo-F103RB CAN & USB Pins
The STM32F103RB has 1x bxCAN 2.0B controller and 1x USB 2.0 Full-Speed device, and both use PA11/PA12 (CN10-14 / CN10-12) by default. CAN can also be remapped to D15 (PB8, CANRX) and D14 (PB9, CANTX). USB and CAN share 512 bytes of SRAM, so you can’t use them at the same time.

| Signal | Default Pin | Remap | Header Pins |
|---|---|---|---|
| CANRX | PA11 | PB8 (D15)R | CN10-14 / CN5-10 |
| CANTX | PA12 | PB9 (D14)R | CN10-12 / CN5-9 |
| USB D− (USBDM) | PA11 | – | CN10-14 |
| USB D+ (USBDP) | PA12 | – | CN10-12 |
- CAN: the MCU only has the controller, so add a 3.3v CAN transceiver (like the SN65HVD230) between the pins and the bus.
- USB: the board’s Mini-B connector goes to the ST-LINK, not to the F103. Wire your own USB connector to PA11 (D−), PA12 (D+) and GND, and add a 1.5kΩ pull-up from PA12 (D+) to 3.3v, because the F103 has no internal one (ST Community).
- USB clock: USB needs 48MHz, which you get from a 72MHz PLL with the USB prescaler set to 1.5. Keep APB1 at 13MHz or higher for USB (ES096 section 2.12).
Note: The STM32F103 medium-density bootloader has no USB DFU: you can’t flash the F103RB over its own USB port without your own bootloader. Use the on-board ST-LINK, or USART1 on D8/D2.
Learn more in our STM32 USB CDC Tutorial.
Also Read
Nucleo-F103RB Debug (SWD) & Boot Pins
The Nucleo-F103RB is programmed and debugged over SWD on PA13 (SWDIO) and PA14 (SWCLK), wired to the on-board ST-LINK/V2-1. The boot mode is set by BOOT0 (CN7-7) and PB2/BOOT1 (CN10-22).

| Pin | Header Pin | Function After Reset |
|---|---|---|
| PA13 | CN7-13 | SWDIO (JTMS) |
| PA14 | CN7-15 | SWCLK (JTCK) |
| PB3 | D3, CN10-31 | JTDO / TRACESWO (to CN4 SWO via SB15) |
| PA15 | CN7-17 | JTDI |
| PB4 | D5, CN10-27 | NJTRST |
| NRST | CN6-3, CN7-14 | Reset (B2 button, ST-LINK) |
| BOOT0 | CN7-7 | Pulled LOW by 10kΩ |
| PB2 (BOOT1) | CN10-22 | Read at reset when BOOT0 = 1; floating on this board |
| BOOT0 | BOOT1 (PB2) | Boots From |
|---|---|---|
| 0 | any | Main Flash (normal) |
| 1 | 0 | System memory (ST bootloader) |
| 1 | 1 | Embedded SRAM |
Nucleo-F103RB Bootloader Pins
The STM32F103RB system bootloader listens on USART1 only: PA9 (TX) = D8 and PA10 (RX) = D2. It’s not on the ST-LINK Virtual COM port (USART2), so you need a USB-to-serial adapter on D8/D2. To start it, jumper CN7-5 (VDD) to CN7-7 (BOOT0) and tie PB2 (CN10-22) to the GND pin right next to it (CN10-20), then reset the board.
Note: On the Nucleo-F103RB, PB2 (BOOT1) has no pull-down resistor, so it floats. With BOOT0 high and BOOT1 floating, the chip may boot from SRAM instead of the bootloader. Also, the BOOT pins are sampled again when the MCU leaves Standby, so keep them in the state you want during Standby.
PA15, PB3 and PB4 are JTAG pins after reset. To use them as GPIO, timer or SPI pins, set Debug = Serial Wire in CubeMX (SYS), which is __HAL_AFIO_REMAP_SWJ_NOJTAG(): JTAG is off and SWD stays on, so the ST-LINK still works. Never disable SWD on a Nucleo unless you know how to recover (connect under reset in STM32CubeProgrammer).
To debug another STM32 board with the on-board ST-LINK, remove both CN2 jumpers and use the 6-pin CN4 SWD connector (1 VDD_TARGET, 2 SWCLK, 3 GND, 4 SWDIO, 5 NRST, 6 SWO).
Learn more in our STM32 SWD Debugging Tutorial.
Also Read
Nucleo-F103RB On-Board Features
Besides the headers, the Nucleo-F103RB has 3 LEDs, 2 buttons, a few jumpers, and a long list of solder bridges. Here’s what each one does.
| Part | Pin / Connection | What It Does |
|---|---|---|
| LD1 COM (red/green) | ST-LINK | Blinking red: USB enumeration. Red: enumerated, no communication. Blinking red/green: communicating. Green: communication OK. Orange: last communication failed |
| LD2 USER (green) | PA5 / D13 (SB21) | HIGH = on |
| LD3 PWR (red) | +5V | The board is powered (off on USB if the PC refused the 300mA) |
| B1 USER (blue) | PC13 (SB17) | 4.7kΩ pull-up, reads LOW when pressed |
| B2 RESET (black) | NRST | Resets the MCU |
| JP5 | Power select | U5V (default) or E5V (for VIN and E5V) |
| JP6 (IDD) | MCU supply | Remove it and insert an ammeter to measure the MCU current |
| CN2 | ST-LINK jumpers | ON: the ST-LINK debugs the on-board MCU. OFF: use CN4 for an external target |
Nucleo-F103RB Solder Bridges
These are the solder bridges you’re most likely to change (UM1724 Table 10, defaults checked against the MB1136 C-05 schematic):
| Bridge | Default | Effect |
|---|---|---|
| SB13, SB14 | ON | PA2/PA3 (USART2) to the ST-LINK Virtual COM port |
| SB62, SB63 | OFF | PA2/PA3 not on D1/D0 (close them to use D0/D1) |
| SB51, SB56 | ON | A5 = PC0, A4 = PC1 |
| SB46, SB52 | OFF | Close (and open SB51/SB56) to put PB9/PB8 on A4/A5 |
| SB21 | ON | LED LD2 on PA5 |
| SB16, SB50 | ON | 8MHz MCO from the ST-LINK into PD0-OSC_IN |
| SB55 | OFF | PD0 not on CN7-29 |
| SB48, SB49 | OFF | PC14/PC15 go to X2, not to CN7-25/27 |
| SB45 | ON | VBAT = VDD |
| SB57 | ON | AVDD/AREF = VDD |
| SB2, SB12 | ON | 3.3v regulator output, ST-LINK NRST |
| SB15 | ON | SWO (PB3) to the CN4 SWD connector |
| SB17 | ON | B1 button on PC13 |
Getting Started With Nucleo-F103RB
You can program the Nucleo-F103RB with any of the common STM32 toolchains, and the ST-LINK on board means you don’t need anything else besides a Mini-USB cable.
- STM32CubeIDE: start a new project from the Board Selector, pick NUCLEO-F103RB, and let CubeMX set up the clock, LD2, B1 and USART2 for you. Set HSE to “BYPASS Clock Source” for the 8MHz MCO, and Debug to “Serial Wire”.
- Arduino IDE (STM32duino): install “STM32 MCU based boards”, then choose Board: “Nucleo-64” and Board part number: “Nucleo F103RB”.
- PlatformIO: board ID nucleo_f103rb, with the STM32Cube, Arduino, Mbed or Zephyr framework.
- Zephyr RTOS: board name nucleo_f103rb.
- Drag-and-drop: the board shows up as a USB drive; copy a .bin file onto it to flash it.
| Arduino Name | Pin | Default |
|---|---|---|
Serial | PA2 / PA3 (USART2) | To the PC through the ST-LINK |
Wire | PB9 (SDA, D14), PB8 (SCL, D15) | I2C1, remap applied by the core |
SPI | D13 / D12 / D11 | SPI1, default pins |
LED_BUILTIN | PA5 (D13) | LD2 |
USER_BTN | PC13 | B1 |
Here’s the classic first test, blinking LD2 and printing to the Serial Monitor at 115200 baud:
|
1 2 3 4 5 6 7 8 9 10 11 |
void setup() { pinMode(LED_BUILTIN, OUTPUT); // LD2 on PA5 (D13) pinMode(USER_BTN, INPUT); // B1 on PC13, LOW when pressed Serial.begin(115200); // USART2 to the ST-LINK VCP } void loop() { digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); Serial.println(digitalRead(USER_BTN) ? "B1 released" : "B1 pressed"); delay(500); } |
With STM32CubeIDE and HAL, the same blink is HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5); in the main loop. Follow the STM32 LED Blink Code Example for the full walk-through, and set up the 72MHz clock with the STM32 RCC Clock Configuration Guide (8MHz HSE bypass × 9 PLL, APB1 at 36MHz max, 2 Flash wait states).
Nucleo-F103RB Common Problems & Fixes
Why doesn’t I2C work on D14/D15? PB8/PB9 are I2C1 only after the I2C1 remap. Enable the AFIO clock and the remap (CubeMX and STM32duino do it for you), and add 4.7kΩ pull-ups. Or use the default I2C1 pins, D10 (SCL) and PB7 (SDA).
Why is there no PWM on D3, D5, D6 or D9? Those pins need timer remaps (TIM2 partial 1 for D3, TIM3 partial for D5, TIM2 partial 2 for D6, TIM3 full for D9), and D3/D5 also need JTAG disabled. Older Mbed versions even drove the wrong pin for D9 (Mbed forum).
Why don’t PB3 (D3) and PB4 (D5) toggle as GPIO? They’re JTAG pins after reset. In CubeMX, set System Core → SYS → Debug to “Serial Wire”, which calls __HAL_AFIO_REMAP_SWJ_NOJTAG() and frees PB3, PB4 and PA15 (ST Community).
Why does D4 (PB5) stay HIGH instead of outputting PWM? It’s the ES096 erratum 2.3.8: with I2C1 and TIM3 both clocked, PB5 is forced high by the I2C1 SMBA signal. Use D11 for TIM3_CH2 PWM instead.
Why doesn’t Serial work on D0/D1? PA2/PA3 go to the ST-LINK Virtual COM port, and D0/D1 are disconnected by default (SB62/SB63 open). Read Serial in the PC’s terminal over USB, or use USART1 on D8/D2 for a header UART.
Why did my 5v sensor kill an analog pin? A0–A5 and D11–D13 are 3.3v-only pins on the STM32F103RB (4.0v absolute max). Use a voltage divider or a level shifter.
Why does my code hang in SystemClock_Config (HSE never ready)? There’s no HSE crystal. HSE is an 8MHz external clock from the ST-LINK, so set HSE to “BYPASS Clock Source”, not “Crystal/Ceramic Resonator”, or run from the 8MHz HSI (64MHz max through the PLL).
Why won’t the bootloader start with BOOT0 high? PB2 (BOOT1) floats on this board. Tie CN10-22 to CN10-20 (GND) and talk to the bootloader on USART1 (D8/D2), not the Virtual COM port.
Why doesn’t my PC see the F103’s own USB? The Mini-B connector belongs to the ST-LINK. Wire a USB connector to PA11/PA12 with a 1.5kΩ pull-up on PA12 (D+), and don’t enable CAN at the same time.
Nucleo-F103RB vs Blue Pill vs Nucleo-F446RE
The Nucleo-F103RB uses the same STM32F103 family as the Blue Pill, and the same MB1136 PCB as the Nucleo-F446RE. Here’s how the three compare:
| Feature | Nucleo-F103RB | Blue Pill | Nucleo-F446RE |
|---|---|---|---|
| MCU | STM32F103RBT6 (LQFP64) | STM32F103C8T6 (LQFP48) | STM32F446RET6 (LQFP64) |
| Core / clock | Cortex-M3, 72MHz | Cortex-M3, 72MHz | Cortex-M4F, 180MHz |
| Flash / RAM | 128KB / 20KB | 64KB / 20KB | 512KB / 128KB |
| GPIO | 51 | 37 | 50 |
| Pin mapping | AFIO remaps | AFIO remaps | Per-pin AF numbers |
| 5v tolerance | Partial (A0–A5 are 3.3v only) | Partial | Almost all pins |
| Debugger | On-board ST-LINK/V2-1 | None (external ST-LINK needed) | On-board ST-LINK/V2-1 |
| USB | Device on PA11/PA12 (Morpho, no connector) | Device on its own USB connector | OTG FS + OTG HS |
| DAC / CAN | No / 1x CAN | No / 1x CAN | 2 channels / 2x CAN |
| Headers | Arduino Uno + ST Morpho | Breadboard pins | Arduino Uno + ST Morpho |
Pick the Nucleo-F103RB when you want to learn or prototype STM32F1 code with a real debugger and Arduino shields; code moves to a Blue Pill with few changes, since it’s the same peripheral set and the same remap system. The Blue Pill is the cheap, breadboard-friendly choice for the final build. And when you need speed, an FPU, a DAC, more RAM, or 5v-tolerant pins, the Nucleo-F446RE is the drop-in upgrade on the very same board layout.
Nucleo-F103RB Pin Details
Here is every Nucleo-F103RB header pin in physical order, with its main functions, all its default and remap functions, its 5v tolerance, and a short description. Functions marked R need an AFIO remap. The Arduino headers come first, then the two ST Morpho headers.
Nucleo-F103RB Arduino Header Pins (CN5, CN6, CN8, CN9)
Click to expand the full pin table (32 pins)
| Pin | Label | GPIO | Main Functions | All Functions (Default; Remap) | 5v Tolerant | Description |
|---|---|---|---|---|---|---|
| CN6-1 | NC | – | – | – | – | Not connected. |
| CN6-2 | IOREF | – | 3.3v ref | – | – | 3.3v I/O reference for shields. |
| CN6-3 | RESET | – | NRST | – | – | NRST: pull it LOW to reset the MCU. |
| CN6-4 | 3V3 | – | 3.3v in/out | – | – | 3.3v output from the LD39050 regulator (500mA), or 3.3v input with SB2/SB12 open. |
| CN6-5 | 5V | – | 5v out | – | – | 5v output from USB, VIN or E5V. |
| CN6-6 | GND | – | – | – | – | Ground. |
| CN6-7 | GND | – | – | – | – | Ground. |
| CN6-8 | VIN | – | 7v–12v in | – | – | 7v–12v input to the 5v regulator. |
| CN8-1 | A0 | PA0 | ADC12_IN0, TIM2_CH1_ETR, USART2_CTS, WKUP | ADC1_IN0, ADC2_IN0, SYS_WKUP, TIM2_CH1, TIM2_ETR, USART2_CTS; remap: TIM2_CH1 (TIM2_PARTIAL_2), TIM2_ETR (TIM2_PARTIAL_2) | No (3.3v only) | A0 analog input (ADC12_IN0), the WKUP pin and TIM2_CH1 PWM; not 5v tolerant. |
| CN8-2 | A1 | PA1 | ADC12_IN1, TIM2_CH2, USART2_RTS | ADC1_IN1, ADC2_IN1, TIM2_CH2, USART2_RTS; remap: TIM2_CH2 (TIM2_PARTIAL_2) | No (3.3v only) | A1 analog input (ADC12_IN1) and TIM2_CH2 PWM; not 5v tolerant. |
| CN8-3 | A2 | PA4 | ADC12_IN4, USART2_CK, SPI1_NSS | ADC1_IN4, ADC2_IN4, SPI1_NSS, USART2_CK | No (3.3v only) | A2 analog input (ADC12_IN4) and the default SPI1_NSS pin; not 5v tolerant. |
| CN8-4 | A3 | PB0 | ADC12_IN8, TIM3_CH3, TIM1_CH2N R | ADC1_IN8, ADC2_IN8, TIM3_CH3; remap: TIM1_CH2N (TIM1_PARTIAL), TIM3_CH3 (TIM3_PARTIAL) | No (3.3v only) | A3 analog input (ADC12_IN8) and TIM3_CH3 PWM; not 5v tolerant. |
| CN8-5 | A4 | PC1 | ADC12_IN11 | ADC1_IN11, ADC2_IN11 | No (3.3v only) | A4 analog input (ADC12_IN11); I2C only after the SB56/SB46 change and the I2C1 remap. |
| CN8-6 | A5 | PC0 | ADC12_IN10 | ADC1_IN10, ADC2_IN10 | No (3.3v only) | A5 analog input (ADC12_IN10); I2C only after the SB51/SB52 change and the I2C1 remap. |
| CN5-10 | D15 | PB8 | TIM4_CH3, I2C1_SCL R, CANRX R | TIM4_CH3; remap: CAN_RX (CAN1_2), I2C1_SCL (I2C1) | Yes | D15: TIM4_CH3 PWM by default; I2C1_SCL or CANRX only after a remap. |
| CN5-9 | D14 | PB9 | TIM4_CH4, I2C1_SDA R, CANTX R | TIM4_CH4; remap: CAN_TX (CAN1_2), I2C1_SDA (I2C1) | Yes | D14: TIM4_CH4 PWM by default; I2C1_SDA or CANTX only after a remap. |
| CN5-8 | AREF | – | = AVDD (SB57) | – | – | ADC reference, tied to VDD by SB57. |
| CN5-7 | GND | – | – | – | – | Ground. |
| CN5-6 | D13 | PA5 | ADC12_IN5, SPI1_SCK, LED LD2 | ADC1_IN5, ADC2_IN5, SPI1_SCK | No (3.3v only) | D13: the default SPI1_SCK and ADC12_IN5; it also drives the green user LED LD2. No PWM on this pin. |
| CN5-5 | D12 | PA6 | ADC12_IN6, TIM3_CH1, TIM1_BKIN R, SPI1_MISO | ADC1_IN6, ADC2_IN6, SPI1_MISO, TIM3_CH1; remap: TIM1_BKIN (TIM1_PARTIAL) | No (3.3v only) | D12: the default SPI1_MISO, ADC12_IN6 and TIM3_CH1 PWM. |
| CN5-4 | D11 | PA7 | ADC12_IN7, TIM3_CH2, TIM1_CH1N R, SPI1_MOSI | ADC1_IN7, ADC2_IN7, SPI1_MOSI, TIM3_CH2; remap: TIM1_CH1N (TIM1_PARTIAL) | No (3.3v only) | D11: the default SPI1_MOSI, ADC12_IN7 and TIM3_CH2 PWM. |
| CN5-3 | D10 | PB6 | TIM4_CH1, USART1_TX R, I2C1_SCL | I2C1_SCL, TIM4_CH1; remap: USART1_TX (USART1) | Yes | D10: the default I2C1_SCL and TIM4_CH1 PWM; USART1_TX after the USART1 remap. |
| CN5-2 | D9 | PC7 | TIM3_CH2 R | remap: TIM3_CH2 (TIM3) | Yes | D9: PWM (TIM3_CH2) only after the TIM3 full remap, which takes TIM3 away from D11, D12 and A3. |
| CN5-1 | D8 | PA9 | TIM1_CH2, USART1_TX | TIM1_CH2, USART1_TX; remap: TIM1_CH2 (TIM1_PARTIAL) | Yes | D8: the default USART1_TX (the bootloader TX pin) and TIM1_CH2 PWM. |
| CN9-8 | D7 | PA8 | TIM1_CH1, USART1_CK, MCO | RCC_MCO, TIM1_CH1, USART1_CK; remap: TIM1_CH1 (TIM1_PARTIAL) | Yes | D7: TIM1_CH1 PWM, USART1_CK and the MCO clock output. |
| CN9-7 | D6 | PB10 | TIM2_CH3 R, USART3_TX, I2C2_SCL | I2C2_SCL, USART3_TX; remap: TIM2_CH3 (TIM2_PARTIAL_2), TIM2_CH3 (TIM2) | Yes | D6: USART3_TX and I2C2_SCL by default; PWM (TIM2_CH3) only after a TIM2 remap. |
| CN9-6 | D5 | PB4 | TIM3_CH1 R, SPI1_MISO R, NJTRST | SYS_NJTRST; remap: SPI1_MISO (SPI1), TIM3_CH1 (TIM3_PARTIAL) | Yes | D5: NJTRST after reset; PWM (TIM3_CH1) and SPI1_MISO only after a remap plus the JTAG-disable remap. |
| CN9-5 | D4 | PB5 | TIM3_CH2 R, SPI1_MOSI R, I2C1_SMBA | I2C1_SMBA; remap: SPI1_MOSI (SPI1), TIM3_CH2 (TIM3_PARTIAL) | No (3.3v only) | D4: not 5v tolerant; PWM (TIM3_CH2) and SPI1_MOSI only after a remap, and the ES096 errata blocks both outputs while I2C1 is clocked. |
| CN9-4 | D3 | PB3 | TIM2_CH2 R, SPI1_SCK R, JTDO, TRACESWO | SYS_JTDO-TRACESWO; remap: SPI1_SCK (SPI1), TIM2_CH2 (TIM2_PARTIAL_1), TIM2_CH2 (TIM2) | Yes | D3: JTDO/SWO after reset; PWM (TIM2_CH2) and SPI1_SCK only after a remap plus the JTAG-disable remap. |
| CN9-3 | D2 | PA10 | TIM1_CH3, USART1_RX | TIM1_CH3, USART1_RX; remap: TIM1_CH3 (TIM1_PARTIAL) | Yes | D2: the default USART1_RX (the bootloader RX pin) and TIM1_CH3 PWM. |
| CN9-2 | D1 | PA2 | ADC12_IN2, TIM2_CH3, USART2_TX | ADC1_IN2, ADC2_IN2, TIM2_CH3, USART2_TX; remap: TIM2_CH3 (TIM2_PARTIAL_1) | No (3.3v only) | USART2_TX, wired to the ST-LINK Virtual COM port, so it is not on D1 unless you close SB62. |
| CN9-1 | D0 | PA3 | ADC12_IN3, TIM2_CH4, USART2_RX | ADC1_IN3, ADC2_IN3, TIM2_CH4, USART2_RX; remap: TIM2_CH4 (TIM2_PARTIAL_1) | No (3.3v only) | USART2_RX, wired to the ST-LINK Virtual COM port, so it is not on D0 unless you close SB63. |
Nucleo-F103RB Morpho CN7 Pins
On CN7, pin 1 is at the end nearest the ST-LINK, and odd pins are on the outer column.
Click to expand the full pin table (38 pins)
| Pin | Label | GPIO | Main Functions | All Functions (Default; Remap) | 5v Tolerant | Description |
|---|---|---|---|---|---|---|
| CN7-1 | – | PC10 | USART3_TX R | remap: USART3_TX (USART3_PARTIAL) | Yes | Morpho only: USART3_TX after the USART3 partial remap (a second Virtual COM port option). |
| CN7-2 | – | PC11 | USART3_RX R | ADC1_EXTI11, ADC2_EXTI11; remap: USART3_RX (USART3_PARTIAL) | Yes | Morpho only: USART3_RX after the USART3 partial remap. |
| CN7-3 | – | PC12 | USART3_CK R | remap: USART3_CK (USART3_PARTIAL) | Yes | Morpho only: USART3_CK after the USART3 partial remap. |
| CN7-4 | – | PD2 | TIM3_ETR | TIM3_ETR | Yes | Morpho only: a plain GPIO with TIM3_ETR. |
| CN7-5 | VDD | – | 3.3v (VDD) | – | – | 3.3v MCU supply (VDD). |
| CN7-6 | E5V | – | 5v external in | – | – | External 5v input (4.75v–5.25v, 500mA) with JP5 on E5V. |
| CN7-7 | BOOT0 | – | 10kΩ to GND | – | – | BOOT0, pulled LOW by 10kΩ; tie it to VDD (CN7-5) to start the system bootloader. |
| CN7-8 | GND | – | – | – | – | Ground. |
| CN7-9 | NC | – | – | – | – | Not connected. |
| CN7-10 | NC | – | – | – | – | Not connected. |
| CN7-11 | NC | – | – | – | – | Not connected. |
| CN7-12 | IOREF | – | 3.3v ref | – | – | 3.3v I/O reference for shields. |
| CN7-13 | – | PA13 | SWDIO | SYS_JTMS-SWDIO | Yes | SWDIO, used by the on-board ST-LINK to program and debug the MCU; leave it alone. |
| CN7-14 | RESET | – | NRST | – | – | NRST: pull it LOW to reset the MCU. |
| CN7-15 | – | PA14 | SWCLK | SYS_JTCK-SWCLK | Yes | SWCLK, used by the on-board ST-LINK to program and debug the MCU; leave it alone. |
| CN7-16 | 3V3 | – | 3.3v in/out | – | – | 3.3v output from the LD39050 regulator (500mA), or 3.3v input with SB2/SB12 open. |
| CN7-17 | – | PA15 | TIM2_CH1_ETR R, SPI1_NSS R, JTDI | ADC1_EXTI15, ADC2_EXTI15, SYS_JTDI; remap: SPI1_NSS (SPI1), TIM2_CH1 (TIM2_PARTIAL_1), TIM2_CH1 (TIM2), TIM2_ETR (TIM2_PARTIAL_1), TIM2_ETR (TIM2) | Yes | JTDI after reset; after the JTAG-disable remap it can be TIM2_CH1 or SPI1_NSS (remap). |
| CN7-18 | 5V | – | 5v out | – | – | 5v output from USB, VIN or E5V. |
| CN7-19 | GND | – | – | – | – | Ground. |
| CN7-20 | GND | – | – | – | – | Ground. |
| CN7-21 | – | PB7 | TIM4_CH2, USART1_RX R, I2C1_SDA | I2C1_SDA, TIM4_CH2; remap: USART1_RX (USART1) | Yes | Morpho only: the default I2C1_SDA and TIM4_CH2 PWM; USART1_RX after the USART1 remap. |
| CN7-22 | GND | – | – | – | – | Ground. |
| CN7-23 | – | PC13 | B1 USER, TAMPER-RTC | RTC_OUT, RTC_TAMPER | No (3.3v only) | The blue user button B1 (reads LOW when pressed); a weak backup-domain pin (3mA sink max). |
| CN7-24 | VIN | – | 7v–12v in | – | – | 7v–12v input to the 5v regulator. |
| CN7-25 | – | PC14 | OSC32_IN | RCC_OSC32_IN | No (3.3v only) | OSC32_IN for the 32.768kHz LSE crystal X2; not connected to the header by default. |
| CN7-26 | NC | – | – | – | – | Not connected. |
| CN7-27 | – | PC15 | OSC32_OUT | ADC1_EXTI15, ADC2_EXTI15, RCC_OSC32_OUT | No (3.3v only) | OSC32_OUT for the 32.768kHz LSE crystal X2; not connected to the header by default. |
| CN7-28 | A0 | PA0 | ADC12_IN0, TIM2_CH1_ETR, USART2_CTS, WKUP | ADC1_IN0, ADC2_IN0, SYS_WKUP, TIM2_CH1, TIM2_ETR, USART2_CTS; remap: TIM2_CH1 (TIM2_PARTIAL_2), TIM2_ETR (TIM2_PARTIAL_2) | No (3.3v only) | A0 analog input (ADC12_IN0), the WKUP pin and TIM2_CH1 PWM; not 5v tolerant. |
| CN7-29 | – | PD0 | OSC_IN | RCC_OSC_IN | No (3.3v only) | OSC_IN, fed with the 8MHz MCO clock from the ST-LINK; not connected to the header by default. |
| CN7-30 | A1 | PA1 | ADC12_IN1, TIM2_CH2, USART2_RTS | ADC1_IN1, ADC2_IN1, TIM2_CH2, USART2_RTS; remap: TIM2_CH2 (TIM2_PARTIAL_2) | No (3.3v only) | A1 analog input (ADC12_IN1) and TIM2_CH2 PWM; not 5v tolerant. |
| CN7-31 | – | PD1 | OSC_OUT | RCC_OSC_OUT | No (3.3v only) | OSC_OUT; it must stay unused in HSE bypass, and it is a GPIO only after the PD01 remap. |
| CN7-32 | A2 | PA4 | ADC12_IN4, USART2_CK, SPI1_NSS | ADC1_IN4, ADC2_IN4, SPI1_NSS, USART2_CK | No (3.3v only) | A2 analog input (ADC12_IN4) and the default SPI1_NSS pin; not 5v tolerant. |
| CN7-33 | VBAT | – | = VDD (SB45) | – | – | RTC/backup supply, tied to VDD by SB45. |
| CN7-34 | A3 | PB0 | ADC12_IN8, TIM3_CH3, TIM1_CH2N R | ADC1_IN8, ADC2_IN8, TIM3_CH3; remap: TIM1_CH2N (TIM1_PARTIAL), TIM3_CH3 (TIM3_PARTIAL) | No (3.3v only) | A3 analog input (ADC12_IN8) and TIM3_CH3 PWM; not 5v tolerant. |
| CN7-35 | – | PC2 | ADC12_IN12 | ADC1_IN12, ADC2_IN12 | No (3.3v only) | Morpho only: ADC12_IN12 analog input; not 5v tolerant. |
| CN7-36 | A4 | PC1 | ADC12_IN11 | ADC1_IN11, ADC2_IN11 | No (3.3v only) | A4 analog input (ADC12_IN11); I2C only after the SB56/SB46 change and the I2C1 remap. |
| CN7-37 | – | PC3 | ADC12_IN13 | ADC1_IN13, ADC2_IN13 | No (3.3v only) | Morpho only: ADC12_IN13 analog input; not 5v tolerant. |
| CN7-38 | A5 | PC0 | ADC12_IN10 | ADC1_IN10, ADC2_IN10 | No (3.3v only) | A5 analog input (ADC12_IN10); I2C only after the SB51/SB52 change and the I2C1 remap. |
Nucleo-F103RB Morpho CN10 Pins
On CN10, pin 1 is also at the ST-LINK end, but odd pins are on the inner column.
Click to expand the full pin table (38 pins)
| Pin | Label | GPIO | Main Functions | All Functions (Default; Remap) | 5v Tolerant | Description |
|---|---|---|---|---|---|---|
| CN10-1 | – | PC9 | TIM3_CH4 R | remap: TIM3_CH4 (TIM3) | Yes | Morpho only: TIM3_CH4 PWM after the TIM3 full remap. |
| CN10-2 | – | PC8 | TIM3_CH3 R | remap: TIM3_CH3 (TIM3) | Yes | Morpho only: TIM3_CH3 PWM after the TIM3 full remap. |
| CN10-3 | D15 | PB8 | TIM4_CH3, I2C1_SCL R, CANRX R | TIM4_CH3; remap: CAN_RX (CAN1_2), I2C1_SCL (I2C1) | Yes | D15: TIM4_CH3 PWM by default; I2C1_SCL or CANRX only after a remap. |
| CN10-4 | – | PC6 | TIM3_CH1 R | remap: TIM3_CH1 (TIM3) | Yes | Morpho only: TIM3_CH1 PWM after the TIM3 full remap. |
| CN10-5 | D14 | PB9 | TIM4_CH4, I2C1_SDA R, CANTX R | TIM4_CH4; remap: CAN_TX (CAN1_2), I2C1_SDA (I2C1) | Yes | D14: TIM4_CH4 PWM by default; I2C1_SDA or CANTX only after a remap. |
| CN10-6 | – | PC5 | ADC12_IN15 | ADC1_IN15, ADC2_IN15 | No (3.3v only) | Morpho only: ADC12_IN15 analog input; not 5v tolerant. |
| CN10-7 | AVDD | – | = VDD (SB57) | – | – | Analog supply VDDA, tied to VDD by SB57. |
| CN10-8 | U5V | – | USB 5v | – | – | 5v from the ST-LINK USB connector. |
| CN10-9 | GND | – | – | – | – | Ground. |
| CN10-10 | NC | – | – | – | – | Not connected. |
| CN10-11 | D13 | PA5 | ADC12_IN5, SPI1_SCK, LED LD2 | ADC1_IN5, ADC2_IN5, SPI1_SCK | No (3.3v only) | D13: the default SPI1_SCK and ADC12_IN5; it also drives the green user LED LD2. No PWM on this pin. |
| CN10-12 | – | PA12 | TIM1_ETR, USART1_RTS, CANTX, USBDP | CAN_TX, TIM1_ETR, USART1_RTS, USB_DP; remap: TIM1_ETR (TIM1_PARTIAL) | Yes | Morpho only: USB D+ (USBDP), the default CANTX, and TIM1_ETR. |
| CN10-13 | D12 | PA6 | ADC12_IN6, TIM3_CH1, TIM1_BKIN R, SPI1_MISO | ADC1_IN6, ADC2_IN6, SPI1_MISO, TIM3_CH1; remap: TIM1_BKIN (TIM1_PARTIAL) | No (3.3v only) | D12: the default SPI1_MISO, ADC12_IN6 and TIM3_CH1 PWM. |
| CN10-14 | – | PA11 | TIM1_CH4, USART1_CTS, CANRX, USBDM | ADC1_EXTI11, ADC2_EXTI11, CAN_RX, TIM1_CH4, USART1_CTS, USB_DM; remap: TIM1_CH4 (TIM1_PARTIAL) | Yes | Morpho only: USB D− (USBDM), the default CANRX, and TIM1_CH4 PWM. |
| CN10-15 | D11 | PA7 | ADC12_IN7, TIM3_CH2, TIM1_CH1N R, SPI1_MOSI | ADC1_IN7, ADC2_IN7, SPI1_MOSI, TIM3_CH2; remap: TIM1_CH1N (TIM1_PARTIAL) | No (3.3v only) | D11: the default SPI1_MOSI, ADC12_IN7 and TIM3_CH2 PWM. |
| CN10-16 | – | PB12 | TIM1_BKIN, USART3_CK, SPI2_NSS, I2C2_SMBA | I2C2_SMBA, SPI2_NSS, TIM1_BKIN, USART3_CK | Yes | Morpho only: SPI2_NSS, USART3_CK and TIM1_BKIN. |
| CN10-17 | D10 | PB6 | TIM4_CH1, USART1_TX R, I2C1_SCL | I2C1_SCL, TIM4_CH1; remap: USART1_TX (USART1) | Yes | D10: the default I2C1_SCL and TIM4_CH1 PWM; USART1_TX after the USART1 remap. |
| CN10-18 | – | PB11 | TIM2_CH4 R, USART3_RX, I2C2_SDA | ADC1_EXTI11, ADC2_EXTI11, I2C2_SDA, USART3_RX; remap: TIM2_CH4 (TIM2_PARTIAL_2), TIM2_CH4 (TIM2) | Yes | Morpho only (CN10-18): USART3_RX and I2C2_SDA; TIM2_CH4 after a TIM2 remap. |
| CN10-19 | D9 | PC7 | TIM3_CH2 R | remap: TIM3_CH2 (TIM3) | Yes | D9: PWM (TIM3_CH2) only after the TIM3 full remap, which takes TIM3 away from D11, D12 and A3. |
| CN10-20 | GND | – | – | – | – | Ground. |
| CN10-21 | D8 | PA9 | TIM1_CH2, USART1_TX | TIM1_CH2, USART1_TX; remap: TIM1_CH2 (TIM1_PARTIAL) | Yes | D8: the default USART1_TX (the bootloader TX pin) and TIM1_CH2 PWM. |
| CN10-22 | – | PB2 | BOOT1 | – | Yes | BOOT1. It floats on this board (no resistor), so tie it to GND before using the system bootloader. |
| CN10-23 | D7 | PA8 | TIM1_CH1, USART1_CK, MCO | RCC_MCO, TIM1_CH1, USART1_CK; remap: TIM1_CH1 (TIM1_PARTIAL) | Yes | D7: TIM1_CH1 PWM, USART1_CK and the MCO clock output. |
| CN10-24 | – | PB1 | ADC12_IN9, TIM3_CH4, TIM1_CH3N R | ADC1_IN9, ADC2_IN9, TIM3_CH4; remap: TIM1_CH3N (TIM1_PARTIAL), TIM3_CH4 (TIM3_PARTIAL) | No (3.3v only) | Morpho only: ADC12_IN9 analog input and TIM3_CH4 PWM; not 5v tolerant. |
| CN10-25 | D6 | PB10 | TIM2_CH3 R, USART3_TX, I2C2_SCL | I2C2_SCL, USART3_TX; remap: TIM2_CH3 (TIM2_PARTIAL_2), TIM2_CH3 (TIM2) | Yes | D6: USART3_TX and I2C2_SCL by default; PWM (TIM2_CH3) only after a TIM2 remap. |
| CN10-26 | – | PB15 | TIM1_CH3N, SPI2_MOSI | ADC1_EXTI15, ADC2_EXTI15, SPI2_MOSI, TIM1_CH3N | Yes | Morpho only: SPI2_MOSI and TIM1_CH3N PWM. |
| CN10-27 | D5 | PB4 | TIM3_CH1 R, SPI1_MISO R, NJTRST | SYS_NJTRST; remap: SPI1_MISO (SPI1), TIM3_CH1 (TIM3_PARTIAL) | Yes | D5: NJTRST after reset; PWM (TIM3_CH1) and SPI1_MISO only after a remap plus the JTAG-disable remap. |
| CN10-28 | – | PB14 | TIM1_CH2N, USART3_RTS, SPI2_MISO | SPI2_MISO, TIM1_CH2N, USART3_RTS; remap: USART3_RTS (USART3_PARTIAL) | Yes | Morpho only: SPI2_MISO and TIM1_CH2N PWM. |
| CN10-29 | D4 | PB5 | TIM3_CH2 R, SPI1_MOSI R, I2C1_SMBA | I2C1_SMBA; remap: SPI1_MOSI (SPI1), TIM3_CH2 (TIM3_PARTIAL) | No (3.3v only) | D4: not 5v tolerant; PWM (TIM3_CH2) and SPI1_MOSI only after a remap, and the ES096 errata blocks both outputs while I2C1 is clocked. |
| CN10-30 | – | PB13 | TIM1_CH1N, USART3_CTS, SPI2_SCK | SPI2_SCK, TIM1_CH1N, USART3_CTS; remap: USART3_CTS (USART3_PARTIAL) | Yes | Morpho only: SPI2_SCK and TIM1_CH1N PWM. |
| CN10-31 | D3 | PB3 | TIM2_CH2 R, SPI1_SCK R, JTDO, TRACESWO | SYS_JTDO-TRACESWO; remap: SPI1_SCK (SPI1), TIM2_CH2 (TIM2_PARTIAL_1), TIM2_CH2 (TIM2) | Yes | D3: JTDO/SWO after reset; PWM (TIM2_CH2) and SPI1_SCK only after a remap plus the JTAG-disable remap. |
| CN10-32 | AGND | – | – | – | – | Analog ground. |
| CN10-33 | D2 | PA10 | TIM1_CH3, USART1_RX | TIM1_CH3, USART1_RX; remap: TIM1_CH3 (TIM1_PARTIAL) | Yes | D2: the default USART1_RX (the bootloader RX pin) and TIM1_CH3 PWM. |
| CN10-34 | – | PC4 | ADC12_IN14 | ADC1_IN14, ADC2_IN14 | No (3.3v only) | Morpho only: ADC12_IN14 analog input; not 5v tolerant. |
| CN10-35 | D1 | PA2 | ADC12_IN2, TIM2_CH3, USART2_TX | ADC1_IN2, ADC2_IN2, TIM2_CH3, USART2_TX; remap: TIM2_CH3 (TIM2_PARTIAL_1) | No (3.3v only) | USART2_TX, wired to the ST-LINK Virtual COM port, so it is not on D1 unless you close SB62. |
| CN10-36 | NC | – | – | – | – | Not connected. |
| CN10-37 | D0 | PA3 | ADC12_IN3, TIM2_CH4, USART2_RX | ADC1_IN3, ADC2_IN3, TIM2_CH4, USART2_RX; remap: TIM2_CH4 (TIM2_PARTIAL_1) | No (3.3v only) | USART2_RX, wired to the ST-LINK Virtual COM port, so it is not on D0 unless you close SB63. |
| CN10-38 | NC | – | – | – | – | Not connected. |
Wrap Up
To conclude this guide article, the Nucleo-F103RB is a very solid entry-level development board for learning the STM32F1 family. It gives you a 72MHz Cortex-M3 with 128KB of Flash, 3 UARTs, 2 I2C buses, 2 SPI ports, CAN, and USB, on a board that you can program out of the box.
Just keep the following notes in mind: A0–A5 and D11–D13 are 3.3v only, D14/D15 I2C and the D3/D5/D6/D9 PWM need AFIO remaps, D0/D1 are the ST-LINK’s, and PB2 (BOOT1) floats.
I hope you’ve found this guide helpful. For more boards, check out the Pinouts, Datasheets & Schematic Diagrams Library. Follow this STM32 Series of Tutorials to learn more about programming STM32 microcontrollers.
If you’re just getting started with STM32, you need to check out the STM32 Getting Started Ultimate Guide below.
The complete beginner’s guide to STM32 microcontrollers: the toolchain, your first project, and the STM32 tutorials series step by step.









