第一课 序言《AI8051U的特点》

Yan***

接着我们搞把密码锁：

Yan***

密码锁就复杂很多

首先确定数码管扫描显示时间是1ms

static TASK_COMPONENTS Task_Comps[]=
{
//状态  计数  周期  函数
       
// {0, 300,   300,   LED0_Blink},      /* task 1 Period： 300ms */
// {0, 600,   600,   LED1_Blink},      /* task 1 Period： 600ms */
// {0, 900,   900,   LED2_Blink},      /* task 1 Period： 600ms */  
// {0, 10,    10,    KEY_Task},      /* task 1 Period： 600ms */  
       
        {0, 10,  10,     Task_1},      /* task 1 Period： 300ms */
        {0,  1,   1,     SEG_Task},      /* task 1 Period： 300ms */       
        {0, 10,  10,     PW_write_Task},
       
};

SEG_Task（）的执行间隔不能超过20ms,否则会闪烁的厉害

先建立密码数组：

u8 passward[8] = { 16,16,16,16,16,16,16,16 };

初始值是8个 “ - ”

上电初始显示8个横杠

u8 passward[8] = { 16,16,16,16,16,16,16,16 };

u8 Seg_no = 0;
void SEG_Task(void)
{
        u8 num = 0;
        if( Seg_no ==0 )                                                                //小时十位
        {
                Display_Seg( SEG_NUM[passward[0]] , ~T_NUM[0]);                //数码管刷段码和位码
        }
        else if( Seg_no ==1 )                                                        //小时的个位
        {
                Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                //数码管刷段码和位码
        }       
        else if( Seg_no ==2 )                                                        //第一个横杠
        {
                Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                //数码管刷段码和位码
        }       
        else if( Seg_no ==3 )                                                        //分钟的十位
        {
                Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                //数码管刷段码和位码
        }
        else if( Seg_no ==4 )
        {
                Display_Seg( SEG_NUM[passward[4]] , ~T_NUM[4]);                //数码管刷段码和位码
        }       
        else if( Seg_no ==5 )
        {
                Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                //数码管刷段码和位码
        }       
        else if( Seg_no ==6 )
        {
                Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);                //数码管刷段码和位码
        }
        else if( Seg_no ==7 )
        {
                Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                //数码管刷段码和位码
        }       
        else
        {
               
        }
        Seg_no ++;
        if( Seg_no>7 )
                Seg_no=0;
}

Yan***

接着我们写密码写入的一个函数：

u8 Key_Vol3 = 0;
u8 key_no =0 ;

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;        //不能有这句，否则第8位密码
                        //不管你输入什么，都变成了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;
        }
}

Yan***

当然，我们到底是按了矩阵键盘的哪个健

还是由任务一的void Task_1(void)负责检测

它是10ms 检测一次

static TASK_COMPONENTS Task_Comps[]=
{
//状态  计数  周期  函数
       
// {0, 300,   300,   LED0_Blink},      /* task 1 Period： 300ms */
// {0, 600,   600,   LED1_Blink},      /* task 1 Period： 600ms */
// {0, 900,   900,   LED2_Blink},      /* task 1 Period： 600ms */  
// {0, 10,    10,    KEY_Task},      /* task 1 Period： 600ms */  
       
        {0, 10,  10,     Task_1},      /* task 1 Period： 300ms */
        {0,  1,   1,     SEG_Task},      /* task 1 Period： 300ms */       
        {0, 10,  10,     PW_write_Task},
       
};

Yan***

这里是有点技巧的

先声明2个变量：

u8 Key_Vol3 = 0;
u8 key_no =0 ;

假如有按键按下：if( key_num <0xff )

Key_Vol3 ++;

第一次是0+1=1，一定小于5

10ms后转第二圈（        {0, 10,  10,     PW_write_Task},）

Key_Vol3 ++;

第二次是1+1=2，一定小于5

10ms后转第3圈（        {0, 10,  10,     PW_write_Task},）

Key_Vol3 ++;

第3次是2+1=3，一定小于5

10ms后转第4圈（        {0, 10,  10,     PW_write_Task},）

Key_Vol3 ++;

第4次是3+1=4，一定小于5

10ms后转第5圈（        {0, 10,  10,     PW_write_Task},）

Key_Vol3 ++;

第5次是4+1=5，一定=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 ++;

这样就采集到了输入的密码

Yan***

因为有8位密码

所以key_no ++;

一直到key_no =8 （输入到了第8位）：

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;
                       

Yan***

初学的时候，其实不是很好理解

窍门是把变量的值带进去，一圈一圈的跑

慢慢才能理解，千万不要以为冲哥很轻松的写出来

你一听就懂了，其实你不懂，不信你自己去写一下？

肯定是一写就废，就像高考物理一样一样的

因为只要你没有独立开发项目，不是专职工程技术人员，不需要天天写代码

那么哪怕是单片机的老师，也是记不住的，不熟练的，我们是理解理论

但调试读懂程序，是要积累经验的，不是说像AI那样，搜索文章汇总回答就可以

文科的文章可以交差，计算机的程序能不能跑起来都难说，更不要说调试，更改，正常运行

Yan***

最后的这句： key_no = 0;

是输入正确后

我们显示8个8（继电器通电，开门）后

我们要记得把密码清空！

当然先去io.h声明

#ifndef __IO_H
#define __IO_H

#include "config.h"                        //调用头文件

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

#define HC595_SER         P34
#define HC595_RCK         P35
#define HC595_SCK         P32

extern u8 key_num ;

void LED0_Blink(void);
void LED1_Blink(void);
void LED2_Blink(void);

void KEY_Task(void);
void Task_1(void);
void SEG_Task(void);
void Init_595(void);
void PW_write_Task(void);

#endif

Yan***

再去task.c里调用：

static TASK_COMPONENTS Task_Comps[]=
{
//状态  计数  周期  函数
       
// {0, 300,   300,   LED0_Blink},      /* task 1 Period： 300ms */
// {0, 600,   600,   LED1_Blink},      /* task 1 Period： 600ms */
// {0, 900,   900,   LED2_Blink},      /* task 1 Period： 600ms */  
// {0, 10,    10,    KEY_Task},      /* task 1 Period： 600ms */  
       
        {0, 10,  10,     Task_1},      /* task 1 Period： 300ms */
        {0,  1,   1,     SEG_Task},      /* task 1 Period： 300ms */       
        {0, 10,  10,     PW_write_Task},
       
};

3件事情： 1扫描矩阵键盘，得到按键值  2 根据按键值存入密码数组  3 循环显示数码管

Yan***

要注意数码管刷新频率

好了，编译连接下载：