- Home
- Product Categories
- Raspberry Pi Boards
- SparkFun Pro Micro - RP2350
SparkFun Pro Micro - RP2350
The SparkFun RP2350 Pro Micro provides a powerful development platform in SparkFun's compact Pro Micro form factor, built around the RP2350 from the Raspberry Pi Foundation. This board uses the updated Pro Micro form factor. It includes a USB-C connector, Qwiic connector, WS2812B addressable RGB LED, Boot and Reset buttons, resettable PTC fuse, and PTH and castellated solder pads.
The RP2350 is a unique dual-core microcontroller with two ARM® Cortex® M33 processors and two Hazard3 RISC-V processors, all running at up to 150 MHz! Now, this doesn't mean the RP2350 is a quad-core microcontroller. Instead, users can select which two processors to run on boot instead. You can run two processors of the same type or one of each. The RP2350 also features 520kB SRAM in ten banks, a host of peripherals including two UARTs, two SPI and two I2C controllers, and a USB 1.1 controller for host and device support.
The Pro Micro also includes two expanded memory options: 16MB of external Flash and 8MB PSRAM connected to the RP2350's QSPI controller. The RP2350 Pro Micro works with C/C++ using the Pico SDK, MicroPython, and Arduino development environments.
The SparkFun Qwiic Connect System is an ecosystem of I2C sensors, actuators, shields and cables that make prototyping faster and less prone to error. All Qwiic-enabled boards use a common 1mm pitch, 4-pin JST connector. This reduces the amount of required PCB space, and polarized connections mean you can’t hook it up wrong.
RP2350 Features
- Dual ARM CortexM33 and Hazard3 RISC-V Processors
- User-selectable for dual-cores
- 520kB integrated SRAM in 10 banks
- 3.3V-tolerant GPIO
- Peripherals
- 2x UART
- 2x SPI
- 2x I2C
- 24x PWM Channels
- 12x PIO State Machines
SparkFun Pro Micro - RP2350 Features
- RP2350 Microcontroller
- 8MB PSRAM
- 16MB Flash
- Supply Voltage
- USB: 5V
- RAW: 5.3V MAX
- Pro Micro Pinout
- 2x UART
- 1x SPI
- 10x GPIO (4 used for UART1 and UART0)
- 4x Analog
- USB-C Connector
- USB 1.1 Host/Device Support
- Qwiic Connector
- Buttons
- Reset
- Boot
- LEDs
- WS2812 Addressable RGB LED
- Red Power LED
- Dimensions: 1.3in x 0.7in (33.02mm x 17.78mm)
SparkFun Pro Micro - RP2350 Product Help and Resources
Core Skill: Programming
If a board needs code or communicates somehow, you're going to need to know how to program or interface with it. The programming skill is all about communication and code.
Skill Level: Rookie - You will need a better fundamental understand of what code is, and how it works. You will be using beginner-level software and development tools like Arduino. You will be dealing directly with code, but numerous examples and libraries are available. Sensors or shields will communicate with serial or TTL.
See all skill levels
Core Skill: Electrical Prototyping
If it requires power, you need to know how much, what all the pins do, and how to hook it up. You may need to reference datasheets, schematics, and know the ins and outs of electronics.
Skill Level: Rookie - You may be required to know a bit more about the component, such as orientation, or how to hook it up, in addition to power requirements. You will need to understand polarized components.
See all skill levels
Comments
Looking for answers to technical questions?
We welcome your comments and suggestions below. However, if you are looking for solutions to technical questions please see our Technical Assistance page.
Customer Reviews
4 out of 5
Based on 5 ratings:
Nice board but could be better
It is a very nice small board for the RP2350. The biggest omission is the lack of a debug connector exposing the SWD interface. I had to glue and fly wire a connector to test pads on the back of the board to gain access to the debug port. It could be worse if there were no test pads but still, it is a pretty big omission to not make the debug port easy to access. Otherwise it is a nice board.
Poor Documentation
I purchased it because there were micropython examples on the website. Now they're gone. Documentation of SF port of micropython is apparently non-existent.
Also baud rate is 57600 where all other Pi Pico boards run at 115200. This wasted a lot of my time figuring this out. No documentation.
Otherwise, seems like a solid product. A lot smaller than I expected. Limited number of pins. Would prefer it in the normal Pi Pico form factor.
Great early-access RP2350 board
Great price and features (8MB PSRAM). Cons are nonstandard LED and no SWD debugging connector. However you can do SWD debugging by soldering wires to pads on the bottom of the board.
Amazing board.
I used this board as it was the first board I could buy to have PSRAM on board. Many thanks for PSRAM example code, which the Pi foundation didn't have examples for at the time.
I like the USB-C and the form factor, but it would be nice to have SWD broken out.
Recommendation for V2 put the test pads for GND SWIO and SWCLK near the edge for an SMD header or put the pads for the 3-pin JST-SH connector.
A full featured board with a powerful microcontroller
The Sparkfun Pro Micro - RP2350 has a lot of nice features that fits many applications. My first project was a fairly simple one using the onboard qwiic connector to a couple of qwiic enabled human presence detectors, and reed switch on a door. All to light up a LED strip different colors depending if someone was on the other side of the door. Since the human presence detectors had the same address I added a second qwiic connector. While I typically program in C, I used micropython on this project and was very happy with the speed and performance. Looking forward to exploring the dual micros and security features on the next project!
Is there a graphic to show the pins and their functionality? This is common with other RPi Pico boards. Thanks
I'm looking at the specs on the PSRAM chip and according to the manufacturer the maximum clock rate with a VDD of 3.3 Volts is only 109MHZ. I also noted that in the sfe_pico_alloc.c code that the timing for the maximum CS assertion is based on a 133MHZ system clock frequency (7.52 nS). If this is running at the new 150 MHZ system clock speed, then I'm wondering how reliable the PSRAM is going to be running at nearly 40% over its rated clock speed. It also looks like the flash is limited to 133MHZ, which does make me wonder about the new 150 MHZ system clock speed.
I could be missing something obvious here, and the only reason why I was looking into this was to try to get some idea of possible performance. I realize that it is very difficult to get definitive performance specs since the QSPI bus will be shared between the PSRAM and the flash and the amount of time that the PSRAM will have for transactions will depend upon how often instructions are found in the XIP cache.
Anyway, can you clear up the confusion here? And lastly, is the PSRAM configuration set up to read/write two bytes per command, or can it do more? The data sheet for the PSRAM is difficult to follow, and I've been reading data sheets for a long time!
Any insight would be greatly appreciated. I'd love to be able to use the PSRAM for some high-speed DMA-based buffering. But I need to determine the worst-case scenarios, and that means understanding the numbers.
Hi there,
We created that PSRAM implementation since official PSRAM support is still in development in the Pico SDK. So our implementation should be considered an experimental interim solution until official support is added, at which point I'm guessing the timing stuff will all be handled.
FWIW I just probed the clock pin and measured it to actually be 75MHz. I haven't personally looked through our PSRAM code in detail, so there's probably an extra divide by 2 somewhere. Again, consider this implementation to be experimental.
Our PSRAM implementation has worked fine for us so far. To my knowledge, we've not encountered any stability issues, though we admittedly haven't put it through super extensive testing (eg. running it for hours in a thermal chamber). If you end up doing more thorough testing, we'd love to hear your results!
Hope this helps!
Can we debug this board by connecting to the rp2350 swdio and swdck pins? Jtag? Openocd?
75MHZ Makes complete sense. That would have been my approach had I attempted to do an implementation from scratch. But it sure helps to have someone else's example to use as a starting point. I can tell that once the control parameters are set, then the XIP hardware just manages things from there. That is so much more convenient than trying to attempt something in PIO.
For my situation it just comes down to whether or not you can get chunks of data in and out when code is executing out of cache, or when critical code is moved into RAM so that flash access is minimal. Since the addressing portion of the PSRAM only needs to be done once, at the beginning of a block read or write, I can get the throughput I need with average transfers on the order of four bytes or more at a time. More is always better. I'm hoping that the XIP hardware will move as many bytes at a time as it can, provided a flash access is not needed, and as long as the total transfer time stays below the maximum programmed PSRAM CS active time. That will take testing to quantify.
I'm thankful to have your code as a starting point. I've looked around a bit and not found any other examples of setting up and using the PSRAM function of the RP2350 so far!
Hi -
We just posted a more up to date set of setup code and other utilities for our RP2350 boards.
The code and examples are located here: https://github.com/sparkfun/sparkfun-pico
The PSRAM detection and setup methods now use the system clock frequency to calculate the timing settings - we no longer use the hard coded values we original obtained. And overall the code is cleaned up and a majority of the Magic numbers made into #defines.
This also includes the use of an allocator to help manage the PSRAM (and all ram if you like).
And FWIW - we'll get this added/integrated to a micro python port shortly.
Yes, the SWD pins are broken out to test points on the bottom, labeled "C" and "D". You'll need to solder wires to these, then you can connect a Pico Probe (or similar device) to debug the RP2350: https://www.sparkfun.com/products/21802 If you're not familiar with using the Pico Probe, please read through Raspberry Pi's docs: https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html
Hope this helps!
what is the "b" test point for? ground? thanks for your help
You can see that in the schematic and Eagle files linked above, but that connects to the Boot button, and is mainly just there to make our production testing more automated.
i hooked a pico debug probe (with the latest firmware) up to the unit and tried:
openocd -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000"
i got the following error:
Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : Using CMSIS-DAPv2 interface with VID:PID=0x2e8a:0x000c, serial=E6633861A39C662C
Info : CMSIS-DAP: SWD supported
Info : CMSIS-DAP: Atomic commands supported
Info : CMSIS-DAP: Test domain timer supported
Info : CMSIS-DAP: FW Version = 2.0.0
Info : CMSIS-DAP: Interface Initialised (SWD)
Info : SWCLK/TCK = 0 SWDIO/TMS = 0 TDI = 0 TDO = 0 nTRST = 0 nRESET = 0
Info : CMSIS-DAP: Interface ready
Info : clock speed 5000 kHz
Error: Failed to connect multidrop rp2040.dap0
any clues as how to proceed?
thanks for help
Looks like you're configured to debug the RP2040 instead of the RP2350.
If you run into any other issues, please seek help on our community forum, as this is not the correct place for tech support: https://community.sparkfun.com/
Thanks, and I hope you get things working!
The Github link is still private https://github.com/sparkfun/SparkFun_Pro_Micro_RP2350. Also, will there be psram examples?
Apologies for it still being private! I just fixed it, thanks for pointing that out!
If you want to use PSRAM with the Pico SDK, we have this demo in the hookup guide: https://docs.sparkfun.com/SparkFun_Pro_Micro_RP2350/camera_demo/ Note that this currently uses a custom implementation for the PSRAM; native SDK support is still in progress, so this is an interim solution for users to get going early.
We've also compiled MicroPython for the Pro Micro RP2350 that handles the PSRAM setup for you, so it's completely transparent to the end user: https://docs.sparkfun.com/SparkFun_Pro_Micro_RP2350/micropython_setup/ Again, this is an interim solution until native PSRAM support is added in the official MicroPython release.
Hope this helps!
Thanks a bunch!