Rewrote library to fix several issues

Author: lord-ne

.gitignore

@@ -1,3 +1,4 @@
 /target/
 **/*.rs.bk
+/.vscode
 Cargo.lock

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "avr_delay"
-version = "0.3.2"
+version = "1.0.0"
 authors = ["John Jorgensen <[email protected]>"]
 edition = "2018"
 
@@ -11,7 +11,7 @@ license = "MIT/Apache-2.0"
 categories = ["embedded", "no-std", "hardware-support"]
 
 [dependencies]
-avr-config = { version = "2.0", features = ["cpu-frequency"] }
+avr-config = { version = "2.0.1", features = ["cpu-frequency"] }
 
 [dev-dependencies]
-avr-std-stub = "1.0" # for examples
+avr-std-stub = "1.0.3" # for examples

src/lib.rs

@@ -10,7 +10,7 @@
 /// hardware timer.
 
 // This library does all of the busy-wait loop in rust.
-// We pack as much of the looping as possible into asm!
+// We pack as much of the looping as possible into llvm_asm!
 // so that we can count cycles.
 //
 // Ignoring the overhead, which may be significant:
@@ -21,56 +21,68 @@
 // initially, and then 11 cycles per outer loop. We ignore
 // all that.
 
-/// Internal function to implement a variable busy-wait loop.
+///delay for N milliseconds
 /// # Arguments
-/// * 'count' - an i32, the number of times to cycle the loop.
-pub fn delay(count: u32) {
-    // Our asm busy-wait takes a 16 bit word as an argument,
-    // so the max number of loops is 2^16
-    let outer_count = count / 65536;
-    let last_count = ((count % 65536)+1) as u16;
-    for _ in 0..outer_count {
-        // Each loop through should be 4 cycles.
-        unsafe {llvm_asm!("1: sbiw $0,1
-                      brne 1b"
-                     :
-                     : "w" (0)
-                     :
-                     :)}
-    }
-    unsafe {llvm_asm!("1: sbiw $0,1
-                      brne 1b"
-                 :
-                 : "w" (last_count)
-                 :
-                 :)}
-}
-
-///delay for N miliseconds
-/// # Arguments
-/// * 'ms' - an u32, number of milliseconds to busy-wait
+/// * 'ms' - a u32, number of milliseconds to busy-wait
+#[inline(always)]
 pub fn delay_ms(ms: u32) {
-    // microseconds
-    let us = ms * 1000;
-    delay_us(us);
+    let ticks: u64 = (u64::from(avr_config::CPU_FREQUENCY_HZ) * u64::from(ms)) / 4_000;
+    internal_delay_functions::delay(ticks);
 }
 
 ///delay for N microseconds
 /// # Arguments
-/// * 'ms' - an u32, number of microseconds to busy-wait
+/// * 'ms' - a u32, number of microseconds to busy-wait
+#[inline(always)]
 pub fn delay_us(us: u32) {
-    // picoseconds
-    let ps = us * 1000;
-    let ps_lp = 1000000000 / (avr_config::CPU_FREQUENCY_HZ / 4);
-    let loops = (ps / ps_lp) as u32;
-    delay(loops);
+    let ticks: u64 = (u64::from(avr_config::CPU_FREQUENCY_HZ) * u64::from(us)) / 4_000_000;
+    internal_delay_functions::delay(ticks);
 }
 
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        assert_eq!(2 + 2, 4);
+/// Functions used internally for our busy-wait loop.
+///
+/// These are not primarily intended to be used in user code, but are left public for
+/// use in making longer or more precise delays.
+pub mod internal_delay_functions {
+    /// Internal function to implement a variable busy-wait loop. 
+    /// Delays for up up to 2^48 iterations, not including setup overhead.
+    /// # Arguments
+    /// * 'count' - a u64, the number of times to iterate the loop.
+    /// The top 16 bits of count are ignored.
+    /// 
+    #[inline(always)]
+    pub fn delay(count: u64) {
+        // Casting truncates, so this is equivalent to `(count & 0xFFFF) as u16`
+        let remaining_count: u16 = count as u16;
+        // if remaining_count is zero, calling delay_loop_4_cycles would delay for 2^16 cycles,
+        // so we don't loop in this case
+        if remaining_count != 0 {
+            delay_loop_4_cycles(remaining_count);
+        }
+        // Casting truncates, so this is equivalent to `((count >> 16) & 0xFFFF_FFFF) as u32`
+        let outer_count: u32 = (count >> 16) as u32;
+        for _ in 0..outer_count {
+            // Each loop through should be 4 cycles, so we're getting 262,144 cycles per outer loop.
+            delay_loop_4_cycles(0);
+        }
+    }
+    
+    /// Internal function to implement a 16-bit busy-wait loop in assembly.
+    /// Delays for 4 cycles per iteration, not including setup overhead.
+    /// Up to 2^16 iterations (the value 2^16 would have to be passed as 0).
+    /// # Arguments
+    /// * 'count' - a u16, the number of times to cycle the loop.
+    #[inline(always)]
+    #[allow(unused_assignments)]
+    fn delay_loop_4_cycles(mut count: u16) {
+        unsafe {
+            llvm_asm!(
+                "1: sbiw $0,1\n\tbrne 1b"
+                : "=w" (count)
+                : "0" (count)
+                :
+                : "volatile"
+            );
+        }
     }
 }
-