Displays
The project began with a tray of small MD0657C2-R displays I found in a surplus shop at a very low price.

To begin, I needed a way to drive those displays. I decided to use the MAX6952 chip: it's a bit pricey, but it can drive up to four displays at once and can be daisy-chained.
I created a simple PCB using the reference design from the datasheet, added a pair of pins for power and data, and had them manufactured using standard options.



Soldering was challenging. I ordered the SSOP variant of the MAX6952, which has very small pins, too small for (my) hand-soldering.
Fortunately, soldering flux turned out to be very effective. I had never used it before, but it allowed me to solder everything correctly on the first try :)


Using a Raspberry Pi Pico and some quick code, I started sending the required signals to the MAX6952, and it worked °o°

However, I discovered that I had placed the four displays on the PCB with no margin between them. This isn't a critical issue (since it's possible to create custom characters), but for text display purposes, the lack of spacing causes a loss of one column of pixels/LEDs between displays. Ideally, I should have left some space.
Panels
I wanted aesthetically pleasing backlit panels, inspired by this video or this project, so I took a similar approach.
I used semi-transparent acrylic panels, sprayed them with black paint, and let it dry. Then, I laser-cut the panel and etched the paint in a single pass.

As some tutorials suggested, it's probably best to do the laser cutting first, then paint and etch, to avoid burning residue on the paint. However, I had limited access to the laser cutter and didn't want to have alignments issues, so I chose the faster approach. At the end, the marks are only visible under certain lighting conditions.

The laser cutter software was probably the worst I’ve ever used. It took hours to get designs imported and cut correctly. Most of the time wasn’t spent cutting or etching, but manually fixing imported files for mistakes and missing elements.
I designed two panel types, both with the same dimensions:
- The first type shows a datacenter link with the name and provider - just basic shapes and text.
- The second one shows a map of datacenter locations, created manually by tracing borders over a real map background in Inkscape.

To mount the display behind the panel, I quickly designed a 3D-printed connector that holds everything in place via friction.
Finally, I added black tape to prevent backlight from bleeding through the displays - et voilà :)


Frame
Structure
The frame consists of wooden pieces cut to length and a laser-cut wooden top that aligns with the panels and includes mounting holes.
I also added internal dividers to isolate the light between each panel.
Everything is just glued or screwed together.



I should have left more margin on the wood structure for the panel, some light is leaking, but it it's fine.
Backlight
For the backlight, I used LED rings from, ordered alongside the display PCBs. These use 5050 WS2812 LEDs, which are individually addressable and can be controlled for brightness and color using common LED libraries.

Displays
The displays are also daisy-chained, with two displays per panel, one for each direction of bandwidth.
That’s when I discovered another problem: chaining more than four displays didn’t work reliably.
I suspect the Raspberry Pi Pico couldn't drive the CLK/CS lines properly across longer wires. There are probably proper ways to solve this, but I opted for a simpler workaround: I ordered five more Raspberry Pi Picos, each driving just two displays, and connected them using a basic serial relay system.
At this point we now have the final architecture:

Software
Relays Raspberry Pico
Each relay Pico is simple: it has a UART input (from the previous Pico or main Pico) and a UART output (to the next one).
It reads the input, writes it directly to the output, and also stores it in a buffer.
The command format includes:
- A start pattern
- A target ID (or 0xFF to broadcast to all)
- Four bytes for the MAX6952 (which accepts 4-byte instructions)
A packet looks like that:
0x42 0x24 0x77 0x41 0x12 0x21 [ID] [D1] [D2] [D3] [D4]
If the buffer exceeds 11 bytes, the relay checks for the start pattern. If not found, it drops the first byte—this helps recover in case of noise or desynchronization.
If the pattern is found and the ID matches the relay's ID (or is 0xFF), the data bytes are sent to the MAX6952.
Main Raspberry Pi Pico W
The main Pico handles most of the system logic:
- It initializes the LEDs using the NeoPixel library.
- It sends initialization commands to each MAX6952, including uploading custom fonts to compensate for the missing gaps between displays. This takes time, so it uses broadcast commands to update all MAX6952 chips simultaneously through the relays.
- It then connects to the data source and updates values in real time.
If a link is marked down, the LED color for the corresponding panel changes, and a special font is sent to the display to show a “link down” message. When the link comes back up, the original font is restored.
Fetching data
To show live data, I decided to use MQTT. This gave me instant updates and better security: the map only needs access to a public MQTT server - not direct access to the internal monitoring system.

I wrote a small script that averages the last 5 minutes of data from our monitoring system (which tracks the switches). It gathers traffic stats for all inter-datacenter interfaces and pushes them to the MQTT server.
The main Raspberry Pi Pico subscribes to a livemap topic on the server. When new data arrives, the relevant display is updated immediately.



