Getting started with WiFi on Raspberry Pi Pico W board

Raspberry Pi Trading announced the Raspberry Pi Pico W board basically based on the same design as the original Raspberry Pi Pico board with RP2040 dual-core Cortex-M0+ microcontroller but adding a wireless module with WiFi 4 and Bluetooth LE 5.2, although the latter is not enabled on the board at this time.

The company sent me a sample for review/evaluation, and I’ll focus on the WiFi part since the Raspberry Pi Pico W supports the same MicroPython and C/C++ SDKs as for the Raspberry Pi Pico board plus additional APIs for wireless connectivity.

Raspberry Pi Pico W unboxing

The board I received was cut from a 480-unit reel, and I also got a one-meter long micro USB to USB cable, which should probably not be included by default for people ordering the $6 board.

Just like its predecessor, the board is tiny, and

The pinout is the same as the first RP2040 board, and clearly marked on the bottom side of the board.

Connecting Raspberry Pi Pico W to your computer

Once we connect the board to the host computer it should show up as the RPI-RP2 drive in your computer. My laptop is running Ubuntu 20.04, but it will be the same on Windows or macOS.

There are two files in the drive with INFO_UF2.txt with some information about the UF2 bootloader version and board model, and INDEX.HTM that redirects to the Pico documentation on the Raspberry Pi website. So nothing has changed here.

Here’s the output from kernel log for reference:

WiFi with MicroPython

Raspberry Pi Pico and Pico W share the same bootloader, but the MicroPython firmware is different, possibly due to small hardware differences (e.g. user LED connection), but also because it would not make sense to add the WiFi stack to Raspberry Pi Pico and waste precious storage and memory on a resources-constrained microcontroller.

We’ll find the right firmware file on Raspberry Pi website or we can download it directly as follows:

Once we’ve downloaded it, simply copy rp2-pico-w-latest.uf2 to the RPI-RP2 drive…

… and soon the drive will disappear, and the Raspberry Pi Pico W will now show as a serial device:

Which we can also detect in BootTerm (or other tools like Putty, minicom, tio, etc…):

If we connect to the serial device, we’ll enter a REPL interface where we can type some commands to list the 2.4 GHz access points:

Great! It works. There’s only one visible access point detected because I live in the countryside.  The other value (”) is for a hidden SSID open on my Xiaomi router. According to MicroPython API documentation, the five other values are for the bssid, channel number, RSSI, authmode, and hidden status, but the last two numbers are out of range:

There are five values for security:

• 0 – open
• 1 – WEP
• 2 – WPA-PSK
• 3 – WPA2-PSK
• 4 – WPA/WPA2-PSK

and two for hidden:

• 0 – visible
• 1 – hidden

To go further, we’ll look at the “Connecting to the Internet” documentation for the board. The easiest way to update the code it to install Thonny editor first:

We can run the previous MicroPython program in Thonny IDE without any issue after going to Run->Select Interpreter and selecting “MicroPython (Raspberry Pi Pico)”

Let’s connect to CNX_Software_Xiaomi SSID with the following program:

My Raspberry Pi Pico W got an IP address and I can ping it successfully:

For reference, it shows as PYPB on the network:

The firmware ships with safe, global settings, but you may enable extra channels by setting up the country:

This will be especially useful if your board fails to connect to your router due to unavailable channels.

A typical use case for this type of board is to have a web interface to control LEDs or GPIOs. Let’s run a web server to control the user LED on the board:

The code is a little long as it includes some error handling as well. It works fine as you can see from the short demo video below.

The code could be easily modified to control relays or GPIOs.

It’s also possible to install and run the popular iperf3 tool on the Raspberry Pi Pico W:

The code is rather short because we’ve skipped error handling for the connection. Anyway here’s the output from the network benchmark test:

That looks fairly slow to me, even though performance is not always the main requirement on this type of platform. It may also be typical (for this benchmark) on this class of hardware as, for reference, Damien George (MicroPython’s main developer) tested it on the Pyboard D-series board and achieved around 7 Mbits/sec.

If the announcement we were told the Raspberry Pi Pico W can also be used as an access point with up to four clients. I did not find any tutorial for this in MicroPython, but there are instructions for ESP8266 and ESP32, so let’s try to setup a CNX-PICO SSID and connect from a phone:

The good news is that my Raspberry Pi Pico W is now indeed an access point, but the less good news is that the custom ssid configuration did not work, and instead the board will automatically generate an access point name (PICO349B) with an open network.

So the API must be different, or custom access point names are not supported on Raspberry Pi Pico W MicroPython firmware just yet.

Using WiFi on Raspberry Pi Pico W with C programming

Let’s try to reproduce the code samples above with the C/C++ SDK. If you haven’t done so already, you’ll need to set up the SDK as we did for the Raspberry Pi Pico board and get the samples in a Linux computer or Raspberry Pi board:

There’s now a new directory for Pico W:

Here’s the WiFi scan sample code:

That’s a bit more complex than our MicroPython sample above. Let’s prepare the system to build the C samples:

You’d obviously need to change the SSID and password to match the ones in your network Here’s the output from the command for reference:

We can now build the wifi_scan sample:

The output is fairly long but should start and end as follows:

The build will have generated a bunch of files including the UF2 file we’ll use to copy to the board:

Since we’ve already installed the MicroPython firmware on the board, We’ll need to press the BOOT button and power cycle the board to enter mass storage mode and copy picow_wifi_scan_poll.uf2 file to the RPI-RP2 drive.

The drive will disappear to reboot and automatically start the program, but I noticed the board will not show as a serial device anymore. That’s because we need to access the serial console through the UART pins of the Raspberry Pi Pico W with pin 1 Tx, pin 2 Rx, and pin 3 GND. So I soldered a short header to the relevant pins on Raspberry Pi Pico W and I used a USB to TTL board connected to my laptop, but if you’re programming the Pico W board with a Raspberry Pi SBC you could use the UART from the 40-pin GPIO header instead.

Now I can use BootTerm and see CNX_Software_Xiaomi SSID and the hidden SSID from my router properly detected:

So scanning works (although it shows the same SSID several times), and we can now try to connect to our WiFi router using the following sample (from Pico W documentation) in wifi_connect/wifi_connect.c:

Just make sure you change the ssid and pass values, as well as the country (CYW43_COUNTRY_??). We’ll also need a CMakeLists.txt file:

We’ll also need to copy some extra files to your working directory:

You should now have four files in the folder:

We can now build the program as we did before:

If there is any issue during the cmake step, simply correct the CMakeLists.txt file and delete all files in the build folder before running the cmake command again.

Since I’m in Thailand, I first assumed CYW43_COUNTRY_TH would do. Wrong!:

The available countries are available in pico-sdk/lib/cyw43-driver/src/cyw43_country.h. Here’s an extract:

I see. I have to use CYW43_COUNTRY_THAILAND instead and the build could complete. We have the required UF2 file:

Let’s flash it to the board with the usual method, and see if we can indeed connect to the router:

That does not tell us much, but at least the program runs without error. Working in C with the Raspberry Pi Pico W will require some work both in terms of learning the new low-level CYW43 API, LWiP library, and even playing with FreeRTOS for more complex examples.

There’s no sample to run a webpage to control an LED, so let’s check out the iperf sample. Let’s go into the /pico-examples/build/pico_w/iperf folder, and build the sample:

In that case, we have two UF2 files:

If we look at the code this is selected through PICO_CYW43_ARCH_POLL:

1. PICO_CYW43_ARCH_POLL = 1 –  if you are using pico_cyw43_arch_poll, then you must poll periodically from your main loop (not from a timer) to check for WiFi driver or lwIP work that needs to be done.
2. PICO_CYW43_ARCH_POLL != 1 – if you are not using pico_cyw43_arch_poll, then WiFI driver and lwIP work is done via interrupt in the background. This sleep is just an example of some (blocking)

Those are just two different programming methods for the program flow either using polling or interrupt. The latter is normally more efficient, but more complex. I’ll just copy picow_iperf_server_background.uf2 to the board for testing. Note the implementation is based on iperf2, not iperf3 as with the MicroPython example. The iperf server is running on the Raspberry Pi Pico W:

Let’s run iperf client on the laptop:

8 Mbps that a bit better than with MicroPython, but still in the same ballpark. The result is also shown in the Pico W serial console:

If you want to run the iperf sample as a client on Pico W you’ll need to add the following two lines after the headers:

This “Getting Started Guide” is getting long and has a bit more details than I initially expected, so I’ll skip that part.

Let’s complete the WiFi tutorial with the access point demo for Raspberry Pi Pico W. Before building the sample, we’ll want to have a look at the code in pico-examples/pico_w/access_point/picow_access_point.c:

This part is in the main() function. We can see that by default the SSID (access point name0 is picow_test, the password is password (with WPA2 security), the subnet will be 192.168.4.0, and the program will also start a DHCP server so that the client can get an IP address. If you set the password to NULL, it should become an open network. Let’s changed the ap_name to picow_cnxsoft, and the password to 123456…

Let’s build the sample and copy picow_access_point_poll.uf2 or picow_access_point_background.uf2 to the board as usual. Here’s the output from the terminal:

The server on port 80 is not a web server, but instead, a basic TCP server that I suppose is meant to work with the TCP client sample installed on another Raspberry Pi Pico.

Nevertheless, I could connect my phone to the picow_cnxsoft access point…

as well as my Ubuntu laptop

Both devices also show up in Raspberry Pi Pico W’s serial terminal:

Raspberry Pi Pico W’s documentation is pretty good to get started with WiFi, but not necessarily complete, as for example, at this time there’s no example to set up an access point in MicroPython and be prepared to look into the code, for example, I had to look into the code in the C/C++ SDK, as opposed as to the documentation, to find country settings. Most people should probably get started with MicroPython, as while the C/C++ SDK is more flexible, the learning curve should be much steeper.

Support CNX Software! Donate via cryptocurrencies, become a Patron on Patreon, or purchase goods on Amazon or Aliexpress