🌓 切换到窄版

 找回密码
 立即注册
学习《Ai8051U教学视频》发表七集 以上学习心得，送强大的 Ai8051U实验箱
国芯人工智能技术交流网站»32位8051交流社区，车规 AEC-Q100 Grade1 › 技术交流 › 学习打卡区 | 感悟 › Ai8051u擎天柱学习冲哥《8051U深度入门到32位51大型实战 ...
123
返回列表 发新帖
楼主: 飞行者

Ai8051u擎天柱学习冲哥《8051U深度入门到32位51大型实战视频》记录贴

[复制链接]
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 2025-8-4 12:02:20 | 显示全部楼层
11.矩阵按键

屏幕截图 2025-07-26 154436.png
io.c代码
  1. #include "io.h"

  2. 

  3. u8 State1 = 0;                                        //LED1初始状态

  4. u8 State2 = 0;                                        //LED2初始状态

  5. u8 State3 = 0;                                        //LED3初始状态

  6. 

  7. u16 Key_Vol = 0;                                //按键按下持续时间（几个十秒）

  8. 

  9. u8 SEG_NUM[] = 

  10. {

  11.         0x3F,       /*'0', 0*/

  12.     0x06,       /*'1', 1*/

  13.     0x5B,       /*'2', 2*/

  14.     0x4F,       /*'3', 3*/

  15.     0x66,       /*'4', 4*/

  16.     0x6D,       /*'5', 5*/

  17.     0x7D,       /*'6', 6*/

  18.     0x07,       /*'7', 7*/

  19.     0x7F,       /*'8', 8*/

  20.     0x6F,       /*'9', 9*/

  21.     0x77,       /*'A', 10*/

  22.     0x7C,       /*'B', 11*/

  23.     0x39,       /*'C', 12*/

  24.     0x5E,       /*'D', 13*/

  25.     0x79,       /*'E', 14*/

  26.     0x71,       /*'F', 15*/

  27.     0x40,       /*'-', 16*/

  28.     0x00,       /*' ', 17*/

  29.     0x80,       /*'.', 18*/

  30. };

  31. 

  32. u8 T_NUM[8] = 

  33. {

  34.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  35. };

  36. 

  37. 

  38. void LED0_Blink(void)

  39. {

  40.         State1 = !State1;

  41.         P00 = State1;

  42. }

  43. void LED1_Blink(void)

  44. {

  45.         State2 = !State2;

  46.         P01 = State2;

  47. }

  48. void LED2_Blink(void)

  49. {

  50.         State3 = !State3;

  51.         P02 = State3;

  52. }

  53. void Key_Task(void)

  54. {

  55.                 if( P32 == 0 )

  56.                 {

  57.                         Key_Vol++;

  58.                         if(Key_Vol == 5)

  59.                         {

  60.                                 printf("按键单击\r\n");

  61.                         }        

  62.                 }

  63.                 else

  64.                 {

  65.                         Key_Vol = 0;        

  66.                 }

  67. }

  68. 

  69. /*

  70. ----------行------------

  71.         #define ROW1        P06                //定义端口

  72.         #define ROW2        P07

  73. ----------列-------------

  74.         #define COL1        P00

  75.         #define COL2        P01

  76.         #define COL3        P02                                                

  77.         #define COL4        P03

  78. */

  79. //任务1：数码管显示当前的按键号

  80. 

  81. u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  82. 

  83. void Task_1(void)

  84. {

  85.                         //static静态变量，只有第一次进来时才赋值，key_num =0 给按键传递一个键值

  86.         

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

  88.          COL1 = 0;

  89.         COL2 = 0;

  90.         COL3 = 0;

  91.         COL4 = 0;

  92.         ROW1 = 1;

  93.         ROW2 = 1;

  94.         

  95.         if((ROW1 == 0) || (ROW2 == 0))                        //"||"或的符号，只要满足其中之一的条件(行按键按下)

  96.         {

  97.                 if((ROW1 == 0) && (ROW2 == 0))                //如果两行都有按键按下，不处理

  98.                 {

  99.                 

  100.                 }

  101.                 else if ( ((ROW1 == 1)&&(ROW2 == 0)) || ((ROW1 == 0)&&(ROW2 == 1)) )        //如果有按键按下，而且只有一颗

  102.                 {

  103.                         if( ROW1 == 0 )                                        //判断哪一行，输出行开始的序号

  104.                                 key_num = 0;

  105.                         else if(ROW2 == 0)

  106.                                 key_num = 4;

  107.                         

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

  109.                         COL1 = 1;

  110.                         COL2 = 1;

  111.                         COL3 = 1;

  112.                         COL4 = 1;

  113.                         ROW1 = 0;

  114.                         ROW2 = 0;

  115.                         

  116.                         //判断哪一列，叠加按键的序号

  117.                         if(COL1 ==0)                

  118.                         {

  119. //                                key_num = key_num +0;

  120.                         }

  121.                         else if( COL2 == 0)

  122.                         {

  123.                                 key_num = key_num +1;

  124.                         }

  125.                         else if( COL3 == 0)

  126.                         {

  127.                                 key_num = key_num +2;

  128.                         }

  129.                         else if( COL4 == 0)

  130.                         {

  131.                                 key_num = key_num +3;

  132.                         }

  133.                 }

  134.                 COL1 = 0;

  135.                 COL2 = 0;

  136.                 COL3 = 0;

  137.                 COL4 = 0;

  138.                 ROW1 = 1;

  139.                 ROW2 = 1;

  140.         }

  141.         else

  142.         {

  143.                 key_num =0xff;

  144.         }

  145.                                                                         

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

  147. }

  148. 

  149. void Init_595(void)

  150. {

  151.         HC595_SER  = 0;

  152.         HC595_RCK  = 0;

  153.         HC595_SCK  = 0;

  154. }

  155. 

  156. 

  157. void Send_595( u8 dat )

  158. {

  159.         u8 i;

  160.         for( i=0; i<8; i++ )

  161.         {

  162.                 dat <<= 1;                        //数值左移一位

  163.                 HC595_SER  = CY;        //数据写到引脚

  164.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  165.         HC595_SCK  = 0;

  166.         }

  167. }

  168. 

  169. 

  170. void Display_Seg( u8 HC595_1,u8 HC595_2)

  171. {

  172.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  173.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  174.         HC595_RCK  = 1;                        //数据输出

  175.         HC595_RCK  = 0;

  176. }

  177. 

  178. //void SEG_Task(void)

  179. //{

  180. //        if(key_num == 255)

  181. //                Display_Seg( SEG_NUM[17], ~T_NUM[0]);        //数码管段码和位码

  182. //        else

  183. //                Display_Seg( SEG_NUM[key_num], ~T_NUM[0]);        //数码管段码和位码

  184. //}        

  185. 

  186. //任务二：简易密码箱

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

  188. u8 Seg_no = 0;

  189. void SEG_Task(void)

  190. {

  191.                 u8 num = 0;

  192.         if( Seg_no ==0 )                                                                //小时十位

  193.         {

  194.         

  195.                 Display_Seg( SEG_NUM[passward[0]] , ~T_NUM[0]);                //数码管刷段码和位码

  196.         }

  197.         else if( Seg_no ==1 )                                                        //小时的个位

  198.         {

  199.                 

  200.                 Display_Seg( SEG_NUM[passward[1]] , ~T_NUM[1]);                //数码管刷段码和位码

  201.         }        

  202.         else if( Seg_no ==2 )                                                        //第一个横杠

  203.         {

  204.                 Display_Seg( SEG_NUM[passward[2]] , ~T_NUM[2]);                //数码管刷段码和位码

  205.         }        

  206.         else if( Seg_no ==3 )                                                        //分钟的十位

  207.         {

  208.                 

  209.                 Display_Seg( SEG_NUM[passward[3]] , ~T_NUM[3]);                //数码管刷段码和位码

  210.         }

  211.         else if( Seg_no ==4 )

  212.         {

  213.                 

  214.                 Display_Seg( SEG_NUM[passward[4]] , ~T_NUM[4]);                //数码管刷段码和位码

  215.         }        

  216.         else if( Seg_no ==5 )

  217.         {

  218.                 Display_Seg( SEG_NUM[passward[5]] , ~T_NUM[5]);                //数码管刷段码和位码

  219.         }        

  220.         else if( Seg_no ==6 )

  221.         {

  222.                 

  223.                 Display_Seg( SEG_NUM[passward[6]] , ~T_NUM[6]);                //数码管刷段码和位码

  224.         }

  225.         else if( Seg_no ==7 )

  226.         {

  227.                 

  228.                 Display_Seg( SEG_NUM[passward[7]] , ~T_NUM[7]);                //数码管刷段码和位码

  229.         }        

  230.         else

  231.         {

  232.                 

  233.         }

  234.         Seg_no ++;

  235.         if( Seg_no>7 )

  236.                 Seg_no=0;                

  237. }

  238. u8 Key_Vol3 = 0;                                                //判断按钮是否按下

  239. u8 Key_no = 0;                                                        //数码管位计数

  240. //密码输入显示

  241. void PW_write_Task(void)

  242. {

  243.         if( key_num <0xff )

  244.                 {

  245.                         Key_Vol3 ++;

  246.                         if(Key_Vol3 == 5)

  247.                         {

  248.                                 if(Key_no == 0)                        //数码管没有按下时显示“-”

  249.                                 {

  250.                                         passward[0] = 16;

  251.                                         passward[1] = 16;

  252.                                         passward[2] = 16;

  253.                                         passward[3] = 16;

  254.                                         passward[4] = 16;

  255.                                         passward[5] = 16;

  256.                                         passward[6] = 16;

  257.                                         passward[7] = 16;

  258.                                 }

  259.                                 passward[Key_no] = key_num;

  260.                                 Key_no++;

  261. 

  262.                                 if( Key_no == 8 )                //密码输入到了八位

  263.                                 {

  264.                                         if((passward[0]==1)&&(passward[1]==2)&&(passward[2]==3)&&(passward[3]==4)&&(passward[4]==5)&&(passward[5]==6)&&(passward[6]==7)&&(passward[7]==8))

  265.                                         {

  266.                                                 //密码正确八位数码管显示为1

  267.                                                 passward[0] = 17;

  268.                                                 passward[1] = 17;

  269.                                                 passward[2] = 17;

  270.                                                 passward[3] = 17;

  271.                                                 passward[4] = 17;

  272.                                                 passward[5] = 17;

  273.                                                 passward[6] = 17;

  274.                                                 passward[7] = 1;

  275.                                         }

  276.                                         else                                 //密码输入错误八位数码管显示为空

  277.                                         {

  278.                                                 passward[0] = 16;

  279.                                                 passward[1] = 16;

  280.                                                 passward[2] = 16;

  281.                                                 passward[3] = 16;

  282.                                                 passward[4] = 16;

  283.                                                 passward[5] = 16;

  284.                                                 passward[6] = 16;

  285.                                                 passward[7] = 16;

  286.                                         }

  287.                                         Key_no = 0;

  288.                                 }

  289.                                         

  290.                         }        

  291.                 }

  292.                 else

  293.                 {

  294.                         Key_Vol3 = 0;        

  295.                 }

  296. }
复制代码
io.h代码
  1. #ifndef __IO_H

  2. #define __IO_H

  3. 

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

  5. 

  6. //定义引脚名称

  7. 

  8. #define HC595_SER         P34

  9. #define HC595_RCK         P35

  10. #define HC595_SCK         P32

  11. 

  12. /*-----------定义端口-------------*/

  13. #define ROW1        P06                //定义端口

  14. #define ROW2        P07

  15. #define COL1        P00

  16. #define COL2        P01

  17. #define COL3        P02

  18. #define COL4        P03

  19. 

  20. extern u8 key_num ;

  21. 

  22. /*-----------函数声明-------------*/

  23. void LED0_Blink(void);

  24. void LED1_Blink(void);

  25. void LED2_Blink(void);

  26. 

  27. void Key_Task(void);

  28. void Task_1(void);

  29. void SEG_Task(void);

  30. void Init_595(void);

  31. void PW_write_Task(void);

  32. 

  33. #endif
复制代码
task.c代码

  1. #include "task.h"

  2. #include "io.h"

  3. 

  4. //========================================================================

  5. //                               本地变量声明

  6. //========================================================================

  7. 

  8. static TASK_COMPONENTS Task_Comps[]=

  9. {

  10. //状态  计数  周期  函数

  11. 

  12. //        {0, 300,   300,   LED0_Blink},     /* task 1 Period： 300ms */

  13. //        {0, 600,   600,   LED1_Blink},      /* task 1 Period： 600ms */

  14. //        {0, 900,   900,   LED2_Blink},      /* task 1 Period： 900ms */

  15. //        {0, 10,    10,    Key_Task},      /* task 1 Period： 50ms */

  16.         {0, 10,     10,     Task_1},      /* task 1 Period： 10ms */

  17.         {0, 1,     1,     SEG_Task},      /* task 1 Period： 10ms */

  18.         {0, 10,    10,   PW_write_Task},      /* task 1 Period： 100ms */

  19.         

  20.         

  21. };

  22. 

  23. u8 Tasks_Max = sizeof(Task_Comps)/sizeof(Task_Comps[0]);

  24. 

  25. //========================================================================

  26. // 函数: Task_Handler_Callback

  27. // 描述: 任务标记回调函数.

  28. // 参数: None.

  29. // 返回: None.

  30. // 版本: V1.0, 2012-10-22

  31. //========================================================================

  32. void Task_Marks_Handler_Callback(void)

  33. {

  34.     u8 i;

  35.     for(i=0; i<Tasks_Max; i++)

  36.     {

  37.         if(Task_Comps[i].TIMCount)      /* If the time is not 0 */

  38.         {

  39.             Task_Comps[i].TIMCount--;   /* Time counter decrement */

  40.             if(Task_Comps[i].TIMCount == 0) /* If time arrives */

  41.             {

  42.                 /*Resume the timer value and try again */

  43.                 Task_Comps[i].TIMCount = Task_Comps[i].TRITime;  

  44.                 Task_Comps[i].Run = 1;      /* The task can be run */

  45.             }

  46.         }

  47.     }

  48. }

  49. 

  50. //========================================================================

  51. // 函数: Task_Pro_Handler_Callback

  52. // 描述: 任务处理回调函数.

  53. // 参数: None.

  54. // 返回: None.

  55. // 版本: V1.0, 2012-10-22

  56. //========================================================================

  57. void Task_Pro_Handler_Callback(void)

  58. {

  59.     u8 i;

  60.     for(i=0; i<Tasks_Max; i++)

  61.     {

  62.         if(Task_Comps[i].Run) /* If task can be run */

  63.         {

  64.             Task_Comps[i].Run = 0;      /* Flag clear 0 */

  65.             Task_Comps[i].TaskHook();   /* Run task */

  66.         }

  67.     }

  68. }

  69. 

复制代码


11.矩阵按键.rar (183.66 KB, 下载次数: 6)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 2025-8-10 21:34:44 | 显示全部楼层
11课 矩阵按键 课后小练 简易洗衣机

屏幕截图 2025-08-10 205123.png
核心工作原理

1. 矩阵按键扫描原理
        硬件结构：采用 2 行（ROW1、ROW2）4 列（COL1-COL4）的矩阵按键，通过行列交叉定位按键。
        扫描逻辑：
        行检测：列输出低电平，行输出高电平，检测行电平（低电平表示该行有按键按下），确定行号（ROW1=0 对应行 0，ROW2=0 对应行 4）。
        列检测：行输出低电平，列输出高电平，检测列电平（低电平表示该列有按键按下），确定列号（COL1-COL4 对应 0-3）。
        键值计算：键值 = 行号 + 列号（如行 0 列 1 对应键值 1，行 1 列 2 对应键值 6）。

2. 数码管显示原理
        硬件驱动：通过 74HC595 芯片级联驱动 8 位数码管，实现串行数据转并行输出，节省 IO 口。
        动态扫描：通过 Seg_no 循环切换数码管位选（0-7），每次仅点亮一位数码管，利用人眼视觉暂留效应实现 “同时显示”。
        显示逻辑：仅使用第 6、7 位数码管（从 0 开始计数），非计时模式显示工作模式（如 “01” 表示模式 1），计时模式显示倒计时（如 “10” 表示 10 秒）。

3. 洗衣机工作流程
        开机：按下开机键（key_num=0），ON_OFF=1 上电，默认模式 1（workingMode=1），数码管显示 “01”。
        选模式：按下模式键 1-5（key_num=1-5），workingMode 更新为对应值，数码管同步显示。
        启动：按下启动键（key_num=6），Start_work=1 开始计时，Work_Time=1 切换到计时模式，数码管显示倒计时。
        倒计时：TIMECOUNT_Task 定期递减 timeVol（单位：ms），数码管实时刷新剩余时间。
        结束：倒计时结束（timeVol=0），自动关机（ON_OFF=0），数码管熄灭。

IO.C
  1. #include "io.h"

  2. 

  3. bit ON_OFF = 0;                 //洗衣机的加电和去电，对应的开和关。1 洗衣机加电，0 洗衣机断电

  4. bit Start_work = 0;                //洗衣机的启动和停止。1 洗衣机启动工作，0 洗衣机停止工作。

  5. bit Work_Time = 0;                //工作计数。        1 工作模式开始倒计时，0 暂停工作模式。

  6. u8 Run_Key =0 ;                        //运行

  7. u8 key_num = 17;                //定义按键的初始值，11对应段码的空字符

  8. u8 workingMode = 17;    //定义密码初始值，17对应段码的空字符

  9. u8 Seg_no = 0;                         // 数码管扫描位置（0-7，控制8位数码管的刷新）

  10. u16 key_vol = 0;                        //按键延时（用于防抖）

  11. u16 timeVol = 0;                        //计时

  12. 

  13. u8 SEG_NUM[] = 

  14. {

  15.         0x3F,       /*'0', 0*/

  16.     0x06,       /*'1', 1*/

  17.     0x5B,       /*'2', 2*/

  18.     0x4F,       /*'3', 3*/

  19.     0x66,       /*'4', 4*/

  20.     0x6D,       /*'5', 5*/

  21.     0x7D,       /*'6', 6*/

  22.     0x07,       /*'7', 7*/

  23.     0x7F,       /*'8', 8*/

  24.     0x6F,       /*'9', 9*/

  25.     0x77,       /*'A', 10*/

  26.     0x7C,       /*'B', 11*/

  27.     0x39,       /*'C', 12*/

  28.     0x5E,       /*'D', 13*/

  29.     0x79,       /*'E', 14*/

  30.     0x71,       /*'F', 15*/

  31.     0x40,       /*'-', 16*/

  32.     0x00,       /*' ', 17*/

  33.     0x80,       /*'.', 18*/

  34. };

  35. 

  36. u8 T_NUM[8] = 

  37. {

  38.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  39. };

  40. 

  41. /*

  42. ----------行------------

  43.         #define ROW1        P06                //定义端口

  44.         #define ROW2        P07

  45. ----------列-------------

  46.         #define COL1        P00

  47.         #define COL2        P01

  48.         #define COL3        P02                                                

  49.         #define COL4        P03

  50. */

  51. 

  52. //u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  53. 

  54. void Task_1( void )

  55. {

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

  57.          COL1 = 0;

  58.         COL2 = 0;

  59.         COL3 = 0;

  60.         COL4 = 0;

  61.         ROW1 = 1;

  62.         ROW2 = 1;

  63.         

  64.         if((ROW1 == 0) || (ROW2 == 0))                        //"||"或的符号，只要满足其中之一的条件(行按键按下)

  65.         {

  66.                 if((ROW1 == 0) && (ROW2 == 0))                //如果两行都有按键按下，不处理

  67.                 {

  68.                 

  69.                 }

  70.                 else if ( ((ROW1 == 1)&&(ROW2 == 0)) || ((ROW1 == 0)&&(ROW2 == 1)) )        //如果有按键按下，而且只有一颗

  71.                 {

  72.                         if( ROW1 == 0 )                                        //判断哪一行，输出行开始的序号

  73.                                 key_num = 0;

  74.                         else if(ROW2 == 0)

  75.                                 key_num = 4;

  76.                         

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

  78.                         COL1 = 1;

  79.                         COL2 = 1;

  80.                         COL3 = 1;

  81.                         COL4 = 1;

  82.                         ROW1 = 0;

  83.                         ROW2 = 0;

  84.                         

  85.                         //判断哪一列，叠加按键的序号

  86.                         if(COL1 ==0)                

  87.                         {

  88. //                                key_num = key_num +0;

  89.                         }

  90.                         else if( COL2 == 0)

  91.                         {

  92.                                 key_num = key_num +1;

  93.                         }

  94.                         else if( COL3 == 0)

  95.                         {

  96.                                 key_num = key_num +2;

  97.                         }

  98.                         else if( COL4 == 0)

  99.                         {

  100.                                 key_num = key_num +3;

  101.                         }

  102.                 }

  103.                 COL1 = 0;

  104.                 COL2 = 0;

  105.                 COL3 = 0;

  106.                 COL4 = 0;

  107.                 ROW1 = 1;

  108.                 ROW2 = 1;

  109.         }

  110.         else

  111.         {

  112.                 key_num =0xff;

  113.         }

  114.                                                                         

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

  116. }

  117. 

  118. void Init_595(void)

  119. {

  120.         HC595_SER  = 0;

  121.         HC595_RCK  = 0;

  122.         HC595_SCK  = 0;

  123. }

  124. 

  125. 

  126. void Send_595( u8 dat )

  127. {

  128.         u8 i;

  129.         

  130.         for( i=0; i<8; i++ )

  131.         {

  132.                 dat <<= 1;                        //数值左移一位

  133.                 HC595_SER  = CY;        //数据写到引脚

  134.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  135.         HC595_SCK  = 0;

  136.         }

  137. }

  138. 

  139. 

  140. void Display_Seg( u8 HC595_1,u8 HC595_2)

  141. {

  142.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  143.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  144.         

  145.         HC595_RCK  = 1;                        //数据输出

  146.         HC595_RCK  = 0;

  147. }

  148. 

  149. 

  150. 

  151. 

  152. void SEG_Task(void)

  153. {

  154.     // 只需使用两位数码管，其它位全部为空白

  155.     if (Seg_no == 0)

  156.     {

  157.         // 第0位数码管：显示空字符

  158.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  159.     }

  160.     else if (Seg_no == 1)

  161.     {

  162.         // 第1位数码管：显示空字符

  163.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  164.     }

  165.     else if (Seg_no == 2)

  166.     {

  167.         // 第2位数码管：显示空字符

  168.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  169.     }

  170.     else if (Seg_no == 3)

  171.     {

  172.         // 第3位数码管：显示空字符

  173.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  174.     }

  175.     else if (Seg_no == 4)

  176.     {

  177.         // 第4位数码管：显示空字符

  178.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  179.     }

  180.     else if (Seg_no == 5)

  181.     {

  182.         // 第5位数码管：显示空字符

  183.         Display_Seg(SEG_NUM[17], ~T_NUM[Seg_no]);

  184.     }

  185.     else if (Seg_no == 6)

  186.     {

  187.         // 第6位数码管：计时模式显示十位数，否则显示空

  188.         u8 seg_index;  // 定义段码下标变量

  189.         if (Work_Time == 1)  // 判断是否为计时模式

  190.         {

  191.             seg_index = timeVol / 10000;  // 计时模式：取倒计时十位数

  192.         }

  193.         else

  194.         {

  195.             //seg_index = workingMode / 10; // 工作模式：显示空字符

  196.                         seg_index = (workingMode == 17) ? 17 : (workingMode / 10);

  197.         }

  198.         Display_Seg(SEG_NUM[seg_index], ~T_NUM[Seg_no]);

  199.     }

  200.     else if (Seg_no == 7)

  201.     {

  202.         // 第7位数码管：计时模式显示个位数，否则显示工作模式

  203.         u8 seg_index;  // 定义段码下标变量

  204.         if (Work_Time == 1)  // 判断是否为计时模式

  205.         {

  206.             seg_index = timeVol / 1000 % 10;  // 计时模式：取倒计时个位数

  207.         }

  208.         else

  209.         {

  210.             seg_index = workingMode;  // 工作模式：显示当前模式编号

  211.         }

  212.         Display_Seg(SEG_NUM[seg_index], ~T_NUM[Seg_no]);

  213.     }

  214. 

  215.     // 更新数码管扫描位置（循环0-7）

  216.     Seg_no++;

  217.     if (Seg_no > 7)

  218.     {

  219.         Seg_no = 0;

  220.     }

  221. }

  222. //倒计时

  223. void TIMECOUNT_Task(void)

  224. {

  225.         if(Start_work == 1)

  226.         {

  227.                 timeVol--;

  228.                 if(timeVol == 0)

  229.                 {

  230.                                         Start_work = 0;                          //停止计时

  231.                                         Work_Time = 0;                         //切换到工作模式状态

  232.                                         workingMode = 17;                          //清屏

  233.                                         ON_OFF = 0;                             //关机                        

  234.                 }

  235.         }

  236. }

  237. /*简易洗衣机面板

  238. 1.按下开机键后，数码管显示1，表示默认为清洗模式1；

  239. 2.用矩阵按键模拟洗衣机的操作面板，前五个按键模拟1-5的清洗模式按键，选择几的时候数码管显示数字几，表示以当前为第几个功能；

  240. 3.按下启动后，按照选择的模式对应的时间开始倒计时，倒计时结束后，数码管熄灭，表示清洗完成（清洗时间自己随意设置）

  241. */

  242. 

  243. 

  244. 

  245. void Task_2( void )

  246. {

  247.         if(key_num < 17)

  248.         {

  249.                 key_vol++;

  250.                 if(key_vol >= 20)

  251.                 {

  252.                         // 现有case处理逻辑...

  253.             // 处理完成后可临时锁定，避免重复触发（可选）

  254.             key_vol = 20;  // 保持阈值，避免长按重复触发

  255.         }

  256.                 

  257.                 else  // 按键释放状态

  258.                 {

  259.                         key_vol = 0;  // 重置防抖计数

  260.                 }

  261.                         switch(key_num)

  262.                         {

  263.                                 case 0:

  264.                                                 if(ON_OFF == 0)                

  265.                                                 {

  266.                                                                 ON_OFF = 1;

  267.                                                                 workingMode = 1;  // 开机默认模式1

  268.                                                                 timeVol = 10000;  // 默认模式时间

  269.                                                 }

  270.                                                 break;  // 新增break，避免穿透

  271.                                 case 1:                                                //1：常用模式,定时10秒

  272.                                                 if(ON_OFF == 1 && Start_work == 0)

  273.                                                 {

  274.                                                                 workingMode = 1;        //与case0共用本条，开机与设置为常用模式都置1

  275.                                                                 timeVol = 10000;

  276.                                                 }

  277.                                                 break;

  278.                                 case 2:                                                //2：标准模式，定时15秒

  279.                                                 if(ON_OFF ==1 && Start_work == 0)

  280.                                                 {

  281.                                                                 workingMode = key_num;

  282.                                                                 timeVol = 15000;

  283.                                                 }

  284.                                                 break;

  285.                                 case 3:                                                //3：快洗模式，定时5秒

  286.                                                 if(ON_OFF ==1 && Start_work == 0)

  287.                                                 {

  288.                                                                 workingMode = key_num;

  289.                                                                 timeVol = 5000;

  290.                                                 }

  291.                                                 break;

  292.                                 case 4:                                                //4：毛毯模式，定时30秒

  293.                                                 if(ON_OFF ==1 && Start_work == 0)

  294.                                                 {

  295.                                                                 workingMode = key_num;

  296.                                                                 timeVol = 30000;

  297.                                                 }

  298.                                                 break;

  299.                                 case 5:                                                //5：风干模式，定时20秒

  300.                                                 if(ON_OFF ==1 && Start_work == 0)

  301.                                                 {

  302.                                                                 workingMode = key_num;

  303.                                                                 timeVol = 20000;

  304.                                                 }

  305.                                                 break;

  306.                                 case 6:                                                //启动模式

  307.                                                 if(ON_OFF == 1)

  308.                                                 {

  309.                                                                 Start_work  = 1;        //定时器开始工作

  310.                                                                 Work_Time = 1;        //切换到计时工作状态

  311.                                                 }

  312.                                                 break;

  313.                                 default:                                        //其它情况默认不执行直接退出，比如按下按键7

  314.                                                 break;

  315. 

  316.                         }

  317.                 }

  318.         }

  319. 

  320. 

  321.         

复制代码
main.c
  1. #include "config.h"

  2. #include "task.h"

  3. #include "io.h"

  4. 

  5. 

  6. void main(void)

  7. {

  8.         

  9.         Sys_init();                                        //系统初始化

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

  11.         

  12.         IE2 |= 0x80;                //使能USB中断

  13.         Timer0_Init();                                //定时器初始化

  14.         Init_595();

  15.         P0 = 0XFF;                                        // 初始化IO口（置高，确保输入有效）

  16.         

  17.         EA = 1;

  18.         P40 = 0;

  19.         while(1)

  20.         {

  21.                  if (bUsbOutReady)

  22.         {

  23. //            USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）

  24.             usb_OUT_done();

  25.         }

  26.                 Task_1();      // 扫描按键

  27.         Task_2();      // 处理按键

  28.         SEG_Task();    // 刷新数码管

  29.         TIMECOUNT_Task(); // 可选：添加定时器中断触发

  30.         }

  31.         

  32. }

  33. void Timer0_Isr(void) interrupt 1

  34. {

  35.         

  36.         Task_Marks_Handler_Callback();                        //系统计时

  37. ;

  38. }
复制代码

demo1.rar (191.49 KB, 下载次数: 2)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 2025-8-10 21:42:46 | 显示全部楼层
12 复位系统

屏幕截图 2025-08-02 093936.png
IO.C
  1. #include "io.h"

  2. 

  3. u8 SEG_NUM[] = 

  4. {

  5.     0x3F,       /*'0', 0*/

  6.     0x06,       /*'1', 1*/

  7.     0x5B,       /*'2', 2*/

  8.     0x4F,       /*'3', 3*/

  9.     0x66,       /*'4', 4*/

  10.     0x6D,       /*'5', 5*/

  11.     0x7D,       /*'6', 6*/

  12.     0x07,       /*'7', 7*/

  13.     0x7F,       /*'8', 8*/

  14.     0x6F,       /*'9', 9*/

  15.     0x77,       /*'A', 10*/

  16.     0x7C,       /*'B', 11*/

  17.     0x39,       /*'C', 12*/

  18.     0x5E,       /*'D', 13*/

  19.     0x79,       /*'E', 14*/

  20.     0x71,       /*'F', 15*/

  21.     0x54,       /*'N', 16*/

  22.     0x5C,       /*'O', 17*/

  23.     0x73,       /*'P', 18*/

  24.     0x50,       /*'R', 19*/

  25.     0x40,       /*'-', 20*/

  26.     0x00,       /*' ', 21*/

  27.     0x80,       /*'.', 22*/

  28. };

  29. 

  30. u8 T_NUM[8] = 

  31. {

  32.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  33. };

  34. 

  35. /*

  36. ----------行------------

  37.         #define ROW1        P06                //定义端口

  38.         #define ROW2        P07

  39. ----------列-------------

  40.         #define COL1        P00

  41.         #define COL2        P01

  42.         #define COL3        P02                                                

  43.         #define COL4        P03

  44. */

  45. 

  46. u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  47. 

  48. void Task_1( void )

  49. {

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

  51.          COL1 = 0;

  52.         COL2 = 0;

  53.         COL3 = 0;

  54.         COL4 = 0;

  55.         ROW1 = 1;

  56.         ROW2 = 1;

  57.         

  58.         if((ROW1 == 0) || (ROW2 == 0))                        //"||"或的符号，只要满足其中之一的条件(行按键按下)

  59.         {

  60.                 if((ROW1 == 0) && (ROW2 == 0))                //如果两行都有按键按下，不处理

  61.                 {

  62.                 

  63.                 }

  64.                 else if ( ((ROW1 == 1)&&(ROW2 == 0)) || ((ROW1 == 0)&&(ROW2 == 1)) )        //如果有按键按下，而且只有一颗

  65.                 {

  66.                         if( ROW1 == 0 )                                        //判断哪一行，输出行开始的序号

  67.                                 key_num = 0;

  68.                         else if(ROW2 == 0)

  69.                                 key_num = 4;

  70.                         

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

  72.                         COL1 = 1;

  73.                         COL2 = 1;

  74.                         COL3 = 1;

  75.                         COL4 = 1;

  76.                         ROW1 = 0;

  77.                         ROW2 = 0;

  78.                         

  79.                         //判断哪一列，叠加按键的序号

  80.                         if(COL1 ==0)                

  81.                         {

  82. //                                key_num = key_num +0;

  83.                         }

  84.                         else if( COL2 == 0)

  85.                         {

  86.                                 key_num = key_num +1;

  87.                         }

  88.                         else if( COL3 == 0)

  89.                         {

  90.                                 key_num = key_num +2;

  91.                         }

  92.                         else if( COL4 == 0)

  93.                         {

  94.                                 key_num = key_num +3;

  95.                         }

  96.                 }

  97.                 COL1 = 0;

  98.                 COL2 = 0;

  99.                 COL3 = 0;

  100.                 COL4 = 0;

  101.                 ROW1 = 1;

  102.                 ROW2 = 1;

  103.         }

  104.         else

  105.         {

  106.                 key_num =0xff;

  107.         }

  108.                                                                         

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

  110. }u8 Key_vol = 0;

  111. void KEY_Task(void)

  112. {

  113.         if(P33 == 0)

  114.         {

  115.                 Key_vol++;

  116.                 if(Key_vol == 5)

  117.                 {

  118.                         USB_Reset_U();

  119.                         IAP_CONTR = 0X20;

  120.                 }

  121.         }

  122.                 

  123. }

  124. void Init_595(void)

  125. {

  126.         HC595_SER  = 0;

  127.         HC595_RCK  = 0;

  128.         HC595_SCK  = 0;

  129. }

  130. 

  131. 

  132. void Send_595( u8 dat )

  133. {

  134.         u8 i;

  135.         

  136.         for( i=0; i<8; i++ )

  137.         {

  138.                 dat <<= 1;                        //数值左移一位

  139.                 HC595_SER  = CY;        //数据写到引脚

  140.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  141.         HC595_SCK  = 0;

  142.         }

  143. }

  144. 

  145. 

  146. void Display_Seg( u8 HC595_1,u8 HC595_2)

  147. {

  148.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  149.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  150.         

  151.         HC595_RCK  = 1;                        //数据输出

  152.         HC595_RCK  = 0;

  153. }

  154. 

  155. //void SEG_Task(void)

  156. //{

  157. //        if(key_num == 255)

  158. //                Display_Seg( SEG_NUM[17], ~T_NUM[0]);        //数码管段码和位码

  159. //        else

  160. //                Display_Seg( SEG_NUM[ key_num ], ~T_NUM[0]);        //数码管段码和位码

  161. //}        

  162. 

  163. //任务二：简易密码箱

  164. u8 passward[8] = { 20,20,20,20,20,20,20,20};

  165. u8 Seg_no = 0;

  166. void SEG_Task(void)

  167. {

  168.                 u8 num = 0;

  169. 

  170.         switch(Seg_no){

  171.                 case 0: Display_Seg( SEG_NUM[passward[0]], ~T_NUM[0] );                   break;

  172.                 case 1: Display_Seg( SEG_NUM[passward[1]], ~T_NUM[1] );         break;

  173.                 case 2: Display_Seg( SEG_NUM[passward[2]], ~T_NUM[2] );                   break;

  174.                 case 3: Display_Seg( SEG_NUM[passward[3]], ~T_NUM[3] );                   break;

  175.                 case 4: Display_Seg( SEG_NUM[passward[4]], ~T_NUM[4] );                   break;

  176.                 case 5: Display_Seg( SEG_NUM[passward[5]], ~T_NUM[5] );                   break;

  177.                 case 6: Display_Seg( SEG_NUM[passward[6]], ~T_NUM[6] );         break;

  178.                 case 7: Display_Seg( SEG_NUM[passward[7]], ~T_NUM[7] );         break;

  179.         }

  180.         Seg_no ++;

  181.         if( Seg_no>7 )

  182.                 Seg_no=0;                

  183. }

  184. u8 Key_Vol3 = 0;                                                //判断按钮是否按下

  185. u8 Key_no = 0;                                                        //数码管位计数

  186. //密码输入显示

  187. void PW_write_Task(void)

  188. {

  189.         if( key_num <0xff )

  190.                 {

  191.                         Key_Vol3 ++;

  192.                         if(Key_Vol3 == 5)                        //是否延时50m秒

  193.                           {

  194.                                 if(Key_no == 0)                        //数码管没有按下时显示“--------”

  195.                                 {

  196.                                         passward[0] = 20;

  197.                                         passward[1] = 20;

  198.                                         passward[2] = 20;

  199.                                         passward[3] = 20;

  200.                                         passward[4] = 20;

  201.                                         passward[5] = 20;

  202.                                         passward[6] = 20;

  203.                                         passward[7] = 20;

  204. 

  205.                                         

  206.                                 }

  207.                                 passward[Key_no] = key_num; //键值传递

  208.                                 Key_no++;

  209. 

  210.                                 if( Key_no == 8 )                //密码输入到了八位

  211.                                 {

  212.                                         if((passward[0]==1)&&(passward[1]==2)&&(passward[2]==3)&&(passward[3]==4)&&(passward[4]==5)&&(passward[5]==6)&&(passward[6]==7)&&(passward[7]==0))

  213.                                         {

  214.                                                 //密码正确八位数码管显示为1

  215.                                                 passward[0] = 20;

  216.                                                 passward[1] = 20;

  217.                                                 passward[2] = 17;

  218.                                                 passward[3] = 18;

  219.                                                 passward[4] = 14;

  220.                                                 passward[5] = 16;

  221.                                                 passward[6] = 20;

  222.                                                 passward[7] = 20;

  223.                                                 

  224. 

  225.                                         }

  226.                                         else                                 //密码输入错误八位数码管显示为空

  227.                                         {

  228.                                                 passward[0] = 20;

  229.                                                 passward[1] = 20;

  230.                                                 passward[2] = 20;

  231.                                                 passward[3] = 20;

  232.                                                 passward[4] = 20;

  233.                                                 passward[5] = 20;

  234.                                                 passward[6] = 20;

  235.                                                 passward[7] = 20;

  236.                                         }                 

  237.                                         Key_no = 0;

  238.                                 }

  239.                                         

  240.                         }        

  241.                 }

  242.                 else

  243.                 {

  244.                         Key_Vol3 = 0;        

  245.                 }

  246. }
复制代码
config.c部分代码
  1. //config.c部分代码

  2. #include "config.h"

  3. 

  4. void Delay10ms(void)        //@24.000MHz

  5. {

  6.         unsigned long edata i;

  7. 

  8.         _nop_();

  9.         _nop_();

  10.         _nop_();

  11.         i = 59998UL;

  12.         while (i) i--;

  13. }

  14. 

  15. 

  16. void USB_Reset_U(void)

  17. {

  18.                 P3M0 = 0x00;

  19.         P3M1 = 0x00;

  20. 

  21.         P3M0 &= ~0x03;

  22.         P3M1 |= 0x03;

  23. 

  24.         USBCON = 0X00;

  25.         USBCLK = 0X00;

  26.         IRC48MCR = 0X00;

  27.         Delay10ms();

  28. 

  29. }

  30. void Sys_init(void)

  31. {

  32. 

  33.         WTST = 0;                                          //设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快

  34.     EAXFR = 1;                                         //扩展寄存器(XFR)访问使能

  35.     CKCON = 0;                                         //提高访问XRAM速度

  36.         

  37.         P0M1 = 0x00;   P0M0 = 0x00;

  38.     P1M1 = 0x00;   P1M0 = 0x00;

  39.     P2M1 = 0x00;   P2M0 = 0x00;

  40.     P3M1 = 0x00;   P3M0 = 0x00;

  41.     P4M1 = 0x00;   P4M0 = 0x00;

  42.     P5M1 = 0x00;   P5M0 = 0x00;

  43.     P6M1 = 0x00;   P6M0 = 0x00;

  44.     P7M1 = 0x00;   P7M0 = 0x00;

  45.         

  46.         USB_Reset_U();

  47. }
复制代码
config.h代码
  1. //config.h代码

  2. #ifndef __CONFIG_H

  3. #define __CONFIG_H

  4. 

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

  6. #include "AI_usb.h"                                //调用头文件

  7. #include "intrins.h"                        //d调用头文件

  8. 

  9. void Sys_init(void);                        //函数声明

  10. void Timer0_Init(void);

  11. void USB_Reset_U(void);

  12. #endif

  13. 

  14. //
复制代码
main.c
  1. //main.c代码

  2. #include "config.h"

  3. #include "task.h"

  4. #include "io.h"

  5. 

  6. 

  7. void main(void)

  8. {

  9.         

  10.         Sys_init();                                        //系统初始化

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

  12.         

  13.         IE2 |= 0x80;                                    //使能USB中断

  14.         Timer0_Init();                                                                        //定时器初始化

  15.         Init_595();

  16.         EA = 1;

  17.         P40 = 0;

  18.         WDT_CONTR = 0X24;

  19.         while(1)

  20.         {

  21.                  if (bUsbOutReady)

  22.         {

  23. //            USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）

  24.             usb_OUT_done();

  25.         }

  26.                 Task_Pro_Handler_Callback();                                //执行功能函数

  27.                 WDT_CONTR = 0X34;

  28.         }

  29.         

  30. }

  31. void Timer0_Isr(void) interrupt 1

  32. {

  33.         

  34.         Task_Marks_Handler_Callback();                        //系统计时

  35. ;

  36. }
复制代码

demo1.rar (183.73 KB, 下载次数: 2)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 2025-8-12 07:25:49 | 显示全部楼层
12 复位系统  课后小练

密码锁
1.没有输入时，显示“- - - - - - - -”
2.有输入时，按下一个按键，开始按顺序写入
    例如，第一个按下1，显示“1 - - - - - - -”   
    例如，第二个按下3，显示“1 3 - - - - - -”
3.当按下的密码为“ 1 2 3 4 5 6 7 0”时，数码管显示open的字符，否则，还是显示“- - - - - - - -”

新增：
1.看门狗，超时1秒自动复位
2.增加开机版本号，开机显示三秒的U 1.00 版本号
3.增加手动复位，P33按钮按下时重启（方便查看版本号和清除密码）

屏幕截图 2025-08-12 062115.png
io.c
  1. #include "io.h"

  2. 

  3. 

  4. u8 State1 = 0;                                        //LED1初始状态

  5. u8 State2 = 0;                                        //LED2初始状态

  6. u8 State3 = 0;                                        //LED3初始状态

  7. u16 Key_Vol ;                                //按键按下持续时间

  8. 

  9. u8 SEG_NUM[] = 

  10. {

  11.     0x3F,       /*'0', 0*/

  12.     0x06,       /*'1', 1*/

  13.     0x5B,       /*'2', 2*/

  14.     0x4F,       /*'3', 3*/

  15.     0x66,       /*'4', 4*/

  16.     0x6D,       /*'5', 5*/

  17.     0x7D,       /*'6', 6*/

  18.     0x07,       /*'7', 7*/

  19.     0x7F,       /*'8', 8*/

  20.     0x6F,       /*'9', 9*/

  21.     0x77,       /*'A', 10*/

  22.     0x7C,       /*'B', 11*/

  23.     0x39,       /*'C', 12*/

  24.     0x5E,       /*'D', 13*/

  25.     0x79,       /*'E', 14*/

  26.     0x71,       /*'F', 15*/

  27.     0x54,       /*'N', 16*/

  28.     0x5C,       /*'O', 17*/

  29.     0x73,       /*'P', 18*/

  30.     0x3E,       /*'U', 19*/

  31.     0x40,       /*'-', 20*/

  32.     0x86,       /*'1', 21*/

  33.     0x00,       /*' ', 22*/

  34.     0x80,       /*'.', 23*/

  35. 

  36. 

  37. };

  38. 

  39. u8 T_NUM[8] = 

  40. {

  41.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  42. };

  43. 

  44. void LED1_Blink(void)

  45. {

  46.         State2 = !State2;

  47.         P01 = State2;

  48. }

  49. 

  50. void LED2_Blink(void)

  51. {

  52.         State3 = !State3;

  53.         P02 = State3;

  54. }

  55. 

  56. void KEY_Task(void)

  57. {

  58.         if( P33 == 0 )

  59.         {

  60.                 Key_Vol++;

  61.                 if( Key_Vol==5 )

  62.                 {

  63.                         //按键按下的任务

  64. //                        printf( "按键单击\r\n" );

  65.                         

  66.                         USB_Reset_U();

  67.                         

  68.                         IAP_CONTR = 0X20;

  69.                 }

  70.         }

  71.         else

  72.         {

  73.                 Key_Vol = 0;

  74.         }

  75.         

  76. }

  77. 

  78. /*

  79. ----------行------------

  80.         #define ROW1        P06                //定义端口

  81.         #define ROW2        P07

  82. ----------列-------------

  83.         #define COL1        P00

  84.         #define COL2        P01

  85.         #define COL3        P02                                                

  86.         #define COL4        P03

  87. */

  88. 

  89. u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  90. 

  91. void Task_1( void )

  92. {

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

  94.          COL1 = 0;

  95.         COL2 = 0;

  96.         COL3 = 0;

  97.         COL4 = 0;

  98.         ROW1 = 1;

  99.         ROW2 = 1;

  100.         

  101.         if((ROW1 == 0) || (ROW2 == 0))                        //"||"或的符号，只要满足其中之一的条件(行按键按下)

  102.         {

  103.                 if((ROW1 == 0) && (ROW2 == 0))                //如果两行都有按键按下，不处理

  104.                 {

  105.                 

  106.                 }

  107.                 else if ( ((ROW1 == 1)&&(ROW2 == 0)) || ((ROW1 == 0)&&(ROW2 == 1)) )        //如果有按键按下，而且只有一颗

  108.                 {

  109.                         if( ROW1 == 0 )                                        //判断哪一行，输出行开始的序号

  110.                                 key_num = 0;

  111.                         else if(ROW2 == 0)

  112.                                 key_num = 4;

  113.                         

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

  115.                         COL1 = 1;

  116.                         COL2 = 1;

  117.                         COL3 = 1;

  118.                         COL4 = 1;

  119.                         ROW1 = 0;

  120.                         ROW2 = 0;

  121.                         

  122.                         //判断哪一列，叠加按键的序号

  123.                         if(COL1 ==0)                

  124.                         {

  125. //                                key_num = key_num +0;

  126.                         }

  127.                         else if( COL2 == 0)

  128.                         {

  129.                                 key_num = key_num +1;

  130.                         }

  131.                         else if( COL3 == 0)

  132.                         {

  133.                                 key_num = key_num +2;

  134.                         }

  135.                         else if( COL4 == 0)

  136.                         {

  137.                                 key_num = key_num +3;

  138.                         }

  139.                 }

  140.                 COL1 = 0;

  141.                 COL2 = 0;

  142.                 COL3 = 0;

  143.                 COL4 = 0;

  144.                 ROW1 = 1;

  145.                 ROW2 = 1;

  146.         }

  147.         else

  148.         {

  149.                 key_num =0xff;

  150.         }

  151.                                                                         

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

  153. }

  154. 

  155. void Init_595(void)

  156. {

  157.         HC595_SER  = 0;

  158.         HC595_RCK  = 0;

  159.         HC595_SCK  = 0;

  160. }

  161. 

  162. 

  163. void Send_595( u8 dat )

  164. {

  165.         u8 i;

  166.         

  167.         for( i=0; i<8; i++ )

  168.         {

  169.                 dat <<= 1;                        //数值左移一位

  170.                 HC595_SER  = CY;        //数据写到引脚

  171.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  172.         HC595_SCK  = 0;

  173.         }

  174. }

  175. 

  176. 

  177. void Display_Seg( u8 HC595_1,u8 HC595_2)

  178. {

  179.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  180.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  181.         

  182.         HC595_RCK  = 1;                        //数据输出

  183.         HC595_RCK  = 0;

  184. }

  185. 

  186. //void SEG_Task(void)

  187. //{

  188. //        if(key_num == 255)

  189. //                Display_Seg( SEG_NUM[17], ~T_NUM[0]);        //数码管段码和位码

  190. //        else

  191. //                Display_Seg( SEG_NUM[ key_num ], ~T_NUM[0]);        //数码管段码和位码

  192. //}        

  193. 

  194. //任务二：简易密码箱

  195. u8 passward[8] = { 22,22,22,22,19,21,0,0};

  196. extern u16 Ms_Time;

  197. u8 Start_ms=0;

  198. //延时三秒函数

  199. void Timing_Start(void)

  200. {

  201.         

  202.         if(Start_ms==0)

  203.                 {

  204.                 

  205.                 if(Ms_Time==3000)

  206.                 {

  207.                         passward[0] = 20;

  208.                         passward[1] = 20;

  209.                         passward[2] = 20;

  210.                         passward[3] = 20;

  211.                         passward[4] = 20;

  212.                         passward[5] = 20;

  213.                         passward[6] = 20;

  214.                         passward[7] = 20;                        

  215.                         

  216.                         Start_ms=1;

  217.                 }

  218.                 }

  219. 

  220. }

  221. 

  222. u8 Seg_no = 0;

  223. void SEG_Task(void)

  224. {

  225.                 u8 num = 0;

  226. 

  227.         switch(Seg_no){

  228.                 case 0: Display_Seg( SEG_NUM[passward[0]], ~T_NUM[0] );                   break;

  229.                 case 1: Display_Seg( SEG_NUM[passward[1]], ~T_NUM[1] );         break;

  230.                 case 2: Display_Seg( SEG_NUM[passward[2]], ~T_NUM[2] );                   break;

  231.                 case 3: Display_Seg( SEG_NUM[passward[3]], ~T_NUM[3] );                   break;

  232.                 case 4: Display_Seg( SEG_NUM[passward[4]], ~T_NUM[4] );                   break;

  233.                 case 5: Display_Seg( SEG_NUM[passward[5]], ~T_NUM[5] );                   break;

  234.                 case 6: Display_Seg( SEG_NUM[passward[6]], ~T_NUM[6] );         break;

  235.                 case 7: Display_Seg( SEG_NUM[passward[7]], ~T_NUM[7] );         break;

  236.         }

  237.         Seg_no ++;

  238.         if( Seg_no>7 )

  239.                 Seg_no=0;                

  240. }

  241. u8 Key_Vol3 = 0;                                                //判断按钮是否按下

  242. u8 Key_no = 0;                                                        //数码管位计数

  243. //密码输入显示

  244. void PW_write_Task(void)

  245. {

  246.         if( key_num <0xff )

  247.                 {

  248.                         Key_Vol3 ++;

  249.                         if(Key_Vol3 == 5)                        //是否延时50m秒

  250.                           {

  251. 

  252.                                 passward[Key_no] = key_num; //键值传递

  253.                                 Key_no++;

  254. 

  255.                                 if( Key_no == 8 )                //密码输入到了八位

  256.                                 {

  257.                                         if((passward[0]==1)&&(passward[1]==2)&&(passward[2]==3)&&(passward[3]==4)&&(passward[4]==5)&&(passward[5]==6)&&(passward[6]==7)&&(passward[7]==0))

  258.                                         {

  259.                                                 //密码正确八位数码管显示为1

  260.                                                 passward[0] = 21;

  261.                                                 passward[1] = 21;

  262.                                                 passward[2] = 17;

  263.                                                 passward[3] = 18;

  264.                                                 passward[4] = 14;

  265.                                                 passward[5] = 16;

  266.                                                 passward[6] = 21;

  267.                                                 passward[7] = 21;

  268.                                                 

  269.                                         }

  270.                                         else                                 //密码输入错误八位数码管显示为空

  271.                                         {

  272.                                                 passward[0] = 20;

  273.                                                 passward[1] = 20;

  274.                                                 passward[2] = 20;

  275.                                                 passward[3] = 20;

  276.                                                 passward[4] = 20;

  277.                                                 passward[5] = 20;

  278.                                                 passward[6] = 20;

  279.                                                 passward[7] = 20;

  280.                                         } 

  281.                                         

  282.                                         

  283.                                         Key_no = 0;

  284.                                 }

  285.                                         

  286.                         }        

  287.                 }

  288.                 else

  289.                 {

  290.                         Key_Vol3 = 0;        

  291.                 }

  292. 

  293. }
复制代码

demo1.rar (192.55 KB, 下载次数: 0)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 2025-8-16 15:33:28 | 显示全部楼层
13 外部中断

屏幕截图 2025-08-06 154347.png 
  1. io.c

  2. //外部中断INT1 函数

  3. void INT1_Init(void)

  4. {

  5.         IT1 = 1;                //下降沿中断

  6.         EX1 = 1;                //下降中断允许

  7.         EA = 1;                        //打开总中断

  8. }

  9. 

  10. //中断服务函数，一旦发生了中断就先执行“中断服务函数”

  11. void INI1_Isr(void) interrupt 2

  12. {

  13.         P01 = !P01;

  14. }

  15. 

  16. 

  17. io.h

  18. void INT1_Init(void);  外部中断INT1 函数声明

  19. 

  20. main.c

  21. #include "config.h"

  22. #include "task.h"

  23. #include "io.h"

  24. //延时函数

  25. void Delay3000ms(void)        //@24.000MHz

  26. {

  27.         unsigned long edata i;

  28. 

  29.         _nop_();

  30.         _nop_();

  31.         i = 17999998UL;

  32.         while (i) i--;

  33. }

  34. 

  35. 

  36. void main(void)

  37. {

  38.         

  39.         Sys_init();                                        //系统初始化

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

  41.         

  42.         IE2 |= 0x80;                //使能USB中断

  43.         Timer0_Init();                                //定时器初始化

  44.         Init_595();

  45.         INT1_Init();                                //外部中断int1初始化

  46.         

  47.         EA = 1;

  48.         P40 = 0;

  49. //        WDT_CONTR = 0X24;

  50.         while(1)

  51.         {

  52.                  if (bUsbOutReady)

  53.         {

  54. //            USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）

  55.             usb_OUT_done();

  56.         }

  57. //                Task_Pro_Handler_Callback();                                //执行功能函数

  58. //                WDT_CONTR = 0X34;

  59.                 

  60.                 /*延时三秒钟P00LED灯取反一次 */

  61.                 P00 = !P00;

  62.                 Delay3000ms();

  63. 

  64.                         

  65.                 

  66.         }

  67.         

  68. }

  69. void Timer0_Isr(void) interrupt 1

  70. {

  71.         

  72.         Task_Marks_Handler_Callback();                        //系统计时

  73. ;

  74. }
复制代码

demo1.rar (185.4 KB, 下载次数: 0)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 昨天 20:03 | 显示全部楼层
13.外部中断 课后小练 雕刻机保护系统

屏幕截图 2025-08-23 195146.png
io.c代码
  1. #include "io.h"

  2. #define LED04 P04

  3. u8 SEG_NUM[] = 

  4. {

  5.     0x3F,       /*'0', 0*/

  6.     0x06,       /*'1', 1*/

  7.     0x5B,       /*'2', 2*/

  8.     0x4F,       /*'3', 3*/

  9.     0x66,       /*'4', 4*/

  10.     0x6D,       /*'5', 5*/

  11.     0x7D,       /*'6', 6*/

  12.     0x07,       /*'7', 7*/

  13.     0x7F,       /*'8', 8*/

  14.     0x6F,       /*'9', 9*/

  15.     0x77,       /*'A', 10*/

  16.     0x7C,       /*'B', 11*/

  17.     0x39,       /*'C', 12*/

  18.     0x5E,       /*'D', 13*/

  19.     0x79,       /*'E', 14*/

  20.     0x71,       /*'F', 15*/

  21.     0x54,       /*'N', 16*/

  22.     0x5C,       /*'O', 17*/

  23.     0x73,       /*'P', 18*/

  24.     0x50,       /*'R', 19*/

  25.     0x40,       /*'-', 20*/

  26.     0x00,       /*' ', 21*/

  27.     0x80,       /*'.', 22*/

  28. };

  29. 

  30. u8 T_NUM[8] = 

  31. {

  32.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  33. };

  34. 

  35. /*

  36. ----------行------------

  37.         #define ROW1        P06                //定义端口

  38.         #define ROW2        P07

  39. ----------列-------------

  40.         #define COL1        P00

  41.         #define COL2        P01

  42.         #define COL3        P02                                                

  43.         #define COL4        P03

  44. */

  45. 

  46. u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  47. 

  48. //矩阵键盘扫描

  49. void Task_1( void )

  50. {

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

  52.          COL1 = 0;

  53.         COL2 = 0;

  54.         COL3 = 0;

  55.         COL4 = 0;

  56.         ROW1 = 1;

  57.         ROW2 = 1;

  58.         

  59.         if((ROW1 == 0) || (ROW2 == 0))                        //"||"或的符号，只要满足其中之一的条件(行按键按下)

  60.         {

  61.                 if((ROW1 == 0) && (ROW2 == 0))                //如果两行都有按键按下，不处理

  62.                 {

  63.                         key_num = 0xff;

  64.                 }

  65.                 else if ( ((ROW1 == 1)&&(ROW2 == 0)) || ((ROW1 == 0)&&(ROW2 == 1)) )        //如果有按键按下，而且只有一颗

  66.                 {

  67.                         if( ROW1 == 0 )                                        //判断哪一行，输出行开始的序号

  68.                                 key_num = 0;

  69.                         else if(ROW2 == 0)

  70.                                 key_num = 4;

  71.                         

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

  73.                         COL1 = 1;

  74.                         COL2 = 1;

  75.                         COL3 = 1;

  76.                         COL4 = 1;

  77.                         ROW1 = 0;

  78.                         ROW2 = 0;

  79.                         

  80.                         //判断哪一列，叠加按键的序号

  81.                         if(COL1 == 0)                key_num += 0;

  82.                         else if(COL2 == 0)        key_num += 1;

  83.                         else if(COL3 == 0)        key_num += 2;

  84.                         else if(COL4 == 0)        key_num += 3;                

  85.                 }

  86.         }

  87.         else

  88.         {

  89.                 key_num = 0xff;                // 无按键按下

  90.         }

  91.                 

  92.                                                                 

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

  94.         COL1 = 1;

  95.         COL2 = 1;

  96.         COL3 = 1;

  97.         COL4 = 1;

  98.         ROW1 = 1;

  99.         ROW2 = 1;

  100. }

  101. 

  102. void LED_Control_Task(void)

  103. {        

  104.             // 根据工作状态控制LED0

  105.     if(is_working)

  106.         LED0 = 0;  // 低电平点亮LED0

  107.     else

  108.         LED0 = 1;  // 高电平熄灭LED0

  109. }

  110. 

  111. u8 Key_vol = 0;

  112. u8 is_working = 0;      // 工作状态：0-停止，1-工作

  113. u8 key_press_flag = 0;  // 按键消抖标志（防止重复触发）

  114. void KEY_Task(void)

  115. {

  116.          //static u8 key_press_flag = 0;  // 按键按下标志

  117.     

  118.     // 检测到按钮1按下且未处理过

  119.     if(key_num == 1 && key_press_flag == 0)

  120.     {

  121.         key_press_flag = 1;         // 标记为已处理

  122.         is_working = !is_working;   // 切换工作状态

  123.     }

  124.     // 按键释放后重置标志

  125.     else if(key_num == 0xff)

  126.     {

  127.         key_press_flag = 0;

  128.     }

  129.                 

  130. }

  131. void Init_595(void)

  132. {

  133.         HC595_SER  = 0;

  134.         HC595_RCK  = 0;

  135.         HC595_SCK  = 0;

  136. }

  137. 

  138. 

  139. void Send_595( u8 dat )

  140. {

  141.         u8 i;

  142.         

  143.         for( i=0; i<8; i++ )

  144.         {

  145.                 dat <<= 1;                        //数值左移一位

  146.                 HC595_SER  = CY;        //数据写到引脚

  147.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  148.         HC595_SCK  = 0;

  149.         }

  150. }

  151. 

  152. 

  153. void Display_Seg( u8 HC595_1,u8 HC595_2)

  154. {

  155.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  156.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  157.         

  158.         HC595_RCK  = 1;                        //数据输出

  159.         HC595_RCK  = 0;

  160. }

  161. 

  162. 

  163. u8 Seg_no = 0;

  164. void SEG_Task(void)

  165. {

  166.             // 显示工作状态：1表示工作，0表示停止

  167.     u8 disp_num = is_working ? 1 : 0;

  168.     

  169.     switch(Seg_no)

  170.     {

  171.         case 0: Display_Seg(SEG_NUM[disp_num], ~T_NUM[0]); break;

  172.         case 1: Display_Seg(SEG_NUM[21], ~T_NUM[1]); break;  // 空格

  173.         // 其他位不显示

  174.         case 2: Display_Seg(SEG_NUM[21], ~T_NUM[2]); break;

  175.         case 3: Display_Seg(SEG_NUM[21], ~T_NUM[3]); break;

  176.         case 4: Display_Seg(SEG_NUM[21], ~T_NUM[4]); break;

  177.         case 5: Display_Seg(SEG_NUM[21], ~T_NUM[5]); break;

  178.         case 6: Display_Seg(SEG_NUM[21], ~T_NUM[6]); break;

  179.         case 7: Display_Seg(SEG_NUM[21], ~T_NUM[7]); break;

  180.     }

  181.     Seg_no = (Seg_no + 1) % 8;

  182. }

  183. 

  184. //外部中断INT1 函数

  185. void INT1_Init(void)

  186. {

  187.         IT1 = 1;                //下降沿中断

  188.         EX1 = 1;                //下降中断允许

  189.         EA = 1;                        //打开总中断

  190.         P33 = 1;

  191. }

  192. 

  193. //中断服务函数，一旦发生了中断就先执行“中断服务函数”

  194. void INT1_Isr(void) interrupt 2

  195. {

  196.     // 测试：按下P33时，数码管0位显示0（模拟切断电源）

  197.     is_working = 0;  // 停止工作状态

  198.     // 清除中断标志（部分单片机需手动清除，防止重复触发）

  199.     IE1 = 0;        // 显式清除INT1中断标志

  200. }

复制代码

demo1.rar (185.12 KB, 下载次数: 0)

回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 昨天 20:08 | 显示全部楼层
14.IO中断（所有普通IO都支持“外部中断”）

屏幕截图 2025-08-20 170442.png
io.c
  1. //IO口中断函数

  2. //数码管显示0：执行while函数  1：执行P3_IO中断   2：执行P4_IO中断 

  3. void P3_IO_Init(void)

  4. {

  5.         P3IM0 = 0x00;                //选择合适的中断模式--下降沿中断

  6.         P3IM1 = 0xff;

  7.         

  8.         P3INTE = 0x08;                //使能端口中断功能

  9. }

  10. void P3_IO_ISR(void) interrupt 40

  11. {

  12.         u8 intf;

  13.         

  14.         intf = P3INTF;

  15.         

  16.         if(intf)

  17.         {

  18.                 P3INTF = 0;

  19.                 

  20.                 if(intf & 0x08)

  21.                 {

  22.                         passward[0] = 1;

  23.                         //P01 = !P01;

  24.                 }

  25.         }

  26. }

  27. 

  28. void P4_IO_Init(void)

  29. {

  30.         P4IM0 = 0x00;                //选择合适的中断模式--低电平中断

  31.         P4IM1 = 0xff;

  32.         

  33.         P4INTE = 0x80;                //使能端口中断功能

  34.         

  35.         PINIPH = 0X00;

  36.         PINIPL = 0X10;

  37. }

  38. void P4_IO_ISR(void) interrupt 41

  39. {

  40.         u8 intf;

  41.         

  42.         intf = P4INTF;

  43.         

  44.         if(intf)

  45.         {

  46.                 P4INTF = 0;

  47.                 

  48.                 if(intf & 0x80)

  49.                 {

  50.                         passward[0] = 2;

  51.                         //P01 = !P01;

  52.                 }

  53.         }

  54. }
复制代码
main.c文件部分代码
  1. main.c文件部分代码

  2. void main(void)

  3. {

  4.         

  5.         Sys_init();                                        //系统初始化

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

  7.         

  8.         IE2 |= 0x80;                //使能USB中断

  9.         Timer0_Init();                                //定时器初始化

  10.         Init_595();

  11. //        INT1_Init();                                //外部中断int1初始化

  12.         P3_IO_Init();                                //IO中断初始化

  13.         P4_IO_Init();

  14.         

  15.         EA = 1;

  16.         P40 = 0;

  17. //        WDT_CONTR = 0X24;

  18.         while(1)

  19.         {

  20.                  if (bUsbOutReady)

  21.         {

  22. //            USB_SendData(UsbOutBuffer,OutNumber);   //发送数据缓冲区，长度（接收数据原样返回, 用于测试）

  23.             usb_OUT_done();

  24.         }

  25.                 Task_Pro_Handler_Callback();                                //执行功能函数

  26.                 

  27.                 passward[0] = 0;

  28. //                WDT_CONTR = 0X34;

  29.                 

  30.                 /*延时三秒钟P00LED灯取反一次 */

  31. //                P00 = !P00;

  32. //                Delay3000ms();

  33.         

  34.         }

  35.         

  36. }

  37. config.c部分代码

  38. void Timer0_Init(void)                //1毫秒@24.000MHz                //定时器函数定义

  39. {

  40.         TM0PS = 0x00;                        //设置定时器时钟预分频 ( 注意:并非所有系列都有此寄存器,详情请查看数据手册 )

  41.         AUXR &= 0x7F;                        //定时器时钟12T模式

  42.         TMOD &= 0xF0;                        //设置定时器模式

  43.         TL0 = 0x30;                                //设置定时初始值

  44.         TH0 = 0xF8;                                //设置定时初始值

  45.         TF0 = 0;                                //清除TF0标志

  46.         TR0 = 1;                                //定时器0开始计时

  47.         ET0 = 1;                                //使能定时器0中断

  48.         

  49.         IPH |= (1<<1);

  50.         IP  |= (1<<1);

  51. }
复制代码

demo1.rar (187.51 KB, 下载次数: 0)
回复

使用道具 举报 送花
飞***
  • 打卡等级：常住居民III
  • 打卡总天数：107
  • 最近打卡：2025-08-23 08:40:09

2

主题

47

回帖

205

积分

中级会员

积分
205
发表于 昨天 22:07 | 显示全部楼层
14 IO中断（所有普通IO都支持“外部中断”） 课后小练  多路抢答器

屏幕截图 2025-08-23 201059.png

功能说明
1核心功能：
        上电后第一位数码管显示0（等待抢答）。
        矩阵键盘按键 1（第一行第一列）对应用户 1，按下后显示1并锁定。
        矩阵键盘按键 2（第一行第二列）对应用户 2，按下后显示2并锁定。
        矩阵键盘按键 3（第一行第三列）对应用户 3，按下后显示3并锁定。
        锁定后不再响应其他按键，确保优先抢答的公平性。
2复位功能：
        按矩阵键盘按键 4（第一行第四列）可复位，数码管恢复显示0，解除锁定，允许新一轮抢答。v

io.c
  1. #include "io.h"

  2. 

  3. u8 SEG_NUM[] = 

  4. {

  5.     0x3F,       /*'0', 0*/

  6.     0x06,       /*'1', 1*/

  7.     0x5B,       /*'2', 2*/

  8.     0x4F,       /*'3', 3*/

  9.     0x66,       /*'4', 4*/

  10.     0x6D,       /*'5', 5*/

  11.     0x7D,       /*'6', 6*/

  12.     0x07,       /*'7', 7*/

  13.     0x7F,       /*'8', 8*/

  14.     0x6F,       /*'9', 9*/

  15.     0x77,       /*'A', 10*/

  16.     0x7C,       /*'B', 11*/

  17.     0x39,       /*'C', 12*/

  18.     0x5E,       /*'D', 13*/

  19.     0x79,       /*'E', 14*/

  20.     0x71,       /*'F', 15*/

  21.     0x54,       /*'N', 16*/

  22.     0x5C,       /*'O', 17*/

  23.     0x73,       /*'P', 18*/

  24.     0x50,       /*'R', 19*/

  25.     0x40,       /*'-', 20*/

  26.     0x00,       /*' ', 21*/

  27.     0x80,       /*'.', 22*/

  28. };

  29. 

  30. u8 T_NUM[8] = 

  31. {

  32.         0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80

  33. };

  34. 

  35. /*

  36. ----------行------------

  37.         #define ROW1        P06                //定义端口

  38.         #define ROW2        P07

  39. ----------列-------------

  40.         #define COL1        P00

  41.         #define COL2        P01

  42.         #define COL3        P02                                                

  43.         #define COL4        P03

  44. */

  45. 

  46. u8 key_num = 0xff;                //key_num =0 给按键传递一个键值

  47. 

  48. // 抢答核心变量

  49. u8 answerFlag = 0;                // 抢答结果（0-未抢答，1-3对应用户1-3）

  50. bit isAnswered = 0;                // 抢答锁定标志（0-未锁定，1-已锁定）

  51. 

  52. //显示缓存

  53. u8 passward[8] = { 21,21,21,21,21,21,21,21};

  54. u8 Seg_no = 0;

  55. 

  56. // 延时函数（消抖用）

  57. void delay_ms(u16 ms)

  58. {

  59.     u16 i, j;

  60.     for(i = 0; i < ms; i++)

  61.         for(j = 0; j < 120; j++);

  62. }

  63. 

  64. void Init_595(void)

  65. {

  66.         HC595_SER  = 0;

  67.         HC595_RCK  = 0;

  68.         HC595_SCK  = 0;

  69. }

  70. 

  71. 

  72. void Send_595( u8 dat )

  73. {

  74.         u8 i;

  75.         

  76.         for( i=0; i<8; i++ )

  77.         {

  78.                 dat <<= 1;                        //数值左移一位

  79.                 HC595_SER  = CY;        //数据写到引脚

  80.             HC595_SCK  = 1;                //输出上升沿的时钟信号

  81.         HC595_SCK  = 0;

  82.         }

  83. }

  84. 

  85. 

  86. void Display_Seg( u8 HC595_1,u8 HC595_2)

  87. {

  88.         Send_595(HC595_1);                //数码管段码输出        高电平点亮

  89.         Send_595(HC595_2);                //数码管位码输出        低电平点亮

  90.         

  91.         HC595_RCK  = 1;                        //数据输出

  92.         HC595_RCK  = 0;

  93. }

  94. 

  95. 

  96. 

  97. void SEG_Task(void)

  98. {

  99.                 u8 num = 0;

  100. 

  101.         switch(Seg_no){

  102.                 case 0: Display_Seg( SEG_NUM[passward[0]], ~T_NUM[0] );                   break;

  103.                 case 1: Display_Seg( SEG_NUM[passward[1]], ~T_NUM[1] );         break;

  104.                 case 2: Display_Seg( SEG_NUM[passward[2]], ~T_NUM[2] );                   break;

  105.                 case 3: Display_Seg( SEG_NUM[passward[3]], ~T_NUM[3] );                   break;

  106.                 case 4: Display_Seg( SEG_NUM[passward[4]], ~T_NUM[4] );                   break;

  107.                 case 5: Display_Seg( SEG_NUM[passward[5]], ~T_NUM[5] );                   break;

  108.                 case 6: Display_Seg( SEG_NUM[passward[6]], ~T_NUM[6] );         break;

  109.                 case 7: Display_Seg( SEG_NUM[passward[7]], ~T_NUM[7] );         break;

  110.         }

  111.         Seg_no ++;

  112.         if( Seg_no>7 )

  113.                 Seg_no=0;                

  114. }

  115. // 矩阵键盘扫描任务（核心修改：识别1、2、3键并处理抢答）

  116. void Task_1(void) {

  117.     static u8 key_stable = 0;  // 按键稳定计数（消抖）

  118. 

  119.     // 第一步：扫描行

  120.     COL1 = 0; COL2 = 0; COL3 = 0; COL4 = 0;  // 列线拉低

  121.     ROW1 = 1; ROW2 = 1;                      // 行线拉高

  122.     delay_ms(1);  // 稳定电平

  123. 

  124.     // 检测是否有按键按下

  125.     if((ROW1 == 0) || (ROW2 == 0)) {

  126.         key_stable++;

  127.         if(key_stable >= 3) {  // 连续3次检测到按键（消抖）

  128.             // 第二步：确定行

  129.             if(ROW1 == 0) {  // 第一行（对应按键1、2、3、4）

  130.                 // 第三步：扫描列确定具体按键

  131.                 ROW1 = 0; ROW2 = 1;  // 锁定第一行

  132.                 COL1 = 1; COL2 = 1; COL3 = 1; COL4 = 1;  // 列线拉高

  133.                 delay_ms(1);

  134. 

  135.                 if(COL1 == 0) key_num = 0;  // 按键1（第一行第一列）

  136.                 else if(COL2 == 0) key_num = 1;  // 按键2（第一行第二列）

  137.                 else if(COL3 == 0) key_num = 2;  // 按键3（第一行第三列）

  138.                 else if(COL4 == 0) key_num = 3;  // 按键4（作为复位键）

  139.             }

  140.             // 处理抢答逻辑

  141.             if(!isAnswered) {  // 未锁定时响应

  142.                 switch(key_num) {

  143.                     case 0:  // 用户1（按键1）

  144.                         answerFlag = 1;

  145.                         passward[0] = 1;  // 显示1

  146.                         isAnswered = 1;  // 锁定

  147.                         break;

  148.                     case 1:  // 用户2（按键2）

  149.                         answerFlag = 2;

  150.                         passward[0] = 2;  // 显示2

  151.                         isAnswered = 1;  // 锁定

  152.                         break;

  153.                     case 2:  // 用户3（按键3）

  154.                         answerFlag = 3;

  155.                         passward[0] = 3;  // 显示3

  156.                         isAnswered = 1;  // 锁定

  157.                         break;

  158.                 }

  159.             }

  160.             // 复位功能（按键4作为复位键）

  161.             if(key_num == 3) {

  162.                 delay_ms(10);

  163.                 if(COL4 == 0) {

  164.                     answerFlag = 0;

  165.                     passward[0] = 0;  // 恢复显示0

  166.                     isAnswered = 0;  // 解除锁定

  167.                 }

  168.             }

  169.         }

  170.     } else {

  171.         key_num = 0xff;  // 无按键

  172.         key_stable = 0;  // 重置稳定计数

  173.     }

  174.     // 恢复引脚状态

  175.     COL1 = 0; COL2 = 0; COL3 = 0; COL4 = 0;

  176.     ROW1 = 1; ROW2 = 1;

  177. }

  178. 

  179. // 初始化显示（上电显示0）

  180. void Display_Init(void) {

  181.     Init_595();

  182.     passward[0] = 0;  // 初始显示0

  183. }

  184. 

  185. // 注释不需要的IO中断函数（改用矩阵键盘扫描）

  186. void P3_IO_Init(void) {

  187.     // 禁用原P3中断，避免冲突

  188.     P3INTE = 0x00;

  189. }

  190. void P4_IO_Init(void) {

  191.     // 禁用原P4中断，避免冲突

  192.     P4INTE = 0x00;

  193. }

复制代码

demo1.rar (184.29 KB, 下载次数: 0)
回复

使用道具 举报 送花
123
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|深圳国芯人工智能有限公司 ( 粤ICP备2022108929号-2 )

GMT+8, 2025-8-24 04:07 , Processed in 1.748875 second(s), 90 queries .

Powered by Discuz! X3.5

© 2001-2025 Discuz! Team.

快速回复 返回顶部 返回列表