PIC Microcontroller Memory Method

reentrant code

A subroutine is "re-entrant" if it is designed so that, if it is ever interrupted in the middle, and then the interrupt routine calls the same subroutine, then everything works the way it ought to work.

• Many kinds of multitasking require subroutines to be re-entrant if more than one task calls the subroutine.
• Recursive subroutines are required to be re-entrant (unless they are merely "tail-recursive").
• If we want one source of interrupts to interrupt the processing of another source of interrupts, the interrupt handler must be re-entrant.

Alas, it is very difficult to write re-entrant code on the Microchip PIC processors.

For example, if you have a "square_root" subroutine, and you call it with "9", but while it is still calculating it gets interrupted, and the interrupt routine decides it needs to find the square root of "4" -- what happens? Most square root routines for the PIC will return the proper value "2" to the interrupt routine ... but when the calculation of the square root of "9" resumes, they wig out and return "2" or some other completely wrong answer.

Our options are:

• Write truely re-entrant code, by keeping input parameters, output parameters, and temporary variables on a stack (more on this below). On a PIC we can use 2 stacks -- one stack used when executing the "background" main loop, and another stack when executing the "foreground" interrupt routine.
• write code that we know is not re-entrant, and be very careful that we never try to re-enter a subroutine. There are the "background" subroutines called by the main loop, and there are the "foreground" subroutines called by the interrupt routine; we make sure that each subroutine is *either* called by the main loop, *or* called by the interrupt routine, but never both. If we *need* to calculate the square root in both places, we make 2 different square root routines, that hold all their parameters and temporary variables in 2 different places.)

  write code that we know is not re-entrant, and whenever an interrupt might mess up the calculation, disable interrupts temporarily. (The section between disabling interrupts and re-enabling interrupts is called the "critical section").

• In some cases, it doesn't hurt for a subroutine to run several times even when we only called it twice -- such as "delay for at least N cycles" and most mathematical functions. We do the same sort of "critical section" analysis, except instead of completely disabling interrupts, we merely set a flag. Inside the interrupt routine, we always clear that flag. At the point where we would have re-enabled the interrupts, we check the flag. If the flag has been cleared, we know the interrupt routine has potentially messed things up, so we loop back to the point where we set the flag. If the flag it's still set, we know everything is fine so we continue.

nested interrupts require data stacks

(see also software stacks on the Scenix )

Nikolai Golovchenko says:

Yes, the nested interrupts are possible. The method I used on 16F84 processed two interrupts (RBIF and TMR0IF), but more interrupts could be okay. To do this, I use software stack macros (see attachment) that use FSR as a stack pointer. A typical interrupt handler looks like this:

            ORG     0x004                   ; interrupt vector location
            PUSHW                             ;store W
            PUSHSTATUS                 ;store STATUS

                                            ;code goes here

            POPSTATUS                      ;restore W
            POPW                            ;restore STATUS
            retfie                          ; return from interrupt

After storing W and STATUS goes usual interrupt flags polling .
As soon as a set flag is detected, it should be cleared and GIE=1 to allow other interrupts to actually interrupt the process.
Be careful not to allow too many interrupts to be processed, only the ones that have critical response time, because hardware stack may overflow. The best way is to keep GIE reset during the most critical interrupt so that it could finish without unwanted interrupts.
Priority of different interrupts is programmed by flags polling sequence(in case they trigger at the same time).
That's it.

By the way, I find software stack macros very useful in practically every program. The best example is when you need one scratch pad register. Using stack it's simple:

PUSH    ;reserve one byte on stack
....use INDF as a scratch pad reg
POP    ;restore stack

Good luck.

;*******************************
;Software stack organization
;*******************************
;FSR is a stack pointer
;Top of stack is in INDF
;Stack grows in upper addresses direction
;*******************************************************************
;MACRO:      INSTR.NUMBER:   STATUS INFLUENCE:          W INFLUENCE:
;
;PUSHW          2               no                      no
;POPW           3               no                      yes
;POPW2          2               yes!!!                  yes
;PUSHSTATUS     3               no                      yes!!!
;POPSTATUS      3               yes                     yes!!!
;PUSH           1               no                      no
;POP            1               no                      no
;*******************************************************************
;Notes: 1) FSR should point at the stack top
;       2) PUSHSTATUS and POPSTATUS must be used in pair,
;       because these macros mangle quadruples
;*******************************************************************

PUSHW   MACRO
        INCFSZ FSR, F   ;never goes zero, but STATUS is safe
        MOVWF INDF
        ENDM

POPW    MACRO
        SWAPF INDF, F
        SWAPF INDF, W	;same as movfw indf, but STATUS unchanged
        DECFSZ FSR, F   ;never goes zero, but STATUS is safe
        ENDM

POPW2   MACRO
        MOVF INDF, W
        DECFSZ FSR, F   ;the popped W STATUS is safe
        ENDM

PUSHSTATUS      MACRO
        SWAPF STATUS, W
        INCFSZ FSR, F   ;never goes zero, but STATUS is safe
        MOVWF INDF
        ENDM

POPSTATUS       MACRO
        SWAPF INDF, W
        MOVWF STATUS
        DECFSZ FSR, F
        ENDM

PUSH    MACRO
        INCFSZ FSR, F
        ENDM

POP     MACRO
        DECFSZ FSR, F
        ENDM

Robin Abbott of Forest Electronic Developments says:

This might be of use to someone. Recently I had a project where a subroutine took a value in W and saved to a software stack:

movwf Temp
movfw sp        ; Stack pointer
movwf FSR    ; Point to it
movfw Temp
movwf 0

Trouble is it uses a temporary variable which I didn't have (it is in an interrupt). This alternative which makes use of XOR uses no temporary variable at the expense of 1 extra word:

  movwf FSR
  movfw sp
  xorwf FSR
  xorwf FSR,w
  xorwf FSR
  movwf 0

You can also use this to swap two variables (say x and y) without a temporary variable leaving X (or Y if order is reversed) in W.

    movfw x       ; Get X
    xorwf y         ; Y is now X^Y
    xorwf y,w     ; W is now (X^y)^X==Y  (say OldY)
    movwf x       ; Now X is OldY
    xorwf y         ; finally Y is (OldX^Y)^Y==OldX

I think this may be an old technique - I have vague memories of something similar from the pre-history of programming, but only found a use for it now

(See math/bit/swap.htm for details. )

Timer tutorial (incl prescalers) by Andrew Warren

Are the stack-based math routines /techref/microchip/pfu.htm compatible with the above code?

James Cameron [quozl at us.netrek.org] says:

I've also done a software stack, mainly for mathematical functions, in order to significantly reduce memory (file register) utilisation on a 12C509. Not a call and return stack, just a parameter stack. http://quozl.netrek.org/stack-math.asm

{ed: This has now been expanded at http://quozl.netrek.org/uptime/ to include

• LCD display access, put a data byte or a command on stack and call the function,
• vectored execution, put a pointer to a function on the stack and call the function,
• data table handler, give it a pointer to the table function, a pointer to a function to be called for each table entry, and call the function,
• binary coded decimal conversion, nice wasteful code that takes a high and a low byte of a 16-bit word on the stack, and returns three bytes of binary coded decimal,
• hexadecimal conversion, takes a byte and returns two ASCII characters on the stack.

FORTH on the PIC uses 2 software stacks: the Data stack and the "Rack" http://wiki.enst.fr/bin/view/Picforth/FakeReturnStack

deeper return stack

See also

• A multitasking kernel for the 8080 /techref/method/multitask/8080kern.htm
• Writing Memory-Resident Software for MS-DOS /techref/language/masm/masmc11.htm describes problems that occur with non-reentrant code and some techniques for working around those problems.
• a PICList thread discusses whether C compilers for the PIC18 generate re-entrant code. /techref/postbot.asp?by=time&id=piclist\2001\03\22\120704a.txt
• Another PIClist thread discusses whether it is possible to have a reentrant interrupt service. /techref/postbot.asp?by=time&id=piclist\1998\06\22\083312a.txt
• The '[PIC]: CAN Interrupts' thread /techref/postbot.asp?by=time&id=piclist\2006\04\01\003655a.txt discusses re-entrant code (in this case they were able to figure out a way to re-structure the code so it didn't need to be re-entrant -- one subroutine called from both the main line and the interrupt routine, but they could guarantee that it would be called from the interrupt routine only long after it finished executing in the main line. )

Interested:

Questions:

PICList 2008 contributors: o List host: MIT, Site host massmind.org, Top posters @20080828 Apptech, Jinx, Xiaofan Chen, olin piclist, Alan B. Pearce, Vitaliy, William \Chops\ Westfield, Tamas Rudnai, Cedric Chang, David VanHorn, * Page Editors: James Newton, David Cary, and YOU! * Roman Black of Black Robotics donates from sales of Linistep stepper controller kits. * Ashley Roll of Digital Nemesis donates from sales of RCL-1 RS232 to TTL converters. * Monthly Subscribers: Shultz Electronics, Timothy Weber, on-going support is MOST appreciated! * Contributors: Richard Seriani, Sr.

  .