Cargo.toml

@@ -10,5 +10,6 @@ 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" }
+esp-alloc = { version = "0.3.0" }
 si5351 = "0.2.0"
 embedded-hal = "0.2.7"

src/main.rs

@@ -2,24 +2,31 @@
 #![no_main]
 
 extern crate alloc;
+use core::mem::MaybeUninit;
 use esp_backtrace as _;
+//use esp_println::println;
 
 use embedded_hal::serial::Read;
 use hal::{clock::ClockControl, i2c::I2C, peripherals::Peripherals, prelude::*};
-use hal::{
+use hal::{uart, Uart /*Delay*/, IO};
-    ledc::{
-        channel::{self, ChannelIFace},
-        timer::{self, TimerIFace},
-        HighSpeed, LEDC,
-    },
-    uart, Uart, /*Delay*/
-    IO,
-};
 
+use si5351;
 use si5351::{Si5351, Si5351Device};
 
+#[global_allocator]
+static ALLOCATOR: esp_alloc::EspHeap = esp_alloc::EspHeap::empty();
+
+fn init_heap() {
+    const HEAP_SIZE: usize = 32 * 1024;
+    static mut HEAP: MaybeUninit<[u8; HEAP_SIZE]> = MaybeUninit::uninit();
+
+    unsafe {
+        ALLOCATOR.init(HEAP.as_mut_ptr() as *mut u8, HEAP_SIZE);
+    }
+}
 #[entry]
 fn main() -> ! {
+    init_heap();
     let peripherals = Peripherals::take();
     //let uart = peripherals.UART0;
     let mut system = peripherals.DPORT.split();
@@ -55,41 +62,13 @@ fn main() -> ! {
             log::info!("Si5351 Initialized succesfully");
             main_loop(clock, serial);
         }
-        Err(e) => {
+        Err(si5351::Error::CommunicationError) => {
-            match e {
+            log::info!("Could not initialize Si5351: CommunicationError");
-                si5351::Error::InvalidParameter => {
+            main_loop(Dummy {}, serial);
-                    log::warn!("Could not initialize Si5351; Using LedC PWM")
         }
-                si5351::Error::CommunicationError => {
+        Err(si5351::Error::InvalidParameter) => {
-                    log::info!("Could not find Si5351 device; Using LedC PWM")
+            log::info!("Could not initialize Si5351: InvalidParameter");
-                }
+            main_loop(Dummy {}, serial);
-            }
-            let ledc = LEDC::new(
-                peripherals.LEDC,
-                &clocks,
-                &mut system.peripheral_clock_control,
-            );
-            let led = io.pins.gpio4.into_push_pull_output();
-
-            let mut hstimer0 = ledc.get_timer::<HighSpeed>(timer::Number::Timer0);
-            hstimer0
-                .configure(timer::config::Config {
-                    duty: timer::config::Duty::Duty5Bit,
-                    clock_source: timer::HSClockSource::APBClk,
-                    frequency: 1u32.MHz(),
-                })
-                .unwrap();
-
-            let mut channel0 = ledc.get_channel(channel::Number::Channel0, led);
-            channel0
-                .configure(channel::config::Config {
-                    timer: &hstimer0,
-                    duty_pct: 50,
-                    pin_config: channel::config::PinConfig::PushPull,
-                })
-                .unwrap();
-
-            main_loop(ledc, serial);
         }
     }
 }
@@ -108,27 +87,9 @@ fn main_loop<T: Clockable, U: _esp_hal_uart_Instance>(mut clock: T, mut serial:
 trait Clockable {
     fn set_freq(&mut self, freq: u32) -> Result<(), ()>;
 }
-
+impl<T> Clockable for T
-impl Clockable for LEDC<'_> {
-    fn set_freq(&mut self, freq: u32) -> Result<(), ()> {
-        let mut hstimer0 = self.get_timer::<HighSpeed>(timer::Number::Timer0);
-
-        let res = hstimer0.configure(timer::config::Config {
-            duty: timer::config::Duty::Duty5Bit,
-            clock_source: timer::HSClockSource::APBClk,
-            frequency: freq.Hz(),
-        });
-
-        match res {
-            Ok(_) => Ok(()),
-            Err(_) => Err(()),
-        }
-    }
-}
-
-impl<T> Clockable for Si5351Device<T>
 where
-    Si5351Device<T>: Si5351,
+    T: Si5351,
 {
     fn set_freq(&mut self, freq: u32) -> Result<(), ()> {
         match self.set_frequency(si5351::PLL::A, si5351::ClockOutput::Clk0, freq) {
@@ -169,28 +130,28 @@ fn read_freq<T: _esp_hal_uart_Instance>(serial: &mut Uart<'_, T>) -> u32 {
     loop {
         match nb::block!(serial.read()) {
             Ok(input) if input >= b'0' && input <= b'9' => {
-                log::debug!("Got char: {}", char::from(input));
+                log::info!("Got char: {}", char::from(input));
                 freq = (freq * 10) + (input - b'0') as u32;
             }
             Ok(input) if invalid && (input == b'\n' || input == b'\r') => {
-                log::debug!("Got bad end: {}", char::from(input));
+                log::info!("Got bad end: {}", char::from(input));
                 freq = 0;
                 invalid = false;
             }
             Ok(input) if !invalid && (input == b'\n' || input == b'\r') => {
-                log::debug!("Got end: {}", char::from(input));
+                log::info!("Got end: {}", char::from(input));
                 break;
             }
             Ok(input) if input == b'.' || input == b',' || input == b'_' => {
-                log::debug!("Got ignor: {}", char::from(input));
+                log::info!("Got ignor: {}", char::from(input));
                 continue;
             }
             Ok(input) => {
-                log::debug!("Got inval: {}", char::from(input));
+                log::info!("Got inval: {}", char::from(input));
                 invalid = true;
             }
             Err(e) => {
-                log::debug!("Got error: {:?}", e);
+                log::info!("Got error: {:?}", e);
             }
         }
     }