I did a recap using Google AI. This is the tool I used for coding and do research since I am not an expert at coding.I used an Arduino R4 wifi, same NTC controller, a fixed resistor for voltage divider (440 ohms) and this MOSFET
https://www.amazon.com/Anmbest-High...-Brightness/dp/B07NWD8W26/?tag=wranglerorg-20
1. The Hardware Setup:
Here's a quick rundown of the components I used:
- Microcontroller: Arduino UNO R4 WiFi (the brains of the operation!)
- Temperature Sensor: An NTC Thermistor (standard engine temperature sensor for cars).
- Voltage Divider: A simple resistor (R1) in series with the thermistor to convert resistance changes into voltage changes, readable by the Arduino's Analog-to-Digital Converter (ADC).
- PWM Fan Control Module: A robust module capable of handling the radiator fan's high current draw, controlled by a PWM signal from the Arduino.
- Radiator Fan: A 12V high-capacity electric fan (the one I'm controlling).
- Power Supply: A dedicated 12V power source for the fan (ensuring it gets enough juice).
- Measurement Tools: A digital multimeter (for initial calibration checks) and a clamp meter (essential for real-world current draw validation).
The wiring is straightforward: the thermistor voltage divider goes to an analog input pin on the Arduino, and a PWM output pin from the Arduino connects to the fan control module's input. The fan module then connects directly to the 12V fan and its dedicated power supply.
2. The Brains: Arduino Code Logic (Simplified)
The core of the system lies in the Arduino code. It continuously monitors the engine temperature and adjusts the fan speed using a Pulse Width Modulation (PWM) signal.
Here's a simplified explanation of the key logic in my loop():
- Read Sensor: The Arduino reads the analog voltage from the thermistor's voltage divider.
- Calculate Resistance: This voltage is converted back into the thermistor's resistance (R_thermistor).
- Calculate Temperature: The R_thermistor value is then converted into a temperature reading (in Fahrenheit or Celsius) using the Steinhart-Hart equation or a lookup table.
- Map Temperature to Fan Speed (PWM):This is the crucial part. I've defined specific temperature (resistance) thresholds and corresponding fan speeds (PWM duty cycles):
- Below 660 Ohms (~139°F): Fan runs at a low 38 PWM (15% duty cycle). This is a baseline "always-on" for airflow.
- Between 660 Ohms and 270 Ohms (~139°F to ~188°F): The fan linearly ramps up its speed from 38 PWM to 166 PWM (65% duty cycle). This is handled by a map() function: fanPWM = map(R_thermistor, 660, 270, 38, 166);
- (Optional/Future): Beyond 270 Ohms (e.g., if engine gets even hotter down to 220 Ohms / ~199°F), the fan can ramp further up to 191 PWM (75% duty cycle).
- Control Fan: The calculated fanPWM value is then sent to the fan control module using analogWrite().
This piecewise linear approach allows for fine-tuned control across different temperature ranges.
3. The Real-World Behavior: Test Results!
I conducted tests under two very different ambient temperature conditions:
Scenario 1: Controlled Test (Ambient Temp: 75°F)
- Engine Temperature: During this test, the engine never got hot enough to drop below the 660 Ohm (~139°F)threshold.
- Fan Behavior: As expected, the fan correctly remained at its 38 PWM (15% duty cycle) baseline. According to my reference table (similar to the one in the attached image), this corresponds to approximately 851 RPM.
- Finding: This validates the system's idle state and confirms it doesn't over-cool when not needed.
Scenario 2: Hot Climate Test (Ambient Temp: 101°F
This is where the system really shined!
- Engine Temperature Rise: Due to the extremely hot ambient conditions, the engine temperature steadily climbed. My Calculated Ohms readings consistently dropped, moving from the 500s all the way down into the low 300s (e.g., 290-320 Ohms), just above my 270 Ohm target.
- Fan Responsiveness: The fan system detected this rising engine temperature perfectly! As soon as the Calculated Ohms dropped below 660, the fan's PWM signal smoothly and continuously ramped up.
- Observed Fan Speed (PWM): We saw the PWM values climb progressively, reaching into the 150s (up to 160 PWM!). This clearly shows the map() function actively working as designed.
- Estimated Fan RPMs: Based on my reference table (which maps Ohms to Fan RPM), this translates to the fan operating from its baseline of ~851 RPM and reaching as high as approximately 1500 to 1850 RPM at the hottest temperatures observed (as the Ohms approached 290).
- Validation: This test unequivocally validates the functionality of the first linear fan ramp segment in a real-world, high-stress scenario. The fan correctly and dynamically increased its cooling capacity to manage the engine's rising temperature, even under challenging ambient conditions.
Final Thoughts & Next Steps:
I'm incredibly pleased with the behavior of this system. It consistently responded to engine temperature changes, ramping up the fan speed exactly as programmed. It proves that the hardware setup and the Arduino code logic are working beautifully together.
My next step is to push the engine temperature further (perhaps with a longer drive or more load) to ensure it reaches the
270 Ohms (~188°F) threshold. At that exact point, I expect the PWM to hit
166 (65% duty cycle), and I will be taking a
clamp meter amperage reading to validate the fan's current draw against my target of ~27 Amps.
Has anyone else built similar systems? Any insights or suggestions for further testing or improvements would be greatly appreciated!
