DR-0001

1U Rackmount for Raspberry Pi 5

• Purchase URL: [ https://52pi.com ] or [ https://deskpi.com ]

Description

This is an upgraded version of a 1U Rackmount designed for compatibility with both Raspberry Pi 5 . It features a motherboard that supports PCIe expansion, allowing the PCIe interface of the Raspberry Pi 5 to be extended to accommodate an M.2 NVMe SSD in 2230/2242/2260/2280 form factors. The expansion board also routes the Raspberry Pi's 5V and GND, SDA, and SCL pins to the rear through PogoPin connectors, providing I2C interface peripherals in a Grove format. Additionally, a red LED is included on the board for the Raspberry Pi ID signal pin, which can be programmed to indicate the current device by controlling the GPIO4 pin's high or low level, acting as a programmable device ID signal light.

The Rackmount supports the connection of up to five Raspberry Pi devices and can also be configured with an OLED display frame in place of one of the Raspberry Pi slots. These components can be easily adjusted and removed due to the use of hand-tightened screws. The OLED display features a 0.91-inch screen and communicates with the Raspberry Pi via I2C protocol, displaying real-time information such as CPU status, memory status, IP information, and serial numbers. The content displayed on the OLED can be fully customized.

Features

• Compatibility: Designed to work with both Raspberry Pi 5.
• PCIe Expansion Support: Includes a motherboard that enables PCIe expansion, allowing the connection of M.2 NVMe SSDs in various form factors (2230/2242/2260/2280).
• I2C Interface: The board routes the Raspberry Pi's 5V, GND, SDA, and SCL pins to the rear through PogoPin connectors, offering I2C interface peripherals in a Grove format.
• Programmable LED Indicator: A red LED on the board serves as a programmable device ID signal, controllable via the GPIO4 pin to indicate the status or identity of the device.
• Modular Design: Supports the integration of up to five Raspberry Pi devices, with the option to replace one slot with an OLED display frame.
• OLED Display Integration: The option to include a 0.91-inch OLED screen that communicates with the Raspberry Pi via I2C, displaying customizable information such as CPU usage, memory status, IP address, and serial numbers.
• Easy Assembly and Disassembly: Components are secured with hand-tightened screws, allowing for convenient adjustments and removal.
• Customizable Display Content: The information displayed on the OLED screen can be fully customized to meet specific needs or preferences.
• Rackmount Form Factor: Designed to fit into a 1U rack space, making it suitable for data centers or other environments where space is at a premium.
• Versatility: The Rackmount can be configured in various ways to suit different use cases, whether for development, testing, or deployment in a production environment.

Specifications

• Form Factor: 1U Rackmount design suitable for standard 19-inch racks.
• Raspberry Pi Compatibility: Specifically designed for Raspberry Pi 5.
• PCIe Expansion:Supports M.2 NVMe SSDs in 2230, 2242, 2260, and 2280 form factors. Provides a PCIe interface for high-speed data transfer.
• I/O Connectivity: Rear I2C interface via PogoPin connectors for external peripherals.
• GPIO4 pin for programmable LED control.
• LED Indicator:Red LED for device identification or status indication. Programmable through software to show different statuses.
• Modular Bays: Five bays for Raspberry Pi devices. One bay can be replaced with an OLED display module.
• OLED Display Specifications:0.91-inch screen size, 128x32 pixels. I2C communication protocol.
• Customizable display for system information.
• Physical Security:Hand-tightened screws for secure mounting of Raspberry Pi devices and OLED display.
• Ensures stability and ease of maintenance.
• Power Requirements: Compatibility with Raspberry Pi's standard power supply.
• Material and Construction: Durable metal construction for the rackmount chassis. High-quality components for reliable performance.
• Mounting Options: Standard rackmount holes for easy installation into a rack.
• Includes additional mounting accessories for different setups.
• Software Compatibility: Compatible with Raspberry Pi's operating system and software ecosystem.
• Support for GPIO programming for custom LED and device control.

Gallery

• Product outlook

• Application Senario

NOTE: Raspberry Pis are not included in the package, additional purchase required!

• Easy to assemble and maintain

• Customizable OLED display screen, with a size of 0.91 inches

• Ports Definitions and Featrues

Programmable I/O controlled UID indicator light, which can be programmed to control the LED blinking to indicate the device's location, facilitating faster troubleshooting and easier maintenance operations.

How to connect OLED display to Raspberry Pi on GPIO pins

• Please refer to following figure to connect OLED display to Raspberry Pi on GPIO.

NOTE: OLED's VCC should be connected to 3.3V power rail, Do not connect it to 5V power rail!!!

• Grove Connector Support I2C and Uart

• Accessories Dimension

• OLED assemble details

Please remove the protection film from acrylic panel and use the washer between OLED PCB board and acrylic panel.

• PCIe Expansion board for Raspberry Pi 5 only

The expansion board supports M.2 NVMe M-key SSD 2230/2242/2260/2280, and the board will be powered by Raspberry Pi 5 via PogoPin on the PCB board, please make sure the board's pogoins are contact well with the soldering point on back of the Raspberry Pi 5 on GPIO pins.

How to assemble it?

• Please note that there are several details you need to pay attention, plesae check out following figure.

Package Includes

• Following figure shows the details of the product:

How to enable I2C OLED display?

• We assume that you are using Raspberry Pi OS 64bit(bookworm, the latest official image)

To enable I2C and UART on your Raspberry Pi, you can follow these detailed steps:

Enabling I2C

• Method 1. Using the Raspberry Pi Configuration Tool:

 
sudo raspi-config

to open the configuration tool. Navigate to `Interface Options`, Select `I2C` and enable it.

• Method 2. Using the Command Line:

You can also enable I2C by editing the `/boot/firmware/config.txt` file and adding `dtparam=i2c_arm=on` if it's not already present, After making changes, reboot your Pi.

Verifying I2C

• Install I2C tools using `sudo apt-get install -y i2c-tools`.
• Use

i2cdetect -y 1

to scan for I2C devices, if you see `3c` means that the OLED display has been recognized by your Raspberry Pi.

Enabling UART

• Method 1. Using the Raspberry Pi Configuration Tool:

sudo raspi-config

Go to `Interface Options`, Select `Serial` and enable it.

 Note: This will also enable the login shell on the serial port. 

• Method 2. Using the Command Line:

Edit `/boot/config.txt` and add `enable_uart=1`, save it and then reboot your Pi.

Accessing UART

• Connect your Pi to a USB-to-TTL converter, On Windows, you may need to install drivers for the converter. on Linux just use a terminal program like `minicom`, `putty`, or `screen` to access the UART interface.

Remember to check the documentation for your specific Raspberry Pi model, as the steps might vary slightly. If you need more detailed instructions or encounter any issues, refer to the [ https://www.raspberrypi.org/documentation/ ] or community forums for additional support.

How to display customized information on OLED display?

• Final result

How to customize content on OLED ?

• For example: If you want to display current IP address of wlan interface and the serial number of your Raspberry Pi 5, please follow next steps to configure it.

Install Virtal environment package

• Open a terminal and typing following commands:

 
sudo apt update 
sudo apt upgrade -y 
sudo apt -y install virtualenv 
sudo usermod -a -G i2c,spi,gpio pi
sudo apt install python3-dev python3-pip python3-numpy libfreetype6-dev libjpeg-dev build-essential
sudo apt install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libportmidi-dev

Create virtual environment

virtualenv -p python3 venv 
cd venv/
source bin/activate 

Install SSD1306 driver and library for OLED 0.91

pip install luma.oled
pip install psutil

Clone luma.examples repository

Log out and in again and clone this repository:

git clone https://github.com/rm-hull/luma.examples.git
cd luma.examples/

Install luma libraries

sudo -H pip install -e . --break-system-packages  

Test the demo

cd examples/
sudo python 3d_box.py --width=128 --height=32 -r 2 

NOTE:
--width=128 and --height=32 should be added to declear the OLED's resolution information.
-r 2 means --rotate 2 , Allowed values are: 0, 1, 2, 3 (default:0)

If you see a 3D-box rotating animation is in the middle of screen means that you have installed the OLED driver successfully!

and then press "Ctrol+C" abort the demo.

Use the demo code

• There are a lot of demo codes in the examples folder, you can test it as you want.

for example:

sudo python carousel.py --width=128 --height=32 -r 2 

It will display all information of your Raspberry Pi 5 and scrolling display.

Customize the display on screen

Modify the sys_info.py python file and adding your own function to show the information you want, do remember backup the origin file.

cp sys_info.py sys_info.py.bak 
vim.tiny sys_info.py 

Press 'i' to insert mode, and paste following lines into it. you can modify this file by other text editor what you like.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2014-2022 Richard Hull and contributors
# See LICENSE.rst for details.
# PYTHON_ARGCOMPLETE_OK

"""
Display basic system information.

Needs psutil (+ dependencies) installed::

  $ sudo apt-get install python-dev
  $ sudo -H pip install psutil
"""

import os
import sys
import time
from pathlib import Path
from datetime import datetime
import subprocess as sp

if os.name != 'posix':
    sys.exit(f'{os.name} platform is not supported')

from demo_opts import get_device
from luma.core.render import canvas
from PIL import ImageFont

try:
    import psutil
except ImportError:
    print("The psutil library was not found. Run 'sudo -H pip install psutil' to install it.")
    sys.exit()


# TODO: custom font bitmaps for up/down arrows
# TODO: Load histogram


def bytes2human(n):
    """
    >>> bytes2human(10000)
    '9K'
    >>> bytes2human(100001221)
    '95M'
    """
    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
    prefix = {}
    for i, s in enumerate(symbols):
        prefix[s] = 1 << (i + 1) * 10
    for s in reversed(symbols):
        if n >= prefix[s]:
            value = int(float(n) / prefix[s])
            return '%s%s' % (value, s)
    return f"{n}B"


def cpu_usage():
    # load average, uptime
    uptime = datetime.now() - datetime.fromtimestamp(psutil.boot_time())
    #av1, av2, av3 = os.getloadavg()
    #return "Ld:%.1f %.1f %.1f Up: %s" \
    #    % (av1, av2, av3, str(uptime).split('.')[0])
    return "Up: %s" % (str(uptime).split('.')[0])


def mem_usage():
    usage = psutil.virtual_memory()
    return "Mem: %s %.0f%%" \
        % (bytes2human(usage.used), 100 - usage.percent)

def disk_usage(dir):
    usage = psutil.disk_usage(dir)
    return "SD:  %s %.0f%%" \
        % (bytes2human(usage.used), usage.percent)


def network(iface):
    stat = psutil.net_io_counters(pernic=True)[iface]
    return "%s: Tx%s, Rx%s" % \
           (iface, bytes2human(stat.bytes_sent), bytes2human(stat.bytes_recv))

def mem_usage():
    usage = psutil.virtual_memory()
    return "Mem: %s %.0f%%" \
        % (bytes2human(usage.used), 100 - usage.percent)


def disk_usage(dir):
    usage = psutil.disk_usage(dir)
    return "SD:  %s %.0f%%" \
        % (bytes2human(usage.used), usage.percent)


def network(iface):
    stat = psutil.net_io_counters(pernic=True)[iface]
    return "%s: Tx%s, Rx%s" % \
           (iface, bytes2human(stat.bytes_sent), bytes2human(stat.bytes_recv))


def get_ip_address():
    ip = sp.getoutput('hostname -I')
    return "IP: %s" % ip

def get_id():
    id_of_pi = sp.getoutput("cat /proc/cpuinfo | grep -i serial| awk -F: '{print $2}'|xargs")
    return "%s" % id_of_pi


def stats(device):
    # use custom font
    font_path = str(Path(__file__).resolve().parent.joinpath('fonts', 'C&C Red Alert [INET].ttf'))
    #font_path = str(Path(__file__).resolve().parent.joinpath('fonts', 'DejaVuSansMono.ttf'))
    font2 = ImageFont.truetype(font_path, 15)

    with canvas(device) as draw:
        # draw.text((0, 0), cpu_usage(), font=font2, fill="white")
        draw.text((0, 0), get_id(), font=font2, fill="white")
        if device.height >= 32:
            #draw.text((0, 11), mem_usage(), font=font2, fill="white")
            #draw.text((0, 16), disk_usage('/'), font=font2, fill="white")
            draw.text((0, 16), get_ip_address(), font=font2, fill="white")

        if device.height >= 64:
            draw.text((0, 26), disk_usage('/'), font=font2, fill="white")
            try:
                draw.text((0, 38), network('wlan0'), font=font2, fill="white")
            except KeyError:
                # no wifi enabled/available
                pass


def main():
    while True:
        stats(device)
        time.sleep(5)


if __name__ == "__main__":
    try:
        device = get_device()
        main()
    except KeyboardInterrupt:
        pass

Here let me explain to you what i did.

• adding " import subprocess as sp", this will help me to execute some shell command in OS.
• adding following parts:

def get_ip_address():
    ip = sp.getoutput('hostname -I')
    return "IP: %s" % ip

def get_id():
    id_of_pi = sp.getoutput("cat /proc/cpuinfo | grep -i serial| awk -F: '{print $2}'|xargs")
    return "%s" % id_of_pi

• get_ip_address will execute the command "hostname -I" in system and grab the IP address and return it to main process.
• get_id is to read /proc/cpuinfo file and grab the serial number and return to main process.

Use custom font

   font_path = str(Path(__file__).resolve().parent.joinpath('fonts', 'C&C Red Alert [INET].ttf'))
   font2 = ImageFont.truetype(font_path, 15)   # change font size to 15. 

Modify the draw function

  with canvas(device) as draw:
        # draw.text((0, 0), cpu_usage(), font=font2, fill="white")
        draw.text((0, 0), get_id(), font=font2, fill="white")         #####　draw id on screen at (0,0) position, (x,y)
        if device.height >= 32:
            #draw.text((0, 11), mem_usage(), font=font2, fill="white")
            #draw.text((0, 16), disk_usage('/'), font=font2, fill="white")
            draw.text((0, 16), get_ip_address(), font=font2, fill="white")   ####　draw text on (0,16) with IP address. 

How to create a systemd file to make it automatically start at boot up

• Step1. create a shell script called it 'start_led.sh'

#!/bin/bash
#
cd /home/pi/venv/ && source /home/pi/venv/bin/activate 
/usr/bin/python3 /home/pi/luma.examples/examples/sys_info.py --width=128 --height=32 -r 2 

save it and grant executable permission and test it.

chmod +x start_led.sh 
./start_led.sh

If if works properly, just press "ctrol+c" to abort the test.

• Step2. create a systemd file and enable it.

sudo vim.tiny /etc/systemd/system/rackmount_oled.service

And then, adding following lines:

[Unit]
Description=Rackmount OLED service on RPi5
DefaultDependencies=no
StartLimitIntervalSec=60
StartLimitBurst=5

[Service]
Type=simple
ExecStart=/bin/bash /home/pi/start_led.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

Save it and quit.

Enable rackmount_oled.service

• reload daemon

sudo systemctl daemon-reload

• Enable service

 
sudo systemctl enable rackmount_oled.service 

• Start service

sudo systemctl start rackmount_oled.service

• Restart service

sudo systemctl restart rackmount_oled.service 

• Stop service

sudo systemctl stop rackmount_oled.service

• Disable service

sudo systemctl disable rackmount_oled.service 

How to enable PCIe function on Raspberry Pi 5?

• To enable PCIe functionality on the Raspberry Pi 5, follow these steps:

1. Enable the PCIe External Connector:

By default, the PCIe connector on the Raspberry Pi 5 is not enabled. To enable it, you need to add a configuration parameter to the `config.txt` file located in the `/boot/firmware` directory. You can use either of these lines:

dtparam=pciex1

After adding the line, reboot your Raspberry Pi for the changes to take effect.

2.Enable PCIe Gen 3.0 (Optional):

The Raspberry Pi 5's PCIe connection is certified for Gen 2.0 speeds. However, if you want to attempt using Gen 3.0 speeds, add the following line to the `config.txt` file as well:

dtparam=pciex1_gen=3

Be aware that the Raspberry Pi 5 is not certified for Gen 3.0 speeds, and using this setting may result in instability .

3.Booting from PCIe:

If you intend to boot from a device connected via PCIe, such as an NVMe SSD, you will need to modify the boot order in the EEPROM. Use the following command to edit the EEPROM configuration:

sudo apt update 
sudo apt upgrade -y 
sudo rpi-eeprom-config --edit

Then, change the `BOOT_ORDER` line to include NVMe in the boot order:

BOOT_ORDER=0xf416

This setting will make the Raspberry Pi attempt to boot from an NVMe device connected to the PCIe port .

4. Kernel Compilation (Advanced):

If you need to compile the kernel to add support for specific PCIe devices, you can follow the steps outlined in the Raspberry Pi documentation. This involves cloning the Raspberry Pi kernel repository, configuring the kernel with `make menuconfig`, and enabling the necessary modules for your devices . Remember to always check the compatibility of the devices you intend to use with the Raspberry Pi 5's PCIe interface, as not all devices may be supported out of the box.

How to light up identical LED?

To light up UID LED indicator on a Raspberry Pi 5, you'll make sure the GPIO Pin of the UID LED connected to.

GPIO (General Purpose Input/Output) pins on the Raspberry Pi.

Steps

• 1. Identify GPIO Pins: GPIO4
  

• 2. Power On:

Make sure your Raspberry Pi is powered off before connecting the LED. Once everything is connected, you can power on your Raspberry Pi.

• 3. Software Setup:

You'll need to write a small program to turn the GPIO pin on and off to control the LED. You can use Python with the `gpiozero` library or `RPi.GPIO` library to control the GPIO pins.

Example Python Code with gpiozero:

from gpiozero import LED
from time import sleep


led = LED('GPIO4')

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

Example Python Code with RPi.GPIO:

import RPi.GPIO as GPIO
import time

# Set the GPIO mode
GPIO.setmode(GPIO.BCM)


GPIO_PIN = 4

# Set up the GPIO pin as an output channel
GPIO.setup(GPIO_PIN, GPIO.OUT)

while True:
    GPIO.output(GPIO_PIN, GPIO.HIGH)  # Turn on the LED
    time.sleep(1)
    GPIO.output(GPIO_PIN, GPIO.LOW)   # Turn off the LED
    time.sleep(1)

# Clean up the GPIO pins before exiting the program
GPIO.cleanup()

Safety Tips:

• Be careful not to short any pins on the Raspberry Pi.

FAQ

SSD1306 OLED Black-Screen Debugging Report & Operation Guide

Target hardware: 0.91" OLED, 128×32 px, SSD1306, I2C, address 0x3C, Raspberry Pi 5 Software: luma.oled 3.15.0, luma.core 2.6.0, Python 3.13, smbus2

1. Executive Summary — What Was Actually Wrong

Nothing was wrong with the code, the luma library, or the SSD1306 register configuration. No library or example source code was modified. The failures came from hardware and configuration, in one layers:

A parameter mismatch in the examples. The examples in this directory default to

 `ssd1305 / 128×64`; this panel is `ssd1306 / 128×32`. Running without parameters
 produces a black or garbled screen. The fix is to pass the correct display, interface,
 geometry and address — done via the config file `ssd1306_128x32.conf`.

• ssd1306_128x32.conf contents:

--display=ssd1306
--interface=i2c
--i2c-port=1
--i2c-address=0x3c
--width=128
--height=32

Put this configuration file to your demo code location:

• How to execute with config file

sudo python3 demo.py -f ssd1306_128x32.conf 

2. What Was Done, Step by Step (Method and Basis)

Diagnosis — locating the fault

Method	Basis / Reasoning
Bus scan with i2cdetect	An ACK at 0x3C proves all four wires (VCC/GND/SDA/SCL) are connected and the driver IC is powered
Source inspection of ssd1306 in luma.oled 3.15.0	The 128×32 init sequence (multiplex 0x1F, compins 0x02, charge pump 0x14) matches the datasheet standard — a register-level bug was ruled out on evidence
Raw-register write of 0xA5 (force all-on)	This command bypasses GDDRAM; a healthy panel must glow. No light = fault in the high-voltage path (charge pump / panel / flex cable)
Status-register read before/after DISPLAY ON/OFF commands	Per the SSD1306 datasheet, bit 6 is the display ON/OFF flag. It flipped correctly, proving the chip executes commands — fault isolated to the panel side
5 consecutive bus scans + 10 consecutive status reads	All values stable and identical — ruled out loose wiring and parasitic power

3. Files Created / Modified

Fixes and deliverables

File	Type	Description
ssd1306_128x32.conf	Fixed	Initially written in INI format, causing "unrecognized arguments". Based on the source of luma.core.cmdline.load_config (reads line by line, no whitespace splitting), rewritten as one --key=value per line; demo.py then ran successfully
ssd1306_raw.py	Created	Library-free SSD1306 driver; writes registers directly via smbus2 (PIL used only for pixel rendering)
OLED_128x32_I2C_manual.md	Created / updated	Bilingual operation manual; added the regulator/supply-voltage rule and the hardware-failure criterion
SSD1306_Debug_Report_EN.md	Created	Full English debugging report and operation guide

No files in luma.oled / luma.core or the example scripts were modified.

4. Final Working Configuration

• Module: bare 0.91" 128×32 SSD1306, no onboard regulator
• Wiring: VCC → 3.3 V (pin 1), GND → GND, SDA → GPIO2 (pin 3), SCL → GPIO3 (pin 5)
• No RST/RES connection needed (I2C interface)
• I2C address: `0x3C`

5. Operating Instructions

Run any luma example in this directory

python demo.py    -f ssd1306_128x32.conf
python clock.py   -f ssd1306_128x32.conf
python pi_logo.py -f ssd1306_128x32.conf

Or pass parameters explicitly:

python demo.py -d ssd1306 -i i2c --i2c-port 1 --i2c-address 0x3c --width 128 --height 32

Run the library-free raw driver

python ssd1306_raw.py                 # 0.96" 128x64
python ssd1306_raw.py --height 32     # 0.91" 128x32 (this panel)
python ssd1306_raw.py --addr 0x3D     # modules with address 0x3D

Minimal code (luma)

from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas


device = ssd1306(i2c(port=1, address=0x3C), width=128, height=32)
with canvas(device) as draw:
    draw.rectangle(device.bounding_box, outline="white")
    draw.text((4, 10), "OK 128x32", fill="white")

6. Black-Screen Decision Tree (for future modules)

• `i2cdetect -y 1` shows the address?

 No → power/wiring fault: measure VCC-GND **at the module's solder pads**, check SDA=pin 3, SCL=pin 5, try fresh dupont wires.
 Yes → continue.

• Run `python oled_diagnose.py`. Any step lights the panel?

 Yes → software/parameter issue; use the matching parameters (`-d ssd1306 --width 128 --height 32 --i2c-address 0x3c`).
 No → continue.

Keywords

• 1U Rackmount for Raspberry Pi 5 with M.2 NVMe SSD support.