51 MCU external interrupt programming example 2

1. The five major interrupt sources of the 51 MCU: serial port interrupt, timer interrupt 1, external interrupt 1, timer interrupt 0, external interrupt 0;
2. Interrupt source numbering: serial port interrupt is 4, timer interrupt 1 is 3, external interrupt 1 is 2, timer interrupt 0 is 1, external interrupt 0 is 0;
3. Interrupt source priority: in the above order, serial port interrupt is the lowest and external interrupt 0 is the highest;
4. When using external interrupts 0 and 1, the TCON register must be set to set its trigger mode to low level trigger (0) or falling edge trigger (1);
5. Before use, the general interrupt and its own interrupt must be enabled through the IE register;

1. External interrupt basic routine (interrupt not used, keyboard scan is general port scan)
#include .h>
sbit k1=P3^2;
sbit led=P2^7;
void delay_ms(unsigned int xms); //ms level delay subroutine
void key_scan(); //Declare keyboard scan subfunction
void main()
{
led=1; //Power-on initialization, LED light is not on
while(1)
{
key_scan();
delay_ms(3000);
}
}
void delay_ms(unsigned int xms) //ms level delay subroutine
{ unsigned int x,y; 
for(x=xms;x>0;x--)
for(y=130;y>0;y--);}
void key_scan() //Keyboard scan subfunction
{ if(k1==0) //Is any key pressed? (k1=0?)
{ delay_ms(10); //delay to eliminate jitter
if(k1==0) //A key is indeed pressed, then:
{led=!led; //flip the light status
    while(!k1);} //wait for the key to be released
} 
}

2. External interrupt basic routine (single keyboard external interrupt 0 scan processing)
//Use a key to control the on and off of a light
#include
sbit k1=P3^2;
sbit led=P2^7;
void delay_ms(unsigned int xms); //ms level delay subroutine
void key_scan() interrupt 0 //Keyboard scan subroutine using external interrupt 0. It can also be placed in the main function without pre-declaration
{ if(k1==0) //Is there a key pressed? (k1=0?)
{ delay_ms(10); //delay debounce
if(k1==0) //A key is indeed pressed, then:
{led=!led; //flip the state of the light
    while(!k1);} //wait for the key to be released
} 
}
void main()
{
led=1; //power-on initialization, the LED light is not on
TCON=0x01; //turn on external interrupt 0 and set it to falling edge trigger
IE=0x81; //turn on total interrupt
while(1)
{
delay_ms(3000); //note that there is no keyboard scanning program in the main function
}
}
void delay_ms(unsigned int xms) //ms level delay subroutine
{ unsigned int x,y; 
for(x=xms;x>0;x--)
for(y=130;y>0;y--);

}

3. External interrupt basic routine (external interrupt 1 scan processing of a single keyboard)

Author: CJoy, School of Mechanical Engineering, Jiangsu University of Science and Technology
//The function is the same as the previous example, using a button to control the on and off of a light, but using external interrupt 1
#include
sbit k2=P3^3;  
sbit led=P2^7;
void delay_ms(unsigned int xms); //ms-level delay subroutine
void main()
{
led=1; //Power-on initialization, the LED light is not on
TCON=0x04; //Turn on external interrupt 1 and set it to falling edge trigger
IE=0x84; //Turn on total interrupt and external interrupt 1
while(1)
{
delay_ms(3000);
}
}
void delay_ms(unsigned int xms) //ms-level delay subroutine
{ unsigned int x,y; 
for(x=xms;x>0;x--)
for(y=130;y>0;y--);}
void key_scan() interrupt 2 //Keyboard scanning subfunction using external interrupt 1
{ if(k2==0) //Is a key pressed? (k1=0?)
{ delay_ms(10); //Delay to eliminate jitter
if(k2==0) //A key is indeed pressed, then:
{led=!led; //Flip the state of the light
    while(!k2);} //Wait for the key to be released
} 
}

 4. External interrupt basic routine (using external interrupt 0 and external interrupt 1 at the same time)
//Use one key to control the on and off of the eight lights connected to port P0, and another key to control the on and off of one light
#include
sbit k1=P3^2;
sbit k2=P3^3; 
sbit led=P2^7;
void delay_ms(unsigned int xms); //ms level delay subroutine
void main()
{
P0=0xff; //Power-on initialization, P0 all off
led=1; //Power-on initialization, LED light is not on
TCON=0x05; //Open external interrupts 1 and 2, and set them to fall edge trigger
IE=0x85; //Open general interrupt and external interrupts 1 and 2

while(1)
{
delay_ms(3000);
}
}
void delay_ms(unsigned int xms) //ms level delay subroutine
{ unsigned int x,y; 
for(x=xms;x>0;x--)
for(y=130;y>0;y--);}
void key_scan_1() interrupt 0 //Keyboard scan subroutine using external interrupt 0
{ if(k1==0) //Is there a key pressed? (k1=0?)
{ delay_ms(10); //Delay debounceif
(k1==0) //A key is indeed pressed, then:
{P0=~P0; //Flip the status of the 8 lightswhile
    (!k1);} //Wait for the key to be released
} 
}
void key_scan_2() interrupt 2 //Keyboard scan subroutine using external interrupt 1
{ if(k2==0) //Is there a key pressed? (k1=0?)
{ delay_ms(10); //delay to eliminate jitter
if(k2==0) //A key is indeed pressed, then:
{led=!led; //flip the state of a single light
    while(!k2);} //wait for the key to be released
} 
}

5. External interrupt extension application routine (8 buttons control the on and off of 8 lights respectively)

//The eight buttons are connected to the external interrupt pin 0 through eight diodes for interrupt expansion, thus solving the problem of insufficient external interrupt ports.
#include
sbit k0=P2^0; //The eight buttons are connected to the pins of P2 port respectively,
sbit k1=P2^1; //At the same time, they are also connected to the external interrupt pin 0 (P3.2) through diodes
sbit k2
=P2^2;
sbit k3=P2^3;
sbit k4=P2^4;
sbit k5=P2^5; sbit k6=P2^6;
sbit k7=P2^7;

sbit led0=P0^0; //The 8 LED lights connected to the P0 pin are controlled by the above 8 buttons respectively
sbit led1=P0^1;
sbit led2=P0^2;
sbit led3=P0^3;
sbit led4=P0^4;
sbit led5=P0^5;
sbit led6=P0^6;
sbit led7=P0^7;

void delay_ms(unsigned int xms); //ms level delay subroutine
void main()
{
   //Power-on initialization, LED light is off
TCON=0x01; //Open external interrupt 0, and set it to falling edge trigger
IE=0x81; //Open total interrupt
while(1)
{
delay_ms(3000);
}
}
void delay_ms(unsigned int xms) //ms level delay subroutine
{ unsigned int x,y; 
for(x=xms;x>0;x--)
for(y=130;y>0;y--);

}
void key_scan() interrupt 0 //Keyboard scan subfunction using external interrupt 0
{ if(k0==0) //Is there a key pressed? (k0=0?)
{ delay_ms(10); //Delay debounce
if(k0==0) //A key is indeed pressed, then:
{led0=~led0; //Flip the state of the light
    while(!k0);} //Wait for the key to be released
}
if(k1==0) //Is there a key pressed? (k1=0?)
{ delay_ms(10); //Delay debounce
if(k1==0) //A key is indeed pressed, then:
{led1=!led1; //Flip the state of the light
    while(!k1);} //Wait for the key to be released
}
if(k2==0) //Is there a key pressed? （k2=0?）
{ delay_ms(10); //Delay debounce
if(k2==0) //A key is pressed, then:
{led2=!led2; //Flip the state of the light
    while(!k2);} //Wait for the key to be released
}
if(k3==0) //Is a key pressed? （k3=0?）
{ delay_ms(10); //Delay debounce
if(k3==0) //A key is pressed, then:
{led3=!led3; //Flip the state of the light
    while(!k3);} //Wait for the key to be released
}
if(k4==0) //Is a key pressed? （k4=0?）
{ delay_ms(10); //Delay debounce
if(k4==0) //A key is pressed, then:
{led4=!led4; //Flip the state of the light
    while(!k4);} //Wait for the key to be released
}
if(k5==0) //Is a key pressed? （k5=0?）
{ delay_ms(10); //Delay debounce
if(k5==0) //A key is pressed, then:
{led5=!led5; //Flip the state of the light
    while(!k5);} //Wait for the key to be released
}
if(k6==0) //Is a key pressed? （k6=0?）
{ delay_ms(10); //Delay debounce
if(k6==0) //A key is pressed, then:
{led6=!led6; //Flip the state of the light
    while(!k6);} //Wait for the key to be released
}
if(k7==0) //Is a key pressed? （k7=0?）
{ delay_ms(10); //Delay debounce
if(k7==0) //A key is pressed, then:
{led7=!led7; //Flip the state of the light
    while(!k7);} //Wait for the key to be released