DIY NVMe Cooling for the HPE ProLiant Gen 10 Plus Microserver

1
watch -n 2 'nvme smart-log /dev/nvme0n1 | grep -i temperature'

1
#define FAN_PWM   4  // PWM on GPIO4
2
#define FAN_TACH  3  // Tachometer on GPIO3
3

4
const int pwmFreq = 25000;     // PWM Frequency (Hz)
5
const int pwmResolution = 8;   // PWM Resolution (bits)
6
volatile unsigned long rpmPulses = 0;  // Number of pulses from tachometer
7
unsigned long lastDataTime = 0;        // Time of last temperature receipt
8
bool emergencyMode = false;             // Emergency mode (no data)
9
const int pulsesPerRev = 2;             // Tachometer pulses per revolution
10

11
int currentPwm = 25;  // Current PWM
12
int targetPwm = 25;   // Target PWM
13

14
// Curve defining relationship between temperature and fan PWM
15
struct FanCurvePoint {
16
  int temp;
17
  int pwm;
18
} fanCurve[] = {
19
  {30, 25},
20
  {45, 40},
21
  {55, 120},
22
  {65, 200},
23
  {75, 255}
24
};
25

26
const int curvePoints = sizeof(fanCurve) / sizeof(fanCurve[0]);
27

28
// Interrupt handler for counting tachometer pulses
29
void IRAM_ATTR countRPM() {
30
  rpmPulses++;
31
}
32
// End: tachometer pulse counting function
33

34
void setup() {
35
  Serial.begin(115200);
36
  delay(500);
37

38
  // PWM setup: using ledcAttach() according to Espressif Arduino 3.x
39
  ledcAttach(FAN_PWM, pwmFreq, pwmResolution);
40

41
  // Set initial PWM value
42
  ledcWrite(FAN_PWM, currentPwm);
43

44
  // Tachometer input setup with pull-up resistor
45
  pinMode(FAN_TACH, INPUT_PULLUP);
46
  attachInterrupt(digitalPinToInterrupt(FAN_TACH), countRPM, FALLING);
47

48
  lastDataTime = millis();
49
  Serial.println("=== FAN Controller started ===");
50
}
51
// End: initialization and setup
52

53
void loop() {
54
  // Read data from Serial to get temperature
55
  if (Serial.available()) {
56
    String input = Serial.readStringUntil('\n');
57
    input.trim();
58
    if (input.startsWith("temperature")) {
59
      int temp = input.substring(input.indexOf(':') + 1).toInt();
60
      if (temp > 0 && temp < 120) {
61
        targetPwm = mapTemperatureToPwm(temp);
62
        lastDataTime = millis();
63
        emergencyMode = false;
64
      } else {
65
        Serial.printf("Invalid temp: %d\n", temp);
66
      }
67
    }
68
  }
69

70
  // If no data received for over 8 seconds — enable emergency mode with max PWM
71
  if (millis() - lastDataTime > 8000) {
72
    emergencyMode = true;
73
    targetPwm = 255;
74
    Serial.println("EMERGENCY: No data from NVMe!");
75
  }
76

77
  smoothFanSpeed();
78

79
  // Output RPM to Serial every 2 seconds
80
  static unsigned long lastRpmTime = 0;
81
  if (millis() - lastRpmTime > 2000) {
82
    detachInterrupt(digitalPinToInterrupt(FAN_TACH));
83
    unsigned long rpm = (rpmPulses * (60000 / 2000)) / pulsesPerRev;
84
    Serial.printf("RPM: %lu (pulses: %lu)\n", rpm, rpmPulses);
85
    rpmPulses = 0;
86
    attachInterrupt(digitalPinToInterrupt(FAN_TACH), countRPM, FALLING);
87
    lastRpmTime = millis();
88
  }
89
}
90
// End: main processing loop
91

92
// Function that returns PWM based on temperature according to the curve,
93
// turns off the fan at temperatures below 30,
94
// and prevents PWM from dropping below 24 when the fan is on.
95
int mapTemperatureToPwm(int temp) {
96
  if (temp < 30) return 0;  // Fan off when temp < 30°C
97
  for (int i = 0; i < curvePoints - 1; i++) {
98
    if (temp <= fanCurve[i + 1].temp) {
99
      int pwm = map(temp, fanCurve[i].temp, fanCurve[i + 1].temp,
100
                    fanCurve[i].pwm, fanCurve[i + 1].pwm);
101
      if (pwm < 24) pwm = 24;  // Minimum PWM for stable fan startup
102
      return pwm;
103
    }
104
  }
105
  return fanCurve[curvePoints - 1].pwm;
106
}
107
// End: temperature to PWM mapping function
108

109
// Function to smoothly change fan speed to target value
110
// Minimum PWM 24 if targetPwm is not 0, otherwise full stop (0)
111
void smoothFanSpeed() {
112
  if (targetPwm < 24) {
113
    // If target is below startup threshold — turn fan off immediately
114
    currentPwm = 0;
115
  } else {
116
    // Smoothly approach targetPwm
117
    if (currentPwm < targetPwm) {
118
      currentPwm += 5;
119
      if (currentPwm > targetPwm) currentPwm = targetPwm;
120
    } else if (currentPwm > targetPwm) {
121
      currentPwm -= 2;
122
      if (currentPwm < targetPwm) currentPwm = targetPwm;
123
    }
124
    // Minimum threshold for startup and maintenance
125
    if (currentPwm < 24) currentPwm = 24;
126
  }
127
  ledcWrite(FAN_PWM, currentPwm);
128
  Serial.printf("PWM set to: %d\n", currentPwm);
129
}
130
// End: smooth fan speed change

1
# nano /usr/local/bin/nvme_temp_sender.sh

1
#!/bin/bash
2

3
DEVICE="/dev/serial/by-id/usb-Espressif_USB_JTAG_serial_debug_unit_XX:XX:XX:XX:XX:XX-if00"
4
NVME_DEVICE="/dev/nvme0n1"
5

6
while true; do
7
    # Wait for ESP32 device to appear
8
    while [ ! -e "$DEVICE" ]; do
9
        echo "[WARN] ESP32 not found, waiting for connection..."
10
        sleep 2
11
    done
12

13
    echo "[INFO] Connecting to $DEVICE"
14

15
    # Open device for writing via descriptor 3
16
    exec 3> "$DEVICE"
17

18
    while true; do
19
        # If device is disconnected — exit inner loop to reconnect
20
        if [ ! -e "$DEVICE" ]; then
21
            echo "[WARN] ESP32 disconnected, restarting..."
22
            exec 3>&-
23
            break
24
        fi
25

26
        # Read NVMe temperature
27
        TEMP=$(nvme smart-log "$NVME_DEVICE" 2>/dev/null | awk '/^temperature/ {print $3; exit}')
28

29
        if [[ -z "$TEMP" ]]; then
30
            echo "[ERROR] Failed to get NVMe temperature!"
31
            TEMP=0
32
        fi
33

34
        # Send string to ESP32
35
        echo "temperature: $TEMP" >&3
36
        sleep 2
37
    done
38
done

1
# chmod +x /usr/local/bin/nvme_temp_sender.sh

1
# nano /etc/systemd/system/nvme_temp_monitor.service

1
[Unit]
2
Description=NVMe Temperature Monitor for ESP32 over USB Serial
3
After=network.target
4

5
[Service]
6
Type=simple
7
User=root
8
ExecStart=/usr/local/bin/nvme_temp_sender.sh
9
Restart=always
10
RestartSec=5
11
StandardOutput=syslog
12
StandardError=syslog
13
SyslogIdentifier=nvme_temp_monitor
14

15
[Install]
16
WantedBy=multi-user.target

1
# systemctl daemon-reload

1
# systemctl enable --now nvme_temp_monitor.service

1
# systemctl start nvme_temp_monitor

1
cat /dev/ttyACM0 | awk '/RPM:/ {rpm=$2} /PWM set to:/ {pwm=$4} rpm && pwm {print "RPM=" rpm, "PWM=" pwm}'

1
RPM=1410 PWM=154
2
RPM=1410 PWM=154
3
RPM=1410 PWM=159
4
RPM=1800 PWM=159
5
RPM=1800 PWM=159
6
RPM=1800 PWM=159

1
watch -n 2 'nvme smart-log /dev/nvme0n1 | grep -i temperature'

1
temperature : 44 C
2
Warning Temperature Time : 0
3
Critical Composite Temperature Time : 0
4
Temperature Sensor 1 : 44 C
5
Temperature Sensor 2 : 43 C
6
Temperature Sensor 3 : 43 C