不用延时去抖的按键程序

//主函数 main

#include
#include "key.h"
#include "lcd1602.h"

uchar Key_Flag=0;
uchar Keyval = 0;
uchar Respond_Key_Flag=0;      //响应键
uchar Set_Confirm_Flag=0;      //设设置/确认标志

uchar Volt_buf[5]={'1','2','.','2','6'};                                     
uchar Curr_buf[5]={'0','5','.','5','4'};

void Init_port();
void Init_SysClk();
void Init_TimerB();
void key_process(); 
//////////////////主函数///////////////
void main()
{
   WDTCTL = WDTPW + WDTHOLD;                 //关闭看门狗
   Init_port();
   Init_LCD() ;
   Init_SysClk();
   Init_TimerB();
   _EINT();
   
   Disp1Char(0,0,'U') ;
   Disp1Char(1,0,':') ;
   DispNChar(3,0, 5,Volt_buf);
   Disp1Char(0x0F,0,'V') ;
   
   Disp1Char(0,1,'I') ;
   Disp1Char(1,1,':') ;
   DispNChar(3,1, 5,Curr_buf);
   Disp1Char(0x0F,1,'A') ;
   
   
   
   while(1)
   {    
     key_process(); 
     
     
   }

}
/*******************************************
函数名称：key_process
功    能：根据按键值执行任务
参    数：无
返回值  ：无
********************************************/
void key_process()
{
      static uchar x=3;
      uchar keyvalue;
      static uchar key_one_flag=0;
      
      keyvalue = Key_Scan();
      Keyval = 0;
      if(Set_Confirm_Flag == 1)
      {  
                if(keyvalue == 1)               //设置/确认键
                {  
                    key_one_flag ^= 1;
                    if(key_one_flag==1)
                    {
                        write_cmd(0x0f);  //打开显示屏，显示光标，光标所在位置的字符闪烁
                        LocateXY(3,0);    //向液晶写入显示字符位置的坐标信息  
                    }
                    else 
                    {
                      write_cmd(0x0c);//开显示， 关光标，光标所在位置的字符不闪烁 
                      Set_Confirm_Flag =0;
                    }
                }
                                    
                if((keyvalue == 2)&&( Respond_Key_Flag==1))      //短路键
                {
                  
                  Respond_Key_Flag=0;
                  Disp1Char(3,0,'Z') ;
                  //TACCR0 = 65535;                   //PWM占空比设置为百分之百
                }
            
      
                if((keyvalue == 3)&&( Respond_Key_Flag==1))      //左移
                { 
                  
                  Respond_Key_Flag=0;
                  if(x >3) 
                  {
                    --x; 
                    if(x<8)
                      LocateXY(x,0);
                    else
                      LocateXY(x-5,1);  
                  }
                  else 
                  {
                    x=12;
                    LocateXY(x-5,1);
                  }        
                }
                
                
     
                if((keyvalue == 4)&&( Respond_Key_Flag==1))      //右移
                {
                  Respond_Key_Flag=0; 
                  
                  if(x < 12) 
                  {
                    ++x; 
                    if(x<8)
                      LocateXY(x,0);
                    else
                      LocateXY(x-5,1);  
                  }
                  else 
                  {
                    x=3;
                    LocateXY(x,0);
                  }        
                  
                }
                
      
      
      
                 if((keyvalue == 5)&&( Respond_Key_Flag==1))      //数值"+"键
                  {
                    Respond_Key_Flag=0; 
                    
                    if(x<3 || x>12)
                    { 
                      write_data(' ') ;
                    }
                    else if(x==5||x==10) 
                       {
                          write_data('.') ; 
                          if(x==5)
                            LocateXY(x,0);
                          if(x==10)
                            LocateXY(x-5,1);
                            
                       }
                     else
                       {
                           if((x>=3)&&(x<=7))
                           {
                              if(Volt_buf[x-3]<'9')
                               Volt_buf[x-3] += 1;
                               else Volt_buf[x-3]='0';
                               Disp1Char(x,0,Volt_buf[x-3]) ;
                               LocateXY(x,0);
                           }
                           else
                             {
                               if(Curr_buf[x-8]<'9')
                               Curr_buf[x-8] += 1;
                               else Curr_buf[x-8]='0';
                               Disp1Char(x-5,1,Curr_buf[x-8]) ;
                               LocateXY(x-5,1);
                           }                                                             
                       }
                    } 
       
           
        
                    
                     if((keyvalue == 6)&&( Respond_Key_Flag==1))    //数值"-"键
                      {
                        Respond_Key_Flag=0; 
                          
                          if(x<3 || x>12)
                          { 
                            write_data(' ') ;
                          }
                          else if(x==5||x==10) 
                             {
                                write_data('.') ; 
                                if(x==5)
                                  LocateXY(x,0);
                                if(x==10)
                                  LocateXY(x-5,1);
                                  
                             }
                           else
                             {
                                 if((x>=3)&&(x<=7))
                                 {
                                    if(Volt_buf[x-3]>'0')
                                     Volt_buf[x-3] -= 1;
                                     else Volt_buf[x-3]='9';
                                     Disp1Char(x,0,Volt_buf[x-3]) ;
                                     LocateXY(x,0);
                                 }
                                 else
                                   {
                                     if(Curr_buf[x-8]>'0')
                                     Curr_buf[x-8] -= 1;
                                     else Curr_buf[x-8]='9';
                                     Disp1Char(x-5,1,Curr_buf[x-8]) ;
                                     LocateXY(x-5,1);
                                 }                                                             
                             }
                      }
                
      }

    
}

/*============================================
函数名称：Init_port
功    能：初始化I/O端口
参    数：无       
返回值  ：无
==============================================*/
void Init_port()
{
    /*下面六行程序关闭所有的IO口*/
    P1DIR = 0XFF;P1OUT = 0XFF;
    P2DIR = 0XFF;P2OUT = 0XFF;
    P3DIR = 0XFF;P3OUT = 0XFF;
    P4DIR = 0XFF;P4OUT = 0XFF;
    P5DIR = 0XFF;P5OUT = 0XFF;
    P6DIR = 0XFF;P6OUT = 0XFF;
    P6DIR |= BIT2;P6OUT |= BIT2;      //关闭电平转换
     //定义液晶端口
    
    P4DIR = 0XFF;                     //数据口
    P4OUT = 0;
    //定义按键端口
    P1DIR =BIT6 + BIT7;               //设置P1.0~P.3为输入状态，P.7为输出
   
    
}
/*============================================
函数名称：Init_SysClk
功    能：初始化系统时钟
参    数：无       
返回值  ：无
==============================================*/

void Init_SysClk()
 {
 
  unsigned int i;
   
   BCSCTL1 &= ~XT2OFF;                       // XT2= HF XTAL

  do
  {
  IFG1 &= ~OFIFG;                           // Clear OSCFault flag
  for (i = 0xFF; i > 0; i--);               // Time for flag to set
  }
  while ((IFG1 & OFIFG));                   // OSCFault flag still set?

  BCSCTL2 |= SELM_2;                        // MCLK= XT2 (safe)，分频椅子为1
  BCSCTL2 |= SELS;                          //SMCLK的时钟源为TX2CLK，分频因子为1
  
 }

/*============================================
函数名称：Init_TimerB
功    能：初始化定时器B，设定基准时间500us
参    数：无       
返回值  ：无
==============================================*/
void  Init_TimerB()  
 {
    TBCTL |= TBSSEL1 +TBCLR; //MCLK ,8M
    TBCCTL0 = CCIE;
    TBCCR0 =4000;            //定时500us  
    TBCTL |= MC_1;           // Start Timer_B in up mode
 }

/*===========================================
函数名称：TimerB_ISR
功    能：设定时间间隔
参    数：无       
返回值  ：无
=============================================*/
// Timer B0 interrupt service routine
#pragma vector=TIMERB0_VECTOR
__interrupt void TimerB_ISR (void)
{
    static uchar Flag_500us = 0;  
    Flag_500us ++;
     if(Flag_500us  ==20)
     {
         Key_Flag =1;          //定时10ms
         Flag_500us=0;
        // TBCCTL0 = ~CCIE;    //关中断，单步调试时用，不然一直在中断里
       
       
     }   
         
}

//按键头文件 key.h

#ifndef MSP430_KEY_PROCESS_H
#define MSP430_KEY_PROCESS_H
/***************************************************
程序功能：用定时扫描方式读取6个行列式按键的键值
****************************************************/
#include
#include "lcd1602.h"

#define keyin (P1IN & 0x0F)

uchar KEY_BUFFER ;
uchar KEY_BUFFER1 ;

uchar KEY_DATA = 0x00;
uchar Num=0;
extern uchar Key_Flag; 
extern uchar Keyval;
extern uchar Respond_Key_Flag;
extern uchar Set_Confirm_Flag;

/*******************************************
函数名称：Delay10us
功    能：延时约10us
参    数：无
返回值  ：无
********************************************/
void Delay10us(void)
{ 
    uint i=10;
    while (i != 0)
    {
        i--;
    }
}
/*******************************************
函数名称：Key_Scan
功    能：扫描按键值
参    数：无
返回值  ：Keyval
********************************************/
uchar Key_Scan()
{      
       
       if(Key_Flag ==1 )            //10ms扫描一次
       {                  
         Key_Flag =0;                
        //位处理，先用一个字节把八位按键的值读出来，然后再进行判断 
         P1OUT =0X70;
         Delay10us();                 //给硬件响应时间
         KEY_BUFFER =keyin;
         KEY_BUFFER =~KEY_BUFFER;
         KEY_BUFFER1 =KEY_BUFFER<<4;
       
         P1OUT =0XB0;
         Delay10us();
         KEY_BUFFER =keyin;
         KEY_BUFFER =~KEY_BUFFER;
         KEY_BUFFER &=0X0F;           //屏蔽高四位
         KEY_BUFFER1 |=KEY_BUFFER ;  
         
         if(KEY_BUFFER1 != KEY_DATA)  //首先判断是否有键按下
         {
            KEY_DATA =KEY_BUFFER1;    //读键值
            Num =0;
         }
         else                    //KEY_BUFFER1 = KEY_DATA的处理
         {
                Num ++; 
                         
                if(Num==4)     //Num=4，读4次有效，延时达到40ms 
                {               
                  if(KEY_DATA==0x10)      //判断键值
                     Keyval=1;
                  else if(KEY_DATA==0x20)
                     Keyval=2;
                  else if(KEY_DATA==0x40)
                     Keyval=3;
                  else if(KEY_DATA==0x80)
                     Keyval=4;
                  else if(KEY_DATA==0x01)
                     Keyval=5;
                  else if(KEY_DATA==0x02)
                     Keyval=6;
                  else Keyval=0;
                  
                }
                else                          //  Num!=4 的处理      
                {
                          
                          
                          if( KEY_DATA == 0x00)      //按键放开，允许响应
                          {
                            Num=0;
                            Respond_Key_Flag =1;     //按键响应标志位                      
                          }
                          else                       //按键没放开，连续按
                          {
                                  
                              if((KEY_DATA == 0x10)&&(Num >=100)) //1s,判断是否为设置/确认键
                              {                                 
                                  Num =0;
                                  Set_Confirm_Flag =1;                                   
                                 
                              }
                             
                                  
                          }
                            
                  }
   
         }
         
       }
         
return Keyval;

}
#endif

  //液晶1602头文件 lcd1602.h

#ifndef MSP430_LCD1602_PROCESS_H
#define MSP430_LCD1602_PROCESS_H
//硬件连接    P4 数据口    P3.2---EN  P3.1---RW  P3.0----RS

#include"msp430x14x.h" 
typedef unsigned int uint;
typedef unsigned char uchar;
//定义MCU与LCD的接口
/**************宏定义***************/   
#define Busy     0x80
#define CtrlDir     P3DIR
#define CLR_RS P3OUT&=~BIT0    //RS = P3.0 
#define SET_RS P3OUT|=BIT0 
#define CLR_RW P3OUT&=~BIT1 //RW = P3.1
#define SET_RW P3OUT|=BIT1 
#define CLR_EN P3OUT&=~BIT2 //EN = P3.2 
#define SET_EN P3OUT|=BIT2  
/*******************************************
函数名称：Delay5ms
功    能：延时约5ms
参    数：无
返回值  ：无
********************************************/
void Delay5ms(void)
{ 
    uint i=40000;
    while (i != 0)
    {
        i--;
    }
}
/*******************************************
函数名称：WaitForEnable
功    能：等待1602液晶完成内部操作
参    数：无
返回值  ：无
********************************************/
void WaitForEnable(void) 
{
    P4DIR &= 0x00;  //将P4口切换为输入状态

    CLR_RS;
    SET_RW;
    _NOP();
    SET_EN; 
    _NOP();
    _NOP();
 
    while((P4IN & Busy)!=0);  //检测忙标志

    CLR_EN;

    P4DIR |= 0xFF;  //将P4口切换为输出状态
} 
/*******************************************
函数名称：write_cmd
功    能：向液晶模块写入命令
参    数：com--命令，         
返回值  ：无
********************************************/
void write_cmd(unsigned char com) 
{ 
    WaitForEnable();        //等待液晶不忙
    CLR_RS ;                //RS=0,RW=0,写指令
    CLR_RW;
    _NOP();
    P4OUT = com; 
    _NOP(); 
    SET_EN ;
    _NOP(); 
    _NOP();
    CLR_EN;
}

/*******************************************
函数名称：write_data
功    能：向液晶显示的当前地址写入显示数据
参    数：data--显示字符数据
返回值  ：无
********************************************/ 
void write_data(unsigned char data) 
{  
    WaitForEnable();        //等待液晶不忙
    SET_RS;                 //RS=1,RW=0，写数据
    CLR_RW;
    _NOP();
    P4OUT = data; 
    _NOP(); 
    SET_EN ;                //产生负脉冲
    _NOP(); 
    _NOP();  
    CLR_EN ;             
}

/*============================================
函数名称：Init_LCD
功    能：初始化液晶
参    数：无
返回值  ：无
==============================================*/
void Init_LCD() 
{ 
    CtrlDir |= 0x07;                 //控制线端口设为输出状态 
    P4DIR  = 0xFF;                   //数据端口设为输出状态
    
    write_cmd(0x38);                 //规定的复位操作
    Delay5ms();
    write_cmd(0x38);  
    Delay5ms();
    write_cmd(0x38);
    Delay5ms();
   
    write_cmd(0x38);//16×2显示，5×7点阵，8位数据接口  
    write_cmd(0x08);//关闭显示
    write_cmd(0x01);//清屏，数据指针=0，所有显示=0
    write_cmd(0x06);//读或写一个字符后地址指针加1 &光标加1，整屏显示不移动
    write_cmd(0x0c);//开显示， 关光标，光标所在位置的字符不闪烁    
     
}

/*******************************************
函数名称：LocateXY
功    能：向液晶写入显示字符位置的坐标信息
参    数：x--位置的列坐标
          y--位置的行坐标
返回值  ：无
********************************************/
void LocateXY(uchar x,uchar y) 
{
    uchar temp;

    temp = x&0x0f;
    y &= 0x01;
    if(y)   temp |= 0x40;  //如果在第2行
    temp |= 0x80;

    write_cmd(temp);
}
/*******************************************
函数名称：Disp1Char
功    能：在某个位置显示一个字符
参    数：x--位置的列坐标
          y--位置的行坐标
          data--显示的字符数据
返回值  ：无
********************************************/
void Disp1Char(uchar x,uchar y,uchar data) 
{
    LocateXY( x, y );   
    write_data( data );  
}

/***********************************************
函数名称：DispStr
功    能：让液晶从某个位置起连续显示一个字符串
参    数：x--位置的列坐标
          y--位置的行坐标
          ptr--指向字符串存放位置的指针
返回值  ：无
***********************************************/
void DispStr(uchar x,uchar y,uchar *ptr) 
{
    uchar *temp;
    uchar i,n = 0;
    
    temp = ptr;
    while(*ptr++ != '\0')   n++;    //计算字符串有效字符的个数
    
    for (i=0;i     {
        Disp1Char(x++,y,temp[i]);
        if (x == 0x0f)
        {
           x  = 0; 
           y ^= 1;
        }
    }
}

/*******************************************
函数名称：DispNchar
功    能：让液晶从某个位置起连续显示N个字符
参    数：x--位置的列坐标
          y--位置的行坐标
          n--字符个数
          ptr--指向字符存放位置的指针
返回值  ：无
********************************************/
void DispNChar(uchar x,uchar y, uchar n,uchar *ptr) 
{
    uchar i;
    
    for (i=0;i     {
        Disp1Char(x++,y,ptr[i]);
        if (x == 0x0f)
        {
           x = 0; 
        y ^= 1;
        }
    }
}

#endif

第一次写的在实际使用时，发现不是很稳定，后经过两三天的修改，最终定型为以上代码，完全可以使用。