Raspberry Pi Pico compared to Arduino Maker 1010

 

Starting with a feature and price breakdown.

 

MKR WiFi 1010

Pi Pico W

Processor

Cortex-M0+ 32bit ARM running at 48MHz

2 ARM Cortex-M0+ 32 bit cores clocked at 133MHz

Memory

256Kb Flash plus 32Kb RAM

256Kbyte RAM

WiFi

2.4GHz 802.11 b/g/n

2.4GHz 802.11 b/g/n

Bluetooth

BLE

5.2

GPIO Pins (excl. power etc.)

22

1xSPI, 1xI2C, 1xUART, 7x12-bit ADC, 1x10-bit DAC, 13xPMW

10x External interrupts

26

2×SPI, 2×I2C, 2×UART, 3×12-bit ADC, 16× PWM

All GPIO pins support external interrupts

Real time clock

yes

yes

Other

Encryption Chip

Temperature sensor

Floating Point library on chip

8×Programmable IO state machines

SoftAP

Price

£29.90

£7.00

Looks like an easy price/performance win for the Pico even if you needed to buy an external DAC for a specific project.

Board hook-up usability.

The Arduino comes with male and female headers while the Pico WH, I chose, has just male pins. You could, of course, buy the bare Pico W and solder your own chosen header type to the board. Both can be powered and programmed though a micro-USB port.

Developer Set-up.

A clear win here for the Arduino. Arduino development using the desktop IDE is a simple installation on Windows, Linux and MacOS that could be titled “It Just Works”. Setting up the toolchain for the Pico requires a rather more effort and expertise.

The Raspberry Pi family is rooted in the Linux OS and even though the Pico runs C++ “on the metal” it is way more straightforward to develop using a Linux PC. A reasonable choice might be a Raspberry Pi 4 – I chose to use my Raspberry Pi 400 and there is a pre-prepared installation kit available for those platforms. I did build a setup on Windows (10) and it was pretty steady but the Raspberry Pi installation instructions suggested that you need a Raspberry Pi (4B maybe) to sit between a Windows PC and the Pico. This turned out to be strange advice. Once I had built and loaded a program for my Pico using Linux I just followed the same procedure to load a compiled program from Windows (see below) and all worked as expected.

Later it also turned out that the Arduino IDE supported Pico C/C++ development on all relevant platforms - including Windows.

The Pico can be programmed using Python and the MicroPython firmware running on the board. This could be a key feature for some.

Python aside, someone coming new to microprocessors should probably choose the Arduino offerings unless they have pre-existing skills building toolchains on their favoured PC platform. More experienced developers are going to relish the opportunities afforded by the Pico family.

Hello World.

It was not my original intention to compare the development process between the two boards but I did want to note the code, compile and deploy steps for the classic “Hello World”. Later I wanted to check that the Pico could handle all of the projects developed for Arduino in my book “Practical Arduino C” and more.


Yes - I installed the Arduino IDE on the Raspberry Pi 400 alongside VS Code and the Pico toolchain (just spreading that microprocessor love around).

Here is an Arduino version:

void setup() {
    Serial.begin(115200);
    while(!Serial){
        ;
    }

    Serial.println("Hello World");
}

void loop() {

}

and a variant for the Pico from the supplied Pico examples:

#include <stdio.h>
#include "pico/stdlib.h"

int main() {
    stdio_init_all();
    while (true) {
        printf("Hello, world!\n")
        sleep_ms(1000);
}
    return 0;
}

as that version has a pre-prepared CMake FILE:

if (TARGET tinyusb_device)
    add_executable(hello_usb
            hello_usb.c
        )

# pull in common dependencies
    target_link_libraries(hello_usb pico_stdlib)

# enable usb output, disable uart output
    pico_enable_stdio_usb(hello_usb 1)  
    pico_enable_stdio_uart(hello_usb 0)

# create map/bin/hex/uf2 file etc.
    pico_add_extra_outputs(hello_usb)

# add url via pico_set_program_url
    example_auto_set_url(hello_usb)

elseif(PICO_ON_DEVICE)

    message(WARNING "not building hello_usb because TinyUSB submodule is not initialized in the SDK")

endif()

Of course, the automated Arduino toolchain deals with the inclusion of key libraries and "masks" the structure of a standard C program - all arguably user friendly features.

Installing and running the Arduino version simply requires the selection of board and port, opening the Serial Monitor and clicking the upload button. After the automated compile, build and upload, the legend "Hello World" appeared in the Serial Monitor window.

I used Visual Studio Code (on the Pi 400) to build the Pico version. I then connected the Pico to the USB port on the Pi 400 while holding down the BOOTSEL button; which then mounted the Pico as a USB mass storage device. I then used the file manager to copy the hello_usb.uf2 file from the build directory to the Pico. The program was then automatically loaded and run by the Pico which disconnected as a mass storage device. Normally, you would then use a program such as minicom (sudo apt install minicom; if not already installed) to connect to the USB port and display the output. As it happened, I already had the Arduino IDE Serial Monitor (version 1 IDE) window open and that worked just fine.

A Different approach

So that demonstrated the "official" Raspberry Pi approach to Pico C/C++ development.

How about using the Arduino IDE to develop for the Pico board? This article on the Drone Bot Workshop site shows you how to set up the IDE to program a Pico. This allowed me to quickly get the Arduino version of the infamous "blink" sample program up and running on my Pico on Windows without any trouble (which begs a few questions).

I then tried out the suggested code to connect the Pico W to my WiFi network. There was a bit of fiddling with the assigned port to get the program uploaded (warts and all here) but after an upload and a short wait the IDE Serial Monitor was soon displaying the IP address assigned to the Pico by my router. Note that the Serial Monitor says that it is not connected to a port even though it is happily displaying incoming text from the Pico. I switched it to the available COM port after uploading the program to capture the output but as this is not notionally connected to a board you get that message.


The Pico responded happily to a "ping" just as advertised.

There is no significant difference between the code used here on the Pico (via the Arduino IDE) and the code I used when exploring the Arduino MKR 1010.

Anyone with Arduino programming experience is going to find this approach much more comfortable than ploughing through the Pico C/C++ SDK and the Pico supplied example programs. I had not expected that when I set out.

Pushing the envelope.

I decided to try out some of my existing Arduino "demo" programs on the Pico. I started with a Sudoku solving program. The first version runs a test tackling 96 puzzles of increasing difficulty. When I compiled my Arduino code for the Pico I got two error messages. They both featured the words "error control reaches end of non-void function" and indicated two functions. One was declared as returning a bool and the other a uint8_t type. In reality, both functions always returned a value of the required type during execution but the compiler had no way of knowing that for sure and so I needed to add an appropriate return statement at the end of each. With those two small changes in place, the program ran happily (and fast) on the Pico.

Next up was a version of the sudoku program that renders a web page where a sudoku puzzle can be entered and then offers a service accessed using Ajax to solve any arbitrary puzzle. After all I was supposed to be testing a WiFi enabled board. This program project is built from 5 separate code files.

This is where I started to run into problems. The HTML and JavaScript being rendered to the browser ran to 120 odd lines of text of roughly 50 characters but it was clear that a great many lines were not making it. The web page repaired itself but the JavaScript was woefully incomplete. Obviously, the Pico would be executing the lines writing the text to the WiFiClient instance way faster than the Arduino MKR 1010 so maybe there was a bottleneck. Some experimentation found a workaround - by writing each line to the Serial object immediately after the client instance. This appeared to slow things up sufficiently for the web browser to receive the full set.

Looks like the client write buffer might be inherited from Print::write. Should I go off down the possible rabbit hole of finding and adjusting the buffer or go look at some other aspects of the Pico board?

Going further was going to need some studying of the C/C++ SDK documentation and much experiment. So, for the moment, I am leaving it there.

Conclusion.

If an Arduino board can deliver the speed, memory and functionality you need then you might want to stick with that format. The Pico though, probably represents the future with an amazing price/performance ratio.

Comments

Post a Comment

Popular posts from this blog

Unicode output from an Arduino.

Image
I have been working hard on a second edition for my book called "Practical Arduino C". The new edition has an extra chapter focusing on adding an Internet capability to Arduino boards plus some additional data structures. Overall, the text has been polished and the index extended and tidied. I have also changed the way the book is being published and sold. This has halved the retail price while still ensuring fast delivery when ordered from Amazon ( Amazon UK link here ). One item that featured in the first edition has been dropped as with hindsight it became clear that it did not add to the reader's learning experience. It made sense therefore to move the section on Unicode output over the Arduino serial interface to a blog post here. Unicode Characters The Arduino C is a great tool for manipulating, displaying and communicating ASCII encoded characters, which is perfect if the language you want to use is based upon the Latin character set. Most recent programming...
Read more

Arduino Regular Expressions

The first chapter of a wonderful book titled “Beautiful Code” (O’Reilly 2007) was written by Brian Kernighan who described an episode from when he and Rob Pyke were writing a book together called “The Practice of Programming”. They wanted to include a discussion on regular expressions but also wanted to include the code of an implementation. Existing code bases would have been a book length by themselves. Rob Pyke developed 30 lines of C code in less than two hours that implements a substantial part of the day to day usage of regular expressions. The code can be described as beautiful for its elegant efficiency. The final line of the chapter reads “I don’t know of another piece of code that does so much in so few lines while providing such a rich source of insight and further ideas”. The code handles the following constructs: Character Meaning c Matches any literal character (in this case ‘c’) . (full stop) Matches any single character ...
Read more

Arduino: How to scroll long text on OLED screen

 While exploring a new and tiny SSD 1306 OLED screen as a useful user interface I hit on the need to scroll some longish text across the screen. This did not seem to be a feature of the Adafruit library I was using to run the device. So I am introducing this working demo of my solution to the problem. The solution is to position the start point of the text in steps towards the left and beyond the left hand edge of the screen. The screen "clips" the text and displays all it can across the width of the screen. The demo includes some fixed text at the top of the screen and scrolls the long text below. #include <SPI.h> #include <Wire.h> #include <Adafruit_SSD1306.h> #define SCREEN_WIDTH 128 // OLED display width, in pixels #define SCREEN_HEIGHT 32 // OLED display height, in pixels #define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin) #define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32 Adafr...
Read more