PC-Upgrade

Projekt-Steckbrief

• Schwierigkeit: Amateur 3/5
• Kosten: ~500€
• Zeitaufwand: ~20h

Ziel und Motivation

Im Jahr 2006 hatte ich mir einen Spiele-PC gegönnt. Als Gehäuse kaufte ich ein HTPC-Gehäuse. Es ist relativ flach und passt in das Rack einer Stereoanlage. 2015 tauschte ich ein erstes mal das Innenleben, als mir die Hardware zu langsam wurde. Ende 2025 war es wieder so weit: Das Netzteil zeigte sich mit der Leistungsaufnahme der neuen Grafikkarte überfordert, die Festplatten liefen voll und Spiele nicht mehr stabil.

Umbauten

Kurz: Es muss neue Hardware her. Doch diese erzeugt viel mehr Abwärme als die Vorherige. Zur Optimierung des Luftstroms sind daher einige Umbauten vorzunehmen. Klingt doch nach einem tollen Projekt mit vielen Facetten, die dieses Blog ausmachen: Mechanik, Elektronik, Software, CNC-fräsen.

Neue Komponenten

Einzubauen sind

• 650W Enermax Netzteil ersetzt 400W
• Neues Motherboard MSI B550
• AMD Ryzen5600x ersetzt Intel i5-6500
• 32GB DDR4 RAM statt 16GB
• 1TB PCIE SSD statt SATA SSDs
• 140mm Lüfter in 5.25” Schacht
• 2x60mm Lüfter in hintere Auslässe
• 96mm Lüfter für CPU, neuer Heatpipe-Kühler

Die meisten Komponenten besorge ich mir gebraucht. Nur Netzteil, Platte und Lüfter sind Neuware. Doch schnell zeigt sich, dass ich das Gehäuse modifizieren muss: Die Grafikkarte kollidiert mit dem 3.5”-Schacht, wo bis dato Festplatten und Kartenlesegerät untergebracht waren. Der große 140mm-Lüfter passt nur an die Stelle, wo sich der 5.25”-Schacht befindet.

Also müssen beide Schächte entfernt oder mit dem Trennschleifer bearbeitet werden, um Platz zu schaffen. Außerdem benötige ich eine Montagevorrichtung für den Lüfter vor der 5.25”-Öffnung. Hingucker für das Gehäuse wäre es jetzt noch, die Laufwerkklappe automatisch steuern zu können. Dann würde sie nur bei laufendem Lüfter unter hoher Rechenlast geöffnet und im Normalbetrieb geschlossen bleiben.

Anpassung des Gehäusedeckels

In meinem Artikel zum Thema Fräsen von SECC-Stahlblech zeige ich, wie man den Gehäusedeckel zwecks besserer Belüftung der Grafikkarte mit zusätzlichen Schlitzen ausstattet.

3.5”-Schacht

Die Grafikkarte ist so lang, dass sie 1cm Überlappung mit dem 3.5”-Schacht besitzt. Zum Glück lässt sich der Schacht im Handumdrehen ausbauen. Also nehme ich den Trennschleifer zur Hand und bringe einen Ausschnitt in die Halterung ein. Anschließend bohre ich ein paar zusätzliche Löcher in die Seiten des Schachtes, sodass meine 2.5”-SSDs auf der von der Grafikkarte abgewandten Seite des Schachtes befestigt werden können. Auch der Schachtdeckel erhält ein weiteres Loch zur Befestigung am Gehäuse, da zwei Rastnasen durch den Ausschnitt für die Grafikkarte entfallen.

Der Kartenleser nutzt die volle Tiefe des Schachtes aus. Ich fürchte also schon, ihn gar nicht wieder montiert zu bekommen. Probehalber öffne ich sein Gehäuse und siehe da: Nur das vorderste Drittel wird tatsächlich von Leiterplatten belegt. Der hintere Teil ist anscheinend nur dafür da, Befestigungsmöglichkeiten zu bieten. Also trenne ich den hinteren Teil des Kartenlesergehäuses kurzerhand ab und baue alles wieder zusammen, sodass er sich nun passend im Schacht anbringen lässt.

5.25”-Schacht

Der Schacht ist hoch genug, um zwei Laufwerke aufzunehmen. Ich benutze aber kaum noch CDs bzw. DVDs - und wenn, dann tut es auch ein externes Laufwerk. Den leeren Laufwerkkäfig kann ich also ausbauen und stattdessen an seiner Stelle einen Lüfter montieren. Dafür entwerfe ich im CAD eine Adapterplatte, die Befestigungsmöglichkeiten und Ausschnitte für den Lüfter enthält.

Lüfterplatzierung

Ich setze Gehäuselüfter gezielt ein, um zwei voneinander getrennte Luftströmungen im PC-Gehäuse zu erzeugen: Die CPU-Netzeil-Strömung verläuft an der Gehäusefront über einen 140mm-Lüfter an den CPU-Kühler, von wo aus die Warme Luft durch Netzteil und zwei weitere 60mm-Gehäuselüfter hinaus geleitet werden.

Der Luftstrom zur Grafikkarte wird über einen außerhalb des Gehäuses verbauten 140mm-Lüfter gestützt. Die Grafikkarte selbst fördert die erwärmte Luft direkt über den Gehäusedeckel nach draußen. Um den externen Lüfter anzuschließen, schneide ich ein Loch in eine Slotblende für PCI-Einbauschächte. Dort hinein passt genau die Buchse eines Lüftersteckers. Mittels Heißkleber sichere ich die Buchse in der Blende und schließe sie sonst den Lüfter auch an einen AUX-FAN Anschluss an.

Klappensteuerung

Nun soll die Frontklappe noch automatisch öffnen, sobald der Lüfter dreht. Ist zwar komplizierter als wenn ich das von Hand mache, aber dieses Gimmick macht das Gehäuse doch erst richtig interessant. Ich entferne also das Klappenschloss und füge der Adapterplatte eine Halterung für ein Modellbauservo hinzu, welches die Klappe öffenn und schließen können soll.

Elektronik

Das Servo benötigt eine Ansteuerung. Außerdem möchte ich die Klappenzustand wie den Lüfter auch temperaturabhängig regeln, sodass ich die an dem Lüfter angelegte Spannung einlesen muss. Hierfür setze ich den Microcontroller ATTINY44 ein. Die Schaltung habe ich nur mit den allernötigsten Komponenten bestückt:

Der Microcontroller gibt ein pulsweitengesteuertes Signal an den Servo aus. Dessen Spannungsversorgung wird über einen Elko gepuffert. Die Energieversorgung für den Gehäuselüfter leite ich über zwei Steckerleisten weiter. Dort greife ich das Signal mittels Spannungsteiler ab und führe es einem Analogeingang zu. Ansonsten ist nur ein weiterer Widerstand verbaut, der den RESET-Eingang des Microcontrollers auf VCC zieht und ihn so in Betrieb hält.

Software-Anforderungen

Die Anforderungen an die Software sind einfach und klar:

1. Wenn der Lüfter steht, soll die Klappe schließen
2. Ist der Lüfter in Betrieb, soll die Klappe öffnen
3. Damit die Klappe nicht zu oft hin- und her fährt, soll der Klappenzustand mit etwas Verzögerung geändert werden und auch nur dann, wenn der Lüfter in der Zwischenzeit seinen Zustand beibehalten hat.

Die daraus entstandene Software ist auf meinem Github-Account frei verfügbar.

Software: Hauptschleife

Bei der Ansteuerung des Modellbauservos mache ich es mir einfach: Ich verwende die Servo-Bibliothek von Arduino.

Das Programm macht nicht viel. Ich initialisiere das Servo servoHatch, welches später im Programm angesteuert wird, definiere ein paar wenige Variablen und lege fest, auf welchem Pin der Spannungsteiler vom Lüfter liegt. Die Hauptschleife begnügt sich damit, die Spannung am Lüfter einzulesen und basierend darauf zu entscheiden, ob sich die Klappe bewegen sollte.

Die Auswertung übergebe ich dann der Klappensteuerung. Anschließend wartet das Programm 15ms und läuft dann erneut los.

Servo servoHatch;       // create Servo object to control a servo
uint16_t fanVoltage{0};    // variable to read the value from the analog pin
bool open{false};

void setup() {
    pinMode(pinFanVoltage, INPUT);
}

void loop() {
    fanVoltage = analogRead(pinFanVoltage);    // reads the value of the fan voltage (value between 0 and 1023)
    open = mapHatchState(fanVoltage);

    
    setHatch(open);
    delay(15);                           // waits for the servo to get there
}

Software: Hysterese

Mit der Funktion mapHatchState lege ich den Sollzustand der Klappe in Abhängigkeit der Spannung am Lüfter fest.

Liegt die Spannung lange genug unter etwa 4.8V, so schließt die Klappe oder behält ihren geschlossenen Zustand bei. Liegt sie darüber, soll die Klappe geöffnet werden. Der Dauer des Zustandswechsels hängt von der Spannung selbst ab; bei Werten weit ab vom Schwellwert läuft der Aggregator schneller voll und der Klappenzustand wird ebenfalls zügiger verändert.

bool mapHatchState(uint16_t voltage){
    #define maxint 32767 - 1024
    #define minint -32768 + 1024
    static int16_t vAggregate{0};
    static bool hatchOpen{false};

    // Divider VCC 33k T 22k GND, 12V fan will yield 4.8V at divider --> 983 digit
    // So a value of 410 is roughly 5V which allows Fan start + hatch open
    vAggregate = vAggregate + voltage - 410;
    if (vAggregate > maxint) {
        vAggregate = maxint;
        hatchOpen = true;
    }
    else if (vAggregate < minint) {
        vAggregate = minint;
        hatchOpen = false;
    }

    return hatchOpen;
}

Software : Klappe bewegen

Die Funktion setHatch() prüft den gewünschten Zustand der Klappe und bewegt sie, falls sie vom aktuellen Zustand abweicht, dort hin. Dabei wird dem Servo mittels write() ein Zielwinkel vorgegeben, der eingestellt und gehalten werden soll. Die Bewegung geschieht graduell und über die Iteration von hatchState, da die Klappe sich mir sonst viel zu ruckartig und schnell bewegt.

Test der Klappensteuerung durch Verstellen der Lüfterspannung

void setHatch(bool open){
    static uint8_t hatchState{180};  // variable to capture current position, default closed
    static bool wasMoving{false};
    bool isMoving{false};

    if (open && (hatchState > 0)){
        hatchState--;
        isMoving = true;
    } else if (!open  && (hatchState < 180)) {
        hatchState++;
        isMoving = true;
    }


    if (!wasMoving && isMoving) {
        servoHatch.attach(portServo);  // connect servo on start
    }
    else if (wasMoving && !isMoving) {
        servoHatch.detach();  // disconnect servo on finish
    }

    servoHatch.write(hatchState);
    wasMoving = isMoving;
}

Die Funktionen attach() und detach() definieren den Signalausgang zum Servo, ordnen also den Pin des Microcontrollers intern dem Servo so zu, wie er tatsächlich verdrahtet ist. Bei meinen Experimenten fand ich heraus, dass das Servo im Stillstand bei detached nur wenig Energie benötigt - viel weniger, als wenn ich es attached lasse und nur kein weiteres Bewegungssignal sende. Daher melde ich es für jede Bewegung an und danach wieder ab.

Ergebnis

Ich erhalte einen schön aufgeräumten, modernen PC. Mittels diverser Bloatware-Lösungen (die ich nach getaner Arbeit direkt wieder deinstalliere) schaffe ich es nach einigem Fluchen, alle LED-Farben aufeinander abzustimmen. Besonderes Highlight ist die automatische Klappe, welche bei höherer CPU-Last samt Lüfter aktiviert wird.