semi working quadrature output

Cargo.toml

@@ -10,5 +10,5 @@ hal = { package = "esp32-hal", version = "0.15.0" }
 esp-backtrace = { version = "0.8.0", features = ["esp32", "panic-handler", "exception-handler", "print-uart"] }
 esp-println = { version = "0.6.0", features = ["esp32","log"] }
 log = { version = "0.4.18" }
-si5351 = "0.2.0"
+si5351 = { git = "http://192.168.1.41:3000/lks/si5351.git" }
 embedded-hal = "0.2.7"

src/main.rs

@@ -11,7 +11,8 @@ use hal::{
         timer::{self, TimerIFace},
         HighSpeed, LEDC,
     },
-    uart, Delay, Uart, IO,
+    uart, Uart, /*Delay*/
+    IO,
 };
 
 use si5351::{Si5351, Si5351Device};
@@ -19,10 +20,11 @@ use si5351::{Si5351, Si5351Device};
 #[entry]
 fn main() -> ! {
     let peripherals = Peripherals::take();
+    //let uart = peripherals.UART0;
     let mut system = peripherals.DPORT.split();
     let io = IO::new(peripherals.GPIO, peripherals.IO_MUX);
     let clocks = ClockControl::max(system.clock_control).freeze();
-    let delay = Delay::new(&clocks);
+    //let mut delay = Delay::new(&clocks);
 
     let serial = { uart::Uart::new(peripherals.UART0, &mut system.peripheral_clock_control) };
 
@@ -32,6 +34,7 @@ fn main() -> ! {
     // this requires a clean rebuild because of https://github.com/rust-lang/cargo/issues/10358
     esp_println::logger::init_logger_from_env();
     log::info!("Logger is setup");
+    //println!("Hello world!");
 
     let i2c = I2C::new(
         peripherals.I2C0,
@@ -43,12 +46,13 @@ fn main() -> ! {
     );
     log::info!("I2C Initialized");
 
+    //i2c.write(0b0110_0000, &[0x64]);
+
     let mut clock = Si5351Device::new_adafruit_module(i2c);
     match clock.init_adafruit_module() {
         Ok(_) => {
             log::info!("Si5351 Initialized succesfully");
-            clock.set_freq(1_000_000).unwrap();
+            main_loop(clock, serial);
-            main_loop(clock, serial, delay);
         }
         Err(e) => {
             match e {
@@ -84,20 +88,17 @@ fn main() -> ! {
                 })
                 .unwrap();
 
-            main_loop(ledc, serial, delay);
+            main_loop(ledc, serial);
         }
     }
 }
 
-fn main_loop<T: Clockable, U: _esp_hal_uart_Instance>(
+fn main_loop<T: Clockable, U: _esp_hal_uart_Instance>(mut clock: T, mut serial: Uart<'_, U>) -> ! {
-    mut clock: T,
+    clock.set_freq(1_000_000).unwrap();
-    mut serial: Uart<'_, U>,
-    mut delay: Delay,
-) -> ! {
     loop {
-        let freq = read_freq(&mut serial, &mut delay);
+        let freq = read_freq(&mut serial);
         log::info!("Got Freq: {}", freq);
-        match clock.set_freq(freq) {
+        match clock.set_quad(freq) {
             Ok(_) => log::info!("Set frequency to {}", freq),
             Err(_) => log::warn!("Could not set frequency to {}", freq),
         }
@@ -106,9 +107,13 @@ fn main_loop<T: Clockable, U: _esp_hal_uart_Instance>(
 
 trait Clockable {
     fn set_freq(&mut self, freq: u32) -> Result<(), ()>;
+    fn set_quad(&mut self, freq: u32) -> Result<f32, ()>;
 }
 
 impl Clockable for LEDC<'_> {
+    fn set_quad(&mut self, _freq: u32) -> Result<f32, ()> {
+        Err(())
+    }
     fn set_freq(&mut self, freq: u32) -> Result<(), ()> {
         let mut hstimer0 = self.get_timer::<HighSpeed>(timer::Number::Timer0);
 
@@ -129,6 +134,9 @@ impl<T> Clockable for Si5351Device<T>
 where
     Si5351Device<T>: Si5351,
 {
+    fn set_quad(&mut self, freq: u32) -> Result<f32, ()> {
+        Si5351::set_quad(self, freq).map_err(|_| ())
+    }
     fn set_freq(&mut self, freq: u32) -> Result<(), ()> {
         match self.set_frequency(si5351::PLL::A, si5351::ClockOutput::Clk0, freq) {
             Ok(_) => Ok(()),
@@ -155,12 +163,11 @@ where
 //  return freq;
 
 // fn rf<T: embedded_hal::serial::Read<u8>>(serial: &mut T) -> u32 { 0 }
-fn read_freq<T: _esp_hal_uart_Instance>(serial: &mut Uart<'_, T>, delay: &mut Delay) -> u32 {
+fn read_freq<T: _esp_hal_uart_Instance>(serial: &mut Uart<'_, T>) -> u32 {
     let mut freq = 0;
     let mut invalid = false;
     loop {
-        //match nb::block!(serial.read()) {
+        match nb::block!(serial.read()) {
-        match serial.read() {
             Ok(input) if input >= b'0' && input <= b'9' => {
                 log::debug!("Got char: {}", char::from(input));
                 freq = (freq * 10) + (input - b'0') as u32;
@@ -182,12 +189,9 @@ fn read_freq<T: _esp_hal_uart_Instance>(serial: &mut Uart<'_, T>, delay: &mut De
                 log::debug!("Got inval: {}", char::from(input));
                 invalid = true;
             }
-            Err(nb::Error::Other(e)) => {
+            Err(e) => {
                 log::debug!("Got error: {:?}", e);
             }
-            Err(nb::Error::WouldBlock) => {
-                delay.delay(10);
-            }
         }
     }