DudefromHamburg

oh that board is an AM3+ board, so you'd only need a BIOS update for it to work.
 
https://www.asus.com/us/Motherboards/M5A97_R20/HelpDesk_BIOS/

A single 120mm AIO probably won't get you much better performance than the stock cooler. I can't see it working super well without doing it for dirty and having a larger rad hanging out of the case, or a NH-D15 with the side panel open

Hi, I like quiet computers.
 
Let's get started.
 
First off: yes, I am aware that I am talking about a five years old GPU series but I found this interesting enough to share, so bear with me.
 
 
The problem:
As far as I am aware at least the 770, 780 & 780ti of Nvidia's GTX GPU series limit the minimum speed of the cooling fans to about 1000 RPM regardless of ambient conditions and software targets. This leads to unnecessary noise and wear in idle and low utilization.
 
The goal:
The minimum fanspeed is adjustable without impacting cooling capabilities under high load.
 
Theory:
A PC fan typically has three connections: ground, supply voltage & tacho signal. The first two supply power to the fan and by varying the voltage potential most fans will change their speed. The third indicates the speed of the the motor with multiple voltage pulses per revolution.
Often there is a fourth connection called PWM (Pulse Width Modulation) which can be used to adjust the RPM while keeping a constant supply voltage.
 
The mentioned Nvidia cards use four pin fans and - by detecting the fan speed at the third tacho connection - know when to maintain the appropriate PWM signal on the fourth pin to limit the minimum RPM.
Since there's no getting into the BIOS easily without risking the card's life the tacho signal the card receives must be manipulated to allow lower fan speed.
 
Concept:
The fans themselves aren't easy to modify so an external device will be implemented - ideally allowing for swapping fans without modifications.
This device will measure the fan's tacho signal, multiply it's frequency by an arbitrary number chosen by the user and output the modified signal with the resulting frequency.
 
Implementation:
An Arduino Nano will serve as the computing platform with supporting circuitry.
 
Code: Please, do not redistribute without my explicit written permission! You are free to use this code as you please for any civil non-profit application.
The code implementation in the Arduino IDE looks as follows:
/* * (c) 2018 - Karikiro * * Do not remove this header. Do not redistribute. Not for use in commercial or military applications. * * This Code is provided as is and may contain errors. * You are applying it at your own risk. * I take no responsibility for any damage or injuries caused by it. */ #define PIN_F_IN 2 //pin number of the input signal #define PIN_F_OUT 9 //pin number of the output signal #define F_SYS 16000000 //system clock frequency in Hz #define UPDATE_TIME 500 //time delay in ms in which the input and output frequency is calculated and output frequency set #define AVERAGE_TIME 2000 //time over which the mean of the input frequency is calculated; this value MUST BE a multiple of UPDATE_TIME #define FREQUENCY_RATIO 2 //desired output frequency divided by input frequency unsigned long previous_timestamp = 0; //last stored timestamp in ms unsigned int icr1_val = 65535; //auxiliary variable to help dynamicly changing the Timer 1 frequency unsigned int f_in_count = 0; //current number of pulses of f_in since last reset unsigned int f_in_idx = 0; //array index for running average of f_in float f_in[AVERAGE_TIME / UPDATE_TIME] = {}; //measured input frequency in Hz float f_in_avg = 1; float f_out = 1; //output frequency in Hz void setupPins(){ pinMode(PIN_F_IN, INPUT); pinMode(PIN_F_OUT, OUTPUT); attachInterrupt(digitalPinToInterrupt(PIN_F_IN), isrD2, FALLING); //attach the interrupt service routine 'isrD2' if 'PIN_F_IN' detects a FALLING edge } void setupTimer1(){ //Timer 1 will be responsible for providing the output frequency and will be configured as described in chapter 20.12.5 and shown in figure 20-9 on pages 166...168 of the datasheet. //Set Compare Output Mode (COM1xn) (P.171, T.20-5): Clear OC1A/OC1B on Compare Match when up-counting. Set OC1A/OC1B on Compare Match when down-counting. //Set Waveform Generation Mode (WGM1n) (P.171/172, T.20-6): Mode: 8 | Timer/Counter Mode of Operation: PWM, Phase and Frequency Correct | TOP: ICR1 | Update of OCR1x at: BOTTOM | TOV1 Flag Set on: BOTTOM //Set Prescaler (CS1n) (P.173, T.20-7): Prescaler is 64, therefore counting occurs every 64th I/O-clock TCCR1A |= _BV(COM1A1) | _BV(COM1B1); TCCR1A &= ~(_BV(COM1B0) | _BV(COM1A0) | _BV(WGM11) | _BV(WGM10)); TCCR1B |= _BV(WGM13) | _BV(CS11) | _BV(CS10); TCCR1B &= ~(_BV(WGM12) | _BV(CS12)); //'_BV(X)' is a MACRO and defined as '1 << X'. It shifts a '1' by 'X' places to the MSB (most significant Bit) } void setup(){ setupPins(); setupTimer1(); } void isrD2(){ f_in_count++; } void loop(){ if ((millis() - previous_timestamp) >= UPDATE_TIME || (millis() - previous_timestamp) < 0){ //Store Current Timestamp for Next Iteration previous_timestamp = millis(); //Calculate Current Input Frequency f_in[f_in_idx] = 1000.0 * f_in_count / (float)(UPDATE_TIME); //multiplying by 1000 to convert from ms of UPDATE_TIME to s //Reset Counter f_in_count = 0; //Shift Index for Array of Input Frequencies f_in_idx++; if (f_in_idx >= (AVERAGE_TIME / UPDATE_TIME)) f_in_idx = 0; //Calculate Average of Input Frequencies f_in_avg = 0; for (int i = 0; i < (AVERAGE_TIME / UPDATE_TIME); i++) f_in_avg += f_in[i]; f_in_avg /= (float)(AVERAGE_TIME / UPDATE_TIME); f_out = f_in_avg * (float)(FREQUENCY_RATIO); //Adapt Timer 1 noInterrupts(); //disable interrupts to ensure correct register values icr1_val = (unsigned int)((float)(F_SYS) / (128 * f_out)); //defines the PWM frequency of the output frequency and is calculated with: f_PWM = F_SYS / (2 * prescaler * TOP) with TOP being ICR1 => ICR1 = F_SYS / (2 * prescaler * f_PWM) ICR1 = icr1_val; OCR1A = icr1_val / 2; //defines the PWM duty cycle interrupts(); //enable interrupts again } }  
Pin 2 (D2) will be used to measure the input tacho signal of the fan because of it's interrupt capabilities. Pin 9 (D9) will with supporting circuitry provide the graphics card with the modified frequency because of it can be mapped to a timer.
 
To allow for different Arduino platforms (those using Atmel's Atmega 328P micro controller) the system clock can be specified. Further, the interval time between updates of the output frequency can be set as well as an averaging interval time to suppress noise on the signal (which MUST BE a whole number multiple of the update time).
 
Timer 1 will later provide the actual output signal via pin 9 and is set up accordingly as an frequency adjustable PWM timer.
 
Now if a falling edge of the input tacho signal on the interrupt pin 2 (D2) occurs a counter is incremented immediately. (Exception: While the output time (Timer 1) is beeing configured interrupts are disabled.)
Else the main loop() is run indefinitely: Using the Arduino's millis() function the following is executed periodically (this implementation bugs out after about 49,7 days with a single inconsistent interval but this mod really isn't meant to operate for anywhere near that long and the averaging will smooth that out anyway):
The current millis() is stored for the next interval then the input tacho signal frequency is calculated using the interrupt counter of pin 2 (D2) which is reset right after and stored in an array containing some (in this exact code 4) previous values which are averaged and then fed into the timer 1 registers. At last the frequency counter is reset.
 
 
Circuitry:
To enable the Arduino Nano to measure and output the signals the following circuit is build:
 
 
The Arduino Nano is attached to a striped prototyping PCB with a bit of double sided sticky tape and connected with jumper cables.
 
The PCB is home to three four pin male pin headers for three fans, one four pin female pin header for the Arduino Nano, a transistor (Q1) with base resistor (RQ1), a pull up resistor (RZ1), a Zener diode (DZ) and a regular diode (DFW) (depicted as Schottky).
 
Q1 is driven by pin 9 (D9) of the Arduino Nano via RQ1 and provides the open drain (collector) type output tacho signal to the graphics card.
RZ1 is the pullup resistor for the input tacho signal of the fan which provides an open drain type signal. Since the Arduino Nano I am using is a 16MHz @ 5V variant DZ (a 5,1V Zener diode) clamps the signal voltage while the fan's tacho connection is floating.
Lastly DFW is used as a free wheeling diode for fan spin down to protect the power supply from backfeeding. (probably not necessary but nice to have)
 
 
Results:
Measuring with an oscilloscope the following traces can be observed:
 
Input Signal
 
Output Signal
 
Success! As is clearly visible (figuratively not literally because the pictures are pretty bad) the input frequency as shown in the top left corner of the TFT has doubled (for the provided code where FREQUENCY_RATIO was set to 2). This measured result is consistent with what MSI Afterburner reports at 100% fan speed target.
 
MSI Afterburner without mod
 
MSI Afterburner with mod
The 500ms update interval is clearly visible. Also for some reason the fall time of the unmodified fan control is considerably longer than with the mod.
 
 
Conclusion:
It works. Would be nice to change the ratio externally but I can't be bothered.
If you have any questions please just ask I'll gladly answer them. (Though I may take some time to respond - I am not exactly active in this site but I'll try.)
Hope you enjoyed. ❤️
 

without any shadow of a doubt your GPU, Kaby Lake Quad Core i5 even though its a non K should run well enough. i guess you are going for 1080p, so CPU Bottleneck wont become much on an issue
 
ditch the mainboard and invest in the new gpu.

Get some C3H8O (sorry, language barrier,  better go with chemical formular) and some Q-Tips and then clean, dry, clean, dry and so on untill no more gunk is visible.

I had mixed results, depending on a) the kind of paste (conductive vs. non conductive) and b) wether the previoues owner already tried some shady stuff and maybe even tried to booth with gunk still in the socket.

But calm hands, patience and mr.myagi style of wax on wax off are you best bet

While that is a good board, it doesn't make sense to have your motherboard be the most expensive part of your build.

Hi PapaP,
 
having respect is a good thing, but dont be afraid. There was a time where flashing a bios was a pretty nerve wrecking experience, but nowadays with EZ Flash of some kind from every developer the risks are minimal. You can get the latest bios with a few clicks from official channels, most of the time with well documented How-Tos and sometimes even a windows flash tool.
 
Using CPU-Z for Identifying your bios Version should work. RUn it, switch to mainboard tab and locate bios version and date. If its 6 Month or newer, keep the current. If its 2yrs or so, get the new one.
 
Edit:

3 Mouseclicks later: https://de.msi.com/Motherboard/support/B350-GAMING-PRO-CARBON
 
With youtube how to do it :). So basing on the date there, if you bios is 2017 or older, get the new. If its a 2018 version, only some finetuning was done.

my best experience was with the NF-Axx PWM

amazing answer, left me speechless in terms of how i could say thank you.

Much obliged!!!!!

Neliz seems on to sth. My GF had similar Issues with her Notebook. In her Case it was the BIOS Setting for Max.Graphics RAM. You should really check this.