.cargo/config

     "-C", "inline-threshold=5",
     "-C", "no-vectorize-loops",
 ]
-runner = "elf2uf2-rs -d"
+#runner = "elf2uf2-rs -d"
+runner = "arm-none-eabi-gdb -x openocd.gdb"
+

Cargo.lock

  "syn",
 ]
 
+[[package]]
+name = "cortex-m-semihosting"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bffa6c1454368a6aa4811ae60964c38e6996d397ff8095a8b9211b1c1f749bc"
+dependencies = [
+ "cortex-m",
+]
+
 [[package]]
 name = "crc-any"
 version = "2.4.0"
 ]
 
 [[package]]
-name = "panic-halt"
-version = "0.2.0"
+name = "panic-semihosting"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de96540e0ebde571dc55c73d60ef407c653844e6f9a1e2fdbd40c07b9252d812"
+checksum = "c3d55dedd501dfd02514646e0af4d7016ce36bc12ae177ef52056989966a1eec"
+dependencies = [
+ "cortex-m",
+ "cortex-m-semihosting",
+]
 
 [[package]]
 name = "paste"
  "cortex-m",
  "cortex-m-rt",
  "cortex-m-rtic",
+ "cortex-m-semihosting",
  "embedded-hal",
  "embedded-time",
  "nb 1.0.0",
- "panic-halt",
+ "panic-semihosting",
  "pio",
  "pio-proc",
  "rp2040-boot2",

Cargo.toml

 cortex-m = "0.7.2"
 cortex-m-rt = "0.7"
 cortex-m-rtic = "0.6.0-alpha.5"
+cortex-m-semihosting = "0.3.7"
 embedded-hal ="0.2.5"
 embedded-time = "0.12.0"
 nb = "1.0"
-panic-halt = "0.2.0"
+#panic-halt = "0.2.0"
+panic-semihosting = "0.5"
+#panic-write = "0.1.0"
 pio = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
 pio-proc = { git = "https://github.com/rp-rs/pio-rs.git", branch = "main" }
 #rp2040-hal = { git = "https://github.com/rp-rs/rp-hal.git", features = ["rt"] }
 
 [patch.crates-io]
 usb-device = { path = "../usb-device" }
+
+[profile]
+[profile.release]
+debug = true
+lto = true

openocd.cfg

+source [find interface/cmsis-dap.cfg]
+transport select swd
+
+adapter speed 100
+source [find target/rp2040.cfg]
+

openocd.gdb

+set history save on
+set confirm off
+target extended-remote :3333
+monitor arm semihosting enable
+monitor reset halt
+
+# print demangled symbols
+set print asm-demangle on
+
+# set backtrace limit to not have infinite backtrace loops
+set backtrace limit 32
+
+# detect unhandled exceptions, hard faults and panics
+break DefaultHandler
+break HardFault
+#break rust_begin_unwind
+
+#break main
+
+load
+run
+# continue
+# monitor verify
+# monitor reset
+# quit
+

src/main.rs

 #![no_std]
 #![no_main]
 
-use panic_halt as _;
+//use panic_halt as _;
+use cortex_m::interrupt::CriticalSection;
+use panic_semihosting as _;
+use rp2040_hal::pac::UART0;
+use rp2040_hal::uart;
 
 mod audio_buffer;
 mod i2s_master;
 #[used]
 pub static BOOT2: [u8; 256] = rp2040_boot2::BOOT_LOADER;
 
+/*pub fn uart<'cs>(cs: &'cs CriticalSection) -> &'cs mut uart::UartPeripheral<uart::Enabled, UART0> {
+    use panic_write::PanicHandler;
+
+    unsafe {
+        let panic_handler = app::PANIC_HANDLER.borrow(cs).get();
+        let panic_handler_ref = core::mem::transmute::<
+            *mut Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+            &mut Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+        >(panic_handler);
+        panic_handler_ref.as_mut().unwrap()
+    }
+}*/
+
 #[rtic::app(device = rp2040_hal::pac, peripherals = true, dispatchers = [RTC_IRQ, XIP_IRQ])]
 mod app {
     use embedded_hal::digital::v2::OutputPin;
     use crate::audio_buffer::AudioBuffer;
     use crate::i2s_master::I2sMaster;
     use crate::usb::Usb;
-    use cortex_m::interrupt;
+    //use core::cell::UnsafeCell;
+    use core::fmt::Write;
+    use cortex_m::interrupt::{self, Mutex};
+    //use panic_write::PanicHandler;
     use rp2040_hal::dma::{DMAExt, SingleChannel, CH0};
     use rp2040_hal::gpio::bank0::{Gpio0, Gpio1, Gpio3, Gpio6};
-    use rp2040_hal::gpio::{Function, Pin, Pio0};
+    use rp2040_hal::gpio::{Function, FunctionUart, Pin, Pio0};
+    use rp2040_hal::pac::UART0;
     use rp2040_hal::pio::{PIOExt, PIO0SM0};
     use rp2040_hal::pll::common_configs::PLL_USB_48MHZ;
     use rp2040_hal::pll::{setup_pll_blocking, PLLConfig};
     use rp2040_hal::sio::Sio;
     use rp2040_hal::timer::Timer;
+    //use rp2040_hal::uart;
     use rp2040_hal::usb::UsbBus;
     use rp2040_hal::watchdog::Watchdog;
     use rp2040_hal::xosc::setup_xosc_blocking;
     };
 
     static AUDIO_BUFFER: AudioBuffer<4> = AudioBuffer::new();
+    /*pub static UART: Mutex<
+        MaybeUninit<Option<&'static mut uart::UartPeripheral<uart::Enabled, UART0>>>,
+    > = Mutex::new(UnsafeCell::new(None));*/
+    /*pub static mut PANIC_HANDLER: Mutex<
+        UnsafeCell<
+            Option<core::pin::Pin<PanicHandler<uart::UartPeripheral<uart::Enabled, UART0>>>>,
+        >,
+    > = Mutex::new(UnsafeCell::new(None));*/
 
     #[monotonic(binds = SysTick, default = true)]
     type SystickMono = Systick<100>;
         let mut led = pins.gpio25.into_push_pull_output();
         led.set_low().ok().unwrap();
 
+        /*// We need a UART to debug panics.
+        let mut uart = uart::UartPeripheral::<_, _>::enable(
+            c.device.UART0,
+            &mut resets,
+            uart::common_configs::_115200_8_N_1,
+            clocks.peripheral_clock.into(),
+        )
+        .unwrap();
+        let _tx_pin = pins.gpio16.into_mode::<FunctionUart>();
+        let _rx_pin = pins.gpio17.into_mode::<FunctionUart>();
+        writeln!(&mut uart, "Initializing...\r").unwrap();
+        interrupt::free(|cs| unsafe {
+            let panic_handler = PANIC_HANDLER.borrow(cs);
+            *panic_handler.get() = Some(PanicHandler::new(uart));
+            writeln!(super::uart(cs), "Panic handler installed.\r").unwrap();
+        });*/
+
         // We need a timer so that we can determine the USB SOF frequency for asynchronous USB
         // audio.
         let timer = Timer::new(c.device.TIMER, &mut resets);
         }
     }
 
-    /// DMA interrupt handler.
+    /*/// DMA interrupt handler.
     ///
     /// DMA interrupts need to have highest priority as we need to quickly restart the DMA transfer
     /// to ensure that the PIO FIFO always contains data.
             }
             write.write_finished(packet, cs);
         });
-    }
+    }*/
 
     /// USB interrupt handler.
     ///

src/usb.rs

         // using the USB peripheral at this time.
         let sof = unsafe { (&*USBCTRL_REGS::ptr()).intr.read().dev_sof().bit_is_set() };
         if sof {
+            // Clear the SOF IRQ.
+            unsafe { (&*USBCTRL_REGS::ptr()).sof_rd.read() };
+
             // Calculate the frequency difference (frames versus 1kHz derived from the system
             // clock) and update the synchronization data for the USB audio class accordingly.
             // Also, add a correction factor if the buffers are running low or high.

src/usb_audio.rs

 //!
 //! See "Universal Serial Bus Device Class Definition for Audio Devices", release 1.0 (March 18,
 //! 1998) for a specification of the USB audio class.
+use cortex_m::interrupt;
 use usb_device::class_prelude::*;
 use usb_device::endpoint::{IsochronousSynchronizationType, IsochronousUsageType};
 use usb_device::Result;
     audio_streaming_inactive: InterfaceNumber,
     audio_streaming: InterfaceNumber,
     audio_out: EndpointOut<'a, B>,
-    audio_out_sync: EndpointIn<'a, B>,
+    //audio_out_sync: EndpointIn<'a, B>,
     //audio_in: EndpointIn<'a, B>,
     samples_per_frame: [u8; 3],
 
                 256,
                 1,
             ),
-            audio_out_sync: bus_alloc.isochronous(
+            /*audio_out_sync: bus_alloc.isochronous(
                 IsochronousSynchronizationType::Asynchronous,
                 IsochronousUsageType::Feedback,
                 3,
                 1,
-            ),
+            ),*/
             /*audio_in: bus_alloc.isochronous(
                 IsochronousSynchronizationType::Asynchronous,
                 IsochronousUsageType::Data,
 
 impl<B: UsbBus, OUTBUF: AsRef<[u32]>> UsbClass<B> for UsbAudioClass<'_, B, OUTBUF> {
     fn get_configuration_descriptors(&self, writer: &mut DescriptorWriter) -> Result<()> {
+        /*interrupt::free(|cs| {
+            writeln!(crate::uart(cs), "A\r").unwrap();
+        });*/
         writer.iad(
             self.audio_control,
             2,   // Two interfaces (control + streaming).
             Ok(2)
         })?;*/
 
+        /*interrupt::free(|cs| {
+            writeln!(crate::uart(cs), "B\r").unwrap();
+        });*/
+
         Ok(())
     }
 
 
     fn reset(&mut self) {
         // Start sending synchronization data.
-        self.endpoint_in_complete(self.audio_out_sync.address());
+        //self.endpoint_in_complete(self.audio_out_sync.address());
     }
 
     fn control_out(&mut self, xfer: ControlOut<B>) {
         };
     }
 
-    fn endpoint_out(&mut self, addr: EndpointAddress) {
+    /*fn endpoint_out(&mut self, addr: EndpointAddress) {
         if addr == self.audio_out.address() {
             if self.audio_out_buf.is_some() {
                 // TODO: Write data into buffer, move buffer somewhere else.
             // Immediately write the next sync value.
             //self.audio_out_sync.write(&self.samples_per_frame).unwrap();
         }
-    }
+    }*/
 }
 
 /*use usb_device::class_prelude::*;