v0.5 with timer-based delay

Author: nerdralph

README.md

@@ -1,6 +1,6 @@
 # ArduinoShrink
-This library replaces Arduino AVR Core functions with smaller and faster versions.  
-For example, the Blink example sketch built for the Uno takes 924 bytes of flash, but only needs 196 bytes with ArduinoShrink.
+This library replaces Arduino AVR Core functions with smaller and faster versions, with the same functionality. 
+For example, the Blink example sketch built for the Uno takes 924 bytes of flash, but only needs 286 bytes with ArduinoShrink.
 
 ## Usage
 Download [a release](https://github.com/nerdralph/ArduinoShrink/releases), and extract the files into your Arduino/libraries folder.  Select ArduinoShrink from the Sketch, Include Library menu.  This will replace several Arduino functions with smaller and faster versions.  The Arduino pin number must be known at compile time if you are using this library.

src/ArduinoShrink.h

@@ -12,9 +12,18 @@ inline void delayMicroseconds(unsigned int us)
     _delay_us(us);
 }
 
+// move millis to millis.c - LTO can inline
+// millis_raw is slow by 2.4% (1000/1024), so multiply by 1.024
+// shift and add instead of multiply: 1 6/256 = 1.0234375
+// ifdef RAW_MILLIS - else precise millis
 extern "C" uint32_t millis_raw();
 inline uint32_t millis()
 {
     uint32_t m = millis_raw();
-    return m + ((m * 1573) >> 16);
+    // return m;
+    // high-precision millis correction =~ 32 extra bytes
+    // 1 + 1573/2^16 = 1.0240
+    // return m + ((m * 1573) >> 16);
+    return m + m>>6 + m>>7;
 }
+

src/delay.S

@@ -0,0 +1,47 @@
+; (c) Ralph Doncaster 2020
+; ArduinoShrink
+
+; all used io registers are < 0x3F
+#define __SFR_OFFSET 0
+#include <avr/io.h>
+#include "macros.inc"
+
+;struct {
+;    uint32_t t0_ovfl;
+;    uint8_t ovfl_pad;
+;} t0_millis;
+
+
+; to force t0_isr to get linked in
+.global t0_ovfl_isr
+
+; read lower 16 bits of extended TCNT0 into r19:r18
+r18_t0cnt:
+    in r18, TCNT0
+    lds r19, t0_millis
+    in r0, TCNT0
+    sub r0, r18                         ; TCNT0 overflow?
+    brcs r18_t0cnt
+ret
+
+; delay for r27:r24 (ulong) ms
+GLABEL delay_impl
+    rcall r18_t0cnt
+    movw r20, r18                       ; r20 = start count
+    rjmp decms
+dloop:
+    rcall r18_t0cnt
+    sub r18, r20                        ; current - start
+    sbc r19, r21
+    subi r18, lo8(T0CNT_PER_MS)         ; > 1ms?
+    sbci r19, hi8(T0CNT_PER_MS)
+    brcc dloop
+    subi r20, lo8(-(T0CNT_PER_MS))        ; add 1ms to start
+    sbci r21, hi8(-(T0CNT_PER_MS))
+decms:                                  ; decrement ms argument
+    sbiw r24, 1
+    sbci r26, 0
+    sbci r27, 0
+    brcc dloop
+    ret
+

src/millis.c

@@ -12,10 +12,20 @@ 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" : "=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;
 }
 
+// avr-libc math.h does not declare gcc log2 builtin
+double log2(double);
+
 // portability macros for mega8
 #ifndef TCCR0B
 #define TCCR0B TCCR0
@@ -25,6 +35,9 @@ uint32_t micros()
 __attribute(( section(".init8"), used, naked))
 void init_millis()
 {
+    // scaling factor for t0 vs 16Mhz
+    uint8_t t0_scale = log2(16000000/F_CPU);
+    asm ( ".equ T0_SCALE, %0\n" :: "M" (t0_scale) );
     TCCR0B = _BV(CS01) | _BV(CS00);     // div64 prescaler
     TIMSK0 = _BV(TOIE0);                // enable overflow interrupt
 }

src/wiring.c

@@ -4,28 +4,19 @@
 #include <Arduino.h>
 #include <util/delay.h>
 
-/*
-__attribute ((noinline))
-void delay(unsigned long ms)
+// lightweight custom function call abi
+extern void delay_impl();
+void delay(uint32_t msec)
 {
-    do {
-        _delay_us(999);                 // leave 1us for loop overhead
-    } while (--ms);
-}
-*/
-
-void delay(unsigned long ms)
-{
-    // lower 16-bits of micros is enough considering wraparound
-    uint16_t start = micros();
-
-    while (ms > 0) {
-        yield();
-        while (ms > 0 && ((uint16_t)micros() - start) >= 1000) {
-            ms --;
-            start += 1000;
-        }
-    }
+    register uint32_t ms asm ("r24") = msec;
+    asm volatile (
+        ".global T0CNT_PER_MS\n"
+        ".equ T0CNT_PER_MS, 250\n"
+        "rcall %x1\n" 
+        : "+r"(ms)
+        : "i"(delay_impl)
+        : "r18", "r19", "r20", "r21"
+    );
 }
 
 // avr-libc math.h does not declare gcc log2 builtin
@@ -39,3 +30,4 @@ void init()
     uint8_t prescaler = log2(F_CPU/500000);
     ADCSRA = prescaler | (1 << ADEN);
 }
+

src/wiring_digital.c

@@ -26,6 +26,7 @@ inline ioreg_p pin_to_pinreg(uint8_t pin)
 inline uint8_t pin_to_bit(uint8_t pin)
 {
     return digital_pin_to_bit_mask_PGM[pin];
+    //return ((const __flash uint8_t*) digital_pin_to_bit_mask_PGM)[pin];
 }
 
 void pinMode(uint8_t pin, uint8_t mode)