Use clippy

Author: JalonWong

.github/workflows/release.yml

@@ -22,8 +22,10 @@ jobs:
         with:
           python-version: "3.13"
       - run: python scripts/sync_code.py --check
-      - run: cargo build --release --features=stm32f103,xG
       - run: cargo build --release --features=stm32f100,xC
+      - run: cargo build --release --features=stm32f103,xG,rtic
+      - run: cargo clippy --features=stm32f103,xG,rtic
+      - run: cargo test --target=x86_64-unknown-linux-gnu --features=std
       - run: python scripts/build.py --example=f103c8
 
   publish:

Cargo.toml

@@ -9,7 +9,7 @@
     name = "stm32f1-hal"
     readme = "README.md"
     repository = "https://github.com/jw-mcu-rust/stm32f1-hal"
-    version = "0.0.4"
+    version = "0.0.5"
 
     [package.metadata.docs.rs]
         features = ["stm32f103", "xG"]

src/common/dma/circular_buffer_rx.rs

@@ -26,15 +26,18 @@ where
     }
 }
 
-pub struct CircularBuffer<T: Sized> {
+pub struct CircularBuffer<T> {
     recv_buf: Vec<T>,
     read_idx: usize,
 }
 
-impl<T> CircularBuffer<T> {
+impl<T: Sized + Copy> CircularBuffer<T> {
     fn new(buf_size: usize) -> Self {
         let mut recv_buf = Vec::<T>::with_capacity(buf_size);
-        unsafe { recv_buf.set_len(buf_size) }
+        #[allow(clippy::uninit_vec)]
+        unsafe {
+            recv_buf.set_len(buf_size)
+        }
 
         Self {
             recv_buf,
@@ -63,18 +66,15 @@ impl<T> CircularBuffer<T> {
                 ret = Some(&self.recv_buf[self.read_idx..end]);
                 self.read_idx = end;
             }
+        } else if max > dma_recv_idx - self.read_idx {
+            ret = Some(&self.recv_buf[self.read_idx..dma_recv_idx]);
+            self.read_idx = dma_recv_idx;
         } else {
-            if max > dma_recv_idx - self.read_idx {
-                ret = Some(&self.recv_buf[self.read_idx..dma_recv_idx]);
-                self.read_idx = dma_recv_idx;
-            } else {
-                let end = self.read_idx + max;
-                ret = Some(&self.recv_buf[self.read_idx..end]);
-                self.read_idx = end;
-            };
+            let end = self.read_idx + max;
+            ret = Some(&self.recv_buf[self.read_idx..end]);
+            self.read_idx = end;
         }
-
-        return ret;
+        ret
     }
 
     fn as_slice(&self) -> &[T] {

src/common/dma/ringbuf_tx.rs

@@ -6,6 +6,7 @@ use critical_section::Mutex;
 pub struct DmaRingbufTx {}
 
 impl DmaRingbufTx {
+    #[allow(clippy::new_ret_no_self)]
     pub fn new<T, CH>(
         mut ch: CH,
         peripheral_addr: usize,

src/common/os.rs

@@ -69,12 +69,8 @@ impl TimeoutInstance for RetryTimesInstance {
 
 // Always ----------------------------------
 
+#[derive(Default)]
 pub struct AlwaysTimeout {}
-impl AlwaysTimeout {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
 impl Timeout for AlwaysTimeout {
     #[inline]
     fn start(&mut self) -> impl TimeoutInstance {

src/common/ringbuf.rs

@@ -10,10 +10,10 @@ pub trait ProducerExt<T> {
 impl<T: Copy> ProducerExt<T> for Producer<T> {
     fn get_write_chunk_uninit(&mut self) -> Option<WriteChunkUninit<'_, T>> {
         let n = self.slots();
-        if n > 0 {
-            if let Ok(chunk) = self.write_chunk_uninit(n) {
-                return Some(chunk);
-            }
+        if n > 0
+            && let Ok(chunk) = self.write_chunk_uninit(n)
+        {
+            return Some(chunk);
         }
         None
     }
@@ -81,10 +81,10 @@ pub trait ConsumerExt<T> {
 impl<T: Copy> ConsumerExt<T> for Consumer<T> {
     fn get_read_chunk(&mut self) -> Option<ReadChunk<'_, T>> {
         let n = self.slots();
-        if n > 0 {
-            if let Ok(chunk) = self.read_chunk(n) {
-                return Some(chunk);
-            }
+        if n > 0
+            && let Ok(chunk) = self.read_chunk(n)
+        {
+            return Some(chunk);
         }
         None
     }

src/common/timer/counter.rs

@@ -88,7 +88,7 @@ impl<TIM: GeneralTimer> CounterHz<TIM> {
         // freq_divider is always bigger than 0, since (psc + 1) is always less than
         // timer_clock
         let freq_divider = (self.clk.raw() / (psc + 1)) as u64;
-        let cnt: u32 = self.tim.read_count().into();
+        let cnt: u32 = self.tim.read_count();
         let cnt = cnt as u64;
 
         // It is safe to make this cast, because the maximum timer period in this HAL is
@@ -132,7 +132,7 @@ impl<TIM: GeneralTimer, const FREQ: u32> Counter<TIM, FREQ> {
     }
 
     pub fn now(&self) -> TimerInstantU32<FREQ> {
-        TimerInstantU32::from_ticks(self.tim.read_count().into())
+        TimerInstantU32::from_ticks(self.tim.read_count())
     }
 
     pub fn start(&mut self, timeout: TimerDurationU32<FREQ>) -> Result<(), Error> {

src/common/timer/mod.rs

@@ -24,6 +24,9 @@ pub trait GeneralTimer {
     fn reset_counter(&mut self);
     fn enable_preload(&mut self, b: bool);
     fn max_auto_reload() -> u32;
+    /// # Safety
+    ///
+    /// `arr` must be greater than 0
     unsafe fn set_auto_reload_unchecked(&mut self, arr: u32);
     fn set_auto_reload(&mut self, arr: u32) -> Result<(), Error>;
     fn read_auto_reload(&self) -> u32;

src/common/timer/pwm.rs

@@ -23,12 +23,12 @@ impl<TIM: TimerWithPwm> PwmTimer<TIM> {
 
     #[inline]
     pub fn get_count_value(&self) -> u32 {
-        self.tim.read_count().into()
+        self.tim.read_count()
     }
 
     #[inline]
     pub fn get_max_duty(&self) -> u32 {
-        (self.tim.read_auto_reload() as u32).wrapping_add(1)
+        self.tim.read_auto_reload().wrapping_add(1)
     }
 
     #[inline]

src/common/uart/uart_dma.rs

@@ -55,7 +55,7 @@ where
 {
     #[inline(always)]
     fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
-        if buf.len() == 0 {
+        if buf.is_empty() {
             return Err(Error::Other);
         }
 
@@ -126,7 +126,7 @@ where
     T: Timeout,
 {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
-        if buf.len() == 0 {
+        if buf.is_empty() {
             return Err(Error::Other);
         }