Fix clippy warnings

.github/workflows/ci.yml

@@ -35,6 +35,12 @@ jobs:
       - name: Build
         run: cargo build --release --verbose --target ${{ matrix.target }}
 
+      - name: Lint
+        run: cargo clippy --release --verbose --target ${{ matrix.target }} -- -D warnings
+
+      - name: fmt
+        run: cargo fmt --check
+
       - name: Build examples
         run: cargo build --verbose --examples --target ${{ matrix.target }}
         if: matrix.target != 'x86_64-unknown-linux-gnu'

Cargo.toml

@@ -38,8 +38,7 @@ littlefs2 = { version = "0.5", optional = true }
 [dev-dependencies]
 aes = "0.7"
 cortex-m-rt = "0.6"
-# cortex-m-rtic = "0.5"
-lpc55-rtic = "0.5"
+rtic = { package = "cortex-m-rtic", version = "1" }
 cortex-m-semihosting = "0.3"
 heapless = "0.7"
 panic-halt  = "0.2"

examples/adc.rs

@@ -143,5 +143,7 @@ fn main() -> ! {
     }
 
     heprintln!("looping").unwrap();
-    loop {}
+    loop {
+        heprintln!("looping").unwrap();
+    }
 }

examples/aes.rs

@@ -36,8 +36,8 @@ fn main() -> ! {
     //
     // via software
     //
-    let mut sw_block = block.clone();
-    let cipher = aes::Aes256::new(&key);
+    let mut sw_block = block;
+    let cipher = aes::Aes256::new(key);
 
     let (sw_cyc_enc, _) = hal::count_cycles(|| {
         cipher.encrypt_block(&mut sw_block);
@@ -57,7 +57,7 @@ fn main() -> ! {
     //
     // via hardware
     //
-    let mut hw_block = block.clone();
+    let mut hw_block = block;
     let cipher = hashcrypt.aes256(&raw_key);
 
     cipher.prime_for_encryption();

examples/flash.rs

@@ -175,12 +175,12 @@ fn main() -> ! {
     buf[..4].copy_from_slice(&data);
 
     flash
-        .write_native(WHERE, &generic_array::GenericArray::from_slice(&buf))
+        .write_native(WHERE, generic_array::GenericArray::from_slice(&buf))
         .unwrap();
     buf[0] = 37;
     // // buf[3] = 37;
     flash
-        .write_native(WHERE, &generic_array::GenericArray::from_slice(&buf))
+        .write_native(WHERE, generic_array::GenericArray::from_slice(&buf))
         .unwrap();
     flash.write_u8(0x4_000F, 69).ok();
     flash.read(WHERE, &mut read_buf);

examples/i2c.rs

@@ -15,7 +15,6 @@ use hal::{
     time::Hertz,
 };
 
-use ssd1306;
 use ssd1306::prelude::*;
 
 #[entry]

examples/late.rs

@@ -1,6 +1,5 @@
 //! examples/late.rs
 
-#![deny(unsafe_code)]
 // something something about:
 //
 // error: use of deprecated item
@@ -11,34 +10,44 @@
 #![no_main]
 #![no_std]
 
-use cortex_m_semihosting::hprintln;
-use hal::raw::Interrupt;
-use heapless::spsc::{Consumer, Producer, Queue};
-use lpc55_hal as hal;
 use panic_semihosting as _;
 
-#[rtic::app(device = hal::raw)]
-const APP: () = {
-    // Late resources
-    struct Resources {
+#[rtic::app(device = lpc55_hal::raw)]
+mod app {
+    use core::ptr::addr_of_mut;
+
+    use cortex_m_semihosting::hprintln;
+    use hal::raw::Interrupt;
+    use heapless::spsc::{Consumer, Producer, Queue};
+    use lpc55_hal as hal;
+
+    #[shared]
+    struct SharedResources {}
+
+    #[local]
+    struct LocalResources {
         p: Producer<'static, u32, 4>,
         c: Consumer<'static, u32, 4>,
     }
 
     #[init]
-    fn init(_: init::Context) -> init::LateResources {
+    fn init(_ctx: init::Context) -> (SharedResources, LocalResources, init::Monotonics) {
         static mut Q: Queue<u32, 4> = Queue::new();
 
-        let (p, c) = Q.split();
+        let (p, c) = unsafe { (*addr_of_mut!(Q)).split() };
 
         // Initialization of late resources
-        init::LateResources { p, c }
+        (
+            SharedResources {},
+            LocalResources { p, c },
+            init::Monotonics(),
+        )
     }
 
-    #[idle(resources = [c])]
-    fn idle(c: idle::Context) -> ! {
+    #[idle(local = [c])]
+    fn idle(ctx: idle::Context) -> ! {
         loop {
-            if let Some(byte) = c.resources.c.dequeue() {
+            if let Some(byte) = ctx.local.c.dequeue() {
                 hprintln!("received message: {}", byte).unwrap();
             // cortex_m::asm::wfi();
             } else {
@@ -47,8 +56,8 @@ const APP: () = {
         }
     }
 
-    #[task(binds = ADC0, resources = [p])]
-    fn adc0(c: adc0::Context) {
-        c.resources.p.enqueue(42).unwrap();
+    #[task(binds = ADC0, local = [p])]
+    fn adc0(ctx: adc0::Context) {
+        ctx.local.p.enqueue(42).unwrap();
     }
-};
+}

examples/pfr.rs

@@ -67,7 +67,7 @@ fn main() -> ! {
     dump_cfpa(&cfpa);
 
     heprintln!("Increment the version and write back cfpa!").ok();
-    cfpa.version = cfpa.version + 1;
+    cfpa.version += 1;
     cfpa.secure_fw_version += 1;
     cfpa.ns_fw_version += 1;
     // increment a byte of customer data (with overflow)

examples/prince.rs

@@ -29,7 +29,7 @@ fn main() -> ! {
     let mut syscon = hal.syscon;
 
     // prince region 2 (128KB)
-    const DATA_ADDR: usize = 0x00080000 + 0;
+    const DATA_ADDR: usize = 0x00080000;
 
     let _clocks = hal::ClockRequirements::default()
         .system_frequency(12.MHz())
@@ -39,15 +39,15 @@ fn main() -> ! {
     let flash = hal.flash.enabled(&mut syscon);
     let mut flash = hal::FlashGordon::new(flash);
 
-    let mut rng = hal.rng.enabled(&mut syscon);
+    let rng = hal.rng.enabled(&mut syscon);
 
-    let mut prince = hal.prince.enabled(&mut rng);
+    let mut prince = hal.prince.enabled(&rng);
 
     prince.enable_all_region_2();
 
     hprintln!("writing AA's to flash data.").ok();
 
-    flash.erase_page((DATA_ADDR / 512) + 0).unwrap();
+    flash.erase_page(DATA_ADDR / 512).unwrap();
     flash.erase_page((DATA_ADDR / 512) + 1).unwrap();
 
     prince.write_encrypted(|_prince| {
@@ -58,19 +58,21 @@ fn main() -> ! {
     hprintln!("Read bytes PRINCE ON:").ok();
     let mut buf = [0u8; 1024];
 
+    #[allow(clippy::needless_range_loop)]
     for i in 0..buf.len() {
         let ptr = DATA_ADDR as *const u8;
-        buf[i] = unsafe { *ptr.offset(i as isize) };
+        buf[i] = unsafe { *ptr.add(i) };
     }
 
     dump_hex!(&buf[0..32]);
 
     // Turn off PRINCE.
     prince.disable_all_region_2();
 
+    #[allow(clippy::needless_range_loop)]
     for i in 0..buf.len() {
         let ptr = DATA_ADDR as *const u8;
-        buf[i] = unsafe { *ptr.offset(i as isize) };
+        buf[i] = unsafe { *ptr.add(i) };
     }
 
     hprintln!("Read bytes PRINCE OFF:").ok();

examples/puf.rs

@@ -94,7 +94,7 @@ fn main() -> ! {
         // write first 512-byte chunk
         write_buf[0..4].copy_from_slice(&(State::Enrolled as u32).to_ne_bytes());
         write_buf[16..].copy_from_slice(&ac[..496]);
-        flash.write(PUF_STATE_FLASH + 0, &write_buf).unwrap();
+        flash.write(PUF_STATE_FLASH, &write_buf).unwrap();
 
         // // write 2nd chunk
         write_buf.copy_from_slice(&ac[496..1008]);
@@ -117,10 +117,10 @@ fn main() -> ! {
         }
 
         for i in 0..kc1.len() {
-            assert!(kc1[i] == check_buf[1192 + 52 * 0 + i])
+            assert!(kc1[i] == check_buf[1192 + i])
         }
         for i in 0..kc2.len() {
-            assert!(kc2[i] == check_buf[1192 + 52 * 1 + i])
+            assert!(kc2[i] == check_buf[1192 + 52 + i])
         }
         for i in 0..kc3.len() {
             assert!(kc3[i] == check_buf[1192 + 52 * 2 + i])
@@ -133,23 +133,12 @@ fn main() -> ! {
     } else {
         dbg!("The device is already enrolled.");
         flash.read(PUF_STATE_FLASH + 16, &mut check_buf);
-        for i in 0..1192 {
-            ac[i] = check_buf[i];
-        }
-
-        for i in 0..kc1.len() {
-            kc1[i] = check_buf[1192 + 52 * 0 + i];
-        }
-        for i in 0..kc2.len() {
-            kc2[i] = check_buf[1192 + 52 * 1 + i];
-        }
-        for i in 0..kc3.len() {
-            kc3[i] = check_buf[1192 + 52 * 2 + i];
-        }
-        for i in 0..kc4.len() {
-            kc4[i] = check_buf[1192 + 52 * 3 + i];
-        }
+        ac.copy_from_slice(&check_buf[..1192]);
 
+        kc1.copy_from_slice(&check_buf[1192..][..52]);
+        kc2.copy_from_slice(&check_buf[1192 + 52..][..52]);
+        kc3.copy_from_slice(&check_buf[1192 + 52 * 2..][..52]);
+        kc4.copy_from_slice(&check_buf[1192 + 52 * 3..][..52]);
         dump_hex!(ac[..16], 16);
         dump_hex!(ac[1192 - 16..], 16);
 
@@ -203,5 +192,7 @@ fn main() -> ! {
     }
 
     dbg!("Looping");
-    loop {}
+    loop {
+        dbg!("Loop");
+    }
 }

examples/pwm.rs

@@ -7,6 +7,8 @@ extern crate panic_semihosting; // 4004 bytes
 #[macro_use(block)]
 extern crate nb;
 
+use core::f32;
+
 use cortex_m_rt::entry;
 
 use hal::drivers::{Pins, Pwm, Timer};
@@ -95,8 +97,9 @@ fn main() -> ! {
             }
         }
 
+        #[allow(clippy::needless_range_loop)]
         for i in 0..3 {
-            let duty = (sin(duties[i] * 3.14159265f32 / 180f32) * 255f32) as u16;
+            let duty = (sin(duties[i] * f32::consts::PI / 180f32) * 255f32) as u16;
             match i {
                 0 => {
                     // need to tune down red some

examples/rtic_led.rs

@@ -3,23 +3,27 @@
 
 extern crate panic_semihosting;
 // extern crate panic_halt;
-use cortex_m_semihosting::dbg;
 
-use hal::{drivers::pins, drivers::pins::Level, prelude::*, typestates::pin};
-use lpc55_hal as hal;
+#[rtic::app(device = lpc55_hal::raw, peripherals = true)]
+mod app {
+    use cortex_m_semihosting::dbg;
 
-type RedLed = hal::Pin<pins::Pio1_6, pin::state::Gpio<pin::gpio::direction::Output>>;
+    use hal::{drivers::pins, drivers::pins::Level, prelude::*, typestates::pin};
+    use lpc55_hal as hal;
 
-#[rtic::app(device = crate::hal::raw, peripherals = true)]
-const APP: () = {
-    struct Resources {
+    type RedLed = hal::Pin<pins::Pio1_6, pin::state::Gpio<pin::gpio::direction::Output>>;
+    #[shared]
+    struct SharedResources {}
+
+    #[local]
+    struct LocalResources {
         led: RedLed,
         // delay: hal::clock::Ticks<'static, hal::syscon::Fro1MhzUtickClock<states::init_state::Enabled>>,
         // sleep: hal::sleep::Busy<'static, 'static>,
     }
 
     #[init]
-    fn init(c: init::Context) -> init::LateResources {
+    fn init(c: init::Context) -> (SharedResources, LocalResources, init::Monotonics) {
         // dbg!("init");
         let _cp = c.core;
         let dp = c.device;
@@ -48,18 +52,21 @@ const APP: () = {
         // let mut utick = hal::utick::wrap(dp.UTICK).enabled(&mut syscon, &clock);
         // // let mut sleep = hal::sleep::Busy::prepare(&mut utick);
         // let mut sleep = hal::sleep::Busy::wrap(&mut utick);
-
-        init::LateResources {
-            led: red_led,
-            // delay,
-            // sleep,
-        }
+        (
+            SharedResources {},
+            LocalResources {
+                led: red_led,
+                // delay,
+                // sleep,
+            },
+            init::Monotonics(),
+        )
     }
 
     // #[idle(resources = [led, delay, sleep])]
-    #[idle(resources = [led])]
-    fn idle(c: idle::Context) -> ! {
-        let led = c.resources.led;
+    #[idle(local = [led])]
+    fn idle(ctx: idle::Context) -> ! {
+        let led = ctx.local.led;
         loop {
             dbg!("low");
             led.set_low().unwrap();
@@ -70,4 +77,4 @@ const APP: () = {
             // c.resources.sleep.sleep(c.resources.delay);
         }
     }
-};
+}

examples/semihosting.rs

@@ -27,8 +27,9 @@ fn main() -> ! {
     const UUID: *mut u32 = 0x0009_FC70 as *mut u32;
     // dbg!(UUID);
     let mut uuid: [u32; 4] = [0; 4];
+    #[allow(clippy::needless_range_loop)]
     for i in 0..4 {
-        uuid[i] = unsafe { dbg!(UUID.offset(i as isize).read_volatile()) };
+        uuid[i] = unsafe { dbg!(UUID.add(i).read_volatile()) };
     }
     // dbg!(uuid);