基于51单片机的光电电机测量转速系统(代码+仿真+文档)

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

单片机源程序如下:

1. #include <REG52.H>
   
2. #define uchar unsigned char
   
3. #define uint unsigned int
   
4. #define ulong unsigned long
   
5. #define LED_DAT P1
   
6. sbit LED_SEG0 = P2^4;
   
7. sbit LED_SEG1 = P2^5;
   
8. sbit LED_SEG2 = P2^6;
   
9. sbit LED_SEG3 = P2^7;
   
10. 
    
11. sbit led22= P3^7;
    
12. //sbit pin_SpeedSenser = P3^5; //光电传感器信号接在T1上
    
13. #define TIME_CYLC 100 //12M晶振，定时器10ms 中断一次 我们1秒计算一次转速 // 1000ms/10ms = 100
    
14. #define PLUS_PER 10 //码盘的齿数 ，这里假定码盘上有10个齿，即传感器检测到10个脉冲，认为1圈
    
15. #define K         100.0   //校准系数
    
16. 
    
17. 
    
18. 
    
19. unsigned char code  table[]=
    
20.                                           {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
    
21. 
    
22. uchar data Disbuf[4];// 显示缓冲区
    
23. uint Tcounter = 0;   //时间计数器
    
24. bit Flag_Fresh = 0; // 刷新标志
    
25. bit Flag_clac = 0; //计算转速标志
    
26. bit Flag_Err = 0; //超量程标志
    
27. //在数码管上显示一个四位数
    
28. void DisplayFresh();
    
29. //计算转速，并把结果放入数码管缓冲区
    
30. void ClacSpeed();
    
31. //初始化定时器T0
    
32. void init_timer0();
    
33. //初始化定时器T1
    
34. void init_timer1();
    
35. //延时函数
    
36. void Delay(uint ms);
    
37. void it_timer0() interrupt 1 /* interrupt address is 0x000b */
    
38. {
    
39. TF0 = 0;       //d定时器 T0用于数码管的动态刷新
    
40.          //
    
41. TH0 = 0xC0;            /* init values */
    
42. TL0 = 0x00;
    
43. Flag_Fresh = 1;
    
44. Tcounter++;
    
45. if(Tcounter>TIME_CYLC)
    
46. { Flag_clac = 1;//周期到，该重新计算转速了
    
47. }
    
48. }
    
49. void it_timer1() interrupt 3 /* interrupt address is 0x001b */
    
50. {
    
51. TF1 = 0;   //定时器T1用于单位时间内收到的脉冲数
    
52.                  //要速度不是很快，T1永远不会益处
    
53. Flag_Err = 1;   //如果速度很高，我们应考虑另外一种测速方法，：脉冲宽度算转速
    
54. 
    
55. }
    
56. void main(void)
    
57. {
    
58. Disbuf[0] = 0; //开机时，初始化为0000
    
59. Disbuf[1] = 0;
    
60. Disbuf[2] = 0;
    
61. Disbuf[3] = 0;
    
62.    init_timer0();
    
63. init_timer1();
    
64. while(1)
    
65. {
    
66. if(Flag_Fresh)
    
67.    { Flag_Fresh = 0;
    
68.     DisplayFresh();    // 定时刷新数码管显示
    
69.    }
    
70.    if(Flag_clac)
    
71.    { Flag_clac = 0;
    
72.     ClacSpeed(); //计算转速，并把结果放入数码管缓冲区
    
73.     Tcounter = 0;//周期定时 清零
    
74.     TH1=TL1 = 0x00;//脉冲计数清零
    
75. 
    
76.    }
    
77.    if(Flag_Err)        //超量程处理
    
78.    {
    
79.       //数码管显示字母'EEEE'
    
80.     Disbuf[0] = 0x9e; //开机时，初始化为0000
    
81.     Disbuf[1] = 0x9e;
    
82.     Disbuf[2] = 0x9e;
    
83.     Disbuf[3] = 0x9e;
    
84.     while(1)
    
85.     { DisplayFresh();//不再测速 等待复位i
    
86.     }
    
87.    }
    
88. 
    
89. }
    
90. }
    
91. 
    
92. //在数码管上显示一个四位数
    
93. void DisplayFresh()
    
94. {
    
95. P2 |= 0xF0;
    
96. LED_SEG0 = 0;
    
97. LED_DAT = table[Disbuf[0]];
    
98. Delay(1);
    
99. P2 |= 0xF0;
    
100. LED_SEG1 = 0;
     
101. LED_DAT = table[Disbuf[1]];
     
102. Delay(1);
     
103. P2 |= 0xF0;
     
104. LED_SEG2 = 0;
     
105. LED_DAT = table[Disbuf[2]];
     
106. Delay(1);
     
107. P2 |= 0xF0;
     
108. LED_SEG3 = 0;
     
109. LED_DAT = table[Disbuf[3]];
     
110. Delay(1);
     
111. P2 |= 0xF0;
     
112. 
     
113. }
     
114. //计算转速，并把结果放入数码管缓冲区
     
115. void ClacSpeed()
     
116. {
     
117. uint speed ;
     
118. uint PlusCounter;
     
119. 
     
120. PlusCounter = TH1*256 + TL1;
     
121. speed = K*(PlusCounter/PLUS_PER)/60;//K是校准系数，如速度不准，调节K的大小
     
122. Disbuf[0] = (speed/1000)%10;
     
123. Disbuf[1] = (speed/100)%10;
     
124. Disbuf[2] = (speed/10)%10;
     
125. Disbuf[3] = speed%10;
     
126.         
     
127.         if(speed>=30)
     
128.         {
     
129.         led22=1;
     
130.         }
     
131.         else  led22=0;
     
132. }
     
133. //初始化定时器T0
     
134. void init_timer0()
     
135. {
     
136. TMOD &= 0xf0; //定时10毫秒         /* Timer 0 mode 1 with software gate */
     
137. TMOD |= 0x01;              /* GATE0=0; C/T0#=0; M10=0; M00=1; */
     
138. 
     
139. TH0 = 0xC0;            /* init values */
     
140. TL0 = 0x00;
     
141. ET0=1;                     /* enable timer0 interrupt */
     
142. EA=1;                /* enable interrupts */
     
143. TR0=1;               /* timer0 run */
     
144. }
     
145. //延时函数
     
146. void Delay(uint ms)
     
147. {
     
148. uchar i;
     
149. while(ms--)
     
150.    for(i=0;i<100;i++);
     
151. }
     
152. //初始化定时器T1
     
153. void init_timer1()
     
154. {
     
155. TMOD &= 0x0F;         /* Counter 1 mode 1 with software gate */
     
156. TMOD |= 0x50;              /* GATE0=0; C/T0#=1; M10=0; M00=1; */
     
157. 
     
158. TH1 = 0x00;            /* init values */
     
159. TL1 = 0x00;
     
160. ET1=1;                     /* enable timer1 interrupt */
     
161. EA=1;                /* enable interrupts */
     
162. TR1=1;               /* timer1 run */
     
163. }

复制代码