BigClive-alike "SuperComputer Panel Display", Software Version

I like the so-called SuperComputer Panel, that BigClive has on some of his youtube videos.

I don't have the hardware to make a real analogue one, so I had a take at a software version, well at 3 versions actually.

One version using an ESP8266 with a built-in OLED Display

One is using an Arduino driving a MAX7219 led matrix driver.

And the third one is purely software, implemented as a Processing sketch.

The idea is to have an array of blinking pixels/leds that are randomly slightly desychronized at each refersh. After about 30s the illusion is quite satisfying to me.

Supplies

You'll need:

Either an ESP8266 board with a built-in OLED display, or any Arduino or common microcontroller depending on the version you want.
If you go for a MCU version you'll need:
a 8x8 LED Matrix and a MAX7219 led driver. There are boards on Aliexpress that bundle both together, so that you don't have to wire the led matrix by yourself.
a 10KOhms resistor (LOAD pin pull-up)

Unfortunately I did not take any photo when wiring the led matrix. Anyway, it's a matter of wiring the columns to the SEGment output and lines to the DIGit outputs, with the decimal point wired to the first column.

There are lots of tutorials about this online.

ESP8266 With Built-in OLED Display

The sketch is using the Adafruit SSD1306 library to drive the OLED Display.

It's using 3 arrays to track the pixels state and their on/off time

bool bits[32][32]; // display cells states

uint32_t on_time[32][32]; // state change trackers

uint32_t off_time[32][32];

The heart of the sketch is the process_bits() function that iterates over the cells and change their states.

Each time a cell is turned on/off a random delay is added/substracted to the cell's period.

This delay was set by trial and error.

With the current setting, all cells start synchronized and start to diverge quickly.

After about 30s, the illusion of an old Super Computer Panel is set and the pixels seem to light rather randomly but with some kind of running patterns.

// turn bits on and off with random shifting

// causing them to desynchronize after some time

// producing the "random light panel" effet

void process_bits()

{

for (int y = 0; y < 32; y++)

{

for (int x = 0; x < 32; x++)

{

uint32_t now = micros64();

uint32_t randomized_period = PERIOD + random(RANDROM_SHIFT) - random(RANDROM_SHIFT);

if (bits[x][y])

{ // bit at 1

if (now - on_time[x][y] > randomized_period)

{

bits[x][y] = false;

off_time[x][y] = now;

}

else

{ // bit at 0

if (now - off_time[x][y] > randomized_period * 1.5)

{

bits[x][y] = true;

on_time[x][y] = now;

}

The display_bits() iterates over the bit array and draws the pixels.

These are actually 4x4 filled rectangles in order to resemble actual LED/Lamps.

(I could optimize the bits array, I know, I just didn't, after making the pixels bigger).

The code is avalailable here.

This was a fun week-end project!

But then I remembered that I had an old 8x8 LED Matrix and a MAX7219 collecting dust in a drawer...

LED Matrix Version With Arduino (or Any Other MCU)

So I wired-up the 8x8 LED Matrix to the MAX7219.

The sketch is using the wayoda/LedControl library to drive the MAX7219.

It's pretty straightforward to use.

The display_bits() function was rewritten to to LedControl's setLed() function and the bits and on/off times array were reduced to 8x8.

The effect is even nicer on a real physical display such as a LED Matrix.

I might make a bigger one some day.

The code archive is available here.

Demo Video

BigClive's SuperComputer panel - software version

Here is a Demo Video

Processing Version

I also implemented a version purely in software, just for fun and because I like the Processing creative coding environment.

It's also in the same git repo.