WIZnet W6300/ W 5500/ W 5100S-EVB-Pico2 are three Ethernet evaluation development boards based on the Raspberry Pi RP2350 microcontroller and WIZnet full hardware TCP/IP controllers (W6300/W5500/W5100S). Combining the high-performance computing capability of the RP2350 and the hard-wired network protocol stack of WIZnet chips, these boards provide a complete solution for embedded network applications.
In terms of hardware, it adopts the RP2350 microcontroller chip officially designed by Raspberry Pi, which is equipped with dual-core ARM Cortex-M33 or dual RISC-V Hazard3 processors, operates at a frequency of up to 150MHz, has a built-in 520KB SRAM, and supports external QSPI flash memory up to 16MB. In terms of software, developers can choose the C/C++ SDK or MicroPython provided by Raspberry Pi for development, with complete supporting Ethernet driver libraries and development materials.
0.1.1 W5500-EVB-Pico2
W5500-EVB-Pico2 is a microcontroller evaluation board based on the Raspberry Pi RP2350 and the fully hardwired TCP/IP controller W5500, which leverages the W5500 to boost the performance of the conventional Raspberry Pi Pico2 board and add more Ethernet functionalities.
W5100S-EVB-Pico2 is a microcontroller evaluation board based on the Raspberry Pi RP2350 and the fully hardwired TCP/IP controller W5100S — it enhances the functionality of the traditional Raspberry Pi Pico board by adding Ethernet capability via the W5100S.
Enhanced Raspberry Pi Pico Clone
Ethernet (W5100S hardwired TCP/IP chip)
0.1.3 W6300-EVB-Pico2
W6300-EVB-Pico2 is a microcontroller evaluation board based on the Raspberry Pi RP2350 and the fully hardwired TCP/IP controller W6300. It essentially works the same way as the Raspberry Pi Pico board, but adds an Ethernet port via the W6300.
Differences between a development board and a chip:
What is a "chip"(taking RP2350 as an example): RP2350 is a single electronic component, an integrated circuit independently developed by Raspberry Pi:
It serves as the core functional carrier for the WIZnet W6300/ W 5500/ W 5100S-EVB-pico2 development board, and inherently integrates core computing/storage modules including dual-core ARM Cortex-M33 and dual-core RISC-V Hazard3 processors, 512KB SRAM, and 4MB flash memory;
However, the chip cannot function independently: it is merely an encapsulated integrated circuit, devoid of peripheral components such as power supply circuits, interfaces, and pin extensions. If you take the RP2350 chip alone, you can neither power it nor connect it to sensors or peripherals.
What is a "development board"(taking W6300-EVB-Pico2 as an example): W6300-EVB-Pico2 is a finished circuit board based on the RP2350 chip:
A ready-to-use finished tool that centers on the RP2350 chip and integrates peripheral components including the WIZnet Ethernet controller, USB power supply circuit, GPIO header pins, BOOTSEL button, LED indicator, and RJ45 Ethernet port.
1.1 Basic parameters of W6300/ W 5500/ W 5100S-EVB-pico2
1.1.1 Basic Parameters of W6300-EVB-pico2
RP2350 microcontroller with integrated 16Mbit flash memory
Dual symmetric Arm Cortex-M33 cores, with a maximum clock speed of up to 150MHz
High-performance SRAM with 520KB multi-bank
External Quad-SPI flash interface with Execute In Place (XIP) function
Full crossbar bus architecture for enhanced performance
Up to 48 multifunctional general-purpose I/Os (8 of which on the RP2350-B model are available for ADC)
IO Voltage: 1.8-5.0V
Safety Features
One-Time Programmable (OTP) Memory: used for boot configuration and security key storage.
Secure Boot: It uses OTP for key verification to ensure that only authenticated software can run on the device.
Arm TrustZone Technology: It provides hardware isolation between secure and non-secure software.
Analog and Digital Peripherals
12-bit 500ksps Analog-to-Digital Converter (ADC)
2 × UART, 2 × I2C, 2 × SPI, 16 × PWM channels
1 × timer with 4 alarms, 1 × real-time counter
3 × programmable I/O (PIO) modules, with a total of 12 finite-state machines
Flexible, user-programmable high-speed IO
It can simulate interfaces such as SD card and VGA.
It can simulate interfaces such as SD card and VGA.
Connectivity
USB-C port: used for power supply, data transmission (and flash memory reprogramming)
40-pin interface: Adopts a "DIP" style PCB with dimensions of 21x51, a board thickness of 1mm, through-hole pins with a 0.1-inch pitch, and features edge half-hole processing
Debug Interface: 3-pin ARM Serial Wire Debug (SWD) port
Network Functions
Built-in 10/100 Mbps Ethernet PHY
Supports auto-negotiation
Supports full-duplex/half-duplex
Based on the 10/100 Mbps standard
Integrated RJ45 interface
Power Supply
Built-in switching DC-DC converter (replaces LDO to improve power supply efficiency)
1.2 Hardware Specifications
1.2.1 W6300-EVB-pico2
The pins of the W6300-EVB-Pico2 are directly connected to the GPIOs of the RP2350, and its pinout is identical to that of the Raspberry Pi Pico 2 board. However, GPIO15, GPIO16, GPIO17, GPIO18, GPIO19, GPIO20, GPIO21 and GPIO22 are all connected to the W6300 on the main board. These pins enable QSPI communication with the W6300 to support Ethernet functionality, and thus cannot be used for any other purposes when the Ethernet function is in use.
The RP2350 GPIOs internally used by the W6300-EVB-Pico are as follows.
Input/Output
Name
Description
O
GPIO15
Connected to INTn on the W6300
O
GPIO16
Connected to CSn on the W6300
O
GPIO17
Connected to SCLK on the W6300
Input/Output
GPIO18
Connected to IO0 (MOSI) on the W6300 (QSPI)
Input/Output
GPIO19
Connected to IO1 (MISO) on the W6300 (QSPI)
Input/Output
GPIO20
Connected to IO2 on the W6300 (QSPI)
Input/Output
GPIO21
Connected to IO3 on the W6300 (QSPI)
O
GPIO22
Connected to RSTn on the W6300
I
GPIO24
VBUS sense: high if VBUS is present, otherwise low
O
GPIO25
Connected to the user LED
I
GPIO29
Used in ADC mode (ADC3) to measure VSYS/3
QSPI mode IO lines
The IO lines for each QSPI mode are as follows.
Mode
Input/Output
Badge name
Description
Single
O
GPIO18
Connected to IO0 (MOSI) on the W6300
Single
I
GPIO19
Connected to IO1 (MISO) on the W6300
Mode
Input/Output
Badge name
Description
Dual
Input/Output
GPIO18
Connected to IO0 on the W6300 (dual mode)
Dual
Input/Output
GPIO19
Connected to IO1 on the W6300 (dual mode)
Mode
Input/Output
Badge name
Description
Quad
Input/Output
GPIO18
Connected to IO0 on the W6300 (quad mode)
Quad
Input/Output
GPIO19
Connected to IO1 on the W6300 (quad mode)
Quad
Input/Output
GPIO20
Connected to IO2 on the W6300 (quad mode)
Quad
Input/Output
GPIO21
Connected to IO3 on the W6300 (quad mode)
In addition to GPIO pins and ground pins, there are 7 other pins on the main 40-pin header:
No.
Badge name
Description
PIN40
VBUS
USB Type-C input voltage, connected to pin 1 of the USB Type-C port. Nominally 5V.
PIN39
VSYS
Main system input voltage, which can vary within the allowed range of 4.3V to 5.5V; used by the onboard LDO to generate 3.3V.
PIN37
3V3_EN
Connected to the onboard LDO enable pin. To disable the 3.3V (which also powers down the RP2350 and W6300), short this pin to low.
PIN36
3V3
Main 3.3V supply for the RP2350 and W6300, generated by the onboard LDO.
PIN35
ADC_VREF
ADC supply (and reference) voltage, generated on the W6300-EVB-Pico2 through a filtered 3.3V supply.
PIN33
AGND
Ground reference for GPIO26-29.
PIN30
RUN
RP2350 enable pin. To reset the RP2350, short this pin to low.
1.2.2 W5500-EVB-pico2
As shown in the figure above, the pins of the W5500-EVB-Pico2 are directly connected to the GPIOs of the RP2350, and its pin arrangement is identical to that of the Raspberry Pi Pico 2 board. However, GPIO16, GPIO17, GPIO18, GPIO19, GPIO20 and GPIO21 are all connected to the W5500 on the main board internally. These pins implement SPI communication with the W5500 to enable Ethernet functionality, so they cannot be used for other purposes if you are utilizing the Ethernet feature.
The RP2350 GPIOs internally used by the W5500-EVB-Pico are as follows.
Input/Output
Name
Description
I
GPIO16
Connected to MISO on the W5500
O
GPIO17
Connected to CSn on the W5500
O
GPIO18
Connected to SCLK on the W5500
O
GPIO19
Connected to MOSI on the W5500
O
GPIO20
Connected to RSTn on the W5500
I
GPIO21
Connected to INTn on the W5500
I
GPIO24
VBUS sense: high if VBUS is present, otherwise low
O
GPIO25
Connected to the user LED
I
GPIO29
Used in ADC mode (ADC3) to measure VSYS/3
In addition to GPIO pins and ground pins, there are 7 other pins on the main 40-pin header:
No.
Name
Description
PIN40
VBUS
Micro-USB input voltage, connected to pin 1 of the micro-USB port. Nominally 5V.
PIN39
VSYS
Main system input voltage, which can vary within the allowed range of 4.3V to 5.5V; used by the onboard LDO to generate 3.3V.
PIN37
3V3_EN
Connected to the onboard LDO enable pin. To disable the 3.3V (which also powers down the RP2350 and W5500), short this pin to low.
PIN36
3 to 3
Main 3.3V supply for the RP2350 and W5500, generated by the onboard LDO.
PIN35
ADC_VREF
ADC supply (and reference) voltage, generated on the W5500-EVB-Pico through a filtered 3.3V supply.
PIN33
AGND
Ground reference for GPIO26-29.
PIN30
Fast run
RP2350 enable pin. To reset the RP2350, short this pin to low.
Operating Conditions
Item
Description
Upper operating temperature limit
85 °C (including self-heating)
Lower operating temperature limit
-20 °C
VBUS
5V DC (+/- 10%)
VSYS Min
4.3V DC
VSYS Max
5.5V DC
The recommended maximum ambient temperature is 70 degrees Celsius.
1.2.3 W5100S-EVB-pico2
The pins of the W5100S-EVB-Pico2 are directly connected to the GPIOs of the RP2350, as shown in the diagram above. Its pinout is identical to that of the Raspberry Pi Pico 2 board. However, GPIO16, GPIO17, GPIO18, GPIO19, GPIO20 and GPIO21 are all connected to the onboard W5100S on the main board. These pins enable SPI communication with the W5100S to support Ethernet functionality, and thus cannot be used for any other purposes if you are utilizing the Ethernet feature.
The RP2350 GPIOs internally used by the W5100S-EVB-Pico2 are as follows.
Input/Output
Pin name
Description
I
GPIO16
Connected to MISO on the W5100S
O
GPIO17
Connected to CSn on the W5100S
O
GPIO18
Connected to SCLK on the W5100S
O
GPIO19
Connected to MOSI via W5100S
O
GPIO20
RSTn connected to W5100S
I
GPIO21
INTn connected to W5100S
I
GPIO24
VBUS sense: high if VBUS is present, otherwise low
O
GPIO25
Connected to the user LED
I
GPIO29
Used in ADC mode (ADC3) to measure VSYS/3
In addition to GPIO pins and ground pins, there are 7 other pins on the main 40-pin header:
No.
Name
Description
PIN40
VBUS
Micro-USB input voltage, connected to pin 1 of the micro-USB port. Nominally 5V.
PIN39
VSYS
Main system input voltage, which can vary within the allowed range of 4.3V to 5.5V; used by the onboard LDO to generate 3.3V.
PIN37
3V3_EN
Connects to the onboard LDO enable pin. To disable 3.3V (which also powers down the RP2350 and W5100S), short this pin to low.
PIN36
3 to 3
The main 3.3V supply for the RP2350 and W5100S is generated by the onboard LDO.
PIN35
ADC_VREF
ADC supply (and reference) voltage, generated on the W5100S-EVB-Pico from the filtered 3.3V supply.
PIN33
AGND
Ground reference for GPIO26-29.
PIN30
Fast run
RP2350 enable pin. To reset the RP2350, short this pin to low.
Operating Conditions
Item
Description
Upper operating temperature limit
85 °C (including self-heating)
Lower operating temperature limit
-20 °C
VBUS
5V DC (+/- 10%)
VSYS Min
4.3V DC
VSYS Max
5.5V DC
The recommended maximum ambient temperature is 70 degrees Celsius.
1.3 Development Board Hardware Circuit
1.3.1 W6300-EVB-pico2
1.3.2 W5500-EVB-pico2
1.3.3 W5100S-EVB-pico2
2. Detailed Introduction to Ethernet Controller Chips
2.1 W6300
The W6300 is a hardwired TCP/IP stack internet controller chip based on WIZnet technology, designed for high-speed Ethernet communication. It integrates a dual IPv4/IPv6 hardware stack, 10/100 Ethernet MAC and PHY into a single chip. To achieve performance exceeding 90Mbps, the W6300 supports a 150MHz system clock and QSPI interface, and is equipped with 4 data lines. It provides 8 independent sockets and 64KB internal SRAM, supporting reliable Ethernet application development through socket programming.
These application notes describe how to use W6300 's core network functions, including TCP, UDP, IPRAW modes, IPv6 features and PPPoE.
hardware resources
Technical Resources
Resources
Description
Notes
W6300-EVB-Pico SCH and PCB Library
Schematic, parts list, and Gerber files
-
W6300-EVB-Pico2 SCH and PCB Library
Schematic, parts list, and Gerber files
-
Design Guide
TBD
-
Reference Schematic (Extended)
External Transformer Schematic
Includes recommended circuit design
Reference Schematic (RRJ45)
TBD
-
Testing and Certification
Resources
Description
Notes
ESD Test
TBD
-
Ethernet Compliance Test
TBD
-
Distance Test
TBD
-
EMC Test
TBD
-
Reliability Test
TBD
-
Certificates
TBD
-
2.2 W5500
The W5500 is a hardwired TCP/IP stack internet controller chip based on WIZnet technology, which provides convenient internet connectivity for external MCUs via an SPI interface with a maximum clock speed of 80MHz. As a single-chip solution, it integrates a 10/100 Ethernet MAC and PHY, and supports multiple protocols including TCP, UDP and IPv4. In addition, it features 8 independent SOCKETs and 32KB of internal memory, enabling Ethernet application development directly through SOCKET programming.It also reduces power consumption through WOL (Wake-on-LAN) and power-off modes.
block diagram
Pin Diagram
Parameters
Supports the following wired TCP/IP protocols: TCP, UDP, ICMP, IPv4, ARP, IGMP, PPPoE
Supports 8 independent sockets for simultaneous use.
Support shutdown mode
Supports UDP-based Wake-on-LAN
Supports High-Speed Serial Peripheral Interface (SPI MODE 0,3)
Internal 32K-byte memory for transmit/receive buffers
10BaseT/100BaseTX Ethernet PHY Embedded
Supports auto-negotiation (full-duplex and half-duplex, based on 10 and 100)
IP sharding is not supported
3.3V operation, 5V I/O signal tolerance
LED Output (Full/Half Duplex, Link, Speed, Active)
Technical specifications and features of the W5500 chip
-
Technical Documentation
Title
Description
Notes
SPI performance
-
-
Software Resources
Drive
Application Notes
Driver
Resources
Description
ioLibrary_Driver
Official WIZnet driver library for W5500 and other chips
ioLibrary_Driver_BSD
Official WIZnet driver library for W5500 and other chips
Information
The ioLibrary_Driver is an MCU-independent library compatible with WIZnet W5x00 and W6x00 series chips. It provides basic TCP/IP service implementations, enabling developers to build network applications with minimal MCU dependency.
Supported Services
DHCP, DNS, MQTT, SNTP, TFTP, HTTP servers
Application Notes
Example Name
Description
Notes
TCP Function
How to use TCP Function
ITCP Function handles IPv4 layer communication
UDP Function
How to use UDP Function
UDP Function handles IPv4 layer communication
IPRAW
How to use IPRAW Mode
IPRAW Mode handles IPv4 layer communication
PPPoE
How to use PPP/PPPoE
PPP is Link-Layer protocol for point-to-point
Information
These application notes describe how to use the core network functions of the W5500, including TCP, UDP, IPRAW mode and PPPoE protocol.
hardware resources
technical resources
Resources
Description
Notes
Reference Schematic (Extended)
External Transformer Schematic
Includes recommended circuit design
Reference Schematic (RJ45)
RJ45 with transformer schematic
Includes recommended circuit design
SCH and PCB Library
TBD
-
Design Guide
TBD
-
Testing and Certification
Resources
Description
Notes
ESD Test
ESD Test Confirmation
-
Ethernet Compliance Test
TBD
-
Distance Test
TBD
-
EMC Test
TBD
-
Reliability Test
TBD
-
Certificates
TBD
-
2.3 W5100S
W5100S is a wired TCP/IP protocol stack internet controller chip based on WIZnet technology, which provides convenient internet connectivity for external MCUs via SPI or Parallel System BUS. The SPI interface supports a maximum clock frequency of 70MHz, while the Parallel System BUS delivers higher data throughput to achieve faster network communication. Integrated with embedded Ethernet MAC and PHY, the W5100S enables developers to easily build Ethernet applications through socket programming.
block diagram
Pin Diagram
Parameters
Supported wired Internet protocols: TCP, UDP, WOL over UDP, ICMP, IGMPv1/v2, IPv4, ARP, PPPoE
LED Output (Full/Half Duplex, Link, 10/100 Speed, Active)
Two package types: 48-pin LQFP and QFN lead-free package (7x7mm, 0.5mm pitch)
Literature and Materials
datasheet
Title
Description
Notes
W5100S Datasheet
Technical specifications and features of the W5100S chip
-
Technical Documentation
Title
Description
Notes
W5100S Errata
Known issues and corrections for the W5100S chip
-
W5100S vs. W5100 Comparison Table
Feature comparison of the W5100S and W5100 chips
-
software resources
Driver
Application Notes
Driver
ioLibrary refers to the "Internet Offload Library" for WIZnet chips, which includes drivers and application protocols. It can be used in the application design of the W5100S and other chips, and relevant information will be updated continuously.
Resources
Description
ioLibrary_Driver
Official WIZnet driver library for W5100S and other chips
Information
The ioLibrary_Driver is an MCU-independent library applicable to WIZnet W5x00 and W6x00 chips. It provides basic TCP/IP service implementations, enabling developers to build network applications with minimal MCU dependency.
Supported Services
DHCP, DNS, MQTT, SNTP, TFTP, HTTP servers
Application Notes
Name
Description
Notes
TCP Functions
How to Use IPRAW Mode
IPRAW mode handles IPv4-layer communication
UDP Functions
How to Use IPRAW Mode
IPRAW mode handles IPv4-layer communication
IPRAW
How to Use IPRAW Mode
IPRAW mode handles IPv4-layer communication
PPPoE
How to Use PPP/PPPoE
PPP is a point-to-point link-layer protocol
Socketless Commands
Socketless ARP and PING Procedure
Command-based ARP and PING processing
Interrupts
Interrupt Example
Publish a Message to the Broker
DMA
How to Use IPRAW Mode
IPRAW mode handles IPv4-layer communication
hardware resources
Technical Resources
Resources
Description
Notes
Reference Schematic
Typical Application Schematic
Includes recommended circuit design
Reference Schematic (Extended)
External Transformer Type
Includes recommended circuit design
Reference Schematic (International)
RJ45 Transformer Type
Includes recommended circuit design
SCH and PCB Library
TBD
Design Guide
TBD
Testing and Certification
Resources
Description
Notes
Ethernet Compliance Test
TBD
Distance Test
TBD
EMC Test
TBD
Reliability Test
TBD
Certificates
TBD
2. Detailed Introduction to the RP2350A Chip
RP2350A is the second-generation self-developed microcontroller chip launched by Raspberry Pi. Building on the huge success of the RP2040, it delivers a significant leap in performance and enhanced functionality, while inheriting the features of low power consumption, high cost-effectiveness and excellent development experience.
The RP2350A chip adopts a 40nm process, which translates to a compact die size and low power consumption, and comes in a 7×7mm QFN-60 package — meaning it is a 7mm square chip with 60 small pins for easy soldering onto circuit boards:
The specific specifications and parameters are as follows:
Dual-core Arm Cortex-M33 or dual-core Hazard3 RISC-V @ 150MHz (TrustZone security extension supported)
The chip integrates 520KB of SRAM, which is divided into 10 independent banks.
It supports external flash/PSRAM up to 16MB via a dedicated QSPI bus, and an additional 16MB can be accessed through an optional second chip select.
Built-in DMA controller (acts as the chip’s "errand runner" to transfer data, so that the chip can focus on computation without wasting computing power)
30 GPIO pins, 4 of which can be used as analog inputs
4 ADC channels, maximum sampling rate of 0.5 MSa/s, 12-bit precision, and support for external reference voltage input
2 UARTs, 2 SPI controllers and 2 I2C controllers
24 PWM channels
USB 1.1 host and device support
12 Raspberry Pi programmable I/O (PIO) finite-state machines for custom peripheral support
1 HSTX (High-Speed Transmit) controller, designed for high-speed scenarios such as digital video output
Supports UF2-enabled USB mass storage boot mode for drag-and-drop programming
Supports SWD debugging and downloading
Six dedicated IOs are used for SPI Flash to support XIP (which enables direct reading of programs from external flash without first copying them into the chip)
Built-in temperature sensor
Accelerated floating-point library in ROM and hardware SHA-256 accelerator
Fully connected AHB crossbar (the "expressway" inside the chip that enables faster data transmission between various components)
Interpolator, integer divider, and hardware multiplier-divider unit
On-chip programmable LDO and switcher (switching power supply) for generating core voltage
2 on-chip PLLs are used to generate USB and core clocks
Robust security system: Based on Arm TrustZone, it supports optional boot signatures, protected OTP storage, global bus filtering, and hardware fault injection attack mitigation
What is "encapsulation"?
The core of a chip, which refers to the integrated circuit on the silicon wafer, can be understood as a "fragile die" — it is extremely thin and delicate, vulnerable to impacts and moisture, and has no directly connectable interfaces, making it impossible to use as-is. "Packaging" is the process of providing this die with "a protective enclosure plus lead-out interfaces":
It serves as the "protective casing" of a chip: it encloses the fragile core circuitry to guard against drops, moisture and dust, thereby preventing damage to the circuits.
It serves as the "external interface" of the chip: metal pins are drawn out from the core circuit to facilitate soldering the chip onto a circuit board, enabling the chip to receive power and transmit signals with external components.
Different packages feature varying shapes and pin counts; for instance, the "7×7mm QFN-56 package" used for the RP2040: QFN denotes the package type (a flat, no-lead form factor), 56 indicates that this package has 56 pins, and 7×7mm refers to the physical dimensions of the package.
Apart from the QFN package used for the RP2040, here are other common chip packages:
DIP package (Dual In-line Package) For example, "DIP-20": it features long metal pins arranged in two rows, which can be directly inserted into a breadboard/perforated prototype board.
Features: beginner-friendly, easy to insert, easy to solder, and easy to disassemble when damaged; however, it is relatively bulky.
Applicable scenarios: Experiments for beginners, prototype verification on breadboards (for example, early 51 single-chip microcontrollers commonly used DIP packages).
SOIC package (Small Outline Integrated Circuit package) For example, "SOIC-16": it is a surface-mount package with small metal pins on the surface of the circuit board, and its volume is much smaller than that of DIP.
Features: Compact size, suitable for tight circuit boards; however, it requires surface-mount soldering, making manual soldering more difficult for beginners than DIP packages.
Application scenarios: Small consumer electronics (e. g., chips for Bluetooth modules, small-sized sensors).
QFP package (Quad Flat Package) Take "QFP-44" as an example: its leads are arranged on all four sides of the chip, with a higher pin count than SOIC.
Features: It can support more functions (more pins correspond to more chip functions), with a size smaller than DIP but larger than BGA.
Applicable scenarios: Devices with moderate complexity (such as some feature-rich microcontrollers and small industrial control board chips).
BGA Package (Ball Grid Array Package) Take "BGA-100" for example: its pins are solder balls located at the bottom of the chip (rather than exposed pins), featuring an extremely compact size and a very large number of pins.
Features: It can accommodate a large number of pins (supporting high-performance chips) and has an extremely small size; however, it requires professional equipment for soldering and is hardly usable for beginners.
Application scenarios: High-end small-sized devices (e. g., processors in mobile phones and tablets, high-performance sensor chips).
The core differences between these packages lie in their size, pin configuration, and soldering difficulty: beginners typically use DIP (easy to handle) for experiments, SOIC/QFN for compact finished products, and BGA for high-end miniature devices.
USB Flashing Format (UF2) File
UF2 is a brand-new firmware update file format developed by Microsoft for PXT (also known as Microsoft MakeCode), which is particularly suitable for the firmware upgrade process of microcontrollers and embedded devices via Flash memory.
The core features of the UF2 file lie in its divisibility and easy identifiability. Each UF2 file consists of a series of fixed-size (typically 512-byte) data blocks, which can be read independently by the device. When the device detects consecutive data blocks, it will automatically combine them into a firmware image. This design allows the device to start running the update after receiving a partial file, thus improving the reliability of the update.
In addition, UF2 files feature a specific trailing structure that allows devices to easily identify their file type. This characteristic enables UF2 files to operate seamlessly across various operating systems such as Windows, Linux, or macOS, and be compatible with a wide range of development boards.
It has the following features:
Easy to use - Users can upload UF2 files to compatible hardware devices via simple drag-and-drop operations;
Cross-platform compatibility - works with multiple operating systems and is widely used in various microcontrollers and development boards;
Robustness - Ensures successful firmware updates even in unstable network environments;
Flexibility - Can be easily adapted to different hardware architectures and memory layouts.
XIP —— eXecute In Place
Memory units in a microcontroller can be roughly divided into two categories:
RAM: All the modifiable variables used during program execution are stored in RAM;
ROM: Mainly used to store instruction codes and certain fixed values, which cannot be modified after the program is running. For example, all the code in. c and. h files, global variables, local variables, constant data defined by the 'const' qualifier, and the code in the startup.asm file are all stored in ROM.
Flash memory, also known as flash, combines the advantages of both ROM and RAM. It not only features the electrically erasable programmable (EEPROM) performance, but also retains data without power supply while enabling fast data readout. In the past, embedded systems consistently used ROM (EPROM) as their storage device; however, in recent years, Flash has fully replaced the position of ROM in embedded systems.
During the code execution of a microcontroller unit (MCU), it is usually necessary to read the code from ROM or external flash memory into a RAM buffer before executing it sequentially. However, many modern NOR QSPI flash memories support the XIP (eXecute In Place) function. In this mode, an embedded MCU chip can directly fetch instructions from the NOR QSPI flash for subsequent use by the decoder and execution unit, without the need to preload the code into RAM..Simply put, XIP is a mechanism that enables code to be executed directly in flash memory without being loaded into RAM for execution, which reduces the time required for the kernel to be copied from flash memory to RAM.
When flashing a self-developed application to the Raspberry Pi Pico 2, the program is first written to the external Flash, and then when the chip boots up, the bootloader in its internal ROM loads and executes the program via XIP/Cache.
The specific meaning of each symbol in its name RP2350A is as follows:
(Note: RP stands for Raspberry Pi, 2 indicates the 2nd-generation architecture, 3 denotes the core architecture generation, 5 represents 2 to the power of 5 (i. e., 32), 0 means no built-in Flash, and A refers to the 7x7 QFN-60 package)
2.1 Block Diagram of the Chip System
For any chip, the block diagram serves as the core starting point for learning — it acts as the chip's "architecture specification" and helps you build a systematic understanding (rather than a scattered list of functions) of the chip, which is the universal approach to learning all chips. Through the block diagram, you can first grasp the information from the following general dimensions before diving into specific functions:
Clarify the composition of core functional modules: Whether it is a microcontroller, a processor or a dedicated chip, the block diagram clearly divides the arithmetic core (such as the dual cores of RP2040), storage units (such as SRAM), peripheral interfaces (such as SPI/I2C), and auxiliary modules (such as clock/power supply), allowing you to quickly understand what basic components the chip "contains" — this serves as the "component list" for subsequent learning.
Master the architectural logic between modules: The block diagram presents the hierarchical relationship of each module (e. g., the core is the core control layer, and the peripherals are the external interaction layer) and the communication links (e. g., the bus is the interconnection hub between modules), helping you understand "how the components of a chip work together" — for example, the cores of all chips access memory and control peripherals through the bus, which is the general logic of chip operation (corresponding to the Bus Fabric interconnection of RP2040).
Clarify the allocation boundaries of hardware resources: Key resources of the chip (such as the number of GPIOs, memory size, and peripheral types) can be directly obtained through the block diagram, which is the premise for subsequent hardware design and program development — for example, by knowing how many UARTs a chip has, one can determine how many serial port devices it can connect simultaneously (corresponding to the 2 UARTs and 30 GPIOs of the RP2040).
Evaluate the adaptability for feature expansion: The programmable modules in the block diagram (such as the PIO of RP2040) and expansion interfaces (such as QSPI) indicate whether the chip supports custom functions and external devices, which is the core basis for judging whether the chip can adapt to a specific scenario — for example, the block diagram of a general-purpose microcontroller includes programmable modules, while the block diagrams of dedicated chips mostly consist of fixed peripherals.
Establish a logical framework for fault debugging: When encountering problems subsequently, you can quickly locate the failure domain according to the module division of the block diagram (for example, check the peripherals and bus first for communication anomalies, and check the core first for operation errors) — this is a general idea for debugging all chips.
The RP2350A features dual M33/RISC-V processor cores, DMA, on-chip memory, and peripheral blocks connected via an AHB/APB bus structure:
We can regard a chip as a "miniature factory", where each module in the diagram corresponds to a distinct "workshop / position". Below, we will explain the role of each "position" in the RP2350A according to the partitions in the diagram:
Clock System: It acts as the "metronome" of the factory — responsible for generating a stable "time rhythm"(for example, the internal oscillator and external crystal oscillator provide the basic beat, while the PLL module adjusts the beat up to 150MHz), ensuring that all modules operate in a synchronized rhythm.
Kernel, Interrupt and Debug Section: This section acts as the "core workers" of the factory — Proc0 and Proc1 are the two "workers"(dual-core, with optional Cortex-M33 or Hazard3 RISC-V), responsible for executing programs and handling core tasks; the SIO serves as the "tool room for the workers"; Interrupts function as the "emergency call device"; and SWD is the "supervisor interface".
DMA Bus Master: It acts as the "material handler" in the factory. The RP2350A is equipped with a more powerful DMA controller (16 channels, 4 IRQs), which can efficiently perform bulk data transfers on behalf of the processor, freeing the core "workers" to focus on their assigned tasks.
Bus Fabric: It serves as the "internal pathway" of the factory. Adopting a fully connected AHB Crossbar, all inter-module communication and data transmission are carried out through this "pathway", ensuring efficient interconnection between all functional units.
Internal RAM Partition: This serves as the factory's "temporary warehouse" — the 520KB SRAM is divided into 10 "sub-warehouses"(banks), which can store different types of temporary data simultaneously to avoid space conflicts and improve data access efficiency.
Peripheral Section: This serves as the "external interface" of the factory — it comprises modules including SPI/I2C/UART, PWM (24 channels), and ADC&TS (the "measuring instrument" for voltage/temperature detection), and is responsible for connecting and interacting with external components such as sensors and LEDs.
PIO Controller: It serves as the "universal workbench" for factories. The RP2350A is upgraded to 3 PIO coprocessors with a total of 12 finite-state machines, which enable more flexible customization of interface functions and extend the peripheral capabilities that the chip does not natively support.
The QSPI interface implements the XIP function, which acts as the "direct access channel from external warehouse" for the factory: it connects to external flash memory/PSRAM (equivalent to an "external large warehouse") via the QSPI interface, and the XIP function enables the chip to read programs directly from the external warehouse.
USB PHY Unit: It acts as the "USB express interface" of the factory — responsible for communicating with external USB devices (computers, USB flash drives) to enable program download and data transmission.
Internal Voltage Regulator: It acts as the factory's "power supply stabilizer" — with an added on-chip Switch Mode Power Supply (SMPS), it can manage power more efficiently, stably convert the externally input voltage into the voltage required by the chip core, and ensure stable power supply for all modules.
HSTX High-Speed Transmit Controller: It acts as the factory's "HD LIVE Studio"(newly added in RP2350A) — a dedicated component for high-speed serial data transmission (e. g., driving digital video displays) that delivers extremely high throughput.
A brief description is provided as follows:
XIP/Cache: The microcontroller connects to external NOR QSPI FLASH/PSRAM via a dedicated QSPI interface to implement the XIP (execute-in-place) function, and a large cache can improve the performance of typical applications;
SWD Debug Interface: The SWD debug interface is connected to the core;
Internal SRAM partitioning: The internal SRAM can hold code or data. It is mapped as a single 520 kB region, but is physically divided into 10 banks to enable simultaneous parallel access from different host buses;
GPIO Ports and Peripherals: GPIO pins can be directly driven, or work with peripherals to implement multiplexing functions such as SPI, I2C, and UART;
PIO Controller: The flexible and configurable PIO controller can be used to provide various IO functions (3 PIOs, 12 finite-state machines);
USB PHY Unit: A USB controller with an embedded PHY can be used to provide FS/LS host or device connection under software control;
Clock System: Two PLLs (Phase-Locked Loops) provide a fixed 48MHz clock for USB or ADC, along with a flexible system clock that can reach up to 150MHz;
Internal voltage regulator: incorporates a programmable LDO and a high-efficiency switched-mode power supply (SMPS) to supply the 1.1V core voltage;
DMA bus: The 16-channel DMA can be used to offload repetitive data transfer tasks from the processor;
Kernel part: two completely symmetric processing cores, Proc0 and Proc1 (supporting Cortex-M33 or RISC-V);
Security System: Global bus filtering based on TrustZone to protect sensitive resources.
2.2 Pin Mapping
For chip learning, pin mapping is the key link between "internal chip functions" and "actual physical hardware" — it is a "wiring guide" that establishes a one-to-one correspondence between the functional modules in the chip block diagram (such as GPIO, ADC, UART) and the physical pins on the chip package (i. e., the exposed metal leads of the chip).
The reason why it is necessary to understand the pin mapping is as follows:
It serves as the "operation manual" for hardware design: the block diagram tells you that the chip has functions such as GPIO and ADC, but the pinout will clearly specify "which physical pins on the chip these functions correspond to specifically" — for example, if you want to connect a temperature and humidity sensor (using I2C) to an RP2040, you have to find the physical pins that support the I2C function through the pinout before you can solder and wire correctly;
It serves as the "function index" for program development: when writing a program to control a certain function (such as turning on an LED), you need to determine the "pin number corresponding to that function" through pin mapping, so as to correctly configure the pin in the code;
It serves as a "reference sheet" for function multiplexing: many pins support multiple purposes (for example, the GPIOx pins of the RP2040 support ADC functionality at the same time), and the pinout will mark the multiplexing functions of each pin, making it convenient for you to select the appropriate pins according to your project requirements.
Name
Description
GPIOx
General-purpose digital input and output. Can connect internal peripherals or be controlled directly from software.
GPIOx/ADCy
General-purpose digital input and output, with analogue-to-digital converter function. The RP2350 ADC has an analogue multiplexer to select these pins for voltage sampling.
QSPIx
Interface to SPI, Dual-SPI, or Quad-SPI flash or PSRAM device, with execute-in-place support. Can be used as software-controlled GPIOs if not required for flash access.
USB_DM and USB_DP
USB controller, supporting Full Speed device and Full/Low Speed host. Requires 27Ω series termination resistor on each pin. Bus pullups and pulldowns are provided internally. Can be used as GPIOs if USB is not required.
XIN and XOUT
Connect a crystal to RP2350’s crystal oscillator. XIN can also be a CMOS clock input. Defaults to 12 MHz crystal or clock input for USB bootloader. Configurable via OTP.
RUN
Global asynchronous reset pin. Reset when driven low, run when driven high. Can be tied directly to IOVDD if no external reset is needed.
SWCLK and SWDIO
Access to internal Serial Wire Debug bus for debug access and code download.
GND
Single external ground connection, bonded to internal ground pads.
IOVDD
Power supply for digital GPIOs, nominal voltage 1.8V to 3.3V.
USB_OTP_VDD
Power supply for internal USB Full Speed PHY and OTP storage, nominal voltage 3.3V.
ADC_AVDD
Power supply for analogue-to-digital converter, nominal voltage 3.3V.
QSPI_IOVDD
Power supply for QSPI IOs, nominal voltage 1.8V to 3.3V.
VREG_AVDD
Analogue power supply for internal core voltage regulator, nominal voltage 3.3V.
VREG_PGND
Power-ground connection for internal core voltage regulator, tie to ground externally.
VREG_LX
Switched-mode output for internal core voltage regulator, connected to an external inductor. Max current 200 mA, nominal voltage 1.1V after filtering.
VREG_VIN
Power input for internal core voltage regulator, nominal voltage 2.7V to 5.5V.
VREG_FB
Voltage feedback for internal core voltage regulator, connect to filtered VREG output (e.g., to DVDD, if used to supply DVDD).
DVDD
Digital core power supply, nominal voltage 1.1V. Must be connected externally, either to the voltage regulator output or an external board-level power supply.
Taking the pin mapping of this RP2350A as an example: the figure above shows the physical pin numbers (1-60) of the chip, and the table below lists the corresponding functions of each pin. Only by mastering this can you translate the information you previously learned from the table — "pins with GPIO and ADC functions" — into practical hardware connections and program development.
2.3 Pin Multiplexing Function
Put simply, pin multiplexing means "a single GPIO pin can serve multiple roles" — for instance, one GPIO pin can function as an ordinary switch (to control the on/off of an LED), or be switched to act as an "SPI interface"(to connect a sensor) or a "UART interface"(to connect to a serial port). Just like a smartphone's Type-C port, which can not only charge the device but also transfer data and connect to other peripherals, realizing multiple functions through one single port — that is exactly what "multiplexing" refers to.
Each individual GPIO pin can be connected to an internal peripheral device via the GPIO function defined below.
This table is the "Role Selection Table for GPIO", and its structure and usage are very straightforward:
First column (GPIO number): This refers to the specific GPIO pins (e. g., GPIO0, GPIO1), with each pin corresponding to one row;
Columns F1 to F11 (function options): These represent the "roles" that this GPIO can switch between — each GPIO can select one function from these options for use (only one function can be selected at a time);
The function description table above explains which internal components of the chip each "role" corresponds to and what this function is used for.
2.4 Brief Introduction to System Characteristics and Architecture
2.4.1 Bus Interconnection Architecture
The bus interconnection structure serves as the "data transportation system" inside a chip — it governs how data and instructions are transmitted between various functional modules (cores, memory, peripherals), making it one of the core architectures that impact the chip's operating efficiency. Understanding it clarifies how the chip "avoids data transmission congestion" and the "communication priorities of different modules", which is the key to grasping the chip's performance bottlenecks and resource scheduling logic.
The core logic of the "on-chip communication network" of the RP2350A is as follows:
AHB-Lite master (upstream port): It is the "initiator of data requests", corresponding to 4 "traffic initiators" — two processor cores (Core0, Core1), the read port of DMA, and the write port of DMA, which are responsible for sending "read/write data" requests to other modules.
AHB-Lite Crossbar (bus hub): acting as a "traffic dispatch center", it distributes requests from 4 masters to multiple "downstream ports"(i. e. the modules to which data is to be delivered); it can complete up to 4 transmissions of 32-bit data per cycle, ensuring the efficiency of data interaction.(Note: The Crossbar of RP2350A is a fully connected matrix, which is more flexible than that of RP2040)
Downstream port (destination module): It serves as the recipient of data requests and falls into three categories:
Memory Class Modules: including ROM, Flash XIP, and the split SRAM0~9 (each SRAM occupies an independent port). Splitting the SRAM into 10 ports is designed to enable "multi-module parallel access" so as to avoid access congestion of memory resources.
High-speed peripheral modules: including "Fast AHB-Lite peripherals" such as PIO0/1/2, USB, and HSTX, which are directly connected to the bus hub to adapt to the requirements of high-speed data transmission.
Low-speed peripheral modules: including peripherals such as UART, SPI, and I2C, which are connected to the bus hub via the "APB bridge" — the APB bridge acts as a "slow lane adapter", ensuring that communications from low-speed peripherals do not affect the transmission efficiency of high-speed modules.
2.4.2 Address Mapping
To understand address mapping, we must first clarify its core definition: Address mapping refers to the rules by which a chip assigns unique "numeric addresses" to all its internal resources (including ROM, SRAM, peripheral registers, etc.)— it is essentially assigning a "house number" to every memory block and functional module inside the chip; modules such as the core and DMA can use this "house number"(address) to precisely locate and access the corresponding resource.
The reason why address mapping is required is that the arithmetic and control modules of the chip (such as dual-core processors and DMA controllers) can only locate resources via "addresses": for example, when the core needs to read data from the SRAM or configure the communication parameters of the UART, it must first find the storage area of the SRAM and the control registers of the UART through the corresponding addresses — without address mapping, these modules are like "rooms without house numbers" that cannot be located or accessed at all. The essence of address mapping is to establish a unique accessible identifier for resources, which serves as the fundamental rule for internal communication within the chip.
And the address mapping works in deep coordination with the previously mentioned "SRAM partitioning" — take the SRAM of RP2040 as an example: As previously explained, the SRAM is physically divided into 6 banks (SRAM0 to SR5), which is designed to support "parallel access" by multiple modules (for instance, while Core0 is accessing SRAM0, the DMA can access SRAM1 simultaneously);The address mapping table assigns independent address ranges to these 6 banks (for example, SRAM0_BASE is 0x21000000 and SRAM1_BASE is 0x21010000).
As a result, when Core0 accesses addresses starting with "0x21000000", they actually correspond to the physical SRAM0; when DMA accesses addresses starting with "0x21010000", they correspond to the physical SRAM1 — the address mapping enables different modules to access "different physical partitions" via "different house numbers", which not only realizes precise resource positioning, but also achieves "parallel access" in coordination with the physical partitions of SRAM, avoiding resource conflicts between modules and improving data access efficiency.
The address map of the RP2350A is a significant expansion of that of the RP2040 to accommodate the increased memory and newly added peripherals:
...
As can be seen from the address mapping table in the figure:
Different types of resources are allocated to distinct address ranges, making it easier for modules to distinguish whether the target to be accessed is memory or a peripheral device.
Different sub-modules of the same type of resource (e. g., SRAM0 to SRAM9) have consecutive yet independent address ranges, which not only ensures the integrity of storage but also supports partitioned access.
A large number of additional APB peripheral address spaces have been added to map the control registers of various low-speed peripherals.
2.4.3 Processor Subsystem
The RP2350A processor subsystem consists of two switchable-architecture processors (Arm Cortex-M33 or Hazard3 RISC-V) — each comes with its standard internal Arm CPU peripherals as well as external peripherals for GPIO access and inter-core communication.
The "working interconnect framework" of the RP2350A dual-core processor defines the communication modes between the two cores and other modules of the chip as well as external devices. It serves as the fundamental supporting structure for the dual-core collaborative operation, and the functions of the core communication interfaces are as follows:
Independent AHB-Lite Bus Interface: Each core is equipped with a dedicated 32-bit AHB-Lite bus, which serves as its "exclusive main artery" for accessing memory and peripherals. The design of independent buses eliminates "traffic congestion and resource contention" that would otherwise occur when the dual cores access shared resources.
SIO Block and IOPORT: High-Speed GPIO Access + Dual-Core Collaboration. SIO is a "high-speed interface block" dedicated to dual-core systems. Each core connects to the SIO via the IOPORT, which enables "high-speed, zero-latency access" to GPIO pins and handles "Events communication" between the two cores.
Interrupt System: Division-based Response to Burst Tasks. Peripherals generate interrupt signals, which are routed to the NVICs of the two cores — the interrupt system of the RP2350A can flexibly assign system-level interrupts to either core for processing, thus improving the real-time performance of the system.
SWD Debug Bus: A unified entry point for external debugging. An external debugger connects to the DAP modules of both cores simultaneously via a multi-drop serial wire debug bus, enabling the external debug host to access and debug both cores at the same time.
Next, we will introduce these key components one by one.
2.4.3.1 Single-cycle IO block (SIO)
SIO is the "high-speed collaboration toolbox" for the RP2350A dual-core processor — it leverages the IOPORT auxiliary bus of the Cortex-M33 to achieve "single-cycle (ultra-fast)" operations, and is specifically designed to handle tasks with stringent speed and timing requirements such as "high-speed data transfer between dual cores", "contention for shared resources", and "high-speed GPIO control".
The essence of SIO is a "fast lane module" based on the IOPORT auxiliary bus: IOPORT is a dedicated fast bus port of Cortex-M33, corresponding to the address range starting from 0xd0000000, which can be accessed with ordinary read and write instructions. Moreover, SIO is not connected to the main system bus and only uses this fast channel — this ensures that all read and write operations of SIO can be completed within 1 cycle, featuring high speed and precise timing.
SIO is accessed by using the auxiliary bus IOPORT of Cortex-M33, which is designed to save access time, execute high-speed computing tasks, and can also be used for communication between two cores.
IOPORT is an auxiliary bus port on the Cortex-M33, which is capable of performing high-speed 32-bit read and write operations.
Processors access their IOPORTs using normal load and store instructions, pointing to the special IOPORT address range 0xd0000000.. .0xdfffffff. The SIO appears as memory-mapped hardware in the IOPORT space.
SIO has a dedicated bus interface for each processor's IOPORT. Due to its strict timing requirements, SIO is not connected to the main system bus, and can only be accessed by the processor or a debugger via the processor debug port.
Read and write operations of SIO are all completed in one cycle, consisting of the following units:
Dual-core FIFO: used to transfer data, messages or ordered events between two cores
One of the FIFOs can only be written by core 0 and read by core 1
The other one can only be written by core 1 and read by core 0.
CPUID: Used to identify the currently working core, the CPUID register is the first register in the IOPORT space. When accessing this address, core 0 reads a value of 0, while core 1 reads a value of 1. The software determines which core it is running on during the initial boot process: both cores start running simultaneously, core 1 enters a deep sleep state, and core 0 continues to execute the main boot sequence.
Hardware Mutex lock: It can be used to manage mutually exclusive access to shared software resources, and software interacts with each spin lock through one of the following operations
Read: i. e., acquire the lock
Write: Release the lock
Hardware division and interpolator
IO Shared Access Control
Popular Explanation of SIO
The core functional units included in SIO all serve the purposes of "dual-core collaboration" and "high-speed operation":
Dual-Core FIFO: serves as the "high-speed express box" between the two cores
FIFO0 can only be written to by Core0 and read by Core1; FIFO1 can only be written to by Core1 and read by Core0.
Its function is to enable the dual-core to transmit data and messages quickly (for example, after Core0 processes the sensor data, it directly writes the data into FIFO0, from which Core1 can read it immediately) without going through the main bus, thus avoiding latency.
CPUID: The "identification tag" for dual-core processors
Core0 reads this register and gets "0", while Core1 reads it and gets "1".
At startup, the two cores run simultaneously: Core1 reads its own ID as "1" and enters sleep mode, while Core0, which reads "0", executes the bootloader. Through this "identity identifier", task division during dual-core startup is achieved to avoid conflicts.
hardware Mutex lock (spin lock): a "shared resource placeholder" for dual-core systems
When two cores need to access the same shared resource (such as the same block of memory), use this lock: a "read lock" is equivalent to "occupying the resource", while a "write lock" is equivalent to "releasing the resource".
Ensure that only one core can use the shared resource at the same time to avoid data confusion.
Hardware Division & Interpolator: The "Fast Calculation Accelerator" for Dual-Core Processors
A hardware divider enables division operations to be completed within a single cycle (far faster than software-based calculation); an interpolator is a piece of hardware that assists with interpolation operations.
Its function is to accelerate specific computing tasks and improve core computing efficiency.
IO Shared Access Control: It is the "high-speed control port" of GPIO
Accessing GPIO registers via SIO follows a "single-cycle + atomic operation" mechanism (the operation will not be interrupted), which is faster and more precise than controlling GPIOs through the main bus.
Suitable for scenarios with high requirements for GPIO timing (such as fast control of LED blinking and high-frequency signal output).
2.4.3.2 Interrupt
Interrupts are the core mechanism of the RP2350 for handling "sudden tasks" — for example, when a timer expires, data is received via a serial port, or a sensor triggers a signal, the core cannot wait to "finish the task at hand" before processing these events; at such times, an interrupt will "interrupt" the core's current operation to prioritize the urgent task. The NVIC (Nested Vectored Interrupt Controller) acts as the "interrupt dispatcher" for each core, responsible for managing interrupt priorities and execution sequences. The following explains its logic clearly with reference to the table and relevant rules:
IRQ and Priority
IRQ :short for "Interrupt Request", is an "urgent call signal" sent by peripherals (such as timers and UARTs) to the processor core. When a peripheral needs the core to process a task immediately (for example, when a timer expires or data is received via a serial port), it will trigger the corresponding IRQ, causing the core to suspend its current work and prioritize handling this urgent task.
Priority: refers to the sorting rule for the urgency of interrupt tasks. A chip may receive multiple IRQs at the same time, and tasks with higher priority will be processed first by the core to prevent urgent tasks from being delayed.
Each core (Core0 and Core1) has an independent NVIC (equivalent to a dedicated "interrupt dispatcher") that can receive 52 interrupt signals. On the RP2350, only the lower 46 IRQ signals are connected to system-level interrupt sources, while IRQ 46 to 51 are hardwired to zero (never triggered).These six spare interrupts (referred to as SPAREIRQ_IRQ_0 to SPAREIRQ_IRQ_5 in the table) are intentionally reserved for the kernel to use for self-interrupts (via the Arm NVIC_ISPR0 register or the Hazard3 MEIFA CSR), for example, when an interrupt handler wishes to schedule a "bottom half" handler for work that must be completed after the interrupt handler exits but before the code returning to foreground execution runs.
Hardware supports nested interrupts: a low-priority interrupt can be preempted by a higher-priority interrupt or fault, and resumed after the higher-priority handler returns. The preemption priority order is determined by the interrupt priority registers, starting from NVIC_IPR0 (for Cortex-M33) or the MEIPRA interrupt priority array CSR (for Hazard3).
When multiple interrupts enter with the same dynamic priority, the interrupt with the lowest IRQ number will be selected as the winner. For this reason, system-level IRQ numbering typically assigns higher-priority interrupts to lower IRQ numbers, although the actual priority often depends on the specific application.
The interrupt vector table of the RP2350 is as follows. This table acts as the "task list for IRQs", where each IRQ number corresponds to a specific "source of urgent task":
For example, IRQ0 corresponds to the "IRQ of Timer 0"(meaning Timer 0 has timed out), and IRQ33 corresponds to the "IRQ of UART0"(meaning UART0 has received data). Once the core sees the IRQ number, it can immediately identify which peripheral has sent the "urgent call" and then invoke the corresponding handler.
The meanings of the respective interrupts are as follows:
Interrupt name
Interrupt Meaning and Additional Notes
TIMER_IRQ_x (x=0~3)
Interrupts related to the general-purpose timers (x is 0-3, corresponding to the interrupts of the 4 general-purpose timers)
PWM_IRQ_WRAP
PWM timer wrap interrupt (triggered when the PWM counter reaches its maximum value and wraps around)
USBCTRL_IRQ
USB control interrupts (triggered by events such as USB peripheral state changes and data transfers)
XIP_IRQ
Interrupt related to the SSI synchronous serial interface controller; the signal comes from the SSI controller of the XIP cache for external flash, and can be used in configurations where code runs from SRAM instead of flash; once enabled, the XIP block can be used as a normal SSI peripheral
PIOx_IRQ_y (x=0/1, y=0/1)
Programmable IO interrupts (x is 0-1 for the 2 PIO blocks, y is 0-1 for the 2 interrupts of each PIO block)
DMA_IRQ_x (x=0/1)
DMA controller interrupts (x is 0-1 for the interrupts of the 2 DMA controllers)
IO_IRQ_BANK0
General-purpose GPIO interrupts (triggered by level changes on the Pico's ordinary GPIO pins)
IO_IRQ_QSPI
Interrupts related to the QSPI peripheral GPIOs connected to external flash (triggered by events on the QSPI interface GPIO pins)
SIO_IRQ_PROCx (x=0/1)
Single-cycle low-latency IO interrupts (x is 0-1 for the SIO interrupts of the 2 CPU cores)
CLOCKS_IRQ
Clock system interrupts (triggered by events such as clock module state changes and frequency adjustments)
SPIx_IRQ (x=0/1)
SPI peripheral interrupts (x is 0-1 for the interrupts of the 2 SPI peripherals, such as receive complete and transmit complete)
UARTx_IRQ
Serial port interrupts (interrupts of the UART peripheral, such as receive complete, transmit complete, and communication errors)
ADC_IRQ_FIFO
Interrupts related to the FIFO memory of the ADC analog-to-digital converter (triggered by events such as the ADC FIFO buffer reaching a threshold or overflowing)
I2Cx_IRQ (x=0/1)
I2C serial communication bus interrupts (x is 0-1 for the interrupts of the 2 I2C peripherals, such as receive complete and transmit complete)
Actually, interrupts can also be divided into the following two types: maskable interrupts (IRQ, Interrupt Request) and non-maskable interrupts (NMI, Non Maskable Interrupt). The core difference between the two lies in "whether they can be selectively ignored by the CPU", as summarized in the table below:
Feature
Maskable Interrupt (IRQ)
Non-Maskable Interrupt (NMI)
Core Definition
An interrupt that can be selectively ignored through software configuration (masking)
The highest-priority interrupt, which breaks through normal masking restrictions
Maskability
Can be completely masked by the CPU's interrupt mask bit; once masked, the CPU will not respond even if the interrupt occurs
Cannot be masked by normal means (the core meaning of the name); can only be configured in a limited way through dedicated registers
Trigger Scenarios
Routine peripheral events (such as UART data reception, GPIO button presses, timer timeouts)
Severe emergency events (such as hardware faults, power loss, coprocessor errors, core hardware exceptions)
Priority
Lower; multiple IRQs can be nested by setting priorities through the NVIC
Highest; can interrupt an IRQ being handled, and even the CPU's normal operation
Simply put:
Maskable interrupts (IRQs) are "routine-level" interrupts — for example, the notification alert when a WeChat message arrives on your phone (which you can block by enabling Do Not Disturb mode);
A non-maskable interrupt (NMI) is an "emergency-level" interrupt, such as the alert triggered when a mobile phone detects that its battery is about to run out — this alert will pop up forcibly even if Do Not Disturb mode is enabled.
The system interrupts of the RP2350 (such as TIMER_IRQ, UART_IRQ, GPIO_IRQ, etc.) will undergo two-step processing before being combined with core interrupts into a single NMI signal that is fed into the corresponding CPU core. This entire process can be understood as "interrupt filtering and merging":
Step 1: Masking (selectively ignoring some system interrupts): First, 26 system interrupts will go through masking processing — which is equivalent to setting a "do not disturb switch" for these interrupts. You can configure the mask register to select "which system interrupts to temporarily ignore even if they occur". For example, you can set "mask UART_IRQ", then even if the UART receives data, this interrupt will not enter the subsequent processing flow.
Step 2: Perform an OR operation with the kernel interrupt to merge them into an NMI: After being masked, the remaining "non-ignored system interrupts" will undergo an OR operation with the CPU's internal kernel interrupts (such as more severe internal exceptions like power loss, coprocessor operation errors, and hardware faults) — if any one of these interrupts occurs, the result will be "interrupt present". Eventually, these scattered interrupt signals will be merged into a unified NMI signal and fed into the CPU core.
The core purpose of this process is: to uniformly encapsulate all emergency events that require the highest priority processing into NMI signals, so as to ensure that the CPU can respond to these critical events first.
NMI is not absolutely non-maskable
Many beginners mistakenly assume that NMI stands for "interrupts that absolutely cannot be masked", but in reality, the true meaning of "Non-maskable" is that even when normal maskable interrupts (IRQs) are masked, such NMI interrupts can still be delivered to the CPU.
In other words, the "non-maskable" property of NMI is relative to the masking of conventional interrupts, and it is not absolutely impossible to configure: we can still perform limited configuration on the enable of NMI signals through dedicated registers (this is a special configuration for NMI, which is different from conventional interrupt masks).
On the RP2350, by setting the bit corresponding to the target IRQ number in NMI_MASK0 or NMI_MASK1, system IRQ signals can be routed to the Non-Maskable Interrupt (NMI) input of the Cortex-M33. A non-maskable interrupt ignores the processor's interrupt enable/disable state (PRIMASK) and can preempt any other active interrupt. NMIs are typically used for emergency situations that require the processor's unconditional attention, such as PLL lock loss or compromised power integrity.
The NMI mask register is core-local, so each core can route a different combination of interrupts to its NMI input. Both the NMI mask register and all other EPPB registers are reset by a warm reset of the core. This avoids a potential issue in the RP2040 where the NMI mask register might remain asserted after a processor reset.
In addition to system-level interrupts, a non-maskable interrupt is also generated when an integrity check failure occurs in the Redundant Coprocessor (RCP). This behavior cannot be disabled, but a properly programmed RCP will not trigger it under normal voltage, frequency, and temperature conditions. Likewise, the RCP will never trigger if user code does not execute any RCP instructions. When an integrity check fails, the RCP NMI outputs on both cores are asserted, and they are cleared via a processor warm reset.
2.4.3.3 Event Signals
First, clarify the core concepts:
Event signal: It is a lightweight "wakeup/notification signal". The difference between it and an interrupt is that an interrupt "interrupts the core's current work" to handle urgent tasks, whereas an event mainly "wakes up a sleeping core" or "sends a notification to another core" and will not actively interrupt the core's operation.
WFE instruction :The full name is Wait For Event. After executing this instruction at its core, the system will enter a sleep state, suspend its operation, and will not be woken up until an event or interrupt arrives.
SEV instruction: short for Send Event. Executing this instruction on a core can actively generate an event signal to notify or wake up other cores.
In the RP2350, the event signal serves as the core mechanism for dual-core collaboration and low-power sleep, with the logic as follows:
Event intercommunication between dual cores:
The event signals between the two cores (Core0 and Core1) of the RP2350 are "cross-connected" — for example, when Core0 executes the SEV instruction to send an event, this event will be received by Core1; conversely, events sent by Core1 can also be received by Core0.
The purpose of this design is to implement "lightweight notification between dual cores": for example, after Core 0 completes Data Acquisition, it sends an event to wake up Core 1 which is in sleep state, so that Core 1 can continue processing the data. This not only avoids the waste of computing power caused by cores idling and waiting, but also is more lightweight than notification via interrupts.
Implementation of low-power sleep mode:
When the core enters sleep state by executing the WFE (or WFI, Wait For Interrupt) instruction, the core's internal clock gate is turned off, so it no longer consumes additional power; if both cores enter sleep state and the DMA is also inactive, the entire RP2350 will enter "global hibernate", which simultaneously turns off the clocks of unused modules to further reduce power consumption.
Moreover, the trigger conditions for wake-up are highly flexible: whether it is an event sent by another core or an interrupt triggered by a peripheral, it can wake up the core (or the entire chip) from sleep and resume operation — this is extremely practical in scenarios requiring low power consumption, such as battery-powered devices.
2.4.3.4 Debugging
Before understanding the structure of debugging, let's first clarify several core concepts:
SWD (Serial Wire Debug): A debug interface that uses only two wires (the SWCLK clock line and the SWDIO data line). It serves as the "channel" for communication between an external debugger (such as a debugging tool on a computer) and the internal modules of a chip, and is used to implement operations like program downloading and debugging.
DAP (Debug Access Port): It serves as the "debug entry point" inside the chip. Each core (Core0, Core1) corresponds to one DAP (DAP_0, DAP_1). An external debugger can access the operating status of the cores and control their execution via the DAP.
SWD Multi-Node Arbiter: It acts as the "traffic controller" for debug communication: an external debugger only has one SWD interface, yet needs to connect to the DAPs of two cores and the backup rescue port. The arbiter is responsible for allocating communication resources to prevent signal contention from multiple debug access points.
Rescue DP (Debug Port for Rescue): It serves as the "safe exit" for debugging — when normal DAP debugging fails (for instance, the core is locked up), this backup port can be used to restore the debugging function.
The debug communication architecture of the RP2350A implements "unified control of the dual-core by an external debugger + debug reliability assurance". The core logic is as follows:
Basic Communication of the SWD Interface: An external debugger connects to the chip's IO module via the two lines SWCLK and SWDIO, and then accesses the SWD multi-node arbiter — this is the only communication channel between the debugger and the chip's internal circuitry. It is recommended to use a maximum frequency of 24MHz to ensure stable communication.
Debug resource scheduling (function of the arbiter): Since there are 2 core DAPs inside the chip (DAP_0 corresponds to Core0, DAP_1 corresponds to Core1) and 1 Rescue DP, while the debugger only has 1 SWD interface, the arbiter allocates communication to the corresponding port according to debugging requirements:
To debug Core0, assign it to DAP_0;
To debug Core1, allocate it to DAP_1;
When normal debugging fails, it is allocated to the Rescue DP. This prevents multiple debugging entry points from competing for signals and ensures orderly communication.
Core Functions of SWD Debugging Through this architecture, an external debugger can perform the following operations:
loading programs (firmware) to the SRAM of the chip or external flash memory;
View / modify the core operating status (e. g., register values);
Core Execution Control: enables the core to run, stop, and execute code step by step, and also supports setting breakpoints (to make the core pause when executing to the specified code position).
"Rescue" Guarantee of Rescue DP When normal DAP debugging becomes unavailable due to core lockup, configuration errors or other reasons, Rescue DP can serve as a backup entry to restore the debugging function via the pam_restart signal — this is a safety mechanism to prevent the chip from being "bricked" due to debugging failures.
2.4.4 Cortex-M33 / Hazard3 Core
Here is the biggest architecture upgrade highlight of the RP2350A
The core is the central processing brain of a microcontroller chip. The RP2350A breaks the norm by integrating two distinct dual-core processor architectures on a single chip, which users can select at boot time via software or even OTP fuse bits:
Arm Cortex-M33 processor: This is an industry-standard core. Compared with the Cortex-M0+ of the RP2040, it not only features a higher clock speed (150MHz), but also supports hardware single-precision floating-point operations (FPU) and DSP instructions, and introduces Arm TrustZone technology, which can create an isolated secure environment for sensitive code and data.
Hazard3 RISC-V Processor: This is a pair of open-source RISC-V cores that allows users to experiment with and transition to the RISC-V architecture in a stable, well-supported ecosystem.
Regardless of which architecture is selected, both cores will operate at a frequency of 150MHz.
Core Features of Arm Cortex-M33:
It adopts a 3-stage pipeline structure (instruction fetch, decode, execute), which delivers higher efficiency than the 2-stage pipeline of the M0+;
Supports single-cycle I/O access with extremely fast I/O access speed;
Low power consumption with integrated sleep mode;
Capable of deterministic, fixed-latency interrupt processing;
The Thumb-2 technology combines 16-bit short instructions and 32-bit long instructions;
Supports hardware single-precision floating-point arithmetic (FPU) and DSP instructions;
Arm TrustZone technology is introduced to support switching between secure and non-secure states;
An exception model compatible with C application binary interfaces;
Enter low-power sleep mode using the Wait-For-Interrupt (WFI) and Wait-For-Event (WFE) instructions;
What is a "pipeline"?
Pipelining is a parallelized working mechanism for processors to execute instructions. The 3-stage pipeline of the Cortex-M33 splits instructions into three steps: "fetch", "decode" and "execute", allowing different steps to be carried out simultaneously to further improve instruction execution efficiency.
Commonly used in the following applications:
General data processing and I/O control tasks
Ultra-low Power Consumption Applications
Security applications requiring trusted firmware
Industrial-grade deployments with stringent I/O requirements
For the normal operation of the kernel, different modules are required to provide basic guarantees such as power supply, clock, interrupt, and debugging for the kernel:
Power Consumption and Clock PMU: A core module that controls the power consumption state of the kernel and realizes "ultra-low power consumption".
Reset Control (RESET CTRL): Responsible for the restart of the core.
Memory and Access MPU + Bus Interface: The MPU (Memory Protection Unit) manages the memory access permissions of the core to prevent programs from accessing illegal memory by mistake.
Interrupt and Low-Power NVIC + WIC: It schedules interrupt priorities, and the WIC can detect interrupt signals and wake up the core when it is in deep sleep mode.
Debug Breakpoint/Watchpoint Unit + DAP: The "handle" for debugging programs, serving as the entry point for communication between external debuggers and the core.
(If the RISC-V architecture is selected, its internal structure is similar to the above, but it complies with the standard instruction set and debugging specifications of RISC-V)
2.4.5 DMA
The core function of a kernel is to "perform operations and process tasks"; if it is made to manually move data, computing power will be wasted. DMA, by contrast, is a "dedicated data transfer tool" that can efficiently complete bulk transfers.
The RP2350A upgrades the DMA to 16 independent channels, is equipped with 4 system IRQs, features separate read and write master connections, and can perform bulk data transfers on behalf of the processor.
DMA can control up to 32-bit data during individual read and write operations, features 16 independent channels, and each channel monitors a series of bus transmissions.
DMA is typically used for data transmission in the following three scenarios:
Memory to Peripheral
Peripheral to Memory
memory to memory
The architecture diagram illustrates the "internal workflow" of DMA, and the functions of each module are as follows:
AHB-lite Read/Write Master Bus: The "interface" where DMA connects to the system bus (AHB-lite);
Read/Write Address FIFO: It stores the addresses to be read from or written to, so as to avoid laggy performance caused by the "mismatched rhythm" between address generation and data transfer;
Transfer Data FIFO: It stores the data being transferred, and also functions as a buffer;
Address Generator: the "automatic address calculator" of DMA;
Control/Status Registers: the control center and status display of DMA;
AHB-lite Slave Interface: it serves as the entry point for DMA configuration via the core;
Next, let's take the "peripheral to memory" transfer as an example:
The core writes configurations to the Control/Status Registers via the AHB-lite Slave Interface;
The Address Generator automatically generates the peripheral address to be read and the memory address to be written, and stores them in the Read/Write Address FIFO respectively;
The AHB-lite Read Master reads data from the peripheral and stores it into the Transfer Data FIFO buffer;
The AHB-lite Write Master fetches data from the Transfer Data FIFO and writes it to the target address in the memory.
During the entire process, the kernel does not need to participate, and the whole process is completed automatically by DMA.
Each channel of DMA is equipped with a corresponding status register, through which software can program and monitor the progress of data read and write operations on that channel.
The size of data transferred via DMA can be 32 bits, 16 bits or 8 bits. Each channel is configured such that the source transfer size matches the destination transfer size.
DMA channels can be combined with each other; for instance, one channel can configure another one by loading configuration data from a series of control blocks in memory, and then when reconfiguration is required, the second channel can invoke the first channel via the CHAIN_TO option.
Meanwhile, DMA can also be used in conjunction with other peripherals, and data is transmitted directly between peripherals and DMA via DREQ channels.
For the correspondence between different peripherals and DREQ channels, please refer to the DREQ table:
DMA can also be used in conjunction with interrupts, and an interrupt can be triggered when data reading and writing of a certain channel in DMA is completed.
The RP2350A DMA provides four system IRQs (IRQ0 to IRQ3) with individual masking and status registers. Any combination of channel interrupt requests can be routed to any of these four system IRQs:
System IRQs: These act as four "general service hotlines", through which all DMA channels send their "completion notifications" to the kernel.
Mask Register: A "mute switch" that controls which channel interrupts can be responded to.
Status Register: "Call Log", which records which channel has completed its task.
Routing: Flexibly arrange which channel's notifications go through which hotline, and you can even set priorities.
The advantage of this design is that it can manage the interrupts of up to 16 DMA channels more flexibly and avoid interrupt signal confusion.
2.4.6 Memory
Here, we first clarify several core concepts of "mapping"(which serves as the foundation of memory access), and then explain the address mapping tables for memory and SRAM. For the resources inside a chip (including memory, registers, and peripherals) to be accessible, they must first be assigned "house numbers" — this is the essence of "mapping":
Address mapping: Assign a unique "digital house number"(i. e., system address) to all resources in the chip. For example, the house number of SRAM starts at 0x20000000, and that of ROM starts at 0x00000000. The core / DMA can accurately locate the resource to be accessed through the "house number", which is equivalent to a "correspondence table between resources and house numbers";
Register mapping: A subset of address mapping, which assigns "house numbers" to the registers (small memory units for storing configuration and status) inside a chip. For example, "0x40008000 corresponds to the baud rate register of the UART" — software can configure the UART by writing to this address, which essentially serves as a "correspondence table between register functions and their assigned addresses".
Remapping refers to "reassigning port numbers" — for example, if port A originally corresponds to memory, after remapping, port A can correspond to a peripheral, which allows flexible adjustment of resource access addresses to adapt to different scenarios.
For knowledge related to address mapping, register mapping, remapping and other related concepts, please refer to the following link:
Fundamentals of the STM32 Register Version — Memory Mapping:
https://developer.aliyun.com/article/935522
【Experience Sharing】STM32 Getting Started Series - STM32 Peripheral Address Mapping
Memory access is entirely based on address mapping. Let’s take a closer look at the memory of the RP2350A: the RP2350A has built-in ROM and SRAM, and accesses external Flash or PSRAM via the QSPI interface.
2.4.6.1 ROM
16kB Read-Only Memory (ROM) at address 0x00000000, which is equivalent to a "pre-installed toolkit built into the chip" and contains:
Initialize the boot routine
Flash boot sequence
Flash Programming Routine
USB mass storage device supporting UF2
Utility libraries (e. g., fast floating-point, hardware SHA-256 acceleration interface, etc.)
This ROM supports single-cycle read-only bus access and is connected to a dedicated AHB-Lite arbiter; any attempt to write to the ROM will have no effect.
2.4.6.2 SRAM
The total on-chip SRAM amounts to 520 kB. Physically, it is divided into ten banks (Bank0 to Bank9), which significantly enhances the memory bandwidth for multiple masters; for software, it can be regarded as a contiguous 520 kB memory region for read and write access operations.
Each SRAM bank can be accessed via a dedicated AHB-Lite arbiter, which means that different bus masters can access separate SRAM banks in parallel, allowing up to four 32-bit SRAM accesses per system clock cycle.
In the memory map, the start address of the SRAM is 0x20000000, and the base address of each specific bank is as follows:
[Image]
We can see that this mapping table contains the following information:
System address: the "house number" of SRAM;
SRAM Bank (SRAM physical partition): The actual physical storage blocks of SRAM (Bank0 to Bank9);
SRAM word address: The offset house number inside this bank.
System addresses are sequentially mapped to different physical banks. The advantage of this mapping is that when multiple modules access different system addresses simultaneously, they are actually accessing separate physical banks, which enables "parallel access" and significantly improves the read and write speed of SRAM.
2.4.6.3 Flash and External Storage
Here, we first introduce two key concepts:
QSPI interface: the "high-speed data line" between the chip and external Flash/PSRAM, which is responsible for the communication between the chip and external storage.
XIP (Execute In Place): It allows programs to be executed directly by accessing the external storage without the need to copy the programs from the external storage to the on-chip SRAM.
The core of the entire structure is to enable external storage to be accessed in the same way as internal memory, while leveraging caching to boost speed:
SSI module: directly connected to the QSPI interface, serving as the "physical layer" for communication with external storage;
Atomic RWType Interposer: ensures that read and write operations to Flash are "completely uninterrupted";
Mux Multiplexer: The "data path switch" that selects whether data is read from the Cache or directly from storage;
Read-only Cache: Since external storage is relatively slow in speed, the Cache stores frequently accessed content here, which significantly improves the speed of XIP;
Streaming FIFO: When reading a large amount of consecutive data, the data is first stored in this FIFO to enable smoother consecutive access;
Decode and Config: parses the address sent by the core, and manages the configuration of the entire XIP hardware;
Main AHBL Slave / Aux AHBL Slave: the "interface" connected to the system bus;
AHBL-APB Bridge for SSI Configuration: The kernel configures parameters for the SSI module through this interface.
When the kernel needs to read program instructions from external storage, it efficiently completes this operation through this set of hardware mechanisms. In addition, the QSPI controller of the RP2350A also supports external PSRAM, which further expands the memory capacity.
2.4.6.4 OTP (One-Time Programmable Memory) — New in RP2350A
The RP2350A introduces 8kB of one-time programmable (OTP) memory.
OTP is a type of storage medium that can only be written once (or a small number of times); once written, the data is permanently retained, will not be lost even when power is cut off, and cannot be easily tampered with.
In the RP2350A, OTP is primarily used to store security-sensitive information, such as:
The decryption key or public key fingerprint (Hash) for Secure Boot
Unique Identifier (Unique ID) of the device
User-defined encryption key
By combining the secure boot code in ROM with the keys in OTP, the RP2350A can implement robust anti-firmware tampering and cloning protection mechanisms.
2.4.7 BOOT Boot Sequence
The "boot sequence" of a chip is just like the entire process of a computer from being in a "black-screen power-off state" to "entering the system and being able to run software" after it is turned on. After the RP2350A is powered on or reset, it will first execute the "boot process" built into the chip.
The startup process here can be divided into the following two stages:
Hardware control (hardware controlled): The chip performs its own preparation tasks;
Processor controlled: Execute the bootrom bootloader.
bootrom boot loader
The bootrom bootloader is a piece of code smaller than 16KB that runs first when the chip is powered on or reset. It consists of:
Processor core 1 low power wait and launch protocol (Core 1 low-power wait and start protocol)
USB MSC class mass storage bootloader (supporting UF2) for downloading code/data to FLASH or RAM
USB PICOBOOT bootloader interface for advanced management
Routines for programming and operating external flash memory
Fast Floating-Point Library
Fast Bit Counting/Manipulation Function
Fast memory fill/copy function
2.4.7.1 hardware-controlled boot sequence
When the chip is powered on, the RUN pin is set;
The on-chip voltage regulator waits for the digital chip power supply (DVDD) to stabilize;
The power-on finite-state machine has been started and has completed the following tasks in sequence:
a. The ROSC (Ring Oscillator) has been started, providing the initial clock source for the clock generator, with clk_sys and clk_ref operating at a relatively low frequency;
b. The main clock multiplexer selects ROSC as the clock source;
c. The reset controller releases the reset on the processor, and the processor starts executing code;
d. Instruct the ROM (boot ROM) to start execution.
2.4.8 Power Supply System
Popular Analogy
If a chip is compared to a miniature city, its power supply system is exactly the "power grid" of this city. All the residents (cores), shopping malls (SRAM) and external stations (GPIO) in the city require power of different specifications to function. Fortunately, the RP2350A is a "highly integrated" modern city: you only need to connect it to a 3.3V main power supply, and its internal "substation (LDO)" will automatically step down the voltage and distribute it to each component, eliminating the need for you to build a complex external power supply circuit.
The power supply system of the RP2350A has been restructured compared to the RP2040: the separate power pin for the ADC has been removed, and the independence of the core power supply has been enhanced. Its main power supply pins are divided into the following categories:
2.4.8.1 External Main Power Supply Input (VREG_VIN)
This is the "main switch" that supplies power to the entire interior of the chip. You only need to connect a 3.3V DC power supply here, and the voltage regulator inside the chip will start working to generate the required voltage for other modules.
Connection method: Connect a 1μF ceramic capacitor in parallel to the ground near the pins to filter out power supply noise and ensure a stable input voltage.
2.4.8.2 Digital IO Power Supplies (VDDIO0 and VDDIO1)
This is the power supply for the chip's "external communication", namely the high-level voltage of the GPIO pins.
Function: The RP2350A divides GPIOs into two groups (Bank0 and Bank1), each with independent power supply pins (VDDIO0 and VDDIO1). This means you can have one group of pins operating at 3.3V, while the other group is compatible with 1.8V or 2.5V devices via an external level shifter chip.
Note: Typically, it is sufficient to connect to the same 3.3V power supply as VREG_VIN. A 100nF decoupling capacitor shall be placed adjacent to each pin.
2.4.8.3 Core Power Supplies (VCORE0 and VCORE1)
This is a dedicated power supply for the "brain and memory" of the chip (dual-core processor, SRAM, ROM), with an extremely low voltage (usually around 0.8V - 1.1V).
Features: No external supply required! The two built-in LDOs (Low-Dropout Regulators) inside the chip will automatically step down the input 3.3V to the standard voltage required by the core.
Connection Method: All you need to do is to filter the internal LDO output pins (VREG_LDO_OUT0/1) via a capacitor (2.2μF is recommended), and then directly connect them to the corresponding core power pins (VCORE0/1). This is just like connecting the output terminal of a "substation" to the "urban power grid".
2.4.9 Linear Dropout Regulator (LDO) for Core Power Supply
Simple Analogy
If the external 3.3V supply is the "high-voltage power line", then the on-chip low-dropout regulator (LDO) is the chip's built-in "phone charger (power bank)". It is responsible for precisely stepping down the 3.3V high voltage to around 1.1V that the core can accept, while also keeping the voltage rock-solid so as to prevent the chip from "crashing and rebooting" due to voltage fluctuations.
The RP2350A integrates two independent LDOs (LDO0 and LDO1), which supply power to the two cores (Core 0 and Core 1) of the processor and their associated memory units respectively. Automatic voltage regulation: By default, the LDO outputs 1.1V. However, if you are writing low-power code, you can configure the voltage to a lower level (down to 0.65V minimum) via software; when combined with a reduced main frequency, this enables the chip to achieve ultra-low power consumption when entering sleep mode.
Overload protection: Built-in current limiting (maximum output approx. 400mA) to prevent chip burnout caused by short circuits or program runaway.
Three operating modes of LDO (controlled via registers):
Normal Mode (Normal): The default state upon power-on, which stably outputs the set voltage and supplies power at full capacity.
High-impedance mode (High-Z): The LDO stops operating, and the output terminal becomes "floating". This mode is typically used when you want to connect an external, more power-efficient switching power supply to replace the internal LDO (an advanced usage scenario).
Shutdown Mode: Complete power-off. If the kernel is still running at this point, it will trigger a reset.
2.4.10 Low Power Mode Adjustment
Popular Analogy
Power consumption of a chip is analogous to running a company, and low-power regulation functions as an "energy-saving management system". When certain departments (peripherals) have no tasks to handle, you either put them on "standby (clock gated)" or directly "lay off staff (power gated)" to cut down the company's operating costs (battery life).
The RP2350A features highly flexible dynamic power management:
Precise Clock Gating: Each peripheral (such as UART, PWM, PIO) is equipped with an independent "clock switch". In the code, as long as you do not initialize a certain peripheral, its clock is turned off by default, resulting in zero dynamic power consumption.
Dynamic adjustment of main frequency: The system clock (CLK_SYS) can switch its source or reduce the frequency division coefficient at any time. For example, it normally runs at full speed of 150MHz, and will automatically drop to 48MHz or even lower when it detects that the user has not operated for 5 seconds.
For static power consumption (leakage current during standby), the RP2350A provides multiple levels of sleep modes:
WFI (Wait For Interrupt) / Sleep Mode:
State: The CPU stops executing instructions, while the contents of the SRAM and registers are fully retained, and all peripherals continue operating.
Wake-up: Any interrupt (such as a timer timeout or a key press) can wake up the the CPU instantly.
Power consumption: Medium (mainly the static leakage current of SRAM and LDO).
Deep Sleep :
Status: The CPU, most peripherals, and even the high-frequency PLL are all shut down. Only the low-speed real-time clock (RTC) and wake-up logic remain operational. The contents of the SRAM are still retained.
Wake-up: It can only be triggered by the level change of a specific GPIO pin or the RTC alarm.
Power consumption: Extremely low (only at the microampere level), making it ideal for battery-powered IoT devices.
2.4.11 Reset System
Simple Analogy
Reset is the "restart mechanism" of a chip. This mechanism is required in all scenarios, whether it is when power is just plugged in (cold start), when the program runs wild and crashes (watchdog reset), or when you simply want to reset a faulty hardware module (subsystem reset).
2.4.11.1 Chip-Level Reset (Global Reset)
This reset will return the chip to its factory state, clearing all registers and memory (with the exception of special reserved areas).
Trigger Condition:
Power-On Reset (POR): Automatically triggered the moment the power supply is plugged in, as the voltage rises from 0 to a stable value.
External pin reset: Pull the RUN pin low for a period of time (similar to the restart button on a computer).
Brown-Out Detection (BOD): When the input voltage drops below a safe threshold (for example, falling from 3.3V to 2.7V), the chip will force a reset and cut off the power supply to prevent logic confusion.
Watchdog Reset (Watchdog): If the program freezes and fails to "feed the dog"(reset the watchdog) on time, the watchdog will trigger a system reset.
2.4.11.2 Subsystem Reset (Peripheral Reset)
Only reset the specified peripheral without affecting the CPU and other modules.
Application Scenario: For example, if your USB communication is suddenly interrupted, instead of restarting the entire chip and causing task interruption, you can just reset the USB controller to let it re-enumerate, and the connection will be restored in one second.
2.4.12 Power-On finite-state machine (Power-On State Machine)
Popular Analogy
If we compare chip startup to a rocket launch, the power-on finite-state machine is exactly that "countdown system". It is controlled purely by hardware logic, independent of software, and is responsible for waking up the internal modules of the chip one by one in a strict sequence.
Why is it needed?
If power is supplied to all modules at once, it may generate a huge inrush current that burns out the chip, or cause the kernel to start reading data before the clock stabilizes, leading to a crash.
Boot sequence of the RP2350A:
Power Supply and Reset: When the VREG_VIN voltage is detected to meet the specification, the RUN pin is pulled high to release the global reset.
Start the internal oscillator (ROSC): First, activate a relatively inaccurate internal clock to provide the system with a "heartbeat".
Start the external crystal oscillator (XOSC): Switch to an external high-precision crystal oscillator (e. g., 12MHz) to obtain a stable clock.
Start the phase-locked loop (PLL): multiply the crystal oscillator frequency (e. g., up to 150MHz) to serve as the system clock frequency.
Initialize memory and bus: Wake up the SRAM, initialize the AHB crossbar switch, and open up the data expressway.
Yield control: Finally, jump to the Bootloader code in the ROM to prepare for loading the user program.
The whole process is fully automatic, and developers do not need to write any code, just ensure that the hardware circuit is correct.
2.4.13 Clock System
Popular Analogy
If the heartbeat of a chip is uniform, different components, like organs, require different blood supply rates. The clock system is essentially a "variable-frequency water supply system": it features multiple water inlets (clock sources), which, after going through pressurization (PLL) and flow splitting (frequency dividers), deliver power precisely to every peripheral component.
Clock architecture upgrade points of the RP2350A:
More abundant clock sources: In addition to the internal ring oscillator (ROSC) and crystal oscillator (XOSC), support for USB recovery clock and HSTX high-speed clock has also been added.
Independent PLLs: Equipped with two separate phase-locked loops (PLL_SYS and PLL_USB), which can respectively generate the high-frequency clock required by the system and the fixed 48MHz clock for USB.
Configurable GPOUT: Any internal clock frequency can be output via GPIO pins, which facilitates oscilloscope measurement or serves as a clock source for other chips.
Common clock distribution:
CLK_SYS (System Clock): The operating frequency of the CPU and bus, with a maximum value of 150MHz (133MHz for RP2040).
CLK_PERI (Peripheral Clock): It usually follows the system clock and is used for standard peripherals such as UART and SPI.
CLK_USB (USB Clock): Fixed at 48MHz to ensure error-free USB communication timing.
CLK_ADC (ADC Clock): It is usually set to 48MHz or derived from the frequency division of the system clock to ensure the accuracy of analog-to-digital conversion.
CLK_RTC (Real-Time Clock):Derived from frequency division of a low-frequency clock (e. g., 46875Hz), it is used to provide precise second-level timing.
2.4.14 GPIO Interfaces and Peripherals
Popular Analogy
GPIO is the "tentacles" and "eyes" that chips extend to the outside world. The RP2350A features up to 48 GPIO pins (the exact number depends on the package; for example, the QFN-60 package provides 30 user GPIOs), which are extremely flexible and can be configured via software to function as almost any type of Communication Protocol.
2.4.14.1 Function Select
The RP2350A has much more powerful pin multiplexing capabilities. Each pin incorporates an internal multiplexer that can be configured via the FUNCSEL register to assign the pin to one of the following roles at any given time:
SIO (Software Controlled IO): The most basic input/output function, used to light up LEDs or read key presses.
UART / SPI / I2C: Standard UART, synchronous serial and two-wire serial communication.
PWM: Pulse Width Modulation, which is used to control the speed of a motor or the brightness of an LED.
PIO (Programmable Input/Output): The ace peripheral of the RP2350A! You can program the hardware finite-state machine logic on your own to implement functions such as WS2812B LED strip control, SD card read/write, and even VGA video output.
HSTX (High-Speed Serial Port): Used to drive high-speed peripherals, such as those connected to LCD screens and the like.
(Note: To avoid signal conflicts, only one function can be selected for a single pin at a time; likewise, the input pin of a peripheral cannot be bound to two different GPIOs simultaneously.)
2.4.14.2 Interrupt Control
GPIO can be configured to trigger an interrupt when a level or edge change occurs, eliminating the need for the CPU to constantly perform polling queries.
High-level trigger / Low-level trigger
Rising edge trigger (level changes from low to high) / Falling edge trigger (level changes from high to low)
2.4.14.3 Electrical Characteristics of IO (Pads)
To protect the chip and adapt to different peripherals, the physical interface (Pad) of GPIO supports hardware-level parameter adjustment:
Drive Strength: Optional values are 2mA, 4mA, 8mA and 12mA. If the LED cannot be driven properly, try increasing the drive current.
Pull-up / Pull-down Resistor: When the pin is left floating, it automatically clamps the pin to a high or low level to eliminate the indeterminate state.
Schmitt Trigger: When enabled, it can enhance the anti-jitter capability of the pin, which is very useful when reading mechanical contacts such as buttons.
Slew Rate: Controls the speed of level transition. Set it to a higher value for high-speed communication, and a lower value for low-speed operation to reduce electromagnetic interference (EMI).
2.4.15 Sysinfo Register (System Information)
Popular Analogy
Just like pressing Win + Pause when a computer starts up to open "System Properties", the Sysinfo module acts as an "ID card reader" reserved by the chip for software to query relevant information.
Its register base address is 0x40000000, which stores several key read-only pieces of information:
CHIP_ID (Chip ID): A manufacturer ID and device ID compliant with the JEDEC standard. Software can read it to determine which chip it is currently running on (to prevent code from being flashed to the wrong model).
PLATFORM: Platform identification code, used to distinguish different packages or variants of the same chip.
GITREF: The Git version hash during the chip R&D phase, which is mainly used by the official Raspberry Pi team to trace the factory batches and firmware versions of chips.
2.4.16 Syscfg Register (System Configuration)
Popular Analogy
If Sysinfo serves as the tool for "viewing system properties", then Syscfg is the "BIOS setup interface" for the chip, which governs the most core low-level behavior configurations of the chip.
The address is 0x40008000, and its main functions include:
NMI Mask Configuration (NMI_MASK): NMI (Non-Maskable Interrupt) is the highest-priority hardware interrupt, which will forcibly interrupt the CPU even when it is processing other tasks. This section allows you to configure which hardware errors (such as watchdog timeout, power failure) can trigger an NMI.
Debug Interface Control (DBGFORCE): Allows forcibly enabling or disabling the debug port via software. It can also be configured to let Core0 debug a crashed Core1, implementing the "dual-core mutual check" function.
Memory Power-Down Control (MEMPOWERDOWN): An ultra power-saving option. If you are certain that certain SRAM Banks or ROM are not needed at present, you can cut off their power here. Note: Data in the powered-down Banks will be lost!
GPIO Synchronization Bypass (IN_SYNC_BYPASS): An advanced optimization option. Under normal conditions, external GPIO signals need to be synchronized to the system clock domain through two stages of flip-flops to prevent metastability. If you Aim for the Highest IO toggle speed (e. g., generating ultra-high frequency signals via PIO), you can bypass the synchronizer through this register, provided that the external signals strictly meet the timing requirements.
2.4.18 TBMAN (Test Bench Manager)
Popular Explanation
TBMAN is short for Test Bench Manager.
Before a chip leaves the factory, the manufacturer requires an automated mechanism to test whether there are short circuits or open circuits in the logic gates and interconnects inside the chip. TBMAN is a module retained inside the chip for this production test purpose.
Impact on developers:
As an ordinary application developer, you will generally never need to operate on or care about the TBMAN module. It is only used during the self-test performed by Bootrom in the very early stage of chip startup, or in extremely special hardware fault diagnosis scenarios. If you encounter this module in an Errata or during advanced debugging, just know that it serves as an "internal physical checkup for the chip".
References
Analysis of Hardware Design and Power Architecture of RP2350A Development Board https://blog.csdn.net/weixin_34511754/article/details/159254446
DC-DC Power Supply Chip —— RT6150BGQW Datasheet https://item.szlcsc.com/159304.html
Raspberry Pi Pico2 Python SDK:A MicroPython environment for RP2350 microcontrollers
RP2350 Datasheet
Raspberry Pi Pico W Pinout and Battery Power Supply Method https://www.cnblogs.com/doulan/articles/17249356.html
[Raspberry Pi Pico Review] Pico Power Supply Section https://bbs.eeworld.com.cn/thread-1160873-1-1.html
Exploring Microsoft UF2: A Simple and User-Friendly Firmware Update Format https://blog.csdn.net/gitblog_00010/article/details/137706427
USB Flashing Format (UF2): https://microsoft.github.io/uf2/
XIP (eXecute In Place) Function of QSPI FLASH https://www.coder.work/article/7761270#google_vignette
Execute In Place (XIP) on Nor Flash chip https://blog.csdn.net/u012351051/article/details/81034661
TaterLi Personal Blog https://www.taterli.com/
Pico Development Environment Configuration https://blog.csdn.net/always_one/article/details/128193686
Version Record
Version Number
Modifier
Time
Content
v1.0.0
Li Zisheng
2025/09/16
Initialize the document, based on MicroPython version V1.23.0.