Project Files of 4-Pin PC Fan Library for Proteus V1.0 (PWM, Tach, Arduino)

4-PIN PC FAN LIBRARY FOR PROTEUS - V1.0 (a 120 mm 12 V PWM fan with a working tach and a pop-up panel)
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/11/4-pin-pc-fan-library-for-proteus-v1-0.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/motor-driver-proteus-library
The demo runs on our Arduino UNO V4.0 (included) - working LEDs, RESET and a
built-in serial monitor, no Virtual Terminal to wire - its own article:
  https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
No driver is needed: the fan has its own controller (its PWM wire is a logic
input), so this package holds everything the demo uses.
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
4-Pin-PC-Fan-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                              201.9 KB   TEP Arduino boards V4.0 (UNO) -> LIBRARY
|   |-- TEPPCFAN.LIB                                   24.8 KB   the library -> LIBRARY folder
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                883.5 KB   the Arduino board model -> MODELS folder
|   |-- TEPPCFAN.DLL                                  303.5 KB   the model -> MODELS folder
|-- Proteus Simulation/
|   |-- 4-Pin-PC-Fan-ArduinoUnoV4.pdsprj               22.9 KB   the demo project
|   |-- PCFan_Demo.hex                                 15.5 KB   the demo firmware
|   |-- TEPARDUINO.DLL                                883.5 KB   copy of the board model
|   |-- TEPPCFAN.DLL                                  303.5 KB   copy of the model
|-- Arduino Code/
|   |-- PCFan_Demo/PCFan_Demo.ino                       4.3 KB   the demo sketch (source of the .hex)
|-- README.txt                                        ~19.0 KB   this file
Total: 2.60 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
A simulation model of the 4-pin 12 V PC fan (120 mm, the Intel 4-wire fan of
CPU coolers, PC cases, 3D printers, enclosures and power supplies). The fan
has its own brushless controller: it runs from +12V, takes a 25 kHz PWM signal
on its blue wire to set the speed and reports the speed on its green wire.
Our own model:
  * The four wires: GND (black), +12V (yellow), TACH (green), PWM (blue).
  * The controller's speed curve: 300 RPM at 20 % duty or less (it never
    stops on PWM alone - the Intel spec's minimum), 1,500 RPM at 100 %, a
    straight line between: 40 % = 600 RPM, 50 % = 750 RPM.
  * The PWM input is pulled up inside the fan: no signal (HIGH, or the wire
    left open) = full speed, a safe failure for cooling. PWM held LOW = the
    minimum. The model measures the frequency and the duty from the edges and
    warns when the PWM is outside the spec's 21 - 28 kHz (analogWrite's 490 Hz
    works, but a real fan may whine or hunt).
  * TACH is an open collector: 2 pulses a turn, LOW while the hall sensor sees
    one pole - it needs a pull-up (the Arduino's INPUT_PULLUP, or 10k to 5V).
    RPM = tach pulses a second x 60 / 2. Property TACHPULLUP gives the fan its
    own pull-up instead.
  * The blades follow the controller's target with a lag (1.2 s up, 2.5 s
    down: the air brakes them less than the drive pushes): 600 to 1,500 RPM in
    about 4.9 s to steady.
  * The supply: the controller starts at 7 V and runs down to 5 V; under 12 V
    the top speed falls with the voltage (9 V: 1,125 RPM at 100 %); no 12 V:
    the fan coasts to a stop and TACH floats.
  * A locked rotor (a finger on the blades): the tach stops, the controller
    cuts the drive and retries every 3 s (0.5 s pulses of 0.3 A, 0.02 A
    between) - the locked-rotor protection of real fans. Free the blades and
    it restarts.
  * The fan laws: the current (0.02 A for the electronics + 0.13 A x the
    speed cubed: 0.150 A at full speed, 0.029 A at 600 RPM), the airflow (60
    CFM at full speed, in proportion), the noise (25 dBA at full speed, 50
    log10 of the speed ratio less).
The symbol shows the fan from the front: the black square frame with its four
corner holes, the round opening, seven swept black blades on a hub with the
round "DC 12V 0.15A" label, and the four coloured wires to the pins. On the
sheet the blades turn at the simulated speed (faint copies at a slow turn, a
dark disc at speed, as the eye sees it); click the fan and a finger stops
them. The plate, its text, the PWR (red) and TACH (green, lit while the tach
pulses) LEDs and the strip under the plate (RPM, PWM, A, OPEN PANEL) are
TEP additions; the real fan has none of them.

ONE DEVICE (search "PC fan" in Pick Devices):
  PCFAN4PINTEP   "4-Pin PC Fan V1.0"   (category Electromechanical > Fans),
                 model TEPPCFAN.DLL
  The pop-up panel "TEP 4-Pin PC Fan" opens at Run (and with OPEN PANEL on the
  strip) - the look of the TEP Serial Monitor. Tabs Fan, Graphs, Event log and
  Check; gear and ? icons for Settings and Help; the palette icon switches the
  theme:
    Fan        the state in big letters (600 RPM - PWM 25.0 KHZ, 40 %, TACH
               20.0 HZ ...; PWM OUT OF SPEC; LOCKED ROTOR - NO TACH PULSES;
               NO 12 V); the speed dial (0 - 1,800 RPM, the blades blue, the
               controller's target orange); the live values (the blades, the
               target, the PWM, the tach, the RPM an Arduino counts from it,
               the current, the airflow, the noise); the PWM on the blue wire
               and the tach on the green wire as traces. The toolbar: the
               blades Free / Blocked (a finger).
    Graphs     the blades and the target, the PWM duty and the current over the
               last 5, 15 or 30 s. Live / Freeze.
    Event log  12 V on, every PWM change ("PWM 25.0 kHz, 40 % duty - the fan
               aims at 600 RPM"), every steady speed ("STEADY at 600 RPM after
               5.6 s - tach 20.0 Hz (2 a turn), 0.029 A, 24 CFM, about 10
               dBA"), no PWM signal, the locked rotor and the restart, the
               warnings; filters All / PWM + speed / Warnings, Pause, Clear
    Check      Good for: a fan that does not spin, ignores the PWM, reads 0
               RPM, or reads half / double the speed - 12 V, the PWM, the
               target, the speed, the tach, the counted RPM, the current, the
               air
    Settings   theme, text size, open at Run, window size
    Help       report a bug, suggest a feature, article, updates, donate,
               forum; Copy diagnostics for a bug report

TEST STATUS
V1.0: verified in Proteus 8.5 on 29 Oct 2026 (the demo project as shipped: an
A4 sheet, an Arduino UNO V4.0 with its built-in monitor, the fan on a +12V
supply with TACH on D2 and PWM on D9, RV1 on A0; the pop-up open). What the
runs showed:
  * The project loads and starts cleanly. RV1 at 40 %: "Pot 410: duty 40 % at
    25 kHz (Timer1)"; the fan: "PWM 25.0 kHz, 40 % duty - the fan aims at 600
    RPM", then "STEADY at 600 RPM after 5.6 s - tach 20.0 Hz (2 a turn),
    0.029 A, 24 CFM, about 10 dBA"; the monitor: "duty 40 %: 600 RPM (20 tach
    pulses in 1 s)"; the PWR and TACH LEDs lit, the blades turning.
  * "d 100" (the PWM pin held HIGH): "no PWM signal (HIGH or open: the fan
    pulls it up) - full speed, 1500 RPM", then "STEADY at 1500 RPM after 4.9 s
    - tach 50.0 Hz (2 a turn), 0.150 A, 60 CFM, about 25 dBA".
  * "d 10": "PWM 25.0 kHz, 10 % duty - the fan aims at 300 RPM (its minimum:
    it never stops on PWM)".
  * "slow" (analogWrite, 490 Hz): "PWM at 490 Hz is outside the fan's 21 - 28
    kHz: it follows the duty, but a real fan may whine or hunt (Timer1 at 25
    kHz fixes it)"; "d 50" there: 49.8 % (127/255), 747 RPM.
  * "fast": "PWM 25.0 kHz, 50 % duty - the fan aims at 750 RPM".
  * Blocked (a finger) at 750 RPM: "LOCKED ROTOR - the tach stopped: the
    controller cuts the drive and retries every 3 s", 0 RPM, 0.3 A pulses
    every 3 s on the Graphs page; Free: "the rotor turns again: the controller
    restarts the fan".
  * "knob": back to RV1 at 40 %, 600 RPM counted again from the tach.
  Plus automatic checks on a PC, 0 failed: 20 on the fan (25 kHz 40 %: 600
  RPM, tach 20 Hz, the RPM counted from the tach; 100 %: 1,500 RPM, 0.150 A,
  60 CFM, 25 dBA; 600 to 1,500 RPM: 90 % of the way in about 2.8 s; 10 %:
  300 RPM; no PWM: full speed; PWM LOW: the minimum; 490 Hz 50 %: 750 RPM and
  the warning; no 12 V: TACH floats; blocked: a locked rotor, 0.30 A pulses,
  0.02 A between, the restart; TACH an open collector, HIGH with TACHPULLUP;
  9 V: 1,125 RPM; 6 V does not start it, keeps it running; 4 V stops it);
  5 on the pop-up pages rendered; the demo project read back from disk (57
  checks: devices, pins, wires, labels, no wire through a part, no crossing).

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPPCFAN.LIB, and our Arduino
   library V4.0, ArduinoV4TEP.LIB, with the ARDUINO UNO V4.0 used by the demo)
   to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\
   LIBRARY - use the folder that already holds Proteus's own .LIB files).
3. Copy TEPPCFAN.DLL and TEPARDUINO.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
   ArduinoV4TEP.LIB and TEPARDUINO.DLL are the files of our Arduino Library
   V4.0 - if you have it, they are the same.
4. Delete TEPPCFAN.IDX from the LIBRARY folder if it is there (Proteus makes a
   new index).
5. Start Proteus. In Pick Devices (P) search "PC fan".

RUN THE DEMO
"Proteus Simulation\4-Pin-PC-Fan-ArduinoUnoV4.pdsprj" (an A4 sheet) - keep
the .hex file and the two DLLs beside the project.
  ARD1: Arduino UNO V4.0 running PCFan_Demo.hex, its serial monitor built in
        (window "TEP Arduino UNO - ARD1").
  FAN1: the fan - +12V on a +12V supply terminal, GND on ground, TACH on D2
        and PWM on D9 (by the net labels above both parts).
  RV1:  a 10k potentiometer (POT-HG) on A0: the PWM duty, 0 - 100 % (it
        starts at 40 %).
  1. Press Run. The monitor and the fan's pop-up open (move them aside - they
     open over the schematic). The fan runs up to 600 RPM; each second the
     sketch prints the RPM it counts from the tach.
  2. Click RV1's arrows: the duty and the speed follow (20 % and less: 300
     RPM, the fan's minimum).
  3. Type in the monitor and press Send: d 40, d 100, slow, fast, knob, help.
  4. Click the fan on the sheet (or Blocked on the pop-up): a finger stops
     the blades - LOCKED ROTOR; click again to free them.
  5. The fan's pop-up: Fan, Graphs, Event log, Check.
Closed a window? The monitor: click the UNO's USB port; the pop-up: OPEN PANEL.

WIRING (the same in Proteus and on a real board)
  Fan             Arduino UNO
   GND (black)    GND - common with the 12 V supply
   +12V (yellow)  a 12 V supply (not the Arduino's 5V)
   TACH (green)   D2 (INT0) with pinMode(2, INPUT_PULLUP) - or 10k to 5V
   PWM (blue)     D9 (OC1A: Timer1 at 25 kHz)
  Potentiometer   the ends to 5V and GND, the wiper to A0 (the demo's duty)
In the sketch (no library needed):
  Timer1 at 25 kHz on D9: fast PWM, TOP = ICR1 = 639 (16 MHz / 640)
    TCCR1A = _BV(COM1A1) | _BV(WGM11);
    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS10);
    ICR1 = 639;  OCR1A = duty * 640 / 100 - 1;
  the tach: attachInterrupt(digitalPinToInterrupt(2), onTach, FALLING);
    rpm = falls counted in one second x 30   (2 pulses a turn)
REAL HARDWARE:
 * Never pull the tach up to 12 V: it would put 12 V on the Arduino's pin.
   INPUT_PULLUP (20 - 50k to 5V inside the UNO) or 10k to 5V is right.
 * The PWM input is a logic input of the fan, pulled up inside (to 5 V or
   3.3 V): the Arduino's pin drives it directly, no transistor needed.
 * Many 4-pin fans keep a minimum speed at 0 % duty (some stop). To stop any
   fan, switch its 12 V with a logic-level MOSFET (or a relay).
 * Timer1 also runs D10 (OC1B) at the same 25 kHz - a second fan. Changing
   Timer1 stops the Servo library; it does not touch millis() (Timer0).
 * The GND of the 12 V supply and the Arduino must be common.

THE DEMO SKETCH ON THE SERIAL MONITOR (PCFan_Demo V1.0, 9600 baud)
  d 40      duty 40 % (RV1 is ignored until knob)
  knob      follow the pot on A0 again
  slow      PWM with analogWrite (490 Hz - outside the fan's spec)
  fast      PWM at 25 kHz again (Timer1)
  help      the list
EXPECTED MONITOR OUTPUT
  4-Pin PC Fan demo - The Engineering Projects
  PWM on D9 at 25 kHz (Timer1), TACH on D2 (INPUT_PULLUP, 2 pulses a turn). The pot on A0 sets the duty.
  Commands: d 40 | knob | slow | fast | help
  Pot 410: duty 40 % at 25 kHz (Timer1)
  duty 40 %: 600 RPM (20 tach pulses in 1 s)
  duty 100 % at 25 kHz (Timer1)
  slow: duty 10 % at 490 Hz (analogWrite)
  TACH: no pulses for 2 s - the fan has stopped (blocked, or no 12 V?)
While the speed changes, the counted RPM steps through the values on the way
(690, 660, 630 ...): the sketch counts whole pulses in one second, 30 RPM each.

PROPERTIES (double-click the part > Edit Properties)
  TACHPULLUP   NO (default): TACH is an open collector, as on the real fan -
               pull it up at the Arduino (INPUT_PULLUP); YES: the fan pulls it
               up itself (a weak HIGH), for a circuit without a pull-up
Every run starts again from the properties. The demo's UNO (ARDUINO UNO V4.0):
PROGRAM PCFan_Demo.hex, MONITOR YES (the built-in monitor), BAUD 9600,
AUTOOPEN YES, BOOTLOADER YES.

TROUBLESHOOTING
* The fan never turns and the pop-up says NO 12 V: +12V is not on a 12 V
  supply (the demo uses a +12V supply terminal) or GND is open. Under 7 V
  the controller does not start.
* Full speed whatever the duty: the PWM wire is open (the fan pulls it up) or
  the duty is 100 %.
* It never stops at 0 %: right - 300 RPM is the fan's minimum; switch its
  12 V to stop it.
* The sketch reads 0 RPM: TACH has no pull-up (INPUT_PULLUP, or set
  TACHPULLUP to YES), or it is on a pin without an interrupt (use D2 or D3).
* The RPM is half or double: the fan gives 2 pulses a turn - RPM = pulses a
  second x 30.
* PWM OUT OF SPEC on the pop-up: analogWrite's 490 Hz - use Timer1 at 25 kHz.
* The part is not simulated / the blades never turn: TEPPCFAN.DLL is missing
  from MODELS and from the project folder. No UNO / no monitor window:
  TEPARDUINO.DLL is missing, or click the UNO's USB port.
* The pop-up does not appear: click OPEN PANEL on the strip, or turn "Open the
  panel at Run" on its Settings page back on.

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot, the Serial Monitor text, the
simulation log and the pop-up's Copy diagnostics text:
  https://www.theengineeringprojects.com/forum/category/motor-driver-proteus-library

SUPPORT US
This library is free. If it saves you time, please support our work:
  https://www.theengineeringprojects.com/donate

WEBSITE
  https://www.theengineeringprojects.com/

LICENCES AND THIRD-PARTY NOTES
* The fan model (TEPPCFAN.DLL), the symbol and artwork and the Arduino
  Library V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL, with its built-in TEP Serial
  Monitor Advance) are made by The Engineering Projects. The model is an
  independent implementation written from the Intel 4-wire PWM fan
  specification and the typical data of 120 mm 12 V PC fans. The model uses
  only standard Windows libraries; no Visual C++ redistributable is needed.
  The C++ source code is not included.
* Arduino UNO V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL, our Arduino Library
  V4.0): The Engineering Projects,
  https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
* The potentiometer is Proteus's own POT-HG.
* The .hex file is built from the demo sketch and the Arduino AVR core 1.8.6,
  which includes LGPL-licensed code; its source code is available at
  https://github.com/arduino/ArduinoCore-avr/tree/1.8.6
* Proteus is a product of Labcenter Electronics and is not included. Arduino is
  a trademark of Arduino SA. This library is not made or endorsed by any fan
  maker, Intel, Arduino or Labcenter.

REBUILDING THE FIRMWARE (OPTIONAL)
The HEX file is supplied; Arduino IDE is not needed to run the demo. To edit the
sketch, open Arduino Code\PCFan_Demo\PCFan_Demo.ino, select Arduino Uno and use
Sketch > Export Compiled Binary. Replace the simulation's .hex with the
exported HEX. The sketch needs 5,632 bytes of flash (17 % of the UNO) and 262
bytes of RAM.

MODEL SCOPE AND LIMITS
Modelled: the controller's speed curve from the PWM duty (300 - 1,500 RPM),
the PWM's frequency and duty measured from its edges, the input's pull-up
(open = full speed), the blades' lag (1.2 s up, 2.5 s down), the tach (2
pulses a turn, an open collector or the fan's pull-up), the supply (starts at
7 V, runs down to 5 V, the top speed in proportion under 12 V), the
locked-rotor protection and its retries, the current, the airflow and the
noise by the fan laws.
How it runs: a mixed model - +12V / GND are analog (the fan's current drawn
from the supply), TACH and PWM digital; each tach edge is predicted and
scheduled exactly, with a 50 ms poll for the supply, the clicks and the log.
Not modelled: the ripple of the current at each commutation, the fan's
pressure curve (a filter or a heatsink in front of it), the noise's spectrum,
a 3-pin fan driven by switching its supply, the differences between real
fans (other models have other curves: 2,000 or 3,000 RPM, minimums of 0 or
30 %).

VERSION
TEP 4-Pin PC Fan library V1.0 (Oct 2026). Device PCFAN4PINTEP
(TEPPCFAN.LIB / TEPPCFAN.DLL). Demo sketch PCFan_Demo V1.0. Demo board:
ARDUINO UNO V4.0 (TEP Arduino Library V4.0) with its built-in serial monitor.