Merge pull request #7 from r15ch13/vega-fix

Compare target pwm value to pwm1_min and pwm1_max instead of fan rpm

src/main.rs

@@ -27,6 +27,8 @@ pub struct HwMon {
     name: String,
     fan_min: Option<u32>,
     fan_max: Option<u32>,
+    pwm_min: Option<u32>,
+    pwm_max: Option<u32>,
 }
 
 impl HwMon {
@@ -36,6 +38,8 @@ impl HwMon {
             name: String::from(name),
             fan_min: None,
             fan_max: None,
+            pwm_min: None,
+            pwm_max: None,
         }
     }
 
@@ -60,7 +64,7 @@ impl HwMon {
                     .unwrap_or(0),
             )
         };
-        self.fan_min.unwrap_or(0)
+        self.fan_min.unwrap_or_default()
     }
 
     pub fn fan_max(&mut self) -> u32 {
@@ -69,10 +73,10 @@ impl HwMon {
                 self.read("fan1_max")
                     .unwrap_or_default()
                     .parse()
-                    .unwrap_or(255),
+                    .unwrap_or(1500),
             )
         };
-        self.fan_max.unwrap_or(255)
+        self.fan_max.unwrap_or(1500)
     }
 
     pub fn fan_speed(&self) -> std::io::Result<u64> {
@@ -82,6 +86,37 @@ impl HwMon {
         })
     }
 
+    pub fn pwm_min(&mut self) -> u32 {
+        if self.pwm_min.is_none() {
+            self.pwm_min = Some(
+                self.read("pwm1_min")
+                    .unwrap_or_default()
+                    .parse()
+                    .unwrap_or(0),
+            )
+        };
+        self.pwm_min.unwrap_or_default()
+    }
+
+    pub fn pwm_max(&mut self) -> u32 {
+        if self.pwm_max.is_none() {
+            self.pwm_max = Some(
+                self.read("pwm1_max")
+                    .unwrap_or_default()
+                    .parse()
+                    .unwrap_or(255),
+            )
+        };
+        self.pwm_max.unwrap_or(255)
+    }
+
+    pub fn pwm_speed(&self) -> std::io::Result<u64> {
+        self.read("pwm1")?.parse().map_err(|_e| {
+            log::warn!("Read from gpu monitor failed. Invalid fan speed");
+            std::io::Error::from(ErrorKind::InvalidInput)
+        })
+    }
+
     pub fn is_fan_manual(&self) -> bool {
         self.read("pwm1_enable")
             .map(|s| s.as_str() == "1")
@@ -115,11 +150,11 @@ impl HwMon {
         self.write("pwm1_enable", 2)
     }
 
-    pub fn set_speed(&self, speed: u64) -> std::io::Result<()> {
+    pub fn set_speed(&self, pwm: u64) -> std::io::Result<()> {
         if self.is_fan_automatic() {
             self.set_manual()?;
         }
-        self.write("pwm1", speed)
+        self.write("pwm1", pwm)
     }
 
     fn read(&self, name: &str) -> std::io::Result<String> {
@@ -289,12 +324,13 @@ fn service(config: Config) -> std::io::Result<()> {
             let gpu_temp = controller.hw_mon.gpu_temp().unwrap_or_default();
 
             let speed = config.speed_for_temp(gpu_temp);
-            if controller.hw_mon.fan_min() > speed || controller.hw_mon.fan_max() < speed {
+            let target_pwm = (speed as f32 * 2.55).round() as u32;
+            if controller.hw_mon.pwm_min() > target_pwm || controller.hw_mon.pwm_max() < target_pwm {
                 continue;
             }
 
-            if let Err(e) = controller.hw_mon.set_speed(speed as u64) {
-                log::error!("Failed to change speed to {}. {:?}", speed, e);
+            if let Err(e) = controller.hw_mon.set_speed(target_pwm as u64) {
+                log::error!("Failed to change speed to {}. {:?}", target_pwm, e);
             }
             controller.last_temp = gpu_temp;
         }
@@ -342,15 +378,17 @@ fn monitor_cards(config: Config) -> std::io::Result<()> {
         print!("{esc}[2J{esc}[1;1H", esc = 27 as char);
         for card in controllers.iter_mut() {
             println!(
-                "Card {:3} | Temp     | fan speed |  MAX |  MIN ",
-                card.hw_mon.card.0
+                "Card {:3} | Temp     |  RPM |  MIN |  MAX |  PWM |   %",
+                card.hw_mon.card.to_string().replace("card", "")
             );
             println!(
-                "         | {:>5.2}    | {:>9} | {:>4} | {:>4}",
+                "         | {:>5.2}    | {:>4} | {:>4} | {:>4} | {:>4} | {:>3}",
                 card.hw_mon.gpu_temp().unwrap_or_default(),
                 card.hw_mon.fan_speed().unwrap_or_default(),
                 card.hw_mon.fan_min(),
                 card.hw_mon.fan_max(),
+                card.hw_mon.pwm_speed().unwrap_or_default(),
+                (card.hw_mon.pwm_speed().unwrap_or_default() as f32 / 2.55).round(),
             );
         }
         std::thread::sleep(std::time::Duration::from_secs(4));