init thermal-control

Author: WantClue

main/NvsManager/inc/nvs_config.h

@@ -27,6 +27,8 @@
 #define NVS_CONFIG_PRODUCTION_TEST "productiontest"
 #define NVS_CONFIG_OVERHEAT_MODE "overheat_mode"
 #define NVS_CONFIG_OVERCLOCK_ENABLED "oc_enabled"
+#define NVS_CONFIG_THERMAL_CTRL   "thermalctrl"
+#define NVS_CONFIG_THERMAL_TARGET "thermaltarget"
 #define NVS_CONFIG_SWARM "swarmconfig"
 
 // Theme configuration

main/http_server/axe-os/src/app/components/edit/edit.component.html

@@ -84,6 +84,27 @@ <h1 class="text-2xl font-bold mb-3">Performance Mode</h1>
             </div>
         </div>
 
+        <!-- Thermal Control Section (manual fan mode only) -->
+        <div class="col-12" *ngIf="form.controls['autofanspeed'].value != true">
+            <div class="field-checkbox">
+                <p-checkbox name="thermalControl" formControlName="thermalControl" inputId="thermalControl"
+                    [binary]="true"></p-checkbox>
+                <label for="thermalControl">Thermal Control (Auto-Frequency)</label>
+            </div>
+        </div>
+
+        <div *ngIf="form.controls['thermalControl'].value == true">
+            <div class="col-12">
+                <label>Target Temperature: {{form.controls['thermalTarget'].value}}°C</label>
+                <p-slider formControlName="thermalTarget" [min]="45" [max]="72" [step]="1"></p-slider>
+                <small class="block mt-1" style="color: #aaa;">
+                    Frequency adjusts automatically (±25 MHz every 2s) to maintain this temperature.
+                    Both ASIC chip temp and VR temperature are monitored.
+                    <span *ngIf="frequencyActual">Current running frequency: {{frequencyActual}} MHz</span>
+                </small>
+            </div>
+        </div>
+
         <div class="mt-2">
             <button pButton [disabled]="!form.dirty || form.invalid" (click)="updateSystem()"
                 class="btn btn-primary mr-2">Save</button>

main/http_server/axe-os/src/app/components/edit/edit.component.ts

@@ -21,6 +21,7 @@ export class EditComponent implements OnInit, OnDestroy {
   public websiteUpdateProgress: number | null = null;
 
   public savedChanges: boolean = false;
+  public frequencyActual: number | undefined;
   public settingsUnlocked: boolean = false;
   public eASICModel = eASICModel;
   public ASICModel!: eASICModel;
@@ -103,6 +104,7 @@ export class EditComponent implements OnInit, OnDestroy {
       )
       .subscribe(info => {
         this.ASICModel = info.ASICModel;
+        this.frequencyActual = info.frequencyActual;
 
         // Check if overclock is enabled in NVS
         if (info.overclockEnabled === 1) {
@@ -118,7 +120,9 @@ export class EditComponent implements OnInit, OnDestroy {
           frequency: [info.frequency, [Validators.required]],
           autofanspeed: [info.autofanspeed == 1, [Validators.required]],
           manualFanSpeed: [info.manualFanSpeed, [Validators.required]],
-          overheat_mode: [info.overheat_mode, [Validators.required]]
+          overheat_mode: [info.overheat_mode, [Validators.required]],
+          thermalControl: [info.thermalControl == 1, [Validators.required]],
+          thermalTarget: [info.thermalTarget ?? 65, [Validators.required, Validators.min(45), Validators.max(72)]],
         });
 
         this.form.controls['autofanspeed'].valueChanges.pipe(
@@ -127,8 +131,22 @@ export class EditComponent implements OnInit, OnDestroy {
         ).subscribe(autofanspeed => {
           if (autofanspeed) {
             this.form.controls['manualFanSpeed'].disable();
+            this.form.controls['thermalControl'].setValue(false);
+            this.form.controls['thermalControl'].disable();
           } else {
             this.form.controls['manualFanSpeed'].enable();
+            this.form.controls['thermalControl'].enable();
+          }
+        });
+
+        this.form.controls['thermalControl'].valueChanges.pipe(
+          startWith(this.form.controls['thermalControl'].value),
+          takeUntil(this.destroy$)
+        ).subscribe(enabled => {
+          if (enabled) {
+            this.form.controls['thermalTarget'].enable();
+          } else {
+            this.form.controls['thermalTarget'].disable();
           }
         });
       });
@@ -147,6 +165,8 @@ export class EditComponent implements OnInit, OnDestroy {
       delete form.stratumPassword;
     }
 
+    form.thermalControl = form.thermalControl ? 1 : 0;
+
     this.systemService.updateSystem(this.uri, form)
       .pipe(this.loadingService.lockUIUntilComplete())
       .subscribe({

main/http_server/axe-os/src/app/services/system.service.ts

@@ -68,7 +68,10 @@ export class SystemService {
 
           chiptemp1: 30,
           chiptemp2: 40,
-          overheat_mode: 0
+          overheat_mode: 0,
+          thermalControl: 0,
+          thermalTarget: 65,
+          frequencyActual: 525,
         }
       ).pipe(delay(1000));
     }

main/http_server/axe-os/src/models/ISystemInfo.ts

@@ -56,4 +56,7 @@ export interface ISystemInfo {
     overheat_mode: number,
     power_fault?: string
     overclockEnabled?: number
+    frequencyActual?: number,
+    thermalControl?: number,
+    thermalTarget?: number,
 }

main/http_server/http_server.c

@@ -591,6 +591,15 @@ static esp_err_t PATCH_update_settings(httpd_req_t * req)
     if ((item = cJSON_GetObjectItem(root, "overclockEnabled")) != NULL) {
         nvs_config_set_u16(NVS_CONFIG_OVERCLOCK_ENABLED, item->valueint);
     }
+    if ((item = cJSON_GetObjectItem(root, "thermalControl")) != NULL) {
+        nvs_config_set_u16(NVS_CONFIG_THERMAL_CTRL, item->valueint);
+    }
+    if ((item = cJSON_GetObjectItem(root, "thermalTarget")) != NULL) {
+        uint16_t target = (uint16_t)item->valueint;
+        if (target < 45) target = 45;
+        if (target > 72) target = 72;
+        nvs_config_set_u16(NVS_CONFIG_THERMAL_TARGET, target);
+    }
 
     cJSON_Delete(root);
     httpd_resp_send_chunk(req, NULL, 0);
@@ -683,6 +692,9 @@ static esp_err_t GET_system_info(httpd_req_t * req)
     cJSON_AddNumberToObject(root, "coreVoltage", nvs_config_get_u16(NVS_CONFIG_ASIC_VOLTAGE, CONFIG_ASIC_VOLTAGE));
     cJSON_AddNumberToObject(root, "coreVoltageActual", VCORE_get_voltage_mv(GLOBAL_STATE));
     cJSON_AddNumberToObject(root, "frequency", nvs_config_get_u16(NVS_CONFIG_ASIC_FREQ, CONFIG_ASIC_FREQUENCY));
+    cJSON_AddNumberToObject(root, "frequencyActual", GLOBAL_STATE->POWER_MANAGEMENT_MODULE.thermal_freq);
+    cJSON_AddNumberToObject(root, "thermalControl", nvs_config_get_u16(NVS_CONFIG_THERMAL_CTRL, 0));
+    cJSON_AddNumberToObject(root, "thermalTarget", nvs_config_get_u16(NVS_CONFIG_THERMAL_TARGET, 65));
     cJSON_AddStringToObject(root, "ssid", ssid);
     cJSON_AddStringToObject(root, "macAddr", formattedMac);
     cJSON_AddStringToObject(root, "hostname", hostname);

main/tasks/power_management_task.c

@@ -28,6 +28,12 @@
 #define TPS546_THROTTLE_TEMP 105.0
 #define TPS546_MAX_TEMP 145.0
 
+#define THERMAL_CTRL_STEP_MHZ   25.0f
+#define THERMAL_CTRL_MIN_MHZ    400.0f
+#define THERMAL_CTRL_MAX_MHZ    650.0f
+#define THERMAL_CTRL_HYSTERESIS 3.0f
+#define THERMAL_TARGET_DEFAULT  65
+
 static const char * TAG = "power_management";
 
 static bool even = false;
@@ -85,6 +91,55 @@ static double automatic_fan_speed(float chip_temp, float vr_temp, GlobalState *
     return result;
 }
 
+// Adjust ASIC frequency to maintain target temperature.
+// Uses max(chip_temp_max, vr_temp_normalized) as effective temperature.
+// VR range 60-85°C is mapped to ASIC 45-75°C scale.
+static void thermal_control_adjust_frequency(PowerManagementModule * pm, float nvs_base_freq, GlobalState * GLOBAL_STATE)
+{
+    // Get max ASIC chip temperature
+    float chip_max = 0.0f;
+    if (pm->chip_temp[0] > 0.0f && pm->chip_temp[1] > 0.0f) {
+        chip_max = (pm->chip_temp[0] > pm->chip_temp[1]) ? pm->chip_temp[0] : pm->chip_temp[1];
+    } else if (pm->chip_temp[0] > 0.0f) {
+        chip_max = pm->chip_temp[0];
+    } else if (pm->chip_temp[1] > 0.0f) {
+        chip_max = pm->chip_temp[1];
+    } else {
+        chip_max = 50.0f; // fallback if both sensors zero
+    }
+
+    // Normalize VR temp to ASIC scale: 60-85°C → 45-75°C
+    float vr_normalized = 45.0f + (pm->vr_temp - 60.0f) * (30.0f / 25.0f);
+    float effective_temp = (chip_max > vr_normalized) ? chip_max : vr_normalized;
+
+    uint16_t target = nvs_config_get_u16(NVS_CONFIG_THERMAL_TARGET, THERMAL_TARGET_DEFAULT);
+    // Clamp target to valid range
+    if (target < 45) target = 45;
+    if (target > 72) target = 72;
+
+    float new_freq = pm->thermal_freq;
+
+    if (effective_temp > (float)target) {
+        new_freq -= THERMAL_CTRL_STEP_MHZ;
+        if (new_freq < THERMAL_CTRL_MIN_MHZ) new_freq = THERMAL_CTRL_MIN_MHZ;
+    } else if (effective_temp < (float)target - THERMAL_CTRL_HYSTERESIS) {
+        new_freq += THERMAL_CTRL_STEP_MHZ;
+        float ceiling = (nvs_base_freq < THERMAL_CTRL_MAX_MHZ) ? nvs_base_freq : THERMAL_CTRL_MAX_MHZ;
+        if (new_freq > ceiling) new_freq = ceiling;
+    } else {
+        return; // within dead band, no change
+    }
+
+    ESP_LOGI(TAG, "ThermalCtrl: eff=%.1f°C target=%u°C freq %.0f->%.0f MHz",
+             effective_temp, target, pm->thermal_freq, new_freq);
+
+    bool success = ASIC_set_frequency(GLOBAL_STATE, new_freq);
+    if (success) {
+        pm->thermal_freq = new_freq;
+        pm->frequency_value = new_freq;
+    }
+}
+
 void POWER_MANAGEMENT_task(void * pvParameters)
 {
     ESP_LOGI(TAG, "Starting");
@@ -95,13 +150,12 @@ void POWER_MANAGEMENT_task(void * pvParameters)
     SystemModule * sys_module = &GLOBAL_STATE->SYSTEM_MODULE;
 
     power_management->frequency_multiplier = 1;
-
-    //int last_frequency_increase = 0;
-    //uint16_t frequency_target = nvs_config_get_u16(NVS_CONFIG_ASIC_FREQ, CONFIG_ASIC_FREQUENCY);
+    power_management->thermal_freq = (float)nvs_config_get_u16(NVS_CONFIG_ASIC_FREQ, CONFIG_ASIC_FREQUENCY);
+    uint16_t last_thermal_ctrl = nvs_config_get_u16(NVS_CONFIG_THERMAL_CTRL, 0);
 
     vTaskDelay(500 / portTICK_PERIOD_MS);
     uint16_t last_core_voltage = 0.0;
-    uint16_t last_asic_frequency = power_management->frequency_value;
+    uint16_t last_asic_frequency = nvs_config_get_u16(NVS_CONFIG_ASIC_FREQ, CONFIG_ASIC_FREQUENCY);
 
     while (1) {
         PAC9544_selectChannel(even + 2U);
@@ -189,7 +243,7 @@ void POWER_MANAGEMENT_task(void * pvParameters)
             Thermal_setFanSpeedPercent((float) fs / 100.0);
         }
 
-        // New voltage and frequency adjustment code
+        // Voltage adjustment
         uint16_t core_voltage = nvs_config_get_u16(NVS_CONFIG_ASIC_VOLTAGE, CONFIG_ASIC_VOLTAGE);
         uint16_t asic_frequency = nvs_config_get_u16(NVS_CONFIG_ASIC_FREQ, CONFIG_ASIC_FREQUENCY);
 
@@ -199,17 +253,37 @@ void POWER_MANAGEMENT_task(void * pvParameters)
             last_core_voltage = core_voltage;
         }
 
-        if (asic_frequency != last_asic_frequency) {
-            ESP_LOGI(TAG, "New ASIC frequency requested: %uMHz (current: %uMHz)", asic_frequency, last_asic_frequency);
-            
-            bool success = ASIC_set_frequency(GLOBAL_STATE, (float)asic_frequency);
-            
-            if (success) {
-                power_management->frequency_value = (float)asic_frequency;
+        // Thermal control / frequency adjustment
+        uint16_t thermal_ctrl_enabled = nvs_config_get_u16(NVS_CONFIG_THERMAL_CTRL, 0);
+
+        if (thermal_ctrl_enabled) {
+            // Clamp thermal_freq ceiling to current NVS base freq in case user lowered it
+            if (power_management->thermal_freq > (float)asic_frequency) {
+                power_management->thermal_freq = (float)asic_frequency;
+            }
+            thermal_control_adjust_frequency(power_management, (float)asic_frequency, GLOBAL_STATE);
+            last_asic_frequency = (uint16_t)power_management->thermal_freq;
+        } else {
+            if (last_thermal_ctrl) {
+                // Thermal control was just disabled — restore NVS base frequency
+                ESP_LOGI(TAG, "ThermalCtrl disabled, restoring NVS freq %uMHz", asic_frequency);
+                bool success = ASIC_set_frequency(GLOBAL_STATE, (float)asic_frequency);
+                if (success) {
+                    power_management->frequency_value = (float)asic_frequency;
+                    power_management->thermal_freq = (float)asic_frequency;
+                }
+                last_asic_frequency = asic_frequency;
+            } else if (asic_frequency != last_asic_frequency) {
+                ESP_LOGI(TAG, "New ASIC frequency requested: %uMHz (current: %uMHz)", asic_frequency, last_asic_frequency);
+                bool success = ASIC_set_frequency(GLOBAL_STATE, (float)asic_frequency);
+                if (success) {
+                    power_management->frequency_value = (float)asic_frequency;
+                    power_management->thermal_freq = (float)asic_frequency;
+                }
+                last_asic_frequency = asic_frequency;
             }
-            
-            last_asic_frequency = asic_frequency;
         }
+        last_thermal_ctrl = thermal_ctrl_enabled;
 
         // Check for changing of overheat mode
         uint16_t new_overheat_mode = nvs_config_get_u16(NVS_CONFIG_OVERHEAT_MODE, 0);

main/tasks/power_management_task.h

@@ -16,6 +16,7 @@ typedef struct
     float frequency_value;
     float power;
     float current;
+    float thermal_freq;  // current thermally-adjusted running frequency (MHz)
 } PowerManagementModule;
 
 void POWER_MANAGEMENT_task(void * pvParameters);