diff --git a/avr/att84_temp1.asm b/avr/att84_temp1.asm
index 1e1ac34..0c34587 100644
--- a/avr/att84_temp1.asm
+++ b/avr/att84_temp1.asm
@@ -243,6 +243,12 @@
 .dseg
 
 
+sramTimerProtocolEverySec: .byte 2
+sramTimerEnqueueSendStats: .byte 2
+sramTimerEnqueueMemStats:  .byte 2
+sramTimerEnqueueValues:    .byte 2
+sramTimerSI7021Measure:    .byte 2
+
 
 
 ; ***************************************************************************
@@ -256,6 +262,25 @@ blinkPattern:  .db 2, 50, 0xff, 0xff   ; 1 short blink, 2s pause, restart
 
 
 
+
+; ---------------------------------------------------------------------------
+; timer list
+
+
+; TODO: add flags (IF_COM_ADDR)
+timerList:
+;     SRAM variable/counter      routine                     flags                secs (0=don't start or restart)
+  .dw sramTimerProtocolEverySec, CPRO_OnEverySecond,         0,                   1     ; every 1s
+  .dw sramTimerEnqueueSendStats, enqueueSendStats,           TIMER_FLAGS_IF_ADDR, 300   ; every 5m
+  .dw sramTimerEnqueueMemStats,  enqueueMemStats,            TIMER_FLAGS_IF_ADDR, 120   ; every 2m
+  .dw sramTimerSI7021Measure,    SI7021_PeriodicMeasurement, 0,                   30    ; every 30s
+  .dw sramTimerEnqueueValues,    Main_SendValueMsg,          TIMER_FLAGS_IF_ADDR, 60    ; every 1m
+  .dw 0 ; end of list
+
+
+
+
+
 .include "main.asm"
 
 
@@ -265,6 +290,7 @@ blinkPattern:  .db 2, 50, 0xff, 0xff   ; 1 short blink, 2s pause, restart
 onSystemStart:
 
 #ifdef MODULES_COM
+  ; todo: setup once timer to start reclaiming address
   rcall CPRO_StartReclaimAddrProcedure
 #endif
 
@@ -272,6 +298,27 @@ onSystemStart:
 
 
 
+#ifdef MODULES_COM
+enqueueSendStats:
+    ldi r16, 0xff                     ; send stats to everybody
+    rcall CPRO_EnqueueComSendStats
+
+    ldi r16, 0xff                     ; send stats to everybody
+    rjmp CPRO_EnqueueComRecvStats
+#endif
+
+
+#ifdef MODULES_COM
+enqueueMemStats:
+    ldi r16, 0xff                     ; send to everybody
+    rcall CPRO_EnqueueMemStats
+#endif
+
+
+
+
+
+
 ; ---------------------------------------------------------------------------
 ; Called every 100ms. Add your routine calls here. No arguments, no results.
 
@@ -288,52 +335,6 @@ onEvery100ms:
 
 
 
-; ---------------------------------------------------------------------------
-; Called every second. Add your routine calls here. No arguments, no results.
-
-onEverySecond:
-;  rcall TWI_Master_ScanNext
-  rcall CPRO_OnEverySecond
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 5 seconds. Add your routine calls here.  No arguments, no results.
-
-onEvery5s:
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 10 seconds. Add your routine calls here.  No arguments, no results.
-
-onEvery10s:
-#ifdef MODULES_LCD
-  rcall printSendStats
-#endif
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 30 seconds. Add your routine calls here. No arguments, no results.
-
-onEvery30s:
-#ifdef MODULES_SI7021
-  in r15, SREG
-  push r15
-    cli
-    rcall SI7021_PeriodicMeasurement
-    rcall Main_SendValueMsg
-  pop r15
-  out SREG, r15
-#endif
-  ret
-
-
-
 ; ---------------------------------------------------------------------------
 ; Called every minute. Add your routine calls here. No arguments, no results.
 
@@ -352,64 +353,6 @@ onEvery1m_l1:
   ret
 
 
-; ---------------------------------------------------------------------------
-; Called every 5 minutes. Add your routine calls here. No arguments, no results.
-
-onEvery5m:
-
-#ifdef MODULES_COM
-    ; will later send these only every hour or so
-    ldi r16, 0xff                     ; send stats to everybody
-    rcall CPRO_EnqueueComSendStats
-
-    ldi r16, 0xff                     ; send recv to everybody
-    rcall CPRO_EnqueueComRecvStats
-#endif
-
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 15 minutes. Add your routine calls here. No arguments, no results.
-
-onEvery15m:
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 30 minutes. Add your routine calls here. No arguments, no results.
-
-onEvery30m:
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every hour. Add your routine calls here. No arguments, no results.
-
-onEvery1h:
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every 12 hours. Add your routine calls here. No arguments, no results.
-
-onEvery12h:
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Called every day. Add your routine calls here. No arguments, no results.
-
-onEvery1d:
-  ret
-
-
-
 ; ---------------------------------------------------------------------------
 ; onPacketReceived:
 ;
diff --git a/avr/timer.asm b/avr/timer.asm
index e1dbceb..aff3c65 100644
--- a/avr/timer.asm
+++ b/avr/timer.asm
@@ -14,9 +14,7 @@
 ; ***************************************************************************
 ; defs
 
-.equ TIMER_FLAGS_100MS       = 1
-.equ TIMER_FLAGS_1S          = 2
-
+.equ TIMER_FLAGS_IF_ADDR = 1
 
 
 
@@ -27,11 +25,9 @@
 
 timerModuleData:
 timerModuleTickCounter:      .byte 1
-timerModuleFlags:            .byte 1
+timerTicksSinceLastRun:      .byte 2
 timerModuleCounterSecs:      .byte 4
 
-timerModuleDerivedCounters:  .byte 10 ; size must be number of entries in timer table
-
 timerModuleData_end:
 
 
@@ -45,21 +41,6 @@ timerModuleData_end:
 TIMER_BEGIN:
 
 
-; number of entries here must be equal to bytes in timerModuleDerivedCounters!
-timerTable:
-  .db  5, 0, LOW(onEvery5s),  HIGH(onEvery5s)  ;  5s: overflow after 5*1s  (1)
-  .db  2, 0, LOW(onEvery10s), HIGH(onEvery10s) ; 10s: overflow after 2*5s  (2)
-  .db  3, 0, LOW(onEvery30s), HIGH(onEvery30s) ; 30s: overflow after 3*10s (3)
-  .db  2, 0, LOW(onEvery1m),  HIGH(onEvery1m)  ;  1m: overflow after 2*30s (4)
-  .db  5, 0, LOW(onEvery5m),  HIGH(onEvery5m)  ;  5m: overflow after 5*1m  (5)
-  .db  3, 0, LOW(onEvery15m), HIGH(onEvery15m) ; 15m: overflow after 3*5m  (6)
-  .db  2, 0, LOW(onEvery30m), HIGH(onEvery30m) ; 30m: overflow after 2*15m (7)
-  .db  2, 0, LOW(onEvery1h),  HIGH(onEvery1h)  ;  1h: overflow after 2*30m (8)
-  .db 12, 0, LOW(onEvery12h), HIGH(onEvery12h) ; 12h: overflow after 12*1h (9)
-  .db  2, 0, LOW(onEvery1d),  HIGH(onEvery1d)  ;  1d: overflow after 2*12h (10)
-  .db  0, 0
-
-
 
 ; ---------------------------------------------------------------------------
 ; Timer_Init
@@ -96,6 +77,8 @@ Timer_Init:            ; setup timer for IRQ every 100ms
   ldi r16, (1<<OCIE0A)
   out TIMSK0, r16
   
+  rcall timerInitTimers
+  
   ret
 
 
@@ -121,136 +104,140 @@ Timer_Fini:
 ; - nothing
 ; OUT:
 ; - CFLAG: set if something done, cleared otherwise
-; USED: r15, r16, r17, R19 (more depending on called routines)
+; USED: r15, r16, r24, r25 (more depending on called routines)
 
 Timer_Run:
   in r15, SREG
   cli
-  lds r17, timerModuleFlags       ; get timer flags
-  clr r16                         ; replace with 0 for next IRQ
-  sts timerModuleFlags, r16
-  mov r16, r17
-  andi r16, TIMER_FLAGS_100MS     ; timer irq occurred?
-  brne Timer_Run_100ms_passed     ; yes, go handle
-  out SREG, r15                   ; restore global IRQ flag
-  clc                             ; nothing done
-  ret
-Timer_Run_100ms_passed:
-  mov r16, r17
-  andi r16, TIMER_FLAGS_1S
-  brne Timer_Run_1s_passed
-  out SREG, r15                   ; restore global IRQ flag
-  rcall onEvery100ms              ; only call this one
-  sec
-  ret
-Timer_Run_1s_passed:
-  rcall timerIncrementCounters    ; 1s passed, handle cascading counters, get number of callable handlers
-  out SREG, r15                   ; restore global IRQ flag
-  rcall timerCallFirstOnEveryHandlers
-  sec
-  ret
-
-
-
-; ---------------------------------------------------------------------------
-; Increment cascading timer counters. Called once every second.
-;
-; This routine starts with the first cascaded counter and increments it.
-; If that counter value does not overflow (according to timer table entry) then
-; handling the timer table is stopped.
-; Otherwise the return value is incremented and the next counter entry is inspected
-; until the full table is handled.
-;
-; The result value has to be interpreted as the number of entries started at the first
-; which have overflowed.
-;
-; Example: A return value of 1 means that the first entry overflowed, meaning that 10s have
-; elapsed.
-; A return value of 2 means that the first entry overflowed (i.e. 10s elapsed) and also the nex
-; entry overflowed (i.e. also 30s elapsed).
-;
-; IN:
-; - nothing
-; OUT:
-; - R16: number of timer table entries which caused an overflow
-; REGS: R16, R17, R18, X, Z
-
-timerIncrementCounters:
-  ldi xl, LOW(timerModuleDerivedCounters)  ; points to first counter: timerModuleCounterFor10s
-  ldi xh, HIGH(timerModuleDerivedCounters)
-  ldi zl, LOW(timerTable*2)
-  ldi zh, HIGH(timerTable*2)
-  
-  clr r18
-  
-timerIncrementCounters_loop:
-    lpm r17, Z    ; overflow value
-    tst r17
-    breq timerIncrementCounters_done ; end of list
-    ld r16, X     ; get current counter value
+    lds r24, timerTicksSinceLastRun
+    lds r25, timerTicksSinceLastRun+1
+    clr r16                               ; replace with 0 for next IRQ
+    sts timerTicksSinceLastRun, r16
+    sts timerTicksSinceLastRun+1, r16
+  out SREG, r15                           ; restore global IRQ flag
+  sbiw r25:r24, 0
+  clc                                     ; flag "nothing done"
+  breq Timer_Run_End
+Timer_Run_loop:                           ; for every occurred 100ms irq
+    push r24
+      push r25
+        rcall onEvery100ms
+      pop r25
+    pop r24
+    lds r16, timerModuleTickCounter
     inc r16
-    cp r16, r17   ; compare against overflow value
-    brcs timerIncrementCounters_counterSmaller
-    clr r16       ; overflow occurred
-    st X+, r16
-    ; next
-    inc r18
-    adiw zh:zl, 4
-  rjmp timerIncrementCounters_loop
+    cpi r16, 10
+    brcc Timer_Run_SecondElapsed
+    sts timerModuleTickCounter, r16
+    rjmp Timer_Run_loop_end
+Timer_Run_SecondElapsed:
+    clr r16
+    sts timerModuleTickCounter, r16
+    push r24
+      push r25
+        rcall timerRunTimers
+      pop r25
+    pop r24
+Timer_Run_loop_end:
+    sbiw r25:r24, 1
+  brne Timer_Run_loop
+  sec
+Timer_Run_End:
+  ret
 
-timerIncrementCounters_counterSmaller:
-  st X, r16
-timerIncrementCounters_done:
-  mov r16, r18
+
+
+timerInitTimers:
+  ldi zl, LOW(timerList*2)
+  ldi zh, HIGH(timerList*2)
+  clr r16                      ; run var for pos in time table
+  clr r17                      ; 0 for adc
+timerInitTimers_loop:
+    rcall timerReadTableEntry
+    mov r18, xl
+    or r18, xh
+    breq timerInitTimers_end
+
+    add r20, r16               ; add counter pos in table so that not all timers elapse at the same time
+    adc r21, r17
+    st X+, r20
+    st X, r21
+    inc r16
+  rjmp timerInitTimers_loop
+
+timerInitTimers_end:
+  ret
+
+
+
+timerRunTimers:
+; TODO: incremenent uptime counter
+  ldi xl, LOW(timerModuleCounterSecs)
+  ldi xh, HIGH(timerModuleCounterSecs)
+  rcall Utils_IncrementCounter32
+  ldi zl, LOW(timerList*2)
+  ldi zh, HIGH(timerList*2)
+timerRunTimers_loop:
+    rcall timerReadTableEntry
+    mov r16, xl
+    or r16, xh
+    breq timerRunTimers_end
+    mov r16, r22
+    andi r16, TIMER_FLAGS_IF_ADDR
+    breq timerRunTimers_l1         ; no need to check address
+    lds r16, comAddress            ; check address
+    tst r16
+    breq timerRunTimers_loop       ; no address, ignore counter
+timerRunTimers_l1:
+    ld r24, X+
+    ld r25, X
+    sbiw r25:r24, 1
+    brcs timerRunTimers_loop        ; overflow, so already was zero, ignore entry
+    breq timerRunTimers_reachedZero ; reached zero
+    st X, r25                  
+    st -X, r24
+  rjmp timerRunTimers_loop
+timerRunTimers_reachedZero:
+    st X, r21                       ; reset initial value
+    st -X, r20
+    push zl
+      push zh
+        rcall timerCallR19R18
+      pop zh
+    pop zl
+  rjmp timerRunTimers_loop
+timerRunTimers_end:
   ret
 
 
 
 ; ---------------------------------------------------------------------------
-; Call first N handlers from the timer table.
+; read time table entry.
 ;
 ; IN:
-; - R16: number of handlers to call (returned by timerIncrementCounters)
+; - Z      : pointer to time list entry (suitable for LPM)
 ; OUT:
-; - nothing
-; REGS: depening on handler called (expect all registers to be clobbered)
-
-timerCallFirstOnEveryHandlers:
-  push r16
-    rcall onEvery100ms                       ; always call this one
-    rcall onEverySecond                      ; and this
-  pop r16
-
-  tst r16
-  breq timerCallFirstOnEveryHandlers_done
-  
-  ldi zl, LOW(timerTable*2)
-  ldi zh, HIGH(timerTable*2)
-
-timerCallFirstOnEveryHandlers_loop:
-    lpm r17, Z                               ; overflow value
-    tst r17                                  ; 0?
-    breq timerCallFirstOnEveryHandlers_done  ; yes: end of list
-    adiw zh:zl, 2                            ; skip to handler address
-    lpm r20, Z+                              ; read handler address
-    lpm r21, Z+
-    push r16                                 ; call handler
-      push zl
-        push zh
-          rcall timerCallR21R20
-        pop zh
-      pop zl
-    pop r16
-    dec r16
-  brne timerCallFirstOnEveryHandlers_loop
-
-timerCallFirstOnEveryHandlers_done:
+; - r19:r18: handler routine
+; - X      : SRAM address for counter
+; - r21:r20: initial value
+; - r22    : flags
+; - r23    : reserved
+timerReadTableEntry:
+  lpm xl, Z+    ; SRAM address of counter
+  lpm xh, Z+
+  lpm r18, Z+   ; routine (low)
+  lpm r19, Z+   ; routine (high)
+  lpm r22, Z+   ; flags
+  lpm r23, Z+   ; reserved
+  lpm r20, Z+   ; initial value
+  lpm r21, Z+
   ret
 
 
-timerCallR21R20:
-  push r20
-  push r21
+
+timerCallR19R18:
+  push r18
+  push r19
   ret
 
 
@@ -258,56 +245,22 @@ timerCallR21R20:
 ; ---------------------------------------------------------------------------
 ; OC0A interrupt handler
 ;
-; Called every 100 milliseconds, sets flag TIMER_FLAGS_100MS.
-; Increments an internal counter. If that counter reaches 10 the seconds counter is incremented and a the flag
-; TIMER_FLAGS_1S is set.
+; Called every 100 milliseconds, increments timerTicksSinceLastRun. The rest is done outside ISR
+; in Timer_Run.
 
 timerIrqOC0A:
   push r15
     in r15, SREG
 
-    push r16
-      push r17
-        lds r17, timerModuleFlags
-        ori r17, TIMER_FLAGS_100MS
-        lds r16, timerModuleTickCounter
-        inc r16
-        cpi r16, 10
-        brcc timerIrq2_l1
-        sts timerModuleTickCounter, r16
-        rjmp timerIrq2_l2
-timerIrq2_l1: ; increment seconds
-        ; reset 100ms counter
-        clr r16
-        sts timerModuleTickCounter, r16
-        ; increment seconds
-        push xh
-          push xl
-            push r18
-              ldi xh, HIGH(timerModuleCounterSecs)
-              ldi xl, LOW(timerModuleCounterSecs)
-              ldi r18, 1
-              ld r16, X         ; byte 0
-              adc r16, r18      ; inc by 1
-              dec r18           ; doesn't affect carry flag! (r18 becomes 0 for following ADC)
-              st X+, r16
-              ld r16, X         ; byte 1
-              adc r16, r18
-              st X+, r16
-              ld r16, X         ; byte 2
-              adc r16, r18
-              st X+, r16
-              ld r16, X         ; byte 3
-              adc r16, r18
-              st X+, r16
-            pop r18
-          pop xl
-        pop xh
-        ori r17, TIMER_FLAGS_1S
-timerIrq2_l2:
-        sts timerModuleFlags, r17 ; store new timer flags
-      pop r17
-    pop r16
+    push r24
+      push r25
+        lds r24, timerTicksSinceLastRun
+        lds r25, timerTicksSinceLastRun+1
+        adiw r25:r24, 1
+        sts timerTicksSinceLastRun, r24
+        sts timerTicksSinceLastRun+1, r25
+      pop r25
+    pop r24
     out SREG, r15
   pop r15
   reti
diff --git a/avr/utils.asm b/avr/utils.asm
index 9bb1df8..ab0ba52 100644
--- a/avr/utils.asm
+++ b/avr/utils.asm
@@ -254,7 +254,6 @@ Utils_FillSram_end:
 
 
 
-#if 0
 ; ---------------------------------------------------------------------------
 ; Increment a 32 bit counter at the address given by X.
 ; IN:
@@ -279,7 +278,6 @@ Utils_IncrementCounter32:
   st -x, r19
   st -x, r18
   ret
-#endif