martin/aqhomecontrol
Public Access
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

avr: reworked timer code.

Browse Source 
Allow for more tailored timers.
This commit is contained in:
Martin Preuss
2023-04-10 01:00:58 +02:00
parent f49a3ad4e6
commit dc8fa1a840
3 changed files with 179 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
avr/att84_temp1.asm
View File

@@ -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:
;

303
avr/timer.asm
View File

@@ -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
lds r24, timerTicksSinceLastRun
lds r25, timerTicksSinceLastRun+1
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
sts timerTicksSinceLastRun, r16
sts timerTicksSinceLastRun+1, r16
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
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
timerIncrementCounters_counterSmaller:
st X, r16
timerIncrementCounters_done:
mov r16, r18
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
; ---------------------------------------------------------------------------
; Call first N handlers from the timer table.
;
; IN:
; - R16: number of handlers to call (returned by timerIncrementCounters)
; OUT:
; - nothing
; REGS: depening on handler called (expect all registers to be clobbered)
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
timerCallFirstOnEveryHandlers:
push r16
rcall onEvery100ms ; always call this one
rcall onEverySecond ; and this
pop r16
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 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
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 timerCallR21R20
rcall timerCallR19R18
pop zh
pop zl
pop r16
dec r16
brne timerCallFirstOnEveryHandlers_loop
timerCallFirstOnEveryHandlers_done:
rjmp timerRunTimers_loop
timerRunTimers_end:
ret
timerCallR21R20:
push r20
push r21
; ---------------------------------------------------------------------------
; read time table entry.
;
; IN:
; - Z : pointer to time list entry (suitable for LPM)
; OUT:
; - 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
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

2
avr/utils.asm
View File

@@ -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