In this article, I’ll show you the Raspberry Pi Pico2 (RP2350) schematic & PCB design steps to make your own custom RP2350 PCB board. I’ll explain some of the design decisions I’ve made, how to prepare the files needed for manufacturing, and how to place the PCB SMT order at JLCPCB, who are kindly sponsoring this project.
This is a custom RP2350 development board designed for evaluating the Raspberry Pi Pico2 RP2350 MCU with an ESP32-C3 for WiFi/BLE connectivity. This project can serve as a baseline for anyone willing to create their own custom dev board based on the RP2350 microcontroller.
This Project is Sponsored By JLCPCB
Table of Contents
- RP2350 Hardware Design Overview
- Raspberry Pi Pico2 (RP2350) Schematic Design
- Placing PCBA Order @ JLCPCB
- Getting Started With Raspberry Pi Pico C/C++ SDK
- RP2350 LED Blinking GPIO Example (C SDK)
- RP2350 USB CDC Serial Printf Example (C SDK)
- RP2350 WS2812 Neopixel RGB Example (C SDK)
- Getting Started With RP2350/RP2040 (in Arduino)
- RP2350 GPIO + USB CDC Serial Print (in Arduino)
- RP2350 + ESP32-C3 WiFi WebServer Demo Example
- Wrap Up
- [YouTube Video] RP2350 Schematic + PCB Design Project
RP2350 Hardware Design Overview
This PCB project features an RP2350B microcontroller for evaluation and development purposes, and it also has an ESP32-C3 with a chip antenna onboard to provide WiFi/BLE connectivity over an SPI bus between the RP2350 & ESP32-C3 microcontrollers.
In this project article, we’ll address the RP2350 hardware design aspect of the project, and the ESP32-C3 part will be covered in an upcoming project article.
RP2350 Overview
The RP2350 is a quad-core microcontroller designed by Raspberry Pi, featuring Dual ARM Cortex-M33 processors or Dual RISC-V cores. It supports either ARM or RISC-V dual-core operation, so you won’t have all 4 cores running at the same time.
It includes a rich set of peripherals such as ADC, DMA, PWM, Timers, Serial Communication interfaces, and PIO (Programmable I/O), which enable versatile hardware control and interfacing.
The RP2350 strikes a great balance between performance, low power consumption, and affordability, making it an ideal choice for DIY projects, education, and professional applications. Below is a block diagram of the microcontroller’s top-level architecture.
RP2350 Variants
There are four variants in the RP2350 microcontroller family, which are: RP2350A, RP2350B, RP2354A, RP2354B.
Here is a brief comparison table for the major differences between those devices:
RP2350 VS RP2040
Here’s a brief (RP2350 vs RP2040) comparison table highlighting their major differences:
| Feature | RP2040 | RP2350 |
| CPU Cores | Dual-core ARM Cortex-M0+ | Dual-core ARM Cortex-M33 (with FPU) OR Dual-core Hazard3 RISC-V (user-selectable) |
| Max Clock Speed | 133 MHz (Can be overclocked) | 150 MHz (Can be overclocked) |
| SRAM | 264 KB | 520 KB (in 10 banks) |
| Flash (Internal) | None (relies on external QSPI flash) | None on RP2350A/B, but RP2354A/B variants include on-chip 2MB QSPI NOR flash |
| GPIO Pins | 30 | 30 to 48 (depending on package variant) |
| PIO State Machines | 8 (2 blocks) | 12 (3 blocks) |
| USB Support | USB 1.1 Device and Host | USB 1.1 Device and Host (controller and PHY included) |
| Security Features | None | Arm TrustZone, signed boot, 8KB antifuse OTP, SHA-256 acceleration, hardware TRNG, glitch detectors, global bus filtering |
| Floating Point | Software-Emulated | Hardware floating-point unit (FPU) |
| Power Management | Basic | Improved with on-chip switched-mode power supply (SMPS) and programmable LDO |
RP2350 Hardware Design Guidelines & Datasheet
To design a custom RP2350-based PCB project, we’ll need to reference the documents below.
RP2350 Raspberry Pi Pico2 Datasheet
RP2350 Hardware Design Guidelines
Raspberry Pi Pico2 (RP2350) Schematic Design
This is the schematic design that I came up with for this Raspberry Pi Pico RP2350 development board project. Some parts are not mandatory and can be omitted for even more cost optimization if needed.
1. DC PWR In + LDO + USB
There’s a USB-C port that I’m using for power input (+5V) as well as USB communication that’s required for UF2 flash programming of the Raspberry Pi Pico2 (RP2350) chip.
The USB +5V input is regulated down to 3.3V using an LDO. The +3.3V is then used to power up the RP2350 microcontroller and the internal SMPS that generates the +1.1V digital supply voltage.
2. RP2350B MCU Circuitry + QSPI FLASH
The RP2350 microcontroller requires a +3.3V input voltage @ IOVdd pin, +1.1V from the SMPS that powers the DVDD, 100nF decoupling capacitors, and a 12MHz crystal oscillator.
The RP2350B variant doesn’t have an internal flash memory. Therefore, an external Quad-SPI (QSPI) flash chip is required. You can add a 2MB, 4MB, 8MB, or 16MB flash chip.
On my board, I’ve used the maximum flash size allowed by the RP2040’s XIP (eXcute-In-Place) interface, which is 16MB (128Mbit).
I’ve also added a RESET button to reset the microcontroller when needed. And we’ll need it every time we try to flash a new firmware to the chip. For UF2 programming, a BOOT button is also needed on the QSPI CS line.
3. SWD Debug Port
To debug the the RP2350 microcontroller, a serial wire debug interface can be routed to a pin header on your dev board. Typically, it’ll include: (+3.3v, GND, SWD, SWCLK).
4. IO Port + LEDs
Just pin out all the IO pins you need to one or two headers, depending on your desired board shape and layout.
For my board, I’ve added a power indicator LED + 1x user-programmable LED + 1x NeoPixel RGB LED (WS2812B).
Placing PCBA Order @ JLCPCB
Finally, we’re ready to generate the fabrication files and send them to JLCPCB for PCB fabrication and assembly. For this task, I use the KiCAD plugin named “Fabrication Toolkit”. With just one button click, you’ll have all manufacturing output files ready in a new folder that’s automatically created for you by the plugin toolkit.
1. Upload Your Gerber File & Check PCB Fab. Options
The next step is to upload your PCB Gerber files and modify the PCB fabrication options as needed in your project. Just keep an eye on the price because some options are not considered as a standard fabrication process, which will end up costing you a bit more and take a bit more time to get fabricated.
Even if you’re 100% sure that your design & fabrication files are flawless, the online system & JLCPCB or any other fab house can still pick up incorrect components’ orientation or placement. Always double-check the PCB component placement after uploading your files.
2. Upload BOM & CPL Files
The next step is to upload your design’s BOM file and the components positions file (CPL) to JLCPCB and let it check the files and report the stock status and total number of components to be assembled, their cost, and so on.
Check everything and make sure the components are selected correctly from the JLCPCB SMT library. And also double-check the component placements on the next page and correct any wrong rotations in the CPL file. There is a mismatch between the KiCAD output position file & JLCPCB’s system, so it does pick up wrong orientations for some ICs, diodes, etc. Always double-check everything before placing the order.
Note that if you’re not using the polarized inductor recommended by the RP2350’s datasheet for the buck converter and/or the Abracon 12MHz oscillator, you’ll not be able to proceed with your order and will get a message like the one shown below.
3. Pay To Place Your Order
The last step to place your order is to pay for the invoice, and you can apply any valid discount coupon at this step to reduce the cost.
4. Wait For Delivery & Prepare For Testing!
You should expect to receive your board within 4 days to 1 week, depending on where you live.
Here is how it turned out at the end.
Getting Started With Raspberry Pi Pico C/C++ SDK
To get started with Raspberry Pi Pico (RP2350/RP2040) MCU development in C/C++ SDK, you first need to install the required toolchain. The tutorial linked below is a very detailed guide that will help you get started with embedded C development for the RP2040 microcontroller.
This tutorial is the ultimate guide for getting started with Raspberry Pi Pico using C/C++ SDK. You’ll learn how to install the Pico C/C++ SDK toolchain, create a project from scratch, and build/flash your Embedded-C/C++ projects to the Raspberry Pi Pico (RP2040-based) boards.
Alternatively, you can use the new Visual Studio Code Extension that automatically downloads/installs the toolchain on your machine. And it’ll also make it so much easier for you to create a new project from scratch or from the built-in library of demo examples.
You can download the extension at this link. Scroll down this article to find my YouTube video in which I’ll demonstrate how to use this extension to create and compile embedded C projects for your Raspberry Pi Pico (RP2350/RP2040) microcontrollers in a couple of minutes!
RP2350 LED Blinking GPIO Example (C SDK)
This is the first test example project in which we’ll blink the onboard LED attached to the GPIO25 pin.
We’ll just turn the LED ON/OFF for 100ms each.
RP2350 LED Blinking GPIO Example Code
The Application Code For This Example (main.c)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /* * LAB Name: RP2350 GPIO Demo (C/C++ SDK) * Author: Khaled Magdy * For More Info Visit: www.DeepBlueMbedded.com */ #include <stdio.h> #include "pico/stdlib.h" int main() { stdio_init_all(); gpio_init(25); gpio_set_dir(25, GPIO_OUT); while (1) { gpio_put(25, 1); // LED ON sleep_ms(100); // Delay gpio_put(25, 0); // LED OFF sleep_ms(100); // Delay } } |
Compile & Flash the firmware to the board using the UF2 bootloader.
RP2350 LED Blinking Test Result
This article will give more in-depth information about GPIO digital input output pins in Raspberry Pi Pico (RP2040) using C/C++ SDK. With a couple of code examples & simulations for digital pin read and write operations.
RP2350 USB CDC Serial Printf Example (C SDK)
In this test project, we’ll do serial print using USB CDC with the RP2350 microcontroller using the C SDK.
Note: Routing the printf() function to the USB CDC instead of UART is done in the CMakeLists.txt file.
RP2350 USB CDC Serial Print Example Code
The Application Code For This Example (main.c)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | /* * LAB Name: RP2350 USB CDC Serial Print * Author: Khaled Magdy * For More Info Visit: www.DeepBlueMbedded.com */ #include <stdio.h> #include "pico/stdlib.h" int main() { stdio_init_all(); while (1) { printf("Hello, world!\n"); sleep_ms(1000); } } |
Compile & Flash the firmware to the board using the UF2 bootloader.
RP2350 USB CDC Serial Print Test Result
This article will give more in-depth information about USB serial print in Raspberry Pi Pico (RP2040) using C/C++ SDK. With a couple of code examples & simulations for sending serial messages from the RP2040 over USB to PC and displaying the data on a serial terminal and plotting numeric data on a serial plotter GUI.
RP2350 WS2812 Neopixel RGB Example (C SDK)
In this test project, we’ll do a simple RGB color effect with the onboard WS2812 Neopixel RGB LED connected to our RP2350 microcontroller.
For this test demo, I’ll use a built-in example within the pico C SDK examples directory for WS2812 control using a PIO state machine.
RP2350 WS2812 Neopixel RGB Example Code
The Application Code For This Example (main.c)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | /* * LAB Name: RP2350 WS2812 Neopixel RGB LED Example * Author: Khaled Magdy * For More Info Visit: www.DeepBlueMbedded.com */ #include <stdio.h> #include <stdlib.h> #include "pico/stdlib.h" #include "hardware/spi.h" #include "hardware/pio.h" #include "hardware/clocks.h" #include "ws2812.pio.h" #define IS_RGBW false #define NUM_PIXELS 1 #define WS2812_PIN 40 static inline void put_pixel(PIO pio, uint sm, uint32_t pixel_grb) { pio_sm_put_blocking(pio, sm, pixel_grb << 8u); } static inline uint32_t urgb_u32(uint8_t r, uint8_t g, uint8_t b) { return ((uint32_t) (r) << 8) | ((uint32_t) (g) << 16) | (uint32_t) (b); } // Convert HSV hue to RGB (saturated and full brightness) uint32_t hsv_to_rgb(uint8_t hue) { uint8_t r, g, b; uint8_t region = hue / 43; uint8_t remainder = (hue - (region * 43)) * 6; uint8_t p = 0; uint8_t q = (255 * (255 - remainder)) / 255; uint8_t t = (255 * remainder) / 255; switch (region) { case 0: r = 255; g = t; b = p; break; case 1: r = q; g = 255; b = p; break; case 2: r = p; g = 255; b = t; break; case 3: r = p; g = q; b = 255; break; case 4: r = t; g = p; b = 255; break; default: r = 255; g = p; b = q; break; } return urgb_u32(r, g, b); } int main() { PIO pio; uint sm; uint offset; stdio_init_all(); bool success = pio_claim_free_sm_and_add_program_for_gpio_range(&ws2812_program, &pio, &sm, &offset, WS2812_PIN, 1, true); hard_assert(success); ws2812_program_init(pio, sm, offset, WS2812_PIN, 800000, IS_RGBW); uint8_t hue = 0; while (1) { uint32_t color = hsv_to_rgb(hue++); put_pixel(pio, sm, color); sleep_ms(10); } } |
Compile & Flash the firmware to the board using the UF2 bootloader.
RP2350 WS2812 Neopixel RGB Test Result
Getting Started With RP2350/RP2040 (in Arduino)
To get started with Raspberry Pi Pico1/2 (RP2040/RP2350) MCU development in Arduino C++ inside the Arduino IDE, you first need to install the Raspberry Pi Pico core within your locally installed version of Arduino IDE. The tutorial linked below is a very detailed guide that will help you get started with Arduino code development for the RP2040 microcontroller.
This tutorial is the ultimate guide for getting started with Raspberry Pi Pico (RP2040) using Arduino IDE. You’ll also learn how to simulate your Arduino code on the RP2040 using the Wokwi simulation environment.
RP2350 GPIO + USB CDC Serial Print (in Arduino)
In this test project, we’ll blink the onboard LED and also do serial printing using USB CDC with the RP2350 microcontroller using Arduino IDE.
RP2350 Arduino Example Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | /* * LAB Name: RP2350 GPIO + USB CDC Serial Print Example (Arduino) * Author: Khaled Magdy * For More Info Visit: www.DeepBlueMbedded.com */ void setup() { Serial.begin(115200); pinMode(25, OUTPUT); } void loop() { digitalWrite(25, 1); Serial.println("LED ON"); delay(100); digitalWrite(25, 0); Serial.println("LED OFF"); delay(100); } |
RP2350 Arduino Example Test Result
The onboard LED is blinking, and we’re getting serial messages exactly as expected!
RP2350 + ESP32-C3 WiFi WebServer Demo Example
Before concluding this project, let’s take a look at a quick demo example for the ESP32-C3 acting as a WebServer that allows the user to access a webpage to select a desired color, then sends the data over SPI to the RP2350 that displays it to a Neopixel RGB LED.
Wrap Up
By the end of this project, you should have learned how to create your custom Raspberry Pi Pico2 RP2350 dev board or incorporate this microcontroller in your next project if it fits well. As well as how to bring up your custom RP2350-based hardware design using both C/C++ SDK and Arduino IDE.
We’ve not yet covered the ESP32-C3 part of this project, so stay tuned for that!
Great Article! where can i get the full schematic please?