feat(fan-controller): add Bitaxe cooling control

Add fan control and temperature filtering for Bitaxe boards to improve
thermal management and protect hardware under high load.

Co-authored-by: Johnny Santos <johnnyadsantos@gmail.com>

Author: jayrmotta

mujina-miner/src/board/bitaxe.rs

@@ -1,4 +1,7 @@
 use anyhow::{Context as _, Result, anyhow, bail};
+mod fan_controller;
+mod thermal_task;
+
 use async_trait::async_trait;
 use futures::sink::SinkExt;
 use std::{
@@ -48,6 +51,9 @@ use super::{
     pattern::{Match, StringMatch},
 };
 
+use fan_controller::{FanControllerConfig, ThermalReadings};
+use thermal_task::ThermalTask;
+
 /// Adapter implementing `AsicEnable` for Bitaxe's GPIO-based reset control.
 struct BitaxeAsicEnable {
     /// Reset pin (directly controls nRST on the BM1370)
@@ -125,8 +131,8 @@ pub struct BitaxeBoard {
     asic_nrst: Option<BitaxeRawGpioPin>,
     /// I2C bus controller
     i2c: BitaxeRawI2c,
-    /// Fan controller (board-controlled only, not shared with thread)
-    fan_controller: Option<Emc2101<BitaxeRawI2c>>,
+    /// Concurrent EMC2101 handle
+    emc2101: Option<Arc<Mutex<Emc2101<BitaxeRawI2c>>>>,
     /// Voltage regulator (shared with thread, cached state)
     regulator: Option<Arc<Mutex<Tps546<BitaxeRawI2c>>>>,
     /// Writer for sending commands to chips (transferred to hash thread)
@@ -147,6 +153,10 @@ pub struct BitaxeBoard {
     /// Channel for publishing board telemetry to the API server.
     /// Taken by `spawn_stats_monitor` which publishes periodic snapshots.
     telemetry_tx: Option<watch::Sender<BoardTelemetry>>,
+    /// Fan controller configuration (target temperature, etc.)
+    fan_config: FanControllerConfig,
+    /// Handles for the thermal monitor async task
+    thermal_task_handle: Option<tokio::task::JoinHandle<()>>,
 }
 
 impl BitaxeBoard {
@@ -195,7 +205,7 @@ impl BitaxeBoard {
             control_channel,
             asic_nrst: None,
             i2c,
-            fan_controller: None,
+            emc2101: None,
             regulator: None,
             data_writer: Some(FramedWrite::new(data_writer, bm13xx::FrameCodec)),
             data_reader: Some(FramedRead::new(tracing_reader, bm13xx::FrameCodec)),
@@ -205,6 +215,8 @@ impl BitaxeBoard {
             stats_task_handle: None,
             serial_number,
             telemetry_tx: Some(telemetry_tx),
+            fan_config: FanControllerConfig::default(),
+            thermal_task_handle: None,
         })
     }
 
@@ -451,36 +463,6 @@ impl BitaxeBoard {
         }
     }
 
-    /// Initialize the fan controller
-    async fn init_fan_controller(&mut self) -> Result<()> {
-        // Clone the I2C bus for the fan controller
-        let fan_i2c = self.i2c.clone();
-        let mut fan = Emc2101::new(fan_i2c);
-
-        // Initialize the EMC2101
-        match fan.init().await {
-            Ok(()) => {
-                // Set fan to full speed until closed-loop control is implemented
-                match fan.set_fan_speed(Percent::FULL).await {
-                    Ok(()) => {
-                        debug!("Fan speed set to 100%");
-                    }
-                    Err(e) => {
-                        warn!("Failed to set fan speed: {}", e);
-                    }
-                }
-
-                self.fan_controller = Some(fan);
-                Ok(())
-            }
-            Err(e) => {
-                warn!("Failed to initialize EMC2101 fan controller: {}", e);
-                // Continue without fan control - not critical for operation
-                Ok(())
-            }
-        }
-    }
-
     /// Generate frequency ramp steps for smooth PLL transitions
     ///
     /// Calculates PLL configurations for each frequency step from start to target.
@@ -620,7 +602,6 @@ impl BitaxeBoard {
             .await
             .context("failed to set I2C frequency")?;
 
-        self.init_fan_controller().await?;
         self.init_power_controller().await?;
 
         tokio::time::sleep(Duration::from_millis(500)).await;
@@ -668,8 +649,14 @@ impl BitaxeBoard {
         // Put chip back in reset
         self.hold_in_reset().await?;
 
+        let (thermal_readings_tx, thermal_readings_rx) =
+            watch::channel::<Option<ThermalReadings>>(None);
+
+        // Spawn thermal monitoring task
+        self.spawn_thermal_task(thermal_readings_tx).await?;
+
         // Spawn statistics monitoring task
-        self.spawn_stats_monitor();
+        self.spawn_stats_monitor(thermal_readings_rx);
 
         Ok(())
     }
@@ -680,10 +667,10 @@ impl BitaxeBoard {
     }
 
     /// Spawn a task to periodically log and publish board telemetry.
-    fn spawn_stats_monitor(&mut self) {
-        // Clone data needed for the monitoring task
-        let i2c = self.i2c.clone();
-
+    fn spawn_stats_monitor(
+        &mut self,
+        thermal_readings_rx: watch::Receiver<Option<ThermalReadings>>,
+    ) {
         // Clone the regulator Arc for stats monitoring
         let regulator = self
             .regulator
@@ -710,9 +697,6 @@ impl BitaxeBoard {
             let mut interval = tokio::time::interval(STATS_INTERVAL);
             interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
 
-            // Create fan controller for the stats task
-            let mut fan_ctrl = Emc2101::new(i2c);
-
             const LOG_INTERVAL: Duration = Duration::from_secs(30);
             let mut last_log = tokio::time::Instant::now();
 
@@ -722,11 +706,13 @@ impl BitaxeBoard {
             loop {
                 interval.tick().await;
 
-                // -- Read sensor values --
+                // -- Get latest thermal readings --
 
-                let asic_temp = fan_ctrl.get_external_temperature().await.ok();
-                let fan_percent = fan_ctrl.get_fan_speed().await.ok().map(u8::from);
-                let fan_rpm = fan_ctrl.get_rpm().await.ok();
+                let thermal_readings = thermal_readings_rx
+                    .borrow()
+                    .as_ref()
+                    .copied()
+                    .unwrap_or_default();
 
                 let (vin_mv, vout_mv, iout_ma, power_mw, vr_temp) = {
                     let mut reg = regulator.lock().await;
@@ -769,14 +755,16 @@ impl BitaxeBoard {
                     serial: board_serial.clone(),
                     fans: vec![Fan {
                         name: "fan".into(),
-                        rpm: fan_rpm,
-                        percent: fan_percent,
+                        rpm: thermal_readings.fan_rpm,
+                        percent: thermal_readings.fan_percent,
                         target_percent: None,
                     }],
                     temperatures: vec![
                         TemperatureSensor {
                             name: "asic".into(),
-                            temperature: asic_temp.map(Temperature::from_celsius),
+                            temperature: thermal_readings
+                                .asic_temp_c
+                                .map(Temperature::from_celsius),
                         },
                         TemperatureSensor {
                             name: "vr".into(),
@@ -807,9 +795,9 @@ impl BitaxeBoard {
                     info!(
                         board = %board_model,
                         serial = ?board_serial,
-                        asic_temp_c = ?asic_temp,
-                        fan_percent = ?fan_percent,
-                        fan_rpm = ?fan_rpm,
+                        asic_temp_c = ?thermal_readings.asic_temp_c,
+                        fan_percent = ?thermal_readings.fan_percent,
+                        fan_rpm = ?thermal_readings.fan_rpm,
                         vr_temp_c = ?vr_temp,
                         power_w = ?power_mw.map(|mw| mw as f32 / 1000.0),
                         current_a = ?iout_ma.map(|ma| ma as f32 / 1000.0),
@@ -823,6 +811,27 @@ impl BitaxeBoard {
 
         self.stats_task_handle = Some(handle);
     }
+
+    /// Initialize fan hardware and spawn the thermal control loop task.
+    async fn spawn_thermal_task(
+        &mut self,
+        thermal_readings_tx: watch::Sender<Option<ThermalReadings>>,
+    ) -> Result<()> {
+        let fan_hw = Arc::new(Mutex::new(Emc2101::new(self.i2c.clone())));
+
+        let thermal_task =
+            ThermalTask::new(fan_hw.clone(), self.fan_config.clone(), thermal_readings_tx);
+
+        let handle = thermal_task
+            .start()
+            .await
+            .context("failed to start thermal task")?;
+
+        self.emc2101 = Some(fan_hw);
+        self.thermal_task_handle = Some(handle);
+
+        Ok(())
+    }
 }
 
 #[async_trait]
@@ -857,12 +866,27 @@ impl Board for BitaxeBoard {
             }
         }
 
+        // Cancel the thermal monitoring task
+        if let Some(handle) = self.thermal_task_handle.take() {
+            handle.abort();
+        }
+
         // Reduce fan speed (no more heat generation)
-        if let Some(ref mut fan) = self.fan_controller {
-            let shutdown_speed = Percent::new_clamped(25);
-            if let Err(e) = fan.set_fan_speed(shutdown_speed).await {
-                warn!("Failed to set fan speed: {}", e);
-            }
+        if let Some(ref emc2101_handle) = self.emc2101 {
+            match emc2101_handle
+                .lock()
+                .await
+                .set_fan_speed(Percent::new_clamped(
+                    self.fan_config.fan_speed_min_pct.round() as u8,
+                ))
+                .await
+            {
+                Ok(()) => debug!(
+                    "Fan set to {}%",
+                    self.fan_config.fan_speed_min_pct.round() as u8
+                ),
+                Err(e) => warn!("Failed to set the fan speed: {}", e),
+            };
         }
 
         // Cancel the statistics monitoring task