devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于“51系列单片机”的传送带产品计数器设计（包含Proteus仿真模拟、keil编程，以及实物设计过程）_单片机课程设计传送带产品计数器

作者：我家自动化 | 2024-06-24 08:16:18

赞

踩

单片机课程设计传送带产品计数器

目录

 一、具体实现功能

二、设计方案

2.1、设计思路

2.2、设计版块

1、数码管显示模块

2、矩阵键盘控制模块 

3、直流电机驱动模块

4、基于光敏电阻的光电开关模块

三、proteus仿真图

四、proteus仿真代码部分

五、实物运行视频

六、实物代码部分

 一、具体实现功能

1、用独立按键控制传送带的启动或停止。

2、用基于光敏电阻的光电传感器检测通过其的产品数量。

3、用LED显示传送带通过产品的数量。

4、用矩阵键盘预置终值，当计数达到终值时，传送带停止。

5、可以通过矩阵键盘完成预设终值的输入、退位和清零，以及计数数值清零。

二、设计方案

        在开始设计前，首先需要进行的是对于单片机的选择，我在这里Proteus仿真运行时采用的是正常的89C51单片机，然后在实物方面（由于有现成的开发板）用的是52RC单片机。

2.1、设计思路

下面是本次设计的设计思路：

（1）分析传送带产品计数设计方案中所需要满足的各种功能，选择适合的电子器件作为课程设计的基础。

（2）学习整理单片机相关学习内容（包括直流电机运行、外部中断计数、动态数码管显示、矩阵键盘运用等知识点），同时了解三极管和光敏电阻的基本知识，对于课程设计方案有一个最基本的知识框架。

（3）选用51系列单片机，编写代码以依次实现直流电机的正常运行、动态数码管各位数字的显示、矩阵键盘的按键检测、外部中断I/O口P3.2检测下降沿变化并计数等功能。

（4）根据选用光敏电阻的暗电阻和亮电阻阻值，结合三极管的特点，设计光电开关，用来接在外部中断I/O口P3.2。可以通过检测外部光照强度的大小，改变光敏电阻的阻值，以此来实现高低电平的转换。

（5）将上述功能通过逻辑规划整合到一起，实现4*4矩阵键盘中左侧3*4按键对动态数码管左侧四位预设终止值的数字输入、退位以及清零的功能，右侧四个按键实现控制直流电机正转、倒转、急停，以及对动态数码管右侧四位外部中断计数的清零。

（6）在电脑上通过仿真软件实现该设计的正常运行。在进行软件系统的设计和仿真中，程序在Keil中用单片机c语言编写，电路的搭建和仿真实现在Proteus软件中进行实现。

（7）在电脑的仿真软件中顺利运行后，进行实物的接线以及程序的烧录，调节中断函数中延迟时间来控制外部中断计数的间隔，使其达到通过一个产品，计数加一的效果。

2.2、设计版块

本次设计主要内容分为四个版块，如下：

 这里我为大家分板块进行讲解。

1、数码管显示模块

        

数字显示

LED显示部分

二进制显示

十六进制显示

0

abcdef

0011 1111

0x3f

1

bc

0000 0110

0x06

2

abdeg

0101 1011

0x5b

3

abcdg

0100 1111

0x4f

4

bcfg

0110 0110 

0x66

5

acdfg

0110 1101 

0x6d

6

acdefg

0111 1101

0x7d

7

abc

0000 0111

0x07

8

abcdefg

0111 1111

0x7f

9

abcdfg

0110 1111

0x6f

         采用的是共阴极八位数码管，通过74LS138解码器进行动态显示。静态数码管显示的原理如图表示，a—g七个部分分别控制每一位上七段LED的亮灭，dp是控制小数点部位LED的亮灭。可以对a-g每个部分进行高低电平的赋予，来实现数码管数字的显示。（共阴极数码管是高电平驱动，共阳极数码管是低电平驱动）

        而动态数码管是静态数码管利用上了74LS138解码器，其中三个接口（LSA、LSB、LSC）连接到单片机三个I/O口上，通过高低电平，三组0和1的排列组合，共八（即二的三次方）种，来表示八位数码管显示第几位。

 

2、矩阵键盘控制模块 

        矩阵键盘本质是使用8个I/O口来进行16个按键的控制读取，可以减小I/O口的使用，用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每个交叉点上，设置一个按键。而这样的按键中按键的个数是4 X 4个。

        这样的行列式键盘结构能够有效地提高单片机系统中I/O口的利用率。节约单片机的资源，其本质和独立按键类似，就是进行逐行扫描和逐列扫描，然后判断是第几行的第几列个按键，进而进行整体按键值的确定。

3、直流电机驱动模块

直流电机没有正负之分，在两端加上直流电就能工作。交换电极可以改变电机旋转的方向。

EN1

IN1

IN2

实现功能

0

——

——

停止

1

1

0

顺时针

1

0

1

逆时针

1

0

0

停止

1

1

1

刹停

        基于电机驱动器L293D，EN1、IN1、IN2的三个端口分别接在管脚P3^5、P3^6和P3^7上面，我们可以根据三个串口的高低电平来控制直流电机（传送带）去实现停止、顺时针转动、逆时针转动、刹停等功能，实现内容如上述表格所示。

4、基于光敏电阻的光电开关模块

        光敏电阻随光照强度增大，阻值会变小。

        根据光敏电阻的这一个原理，我们再结合一个三极管或者晶体管（这里选用的是npn型三极管），就可以做成一个简单的光电开关。设计内容如下：

        这就是一个简单的光电开关，实物采用的是型号为8050的三极管、型号为5516的光敏电阻、一个470欧姆的电阻、一个200千欧的滑动变阻器。（实物验证过，可以在添加一个小LED灯下，通过遮挡LED灯进入到外部中断，取消遮挡会回到主程序，滑动变阻器可以调节光敏电阻的灵敏度，正常情况下150千欧是较为合适的。其实在连接I/O口P3.2之前，R3右侧再添加一个电容接地更为严谨，目的是缓冲作用）

        中断发生的过程就是当光敏电阻阻值改变时，基极电流发生改变，会引起集电极电流发生很大改变，I/O口便可以检测到下降沿变化，从而实现外部中断。

（注释：三极管原理：三极管主要用来控制电流的大小，以共发射极接法为例（信号从基极输入，从集电极输出，发射极接地），当基极电压UB有一个微小的变化时，基极电流IB也会随之有一小的变化，受基极电流IB的控制，集电极电流IC会有一个很大的变化，基极电流IB越大，集电极电流IC也越大，反之，基极电流越小，集电极电流也越小，即基极电流控制集电极电流的变化。但是集电极电流的变化比基极电流的变化大得多，这就是三极管的电流放大作用。）

三、proteus仿真图

注释：

        按键AC表示预置终值的清零

        按键BACK表示预置终值的退位

        按键JSAC表示计数数值的清零

        按键FORD表示直流电机正转

        按键DC表示直流电机停止

        按键REV表示直流电机倒转

        keil编写的代码需要将它的hex格式在这个地方配置给仿真的51单片机。

四、proteus仿真代码部分

  1. #include<reg51.h>
  2. #define PKEY P1
  3. #define PDIG P2
  4.  
  5.  
  6. sbit LSA = P3 ^ 0;
  7. sbit LSB = P3 ^ 1;
  8. sbit LSC = P3 ^ 3;
  9. sbit IN0 = P3 ^ 4;
  10. sbit IN1 = P3 ^ 5;
  11. sbit E = P3 ^ 6;
  12.  
  13. unsigned char code smgnum[]={ 0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//?????0~9??
  14. unsigned char code smgmum[]={ 0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};//?????0~9??
  15. unsigned int gd;
  16. unsigned int num=99;
  17. unsigned int keyswitch, tuiwei, wei = 0, x, y;
  18. unsigned int box[8]={0};
  19. unsigned int i;
  20.  
  21.  
  22. void delay(unsigned int x)                //延迟函数
  23. {
  24.     unsigned int i, j;
  25.     for (i = 0; i < x; i++)
  26.         for (j = 0; j < 120; j++) ;
  27. }
  28.  
  29.  
  30.  
  31. void kaishi()                             //电机正转
  32. {
  33.     IN0 = 1;
  34.     IN1 = 0;
  35.     delay(5);
  36. }
  37.  
  38.  
  39.  
  40. void daofang()                            //电机倒转
  41. {
  42.     IN1 = 1;
  43.     IN0 = 0;
  44.     delay(5);
  45. }
  46.  
  47.  
  48.  
  49.  
  50. void int0_init(void)                      //开启外部中断
  51. {
  52. 	EX0=1;
  53. 	IT0=1;
  54. 	EA=1;
  55. }
  56.  
  57.  
  58.  
  59. void key_scan()                           //矩阵键盘检测函数
  60. {
  61.     unsigned char temp0 = 0, temp1 = 0, temp = 0;
  62.     unsigned int a = 0;
  63.     PKEY = 0xf0;
  64.     if (PKEY != 0xf0)
  65.     {
  66.         delay(20);
  67.         if (PKEY != 0xf0)
  68.         {
  69.             temp0 = PKEY;
  70.             PKEY = 0x0f;
  71.             if (PKEY != 0x0f)
  72.             {
  73.                 temp1 = PKEY;
  74.             }
  75.             temp = temp0 + temp1;
  76.             if (temp == 0xee) { num = 1; }
  77.             else if (temp == 0xed) { num = 2; }
  78.             else if (temp == 0xeb) { num = 3; }
  79.             else if (temp == 0xe7) { num = 12; }
  80.             else if (temp == 0xde) { num = 4; }
  81.             else if (temp == 0xdd) { num = 5; }
  82.             else if (temp == 0xdb) { num = 6; }
  83.             else if (temp == 0xd7) { num = 13; }
  84.             else if (temp == 0xbe) { num = 7; }
  85.             else if (temp == 0xbd) { num = 8; }
  86.             else if (temp == 0xbb) { num = 9; }
  87.             else if (temp == 0xb7) { num = 14; }
  88.             else if (temp == 0x7e) { num = 10; }
  89.             else if (temp == 0x7d) { num = 0; }
  90.             else if (temp == 0x7b) { num = 11; }
  91.             else if (temp == 0x77) { num = 15; }
  92.             if (num == 0 || num == 1 || num == 2 || num == 3 || num == 4 || num == 5 || num == 6 || num == 7 || num == 8 || num == 9)
  93.                 keyswitch = 1;
  94.             if (num == 10)
  95.                 tuiwei = 1;
  96.             while ((a < 50) && (PKEY != 0x0f))
  97.             {
  98.                 delay(10);
  99.                 a++;
  100.             }
  101.         }
  102.     }
  103. }
  104.  
  105.  
  106.  
  107. void smg()                           //数码管显示函数
  108. {
  109.     LSA = 1; LSB = 1; LSC = 1;
  110.     PDIG = smgnum[box[0]];
  111.     delay(1); PDIG = 0x00;
  112.  
  113.     LSA = 0; LSB = 1; LSC = 1;
  114.     PDIG = smgnum[box[1]];
  115.     delay(1); PDIG = 0x00;
  116.  
  117.     LSA = 1; LSB = 0; LSC = 1;
  118.     PDIG = smgnum[box[2]];
  119.     delay(1); PDIG = 0x00;
  120.  
  121.     LSA = 0; LSB = 0; LSC = 1;
  122.     PDIG = smgnum[box[3]];
  123.     delay(1); PDIG = 0x00;
  124.  
  125.     LSA = 1; LSB = 1; LSC = 0;
  126.     PDIG = smgnum[box[4]];
  127.     delay(1); PDIG = 0x00;
  128.  
  129.     LSA = 0; LSB = 1; LSC = 0;
  130.     PDIG = smgnum[box[5]];
  131.     delay(1); PDIG = 0x00;
  132.  
  133.     LSA = 1; LSB = 0; LSC = 0;
  134.     PDIG = smgnum[box[6]];
  135.     delay(1); PDIG = 0x00;
  136.  
  137.     LSA = 0; LSB = 0; LSC = 0;
  138.     PDIG = smgnum[box[7]];
  139.     delay(1); PDIG = 0x00;
  140. }
  141.  
  142.  
  143.  
  144. void main()                                    //主函数
  145. {
  146. 		int0_init();
  147.     while (1)
  148.     {
  149.         smg();
  150.         key_scan();
  151.         if (num == 12)                         //按键控制直流电机正转
  152.         {
  153.             x = 1;
  154.             y = 0;
  155.         }
  156.         if (x == 1)
  157.         {
  158.             kaishi();
  159.             if ((box[7] == 0) && (box[6] == 0) && (box[5] == 0) && (box[4] == 0))
  160.             {
  161.                 kaishi();
  162.             }
  163.             else
  164.             {
  165.                 if ((box[3] == box[7]) && (box[2] == box[6]) && (box[1] == box[5]) && (box[0] == box[4]))
  166.                 {
  167.                     num = 13;
  168.                 }
  169.             }
  170.         }
  171.         if (num == 14)                    //按键控制直流电机倒转
  172.         {
  173.             y = 1;
  174.             x = 0;
  175.         }
  176.         if (y == 1) 
  177.             daofang();
  178.             if ((box[7] == 0) && (box[6] == 0) && (box[5] == 0) && (box[4] == 0))
  179.             {
  180.                 daofang();
  181.             }
  182.             else
  183.             {
  184.                 if ((box[3] == box[7]) && (box[2] == box[6]) && (box[1] == box[5]) && (box[0] == box[4]))
  185.                 {
  186.                     num = 13;
  187.                 }
  188.             }
  189.         }
  190.         if (num == 13)                             //按键控制直流电机停止
  191.         {
  192.             E = 1;
  193.             IN0 = 1;
  194.             IN1 = 1;
  195.             x = 0;
  196.             y = 0;
  197.             num = 99;
  198.         }
  199.         if ((keyswitch == 1) && (wei < 4))        //预设数值输入
  200.         {
  201.             for (i = 7; i > 4; i--)
  202.             { box[i] = box[i - 1]; }
  203.             box[4] = num;
  204.             keyswitch = 0;
  205.             wei++;
  206.         }
  207.         if (num == 11)                           //预设数值清零
  208.         {
  209.             for (i = 4; i < 8; i++)
  210.             {
  211.                 box[i] = 0;
  212.             }
  213.             wei = 0;
  214.         }
  215.         if (num == 15)                          //计数数值清零
  216.         {
  217.             gd = 0;
  218.             num = 99;
  219.         }
  220.         if (tuiwei == 1)                        //预设数值退位
  221.         {
  222.             box[4] = box[5];
  223.             box[5] = box[6];
  224.             box[6] = box[7];
  225.             box[7] = 0;
  226.             if (wei > 0)
  227.                 wei--;
  228.             tuiwei = 0;
  229.         }
  230.         box[0] = gd  % 10;
  231.         box[1] = gd / 10 % 10;
  232.         box[2] = gd / 100 % 10;
  233.         box[3] = gd / 1000 % 10;
  234.     }
  235. }
  236.  
  237.  
  238.  
  239. void int0() interrupt 0                  //中断函数
  240. {
  241. 	gd++;
  242. 	delay(200);
  243. }

五、实物运行视频

链接：https://pan.baidu.com/s/1YT7GfhHj1hKg8rdouowqVg?pwd=4c9d 
提取码：4c9d 
--来自百度网盘超级会员V1的分享

六、实物代码部分

  1. #include <REGX52.H>
  2. #define PKEY P1                    //宏定义单片机I/O口的P1为PKEY
  3. #define uchar unsigned char        //宏定义unsigned char为uchar
  4. #define uint  unsigned int         //宏定义unsigned int为uint
  5.  
  6. sbit IN0 = P3 ^ 7;
  7. sbit IN1 = P3 ^ 6;
  8. sbit E = P3 ^ 5;
  9.  
  10.  
  11. uchar NixieTable[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F};
  12. uint x,num,wei,keyswitch,i,shu,a,tuiwei,jishu;
  13. uint box[4]={0};
  14. uchar Counter,Compare,Speed;
  15.  
  16.  
  17.  
  18. void Delay(unsigned int xms)//延迟函数
  19. {
  20. 	unsigned char i, j;
  21. 	while(xms--)
  22. 	{
  23. 		i = 2;
  24. 		j = 23;
  25. 		do
  26. 		{
  27. 			while (--j);
  28. 		} while (--i);
  29. 	}
  30. }
  31.  
  32.  
  33. void int0_init(void)                 //开启外部中断
  34. {
  35. 	EX0=1;
  36. 	IT0=1;
  37. 	EA=1;
  38. }
  39.  
  40.  
  41.  
  42.  
  43. void key_scan()                      //矩阵键盘函数
  44. {
  45.     uchar temp0 = 0, temp1 = 0, temp = 0;
  46.     PKEY = 0xf0;
  47.     if (PKEY != 0xf0)
  48.     {
  49.         Delay(20);
  50.         if (PKEY != 0xf0)
  51.         {
  52.             temp0 = PKEY;
  53.             PKEY = 0x0f;
  54.             if (PKEY != 0x0f)
  55.             {
  56.                 temp1 = PKEY;
  57.             }
  58.             temp = temp0 + temp1;
  59.             if (temp == 0xee) { num = 1; }
  60.             else if (temp == 0xed) { num = 2; }
  61.             else if (temp == 0xeb) { num = 3; }
  62.             else if (temp == 0xe7) { num = 12; }
  63.             else if (temp == 0xde) { num = 4; }
  64.             else if (temp == 0xdd) { num = 5; }
  65.             else if (temp == 0xdb) { num = 6; }
  66.             else if (temp == 0xd7) { num = 13; }
  67.             else if (temp == 0xbe) { num = 7; }
  68.             else if (temp == 0xbd) { num = 8; }
  69.             else if (temp == 0xbb) { num = 9; }
  70.             else if (temp == 0xb7) { num = 14; }
  71.             else if (temp == 0x7e) { num = 10; }
  72.             else if (temp == 0x7d) { num = 0; }
  73.             else if (temp == 0x7b) { num = 11; }
  74.             else if (temp == 0x77) { num = 15; }
  75. 			if (num == 0 || num == 1 || num == 2 || num == 3 || num == 4 || num == 5 || num == 6 || num == 7 || num == 8 || num == 9)
  76. 			{
  77. 				keyswitch = 1;
  78. 			}
  79. 			if (num == 10)
  80. 			{
  81. 				tuiwei = 1;
  82. 				num=99;
  83. 			}
  84. 			while ((a < 50) && (PKEY != 0x0f))
  85.             {
  86.                 Delay(600);
  87.                 a++;
  88.             }
  89. 				 }
  90. 		}
  91. }
  92.  
  93.  
  94.  
  95. void Nixie(unsigned char Location,Number)//数码管显示函数
  96. {
  97. 	switch(Location)
  98. 	{
  99. 		case 1:P2_4=1;P2_3=1;P2_2=1;break;
  100. 		case 2:P2_4=1;P2_3=1;P2_2=0;break;
  101. 		case 3:P2_4=1;P2_3=0;P2_2=1;break;
  102. 		case 4:P2_4=1;P2_3=0;P2_2=0;break;
  103. 		case 5:P2_4=0;P2_3=1;P2_2=1;break;
  104. 		case 6:P2_4=0;P2_3=1;P2_2=0;break;
  105. 		case 7:P2_4=0;P2_3=0;P2_2=1;break;
  106. 		case 8:P2_4=0;P2_3=0;P2_2=0;break;
  107. 	}
  108. 	P0=NixieTable[Number];
  109. 	Delay(1);
  110. 	P0=0x00;
  111. }
  112.  
  113.  
  114.  
  115.  
  116.  
  117. void Timer0_Init(void)   //开启定时器中断
  118. {
  119.  	TMOD &= 0xF0;		//设置定时器模式
  120. 	TMOD |= 0x01;		//设置定时器模式
  121. 	TL0 = 0x9C;		//设置定时初值
  122. 	TH0 = 0xFF;		//设置定时初值
  123. 	TF0 = 0;		//清除TF0标志
  124. 	TR0 = 1;		//定时器0开始计时
  125. 	ET0=1;
  126. 	EA=1;
  127. 	PT0=0;
  128. }
  129.  
  130. void main()//主函数
  131. {
  132. 	E=0;
  133. 	Timer0_Init();
  134. 	while(1)
  135. 	{
  136. 		Nixie(1,box[0]);
  137. 		Delay(1);
  138. 		Nixie(2,box[1]);
  139. 		Delay(1);
  140. 		Nixie(3,box[2]);
  141. 		Delay(1);
  142. 		Nixie(4,box[3]);
  143. 		Delay(1);
  144. 		Nixie(5,x/1000%10);
  145. 		Delay(1);
  146. 		Nixie(6,x/100%10);
  147. 		Delay(1);
  148. 		Nixie(7,x/10%10);
  149. 		Delay(1);
  150. 		Nixie(8,x%10);
  151. 		Delay(1);
  152. 		key_scan();
  153. 		if ((keyswitch == 1) && (wei < 4))
  154. 		{
  155. 			for (i = 0; i < 3; i++)
  156. 			{ box[i] = box[i + 1]; }
  157. 			box[3] = num;
  158. 			keyswitch = 0;
  159. 			wei++;
  160. 			num=99;
  161. 		}
  162. 		if (tuiwei == 1)
  163. 		{
  164. 			box[3] = box[2];
  165. 			box[2] = box[1];
  166. 			box[1] = box[0];
  167. 			box[0] = 0;
  168. 			if (wei > 0)
  169. 			wei--;
  170. 			tuiwei = 0;
  171. 		}
  172. 		if (num == 11)
  173. 		{
  174. 			for (i = 0; i < 4; i++)
  175. 			{
  176. 				box[i] = 0;
  177. 			}
  178. 			wei = 0;
  179. 			num=99;
  180. 		}
  181. 		jishu=1000*box[0]+100*box[1]+10*box[2]+box[3];
  182. 		if(num==12)
  183. 		{
  184. 			E=1;
  185. 			Speed=1;
  186. 			num=99;
  187. 		}
  188. 		if(num==14)
  189. 		{
  190. 			E=1;
  191.             Speed=2;
  192. 			num=99;
  193. 		}
  194. 		if(Speed==1){Compare=0;}
  195. 		if(Speed==2){Compare=51;}
  196. 		if(Speed==0){Compare=100;}
  197. 		if (num==13)
  198.         {
  199.             E = 1;
  200.             IN0 = 1;
  201.             IN1 = 1;
  202. 			Speed=0;
  203.             num = 99;
  204.         }
  205. 		if(num==15)
  206. 		{
  207. 			x=0;
  208. 			num=99;
  209. 		}
  210. 		if(x!=0 && jishu==x)
  211. 		{
  212. 			E = 1;
  213.             IN0 = 1;
  214.             IN1 = 1;
  215. 			Speed=0;
  216.             num = 99;
  217. 		}
  218. 		int0_init();
  219. 	}
  220. }
  221.  
  222.  
  223. void int0() interrupt 0               //外部中断函数
  224. {
  225. 	x++;
  226. 	Delay(300);
  227. }
  228.  
  229.  
  230.  
  231. void Timer0_Routine() interrupt 1     //定时器中断函数
  232. {
  233. 	TL1 = 0x9C;
  234. 	TH1 = 0xFF;
  235. 	Counter++;
  236. 	Counter%=50;
  237. 	if(Compare!=100)
  238. 	{
  239. 		if(Counter<Compare)
  240. 		{
  241. 			IN0=1;
  242. 			IN1=0;
  243. 		}	
  244. 		if(Counter>Compare)
  245. 		{
  246. 			IN0=0;
  247. 			IN1=1;
  248. 		}
  249. 	}
  250. }

        需要提出来一些需要注意的地方，因为可能是电压的原因，传送带在直流电机控制的情况下，给转动信号的时候，不能马上转动起来，需要用手轻微拨动一下，才可以实现传送带的转动。

        然后，实物中，我又比Proteus仿真多用了一个定时器中断，原本想通过定时器中断来精准控制电机正转倒转的时间分配，结果好像用处不大，因为传送带好像大部分都是有按钮控制转动，一个按钮控制停止，转动的时候朝向一个方向不停转动，几乎不会出现我想的正转多少时间再倒转多少时间一直持续这样工作。于是，我保留了定时器中断的格式，稍微修改，还是按照上面Proteus仿真的模式来的。这个代码部分可能乍一看，有点迷，但是到这里应该就会有所理解了。

        还有一个需要注意的是，因为我购买的52RC单片机开发板默认八位数码管连接的是I/O口P0，所以代码里面没有添加进去，所以实物的整体连线是和Proteus仿真有一些区别的，要特别注意！！！！！！

        如果有要制作实物的想法，需要将keil代码烧录进单片机里，不懂的话可以搜索相关教程，一步步来。

若有需求可以联系作者本人，看到后会回复。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/752142
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号