magic fafo constant found

spinnyboy_rust/src/bin/dc_driver/dshot.rs

@@ -16,7 +16,8 @@ fn calculate_crc(frame: u16) -> u16 {
 IFlight XING-E Pro 2207 2750KV 
 */
 const XING_EPRO_22_POLES: u32 = 4; 
-const XING_EPRO_22_MAGNETS: u32 = 14;
+const XING_EPRO_22_MAGNETS: u32 = 14; 
+
 #[allow(dead_code)]
 #[allow(non_camel_case_types)]
 #[derive(Debug)]
@@ -323,7 +324,8 @@ impl<'a> DShot<'a> {
                                             let erpm = (60 * 1_000_000) / period_ms;
 
                                             let rpm = erpm/(XING_EPRO_22_MAGNETS/2);
-                                            self.rpm.set(Some(rpm))
+                                            // let rpm = erpm/7;
+                                            self.rpm.set(Some((rpm as f32) as _))
                                         }
                                     }
                                 }

spinnyboy_rust/src/bin/main.rs

@@ -12,18 +12,18 @@ use esp_hal::delay::Delay;
 use esp_hal::uart::{Config, Uart};
 use esp_hal::{gpio, main};
 
-use core::fmt::Debug;
 use esp_hal::gpio::{Event, OutputConfig};
 use esp_hal::gpio::{Input, InputConfig};
 use esp_hal::handler;
 use esp_hal::rmt::{Rmt, TxChannelConfig, TxChannelCreator};
-use esp_hal::time::{Instant, Rate};
+use esp_hal::time::{ Instant, Rate};
+use core::fmt::Debug;
 //pid-controller
 use core::time::Duration;
 use discrete_pid::pid::PidContext;
-use discrete_pid::time::InstantLike;
 use discrete_pid::time::Millis;
 use discrete_pid::{pid, time};
+use discrete_pid::time::InstantLike;
 
 use core::cell::RefCell;
 use core::mem::forget;
@@ -43,16 +43,12 @@ use crate::dc_driver::dshot;
 use crate::peripherals::ErrCommand;
 use esp_hal::rmt::RxChannelConfig;
 use esp_hal::rmt::RxChannelCreator;
-
-use esp_hal::timer::OneShotTimer;
-use esp_hal::timer::Timer;
-use esp_hal::timer::timg::TimerGroup;
 #[panic_handler]
 fn panic(panic: &core::panic::PanicInfo) -> ! {
-    rprintln!("{}", panic.message());
+    rprintln!("{}",panic.message());
     let trace = Backtrace::capture();
     loop {
-        rprintln!("{}", panic.location().unwrap())
+        // rprintln!("{}",panic.location().unwrap())
     }
 }
 use alloc::format;
@@ -62,8 +58,7 @@ extern crate alloc;
 //target RPM
 const DEFAULT_TARGET_RPM: u32 = 4000;
 //in seconds
-const DEFAULT_SPIN_TIME: u64 = 10;
-const DEFAULT_DRY_SPIN_TIME: u64 = 10;
+const DEFAULT_SPIN_TIME: u32 = 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!();
@@ -83,6 +78,8 @@ impl InstantLike for Time {
     }
 }
 
+
+
 #[main]
 fn main() -> ! {
     // generator version: 1.0.1
@@ -129,19 +126,44 @@ fn main() -> ! {
     //PID-Controller
     let loop_time = Duration::from_micros(10);
     let cfg = pid::PidConfigBuilder::default()
-        .kp(2.0)
-        .ki(0.4)
-        .output_limits(100.00, 400.00)
-        .sample_time(loop_time)
-        .filter_tc(0.1)
-        .build()
-        .expect("Failed to build a PID configuration");
-    let controller = pid::FuncPidController::new(cfg);
+    .kp(2.0)
+    .ki(0.1).output_limits(100.00, 2040.00)
+    .sample_time(loop_time)
+    .filter_tc(0.1)
+    .build()
+    .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 mut control: f32 = 200.0;
-    let mut timg0 = TimerGroup::new(peripherals.TIMG0);
-    let coat_timer = timg0.timer0;
-    // shot_esc.set_throttle(0);
+    let set_point = DEFAULT_TARGET_RPM;
+    dshot_esc.arm();
+    let mut rpm = 0;
+    let mut control: f32 = 600.0;
+    // let timestamp = Instant::now();
+    loop {
+        dshot_esc.process();
+        //let control_val = dc_driver::
+        //this bad boy needs floats, this will be fun :)
+        dshot_esc.set_throttle(control as _);
+        rpm = match dshot_esc.get_rpm() {
+            Some(x) => {
+                // rprintln!("GOT RPM {}", x);
+                x
+            }
+            None => {
+                rprintln!("NO RPM!");
+                rpm
+            }
+        };
+        // rprintln!("RPM:{}",rpm);
+        let last_time = esp_hal::time::Instant::now();
+     
+        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);
+        let dumped_context = ctx.last_time().expect("LAST TIME!"); 
+        rprintln!("control:{},rpm:{}", control,rpm);
+    }
+
+    // rprintln!("RMT SENT!");
     // let mut esc = AfroEsc::new(&mut pwm_pin);;
     // esc.set_timestamp(1000);
     // delay.delay_millis(3000);
@@ -174,12 +196,10 @@ fn main() -> ! {
     .with_rx(peripherals.GPIO5)
     .with_tx(peripherals.GPIO7);
     let mut display = Nextion::new(&mut uart0);
-    //we just set it to page0 to be sure
+
     display.send_command(b"page page0");
-    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 _rpm = DEFAULT_TARGET_RPM;
+    let mut _timer = DEFAULT_SPIN_TIME;
     let mut started = false;
     loop {
         if display.read_ready() {
@@ -189,7 +209,6 @@ fn main() -> ! {
                 }
                 Ok(Command::Start) => {
                     rprintln!("START");
-                    display.send_command(b"page page2");
                     started = true;
                 }
                 Ok(Command::Stop) => {
@@ -199,19 +218,11 @@ fn main() -> ! {
                 }
                 Ok(Command::SetRpm(x)) => {
                     rprintln!("SET_RPM with {}", x);
-                    target_rpm = x;
+                    _rpm = x;
                 }
                 Ok(Command::SetTimer(x)) => {
                     rprintln!("SETTING 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 _;
+                    _timer = x;
                 }
                 Ok(Command::SendConfig) => {
                     rprintln!("SEND CONFIG");
@@ -224,76 +235,12 @@ fn main() -> ! {
                 Err(ErrCommand::ReadError) => {
                     rprintln!("READ FAILED!");
                 }
-                _ => {
-                    rprintln!("This should never happen!")
-                }
             }
             // display.send_command(b"page page0");
         }
         if started {
-            rprintln!("STARTING!");
-            let _ = coat_timer
-                .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;
-            //first round!
-            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 _);
-                current_rpm = match dshot_esc.get_rpm() {
-                    Some(x) => {
-                        // rprintln!("GOT RPM {}", x);
-                        x
-                    }
-                    None => {
-                        rpm_fail_ctr += 1;
-                        // rprintln!("NO RPM!");
-                        current_rpm
-                    }
-                };
-                // rprintln!("RPM:{}",rpm);
-                let last_time = esp_hal::time::Instant::now();
-
-                let timestamp = esp_hal::time::Instant::now()
-                    .duration_since_epoch()
-                    .as_millis();
-                (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, current_rpm);
-                //first we send the RPM!
-                if display.write_ready() {
-                    let running_rpm = format!("rpm1.val={}", current_rpm);
-                    display.send_command(running_rpm.to_string().as_bytes());
-                    let counter = format!("counter.val={}", 1234);
-                    display.send_command(counter.to_string().as_bytes());
-                }
-               if display.read_ready(){
-                   match display.read_command() {
-                   Ok(Command::DoDryRun) =>{
-                            break;
-                        },
-                        _ => {//we don't care about the rest}
-                   }
-               }
-            }
-
-            rprintln!("COATING done!");
-            rprintln!("RPM_READ_FAILS {}", rpm_fail_ctr);
-            started = false;
-            display.send_command(b"page page3");
+            // spincoater.armed();
+            rprintln!("STARTING!")
         }
     }
 }

spinnyboy_rust/src/bin/peripherals/mod.rs

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

spinnyboy_rust/src/bin/peripherals/nextion.rs

@@ -116,15 +116,6 @@ 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))
-            }
-            08 => Ok(Command::DoDryRun),
             00 => Ok(Command::CommandSuccess),
             _ => Err(ErrCommand::NoValidCmd),
         }
@@ -132,9 +123,6 @@ impl<'a> Nextion<'a> {
     pub fn read_ready(&mut self) -> bool {
         self.interface.read_ready()
     }
-    pub fn write_ready(&mut self) -> bool {
-        self.interface.write_ready()
-    }
     fn reset(&mut self) {
         self.state = UartStatemachine::WaitingP;
         self.idx = 0;