二相四線步進電機的單片機源程序 用L298N模塊驅(qū)動

在網(wǎng)上找了很久資料，都沒有直接的源代碼去驅(qū)動二相四線步進電機。本人編寫了一些基本的代碼，再加上L298N模塊，就可以輕松驅(qū)動啦。


單片機源程序如下:

1. #include "reg52.h"
   
2. 
   
3. //電機IO
   
4. #define GPIO_MOTOR P1
   
5. //sbit F1 = P1^0;
   
6. //sbit F2 = P1^1;
   
7. //sbit F3 = P1^2;
   
8. //sbit F4 = P1^3;
   
9. //按鍵IO
   
10. 
    
11. sbit K1=P3^0;
    
12. sbit K2=P3^1;
    
13. sbit K3=P3^2;
    
14. sbit K4=P3^3;
    
15. 
    
16.                                                                                                                                                                     
    
17. sbit a0=P1^0;                          
    
18. sbit a1=P1^1;           
    
19. sbit b0=P1^3;
    
20. sbit b1=P1^4;
    
21. 
    
22. void right(unsigned int y);
    
23. void left(unsigned int x);
    
24. void Delay(unsigned int t);
    
25. unsigned char Direction,Speed;
    
26. void motor();
    
27. /*******************************************************************************
    
28. * 函 數(shù) 名         : main
    
29. * 函數(shù)功能                   : 主函數(shù)
    
30. * 輸    入         : 無
    
31. * 輸    出         : 無
    
32. *******************************************************************************/
    
33. 
    
34. void main(void)
    
35. {
    
36.         unsigned char i;       
    
37.    Speed=10;
    
38. 
    
39.   while(1)
    
40.         {
    
41.                          
    
42.           if(K1==0)                //檢測按鍵K1是否按下
    
43.                 {
    
44.                         Delay(50);        //消除抖動
    
45.                         if(K1==0)
    
46.                         {
    
47.                                 Direction=1;
    
48.                         }
    
49.                         while((i<200)&&(K1==0))         //檢測按鍵是否松開
    
50.                         {
    
51.                                 Delay(50);
    
52.                                 i++;
    
53.                         }
    
54.                         i=0;
    
55.                 }
    
56. 
    
57. 
    
58.                 if(K2==0)                //檢測按鍵K1是否按下
    
59.                 {
    
60.                         Delay(50);        //消除抖動
    
61.                         if(K2==0)
    
62.                         {
    
63.                                 Direction=2;
    
64.                         }
    
65.                         while((i<200)&&(K2==0))         //檢測按鍵是否松開
    
66.                         {
    
67.                                 Delay(50);
    
68.                                 i++;
    
69.                         }
    
70.                         i=0;
    
71.                 }       
    
72. 
    
73. 
    
74. 
    
75.                  if(K3==0)                //檢測按鍵K1是否按下
    
76.                 {
    
77.                         Delay(100);        //消除抖動
    
78.                         if(K3==0)
    
79.                         {
    
80.                                 Speed--;
    
81.                                 if(Speed<=3)
    
82.                                 Speed=4;
    
83.                         }
    
84.                         while((i<200)&&(K2==0))         //檢測按鍵是否松開
    
85.                         {
    
86.                                 Delay(1);
    
87.                                 i++;
    
88.                         }
    
89.                         i=0;
    
90.                 }
    
91.          
    
92.                 if(K4==0)                //檢測按鍵K1是否按下
    
93.                 {
    
94.                         Delay(100);        //消除抖動
    
95.                         if(K4==0)
    
96.                         {
    
97.                                 Speed++;
    
98.                         }
    
99.                         while((i<200)&&(K4==0))         //檢測按鍵是否松開
    
100.                         {
     
101.                                 Delay(100);
     
102.                                 i++;
     
103.                         }
     
104.                         i=0;
     
105.                 }       
     
106. 
     
107.           motor();
     
108.   
     
109. 
     
110.         }
     
111. }
     
112. 
     
113. 
     
114. 
     
115. 
     
116. 
     
117. void motor()
     
118. {
     
119. 
     
120. if(Direction==1)
     
121.         {
     
122.         a0=0;
     
123.         a1=1;
     
124.         b0=1;
     
125.         b1=1;
     
126.         Delay(Speed);
     
127.         a0=1;
     
128.         a1=0;
     
129.         b0=1;
     
130.         b1=1;
     
131.         Delay(Speed);
     
132.         a0=1;
     
133.         a1=1;
     
134.         b0=0;
     
135.         b1=1;
     
136.         Delay(Speed);
     
137.         a0=1;
     
138.         a1=1;
     
139.         b0=1;
     
140.         b1=0;
     
141.         Delay(Speed);
     
142.         }
     
143. 
     
144. 
     
145. if(Direction==2)
     
146.                  
     
147.         {
     
148.         a0=1;
     
149.         a1=1;
     
150.         b0=1;
     
151.         b1=0;
     
152.         Delay(Speed);
     
153.         a0=1;
     
154.         a1=1;
     
155.         b0=0;
     
156.         b1=1;
     
157.         Delay(Speed);
     
158.         a0=1;
     
159.         a1=0;
     
160.         b0=1;
     
161.         b1=1;
     
162.         Delay(Speed);
     
163.         a0=0;
     
164.         a1=1;
     
165.         b0=1;
     
166.         b1=1;
     
167.         Delay(Speed);
     
168.         }
     
169. 
     
170. 
     
171. }
     
172. 
     
173.                                                                                                                                                                           
     
174. void Delay(unsigned int t)
     
175. {                           
     
176.         unsigned int k;
     
177.         while(t--)
     
178.         {
     
179.                 for(k=0; k<70; k++)
     
180.                 { }
     
181.         }
     
182. }
     
183. 
     
184. 
     
185. 
     
186. 
     
187. 
     
188. 
     
189. 
     
190. 
     
191. 
     
192. 
     
193. 
     
194. 
     
195. 
     
196. 
     
197. 
     
198. 
     
199. /*void left(unsigned int x)
     
200. {
     
201. a0=0;
     
202. a1=1;
     
203. b0=1;
     
204. b1=1;
     
205. Delay(x);
     
206. a0=1;
     
207. a1=0;
     
208. b0=1;
     
209. b1=1;
     
210. Delay(x);
     
211. a0=1;
     
212. a1=1;
     
213. b0=0;
     
214. b1=1;
     
215. Delay(x);
     
216. a0=1;
     
217. a1=1;
     
218. b0=1;
     
219. b1=0;
     
220. Delay(x);
     
221. }
     
222. 
     
223. 
     
224. void right(unsigned int y)
     
225. {
     
226. a0=1;
     
227. a1=1;
     
228. b0=1;
     
229. b1=0;
     
230. Delay(y);
     
231. a0=1;
     
232. a1=1;
     
233. b0=0;
     
234. b1=1;
     
235. Delay(y);
     
236. a0=1;
     
237. a1=0;
     
238. b0=1;
     
239. b1=1;
     
240. Delay(y);
     
241. a0=0;
     
242. a1=1;
     
243. b0=1;
     
244. b1=1;
     
245. Delay(y);
     
246. 
     
247. 
     
248. }*/
     
249. 
     
250. 
     
251. 
     
252. 
     
253.   /*
     
254. #include<reg52.h>
     
255.                                                           
     
256. sbit a0=P1^0;
     
257. sbit a1=P1^1;           
     
258. sbit b0=P1^3;
     
259. sbit b1=P1^4;
     
260. 
     
261. 
     
262. 
     
263. 
     
264. 
     
265.                                                           
     
266. void Delay(unsigned int t)       
     
267.                                                          
     
268. 
     
269. void main()
     
270. {
     
271. en0=1;
     
272. en1=1;
     
273. while(1)
     
274. {
     
275. 
     
276. 
     
277. a0=0;
     
278. a1=1;
     
279. b0=1;
     
280. b1=1;
     
281. Delay(500);
     
282. 
     
283. 
     
284. 
     
285. a0=1;
     
286. a1=0;
     
287. b0=1;
     
288. b1=1;
     
289. Delay(500);
     
290. 
     
291. a0=1;
     
292. a1=1;
     
293. b0=0;
     
294. b1=1;
     
295. Delay(500);
     
296. 
     
297. a0=1;
     
298. a1=1;
     
299. b0=1;
     
300. b1=0;
     
301. Delay(500);
     
302. 
     
303. }
     
304. }
     
305. 
     
306. 
     
307. void Delay(unsigned int t)
     
308. {                           
     
309.         unsigned int k;
     
310. 
     
311.         while(t--)
     
312.         {
     
313.                 for(k=0; k<80; k++)
     
314.                 { }
     
315.         }
     
316. }
     
317. 
     
318. 
     
319. 
     
320. #include<reg52.h>
     
321. #define uint unsigned int
     
322. #define uchar unsigned char
     
323. 
     
324. sbit a0=P1^0;
     
325. sbit a1=P1^1;
     
326. sbit en0=P1^2;
     
327. 
     
328. //1
     
329. sbit b0=P1^3;
     
330. sbit b1=P1^4;
     
331. 
     
332. sbit en1=P1^5;
     
333. //2
     
334. 
     
335. 
     
336. void zheng(uchar k,uchar j);
     
337. void yanshi(uint z);
     
338. void xifen(uchar k1,uchar j1);
     
339. uchar b,num,n,num1,n1,h;
     
340. void main()
     
341. {
     
342. en0=1;
     
343. en1=1;
     
344. while(1)
     
345. {
     
346. 
     
347. xifen(10,100); //1/210mS100   果步  1.890
     
348. yanshi(400);
     
349. 
     
350. 
     
351. zheng(15,50);          //15mS  50 1.890
     
352. yanshi(400);
     
353. 
     
354. }
     
355. }
     
356. 
     
357. 
     
358. 
     
359. void zheng(uchar k,uchar j)
     
360. 
     
361. 
     
362. {
     
363. 
     
364. 
     
365. b=j/4;
     
366. b=b+1;
     
367. num=0;
     
368. 
     
369. for(b;b>0;b--)
     
370. 
     
371. {
     
372. 
     
373. 
     
374. if(num<j&n==0)//A-B+
     
375. 
     
376. {
     
377. 
     
378. 
     
379. a0=0;
     
380. a1=1;
     
381. b0=1;
     
382. b1=0;
     
383. 
     
384. yanshi(k);
     
385. num++;
     
386. 
     
387. n=1;
     
388. 
     
389. }
     
390. 
     
391. 
     
392. if(num<j&n==1) //A- B-
     
393. {
     
394. a0=0;
     
395. a1=1;
     
396. b0=0;
     
397. b1=1;
     
398. yanshi(k);
     
399. num++;
     
400. n=2;
     
401. 
     
402. }
     
403. 
     
404. if(num<j&n==2)//A+ B-
     
405. 
     
406. {
     
407. a0=1; a1=0; b0=0; b1=1;
     
408. yanshi(k);
     
409. num++;
     
410. n=3;
     
411. }
     
412. 
     
413. 
     
414. 
     
415. if(num<j&n==3)//A+ B+
     
416. 
     
417. {
     
418. a0=1;
     
419. a1=0;
     
420. b0=1;
     
421. b1=0;
     
422. yanshi(k);
     
423. num++;
     
424.          
     
425. n=0;
     
426. }
     
427. }
     
428. }
     
429. 
     
430. void xifen(uchar k1,uchar j1)
     
431. 
     
432. {
     
433. h=j1/8;
     
434. h=h+1;
     
435. num1=0;
     
436. for(h;h>0;h--)
     
437. {
     
438. if(num1<j1&n1==0)//A- B+
     
439. {
     
440. a0=0;
     
441. a1=1;
     
442. b0=1;
     
443. b1=0;
     
444. yanshi(k1);
     
445. num1++;
     
446. n1=1;
     
447. }
     
448. if(num1<j1&n1==1) //A-
     
449. {
     
450. a0=0;
     
451. a1=1;
     
452. b0=0;
     
453. b1=0;
     
454. yanshi(k1);
     
455. num1++;
     
456. n1=2;
     
457. }
     
458. if(num1<j1&n1==2) //A- B-
     
459. 
     
460. {
     
461. a0=0;
     
462. a1=1;
     
463. b0=0;
     
464. b1=1;
     
465. yanshi(k1);
     
466. num1++;
     
467. n1=3;
     
468. }
     
469. if(num1<j1&n1==3)// B-
     
470. {
     
471. a0=0;
     
472. a1=0;
     
473. b0=0;
     
474. b1=1;
     
475. yanshi(k1);
     
476. num1++;
     
477. n1=4;
     
478. }
     
479. if(num1<j1&n1==4) //A+B-
     
480. 
     
481. ……………………
     
482. 
     
483. …………限于本文篇幅 余下代碼請從51黑下載附件…………
     

復制代碼

所有資料51hei提供下載:
二相四線步進電機（可調(diào)速度）1.zip (1.04 MB, 下載次數(shù): 350)

2017-7-18 09:04 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

非常好的資料，先學習了

幾個月前從軟盤驅(qū)動器上拆下了個二相四線步進電機，用實驗板上的ULN2003試了近百次都沒成功，今天看到樓主的貼子再上網(wǎng)一查原來是ULN2003驅(qū)動不了二相四線步進電機，唉！早該想到是驅(qū)動芯片的問題。

非常好的資料

非常好的資料，先學習了

感謝分享。

謝謝分享 學習了

謝謝樓主分享，好人一生平安。

海洋漁業(yè) 發(fā)表于 2018-12-16 22:47
幾個月前從軟盤驅(qū)動器上拆下了個二相四線步進電機，用實驗板上的ULN2003試了近百次都沒成功，今天看到樓主 ...

看到你的分享，你用的事L293D吧，我用的298，怎么輕微的正反交互蠕動，我是單獨用的L298N,請指點下謝謝！

謝謝分享        

正在尋找的資料，謝謝分享

之前用其他模塊驅(qū)動步進電機，一直不成功，想著換這個模塊試試，正好找到樓主的資料，非常感謝。

非常好的資料，先學習了