单片机基础知识

冷不防 2024-04-24 23:18 134阅读 0赞

文章目录

  • 51单片机之点灯
  • 51单片机之灯的亮灭交替
  • 51单片机之灯的流水灯
  • 51单片机之数码管数字显示
  • 51单片机之数码管数字的流水灯
  • 51单片机之数码管数字的0-7显示
  • 51单片机之蜂鸣器的鸣叫与关闭
  • 51单片机之DS1302时钟设置
  • 51单片机之读出温度传感器温度
  • 代码模块化汇总
    • 主函数
      • main.c
    • 延时函数Delay
      • Delay.c
      • Delay.h
    • 矩阵键盘MatriXKey
      • MatriXKey.c
      • MatriXKey.h
    • 数码管NiXie
      • NiXie.c
      • NiXie.h
    • 时钟DS1302
      • DS1302.c
      • DS1302.h

51单片机之点灯

控制矩阵键盘的第一个按键，从而实现LED_1 电灯亮。

这里给出代码：

  1. KeyNum = MatriXie();
  2.         if(KeyNum == 1)
  3.         {
  5.             LED_1=~LED_1;
  6.         }

51单片机之灯的亮灭交替

控制矩阵键盘的第二个按键，从而实现LED_2电灯的5毫秒的亮灭交替。

这里给出代码：

  1. if(KeyNum == 2)
  2.         {
  4.             KeyNum = 0;
  5.             while(1)
  6.             {
  8.                 LED_1 = 0;
  9.                 Delay(100);
  10.                 LED_1 = 1;
  11.                 Delay(100);
  12.                 KeyNum = MatriXie();
  13.                 if(KeyNum == 2)
  14.                 {
  16.                     LED_1 = 1;
  17.                     break;
  18.                 }
  19.             }
  20.         }

51单片机之灯的流水灯

控制矩阵键盘的第三个按键，从而实现LED的流水灯效果，默认是从左到右流水灯，这里没说延迟多少，所以默认就是Delay(1000) ms。

流水灯这里可以补充一些基础的知识，就是P2 控制的是LED灯，所以只需要对P2 进行赋值16进制的数字即可。

这里给出代码：

  1. if(KeyNum == 3)
  2.         {
  4.             while(1)
  5.             {
  7.                 P2 = 0xFE; // 1111 1110
  8.                 Delay(100);
  9.                 KeyNum = MatriXie();
  10.                 if(KeyNum == 3) 
  11.                 {
  13.                     P2 = 0xFF;
  14.                     break;
  15.                 }
  16.                 P2 = 0xFD; // 1111 1101
  17.                 Delay(100);
  18.                 KeyNum = MatriXie();
  19.                 if(KeyNum == 3) 
  20.                 {
  22.                     P2 = 0xFF;
  23.                     break;
  24.                 }
  25.                 P2 = 0xFB; // 1111 1011
  26.                 Delay(100);
  27.                 KeyNum = MatriXie();
  28.                 if(KeyNum == 3) 
  29.                 {
  31.                     P2 = 0xFF;
  32.                     break;
  33.                 }
  34.                 P2 = 0xF7; // 1111 0111
  35.                 Delay(100);
  36.                 KeyNum = MatriXie();
  37.                 if(KeyNum == 3) 
  38.                 {
  40.                     P2 = 0xFF;
  41.                     break;
  42.                 }
  43.                 P2 = 0xEF; // 1110 1111
  44.                 Delay(100);
  45.                 KeyNum = MatriXie();
  46.                 if(KeyNum == 3) 
  47.                 {
  49.                     P2 = 0xFF;
  50.                     break; 
  51.                 }
  52.                 P2 = 0xDF; // 1101 1111
  53.                 Delay(100);
  54.                 KeyNum = MatriXie();
  55.                 if(KeyNum == 3) 
  56.                 {
  58.                     P2 = 0xFF;
  59.                     break;
  60.                 }
  61.                 P2 = 0xBF; // 1011 1111
  62.                 Delay(100);
  63.                 KeyNum = MatriXie();
  64.                 if(KeyNum == 3) 
  65.                 {
  67.                     P2 = 0xFF;
  68.                     break;
  69.                 }
  70.                 P2 = 0x7F; // 0111 1111
  71.                 Delay(100);
  72.                 //flag=1;
  73.                 KeyNum = MatriXie();
  74.                 if(KeyNum == 3) 
  75.                 {
  77.                     P2 = 0xFF;
  78.                     break;
  79.                 }
  80.             }
  81.         }

51单片机之数码管数字显示

控制矩阵键盘的第四个按键，从而实现数码管显示数字0。

数码管这里补充一些基础知识，就是数码管的数字显示是分为A、B、C、D、E、F、G 以及DP的，详细的可以查看下面这个图片来学习，（这个图片来自江科大的PPT），A、B、C、D对应的16进制的低四位，所以不难得出E、F、G、DP控制的是16进制的高四位。

这里给出代码：

  1. if(KeyNum == 4)
  2.         {
  4.             KeyNum = 0;
  5.             P2_4 = 1;
  6.             P2_3 = 1;
  7.             P2_2 = 1;
  8.             while(1)
  9.             {
  11.                 P0 = 0x66; // 0111 1101
  12.                 KeyNum = MatriXie();
  13.                 if(KeyNum == 4) 
  14.                 {
  16.                     P0 = 0xFF;
  17.                     break;
  18.                 }
  19.             }
  20.         }

51单片机之数码管数字的流水灯

控制矩阵键盘的第五个按键，从而实现数码管显示数字0，并且进行“流水灯”的效果，这里显然很简单，可以封装一个函数NiXie来表示数码管在哪一个位置显示哪一个数字，然后去Delay多少毫秒，就可以完成流水灯的效果。

这里给出代码：

  1. if(KeyNum == 5)
  2.         {
  4.             KeyNum = 0;
  5.             while(1)
  6.             {
  8.                 NiXie(1,4);
  9.                 Delay(100);
  10.                 KeyNum = MatriXie();
  11.                 if(KeyNum == 5) 
  12.                 {
  14.                     P2_4 = 1;
  15.                     P2_3 = 1;
  16.                     P2_2 = 1;
  17.                     P0 = 0xFF;
  18.                     break;
  19.                 }
  20.                 NiXie(2,4);
  21.                 Delay(100);
  22.                 KeyNum = MatriXie();
  23.                 if(KeyNum == 5) 
  24.                 {
  26.                     P2_4 = 1;
  27.                     P2_3 = 1;
  28.                     P2_2 = 1;
  29.                     P0 = 0xFF;
  30.                     break;
  31.                 }
  32.                 NiXie(3,4);
  33.                 Delay(100);
  34.                 KeyNum = MatriXie();
  35.                 if(KeyNum == 5) 
  36.                 {
  38.                     P2_4 = 1;
  39.                     P2_3 = 1;
  40.                     P2_2 = 1;
  41.                     P0 = 0xFF;
  42.                     break;
  43.                 }
  44.                 NiXie(4,4);
  45.                 Delay(100);
  46.                 KeyNum = MatriXie();
  47.                 if(KeyNum == 5) 
  48.                 {
  50.                     P2_4 = 1;
  51.                     P2_3 = 1;
  52.                     P2_2 = 1;
  53.                     P0 = 0xFF;
  54.                     break;
  55.                 }
  56.                 NiXie(5,4);
  57.                 Delay(100);
  58.                 KeyNum = MatriXie();
  59.                 if(KeyNum == 5) 
  60.                 {
  62.                     P2_4 = 1;
  63.                     P2_3 = 1;
  64.                     P2_2 = 1;
  65.                     P0 = 0xFF;
  66.                     break;
  67.                 }
  68.                 NiXie(6,4);
  69.                 Delay(100);
  70.                 KeyNum = MatriXie();
  71.                 if(KeyNum == 5) 
  72.                 {
  74.                     P2_4 = 1;
  75.                     P2_3 = 1;
  76.                     P2_2 = 1;
  77.                     P0 = 0xFF;
  78.                     break;
  79.                 }
  80.                 NiXie(7,4);
  81.                 Delay(100);
  82.                 KeyNum = MatriXie();
  83.                 if(KeyNum == 5) 
  84.                 {
  86.                     P2_4 = 1;
  87.                     P2_3 = 1;
  88.                     P2_2 = 1;
  89.                     P0 = 0xFF;
  90.                     break;
  91.                 }
  92.                 NiXie(8,4);
  93.                 Delay(100);
  94.                 KeyNum = MatriXie();
  95.                 if(KeyNum == 5) 
  96.                 {
  98.                     P2_4 = 1;
  99.                     P2_3 = 1;
  100.                     P2_2 = 1;
  101.                     P0 = 0xFF;
  102.                     break;
  103.                 }
  104.             }
  105.         }

51单片机之数码管数字的0-7显示

控制矩阵键盘的第六个按键，这道题更是送分题了，没什么思考难度，直接不断调用NiXie函数去显示数码管即可。

这里给出代码：

  1. if(KeyNum == 6)
  2.         {
  4.             KeyNum = 0;
  5.             while(1)
  6.             {
  8.                 NiXie(1,0);
  9.                 NiXie(2,1);
  10.                 NiXie(3,2);
  11.                 NiXie(4,3);
  12.                 NiXie(5,4);
  13.                 NiXie(6,5);
  14.                 NiXie(7,6);
  15.                 NiXie(8,7);
  16.                 KeyNum = MatriXie();
  17.                 if(KeyNum == 6) 
  18.                 {
  20.                     P2_4 = 1;
  21.                     P2_3 = 1;
  22.                     P2_2 = 1;
  23.                     P0 = 0xFF;
  24.                     break;
  25.                 }
  26.             }
  27.         }

51单片机之蜂鸣器的鸣叫与关闭

控制矩阵键盘的第七个按键，从而实现蜂鸣器的鸣叫，再次按下第七个按键，实现蜂鸣器的关闭。

蜂鸣器这里补充一些基础知识，蜂鸣器，我的理解就是不断的在一定的振幅改变下才去鸣叫，所以可以利用一个for循环来触发蜂鸣器的鸣叫

这里给出代码：

  1. if(KeyNum == 7)
  2.         {
  4.             KeyNum = 0;
  5.             while(1)
  6.             {
  8.                 BuzzerTime();
  9.                 Delay(1);
  10.                 KeyNum = MatriXie();
  11.                 if(KeyNum == 7) 
  12.                 {
  14.                     BuzzerTime();
  15.                     break;
  16.                 }
  17.             }
  18.         }

51单片机之DS1302时钟设置

控制矩阵键盘的第八个按键，从而实现DS1302时钟功能，让数码管显示时钟，并且秒是可以动的，可以进位到分钟，小时，所以这道题目是很困难的，也是江科大UP主讲了好长时间的课程，一节课1.5h总共两节课，给我学的很困哈哈哈哈不过多学的话就会了。

这里给出代码：

  1. //main函数
  2. if(KeyNum == 8)
  3.         {
  5.             DS1302_SetTime();
  6.             KeyNum = 0;
  7.             while(1)
  8.             {
  10.                 DS1302_ReadTime();
  11.                 NiXie(1,DS1302_Time[0]/10);
  12.                 NiXie(2,DS1302_Time[0]%10);
  13.                 NiXie(3,10);
  14.                 NiXie(4,DS1302_Time[1]/10);
  15.                 NiXie(5,DS1302_Time[1]%10);
  16.                 NiXie(6,10);
  17.                 NiXie(7,DS1302_Time[2]/10);
  18.                 NiXie(8,DS1302_Time[2]%10);
  19.                 KeyNum = MatriXie();
  20.                 if(KeyNum == 8)
  21.                 {
  23.                     P2_2 = 1;
  24.                     P2_3 = 1;
  25.                     P2_4 = 1;
  26.                     P0 = 0xFF;
  27.                     break;
  28.                 }
  29.             }
  30.         }

51单片机之读出温度传感器温度

控制矩阵键盘的第九个按键，从而实现温度传感器读取温度的功能，这道题我当时没有写出来是因为这里我学的不够扎实，当时并没有思路去写出来这个题目。。。。看看小伙伴谁会写的话可以给大家讲出来。

代码模块化汇总

主函数

main.c

  1. #include <REGX52.H>
  2. #include "Delay.h"
  3. #include "MatriXie.h"
  4. #include "NiXie.h"
  5. #include "BuzzerTime.h"
  6. #include "DS1302.h"
  8. //定义LED
  9. sbit LED_1 = P2^0;
  10. sbit LED_2 = P2^1;
  11. sbit LED_3 = P2^2;
  12. sbit LED_4 = P2^3;
  13. sbit LED_5 = P2^4;
  14. sbit LED_6 = P2^5;
  15. sbit LED_7 = P2^6;
  16. sbit LED_8 = P2^7;
  17. //定义独立按键
  18. sbit K_3 = P3^2;
  19. sbit K_4 = P3^3;
  20. sbit K_2 = P3^0;
  21. sbit K1 = P3^1;
  23. unsigned char KeyNum,flag=0;
  25. void main()
  26. {
  28.     //P2 = 0xFE; // 1111 0111
  29.     while(1)
  30.     {
  32.         KeyNum = MatriXie();
  33.         if(KeyNum == 1)
  34.         {
  36.             LED_1=~LED_1;
  37.         }
  38.         if(KeyNum == 2)
  39.         {
  41.             KeyNum = 0;
  42.             while(1)
  43.             {
  45.                 LED_1 = 0;
  46.                 Delay(100);
  47.                 LED_1 = 1;
  48.                 Delay(100);
  49.                 KeyNum = MatriXie();
  50.                 if(KeyNum == 2)
  51.                 {
  53.                     LED_1 = 1;
  54.                     break;
  55.                 }
  56.             }
  57.         }
  58.         if(KeyNum == 3)
  59.         {
  61.             while(1)
  62.             {
  64.                 P2 = 0xFE; // 1111 1110
  65.                 Delay(100);
  66.                 KeyNum = MatriXie();
  67.                 if(KeyNum == 3) 
  68.                 {
  70.                     P2 = 0xFF;
  71.                     break;
  72.                 }
  73.                 P2 = 0xFD; // 1111 1101
  74.                 Delay(100);
  75.                 KeyNum = MatriXie();
  76.                 if(KeyNum == 3) 
  77.                 {
  79.                     P2 = 0xFF;
  80.                     break;
  81.                 }
  82.                 P2 = 0xFB; // 1111 1011
  83.                 Delay(100);
  84.                 KeyNum = MatriXie();
  85.                 if(KeyNum == 3) 
  86.                 {
  88.                     P2 = 0xFF;
  89.                     break;
  90.                 }
  91.                 P2 = 0xF7; // 1111 0111
  92.                 Delay(100);
  93.                 KeyNum = MatriXie();
  94.                 if(KeyNum == 3) 
  95.                 {
  97.                     P2 = 0xFF;
  98.                     break;
  99.                 }
  100.                 P2 = 0xEF; // 1110 1111
  101.                 Delay(100);
  102.                 KeyNum = MatriXie();
  103.                 if(KeyNum == 3) 
  104.                 {
  106.                     P2 = 0xFF;
  107.                     break; 
  108.                 }
  109.                 P2 = 0xDF; // 1101 1111
  110.                 Delay(100);
  111.                 KeyNum = MatriXie();
  112.                 if(KeyNum == 3) 
  113.                 {
  115.                     P2 = 0xFF;
  116.                     break;
  117.                 }
  118.                 P2 = 0xBF; // 1011 1111
  119.                 Delay(100);
  120.                 KeyNum = MatriXie();
  121.                 if(KeyNum == 3) 
  122.                 {
  124.                     P2 = 0xFF;
  125.                     break;
  126.                 }
  127.                 P2 = 0x7F; // 0111 1111
  128.                 Delay(100);
  129.                 //flag=1;
  130.                 KeyNum = MatriXie();
  131.                 if(KeyNum == 3) 
  132.                 {
  134.                     P2 = 0xFF;
  135.                     break;
  136.                 }
  137.             }
  138.         }
  139.         if(KeyNum == 4)
  140.         {
  142.             KeyNum = 0;
  143.             P2_4 = 1;
  144.             P2_3 = 1;
  145.             P2_2 = 1;
  146.             while(1)
  147.             {
  149.                 P0 = 0x66; // 0111 1101
  150.                 KeyNum = MatriXie();
  151.                 if(KeyNum == 4) 
  152.                 {
  154.                     P0 = 0xFF;
  155.                     break;
  156.                 }
  157.             }
  158.         }
  159.         if(KeyNum == 5)
  160.         {
  162.             KeyNum = 0;
  163.             while(1)
  164.             {
  166.                 NiXie(1,4);
  167.                 Delay(100);
  168.                 KeyNum = MatriXie();
  169.                 if(KeyNum == 5) 
  170.                 {
  172.                     P2_4 = 1;
  173.                     P2_3 = 1;
  174.                     P2_2 = 1;
  175.                     P0 = 0xFF;
  176.                     break;
  177.                 }
  178.                 NiXie(2,4);
  179.                 Delay(100);
  180.                 KeyNum = MatriXie();
  181.                 if(KeyNum == 5) 
  182.                 {
  184.                     P2_4 = 1;
  185.                     P2_3 = 1;
  186.                     P2_2 = 1;
  187.                     P0 = 0xFF;
  188.                     break;
  189.                 }
  190.                 NiXie(3,4);
  191.                 Delay(100);
  192.                 KeyNum = MatriXie();
  193.                 if(KeyNum == 5) 
  194.                 {
  196.                     P2_4 = 1;
  197.                     P2_3 = 1;
  198.                     P2_2 = 1;
  199.                     P0 = 0xFF;
  200.                     break;
  201.                 }
  202.                 NiXie(4,4);
  203.                 Delay(100);
  204.                 KeyNum = MatriXie();
  205.                 if(KeyNum == 5) 
  206.                 {
  208.                     P2_4 = 1;
  209.                     P2_3 = 1;
  210.                     P2_2 = 1;
  211.                     P0 = 0xFF;
  212.                     break;
  213.                 }
  214.                 NiXie(5,4);
  215.                 Delay(100);
  216.                 KeyNum = MatriXie();
  217.                 if(KeyNum == 5) 
  218.                 {
  220.                     P2_4 = 1;
  221.                     P2_3 = 1;
  222.                     P2_2 = 1;
  223.                     P0 = 0xFF;
  224.                     break;
  225.                 }
  226.                 NiXie(6,4);
  227.                 Delay(100);
  228.                 KeyNum = MatriXie();
  229.                 if(KeyNum == 5) 
  230.                 {
  232.                     P2_4 = 1;
  233.                     P2_3 = 1;
  234.                     P2_2 = 1;
  235.                     P0 = 0xFF;
  236.                     break;
  237.                 }
  238.                 NiXie(7,4);
  239.                 Delay(100);
  240.                 KeyNum = MatriXie();
  241.                 if(KeyNum == 5) 
  242.                 {
  244.                     P2_4 = 1;
  245.                     P2_3 = 1;
  246.                     P2_2 = 1;
  247.                     P0 = 0xFF;
  248.                     break;
  249.                 }
  250.                 NiXie(8,4);
  251.                 Delay(100);
  252.                 KeyNum = MatriXie();
  253.                 if(KeyNum == 5) 
  254.                 {
  256.                     P2_4 = 1;
  257.                     P2_3 = 1;
  258.                     P2_2 = 1;
  259.                     P0 = 0xFF;
  260.                     break;
  261.                 }
  262.             }
  263.         }
  264.         if(KeyNum == 6)
  265.         {
  267.             KeyNum = 0;
  268.             while(1)
  269.             {
  271.                 NiXie(1,0);
  272.                 NiXie(2,1);
  273.                 NiXie(3,2);
  274.                 NiXie(4,3);
  275.                 NiXie(5,4);
  276.                 NiXie(6,5);
  277.                 NiXie(7,6);
  278.                 NiXie(8,7);
  279.                 KeyNum = MatriXie();
  280.                 if(KeyNum == 6) 
  281.                 {
  283.                     P2_4 = 1;
  284.                     P2_3 = 1;
  285.                     P2_2 = 1;
  286.                     P0 = 0xFF;
  287.                     break;
  288.                 }
  289.             }
  290.         }
  291.         if(KeyNum == 7)
  292.         {
  294.             KeyNum = 0;
  295.             while(1)
  296.             {
  298.                 BuzzerTime();
  299.                 Delay(1);
  300.                 KeyNum = MatriXie();
  301.                 if(KeyNum == 7) 
  302.                 {
  304.                     BuzzerTime();
  305.                     break;
  306.                 }
  307.             }
  308.         }
  310.         if(KeyNum == 8)
  311.         {
  313.             DS1302_SetTime();
  314.             KeyNum = 0;
  315.             while(1)
  316.             {
  318.                 DS1302_ReadTime();
  319.                 NiXie(1,DS1302_Time[0]/10);
  320.                 NiXie(2,DS1302_Time[0]%10);
  321.                 NiXie(3,10);
  322.                 NiXie(4,DS1302_Time[1]/10);
  323.                 NiXie(5,DS1302_Time[1]%10);
  324.                 NiXie(6,10);
  325.                 NiXie(7,DS1302_Time[2]/10);
  326.                 NiXie(8,DS1302_Time[2]%10);
  327.                 KeyNum = MatriXie();
  328.                 if(KeyNum == 8)
  329.                 {
  331.                     P2_2 = 1;
  332.                     P2_3 = 1;
  333.                     P2_4 = 1;
  334.                     P0 = 0xFF;
  335.                     break;
  336.                 }
  337.             }
  338.         }
  339.     }
  340. }

延时函数Delay

Delay.c

  1. void Delay1ms(void)    //@12.000MHz
  2. {
  4.     unsigned char data i, j;
  6.     i = 2;
  7.     j = 239;
  8.     do
  9.     {
  11.         while (--j);
  12.     } while (--i);
  13. }
  14. void Delay(unsigned int x)
  15. {
  17.     while(x--)
  18.     {
  20.         Delay1ms();
  21.     }    
  22. }

Delay.h

  1. void Delay1ms(void);
  2. void Delay(unsigned int x);

矩阵键盘MatriXKey

MatriXKey.c

  1. #include <REGX52.H>
  2. #include "Delay.h"
  4. unsigned int MatriXie()
  5. {
  7.     unsigned char KeyNumber = 0;
  9.     P1 = 0xFF;
  10.     P1_7 = 0;
  11.     if(P1_3 == 0) {
  12.     Delay(20);while(P1_3==0);Delay(20);KeyNumber=1;}
  13.     if(P1_2 == 0) {
  14.     Delay(20);while(P1_2==0);Delay(20);KeyNumber=2;}
  15.     if(P1_1 == 0) {
  16.     Delay(20);while(P1_1==0);Delay(20);KeyNumber=3;}
  17.     if(P1_0 == 0) {
  18.     Delay(20);while(P1_0==0);Delay(20);KeyNumber=4;}
  20.     P1 = 0xFF;
  21.     P1_6 = 0;
  22.     if(P1_3 == 0) {
  23.     Delay(20);while(P1_3==0);Delay(20);KeyNumber=5;}
  24.     if(P1_2 == 0) {
  25.     Delay(20);while(P1_2==0);Delay(20);KeyNumber=6;}
  26.     if(P1_1 == 0) {
  27.     Delay(20);while(P1_1==0);Delay(20);KeyNumber=7;}
  28.     if(P1_0 == 0) {
  29.     Delay(20);while(P1_0==0);Delay(20);KeyNumber=8;}
  31.     P1 = 0xFF;
  32.     P1_5 = 0;
  33.     if(P1_3 == 0) {
  34.     Delay(20);while(P1_3==0);Delay(20);KeyNumber=9;}
  35.     if(P1_2 == 0) {
  36.     Delay(20);while(P1_2==0);Delay(20);KeyNumber=10;}
  37.     if(P1_1 == 0) {
  38.     Delay(20);while(P1_1==0);Delay(20);KeyNumber=11;}
  39.     if(P1_0 == 0) {
  40.     Delay(20);while(P1_0==0);Delay(20);KeyNumber=12;}
  42.     P1 = 0xFF;
  43.     P1_4 = 0;
  44.     if(P1_3 == 0) {
  45.     Delay(20);while(P1_3==0);Delay(20);KeyNumber=13;}
  46.     if(P1_2 == 0) {
  47.     Delay(20);while(P1_2==0);Delay(20);KeyNumber=14;}
  48.     if(P1_1 == 0) {
  49.     Delay(20);while(P1_1==0);Delay(20);KeyNumber=15;}
  50.     if(P1_0 == 0) {
  51.     Delay(20);while(P1_0==0);Delay(20);KeyNumber=16;}
  53.     return KeyNumber;
  54. }

MatriXKey.h

  1. unsigned int MatriXie(void);

数码管NiXie

NiXie.c

  1. #include <REGX52.H>
  2. #include "Delay.h"
  3. #include "MatriXie.h"
  4. #include "NiXie.h"
  6. unsigned char NiXieTable[]={
  7.     0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x40};
  8. void NiXie(unsigned char pos,unsigned char number)
  9. {
  11.     switch(pos)
  12.     {
  14.         case 1:P2_4=1;P2_3=1;P2_2=1;break;
  15.         case 2:P2_4=1;P2_3=1;P2_2=0;break;
  16.         case 3:P2_4=1;P2_3=0;P2_2=1;break;
  17.         case 4:P2_4=1;P2_3=0;P2_2=0;break;
  18.         case 5:P2_4=0;P2_3=1;P2_2=1;break;
  19.         case 6:P2_4=0;P2_3=1;P2_2=0;break;
  20.         case 7:P2_4=0;P2_3=0;P2_2=1;break;
  21.         case 8:P2_4=0;P2_3=0;P2_2=0;break;
  22.     }
  23.     P0 = NiXieTable[number];
  24.     Delay(1);//显示一段时间//消影
  25.     //P0 = 0x00;
  26. }

NiXie.h

  1. void NiXie(unsigned char pos,unsigned char number);

时钟DS1302

DS1302.c

  1. #include <REGX52.H>
  3. //引脚定义
  4. sbit DS1302_SCLK=P3^6;
  5. sbit DS1302_IO=P3^4;
  6. sbit DS1302_CE=P3^5;
  8. //寄存器写入地址/指令定义
  9. #define DS1302_SECOND        0x80
  10. #define DS1302_MINUTE        0x82
  11. #define DS1302_HOUR            0x84
  12. #define DS1302_DATE            0x86
  13. #define DS1302_MONTH        0x88
  14. #define DS1302_DAY            0x8A
  15. #define DS1302_YEAR            0x8C
  16. #define DS1302_WP            0x8E
  18. //时间数组，索引0~6分别为年、月、日、时、分、秒、星期
  19. unsigned char DS1302_Time[]={
  20.     15,22,00};
  22. /**
  23.   * @brief  DS1302初始化
  24.   * @param  无
  25.   * @retval 无
  26.   */
  27. void DS1302_Init(void)
  28. {
  30.     DS1302_CE=0;
  31.     DS1302_SCLK=0;
  32. }
  34. /**
  35.   * @brief  DS1302写一个字节
  36.   * @param  Command 命令字/地址
  37.   * @param  Data 要写入的数据
  38.   * @retval 无
  39.   */
  40. void DS1302_WriteByte(unsigned char Command,Data)
  41. {
  43.     unsigned char i;
  44.     DS1302_CE=1;
  45.     for(i=0;i<8;i++)
  46.     {
  48.         DS1302_IO=Command&(0x01<<i);
  49.         DS1302_SCLK=1;
  50.         DS1302_SCLK=0;
  51.     }
  52.     for(i=0;i<8;i++)
  53.     {
  55.         DS1302_IO=Data&(0x01<<i);
  56.         DS1302_SCLK=1;
  57.         DS1302_SCLK=0;
  58.     }
  59.     DS1302_CE=0;
  60. }
  62. /**
  63.   * @brief  DS1302读一个字节
  64.   * @param  Command 命令字/地址
  65.   * @retval 读出的数据
  66.   */
  67. unsigned char DS1302_ReadByte(unsigned char Command)
  68. {
  70.     unsigned char i,Data=0x00;
  71.     Command|=0x01;    //将指令转换为读指令
  72.     DS1302_CE=1;
  73.     for(i=0;i<8;i++)
  74.     {
  76.         DS1302_IO=Command&(0x01<<i);
  77.         DS1302_SCLK=0;
  78.         DS1302_SCLK=1;
  79.     }
  80.     for(i=0;i<8;i++)
  81.     {
  83.         DS1302_SCLK=1;
  84.         DS1302_SCLK=0;
  85.         if(DS1302_IO){
  86.     Data|=(0x01<<i);}
  87.     }
  88.     DS1302_CE=0;
  89.     DS1302_IO=0;    //读取后将IO设置为0，否则读出的数据会出错
  90.     return Data;
  91. }
  93. /**
  94.   * @brief  DS1302设置时间，调用之后，DS1302_Time数组的数字会被设置到DS1302中
  95.   * @param  无
  96.   * @retval 无
  97.   */
  98. void DS1302_SetTime(void)
  99. {
  101.     DS1302_WriteByte(DS1302_WP,0x00);
  102.     DS1302_WriteByte(DS1302_HOUR,DS1302_Time[0]/10*16+DS1302_Time[0]%10);
  103.     DS1302_WriteByte(DS1302_MINUTE,DS1302_Time[1]/10*16+DS1302_Time[1]%10);
  104.     DS1302_WriteByte(DS1302_SECOND,DS1302_Time[2]/10*16+DS1302_Time[2]%10);
  105.     DS1302_WriteByte(DS1302_WP,0x80);
  106. }
  108. /**
  109.   * @brief  DS1302读取时间，调用之后，DS1302中的数据会被读取到DS1302_Time数组中
  110.   * @param  无
  111.   * @retval 无
  112.   */
  113. void DS1302_ReadTime(void)
  114. {
  116.     unsigned char Temp;;
  117.     Temp=DS1302_ReadByte(DS1302_HOUR);
  118.     DS1302_Time[0]=Temp/16*10+Temp%16;
  119.     Temp=DS1302_ReadByte(DS1302_MINUTE);
  120.     DS1302_Time[1]=Temp/16*10+Temp%16;
  121.     Temp=DS1302_ReadByte(DS1302_SECOND);
  122.     DS1302_Time[2]=Temp/16*10+Temp%16;
  123. }

DS1302.h

  1. #ifndef __DS1302_H__
  2. #define __DS1302_H__
  4. //外部可调用时间数组，索引0~6分别为年、月、日、时、分、秒、星期
  5. extern unsigned char DS1302_Time[];
  7. void DS1302_Init(void);
  8. void DS1302_WriteByte(unsigned char Command,Data);
  9. unsigned char DS1302_ReadByte(unsigned char Command);
  10. void DS1302_SetTime(void);
  11. void DS1302_ReadTime(void);
  13. #endif

在这里插入图片描述

  1. ? [ 笔者 ]   夏目浅石.
  2. ? [ 更新 ]   2024.1
  3. ❌ [ 勘误 ]   /* 暂无 */
  4. ? [ 声明 ]   由于作者水平有限，本文有错误和不准确之处在所难免，
  5.               本人也很想知道这些错误，恳望读者批评指正！

? 参考文献：

B站江科大51单片机入门视频
AYIT嵌入式实验室出题
CSDN嵌入式领域博主：謓泽(学习笔记超级建议看这位大佬的博客，复习很快，学习视频的成本也会低)

在这里插入图片描述如果侵权，请联系作者夏目浅石，立刻删除

发表评论

表情：
评论列表 （有 0 条评论，134人围观）

还没有评论，来说两句吧...

相关阅读

    相关 单片机==回顾基础

    　　作为一个学硬件的学生，我感觉自己实在是太弱了，由于硬件的学习成本较高，一直以来我都是在自己写一些偏软件方面的小项目，对硬件的了解也仅限于学校的课堂了。 　　在我的感觉中，

    布满荆棘的人生布满荆棘的人生/ 0 赞/ 304 阅读