【Arduino】168种传感器系列实验（170）---L293D四路电机驱动板

eagler8

msold5 发表于 2020-11-13 08:22
早鸟的连续剧越来越丰富了

谢谢老师的鼓励

eagler8

附录：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

复制代码

eagler8

附录：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. }

复制代码

eagler8

补充实验

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. }

复制代码

eagler8

eagler8

太极创客团队制作的B站视频，相当不错的视频教程

B站太极创客官方站：https://space.bilibili.com/10358 ... _765f7570696e666f.2

eagler8

Arduino AFMotor电机扩展板（上）
https://www.bilibili.com/video/BV1vb411q7xz?p=1

Arduino AFMotor电机扩展板（下）
https://www.bilibili.com/video/BV1vb411q7xz?p=2

eagler8

AFMotor电机驱动扩展板使用图形编程
【mind+用户库】第三方库方案

先下载安装Mind+（目前版本V1.6.5 RC3.0）
链接：http://mindplus.cc/download.html

eagler8

打开Mind+，进入“扩展”

eagler8

进入“用户库”

eagler8

在用户库中搜索“hockel”即可

eagler8

添加的 AFMotor模块

eagler8

AFMotor电机驱动扩展板积木列表

eagler8

用图形编程驱动四只直流电机

eagler8