单片机教程网

电脑版
提示:原网页已由神马搜索转码, 内容由www.51hei.com提供.
上一页
2/2
下一页
楼主: eagler8
打印上一主题下一主题

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

[复制链接]
41#
ID:513258发表于 2020-11-12 19:38|只看该作者
  1. /*
  2.   【Arduino】168种传感器模块系列实验（资料+代码+图形+仿真）
  3.   实验一百七十：L293D四路电机驱动板 motor control shield 马达板
  4.   Adafruit Motor Shield模块 Arduino AFMotor 电机扩展板

  6.   1、安装库：百度搜索“AFMotor库”— 下载 — 拷贝到Arduino-libraries 文件夹中
  7.   2、实验之六：连接每转48步（7.5度）的步进电机，电机端口2#（M3和M4）
  8. */

  10. #include< AFMotor.h>

  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);

  16. void setup() {
  17.   Serial.begin(9600);         // set up Serial library at 9600 bps
  18.   Serial.println("Stepper test! 测试步进电机！");

  20.   motor.setSpeed(10);  // 10 rpm
  21. }

  23. void loop() {
  24.   Serial.println("Single coil steps 单线圈步");
  25.   motor.step(100, FORWARD, SINGLE);
  26.   motor.step(100, BACKWARD, SINGLE);

  28.   Serial.println("Double coil steps 双线圈步");
  29.   motor.step(100, FORWARD, DOUBLE);
  30.   motor.step(100, BACKWARD, DOUBLE);

  32.   Serial.println("Interleave coil steps 交错线圈台阶");
  33.   motor.step(100, FORWARD, INTERLEAVE);
  34.   motor.step(100, BACKWARD, INTERLEAVE);

  36.   Serial.println("Micrsostep steps 微步前进");
  37.   motor.step(100, FORWARD, MICROSTEP);
  38.   motor.step(100, BACKWARD, MICROSTEP);
  39. }
复制代码


42#
ID:513258发表于 2020-11-12 19:41|只看该作者

43#
ID:513258发表于 2020-11-12 20:26|只看该作者
使用Arduino AFMotor驱动四只直流电机

  1. /*
  2.   【Arduino】168种传感器模块系列实验（资料+代码+图形+仿真）
  3.   实验一百七十：L293D四路电机驱动板 motor control shield 马达板
  4.   Adafruit Motor Shield模块 Arduino AFMotor 电机扩展板

  6.   1、安装库：百度搜索“AFMotor库”— 下载 — 拷贝到Arduino-libraries 文件夹中
  7.   2、实验之七：使用Arduino AFMotor驱动四只直流电机
  8. */

  10. #include< AFMotor.h> // 本程序中使用AFMotor库

  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个直流电机。

  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时电机停止转动。

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

  29. void loop() {
  30.   motor1.run(FORWARD); // 这4条语句的作用是利用run库函数控制4个电机"正向"旋转。
  31.   motor2.run(FORWARD); // 这里所谓的“正向”旋转只是一种说法，假如您发现电机旋转方向和您所要的“正向”不一致。
  32.   motor3.run(FORWARD); // 您可以将电机的两个引线从扩展板上断开，然后交换顺序再接到扩展板接口上
  33.   motor4.run(FORWARD); // 这时您会看到同样使用FORWARD关键字作为run库函数的参数，电机的旋转方向却反过来了。

  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以下的情况下就无法转动了。

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

  52.   motor1.run(BACKWARD); // 这4条语句的作用是利用run库函数控制4个电机"反向"旋转。
  53.   motor2.run(BACKWARD); // 同样的，这里所谓的“反向”旋转也只是一种说法。这部分程序内容
  54.   motor3.run(BACKWARD); // 与本程序33-36行中的内容十分类似。唯一区别就是使用了“BACKWARD”
  55.   motor4.run(BACKWARD); // 关键字参数来通过库函数run控制电机“反向”旋转。

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

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

  73.   motor1.run(RELEASE);   // 这四条语句作用是使用关键字RELEASE作为run函数的参数。
  74.   motor2.run(RELEASE);   // 在这种情况下，AFMotor扩展板将会停止为电机旋转提供动力。
  75.   motor3.run(RELEASE);   // 电机也就会自然的停止转动。
  76.   motor4.run(RELEASE);   // 本段程序后面的delay(1000)的作用就是让4个电机保持无旋转动力状态1秒钟

  78.   delay(1000);
  79. }
复制代码



44#
ID:513258发表于 2020-11-13 08:07|只看该作者
Arduino AFMotor 电机扩展板实验场景图



45#
ID:513258发表于 2020-11-13 08:59|只看该作者
附录：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!

  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


  32. #ifndef _AFMotor_h_
  33. #define _AFMotor_h_

  35. #include< inttypes.h>
  36. #if defined(__AVR__)
  37.    #include< avr/io.h>

  39.    //#define MOTORDEBUG 1

  41.    #define MICROSTEPS 16                 // 8 or 16

  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

  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

  65.    #define MICROSTEPS 16     // 8 or 16

  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

  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

  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

  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

  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

  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. */

  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

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

  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);

  157. private:
  158.   uint8_t motornum, pwmfreq;
  159. };

  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;

  174. };

  176. uint8_t getlatchstate(void);

  178. #endif
复制代码




46#
ID:513258发表于 2020-11-13 09:04|只看该作者

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


  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

  15. #include "AFMotor.h"



  19. static uint8_t latch_state;

  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

  27. AFMotorController::AFMotorController(void) {
  28.    TimerInitalized = false;
  29. }

  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);

  44.   latch_state = 0;

  46.   latch_tx();  // "reset"

  48.   //ENABLE_PORT& = ~_BV(ENABLE); // enable the chip outputs!
  49.   digitalWrite(MOTORENABLE, LOW);
  50. }


  53. void AFMotorController::latch_tx(void) {
  54.   uint8_t i;

  56.   //LATCH_PORT& = ~_BV(LATCH);
  57.   digitalWrite(MOTORLATCH, LOW);

  59.   //SER_PORT& = ~_BV(SER);
  60.   digitalWrite(MOTORDATA, LOW);

  62.   for (i=0; i<8; i++) {
  63.    //CLK_PORT& = ~_BV(CLK);
  64.    digitalWrite(MOTORCLK, LOW);

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

  80. static AFMotorController MC;

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

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

  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

  208.    pinMode(3, OUTPUT);
  209. }

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

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

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



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

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

  338. AF_DCMotor::AF_DCMotor(uint8_t num, uint8_t freq) {
  339.   motornum = num;
  340.   pwmfreq = freq;

  342.   MC.enable();

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

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

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

  415. /******************************************
  416.            STEPPERS
  417. ******************************************/

  419. AF_Stepper::AF_Stepper(uint16_t steps, uint8_t num) {
  420.   MC.enable();

  422.   revsteps = steps;
  423.   steppernum = num;
  424.   currentstep = 0;

  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);

  437.    // use PWM for microstepping support
  438.    initPWM1(STEPPER1_PWM_RATE);
  439.    initPWM2(STEPPER1_PWM_RATE);
  440.    setPWM1(255);
  441.    setPWM2(255);

  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();

  448.    // enable both H bridges
  449.    pinMode(5, OUTPUT);
  450.    pinMode(6, OUTPUT);
  451.    digitalWrite(5, HIGH);
  452.    digitalWrite(6, HIGH);

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

  463. void AF_Stepper::setSpeed(uint16_t rpm) {
  464.   usperstep = 60000000 / ((uint32_t)revsteps * (uint32_t)rpm);
  465.   steppingcounter = 0;
  466. }

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

  480. void AF_Stepper::step(uint16_t steps, uint8_t dir,  uint8_t style) {
  481.   uint32_t uspers = usperstep;
  482.   uint8_t ret = 0;

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

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

  517. uint8_t AF_Stepper::onestep(uint8_t dir, uint8_t style) {
  518.   uint8_t a, b, c, d;
  519.   uint8_t ocrb, ocra;

  521.   ocra = ocrb = 255;

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

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

  576.   if (style == MICROSTEP) {
  577.    if (dir == FORWARD) {
  578.      currentstep++;
  579.    } else {
  580.      // BACKWARDS
  581.      currentstep--;
  582.    }

  584.    currentstep += MICROSTEPS*4;
  585.    currentstep %= MICROSTEPS*4;

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

  603.   currentstep += MICROSTEPS*4;
  604.   currentstep %= MICROSTEPS*4;

  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

  612.   if (steppernum == 1) {
  613.    setPWM1(ocra);
  614.    setPWM2(ocrb);
  615.   } else if (steppernum == 2) {
  616.    setPWM3(ocra);
  617.    setPWM4(ocrb);
  618.   }


  621.   // release all
  622.   latch_state& = ~a& ~b& ~c& ~d; // all motor pins to 0

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


  664.   MC.latch_tx();
  665.   return currentstep;
  666. }
复制代码



47#
ID:513258发表于 2020-11-13 09:51|只看该作者
补充实验

  1. /*
  2.   【Arduino】168种传感器模块系列实验（资料+代码+图形+仿真）
  3.   实验一百七十：L293D四路电机驱动板 motor control shield 马达板
  4.   Adafruit Motor Shield模块 Arduino AFMotor 电机扩展板

  6.   1、安装库：IDE—工具—管理库—搜索“Servo”—安装
  7.   2、实验之八：测试M1M2电机
  8. */

  10. #include< AFMotor.h>

  12. AF_DCMotor motor1(1);
  13. AF_DCMotor motor2(2);

  15. void setup() {
  16.   Serial.begin(9600);
  17.   Serial.println("测试M1M2电机!");

  19.   // turn on motor
  20.   motor1.setSpeed(200);
  21.   motor2.setSpeed(200);

  23.   motor1.run(RELEASE);
  24.   motor2.run(RELEASE);
  25. }

  27. void loop() {
  28.   uint8_t i;

  30.   Serial.println("正转");

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

  40.   for (i = 255; i != 0; i--) {
  41.    motor1.setSpeed(i);
  42.    motor2.setSpeed(i);
  43.    delay(10);
  44.   }

  46.   Serial.println("反转");

  48.   motor1.run(BACKWARD);
  49.   motor2.run(BACKWARD);

  51.   for (i = 0; i< 255; i++) {
  52.    motor1.setSpeed(i);
  53.    motor2.setSpeed(i);
  54.    delay(10);
  55.   }

  57.   for (i = 255; i != 0; i--) {
  58.    motor1.setSpeed(i);
  59.    motor2.setSpeed(i);
  60.    delay(10);
  61.   }

  63.   Serial.println("断电一秒");
  64.   motor1.run(RELEASE);
  65.   motor2.run(RELEASE);
  66.   delay(1000);
  67. }
复制代码



48#
ID:513258发表于 2020-11-13 10:40|只看该作者

49#
ID:513258发表于 2020-11-13 11:01|只看该作者
太极创客团队制作的B站视频，相当不错的视频教程

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





50#
ID:513258发表于 2020-11-13 11:05|只看该作者
Arduino AFMotor电机扩展板（上）
https://www.bilibili.com/video/BV1vb411q7xz?p=1

Arduino AFMotor电机扩展板（下）
https://www.bilibili.com/video/BV1vb411q7xz?p=2
51#
ID:513258发表于 2020-11-13 13:22|只看该作者
AFMotor电机驱动扩展板使用图形编程
【mind+用户库】第三方库方案

先下载安装Mind+（目前版本V1.6.5 RC3.0）
链接(自行替换.)：mindplus点cc/download.html





52#
ID:513258发表于 2020-11-13 13:38|只看该作者
打开Mind+，进入“扩展”



53#
ID:513258发表于 2020-11-13 13:42|只看该作者
进入“用户库”



54#
ID:513258发表于 2020-11-13 13:45|只看该作者
在用户库中搜索“hockel”即可



55#
ID:513258发表于 2020-11-13 13:48|只看该作者
添加的 AFMotor模块



56#
ID:513258发表于 2020-11-13 14:04|只看该作者
AFMotor电机驱动扩展板积木列表



57#
ID:513258发表于 2020-11-13 16:54|只看该作者
用图形编程驱动四只直流电机



58#
ID:513258发表于 2020-11-13 16:55|只看该作者

59#
ID:513258发表于 2020-11-13 17:38|只看该作者
  1. /*
  2.   【Arduino】168种传感器模块系列实验（资料+代码+图形+仿真）
  3.   实验一百七十：L293D四路电机驱动板 motor control shield 马达板
  4.   Adafruit Motor Shield模块 Arduino AFMotor 电机扩展板

  6.   1、安装库：百度搜索“AFMotor库”— 下载 — 拷贝到Arduino-libraries 文件夹中
  7.   2、实验之九：测试M1M2M3M4电机前进与后退
  8. */

  10. #include< AFMotor.h>

  12. // 创建对象
  13. AF_DCMotor motor1(1);
  14. AF_DCMotor motor2(2);
  15. AF_DCMotor motor3(3);
  16. AF_DCMotor motor4(4);


  19. // 主程序开始
  20. void setup() {

  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. }
复制代码


60#
ID:513258发表于 2020-12-29 20:38|只看该作者

实验开源仿真编程（linkboy V4.1）



61#
ID:513258发表于 2020-12-30 17:06|只看该作者
用这款电机驱动扩展板做了一辆麦克纳姆轮小车






62#
ID:513258发表于 2020-12-30 18:04|只看该作者
麦克纳姆轮车子运动模式图





63#
ID:513258发表于 2020-12-30 18:06|只看该作者
实验仿真编程（linkboy V4.1）之二




64#
ID:513258发表于 2020-12-30 18:16|只看该作者
使用
AFMotor电机扩展板的麦克纳姆轮小车（视频）



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





  12
返回列表
发新帖

手机版|小黑屋|51黑电子论坛|51黑电子论坛6群QQ管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网