ESP32 Project

PC Status Monitor

In this project, I build a DIY PC status monitor that displays live system values from a Windows PC on an external display using an ESP32.

The monitor shows CPU usage, RAM usage, GPU usage, CPU temperature, GPU temperature, and live CPU clock speed. The data is collected on the PC, sent over USB serial, and displayed on a small touchscreen display inside a laser-cut enclosure.

DIY PC Status Monitor with ESP32 display

1. Project Idea

The goal is to create a small external display that shows live hardware values from my PC. Instead of opening monitoring software on the main screen, the most important values are always visible directly on the desk.

For this build, I reused a leftover display and an ESP32 from my RGB controller project. This made the electronics part easier and allowed me to reuse components that I already had available.

Main controllerESP32 connected to the display and to the PC over USB serial.

DisplaySPI TFT display controlled by the ESP32. The touchscreen is connected, but not used in this version.

PC softwareLibreHardwareMonitor and a sender script collect the system values and transmit them to the ESP32.

2. How the System Works

The system is split into two parts. The Windows PC reads the live hardware data, while the ESP32 receives the values and updates the graphical dashboard on the display.

Windows PC → LibreHardwareMonitor reads hardware sensors

Sender script → selects the important values

USB serial connection → transfers the data to the ESP32

ESP32 → receives the values and updates the display

In this version, the monitor displays CPU usage, RAM usage, GPU load, CPU temperature, GPU temperature, and live CPU clock speed. The data is updated regularly, so the display works as a compact external dashboard.

3. Required Parts

ESP32 development board
SPI TFT display
Dupont wires
USB cable for power and serial communication
Laser-cut enclosure
Double-sided tape for fixing the display and ESP32

4. Wiring and Display Setup

I connected the display to the ESP32 using Dupont wires. For the wiring concept, I reused the display setup from my previous RGB controller project. This helped keep the build simple because the display and ESP32 configuration were already tested.

Important: The display pin configuration must match the selected display setup in your ESP32 project. If the display stays white, shows wrong colors, or appears mirrored, check the driver, SPI pins, and backlight.

5. Enclosure and SVG File

Because the housing is clearly visible on the desk, I decided to laser cut the enclosure. The case was designed with a tight fit so the parts can be assembled cleanly and the display sits securely in the front opening.

The display and ESP32 are fixed inside the case with double-sided tape. Cable management is kept simple, and the final result is a compact desktop PC status monitor.

Laser-cut SVG enclosure layout for the PC Status Monitor

Laser-cut enclosure SVG with a 96 mm × 62 mm display cutout.

6. Windows Setup

Install and start LibreHardwareMonitor.
Enable the LibreHardwareMonitor web server or JSON endpoint.
Install Python and the required packages for serial communication and system monitoring.
Connect the ESP32 to the PC with a USB cable.
Check the correct COM port in the Arduino IDE or Windows Device Manager.
Start the sender workflow so the PC values are transmitted to the ESP32.

7. ESP32 Firmware Overview

The ESP32 firmware waits for live data from the PC over USB serial. When valid data is received, the values are stored and the display dashboard is refreshed.

Example serial data format

Example PC to ESP32 message

S,34,58,42,61,55,4700

8. PC Sender Workflow

The PC sender script collects live system values from the operating system and from LibreHardwareMonitor. After the values are collected, they are converted into a compact data message and sent to the ESP32 through USB serial.

9. Starting and Stopping the Monitor

For daily use, the project can be started with a simple start workflow. This opens LibreHardwareMonitor and then starts the PC sender script. Before using it for the first time, the COM port must be adjusted to match the connected ESP32.

10. Final Code Files

The final project uses two software parts. The ESP32 sketch runs on the display controller and receives the PC data over USB serial. The Python script is shown here as downloadable/copyable code only.

Firewall-safe website note: The code below is stored inside read-only HTML textareas and encoded as HTML character entities. WordPress displays it as text only. It is not executed on your web server, and this format reduces the chance that a server firewall or ModSecurity rule blocks the page save because of raw script-like content in the HTML.

pc_status_monitor.ino

This Arduino sketch runs on the ESP32. It initializes the TFT display, receives serial data from the Windows PC, parses the values, and updates the dashboard layout.

pc_status_monitor.ino

/*
  ESP32 PC Stats Dashboard – Clean GUI Layout
  – ILI9341 display with TFT_eSPI
  – XPT2046 touch controller on HSPI
  – Receives Windows PC stats over USB serial

  Serial format:
  S,cpuPercent,ramPercent,gpuLoadPercent,cpuTemp,gpuTemp,cpuClockMHz
*/

#include <SPI.h>
#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>

TFT_eSPI tft = TFT_eSPI();

#define TFT_BL 17

#define TOUCH_CS   26
#define TOUCH_IRQ  25

SPIClass touchSPI(HSPI);
XPT2046_Touchscreen ts(TOUCH_CS, TOUCH_IRQ);

// ———- GUI SETTINGS ———-
#define SCREEN_MARGIN 6
#define CARD_GAP      6
#define STATUS_H      16
#define CARD_RADIUS   9

#define COLOR_BG      TFT_BLACK
#define COLOR_CARD    TFT_DARKGREY
#define COLOR_BORDER  TFT_LIGHTGREY
#define COLOR_TEXT    TFT_WHITE
#define COLOR_MUTED   TFT_LIGHTGREY

#define FORMAT_PERCENT 0
#define FORMAT_TEMP_C  1
#define FORMAT_MHZ     2

struct PcStats {
  int cpu;
  int ram;
  int gpuLoad;
  int cpuTemp;
  int gpuTemp;
  int cpuClock;
};

PcStats stats    = {-1, -1, -1, -1, -1, -1};
PcStats oldStats = {-999, -999, -999, -999, -999, -999};

String serialLine = “”;

unsigned long lastPacketMs = 0;
unsigned long lastStatusUpdateMs = 0;

bool dataDirty = false;
bool oldStaleState = false;

struct StatBox {
  int x;
  int y;
  int w;
  int h;
  const char *label;
  int barMax;
  uint8_t format;
  uint16_t color;
};

StatBox boxes[6];

bool parseStatsLine(String line) {
  line.trim();

  if (!line.startsWith(“S,”)) {
    return false;
  }

  char buffer[110];
  line.toCharArray(buffer, sizeof(buffer));

  int cpu, ram, gpuLoad, cpuTemp, gpuTemp, cpuClock;

  int fields = sscanf(
    buffer,
    “S,%d,%d,%d,%d,%d,%d”,
    &cpu,
    &ram,
    &gpuLoad,
    &cpuTemp,
    &gpuTemp,
    &cpuClock
  );

  if (fields != 6) {
    return false;
  }

  stats.cpu = cpu;
  stats.ram = ram;
  stats.gpuLoad = gpuLoad;
  stats.cpuTemp = cpuTemp;
  stats.gpuTemp = gpuTemp;
  stats.cpuClock = cpuClock;

  lastPacketMs = millis();
  dataDirty = true;

  return true;
}

void readSerialData() {
  while (Serial.available()) {
    char c = Serial.read();

    if (c == ‘\n’) {
      parseStatsLine(serialLine);
      serialLine = “”;
    } else if (c != ‘\r’) {
      serialLine += c;

      if (serialLine.length() > 100) {
        serialLine = “”;
      }
    }
  }
}

void setupLayoutValues() {
  int top = SCREEN_MARGIN;
  int usableBottom = STATUS_H + SCREEN_MARGIN;

  int boxW = (tft.width() – 2 * SCREEN_MARGIN – CARD_GAP) / 2;
  int boxH = (tft.height() – top – usableBottom – 2 * CARD_GAP) / 3;

  int x1 = SCREEN_MARGIN;
  int x2 = SCREEN_MARGIN + boxW + CARD_GAP;

  int y1 = top;
  int y2 = top + boxH + CARD_GAP;
  int y3 = top + 2 * (boxH + CARD_GAP);

  // Row 1: CPU core information
  boxes[0] = {x1, y1, boxW, boxH, “CPU”,      100,  FORMAT_PERCENT, TFT_GREEN};
  boxes[1] = {x2, y1, boxW, boxH, “CPU TEMP”, 100,  FORMAT_TEMP_C,  TFT_ORANGE};

  // Row 2: memory and CPU clock speed
  boxes[2] = {x1, y2, boxW, boxH, “RAM”,      100,  FORMAT_PERCENT, TFT_CYAN};
  boxes[3] = {x2, y2, boxW, boxH, “CPU CLK”,  6000, FORMAT_MHZ,     TFT_MAGENTA};

  // Row 3: GPU usage and GPU temperature next to each other
  boxes[4] = {x1, y3, boxW, boxH, “GPU”,      100,  FORMAT_PERCENT, TFT_BLUE};
  boxes[5] = {x2, y3, boxW, boxH, “GPU TEMP”, 100,  FORMAT_TEMP_C,  TFT_RED};
}

void drawStaticBox(const StatBox &box) {
  tft.fillRoundRect(box.x, box.y, box.w, box.h, CARD_RADIUS, COLOR_CARD);
  tft.drawRoundRect(box.x, box.y, box.w, box.h, CARD_RADIUS, COLOR_BORDER);

  // Colored accent line
  tft.fillRoundRect(box.x + 4, box.y + 4, 4, box.h – 8, 3, box.color);

  // Label
  tft.setTextDatum(TL_DATUM);
  tft.setTextColor(COLOR_MUTED, COLOR_CARD);
  tft.setTextSize(1);
  tft.drawString(box.label, box.x + 16, box.y + 7, 2);

  // Bar outline
  int barX = box.x + 16;
  int barY = box.y + box.h – 15;
  int barW = box.w – 26;
  int barH = 8;

  tft.drawRect(barX, barY, barW, barH, COLOR_BORDER);
}

void drawStaticLayout() {
  tft.fillScreen(COLOR_BG);

  for (int i = 0; i < 6; i++) {
    drawStaticBox(boxes[i]);
  }

  // Reserved status line area
  tft.fillRect(0, tft.height() – STATUS_H, tft.width(), STATUS_H, COLOR_BG);
}

void updateBar(const StatBox &box, int value) {
  int barX = box.x + 16;
  int barY = box.y + box.h – 15;
  int barW = box.w – 26;
  int barH = 8;

  tft.fillRect(barX + 1, barY + 1, barW – 2, barH – 2, COLOR_CARD);

  if (value < 0) {
    return;
  }

  int clamped = constrain(value, 0, box.barMax);
  int fillW = map(clamped, 0, box.barMax, 0, barW – 2);

  tft.fillRect(barX + 1, barY + 1, fillW, barH – 2, box.color);
}

void makeValueText(const StatBox &box, int value, char *buffer, size_t bufferSize) {
  if (value < 0) {
    switch (box.format) {
      case FORMAT_PERCENT:
        snprintf(buffer, bufferSize, “– %%”);
        break;
      case FORMAT_TEMP_C:
        snprintf(buffer, bufferSize, “– C”);
        break;
      case FORMAT_MHZ:
        snprintf(buffer, bufferSize, “– MHz”);
        break;
      default:
        snprintf(buffer, bufferSize, “–“);
        break;
    }
    return;
  }

  switch (box.format) {
    case FORMAT_PERCENT:
      snprintf(buffer, bufferSize, “%d %%”, value);
      break;
    case FORMAT_TEMP_C:
      snprintf(buffer, bufferSize, “%d C”, value);
      break;
    case FORMAT_MHZ:
      snprintf(buffer, bufferSize, “%d MHz”, value);
      break;
    default:
      snprintf(buffer, bufferSize, “%d”, value);
      break;
  }
}

void updateValue(const StatBox &box, int value) {
  char valueText[24];
  makeValueText(box, value, valueText, sizeof(valueText));

  int valueX = box.x + box.w / 2;
  int valueY = box.y + box.h / 2 + 5;

  // Clear value area only
  tft.fillRect(box.x + 14, box.y + 24, box.w – 24, 25, COLOR_CARD);

  tft.setTextDatum(MC_DATUM);
  tft.setTextColor(COLOR_TEXT, COLOR_CARD);
  tft.setTextSize(1);
  tft.drawString(valueText, valueX, valueY, 4);
}

void updateStatBox(int index, int value, int oldValue) {
  if (value == oldValue) {
    return;
  }

  updateValue(boxes[index], value);
  updateBar(boxes[index], value);
}

void updateDashboardValues() {
  tft.startWrite();

  updateStatBox(0, stats.cpu,      oldStats.cpu);
  updateStatBox(1, stats.cpuTemp,  oldStats.cpuTemp);
  updateStatBox(2, stats.ram,      oldStats.ram);
  updateStatBox(3, stats.cpuClock, oldStats.cpuClock);
  updateStatBox(4, stats.gpuLoad,  oldStats.gpuLoad);
  updateStatBox(5, stats.gpuTemp,  oldStats.gpuTemp);

  tft.endWrite();

  oldStats = stats;
}

void updateStatusLine() {
  bool dataStale = (lastPacketMs == 0 || millis() – lastPacketMs > 3000);

  if (dataStale == oldStaleState && millis() – lastStatusUpdateMs < 500) {
    return;
  }

  oldStaleState = dataStale;
  lastStatusUpdateMs = millis();

  int statusY = tft.height() – STATUS_H;

  tft.fillRect(0, statusY, tft.width(), STATUS_H, COLOR_BG);

  tft.setTextDatum(MC_DATUM);
  tft.setTextSize(1);

  if (dataStale) {
    tft.setTextColor(TFT_RED, COLOR_BG);

    if (lastPacketMs == 0) {
      tft.drawString(“Waiting for PC data…”, tft.width() / 2, statusY + STATUS_H / 2, 2);
    } else {
      tft.drawString(“PC data timeout”, tft.width() / 2, statusY + STATUS_H / 2, 2);
    }
  } else {
    tft.setTextColor(TFT_GREEN, COLOR_BG);
    tft.drawString(“LIVE”, tft.width() / 2, statusY + STATUS_H / 2, 2);
  }
}

void setup() {
  Serial.begin(115200);
  delay(500);

  pinMode(TFT_BL, OUTPUT);
  digitalWrite(TFT_BL, HIGH);

  tft.init();
  tft.setRotation(1);

  setupLayoutValues();
  drawStaticLayout();

  touchSPI.begin(14, 12, 13, TOUCH_CS);
  ts.begin(touchSPI);
  ts.setRotation(0);

  updateDashboardValues();
  updateStatusLine();

  Serial.println(“ESP32 PC Stats Dashboard ready”);
}

void loop() {
  readSerialData();

  if (dataDirty) {
    updateDashboardValues();
    updateStatusLine();
    dataDirty = false;
  }

  if (millis() – lastStatusUpdateMs > 500) {
    updateStatusLine();
  }
}

pc_sender_skript.py

This Python sender script runs on the Windows PC. It reads CPU and RAM values with psutil, reads CPU/GPU temperature and GPU load from the LibreHardwareMonitor JSON endpoint, and sends the values to the ESP32 over USB serial.

Serial format: S,CPU,RAM,GPU_LOAD,CPU_TEMP,GPU_TEMP,CPU_CLOCK_MHZ

pc_sender_skript.py

import argparse
import json
import re
import time
import urllib.error
import urllib.request

import psutil
import serial


class LibreHardwareMonitorJsonReader:
    def __init__(self, url):
        self.url = url

    def _load_json(self):
        try:
            with urllib.request.urlopen(self.url, timeout=2) as response:
                return json.loads(response.read().decode("utf-8", errors="replace"))
        except urllib.error.URLError as exc:
            print(f"[WARN] Could not read LibreHardwareMonitor JSON: {exc}")
            return None
        except Exception as exc:
            print(f"[WARN] JSON read error: {exc}")
            return None

    def _walk(self, node, path=""):
        text = str(node.get("Text", "")).strip()
        value = str(node.get("Value", "")).strip()

        current_path = f"{path} / {text}" if text else path

        if value:
            yield current_path, text, value

        for child in node.get("Children", []):
            yield from self._walk(child, current_path)

    def _parse_number(self, value_text):
        value_text = value_text.replace(",", ".")
        match = re.search(r"-?\d+(\.\d+)?", value_text)

        if not match:
            return None

        return float(match.group(0))

    def read(self):
        result = {
            "cpu_temp": -1,
            "gpu_temp": -1,
            "gpu_load": -1,
        }

        data = self._load_json()

        if data is None:
            return result

        cpu_temp_candidates = []
        gpu_temp_candidates = []
        gpu_load_candidates = []

        cpu_tokens = [
            "cpu",
            "ryzen",
            "intel core",
            "core i",
            "core ultra",
            "processor",
        ]

        gpu_tokens = [
            "gpu",
            "nvidia",
            "geforce",
            "rtx",
            "gtx",
            "radeon",
            "rx ",
            "arc",
        ]

        motherboard_tokens = [
            "mainboard",
            "motherboard",
            "nuvoton",
            "ite",
            "asus",
            "prime b550-plus",
        ]

        for path, text, value_text in self._walk(data):
            path_lower = path.lower()
            text_lower = text.lower()
            value_lower = value_text.lower()

            value = self._parse_number(value_text)

            if value is None:
                continue

            is_temperature = "°c" in value_lower or " c" in value_lower
            is_percent = "%" in value_lower

            is_cpu_path = any(token in path_lower for token in cpu_tokens)
            is_gpu_path = any(token in path_lower for token in gpu_tokens)
            is_motherboard_path = any(token in path_lower for token in motherboard_tokens)

            # CPU temperature: prefer CPU hardware node, not motherboard sensor chip
            if is_temperature and is_cpu_path and not is_motherboard_path:
                score = 0

                if "package" in text_lower:
                    score += 50
                if "tctl" in text_lower or "tdie" in text_lower:
                    score += 50
                if "core max" in text_lower:
                    score += 40
                if "cpu" in text_lower:
                    score += 30
                if "core" in text_lower:
                    score += 20

                cpu_temp_candidates.append((score, value, path))

            # GPU temperature
            if is_temperature and is_gpu_path:
                score = 0

                if "gpu core" in text_lower:
                    score += 50
                if "hot spot" in text_lower:
                    score += 40
                if "gpu" in text_lower:
                    score += 30
                if "core" in text_lower:
                    score += 20

                gpu_temp_candidates.append((score, value, path))

            # GPU load
            if is_percent and is_gpu_path and "load" in path_lower:
                score = 0

                if "gpu core" in text_lower:
                    score += 50
                if "gpu" in text_lower:
                    score += 40
                if "3d" in text_lower:
                    score += 30
                if "d3d" in text_lower:
                    score += 30
                if "core" in text_lower:
                    score += 20

                gpu_load_candidates.append((score, value, path))

        if cpu_temp_candidates:
            cpu_temp_candidates.sort(key=lambda item: (item[0], item[1]), reverse=True)
            result["cpu_temp"] = round(cpu_temp_candidates[0][1])

        if gpu_temp_candidates:
            gpu_temp_candidates.sort(key=lambda item: (item[0], item[1]), reverse=True)
            result["gpu_temp"] = round(gpu_temp_candidates[0][1])

        if gpu_load_candidates:
            gpu_load_candidates.sort(key=lambda item: (item[0], item[1]), reverse=True)
            result["gpu_load"] = round(gpu_load_candidates[0][1])

        return result


def clamp_percent(value):
    return max(0, min(100, int(round(value))))


def read_cpu_clock_mhz():
    """Return current CPU clock speed in MHz, or -1 if unavailable."""
    try:
        freq = psutil.cpu_freq()
    except Exception:
        return -1

    if freq is None or freq.current is None:
        return -1

    return max(0, int(round(freq.current)))


def main():
    parser = argparse.ArgumentParser(description="Send Windows PC stats to ESP32 over serial.")

    parser.add_argument("port", help="ESP32 COM port, for example COM5")
    parser.add_argument("--baud", type=int, default=115200, help="Serial baud rate")
    parser.add_argument("--interval", type=float, default=1.0, help="Update interval in seconds")
    parser.add_argument(
        "--lhm-url",
        default="http://localhost:8085/data.json",
        help="LibreHardwareMonitor JSON endpoint",
    )

    args = parser.parse_args()

    hardware = LibreHardwareMonitorJsonReader(args.lhm_url)

    print(f"[OK] Opening serial port {args.port} at {args.baud} baud...")
    ser = serial.Serial(args.port, args.baud, timeout=1)

    time.sleep(2)

    psutil.cpu_percent(interval=None)

    print("[OK] Sending PC stats to ESP32.")
    print("[INFO] Format: S,CPU,RAM,GPU_LOAD,CPU_TEMP,GPU_TEMP,CPU_CLOCK_MHZ")
    print("[INFO] Press CTRL+C to stop.\n")

    try:
        while True:
            cpu_percent = clamp_percent(psutil.cpu_percent(interval=0.2))
            ram_percent = clamp_percent(psutil.virtual_memory().percent)
            cpu_clock_mhz = read_cpu_clock_mhz()

            hw = hardware.read()

            gpu_load = int(hw["gpu_load"])
            cpu_temp = int(hw["cpu_temp"])
            gpu_temp = int(hw["gpu_temp"])

            line = (
                f"S,"
                f"{cpu_percent},"
                f"{ram_percent},"
                f"{gpu_load},"
                f"{cpu_temp},"
                f"{gpu_temp},"
                f"{cpu_clock_mhz}\n"
            )

            ser.write(line.encode("ascii"))
            ser.flush()

            print(line.strip())

            time.sleep(args.interval)

    except KeyboardInterrupt:
        print("\n[OK] Stopped.")

    finally:
        ser.close()


if __name__ == "__main__":
    main()

11. Common Problems

The display stays white

Check the display pin setup, display driver, power, backlight connection, and SPI pin assignment.

The PC cannot connect to the ESP32

Close the Arduino Serial Monitor, check the COM port, and reconnect the ESP32 if the port changed.

Temperatures or GPU values are missing

Make sure LibreHardwareMonitor is running and the required sensors are visible.

CPU clock speed does not look correct

Some systems report nominal speed instead of live boost speed. Use the values from LibreHardwareMonitor when possible.

12. Final Result

The final result is a compact DIY PC status monitor with a laser-cut enclosure, an ESP32, and an external display. It shows live system values directly on the desk and is useful while gaming, editing, rendering, or testing hardware.