PC-Status Monitor: CPU-Auslastung auf einem OLED am Leonardo anzeigen

Ein PC-Status Monitor ist eine der praktischsten DIY-Erweiterungen für den Arbeitsplatz: Sie sehen auf einen Blick, wie stark Ihre CPU ausgelastet ist, ohne ständig den Task-Manager zu öffnen oder ein Overlay im Spiel bzw. in der Anwendung laufen zu lassen. Besonders elegant wird das Ganze, wenn Sie die CPU-Auslastung auf einem kleinen OLED-Display direkt am Arduino Leonardo anzeigen. Der Leonardo eignet sich dafür sehr gut, weil er über native USB-Funktionen verfügt und gleichzeitig eine stabile serielle Verbindung über USB bereitstellt. In diesem Artikel lernen Sie Schritt für Schritt, wie ein Setup funktioniert, bei dem Ihr PC die CPU-Auslastung ermittelt, diese Daten über USB-Serial an den Leonardo sendet und der Leonardo sie auf einem OLED (z. B. SSD1306 128×64) als Text, Balkenanzeige oder Mini-Graph darstellt. Sie erfahren, welche Hardware sinnvoll ist, wie die Verdrahtung über I2C oder SPI gelingt, welche Bibliotheken sich bewährt haben, wie Sie ein robustes Datenformat definieren und worauf Sie achten sollten, damit der Monitor flüssig und zuverlässig läuft. Dabei integrieren wir das Hauptkeyword „PC-Status Monitor“ natürlich, arbeiten mit praxisnahen Empfehlungen und geben Ihnen stabile Outbound-Links zu offiziellen Dokumentationen, damit die Umsetzung direkt gelingt.

Konzeptüberblick: So arbeitet der PC-Status Monitor

Bevor Sie Bauteile bestellen, lohnt sich ein kurzer Blick auf das Gesamtsystem. Ein PC-Status Monitor mit OLED am Leonardo besteht im Kern aus drei Teilen:

• Datenerfassung am PC: Ein kleines Programm liest die CPU-Auslastung (z. B. in Prozent) aus.
• Datenübertragung: Der PC sendet die Werte über die serielle USB-Verbindung an den Arduino Leonardo.
• Visualisierung: Der Leonardo rendert die Werte auf dem OLED als Text, Balken, Verlauf oder Icon.

Das wirkt einfach, aber die Qualität entscheidet sich in Details: Wie oft messen Sie? Wie stabil ist das Protokoll? Wie vermeiden Sie Flackern auf dem Display? Und wie stellen Sie sicher, dass die seriellen Daten auch dann sauber ankommen, wenn der PC kurz unter hoher Last steht?

Hardware: Was Sie wirklich benötigen

Für einen zuverlässigen PC-Status Monitor ist die Hardware überschaubar. Wichtig ist, Komponenten zu wählen, die gut dokumentiert sind und sich in der Praxis bewährt haben.

• Arduino Leonardo: Offizielle Board-Infos finden Sie hier: Arduino Leonardo Dokumentation.
• OLED-Display: Häufig genutzt: SSD1306 (128×64 oder 128×32), als I2C- oder SPI-Variante. Eine gut gepflegte Bibliothek ist beispielsweise die Adafruit SSD1306 Library.
• Jumper-Kabel und optional Steckbrett für Prototyping.
• Gehäuse/Standfuß (optional), damit das OLED sauber am Arbeitsplatz steht.

Alternativ zur Adafruit-Library ist U8g2 sehr beliebt, weil sie viele Displays unterstützt und flexible Fonts bietet: U8g2 Grafikbibliothek.

OLED-Anschluss am Leonardo: I2C vs. SPI

Die meisten OLEDs gibt es als I2C- oder SPI-Version. Für Einsteiger ist I2C oft am angenehmsten, weil nur wenige Leitungen nötig sind. SPI ist etwas schneller, benötigt aber mehr Pins. Für eine CPU-Anzeige reicht I2C in der Regel völlig aus.

I2C: Minimaler Kabelaufwand

• VCC → 5V (oder 3,3V je nach Modul)
• GND → GND
• SDA → SDA-Pin am Leonardo
• SCL → SCL-Pin am Leonardo

Beim Leonardo sind SDA/SCL zusätzlich an dedizierten Pins (nahe AREF) herausgeführt. Das ist ein häufiger Stolperstein, wenn man von einem Uno kommt. Für I2C-Grundlagen und Wire-Nutzung ist die Arduino-Referenz hilfreich: Arduino Wire (I2C) Referenz.

SPI: Mehr Leitungen, potenziell höhere Update-Rate

SPI-Displays nutzen Leitungen wie SCK, MOSI, CS, DC und oft RESET. Wenn Sie später sehr schnelle Graphen oder komplexe UI-Elemente zeichnen möchten, kann SPI im Vorteil sein. Für die meisten Statusmonitore ist es jedoch nicht zwingend erforderlich.

Display-Bibliotheken und Rendering: Lesbar statt überladen

Die Visualisierung entscheidet, ob Ihr PC-Status Monitor im Alltag wirklich nützlich ist. Eine reine Zahl „CPU: 37%“ ist gut, ein zusätzliches Balkendiagramm macht es noch intuitiver. Sehr beliebt sind drei Darstellungsformen:

• Textanzeige: CPU in Prozent, ggf. ergänzt um Kerntakt oder Temperatur (später erweiterbar).
• Balkenanzeige: 0–100% als horizontale Leiste.
• Mini-Verlauf: Kleine History-Linie über z. B. die letzten 60 Sekunden.

Wenn Sie die Balkenbreite aus dem Prozentwert berechnen, ist eine einfache lineare Skalierung ausreichend:

$\mathrm{Breite}=\frac{\mathrm{CPU\%}}{100}\⁢\mathrm{MaxBreite}$

Wichtig in der Praxis: Vermeiden Sie zu häufiges Komplett-Redraw, wenn das Display sichtbar flackert. Viele Bibliotheken nutzen Buffering, dennoch lohnt sich eine sinnvolle Update-Rate (z. B. 2–5 Updates pro Sekunde).

Datenerfassung am PC: CPU-Auslastung korrekt auslesen

Die CPU-Auslastung lässt sich je nach Betriebssystem auf verschiedene Weise ermitteln. Zwei besonders praxistaugliche Wege sind:

• Cross-Platform (empfohlen): Python mit psutil, weil Windows, macOS und Linux unterstützt werden. Projektseite: psutil auf PyPI.
• Windows-spezifisch: Performance Counters oder WMI. Offizielle Grundlagen finden Sie bei Microsoft, z. B. zu Performance Counters: Microsoft Learn: PerformanceCounter.

Für die meisten DIY-Setups ist Python besonders attraktiv: Sie können schnell einen kleinen Hintergrunddienst schreiben, der den CPU-Wert abfragt und über Serial sendet. Zusätzlich lässt sich das später leicht erweitern (RAM, GPU, Netzwerk).

USB-Serial am Leonardo: Die Verbindung, die alles zusammenhält

Zwischen PC und Leonardo läuft die Kommunikation in der Regel über die serielle USB-Schnittstelle Serial. Arduino dokumentiert die Serial-API inklusive begin(), read(), write() und available(): Arduino Serial Referenz. Für einen Statusmonitor sind zwei Faktoren entscheidend:

• Stabilität: Klare Paketgrenzen und ein einfaches, robustes Nachrichtenformat.
• Timing: Der PC sendet regelmäßig, der Leonardo liest schnell und blockiert nicht.

Ein häufiger Fehler ist „zu viel auf einmal“: Wenn Sie große Textstrings mit Debug-Ausgaben senden, wird der Empfangspuffer schneller voll und Sie verlieren Daten. Halten Sie die Nutzdaten knapp, und loggen Sie Debug nur bei Bedarf.

Robustes Datenformat: Warum „einfach nur Zahlen“ schnell Probleme macht

Viele starten damit, einfach „37“ oder „CPU:37“ zu senden. Das funktioniert, bis die Daten einmal fragmentiert ankommen (z. B. „3“ und später „7“), oder mehrere Werte im Stream stehen. Besser ist ein eindeutiges Format, das Paketgrenzen klar markiert. Zwei bewährte Varianten:

• Zeilenformat: Jede Nachricht endet mit Newline, z. B. CPU=37n. Der Leonardo liest bis zum Zeilenende.
• CSV/Key-Value: z. B. CPU=37;RAM=62n (später erweiterbar).

Mit einem Key-Value-Ansatz können Sie später zusätzliche Kennzahlen ergänzen, ohne das ganze System umzubauen. Für den Start reicht CPU=xx. Wichtig ist, dass der Leonardo nur dann einen Wert übernimmt, wenn eine vollständige Zeile vorliegt.

Leonardo-Logik: Entprellte Anzeige statt hektischer Zahlen

CPU-Werte können stark schwanken, insbesondere bei kurzen Lastspitzen. Für eine angenehme Anzeige empfiehlt sich eine leichte Glättung. Eine einfache gleitende Mittelung (Moving Average) liefert ein ruhigeres Bild. Mathematisch lässt sich eine einfache Mittelwertbildung über N Messungen so beschreiben:

${\mathrm{CPU}}_{\mathrm{avg}}=\frac{{\sum }_i^1{\mathrm{CPU}}_i}{N}$

In der Praxis reicht oft schon: „Nur neu zeichnen, wenn sich der Wert um mindestens 1–2 Prozentpunkte verändert“ oder „Maximal 4 Updates pro Sekunde“. Das spart Rechenzeit, reduziert Flackern und wirkt professioneller.

OLED-UI-Design: Was auf 128×64 wirklich funktioniert

Ein OLED mit 128×64 Pixeln wirkt zunächst klein, bietet aber genug Platz für eine sehr klare Darstellung. Ein praxistaugliches Layout ist:

• Oben links: CPU als Label
• Groß: Prozentwert (z. B. 37%)
• Darunter: Balkenanzeige über die volle Breite
• Optional unten: Mini-Graph der letzten Werte

Wichtig ist Kontrast: Nutzen Sie eine größere Schrift für die Zahl, und halten Sie den Rest ruhig. Wenn Sie U8g2 verwenden, profitieren Sie von gut lesbaren Fonts, ohne dass Sie selbst Bitmap-Fonts pflegen müssen: U8g2 Fonts und Beispiele.

Update-Rate und Performance: So bleibt die Anzeige flüssig

Ein häufiger Irrtum ist, dass „mehr Updates“ automatisch besser sind. Bei Statusdaten ist das Gegenteil oft wahr: Eine zu hohe Update-Rate führt zu unnötigem seriellen Traffic, häufiger Display-Aktualisierung und im schlimmsten Fall zu Mikrorucklern im Sketch. Für einen CPU-Monitor sind typische Zielwerte:

• PC-Messung: 2–5 Messungen pro Sekunde
• Serial-Senden: 2–5 Nachrichten pro Sekunde
• OLED-Redraw: 2–5 FPS (je nach Bibliothek und Layout)

Wenn Sie zusätzlich einen Verlauf zeichnen, ist es effizienter, nur den neuen Punkt zu ergänzen oder den Verlauf in einem kleinen Buffer zu pflegen, statt jedes Mal aufwendig neu zu berechnen.

Fehlersuche: Die häufigsten Probleme und schnelle Lösungen

Wenn der PC-Status Monitor nicht wie erwartet läuft, sind diese Ursachen besonders typisch:

• OLED bleibt schwarz: Falsche I2C-Adresse (häufig 0x3C oder 0x3D), fehlende GND-Verbindung, falsche Versorgungsspannung.
• Text ist „Müll“: Serial-Baudrate stimmt nicht überein oder das Datenformat ist nicht sauber getrennt.
• Anzeige flackert: Update-Rate zu hoch oder kompletter Bildschirm wird zu oft neu gezeichnet.
• Werte springen extrem: Keine Glättung, oder PC misst in zu kurzen Intervallen.
• Leonardo wird nicht erkannt: USB-Kabel/Port prüfen, ggf. anderen Port nutzen; Board-Infos und Setup: Arduino Leonardo Dokumentation.

Für die serielle Diagnose lohnt es sich, zunächst ohne OLED zu testen: Lassen Sie den Leonardo die empfangenen Zeilen über Serial zurück an den PC senden (Echo), um sicherzustellen, dass das Protokoll sauber ist. Danach wird die Anzeige implementiert.

Erweiterungen: Vom CPU-Monitor zum vollständigen PC-Status Dashboard

Ein großer Vorteil Ihres Setups ist die Erweiterbarkeit. Sobald CPU-Auslastung stabil läuft, sind weitere Kennzahlen fast „nur noch ein Datenfeld“:

• RAM-Auslastung: Prozent oder belegter Speicher
• GPU-Auslastung: je nach Tool (unter Windows häufig über spezielle APIs/Tools)
• CPU-Temperatur: abhängig von Sensorzugriff (nicht immer ohne Zusatztools möglich)
• Netzwerkaktivität: Up/Down als kleine Pfeile oder Zahlen
• Meeting-Status: „Mic muted“ als Icon, wenn Sie ohnehin Hardware am Desk nutzen

Wenn Sie beim Datenformat gleich auf Key-Value (z. B. CPU=37;RAM=62) setzen, können Sie solche Werte später ergänzen, ohne die Grundarchitektur zu ändern. Für das PC-Auslesen bleibt psutil ein sehr guter Ausgangspunkt, weil es viele Systemdaten über eine einheitliche API bietet: psutil Dokumentation.

Stabilität und Sicherheit: Seriell ist lokal, aber nicht automatisch „harmlos“

Ein PC-Status Monitor wirkt wie ein reines Anzeigeprojekt. Dennoch lohnt ein kurzer Blick auf Sicherheit und Stabilität:

• Nur lesen, nicht steuern: Halten Sie das PC-Skript zunächst auf „Read-only“-Daten (CPU/RAM), statt Systembefehle zu senden.
• Keine sensitiven Daten anzeigen: Vermeiden Sie die Anzeige von Dateinamen, Fenstertiteln oder Benutzerdaten, wenn andere Personen den Monitor sehen könnten.
• Serielle Eingaben validieren: Falls der Leonardo irgendwann Befehle empfangen soll, definieren Sie klare Whitelists.

So bleibt das Projekt ein nützlicher, unkritischer Helfer im Alltag – und nicht eine Quelle für unerwartete Nebeneffekte.

Outbound-Links für verlässliche Umsetzung und Bibliotheken

• Arduino Leonardo: Offizielle Hardware-Details
• Arduino Serial: read(), write(), available(), begin()
• Arduino Wire (I2C): Grundlagen und Nutzung
• Adafruit SSD1306 Library: OLED-Ansteuerung
• Adafruit GFX Library: Grafische Basisfunktionen
• U8g2: Flexible Display- und Font-Bibliothek
• psutil: CPU-Auslastung und Systemwerte per Python
• Microsoft Learn: PerformanceCounter (Windows CPU-Daten)

IoT-PCB-Design, Mikrocontroller-Programmierung & Firmware-Entwicklung

PCB Design • Arduino • Embedded Systems • Firmware

Ich biete professionelle Entwicklung von IoT-Hardware, einschließlich PCB-Design, Arduino- und Mikrocontroller-Programmierung sowie Firmware-Entwicklung. Die Lösungen werden zuverlässig, effizient und anwendungsorientiert umgesetzt – von der Konzeptphase bis zum funktionsfähigen Prototyp.

Diese Dienstleistung richtet sich an Unternehmen, Start-ups, Entwickler und Produktteams, die maßgeschneiderte Embedded- und IoT-Lösungen benötigen. Finden Sie mich auf Fiverr.

Leistungsumfang:

• IoT-PCB-Design & Schaltplanerstellung

• Leiterplattenlayout (mehrlagig, produktionstauglich)

• Arduino- & Mikrocontroller-Programmierung (z. B. ESP32, STM32, ATmega)

• Firmware-Entwicklung für Embedded Systems

• Sensor- & Aktor-Integration

• Kommunikation: Wi-Fi, Bluetooth, MQTT, I²C, SPI, UART

• Optimierung für Leistung, Stabilität & Energieeffizienz

Lieferumfang:

• Schaltpläne & PCB-Layouts

• Gerber- & Produktionsdaten

• Quellcode & Firmware

• Dokumentation & Support zur Integration

Arbeitsweise:Strukturiert • Zuverlässig • Hardware-nah • Produktorientiert

CTA:
Planen Sie ein IoT- oder Embedded-System-Projekt?
Kontaktieren Sie mich gerne für eine technische Abstimmung oder ein unverbindliches Angebot. Finden Sie mich auf Fiverr.