Review of the Cytron MAKER PI RP2040

Table of contents

RoadTest: Sign Up to Roadtest the Cytron MAKER PI RP2040

Author: work14

Creation date:

Evaluation Type: Development Boards & Tools

Did you receive all parts the manufacturer stated would be included in the package?: True

What other parts do you consider comparable to this product?: Romeo V2 from DF Robot

What were the biggest problems encountered?: No issues found. This board is very compact, robust and practical.

Detailed Review:

Review of the Cytron MAKER PI RP2040

Cytron Maker Pi RP2040 features the first microcontroller designed by Raspberry Pi - RP2040, embedded on a robot controller board. The board comes with dual channel DC motor driver, 4 servo motor ports and 7 Grove I/O connectors. The Cytron MAKER PI RP2040 is an out-ofthe-box platform for easy robot applications. Some links to key information regarding this RoadTest follow.

What is in the box?

The contents of the box are shown below. The screwdriver was a welcomed addition to the kit since not everyone will have one readily available. The Grove cable connectors are also a very practical and fundamental addition to the kit. Without the cables new users may have a hard time finding what would be needed to connect to sensors and actuators. Well done by Cytron


Summary of Experience with the Cytron MAKER PI RP2040

The Cytron MAKER PI RP2040 is an affordable entry level compact development board ready to use without requiring complex hardware and/or software integration knowledge. The board is user friendly and easy to use for all levels of robotics  experience. The MAKER PI RP2040 is highly recommended for any project that requires to integrate sensors and drive a motor. The board has great support from industry and documentation is easy and readily available. 

The results and take away of the Cytron MAKER PI RP2040 for this RoadTest are itemized below:

  1. Out of the box experience of the is positive. The hardware and available software worked as expected.
  2. The MAKER PI RP2040 integration with various existing software works well.
  3. Building robotics applications with currently available online support from Cytron and AdaFruit is achievable at all levels of expertise.
  4. The MAKER PI RP2040 software integration is very good.
  5. This board itself is a highly capable hardware on its own.
  6. Easy to see that engineers that designed the board have robotics experience.
  7. The available CircuitPython and ready to use libraries make for a powerful combination of hardware/software.
  8. The demo software included in the easy to install firmware provides a solution that works on-target out of the box.
  9. Sensor integration and software development was successfully done and demonstrated.
  10. Documentation for the board was tested and reviewed. The available documentation is ample, readily available, and comprehensive.
  11. We found that most of the information needed was available in one form or another within the available online documentation. 
  12. We recommend the Maker Pi RP2040  and available, on-target ready to use software applications as a powerful starting platform for robotics solutions. 


  • CircuitPython: easy to use with lots of community and industry support and documentation.
  • No hardware design knowledge required to utilize the MAKER PI RP2040 board.
  • Documentation is easily and readily available.
  • All on-target developed software applications work well.
  • Traceback error debugging is excellent and never falters. Well done. 
  • Easy to use CircuitPython development tool.
  • Board is compact, robust with a well designed layout.
  • Board provides exposure to plenty of General Purpose Input/Output (GPIO) signals.
  • The product is simple to use which makes it readily accessible to students and entry level robotic engineers. 
  • The Cytron MAKER PI RP2040 board comes with Grove 4 Pin Buckled to Female Cables that make for easy integration with sensors and actuators.
  • Rich variety of available example applications.
  • Easy to update the  CircuitPython firmware
  • The Cytron MAKER PI RP2040 does simplify development and implementation of robotics application significantly.
  • Out-of-the-box experience is superb. Every thing works as expected.


  • CircuitPython: not suitable for real-time robotics applications. This is a well known tradeoff between easy of use v.s. real-time requirements. 
  • CircuitPython comes with compromises and restrictions for real-time applications. 
  • CircuitPython is easy to use and firmware is easy to update, but it is no C/C++. (Which is precisely the point)
  • CircuitPython lacks some fundamental real-time robotics needs such as threads and interrupt service. 
  • Trying to setup and use C/C++ as a development tool for the MAKER PI RP2040 is not trivial. Not attempted in this review.
  • On-target development sometimes generates errors that are difficult to decipher (but this is common).

Comments and Observations:

  • The Cytron MAKER PI RP2040 is easy to use. 
  • This board is affordable.
  • The board constitutes an excellent hardware platform that seamlessly integrates with an easy-to-use development environment in CircuitPython.
  • The MAKER PI RP2040 hardware and CircuitPython solution works well, and a novice will master this hardware/software integration in a short time. 
  • The MAKER PI RP2040 hardware and CircuitPython solution should be easy to integrate in a classroom environment.
  • Novice engineers will find the hardware/software integration easy to master
  • The available documentation does help with development and integration of sensors and actuators.
  • All efforts to develop new software application was focused with the use of CircuitPython only. No effort was taken to develop in C/C++. 
  • Development in C/C++ requires some non-trivial effort.
  • This kit does provides a simplified hardware and software development environment that makes for an excellent platform for robotics application.
  • Mayor drawback was the inability of CircuitPython to provide thread and interrupt support that are necessary for hard-real-time robotics applications. 
  • Power consumption was not part of this review, but it may be important to understand if a robot is to function autonomously in remote environments. 
  • Trivial note: at the start of this review the Cytron MAKER PI RP2040 was priced at $9.99 dollars. 


Appreciation to Cytron and element14 for providing the opportunity to review the Cytron MAKER PI RP2040. The RoadTest review program experience allows individuals to learn about new hardware and software solutions, and to provide service to the community by submitting a review of various products. 

General Overview element14 RoadTest

The RoadTest program is the element14 community’s flagship product review program. Testers obtain a product to experiment and to provide element14 a written review of their experiences with the product. The following are important points pertaining to this program.

  • RoadTesters have 60 days from the receipt of the product to complete testing and review writing on element14.

  • The review must be filed on the special element14 Roadtest form.

  • Roadtesters who do not complete their reviews will not be eligible to participate in the program in the future. 

  • Roadtesters are shipped the kit free of charge (including customs and/or other fees).

Specific RoadTest Goals for Cytron MAKER PI RP2040 

  1. Test the out-of-box experience of the product. 
  2. Experiment with the capabilities of the product.
  3. optional -- produce an unboxing video.

RoadTest Cytron MAKER PI RP2040

This particular RoadTest  relates to the Cytron MAKER PI RP2040  (see figures below). This board intends to make robotics application development easily done with little out-of-the-box effort. The initial goal of the out-of-box experience is to get applications up and running in under one (1) hour, with no robotics experience needed. This is easily achieved. 

This MAKER PI RP2040 is a ready-to-use hardware board with easy to master CircuitPython software with on-target development. CircuitPython firmware developed by Adafruit does provide tight integration with the board. 





Documentation Summary

Cytron and Adafruit along with some community users provide a plethora of readily available documentation and example programs for the MAKER PI RP2040 and CircuitPython. Some of those links are summarized below for easy find and access. Documentation is satisfyingly easy to access and easy to read.

Main Board Function and Use:

Simplifying Robotics with Raspberry Pi RP2040Cytron Maker Pi RP2040 features the first microcontroller designed by Raspberry Pi - RP2040, embedded on a robot controller board. This board comes with dual channel DC motor driver, 4 servo motor ports and 7 Grove I/O connectors, ready for any robot / motion control project. The board is compact, robust and easy to use. The board layout is well thought out and practical. The exposure of GPIO in the form factor of groove is very functional and practical. The hardware works well, and is well integrated with CircuitPython development tools. 

Cytron MAKER PI RP2040 Hardware Features:

First Contact and First Impressions with the MAKER PI RP2040:

The figure below shows all the GPIO and other features for the board. This layout is well thought out. The engineers responsible for this layout did think of just about every need that arises when developing robotics applications. Of particular practicality are the motor test buttons. The availability of GPIO via grove ports is highly practical. It is what is needed for a lot of sensor and actuator integration for any robotic application. The Gove port also make it very practical in a classroom environment when students need to interact with robust hardware. The Grove ports provide this robustness out of the box. 

The video below shows the out-of-the-box software behavior for the MAKER PI RP2040 integrated with a simple robot. 

Hardware Description:

  • Powered by Rapberry Pi RP2040
    • Dual-core Arm Cortex-M0+ processor
    • 264KB internal RAM
    • 2MB of Flash memory
    • the exact same specifications with Raspberry Pi Pico

Raspberry Pi documentation for the Pico board is widely available. 

  • Robot controller board
    • 4x Servo motors
    • 2x DC motors with quick test buttons

The board layout is well done. Servo connectors are a time saver, and the presence of DC motor quick test buttons sets this Maker Pi RP2040 board sit on top of the heap. These test buttons are very practical when troubleshooting initial wiring connections to the hardware, and then when troubleshooting the software itself. This feature all by itself makes this specific board more attractable than most other. All things being equal, this feature alone would win easily.

  • Versatile power circuit
    • Automatic power selection: USB 5V, LiPo (1-cell) or Vin (3.6-6V)
    • Built-in 1-cell LiPo/Li-Ion charger (over-charged & over-discharged protection)
    • Power on/off switch

Having a number for ways to power the board makes the board very user friendly. This saves a lot of development time.

  • 13x Status indicator LEDs for GPIO pins
  • 1x Piezo buzzer with mute switch
  • 2x Push button
  • 2x RGB LED (Neopixel)

Buttons and LEDs are always welcomed. These features make the board suitable for a classroom environment where students can easily experiment with their software and hardware integration.

  • 7x Grove ports (flexible I/O options: digital, analog, I2C, SPI, UART...)

The Grove ports are an excellent addition to the board layout. These ports make this board very robust. The ports are very practical in the way that wires the signals. For example, the two serial port GPIO signals are conveniently routed to the Grove ports. 

CircuitPython is an easy to use development environment suitable for all levels of robotics expertise.  CircuitPython is tightly coupled with the  Maker Pi RP2040.  This combination makes the  Maker Pi RP2040 and CircuitPython a good choice for students and new robotic enthusiasts. 

  • Mouting holes
    • 4x 4.8mm mounting hole (LEGO® pin compatible)
    • 6x M3 screw hole

It would be fun to integrate the Maker Pi RP2040 to a lego creation. 

Software Description:

Cytron Maker Pi RP2040 is basically the Raspberry Pi Pico + Maker series' goodness + Robot controller & other useful features. Therefore this board is compatible with the existing Pico ecosystem. Software, firmware, libraries and resources that are developed for Pico should work seamlessly with Cytron Maker Pi RP2040 too.

CircuitPython is preloaded on the Maker Pi RP2040 and it runs a simple demo program right out-of-the-box. Connect it to your computer via USB micro cable and turn it on, you will be greeted by a melody tune and LEDs running light. Press GP20 and GP21 push buttons to toggle the LEDs on/off, while controlling any DC and servo motors connected to it to move and stop. The demo code allows to test the board out-of-the-box. This is a very practical software/hardware integration feature. All of the before here mentioned software/hardware features do work out-of-the-box. Excellent work.

While connected to your computer, a new CIRCUITPY drive appears. This allows the user to explore and edit the demo code ( & lib folder) with any code editor, save any changes to the drive and see changes in action in the next auto-reboot. This is a nice feature that new roboticist will like since it does not require to compile and upload code. It is the reason why Cytron embraces CircuitPython - it's very easy to get started.

The following links provide a reference to some of the documentation used in to develop software for this review.

Firmware Update

The latest firmware update can be found in the following link:

This site includes a description of the steps needed to update the firmware. This is done easily.

1. Start the UF2 Bootloader

Most CircuitPython boards ship with a bootloader called UF2 (USB Flashing Format) that makes installing and updating CircuitPython a quick and easy process. The CircuitPython firmware file is in the form of a .uf2 file. For RP2040 boards such as the MAKER PI RP2040, the bootloader on an RP2040 board starts by pressing down the boot select button, and while continuing to hold it, pressing and releasing the reset button. Continue to hold the boot select button until the bootloader drive appears. See figure below.

2. Bootloader Mode

Once successful, the RGB status LED(s) on the board will flash red and then stay green. A new drive will show up on your computer.T he drive will be called RPI-RP2 on all RP2040 boards (see below)


3. Install CircuitPython

Drag the file to the boot drive on your computer. An example of a file name is shown below:


When the user drags the CircuitPython UF2 file to the boot drive, it seems to disappear, and the drive disconnects. This is normal. Once the firmware has been successfully installed, the RPI-RP2 boot drive will disappear and a new drive will show up on your computer called CIRCUITPY.

Limits of CircuitPython

The following are two of the most important omissions in CircuitPython pertaining to the development of real-time robotics applications. 

1. threads

2. interrupt handling

1. Threads

Threads often allow for concurrent execution of blocking and non-blocking of tasks. There is no threading in CircuitPython. Given the wide variety of hardware CircuitPython supports, there is not user controlled threading of specific code. 

2. Interrupt Handling

It is possible to use interrupts directly in some situations. CircuitPython countio module uses actual interrupts to count rising/falling-edge pin transitions. This could be used to see if a button has been pressed, but its use is very limited. The following link has an example of how to use this limited interrupt a

Cooperative Multitasking: Handling Interrupts

A frequent scenario for the use of interrupts is to guarantee that a task is executed precisely at a known interval. This is important for the implementation of data acquisition schemes, digital filters and control laws that require prices timing. It appears that CircuitPython does not currently implement interrupt handling that is able to provide this service. 

Multi-tasking with CircuitPython

The following link provides an overview to multi-tasking for CircuitPytnon:

Multi-tasking with CircuitPython

CircuitPython Schedule

Python Asyncio: The Complete Guide

The last link above provides a Python approach to multitasking. CircuitPython does not implement all elements of the asyncio library. 

Successful Autonomous Robotics Application

The Maker Pi RP2040 was installed in a small robot as shown below:

The  Maker Pi RP2040 is well designed and integration with any robot is very straight forward. The test buttons for the motor interface are particularly practical since they allow for direct electrical troubleshoot without the need to develo or run any code. All thins being equal, this simple interface makes this board stand on its own in terms of ease of integration. As a proof of concept and for the purpose of this review, the author engineer integrated two sensors to the board:

1. GPS module TEL 0132

2. Ultrasonic Distance Sensor UMR 37

The Maker Pi RP2040 Datasheet specifies the grove port assignment and the GPIO functionality for each pin as shown in the table below:

GPS module TEL 0132


The  TEL 0132  GPS unit integration to the Maker Pi RP2040 is done via serial interface UART 0. The reason for this integration is to integrate GPS information into a navigation solution for the robot. The line of code used to start the UART i/o follows:

uart0 = busio.UART( tx=board.GP0, rx=board.GP1, baudrate=9600, timeout=10)  

The RX and TX port assignment are taken from the table above. The following code snippet illustrates the CircuitPython concurrent task code used to read data from the GPS:

async def readGPS( dDat ):

    while True:

        # --- read GPS data
        # -----------------------------------------
        data =   # read up to 32 bytes
        # ---
        await asyncio.sleep(0.003)

        # convert bytearray to string
        dDat.gpsData_string = "".join([chr(b) for b in data])

        # --- never returns
        await asyncio.sleep(0.1)

A short example of the raw GPS data read follows




$GPTXT,01,01,01,ANTENNA OK*35


Some extra code processes the GPS information and passes the GPS data onto a navigation routine that performs sensor fusion via Kalman filters. In this review GPS data was not used in the final autonomous robot application below. The inherent lack of multithreading and interrupt support in CircuitPython makes real-time sensor data fusion somewhat meaningless. After some work to overcome some obstacles, the author decided not to pursue this effort further since the results wold not add much value to the hardware review.

Ultrasonic Distance Sensor UMR 37


This particular ultrasound has a number of ways to interface with the microcontroller. The author engineer chose serial port interface to attempt to assess the Maker Pi RP2040 performance of two simultaneous serial port interface to interact with sensors in real-time. The code snippet to setup the second serial port is below:

uart1 = busio.UART(tx=board.GP4, rx=board.GP5, baudrate=9600, timeout=10) 

A relevant code snippet that reads the ultrasound data is shown below:

# --- ask for distance data
# -----------------------------------------
# ---
await asyncio.sleep(0.001)

# --- fetch distance data
# -----------------------------------------
nbytes = uart1.readinto(urmDataDst) # read ultrasound data

Data is processed and passed onto a control task that computes throttle commands based on distance to obstacles. After some work to overcome some obstacles, the author decided not to pursue in-depth effort to further process ultrasound sensor information since this would not add much value to the hardware review.

Navigation and Control Limitations with CircuitPython

CircuitPython lacks two important features discussed previously in the review:

1. threads

2. interrupt handling

Lack of threads makes concurrent programing difficult. CircuitPython does have a mechanism in place for the implementation of concurrent task execution, but this is not predictive nor deterministic. Lack of interrupt service takes any deterministic behavior out of the application. Signal processing, navigation, guidance and control applications usually require some deterministic operating behavior which is why real-time operating systems (RTOS) do exist. Based on these limitations, the best that could be done was to implement concurrent task execution via the asyncio library. This solution is not predictive nor deterministic.

As a consequence, the robot control implementation for this application was based on simple emerging behaviors. That is, a series of independent behaviors execute concurrently and asynchronously in some fashion such as hierarchical or presumptive or preemptive or any combination thereof. The advantage of this emerging behavior control scheme is that it works with uncertain and incomplete data and requires no predictive or deterministic execution. A disadvantage is that behavior control is not predictive nor deterministic. That is, you get what happens when it happens. In addition, in behavior based control, if data is not present or of poor quality, then you get no behavior. These type of emerging behaviors are regularly seeing in nature and is the essence of pray-predator interactions: if pray does not sense a predator, then it becomes lunch. 

For the purpose of this review two simple emergent behaviors where implemented:

1. deep forward motion

2. obstacle avoidance motion

Deep forward motion behavior is simply to run as fast as possible when there is no forward obstacle. In the presence of a forward obstacle, then implement some degradation of forward motion based on available sensor data. There is no knowledge of or attempt to predictive behavior. Obstacle avoidance motion behavior is simple to implement with some kind of differential motion in the presence of side obstacles. This behavior implements two independent commands for left and right sensor inputs that compete with each other. The objective is to be able to autonomously navigate any environment by some random walk in the presence of minimal information and limited processing of that information. 

The two behaviors are superimposed and executed simultaneously. The overall result is a motion that is unpredictable but smart in some sense. This is kind of fun to see in the two videos below.

Documentation and Hardware/Software Integration Review

The Maker Pi RP2040 is a compact and robust hardware suitable for all levels of robotics expertise. 

Documentation Review

Some of the documentation used in this review are listed below. 

The review engineer had no previous experience with CircuitPython. It took some time to the engineer to realize that some of the limitations of the development software. The decision to not setup and use C/C++ was to help review the Cytron Technologies Maker Pi RP2040 as most users will experience the kit. There was some learning curve, but the available documentation is superb. The number of examples and libraries are plentiful with lots of how-to tutorials. 

Worthy of note is that Adafruit provides a plethora of hardware that are easy to integrate with CircuitPython. This makes both  CircuitPython  and Cytron Technologies Maker Pi RP2040 very attractive choice for a classroom environment, but also to any engineer that wants to integrate readily available hardware to this board. 

CircuitPython Libraries

CircuitPython Hardware

Hardware/Software Integration Review

 The Maker Pi RP2040 offers a compelling platform ready for robotics applications right out-of-the-box. The following are some of the reasons why this hardware offering is good.

  • Powered by Rapberry Pi RP2040
    • Dual-core Arm Cortex-M0+ processor
    • 264KB internal RAM
    • 2MB of Flash memory
    • the exact same specifications with Raspberry Pi Pico

The RP2040 CPU is powerful in its own right. It offers two serial ports, USB support, 30 GPIO, and a number of other features. The Maker Pi RP2040 exposes all of those features to the user in a robust platform. The word robust means that this platform will survive students and new as well as old robotic engineers. 

  • Robot controller board
    • 4x Servo motors
    • 2x DC motors with quick test buttons

The DC motors quick test buttons are a plus. These allow to troubleshoot motor electrical hookup very easily. 

  • Versatile power circuit
    • Automatic power selection: USB 5V, LiPo (1-cell) or Vin (3.6-6V)
    • Built-in 1-cell LiPo/Li-Ion charger (over-charged & over-discharged protection)
    • Power on/off switch

Having a number of ways to power the board is both convenient and practical. Again, this add to the robustness of the board. It makes using the board very easy.

  • 13x Status indicator LEDs for GPIO pins
  • 1x Piezo buzzer with mute switch

The LEDs are always a great addition that aid with real-time software troubleshoot. The Piezo buzzer with a mute switch is a great addition to the board. Very useful in a number of ways. 

  • 2x Push button

Push button integration are practical and functional. The board has them which means the user does not have to do the integration. Adds to design robustness. 

  • 2x RGB LED (Neopixel)

Fun to program. Useful in some ways. 

  • 7x Grove ports (flexible I/O options: digital, analog, I2C, SPI, UART...)

The Grove ports and the included cables are a great addition. A multitude of sensors and actuators can integrate via these very easily. This engineering design is well thought out. 

CircuitPython is an easy development environment for many engineers. The integration with CircuitPython makes code development very easy to do. 

  • Mouting holes
    • 4x 4.8mm mounting hole (LEGO® pin compatible)
    • 6x M3 screw hole

It would be fun to integrate this board in some lego application. 


The following are results and take away of the Cytron Technologies Maker Pi RP2040 RoadTest:

  1. Out of the box experience of the  Maker Pi RP2040  is positive. All the hardware and available software worked as expected.
  2. The Maker Pi RP2040 hardware integration with the readily available CircuitPython development software is effective and error free.
  3. Building a robotics application with current on-board development tools is easily done and requires little effort
  4. The serial ports, servo ports, Grove ports, buttons, power input and more were tested and all worked flawlessly well. 
  5. The Maker Pi RP2040 board is compact and robust and highly capable hardware on its own that is easy to integrate in/with any number of embedded projects.
  6. The Maker Pi RP2040 and  CircuitPython development environment provides a powerful solution that works out of the box.
  7. The available documentation is ample, complete, readily available, and comprehensive.
  8. The documentation itself was tested, and we found that all information needed was available in one form or another.
  9. On-Board Software Development tools and related workflow are well polished.
  10. All tested sensors and actuators used were satisfactorily integrated to the Maker Pi RP2040 in this review.
  11. This kit does provides simplified hardware and software development workflow.
  12. On-Board Application development in C/C++ is possible, but not tested in this review.  
  13. CircuitPython does have some compromises in the form of lack of support for threads and interrupt service.
  14. Cytron Technologies Maker Pi RP2040  and  CircuitPython development environment are recommended for all levels of robotics applications. 


All the RoadTest objectives were met satisfactorily and are summarized in the Results section above this one. 

The Cytron Technologies Maker Pi RP2040 board is a capable compact and robust hardware that can be the starting point for any number of embedded robotic projects, and it is highly recommended. Existing documentation is ample and comprehensive. We recommend the Maker Pi RP2040  and the available CircuitPython development software as an efficient starting platform for Robotics applications.