The freshly released Raspberry Pi Pico 2 comes with two different CPUs onboard. A dual core Arm cortex M33 or a Dual Core RISC-V Hazard3, yes the first RISC-V product from Raspberry Pi! The latter CPU has a performance that falls somewhere between the older Raspberry Pi Pico’s dual core Arm Cortex M0+ and the new Arm Cortex M33. The RISC-V CPU was developed by Raspberry Pi employee Luke Wren as an interesting side project.

Right now there are two ways to use this new CPU, via the C++ workflow, and using a preview of the latest MicroPython firmware. We’re going to use the latest MicroPython firmware for RISC-V to show that it is as easy as the version of MicroPython used for the Arm CPU.

The goal of the project is to create a WS2812B “NeoPixel” light sequence, demonstrating that the RISC-V CPU is capable of handling the timing critical WS2812B protocol and producing a rather splendid “disco light” effect for the office.

For this how to you will need

• Raspberry Pi Pico 2
• Good quality micro USB cable
• Half-size breadboard
• WS2812B “NeoPixel” stick
• 3 x Male to male jumper wires

Installing MicroPython for RISC-V on the Raspberry Pi Pico 2

1. Download the RISC-V MicroPython UF2 file from the MicroPython resource. Ensure that you download the RISC-V preview. Note that as this is a preview, things are liable to break, so do not build any mission critical projects with this firmware.

2. Push and hold the BOOTSEL button on the Pico 2, then connect to your computer using a micro USB cable. Release BOOTSEL once the drive RP2350 appears on your computer.

3. Drag and drop the UF2 file onto the RP2350 drive. The Raspberry Pi Pico 2 will reboot and will now run MicroPython.

If you have never used MicroPython, it is a version of Python 3 developed for microcontrollers. If you can write Python, then you can write MicroPython. To write MicroPython code, we need to use a dedicated editor and the default, basic editor is Thonny which is what we shall use for this tutorial.

4. Download and install Thonny for your OS.

5. Open Thonny.

6. Connect the Raspberry Pi Pico 2 to your computer and in Thonny go to Tools > Options and click on the Interpreter tab. From the interpreter, dropdown list select MicroPython (Raspberry Pi Pico). The port dropdown menu can be left to automatically detect the Pico. Click Ok to close.

7. Check the Python Shell (REPL) for “Raspberry Pi Pico2 with RP2350-RISCV” to confirm that it has been installed correctly.

Building the Circuit

The circuit is a simple connection between the Pico 2 and the WS2812B “NeoPixels” that uses only three wires. We need connections for power and data.

You may need to solder header pins to your Neopixels, for that you will need the best soldering iron or soldering station, and a quick refresher on how to solder.

Writing the code

The goal of the code is to create a pseudo random light sequence along the full length of NeoPixels.

1. Create a new blank file in Thonny (File >> New).

2. Import a series of modules (pre-written code.) The first is machine, this enables the code to talk to the Pico 2’s GPIO. Next is NeoPixel, an abstraction that makes working with the WS2812B RGB LEDs much easier. Then we import time, used to add delays to the code. Finally we import the random integer generator from the random module. This is used to generate random numbers in our code.

import machineimport neopixelimport timefrom random import randint

3. Create an object, np, and use it to tell the code that we have NeoPixels connected to pin 16, and that we have 8 “pixels” (individual LEDs) in the chain. Change this value to match how many you have.

np = neopixel.NeoPixel(machine.Pin(16),8)

4. Create a try, exception handling sequence. Essentially this tells the Pico 2 to try and run the code that is indented inside of it. If it fails, an exception is raised, and we will catch that later.

try:

5. Indented to show that this is the code to “try” and run, add a while True loop to run the code forever. Thonny will auto-indent the code as we type.

   while True:

6. Create four objects, r,g,b and n to store randomly generated numbers between a range of 0 and 128 (r,g,b) and 0 to 7 (n, the number of NeoPixels in our chain, we have eight, but Python starts counting from zero.) The value 128 is half brightness for the NeoPixels. You can set this to be 255 for full brightness, but it does consume more power, and could affect those with photosensitivity.

       r = randint(0,128)       g = randint(0,128)       b = randint(0,128)       n = randint(0,7)

7. Print the current color mix values to the Python Shell. This is the mix of R,G and B that makes up the randomly chosen color.

       print("This color is: ","{} {} {}".format(r,g,b))

8. Set the value of the randomly chosen pixel (n) to the color mix stored as r,g,b using the np object that we created earlier.

       np[n] = (r,g,b)

9. Write the changes to the NeoPixels, and then wait for 0.1 seconds. This adds a short delay before the code goes back to the start of the while True loop and repeats the process.

       np.write()       time.sleep(0.1)

10. Create the exception handler part of the code to detect when the user clicks Stop, or press CTRL + C.

except KeyboardInterrupt:

11. Print a message “EXIT” to the Python Shell. This tells the user that the exception has been successfully raised and the handler process is now in control.

   print("EXIT")

12. Using a for loop, iterating through all of the NeoPixels (8 for us). Set all of them to off, and write the changes to take effect.

   for i in range(8):       np[i] = (0,0,0)       np.write()

13. Save the code to the Raspberry Pi Pico 2 as pixels.py.

14. Click on Run > Run Current Script, or click on the green run button to start the code.

All of the NeoPixels in the chain should soon be a random color, changing every 0.1 seconds. The Python Shell will show the current color as an RGB value.

When you want to stop, click on the stop button, or press CTRL + C on the keyboard.

Complete Code Listing

import machineimport neopixelimport timefrom random import randintnp = neopixel.NeoPixel(machine.Pin(16),8)try:    while True:        r = randint(0,128)        g = randint(0,128)        b = randint(0,128)        n = randint(0,7)        print("This color is: ","{} {} {}".format(r,g,b))        np[n] = (r,g,b)        np.write()        time.sleep(0.1)except KeyboardInterrupt:    print("EXIT")    for i in range(8):        np[i] = (0,0,0)        np.write()

Waveshare has announced its BG95-M3 Zero, a single-board computer (SBC) that offers cellular connectivity as well as compatibility with Raspberry Pi HAT add-ons. It features its own processor and ships with Quectel’s QuecPython MicroPython firmware for easy programming.

The BG95-M3 Zero is in a Raspberry Pi Zero form factor (65 x 30 mm) and integrates an Arm Cortex-A7 processor running ThreadX RTOS. Most Quectel modules for cellular Internet of Things (IoT) usage depend on another board for a host processor. This allows hobbyists and IoT manufacturers to develop smaller smart products with cellular capabilities since there’s no need for an additional SBC to run the show.

This development board is equipped with a BG95-M3 module, which supports LTE Cat M1, LTE Cat NB2, and EGPRS cellular networking worldwide. It also supports GNSS positioning using GPS, GLONASS, BDS,  Galileo, and QZSS. The SBC includes an onboard nano SIM card slot positioned near the edge of the board for easy insertion and removal.

A group of five LEDs on the board indicate operating status. These include power, sleep, and network indicators. There’s also an LED that illuminates when a SIM card is inserted as well as a PWM function indicator.

The Waveshare BG95-M3 Zero has a 40-pin GPIO header and a USB Type-C port for flashing the firmware. The BG95-M3 Zero integrates an onboard MIPI interface for connecting to MIPI displays and Raspberry Pi peripheral devices. The board also has an onboard camera interface to support customized SPI cameras up to 30MP.

While the BG95-M3 Zero doesn’t offer Bluetooth or Wi-Fi support, Waveshare does produce larger boards with expanded networking capabilities. The EC200U-EU is available in Europe, the Middle East, Africa, Australia, New Zealand, and Brazil. There’s also the EC200U-AU available in Australia and Latin America.

Programming the SBC is done through QPYcom, a specialized development and debugging tool for QuecPython. QPYcom is Windows-only, but Waveshare notes that you can use plugins for Thonny IDE. VSCode, and other IDEs to program the board.

Murmurings of official Bluetooth support for the $6 Raspberry Pi Pico W have been running since early 2023. Developers favoring C/C++ received support back in February.  Today via a blog post from Raspberry Pi LTD CEO Eben Upton, MicroPython developers can now create Bluetooth projects using our favorite microcontroller thanks to the latest MicroPython build.

The Raspberry Pi Pico W's wireless chip, the Infineon CYW43439 provides both 2.4 GHz Wi-Fi and Bluetooth 5.2 over a three pin SPI bus between itself and the RP2040 SoC. The latest MicroPython update brings support for Bluetooth Classic (no ACL/SSO support just yet), BLE Central and Peripheral roles. Bluetooth Classic and BLE can be enabled individually. or at the same time. 

The good news is that you don't have to rush out and purchase a new Raspberry Pi Pico W. As this is a software update, work between Raspberry Pi, Infineon and MicroPython creator, Damien George. All you need to do is download the latest update and flash it to your Raspberry Pi Pico W. Also updated is Alasdair Allan's exceptional documentation. A book, Connecting to the Internet with Raspberry Pi Pico W illustrates just how simple a Bluetooth project can now be created using the Raspberry Pi Pico W.

With support now being added for MicroPython, it must only be a short time before it also arrives for CircuitPython.

Managing modules in Python is often handled via pip, the Python package manager which uses a repository provided by PyPi to list available Python modules. But what is there for MicroPython? There was upip, a micro version of pip, but now there is mip, the new, official lightweight package manager for MicroPython. 

Mip is designed for all MicroPython devices, be they online or offline. Devices which can connect to the Internet can be used directly via the Python Shell while offline devices can use a tool, mpremote, to install modules from your computer.

In this how-to, fee we will show you how to use mip directly on a Raspberry Pi Pico W, then offline using a Raspberry Pi Pico and mpremote. We will also go through a few handy mpremote commands.

Using mip With the Raspberry Pi Pico W

Using mip with a network connected MicroPython device means that modules can be directly installed to the device in a similar means to pip installing Python modules, and package managers in Linux.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Open Thonny and click on the Stop button to refresh the connection. This ensures that the Python Shell is open and working correctly.

3. Create a new file. This file will contain all of the steps necessary to connect to Wi-Fi.

4. Add the following lines of code to the new file. Change the SSID and PASSWORD to match your own.

import networkwlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect("SSID","PASSWORD")print(wlan.isconnected())

5. Save the file to the Raspberry Pi Pico W as network-connection.py

6. Click on Run to start a Wi-Fi connection. After a few seconds it should print True to the Python shell. This indicates that we have an Internet connection. If false, click Stop and then Run again.

7. Import mip, the lightweight package manager.

import mip

8. Test mip by installing a package. I chose umqtt, a MQTT module for MicroPython. Packages are installed by calling mip’s install function and passing it the name of a package. Mip uses micropython-lib as its index, Python 3’s package manage, pip uses the PyPI index.

mip.install(“umqtt.simple”)

9. Test installing a third-party MicroPython package. Mip can also be used to install third-party packages outside of the micropython-lib index. Here we pass the install function the URL for the PicoZero library from the Raspberry Pi Foundation.

mip.install(“https://raw.githubusercontent.com/RaspberryPiFoundation/picozero/master/picozero/picozero.py”) 

Using Mip With Mpremote on Raspberry Pi Pico

For MicroPython on a device with no network access, a Raspberry Pi Pico, mip will need to be used with mpremote, a tool that will communicate with the device over a USB / serial interface.

1. Follow these steps to download the latest version of MicroPython for the Raspberry Pi Pico W. The most important steps are to download and install the UF2 firmware image and to set up Thonny. The rest are optional. Ensure that you are downloading MicroPython 1.20 or newer.

2. Ensure that Python 3 is installed on your machine.

3. Open a Command Prompt and use pip to install mpremote.

pip install mpremote

4. Run mpremote and pass mip as an argument, and then specify the package name or the URL for the module. Here I am installing a package to use seven segment displays with the Pico.

mpremote mip install https://raw.githubusercontent.com/mcauser/micropython-tm1637/master/tm1637.py 

Other Useful mpremote Commands

Mpremote is a useful tool for quick tasks on a MicroPython device. We’ve detailed a few extra useful commands that will help manage a MicroPython device.

mpremote: Automatically connects to a device running MicroPython to view the output of running code. Press CTRL + ] to close the connection.

mpremote repl: Opens an interactive Python shell, a REPL (Read, Eval, Print, Loop) where a user can directly work with the hardware.

mpremote soft-reset: Reboot the attached MicroPython device. This is the same as pressing CTRL + D in the REPL.

mpremote fs : Use a series of file system commands with the MicroPython device. These commands are similar to common Unix / Linux commands.

In the example we list the contents of the flash storage, create a new file, then re-list the storage to see the new file.

MORE: Best RP2040 Boards

MORE: Best Raspberry Pi Projects

MORE: Raspberry Pi: How to Get Started

Python How Tos

• How To Install Python on Windows 10 and 11
• How to use For Loops in Python
• How to Enumerate in Python
• How to Create Executable Applications in Python
• How To Remove Backgrounds From Images With Python
• How to Create Web Apps with Python, HTML and Thonny
• How To Use Raspberry Pi Camera Module 3 with Python Code

A new version of MicroPython has been released for compatible microcontrollers. This release. version 1.20, sees support for the Raspberry Pi Pico W and brings a new package manager.

Version 1.20 brings support for the Raspberry Pi Pico W's CYW43439 Wi-Fi chip, this means that stock MicroPython can now take advantage of the $6 boards wireless connectivity. Bluetooth support is still missing, in this and the official MicroPython release. Support for Bluetooth isn't too far away now. Bluetooth support was recently added to the Raspberry Pi Pico SDK, so MicroPython isn't too far away now.

The other addition to the release is a new lightweight package manager, mip. Mip is optimized for use with embedded systems. In MicroPython creator Damien George's release post they state that "It is intended to take over the role of upip and supports installing packages from micropython-lib as well as any URL. Mip can be run directly on a device (with network connectivity) or via mpremote." Raspberry Pi Pico W users would need to ensure that their Pico W is connected to Wi-Fi and that they have access to the Python Shell (REPL) in order to use mip directly on the hardware. Raspberry Pi Pico users will need to use mpremote, a command line tool that provides utilities to communicate between a computer and a MicroPython device over a serial interface.

MicroPython, is the creation of programmer and theoretical physicist Damien George and in broad terms it is a port of Python 3 aimed squarely at microcontrollers. MicroPython has been used with a diverse range of boards (ESP32, ESP8266, W600 etc) but for some it was introduced via the Raspberry Pi Pico. 

We were keen to see if the official Raspberry Pi Pico MicroPython firmware featured support for mip. It seems that it does, the latest firmware for the Raspberry Pi Pico W, rp2-pico-w-20230427-unstable-v1.20.0-1-g82a59a824.uf2 does indeed feature mip. We were able to use mip to install a third-party MicroPython module and then directly use it, all from the Python Shell.

The GurgleApps team is back with another cool Raspberry Pi Pico W project: a Pico W-based web server. But this project does more than serve web pages — it can also run your Python code on the Pico W via a web interface.

The web server is accessible by any device with a web browser, on a local or external network. The project is coded in MicroPython and at a basic level it works with two files. Wi-Fi configuration details are stored in config.py, and the project code is stored in main.py (which MicroPython will autorun when powered on). 

The clever part of this project is the abstraction. Rather than bog the user down with complexities, the team has created its own webserver module (gurgleapps_webserver.py) which the project code imports and uses.
Abstracting code is a good way of getting users comfortable with a project / language before pulling back the curtain to reveal the complexities of a powerful language.

GurgleApps demonstrates the web server by bundling a project to control the Pico's onboard LED using a rather responsive web interface. Crafting a custom URL, advanced users can directly access the function and control the LED. This advanced approach also returns a JSON object to the user, which, in this case, tells us the current delay (blinking on / off) of the LED and the LED's current state. Other example projects include a frequency generator which was used in a Physics experiment to visualize vibrations in sand (or polenta). The frequency data is also displayed on a tiny OLED screen.

The team then goes into great detail on how to create your own functions which can be called via the web interface. This detail is what sells the project — using not very much code we can create a web interface for a robot or see real-time sensor data in a web page.

The user interface is created using HTML and CSS. These files are stored in the www directory of the project's Pico download. Changing the graphics and layout of the user interface would be a quick and easy task for most learners.

It is great to see the GurgleApps team building another simple-yet-powerful project based around our favorite microcontroller. You can learn more about the project via the GurgleApps blog and find all of the raw code this GitHub repository.

Pimoroni's Tufty2040 is a Raspberry Pi Pico-powered color LCD badge, but it can do much more than names. Coder Pixylatte has coded the Atari classic River Raid in MicroPython for Tufty2040 — and it looks perfect.

For those of us too young to remember (I wish that were the case), River Raid was released in 1982 for the Atari 2600 games console (I remember playing it on a Commodore 64). The goal of the game is to fly your jet fighter down a river, attacking enemy vehicles as you fly. You have to dodge attacks and vehicles and make sure you have enough fuel to carry on your mission — "Don't shoot the fuel tanks," is what I would tell my younger self. 

The game never ends, but bridges act as checkpoints along the way to measure your progress, and each life lost returns you to the previous bridge.

Pixylatte's version of the game is coded entirely in MicroPython, and is added as a menu item to the default Tufty 2040 menu. This means that a simple name badge can be quickly turned into a game badge when we're taking a break at a conference!

The coding for the game is fabulous — it uses a sprite map (a large grid of sprites that are swapped as needed) for the game assets. The MicroPython code reacts to player input to control the direction and speed of the jet, along with a button to fire at your enemies. The enemy sprites fly left to right on the screen, dodging your fire as your fly further up the river.

Protecting Tufty2040 from the rigours of gaming is a 3D printed case — one that could be easily reproduced on any of the best 3D printers. The case, designed by Funkypiwy (aka Pierre-yves Baloche) provides great protection to the perimeter of Tufty2040 and also has an optional stand. It appears that Pixylatte has printed a different case back — one which has an integrated coin cell battery pack. You can also design your own case for the Tufty2040.

Pixylatte's project is great fun — you can find all of the details on their GitHub repository.

Overclocking any model of Raspberry Pi is really simple. But overclocking the Raspberry Pi Pico is even simpler. All it takes is two lines of MicroPython and your Pico can easily run at double its normal speed, and without the need for the best CPU coolers.

In this how to we will overclock a Raspberry Pi Pico to 270 MHz, double the base speed of 133 MHz. Then we will write a script to test how far we can overclock, and then how low we can underclock the CPU.

You might be thinking “Why overclock a Raspberry Pi Pico?”Using a low level language, such as C, the Pico is capable of being used to play games such as Doom (the full game) using an HDMI output board. It can emulate retro computers such as the ZX Spectrum and Commodore 64. With MicroPython, overclocking will give us a noticeable speed boost, and underclocking may provide us with longer battery life if we’re using it in a battery-powered project.

This how to will work with the Raspberry Pi Pico, Pico W and many other of the best RP2040 based boards when using MicroPython. There are other methods for changing the frequency when programming the boards in other languages.

For This Project You Will Need

A Raspberry Pi Pico or Pico W or any other RP2040 based board that’s running MicroPython.

Overclocking the Raspberry Pi Pico With MicroPython

1.  Install the latest version of MicroPython on your Pico. If you haven’t already done this, follow up to step three of this guide to learn how.

2. In the REPL, import the machine module and check the current speed of the Raspberry Pi Pico. The returned value will probably be 125000000 Hertz (125 MHz). Some boards or versions of MicroPython may have it set a little higher by default.

import machinemachine.freq()

3. Using the same command, set the CPU speed to 270 MHz.

machine.freq(270000000)

4. Check the CPU speed to ensure that the overclock has worked. The returned value should be 270000000 Hertz (270 MHz).

machine.freq()

Right now this speed boost is temporary. When the Pico is rebooted, it will return to its default speed (usually 125 MHz). In order to retain the overclock, it must be set each time the Pico boots. Adding these two lines to the start of any MicroPython code will overclock the RP2040 to the desired speed when the code is run.

import machinemachine.freq(SPEED IN HERTZ)

How Far Can The RP2040 Be Pushed?

Overclockers are always looking to go just that little bit faster but how can we determine our luck in the silicon lottery? For that we automated the process with a little Python code. 

1. In Thonny start a new file by first importing two modules. Machine is used to change the CPU speed, and time is used to pace the code.

import machineimport time

2. Create a variable, freq and store 270 MHz as Hertz. We know that 270 MHz works well, so we start from a known working speed. If your goal is to underclock the RP2040, reduce the value accordingly.

freq = 270000000

3. Create an object, speed, and in there store the current speed of the RP2040. Using a little math, the returned value in Hertz is converted to megahertz, then rounded to one decimal place, before finally being converted to a string.

speed = str(round(machine.freq()/1000000,1))

4. Print the current CPU speed as part of a message. We needed to convert the speed to a string in order to place it in the message.

print("The starting speed is",speed,"MHz")

5. Print a message to the user, informing them that the test starts in five seconds, then wait for five seconds.

print("Starting the test in five seconds")time.sleep(5)

6. Create a loop to continually run the code. We could use a for loop, but a while True loop will crash when it hits a bad frequency, so we gain nothing from a for loop.

while True:

7. Set the CPU speed using the freq variable.

   machine.freq(freq)

8. Create an object, speed, and in there store the current speed of the RP2040. Using a little math the returned value in Hertz is converted to MegaHertz, then rounded to one decimal place, before finally being converted to a string.

   speed = str(round(machine.freq()/1000000,1))

9. Print the current CPU speed as part of a message. We needed to convert the speed to a string in order to place it in the message.

   print("The starting speed is",speed,"MHz")

10. Increment the speed by 10 MHz and save the value to freq. The += operator translates to freq = freq + 10000000. It is shorter and neater in the code. Both work equally as well, and can be interchanged for clarity. The += can be swapped for -= so that the values count down to find the lowest CPU speed.

   freq += 10000000

11. Pause the code for two seconds. This will give us time to read the values before the loop repeats.

   time.sleep(2)

12. Save the code to the Raspberry Pi Pico as speedtest.py and click run. Our best speed was 280 MHz, but you may get lucky.

We also tested an underclock (reducing the speed by 10 MHz each loop) and managed to get it down to 10 MHz, which should significantly reduce the amount of power draw for projects that require a long battery life. We were unable to capture any data due to the level of precision equipment required.

Complete Code Listing

import machineimport timefreq = 270000000speed = str(round(machine.freq()/1000000,1))print("The starting speed is",speed,"MHz")print("Starting the test in five seconds")time.sleep(5)while True:   machine.freq(freq)   speed = str(round(machine.freq()/1000000,1))   print("The current speed is",speed,"MHz")   freq += 10000000   time.sleep(2)

Connecting our projects to the Internet just got a lot easier, and cheaper! The $6 Raspberry Pi Pico W, an upgrade on the original Raspberry Pi Pico, brought one great update: Wi-Fi. This upgrade, along with the $6 price, enables makers to harness the power of the RP2040 SoC for a plethora of Internet of Things applications. The Pico W also tops the list of our best RP2040 boards.

We’ve already covered how to pass data to and from a Raspberry Pi Pico W to another web service, Anvil. But what if you just want to collect some data and send it off into the world? There are many ways to do this, but the simplest has to be IFTTT. 

IFTTT (If This Then That) is a web service that can take data from many different inputs (Twitter, Home Automation, Google, Facebook etc) and send it to other services.

In this project we’ll use the most basic service, webhooks, to send an HTTP POST request from a Raspberry Pi Pico W to IFTTT’s service. On IFTTT we will create an applet that will intercept the webhook, and trigger a tweet to be sent on Twitter.

For this project you will need

• Raspberry Pi Pico W
• DHT11 Temperature Sensor
• Half Breadboard
• 3x Male to male jumper wires

The Temperature Sensor Circuit

Our circuit is simple, consisting of just the Raspberry Pi Pico W and a temperature sensor. The DHT11 is a low-cost four-pin temperature sensor which is ubiquitous in the maker community. Looking from the front (the blue “cage”), we connect to the Raspberry Pi Pico W as follows:

Pin 1: (Red Wire) Connect VCC to 3V3(OUT) of the Pico W.

Pin 2: (Yellow Wire) Connect Data out to GP4 of the Pico W.

Pin 3: No connection.

Pin 4: (Black Wire) Connect GND to GND of the Pico W.

Setting Up IFTTT

IFTTT (If This, Then That) is the conduit which links our Raspberry Pi Pico W to Twitter. IFTTT is a free service that offers a myriad of ways to connect different data services together.

We are going to create an applet which reacts to a webhook (a custom URL) sending data to IFTTT. Then IFTTT will add the data into a message that will be sent to our followers on Twitter.

1. In a browser visit IFTTT and login / create an account.

2. Click on Create.

3. Click on Add. This is our trigger event. If this happens, our applet starts. In our case if a webhook is sent from the Raspberry Pi Pico W.

4. Search for webhook, and then click on the webhook icon.

5. Click on Receive a web request. This is our request, sent from the Raspberry Pi Pico W.

6. Set the Event Name to Post_Tweet and then click Create Trigger.

7. Click on Then That Add. This is the outcome of our trigger, in this case a Tweet is sent.

8. Search for Twitter and then click on the Twitter icon.

9. Select Post a Tweet.

10. Check that the correct Twitter account is selected, you may have to link your Twitter account to IFTTT. Replace the tweet text with your own custom message. Linking your Twitter account to IFTTT is an automated process, which IFTTT will trigger and ask you to confirm.

11. Click on Add ingredient and select Value 1. Then finish the remainder of the message, in this case stating that the temperature is in degrees Celsius. Click Create Action to save. Ingredients are IFTTT’s way of adding extra information to our tweet by pulling the data from our custom URL.

12. Click Continue.

13. Review the applet details, check the notifications option to on, and click Finish when ready. Notifications enable us to debug the applet, should an issue occur.

The IFTTT Applet has been created, but we don’t yet have the webhook URL. This URL is what sends the temperature data from the Raspberry Pi Pico W to our IFTTT service. The URL requires our trigger (Post_Tweet) and an API key, unlocking IFTTT access.

1.Visit this link in a new browser tab / window.

2. Copy the Make a POST or GET web request link into notepad or a text editor. Your text will show a correct API key, for security reasons we have edited the text.

https://maker.ifttt.com/trigger/{event}/json/with/key/YOUR API KEY HERE

3. Remove /json and change {event} to Post_Tweet.

https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR API KEY HERE

You now have a valid webhook URL which will link your Raspberry Pi Pico W to Twitter via IFTTT.

Setting up the Raspberry Pi Pico W

Our Raspberry Pi Pico W is acting as a data collection device. It connects to our Wi-Fi, and every hour takes a temperature reading. This is then sent to IFTTT using a custom webhook URL. IFTTT then sends the message to Twitter as per the applet we have just created. 

Our goal is now to install the latest MicroPython firmware release for our Raspberry Pi Pico W, then write a few lines of MicroPython code to connect to our Wi-Fi, take a temperature reading, and then send that data to IFTTT.

1. Follow this guide to download and install the MicroPython firmware, and setup Thonny.

2. Open Thonny and create a new file.

3. Import three modules of code. Network enables the Pico W to connect to a Wi-Fi network. Urequests is a version of requests, a means to work with web data, for MicroPython. DHT refers to the DHT11 temperature sensor used in the project.

import networkimport urequestsimport dht

4. Import two further modules of code. From the Time module, import the sleep function, we’ll use this to add a pause to the project. From the Machine module import Pin, this enables our code to interact with the GPIO.

from time import sleepfrom machine import Pin

5. Create an object, “sensor” which connects our code to the DHT11 connected via the GPIO. This object enables us to interact with the sensor connected on Pin 2, querying temperature data.

sensor = dht.DHT11(Pin(2)) 

6. Create an object “wlan” and use it to connect the code to the Wi-Fi on the Raspberry Pi Pico W, then turn the Wi-Fi on.

wlan = network.WLAN(network.STA_IF)wlan.active(True)

7. Connect your Pico W to your Wi-Fi access point using its SSID and password.

wlan.connect("SSID","PASSWORD")

8. Pause for five seconds before proceeding onward. This isn’t strictly necessary as the previous Wi-Fi connection is a blocking call that will either connect or fail, then release the block. This pause is present to allow a little extra leeway.

sleep(5)

9. Print the current status of the Wi-Fi connection. This will either be True for a successful connection, or False if it was unable to connect.

print(wlan.isconnected())

10. Add a loop to continually run the following code. A while True loop will continuously run the code until the Pico W is turned off. Note that the code following this line is indented to show that it is part of the loop.

while True:

11. Take a reading with the DHT11. We need to do this in order to get the raw data.

   sensor.measure()

12. Save the current temperature to an object, temperature.

   temperature = sensor.temperature()

13. Print the temperature to the Python Shell (REPL). This is useful to debug any issues. It should show the temperature each time the loop iterates.

   print(temperature)

14. Create an object, message, to store the unique webhook URL that we created earlier. At the end of the URL add ?value1= and ensure that this is contained between quotation marks “ “. Remember to add your unique IFTTT API key.

   message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="

15. To the same line, add the current temperature stored in the “temperature” object. Note that we need to convert the temperature from an integer / float into a string using the str() function. Your message line should now read as follows.

   message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="+str(temperature)

16. Post the message to Twitter using urequests.post. This essentially sends the data to IFTTT via the webhook URL, and IFTTT then sends it to Twitter.

   urequests.post(message)

17. Pause the code for one hour (3600 seconds) before allowing the loop to repeat. IFTTT has a rate limit of 25 tweets per day, so to have a constant feed of data we need to limit the tweets to one per hour. If you go over this limit, IFTTT disables the applet until the next day.

   sleep(3600)

18. Save the code to your Raspberry Pi Pico W as tweet_temp.py

Complete Code Listing

import networkimport urequestsimport dhtfrom time import sleepfrom machine import Pinsensor = dht.DHT11(Pin(2)) wlan = network.WLAN(network.STA_IF)wlan.active(True)wlan.connect("SSID","PASSWORD")sleep(5)print(wlan.isconnected())while True:    sensor.measure()    temperature = sensor.temperature()    print(temperature)    message = "https://maker.ifttt.com/trigger/Post_Tweet/with/key/YOUR IFTTT API KEY HERE?value1="+str(temperature)    urequests.post(message)    sleep(3600)

Testing and Running the Code

Before we properly deploy the project we need to test that the code works.

1. Click on the Run button, located in the top left corner of Thonny.

2. Check the output. You should see True, confirming we are connected to the Wi-Fi. Then the temperature should appear.

3. Visit your Twitter account and check that the message has been posted. This should take approximately 10 - 20 seconds to appear.

4. Click on Stop to stop the running code.

With the code successfully tested, we can now set the code to automatically run when the Raspberry Pi Pico W boots.

1. Save As the code to your Raspberry Pi Pico W as main.py. MicroPython (on any device) will look for main.py when it powers up. If present, the code inside this file is autorun.

2. Unplug the micro USB lead from the Pico W, then re-insert to force a reboot.

3. Check your Twitter account for the corresponding tweet.

Adafruit has shared a new guide detailing the process for using CircuitPython libraries with MicroPython using our favorite microcontroller, the Raspberry Pi Pico.

The layer between CircuitPython and MicroPython is known as Blinka. It's a compatibility library designed to work with Linux SBCs like the Raspberry Pi Pico and the Raspberry Pi. However, the Raspberry Pi Pico microcontroller proved to be a unique challenge and hasn't been able to make use of this support until now.

Getting started is easy enough as Adafruit has supplied a full guide detailing everything you need to do. You will need the latest version of MicroPython. The instructions recommend using Thonny for this but when testing it ourselves, we opted to manually install MicroPython as Thonny had an out-of-date version listed. 

Once you've ensured your copy of MicroPython is truly the latest, you're free to go ahead and complete the guide steps which demonstrate how to use the libraries with a BME280 sensor. At this time not every library will work, we tested with a NeoPixel ring and found that it was not supported. Adafruit advised us that at the time of writing there is support for basic digital IO, I2C, SPI, UART but anything that needs a custom hardware API, including NeoPixels will not currently work. But this will change over time.

We're excited to see this new development bridge the gap between CircuitPython and MicroPython for the Pico which will hopefully save developers plenty of hassle going forward. Check out the full overview at the Adafruit website and guide to get an idea of how this new configuration works and start brainstorming your next microcontroller project. 

The worst thing about modern smartphones and handheld videogame consoles is the lack of Snake. If you can’t play a quick game of Snake during meetings, then what’s the point? Enter Hari Wiguna, who has, via Hackaday, got the game running on a Raspberry Pi Pico and a tiny OLED screen.

The Raspberry Pi Pico, a $4 programmable microcontroller board from the Raspberry Pi Foundation, features a  a dual-core Arm Cortex-M0+ processor with 264KB internal RAM (compared to 1KB on the Nokia 3310, the home of Nokia’s Snake II). And of course, what else could you code Snake in but MicroPython?

Wiguna’s code is fully available on Github for anyone who fancies having a go themselves. Along with the Raspberry Pi Pico, Wiguna used an I2C 128 x 64 OLED screen and five buttons - four for movement and the fifth to start a new game. 

The snake’s slithery undulating movement is a fine showcase for both the Pico’s abilities and Wiguna’s coding ability - and the design drawings documented on the site give an insight into the amount of work it takes just to chase apples across 8,000 pixels.

The $4 Raspberry Pi Pico may be great value, but it had to lose something in order to keep the price low, and that was WiFi. Sure, we can hack our own solution, but Pimoroni's upcoming Pico Wireless board, demonstrated by Pimoroni employee Phil Howard (better known as @Gadgetoid), is shaping up to serve all of our WiFi needs.

Pico Wireless is an ESP32 powered "pack," a term coined by Pimoroni to identify a board that connects to all 40 of the GPIO pins of a Pico, as if it were a backpack. In reality, it requires only a few GPIO pins for an SPI interface and others for basic connectivity.  In the tweet we see Howard using the Pico Wireless next to a Raspberry Pi Pico via a Pico Omnibus, a board that breaks out the GPIO for use with multiple add ons at once. Howard is using the boards to set up a basic web server, which is serving a static HTML page.

The ESP32 at the heart of Pico Wireless is itself a powerful micro-controller, with a dual-core 32-bit LX6 microprocessor running at up to 240 MHz. For Pico Wireless, its sole purpose is to provide wireless communication, and for this it provides WiFi 802.11b/g/n and up to 150 Mbps (802.11n) and Bluetooth 4.2, including Bluetooth LE. The PCB antenna is more than capable of providing good communications over a fair distance. 

Interfacing between the Raspberry Pi Pico and Pico Wireless happens via SPI, and it's highly likely that Pimoroni will add a module to its custom MicroPython firmware, just as the company has done for previous accessories. CircuitPython users already have this feather, as Adafruit has its own Featherwing board that provides this functionality.

Pico Wireless also has three extra features: a micro SD card slot, an RGB LED and a push button. The micro SD card slot should also be an SPI device, and it can be used to store files and record data that can be served by Pico Wireless as if it were a micro web server. The RGB LED is most likely the same as that used on Pico Display, a simple RGB LED that uses PWM (Pulse Width Modulation) to mix red, green and blue to produce a variety of colors, useful as a status LED for a project and to show that your Pico Wireless is working. The final feature, the push button, could be a reset button, something omitted from the Pico, but added via another Pimoroni add-on. Or it could be a user-programmable button.

How much will it be, and how soon will it arrive? Right now we have no idea, but looking at the Pico Wireless board, it already has the correct silkscreen printing and no "bodge wires" used to fix mistakes, so it could be with us very soon. 

This Raspberry Pi Pico creation comes to us from a company called Picosoft. The Japan-based dev team has designed a Python machine known as Orange-Python that boots directly into a MicroPython interface.

Some of the best Raspberry Pi projects we've come across use a custom interface. The MicroPython program developed for the Orange-Python is very small—small enough to be flashed onto the Pico and stored locally.  

The whole operation is powered by an RP2040 on a Raspberry Pi Pico. The only extra accessories you need are a keyboard, VGA monitor and something to supply power via microUSB.

When the Orange-Python system boots, it loads into a mode called Read Evaluate Print Loop (or REPL). This is an interactive interface that works like programming on an old BASIC computer. You can see it in action on Twitter. The team even managed to program a Tetris-style demo.

The DIY kit is planned to retail for $34, ideal for makers who want to assemble the Orange-Python themselves. Pre-built kits will be sold for around $50. Check out the Orange Pico Shop for more products and updates in this one.

7-segment displays, the kind found on old digital alarm clocks, can be great for Raspberry Pi projects, including those you make with Raspberry Pi Pico. You can use a 7-segment display to keep score in a game, show sensor data like temperature or distance numbers or to keep track of time. You can even show some letters.

There are many kinds of 7-segment displays on the market and they vary not only based on the number of digits and the color, but also on the controller board or lack thereof.  Some cheap 7-segment displays have no controller and use separate pins for every single light. When you consider that each digit has seven different lights (hence the name “7-segment display”), that’s a lot of pins. 

However, better 7-segment displays have controller boards which employ an I2C connection that uses just four pins, powered by a TM1637 controller board. Below, we’ll show you how to use one of these TM1637-powered 7-segment displays with a Raspberry Pi Pico.

What You’ll Need

• 7-segment display. There are so many models, but we used this one.
• Raspberry Pi Pico with soldered pin headers and MicroPython.
• Four female-to-female jumper cables

If you haven’t used your Pico before, see our article on how to set up a Raspberry Pi Pico and how to solder pins to your Raspberry Pico.   

How to Connect a 7-Segment Display to Raspberry Pi Pico

The 7-segment display has four pins: CLK, DIO, GND and VCC. If you use female-to-female jumper wires, you don’t need a breadboard to do the connections.

Connect the following pins from the 7-segment display to the PIco.

1. VCC pin to 3V3 on the Pico (physical pin 36, the fifth on the right side).
2. GND pin to GND on the Pico (physical pin 34, the third on the right side).
3. CLK pin to GP16 on the Pico (last pin on the right side).
4. DIO pin to GP17 on the Pico (next-to-last pin on the right side).

You could choose to connect the CLK and DIO pins to any two GPIO pins on the Pico which support I2C SCL and SDA respectively and you can connect the GND pin to any of the Pico’s 8 GND pins. See the Raspberry Pi Pico pinout for details.

How to Code a 7-Segment Display in MicroPython

We’re going to rely heavily on the excellent TM1637 MicroPython library from Mike Causer and create a script which shows a variety of display options, which you can use in your own projects later on. 

5. Download the tm1637.py file from Mike Causer’s TM1637 github project. You don’t need the other files. 

6. Copy tm1637.py to your Pico’s root directory. Since the Pico with MicroPython doesn’t appear as a drive letter, the easiest way to do this is to open tm1637.py in Thonny or the IDE or your choice and save it from there. 

7. Create a new MicroPython script in Thonny or the MicroPython IDE of your choice. 

8. Import the necessary libraries.

import tm1637from machine import Pinfrom utime import sleep

We will use the utime library to put a one-second “sleep” delay between each function so you have time to watch them on the display. 

9. Create an instance of the tm1637.TM1637 object called “mydisplay” and enter the correct pin numbers for the CLK and DIO pins as parameters.

mydisplay = tm1637.TM1637(clk=Pin(16), dio=Pin(17))

10. Use the “show” method to display any four characters. These can be letters or numbers, but note that many letters, W for example, will look awkward. If you enter more than four characters, only the first four will be shown. Be sure to put the parameter string in quotes.

mydisplay.show(“Pico”)sleep(1)

11. Blank the screen by using “show” with four blank spaces (assuming you have four digits on your screen).

mydisplay.show(“    “)sleep(1)

Note that if you don’t blank the display, it will remain on when your program is finished executing. You don’t need to blank the display when changing it, but if you use another show command with less than the maximum number of characters, any characters you don’t replace will stay on the screen. For example, if you do show(“halo”) and then show(“20”), the screen will read 20lo. 

12. Use the “number” method to show an integer. Do not put quotes around the parameter. You can display a negative or positive number, but if it’s a negative number, it has to reserve one character for the minus sign. Note that, if you enter a larger number than the available number of digits (ex: entering 12345 on four-digit display), the screen will read “9999” or “-999” for negative numbers.

mydisplay.number(-123)sleep(1)

Use the “numbers” method to show a time with the color visible. Enter two, two-digit numbers as parameters and the colon, provided your screen has one, will show in between them. This example will appear as 12:59.

13. Considering that you can use the “show” method to show numbers or letters, you might wonder why you’d want to employ the number method instead. One reason is that you don’t need to convert integers to strings and another is that the screen will only use the necessary amount of digits so you don’t need to enter blank spaces to align your number to the right.

mydisplay.numbers(12,59)sleep(1)

14. Adjust the brightness using the brightness method. You can enter a number that ranges from 0 (lowest) to 7 (highest) as the parameter.

#adjust the brightness to make it loewrmydisplay.brightness(0)sleep(1)

15. Use the “scroll” method to display scrolling text. Enter a string (in quotes) as the first parameter and add, “delay=” and a number of milliseconds to control the speed of the scroll. If you skip the delay parameter, it will default to 250ms.

mydisplay.scroll("Hello World 123", delay=200)sleep(1)

16. Use the “temperature” method to show a temperature in Celsius. This method adds the degree symbol and letter C after your digits. You enter either a one or two digit integer as the temperature and you can do negative temperatures but these can only be one digit.

mydisplay.temperature(99)sleep(1)

17. Blank the screen again so it doesn’t stay lit when the program is over.

mydisplay.show(“    “)

Here’s the final code

import tm1637from machine import Pinfrom utime import sleepmydisplay = tm1637.TM1637(clk=Pin(16), dio=Pin(17)) # Show a wordmydisplay.show("Pico")sleep(1) #blank the screenmydisplay.show("    ")sleep(1) #show numbersmydisplay.number(-123)sleep(1) #show a time with colonmydisplay.numbers(12,59)sleep(1) #adjust the brightness to make it loewrmydisplay.brightness(0)sleep(1) #show scrolling textmydisplay.scroll("Hello World 123", delay=200)sleep(1) #show temperaturemydisplay.temperature(99)sleep(1) #blank the screen againmydisplay.show("    ")

There are other methods that Causer documents on his github page, including one that will convert numbers to hexadecimal format for you or take hex input. However, these are the main methods we think most people will need to get use with a 7-segment display and Raspberry Pi Pico.

There are many reasons you might want to use an analog joystick in your Raspberry Pi Pico project. Perhaps you’re creating a game or maybe you need an input device for navigating. Whatever the case, connecting an analog stick to your Raspberry Pi Pico is really easy and coding for it in MicroPython is also a snap. 

What you’ll need 

• Raspberry Pi Pico with pins. See how to solder pins to Raspberry Pi Pico.
• Analog thumb joystick with 5-pin interface. There are many models. We used one of these.
• Breadboard (optional). You can also connect your joystick directly to the pins.
• Five jumper cables: female-to-female. If you’re using a breadboard, you’ll need female-to-male.

If you haven’t programmed your Pico before, see our tutorial on how to set up Raspberry Pi Pico. 

Wiring a Joystick to Raspberry Pi Pico

1. Wire the joystick’s 5 pins to the Pico as follows:

• GND to GND (Any GND pin)
• +5V to 3V3 Out (physical pin 36). Yes, a 5V joystick will work with the 3V3 power of Pico.
• VRx to GP27 / ADC1 (physical pin 32)
• VRy to GP26 / ADC0 (physical pin 31)
• SW to GP16 (physical pin 21). This would work with most of the GPIo pins.

Coding a Joystick in MicroPython for Raspberry Pi Pico 

An analog thumbstick is effectively three devices in one: a potentiometer for the X axis, a potentiometer for the Y axis and a digital momentary button when you press down. Below, we’ll write some simple code to help us see where the joystick is pointing. 

2. Start a blank program in your MicroPython IDE, most likely Thonny.

3. Import the necessary modules: Pin, ADC from machine and utime 

from machine import Pin, ADCimport utime

We’ll use the utime.sleep function later to put a necessary delay into a loop which reads the button state. 

4. Create xAxis and yAxis variables and assign them to the GP pins for each, 27 and 26. 

xAxis = ADC(Pin(27))yAxis = ADC(Pin(26))

5. Create a button variable and assign it to a Pin object. 

button = Pin(16,Pin.IN, Pin.PULL_UP)

Note that the Pin object has three arguments, the GP number, the mode (which is input in our case) and whether it has a pull-up or pull-down resistor (see resistor color codes to identify different types). We want it to be in input mode and pull up.  

6.  Create a continuous loop that checks and prints values for x, y and button.

while True:    xValue = xAxis.read_u16()    yValue = yAxis.read_u16()    buttonValue= button.value()    print(str(xValue) +", " + str(yValue) + " -- " + str(buttonValue))    utime.sleep(0.1)

7.  Run the code and observe the results in the MicroPython shell as you move the joystick and press the button. What you’ll likely see is that, if the joystick isn’t moved or pressed, the X and Y values will be around 32,000 to 33,000 and the button value will be 1. Moving to the left will put the X value in the 300 to 500 range and to the right will be around 65,000. Pointing up will put the 300 to 500 range and pointing down will be around 65,000. Pressing the button will give it a value of 0 while you hold it down.

8. Stop the execution and erase the print statement to save space. 

9. Create variables for the plain English status of X, Y and button. Place them within the loop and give them default values that an untouched joystick.

    xStatus = "middle"    yStatus = "middle"    buttonStatus = "not pressed"

10. Use if / then statements to correctly label the joystick and button status within the loop. 

 if xValue <= 600:        xStatus = "left"    elif xValue >= 60000:        xStatus = "right"    if yValue <= 600:        yStatus = "up"    elif yValue >= 60000:        yStatus = "down"    if buttonValue == 0:        buttonStatus = "pressed"

11.  Use a print statement to print the variables and place it above the sleep command.

print("X: " + xStatus + ", Y: " + yStatus + " -- button " + buttonStatus)

 Your final code should look like this: 

from machine import Pin, ADCimport utimexAxis = ADC(Pin(27))yAxis = ADC(Pin(26))button = Pin(16,Pin.IN, Pin.PULL_UP)while True:    xValue = xAxis.read_u16()    yValue = yAxis.read_u16()    buttonValue = button.value()    xStatus = "middle"    yStatus = "middle"    buttonStatus = "not pressed"    if xValue <= 600:        xStatus = "left"    elif xValue >= 60000:        xStatus = "right"    if yValue <= 600:        yStatus = "up"    elif yValue >= 60000:        yStatus = "down"    if buttonValue == 0:        buttonStatus = "pressed"    print("X: " + xStatus + ", Y: " + yStatus + " -- button " + buttonStatus)    utime.sleep(0.1)

Now that you know how to identify what your joystick is doing, you can incorporate it into your MicroPython programs for Raspberry Pi Pico. See our list of Raspberry Pi Pico tutorials for more ideas.