Replace log based logging with uwriteln

Author: lmbollen

firmware-binaries/demos/soft-ugn-demo-mu-2/src/main.rs

@@ -17,7 +17,6 @@ use bittide_sys::net_state::{Manager, Subordinate, UgnEdge, UgnReport};
 use bittide_sys::smoltcp::ringbuffer::RingbufferDevice;
 use bittide_sys::stability_detector::Stability;
 use core::fmt::Write;
-use log::{info, trace, warn, LevelFilter};
 use riscv::register::{mcause, mepc, mtval};
 use smoltcp::iface::{Config, Interface, SocketHandle, SocketSet, SocketStorage};
 use smoltcp::socket::tcp;
@@ -28,7 +27,6 @@ const INSTANCES: DeviceInstances = unsafe { DeviceInstances::new() };
 const LINK_COUNT: usize = 7;
 const TCP_BUF_SIZE: usize = 256;
 const MANAGER_DNA: [u8; 12] = [133, 129, 48, 4, 64, 192, 105, 1, 1, 0, 2, 64];
-const LOG_TICK_EVERY: u32 = 500;
 const CLIENT_IP: [u8; 4] = [100, 100, 100, 100];
 const SERVER_IP: [u8; 4] = [100, 100, 100, 101];
 
@@ -61,30 +59,24 @@ fn socket_set<'a>(storage: &'a mut [SocketStorage<'static>]) -> SocketSet<'a> {
 fn make_device(
     rx: ReceiveRingbuffer,
     tx: TransmitRingbuffer,
+    uart: &mut bittide_hal::shared_devices::Uart,
 ) -> RingbufferDevice<ReceiveRingbuffer, TransmitRingbuffer> {
     let mut rx_aligned = AlignedReceiveBuffer::new(rx);
     rx_aligned.align(&tx);
-    info!(
+    uwriteln!(
+        uart,
         "Aligned RX buffer with offset {}",
         rx_aligned.get_alignment_offset().unwrap()
-    );
+    )
+    .ok();
     RingbufferDevice::new(rx_aligned, tx)
 }
 
 #[cfg_attr(not(test), entry)]
 fn main() -> ! {
     let mut uart = INSTANCES.uart;
-    unsafe {
-        use bittide_sys::uart::log::LOGGER;
-        let logger = &mut (*LOGGER.get());
-        logger.set_logger(uart.clone());
-        logger.set_timer(INSTANCES.timer);
-        logger.display_source = LevelFilter::Warn;
-        log::set_logger_racy(logger).ok();
-        log::set_max_level_racy(LevelFilter::Info);
-    }
 
-    info!("=== Soft UGN Demo MU2 ===");
+    uwriteln!(uart, "=== Soft UGN Demo MU2 ===").ok();
     let transceivers = &INSTANCES.transceivers;
     let cc = INSTANCES.clock_control;
     let elastic_buffers = [
@@ -114,7 +106,7 @@ fn main() -> ! {
     // 6) Run manager state machines to connect to neighbors and request UGNs.
     // 7) Collect UGN edges over TCP and aggregate locally.
 
-    info!("Bringing up links...");
+    uwriteln!(uart, "Bringing up links...").ok();
     let mut link_startups = [LinkStartup::new(); LINK_COUNT];
     while !link_startups.iter().all(|ls| ls.is_done()) {
         for (i, link_startup) in link_startups.iter_mut().enumerate() {
@@ -127,7 +119,7 @@ fn main() -> ! {
         }
     }
 
-    info!("Waiting for stability...");
+    uwriteln!(uart, "Waiting for stability...").ok();
     loop {
         let stability = Stability {
             stable: cc.links_stable()[0],
@@ -138,7 +130,7 @@ fn main() -> ! {
         }
     }
 
-    info!("Stopping auto-centering...");
+    uwriteln!(uart, "Stopping auto-centering...").ok();
     elastic_buffers
         .iter()
         .for_each(|eb| eb.set_auto_center_enable(false));
@@ -153,14 +145,16 @@ fn main() -> ! {
         capture_ugn.set_elastic_buffer_delta(eb_delta);
     }
 
-    info!("Captured hardware UGNs");
+    uwriteln!(uart, "Captured hardware UGNs").ok();
     for (i, capture_ugn) in capture_ugns.iter().enumerate() {
-        info!(
+        uwriteln!(
+            uart,
             "Capture UGN {}: local = {}, remote = {}",
             i,
             capture_ugn.local_counter(),
             capture_ugn.remote_counter()
-        );
+        )
+        .ok();
     }
 
     let receive_ringbuffers = [
@@ -190,8 +184,14 @@ fn main() -> ! {
         core::array::from_fn(|i| {
             let rx = receive_iter.next().expect("missing receive ringbuffer");
             let tx = transmit_iter.next().expect("missing transmit ringbuffer");
-            let device = make_device(rx, tx);
-            trace!("Made device for link {}, with MTU {}", i, device.mtu());
+            let device = make_device(rx, tx, &mut uart);
+            uwriteln!(
+                uart,
+                "Made device for link {}, with MTU {}",
+                i,
+                device.mtu()
+            )
+            .ok();
             device
         });
 
@@ -207,71 +207,68 @@ fn main() -> ! {
         sockets.add(socket)
     });
     let dna = INSTANCES.dna.dna();
-    info!("My dna: {:?}", dna);
+    uwriteln!(uart, "My dna: {:?}", dna).ok();
     let is_manager = dna == MANAGER_DNA;
-    info!(
+    uwriteln!(
+        uart,
         "Role: {}",
         if is_manager { "manager" } else { "subordinate" }
-    );
-    unsafe {
-        log::set_max_level_racy(LevelFilter::Trace);
-    }
+    )
+    .ok();
 
     if is_manager {
-        info!("Starting manager state machines...");
+        uwriteln!(uart, "Starting manager state machines...").ok();
         let mut reports: [Option<UgnReport>; LINK_COUNT] = [None; LINK_COUNT];
         for link in 0..LINK_COUNT {
             let socket_handle = socket_handles[link];
-            info!("Starting manager for link {}", link);
+            uwriteln!(uart, "Starting manager for link {}", link).ok();
             let now = to_smoltcp_instant(INSTANCES.timer.now());
             let mut iface =
                 Interface::new(Config::new(HardwareAddress::Ip), &mut devices[link], now);
             set_iface_ip(&mut iface, CLIENT_IP);
             let mut manager = Manager::new(iface, socket_handle, link, SERVER_IP);
 
-            trace!("Starting manager loop for link {}", link);
             loop {
                 let now = to_smoltcp_instant(INSTANCES.timer.now());
                 let mut sockets = socket_set(&mut sockets_storage[link][..]);
-                trace!("Polling manager link {}", link);
                 manager.poll(now, &mut devices[link], &mut sockets);
-                trace!("manager link {} state {:?}", link, manager.state());
                 if manager.is_done() {
-                    trace!("manager link {} is done", link);
                     break;
                 }
             }
             reports[link] = Some(manager.report());
         }
 
-        info!("UGN reports from subordinates:");
+        uwriteln!(uart, "UGN reports from subordinates:").ok();
         for (idx, report) in reports.iter().enumerate() {
             if let Some(report) = report {
-                info!("Link {}: {} edges", idx, report.count);
+                uwriteln!(uart, "Link {}: {} edges", idx, report.count).ok();
                 for (edge_idx, edge) in report.edges.iter().enumerate() {
                     if edge_idx >= report.count as usize {
                         break;
                     }
                     if let Some(edge) = edge {
-                        info!(
+                        uwriteln!(
+                            uart,
                             "  Edge {}: {}:{} -> {}:{}, ugn={}",
                             edge_idx,
                             edge.src_node,
                             edge.src_port,
                             edge.dst_node,
                             edge.dst_port,
                             edge.ugn
-                        );
+                        )
+                        .ok();
                     } else {
-                        warn!("  Edge {}: missing", edge_idx);
+                        uwriteln!(uart, "  Edge {}: missing", edge_idx).ok();
                     }
                 }
             } else {
-                warn!("Link {}: no report", idx);
+                uwriteln!(uart, "Link {}: no report", idx).ok();
             }
         }
     } else {
-        info!("Starting subordinate state machines...");
+        uwriteln!(uart, "Starting subordinate state machines...").ok();
 
         let mut subordinates: [Subordinate; LINK_COUNT] = core::array::from_fn(|idx| {
             let now = to_smoltcp_instant(INSTANCES.timer.now());
@@ -287,36 +284,10 @@ fn main() -> ! {
 
         loop {
             tick = tick.wrapping_add(1);
-            if tick % LOG_TICK_EVERY == 0 {
-                info!("subordinate loop tick {}", tick);
-            }
             let now = to_smoltcp_instant(INSTANCES.timer.now());
             for link in 0..LINK_COUNT {
                 let mut sockets = socket_set(&mut sockets_storage[link][..]);
-                trace!("Polling subordinate link {}", link);
                 subordinates[link].poll(now, &mut devices[link], &mut sockets);
-                {
-                    let socket = sockets.get::<tcp::Socket>(socket_handles[link]);
-                    trace!(
-                        "subordinate link {} socket open {} active {} can_send {} can_recv {} state {:?}",
-                        link,
-                        socket.is_open(),
-                        socket.is_active(),
-                        socket.can_send(),
-                        socket.can_recv(),
-                        socket.state()
-                    );
-                }
-                trace!(
-                    "subordinate link {} ip addrs {:?}",
-                    link,
-                    subordinates[link].iface().ip_addrs()
-                );
-                trace!(
-                    "subordinate link {} state {:?}",
-                    link,
-                    subordinates[link].state()
-                );
             }
         }
     }
@@ -341,9 +312,9 @@ fn exception_handler(_trap_frame: &riscv_rt::TrapFrame) -> ! {
     let mut uart = INSTANCES.uart;
     riscv::interrupt::free(|| {
         uwriteln!(uart, "... caught an exception. Looping forever now.\n").unwrap();
-        info!("mcause: {:?}\n", mcause::read());
-        info!("mepc: {:?}\n", mepc::read());
-        info!("mtval: {:?}\n", mtval::read());
+        writeln!(uart, "mcause: {:?}\n", mcause::read()).ok();
+        writeln!(uart, "mepc: {:?}\n", mepc::read()).ok();
+        writeln!(uart, "mtval: {:?}\n", mtval::read()).ok();
     });
     loop {
         continue;
@@ -364,6 +335,5 @@ fn build_report_for_link(
         dst_port: link as u32,
         ugn: capture_ugn.local_counter() as i64,
     });
-    trace!("Prepared report for link {}", link);
     report
 }