机缘巧合，跟AI8051U握个手

cored***

第九课： 数码管

1. 数码管的类型

根据管脚的接法，可分为两种， 共阳极 和 共阴极。

2. 段码和位码

段码： 一个“8”字，刚好由 a、b、c、d、e、f、g、dp 8个段构成，8个段的排列组合，构成不同含义的外观，这些排列组合由一个16进制的数标识，就是段码；
位码：共极数码管上有多个“8”字，例如实验箱上有8个“8”字，第n个“8”的位置，用一个16进制的数表示，就是位码。


两个码的数据，就可以向数码管发送指令，点亮那个位置、什么形状的灯。

3. 原理图

数码管由两个74HC595芯片共同实现控制。一个控制“段”，一个控制“位”。


4. 取段码的原理

实验箱是共阴极的设计，需要点亮的管脚为 0 ， 不需要点亮的管脚为 1， 由下往上排序，就得到8位二进制码，转为16进制数就是段码。

5. 取位码的原理

根据第一个74CH595芯片管脚与com口对应的序号，将序号转为16进制，就是位码。

6. 数码管的数据发送“接口”

（1）移位寄存器

    通过74CH595发送数据，移位寄存器扮演着重要的角色。它是AI8051U的能力之一，具体可参考手册 12.2.3 程序状态寄存器。CY 是进位标志。段码和位码数据的发送，就是通过位操作，将数据送出去。
    发送段码和位码的方法

void Send595(unsigned char dat)
{
        unsigned char i;
        for(i=0; i < 8; i++)
        {
                dat <<= 1;                // 左边1位移入 CY
                HC595_SER = CY;
                HC595_SCK = 1;
                HC595_SCK = 0;
        }
}
复制代码

   最后的 HC595_SCK 切换高低电平操作，是所谓的“发送上升沿”。
    发送段码和位码后，还要发送一次“上升沿”，才能点亮数码管。发送方法：

void DisplaySeg(unsigned char segCode, unsigned char posCode)
{
        Send595(segCode);
        Send595(posCode);
        HC595_RCK = 1;
        HC595_RCK = 0;
}
复制代码

   注意，发送段码和位码，使用 P32（HC595_SCK）发送，最后点亮数码管，使用 P35（HC595_RCK）发送。

    （这里的控制方法与江协科技的STC89C52有很大不同，STC89C52控制数码管的方式与LED类似，仅需注意段码、位码取码的方式）
    江协科技基于89C52芯片的实验版，静态显示数码管的方法（供对照参考，没有发送“上升沿”操作）

// 静态显示数码管
// @param unsigned char pos 位码索引，取值范围 1 - 8
// @param unsigned char num 段码索引，取值范围 0 - 16
void Nixie(unsigned char pos, num){
        // 位码
        // P2_4 , P2_3, P2_2 构成 3 位二进制数，指向数码管特定的“位”
        switch(pos){
                case 1: P2_4 = 1; P2_3 = 1; P2_2 = 1;break;
                case 2: P2_4 = 1; P2_3 = 1; P2_2 = 0;break;
                case 3: P2_4 = 1; P2_3 = 0; P2_2 = 1;break;
                case 4: P2_4 = 1; P2_3 = 0; P2_2 = 0;break;
                case 5: P2_4 = 0; P2_3 = 1; P2_2 = 1;break;
                case 6: P2_4 = 0; P2_3 = 1; P2_2 = 0;break;
                case 7: P2_4 = 0; P2_3 = 0; P2_2 = 1;break;
                case 8: P2_4 = 0; P2_3 = 0; P2_2 = 0;break;
        }
        
        // 段码赋值
        P0 = digit[num];
}
复制代码

7. 数码管的静态显示和动态显示。

由于数码管的8个数字，阴极的管脚都是接通的，同一时间，只能发送一个段码+位码，只能显示一个 管位 。 这是静态显示。
利用人眼影像暂留原理，在极短的时间内进行循环切换，可以显示多个 管位 ，这是动态显示。这跟老式的电影播放机的原理相同，只要频率大于24HZ，人眼就觉察不到闪烁。

8. ISP 段码生成工具

ISP 提供了字库生成工具，其中就包括了段码生成功能。可根据数码段的排列组合，自动生成16进制段码。

9. ISP 的虚拟外设

ISP提供了部分虚拟的外设，通过配置后，可接入擎天柱灯简化的实验板，模拟真实硬件的运行情况。例如LED-DIP40、数码管等，同时提供了使用接口说明。

10. 作业：免单计数器。（待补充）

神***

2025/12/21：
可以申请实验箱了，等实验箱的同时，可以实战 USB ！



永远用最新版 软件

深圳国芯人工智能有限公司-工具软件

cored***

第九课 数码管作业： 10秒免单挑战器


设计目标：

前面 4 位，静态显示 10.00 作为挑战目标

后面 4 位，默认静态显示 00.00
按下 P33 按钮后，开始显示计时器，前面2位显示单位秒，后面两位分别显示百毫秒、十毫秒
当计时器到达 99.99 秒后，计时器归零。
在计时期间，按下 P33 按钮，可暂停计时，时间以1HZ的频率，闪烁显示按下时刻的值。
当计时暂停时，按下 P33 按钮，计时器归零，并且停止闪烁。
当再次按下 P33 按钮时，重新开始计时。


实现的过程，遇到了一些问题

1. P32 按钮作为 usb 中断，使用 P32 按钮作为挑战按钮，会导致程序出现 BUG
2. 模块化代码设计，固然可以让逻辑更为清晰，同时也带来代码分享的障碍
3. C语言的数组长度，与高级语言的数组长度计算有很大差异。 使用 sizeof 计算数组占用字节总长度和单个元素长度，从而计算数组元素个数，这是C语言的经典做法。
4. 使用定时器实现无阻塞中断非常好，但是也带来了程序的复杂度，尤其是在嵌套使用时。
5. 设计程序时，要牢牢把握住， 定时器回调函数，用于周期性更新， main 函数中的 while 循环，用于即时获取更新后的结果。

下面是运行结果及源代码

#include "ai8051u.h"                        //调用头文件
#include "stc32_stc8_usb.h"                //调用头文件
#include "stdlib.h"

//注意：擎天柱的LED端口在P2，且没有三极管的电源控制，所以只要控制P2端口即可，本节课程的其余内容（USB不停电下载）均通用！
char* USER_DEVICEDESC = NULL;
char* USER_PRODUCTDESC = NULL;
char* USER_STCISPCMD = "@STCISP#";

/* ----------------------------- config module ----------------------------- */

void Timer0_Init(void);                //1毫秒@24.000MHz

void Delay(unsigned int ms);        //@24.000MHz

void sys_init(void);                // 初始化

void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}

void Delay(unsigned int ms)        //@24.000MHz
{
        unsigned char data i, j;

        while(ms--)
        {
                i = 24;
                j = 85;
                do
                {
                        while(--j);
                }
                while(--i);
        }
}

void sys_init(void)
{
        
        //P_SW2 |= 0x80;                //B7位写1，使能访问XFR  等同于  EAFXR = 1;
        WTST = 0;
        EAXFR = 1;
        CKCON = 0;

        P0M1 = 0x00;
        P0M0 = 0x00;
        P1M1 = 0x00;
        P1M0 = 0x00;
        P2M1 = 0x00;
        P2M0 = 0x00;
        P3M1 = 0x00;
        P3M0 = 0x00;
        P4M1 = 0x00;
        P4M0 = 0x00;
        P5M1 = 0x00;
        P5M0 = 0x00;
        P6M1 = 0x00;
        P6M0 = 0x00;
        P7M1 = 0x00;
        P7M0 = 0x00;

        usb_init();                                     //USB CDC 接口配置

        IE2 |= 0x80;                                    //使能USB中断
        EA = 1;                                                                                        //IE |= 0X80;

        while(DeviceState != DEVSTATE_CONFIGURED);      //等待USB完成配置        
        
}

/* -----------------------------END config module END----------------------------- */

/* ----------------------------- BEGIN button module BEGIN ----------------------------- */

// 按钮状态
typedef enum
{
        KEY_STATE_IDLE,
        KEY_STATE_PRESS,
        KEY_STATE_CONFIRM,
        KEY_STATE_RELEASE
} KeyState;

// 按钮结构体
typedef struct
{
        unsigned char pin;          // 按钮引脚电压 0 / 1
        KeyState state;
        unsigned int debounce_cnt;
        unsigned char press_flag;
        unsigned char change_flag;
} KeyStruct;


// 每毫秒扫描一次按钮状态变化
// 找到遵循<抖动、按下、抖动、稳定>物理规律的按钮状态改变
void KeyScan(KeyStruct* key, unsigned char current_pin);

// 检查按键事件
unsigned char Key_GetEvent(KeyStruct* key);

// 每毫秒扫描一次按钮状态变化
// 找到遵循<抖动、按下、抖动、稳定>物理规律的按钮状态改变
void KeyScan(KeyStruct* key, unsigned char current_pin)
{
        switch(key->state)
        {
                case KEY_STATE_IDLE:
                        if(current_pin == 0)                                 // 检测到按钮按下动作
                        {
                                key->state = KEY_STATE_PRESS;
                                key->debounce_cnt = 0;
                        }
                        break;
                case KEY_STATE_PRESS:
                        key->debounce_cnt++;
                        if(key->debounce_cnt >= 20)
                        {
                                if(current_pin == 0)                         // 确实被按下，已停止抖动
                                {
                                        key->state = KEY_STATE_CONFIRM;
                                        key->press_flag = 1;
                                        key->change_flag = 1;
                                }
                                else                                                         // 是抖动，按钮弹回原位
                                {
                                        key->state = KEY_STATE_IDLE;
                                }
                                key->debounce_cnt = 0;                         // 不管是哪种情况， 消抖计数都归零
                        }
                        break;
                case KEY_STATE_CONFIRM:
                        if(current_pin == 1)                                 // 检测到按钮释放
                        {
                                key->state = KEY_STATE_RELEASE;
                                key->debounce_cnt = 0;
                        }
                        break;
                case KEY_STATE_RELEASE:
                        key->debounce_cnt++;
                        if(key->debounce_cnt >= 20)                 // 20ms 释放消抖
                        {
                                if(current_pin == 1)                         // 确认按钮释放
                                {
                                        key->state = KEY_STATE_IDLE;
                                        key->press_flag = 0;
                                }
                                else
                                {
                                        key->state = KEY_STATE_CONFIRM;                // 按钮弹回
                                }
                                key->debounce_cnt = 0;
                        }
                        break;
        }
}

// 检查按键事件
unsigned char Key_GetEvent(KeyStruct* key)
{        
        if(key->change_flag)
        {
                key->change_flag = 0;                // 有按键事件
                return 1;
        }
        return 0;                                                // 无按键事件
}        
        

/* ----------------------------- END button module END ----------------------------- */

/* ----------------------------- BEGIN nixie module BEGIN ----------------------------- */

// 定义 595 引脚
#define HC595_SER P34
#define HC595_RCK P35
#define HC595_SCK P32

// 10秒状态
typedef enum 
{
        DS_STOP = 0,
        DS_RUN = 1,
        DS_CLEAN_STOP = 2,
} DigitState;

// 灯管模块
typedef struct
{
        unsigned int tms;                // 灯管数值, 取值范围 0 - 9999
        DigitState state;                // 灯光状态
        
} LightModule;

// 灯管模块
LightModule digitLights = { 0, DS_STOP };
        
void Init595(void);
void Send595(unsigned char dat);
void DisplaySeg(unsigned char segCode, unsigned char posCode);

void targetLights(void);
void DisplayDigitLights(void);

// 段码
unsigned char segNum[] = 
{
        0x3F,       /*'0', 0*/
        0x06,       /*'1', 1*/
        0x5B,       /*'2', 2*/
        0x4F,       /*'3', 3*/
        0x66,       /*'4', 4*/
        0x6D,       /*'5', 5*/
        0x7D,       /*'6', 6*/
        0x07,       /*'7', 7*/
        0x7F,       /*'8', 8*/
        0x6F,       /*'9', 9*/
        0x77,       /*'A', 10*/
        0x7C,       /*'B', 11*/
        0x39,       /*'C', 12*/
        0x5E,       /*'D', 13*/
        0x79,       /*'E', 14*/
        0x71,       /*'F', 15*/
        0x40,       /*'-', 16*/
        0x00,       /*' ', 17*/
        0x80,       /*'.', 18*/
        0x78,       /*'T', 19*/
        0xBF,       /*'0', 20*/
    0x86,       /*'1', 21*/
    0xDB,       /*'2', 22*/
    0xCF,       /*'3', 23*/
    0xE6,       /*'4', 24*/
    0xED,       /*'5', 25*/
    0xFD,       /*'6', 26*/
    0x87,       /*'7', 27*/
    0xFF,       /*'8', 28*/
    0xEF,       /*'9', 29*/
        
};

// 位码 0000 0001, 0000 0010, 0000 0100 ... 为方便赋值，使用了相反的二进制，使用时需要取反
unsigned char posNum[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};        

void Init595(void)
{
        HC595_SER = 0; 
        HC595_RCK = 0; 
        HC595_SCK = 0; 
}

void Send595(unsigned char dat)
{
        unsigned char i;
        for(i=0; i < 8; i++)
        {
                dat <<= 1;                // 左边1位移入 CY
                HC595_SER = CY;
                HC595_SCK = 1;
                HC595_SCK = 0;
        }
}

void DisplaySeg(unsigned char segCode, unsigned char posCode)
{
        Send595(segCode);
        Send595(posCode);
        HC595_RCK = 1;
        HC595_RCK = 0;
}

void targetLights(void)
{
        DisplaySeg(segNum[1], ~posNum[0]);
        Delay(1);
        DisplaySeg(segNum[20], ~posNum[1]);
        Delay(1);
        DisplaySeg(segNum[0], ~posNum[2]);
        Delay(1);
        DisplaySeg(segNum[0], ~posNum[3]);
        Delay(1);
}

// 10秒挑战 程序逻辑
// 后面 4 位，默认静态显示 00.00
// 按下 P32 按钮后，开始显示计时器，前面2位显示单位秒，后面两位分别显示百毫秒、十毫秒
// 当计时器到达 99.99 秒后，计时器归零。
// 在计时期间，按下 P32 按钮，可暂停计时，时间以1HZ的频率，闪烁显示按下时刻的值。
// 当计时暂停时，按下 P32 按钮，计时器归零，并且停止闪烁。
// 当再次按下 P32 按钮时，重新开始计时。

void DisplayDigitLights(void)
{
        unsigned char digit_1 = 0;
        unsigned char digit_2 = 0;
        unsigned char digit_3 = 0;
        unsigned char digit_4 = 0;        
        digit_1 = digitLights.tms / 1000;
        digit_2 = (digitLights.tms % 1000) / 100;
        digit_3 = (digitLights.tms % 100) / 10;
        digit_4 = digitLights.tms % 10;
        DisplaySeg(segNum[digit_1], ~posNum[4]);
        Delay(1);
        DisplaySeg(segNum[digit_2 + 20], ~posNum[5]);
        Delay(1);
        DisplaySeg(segNum[digit_3], ~posNum[6]);
        Delay(1);
        DisplaySeg(segNum[digit_4], ~posNum[7]);
        Delay(1);
}

// 刷新灯管计时器
void freshDigitLight(void)
{
        switch((&digitLights)->state)
        {
                case DS_STOP:                                // 灯管处于准备状态
                        if( (&digitLights)->tms > 0 )
                        {
                                (&digitLights)->tms = 0;
                        }
                        break;
                case DS_RUN:                                // 灯管处于运行状态, 计时器自增
                        if( (&digitLights)->tms < 9999 )
                        {
                                (&digitLights)->tms++;
                        }
                        else
                        {
                                (&digitLights)->tms = 0;
                        }
                        break;
                case DS_CLEAN_STOP:                        // 灯管处于展示结果状态
                        break;
        }
}

/* ----------------------------- END nixie module END ----------------------------- */


/* ----------------------------- BEGIN  task module BEGIN ----------------------------- */
// 任务对象
typedef struct 
{
        unsigned char run_state;                        //         执行状态
        int timer;                        //  倒计时
        int cycle_length;                        //  执行周期
        void (*TaskHook)(void);                // 任务回调函数        
} TASK_COMPONENT;

void timer_callback(void);
void task_callback(void);

// 静态任务数组
// 编译前已确定数组长度
static TASK_COMPONENT tasks[] = 
{
        {0, 10, 10, freshDigitLight }
};

// 任务数组长度
unsigned int tasks_length = sizeof(tasks) / sizeof(tasks[0]);

// 定时器回调函数
// 定时触发 run_state
void timer_callback(void)
{
        unsigned int i = 0;
        for(i = 0; i < tasks_length; i++)
        {
                
                if(tasks[i].timer == 0 && tasks[i].run_state == 0){
                        tasks[i].timer = tasks[i].cycle_length;
                }
                
                if(tasks[i].timer > 0)
                {
                        tasks[i].timer--;
                        if(tasks[i].timer == 0)
                        {
                                tasks[i].timer = tasks[i].cycle_length;
                                tasks[i].run_state = 1;
                        }
                }
        }
}

// 任务处理回调函数
// 定时执行任务
void task_callback(void)
{
        
        unsigned int i = 0;
        for(i = 0; i < tasks_length; i++)
        {
                if(tasks[i].run_state == 1)
                {
                        tasks[i].run_state = 0;
                        tasks[i].TaskHook();
                }
        }
        
}

/* ----------------------------- END task module END ----------------------------- */

// 按钮
KeyStruct key33 = {1, KEY_STATE_IDLE, 0, 0, 0};

void main(void)
{
        sys_init();
        Timer0_Init();
        
        Init595();
        
        while(1)
        {
                
                task_callback();
                
                // 如果按钮被按下
                if(Key_GetEvent(&key33))
                {
                        switch ( (&digitLights)->state )
                        {
                                case DS_STOP:
                                        (&digitLights)->state = DS_RUN;                                // 开始计时
                                        break;
                                case DS_RUN:
                                        (&digitLights)->state = DS_CLEAN_STOP;                // 停止计时
                                        break;
                                case DS_CLEAN_STOP:
                                        (&digitLights)->state = DS_STOP;                                // 清理计时结果
                                        break;
                        }
                }
                
                // 显示挑战目标 10.00 秒
                targetLights();
                
                // 显示挑战结果，挑战前、挑战中、结果
                DisplayDigitLights();
                
                if(bUsbOutReady)
                {
                        //USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
                        
                        usb_OUT_done();
                }

        }
}

// 定时器中断回调函数
void Timer0_Isr(void) interrupt 1
{
        timer_callback();
        KeyScan(&key33, P33);
}
复制代码

如果无法播放，请点击此处在新窗口打开

cored***

第九课 数码管 仿真接口

使用仿真接口的方法：

1. 打开 ISP 工具，打开菜单 “调试仿真接口” -- “接口设置”， 设置为“将所有调试接口绑定到 USB-CDC / 串口助手”

2. 打开 “CDC/HID-串口助手” ， 选择串口与左侧的“扫描串口”选项一致（我这里是 com4 USB-CDC），然后“打开串口”

3. 再打开“调试仿真接口” - “擎天柱 - LED - DIP40” 。

在打开仿真接口时走了一些弯路。

1. 每个人的电脑打开的 com 口数量、序号是不同的。想我开发用的电脑， 实际使用的是 com4 ，并且只有一个。实际应用中，只要打开的com口与左侧使用的com口一致就行。（教学视频中有多个，让我以为可能存在多个）

2. 物理的 LED 灯，开启只要在 main 函数中打开 1 次就能点亮。 仿真接口的不可以， 我猜测是当main函数调用时， 仿真接口还没有就绪，因此做了个实验，在 main 函数中，放在 while(1) 循环之前，先 Delay（1000），再调用 PLED_40()， 就可以点亮了。这对初学者的我造成了一段时间的困惑，以为仿真接口没有正常工作。

代码片段

void main(void)
{
        sys_init();
        Timer0_Init();
        
        Init595();
        
// 延迟 1 秒， 等待仿真接口加载完毕，再发送接口数据。
        Delay(1000);
        PLED_40();
        
        while(1)
        {}
复制代码

验证视频

如果无法播放，请点击此处在新窗口打开

源码

#include "ai8051u.h"                        //调用头文件
#include "stc32_stc8_usb.h"                //调用头文件
#include "stdlib.h"

//注意：擎天柱的LED端口在P2，且没有三极管的电源控制，所以只要控制P2端口即可，本节课程的其余内容（USB不停电下载）均通用！
char* USER_DEVICEDESC = NULL;
char* USER_PRODUCTDESC = NULL;
char* USER_STCISPCMD = "@STCISP#";

/* ----------------------------- config module ----------------------------- */

void Timer0_Init(void);                //1毫秒@24.000MHz

void Delay(unsigned int ms);        //@24.000MHz

void sys_init(void);                // 初始化

void Timer0_Init(void)                //1毫秒@24.000MHz
{
        TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )
        AUXR &= 0x7F;                        //定时器时钟12T模式
        TMOD &= 0xF0;                        //设置定时器模式
        TL0 = 0x30;                                //设置定时初始值
        TH0 = 0xF8;                                //设置定时初始值
        TF0 = 0;                                //清除TF0标志
        TR0 = 1;                                //定时器0开始计时
        ET0 = 1;                                //使能定时器0中断
}

void Delay(unsigned int ms)        //@24.000MHz
{
        unsigned char data i, j;

        while(ms--)
        {
                i = 24;
                j = 85;
                do
                {
                        while(--j);
                }
                while(--i);
        }
}

void sys_init(void)
{
        
        //P_SW2 |= 0x80;                //B7位写1，使能访问XFR  等同于  EAFXR = 1;
        WTST = 0;
        EAXFR = 1;
        CKCON = 0;

        P0M1 = 0x00;
        P0M0 = 0x00;
        P1M1 = 0x00;
        P1M0 = 0x00;
        P2M1 = 0x00;
        P2M0 = 0x00;
        P3M1 = 0x00;
        P3M0 = 0x00;
        P4M1 = 0x00;
        P4M0 = 0x00;
        P5M1 = 0x00;
        P5M0 = 0x00;
        P6M1 = 0x00;
        P6M0 = 0x00;
        P7M1 = 0x00;
        P7M0 = 0x00;

        usb_init();                                     //USB CDC 接口配置

        IE2 |= 0x80;                                    //使能USB中断
        EA = 1;                                                                                        //IE |= 0X80;

        while(DeviceState != DEVSTATE_CONFIGURED);      //等待USB完成配置        
        
}

/* -----------------------------END config module END----------------------------- */

/* ----------------------------- BEGIN button module BEGIN ----------------------------- */

// 按钮状态
typedef enum
{
        KEY_STATE_IDLE,
        KEY_STATE_PRESS,
        KEY_STATE_CONFIRM,
        KEY_STATE_RELEASE
} KeyState;

// 按钮结构体
typedef struct
{
        unsigned char pin;          // 按钮引脚电压 0 / 1
        KeyState state;
        unsigned int debounce_cnt;
        unsigned char press_flag;
        unsigned char change_flag;
} KeyStruct;


// 每毫秒扫描一次按钮状态变化
// 找到遵循<抖动、按下、抖动、稳定>物理规律的按钮状态改变
void KeyScan(KeyStruct* key, unsigned char current_pin);

// 检查按键事件
unsigned char Key_GetEvent(KeyStruct* key);

// 每毫秒扫描一次按钮状态变化
// 找到遵循<抖动、按下、抖动、稳定>物理规律的按钮状态改变
void KeyScan(KeyStruct* key, unsigned char current_pin)
{
        switch(key->state)
        {
                case KEY_STATE_IDLE:
                        if(current_pin == 0)                                 // 检测到按钮按下动作
                        {
                                key->state = KEY_STATE_PRESS;
                                key->debounce_cnt = 0;
                        }
                        break;
                case KEY_STATE_PRESS:
                        key->debounce_cnt++;
                        if(key->debounce_cnt >= 20)
                        {
                                if(current_pin == 0)                         // 确实被按下，已停止抖动
                                {
                                        key->state = KEY_STATE_CONFIRM;
                                        key->press_flag = 1;
                                        key->change_flag = 1;
                                }
                                else                                                         // 是抖动，按钮弹回原位
                                {
                                        key->state = KEY_STATE_IDLE;
                                }
                                key->debounce_cnt = 0;                         // 不管是哪种情况， 消抖计数都归零
                        }
                        break;
                case KEY_STATE_CONFIRM:
                        if(current_pin == 1)                                 // 检测到按钮释放
                        {
                                key->state = KEY_STATE_RELEASE;
                                key->debounce_cnt = 0;
                        }
                        break;
                case KEY_STATE_RELEASE:
                        key->debounce_cnt++;
                        if(key->debounce_cnt >= 20)                 // 20ms 释放消抖
                        {
                                if(current_pin == 1)                         // 确认按钮释放
                                {
                                        key->state = KEY_STATE_IDLE;
                                        key->press_flag = 0;
                                }
                                else
                                {
                                        key->state = KEY_STATE_CONFIRM;                // 按钮弹回
                                }
                                key->debounce_cnt = 0;
                        }
                        break;
        }
}

// 检查按键事件
unsigned char Key_GetEvent(KeyStruct* key)
{        
        if(key->change_flag)
        {
                key->change_flag = 0;                // 有按键事件
                return 1;
        }
        return 0;                                                // 无按键事件
}        
        

/* ----------------------------- END button module END ----------------------------- */

/* ----------------------------- BEGIN nixie module BEGIN ----------------------------- */

// 定义 595 引脚
#define HC595_SER P34
#define HC595_RCK P35
#define HC595_SCK P32

// 10秒状态
typedef enum 
{
        DS_STOP = 0,
        DS_RUN = 1,
        DS_CLEAN_STOP = 2,
} DigitState;

// 灯管模块
typedef struct
{
        unsigned int tms;                // 灯管数值, 取值范围 0 - 9999
        DigitState state;                // 灯光状态
        
} LightModule;

// 灯管模块
LightModule digitLights = { 0, DS_STOP };
        
void Init595(void);
void Send595(unsigned char dat);
void DisplaySeg(unsigned char segCode, unsigned char posCode);

void targetLights(void);
void DisplayDigitLights(void);

// 段码
unsigned char segNum[] = 
{
        0x3F,       /*'0', 0*/
        0x06,       /*'1', 1*/
        0x5B,       /*'2', 2*/
        0x4F,       /*'3', 3*/
        0x66,       /*'4', 4*/
        0x6D,       /*'5', 5*/
        0x7D,       /*'6', 6*/
        0x07,       /*'7', 7*/
        0x7F,       /*'8', 8*/
        0x6F,       /*'9', 9*/
        0x77,       /*'A', 10*/
        0x7C,       /*'B', 11*/
        0x39,       /*'C', 12*/
        0x5E,       /*'D', 13*/
        0x79,       /*'E', 14*/
        0x71,       /*'F', 15*/
        0x40,       /*'-', 16*/
        0x00,       /*' ', 17*/
        0x80,       /*'.', 18*/
        0x78,       /*'T', 19*/
        0xBF,       /*'0', 20*/
    0x86,       /*'1', 21*/
    0xDB,       /*'2', 22*/
    0xCF,       /*'3', 23*/
    0xE6,       /*'4', 24*/
    0xED,       /*'5', 25*/
    0xFD,       /*'6', 26*/
    0x87,       /*'7', 27*/
    0xFF,       /*'8', 28*/
    0xEF,       /*'9', 29*/
        
};

// 位码 0000 0001, 0000 0010, 0000 0100 ... 为方便赋值，使用了相反的二进制，使用时需要取反
unsigned char posNum[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};        

void Init595(void)
{
        HC595_SER = 0; 
        HC595_RCK = 0; 
        HC595_SCK = 0; 
}

void Send595(unsigned char dat)
{
        unsigned char i;
        for(i=0; i < 8; i++)
        {
                dat <<= 1;                // 左边1位移入 CY
                HC595_SER = CY;
                HC595_SCK = 1;
                HC595_SCK = 0;
        }
}

void DisplaySeg(unsigned char segCode, unsigned char posCode)
{
        Send595(segCode);
        Send595(posCode);
        HC595_RCK = 1;
        HC595_RCK = 0;
}

// 挑战目标显示在数码管上
void targetLights(void)
{
        DisplaySeg(segNum[1], ~posNum[0]);
        Delay(1);
        DisplaySeg(segNum[20], ~posNum[1]);
        Delay(1);
        DisplaySeg(segNum[0], ~posNum[2]);
        Delay(1);
        DisplaySeg(segNum[0], ~posNum[3]);
        Delay(1);
}

// 10秒挑战 程序逻辑
// 后面 4 位，默认静态显示 00.00
// 按下 P32 按钮后，开始显示计时器，前面2位显示单位秒，后面两位分别显示百毫秒、十毫秒
// 当计时器到达 99.99 秒后，计时器归零。
// 在计时期间，按下 P32 按钮，可暂停计时，时间以1HZ的频率，闪烁显示按下时刻的值。
// 当计时暂停时，按下 P32 按钮，计时器归零，并且停止闪烁。
// 当再次按下 P32 按钮时，重新开始计时。

void DisplayDigitLights(void)
{
        unsigned char digit_1 = 0;
        unsigned char digit_2 = 0;
        unsigned char digit_3 = 0;
        unsigned char digit_4 = 0;        
        digit_1 = digitLights.tms / 1000;
        digit_2 = (digitLights.tms % 1000) / 100;
        digit_3 = (digitLights.tms % 100) / 10;
        digit_4 = digitLights.tms % 10;
        DisplaySeg(segNum[digit_1], ~posNum[4]);
        Delay(1);
        DisplaySeg(segNum[digit_2 + 20], ~posNum[5]);
        Delay(1);
        DisplaySeg(segNum[digit_3], ~posNum[6]);
        Delay(1);
        DisplaySeg(segNum[digit_4], ~posNum[7]);
        Delay(1);
}

// 刷新灯管计时器
void freshDigitLight(void)
{
        switch((&digitLights)->state)
        {
                case DS_STOP:                                // 灯管处于准备状态
                        if( (&digitLights)->tms > 0 )
                        {
                                (&digitLights)->tms = 0;
                        }
                        break;
                case DS_RUN:                                // 灯管处于运行状态, 计时器自增
                        if( (&digitLights)->tms < 9999 )
                        {
                                (&digitLights)->tms++;
                        }
                        else
                        {
                                (&digitLights)->tms = 0;
                        }
                        break;
                case DS_CLEAN_STOP:                        // 灯管处于展示结果状态
                        break;
        }
}

unsigned char idx = 0;
unsigned char num[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

void PLED_40(void)
{
        
        BYTE cod[8];
        cod[0] = 0x0f;
        cod[1] = 0x00;
        cod[2] = 0x00;
        cod[3] = ~num[idx];
        cod[4] = 0xfe;
        LED40_SendData(cod, 5);
        
        P2 = ~num[idx];
        
        idx++;
        if(idx > 7)
                idx = 0;
        
}

/* ----------------------------- END nixie module END ----------------------------- */


/* ----------------------------- BEGIN  task module BEGIN ----------------------------- */
// 任务对象
typedef struct 
{
        unsigned char run_state;                        //         执行状态
        int timer;                        //  倒计时
        int cycle_length;                        //  执行周期
        void (*TaskHook)(void);                // 任务回调函数        
} TASK_COMPONENT;

void timer_callback(void);
void task_callback(void);

// 静态任务数组
// 编译前已确定数组长度
static TASK_COMPONENT tasks[] = 
{
        {0, 10, 10, freshDigitLight },
        {0, 500, 500, PLED_40 },
};

// 任务数组长度
unsigned int tasks_length = sizeof(tasks) / sizeof(tasks[0]);

// 定时器回调函数
// 定时触发 run_state
void timer_callback(void)
{
        unsigned int i = 0;
        for(i = 0; i < tasks_length; i++)
        {
                
                if(tasks[i].timer == 0 && tasks[i].run_state == 0){
                        tasks[i].timer = tasks[i].cycle_length;
                }
                
                if(tasks[i].timer > 0)
                {
                        tasks[i].timer--;
                        if(tasks[i].timer == 0)
                        {
                                tasks[i].timer = tasks[i].cycle_length;
                                tasks[i].run_state = 1;
                        }
                }
        }
}

// 任务处理回调函数
// 定时执行任务
void task_callback(void)
{
        
        unsigned int i = 0;
        for(i = 0; i < tasks_length; i++)
        {
                if(tasks[i].run_state == 1)
                {
                        tasks[i].run_state = 0;
                        tasks[i].TaskHook();
                }
        }
        
}

/* ----------------------------- END task module END ----------------------------- */

// 按钮
KeyStruct key33 = {1, KEY_STATE_IDLE, 0, 0, 0};

void main(void)
{
        sys_init();
        Timer0_Init();
        
        Init595();
        
        while(1)
        {
                
//                PLED_40();
//                Delay(500);
                
                task_callback();
                
                // 如果按钮被按下
//                if(Key_GetEvent(&key33))
//                {
//                        switch ( (&digitLights)->state )
//                        {
//                                case DS_STOP:
//                                        (&digitLights)->state = DS_RUN;                                // 开始计时
//                                        break;
//                                case DS_RUN:
//                                        (&digitLights)->state = DS_CLEAN_STOP;                // 停止计时
//                                        break;
//                                case DS_CLEAN_STOP:
//                                        (&digitLights)->state = DS_STOP;                                // 清理计时结果
//                                        break;
//                        }
//                }
                
                // 显示挑战目标 10.00 秒
                // targetLights();
                
                // 显示挑战结果，挑战前、挑战中、结果
                // DisplayDigitLights();
                
                if(bUsbOutReady)
                {
                        //USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）
                        
                        usb_OUT_done();
                }

        }
}

// 定时器中断回调函数
void Timer0_Isr(void) interrupt 1
{
        timer_callback();
        //KeyScan(&key33, P33);
}
复制代码

cored***

第十课 仿真接口


本课视频详细介绍了仿真接口（部分内容与上一节课后半部分重复），包括 LED ， 数码管， 虚拟键盘。

1. 仿真接口的调用， 由于有头文件函数的加持， 调用难度反而比集成在板子上的接口更简单。
2. 仿真接口传参的设计，本着最省资源的原则，有的甚至一个字节传递多个不同目的的参数。
3. 使用仿真接口，可以加深二进制在单片机程序中灵活应用的理解。

课后小练： 模拟密码面板

1. 原本想通过显示字符串函数（SEG5_ShowString）实现，实际应用是发现使用这个接口其实更加复杂。设计字符串构建、修改、比较、转换，这些操作在Java中是很简单的，在C中相对复杂。
2. 后来直接用显示段码函数（SEG5_ShowCode）实现，逻辑上更加简单，知识盲区也相对较少。
3. 发现变量定义不能放在 if 语句里面（可以放在函数中）。

下面是课后小练实验视频

如果无法播放，请点击此处在新窗口打开

下面是课程截图和课后小练源码包（因为更新了库函数，打包下载更容易重现）

cored***

第11课： 矩阵按钮

1.

矩阵按钮使了 6 个针脚来接收 8 个按钮的按键信号（2✖️4），比一个按钮一个针脚，节省了 8 - 6 = 2 个针脚。
这在少量按钮判断上， 似乎差别不大。 在大量按钮时， 才有明显的差别。比如 5 ✖️ 10 矩阵，单独针脚的话，序号 50 个针脚。使用矩阵按钮的方式，只需要 5➕10 = 15 个针脚。
不过按照教程视频的说法， 矩阵按钮存在多按钮同时按下会冲突的情况。 这让我联想到了机械键盘。机械键盘号称104键无冲，这在 PS/2 接口有限的针脚是怎么做到的呢？很神奇。

2.

视频教程在处理矩阵键盘行、列与针脚对应关系时，建议使用类似 #define ROW_01 P00 这样的方法，给针脚定义一个别名。这样做的好处是编程时好记，而且程序迁移到其它板兼容性更好。
看视频时我就想，使用数组来索引这些针脚不是更好吗，用循环更方便处理。经过实践，才知道，单片机的针脚定义，通常都是位变量，而位变量，是不能使用指针引用的。

3.

下面是对视频中的显示按钮序号示例，进行了重写。数码管显示的方式，只需要传递 btn_idx 给显示函数就可以了。

#define ROW_01 P06
#define ROW_02 P07
#define COL_01 P00
#define COL_02 P01
#define COL_03 P02
#define COL_04 P03

// 被按下按钮序号
char btn_idx = 0;
char current_row = 0;

// 矩阵按钮
// 循环判断此函数，可判断矩阵按钮按下
void MatrixButtons(void)
{
        // 列置 0 ， 行置 1
        //*ROW[0] = 1; *ROW[1] = 1;
        //*COL[0] = 0; *COL[1] = 0; *COL[2] = 0; *COL[3] = 0;
        ROW_01 = 1;
        ROW_02 = 1;
        COL_01 = 0;
        COL_02 = 0;
        COL_03 = 0;
        COL_04 = 0;
        
        // 两行取值不同
        if(ROW_01 != ROW_02)
        {
                // 判断属于哪一行
                if(ROW_02 == 0)
                {
                        current_row = 1;
                }
                
//                *ROW[0] = 0; *ROW[1] = 0;
//                *COL[0] = 1; *COL[1] = 1; *COL[2] = 1; *COL[3] = 1;
                ROW_01 = 0;
                ROW_02 = 0;
                COL_01 = 1;
                COL_02 = 1;
                COL_03 = 1;
                COL_04 = 1;
                
                // 判断列
                if(COL_01 == 0)
                {
                        btn_idx = current_row*4 + 1;
                }
                else if(COL_02 == 0)
                {
                        btn_idx = current_row*4 + 2;
                }
                else if(COL_03 == 0)
                {
                        btn_idx = current_row*4 + 3;
                }
                else if(COL_04 == 0)
                {
                        btn_idx = current_row*4 + 4;
                }
                
                ROW_01 = 1;
                ROW_02 = 1;
                COL_01 = 0;
                COL_02 = 0;
                COL_03 = 0;
                COL_04 = 0;                
        }
        else
        {
                current_row = 0;
        }
}
复制代码

如果无法播放，请点击此处在新窗口打开

4. 教学视频中的模拟密码箱功能，我也进行了重构，从重构中学习到一些知识点。

（1） Keil 软件，专门提供了一个针对单片机位操作的数据类型sbit，且提供了一个操作位的操作符^；下面是使用这种方式，定义矩阵键盘按钮对应物理位的声明：

// 矩阵键盘引脚定义
sbit ROW1 = P0^6;
sbit ROW2 = P0^7;
sbit COL1 = P0^0;
sbit COL2 = P0^1;
sbit COL3 = P0^2;
sbit COL4 = P0^3;
复制代码

其中的 P0^6 等价于 P06，P0^7 等价于 P07。就是取P0的第N个二进制位的意思。
（2）实验箱的P0 I/O 口是准双向口，在频繁操作时，存在“读-改-写”问题。这个问题我是怎么遇到的呢？我使用逐列扫描法来发现矩阵按钮按下时，发现第4个按钮经常无法扫描到。

    // 扫描第一列
    COL1 = 0; COL2 = 1; COL3 = 1; COL4 = 1;

    if(!(P0 & 0x40)) currentKey = 1;  // P0.6 (ROW1)
    else if(!(P0 & 0x80)) currentKey = 5;  // P0.7 (ROW2)
复制代码

最后的解决办法是在进行逐列扫描前，先把P0端口的值取出到临时变量中。

unsigned char ReadP0Pin(void)
{
    // 先读取P0端口的值到临时变量，避免读-改-写问题
    unsigned char temp = P0;
    return temp;
}
复制代码

完整的扫描和消抖代码如下：

// 优化的矩阵键盘扫描函数 - 修复读引脚问题
unsigned char MatrixKeyScan()
{
    unsigned char currentKey = 0;
    unsigned char i;
    unsigned char portValue;
    
    // 扫描第一列[4](@ref)
    COL1 = 0; COL2 = 1; COL3 = 1; COL4 = 1;
    
    portValue = ReadP0Pin();  // 正确读取引脚电平
    if(!(portValue & 0x40)) currentKey = 1;  // P0.6 (ROW1)
    else if(!(portValue & 0x80)) currentKey = 5;  // P0.7 (ROW2)
    
    // 扫描第二列
    COL1 = 1; COL2 = 0; COL3 = 1; COL4 = 1;
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 2;
    else if(!(portValue & 0x80)) currentKey = 6;
    
    // 扫描第三列
    COL1 = 1; COL2 = 1; COL3 = 0; COL4 = 1;
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 3;
    else if(!(portValue & 0x80)) currentKey = 7;
    
    // 扫描第四列
    COL1 = 1; COL2 = 1; COL3 = 1; COL4 = 0;
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 4;  // 按键4
    else if(!(portValue & 0x80)) currentKey = 8;
    
    // 恢复列线状态
    COL1 = 1; COL2 = 1; COL3 = 1; COL4 = 1;
    
    // 状态机消抖逻辑
    for(i = 0; i < 8; i++)
    {
        if(currentKey == (i + 1))  // 当前扫描到按键i+1
        {
            if(keyState[i] == 0)   // 之前未按下
            {
                keyDebounceCnt[i]++;
                if(keyDebounceCnt[i] >= DEBOUNCE_TIME)
                {
                    // 消抖完成，确认按键按下
                    keyState[i] = 1;
                    if(lastStableKey != currentKey)  // 防止重复触发
                    {
                        keyPressFlag[i] = 1;
                        lastStableKey = currentKey;
                    }
                    keyDebounceCnt[i] = 0;
                }
            }
            else
            {
                // 保持按下状态，重置计数器
                keyDebounceCnt[i] = 0;
            }
        }
        else  // 当前未扫描到按键i+1
        {
            if(keyState[i] == 1)   // 之前是按下的
            {
                keyDebounceCnt[i]++;
                if(keyDebounceCnt[i] >= DEBOUNCE_TIME)
                {
                    // 消抖完成，确认按键释放
                    keyState[i] = 0;
                    keyDebounceCnt[i] = 0;
                    if(lastStableKey == (i + 1))
                    {
                        lastStableKey = 0;  // 清除上次稳定按键
                    }
                }
            }
            else
            {
                keyDebounceCnt[i] = 0;  // 保持释放状态
                keyPressFlag[i] = 0;    // 清除按下标志
            }
        }
    }
    
    return 0;
}
复制代码

经过测试，效果稳定输出。完整代码如下：

#include "ai8051u.h"
#include "AI_usb.h"
#include "stdlib.h"

char* USER_DEVICEDESC = NULL;
char* USER_PRODUCTDESC = NULL;

/* ----------------------------- config module ----------------------------- */
void Timer0_Init(void);
void sys_init(void);

void Timer0_Init(void)
{
    TM0PS = 0x00;
    AUXR &= 0x7F;
    TMOD &= 0xF0;
    TL0 = 0x30;
    TH0 = 0xF8;
    TF0 = 0;
    TR0 = 1;
    ET0 = 1;
}

void sys_init(void)
{
    WTST = 0;
    EAXFR = 1;
    CKCON = 0;

    P0M1 = 0x00; P0M0 = 0x00;
    P1M1 = 0x00; P1M0 = 0x00;
    P2M1 = 0x00; P2M0 = 0x00;
    P3M1 = 0x00; P3M0 = 0x00;
    P4M1 = 0x00; P4M0 = 0x00;
    P5M1 = 0x00; P5M0 = 0x00;
    P6M1 = 0x00; P6M0 = 0x00;
    P7M1 = 0x00; P7M0 = 0x00;

    usb_init();
    IE2 |= 0x80;
    EA = 1;
    while(DeviceState != DEVSTATE_CONFIGURED);
}
/* -----------------------------END config module END----------------------------- */

// 定义 595 引脚
#define HC595_SER P34
#define HC595_RCK P35
#define HC595_SCK P32

void Init595(void)
{
    HC595_SER = 0; 
    HC595_RCK = 0; 
    HC595_SCK = 0; 
}

// 矩阵键盘引脚定义
sbit ROW1 = P0^6;
sbit ROW2 = P0^7;
sbit COL1 = P0^0;
sbit COL2 = P0^1;
sbit COL3 = P0^2;
sbit COL4 = P0^3;

// 包含英文字母的段码
unsigned char segNum_all[] = {
    0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F,  // 0-9
    0x77, 0x7C, 0x39, 0x5E, 0x79, 0x71, 0x3D, 0x76, 0x10, 0x0E,  // A-J
    0x7A, 0x38, 0x55, 0x54, 0x5C, 0x73, 0x67, 0x50, 0x64, 0x78,  // K-T
    0x3E, 0x62, 0x6A, 0x36, 0x6E, 0x49, 0x40, 0x00, 0x80          // U-.
};

// 密码定义 (12345678)
unsigned char password[] = {1, 2, 3, 4, 5, 6, 7, 8};
#define PASSWORD_LENGTH 8

// 全局变量
unsigned char inputBuffer[8] = {0};
unsigned char inputCount = 0;
bit passwordCorrect = 0;
unsigned char displayBuffer[8] = {36, 36, 36, 36, 36, 36, 36, 36};
unsigned char currentDigit = 0;

// 按键检测相关变量
unsigned char keyState[8] = {0};        // 每个按键的状态：0=释放，1=按下
unsigned char keyPressFlag[8] = {0};    // 按键按下标志：1表示有新的按键事件
unsigned int keyDebounceCnt[8] = {0};   // 消抖计数器
unsigned char lastStableKey = 0;        // 上次稳定的按键值
#define DEBOUNCE_TIME 20                // 消抖时间20ms

// 595发送函数
void Send595(unsigned char dat)
{
    unsigned char i;
    for(i = 0; i < 8; i++)
    {
        dat <<= 1;
        HC595_SER = CY;
        HC595_SCK = 1;
        HC595_SCK = 0;
    }
}

// 显示函数
void DisplaySeg(unsigned char segCode, unsigned char posCode)
{
    Send595(segCode);
    Send595(posCode);
    HC595_RCK = 1;
    HC595_RCK = 0;
}

// 关键修复：正确的引脚读取函数
unsigned char ReadP0Pin(void)
{
    // 先读取P0端口的值到临时变量，避免读-改-写问题
    unsigned char temp = P0;
    return temp;
}

// 优化的矩阵键盘扫描函数 - 修复读引脚问题
unsigned char MatrixKeyScan()
{
    unsigned char currentKey = 0;
    unsigned char i;
    unsigned char portValue;
    
    // 扫描第一列[4](@ref)
    COL1 = 0; COL2 = 1; COL3 = 1; COL4 = 1;
    // 添加短暂延时确保电平稳定
    // _nop_(); _nop_(); _nop_(); _nop_();
    
    portValue = ReadP0Pin();  // 正确读取引脚电平
    if(!(portValue & 0x40)) currentKey = 1;  // P0.6 (ROW1)
    else if(!(portValue & 0x80)) currentKey = 5;  // P0.7 (ROW2)
    
    // 扫描第二列
    COL1 = 1; COL2 = 0; COL3 = 1; COL4 = 1;
    // _nop_(); _nop_(); _nop_(); _nop_();
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 2;
    else if(!(portValue & 0x80)) currentKey = 6;
    
    // 扫描第三列
    COL1 = 1; COL2 = 1; COL3 = 0; COL4 = 1;
    // _nop_(); _nop_(); _nop_(); _nop_();
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 3;
    else if(!(portValue & 0x80)) currentKey = 7;
    
    // 扫描第四列 - 重点修复按键4的问题
    COL1 = 1; COL2 = 1; COL3 = 1; COL4 = 0;
    // _nop_(); _nop_(); _nop_(); _nop_();
    
    portValue = ReadP0Pin();
    if(!(portValue & 0x40)) currentKey = 4;  // 按键4
    else if(!(portValue & 0x80)) currentKey = 8;
    
    // 恢复列线状态
    COL1 = 1; COL2 = 1; COL3 = 1; COL4 = 1;
    
    // 改进的状态机消抖逻辑[6,8](@ref)
    for(i = 0; i < 8; i++)
    {
        if(currentKey == (i + 1))  // 当前扫描到按键i+1
        {
            if(keyState[i] == 0)   // 之前未按下
            {
                keyDebounceCnt[i]++;
                if(keyDebounceCnt[i] >= DEBOUNCE_TIME)
                {
                    // 消抖完成，确认按键按下
                    keyState[i] = 1;
                    if(lastStableKey != currentKey)  // 防止重复触发
                    {
                        keyPressFlag[i] = 1;
                        lastStableKey = currentKey;
                    }
                    keyDebounceCnt[i] = 0;
                }
            }
            else
            {
                // 保持按下状态，重置计数器
                keyDebounceCnt[i] = 0;
            }
        }
        else  // 当前未扫描到按键i+1
        {
            if(keyState[i] == 1)   // 之前是按下的
            {
                keyDebounceCnt[i]++;
                if(keyDebounceCnt[i] >= DEBOUNCE_TIME)
                {
                    // 消抖完成，确认按键释放
                    keyState[i] = 0;
                    keyDebounceCnt[i] = 0;
                    if(lastStableKey == (i + 1))
                    {
                        lastStableKey = 0;  // 清除上次稳定按键
                    }
                }
            }
            else
            {
                keyDebounceCnt[i] = 0;  // 保持释放状态
                keyPressFlag[i] = 0;    // 清除按下标志
            }
        }
    }
    
    return 0;
}

// 获取按键按下事件（只触发一次）
unsigned char GetKeyPress()
{
    unsigned char i;
    for(i = 0; i < 8; i++)
    {
        if(keyPressFlag[i])
        {
            keyPressFlag[i] = 0;  // 清除标志
            return i + 1;         // 返回键值(1-8)
        }
    }
    return 0;
}

// 更新显示缓冲区
void UpdateDisplayBuffer()
{
    unsigned char i;
    
    if(passwordCorrect)
    {
        displayBuffer[0] = 36; displayBuffer[1] = 36;
        displayBuffer[2] = 24; displayBuffer[3] = 25;
        displayBuffer[4] = 14; displayBuffer[5] = 23;
        displayBuffer[6] = 36; displayBuffer[7] = 36;
    }
    else
    {
        for(i = 0; i < PASSWORD_LENGTH; i++)
        {
            displayBuffer[i] = (i < inputCount) ? inputBuffer[i] : 36;
        }
    }
}

// 检查密码是否正确
bit CheckPassword()
{
    unsigned char i;
    if(inputCount != PASSWORD_LENGTH) return 0;
    
    for(i = 0; i < PASSWORD_LENGTH; i++)
    {
        if(inputBuffer[i] != password[i]) return 0;
    }
    return 1;
}

// 清空输入
void ClearInput()
{
    unsigned char i;
    inputCount = 0;
    for(i = 0; i < PASSWORD_LENGTH; i++)
    {
        inputBuffer[i] = 0;
    }
}

// 处理键盘输入
void ProcessKeyInput(unsigned char keyNum)
{
    if(passwordCorrect)
    {
        passwordCorrect = 0;
        ClearInput();
        return;
    }
    
    if(keyNum >= 1 && keyNum <= 9)
    {
        if(inputCount < PASSWORD_LENGTH)
        {
            inputBuffer[inputCount] = keyNum;
            inputCount++;
            
            if(inputCount == PASSWORD_LENGTH)
            {
                passwordCorrect = CheckPassword();
                if(!passwordCorrect) ClearInput();
            }
        }
    }
}

void main(void)
{
    unsigned char keyNum = 0;
    
    sys_init();
    Timer0_Init();
    Init595();
    ClearInput();
    
    while(1)
    {
        // 扫描键盘但不阻塞
        MatrixKeyScan();
        
        // 获取按键事件
        keyNum = GetKeyPress();
        if(keyNum != 0)
        {
            ProcessKeyInput(keyNum);
            UpdateDisplayBuffer();
        }
        
        if(bUsbOutReady)
        {
            usb_OUT_done();
        }
    }
}

// 定时器中断服务函数 - 数码管动态扫描
// 中断函数应尽量控制运算量，只做瞬间完成的动作
void Timer0_Isr(void) interrupt 1
{
    TL0 = 0x30;
    TH0 = 0xF8;
    
    switch(currentDigit)
    {
        case 0: DisplaySeg(segNum_all[displayBuffer[0]], ~0x01); break;
        case 1: DisplaySeg(segNum_all[displayBuffer[1]], ~0x02); break;
        case 2: DisplaySeg(segNum_all[displayBuffer[2]], ~0x04); break;
        case 3: DisplaySeg(segNum_all[displayBuffer[3]], ~0x08); break;
        case 4: DisplaySeg(segNum_all[displayBuffer[4]], ~0x10); break;
        case 5: DisplaySeg(segNum_all[displayBuffer[5]], ~0x20); break;
        case 6: DisplaySeg(segNum_all[displayBuffer[6]], ~0x40); break;
        case 7: DisplaySeg(segNum_all[displayBuffer[7]], ~0x80); break;
    }
    
    currentDigit++;
    if(currentDigit >= 8) currentDigit = 0;
}
复制代码

验证视频

如果无法播放，请点击此处在新窗口打开

cored***

第 11 课 ：矩阵按钮 - 课后小练

1. 模拟洗衣机面板。由于数码管实际有8位，因此我稍微做了一些扩充，前 2 位显示洗衣模式； 中间 2 位显示洗衣分钟数； 最后 2 位显示洗衣秒数。
2. 矩阵数组按键 1 - 5 ， 分别表示 5 中洗衣模式，为了与显示位数匹配，模式耗时设定，最高不多余 99分钟99秒。
3. 按键 6 空置。
4. 按键 7 作为启动按钮。按下启动按钮，开始洗衣服，倒计时开始运作。洗衣服开始后，无法修改洗衣模式、启动按钮锁定无效。
5. 按键 8 作为电源按钮。关机状态下：按下电源按钮，打开洗衣机电源，洗衣模式默认为 模式 1 ；洗衣机处于待机状态；开机状态下，按下电源按钮，关闭洗衣机，数码管熄灭。
6. 注意变量的类型，实际使用中，如果变量值超出类型可容纳的数据范围，将引发BUG（例如本程序的 timeCounter ，一开始设置为 unsigned char ，就无法计算 1000 毫秒 = 1秒的情形。）

完整代码（论坛发代码有点问题，改发压缩包吧）：
源码包
验证视频

如果无法播放，请点击此处在新窗口打开

cored***

第 12 课 复位系统

一、 寄存器英文名称

在学习课程的时候，我们注意到寄存器名称、端口名称使用了一些奇怪的英文组合。这些英文组合是怎么来的呢？为什么看门狗控制寄存器的名称不是 KMGKZ_JCQ 而是 WDT_CONTR 呢？

其实这是因为 AI8051U 是继承1 8051 内核的单片机，继承了标准8051架构的寄存器体系，同时增加了扩展功能寄存器，在寄存器和端口命名上，沿用了8051架构的命名方式。而8051架构源于英语国家，因此这些名称，其实是英文单词的缩写，遵循"功能描述+Register"的命名规则，便于理解和记忆。

下面是一些主要名称对应英文单词和中文名称。

对于本课介绍的看门狗

看门狗寄存器 WDT_CONTR : Watch Dog Timmer ConTrol Register

“使能”： EN ： ENable

WDT_FLAG : 看门狗溢出标志

EN_WDT : 看门狗使能位 ENable Watch Dot Timmer

CLR_WDT : 看门狗定时器清零 CLeaR Watch Dog Timmer

IDL_WDT : IDEL 模式时的看门狗控制位

WDT_PS[2:0] 看门狗定时器时钟分频系数 ， Watch Dog Timmer PreScaler ， 后面的 [2:0] 是借鉴数学中集合的概念，用于标识寄存器中连续的位范围，即从第2位到第0位。 这在手册中的表可以看到对应的是 B2 、B1、B0 三个位

二、看门狗复位

WDT_CONTR 是一个8位寄存器，从手册中可以看到，最后3位用于标识时钟分频系数了，前面 5 位，各自有其含义。在实际使用中，可以直接对整个寄存器赋值，例如视频中讲的程序：

// 启动看门狗，时间频率系数是 100
WDT_CONTR = 0x24;

// 对应的二进制是 0010 0100

// 等价于下面两个语句：

EN_WDT = 1;

WDT_PS = 100;

// 喂狗（启动+清空计时器，频率系数是100）
WDT_CONTR = 0x34;

// 对应二进制是 0011 0100

// 等价于下面语句

EN_WDT = 1;

CLR_WDT = 1;

WDT_PS = 100;

至于有没有对位设置单独的变量，这得查头文件。

三、看门狗复位例子

由于我们使用到了USB，要先进行USB复位。

USB复位操作：

// P3M0 、P3M1 寄存器共同控制 P3 引脚的工作模式
// 先把P3所有引脚设置为准双向口
P3M0 = 0x00;
P3M1 = 0x00;
// 再单独设置推挽输出引脚、高阻输入引脚
P3M0 &= ~0x03;
// 对应二进制 ： 1111 1100
// 由于上一步 P3M0 已经全部置 0 ， 
// 实际上这个操作强制将最低两位（P3M0.1 和 P3M0.0）清零，而其他所有位保持原状不变
// 其实这一步也可以省略
P3M1 |= 0x03;
// 对应二进制 ： 0000 0011
// 实际上这个操作强制将最低两位（P3M0.1 和 P3M0.0）置1，而其他所有位保持原状不变
// 因此操作结果是最后两位设置为 1 - 0 的高阻模式
// 其中， 引脚 7 ~ 2 为推挽输出； 引脚 1 ~ 0 为 高阻输出。

至于后面的USB寄存器等的操作查一下手册就很好理解了。

USBCON = 0x00;  // USB控制寄存器清零 USB CONtroller
USBCLK = 0x00;  // USB时钟控制寄存器清零 USB CLocK
IRC48MCR = 0x00;  // 内部48MHz高速IRC控制寄存器 Internal 48MHz Resistor-Capacitor Oscillator Control Register

最后延迟 10 毫秒以便电气运作正常无需多加解释。

教学视频中的例子： 给上一节课的案例加上看门狗程序。

在重现教学中的例子时，意外发现了一个异常情况。加入看门狗的“密码箱”模拟器在下载时出现意外，程序无法正常下载。原因是我在 usb_init() 函数执行后，调用了 ResetUSB 函数，相当于把稳定的USB通道又给重置了。

经历这个教训，让我更加坚定在学习过程中，必须弄清楚每一句不起眼的代码。

完成后的代码包如下：

附件：第11课 矩阵按钮-密码箱（有消抖、P33看门狗测试）.zip

验证视频如下：

课后小练：

1. 密码箱加上版本号U1.00显示（开机显示3秒，V1.00的V太小气，用U代替），
2. 增加手动复位，以便查看版本号，
3. 增加看门狗逻辑，
4. 版本号显示期间，不响应矩阵键盘

源码： 附件：第11课 矩阵按钮-密码箱（有消抖、看门狗、版本号）.zip

验证视频：

cored***

番外： 让 AICUBE-ISP 跨项目记住你的配置，不需要每个项目都检查下载选项

方法很简单，只需要打开ISP软件的文件菜单，启用两个选项即可：

选项1 ： 启动时加载最新配置

选项2 ： 关闭时检测配置是否被修改

选项3 ： 关闭时自动保存配置

如此，就可以高枕无忧了，不需要每次打开ISP软件，都检查一遍“硬件配置”、“收到用户命令后复位到ISP监控程序区”的选项；如下图：

cored***

第 13 课：外部中断

1. 定时器也使用到了中断的机制。

2. 针脚是否支持中断，可通过手册查询获得。具体见下图。

3. 外部中断有两种类型的电平变化可引发中断：上升沿、下降沿。 上升沿概念，在前面数码管课程中有稍微提及过。其实很简单，上升沿就是电压升高，下降沿就是电压降低。

4. INT0/INT1 同时支持上升沿、下降沿的中断检测。 INT2、INT3只支持下降沿的中断检测。

5. 在示范程序中，中断初始化功能，使用到了 3 个配置参数： IT1 属于（1）定时器控制寄存器 TCON； EX1 、 EA 来自 （2）中断使能寄存器 IE，其实也可以这样写代码（EA 、EX1 同属 IE 寄存器，可简写成 1 行）：

   // IT1 = 1;
   // 0000 0100
   TCON |= 0x04;
   // EX1 = 1;
   // EA = 1;
   // 1000 0100
   IE |= 0x84;
   

6. 使用了中断后，只需要声明中断序号，只要中断发生，中断函数就会被调用。看第一遍的时候，还在纳闷，为啥按下P33后LED会一闪一闪的呢。原因就在于此：P33按下后，变为低电平，产生下降沿，于是触发了中断。

7. 在写代码时，视频教程中使用了中断允许位 EX1 = 1 ，因此中断函数对应的中断号是 2 。这个中断号可以在手册中查看得到。

中断号与中断允许位表

手册中的图，右上角方便的提供了外部中断源管脚

定时器控制寄存器，这在ISP软件中，生成定时器初始化函数时，也会用到（TF0 = 0; TR0 = 1; ）

中断使能寄存器（在配置USB是也会用到 EA = 1）

教程视频中的范例程序

注意要打开LED模组总开关 P40 = 0;

附件：第12课 外部中断 P32点亮LED-1.zip

课后小练

1. 用到了矩阵键盘，按钮 1 按下，点亮 LED-0
2. P33 模拟外部中断，检测到P33按下时，熄灭 LED-0
3. 这里存在一个冲突， P00 - P03 , P06 - P07 既是LED灯的控制位，也是矩阵键盘ROW和COL的控制位，进行矩阵键盘检测时，必然与LED的亮灭起冲突。