标题: 单片机步进电机控制实现直线插补的仿真与程序源码 [打印本页]

---

作者: 151431    时间: 2018-7-10 14:36
标题: 单片机步进电机控制实现直线插补的仿真与程序源码
单片机控制步进电机实现直线插补仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include<reg51.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. 
   
5. uchar code bux[]={0xf0,0xf1,0xf3,0xf2,0xf6,0xf4,0xfc,0xf8,0xf9};
   
6. uchar code buy[]={0x00,0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};
   
7. uchar code comx[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
   
8. uchar code comy[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
   
9. 
   
10. sbit SX=P3^4;
    
11. sbit SY=P3^5;
    
12. sbit ST=P3^6;
    
13. 
    
14. uint countx=0;
    
15. uint county=0;
    
16. uint count,flag=0;
    
17. uint x=0;
    
18. uint y=0;
    
19. uint a=0,b=0,k=0,m=0;
    
20. uint st=0;
    
21. char Fm[20];
    
22. 
    
23. void Key_Scan(void);
    
24. void Key_Action(void);
    
25. void motor();
    
26. void stepx();
    
27. void stepy();
    
28. void star();
    
29. void time0(void);
    
30. 
    
31. void delayms(uint t)
    
32. {
    
33. uint i,j;
    
34. for(i=0;i<t;i++)
    
35.   for(j=0;j<112;j++);
    
36. }
    
37. 
    
38. 
    
39. 
    
40. void main()
    
41. {
    
42.         while(1)
    
43.         {
    
44.                 Key_Scan();
    
45.                 time0();
    
46.                 while(!flag);
    
47.                 flag=0;
    
48.                 motor();
    
49.                 if(1==st)
    
50.                 {       
    
51.                         star();
    
52.                         st=0;
    
53.                 }
    
54.        
    
55.         }
    
56. }
    
57. 
    
58. 
    
59. void Key_Scan(void)
    
60. {
    
61.         if(0==SX)
    
62.         {
    
63.                 delayms(10);
    
64.                 if(0==SX)
    
65.                 {
    
66.                         countx++;
    
67.                         while(!SX);       
    
68.                 }       
    
69.         }
    
70.         if(0==SY)
    
71.         {
    
72.                 delayms(10);
    
73.                 if(0==SY)
    
74.                 {
    
75.                         county++;
    
76.                         while(!SY);       
    
77.                 }       
    
78.         }
    
79.        
    
80. }
    
81. void time0(void)
    
82. {
    
83.         TMOD=0x01;
    
84.         TH0=(65536-9216)/256;
    
85.         TL0=(65536-9216)%256;
    
86.         EA=1;
    
87.         ET0=1;
    
88.         TR0=1;
    
89. }
    
90. void TimeRS(void) interrupt 1
    
91. {
    
92.         TH0=(65536-9216)/256;
    
93.         TL0=(65536-9216)%256;
    
94.         count++;
    
95.         if(count>=10)
    
96.         {
    
97.                 Key_Action();
    
98.                 flag=1;       
    
99.                 count=0;       
    
100.         }
     
101. 
     
102. 
     
103.        
     
104. }
     
105. void Key_Action(void)
     
106. {
     
107.         uint i,j;
     
108.         if(countx>9)
     
109.         {
     
110.                 countx=0;
     
111.         }
     
112.         if(county>9)
     
113.         {
     
114.                 county=0;
     
115.         }
     
116.         P0=comx[countx];
     
117.         //delayms(100);
     
118.         P2=comy[county];
     
119.         //delayms(100);
     
120.        
     
121.        
     
122. }
     
123. void motor()
     
124. {
     
125.         uint i,j;
     
126.         if(0==ST)
     
127.         {
     
128.                 delayms(10);
     
129.                 if(0==ST)
     
130.                 {       
     
131.                         st=1;
     
132.                         while(!ST);       
     
133.                 }       
     
134.         }       
     
135. }
     
136. void star()
     
137. {
     
138.         a=countx;
     
139.         b=county;
     
140.         m=a+b;
     
141.         Fm[k]=0;
     
142.         while(m>0)
     
143.         {
     
144.                 if(Fm[k]>=0)
     
145.                 {
     
146.                         x++;
     
147.                         m--;
     
148.                         stepx();
     
149.                         k++;
     
150.                         Fm[k]=Fm[k-1]-b;
     
151. 
     
152.                 }
     
153.                 if(Fm[k]<0)
     
154.                 {
     
155.                         y++;
     
156.                         m--;
     
157.                         stepy();
     
158.                         k++;
     
159.                         Fm[k]=Fm[k-1]+a;
     
160.        
     
161.                 }
     
162.         }
     
163. }
     
164. void stepx()
     
165. {
     
166.         P3=bux[x];
     
167.         delayms(1000);
     
168. }
     
169. void stepy()
     
170. {       
     
171.         P1=bux[y];
     
172.         delayms(1000);
     
173. }
     
174. 
     
175. #include<reg51.h>
     
176. #define uint unsigned int
     
177. #define uchar unsigned char
     
178. 
     
179. uchar code bux[]={0xf0,0xf1,0xf3,0xf2,0xf6,0xf4,0xfc,0xf8,0xf9};
     
180. uchar code buy[]={0x00,0x10,0x30,0x20,0x60,0x40,0xc0,0x80,0x90};
     
181. uchar code comx[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
     
182. uchar code comy[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
     
183. 
     
184. sbit SX=P3^4;
     
185. sbit SY=P3^5;
     
186. sbit ST=P3^6;
     
187. 
     
188. uint countx=0;
     
189. uint county=0;
     
190. uint count,flag=0;
     
191. uint x=0;
     
192. uint y=0;
     
193. uint a=0,b=0,k=0,m=0;
     
194. uint st=0;
     
195. char Fm[20];
     
196. 
     
197. void Key_Scan(void);
     
198. void Key_Action(void);
     
199. void motor();
     
200. void stepx();
     
201. void stepy();
     
202. void star();
     
203. void time0(void);
     
204. 
     
205. void delayms(uint t)
     
206. {
     
207. uint i,j;
     
208. for(i=0;i<t;i++)
     
209.   for(j=0;j<112;j++);
     
210. }
     
211. 
     
212. 
     
213. 
     
214. void main()
     
215. {
     
216.         while(1)
     
217.         {
     
218.                 Key_Scan();
     
219.                 time0();
     
220.                 while(!flag);
     
221.                 flag=0;
     
222.                 motor();
     
223.                 if(1==st)
     
224.                 {       
     
225.                         star();
     
226.                         st=0;
     
227.                 }
     
228.        
     
229.         }
     
230. }
     
231. 
     
232. 
     
233. void Key_Scan(void)
     
234. {
     
235.         if(0==SX)
     
236.         {
     
237.                 delayms(10);
     
238.                 if(0==SX)
     
239.                 {
     
240.                         countx++;
     
241.                         while(!SX);       
     
242.                 }       
     
243.         }
     
244.         if(0==SY)
     
245.         {
     
246.                 delayms(10);
     
247.                 if(0==SY)
     
248.                 {
     
249.                         county++;
     
250.                         while(!SY);       
     
251.                 }       
     
252.         }
     
253.        
     
254. }
     
255. void time0(void)
     
256. {
     
257.         TMOD=0x01;
     
258.         TH0=(65536-9216)/256;
     
259.         TL0=(65536-9216)%256;
     
260.         EA=1;
     
261.         ET0=1;
     
262.         TR0=1;
     
263. }
     
264. void TimeRS(void) interrupt 1
     
265. {
     
266.         TH0=(65536-9216)/256;
     
267.         TL0=(65536-9216)%256;
     
268.         count++;
     
269.         if(count>=10)
     
270.         {
     
271.                 Key_Action();
     
272.                 flag=1;       
     
273.                 count=0;       
     
274.         }
     
275. 
     
276. 
     
277.        
     
278. }
     
279. void Key_Action(void)
     
280. {
     
281.         uint i,j;
     
282.         if(countx>9)
     
283.         {
     
284.                 countx=0;
     
285.         }
     
286.         if(county>9)
     
287.         {
     
288.                 county=0;
     
289.         }
     
290.         P0=comx[countx];
     
291.         //delayms(100);
     
292.         P2=comy[county];
     
293.         //delayms(100);
     
294.        
     
295.        
     
296. }
     
297. void motor()
     
298. {
     
299.         uint i,j;
     
300.         if(0==ST)
     
301.         {
     
302.                 delayms(10);
     
303.                 if(0==ST)
     
304.                 {       
     
305.                         st=1;
     
306.                         while(!ST);       
     
307.                 }       
     
308.         }       
     
309. }
     
310. void star()
     
311. {
     
312.         a=countx;
     
313.         b=county;
     
314.         m=a+b;
     
315.         Fm[k]=0;
     
316.         while(m>0)
     
317.         {
     
318.                 if(Fm[k]>=0)
     
319.                 {
     
320.                         x++;
     
321.                         m--;
     
322.                         stepx();
     
323.                         k++;
     
324.                         Fm[k]=Fm[k-1]-b;
     
325. 
     
326.                 }
     
327.                 if(Fm[k]<0)
     
328.                 {
     
329.                         y++;
     
330.                         m--;
     
331.                         stepy();
     
332.                         k++;
     
333.                         Fm[k]=Fm[k-1]+a;
     
334.        
     
335.                 }
     
336.         }
     
337. }
     
338. void stepx()
     
339. {
     
340.         P3=bux[x];
     
341.         delayms(1000);
     
342. }
     
343. void stepy()
     
344. {       
     
345.         P1=bux[y];
     
346.         delayms(1000);
     
347. }
     
348. 
     

复制代码

所有资料51hei提供下载:
步进电机.rar (32.22 KB, 下载次数: 81)

2018-7-10 14:35 上传

点击文件名下载附件
步进电机控制
下载积分: 黑币 -5

---

作者: 阿拉登666    时间: 2018-12-3 21:30
感谢分享 值得借鉴

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1