1ms Elapsed Timer Demo with DT's Instant Interrupts

[Tabsoft]

Art,

Tying to respond to your PM, but your inbox is full....

[Art]

This is about an issue of my own. There would be different ways to implement in a program.
It probably should have been commented like this:

; -----------------  ADD TimerConst to TMR1H:TMR1L -------------------------
ADD2_TIMER   macro
     BCF     T1CON,TMR1ON, 0       ;  1 Turn off timer
     MOVLW   LOW(TimerConst)       ;  1
     ADDWF   TMR1L,F, 0            ;  1    
     BTFSC   STATUS,C              ;  1 if carry set / 2 if carry clear
     INCF    TMR1H,F, 0            ;  1 if carry set /0 if carry clear
     MOVLW   HIGH(TimerConst)      ;  1
     ADDWF   TMR1H,F, 0            ;  1
     endm

‘ always up to seven instructions here since stopping the timer
‘ one more instruction will be used to turn on the timer in the
‘ code that called this, and there’s the eight instructions

I need to reset the timer (not add to it) if the ISR was triggered by port interrupt,
It looks like I’ll need another conditional and more instructions to check if it was portb.0 interrupt,
copy the constant values to the timer rather than add to it if it was called due to portb.0 interrupt,
and then also change the constant value to accomodate the extra instructions.

Because currently if the code was not called due to timer overflow, it is unknown what is in the timer.
It could be called by port.0 interrupt when a 0xFFFB value is in the timer for all I know.

My question if this is all because the whole DT interrupt set that can be enabled for multiple interrupts
to allow those interrupts be serviced first like I suggested above.

[Tabsoft]

Art,

First of all, let me say that I "assume" you are using DT's Instant Interrupts in the context of this question.

That being said, I am highly confident that DT "Adds" the Timer1 Preload constant (TimerConst) to the value of the Timer1 Counter
to account for the instructions executed in his Instant Interrupts Processor.
DT's Instant Interrupt Processor handles many things, including as you state multiple interrupts, but it also checks for and handles
Register Context saving for you. All of this takes instruction cycles to perform, ~91 instructions.

Also, the PIC MCU's Timer Interrupt is not instantaneous.
There is Interrupt Latency to contend with as well, which a good explanation can be found here in Microchip's Tech Bulletin TB3100.
http://ww1.microchip.com/downloads/c...s/cn566554.pdf

While Timer1 is enabled, the Timer1 Counter increments for each instruction cycle even after an overflow of the counter occurs.
This is a good thing and is exploited by DT to keep track of all of the processing I mentioned above until the Instant Interrupt Processor vectors to the ISR and the "ADD2_TIMER" macro is called and the "BCF T1CON,TMR1ON" statement is executed which turns off Timer1.

By "adding" the TimerConst to the value of Timer1's Counter, the time-based interrupt period is maintained as consistently as possible.

Hopefully this helps.

Secondly, if you are using DT's Instant Interrupts, why wouldn't you use a different label to vector to, for the PORTB.0 Interrupt on Change?
Is there a reason you would put it all in a single ISR handler?
Instant Interrupts should allow you to define multiple sources each with its own Label to jump to when the interrupt occurs.

Just curious.

[Art]

Ok thanks for confirming, I figured as much.
Dt’s original timer, or a bastardised version of it, because I know for the project it will always be clocked at 10 MHz,
and I also know I will only ever be interested in 100 Hz interrupt form the timer. The portb.0 interrupt is simpler, and I’ve done that manually.

To answer your other question.. It’s still about synchronising the timer to a GPS PPS pulse, but I want to go better than simply resetting Ticks,
and load the timer correctly for that situation as well... So when the program decides to sync, it enables portb.0 int, resets the flag for portb.0 int,
and then the next rising edge interrupt should call the same timer where it is loaded and then the portb.0 interrupt turned straight back off
unless the program decides to do the sync again at some later time.

Dealing with the timer ISR.. it seems I could save myself some instruction counting, and deal with the timer value the same way the reload code does
by just making sure the next Tick will occur correct time, rather than dealing with the current portb.0 int Tick that called the ISR.

This is my first play.. not sure about it and haven’t thought about it too much.. it’s my first play in a compiler since I started talking to you.
I disable ext int just a little later when the time values are being incremented and timing isn’t as critical.
For this version the constant needs another 6 added to it.

For most of the time ext int is disabled it’s supposed to act as it normally would, but take a little longer to execute.

; -----------------  ADD TimerConst to TMR1H:TMR1L
ADD2_TIMER   macro
    CHK?RP  T1CON

     BCF     T1CON,TMR1ON       ; 1 Turn off timer
     MOVLW   LOW(TimerConst)    ; 1

     BTFSC   INTCON,INTE	; 1/2
     MOVWF   TMR1L		; 1/0

     BTFSS   INTCON,INTE	; 1/2
     ADDWF   TMR1L,F            ; 1/0

     BTFSC   STATUS,C           ; 1/2
     INCF    TMR1H,F            ; 1/0
     MOVLW   HIGH(TimerConst)   ; 1

     BTFSC   INTCON,INTE	; 1/2
     MOVWF   TMR1H    		; 1/0

     BTFSS   INTCON,INTE	; 1/2
     ADDWF   TMR1H,F            ; 1/0

     endm

[Tabsoft]

Two initial questions.

1. Are you using DT's Instant Interrupts to handle the Timer1 Interrupt?
2. Is the code snippet below used for both interrupt instances you mentioned?
A. Timer1 100Hz Interrupt
B. PORTB.0 Interrupt to re-synch

[Art]

1.. Yes.
There is a little more in the main program to handle the ext interrupt, but essentially yes (for question 2).

The main program turns external int off and clears it’s trigger flag as well at initialise time.
Then when the sync wants to happen for whatever reason (like the GPS has been locked for a minute),
the main program turns ext int on. Then I figure the next time the ISR is called by ext interrupt,
the timer should be loaded rather than added to... but added to every other time, because
the ISR turns ext int off just a little after this.

ps.. So far the time is still correct, but I can’t test lag or error of the sync to the pulse.

[Art]

It just occurred to me I’d have to comment out anything instant interrupts does with other interrupts
just in case activity on portb.0 changes the time that takes to execute (prior to the timer reload routine being called),
and also add it's instruction time in the value loaded to the timer if portb.0 was the source of the interrupt.