Add non-blocking DMA rx & tx api, add demo

Author: kalkyl

examples/twis-demo/src/main.rs

@@ -43,7 +43,7 @@ const APP: () = {
         let sda = p0.p0_16.into_floating_input().degrade();
 
         let twis = Twis::new(ctx.device.TWIS0, Pins { scl, sda }, ADDR0);
-        twis.address1(ADDR1) // Add a secondary i2c address
+        twis.set_address1(ADDR1) // Add a secondary i2c address
             .enable_interrupt(TwiEvent::Write) // Trigger interrupt on WRITE command
             .enable_interrupt(TwiEvent::Read) // Trigger interrupt on READ command
             .enable();
@@ -73,11 +73,11 @@ const APP: () = {
             rprintln!("Writing data to controller...");
             match twis.address_match() {
                 ADDR0 => {
-                    let res = twis.tx(&buffer0[..]);
+                    let res = twis.tx_blocking(&buffer0[..]);
                     rprintln!("Result: {:?}\n{:?}", res, buffer0);
                 }
                 ADDR1 => {
-                    let res = twis.tx(&buffer1[..]);
+                    let res = twis.tx_blocking(&buffer1[..]);
                     rprintln!("Result: {:?}\n{:?}", res, buffer1);
                 }
                 _ => unreachable!(),
@@ -90,11 +90,11 @@ const APP: () = {
             rprintln!("Reading data from controller...");
             match twis.address_match() {
                 ADDR0 => {
-                    let res = twis.rx(&mut buffer0[..]);
+                    let res = twis.rx_blocking(&mut buffer0[..]);
                     rprintln!("Result: {:?}\n{:?}", res, buffer0);
                 }
                 ADDR1 => {
-                    let res = twis.rx(&mut buffer1[..]);
+                    let res = twis.rx_blocking(&mut buffer1[..]);
                     rprintln!("Result: {:?}\n{:?}", res, buffer1);
                 }
                 _ => unreachable!(),

examples/twis-dma-demo/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "twis-dma-demo"
+version = "0.1.0"
+authors = ["Henrik Alsér"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cortex-m = "0.6.2"
+cortex-m-rtic = "0.5.3"
+rtt-target = {version = "0.2.0", features = ["cortex-m"] }
+nrf52840-hal = { features = ["rt"], path = "../../nrf52840-hal" }
+
+[dependencies.embedded-hal]
+version = "0.2.3"
+features = ["unproven"]

examples/twis-dma-demo/Embed.toml

@@ -0,0 +1,46 @@
+[default.probe]
+# The index of the probe in the connected probe list.
+# probe_index = 0
+# The protocol to be used for communicating with the target.
+protocol = "Swd"
+# The speed in kHz of the data link to the target.
+# speed = 1337
+
+[default.flashing]
+# Whether or not the target should be flashed.
+enabled = true
+# Whether or not the target should be halted after flashing.
+halt_afterwards = false
+# Whether or not bytes erased but not rewritten with data from the ELF
+# should be restored with their contents before erasing.
+restore_unwritten_bytes = false
+# The path where an SVG of the assembled flash layout should be written to.
+# flash_layout_output_path = "out.svg"
+
+[default.general]
+# The chip name of the chip to be debugged.
+chip = "nRF52840"
+# A list of chip descriptions to be loaded during runtime.
+chip_descriptions = []
+# The default log level to be used.
+log_level = "Warn"
+
+[default.rtt]
+# Whether or not an RTTUI should be opened after flashing.
+# This is exclusive and cannot be used with GDB at the moment.
+enabled = true
+# A list of channel associations to be displayed. If left empty, all channels are displayed.
+channels = [
+    # { up = 0, down = 0, name = "name" }
+]
+# The duration in ms for which the logger should retry to attach to RTT.
+timeout = 3000
+# Whether timestamps in the RTTUI are enabled
+show_timestamps = true
+
+[default.gdb]
+# Whether or not a GDB server should be opened after flashing.
+# This is exclusive and cannot be used with RTT at the moment.
+enabled = false
+# The connection string in host:port format wher the GDB server will open a socket.
+# gdb_connection_string

examples/twis-dma-demo/src/main.rs

@@ -0,0 +1,77 @@
+#![no_std]
+#![no_main]
+
+use {
+    core::{
+        panic::PanicInfo,
+        sync::atomic::{compiler_fence, Ordering},
+    },
+    hal::{gpio::p0::Parts, pac::TWIS0, twis::*},
+    nrf52840_hal as hal,
+    rtt_target::{rprintln, rtt_init_print},
+};
+
+pub enum TwisTransfer {
+    Running(Transfer<TWIS0, &'static mut [u8; 8]>),
+    Idle((&'static mut [u8; 8], Twis<TWIS0>)),
+}
+
+#[rtic::app(device = crate::hal::pac, peripherals = true)]
+const APP: () = {
+    struct Resources {
+        transfer: Option<TwisTransfer>,
+    }
+
+    #[init]
+    fn init(ctx: init::Context) -> init::LateResources {
+        static mut BUF: [u8; 8] = [0; 8];
+        let _clocks = hal::clocks::Clocks::new(ctx.device.CLOCK).enable_ext_hfosc();
+        rtt_init_print!();
+        rprintln!("Waiting for commands from controller...");
+
+        let p0 = Parts::new(ctx.device.P0);
+        let scl = p0.p0_14.into_floating_input().degrade();
+        let sda = p0.p0_16.into_floating_input().degrade();
+
+        let twis = Twis::new(ctx.device.TWIS0, Pins { scl, sda }, 0x1A);
+        twis.enable_interrupt(TwiEvent::Write)
+            .enable_interrupt(TwiEvent::Read)
+            .enable_interrupt(TwiEvent::Stopped)
+            .enable();
+
+        init::LateResources {
+            transfer: Some(TwisTransfer::Idle((BUF, twis))),
+        }
+    }
+
+    #[task(binds = SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0, resources = [transfer])]
+    fn on_twis(ctx: on_twis::Context) {
+        let (buf, twis) = match ctx.resources.transfer.take().unwrap() {
+            TwisTransfer::Running(t) => t.wait(),
+            TwisTransfer::Idle(t) => t,
+        };
+        if twis.is_event_triggered(TwiEvent::Read) {
+            twis.reset_event(TwiEvent::Read);
+            rprintln!("READ command received");
+            *ctx.resources.transfer = Some(TwisTransfer::Running(twis.tx(buf).unwrap()));
+        } else if twis.is_event_triggered(TwiEvent::Write) {
+            twis.reset_event(TwiEvent::Write);
+            rprintln!("WRITE command received");
+            *ctx.resources.transfer = Some(TwisTransfer::Running(twis.rx(buf).unwrap()));
+        } else {
+            twis.reset_event(TwiEvent::Stopped);
+            rprintln!("{:?}", buf);
+            *ctx.resources.transfer = Some(TwisTransfer::Idle((buf, twis)));
+        }
+    }
+};
+
+#[inline(never)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    cortex_m::interrupt::disable();
+    rprintln!("{}", info);
+    loop {
+        compiler_fence(Ordering::SeqCst);
+    }
+}