Getting Started with Interstate 75

Interstate 75 is a RP2040-powered driver board for HUB75-style panels - the LED matrix panels that you sometimes see making up big fancy billboards or scrolling LED signage. We've made it so it can slot tidily into the back of a panel, with minimal extra hardware required.

This tutorial will show you how to plug things in and how to start making things light up, and it includes basic getting started instructions for both MicroPython and CircuitPython.

What you'll need

  • An Interstate 75
  • A USB-C cable (for programming)
  • One (or more) RGB LED matrix panels
  • If your project involves multiple panels, lots of brightness or you just want to run it untethered from your computer, you'll need an external 5v power supply attached to Interstate 75's screw terminals. An easy way to breakout wires from a barrel jack power supply is with a screw terminal block (the kind with a socket).


You can power Interstate 75 and attached panels either through the screw terminals or (if you're drawing a modest amount of power) via the USB-C connector. LED matrix panels are hungry beasties - officially a 64x64 panel can consume up to 4 amps of electricity. Unofficially, you will probably get away with a lot less ampage than this if you're using it for things like displaying text or numbers and not driving the panels hard - we've had our clock and scrolling text examples running on four 64x64 panels from a 2A supply.

If your panels are in need of a power supply upgrade you might see glitching, flickering or find your Interstate 75 is constantly rebooting.

Connecting up one panel

For this tutorial, we're going to assume that you have a single panel and you're powering everything through the USB-C connector on Interstate 75. We've not had any problems powering a single panel from our computer, but if you want to ensure that your computer's expensive USB ports are protected from an excess of current, plug Interstate 75 into a powered hub or hook up an external 5V power supply to the screw terminals.

If your project involves multiple panels, it's probably a good idea to start off hooking up a single panel to make sure everything's working.

HUB75 panels have 16 pin data in and data out connectors on the back - you'll need to plug Interstate 75 into the data in connector. The backs of the panels should all have arrow markings which you can use to see the direction in which the data should be flowing through the panel.

Here are the backs of the panels we stock with the data in connector marked in red. Markings and layouts may vary slightly from batch to batch!

Four different sized LED panels with data in connectors labelled

Go ahead and plug the pre-soldered socket header on Interstate 75 into the data in connector on your panel. The data connector has a nubbin on one side of it so you can only plug it in one way.

Panel with Interstate 75 plugged in

Connecting the power cable

To power the panel, you'll need to connect the fork connectors on the red and black power cable that came with the panel to the screw connectors on Interstate 75, red to + and black to -. Make sure you have the polarity correct! Loosen up the screws and slot the fork in-between the screw and the metal post, then tighten up the screws and give the wires a little tug to check they're securely held in place.

Connecting the power cables to Interstate 75

The other end of the cable has a white plug on it - plug this to the power connector on your panel (marked 'power' on some panels, or just VCC and GND on others). The clippy part of this connector means it should also only go in one way round, though there's no harm in checking that the red wires go into VCC and the black wire is connected to GND.

Plugging the power cables into the panel

We've also attached the little magnetic feet that you get with the panel - they're useful if you want to stick your project to a metal surface like a noticeboard or your fridge.

Connecting up multiple panels

We're not going to go a huge amount of detail about chaining multiple panels in this tutorial but you can use the grey ribbon cables that come with the panels - just plug one end of this cable into the vacant data out connector on the first panel, and the other end into the data in connector of the next panel into the chain.

Each panel will need powering, so you'll either have to connect another fork connector to the screw terminals or come up with some sort of custom wiring harness arrangement, like the double ended cable power cable in the photo below. We used some bits of Lego and M3 12mm screws to fasten these two 64x64 panels together, which makes for a nice rigid join that would be easy to expand into a little stand.

Two 64x64 panels joined together

If you're using more than one panel we'd definitely recommend hooking up an external power supply whilst you program Interstate 75 (or disconnecting power from the panels), though modern computers and power supplies should have circuitry to protect themselves from USB over-current mishaps.


The LED matrix drivers in our C++/MicroPython build make use of RP2040's programmable IOs and DMA to update the LEDs quickly in the background, minimising CPU usage and maximising colour depth. Our library will let you set individual pixels to a RGB or HSV colour value (and we've included some examples of how to use these simple functions to do interesting things, like clocks and scrolling text).

Installing our custom MicroPython build

If you're brand new to Raspberry Pi Pico/RP2040s, you might find the step by step instructions in our Getting Started with Raspberry Pi Pico tutorial useful - it will show you how to install our custom MicroPython build and goes into more detail about how to use Thonny . Here's a quick TLDR!

  • Download the most recent MicroPython .uf2 from the Releases page of our pimoroni-pico Github repository (either version, with Blinka or without, will work).
  • Hold down the BOOT button of Interstate 75, and then press, and release, the RESET button. This will put it into bootloader mode, and it should appear as a drive on your computer called RPI-RP2.
  • Copy the .uf2 file to the RPI-RP2 drive - once you've done that Interstate 75 will reboot running Pirate brand MicroPython (it won't show up as a drive anymore).
  • Install Thonny
  • Open up Thonny. Make sure the interpreter (shown in the box on the bottom right corner) is set to 'MicroPython (Raspberry Pi Pico)'. If everything's working as it should look something like this. The flashing cursor next to the >>> in the 'Shell' box tells you that Interstate 75 is talking to your computer and is ready to accept instructions!

Screenshot of Thonny

Lighting up the onboard RGB LED

As a test that the board is working properly and you have the correct version of MicroPython installed, you can light up Interstate 75's onboard RGB LED red with the following code - you can enter it line by line in the REPL (that's the bottom 'Shell' box in Thonny) or copy and paste the whole thing into the top box and hit the green run button to save the code to your Interstate 75. If you choose to save it, you'll be prompted for a filename.

import hub75
from pimoroni import RGBLED

led = RGBLED(hub75.LED_R, hub75.LED_G, hub75.LED_B)

led.set_rgb(255, 0, 0)

The three numbers after set_rgb are an RGB (Red Green Blue) colour code, and each number should be between 0-255.

Running the examples

You can find the MicroPython examples here - the generic examples are good to start with as they don't need any dependencies. If you click on the raw button it makes it easy to copy and paste them into the top box in Thonny.

Some examples require or to be saved on your Interstate 75 - copy and paste 'em into Thonny and click Save As > Raspberry Pi Pico. Make sure you give them the same filename as they have on Github!

Lighting individual LEDs on the matrix

If you're new to matrices, and want to start from the basics we'd recommend playing around with the REPL to get to grips with things (that's the bottom box in Thonny, where you enter code line by line). First we need to take the red pill initialise the matrix. Here's how to do that for a 64 x 64 panel - enter the following code line by line, changing the width and height to match your panel size.

import hub75

WIDTH = 64

matrix = hub75.Hub75(WIDTH, HEIGHT)


To light a pixel in a particular colour, we have to do two things: first, we have to use the set_rgb function to specify which pixel we want to light and in what colour and, second, we have to use the flip() function to update the matrix and actually display the pixel that we set.

Pixels are organised by their x/y coordinates from the top left hand corner, so the top left pixel is 0, 0 and the bottom right pixel is 16, 6. Remember that, in Python, things are numbered from 0 rather than from 1.

The colours of pixels are specified by an RGB colour value. Each colour can be represented by mixing a particular amount of Red, Green, and Blue, from 0 to 255, meaning that you can get over 16 million different colours!! As an example, pure red is 255, 0, 0 and white is 255, 255, 255.

Let's light the top left pixel red. Type the following:

matrix.set_rgb(0, 0, 255, 0, 0)

To clear any pixels that you've set, you can use the clear() function, followed by flip():


Lighting all of the pixels using a for loop

To light all of the pixels, it's just a matter of repeating the process we just did once for each of the pixels. We can make this really quick and easy by using two for loops: one to loop through each column, and another to loop through each pixel in each of those columns.

This time, we'll light the pixels cyan, which is a mix of pure blue and pure green and so can be represented by the RGB colour 0, 255, 255.

Type the following (the four space indents are important, but Thonny should add them automatically):

for x in range(WIDTH):
    for y in range(HEIGHT):
        matrix.set_rgb(x, y, 0, 255, 255)

You might need to press enter twice to tell the interpreter you're done with your for loop and get the >>> prompt back. Then type:


Now we're going to add a while loop to make all the pixels blink pink. All we have to do is continuously light all of the pixels pink, using the technique we just learned, and clear them again, with a short delay, maybe a quarter of a second in between.

Type the following (we'll need to import time for this one, so here's the whole thing again):

import hub75
import time

WIDTH = 64

matrix = hub75.Hub75(WIDTH, HEIGHT)

while True:
    for x in range(WIDTH):
        for y in range(HEIGHT):
            matrix.set_rgb(x, y, 255, 0, 255)

Again, if you're using the REPL you might need to press enter twice to break out of the loop.

This is just the same as in the example where we made all of the pixels light in cyan, except we changed the RGB colour to 255, 0, 255 and we added a couple of lines to sleep for a quarter of a second - time.sleep(0.25) - and to clear all of the pixels - matrix.clear().

There are also functions in the library to set a pixel to a HSV value rather than a RGB value, and to remember colours so that the RP2040 doesn't have to calculate the colour value every time - using these can radically improve performance. Find them in the quick reference!

Using the buttons

Our MicroPython build includes shared helper functions to make it easy to use the buttons and onboard LED (you might be familiar with these if you've been playing with a Plasma 2040). This example makes the LED light up green when you press the A button, and blue when you press the BOOT button.

import hub75
from pimoroni import RGBLED, Button

led = RGBLED(hub75.LED_R, hub75.LED_G, hub75.LED_B)

button_a = Button(hub75.BUTTON_A)
button_boot = Button(hub75.BUTTON_USER)

led.set_rgb(0, 0, 0)

while True:
        led.set_rgb(0, 255, 0)
        led.set_rgb(0, 0, 255)


If you're getting a weird, glitchy top row on your matrix or if the right LEDs aren't lighting up, try initialising your matrix like this:

matrix = hub75.Hub75(WIDTH, HEIGHT, stb_invert=True)

If your matrix isn't lighting up at all when you run the examples (and if you aren't getting any errors in Thonny), first double check that Interstate 75 is plugged into the data in connector on your matrix. If it is, it might be worth giving this option a go - we found a few 64 x 64 panels with a non-standard FM6216A chip that require different register settings to work.

matrix = hub75.Hub75(WIDTH, HEIGHT, panel_type=hub75.PANEL_FM6126A)


CircuitPython drivers are designed to work on a bunch of different microcontrollers so you won't get the fancy RP2040-architecture specific tweaks that you'll find in our library. You will get access to Adafruit's mighty DisplayIO library though, which gives you lots of tools for displaying all sorts of different kinds of text, shapes and even simple images.

Installing CircuitPython and libraries

To install CircuitPython -

  • Download the Interstate 75 CircuitPython .uf2. You'll probably also need the CircuitPython driver bundle (be sure to grab the one that matches the version of CircuitPython that you just downloaded)

  • Hold down the BOOT button of Interstate 75, and then press, and release, the RESET button. This will put it into bootloader mode, and it should appear as a drive on your computer called RPI-RP2.

  • Copy the CircuitPython .uf2 to the RPI-RP2 drive. After a few seconds, it should reappear as a drive called CIRCUITPY.

  • With CircuitPython, you always save your code as, and it will run automatically. You don't need to use Thonny, you can edit with any text editor. Using Mu as your editor is handy though, as it lets you view the serial console which can be useful for debugging error messages.

Running the examples

You can find some RGB matrix code examples in RGB LED Matrices with CircuitPython. To use them with Interstate 75, just point them at the right pins when initialising your matrix object , like this:

32 x 32 or 32 x 64 matrix

matrix = rgbmatrix.RGBMatrix(
    width=64, height=32, bit_depth=6,
    rgb_pins=[board.R0, board.G0, board.B0, board.R1, board.G1, board.B1],
    addr_pins=[board.ROW_A, board.ROW_B, board.ROW_C, board.ROW_D],
    clock_pin=board.CLK, latch_pin=board.LAT, output_enable_pin=board.OE)

64 x 64 matrix

matrix = rgbmatrix.RGBMatrix(
    width=64, height=64, bit_depth=6,
    rgb_pins=[board.R0, board.G0, board.B0, board.R1, board.G1, board.B1],
    addr_pins=[board.ROW_A, board.ROW_B, board.ROW_C, board.ROW_D, board.ROW_E],
    clock_pin=board.CLK, latch_pin=board.LAT, output_enable_pin=board.OE)

Using the buttons and LED

Here's a quick example of how to use Interstate 75's buttons and RGB LED in CircuitPython (you'll need to grab and simpleio.mpy from the library bundle and pop them in your lib folder on CIRCUITPY).

import board
import digitalio
import adafruit_rgbled
import busio

button_boot = digitalio.DigitalInOut(board.USER_SW)
button_boot.direction = digitalio.Direction.INPUT
button_boot.pull = digitalio.Pull.UP

button_a = digitalio.DigitalInOut(board.SW_A)
button_a.direction = digitalio.Direction.INPUT
button_a.pull = digitalio.Pull.UP

led = adafruit_rgbled.RGBLED(board.LED_R, board.LED_G, board.LED_B, invert_pwm = True)

def button_read(button):
    return not button.value

while True:
    if button_read(button_a):
        led.color = (0, 255, 0)
    if button_read(button_boot):
        led.color = (0, 0, 255)

Next steps

Now that you know how to drive an LED matrix with a RP2040, how about hooking up a Breakout Garden breakout and using it to display sensor data, like temperature and humidity? You could attach an encoder and make an RGB Etch-A-Sketch. Or a real-time clock so that your giant holiday countdown timer keeps track of time when it's powered off?

That's all folks!

Search above to find more great tutorials and guides.

Plasma 2040

Swathe everything in rainbows with this all-in-one, USB-C powered controller for WS2812/Neopixel and APA102/Dotstar addressable LED strip.