30 Oktober 2025 –
Raspberry Pi als slim kloppend hart
Regelmatig gebruik ik de Raspberry Pi als centraal brein binnen een prototyping-project. Het is een compacte, krachtige minicomputer waarmee hardware, sensoren en software soepel samenwerken. De Pi vormt daarmee de ideale basis voor slimme installaties, meetopstellingen en onderwijsprojecten, en ik zet hem vaak in bij praktische en innovatieve toepassingen. Hij kan gebruikt worden met monitor, toetsenbord en muis, maar draait ook volledig autonoom — zonder handmatige tussenkomst en als los device op het netwerk.
Netwerkstatus zichtbaar maken zonder scherm
Wanneer een Raspberry Pi zonder monitor draait, is het lastig om te zien of er een actieve internetverbinding is. Zeker bij DHCP-verbindingen kan het IP-adres wisselen, waardoor het lastig wordt om te weten onder welk adres de Pi bereikbaar is. Een klein indicatiescherm dat de netwerkstatus (Online/Offline) en het actuele IP-adres toont, biedt dan uitkomst en maakt headless werken een stuk eenvoudiger.
Benodigde onderdelen voor testopstelling
Voor de opstelling van vandaag, een Raspberry Pi met OLED scherm zijn de volgende componenten en materialen nodig:
– Raspberry Pi 3B met micro-USB voeding 2.5A
– Losse HDMI monitor, USB keywords en muis
– 0.91″ OLED I2C Display White Monochrome 128×32 pixels
– 4 Dupont stekkers (female-female)
– Putty SSH client remote terminal software
Toevoegen van een OLED netwerkdisplay
Om dit te realiseren heb ik mijn Raspberry Pi 3B uitgebreid met een 0.91” I²C OLED-display van 128×32 pixels.
Hierop wil ik direct kunnen zien of het systeem online is, zonder in te loggen. Het display toont realtime de netwerkstatus, het IP-adres en de lokale tijd, zodat ik ook bij IoT-projecten zonder scherm in één oogopslag zie of de Pi verbonden is met het netwerk.
Bibliotheek voor aansturing en grafische weergave
Voor de aansturing gebruik ik de luma.oled-bibliotheek, onderdeel van het bredere Luma-ecosysteem van Richard Hull. Deze biedt een eenvoudige Python-interface voor OLED- en LED-schermen zoals de populaire SSD1306 en SH1106. Onder de motorkap maakt luma.oled gebruik van Pillow (PIL) om tekst en grafische elementen te tekenen en communiceert het via I²C met het display.
Programmeren van het OLED-statusscript
Het OLED-display met adres 0x3C laat op de eerste pagina groot “ONLINE” of “OFFLINE” zien. Op de tweede pagina wordt het IP-adres en de lokale tijd getoond — handig bij het loggen van sensorwaarden met een timestamp. De twee schermen wisselen automatisch iedere twee seconden, wat het overzicht compact en dynamisch houdt.
Aansluitingen op de Raspberry Pi
De voeding van het OLED-display is aangesloten op Pin 1 (3.3 V) en Pin 6 (GND). Voor de I²C-communicatie gebruik ik Pin 3 (GPIO2 / SDA) en Pin 5 (GPIO3 / SCL). Met het commando i2cdetect -y 1 controleer ik of het display correct herkend wordt als 0x3C, waarna ik het Python-programma schrijf.
#!/usr/bin/env python3
"""
Netwerkstatus OLED-display voor Raspberry Pi
Geschikt voor SSD1306 128×32 (0x3C)
Toont ONLINE/OFFLINE en IP-adres met tijd
"""
import time, socket, signal, sys
from datetime import datetime
from PIL import Image, ImageDraw, ImageFont
from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
I2C_ADDR = 0x3C # jouw displayadres
PAGE_TIME = 2.0 # seconden per pagina-wissel
def get_ip_and_online(timeout=1.5):
"""Geef (ip, online_bool)."""
ip, online = None, False
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.settimeout(timeout)
s.connect(("8.8.8.8", 80))
ip = s.getsockname()[0]
s.close()
except Exception:
pass
try:
socket.create_connection(("8.8.8.8", 53), timeout=timeout).close()
online = True
except Exception:
pass
return ip, online
def load_font(size):
try:
return ImageFont.truetype(
"/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", size
)
except Exception:
return ImageFont.load_default()
def draw_centered(draw, text, font, w, h):
tw, th = draw.textbbox((0, 0), text, font=font)[2:]
draw.text(((w - tw) // 2, (h - th) // 2), text, font=font, fill=255)
def main():
serial = i2c(port=1, address=I2C_ADDR)
device = ssd1306(serial)
W, H = device.width, device.height
font_big = load_font(18)
font_small = load_font(12)
stop = {"flag": False}
signal.signal(signal.SIGTERM, lambda *_: stop.update(flag=True))
signal.signal(signal.SIGINT, lambda *_: stop.update(flag=True))
page = 0
while not stop["flag"]:
ip, online = get_ip_and_online()
img = Image.new("1", (W, H), 0)
d = ImageDraw.Draw(img)
if page == 0:
draw_centered(d, "ONLINE" if online else "OFFLINE", font_big, W, H)
else:
d.text((0, 2), f"IP: {ip or '---'}", font=font_small, fill=255)
d.text((0, 18), datetime.now().strftime("%H:%M:%S"), font=font_small, fill=255)
device.display(img)
time.sleep(PAGE_TIME)
page ^= 1
device.clear()
if __name__ == "__main__":
try:
main()
except Exception as e:
print(f"net_oled error: {e}", file=sys.stderr)
try:
ssd1306(i2c(port=1, address=I2C_ADDR)).clear()
except Exception:
pass
sys.exit(1)
Automatisch opstarten van het OLED-programma
Om het script automatisch te starten bij een reboot maak ik het uitvoerbaar met: sudo chmod +x /usr/local/bin/net_oled.py. Vervolgens definieer ik een systemd-service (/etc/systemd/system/net-oled.service) die het script bij elke opstart activeert.
Na een daemon-reload en enable –now draait het display autonoom en toont het iedere twee seconden de actuele status, het IP-adres en de lokale tijd.
[Unit]
Description=OLED Netwerkstatus Display
After=network-online.target
[Service]
ExecStart=/usr/bin/python3 /usr/local/bin/net_oled.py
Restart=always
User=raspberry
Environment=PYTHONUNBUFFERED=1
[Install]
WantedBy=multi-user.target
Nieuwe mogelijkheden met single-board computers
Werken met een single board computer zoals de Raspberry Pi opent talloze nieuwe mogelijkheden. De combinatie van netwerk, GPIO-aansturing en lokale verwerking maakt het eenvoudig om sensoren uit te lezen, beelden te analyseren en resultaten te tonen of te versturen. Het is een krachtige en flexibele basis voor slimme meet- en regeltoepassingen — een waardevolle uitbreiding van mijn toolbox voor data-verzameling, verwerking en visualisatie.