Reworked timers.

micros now returns sensible (16bit) values over a wide range of CPU frequencies.

Author: larsimmisch

Makefile

@@ -1,5 +1,7 @@
+include Makefile.local
+
 OPTIMIZE = -O3
-DEFS = -I /usr/local/avr/avr/include -DF_CPU=16000000
+DEFS = -I /usr/local/avr/avr/include -DF_CPU=$(CPU_FREQUENCY)
 LIBS = -B /usr/local/avr/avr/lib
 CC = avr-gcc
 CXX = avr-g++
@@ -11,8 +13,6 @@ CFLAGS = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS)
 CXXFLAGS = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS)
 LDFLAGS = -Wl,-Map,$@.map $(LIBS)
 
-include Makefile.local
-
 all: avr-ports.h .depend blink.bin blink.lst blink2.bin blink2.lst \
      test_enc28j60.bin test_enc28j60.lst onewire_test.bin onewire_test.lst \
      test_ip.bin test_ip.lst test_serial.bin test_serial.lst test_rf12.bin \
@@ -40,7 +40,7 @@ all: avr-ports.h .depend blink.bin blink.lst blink2.bin blink2.lst \
 	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<
 
 avr-ports.h: get-ports.lst extract-ports.pl
-	./extract-ports.pl < get-ports.lst > avr-ports.h
+	./extract-ports.pl -f $(CPU_FREQUENCY) < get-ports.lst > avr-ports.h
 
 clean:
 	rm -f *.o *.map *.lst *.elf *.bin avr-ports.h .depend

Makefile.ben

@@ -1 +1,3 @@
+CPU_FREQUENCY = 16000000
 MCU_TARGET = atmega328p
+

arduino++.h

@@ -111,15 +111,10 @@ class Pin
     typedef Pin::B5 SPI_SCK;
     };
 
-/** Don't use this directly, use Arduino16 or Arduino32 instead
- */
-template<typename timeres_t>
-class _Arduino
+class Arduino
     {
 public:
 
-    typedef timeres_t time_res_t;
-
     // The analog pins in Arduino numbering
     typedef Pin::C0 A0;
     typedef Pin::C1 A1;
@@ -224,7 +219,16 @@ class _Arduino
         UCSR0B = 0;
 #endif
         }
-    
+    };
+
+/** Don't use this directly, use Timer16 or Timer32 instead
+ */
+template<typename timeres_t>
+class _Timer
+    {
+public:
+    typedef timeres_t time_res_t;
+
     static timeres_t millis()
         {
         const uint8_t oldSREG = SREG;
@@ -238,27 +242,28 @@ class _Arduino
         return m;
         }
 
-    static timeres_t micros()
+    static uint16_t micros()
         {
-        timeres_t m;
-        uint16_t t;
-        uint8_t oldSREG = SREG;
+        uint8_t m;
+        uint8_t t;
+        const uint8_t oldSREG = SREG;
 
         cli();
         t = TCNT0;
+
+        m = timer0_overflow_count % (1 << TIMER16_MICRO_SCALE);
 
 #ifdef TIFR0
         if ((TIFR0 & _BV(TOV0)) && (t == 0))
-            t = 256;
+            m++;
 #else
         if ((TIFR & _BV(TOV0)) && (t == 0))
-            t = 256;
+            m++;
 #endif
 
-        m = timer0_overflow_count;
         SREG = oldSREG;
 
-        return ((m << 8) + t) * 64 / (F_CPU / 1000000L);
+        return ((m << 8) + t) * (64 / (F_CPU / 1000000L));
         }
 
     static void delay(timeres_t ms)
@@ -274,41 +279,9 @@ class _Arduino
     volatile static timeres_t timer0_millis;
     };
 
-template<typename T> volatile T _Arduino<T>::timer0_overflow_count = 0;
-template<typename T> volatile T _Arduino<T>::timer0_clock_cycles = 0;
-template<typename T> volatile T _Arduino<T>::timer0_millis = 0;
-
-/** This is an Arduino with 16bit timer resolution.
-    
-    The value from Arduino16::millis() will wrap around after about 65 seconds
-    and the value from Arduino16::micros() will wrap around after about 65 ms.
-
-    When you use Arduino16, you must #include "arduino++timer16.h", or 
-    Arduino16::millis() will always return 0.
-
-    The recommended way to use a timer value in user code is:
-
-    typename Arduino16::time_res_t now = Arduino16::millis();
-
-    Motivation: With Arduino16 instead of Arduino32, Lars has seen a code size 
-    reduction of 238 bytes with avr-gcc 4.6.1.
- */
-typedef _Arduino<uint16_t> Arduino16;
-
-/** This is an Arduino with 32bit timer resolution.
-    
-    When you use Arduino32, you must #include "arduino++timer32.h", or 
-    Arduino32::millis() will always return 0.
-
-    The recommended way to use a timer value in user code is:
-
-    typename Arduino32::time_res_t now = Arduino32::millis();
-
-    The value from Arduino32::millis() will wrap around after about 49 days
-    and the value from Arduino32::micros() will wrap around after about 
-    71 minutes.
- */
-typedef _Arduino<uint32_t> Arduino32;
+template<typename T> volatile T _Timer<T>::timer0_overflow_count = 0;
+template<typename T> volatile T _Timer<T>::timer0_clock_cycles = 0;
+template<typename T> volatile T _Timer<T>::timer0_millis = 0;
 
 void delayMicroseconds(unsigned int us)
     {

arduino++timer16.h

@@ -11,12 +11,12 @@
 int main(void)
     {
     // Arduino Pin D13 is an output
-    Arduino16::D13::modeOutput();
+    Arduino::D13::modeOutput();
 
     while(true)
         {
         // toggle the pin
-        Arduino16::D13::toggle();
+        Arduino::D13::toggle();
         // wait
         _delay_ms(2000);
         }

blink.cc

@@ -2,10 +2,10 @@
 
 int main(void)
     {
-    Arduino16::D13::modeOutput();
+    Arduino::D13::modeOutput();
     while(true)
         {
-	Arduino16::D13::toggle();
+	Arduino::D13::toggle();
         _delay_ms(200);
         }
     return 0;

blink2.cc

@@ -3,9 +3,19 @@
 use strict;
 
 use Carp;
+use Getopt::Long;
+use POSIX;
+
+my $f_cpu;
+GetOptions ("frequency=f" => \$f_cpu);
 
 print "// Generated by $0\n\n";
 
+# 64 is the timer0 prescale value. We could make that also configurable
+# 16 is the bit width of uint16_t
+my $scale16 = 16 - ceil(log(64.0 / ($f_cpu / 1000000) * 2 ** 8)/log(2));
+print "#define TIMER16_MICRO_SCALE $scale16\n\n";
+
 while (my $line = <>) {
     chomp $line;
 

extract-ports.pl

@@ -3,7 +3,7 @@
 
 #include "arduino++.h"
 
-template<class Arduino_, class Pin, int debounce>
+template<class Timer_, class Pin, int debounce>
 class PushButton
     {
 public:
@@ -21,13 +21,13 @@ class PushButton
         // aktivate pullup
         Pin::set();
         previous_ = !Pin::read();
-        changed_ = Arduino_::millis();
+        changed_ = Timer_::millis();
         duration_ = 0;
         }
 
     event_type read()
         {
-        const typename Arduino_::time_res_t now = Arduino_::millis();
+        const typename Timer_::time_res_t now = Timer_::millis();
         // The button is active low
         const bool pressed = !Pin::read();
 
@@ -36,7 +36,7 @@ class PushButton
             {
             // reset the debouncing timer
             previous_ = pressed;
-            const typename Arduino_::time_res_t delta = now - changed_;
+            const typename Timer_::time_res_t delta = now - changed_;
             changed_ = now;
 
             if (delta > debounce) 
@@ -55,12 +55,12 @@ class PushButton
         }
 
     // duration is only valid after a keyup event
-    typename Arduino_::time_res_t duration() { return duration_; }
+    typename Timer_::time_res_t duration() { return duration_; }
 
 private:
     bool previous_;
-    typename Arduino_::time_res_t changed_;
-    typename Arduino_::time_res_t duration_;
+    typename Timer_::time_res_t changed_;
+    typename Timer_::time_res_t duration_;
 };
 
 #endif

pushbutton.h

@@ -0,0 +1,46 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+uint16_t micros(int freq, int overflow, uint8_t ticks)
+    {
+    return ((overflow << 8) + ticks) * (64 / freq);
+    }
+
+int main(int argc, char * argv[])
+    {
+    if (argc < 2)
+        {
+        printf("usage: ./test_micros freq(MHz) [overflow_count] [ticks]\n");
+        exit(2);
+        }
+
+    int freq = atoi(argv[1]);
+    uint8_t scale = sizeof(uint16_t) * 8 
+        - ceil(log(64.0 / freq * (1 << 8))/log(2.0));
+
+    printf("CPU freq: %d MHz, scale: %d, resolution: %d\n", freq, scale,
+      64/freq);
+    printf("maximum microsecond value: %u\n", 
+           micros(freq, (1 << scale) - 1, 255));
+    printf("maximum overflow count: %u\n", (1 << scale) - 1);
+
+    if (argc > 3)
+        {
+        uint16_t m = atoi(argv[2]);
+        uint16_t t = atoi(argv[3]);
+
+        if (t == 256)
+            ++m;
+        else if (t > 256)
+            {
+            printf("error: ticks may be at most 256");
+            exit(2);
+            }
+
+        m %= (1 << scale);
+
+        printf("micros: %u\n", micros(freq, m, t));
+        }
+    }

test_micros.c

@@ -1,23 +1,23 @@
 #include "arduino++.h"
-#include "arduino++timer16.h"
+#include "timer16.h"
 #include "pushbutton.h"
 
-PushButton<Arduino16, Arduino16::D11, 20> Button;
+PushButton<Timer16, Arduino::D11, 20> Button;
 
 int main(void) 
     {
-    Arduino16::init();
-    Arduino16::D13::modeOutput();
+    Arduino::init();
+    Arduino::D13::modeOutput();
 
     Button.init();
 
     for (;;)
         {
         if (Button.read() == Button.keyup)
             {
-            Arduino16::D13::set();
-            Arduino16::delay(Button.duration());
-            Arduino16::D13::clear();
+            Arduino::D13::set();
+            Timer16::delay(Button.duration());
+            Arduino::D13::clear();
             }
         }
     }