new millis-optimized timer interrupt

Author: nerdralph

src/ArduinoShrink.h

@@ -8,7 +8,7 @@ inline void delay(uint32_t msec)
 {
     register __uint24 ms asm ("r24") = msec;
     asm volatile (
-        "rcall %x1\n" 
+        "%~call %x1\n" 
         : "+r"(ms)
         : "i"(delay_impl)
         : "r19", "r20", "r21"           // clobbers

src/micros.S

@@ -5,25 +5,20 @@
 #define __SFR_OFFSET 0
 #include <avr/io.h>
 
-;struct {
-;    uint32_t t0_ovfl;
-;    uint8_t ovfl_pad;
-;} t0_millis;
-
-
 ; to force t0_isr to get linked in
 .global t0_ovfl_isr
 
 .global micros_raw
 micros_raw:
     ldi ZL, lo8(t0_millis)
     ldi ZH, hi8(t0_millis)
-1:
+  _reload:
     in r22, TCNT0
     ld r23, Z
     ldd r24, Z+1
     ldd r25, Z+2
     in r0, TCNT0
     sub r0, r22                         ; TCNT0 overflow?
-    brcs 1b
+    brcs _reload
 ret
+

src/millis.S

@@ -10,7 +10,7 @@
 GLABEL millis_impl
     ldi ZL, lo8(t0_millis)
     ldi ZH, hi8(t0_millis)
-_reload:
+  _reload:
     ld r22, Z
     ldd r23, Z+1
     ldd r24, Z+2

src/millis.c

@@ -5,28 +5,31 @@
 #include <avr/io.h>
 #include "as_common.h"
 
+#define CPU_MHZ (F_CPU / 1000000)
+
 extern uint32_t micros_raw();
 uint32_t micros()
 {
     register uint32_t u asm("r22");
-    //asm ("%~call %x1" : "=r" (u) : "i"(micros_raw) : "r30", "r31" );
-    //return u * 4;
-    asm (
-        "%~call %x1                 \n"
-        "ldi r30, lo8(T0_SCALE + 2) \n"
-        "rcall lsl4_r22_r30         \n"
-        : "=r" (u) : "i"(micros_raw) : "r30", "r31"
-    );
-    return u;
+    asm ("%~call %x1" : "=r" (u) : "i"(micros_raw) : "r30", "r31" );
+    // split into lower 8 & upper 24-bits
+    uint8_t t0 = u & 0xFF;
+    __uint24 u3 = u >> 8;
+
+    //return (u3 * 1000) + (t0 * (uint8_t)(T0_PRESCALE / CPU_MHZ));
+    // shift + add saves 24B vs * 1000, asm would be a bit smaller
+    return ( ((u3 << 7) - ((u3 << 1) + u3)) << 3 ) + 
+        (t0 * (uint8_t)(T0_PRESCALE / CPU_MHZ));
 }
 
 extern uint32_t millis_impl();
 uint32_t millis()
 {
+    register uint32_t m asm("r22");
+    asm ("%~call %x1" : "=r" (m) : "i"(millis_impl) : "r30", "r31" );
     return millis_impl();
 }
 
-#define CPU_MHZ (F_CPU / 1000000)
 #define MICROS_PER_T0_OVFL ((T0_PRESCALE * 256) / CPU_MHZ)
 #define MILLIS_INC (MICROS_PER_T0_OVFL / 1000)
 #define FRACT_INC ((MICROS_PER_T0_OVFL % 1000) >> 2)
@@ -40,9 +43,6 @@ void init_millis()
     asm ( ".global FRACT_INC\n");
     asm ( ".equ FRACT_INC, %0\n" :: "M" (FRACT_INC) );
 
-    // scaling factor for t0 vs 16Mhz
-    uint8_t t0_scale = log2(16000000/F_CPU);
-    asm ( ".equ T0_SCALE, %0\n" :: "M" (t0_scale) );
     TIMSK0 = _BV(TOIE0);                // enable T0 overflow interrupt
 }
 

src/t0_ovfl_isr.S

@@ -23,9 +23,10 @@ GLABEL t0_ovfl_isr
 
 ; this is an optimized asm version of the Arduino core timer overflow
 ; github.com/arduino/ArduinoCore-avr/blob/master/cores/arduino/wiring.c
-; 8 bits are used instead of 7 for better precision at non 2^n F_CPU
+; uses 8 bits of t0_fract instead of 7 for more precision at non 2^n F_CPU
 .equ FRACT_MAX, (1000 >> 2) 
 GLABEL TIMER0_OVF_vect
+    sei                                 ; allow other interrupts
     push r16
     in r16, SREG
     push r16
@@ -34,14 +35,28 @@ GLABEL TIMER0_OVF_vect
     push ZH
     ldi ZH, hi8(t0_fract)
     ld r16, Z
-    subi r16, lo8(-(FRACT_INC))         ; add millis fraction
-    cpi r16, FRACT_MAX                  ; C set when fract < FRACT_MAX
+    //subi r16, lo8(-(FRACT_INC))         ; add millis fraction
+    //cpi r16, FRACT_MAX                  ; C set when fract < FRACT_MAX
+    subi r16, lo8(FRACT_INC)            ; subtract millis fraction
+    brcc _no_underflow
+    subi r16, lo8(-FRACT_MAX)           ; add FRACT_MAX, clears Carry
+    rjmp 2f
+_no_underflow:
+    sec                                 ; invert Carry
+2:
     st Z+, r16
-_inc_millis:
+    ; add one more to millis LSB when fractional counter underflows
     ld r16, Z
-    sbci r16, lo8(-(MILLIS_INC +1))     ; r16 += MILLIS_INC + NOT Carry
+    sbci r16, lo8(-(MILLIS_INC + 1))     ; r16 += MILLIS_INC + NOT Carry
+    ;adc r16, r1                         ; r16 += Carry
+    ;sbci r16, lo8(-(MILLIS_INC))        ; r16 += MILLIS_INC
+    rjmp _save
+_add1:                                  ; handle most significant bytes
+    ld r16, Z
+    subi r16, -1                        ; add 1
+_save:
     st Z+, r16
-    brcc _inc_millis
+    brcc _add1
     pop ZH
     pop ZL
     pop r16