矩阵键盘时钟

2023-05-16


#include<reg52.h> //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义
#include<intrins.h>
#include "i2c.h"

sbit RS = P2^6;   //定义端口 
sbit RW = P2^5;
sbit EN = P2^7;
sbit Beep = P3^0;

/*sbit KEY1 = P1^0; //暂停
sbit KEY2 = P1^1;   //开始
sbit KEY3 = P1^2;   //选择哪一位操作
sbit KEY4 = P1^3;   //++
sbit KEY5 = P1^4;   //--
sbit KEY6 = P1^5;*/

#define GPIO_KEY P1
#define RS_CLR RS=0 
#define RS_SET RS=1

#define RW_CLR RW=0 
#define RW_SET RW=1 

#define EN_CLR EN=0
#define EN_SET EN=1

#define DataPort P0

char hour,min,sec;
unsigned int kkk;
unsigned char flag = 1;
unsigned char num = 0;
unsigned char local = 0;
unsigned char weizhi;
unsigned char KeyValue;
char clhour,clmin,clsec,clock = 0;
//unsigned char hour1[] = "change hour";
//unsigned char min1[]  = "change min";
//unsigned char sec1[]  = "change sec";
unsigned char KeyScan(void);
/*------------------------------------------------
 uS延时函数，含有输入参数 unsigned char t，无返回值
 unsigned char 是定义无符号字符变量，其值的范围是
 0~255 这里使用晶振12M，精确延时请使用汇编,大致延时
 长度如下 T=tx2+5 uS 
------------------------------------------------*/
void DelayUs2x(unsigned char t)
{   
 while(--t);
}
/*------------------------------------------------
 mS延时函数，含有输入参数 unsigned char t，无返回值
 unsigned char 是定义无符号字符变量，其值的范围是
 0~255 这里使用晶振12M，精确延时请使用汇编
------------------------------------------------*/
void DelayMs(unsigned char t)
{

 while(t--)
 {
     //大致延时1mS
     DelayUs2x(245);
     DelayUs2x(245);
 }
}
/*------------------------------------------------
              判忙函数
------------------------------------------------*/
 bit LCD_Check_Busy(void) 
 { 
 DataPort= 0xFF; 
 RS_CLR; 
 RW_SET; 
 EN_CLR; 
 _nop_(); 
 EN_SET;
 return (bit)(DataPort & 0x80);
 }
/*------------------------------------------------
              写入命令函数
------------------------------------------------*/
 void LCD_Write_Com(unsigned char com) 
 {  
// while(LCD_Check_Busy()); //忙则等待
 DelayMs(5);
 RS_CLR; 
 RW_CLR; 
 EN_SET; 
 DataPort= com; 
 _nop_(); 
 EN_CLR;
 }
/*------------------------------------------------
              写入数据函数
------------------------------------------------*/
 void LCD_Write_Data(unsigned char Data) 
 { 
 //while(LCD_Check_Busy()); //忙则等待
 DelayMs(5);
 RS_SET; 
 RW_CLR; 
 EN_SET; 
 DataPort= Data; 
 _nop_();
 EN_CLR;
 }

/*------------------------------------------------
                清屏函数
------------------------------------------------*/
 void LCD_Clear(void) 
 { 
 LCD_Write_Com(0x01); 
 DelayMs(5);
 }
/*------------------------------------------------
              写入字符串函数
------------------------------------------------*/
 void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s) 
 {     
 if (y == 0) 
    {     
     LCD_Write_Com(0x80 + x);     
    }
 else 
    {     
    LCD_Write_Com(0xC0 + x);     
    }        
 while (*s) 
    {     
 LCD_Write_Data( *s);     
 s ++;     
    }
 }
/*------------------------------------------------
              写入字符函数
------------------------------------------------*/
 void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data) 
 {     
 if (y == 0) 
    {     
    LCD_Write_Com(0x80 + x);     
    }    
 else 
    {     
    LCD_Write_Com(0xC0 + x);     
    }        
 LCD_Write_Data( Data);  
 }
/*------------------------------------------------
              初始化函数
------------------------------------------------*/
 void LCD_Init(void) 
 {
   LCD_Write_Com(0x38);    /*显示模式设置*/ 
   DelayMs(5); 
   LCD_Write_Com(0x38); 
   DelayMs(5); 
   LCD_Write_Com(0x38); 
   DelayMs(5); 
   LCD_Write_Com(0x38);  
   LCD_Write_Com(0x08);    /*显示关闭*/ 
   LCD_Write_Com(0x01);    /*显示清屏*/ 
   LCD_Write_Com(0x06);    /*显示光标移动设置*/ 
   DelayMs(5); 
   LCD_Write_Com(0x0C);    /*显示开及光标设置*/
   }
void Delay(unsigned char i)
{
    while(i--);
}


/*------------------------------------------------
                    主函数
------------------------------------------------*/ 
void main(void) 
{ 
//unsigned char i; 
//unsigned char *p; 

LCD_Init(); 

/*while (1) 
 {  
 i = 1;  
 p = "1234567890";  
 LCD_Clear();  
 LCD_Write_String(2,0,"Welcome to");  
 DelayMs(250);   
 while (*p) 
    {   
    LCD_Write_Char(i,1,*p);   
    i ++;   
    p ++;   
    DelayMs(250);   
    }  
  DelayMs(250);  
 } */

    TMOD = 0x01;        //定时器模式，工作方式是十六位定时器
    TH0 = 0x3c;
    TL0 = 0xb0;
    EA = 1;
    ET0 = 1;
    TR0 = 1;


    hour = 12;
    min = 59;
    sec = 55;
    //Beep= 0;


    while(1)
    {

         num = KeyScan();

         if(num == 1)
         {
            flag = 0;
         }
         if(num == 2)
         {
            flag = 1;
         }
         if(num == 3)
         {
            local++;
            if(local == 6)
            {
                local = 0;
            }
            switch(local)
            {
                case 5://LCD_Clear();
                       /*LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change sec01");*/
                       LCD_Write_Char(14,0,' ');
                       DelayMs(50);
                       break;
                case 4://LCD_Clear();
                       LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change sec10");
                       break;
                case 3://LCD_Clear();
                       LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change min01");
                       break;
                case 2://LCD_Clear();
                       LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change min10");
                       break;
                case 1://LCD_Clear();
                       LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change hou01");
                       break;
                case 0://LCD_Clear();
                       LCD_Write_Com(0x01);
                       LCD_Write_String(2,1,"change hou10");
                       break;
            }
            //LCD_Clear();
         }
         if(num == 4)
         {
            if(clock == 0)
            {
                switch(local)
                {
                    case 5:sec++;
                        if(sec >= 60)
                        {
                            min++;
                            sec = 0;
                        }break;
                    case 4:sec += 10;
                        if(sec >= 60)
                        {
                            min++;
                            sec = 0;
                        }break;
                    case 3:min++;
                        if(min >= 60)
                        {
                           hour++;
                           min = 0;
                        }break;
                    case 2:min += 10;
                        if(min >= 60)
                        {
                           hour++;
                           min = 0;
                        }break;
                    case 1:hour++;
                        if(hour >= 24)
                        {
                           sec = 0;
                           min = 0;
                           hour = 0;
                        }break;
                    case 0:hour += 10;
                        if(hour >= 24)
                        {
                           sec = 0;
                           min = 0;
                           hour = 0;
                        }break; 
                }
            }
            else if(clock == 1)
            {
                switch(local)
                {
                    case 5:clsec++;
                        if(clsec >= 60)
                        {
                            clmin++;
                            clsec = 0;
                        }break;
                    case 4:clsec += 10;
                        if(clsec >= 60)
                        {
                            clmin++;
                            clsec = 0;
                        }break;
                    case 3:clmin++;
                        if(clmin >= 60)
                        {
                           clhour++;
                           clmin = 0;
                        }break;
                    case 2:clmin += 10;
                        if(clmin >= 60)
                        {
                           clhour++;
                           clmin = 0;
                        }break;
                    case 1:clhour++;
                        if(clhour >= 24)
                        {
                           clsec = 0;
                           clmin = 0;
                           clhour = 0;
                        }break;
                    case 0:clhour += 10;
                        if(clhour >= 24)
                        {
                           clsec = 0;
                           clmin = 0;
                           clhour = 0;
                        }break; 
                }
            }
         }
         if(num == 5)
         {
            if(clock == 0)
            {
                switch(local)
                {
                    case 5:sec--;
                           if(sec <= 0)
                           {
                                min--;
                                sec = 0;
                           }break;
                    case 4:sec -= 10;
                           if(sec <= 0)
                           {
                                min--;
                                sec = 0;
                           }break;
                    case 3:min--;
                           if(min <= 0)
                           {
                               hour--;
                               min = 59;
                           }break;
                    case 2:min -= 10;
                           if(min <= 0)
                           {
                               hour--;
                               min = 59;
                           }break;
                    case 1:hour--;
                           if(hour <= 0)
                           {
                               sec = 0;
                               min = 0;
                               hour = 0;
                           }break;
                    case 0:hour -= 10;
                           if(hour <= 0)
                           {
                               sec = 0;
                               min = 0;
                               hour = 0;
                           }break;
                }
            }
            else if(clock == 1)
            {
                switch(local)
                {
                    case 5:clsec--;
                           if(clsec <= 0)
                           {
                                clmin--;
                                clsec = 0;
                           }break;
                    case 4:clsec -= 10;
                           if(clsec <= 0)
                           {
                                clmin--;
                                clsec = 0;
                           }break;
                    case 3:clmin--;
                           if(clmin <= 0)
                           {
                               clhour--;
                               clmin = 59;
                           }break;
                    case 2:clmin -= 10;
                           if(clmin <= 0)
                           {
                               clhour--;
                               clmin = 59;
                           }break;
                    case 1:clhour--;
                           if(clhour <= 0)
                           {
                               clsec = 0;
                               clmin = 0;
                               clhour = 0;
                           }break;
                    case 0:clhour -= 10;
                           if(clhour <= 0)
                           {
                               clsec = 0;
                               clmin = 0;
                               clhour = 0;
                           }break;
                }
            }
         }

         if(num == 6)
         {
              clock = 1;
         }
         if(num == 7)
         {
            clock = 0;
         }
         if(clock == 0)
         {
            //LCD_Write_Com(0x01);
            LCD_Write_String(0,0,"time  :");
            LCD_Write_Char(7,0,(hour/10)+ '0');
            LCD_Write_Char(8,0,(hour%10)+ '0');
            LCD_Write_Char(9,0,':');
            LCD_Write_Char(10,0,(min/10)+ '0');
            LCD_Write_Char(11,0,(min%10)+ '0');
            LCD_Write_Char(12,0,':');
            LCD_Write_Char(13,0,(sec/10)+ '0');
            LCD_Write_Char(14,0,(sec%10)+ '0');
        }
        else
        {
            //LCD_Write_Com(0x01);
            LCD_Write_String(0,0,"clock :");
            LCD_Write_Char(7,0,(clhour/10)+ '0');
            LCD_Write_Char(8,0,(clhour%10)+ '0');
            LCD_Write_Char(9,0,':');
            LCD_Write_Char(10,0,(clmin/10)+ '0');
            LCD_Write_Char(11,0,(clmin%10)+ '0');
            LCD_Write_Char(12,0,':');
            LCD_Write_Char(13,0,(clsec/10)+ '0');
            LCD_Write_Char(14,0,(clsec%10)+ '0');   
        }
         if(sec >= 60)
         {
            sec = 0;
            min++;
            for(kkk = 0;kkk < 1000;kkk++)
            {
                Beep = !Beep;
                Delay(50);
            }
         }
         if(min >= 60)
         {
            min = 0;
            hour++;
            /*for(kkk = 0;kkk < 100;kkk++)
            {
                Beep = !Beep;
                Delay(50);
            }*/
         }

         if(hour >= 24)
         {
            hour = 0;
            min = 0;
            sec = 0;
         }
         if((hour == clhour) && (min == clmin) && (sec == clsec))
         {
            for(kkk == 0;kkk < 500;kkk++)
            {
                Beep = !Beep;
                Delay(50);
            }
         }

    }
}


void ISR_T0(void) interrupt 1
{
    unsigned char i;
    TH0 = 0x3c;
    TL0 = 0xb0;
    if(flag == 1)
    {
        i++;

        if(i == 20)
        {
            i = 0;
            sec++;
        }
    }
}

unsigned char KeyScan(void)
{
    char a = 0;
    GPIO_KEY=0x0f;
    if(GPIO_KEY!=0x0f)//读取按键是否按下
    {
        DelayMs(10);//延时10ms进行消抖
        if(GPIO_KEY!=0x0f)//再次检测键盘是否按下
        {

            //测试列
            GPIO_KEY=0X0F;
            switch(GPIO_KEY)
            {
                case(0X07): KeyValue=1;break;
                case(0X0b): KeyValue=5;break;
                case(0X0d): KeyValue=9;break;
                case(0X0e): KeyValue=13;break;
            }
            //测试行
            GPIO_KEY=0XF0;
            switch(GPIO_KEY)
            {
                case(0X70): KeyValue=KeyValue+3;break;
                case(0Xb0): KeyValue=KeyValue+2;break;
                case(0Xd0): KeyValue=KeyValue+1;break;
                case(0Xe0): KeyValue=KeyValue;break;
            }
            while((a<50) && (GPIO_KEY!=0xf0))    //检测按键松手检测
            {
                DelayMs(10);
                a++;
            }
            return KeyValue;
        }
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

矩阵键盘时钟的相关文章

Failed to execute operation: No such file or directory

安装iptables服务 yum span class token function install span iptables services 然后再执行 xff1a systemctl enable iptables service
为什么块的大小不能设置太小，也不能设置太大？

xff08 1 xff09 HDFS的块设置太小 xff0c 会增加寻址时间 xff0c 程序一直在找块的开始位置 xff1b xff08 2 xff09 如果块设置的太大 xff0c 从磁盘传输数据的时间会明显大于定位这个块开始位置所需的
深入理解混洗过程

混洗过程 Map方法之后 xff0c Reduce方法之前的数据处理过程称之为Shuffle 混洗过程 map方法之后首先进入getpartition方法标记数据属于那个分区并打上分区编号因为后续的数据都是按分区处理不同分区数据会
大数据集群写数据流程原理分析

写入数据流程即客户端如何把数据写入hdfs集群底层原理如下右侧为hdfs集群含有NameNode和DataNode节点左侧为客户端准备把数据传送到集群首先创建客户端分布式的文件系统创建好客户端后向NameNode请求 Nam
集群资源管理基础架构和工作机制

Yarn的基础架构 RM为整个yarn集群资源老大 NM为单个节点资源老大 AM为单个应用程序的资源老大 container容器 xff0c 集群的资源抽象最小单位 xff1b Yarn工作机制 Job gt RM 在命令行上执行一个wc
OpenSSL 3.0 版本已经发布VS2019编译源码教程

1 OpenSSL 3 0版本在2020年五月发布 OpenSSL3 0 在2020年5月发布了第一个版本 xff0c 随即在六月份又发布了一些alpha版本 xff0c 版本修正了一些bug xff0c 增加了一些协议支持 xff0c 继
FFmpeg 4.3 源码在windows上的编译

FFmpeg开发环境准备 nbsp nbsp 学习目标 nbsp nbsp nbsp 学会配置vs2019 msys2 编译环境 nbsp nbsp nbsp 学会编译x264 x265 fdk aac sdl ffmpeg4 3 编译目的
cmake使用方法详解 - Windows Linux MacOS cmake安装教程

一什么是CMake xff0c 为什么要使用它 CMake 是用于构建测试和软件打包的开源跨平台工具 xff0c 为什么要用cmake xff0c 是因为我们需要一个构建系统解决如下问题 xff1a 1 你想避免硬编码路径 2 您需要在
cmake是什么，为什么现在都用cmake,cmake编译原理和跨平台示例

一 cmake是什么 xff1f CMake是一个开源跨平台的工具系列 xff0c 是用来构建测试和打包软件 CMake使用平台无关的配置文件来控制软件编译过程 xff0c 并生成可在您选择的编译器环境中使用项目文件 xff0c 比如可
Socket通信原理

对TCP IP UDP Socket编程这些词你不会很陌生吧 xff1f 随着网络技术的发展 xff0c 这些词充斥着我们的耳朵那么我想问 xff1a 1 什么是TCP IP UDP xff1f 2 Socket在哪里呢 xff1f 3
cmake add_library编译链接静态库cmakelists

本篇文章我们来编写CMakeLists txt使用cmake的add library的构建静态库 xff0c 并使用target link libraries链接指定的静态库 cmake的linux windows 和linux环境的准备可
FFmpeg3最新的解码接口avcodec_send_packet和avcodec_receive_frame分析

ffmpeg3版本的解码接口做了不少调整 xff0c 之前的视频解码接口avcodec decode video2和avcodec decode audio4音频解码被设置为deprecated xff0c 对这两个接口做了合并 xff0c
ffmpeg3.3新版本AVStream的封装流参数由codec替换codecpar（解码）

ffmpeg新版本中 xff08 封装流 xff09 AVStream的codec参数要被codecpar参数所替代 xff0c 这样替代我们要注意什么 xff0c 为什么要替代 xff0c 我们先来看下ffmpeg的代码代码分析和新参数
为什么 qt 成为 c++ 界面编程的第一选择？

为什么qt成为c 43 43 界面编程的第一选择一前言为什么现在QT越来越成为界面编程的第一选择 xff0c 笔者从事qt界面编程已经有接近8年 xff0c 在这之前我做C 43 43 界面都是基于MFC xff0c 也做过5年左右
C++QT5跨平台界面编程原理和实战大全-夏曹俊-专题视频课程

C 43 43 QT5跨平台界面编程原理和实战大全 4271人已学习课程介绍课程讲解基于QT5 9 SDK xff0c 包含QT界面编程的核心内容 xff0c 并提供全部源码 xff0c 课程讲解方式是接口讲解分析演示示例 xff0
Darknet问题：ERROR: Cannot load message class for [darknet_ros_msgs/BoundingBoxes].

运行darknet ros进行目标检测时 xff0c 通过 rostopic list查看到 darknet ros bounding boxes这个话题 xff0c 因此想查看该话题的数据 xff0c 在使用 rostopic echo
ROS问题：ERROR: cannot launch node of type

在运行launch文件时 xff0c 出现如下错误提示 xff1a 原因是没有source 所以解决方案就是在编译完成之后添加source devel setup bash xff0c 问题解决参考网址 xff1a ERROR canno
标注工具labelme的使用

在做目标检测任务时 xff0c 少不了对图像进行标注 xff0c 标注工具有好几种 xff0c labelme是其中比较好用的一种 labelme可对图像进行标注 xff0c 包括多边形矩形线点和图像级标注它是用Python编写的
Linux小技巧之终端terminal全选

当打开一个终端 xff0c 经过若干指令后 xff0c 终端上输出的内容较多 xff0c 直接框选这些内容进行选择比较费事有没有全选的功能呢 xff1f 答案是有的 xff01 方法1 xff1a 终端菜单栏全选当窗口比较小时 xff0
如何使用set::key_comp 和 set::value_comp 标准模板库 (STL) 函数

下面的代码示例演示如何使用 Visual C 43 43 set key comp 和 set value comp 的 STL 功能所需要的头文件 xff1a lt set gt 原型 template lt class K class

随机推荐

Linux小技巧之终端快捷键大全

在前面一篇博客中记录了终端全选的技巧下面记录一下关于终端使用的其它一些小技巧 F1查看帮助F11全屏Shift 43 Ctrl 43 T 打开一个新的终端Shift 43 Ctrl 43 N新建一个窗口打开终端Shift 43 Ctrl
ROS问题：Yolo v4移植到ROS后检测结果/darknet_ros/detection_image在rviz中显示乱码

在前面一篇博客 xff08 Yolo v4移植ROS xff09 中介绍了将Yolo v4移植到ROS中由于Yolo v4的源码在Yolo v3源码的基础上有改动 xff0c 移植成功后会出现一个小bug xff0c 如下图所示 xff1
吉洪诺夫正则化(Tikhonov regularization )

最近看了看吉洪诺夫正则化方法 xff0c 对其基本内容作了一个简单的了解现在总结如下 1 正则化定义 xff1a 正则化 regularization xff0c 是指在线性代数理论中 xff0c 不适定问题通常是由一组线性代数方程定义
C++中getline()、gets()等函数的用法

在学习C 43 43 的过程中 xff0c 经常会遇到输入输出的问题 xff0c 以下总结一下下面几个函数的用法 xff1a 1 cin 2 cin get 3 cin getline 4 getline 5 gets 1 cin gt g
C++字母大小写转换方法

字母大小写这个问题相对比较简单 xff0c 总结了一些常用的大小写转换的方法 xff0c 欢迎指正补充 xff01 思路1 xff1a 根据字母的ASCII表进行转换 xff1a 由表格可以看出 xff0c 对应大小写字母之间相差32 xf
C++ 标准输出控制小数点后位数的方法

在C 43 43 中 xff0c 要实现这个功能 xff0c 就要用到std命名空间中常用于流的控制符 xff0c 这里通常要用到setprecision 函数 xff0c 可以通过这个函数控制小数点后面位数还要注意的是 xff0c 使用
C++中string::npos的一些用法总结

一关于npos的定义在MSDN中有如下说明 xff1a basic string npos static const size type npos 61 1 定义 The constant is the largest represen
CMake：通过target_link_libraries链接第三方库

sdbusplus 通过new method call同步调用service的method 风静如云的博客 CSDN博客例子中需要在编译时链接 lsdbusplus lsystemd 这两个第三方库那么通过cmake怎么指定呢其实很简
在ubuntu终端打开谷歌浏览器的命令

安装好谷歌浏览器后 xff0c 用以下命令在终端打开谷歌浏览器 adb shell am start n com android chrome com google android apps chrome Main 之后便出现如下内容 xf
PELCO_D通信协议

1 球机通信接口 xff08 EIA RS 485 xff09 数据传输方式 xff1a 异步半双工串行通讯通信波特率 xff1a 9600Bps 数据格式 xff1a Start Bit xff1a 1 Bit xff1b Data B
C buffer

这学期在Dartmouth上ENGS20 Introduction to Scientific Computing xff0c 好多东西不记下来就会忘 xff0c 所以开一个笔记在C语言中 xff0c 输入和输出都是有buffer的 xf
寄存器值的操作方法

通过这段时间的工作和学习 xff0c 我感觉在嵌入式硬件编程中 xff0c 大多数情况下都是对相应硬件的功能寄存器进行设置和操作一寄存器的设置和操作特性 1 xff0c 一个寄存器的每个位有其不同的意义 xff0c 进行不同的设置会使硬
UART串口通信（回环测试）

一 UART串口通信简介 UART xff08 Universal Asynchronous Receiver Transmitter xff09 是采用异步串行通信方式的通用异步收发传输器 xff0c 在发送数据时将并行数据转换为串行数据
extern "C"的作用

extern 34 C 34 的作用一前些天编程序是用到了很久以前写的C程序想把里面的函数利用起来连接发现出现了找不到具体函数的错误以下是假设旧的C程序库 C的头文件 c h ifndef C H define C H exte
输入分钟数，按小时和分钟输出

copyright C 2014 2015 Lighting Studio Co Ltd File name xff1a Author xff1a Jerey Jobs Version 0 1 Date Description xff1a
输入一个32位的整数a,使用按位异或^运算,生成一个新的32位整数b,使得该整数b的每一位等于原整数a中该位左右两边两个bit位的异或结果

程序要求 xff1a 输入一个32位的整数a 使用按位异或运算生成一个新的32位整数b 使得该整数b的每一位等于原整数a中该位左右两边两个bit位的异或结果 copyright C 2014 2015 Lighting Studio C
sqlite回调函数的解释与使用

gt 在sqlite3的api函数中有一个sqlite3 exec xff0c 用来执行sql语句 xff1a 函数原型 xff1a int sqlite3 exec sqlite3 ppDb An open database const
Linux节点理解

一 inode是什么 xff1f 理解inode xff0c 要从文件储存说起文件储存在硬盘上 xff0c 硬盘的最小存储单位叫做扇区 xff08 Sector xff09 每个扇区储存512字节 xff08 相当于0 5KB xff0
OSSempend();OSSemPost();函数的解析

浅析 COS II v2 span class hljs number 85 span 内核OSSemPend 和OSSemPost 函数工作原理文章来源 http span class hljs comment gliethttp cu
矩阵键盘时钟

span class hljs preprocessor include lt reg52 h gt span class hljs comment 包含头文件 xff0c 一般情况不需要改动 xff0c 头文件包含特殊功能寄存器的定义 s

矩阵键盘时钟

矩阵键盘时钟 的相关文章

随机推荐

热门标签

矩阵键盘时钟的相关文章