From 5ad291b708528b5772d6ebcc9309fbd3f8a002c8 Mon Sep 17 00:00:00 2001
From: Corey Schuhen <cschuhen@gmail.com>
Date: Sat, 17 Feb 2024 18:12:47 +1000
Subject: Add a buffered mode.

---
 examples/stm32g4/src/bin/can.rs | 97 ++++++++++++++++++++++++++++++++++++++---
 1 file changed, 90 insertions(+), 7 deletions(-)

(limited to 'examples')

diff --git a/examples/stm32g4/src/bin/can.rs b/examples/stm32g4/src/bin/can.rs
index 5ff4f0ef0..043ca7144 100644
--- a/examples/stm32g4/src/bin/can.rs
+++ b/examples/stm32g4/src/bin/can.rs
@@ -5,6 +5,7 @@ use embassy_executor::Spawner;
 use embassy_stm32::peripherals::*;
 use embassy_stm32::{bind_interrupts, can, Config};
 use embassy_time::Timer;
+use static_cell::StaticCell;
 use {defmt_rtt as _, panic_probe as _};
 
 bind_interrupts!(struct Irqs {
@@ -28,13 +29,17 @@ async fn main(_spawner: Spawner) {
     // 250k bps
     can.set_bitrate(250_000);
 
+    let use_fd = false;
+
     // 1M bps
-    can.set_fd_data_bitrate(1_000_000, false);
+    if use_fd {
+        can.set_fd_data_bitrate(1_000_000, false);
+    }
 
     info!("Configured");
 
-    //let mut can = can.into_normal_mode();
-    let mut can = can.into_internal_loopback_mode();
+    let mut can = can.into_normal_mode();
+    //let mut can = can.into_internal_loopback_mode();
 
     let mut i = 0;
     let mut last_read_ts = embassy_time::Instant::now();
@@ -68,11 +73,17 @@ async fn main(_spawner: Spawner) {
     }
 
     // Use the FD API's even if we don't get FD packets.
-    loop {
-        let frame = can::frame::FdFrame::new_extended(0x123456F, &[i; 16]).unwrap();
-        info!("Writing frame using FD API");
 
-        _ = can.write_fd(&frame).await;
+    loop {
+        if use_fd {
+            let frame = can::frame::FdFrame::new_extended(0x123456F, &[i; 16]).unwrap();
+            info!("Writing frame using FD API");
+            _ = can.write_fd(&frame).await;
+        } else {
+            let frame = can::frame::FdFrame::new_extended(0x123456F, &[i; 8]).unwrap();
+            info!("Writing frame using FD API");
+            _ = can.write_fd(&frame).await;
+        }
 
         match can.read_fd().await {
             Ok((rx_frame, ts)) => {
@@ -96,6 +107,7 @@ async fn main(_spawner: Spawner) {
         }
     }
 
+    i = 0;
     let (mut tx, mut rx) = can.split();
     // With split
     loop {
@@ -120,5 +132,76 @@ async fn main(_spawner: Spawner) {
         Timer::after_millis(250).await;
 
         i += 1;
+
+        if i > 2 {
+            break;
+        }
+    }
+
+    let can = can::Fdcan::join(tx, rx);
+
+    info!("\n\n\nBuffered\n");
+    if use_fd {
+        static TX_BUF: StaticCell<can::TxFdBuf<8>> = StaticCell::new();
+        static RX_BUF: StaticCell<can::RxFdBuf<10>> = StaticCell::new();
+        let mut can = can.buffered_fd(
+            TX_BUF.init(can::TxFdBuf::<8>::new()),
+            RX_BUF.init(can::RxFdBuf::<10>::new()),
+        );
+        loop {
+            let frame = can::frame::FdFrame::new_extended(0x123456F, &[i; 16]).unwrap();
+            info!("Writing frame");
+
+            _ = can.write(frame).await;
+
+            match can.read().await {
+                Ok((rx_frame, ts)) => {
+                    let delta = (ts - last_read_ts).as_millis();
+                    last_read_ts = ts;
+                    info!(
+                        "Rx: {} {:02x} --- {}ms",
+                        rx_frame.header().len(),
+                        rx_frame.data()[0..rx_frame.header().len() as usize],
+                        delta,
+                    )
+                }
+                Err(_err) => error!("Error in frame"),
+            }
+
+            Timer::after_millis(250).await;
+
+            i += 1;
+        }
+    } else {
+        static TX_BUF: StaticCell<can::TxBuf<8>> = StaticCell::new();
+        static RX_BUF: StaticCell<can::RxBuf<10>> = StaticCell::new();
+        let mut can = can.buffered(
+            TX_BUF.init(can::TxBuf::<8>::new()),
+            RX_BUF.init(can::RxBuf::<10>::new()),
+        );
+        loop {
+            let frame = can::frame::ClassicFrame::new_extended(0x123456F, &[i; 8]).unwrap();
+            info!("Writing frame");
+
+            _ = can.write(frame).await;
+
+            match can.read().await {
+                Ok((rx_frame, ts)) => {
+                    let delta = (ts - last_read_ts).as_millis();
+                    last_read_ts = ts;
+                    info!(
+                        "Rx: {} {:02x} --- {}ms",
+                        rx_frame.header().len(),
+                        rx_frame.data()[0..rx_frame.header().len() as usize],
+                        delta,
+                    )
+                }
+                Err(_err) => error!("Error in frame"),
+            }
+
+            Timer::after_millis(250).await;
+
+            i += 1;
+        }
     }
 }
-- 
cgit