Temporary central repository of Darrel Taylor's works (including Mr E's Multicalc)

[Darrel Taylor]

The ultimate overkill Blinky Light program ... using Timer 1

LED1   VAR  PORTB.1

INCLUDE "DT_INTS-14.bas"     ' Base Interrupt System
INCLUDE "ReEnterPBP.bas"     ' Include if using PBP interrupts

ASM
INT_LIST  macro    ; IntSource,        Label,  Type, ResetFlag?
        INT_Handler   TMR1_INT,  _ToggleLED1,   PBP,  yes
    endm
    INT_CREATE               ; Creates the interrupt processor
ENDASM

T1CON = $31                ; Prescaler=8, TMR1ON
@ INT_ENABLE  TMR1_INT     ; enable Timer 1 interrupts

Main:
  PAUSE 1
GOTO Main

'---[TMR1 - interrupt handler]--------------------------------------------------
ToggleLED1:
     TOGGLE LED1
@ INT_RETURN

Code Size = 240 words

OK, Why? ... You might ask.
Well, for one, this Blinky Light program will continue Blinking at the same rate, no matter what else you add to the Main: program loop. Try doing that with pauses.

[Darrel Taylor]

The NEW Elapsed Timer does, ... well .. it does exactly the same thing as the old Elapsed Timer. But now it works with the Instant Interrupt system. Which means that you can use many other interrupts in the same program without much trouble at all. Unlike the last version.

Here's an example of just the Elapsed Timer by itself.

INCLUDE "DT_INTS-14.bas"
INCLUDE "ReEnterPBP.bas"
INCLUDE "Elapsed_INT.bas"  ; Elapsed Timer Routines

ASM
INT_LIST  macro    ; IntSource,        Label,  Type, ResetFlag?
        INT_Handler   TMR1_INT,  _ClockCount,   PBP,  yes
    endm
    INT_CREATE            ; Creates the interrupt processor

    INT_ENABLE  TMR1_INT  ; Enable Timer 1 Interrupts  
ENDASM

GOSUB ResetTime           ' Reset Time to  0d-00:00:00.00
GOSUB StartTimer          ' Start the Elapsed Timer

Main:
  IF SecondsChanged = 1 THEN  
     SecondsChanged = 0
     LCDOUT $FE,2, DEC Days,"d-",DEC2 Hours,":",DEC2 Minutes,":",DEC2 Seconds
  ENDIF
GOTO Main

Code Size = 537 Words

This will create a Clock counting at 1/100 seconds. It runs in the background of PBP without any other program intervention required.

The time is kept in the variables:

    Ticks    var byte   ' 1/100th of a second
    Seconds  var byte   ' 0-59
    Minutes  var byte   ' 0-59
    Hours    var byte   ' 0-23
    Days     var word   ' 0-65535

The time can be easily displayed with a single line:

    LCDout $FE,2, dec Days,"d-",dec2 Hours,":",dec2 Minutes,":",dec2 Seconds

For each of the variables (Seconds, Minutes, Hours and Days) there is a flag
that indicates when the value of that variable has changed. The Flags are:

SecondsChanged var bit
MinutesChanged var bit
HoursChanged var bit
DaysChanged var bit

If you wanted to display the time like a clock, you could wait until
SecondsChanged = 1, display the time, then reset the flag.

    Loop1:
        if SecondsChanged = 1 then
           LCDout $FE,2, dec Days,"d-",dec2 Hours,":",dec2 Minutes,":",dec2 Seconds
           SecondsChanged = 0
        endif
    Goto Loop1

If you only wanted to display the time each minute instead of every second
just do the same thing using the MinutesChanged flag.

    Loop1:
        if MinutesChanged = 1 then
           LCDout $FE,2, dec Days,"d-",dec2 Hours,":",dec2 Minutes
           MinutesChanged = 0
        endif
    Goto Loop1

The timer can be Stopped and Started, like a stopwatch.

    Gosub StopTimer
    Gosub StartTimer

[Darrel Taylor]

So far I've shown one interrupt source being used at a time, but as I said in the first post, you can easily service Multiple Interrupt Sources.   So what if we wanted to join the previous 3 examples into one program.   NOT a problem!

To add more interrupt "Handlers", simply add them to the INT_LIST, and create a subroutine for them.

Since both the Blinky Light, and Elapsed Timer used TMR1, lets move the Blinky Light over to TMR0. Elapsed will still use TMR1.

LED1   VAR  PORTD.0
LED2   VAR  PORTD.1

INCLUDE "DT_INTS-14.bas"     ' Base Interrupt System
INCLUDE "ReEnterPBP.bas"     ' Include if using PBP interrupts
INCLUDE "Elapsed_INT.bas"    ' Elapsed Timer Routines

ASM
INT_LIST  macro    ; IntSource,        Label,  Type, ResetFlag?
        INT_Handler    INT_INT,  _ToggleLED1,   PBP,  yes
        INT_Handler   TMR0_INT,  _ToggleLED2,   PBP,  yes
        INT_Handler   TMR1_INT,  _ClockCount,   PBP,  yes
    endm
    INT_CREATE               ; Creates the interrupt processor

    INT_ENABLE   INT_INT     ; enable external (INT) interrupts
    INT_ENABLE  TMR0_INT     ; enable Timer 0 interrupts
    INT_ENABLE  TMR1_INT     ; Enable Timer 1 Interrupts  
ENDASM

OPTION_REG = OPTION_REG & $80 | 1  ; Set TMR0 Prescaler to 256, leave RBPU alone
GOSUB ResetTime              ' Reset Time to  0d-00:00:00.00
GOSUB StartTimer             ' Start the Elapsed Timer

Main:
    IF SecondsChanged = 1 THEN  
       SecondsChanged = 0
       LCDOUT $FE,$C0, DEC Days,"d-",DEC2 Hours,":",DEC2 Minutes,":",DEC2 Seconds
    ENDIF
GOTO Main

'---[INT - interrupt handler]---------------------------------------------------
ToggleLED1:
     TOGGLE LED1
@ INT_RETURN

'---[TMR0 - interrupt handler]-------------------------------(Blinky Light)------
T0Count  VAR WORD
ToggleLED2:
    T0Count = T0Count + 1
    IF T0Count = 512 THEN T0Count = 0 : TOGGLE LED2
@ INT_RETURN

<font size=-2>Code Size = 711 Words</font>

Now we have all three interrupt sources working together in the same program.

LED1 responds to the external INT
LED2 flashes, timed by TMR0
and, the elapsed timer is maintained via TMR1

And, all of this is happening behind the scenes of your normal PBP program.

[Darrel Taylor]

<table cellpadding=6><tr><td valign=center></td><td>The Instant Interrupt System consists of several "Layers".

The Bottom Layer is "DT_INTS-14.bas". This file contains everything required to use Interrupts at the ASM level. &nbsp; It handles all of the "Context Saving/Restoring", detects which interrupt has been triggered, and calls the appropriate "User Routine".

The next layer up is created from the INT_LIST macro you define in the program. &nbsp; It defines the Interrupt sources to use and the corresponding subroutines that will be called. &nbsp; They can be either simple subroutines, or complete "Modules" in a separate Include file, like the Elapse Timer. &nbsp; Up to 14 separate INT_Handler's can be in the LIST.

And, the Top Layer is the normal PBP program that runs in the foreground.

If Basic Laguage interrupts are not being used, then DT_INTS-14.bas is the only file you need to include.</td></tr></table>Here's another example of a Blinky Light program using TMR1 with an Assembly Language Interrupt handler

LED1   VAR  PORTD.0
LOW  LED1                    ; Set to Output Low

INCLUDE "DT_INTS-14.bas"     ; Base Interrupt System

ASM
INT_LIST  macro    ; IntSource,        Label,  Type, ResetFlag?
        INT_Handler   TMR1_INT,   ToggleLED1,   ASM,  yes
    endm
    INT_CREATE               ; Creates the interrupt processor

    INT_ENABLE  TMR1_INT     ; Enable Timer 1 Interrupts  
ENDASM

T1CON = $31                  ; Prescaler=8, TMR1ON

Main:
    PAUSE 1
GOTO Main

'---[TMR1_INT - interrupt handler]------------------------------------------
ASM
ToggleLED1
    btfsc  _LED1
    goto   $+3
    bsf    _LED1
    goto   $+2
    bcf    _LED1
    INT_RETURN
ENDASM

<font size=-3>Code Size = 104 Words</font>

Notice that the INT_Handler's Type is ASM, and the Label does not have an underscore before it.<hr><table cellpadding=6><tr><td></td><td valign=top>By using this type of Layering scheme. It allows us more flexability, depending on the type of interrupt we want to use. &nbsp; If we want to add Basic Language Handlers, all we need to do is Include "ReEnterPBP.bas", and it will insert another Layer in-between the Base and the Handlers.

With this layer included, you can have any combination of ASM and PBP interrupts in the same program</td></tr></table>
<br>

[Darrel Taylor]

October 05, 2002 was a good day. &nbsp; Because that's the day that Tim Box released his "INT_CTRL.pbp" program. &nbsp; The original "Instant Interrupts"

Tim had discovered that the only reason you couldn't use Basic statements in a normal interrupt, was because the PBP system variables currently being used by the statement that got interrupted, would be overwritten by the Basic statements in the interrupt routine. &nbsp; And that, all you have to do is save the state of the system vars at the start of the interrupt, and restore them back to the way they were before exiting the interrupt and you can use any Basic statements you want.

I've probably said it too many times already but ... Thanks again Tim!
<hr>
ReEnterPBP.bas is an adaptation of the same concept, but it allows the Interrupt system to determine if it needs to save the variables or not.

For instance, if you have a program with both ASM and PBP interrupt handlers, and an interrupt triggers an ASM handler, there's no need to save the variables first, it would just be waisting valuable time. And if more than 1 Basic handler is triggered at the same time, it only saves the variables once, and processes all the Interrupts on the same pass, before restoring the system vars, again saving time.

However, it does still take a lot of time to save all those variables. Usually it takes around 70 instruction cycles to save the vars. Then another 70 cycles to restore them again. At 4mhz it's 140us total save and restore time, which limits the maximum interrupt frequency to just over 7khz. At 20mhz OSC, you can go up to almost 36khz. That's fast enough to receive RS232 at over 250Kbaud with the USART. &nbsp; But is still considerably slower than you can get with ASM interrupts.

<br>