new millis ISR equivalent to Arduno

Author: nerdralph

src/t0_ovfl_isr.S

@@ -1,34 +1,51 @@
 ; (c) Ralph Doncaster 2020
 ; ArduinoShrink
 
+#define __SFR_OFFSET 0
 #include <avr/io.h>
 #include "macros.inc"
 
+; millis_pad keeps t0_millis overflow from corrupting memory
 ;struct {
-;    uint32_t t0_ovfl;
-;    uint8_t ovfl_pad;
+;    uint8_t t0_fract;
+;    uint32_t t0_millis;
+;    uint8_t millis_pad;
 ;} t0_millis;
+.lcomm t0_fract, 1
+.global t0_millis
+.lcomm t0_millis, 5                     ; t0_millis + pad
+
+; ensure BSS gets cleared
+.global __do_clear_bss
 
 ; to help with linking
 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
+.equ FRACT_MAX, (1000 >> 2) 
 GLABEL TIMER0_OVF_vect
     push r16
-    in r16, SREG-0x20
+    in r16, SREG
     push r16
     push ZL
-    ldi ZL, lo8(t0_millis)
+    ldi ZL, lo8(t0_fract)
     push ZH
-    ldi ZH, hi8(t0_millis)
-t0_ovfl_inc:
+    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
+    st Z+, r16
+_inc_millis:
     ld r16, Z
-    subi r16, -1
+    sbci r16, lo8(-(MILLIS_INC +1))     ; r16 += MILLIS_INC + NOT Carry
     st Z+, r16
-    brcc t0_ovfl_inc
+    brcc _inc_millis
     pop ZH
     pop ZL
     pop r16
-    out SREG-0x20, r16
+    out SREG, r16
     pop r16
 reti
 

src/wiring.c

@@ -3,33 +3,49 @@
 
 #include <Arduino.h>
 #include <util/delay.h>
+#include "as_common.h"
 
-// lightweight custom function call abi
-extern void delay_impl();
-void delay(uint32_t msec)
+// delays a specified number of microseconds - modified from picoCore
+// works for clock frequencies of 4Mhz and up
+void delayMicroseconds(uint16_t us)
 {
-    register uint32_t ms asm ("r24") = msec;
-    asm ( ".equ T0CNT_PER_MS, %0\n" 
-        ".global T0CNT_PER_MS\n"
-        // T0 prescaler is 64
-        :: "i" (F_CPU / 1000 / 64) );
-    asm volatile (
-        "rcall %x1\n" 
-        : "+r"(ms)
-        : "i"(delay_impl)
-        : "r18", "r19", "r20", "r21"
-    );
-}
+    // if us is a compile-time constant result is accurate to 1 cycle
+    if (__builtin_constant_p(us)) {
+        _delay_us(us);
+        return;
+    }
 
-// avr-libc math.h does not declare gcc log2 builtin
-double log2(double);
+    // code below runs when us is not known at compile time
+    // uses inline asm to guarantee exact cycle counts
+    const float fMHz = (F_CPU/1000000.0);
+    delay1us:
+        // delay 1us per loop, less 4 cycles for overhead
+        _delay_us(1.0 - (4.0 / fMHz));
+        asm volatile ("sbiw %[us], 1" : [us]"+d"(us));
+    asm goto( "brne %l[delay1us]" :::: delay1us);
+}
 
-void init()
+void init(void)
 {
-    asm("sei");
+    // T0CNT_PER_MS needed for delay_impl
+    asm ( ".equ T0CNT_PER_MS, %0\n" 
+        ".global T0CNT_PER_MS\n"
+        :: "i" (F_CPU / 1000 / T0_PRESCALE) );
 
     // setup ADC with 250-500kHz clock
     uint8_t prescaler = log2(F_CPU/500000);
     ADCSRA = prescaler | (1 << ADEN);
+
+    TCCR0B = _BV(CS01) | _BV(CS00);     // enable T0, div64 prescale
+
+    asm("sei");                         // enable interrupts
+}
+
+// replace main() from Arduino core
+int main(void)
+{
+    init();
+    setup();
+    while(1) loop();
 }