使用

AFMotor電機擴展板的麥克納姆輪小車（視頻）

https://v.youku.com/v_show/id_XNTAzNDYyMzE1Mg==.html?spm=a2hzp.8253869.0.0

https://v.youku.com/v_show/id_XNTAzNDYyMzE1Mg==.html

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之九：測試M1M2M3M4電機前進與后退
   
8. */
   
9. 
   
10. #include <AFMotor.h>
    
11. 
    
12. // 創建對象
    
13. AF_DCMotor motor1(1);
    
14. AF_DCMotor motor2(2);
    
15. AF_DCMotor motor3(3);
    
16. AF_DCMotor motor4(4);
    
17. 
    
18. 
    
19. // 主程序開始
    
20. void setup() {
    
21. 
    
22. }
    
23. void loop() {
    
24.   motor1.setSpeed(200);
    
25.   motor1.run(FORWARD);
    
26.   motor2.setSpeed(200);
    
27.   motor2.run(FORWARD);
    
28.   motor3.setSpeed(200);
    
29.   motor3.run(FORWARD);
    
30.   motor4.setSpeed(200);
    
31.   motor4.run(FORWARD);
    
32.   delay(2000);
    
33.   
    
34.   motor1.setSpeed(0);
    
35.   motor1.run(RELEASE);
    
36.   motor2.setSpeed(0);
    
37.   motor2.run(RELEASE);
    
38.   motor3.setSpeed(0);
    
39.   motor3.run(RELEASE);
    
40.   motor4.setSpeed(0);
    
41.   motor4.run(RELEASE);
    
42.   delay(1000);
    
43.   
    
44.   motor1.setSpeed(200);
    
45.   motor1.run(BACKWARD);
    
46.   motor2.setSpeed(200);
    
47.   motor2.run(BACKWARD);
    
48.   motor3.setSpeed(200);
    
49.   motor3.run(BACKWARD);
    
50.   motor4.setSpeed(200);
    
51.   motor4.run(BACKWARD);
    
52.   delay(2000);
    
53.   
    
54.   motor1.setSpeed(0);
    
55.   motor1.run(RELEASE);
    
56.   motor2.setSpeed(0);
    
57.   motor2.run(RELEASE);
    
58.   motor3.setSpeed(0);
    
59.   motor3.run(RELEASE);
    
60.   motor4.setSpeed(0);
    
61.   motor4.run(RELEASE);
    
62.   delay(1000);
    
63. }

復制代碼

Arduino AFMotor電機擴展板（上）
https://www.bilibili.com/video/BV1vb411q7xz?p=1

Arduino AFMotor電機擴展板（下）
https://www.bilibili.com/video/BV1vb411q7xz?p=2

補充實驗

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：IDE—工具—管理庫—搜索“Servo”—安裝
   
7.   2、實驗之八：測試M1M2電機
   
8. */
   
9. 
   
10. #include <AFMotor.h>
    
11. 
    
12. AF_DCMotor motor1(1);
    
13. AF_DCMotor motor2(2);
    
14. 
    
15. void setup() {
    
16.   Serial.begin(9600);
    
17.   Serial.println("測試M1M2電機!");
    
18. 
    
19.   // turn on motor
    
20.   motor1.setSpeed(200);
    
21.   motor2.setSpeed(200);
    
22. 
    
23.   motor1.run(RELEASE);
    
24.   motor2.run(RELEASE);
    
25. }
    
26. 
    
27. void loop() {
    
28.   uint8_t i;
    
29. 
    
30.   Serial.println("正轉");
    
31. 
    
32.   motor1.run(FORWARD);
    
33.   motor2.run(FORWARD);
    
34.   for (i = 0; i < 255; i++) {
    
35.     motor1.setSpeed(i);
    
36.     motor2.setSpeed(i);
    
37.     delay(10);
    
38.   }
    
39. 
    
40.   for (i = 255; i != 0; i--) {
    
41.     motor1.setSpeed(i);
    
42.     motor2.setSpeed(i);
    
43.     delay(10);
    
44.   }
    
45. 
    
46.   Serial.println("反轉");
    
47. 
    
48.   motor1.run(BACKWARD);
    
49.   motor2.run(BACKWARD);
    
50. 
    
51.   for (i = 0; i < 255; i++) {
    
52.     motor1.setSpeed(i);
    
53.     motor2.setSpeed(i);
    
54.     delay(10);
    
55.   }
    
56. 
    
57.   for (i = 255; i != 0; i--) {
    
58.     motor1.setSpeed(i);
    
59.     motor2.setSpeed(i);
    
60.     delay(10);
    
61.   }
    
62. 
    
63.   Serial.println("斷電一秒");
    
64.   motor1.run(RELEASE);
    
65.   motor2.run(RELEASE);
    
66.   delay(1000);
    
67. }

復制代碼

附錄：AFMotor.cpp庫文件
目錄—adafruit/Adafruit-Motor-Shield-library
鏈接—https://github.com/adafruit/Adaf ... /master/AFMotor.cpp

1. // Adafruit Motor shield library
   
2. // copyright Adafruit Industries LLC, 2009
   
3. // this code is public domain, enjoy!
   
4. 
   
5. 
   
6. #if (ARDUINO >= 100)
   
7.   #include "Arduino.h"
   
8. #else
   
9.   #if defined(__AVR__)
   
10.     #include <avr/io.h>
    
11.   #endif
    
12.   #include "WProgram.h"
    
13. #endif
    
14. 
    
15. #include "AFMotor.h"
    
16. 
    
17. 
    
18. 
    
19. static uint8_t latch_state;
    
20. 
    
21. #if (MICROSTEPS == 8)
    
22. uint8_t microstepcurve[] = {0, 50, 98, 142, 180, 212, 236, 250, 255};
    
23. #elif (MICROSTEPS == 16)
    
24. uint8_t microstepcurve[] = {0, 25, 50, 74, 98, 120, 141, 162, 180, 197, 212, 225, 236, 244, 250, 253, 255};
    
25. #endif
    
26. 
    
27. AFMotorController::AFMotorController(void) {
    
28.     TimerInitalized = false;
    
29. }
    
30. 
    
31. void AFMotorController::enable(void) {
    
32.   // setup the latch
    
33.   /*
    
34.   LATCH_DDR |= _BV(LATCH);
    
35.   ENABLE_DDR |= _BV(ENABLE);
    
36.   CLK_DDR |= _BV(CLK);
    
37.   SER_DDR |= _BV(SER);
    
38.   */
    
39.   pinMode(MOTORLATCH, OUTPUT);
    
40.   pinMode(MOTORENABLE, OUTPUT);
    
41.   pinMode(MOTORDATA, OUTPUT);
    
42.   pinMode(MOTORCLK, OUTPUT);
    
43. 
    
44.   latch_state = 0;
    
45. 
    
46.   latch_tx();  // "reset"
    
47. 
    
48.   //ENABLE_PORT &= ~_BV(ENABLE); // enable the chip outputs!
    
49.   digitalWrite(MOTORENABLE, LOW);
    
50. }
    
51. 
    
52. 
    
53. void AFMotorController::latch_tx(void) {
    
54.   uint8_t i;
    
55. 
    
56.   //LATCH_PORT &= ~_BV(LATCH);
    
57.   digitalWrite(MOTORLATCH, LOW);
    
58. 
    
59.   //SER_PORT &= ~_BV(SER);
    
60.   digitalWrite(MOTORDATA, LOW);
    
61. 
    
62.   for (i=0; i<8; i++) {
    
63.     //CLK_PORT &= ~_BV(CLK);
    
64.     digitalWrite(MOTORCLK, LOW);
    
65. 
    
66.     if (latch_state & _BV(7-i)) {
    
67.       //SER_PORT |= _BV(SER);
    
68.       digitalWrite(MOTORDATA, HIGH);
    
69.     } else {
    
70.       //SER_PORT &= ~_BV(SER);
    
71.       digitalWrite(MOTORDATA, LOW);
    
72.     }
    
73.     //CLK_PORT |= _BV(CLK);
    
74.     digitalWrite(MOTORCLK, HIGH);
    
75.   }
    
76.   //LATCH_PORT |= _BV(LATCH);
    
77.   digitalWrite(MOTORLATCH, HIGH);
    
78. }
    
79. 
    
80. static AFMotorController MC;
    
81. 
    
82. /******************************************
    
83.                MOTORS
    
84. ******************************************/
    
85. inline void initPWM1(uint8_t freq) {
    
86. #if defined(__AVR_ATmega8__) || \
    
87.     defined(__AVR_ATmega48__) || \
    
88.     defined(__AVR_ATmega88__) || \
    
89.     defined(__AVR_ATmega168__) || \
    
90.     defined(__AVR_ATmega328P__)
    
91.     // use PWM from timer2A on PB3 (Arduino pin #11)
    
92.     TCCR2A |= _BV(COM2A1) | _BV(WGM20) | _BV(WGM21); // fast PWM, turn on oc2a
    
93.     TCCR2B = freq & 0x7;
    
94.     OCR2A = 0;
    
95. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    
96.     // on arduino mega, pin 11 is now PB5 (OC1A)
    
97.     TCCR1A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc1a
    
98.     TCCR1B = (freq & 0x7) | _BV(WGM12);
    
99.     OCR1A = 0;
    
100. #elif defined(__PIC32MX__)
     
101.     #if defined(PIC32_USE_PIN9_FOR_M1_PWM)
     
102.         // Make sure that pin 11 is an input, since we have tied together 9 and 11
     
103.         pinMode(9, OUTPUT);
     
104.         pinMode(11, INPUT);
     
105.         if (!MC.TimerInitalized)
     
106.         {   // Set up Timer2 for 80MHz counting fro 0 to 256
     
107.             T2CON = 0x8000 | ((freq & 0x07) << 4); // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=<freq>, T32=0, TCS=0; // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=0, T32=0, TCS=0
     
108.             TMR2 = 0x0000;
     
109.             PR2 = 0x0100;
     
110.             MC.TimerInitalized = true;
     
111.         }
     
112.          // Setup OC4 (pin 9) in PWM mode, with Timer2 as timebase
     
113.         OC4CON = 0x8006;    // OC32 = 0, OCTSEL=0, OCM=6
     
114.         OC4RS = 0x0000;
     
115.         OC4R = 0x0000;
     
116.     #elif defined(PIC32_USE_PIN10_FOR_M1_PWM)
     
117.         // Make sure that pin 11 is an input, since we have tied together 9 and 11
     
118.         pinMode(10, OUTPUT);
     
119.         pinMode(11, INPUT);
     
120.         if (!MC.TimerInitalized)
     
121.         {   // Set up Timer2 for 80MHz counting fro 0 to 256
     
122.             T2CON = 0x8000 | ((freq & 0x07) << 4); // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=<freq>, T32=0, TCS=0; // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=0, T32=0, TCS=0
     
123.             TMR2 = 0x0000;
     
124.             PR2 = 0x0100;
     
125.             MC.TimerInitalized = true;
     
126.         }
     
127.          // Setup OC5 (pin 10) in PWM mode, with Timer2 as timebase
     
128.         OC5CON = 0x8006;    // OC32 = 0, OCTSEL=0, OCM=6
     
129.         OC5RS = 0x0000;
     
130.         OC5R = 0x0000;
     
131.     #else
     
132.         // If we are not using PWM for pin 11, then just do digital
     
133.         digitalWrite(11, LOW);
     
134.     #endif
     
135. #else
     
136.    #error "This chip is not supported!"
     
137. #endif
     
138.     #if !defined(PIC32_USE_PIN9_FOR_M1_PWM) && !defined(PIC32_USE_PIN10_FOR_M1_PWM)
     
139.         pinMode(11, OUTPUT);
     
140.     #endif
     
141. }
     
142. 
     
143. inline void setPWM1(uint8_t s) {
     
144. #if defined(__AVR_ATmega8__) || \
     
145.     defined(__AVR_ATmega48__) || \
     
146.     defined(__AVR_ATmega88__) || \
     
147.     defined(__AVR_ATmega168__) || \
     
148.     defined(__AVR_ATmega328P__)
     
149.     // use PWM from timer2A on PB3 (Arduino pin #11)
     
150.     OCR2A = s;
     
151. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
152.     // on arduino mega, pin 11 is now PB5 (OC1A)
     
153.     OCR1A = s;
     
154. #elif defined(__PIC32MX__)
     
155.     #if defined(PIC32_USE_PIN9_FOR_M1_PWM)
     
156.         // Set the OC4 (pin 9) PMW duty cycle from 0 to 255
     
157.         OC4RS = s;
     
158.     #elif defined(PIC32_USE_PIN10_FOR_M1_PWM)
     
159.         // Set the OC5 (pin 10) PMW duty cycle from 0 to 255
     
160.         OC5RS = s;
     
161.     #else
     
162.         // If we are not doing PWM output for M1, then just use on/off
     
163.         if (s > 127)
     
164.         {
     
165.             digitalWrite(11, HIGH);
     
166.         }
     
167.         else
     
168.         {
     
169.             digitalWrite(11, LOW);
     
170.         }
     
171.     #endif
     
172. #else
     
173.    #error "This chip is not supported!"
     
174. #endif
     
175. }
     
176. 
     
177. inline void initPWM2(uint8_t freq) {
     
178. #if defined(__AVR_ATmega8__) || \
     
179.     defined(__AVR_ATmega48__) || \
     
180.     defined(__AVR_ATmega88__) || \
     
181.     defined(__AVR_ATmega168__) || \
     
182.     defined(__AVR_ATmega328P__)
     
183.     // use PWM from timer2B (pin 3)
     
184.     TCCR2A |= _BV(COM2B1) | _BV(WGM20) | _BV(WGM21); // fast PWM, turn on oc2b
     
185.     TCCR2B = freq & 0x7;
     
186.     OCR2B = 0;
     
187. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
188.     // on arduino mega, pin 3 is now PE5 (OC3C)
     
189.     TCCR3A |= _BV(COM1C1) | _BV(WGM10); // fast PWM, turn on oc3c
     
190.     TCCR3B = (freq & 0x7) | _BV(WGM12);
     
191.     OCR3C = 0;
     
192. #elif defined(__PIC32MX__)
     
193.     if (!MC.TimerInitalized)
     
194.     {   // Set up Timer2 for 80MHz counting fro 0 to 256
     
195.         T2CON = 0x8000 | ((freq & 0x07) << 4); // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=<freq>, T32=0, TCS=0; // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=0, T32=0, TCS=0
     
196.         TMR2 = 0x0000;
     
197.         PR2 = 0x0100;
     
198.         MC.TimerInitalized = true;
     
199.     }
     
200.     // Setup OC1 (pin3) in PWM mode, with Timer2 as timebase
     
201.     OC1CON = 0x8006;    // OC32 = 0, OCTSEL=0, OCM=6
     
202.     OC1RS = 0x0000;
     
203.     OC1R = 0x0000;
     
204. #else
     
205.    #error "This chip is not supported!"
     
206. #endif
     
207. 
     
208.     pinMode(3, OUTPUT);
     
209. }
     
210. 
     
211. inline void setPWM2(uint8_t s) {
     
212. #if defined(__AVR_ATmega8__) || \
     
213.     defined(__AVR_ATmega48__) || \
     
214.     defined(__AVR_ATmega88__) || \
     
215.     defined(__AVR_ATmega168__) || \
     
216.     defined(__AVR_ATmega328P__)
     
217.     // use PWM from timer2A on PB3 (Arduino pin #11)
     
218.     OCR2B = s;
     
219. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
220.     // on arduino mega, pin 11 is now PB5 (OC1A)
     
221.     OCR3C = s;
     
222. #elif defined(__PIC32MX__)
     
223.     // Set the OC1 (pin3) PMW duty cycle from 0 to 255
     
224.     OC1RS = s;
     
225. #else
     
226.    #error "This chip is not supported!"
     
227. #endif
     
228. }
     
229. 
     
230. inline void initPWM3(uint8_t freq) {
     
231. #if defined(__AVR_ATmega8__) || \
     
232.     defined(__AVR_ATmega48__) || \
     
233.     defined(__AVR_ATmega88__) || \
     
234.     defined(__AVR_ATmega168__) || \
     
235.     defined(__AVR_ATmega328P__)
     
236.     // use PWM from timer0A / PD6 (pin 6)
     
237.     TCCR0A |= _BV(COM0A1) | _BV(WGM00) | _BV(WGM01); // fast PWM, turn on OC0A
     
238.     //TCCR0B = freq & 0x7;
     
239.     OCR0A = 0;
     
240. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
241.     // on arduino mega, pin 6 is now PH3 (OC4A)
     
242.     TCCR4A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc4a
     
243.     TCCR4B = (freq & 0x7) | _BV(WGM12);
     
244.     //TCCR4B = 1 | _BV(WGM12);
     
245.     OCR4A = 0;
     
246. #elif defined(__PIC32MX__)
     
247.     if (!MC.TimerInitalized)
     
248.     {   // Set up Timer2 for 80MHz counting fro 0 to 256
     
249.         T2CON = 0x8000 | ((freq & 0x07) << 4); // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=<freq>, T32=0, TCS=0; // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=0, T32=0, TCS=0
     
250.         TMR2 = 0x0000;
     
251.         PR2 = 0x0100;
     
252.         MC.TimerInitalized = true;
     
253.     }
     
254.     // Setup OC3 (pin 6) in PWM mode, with Timer2 as timebase
     
255.     OC3CON = 0x8006;    // OC32 = 0, OCTSEL=0, OCM=6
     
256.     OC3RS = 0x0000;
     
257.     OC3R = 0x0000;
     
258. #else
     
259.    #error "This chip is not supported!"
     
260. #endif
     
261.     pinMode(6, OUTPUT);
     
262. }
     
263. 
     
264. inline void setPWM3(uint8_t s) {
     
265. #if defined(__AVR_ATmega8__) || \
     
266.     defined(__AVR_ATmega48__) || \
     
267.     defined(__AVR_ATmega88__) || \
     
268.     defined(__AVR_ATmega168__) || \
     
269.     defined(__AVR_ATmega328P__)
     
270.     // use PWM from timer0A on PB3 (Arduino pin #6)
     
271.     OCR0A = s;
     
272. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
273.     // on arduino mega, pin 6 is now PH3 (OC4A)
     
274.     OCR4A = s;
     
275. #elif defined(__PIC32MX__)
     
276.     // Set the OC3 (pin 6) PMW duty cycle from 0 to 255
     
277.     OC3RS = s;
     
278. #else
     
279.    #error "This chip is not supported!"
     
280. #endif
     
281. }
     
282. 
     
283. 
     
284. 
     
285. inline void initPWM4(uint8_t freq) {
     
286. #if defined(__AVR_ATmega8__) || \
     
287.     defined(__AVR_ATmega48__) || \
     
288.     defined(__AVR_ATmega88__) || \
     
289.     defined(__AVR_ATmega168__) || \
     
290.     defined(__AVR_ATmega328P__)
     
291.     // use PWM from timer0B / PD5 (pin 5)
     
292.     TCCR0A |= _BV(COM0B1) | _BV(WGM00) | _BV(WGM01); // fast PWM, turn on oc0a
     
293.     //TCCR0B = freq & 0x7;
     
294.     OCR0B = 0;
     
295. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
296.     // on arduino mega, pin 5 is now PE3 (OC3A)
     
297.     TCCR3A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc3a
     
298.     TCCR3B = (freq & 0x7) | _BV(WGM12);
     
299.     //TCCR4B = 1 | _BV(WGM12);
     
300.     OCR3A = 0;
     
301. #elif defined(__PIC32MX__)
     
302.     if (!MC.TimerInitalized)
     
303.     {   // Set up Timer2 for 80MHz counting fro 0 to 256
     
304.         T2CON = 0x8000 | ((freq & 0x07) << 4); // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=<freq>, T32=0, TCS=0; // ON=1, FRZ=0, SIDL=0, TGATE=0, TCKPS=0, T32=0, TCS=0
     
305.         TMR2 = 0x0000;
     
306.         PR2 = 0x0100;
     
307.         MC.TimerInitalized = true;
     
308.     }
     
309.     // Setup OC2 (pin 5) in PWM mode, with Timer2 as timebase
     
310.     OC2CON = 0x8006;    // OC32 = 0, OCTSEL=0, OCM=6
     
311.     OC2RS = 0x0000;
     
312.     OC2R = 0x0000;
     
313. #else
     
314.    #error "This chip is not supported!"
     
315. #endif
     
316.     pinMode(5, OUTPUT);
     
317. }
     
318. 
     
319. inline void setPWM4(uint8_t s) {
     
320. #if defined(__AVR_ATmega8__) || \
     
321.     defined(__AVR_ATmega48__) || \
     
322.     defined(__AVR_ATmega88__) || \
     
323.     defined(__AVR_ATmega168__) || \
     
324.     defined(__AVR_ATmega328P__)
     
325.     // use PWM from timer0A on PB3 (Arduino pin #6)
     
326.     OCR0B = s;
     
327. #elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
     
328.     // on arduino mega, pin 6 is now PH3 (OC4A)
     
329.     OCR3A = s;
     
330. #elif defined(__PIC32MX__)
     
331.     // Set the OC2 (pin 5) PMW duty cycle from 0 to 255
     
332.     OC2RS = s;
     
333. #else
     
334.    #error "This chip is not supported!"
     
335. #endif
     
336. }
     
337. 
     
338. AF_DCMotor::AF_DCMotor(uint8_t num, uint8_t freq) {
     
339.   motornum = num;
     
340.   pwmfreq = freq;
     
341. 
     
342.   MC.enable();
     
343. 
     
344.   switch (num) {
     
345.   case 1:
     
346.     latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B); // set both motor pins to 0
     
347.     MC.latch_tx();
     
348.     initPWM1(freq);
     
349.     break;
     
350.   case 2:
     
351.     latch_state &= ~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // set both motor pins to 0
     
352.     MC.latch_tx();
     
353.     initPWM2(freq);
     
354.     break;
     
355.   case 3:
     
356.     latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B); // set both motor pins to 0
     
357.     MC.latch_tx();
     
358.     initPWM3(freq);
     
359.     break;
     
360.   case 4:
     
361.     latch_state &= ~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // set both motor pins to 0
     
362.     MC.latch_tx();
     
363.     initPWM4(freq);
     
364.     break;
     
365.   }
     
366. }
     
367. 
     
368. void AF_DCMotor::run(uint8_t cmd) {
     
369.   uint8_t a, b;
     
370.   switch (motornum) {
     
371.   case 1:
     
372.     a = MOTOR1_A; b = MOTOR1_B; break;
     
373.   case 2:
     
374.     a = MOTOR2_A; b = MOTOR2_B; break;
     
375.   case 3:
     
376.     a = MOTOR3_A; b = MOTOR3_B; break;
     
377.   case 4:
     
378.     a = MOTOR4_A; b = MOTOR4_B; break;
     
379.   default:
     
380.     return;
     
381.   }
     
382.   
     
383.   switch (cmd) {
     
384.   case FORWARD:
     
385.     latch_state |= _BV(a);
     
386.     latch_state &= ~_BV(b);
     
387.     MC.latch_tx();
     
388.     break;
     
389.   case BACKWARD:
     
390.     latch_state &= ~_BV(a);
     
391.     latch_state |= _BV(b);
     
392.     MC.latch_tx();
     
393.     break;
     
394.   case RELEASE:
     
395.     latch_state &= ~_BV(a);     // A and B both low
     
396.     latch_state &= ~_BV(b);
     
397.     MC.latch_tx();
     
398.     break;
     
399.   }
     
400. }
     
401. 
     
402. void AF_DCMotor::setSpeed(uint8_t speed) {
     
403.   switch (motornum) {
     
404.   case 1:
     
405.     setPWM1(speed); break;
     
406.   case 2:
     
407.     setPWM2(speed); break;
     
408.   case 3:
     
409.     setPWM3(speed); break;
     
410.   case 4:
     
411.     setPWM4(speed); break;
     
412.   }
     
413. }
     
414. 
     
415. /******************************************
     
416.                STEPPERS
     
417. ******************************************/
     
418. 
     
419. AF_Stepper::AF_Stepper(uint16_t steps, uint8_t num) {
     
420.   MC.enable();
     
421. 
     
422.   revsteps = steps;
     
423.   steppernum = num;
     
424.   currentstep = 0;
     
425. 
     
426.   if (steppernum == 1) {
     
427.     latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B) &
     
428.       ~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // all motor pins to 0
     
429.     MC.latch_tx();
     
430.    
     
431.     // enable both H bridges
     
432.     pinMode(11, OUTPUT);
     
433.     pinMode(3, OUTPUT);
     
434.     digitalWrite(11, HIGH);
     
435.     digitalWrite(3, HIGH);
     
436. 
     
437.     // use PWM for microstepping support
     
438.     initPWM1(STEPPER1_PWM_RATE);
     
439.     initPWM2(STEPPER1_PWM_RATE);
     
440.     setPWM1(255);
     
441.     setPWM2(255);
     
442. 
     
443.   } else if (steppernum == 2) {
     
444.     latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B) &
     
445.       ~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // all motor pins to 0
     
446.     MC.latch_tx();
     
447. 
     
448.     // enable both H bridges
     
449.     pinMode(5, OUTPUT);
     
450.     pinMode(6, OUTPUT);
     
451.     digitalWrite(5, HIGH);
     
452.     digitalWrite(6, HIGH);
     
453. 
     
454.     // use PWM for microstepping support
     
455.     // use PWM for microstepping support
     
456.     initPWM3(STEPPER2_PWM_RATE);
     
457.     initPWM4(STEPPER2_PWM_RATE);
     
458.     setPWM3(255);
     
459.     setPWM4(255);
     
460.   }
     
461. }
     
462. 
     
463. void AF_Stepper::setSpeed(uint16_t rpm) {
     
464.   usperstep = 60000000 / ((uint32_t)revsteps * (uint32_t)rpm);
     
465.   steppingcounter = 0;
     
466. }
     
467. 
     
468. void AF_Stepper::release(void) {
     
469.   if (steppernum == 1) {
     
470.     latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B) &
     
471.       ~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // all motor pins to 0
     
472.     MC.latch_tx();
     
473.   } else if (steppernum == 2) {
     
474.     latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B) &
     
475.       ~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // all motor pins to 0
     
476.     MC.latch_tx();
     
477.   }
     
478. }
     
479. 
     
480. void AF_Stepper::step(uint16_t steps, uint8_t dir,  uint8_t style) {
     
481.   uint32_t uspers = usperstep;
     
482.   uint8_t ret = 0;
     
483. 
     
484.   if (style == INTERLEAVE) {
     
485.     uspers /= 2;
     
486.   }
     
487. else if (style == MICROSTEP) {
     
488.     uspers /= MICROSTEPS;
     
489.     steps *= MICROSTEPS;
     
490. #ifdef MOTORDEBUG
     
491.     Serial.print("steps = "); Serial.println(steps, DEC);
     
492. #endif
     
493.   }
     
494. 
     
495.   while (steps--) {
     
496.     ret = onestep(dir, style);
     
497.     delay(uspers/1000); // in ms
     
498.     steppingcounter += (uspers % 1000);
     
499.     if (steppingcounter >= 1000) {
     
500.       delay(1);
     
501.       steppingcounter -= 1000;
     
502.     }
     
503.   }
     
504.   if (style == MICROSTEP) {
     
505.     while ((ret != 0) && (ret != MICROSTEPS)) {
     
506.       ret = onestep(dir, style);
     
507.       delay(uspers/1000); // in ms
     
508.       steppingcounter += (uspers % 1000);
     
509.       if (steppingcounter >= 1000) {
     
510.         delay(1);
     
511.         steppingcounter -= 1000;
     
512.       }
     
513.     }
     
514.   }
     
515. }
     
516. 
     
517. uint8_t AF_Stepper::onestep(uint8_t dir, uint8_t style) {
     
518.   uint8_t a, b, c, d;
     
519.   uint8_t ocrb, ocra;
     
520. 
     
521.   ocra = ocrb = 255;
     
522. 
     
523.   if (steppernum == 1) {
     
524.     a = _BV(MOTOR1_A);
     
525.     b = _BV(MOTOR2_A);
     
526.     c = _BV(MOTOR1_B);
     
527.     d = _BV(MOTOR2_B);
     
528.   } else if (steppernum == 2) {
     
529.     a = _BV(MOTOR3_A);
     
530.     b = _BV(MOTOR4_A);
     
531.     c = _BV(MOTOR3_B);
     
532.     d = _BV(MOTOR4_B);
     
533.   } else {
     
534.     return 0;
     
535.   }
     
536. 
     
537.   // next determine what sort of stepping procedure we're up to
     
538.   if (style == SINGLE) {
     
539.     if ((currentstep/(MICROSTEPS/2)) % 2) { // we're at an odd step, weird
     
540.       if (dir == FORWARD) {
     
541.         currentstep += MICROSTEPS/2;
     
542.       }
     
543.       else {
     
544.         currentstep -= MICROSTEPS/2;
     
545.       }
     
546.     } else {           // go to the next even step
     
547.       if (dir == FORWARD) {
     
548.         currentstep += MICROSTEPS;
     
549.       }
     
550.       else {
     
551.         currentstep -= MICROSTEPS;
     
552.       }
     
553.     }
     
554.   } else if (style == DOUBLE) {
     
555.     if (! (currentstep/(MICROSTEPS/2) % 2)) { // we're at an even step, weird
     
556.       if (dir == FORWARD) {
     
557.         currentstep += MICROSTEPS/2;
     
558.       } else {
     
559.         currentstep -= MICROSTEPS/2;
     
560.       }
     
561.     } else {           // go to the next odd step
     
562.       if (dir == FORWARD) {
     
563.         currentstep += MICROSTEPS;
     
564.       } else {
     
565.         currentstep -= MICROSTEPS;
     
566.       }
     
567.     }
     
568.   } else if (style == INTERLEAVE) {
     
569.     if (dir == FORWARD) {
     
570.        currentstep += MICROSTEPS/2;
     
571.     } else {
     
572.        currentstep -= MICROSTEPS/2;
     
573.     }
     
574.   }
     
575. 
     
576.   if (style == MICROSTEP) {
     
577.     if (dir == FORWARD) {
     
578.       currentstep++;
     
579.     } else {
     
580.       // BACKWARDS
     
581.       currentstep--;
     
582.     }
     
583. 
     
584.     currentstep += MICROSTEPS*4;
     
585.     currentstep %= MICROSTEPS*4;
     
586. 
     
587.     ocra = ocrb = 0;
     
588.     if ( (currentstep >= 0) && (currentstep < MICROSTEPS)) {
     
589.       ocra = microstepcurve[MICROSTEPS - currentstep];
     
590.       ocrb = microstepcurve[currentstep];
     
591.     } else if  ( (currentstep >= MICROSTEPS) && (currentstep < MICROSTEPS*2)) {
     
592.       ocra = microstepcurve[currentstep - MICROSTEPS];
     
593.       ocrb = microstepcurve[MICROSTEPS*2 - currentstep];
     
594.     } else if  ( (currentstep >= MICROSTEPS*2) && (currentstep < MICROSTEPS*3)) {
     
595.       ocra = microstepcurve[MICROSTEPS*3 - currentstep];
     
596.       ocrb = microstepcurve[currentstep - MICROSTEPS*2];
     
597.     } else if  ( (currentstep >= MICROSTEPS*3) && (currentstep < MICROSTEPS*4)) {
     
598.       ocra = microstepcurve[currentstep - MICROSTEPS*3];
     
599.       ocrb = microstepcurve[MICROSTEPS*4 - currentstep];
     
600.     }
     
601.   }
     
602. 
     
603.   currentstep += MICROSTEPS*4;
     
604.   currentstep %= MICROSTEPS*4;
     
605. 
     
606. #ifdef MOTORDEBUG
     
607.   Serial.print("current step: "); Serial.println(currentstep, DEC);
     
608.   Serial.print(" pwmA = "); Serial.print(ocra, DEC);
     
609.   Serial.print(" pwmB = "); Serial.println(ocrb, DEC);
     
610. #endif
     
611. 
     
612.   if (steppernum == 1) {
     
613.     setPWM1(ocra);
     
614.     setPWM2(ocrb);
     
615.   } else if (steppernum == 2) {
     
616.     setPWM3(ocra);
     
617.     setPWM4(ocrb);
     
618.   }
     
619. 
     
620. 
     
621.   // release all
     
622.   latch_state &= ~a & ~b & ~c & ~d; // all motor pins to 0
     
623. 
     
624.   //Serial.println(step, DEC);
     
625.   if (style == MICROSTEP) {
     
626.     if ((currentstep >= 0) && (currentstep < MICROSTEPS))
     
627.       latch_state |= a | b;
     
628.     if ((currentstep >= MICROSTEPS) && (currentstep < MICROSTEPS*2))
     
629.       latch_state |= b | c;
     
630.     if ((currentstep >= MICROSTEPS*2) && (currentstep < MICROSTEPS*3))
     
631.       latch_state |= c | d;
     
632.     if ((currentstep >= MICROSTEPS*3) && (currentstep < MICROSTEPS*4))
     
633.       latch_state |= d | a;
     
634.   } else {
     
635.     switch (currentstep/(MICROSTEPS/2)) {
     
636.     case 0:
     
637.       latch_state |= a; // energize coil 1 only
     
638.       break;
     
639.     case 1:
     
640.       latch_state |= a | b; // energize coil 1+2
     
641.       break;
     
642.     case 2:
     
643.       latch_state |= b; // energize coil 2 only
     
644.       break;
     
645.     case 3:
     
646.       latch_state |= b | c; // energize coil 2+3
     
647.       break;
     
648.     case 4:
     
649.       latch_state |= c; // energize coil 3 only
     
650.       break;
     
651.     case 5:
     
652.       latch_state |= c | d; // energize coil 3+4
     
653.       break;
     
654.     case 6:
     
655.       latch_state |= d; // energize coil 4 only
     
656.       break;
     
657.     case 7:
     
658.       latch_state |= d | a; // energize coil 1+4
     
659.       break;
     
660.     }
     
661.   }
     
662. 
     
663. 
     
664.   MC.latch_tx();
     
665.   return currentstep;
     
666. }

復制代碼

附錄：AFMotor.h庫文件
目錄—adafruit/Adafruit-Motor-Shield-library
鏈接—https://github.com/adafruit/Adaf ... ob/master/AFMotor.h

1. // Adafruit Motor shield library
   
2. // copyright Adafruit Industries LLC, 2009
   
3. // this code is public domain, enjoy!
   
4. 
   
5. /*
   
6. * Usage Notes:
   
7. * For PIC32, all features work properly with the following two exceptions:
   
8. *
   
9. * 1) Because the PIC32 only has 5 PWM outputs, and the AFMotor shield needs 6
   
10. *    to completely operate (four for motor outputs and two for RC servos), the
    
11. *    M1 motor output will not have PWM ability when used with a PIC32 board.
    
12. *    However, there is a very simple workaround. If you need to drive a stepper
    
13. *    or DC motor with PWM on motor output M1, you can use the PWM output on pin
    
14. *    9 or pin 10 (normally use for RC servo outputs on Arduino, not needed for
    
15. *    RC servo outputs on PIC32) to drive the PWM input for M1 by simply putting
    
16. *    a jumber from pin 9 to pin 11 or pin 10 to pin 11. Then uncomment one of the
    
17. *    two #defines below to activate the PWM on either pin 9 or pin 10. You will
    
18. *    then have a fully functional microstepping for 2 stepper motors, or four
    
19. *    DC motor outputs with PWM.
    
20. *
    
21. * 2) There is a conflict between RC Servo outputs on pins 9 and pins 10 and
    
22. *    the operation of DC motors and stepper motors as of 9/2012. This issue
    
23. *    will get fixed in future MPIDE releases, but at the present time it means
    
24. *    that the Motor Party example will NOT work properly. Any time you attach
    
25. *    an RC servo to pins 9 or pins 10, ALL PWM outputs on the whole board will
    
26. *    stop working. Thus no steppers or DC motors.
    
27. *
    
28. */
    
29. // <BPS> 09/15/2012 Modified for use with chipKIT boards
    
30. 
    
31. 
    
32. #ifndef _AFMotor_h_
    
33. #define _AFMotor_h_
    
34. 
    
35. #include <inttypes.h>
    
36. #if defined(__AVR__)
    
37.     #include <avr/io.h>
    
38. 
    
39.     //#define MOTORDEBUG 1
    
40. 
    
41.     #define MICROSTEPS 16                       // 8 or 16
    
42. 
    
43.     #define MOTOR12_64KHZ _BV(CS20)             // no prescale
    
44.     #define MOTOR12_8KHZ _BV(CS21)              // divide by 8
    
45.     #define MOTOR12_2KHZ _BV(CS21) | _BV(CS20)  // divide by 32
    
46.     #define MOTOR12_1KHZ _BV(CS22)              // divide by 64
    
47. 
    
48.     #define MOTOR34_64KHZ _BV(CS00)             // no prescale
    
49.     #define MOTOR34_8KHZ _BV(CS01)              // divide by 8
    
50.     #define MOTOR34_1KHZ _BV(CS01) | _BV(CS00)  // divide by 64
    
51.    
    
52.     #define DC_MOTOR_PWM_RATE   MOTOR34_8KHZ    // PWM rate for DC motors
    
53.     #define STEPPER1_PWM_RATE   MOTOR12_64KHZ   // PWM rate for stepper 1
    
54.     #define STEPPER2_PWM_RATE   MOTOR34_64KHZ   // PWM rate for stepper 2
    
55.    
    
56. #elif defined(__PIC32MX__)
    
57.     //#define MOTORDEBUG 1
    
58.    
    
59.     // Uncomment the one of following lines if you have put a jumper from
    
60.     // either pin 9 to pin 11 or pin 10 to pin 11 on your Motor Shield.
    
61.     // Either will enable PWM for M1
    
62.     //#define PIC32_USE_PIN9_FOR_M1_PWM
    
63.     //#define PIC32_USE_PIN10_FOR_M1_PWM
    
64. 
    
65.     #define MICROSTEPS 16       // 8 or 16
    
66. 
    
67.     // For PIC32 Timers, define prescale settings by PWM frequency
    
68.     #define MOTOR12_312KHZ  0   // 1:1, actual frequency 312KHz
    
69.     #define MOTOR12_156KHZ  1   // 1:2, actual frequency 156KHz
    
70.     #define MOTOR12_64KHZ   2   // 1:4, actual frequency 78KHz
    
71.     #define MOTOR12_39KHZ   3   // 1:8, acutal frequency 39KHz
    
72.     #define MOTOR12_19KHZ   4   // 1:16, actual frequency 19KHz
    
73.     #define MOTOR12_8KHZ    5   // 1:32, actual frequency 9.7KHz
    
74.     #define MOTOR12_4_8KHZ  6   // 1:64, actual frequency 4.8KHz
    
75.     #define MOTOR12_2KHZ    7   // 1:256, actual frequency 1.2KHz
    
76.     #define MOTOR12_1KHZ    7   // 1:256, actual frequency 1.2KHz
    
77. 
    
78.     #define MOTOR34_312KHZ  0   // 1:1, actual frequency 312KHz
    
79.     #define MOTOR34_156KHZ  1   // 1:2, actual frequency 156KHz
    
80.     #define MOTOR34_64KHZ   2   // 1:4, actual frequency 78KHz
    
81.     #define MOTOR34_39KHZ   3   // 1:8, acutal frequency 39KHz
    
82.     #define MOTOR34_19KHZ   4   // 1:16, actual frequency 19KHz
    
83.     #define MOTOR34_8KHZ    5   // 1:32, actual frequency 9.7KHz
    
84.     #define MOTOR34_4_8KHZ  6   // 1:64, actual frequency 4.8KHz
    
85.     #define MOTOR34_2KHZ    7   // 1:256, actual frequency 1.2KHz
    
86.     #define MOTOR34_1KHZ    7   // 1:256, actual frequency 1.2KHz
    
87.    
    
88.     // PWM rate for DC motors.
    
89.     #define DC_MOTOR_PWM_RATE   MOTOR34_39KHZ
    
90.     // Note: for PIC32, both of these must be set to the same value
    
91.     // since there's only one timebase for all 4 PWM outputs
    
92.     #define STEPPER1_PWM_RATE   MOTOR12_39KHZ
    
93.     #define STEPPER2_PWM_RATE   MOTOR34_39KHZ
    
94.    
    
95. #endif
    
96. 
    
97. // Bit positions in the 74HCT595 shift register output
    
98. #define MOTOR1_A 2
    
99. #define MOTOR1_B 3
    
100. #define MOTOR2_A 1
     
101. #define MOTOR2_B 4
     
102. #define MOTOR4_A 0
     
103. #define MOTOR4_B 6
     
104. #define MOTOR3_A 5
     
105. #define MOTOR3_B 7
     
106. 
     
107. // Constants that the user passes in to the motor calls
     
108. #define FORWARD 1
     
109. #define BACKWARD 2
     
110. #define BRAKE 3
     
111. #define RELEASE 4
     
112. 
     
113. // Constants that the user passes in to the stepper calls
     
114. #define SINGLE 1
     
115. #define DOUBLE 2
     
116. #define INTERLEAVE 3
     
117. #define MICROSTEP 4
     
118. 
     
119. /*
     
120. #define LATCH 4
     
121. #define LATCH_DDR DDRB
     
122. #define LATCH_PORT PORTB
     
123. #define CLK_PORT PORTD
     
124. #define CLK_DDR DDRD
     
125. #define CLK 4
     
126. #define ENABLE_PORT PORTD
     
127. #define ENABLE_DDR DDRD
     
128. #define ENABLE 7
     
129. #define SER 0
     
130. #define SER_DDR DDRB
     
131. #define SER_PORT PORTB
     
132. */
     
133. 
     
134. // Arduino pin names for interface to 74HCT595 latch
     
135. #define MOTORLATCH 12
     
136. #define MOTORCLK 4
     
137. #define MOTORENABLE 7
     
138. #define MOTORDATA 8
     
139. 
     
140. class AFMotorController
     
141. {
     
142.   public:
     
143.     AFMotorController(void);
     
144.     void enable(void);
     
145.     friend class AF_DCMotor;
     
146.     void latch_tx(void);
     
147.     uint8_t TimerInitalized;
     
148. };
     
149. 
     
150. class AF_DCMotor
     
151. {
     
152. public:
     
153.   AF_DCMotor(uint8_t motornum, uint8_t freq = DC_MOTOR_PWM_RATE);
     
154.   void run(uint8_t);
     
155.   void setSpeed(uint8_t);
     
156. 
     
157. private:
     
158.   uint8_t motornum, pwmfreq;
     
159. };
     
160. 
     
161. class AF_Stepper {
     
162. public:
     
163.   AF_Stepper(uint16_t, uint8_t);
     
164.   void step(uint16_t steps, uint8_t dir,  uint8_t style = SINGLE);
     
165.   void setSpeed(uint16_t);
     
166.   uint8_t onestep(uint8_t dir, uint8_t style);
     
167.   void release(void);
     
168.   uint16_t revsteps; // # steps per revolution
     
169.   uint8_t steppernum;
     
170.   uint32_t usperstep, steppingcounter;
     
171. private:
     
172.   uint8_t currentstep;
     
173. 
     
174. };
     
175. 
     
176. uint8_t getlatchstate(void);
     
177. 
     
178. #endif

復制代碼

使用Arduino AFMotor驅動四只直流電機

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之七：使用Arduino AFMotor驅動四只直流電機
   
8. */
   
9. 
   
10. #include <AFMotor.h> // 本程序中使用AFMotor庫
    
11. 
    
12. AF_DCMotor motor1(1); // 這4條語句的作用是建立4個直流電機對象，它們的名稱分別是：motor1/2/3/4.
    
13. AF_DCMotor motor2(2); // 這四條語句括號中的數字代表各個電機對象所連接在AFMotor擴展板的電機端口號碼。
    
14. AF_DCMotor motor3(3); // AF_DCMotor motor1(1); 代表motor1對象連接在AFMotor擴展板的M1端口上。
    
15. AF_DCMotor motor4(4); // AFMotor電機擴展板最多可以驅動4個直流電機，最少可以驅動1個直流電機。
    
16. 
    
17. void setup() {
    
18.   motor1.setSpeed(200); // 這4條語句的作用是通過setSpped庫函數設置電機運行速度。
    
19.   motor2.setSpeed(200); // setSpped庫函數中的參數是運行速度參數。
    
20.   motor3.setSpeed(200); // 運行速度參數允許范圍是0～255。
    
21.   motor4.setSpeed(200); // 速度參數越大，運轉速度越快。參數為0時電機停止轉動。
    
22. 
    
23.   motor1.run(RELEASE); // 這4條語句的作用是讓4個電機在啟動時停止轉動
    
24.   motor2.run(RELEASE); // run庫函數允許使用的關鍵字參數有RELEASE、FORWARD、BACKWARD
    
25.   motor3.run(RELEASE); // 使用關鍵字RELEASE作為參數使用時，run庫函數將會讓擴展板停止提供電機運轉動力
    
26.   motor4.run(RELEASE); // 電機旋轉一旦失去動力就會自然的停止轉動。
    
27. }
    
28. 
    
29. void loop() {
    
30.   motor1.run(FORWARD); // 這4條語句的作用是利用run庫函數控制4個電機"正向"旋轉。
    
31.   motor2.run(FORWARD); // 這里所謂的“正向”旋轉只是一種說法，假如您發現電機旋轉方向和您所要的“正向”不一致。
    
32.   motor3.run(FORWARD); // 您可以將電機的兩個引線從擴展板上斷開，然后交換順序再接到擴展板接口上
    
33.   motor4.run(FORWARD); // 這時您會看到同樣使用FORWARD關鍵字作為run庫函數的參數，電機的旋轉方向卻反過來了。
    
34. 
    
35.   for (int i = 0; i <= 255; i++) { // 這里使用for循環語句控制4個電機速度由停止逐步加速，最終電機運轉達到最大速度。
    
36.     motor1.setSpeed(i);          // 在for循環語句的作用下,setSpeed庫函數的速度參數i由0逐漸增大，最終達到255。
    
37.     motor2.setSpeed(i);          // 因此電機運行速度也是由停止逐漸加速，最終達到最大速度。
    
38.     motor3.setSpeed(i);          // 對于一些模型電機來說，當速度參數小于一定數值以后就不能轉動了。也就是說，也許您的電機
    
39.     motor4.setSpeed(i);          // 在速度參數在小于某一個速度參數數值的時候就無法轉動了。這屬于正常現象。
    
40.     delay(10);                   // 具體這個最小值是多少，對于不同的電機來說是不同的。有的可能是50也有的可能是100。
    
41.   }                               // 換句話說，很可能您的某一個直流電機在速度參數小于50的情況下就無法轉動了。
    
42.   // 也可能您的另一個直流電機在參數100以下的情況下就無法轉動了。
    
43. 
    
44.   for (int i = 255; i >= 0; i--) { // 這里使用for循環語句控制4個電機由最大旋轉速度逐步減速最終停止旋轉。
    
45.     motor1.setSpeed(i);          // 這一系列語句的操作與上一段for循環語句類似。唯一區別是上一段for循環控制速度參數i由0漲到255
    
46.     motor2.setSpeed(i);          // 而這一段語句控制速度參數i由255減小到0。同樣您可能會發現當速度參數沒有減小到零的時候，電機就已經
    
47.     motor3.setSpeed(i);          // 停止旋轉了。這其中的原因在上一段for循環語句中已經介紹了。不在這里贅述了。
    
48.     motor4.setSpeed(i);
    
49.     delay(10);
    
50.   }
    
51. 
    
52.   motor1.run(BACKWARD); // 這4條語句的作用是利用run庫函數控制4個電機"反向"旋轉。
    
53.   motor2.run(BACKWARD); // 同樣的，這里所謂的“反向”旋轉也只是一種說法。這部分程序內容
    
54.   motor3.run(BACKWARD); // 與本程序33-36行中的內容十分類似。唯一區別就是使用了“BACKWARD”
    
55.   motor4.run(BACKWARD); // 關鍵字參數來通過庫函數run控制電機“反向”旋轉。
    
56. 
    
57.   for (int i = 0; i <= 255; i++) { // 利用for循環語句控制速度參數i由小到大
    
58.     motor1.setSpeed(i);          // 電機也會以“反向”旋轉的方式由停止逐步達到最大速度
    
59.     motor2.setSpeed(i);
    
60.     motor3.setSpeed(i);
    
61.     motor4.setSpeed(i);
    
62.     delay(10);
    
63.   }
    
64. 
    
65.   for (int i = 255; i >= 0; i--) { // 利用for循環語句控制速度參數i由大到小
    
66.     motor1.setSpeed(i);          // 電機也會以“反向”旋轉的方式由最大速度逐步減小到停止
    
67.     motor2.setSpeed(i);
    
68.     motor3.setSpeed(i);
    
69.     motor4.setSpeed(i);
    
70.     delay(10);
    
71.   }
    
72. 
    
73.   motor1.run(RELEASE);   // 這四條語句作用是使用關鍵字RELEASE作為run函數的參數。
    
74.   motor2.run(RELEASE);   // 在這種情況下，AFMotor擴展板將會停止為電機旋轉提供動力。
    
75.   motor3.run(RELEASE);   // 電機也就會自然的停止轉動。
    
76.   motor4.run(RELEASE);   // 本段程序后面的delay(1000)的作用就是讓4個電機保持無旋轉動力狀態1秒鐘
    
77. 
    
78.   delay(1000);
    
79. }

復制代碼

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之六：連接每轉48步（7.5度）的步進電機，電機端口2#（M3和M4）
   
8. */
   
9. 
   
10. #include <AFMotor.h>
    
11. 
    
12. // Connect a stepper motor with 48 steps per revolution (7.5 degree)
    
13. // to motor port #2 (M3 and M4)
    
14. AF_Stepper motor(48, 2);
    
15. 
    
16. void setup() {
    
17.   Serial.begin(9600);           // set up Serial library at 9600 bps
    
18.   Serial.println("Stepper test! 測試步進電機！");
    
19. 
    
20.   motor.setSpeed(10);  // 10 rpm
    
21. }
    
22. 
    
23. void loop() {
    
24.   Serial.println("Single coil steps 單線圈步");
    
25.   motor.step(100, FORWARD, SINGLE);
    
26.   motor.step(100, BACKWARD, SINGLE);
    
27. 
    
28.   Serial.println("Double coil steps 雙線圈步");
    
29.   motor.step(100, FORWARD, DOUBLE);
    
30.   motor.step(100, BACKWARD, DOUBLE);
    
31. 
    
32.   Serial.println("Interleave coil steps 交錯線圈臺階");
    
33.   motor.step(100, FORWARD, INTERLEAVE);
    
34.   motor.step(100, BACKWARD, INTERLEAVE);
    
35. 
    
36.   Serial.println("Micrsostep steps 微步前進");
    
37.   motor.step(100, FORWARD, MICROSTEP);
    
38.   motor.step(100, BACKWARD, MICROSTEP);
    
39. }

復制代碼

與步進電機有關的函數
確保導入AFMotor庫文件并#include < AFMotor.h>后,有這么幾個函數需要用到

1、AF_Stepper steppername(steps,portnumber)
（1）steppername
給電機起個名字,然后這個名字就是此電機在程序中的代號了
（2）steps
設置電機每轉的步數,比如設置36,則每步走1/36轉
（3）portnumber
選擇電機的通道,范圍為1(通道1,2)和2(通道3和4)

2、Step(steps,direction,style)
（1）step
轉動的步數
（2）direction
轉動的方向FORWARD 或者 BACKWARD
（3）style
步進的模式,可以選擇的參數:
a\SINGLE - 一次只給一相線圈供電
b\DOUBLE - 一次給兩項項圈都供電，得到更大的扭矩
c\INTERLEAVE - 電機會運轉得更柔滑，因為步數增加了一倍，同時速度也減小一半
d\MICROSTEP - 電機會運轉的更柔滑，精度更高，但扭矩也會減小

如果想更精細地控制步進電機，可以使用AccelStepper library，這個庫帶有電機加減速度功能。

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之五：驅動28BYJ-48步進電機
   
8. */
   
9. 
   
10. #include <AFMotor.h> // 本程序中使用AFMotor庫
    
11. 
    
12. AF_Stepper motor1(2048, 1);  // 這2條語句的作用是建立2個步進電機對象，它們的名稱分別是：motor1/2。
    
13. AF_Stepper motor2(2048, 2);  // 對象名稱后面括號中的兩個參數分別代表了步進電機旋轉一周的步數以及
    
14.                               // 步進電機連接在擴展板上的端口號。如AF_Stepper motor1(2048, 1)語句中
    
15.                               // 參數2048代表motor1旋轉一周需要走2048步。假如您的電機旋轉一周需要32步，
    
16.                               // 那么請在第一個參數位置輸入32這一數字參數。
    
17.                               // 括號中第二個參數1代表motor1連接在M1和M2端口。
    
18.                               // 對于motor2對象，它括號中的參數2代表該電機連接在M3和M4端口。
    
19. 
    
20. void setup() {
    
21.   Serial.begin(9600);         //啟動串口通訊
    
22.   
    
23.   motor1.setSpeed(10);        // 這2條語句的作用是通過setSpped庫函數設置電機運行速度。
    
24.   motor2.setSpeed(10);        // setSpped庫函數中的參數是運行速度參數。
    
25.                               // 速度參數越大，運轉速度越快。參數為0時電機停止轉動。
    
26. }
    
27. 
    
28. /*
    
29. 以下的loop函數中有4段程序語句。它們的內容十分類似，主要語句都是是通過step庫函數來控制
    
30. 步進電機的運行模式。step庫函數一共有3個參數。如loop函數的第二行語句：motor1.step(2048, FORWARD, SINGLE)。
    
31. 括號中的第一個參數是控制電機走的步數，這里的參數2048就是讓電機走2048步。
    
32. 接下來的關鍵字參數"FORWARD"作用是控制電機旋轉方向。"FORWARD"是控制電機"正轉"，
    
33. 這里也可以使用關鍵字"BACKWARD"讓電機"反轉"。
    
34. 最后一個關鍵字參數是用于控制步進電機運轉模式的。這里可選的關鍵字參數有：
    
35. SINGLE - 全步進模式（單線圈）。電機每走一步，擴展板只給一相線圈供電。
    
36. DOUBLE - 全步進模式（雙線圈）。電機每走一步，擴展板會同時給兩相線圈供電。
    
37.          此模式運行的電機比SINGLE模式下的扭矩要更大，但是電機耗電也會更多。
    
38. INTERLEAVE - 半步進模式。這種模式是SINGLE和DOUBLE的混合。電機每走一步，擴展板對線圈供電方式
    
39.              在一相和兩相之間交替切換。舉例來說，電機走第一步時，只有一相線圈通電。
    
40.              走第二步時，會有兩相線圈供電，然后又是一相，再兩相......這樣交替通電。
    
41.              這種控制模式的優點是電機運行更流暢，但是缺點是運行速度大打折扣。
    
42. MICROSTEP - 微步進模式。此模式下的電機運行更光滑，但缺點是扭矩會打折扣。   
    
43. */
    
44. 
    
45. void loop() {
    
46.   Serial.println("Single Mode");        //串口監視器輸出當前運行模式為“Single”
    
47.   motor1.step(2048, FORWARD, SINGLE);    //步進電機以SINGLE模式"正轉"2048步
    
48.   motor1.step(2048, BACKWARD, SINGLE);   //步進電機以SINGLE模式"反轉"2048步
    
49. 
    
50.   Serial.println("Double Mode");        //串口監視器輸出當前運行模式為“Double”
    
51.   motor2.step(2048, FORWARD, DOUBLE);    //步進電機以DOUBLE模式"正轉"2048步
    
52.   motor2.step(2048, BACKWARD, DOUBLE);   //步進電機以DOUBLE模式"反轉"2048步
    
53. 
    
54.   Serial.println("Interleave Mode");        //串口監視器輸出當前運行模式為“Interleave”
    
55.   motor1.step(2048, FORWARD, INTERLEAVE);    //步進電機以INTERLEAVE模式"正轉"2048步
    
56.   motor1.step(2048, BACKWARD, INTERLEAVE);   //步進電機以INTERLEAVE模式"反轉"2048步
    
57. 
    
58.   Serial.println("Micrsostep Mode");         //串口監視器輸出當前運行模式為“Micrsostep”
    
59.   motor2.step(2048, FORWARD, MICROSTEP);      //步進電機以MICROSTEP模式"正轉"2048步
    
60.   motor2.step(2048, BACKWARD, MICROSTEP);     //步進電機以MICROSTEP模式"反轉"2048步
    
61. }

復制代碼

3、Servo-writeMicroseconds（）函數（精確控制）
以微秒（uS）為單位寫入一個值，從而相應地控制軸。在標準伺服系統上，這將設置軸的角度。在標準伺服器上，參數值1000完全是逆時針方向，2000完全是順時針方向，中間是1500。

請注意，某些制造商并未非常嚴格地遵循此標準，因此，伺服器通常會對700到2300之間的值做出響應。可以隨意增加這些端點，直到伺服器不再繼續增加其范圍為止。但是請注意，嘗試將伺服驅動器驅動通過其端點（通常由嘶嘶聲表示）是高電流狀態，應避免使用。連續旋轉伺服器將以類似于寫入功能的方式響應writeMicrosecond功能。

句法
servo.writeMicroseconds(uS)

參量
伺服：伺服類型的變量
us：參數值（以微秒為單位）（int）

例
#include <Servo.h>

Servo myservo;

void setup()
{
  myservo.attach(9);
  myservo.writeMicroseconds(1500);  // set servo to mid-point
}

void loop() {}


4、Servo-read（）函數（讀取）
讀取伺服器的當前角度（該值傳遞給對write（）的最后一次調用）。

句法
servo.read()

參量
伺服：類型變量Servo
反饋
伺服角度為0到180度。


5、Servo-Attached（）函數（附加）
檢查是否將Servo變量附加到引腳上。

句法
servo.attached()

參量
伺服：類型變量Servo
反饋
true如果伺服系統連接到引腳上；false除此以外。

6、Servo-detach（）函數（分離）
從其引腳上拆下伺服變量。如果所有伺服變量均已分離，則可以使用AnalogWrite（）將引腳9和10用于PWM輸出。

句法
servo.detach()

參量
伺服：類型變量Servo

使用Servo庫
1、Servo-attach（）函數（連接）
將伺服變量附加到引腳上。請注意，在Arduino 0016及更早版本中，Servo庫僅在兩個引腳上僅支持舵機：9和10。

句法
servo.attach(pin)
servo.attach(pin, min, max)

參量
伺服：類型變量Servo
pin：伺服器連接的引腳號
min（可選）：脈沖寬度（以微秒為單位），對應于伺服器上的最小（0度）角度（默認為544）
最大（可選）：脈沖寬度（以微秒為單位），對應于伺服器上的最大（180度）角度（默認為2400）

例
#include <Servo.h>
Servo myservo;
void setup()
{
  myservo.attach(9);
}
void loop() {}

2、Servo-write（x）函數（寫入）
將值寫入伺服器，從而相應地控制軸。在標準伺服器上，這將設置軸的角度（以度為單位），將軸移動到該方向。在連續旋轉伺服系統（360度舵機）上，這將設置伺服系統的速度（0表示一個方向的全速，180表示另一方向的全速，而90左右的值表示無運動）。

句法
servo.write(angle)

參量
伺服：伺服類型的變量
angle：寫入伺服的值，從0到180

例
#include <Servo.h>
Servo myservo;
void setup()
{
  myservo.attach(9);
  myservo.write(90);  // set servo to mid-point
}
void loop() {}

實驗之四：驅動二只伺服電機（1號與2號舵機）

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：IDE—工具—管理庫—搜索“Servo”—安裝
   
7.   2、實驗之四：驅動二只伺服電機（1號與2號舵機）
   
8. */
   
9. 
   
10. #include <Servo.h>
    
11. 
    
12. Servo servo1;   //建立舵機對象servo1
    
13. Servo servo2;   //建立舵機對象servo2
    
14. 
    
15. int pos = 0;   
    
16. void setup() {
    
17.   servo1.attach(10);    //servo1對象接在擴展板servo1端口。
    
18.                         //servo1端口是由Arduino的10號引腳來控制的。
    
19.   servo2.attach(9);     //servo2對象接在擴展板servo2端口。
    
20.                         //servo2端口是由Arduino的9號引腳來控制的。
    
21. }
    
22. 
    
23. void loop() {
    
24.   //以下程序將控制servo1輸出軸左右旋轉180度
    
25.   for (pos = 0; pos <= 180; pos += 1) {
    
26.     servo1.write(pos);              
    
27.     delay(15);                       
    
28.   }
    
29.   for (pos = 180; pos >= 0; pos -= 1) {
    
30.     servo1.write(pos);   
    
31.     delay(15);      
    
32.   }
    
33.   
    
34.   //以下程序將控制servo2輸出軸左右旋轉180度
    
35.   for (pos = 0; pos <= 180; pos += 1) {
    
36.     servo2.write(pos);              
    
37.     delay(15);                       
    
38.   }
    
39.   for (pos = 180; pos >= 0; pos -= 1) {
    
40.     servo2.write(pos);   
    
41.     delay(15);      
    
42.   }  
    
43. }

復制代碼

實驗之三：驅動單只伺服電機（2號舵機）

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：IDE—工具—管理庫—搜索“Servo”—安裝
   
7.   2、實驗之三：驅動單只伺服電機（2號舵機）
   
8. */
   
9. 
   
10. #include <Servo.h>
    
11. 
    
12. Servo myservo;  // create servo object to control a servo
    
13. // twelve servo objects can be created on most boards
    
14. 
    
15. int pos = 0;    // variable to store the servo position
    
16. 
    
17. void setup() {
    
18.   myservo.attach(9);  // attaches the servo on pin 9 to the servo object
    
19. }
    
20. 
    
21. void loop() {
    
22.   for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    
23.     // in steps of 1 degree
    
24.     myservo.write(pos);              // tell servo to go to position in variable 'pos'
    
25.     delay(15);                       // waits 15ms for the servo to reach the position
    
26.   }
    
27.   for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    
28.     myservo.write(pos);              // tell servo to go to position in variable 'pos'
    
29.     delay(15);                       // waits 15ms for the servo to reach the position
    
30.   }
    
31. }

復制代碼

AF_DCMotor 類函數

AFMotor類配合Adafruit Motor Shied可以最多同時控制4個直流電機的速度和方向。要使用這些功能，首先要在開頭添加庫文件：

#include <AFMotor.h>

AF_DCMotor motorname(portnum,freq)

這是一個建立一個直流電機的函數。在程序中需要聲明每個電機各一次。像下面的例子中一樣，每個電機必須使用不同的名字。

參數：

port num - 選擇你的電機連接到電機驅動板上的接口（1-4）

freq - 選擇PWM頻率。如果你沒有選擇這個選項，默認設置為1KHZ。

適用于通道1和2的頻率：

MOTOR12_64KHZ

MOTOR12_8KHZ

MOTOR12_2KHZ

MOTOR12_1KHZ

適用于通道3和4的頻率：

MOTOR34_64KHZ

MOTOR34_8KHZ

MOTOR34_1KHZ

例如：

AF_DCMotor motor4(4);//通道4,默認1KHZ頻率

AF_DCMotor left_motor(1,MOTOR12_64KHZ);//通道1,64KHZ頻率

注意：更高的頻率會減小電機在運動過程中的噪音，但同時也會降低扭矩。

setSpeed(speed)

設置電機的速度

參數：

speed-范圍為0到255，0代表停止，255代表全速。

注意：直流電機的回饋并不是典型線性的，所以真正的轉速并不會與程序中設定的速度成正比。

run(cmd)

設置電機的運轉模式

參數：

cmd - 選擇你想要的電機運轉模式

可選擇的模式：

FORWARD - 正轉（真正的轉動方向取決于你電機的連線）

BACKWARD - 反轉 （轉動方向與正轉相反）

RELEASE - 停止。使電機斷電，與setSpeed(0)函數功能相同。調用了這個函數后，電機需要一定時間才能徹底停止。

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之二：引擎測試—用串口查看2號直流電機運轉情況
   
8. */
   
9. 
   
10. #include "AFMotor.h"
    
11. 
    
12. AF_DCMotor motor(2);
    
13. 
    
14. void setup() {
    
15.   Serial.begin(9600);           // set up Serial library at 9600 bps
    
16.   Serial.println("引擎測試 Motor test!");
    
17. 
    
18.   // turn on motor
    
19.   motor.setSpeed(200);
    
20. 
    
21.   motor.run(RELEASE);
    
22. }
    
23. 
    
24. void loop() {
    
25.   uint8_t i;
    
26. 
    
27.   Serial.println("向前 FORWARD！");
    
28. 
    
29.   motor.run(FORWARD);
    
30.   for (i = 0; i < 255; i++) {
    
31.     motor.setSpeed(i);
    
32.     delay(10);
    
33.   }
    
34. 
    
35.   for (i = 255; i != 0; i--) {
    
36.     motor.setSpeed(i);
    
37.     delay(10);
    
38.   }
    
39. 
    
40.   Serial.println("向后 BACKWARD！");
    
41. 
    
42.   motor.run(BACKWARD);
    
43.   for (i = 0; i < 255; i++) {
    
44.     motor.setSpeed(i);
    
45.     delay(10);
    
46.   }
    
47. 
    
48.   for (i = 255; i != 0; i--) {
    
49.     motor.setSpeed(i);
    
50.     delay(10);
    
51.   }
    
52. 
    
53. 
    
54.   Serial.println("停止 RELEASE！");
    
55.   motor.run(RELEASE);
    
56.   delay(1000);
    
57. }

復制代碼

1. /*
   
2.   【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
   
3.   實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
   
4.   Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
   
5. 
   
6.   1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
   
7.   2、實驗之一：測試驅動M2直流電機
   
8. */
   
9. 
   
10. #include <AFMotor.h>
    
11. 
    
12. AF_DCMotor motor(2, MOTOR12_64KHZ);
    
13. 
    
14. void setup() {
    
15.   motor.setSpeed(200);
    
16. }
    
17. 
    
18. void loop() {
    
19.   motor.run(FORWARD);
    
20.   delay(1000);
    
21.   motor.run(BACKWARD);
    
22.   delay(1000);
    
23.   motor.run(RELEASE);
    
24.   delay(1000);
    
25. }

復制代碼