第一次：环境的创立 | 送实验箱

wuzhe***

第十一集  《矩阵按键》

那么像这种矩阵式的按键, 它和独立按键的区别就是它的端可是可以复用的,

可以看到这里有8个按键, 如果说按照独立按键的接法, 他是不是应该接在8个10口上？但是这里可以看到他只有6个，是不是能发现他横着4个，接在一个脚上。

这里两行占了两个竖的一列，竖的1列接在了一个引脚上，对不对这里有4列，所以有4个端口，他总共用了6个端口，他就可以实现我们8个按键。如果是16个按键，他是不是只要4列加4行都可以？这种就是一个矩阵按键。

wuzhe***

最大的好处在哪里呢？就是它可以用有限的端口，去实现我们更多的按键。

这个按键检测，会比这个独立按键比较慢，因为独立按键他单个端口就检测一个引脚对不对，那么这里的话他要反复的去扫描。先一列一列的扫过去，然后再一行一行的扫过去。好那我们来看一下这个原理这个矩阵按键的原理是什么呢？

按键识别原理：端口默认为高电平，实时读取到引脚为低电平是表示按下。

①  第一步：现将P0.0-P0.3输出低电平，P0.6-P0.7输出高电平，如果有按键按下，按下的那一行的10就会变成低电平，就可以判断出哪一行按下了。

②  第二步：现将P0.0-P0.3输出高电平，P0.6-P0.7输出低电平，如果有按键按下，按下的那一列的10就会变成低电平，就可以判断出哪一列按下了。

③  第三步：行列组合一下就可以判断出是哪个按键按下了。

wuzhe***

核心扫描代码如下：

/*
        #define ROW1        P06                        //端口定义
        #define ROW2        P07
        #define COL1        P00
        #define COL2        P01
        #define COL3        P02
        #define COL4        P03
*/

u8 key_num = 0xff;

//任务1：数码管显示当前的按键号
void Task_1(void)
{
        //①第一步：现将P0.0-P0.3输出低电平，P0.6-P0.7输出高电平，如果有按键按下，按下的那一行的IO就会变成低电平，就可以判断出哪一行按下了。
        COL1 = 0;
        COL2 = 0;
        COL3 = 0;
        COL4 = 0;
        ROW1 = 1;
        ROW2 = 1;
        
        if(( ROW1 == 0 ) || ( ROW2 == 0 ))                //如果行按键有按下
        {
                if(( ROW1 ==0 ) && ( ROW2 ==0 ))        //如果两行都有按键按下，不处理
                {
                        
                }
                else if((( ROW1 ==1 )&&( ROW2 ==0 )) || (( ROW1 ==0 )&&( ROW2 ==1 )))        //如果有按键按下，而且只有一颗
                {
                        if( ROW1 ==0 )                                //判断哪一行，输出行开始的序号
                                key_num = 0;
                        else if( ROW2 ==0 )
                                key_num = 4;
                                
                        //②第二步：现将P0.0-P0.3输出高电平，P0.6-P0.7输出低电平，如果有按键按下，按下的那一列的IO就会变成低电平，就可以判断出哪一列按下了。
                        COL1 = 1;
                        COL2 = 1;
                        COL3 = 1;
                        COL4 = 1;
                        ROW1 = 0;
                        ROW2 = 0;
                        
                        if( COL1 ==0 )                                //判断哪一列，叠加按键的序号
                        {
//                                key_num = key_num ;
                        }
                        else if( COL2 ==0 )
                        {
                                key_num = key_num + 1;
                        }
                        else if( COL3 ==0 )
                        {
                                key_num = key_num + 2;
                        }
                        else if( COL4 ==0 )
                        {
                                key_num = key_num + 3;
                        }
                }
                COL1 = 0;
                COL2 = 0;
                COL3 = 0;
                COL4 = 0;
                ROW1 = 1;
                ROW2 = 1;                
        }
        else
        {
                key_num = 0xff;
        }
        
        //③第三步：行列组合一下就可以判断出是哪个按键按下了。

}

复制代码

wuzhe***

实际上，虽然跟着冲哥听就觉得还可以理解，但是要自己独立的完成
任务二密码锁，还是相当困难的：

void PW_write_Task(void)
{
        if( key_num <0xff )
        {
                Key_Vol3 ++;
                if( Key_Vol3 == 5 )
                {
                        if( key_no == 0 )
                        {
                                passward[0] = 16;
                                passward[1] = 16;
                                passward[2] = 16;
                                passward[3] = 16;
                                passward[4] = 16;
                                passward[5] = 16;
                                passward[6] = 16;
                                passward[7] = 16;                        
                        }                                
                        passward[ key_no] = key_num ; 
                        key_no ++;
//                        passward[7] = 17;        
                        if( key_no == 8 )                //密码输入到了八位
                        {
                                if((passward[0]==0) && (passward[1]==1) && (passward[2]==2) && (passward[3]==3) && (passward[4]==4) && (passward[5]==5) && (passward[6]==6) &&(passward[7]==7) )  
                                {
//                                        passward[0] = 17;
//                                        passward[1] = 17;
//                                        passward[2] = 17;
//                                        passward[3] = 17;
//                                        passward[4] = 17;
//                                        passward[5] = 17;
//                                        passward[6] = 17;
//                                        passward[7] = 17;        


                                        passward[0] = 8;  //密码对，显示8个8
                    passward[1] = 8;
                    passward[2] = 8;
                    passward[3] = 8;
                    passward[4] = 8;
                    passward[5] = 8;
                    passward[6] = 8;
                    passward[7] = 8;
                                        
                                }
                                else
                                {
//                                        passward[0] = 16;  
//                                        passward[1] = 16;
//                                        passward[2] = 16;
//                                        passward[3] = 16;
//                                        passward[4] = 16;
//                                        passward[5] = 16;
//                                        passward[6] = 16;
//                                        passward[7] = 16;        

                                        passward[0] = 14;   //密码错，显示8个E
                    passward[1] = 14;
                                        passward[2] = 14;
                                        passward[3] = 14;
                                    passward[4] = 14;
                                    passward[5] = 14;
                                    passward[6] = 14;
                                    passward[7] = 14;
                                
                                
                                
                                }   
                                key_no = 0;
                        }       
                }           
        }               
        else
        {
                Key_Vol3 = 0;
        }
}
复制代码

这部分代码和键盘扫描，其实逻辑很严密，自己估计搞不掂........

wuzhe***

第十二集： 系统复位：

任务1：编写看门狗程序

void main(void)
{
        Sys_init();                                                                                //系统初始化
        usb_init();                                     //USB CDC 接口配置

    IE2 |= 0x80;                                    //使能USB中断
        Timer0_Init();                                                                        //定时器初始化
        Init_595();
    EA = 1;                                                                                        //IE |= 0X80;
        
        P40 = 0;
        
        while (DeviceState != DEVSTATE_CONFIGURED);     //等待USB完成配置
        WDT_CONTR = 0X24;  //启动看门狗---0.5s溢出
        
        while(1)
        {
                
        if (bUsbOutReady)                                                        //如果接收到了数据
        {
            //USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
                        
            usb_OUT_done();                                                        //
        }
                Task_Pro_Handler_Callback();                                //执行功能函数

                if( P33 !=0 ) //人为加条件，按住P33超过0.5秒就复位！
//按键P33按下超过0.5秒系统就会复位，因为在0.5秒内没有喂狗                        
                WDT_CONTR = 0X34; //喂狗清看门狗，否则系统复位
        }
}
复制代码

wuzhe***

二、软件复位：

9.1.2 IAP 控制寄存器（IAP_CONTR）

关键函数：

void KEY_Task(void)
{
        if( P33 == 0 )
        {
                Key_Vol++;
                if( Key_Vol==5 )
                {
                        //按键按下的任务
//                        printf( "按键单击\r\n" );
                        
                        USB_Reset_U();      //USB复位

                        //IAP_CONTR = 0X60;  //前提是先执行USB的复位
                        
                        IAP_CONTR = 0X20;  //软件复位，前提是先执行USB的复位
                        
                                        }
        }
        else
        {
                Key_Vol = 0;
        }
        
}
复制代码

wuzhe***

13.外部中断

第十三集 外部中断   摘要

1.中断系统介绍

2.外部中断介绍

3.外部中断用法

wuzhe***

每一个中断源可以用软件独立地控制为开中断或关中断

例子程序也好理解：

//测试工作频率为11.0592MH：
#include“Ai8051U.H”  //头文件见下载软件
#include"intrins.h"    //使用_nop_（函数所必须要包含的头文件，
//否则延时函数中调用的_nop_0函数没有被头文件引用过来，会导致编译器找不//到这个而函数而报错。

Void  INT0_Isr（） interrupt 0
{
if(P32)  / /判断上升沿和下降沿
{
P10=！P10;   //测试端口
}
else
{
P11=！P11; //测试端口
}
}
void main()
{
EAXFR=1;//允许访问扩展的特殊寄存器•XFR
//（32位模式请使用这句•注释下一句）
//P_SW2|=0x80; //（8 位模式请使用这句•注释上一句）
          //允许访问扩展的特殊寄存器•XFR

WTST=0;    //设置取程序代码等待时间
             //赋值为 0 表示不等待•程序以最快速度运行
CKCON=0;   //设置访问片内的xdata速度.
//赋值为 0 表示用最快速度访问•不增加额外的等待时间
P0M0= 0x00;
P0M1=0x00;
P1M0=0x00;
P1M1=0x00;
P2M0=0x00;
P2M1=0x00;
P3M0=0x00;
P3M1=0x00;
P4M0=0x00;
P4M1=0x00;
P5M0=0x00;
P5M1=0x00;
IT0=0;   //使能 INT0 上升沿和下降沿中断
EX0= 1;  //使能 INTO 中断
EA=1;
while（1）;
}
复制代码

很简单，好理解吧？

wuzhe***

什么引脚能作为外部中断口？

引脚带INTx标识的！！！

其实只有4个脚可以外部中断P32 INT0  、P33INT1、P36INT2、P37INT3

wuzhe***

设置外部中断，很简单，只需3步：

        ① IT0 = 1;                       //下降沿中断,0是上升沿和下降沿都可以

                //外部中断0：IT0可以置0，也可以置1

                      IE0  //是中断标志，如果INT0触发了，这个标志位置1

                            //当然标志位置1是硬件自动的。

②EX0 = 1; //打开中断允许，允许往后走

③EA = 1;                                  //打开总中断，执行中断

接着配置中断函数：

Void  INT0_Isr（） interrupt 0  //INT0中断（上升沿和下降沿），可同时支持上升沿和下降沿

{

if(P32)  / /判断上升沿和下降沿

{

P10=!P10;   //测试端口

}

else

{

P11=!P11; //测试端口

}

}