About C51 interrupt programming

The basic structure of the 8051 series MCU includes: 32 I/O ports (4 groups of 8-bit ports); two 16-bit timer counters; full-duplex serial communication; 6 interrupt sources (2 external interrupts, 2 timer/counter interrupts, 1 serial port input/output interrupt), two-level interrupt priority; 128 bytes of built-in RAM; independent 64K bytes of addressable data and code areas. After an interrupt occurs, the MCU goes to one of the 5 interrupt entry points and then executes the corresponding interrupt service
handler. The entry address of the interrupt program is placed in the interrupt vector by the compiler. The interrupt vector is located at the lowest address of the program code segment. Note that the serial port input/output interrupt here shares an interrupt vector. The interrupt vector table of 8051 is as follows:
Interrupt SourceInterrupt Vector
--------------------------
Power-On Reset 0000H
External Interrupt 0 0003H
Timer 0 Overflow 000BH
External Interrupt 1 0013H
Timer 1 Overflow 001BH
Serial Port Interrupt 0023H
Timer 2 Overflow 002BH

Both interrupt and using are keywords of C51. The C51 interrupt procedure is implemented by using the interrupt keyword and the interrupt number (0 to 31). The interrupt number indicates the entry address of the compiler interrupt routine. The interrupt number corresponds to the enable bit in the 8051 interrupt enable register IE. The corresponding relationship is as follows:
IE register C51 8051
Enable bit Interrupt number Interrupt source
--------------------------------
IE.0 0 External interrupt 0
IE.1 1 Timer 0 overflow
IE.2 2 External interrupt 1
IE.3 3 Timer 1 overflow
IE.4 4 Serial port interrupt
IE.5 5 Timer 2 overflow

With this declaration, the compiler does not need to care about the use of register bank parameters and the protection of accumulator A, status register, register B, data pointer and default registers. As long as they are used in the interrupt routine, the compiler will push them to the stack and pop them at the end of the interrupt routine. C51 supports all five 8051 standard interrupts from 0 to 4 and up to 27 interrupt sources in the 8051 series (enhanced). The
using keyword is used to specify the register bank used by the interrupt service routine. The usage is: using followed by a number from 0 to 3, corresponding to 4 groups of working registers. Once the working register group is specified, the default working register group will not be pushed onto the stack, which will save 32 processing cycles, because both stacking and popping require 2 processing cycles. The disadvantage of this approach is that all interrupt calling processes must use the same specified register group, otherwise parameter passing will fail. Therefore, you need to be flexible in choosing using.

About using:
You said in the article that "the disadvantage of this approach is that all interrupt calling processes must use the same specified register bank." Is this what you mean?
For example:
define a function
void func(unsigned char i) {
...
if(++i==0x12) {
...
}
...
}
and there is an interrupt function
void int_0(void) interrupt 0 using 1 {
....
}
In the default state, func uses register bank 0 (BANK0), so when int_0 calls func, will there be a parameter passing error when passing parameters?
Thank you!

If registers are used in the interrupt service function ISR, the use of using must be handled properly:
1. The interrupt service function uses using to specify a register bank different from the main function (the main function generally uses Register bank 0).
2. ISRs with the same interrupt priority can use using to specify the same register bank, but ISRs with different priorities must use different register banks. The function called in the ISR must also use using to specify the same register bank as the interrupt function.
3. If using is not used to specify, at the entrance of the ISR, C51 selects register bank 0 by default, which is equivalent to the entrance of the interrupt service program first executing the instruction:
MOV PSW #0.
This ensures that the high-priority interrupt is not specified by using. The low-priority interrupt using different register banks can be interrupted.
4. Use the using keyword to specify the register bank for the interrupt, so that the register bank can be switched directly without a large number of PUSH and POP operations, which can save RAM space and speed up the MCU execution time. In general, the switching of register banks is more prone to errors. You must have a clear understanding of the memory usage, and its correctness must be guaranteed by yourself. Especially when there is direct address access in the program, be careful! As for "when to use register bank switching", one situation is: when you try to run two (or more) jobs at the same time, and their scenes need some isolation, it will be used. Registers are very useful in ISR or using real-time operating system RTOS.
Principles of register bank use: 1.
The lowest 32 bytes of 8051 are divided into 4 groups of 8 registers. They are registers R0 to R7. The register bank is selected by the lower two bits of PSW. In ISR, MCU can switch to a different register bank. Access to register banks is not bit addressable. The C51 compiler stipulates that functions using using or disabling interrupts (#pragma disable) cannot return bit type values.
2. The main program (main function) uses one group, such as bank 0; all interrupts with low interrupt priority use the second group, such as bank 1; all interrupts with high interrupt priority use another group, such as bank 2. Obviously, there is no problem for interrupts of the same level to use the same set of registers, because interrupt nesting will not occur; while high-priority interrupts must use a different set from low-priority interrupts, because it is possible that a high-priority interrupt may occur in a low-priority interrupt. The compiler will automatically determine when absolute register access can be used.
3. When calling other functions in the ISR, the same register set must be used as the interrupt. When the NOAREGS command is not used to make an explicit statement, the compiler will use absolute register addressing to access the register set selected by the function (that is, specified by using or REGISTERBANK). When the register set assumed by the function is different from the one actually selected, unpredictable results will occur, which may result in parameter passing errors and the return value may be in the wrong register set.
For example: when the same function needs to be called inside and outside an interrupt, assuming that according to the program flow control, there will be no recursive call of the function, will there be any problems with such a call? If you are sure that reentry will not occur, there are two situations:
1. If the ISR and the main program use the same register bank (the main program uses BANK 0 by default, and if the ISR does not use using to specify a register area for it, it also uses BANK 0 by default), no other settings are required.
2. If the ISR and the main program use different register banks (the main program uses BANK 0 by default, and the ISR uses using to specify other BANKs), the called function must be placed in:
#pragma NOAREGS
#pragma AREGS
control parameter pair, specifying that the compiler should not use absolute register addressing mode for this function; or you can also select "Don't use absolute register accesses" in Options->C51 to make all codes not use absolute register addressing mode (this will slightly reduce execution efficiency). In either of the above situations, the compiler will give a reentry warning, and you need to manually change the OVERLAY parameter to make a reentry description.
3. There is another way: if the code of the called function is not very long, you can copy the function and replace it with a different function name. This is suitable for ROM with enough extra space.
Therefore, if you are not sure about the use of the using keyword, it is better not to use it and let the compiler system handle it. For
detailed usage, please refer to the C51.PDF file. The above is for reference.