1、定义
    由于某种事件的发生，处理器暂停执行当前的程序，转而执行另一程序，以处理发生的事件，处理完毕后又返回原程序继续作业。
    2、中断优先级
    中断响应原则：
    ①首先响应高优先级的中断请求；
    ②如果优先级相同，按查询次序响应排在前面的中断；
    ③正在进行的中断过程不能被新的同级或低优先级的中断请求所中断；
    ④正在进行的低优先级中断过程，能被高优先级中断请求所中断。
    3、中断的作用：
    处理突发事件；安排事件处理的优先级。
    注：

    1. 中断过程中delay()不起作用，millis函数不包括中断时间，Arduino开发板接收到的串口数据可能丢失；
    2. 中断服务程序不能返回任何数值。所以应尽量在中断服务程序中使用全局变量；
    3. 中断服务程序中涉及的变量应声明为volatile类型。

    4、中断类型：
    （1）定时器中断：设定一个间隔时间，单片机定时器每个相同的间隔时间会产生一次定时器中断，单片机处理器接收到定时器中断信号后执行相应的中断处理程序；“间隔固定时间中断”

    1. #include<TimerOne.h>
    2. Timer1.initialize(interval) //interval是时间间隔，整数，以微秒为单位
    3. Timer1.attachInterrupt(ISR)   //附上中断处理程序
    4. void ISR()   //ISR是中断处理程序，空函数，无参数无返回值

    注：
    ①使用了TimerOne库，则板子上的 pin 9 和 pin 10 就不能再用做 PWM 输出；
    ②Servo库不能和TimerOne库一起使用；
    ③使用 TimerOne 库只能设定一件要定时做的事, 后面的 attachInterrupt( ) 会盖掉前面的 attachInterrupt( )。
    （2）外部中断：单片机外部中断引脚的电平的特定变化产生的中断事件；“让它中断就中断”
    中断配置函数： attachInterrupt(channel,ISR,mode)
    参数：
    channel：中断通道号，Ardunio UNO中通道编号0/1分别对应板子上引脚号2/3
    ISR：用户自定义的中断处理程序，空函数
    mode：中断触发模式
    LOW： 当引脚为低电平时触发中断服务程序
    CHANGE： 当引脚电平发生变化时触发中断服务程序
    RISING： 当引脚电平由低电平变为高电平时触发中断服务程序
    FALLING： 当引脚电平由高电平变为低电平时触发中断服务程序

    1. #include <TimerOne.h>
    2. const long interval = 2000000; //2s
    3. const int R=7,B=6,G=5;
    4. int counter=0;
    5. void setup() 
    6. {
    7.   pinMode(R,OUTPUT);  
    8.   pinMode(B,OUTPUT);  
    9.   pinMode(G,OUTPUT);  
    10.   digitalWrite(R,LOW);
    11.   digitalWrite(B,LOW);
    12.   digitalWrite(G,LOW);
    13.   Timer1.initialize( interval ); // 初始化,每2秒产生一次定时器中断
    14.   Timer1.attachInterrupt( Isr ); 
    15. }
    16. void Isr( )
    17. {
    18.   if(counter==0)
    19.   {
    20.     digitalWrite(R,HIGH);
    21.     digitalWrite(G,LOW);
    22.     digitalWrite(B,LOW);
    23.     counter++;
    24.   }
    25.   else if(counter==1)
    26.   {
    27.     digitalWrite(R,LOW);
    28.     digitalWrite(G,HIGH);
    29.     digitalWrite(B,LOW);
    30.     counter++;
    31.   }
    32.   else
    33.   {
    34.     digitalWrite(R,LOW);
    35.     digitalWrite(G,LOW);
    36.     digitalWrite(B,HIGH);
    37.     counter=0;
    38.   }
    39. }
    40. void loop()
    41. { 
    42. }
    1. const int B=7;
    2. const int interruptPin=2;   //外部中断引脚
    3. int counter=0;
    4. int flag=0;
    6. void setup()
    7. {
    8.   pinMode(B, OUTPUT);
    9.   pinMode(interruptPin, INPUT_PULLUP);
    10.   digitalWrite(B,HIGH);
    11.   attachInterrupt(0, Isr, FALLING);//当int.0电平由高变低时,触发中断函数Isr
    12. }
    14. void loop()
    15. { 
    16.   if(flag==0)
    17.   {
    18.     flag=1;
    19.     delay(1000);
    20.     digitalWrite(B,HIGH);
    21.   }
    22.   else
    23.     digitalWrite(B,HIGH);
    24. }
    26. void Isr()//中断函数
    27. {
    28.   digitalWrite(B,LOW);
    29.   flag=0;
    30. }
    1.  while(digitalRead(SW)==1&&analogRead(Ry)<800){ //调Time
    2.       if(analogRead(Rx)>800){
    3.         if(Time<9){
    4.           Time++;
    5.           SetTimer();
    6.         }
    7.         else{
    8.           Time=0;
    9.           SetTimer();
    10.         }
    11.       }
    12.       else if(analogRead(Ry)<200){
    13.         if(Time>0){
    14.           Time--;
    15.           SetTimer();
    16.         }
    17.         else{
    18.           Time=9;
    19.           SetTimer();
    20.         }
    21.       }
    22.      }  //调Time结束
    1. #include <TimerOne.h>
    2. #include <LiquidCrystal.h>
    4. const int Rx=0,Ry=1,SW=3;
    5. const int rs=13,en=12,d4=11,d5=8,d6=7,d7=4;     
    6. int flag=0,state=2,Time=0,count=0;
    7. const long interval=10000;//10ms
    8. LiquidCrystal LCD(rs, en, d4, d5, d6, d7);  
    10. void wait(){
    11.   LCD.print("Wait...");
    12.   delay(1000);
    13.    LCD.clear();
    14. }
    16. void SetTimer(){
    17.   LCD.setCursor(0,0);
    18.   LCD.print("Timer");
    19.   LCD.setCursor(0,1);
    20.   LCD.print(Time);
    21. }
    23. void setup() {
    24.   LCD.begin(16,2);
    25.   LCD.clear();
    26.   LCD.setCursor(0,0);
    27.   wait();
    28.   pinMode(SW,INPUT_PULLUP);
    29.   attachInterrupt(1, Isr, FALLING);//当int.0电平由高变低时,触发中断函数Isr
    30. }
    32. void loop() {
    33.   if(state==1){
    34.   wait();
    35.   state=2;
    36.   return;
    37.  }
    38.   if(state==2){
    39.     SetTimer();
    40.     //调Timer时间
    42.     while(digitalRead(SW)==1&&analogRead(Ry)<800){ //调Time
    43.       if(flag==0){  
    44.           flag=1;
    45.       if(analogRead(Rx)>800){
    46.         if(Time<9){
    47.           Time++;
    48.           SetTimer();
    49.         }
    50.         else{
    51.           Time=0;
    52.           SetTimer();
    53.             flag=0;
    54.         }
    56.       }
    58.       }
    59.       else if(analogRead(Ry)<200){
    60.         if(Time>0){
    61.           Time--;
    62.           SetTimer();
    63.         }
    64.         else{
    65.           Time=9;
    66.           SetTimer();
    67.         }
    68.       }
    69.      }  //调Time结束
    71.      count=Time*1000;
    72.      state=3;
    73.      return;
    74.   }
    75.   if(state==3){
    76.     Timer1.initialize( interval ); // 初始化,每10ms产生一次定时器中断
    77.     if(count>0){      
    78.       Timer1.attachInterrupt( Isrtime );
    79.     }
    80.     else{
    81.       state=4;
    82.       return;
    83.     }
    84.   }
    85.   if(state==4){
    86.     LCD.clear();
    87.     LCD.setCursor(0,0);
    88.     LCD.print("Beep");
    89.     delay(100);
    90.     if(SW==0){
    91.       state=1;
    92.       return;
    93.     }
    94.   }
    96. }
    98. void Isr(){
    99.   wait();
    100.   state=2;
    101. }
    103. void Isrtime(){
    104.   attachInterrupt(Rx, Isr2, RISING);
    105.   if(count>0){
    106.     LCD.setCursor(0,0);
    107.     LCD.print("Timer");
    108.     LCD.setCursor(0,1);
    109.     LCD.print(count);
    110.     count=count-10;
    111.   }
    112.   else{
    113.     return;
    114.   }
    115. }
    117. void Isr1(){
    119. }
    121. void Isr2(){
    122.     LCD.setCursor(0,0);
    123.     LCD.print("Timer");
    124.     LCD.setCursor(0,1);
    125.     LCD.print(count);
    126.     if(analogRead(Rx)<300){
    127.       Timer1.detachInterrupt();
    128.     }
    129. }
    1. #include <TimerOne.h>
    2. #include <LiquidCrystal.h>
    4. const int Rx=0,Ry=1,SW=3;
    5. const int rs=13,en=12,d4=11,d5=8,d6=7,d7=4;     
    6. int flag1=0,flag2=0,state=2,Time=0,count=0;
    7. const long interval=10000;//10ms
    8. LiquidCrystal LCD(rs, en, d4, d5, d6, d7);  
    10. void wait(){
    11.   LCD.print("Wait...");
    12.   delay(1000);
    13.    LCD.clear();
    14. }
    16. void SetTimer(){
    17.   LCD.setCursor(0,0);
    18.   LCD.print("Timer");
    19.   LCD.setCursor(0,1);
    20.   LCD.print(Time);
    21. }
    23. void setup() {
    24.   Serial.begin(9600);
    25.   LCD.begin(16,2);
    26.   LCD.clear();
    27.   LCD.setCursor(0,0);
    28.   wait();
    29.   pinMode(SW,INPUT_PULLUP);
    30.   attachInterrupt(1, Isr, FALLING);//当int.0电平由高变低时,触发中断函数Isr
    31. }
    33. void loop() {
    34.   if(state==1){
    35.   wait();
    36.   state=2;
    37.   return;
    38.  }
    39.   else if(state==2){
    40.     SetTimer();
    41.     //调Timer时间
    43.   if(analogRead(Ry)<800){ //调Time
    44.       if(analogRead(Rx)>800){
    45.         if(Time<9){
    46.           Time++;
    47.           SetTimer();
    48.         }
    49.         else{
    50.           Time=0;
    51.           SetTimer();
    52.         }
    53.         delay(500);
    54.         Serial.println(Time);
    55.      Serial.println(count);
    56.      Serial.println(state);
    57.       }
    58.       else if(analogRead(Rx)<300){
    59.         if(Time>0){
    60.           Time--;
    61.           SetTimer();
    62.         }
    63.         else{
    64.           Time=9;
    65.           SetTimer();
    66.         }
    67.         delay(500);
    68.         Serial.println(Time);
    69.      Serial.println(count);
    70.      Serial.println(state);
    71.       }  
    72.       return;  
    73.      }  
    74.   else{
    75.     state=3;
    76.     count=Time*1000;
    77.      Serial.println(Time);
    78.      Serial.println(count);
    79.      Serial.println(state);
    80.     return;   
    81.   }
    82.   }
    84.   else if(state==3){
    85.     Serial.println(state);
    86.     Timer1.initialize( interval ); // 初始化,每10ms产生一次定时器中断
    87.     Serial.println(state);
    88.     if(count>0){      
    89.       Timer1.attachInterrupt( Isrtime );
    90.     }
    91.     else{
    92.       state=4;
    93.       return;
    94.     }
    96.   }
    97.   else if(state==4){
    98.     LCD.clear();
    99.     LCD.setCursor(0,0);
    100.     LCD.print("Beep");
    101.     delay(100);
    102.     if(SW==0){
    103.       state=1;
    104.       return;
    105.     }
    106.   }
    108. }
    110. void Isr(){
    111.   wait();
    112.   state=2;
    113. }
    115. void Isrtime(){
    116.   if(count>0&&SW==1){
    117.     if(flag2==0){
    118.       if(analogRead(Rx)<800&&analogRead(Rx)>400){
    119.           LCD.setCursor(0,0);
    120.           LCD.print("Timer");
    121.           LCD.setCursor(0,1);
    122.           LCD.print(count);
    123.           count=count-10;
    124.       }
    125.       if(analogRead(Rx)>600){
    126.         flag2=1;
    127.         LCD.setCursor(0,0);
    128.         LCD.print("Timer");
    129.         LCD.setCursor(0,1);
    130.         LCD.print(count);
    131.       }
    132.     }
    133.    if(analogRead(Rx)<400){
    134.         flag2=0;
    135.    }
    136.   }
    137.   else if(SW==0){
    138.     state=1;
    139.     return;
    140.   }
    141.   else{
    142.     return;
    143.   }
    144. }
    1. else if(state==2){
    2.     SetTimer();
    3.     //调Timer时间
    5.     if(analogRead(Ry)<800){ //调Time
    6.       if(analogRead(Rx)>800){
    7.         if(Time<9){
    8.           Time++;
    9.           SetTimer();
    10.         }
    11.         else{
    12.           Time=0;
    13.           SetTimer();
    14.         }
    15.         delay(500);
    16.         Serial.println(Time);
    17.      Serial.println(count);
    18.      Serial.println(state);
    19.       }
    20.       else if(analogRead(Rx)<300){
    21.         if(Time>0){
    22.           Time--;
    23.           SetTimer();
    24.         }
    25.         else{
    26.           Time=9;
    27.           SetTimer();
    28.         }
    29.         delay(500);
    30.         Serial.println(Time);
    31.      Serial.println(count);
    32.      Serial.println(state);
    33.       }  
    34.       return;  
    35.      }  
    36.   else{
    37.     state=3;
    38.     count=Time*1000;
    39.      Serial.println(Time);
    40.      Serial.println(count);
    41.      Serial.println(state);
    42.     return;   
    43.   }
    44.   }
    1. void Isrtime(){
    2.   if(count>0){
    3.     if(flag==0){
    4.       if(analogRead(Rx)<800&&analogRead(Rx)>400){
    5.         LCD.clear();
    6.           LCD.setCursor(0,0);
    7.           LCD.print("Timer");
    8.           LCD.setCursor(0,1);
    9.           LCD.print(count);
    10.           count=count-10;
    11.       }
    12.       else if(analogRead(Rx)>800){
    13.         flag=1;
    14.         LCD.clear();
    15.         LCD.setCursor(0,0);
    16.         LCD.print("Timer");
    17.         LCD.setCursor(0,1);
    18.         LCD.print(count);
    19.       }
    20.     }
    21.    else if(analogRead(Rx)<400){
    22.         flag=0;
    23.    }
    24.   }
    25.  else{
    26.     return;
    27.   }
    28. }
    1. void Isrtime(){
    2.   if(count>0){
    3.     LCD.setCursor(0,0);
    4.     LCD.print("Timer");
    5.     LCD.setCursor(0,1);
    6.     LCD.print(count);
    7.     count=count-10;
    8.   }
    9.   else{    
    10.     return;
    11.   }
    12. }
    1. #include <TimerOne.h>
    2. #include <LiquidCrystal.h>
    4. const int Rx=0,Ry=1,SW=3;
    5. const int rs=13,en=12,d4=11,d5=8,d6=7,d7=4;     
    6. int flag=0,state=2,Time=0,count=0;
    7. const long interval=10000;//10ms
    8. LiquidCrystal LCD(rs, en, d4, d5, d6, d7);  
    10. void wait(){
    11.   LCD.print("Wait...");
    12.   delay(1000);
    13.    LCD.clear();
    14. }
    16. void SetTimer(){
    17.   LCD.setCursor(0,0);
    18.   LCD.print("Timer");
    19.   LCD.setCursor(0,1);
    20.   LCD.print(Time);
    21. }
    22. void Isr(){
    23.   wait();
    24.   state=2;
    25. }
    27. void setup() {
    28.   Serial.begin(9600);
    29.   LCD.begin(16,2);
    30.   LCD.clear();
    31.   LCD.setCursor(0,0);
    32.   wait();
    33.   pinMode(SW,INPUT_PULLUP);
    34.   attachInterrupt(1,Isr,FALLING);//当int.0电平由高变低时,触发中断函数Isr
    35. }
    37. void loop() {
    38.   if(state==1){
    39.   wait();
    40.   state=3;
    41.   return;
    42.  }
    43.   else if(state==2){
    44.     SetTimer();
    45.     //调Timer时间
    47.     if(analogRead(Ry)<800){ //调Time
    48.       if(analogRead(Rx)>800){
    49.         if(Time<9){
    50.           Time++;
    51.           SetTimer();
    52.         }
    53.         else{
    54.           Time=0;
    55.           SetTimer();
    56.         }
    57.         delay(500);
    58.         Serial.println(Time);
    59.      Serial.println(count);
    60.      Serial.println(state);
    61.       }
    62.       else if(analogRead(Rx)<300){
    63.         if(Time>0){
    64.           Time--;
    65.           SetTimer();
    66.         }
    67.         else{
    68.           Time=9;
    69.           SetTimer();
    70.         }
    71.         delay(500);
    72.         Serial.println(Time);
    73.      Serial.println(count);
    74.      Serial.println(state);
    75.       }  
    76.       return;  
    77.      }  
    78.   else{
    79.     state=3;
    80.     count=Time*1000;
    81.      Serial.println(Time);
    82.      Serial.println(count);
    83.      Serial.println(state);
    84.     return;   
    85.   }
    86.   }  
    87.   else if(state==3){
    88.     Timer1.initialize( interval ); // 初始化,每10ms产生一次定时器中断
    89.     if(count>0){      
    90.       Timer1.attachInterrupt( Isrtime );
    91.     }
    92.     else{
    93.       state=4;
    94.       return;
    95.     }    
    96.   }
    97.   else if(state==4){
    98.     LCD.clear();
    99.     LCD.setCursor(0,0);
    100.     LCD.print("Beep");
    101.     delay(100);
    102.     if(SW==0){
    103.       state=1;
    104.       return;
    105.     }
    106.   }
    108. }
    110. void Isrtime(){
    111.   if(count>0){
    112.     if(flag==0){
    113.       if(analogRead(Rx)<800&&analogRead(Rx)>400){
    114.         LCD.clear();
    115.           LCD.setCursor(0,0);
    116.           LCD.print("Timer");
    117.           LCD.setCursor(0,1);
    118.           LCD.print(count);
    119.           count=count-10;
    120.       }
    121.       else if(analogRead(Rx)>800){
    122.         flag=1;
    123.         LCD.clear();
    124.         LCD.setCursor(0,0);
    125.         LCD.print("Timer");
    126.         LCD.setCursor(0,1);
    127.         LCD.print(count);
    128.       }
    129.     }
    130.    else if(analogRead(Rx)<400){
    131.         flag=0;
    132.    }
    133.   }
    134.  else{
    135.     return;
    136.   }
    137. }