ControlPi

Greetings everyone, and welcome back!

Today, I've got something super cool to show you: ControlPi!

Over time, I've collected quite a few single-board computers, including Raspberry Pis and other ARM-based development boards. Instead of keeping them scattered across my desk, I wanted to bring everything together into a dedicated rack where I could organize, power, and manage all my devices.

The plan is to build a versatile homelab capable of handling multiple tasks, including network-attached storage (NAS), firewall and DNS services, and even experimenting with lightweight, locally hosted language models. With each device serving a different purpose, I wanted a convenient way to keep track of everything running in my setup.

To make managing all these devices easier, I built ControlPi, a dedicated touchscreen control panel designed to monitor and manage my entire homelab from a single interface. Powered by a Raspberry Pi Compute Module 5 (CM5), ControlPi serves as the central dashboard for my collection of single-board computers, bringing device monitoring and Docker container management together in one place.

The software stack is built around Docker and Portainer Community Edition (CE). Docker provides the container runtime for running applications and services in isolated environments, making them easier to deploy, manage, and maintain. Portainer CE adds a web-based management interface that lets me monitor containers, inspect logs, manage application stacks, and control services without relying entirely on the command line.

By connecting additional Docker hosts through Portainer Agents, I can extend the management interface beyond the CM5 to compatible systems across my homelab. This allows me to manage containers running on devices such as the Radxa Rock 5 ITX, ZimaBoard 2, and other SBCs from a single dashboard.

The idea is simple: turn on ControlPi, and the dashboard is ready to go. I want to see the status of my connected devices, check system resources, monitor CPU temperatures, track memory and storage usage, and manage Docker containers without connecting a separate monitor and keyboard to every machine.

Managing multiple SBCs can quickly become a hassle, especially when each device runs different services and serves a different purpose. With ControlPi, I wanted to bring everything together into a single, dedicated touchscreen interface for monitoring system resources and managing Docker containers across my homelab.

In this Instructables, I'll walk you through the complete build process of ControlPi, covering the hardware, software setup, Docker and Portainer configuration, and connecting additional SBCs to the system.

So, without further ado, let's get started!

These were the Components used in this project.

1. Raspberry Pi CM5 4GB Version
2. Raspberry Pi CM5 Evaluation Kit
3. Waveshare 10.1 Inch DSI Touch Display
4. 128GB Gen 3 NVME SSD flashed with Raspberry Pi OS
5. M2 screws
6. 3D-printed frame
7. M2.5 Bolts
8. Radxa Rock Pi 5 ITX

The brain of ControlPi is the Raspberry Pi Compute Module 5 (CM5), a compact, modular computing platform designed for embedded and industrial applications. It features the same Broadcom BCM2712 processor found in the Raspberry Pi 5, with a 64-bit quad-core Arm Cortex-A76 CPU running at 2.4 GHz, but in a more compact module form factor.

For this build, the CM5 is mounted on an evaluation board that provides access to essential connectivity options, including USB ports, Ethernet, dual HDMI outputs, GPIO headers, a microSD card slot, and an M.2 interface for connecting an NVMe SSD.

I'm using the 4GB RAM variant with 32GB of onboard eMMC storage.

For the operating system, I chose the latest Raspberry Pi OS based on Debian Trixie. Instead of running the OS from a microSD card, I installed it on an NVMe SSD for faster storage access and improved overall responsiveness.

I used Raspberry Pi Imager to flash the operating system onto the NVMe drive. To do this, I connected the SSD to my computer using an M.2-to-USB adapter and selected the appropriate OS image in Raspberry Pi Imager.

Once the flashing process was complete, I installed the NVMe SSD in the CM5 evaluation board and powered on the system. The CM5 successfully booted directly from the SSD, providing a fast and responsive foundation for ControlPi.

For the main display, I wanted something huge, not the average 7-inch size, but something larger.

Connectivity was also an important factor, as I wanted a DSI interface instead of HDMI.

So, I selected Waveshare's 10.1-DSI-TOUCH-A display for this project. It is a portrait touchscreen LCD display with ten-point capacitive touch control. The display uses an IPS panel with a hardware resolution of 800×1280, which is perfect for our tablet application.

The LCD pairs with the Raspberry Pi through the DSI interface and supports a refresh rate of up to 60 Hz, which is more than enough for this application.

The kit comes with two FFC cables for pairing the display with a Raspberry Pi 5 or CM5, one FFC cable for pairing with a Raspberry Pi 4, a power cable, and a couple of PCB standoffs.

You can check out more about this display on its wiki page.

https://www.waveshare.com/10.1-dsi-touch-a.htm?&aff_id=Arnov

http://www.waveshare.com/wiki/10.1-DSI-TOUCH-A

Special thanks to Waveshare for providing the hardware used in this project. The 10.1 Inch DSI screen and supporting accessories were supplied as review units for testing and evaluation.

Waveshare is a leading global provider of electronic components, modules, and development tools used across robotics, IoT, automation, education, and many other fields. With a strong focus on quality, reliability, and continuous innovation, Waveshare has earned the trust of engineers, designers, hobbyists, and makers worldwide.

Their extensive product lineup, from displays and HATs to expansion boards and embedded modules, makes them a go-to choice for both professional builds and DIY projects.

For the 3D Model of ControlPi, I opted for a portrait orientation for the display, positioning the evaluation board's I/O ports vertically alongside it.

This arrangement keeps all the essential ports accessible from the front, making it easier to connect peripherals and access the board once ControlPi is mounted in the homelab rack.

Another important consideration was the size of the frame. I wanted the entire design to fit within a 250 × 250 × 250 mm build volume, allowing it to be printed on most standard desktop 3D printers with a 250 mm build area. This was also one of the reasons I chose the portrait orientation for the display.

The display is mounted from the front of the frame. I designed dedicated mounting points that align with the display's PCB standoffs, allowing the screen to sit securely in place when fastened.

The CM5 evaluation board is mounted vertically on the back of the frame, with its I/O ports facing the front. To secure it, I incorporated three mounting ribs with 2 mm holes, positioned to align with the board's existing mounting holes near the I/O section. Three M2 screws hold the evaluation board firmly in place.

This arrangement keeps the display and computing hardware neatly integrated into a compact assembly while ensuring that the necessary ports remain accessible from the front of the rack.

The model was exported as a mesh file and 3D printed using purple Hyper PLA. The print settings included a 0.4 mm nozzle, 25% gyroid infill, and a 0.16 mm layer height, with tree supports and a top Z distance of 0.3 mm.

The assembly process was straightforward.

1. First, we positioned the frame over the back of the 10.1-inch DSI display, aligning the mounting holes with the display's PCB standoffs.
2. Using the four M2.5 bolts included with the display kit, we secured the display and frame together.
3. Next, we positioned the CM5 evaluation board vertically in its designated place and secured it to the frame using three M2 screws.
4. We then connected the display's JST power connector to the 5V and GND pins on the CM5 evaluation board's 40-pin GPIO header, connecting 5V to 5V and GND to GND.
5. Finally, we connected the 10.1-inch display to the CM5 evaluation board using the DSI flex cable, completing the hardware assembly.

We plugged in the power and were hoping this would be a plug-and-play job, but things are never that simple, and the display didn't work straight away.

We needed to connect an external monitor to our CM5, open a terminal, and then edit the config.txt file.

We added the following line at the bottom of the file.

On the wiki page for this display, to Waveshare's credit, they did include a custom pre-flashed Raspberry Pi OS Trixie image. If we use that image and flash our Raspberry Pi with it, the display boots up without requiring any manual edits to the configuration files.

ControlPi uses a combination of Docker, Portainer CE, and Chromium kiosk mode to transform the Raspberry Pi Compute Module 5 into a dedicated touchscreen control panel for my homelab.

The goal is to create an interface that starts automatically when the device is powered on, displays the management dashboard on the touchscreen, and allows me to monitor and manage containers running across multiple single-board computers without needing a keyboard or mouse.

Container Management with Docker

The foundation of ControlPi is Docker, which provides the containerization environment for running services and infrastructure tools.

Docker runs natively on the Raspberry Pi CM5, allowing it to host management services independently of the desktop environment. Once installed, Docker can start automatically at boot and manage the containers required by ControlPi.

Portainer CE: The Control Center

For the management interface, I use Portainer Community Edition (CE). Portainer provides a web-based dashboard for managing Docker environments without relying entirely on the command line.

By deploying Portainer as a Docker container and connecting it to the local Docker socket (/var/run/docker.sock), I can use the touchscreen to:

1. Monitor container health and status.
2. Track CPU and memory usage.
3. Start, stop, and restart containers.
4. Inspect container logs.
5. Deploy applications and manage container stacks.
6. Connect to additional Docker environments running on other SBCs.

This makes Portainer the central management interface for ControlPi.

Managing Multiple SBCs

ControlPi is designed to manage more than just the Raspberry Pi CM5 itself. By deploying Portainer Agents on additional single-board computers, such as a Radxa Rock 5 ITX, I can connect multiple Docker environments to the same Portainer instance.

This provides a unified interface for monitoring and managing services across my homelab without needing to access each machine individually.

Automated Startup and Kiosk Mode

Since ControlPi is intended to function as a dedicated appliance, I want the dashboard to appear automatically whenever the device is powered on.

For this, I configure Raspberry Pi OS Desktop to start its graphical environment and launch Chromium in kiosk mode.

Chromium opens directly to the Portainer dashboard in full-screen mode, hiding the browser interface and desktop elements to provide a clean, touchscreen-friendly experience.

Handling Startup Dependencies

One challenge with an automatically starting kiosk is that the browser may launch before Docker and Portainer are ready.

To address this, I use a custom startup script called start-kiosk sh. The script checks whether the Portainer web interface is responding before launching Chromium.

The startup sequence is therefore:

1. The Raspberry Pi CM5 powers on.
2. Raspberry Pi OS starts the desktop environment.
3. The kiosk startup script begins running.
4. The script waits until Portainer is available.
5. Chromium launches in full-screen mode.
6. The Portainer dashboard appears on the touchscreen.

This reduces startup failures caused by services taking longer to initialize than the graphical environment.

Chromium Configuration

Chromium is launched with kiosk-related options to keep the interface suitable for an always-on display.

Options such as --kiosk and --noerrdialogs help provide a clean presentation, while --password-store=basic can avoid certain desktop keyring prompts.

These options should be selected according to the installed Chromium version and desktop environment. I avoid disabling certificate validation globally; instead, the dashboard should use a correctly configured HTTPS connection when remote access or encrypted connections are required.

Authentication and Security

Although ControlPi is designed to operate without requiring a keyboard or mouse during normal use, the management interface must remain protected.

Portainer should be initialized with a strong administrator password, and its authentication mechanism should be configured appropriately for the deployment.

The dashboard can remain visible on the touchscreen, but unattended access to container-management controls introduces security risks. Anyone who can access a Portainer instance connected to the Docker socket may effectively gain extensive control over the host.

For this reason, I recommend keeping ControlPi on a trusted network, avoiding direct exposure of Portainer to the public internet, and using proper authentication rather than relying on saved sessions or automatically bypassing the login screen.

With Docker providing the container runtime, Portainer acting as the management interface, and Chromium kiosk mode handling the display, ControlPi becomes a dedicated touchscreen command center for my homelab.

The system is designed to boot automatically, wait for the management services to become available, and present the dashboard without requiring manual interaction during normal startup. Additional SBCs can be connected through Portainer Agents as the homelab expands.

For this demonstration, I'm powering the CM5 setup through its USB Type-C port using a smartphone charger. However, my plan is to integrate an ATX power supply into the homelab rack to power the entire CM5 system along with the other components.

One of the main features of ControlPi is the ability to manage Docker containers across multiple SBCs from a single dashboard. To achieve this, I connected Radxa Rock 5 ITX to the same network as ControlPi.

On Radxa, I installed Docker and deployed the Portainer Agent. From the Portainer CE interface running on ControlPi, I then added the device as a separate environment using its IP address and the agent's listening port.

Once connected, the additional devices appeared in the Portainer dashboard, allowing me to switch between environments and manage their Docker containers from the ControlPi touchscreen.

This setup makes it easy to expand my homelab: whenever I add another SBC, I can configure it as a Docker host and connect it to ControlPi.

For the next phase of this project, I'm building the full rack using 40×20 mm aluminum extrusions for the frame, plus 3D-printed parts and laser-cut metal plates.

ControlPi is just one part of this larger build. I plan to integrate an ATX power supply, dedicated mounts for 2.5-inch and 3.5-inch SSDs and HDDs, PC fans with a dedicated control unit, and perhaps even an onboard battery to make this a truly portable, wireless homelab that I can take with me anywhere!

For now, though, the ControlPi project is complete and working exactly as intended, and I'm really happy with the result.

This article includes all the details, files, code, and wiring information, so be sure to check them out.

Thanks for sticking around until the end! I'll be back with a new project real soon.

PEACE!