Sistemul inteligent de răcire pentru PC este un dispozitiv embedded care monitorizează temperatura din interiorul unui calculator și controlează automat viteza unui ventilator în funcție de temperatura măsurată. Proiectul pornește de la ideea unui termometru inteligent, dar este adaptat pentru zona de răcire hardware, unde scopul principal nu este doar afișarea temperaturii, ci și reacția automată la creșterea acesteia.

Dispozitivul măsoară temperatura cu ajutorul unui termistor montat într-o zonă relevantă din carcasă, de exemplu lângă radiator, lângă zona de evacuare a aerului sau în apropierea unei componente care se încălzește. Microcontroller-ul procesează periodic datele primite de la senzor și ajustează viteza ventilatorului printr-un semnal PWM. Astfel, ventilatorul poate funcționa lent atunci când temperatura este mică, pentru a reduce zgomotul, și poate crește progresiv în turație atunci când temperatura urcă.

Scopul proiectului este realizarea unui controller de răcire independent pentru PC, capabil să:

• măsoare temperatura în timp real;
• afișeze temperatura curentă și nivelul de putere al ventilatorului;
• controleze automat viteza ventilatorului;
• ofere feedback vizual prin LED-uri pentru zonele de temperatură;
• reacționeze mai agresiv dacă temperatura crește rapid.

Ideea proiectului a pornit de la faptul că multe sisteme de răcire sunt fie prea zgomotoase, fie nu reacționează suficient de rapid în momentul în care temperatura crește brusc. Un ventilator care merge constant la turație mare produce zgomot inutil, iar unul care pornește prea târziu poate permite încălzirea excesivă a componentelor. Proiectul propune o soluție intermediară: o curbă de control calculată software, care ține cont atât de temperatura actuală, cât și de rata de creștere a temperaturii.

Acest proiect este util deoarece:

• permite controlul automat al unui ventilator de PC;
• reduce zgomotul atunci când sistemul este rece;
• crește capacitatea de răcire când temperatura devine ridicată;
• oferă o metodă practică de înțelegere a senzoristicii analogice, PWM-ului și controlului în buclă;
• poate fi extins ulterior cu afișare RPM, mai mulți senzori sau mai multe ventilatoare.

Sistemul este organizat în mai multe module funcționale care comunică prin intermediul microcontroller-ului. Microcontroller-ul citește temperatura, calculează viteza necesară pentru ventilator și controlează ieșirile către display, LED-uri și ventilator.

Schema bloc a sistemului:

┌──────────────────────────────────────────────────────────────────────┐
│                  Sistem inteligent de răcire pentru PC               │
│                                                                      │
│  ┌──────────────────┐                                                │
│  │ Termistor NTC    │                                                │
│  │ 10kΩ             │──── semnal analogic ─────┐                     │
│  └──────────────────┘                          │                     │
│                                                ▼                     │
│                                      ┌──────────────────────┐        │
│                                      │                      │        │
│  ┌──────────────────┐                │   Arduino UNO /      │        │
│  │ Buton MODE       │──── digital ──►│   ATmega328P         │        │
│  └──────────────────┘                │                      │        │
│                                      │   - citește ADC      │        │
│  ┌──────────────────┐                │   - calculează temp. │        │
│  │ Buton MINUS      │──── digital ──►│   - calculează PWM   │        │
│  └──────────────────┘                │   - controlează I/O  │        │
│                                      │                      │        │
│  ┌──────────────────┐                └──────────┬───────────┘        │
│  │ Buton PLUS       │──── digital ──────────────┘                    │
│  └──────────────────┘                                                │
│                                                                      │
│              ┌────────────────────────────┬───────────────────────┐  │
│              ▼                            ▼                       ▼  │
│  ┌─────────────────────┐       ┌──────────────────┐    ┌──────────────┐
│  │ Display 4 cifre     │       │ LED verde/galben │    │ Driver MOSFET│
│  │ + 74HC595           │       │ /roșu            │    │ + ventilator │
│  └─────────────────────┘       └──────────────────┘    └──────────────┘
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

Modulele principale ale proiectului sunt:

• Unitatea de control - Arduino UNO / ATmega328P
  • citește valoarea analogică de la termistor;
  • convertește citirea ADC în temperatură;
  • calculează rata de creștere a temperaturii;
  • decide nivelul PWM pentru ventilator;
  • actualizează display-ul și LED-urile;
  • gestionează butoanele de configurare.

• Modulul de senzoristică
  • este format dintr-un termistor NTC de 10kΩ și un rezistor de 10kΩ într-un divizor de tensiune;
  • produce o tensiune variabilă în funcție de temperatură;
  • tensiunea este citită de microcontroller pe un pin analogic;
  • permite estimarea temperaturii din interiorul carcasei PC-ului.

• Modulul de control al ventilatorului
  • ventilatorul de 12V este controlat printr-un tranzistor MOSFET logic-level;
  • microcontroller-ul nu alimentează direct ventilatorul, ci doar controlează poarta MOSFET-ului;
  • viteza ventilatorului este reglată prin PWM;
  • sursa de 12V a ventilatorului și Arduino trebuie să aibă masă comună.

• Modulul de afișare
  • display-ul cu 4 cifre afișează temperatura curentă sau procentul de putere al ventilatorului;
  • controlul segmentelor se face printr-un registru de deplasare 74HC595;
  • afișarea poate alterna între temperatura curentă și nivelul ventilatorului.

• Modulul de feedback vizual
  • LED-ul verde indică temperatură normală;
  • LED-ul galben indică temperatură moderată;
  • LED-ul roșu indică temperatură ridicată;
  • LED-urile oferă feedback rapid fără ca utilizatorul să urmărească permanent display-ul.

• Modulul de interacțiune cu utilizatorul
  • butonul MODE schimbă modul de afișare sau intră în modul de configurare;
  • butoanele PLUS și MINUS pot modifica pragurile de temperatură sau intensitatea minimă a ventilatorului;
  • butoanele folosesc rezistențe de pull-up sau `INPUT_PULLUP`.

Interacțiunea dintre module:

• Termistorul transmite către Arduino o tensiune dependentă de temperatură.
• Arduino transformă tensiunea citită într-o valoare de temperatură.
• Pe baza temperaturii și a ratei de creștere, Arduino calculează un nivel PWM.
• Semnalul PWM comandă MOSFET-ul, care controlează alimentarea ventilatorului.
• Display-ul afișează temperatura sau nivelul de putere al ventilatorului.
• LED-urile indică zona termică în care se află sistemul.
• Utilizatorul poate modifica pragurile sau modul de funcționare prin butoane.

Funcția de control propusă pentru ventilator:

fanPWM = clamp(PWM_min + k1 * (T - T_min) + k2 * dT_dt, PWM_min, PWM_max)

unde:

• `T` este temperatura curentă;
• `dT_dt` este rata de creștere a temperaturii;
• `PWM_min` este viteza minimă la care ventilatorul pornește stabil;
• `PWM_max` este viteza maximă;
• `k1` controlează influența temperaturii;
• `k2` controlează reacția la creșteri rapide de temperatură.

Astfel, dacă temperatura este mare, ventilatorul va accelera. Dacă temperatura încă nu este foarte mare, dar crește rapid, ventilatorul va începe să accelereze preventiv.

Termistorul NTC de 10kΩ va fi folosit într-un divizor de tensiune împreună cu un rezistor de 10kΩ. Punctul median al divizorului va fi conectat la pinul analogic A0. Pe măsură ce temperatura crește, rezistența termistorului se modifică, ceea ce duce la modificarea tensiunii citite de ADC.

Citirea brută de la ADC va fi convertită software în temperatură. Pentru etapa inițială, este suficientă măsurarea relativă a temperaturii și calibrarea practică la temperatura camerei. În etapa software, conversia poate fi îmbunătățită folosind formula Steinhart-Hart sau un model Beta pentru termistor.

Ventilatorul de PC funcționează la 12V, deci nu va fi alimentat direct de pe Arduino. Arduino va genera doar semnalul de control PWM, iar comutarea curentului prin ventilator va fi făcută de MOSFET.

Conexiune propusă pentru MOSFET:

• sursa MOSFET-ului se conectează la GND;
• drena MOSFET-ului se conectează la borna negativă a ventilatorului;
• borna pozitivă a ventilatorului se conectează la +12V;
• poarta MOSFET-ului se conectează la pinul PWM D9 printr-un rezistor de 220Ω - 330Ω;
• între poartă și GND se pune un rezistor de 10kΩ pentru pull-down;
• masa sursei de 12V trebuie legată la masa Arduino.

Această soluție permite controlul vitezei ventilatorului prin modificarea factorului de umplere al semnalului PWM.

Display-ul va fi folosit pentru afișarea temperaturii sau a procentului de putere al ventilatorului. Pentru reducerea numărului de pini folosiți, segmentele vor fi controlate printr-un registru de deplasare 74HC595.

Display-ul poate avea două moduri principale:

• afișare temperatură, de exemplu `32.5C`;
• afișare putere ventilator, de exemplu `F075`, pentru 75%.

LED-urile oferă o interpretare rapidă a temperaturii:

• LED verde: temperatură normală;
• LED galben: temperatură în creștere / zonă moderată;
• LED roșu: temperatură ridicată, ventilator aproape de turație maximă.

Pragurile propuse inițial:

• sub 35°C: LED verde;
• între 35°C și 50°C: LED galben;
• peste 50°C: LED roșu.

Aceste praguri pot fi modificate ulterior în funcție de poziționarea senzorului și de comportamentul real al sistemului.

Cele trei butoane vor fi folosite pentru interacțiunea cu sistemul:

• MODE: schimbă între afișarea temperaturii și afișarea nivelului ventilatorului;
• PLUS: crește un prag de temperatură sau viteza minimă;
• MINUS: scade un prag de temperatură sau viteza minimă.

Butoanele vor fi citite folosind `INPUT_PULLUP`, deci în stare normală pinul va fi HIGH, iar la apăsare va deveni LOW.

• Ventilatorul nu trebuie alimentat direct din pinul Arduino.
• Sursa de 12V pentru ventilator trebuie să aibă masă comună cu Arduino.
• MOSFET-ul trebuie să fie logic-level, pentru a putea fi comandat corect la 5V.
• Pentru testare, sistemul poate fi alimentat cu Arduino prin USB și ventilatorul printr-o sursă separată de 12V.
• În etapa de testare, valorile temperaturii vor fi urmărite și în Serial Monitor pentru calibrare.
• Poziționarea termistorului este importantă: dacă este prea aproape de ventilator, temperatura măsurată poate fi mai mică decât temperatura reală a zonei calde.

TODO — va fi completat în etapa următoare.

Pentru etapa software, se plănuiește implementarea următoarelor funcționalități:

• citirea periodică a temperaturii de pe pinul A0;
• conversia valorii ADC în grade Celsius;
• calcularea ratei de creștere a temperaturii;
• generarea unei valori PWM pentru ventilator;
• afișarea temperaturii și a procentului de turație;
• controlul LED-urilor în funcție de pragurile definite;
• citirea butoanelor cu debouncing;
• mod de configurare pentru pragurile de temperatură.

Algoritmul principal va avea următoarea structură:

setup:
  configurează pinii
  inițializează display-ul
  inițializează comunicarea serială
  setează pragurile implicite

loop:
  citește temperatura la interval fix
  calculează rata de creștere a temperaturii
  calculează PWM-ul pentru ventilator
  actualizează ventilatorul
  actualizează LED-urile
  actualizează display-ul
  citește butoanele

TODO — va fi completat după implementarea și testarea proiectului.

Rezultatele urmărite sunt:

• citirea stabilă a temperaturii;
• control vizibil al vitezei ventilatorului;
• afișare corectă pe display;
• reacție automată la creșteri de temperatură;
• feedback vizual corect prin LED-uri.

TODO — va fi completat la finalul proiectului.

Proiectul își propune să demonstreze folosirea practică a senzoristicii analogice, a controlului PWM și a unui algoritm simplu de reglare pentru un sistem fizic real. Prin combinarea temperaturii curente cu rata de creștere a temperaturii, sistemul poate deveni mai eficient decât un control simplu bazat doar pe praguri fixe.

TODO — se va adăuga arhiva proiectului după implementare.

Arhiva finală va conține:

• codul sursă;
• schema electrică;
• eventualele fișiere de proiect;
• README cu instrucțiuni de compilare și testare;
• ChangeLog.

• Arduino UNO Rev3 - documentație oficială
• 74HC595 Shift Register - datasheet
• NTC Thermistor - exemplu datasheet
• IRLZ44N MOSFET - datasheet
• Arduino PWM

• Arduino analogRead
• Arduino analogWrite
• Arduino millis
• Arduino pinMode

Export to PDF