adds the rpm and the timer for the second spinning regime

spinnyboy_rust/src/bin/main.rs

@@ -62,7 +62,8 @@ extern crate alloc;
 //target RPM
 const DEFAULT_TARGET_RPM: u32 = 4000;
 //in seconds
-const DEFAULT_SPIN_TIME: u32 = 10;
+const DEFAULT_SPIN_TIME: u64 = 10;
+const DEFAULT_DRY_SPIN_TIME: u64 = 10;
 // This creates a default app-descriptor required by the esp-idf bootloader.
 // For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
 esp_bootloader_esp_idf::esp_app_desc!();
@@ -129,7 +130,7 @@ fn main() -> ! {
     let loop_time = Duration::from_micros(10);
     let cfg = pid::PidConfigBuilder::default()
         .kp(2.0)
-        .ki(0.0)
+        .ki(0.4)
         .output_limits(100.00, 400.00)
         .sample_time(loop_time)
         .filter_tc(0.1)
@@ -137,8 +138,6 @@ fn main() -> ! {
         .expect("Failed to build a PID configuration");
     let controller = pid::FuncPidController::new(cfg);
     let mut ctx = PidContext::new(Millis(0), 0.0, 0.0);
-    let set_point = DEFAULT_TARGET_RPM;
-    let mut rpm = 0;
     let mut control: f32 = 200.0;
     let mut timg0 = TimerGroup::new(peripherals.TIMG0);
     let coat_timer = timg0.timer0;
@@ -177,8 +176,10 @@ fn main() -> ! {
     let mut display = Nextion::new(&mut uart0);
     //we just set it to page0 to be sure
     display.send_command(b"page page0");
-    let mut _rpm = DEFAULT_TARGET_RPM;
-    let mut _timer = DEFAULT_SPIN_TIME;
+    let mut target_rpm = DEFAULT_TARGET_RPM;
+    let mut timer: u64 = DEFAULT_SPIN_TIME;
+    let mut target_dry_rpm = DEFAULT_DRY_SPIN_TIME;
+    let mut dry_timer: u64 = DEFAULT_SPIN_TIME;
     let mut started = false;
     loop {
         if display.read_ready() {
@@ -198,11 +199,19 @@ fn main() -> ! {
                 }
                 Ok(Command::SetRpm(x)) => {
                     rprintln!("SET_RPM with {}", x);
-                    _rpm = x;
+                    target_rpm = x;
                 }
                 Ok(Command::SetTimer(x)) => {
                     rprintln!("SETTING TIMER {}", x);
-                    _timer = x;
+                    timer = x as _;
+                }
+                Ok(Command::SetRpm2(x)) => {
+                    rprintln!("SET_RPM with {}", x);
+                    target_dry_rpm = x.try_into().expect("Couldn't cast RPM2 to u64");
+                }
+                Ok(Command::SetTimer2(x)) => {
+                    rprintln!("SETTING TIMER {}", x);
+                    dry_timer = x as _;
                 }
                 Ok(Command::SendConfig) => {
                     rprintln!("SEND CONFIG");
@@ -224,18 +233,20 @@ fn main() -> ! {
         if started {
             rprintln!("STARTING!");
             let _ = coat_timer
-                .load_value(esp_hal::time::Duration::from_secs(10))
+                .load_value(esp_hal::time::Duration::from_secs(timer))
                 .expect("TODO: Could not set timer for coating! ");
             dshot_esc.arm();
             let mut rpm_fail_ctr = 0;
+            let set_point = target_rpm;
             coat_timer.start();
+            let mut current_rpm = 0;
             while !coat_timer.is_interrupt_set() {
                 dshot_esc.process();
                 //let control_val = dc_driver::
                 //this bad boy needs floats, this will be fun :)
                 control = 200.00;
                 dshot_esc.set_throttle(control as _);
-                rpm = match dshot_esc.get_rpm() {
+                current_rpm = match dshot_esc.get_rpm() {
                     Some(x) => {
                         // rprintln!("GOT RPM {}", x);
                         x
@@ -243,7 +254,7 @@ fn main() -> ! {
                     None => {
                         rpm_fail_ctr += 1;
                         // rprintln!("NO RPM!");
-                        rpm
+                        current_rpm
                     }
                 };
                 // rprintln!("RPM:{}",rpm);
@@ -252,19 +263,23 @@ fn main() -> ! {
                 let timestamp = esp_hal::time::Instant::now()
                     .duration_since_epoch()
                     .as_millis();
-                (control, ctx) =
-                    controller.compute(ctx, rpm as _, set_point as _, Millis(timestamp), None);
+                (control, ctx) = controller.compute(
+                    ctx,
+                    current_rpm as _,
+                    set_point as _,
+                    Millis(timestamp),
+                    None,
+                );
                 let dumped_context = ctx.last_time().expect("LAST TIME!");
-                rprintln!("control:{},rpm:{}", control,rpm);
+                rprintln!("control:{},rpm:{}", control, current_rpm);
                 //first we send the RPM!
                 if display.write_ready() {
-                    let running_rpm = format!("rpm.val={}", rpm);
+                    let running_rpm = format!("rpm.val={}", current_rpm);
                     display.send_command(running_rpm.to_string().as_bytes());
                 }
                 if display.write_ready() {
                     let counter = format!("counter.val={}", 1234);
                     display.send_command(counter.to_string().as_bytes());
-
                 }
             }
 

spinnyboy_rust/src/bin/peripherals/mod.rs

@@ -7,6 +7,8 @@ pub enum Command {
     Stop,
     SendConfig,
     CommandSuccess,
+    SetRpm2(u32),
+    SetTimer2(u32),
 }
 #[derive(Debug)]
 pub enum ErrCommand {

spinnyboy_rust/src/bin/peripherals/nextion.rs

@@ -116,6 +116,14 @@ impl<'a> Nextion<'a> {
                 Ok(Command::SetTimer(time))
             }
             05 => Ok(Command::SendConfig),
+            06 => {
+                let rpm = u32::from_le_bytes(buf[1..5].try_into().expect("failed to parse rpm!"));
+                Ok(Command::SetRpm2(rpm))
+            }
+            07 => {
+                let time = u32::from_le_bytes(buf[1..5].try_into().expect("failed to parse rpm!"));
+                Ok(Command::SetTimer2(time))
+            }
             00 => Ok(Command::CommandSuccess),
             _ => Err(ErrCommand::NoValidCmd),
         }