Raspberry Pi Pico Iron Man Arc Reactor

In this tutorial we’ll use a Raspberry Pi Pico to control 31 individually addressable LED lights mounted between two discs of acrylic plastic. One of those discs will have a layer of adhesive mirror sheet and the other will have a one-way mirror film; this will give the LEDs a 3D infinity effect. Unfortunately, we haven’t yet perfected our own plasma fusion power source at Raspberry Pi, so instead we will use a rechargeable battery and enclose everything in a 3D-printed case.

This list will help you locate everything you need from your favourite online retailer.

As part of the initial setup, you will also need:

To begin, flash the Pico with firmware using the drag-and-drop method to transfer files. This works just like transferring files to a USB memory stick.

On your computer, download the UF2 file for the latest release of the Pico MicroPython firmware from micropython.org/download/rp2-pico/. The MicroPython programming language is an implementation of Python optimised for use with microcontrollers.

To copy the UF2 file you’ve just downloaded over to your Pico, you need to put it into bootloader mode. Hold down the BOOTSEL button (the small button next to the USB port) while simultaneously plugging a micro USB cable connected to your Pico into your usual computer. Your Pico should now show up as a drive called RPI-RP2:

Drag and drop the .uf2 firmware file that you just downloaded into the RPI-RP2 drive. Your Pico will now reboot automatically. Once you’ve done this, the next time you plug in your Pico, it won’t show up as a drive. But leave the Pico connected for now.

Download, install, and open Thonny, a Python IDE (Integrated Development Environment). It’s the software you’ll use on your computer to program your Pico. With your Pico still connected, Thonny should look like this:

If you see >>> in the Shell window, then you’re already connected to your Pico and have an interactive session enabled. This means you’re ready to program your Pico.

If you don’t see >>> in the Shell window, check that Thonny is set up correctly:

Now you’re ready to program your Pico. Copy and paste the following into the empty <untitled> Thonny program window:

import array, time
from machine import Pin
import rp2

# Configure the number of WS2812 LEDs.
NUM_LEDS = 31
PIN_NUM = 28
brightness = 1

@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW, out_shiftdir=rp2.PIO.SHIFT_LEFT, autopull=True, pull_thresh=24)
def ws2812():
    T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)
[T3 - 1]
    jmp(not_x, "do_zero")   .side(1)
[T1 - 1]
    jmp("bitloop")          .side(1)
[T2 - 1]
    label("do_zero")
    nop()                   .side(0)
[T2 - 1]
    wrap()# Create the StateMachine with the ws2812 program, outputting on pin
sm = rp2.StateMachine(0, ws2812, freq=8_000_000, sideset_base=Pin(PIN_NUM))

# Start the StateMachine, it will wait for data on its FIFO.
sm.active(1)

# Display a pattern on the LEDs via an array of LED RGB values.
ar = array.array("I",
[0 for _ in range(NUM_LEDS)])

##########################################################################
def pixels_show():
    dimmer_ar = array.array("I",
[0 for _ in range(NUM_LEDS)])
    for i,c in enumerate(ar):
        r = int(((c >> 8)
& 0xFF) * brightness)
        g = int(((c >> 16)
& 0xFF) * brightness)
        b = int((c
& 0xFF) * brightness)
        dimmer_ar
[i] = (g<<16) + (r<<8) + b
    sm.put(dimmer_ar, 8)
    time.sleep_ms(10)

def pixels_set(i, color):
    ar
[i] = (color
[1]<<16) + (color
[0]<<8) + color
[2]

def pixels_fill(color):
    for i in range(len(ar)):
        pixels_set(i, color)

def color_chase(color, wait):
    for i in range(NUM_LEDS):
        pixels_set(i, color)
        time.sleep(wait)
        pixels_show()
    time.sleep(0.2)

def wheel(pos):
    # Input a value 0 to 255 to get a color value.
    # The colours are a transition r - g - b - back to r.
    if pos < 0 or pos > 255:
        return (0, 0, 0)
    if pos < 85:
        return (255 - pos * 3, pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (0, 255 - pos * 3, pos * 3)
    pos -= 170
    return (pos * 3, 0, 255 - pos * 3)


def rainbow_cycle(wait):
    for j in range(255):
        for i in range(NUM_LEDS):
            rc_index = (i * 256 // NUM_LEDS) + j
            pixels_set(i, wheel(rc_index
& 255))
        pixels_show()
        time.sleep(wait)

BLACK = (0, 0, 0)
RED = (255, 0, 0)
YELLOW = (255, 150, 0)
GREEN = (0, 255, 0)
CYAN = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (180, 0, 255)
WHITE = (255, 255, 255)
COLORS = (BLACK, RED, YELLOW, GREEN, CYAN, BLUE, PURPLE, WHITE)while True:

    print("fills")
    for color in COLORS:
        pixels_fill(color)
        pixels_show()
        time.sleep(0.2)

    print("chases")
    for color in COLORS:
        color_chase(color, 0.01)

    print("rainbow")
    rainbow_cycle(0)

Thonny should now look like this:

One of the advantages of MicroPython is that much of it is readable English. For example, at the beginning of this program, we can see that Pico will control 31 LEDs via pin 28 and that they are to be set at maximum brightness (1 on a 0-1 scale where 0.5 is 50% brightness). The rest of the program instructs your Pico to display patterns and colours on the LEDs repeatedly.

Select File > Save as…​:

A prompt will appear asking you to specify where you want to save the file:

Click on Raspberry Pi Pico and enter the file name main.py:

It’s important to name the file main.py because Pico runs any file with this name automatically after booting. Congratulations: you’ve programmed your Pico!

Don’t forget to insulate your joins with heat shrink tubing or tape!

Before you glue the pieces together and make it final, check that everything is working as expected and that your LEDs are lighting up by sliding the switch. Check that the charging board functions by attaching a USB-C charger or battery pack: a small LED should illuminate when it’s charging.

Finally, glue the parts together.

Congratulations. You have finished assembling your Arc Reactor!

Upgrades! Everyone enjoys an upgrade, especially Iron Man. Why not use a Raspberry Pi Pico W running a webserver to control your LEDs wirelessly from a browser on your smartphone? Or you could add a touch of paint and stick some velcro to the back of the reactor so that you can wear it on your chest like Tony Stark.