Continue reconfiguring for new cycle structure

src/device.rs

@@ -2,8 +2,10 @@ use std::{fs::{self, File}, path::Path, io::Write, thread, time::Duration};
 use crate::tty::{TTY, Response,Command};
 use rppal::gpio::{Gpio,OutputPin};
 
-const BOOT_TIME:Duration = Duration::new(50, 0);
+//const BOOT_TIME:Duration = Duration::new(50, 0);
-const BP_RUN:Duration = Duration::new(60, 0);
+const BP_RUN_1:Duration = Duration::new(29, 0);
+const TEMP_WAIT:Duration = Duration::new(3,0);
+const BP_RUN_2:Duration = Duration::new(28, 0);
 const REBOOTS_SECTION: &str = "Reboots: ";
 const BP_SECTION: &str = "Successful BP tests: ";
 const TEMP_SECTION: &str = "Successful temp tests: ";
@@ -29,6 +31,7 @@ pub struct Device{
     current_state: State,
     reboots: u64,
     temps: u64,
+    init_temps: u64,
     bps: u64
 }
 
@@ -108,8 +111,7 @@ impl Device{
                     Response::Other | Response::Empty | Response::ShellPrompt 
                         | Response::LoginPrompt | Response::Rebooting => 
                             initial_state = State::LoginPrompt,
-                    Response::BPOn | Response::BPOff | Response::TempFailed 
+                    Response::BPOn | Response::BPOff | Response::TempCount(_) =>
-                        | Response::TempSuccess =>
                             initial_state = State::LifecycleMenu,
                     Response::DebugMenuReady | Response::DebugMenuWithContinuedMessage=>
                             initial_state = State::DebugMenu,
@@ -130,6 +132,7 @@ impl Device{
                     current_state: initial_state,
                     reboots: 0,
                     temps: 0,
+                    init_temps: 0,
                     bps: 0
                 };
                 if !output.load_values(){
@@ -257,7 +260,8 @@ impl Device{
             output_data.push_str(&self.bps.to_string());
             output_data.push_str("\n");
             output_data.push_str(TEMP_SECTION);
-            output_data.push_str(&self.temps.to_string());
+            let saved_temps = self.temps - self.init_temps;
+            output_data.push_str(&saved_temps.to_string());
             output_data.push_str("\n");
             let temp = file_name.write_all(output_data.as_bytes());
             match temp{
@@ -326,27 +330,46 @@ impl Device{
         _ = self.usb_tty.read_from_device(None);
         return self;
     }
-    pub fn is_temp_running(&mut self) -> bool {
+    pub fn update_temp_count(&mut self) -> u64 {
         self.go_to_lifecycle_menu();
         self.usb_tty.write_to_device(Command::ReadTemp);
         for _ in 0..10 {
             match self.usb_tty.read_from_device(None){
-                Response::TempSuccess => return true,
+                Response::TempCount(count) => return count,
-                Response::TempFailed => return false,
                 _ => {},
             }
         }
 	self.usb_tty.write_to_device(Command::ReadTemp);
 	for _ in 0..10{
 	    match self.usb_tty.read_from_device(None){
-		Response::TempSuccess => return true,
+                Response::TempCount(count) => return count,
-		Response::TempFailed => return false,
 		_ => {},
 	    }
         }
 	log::error!("Temp read failed!!!");
-	return false;
+	return 0;
     }
+
+    pub fn init_temp_count(&mut self){
+        self.go_to_lifecycle_menu();
+        self.usb_tty.write_to_device(Command::ReadTemp);
+        for _ in 0..10 {
+            match self.usb_tty.read_from_device(None){
+                Response::TempCount(count) => self.init_temps = count ,
+                _ => {},
+            }
+        }
+	self.usb_tty.write_to_device(Command::ReadTemp);
+	for _ in 0..10{
+	    match self.usb_tty.read_from_device(None){
+                Response::TempCount(count) => self.init_temps = count ,
+		_ => {},
+	    }
+        }
+	log::error!("Temp read failed!!!");
+	//return 0;
+    }
+
     pub fn is_bp_running(&mut self) -> bool {
         self.go_to_lifecycle_menu();
         self.usb_tty.write_to_device(Command::CheckBPState);
@@ -360,7 +383,6 @@ impl Device{
         }
     }
     pub fn reboot(&mut self) -> () {
-        //self.go_to_login_prompt();
         self.usb_tty.write_to_device(Command::Quit);
         while self.usb_tty.read_from_device(None) != Response::Rebooting {}
         self.current_state = State::Shutdown;
@@ -378,11 +400,9 @@ impl Device{
             return true;
         }
     }
-    pub fn test_cycle(&mut self, bp_cycles: Option<u64>, temp_cycles: Option<u64>) -> () {
+    pub fn test_cycle(&mut self, bp_cycles: Option<u64>, _temp_cycles: Option<u64>) -> () {
         let local_bp_cycles: u64 = bp_cycles.unwrap_or(3);
-        let local_temp_cycles: u64 = temp_cycles.unwrap_or(2);
         if self.current_state != State::LoginPrompt { self.reboot(); }
-        thread::sleep(BOOT_TIME);
         self.go_to_lifecycle_menu();
         _ = self.usb_tty.read_from_device(Some("["));
         for _bp_count in 1..=local_bp_cycles{
@@ -390,7 +410,13 @@ impl Device{
             self.start_bp();
             let bp_start = self.is_bp_running();
             log::trace!("Has bp started on device {}? : {:?}",self.serial,bp_start);
-            thread::sleep(BP_RUN);
+            thread::sleep(BP_RUN_1);
+
+            self.start_temp();
+            thread::sleep(TEMP_WAIT);
+            self.stop_temp();
+
+            thread::sleep(BP_RUN_2);
             let bp_end = self.is_bp_running();
             log::trace!("Has bp ended on device {}? : {:?}",self.serial,bp_end);
             if bp_start != bp_end {
@@ -399,16 +425,6 @@ impl Device{
                 self.save_values();
             }
         }
-        for _temp_count in 1..=local_temp_cycles{
-            log::info!("Running temp {} on device {} ...",(self.temps+1),self.serial);
-            let temp_start = self.start_temp().is_temp_running();
-            let temp_end = self.stop_temp().is_temp_running();
-            if temp_start != temp_end {
-                self.temps +=1;
-                log::debug!("Increasing temp count for device {} to {}",self.serial,self.temps);
-                self.save_values();
-            }
-        }
         log::info!("Rebooting {} for the {}th time",self.serial, self.reboots);
         self.reboot();
         self.reboots += 1;

src/main.rs

@@ -49,8 +49,8 @@ fn input_filtering(prompt:Option<&str>) -> String{
 }
 
 fn main(){
-    setup_logs();
     let args = Args::parse();
+    setup_logs(&args.debug);
     log::info!("Seymour Life Testing version: {}",VERSION);
     if args.debug{
         log::debug!("Debug enabled!");
@@ -181,7 +181,7 @@ fn find_gpio(device:&mut Device,gpio:&mut GpioPins) -> bool{
     return false;
 }
 
-pub fn setup_logs(){
+pub fn setup_logs(debug:&bool){
     let chrono_now: DateTime<Local> = Local::now();
     if ! Path::new("logs").is_dir(){
         _ = fs::create_dir("logs");
@@ -204,10 +204,15 @@ pub fn setup_logs(){
                     chrono_now.format("%Y-%m-%d_%H.%M").to_string()
                     )).unwrap()),
         )
-        .chain(
+        .chain({
-            fern::Dispatch::new()
+            let mut stdout_logger = fern::Dispatch::new();
-                .level(log::LevelFilter::Info)
+            if *debug {
-                .chain(std::io::stdout())
+                stdout_logger = stdout_logger.level(log::LevelFilter::Trace);
-        )
+            }
+            else {
+                stdout_logger = stdout_logger.level(log::LevelFilter::Info);
+            }
+                stdout_logger.chain(std::io::stdout())
+        })
         .apply();
 }

src/tty.rs

@@ -32,8 +32,7 @@ pub enum Response{
     ShellPrompt,
     BPOn,
     BPOff,
-    TempFailed,
+    TempCount(u64),
-    TempSuccess,
     LoginPrompt,
     DebugMenuReady,
     DebugMenuWithContinuedMessage,
@@ -51,7 +50,7 @@ const COMMAND_MAP:Lazy<HashMap<Command,&str>> = Lazy::new(||HashMap::from([
     (Command::BrightnessMenu, "B"),
     (Command::BrightnessHigh, "0"),
     (Command::BrightnessLow, "1"),
-    (Command::ReadTemp, "h"),
+    (Command::ReadTemp, "H"),
     (Command::UpMenuLevel, "\\"),
     (Command::Login,"root\n"),
     (Command::RedrawMenu,"?"),
@@ -59,15 +58,14 @@ const COMMAND_MAP:Lazy<HashMap<Command,&str>> = Lazy::new(||HashMap::from([
     (Command::Newline,"\n"),
 ]));
 
-const RESPONSES:[(&str,Response);10] = [
+const RESPONSES:[(&str,Response);9] = [
     ("reboot: Restarting",Response::Rebooting),
     ("login:",Response::LoginPrompt),
     ("Password:",Response::PasswordPrompt),
     ("root@",Response::ShellPrompt),
     ("Check NIBP In Progress: True",Response::BPOn),
     ("Check NIBP In Progress: False",Response::BPOff),
-    ("Temp: 0",Response::TempFailed),
+    ("SureTemp Probe Pulls:",Response::TempCount(0)),
-    ("Temp:",Response::TempSuccess),
     ("> ",Response::DebugMenuWithContinuedMessage),
     (">",Response::DebugMenuReady),
 ];
@@ -127,7 +125,15 @@ impl TTY{
                 if read_line.contains(string){
                    log::debug!("Successful read of {:?} from tty {}, which matches pattern {:?}",read_line,self.tty.name().unwrap_or("unknown shell".to_string()),enum_value);
                    self.failed_read_count = 0;
+                    if enum_value == Response::TempCount(0){
+                        match read_line.rsplit_once(' '){
+                            None =>  return enum_value,
+                            Some((_,temp_count)) => return Response::TempCount(temp_count.parse().unwrap_or(0))
+                        }
+                    }
+                    else{
                     return enum_value;
+                    }
                 }
             }
             return Response::Other;