亚洲精品综合中文字幕,久久69,91在线一区

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

復制代碼

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
2、實驗之二：引擎測試—用串口查看2號直流電機運轉情況
*/
#include "AFMotor.h"
AF_DCMotor motor(2);
void setup() {
Serial.begin(9600); // set up Serial library at 9600 bps
Serial.println("引擎測試 Motor test!");
// turn on motor
motor.setSpeed(200);
motor.run(RELEASE);
}
void loop() {
uint8_t i;
Serial.println("向前 FORWARD！");
motor.run(FORWARD);
for (i = 0; i < 255; i++) {
motor.setSpeed(i);
delay(10);
}
for (i = 255; i != 0; i--) {
motor.setSpeed(i);
delay(10);
}
Serial.println("向后 BACKWARD！");
motor.run(BACKWARD);
for (i = 0; i < 255; i++) {
motor.setSpeed(i);
delay(10);
}
for (i = 255; i != 0; i--) {
motor.setSpeed(i);
delay(10);
}
Serial.println("停止 RELEASE！");
motor.run(RELEASE);
delay(1000);
}

復制代碼

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

復制代碼

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
1、安裝庫：IDE—工具—管理庫—搜索“Servo”—安裝
2、實驗之四：驅動二只伺服電機（1號與2號舵機）
*/
#include <Servo.h>
Servo servo1; //建立舵機對象servo1
Servo servo2; //建立舵機對象servo2
int pos = 0;
void setup() {
servo1.attach(10); //servo1對象接在擴展板servo1端口。
//servo1端口是由Arduino的10號引腳來控制的。
servo2.attach(9); //servo2對象接在擴展板servo2端口。
//servo2端口是由Arduino的9號引腳來控制的。
}
void loop() {
//以下程序將控制servo1輸出軸左右旋轉180度
for (pos = 0; pos <= 180; pos += 1) {
servo1.write(pos);
delay(15);
}
for (pos = 180; pos >= 0; pos -= 1) {
servo1.write(pos);
delay(15);
}
//以下程序將控制servo2輸出軸左右旋轉180度
for (pos = 0; pos <= 180; pos += 1) {
servo2.write(pos);
delay(15);
}
for (pos = 180; pos >= 0; pos -= 1) {
servo2.write(pos);
delay(15);
}
}

復制代碼

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

復制代碼

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

復制代碼

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
2、實驗之七：使用Arduino AFMotor驅動四只直流電機
*/
#include <AFMotor.h> // 本程序中使用AFMotor庫
AF_DCMotor motor1(1); // 這4條語句的作用是建立4個直流電機對象，它們的名稱分別是：motor1/2/3/4.
AF_DCMotor motor2(2); // 這四條語句括號中的數(shù)字代表各個電機對象所連接在AFMotor擴展板的電機端口號碼。
AF_DCMotor motor3(3); // AF_DCMotor motor1(1); 代表motor1對象連接在AFMotor擴展板的M1端口上。
AF_DCMotor motor4(4); // AFMotor電機擴展板最多可以驅動4個直流電機，最少可以驅動1個直流電機。
void setup() {
motor1.setSpeed(200); // 這4條語句的作用是通過setSpped庫函數(shù)設置電機運行速度。
motor2.setSpeed(200); // setSpped庫函數(shù)中的參數(shù)是運行速度參數(shù)。
motor3.setSpeed(200); // 運行速度參數(shù)允許范圍是0～255。
motor4.setSpeed(200); // 速度參數(shù)越大，運轉速度越快。參數(shù)為0時電機停止轉動。
motor1.run(RELEASE); // 這4條語句的作用是讓4個電機在啟動時停止轉動
motor2.run(RELEASE); // run庫函數(shù)允許使用的關鍵字參數(shù)有RELEASE、FORWARD、BACKWARD
motor3.run(RELEASE); // 使用關鍵字RELEASE作為參數(shù)使用時，run庫函數(shù)將會讓擴展板停止提供電機運轉動力
motor4.run(RELEASE); // 電機旋轉一旦失去動力就會自然的停止轉動。
}
void loop() {
motor1.run(FORWARD); // 這4條語句的作用是利用run庫函數(shù)控制4個電機"正向"旋轉。
motor2.run(FORWARD); // 這里所謂的“正向”旋轉只是一種說法，假如您發(fā)現(xiàn)電機旋轉方向和您所要的“正向”不一致。
motor3.run(FORWARD); // 您可以將電機的兩個引線從擴展板上斷開，然后交換順序再接到擴展板接口上
motor4.run(FORWARD); // 這時您會看到同樣使用FORWARD關鍵字作為run庫函數(shù)的參數(shù)，電機的旋轉方向卻反過來了。
for (int i = 0; i <= 255; i++) { // 這里使用for循環(huán)語句控制4個電機速度由停止逐步加速，最終電機運轉達到最大速度。
motor1.setSpeed(i); // 在for循環(huán)語句的作用下,setSpeed庫函數(shù)的速度參數(shù)i由0逐漸增大，最終達到255。
motor2.setSpeed(i); // 因此電機運行速度也是由停止逐漸加速，最終達到最大速度。
motor3.setSpeed(i); // 對于一些模型電機來說，當速度參數(shù)小于一定數(shù)值以后就不能轉動了。也就是說，也許您的電機
motor4.setSpeed(i); // 在速度參數(shù)在小于某一個速度參數(shù)數(shù)值的時候就無法轉動了。這屬于正常現(xiàn)象。
delay(10); // 具體這個最小值是多少，對于不同的電機來說是不同的。有的可能是50也有的可能是100。
} // 換句話說，很可能您的某一個直流電機在速度參數(shù)小于50的情況下就無法轉動了。
// 也可能您的另一個直流電機在參數(shù)100以下的情況下就無法轉動了。
for (int i = 255; i >= 0; i--) { // 這里使用for循環(huán)語句控制4個電機由最大旋轉速度逐步減速最終停止旋轉。
motor1.setSpeed(i); // 這一系列語句的操作與上一段for循環(huán)語句類似。唯一區(qū)別是上一段for循環(huán)控制速度參數(shù)i由0漲到255
motor2.setSpeed(i); // 而這一段語句控制速度參數(shù)i由255減小到0。同樣您可能會發(fā)現(xiàn)當速度參數(shù)沒有減小到零的時候，電機就已經(jīng)
motor3.setSpeed(i); // 停止旋轉了。這其中的原因在上一段for循環(huán)語句中已經(jīng)介紹了。不在這里贅述了。
motor4.setSpeed(i);
delay(10);
}
motor1.run(BACKWARD); // 這4條語句的作用是利用run庫函數(shù)控制4個電機"反向"旋轉。
motor2.run(BACKWARD); // 同樣的，這里所謂的“反向”旋轉也只是一種說法。這部分程序內容
motor3.run(BACKWARD); // 與本程序33-36行中的內容十分類似。唯一區(qū)別就是使用了“BACKWARD”
motor4.run(BACKWARD); // 關鍵字參數(shù)來通過庫函數(shù)run控制電機“反向”旋轉。
for (int i = 0; i <= 255; i++) { // 利用for循環(huán)語句控制速度參數(shù)i由小到大
motor1.setSpeed(i); // 電機也會以“反向”旋轉的方式由停止逐步達到最大速度
motor2.setSpeed(i);
motor3.setSpeed(i);
motor4.setSpeed(i);
delay(10);
}
for (int i = 255; i >= 0; i--) { // 利用for循環(huán)語句控制速度參數(shù)i由大到小
motor1.setSpeed(i); // 電機也會以“反向”旋轉的方式由最大速度逐步減小到停止
motor2.setSpeed(i);
motor3.setSpeed(i);
motor4.setSpeed(i);
delay(10);
}
motor1.run(RELEASE); // 這四條語句作用是使用關鍵字RELEASE作為run函數(shù)的參數(shù)。
motor2.run(RELEASE); // 在這種情況下，AFMotor擴展板將會停止為電機旋轉提供動力。
motor3.run(RELEASE); // 電機也就會自然的停止轉動。
motor4.run(RELEASE); // 本段程序后面的delay(1000)的作用就是讓4個電機保持無旋轉動力狀態(tài)1秒鐘
delay(1000);
}

復制代碼

// Adafruit Motor shield library
// copyright Adafruit Industries LLC, 2009
// this code is public domain, enjoy!
/*
* Usage Notes:
* For PIC32, all features work properly with the following two exceptions:
*
* 1) Because the PIC32 only has 5 PWM outputs, and the AFMotor shield needs 6
* to completely operate (four for motor outputs and two for RC servos), the
* M1 motor output will not have PWM ability when used with a PIC32 board.
* However, there is a very simple workaround. If you need to drive a stepper
* or DC motor with PWM on motor output M1, you can use the PWM output on pin
* 9 or pin 10 (normally use for RC servo outputs on Arduino, not needed for
* RC servo outputs on PIC32) to drive the PWM input for M1 by simply putting
* a jumber from pin 9 to pin 11 or pin 10 to pin 11. Then uncomment one of the
* two #defines below to activate the PWM on either pin 9 or pin 10. You will
* then have a fully functional microstepping for 2 stepper motors, or four
* DC motor outputs with PWM.
*
* 2) There is a conflict between RC Servo outputs on pins 9 and pins 10 and
* the operation of DC motors and stepper motors as of 9/2012. This issue
* will get fixed in future MPIDE releases, but at the present time it means
* that the Motor Party example will NOT work properly. Any time you attach
* an RC servo to pins 9 or pins 10, ALL PWM outputs on the whole board will
* stop working. Thus no steppers or DC motors.
*
*/
// <BPS> 09/15/2012 Modified for use with chipKIT boards
#ifndef _AFMotor_h_
#define _AFMotor_h_
#include <inttypes.h>
#if defined(__AVR__)
#include <avr/io.h>
//#define MOTORDEBUG 1
#define MICROSTEPS 16 // 8 or 16
#define MOTOR12_64KHZ _BV(CS20) // no prescale
#define MOTOR12_8KHZ _BV(CS21) // divide by 8
#define MOTOR12_2KHZ _BV(CS21) | _BV(CS20) // divide by 32
#define MOTOR12_1KHZ _BV(CS22) // divide by 64
#define MOTOR34_64KHZ _BV(CS00) // no prescale
#define MOTOR34_8KHZ _BV(CS01) // divide by 8
#define MOTOR34_1KHZ _BV(CS01) | _BV(CS00) // divide by 64
#define DC_MOTOR_PWM_RATE MOTOR34_8KHZ // PWM rate for DC motors
#define STEPPER1_PWM_RATE MOTOR12_64KHZ // PWM rate for stepper 1
#define STEPPER2_PWM_RATE MOTOR34_64KHZ // PWM rate for stepper 2
#elif defined(__PIC32MX__)
//#define MOTORDEBUG 1
// Uncomment the one of following lines if you have put a jumper from
// either pin 9 to pin 11 or pin 10 to pin 11 on your Motor Shield.
// Either will enable PWM for M1
//#define PIC32_USE_PIN9_FOR_M1_PWM
//#define PIC32_USE_PIN10_FOR_M1_PWM
#define MICROSTEPS 16 // 8 or 16
// For PIC32 Timers, define prescale settings by PWM frequency
#define MOTOR12_312KHZ 0 // 1:1, actual frequency 312KHz
#define MOTOR12_156KHZ 1 // 1:2, actual frequency 156KHz
#define MOTOR12_64KHZ 2 // 1:4, actual frequency 78KHz
#define MOTOR12_39KHZ 3 // 1:8, acutal frequency 39KHz
#define MOTOR12_19KHZ 4 // 1:16, actual frequency 19KHz
#define MOTOR12_8KHZ 5 // 1:32, actual frequency 9.7KHz
#define MOTOR12_4_8KHZ 6 // 1:64, actual frequency 4.8KHz
#define MOTOR12_2KHZ 7 // 1:256, actual frequency 1.2KHz
#define MOTOR12_1KHZ 7 // 1:256, actual frequency 1.2KHz
#define MOTOR34_312KHZ 0 // 1:1, actual frequency 312KHz
#define MOTOR34_156KHZ 1 // 1:2, actual frequency 156KHz
#define MOTOR34_64KHZ 2 // 1:4, actual frequency 78KHz
#define MOTOR34_39KHZ 3 // 1:8, acutal frequency 39KHz
#define MOTOR34_19KHZ 4 // 1:16, actual frequency 19KHz
#define MOTOR34_8KHZ 5 // 1:32, actual frequency 9.7KHz
#define MOTOR34_4_8KHZ 6 // 1:64, actual frequency 4.8KHz
#define MOTOR34_2KHZ 7 // 1:256, actual frequency 1.2KHz
#define MOTOR34_1KHZ 7 // 1:256, actual frequency 1.2KHz
// PWM rate for DC motors.
#define DC_MOTOR_PWM_RATE MOTOR34_39KHZ
// Note: for PIC32, both of these must be set to the same value
// since there's only one timebase for all 4 PWM outputs
#define STEPPER1_PWM_RATE MOTOR12_39KHZ
#define STEPPER2_PWM_RATE MOTOR34_39KHZ
#endif
// Bit positions in the 74HCT595 shift register output
#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR4_A 0
#define MOTOR4_B 6
#define MOTOR3_A 5
#define MOTOR3_B 7
// Constants that the user passes in to the motor calls
#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4
// Constants that the user passes in to the stepper calls
#define SINGLE 1
#define DOUBLE 2
#define INTERLEAVE 3
#define MICROSTEP 4
/*
#define LATCH 4
#define LATCH_DDR DDRB
#define LATCH_PORT PORTB
#define CLK_PORT PORTD
#define CLK_DDR DDRD
#define CLK 4
#define ENABLE_PORT PORTD
#define ENABLE_DDR DDRD
#define ENABLE 7
#define SER 0
#define SER_DDR DDRB
#define SER_PORT PORTB
*/
// Arduino pin names for interface to 74HCT595 latch
#define MOTORLATCH 12
#define MOTORCLK 4
#define MOTORENABLE 7
#define MOTORDATA 8
class AFMotorController
{
public:
AFMotorController(void);
void enable(void);
friend class AF_DCMotor;
void latch_tx(void);
uint8_t TimerInitalized;
};
class AF_DCMotor
{
public:
AF_DCMotor(uint8_t motornum, uint8_t freq = DC_MOTOR_PWM_RATE);
void run(uint8_t);
void setSpeed(uint8_t);
private:
uint8_t motornum, pwmfreq;
};
class AF_Stepper {
public:
AF_Stepper(uint16_t, uint8_t);
void step(uint16_t steps, uint8_t dir, uint8_t style = SINGLE);
void setSpeed(uint16_t);
uint8_t onestep(uint8_t dir, uint8_t style);
void release(void);
uint16_t revsteps; // # steps per revolution
uint8_t steppernum;
uint32_t usperstep, steppingcounter;
private:
uint8_t currentstep;
};
uint8_t getlatchstate(void);
#endif

復制代碼

// Adafruit Motor shield library
// this code is public domain, enjoy!
#if (ARDUINO >= 100)
#include "Arduino.h"
#else
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "WProgram.h"
#endif
#include "AFMotor.h"
static uint8_t latch_state;
#if (MICROSTEPS == 8)
uint8_t microstepcurve[] = {0, 50, 98, 142, 180, 212, 236, 250, 255};
#elif (MICROSTEPS == 16)
uint8_t microstepcurve[] = {0, 25, 50, 74, 98, 120, 141, 162, 180, 197, 212, 225, 236, 244, 250, 253, 255};
#endif
AFMotorController::AFMotorController(void) {
TimerInitalized = false;
}
void AFMotorController::enable(void) {
// setup the latch
/*
LATCH_DDR |= _BV(LATCH);
ENABLE_DDR |= _BV(ENABLE);
CLK_DDR |= _BV(CLK);
SER_DDR |= _BV(SER);
*/
pinMode(MOTORLATCH, OUTPUT);
pinMode(MOTORENABLE, OUTPUT);
pinMode(MOTORDATA, OUTPUT);
pinMode(MOTORCLK, OUTPUT);
latch_state = 0;
latch_tx(); // "reset"
//ENABLE_PORT &= ~_BV(ENABLE); // enable the chip outputs!
digitalWrite(MOTORENABLE, LOW);
}
void AFMotorController::latch_tx(void) {
uint8_t i;
//LATCH_PORT &= ~_BV(LATCH);
digitalWrite(MOTORLATCH, LOW);
//SER_PORT &= ~_BV(SER);
digitalWrite(MOTORDATA, LOW);
for (i=0; i<8; i++) {
//CLK_PORT &= ~_BV(CLK);
digitalWrite(MOTORCLK, LOW);
if (latch_state & _BV(7-i)) {
//SER_PORT |= _BV(SER);
digitalWrite(MOTORDATA, HIGH);
} else {
//SER_PORT &= ~_BV(SER);
digitalWrite(MOTORDATA, LOW);
}
//CLK_PORT |= _BV(CLK);
digitalWrite(MOTORCLK, HIGH);
}
//LATCH_PORT |= _BV(LATCH);
digitalWrite(MOTORLATCH, HIGH);
}
static AFMotorController MC;
/******************************************
MOTORS
******************************************/
inline void initPWM1(uint8_t freq) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer2A on PB3 (Arduino pin #11)
TCCR2A |= _BV(COM2A1) | _BV(WGM20) | _BV(WGM21); // fast PWM, turn on oc2a
TCCR2B = freq & 0x7;
OCR2A = 0;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 11 is now PB5 (OC1A)
TCCR1A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc1a
TCCR1B = (freq & 0x7) | _BV(WGM12);
OCR1A = 0;
#elif defined(__PIC32MX__)
#if defined(PIC32_USE_PIN9_FOR_M1_PWM)
// Make sure that pin 11 is an input, since we have tied together 9 and 11
pinMode(9, OUTPUT);
pinMode(11, INPUT);
if (!MC.TimerInitalized)
{ // Set up Timer2 for 80MHz counting fro 0 to 256
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
TMR2 = 0x0000;
PR2 = 0x0100;
MC.TimerInitalized = true;
}
// Setup OC4 (pin 9) in PWM mode, with Timer2 as timebase
OC4CON = 0x8006; // OC32 = 0, OCTSEL=0, OCM=6
OC4RS = 0x0000;
OC4R = 0x0000;
#elif defined(PIC32_USE_PIN10_FOR_M1_PWM)
// Make sure that pin 11 is an input, since we have tied together 9 and 11
pinMode(10, OUTPUT);
pinMode(11, INPUT);
if (!MC.TimerInitalized)
{ // Set up Timer2 for 80MHz counting fro 0 to 256
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
TMR2 = 0x0000;
PR2 = 0x0100;
MC.TimerInitalized = true;
}
// Setup OC5 (pin 10) in PWM mode, with Timer2 as timebase
OC5CON = 0x8006; // OC32 = 0, OCTSEL=0, OCM=6
OC5RS = 0x0000;
OC5R = 0x0000;
#else
// If we are not using PWM for pin 11, then just do digital
digitalWrite(11, LOW);
#endif
#else
#error "This chip is not supported!"
#endif
#if !defined(PIC32_USE_PIN9_FOR_M1_PWM) && !defined(PIC32_USE_PIN10_FOR_M1_PWM)
pinMode(11, OUTPUT);
#endif
}
inline void setPWM1(uint8_t s) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer2A on PB3 (Arduino pin #11)
OCR2A = s;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 11 is now PB5 (OC1A)
OCR1A = s;
#elif defined(__PIC32MX__)
#if defined(PIC32_USE_PIN9_FOR_M1_PWM)
// Set the OC4 (pin 9) PMW duty cycle from 0 to 255
OC4RS = s;
#elif defined(PIC32_USE_PIN10_FOR_M1_PWM)
// Set the OC5 (pin 10) PMW duty cycle from 0 to 255
OC5RS = s;
#else
// If we are not doing PWM output for M1, then just use on/off
if (s > 127)
{
digitalWrite(11, HIGH);
}
else
{
digitalWrite(11, LOW);
}
#endif
#else
#error "This chip is not supported!"
#endif
}
inline void initPWM2(uint8_t freq) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer2B (pin 3)
TCCR2A |= _BV(COM2B1) | _BV(WGM20) | _BV(WGM21); // fast PWM, turn on oc2b
TCCR2B = freq & 0x7;
OCR2B = 0;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 3 is now PE5 (OC3C)
TCCR3A |= _BV(COM1C1) | _BV(WGM10); // fast PWM, turn on oc3c
TCCR3B = (freq & 0x7) | _BV(WGM12);
OCR3C = 0;
#elif defined(__PIC32MX__)
if (!MC.TimerInitalized)
{ // Set up Timer2 for 80MHz counting fro 0 to 256
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
TMR2 = 0x0000;
PR2 = 0x0100;
MC.TimerInitalized = true;
}
// Setup OC1 (pin3) in PWM mode, with Timer2 as timebase
OC1CON = 0x8006; // OC32 = 0, OCTSEL=0, OCM=6
OC1RS = 0x0000;
OC1R = 0x0000;
#else
#error "This chip is not supported!"
#endif
pinMode(3, OUTPUT);
}
inline void setPWM2(uint8_t s) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer2A on PB3 (Arduino pin #11)
OCR2B = s;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 11 is now PB5 (OC1A)
OCR3C = s;
#elif defined(__PIC32MX__)
// Set the OC1 (pin3) PMW duty cycle from 0 to 255
OC1RS = s;
#else
#error "This chip is not supported!"
#endif
}
inline void initPWM3(uint8_t freq) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer0A / PD6 (pin 6)
TCCR0A |= _BV(COM0A1) | _BV(WGM00) | _BV(WGM01); // fast PWM, turn on OC0A
//TCCR0B = freq & 0x7;
OCR0A = 0;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 6 is now PH3 (OC4A)
TCCR4A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc4a
TCCR4B = (freq & 0x7) | _BV(WGM12);
//TCCR4B = 1 | _BV(WGM12);
OCR4A = 0;
#elif defined(__PIC32MX__)
if (!MC.TimerInitalized)
{ // Set up Timer2 for 80MHz counting fro 0 to 256
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
TMR2 = 0x0000;
PR2 = 0x0100;
MC.TimerInitalized = true;
}
// Setup OC3 (pin 6) in PWM mode, with Timer2 as timebase
OC3CON = 0x8006; // OC32 = 0, OCTSEL=0, OCM=6
OC3RS = 0x0000;
OC3R = 0x0000;
#else
#error "This chip is not supported!"
#endif
pinMode(6, OUTPUT);
}
inline void setPWM3(uint8_t s) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer0A on PB3 (Arduino pin #6)
OCR0A = s;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 6 is now PH3 (OC4A)
OCR4A = s;
#elif defined(__PIC32MX__)
// Set the OC3 (pin 6) PMW duty cycle from 0 to 255
OC3RS = s;
#else
#error "This chip is not supported!"
#endif
}
inline void initPWM4(uint8_t freq) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer0B / PD5 (pin 5)
TCCR0A |= _BV(COM0B1) | _BV(WGM00) | _BV(WGM01); // fast PWM, turn on oc0a
//TCCR0B = freq & 0x7;
OCR0B = 0;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 5 is now PE3 (OC3A)
TCCR3A |= _BV(COM1A1) | _BV(WGM10); // fast PWM, turn on oc3a
TCCR3B = (freq & 0x7) | _BV(WGM12);
//TCCR4B = 1 | _BV(WGM12);
OCR3A = 0;
#elif defined(__PIC32MX__)
if (!MC.TimerInitalized)
{ // Set up Timer2 for 80MHz counting fro 0 to 256
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
TMR2 = 0x0000;
PR2 = 0x0100;
MC.TimerInitalized = true;
}
// Setup OC2 (pin 5) in PWM mode, with Timer2 as timebase
OC2CON = 0x8006; // OC32 = 0, OCTSEL=0, OCM=6
OC2RS = 0x0000;
OC2R = 0x0000;
#else
#error "This chip is not supported!"
#endif
pinMode(5, OUTPUT);
}
inline void setPWM4(uint8_t s) {
#if defined(__AVR_ATmega8__) || \
defined(__AVR_ATmega48__) || \
defined(__AVR_ATmega88__) || \
defined(__AVR_ATmega168__) || \
defined(__AVR_ATmega328P__)
// use PWM from timer0A on PB3 (Arduino pin #6)
OCR0B = s;
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// on arduino mega, pin 6 is now PH3 (OC4A)
OCR3A = s;
#elif defined(__PIC32MX__)
// Set the OC2 (pin 5) PMW duty cycle from 0 to 255
OC2RS = s;
#else
#error "This chip is not supported!"
#endif
}
AF_DCMotor::AF_DCMotor(uint8_t num, uint8_t freq) {
motornum = num;
pwmfreq = freq;
MC.enable();
switch (num) {
case 1:
latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B); // set both motor pins to 0
MC.latch_tx();
initPWM1(freq);
break;
case 2:
latch_state &= ~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // set both motor pins to 0
MC.latch_tx();
initPWM2(freq);
break;
case 3:
latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B); // set both motor pins to 0
MC.latch_tx();
initPWM3(freq);
break;
case 4:
latch_state &= ~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // set both motor pins to 0
MC.latch_tx();
initPWM4(freq);
break;
}
}
void AF_DCMotor::run(uint8_t cmd) {
uint8_t a, b;
switch (motornum) {
case 1:
a = MOTOR1_A; b = MOTOR1_B; break;
case 2:
a = MOTOR2_A; b = MOTOR2_B; break;
case 3:
a = MOTOR3_A; b = MOTOR3_B; break;
case 4:
a = MOTOR4_A; b = MOTOR4_B; break;
default:
return;
}
switch (cmd) {
case FORWARD:
latch_state |= _BV(a);
latch_state &= ~_BV(b);
MC.latch_tx();
break;
case BACKWARD:
latch_state &= ~_BV(a);
latch_state |= _BV(b);
MC.latch_tx();
break;
case RELEASE:
latch_state &= ~_BV(a); // A and B both low
latch_state &= ~_BV(b);
MC.latch_tx();
break;
}
}
void AF_DCMotor::setSpeed(uint8_t speed) {
switch (motornum) {
case 1:
setPWM1(speed); break;
case 2:
setPWM2(speed); break;
case 3:
setPWM3(speed); break;
case 4:
setPWM4(speed); break;
}
}
/******************************************
STEPPERS
******************************************/
AF_Stepper::AF_Stepper(uint16_t steps, uint8_t num) {
MC.enable();
revsteps = steps;
steppernum = num;
currentstep = 0;
if (steppernum == 1) {
latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B) &
~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // all motor pins to 0
MC.latch_tx();
// enable both H bridges
pinMode(11, OUTPUT);
pinMode(3, OUTPUT);
digitalWrite(11, HIGH);
digitalWrite(3, HIGH);
// use PWM for microstepping support
initPWM1(STEPPER1_PWM_RATE);
initPWM2(STEPPER1_PWM_RATE);
setPWM1(255);
setPWM2(255);
} else if (steppernum == 2) {
latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B) &
~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // all motor pins to 0
MC.latch_tx();
// enable both H bridges
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
// use PWM for microstepping support
// use PWM for microstepping support
initPWM3(STEPPER2_PWM_RATE);
initPWM4(STEPPER2_PWM_RATE);
setPWM3(255);
setPWM4(255);
}
}
void AF_Stepper::setSpeed(uint16_t rpm) {
usperstep = 60000000 / ((uint32_t)revsteps * (uint32_t)rpm);
steppingcounter = 0;
}
void AF_Stepper::release(void) {
if (steppernum == 1) {
latch_state &= ~_BV(MOTOR1_A) & ~_BV(MOTOR1_B) &
~_BV(MOTOR2_A) & ~_BV(MOTOR2_B); // all motor pins to 0
MC.latch_tx();
} else if (steppernum == 2) {
latch_state &= ~_BV(MOTOR3_A) & ~_BV(MOTOR3_B) &
~_BV(MOTOR4_A) & ~_BV(MOTOR4_B); // all motor pins to 0
MC.latch_tx();
}
}
void AF_Stepper::step(uint16_t steps, uint8_t dir, uint8_t style) {
uint32_t uspers = usperstep;
uint8_t ret = 0;
if (style == INTERLEAVE) {
uspers /= 2;
}
else if (style == MICROSTEP) {
uspers /= MICROSTEPS;
steps *= MICROSTEPS;
#ifdef MOTORDEBUG
Serial.print("steps = "); Serial.println(steps, DEC);
#endif
}
while (steps--) {
ret = onestep(dir, style);
delay(uspers/1000); // in ms
steppingcounter += (uspers % 1000);
if (steppingcounter >= 1000) {
delay(1);
steppingcounter -= 1000;
}
}
if (style == MICROSTEP) {
while ((ret != 0) && (ret != MICROSTEPS)) {
ret = onestep(dir, style);
delay(uspers/1000); // in ms
steppingcounter += (uspers % 1000);
if (steppingcounter >= 1000) {
delay(1);
steppingcounter -= 1000;
}
}
}
}
uint8_t AF_Stepper::onestep(uint8_t dir, uint8_t style) {
uint8_t a, b, c, d;
uint8_t ocrb, ocra;
ocra = ocrb = 255;
if (steppernum == 1) {
a = _BV(MOTOR1_A);
b = _BV(MOTOR2_A);
c = _BV(MOTOR1_B);
d = _BV(MOTOR2_B);
} else if (steppernum == 2) {
a = _BV(MOTOR3_A);
b = _BV(MOTOR4_A);
c = _BV(MOTOR3_B);
d = _BV(MOTOR4_B);
} else {
return 0;
}
// next determine what sort of stepping procedure we're up to
if (style == SINGLE) {
if ((currentstep/(MICROSTEPS/2)) % 2) { // we're at an odd step, weird
if (dir == FORWARD) {
currentstep += MICROSTEPS/2;
}
else {
currentstep -= MICROSTEPS/2;
}
} else { // go to the next even step
if (dir == FORWARD) {
currentstep += MICROSTEPS;
}
else {
currentstep -= MICROSTEPS;
}
}
} else if (style == DOUBLE) {
if (! (currentstep/(MICROSTEPS/2) % 2)) { // we're at an even step, weird
if (dir == FORWARD) {
currentstep += MICROSTEPS/2;
} else {
currentstep -= MICROSTEPS/2;
}
} else { // go to the next odd step
if (dir == FORWARD) {
currentstep += MICROSTEPS;
} else {
currentstep -= MICROSTEPS;
}
}
} else if (style == INTERLEAVE) {
if (dir == FORWARD) {
currentstep += MICROSTEPS/2;
} else {
currentstep -= MICROSTEPS/2;
}
}
if (style == MICROSTEP) {
if (dir == FORWARD) {
currentstep++;
} else {
// BACKWARDS
currentstep--;
}
currentstep += MICROSTEPS*4;
currentstep %= MICROSTEPS*4;
ocra = ocrb = 0;
if ( (currentstep >= 0) && (currentstep < MICROSTEPS)) {
ocra = microstepcurve[MICROSTEPS - currentstep];
ocrb = microstepcurve[currentstep];
} else if ( (currentstep >= MICROSTEPS) && (currentstep < MICROSTEPS*2)) {
ocra = microstepcurve[currentstep - MICROSTEPS];
ocrb = microstepcurve[MICROSTEPS*2 - currentstep];
} else if ( (currentstep >= MICROSTEPS*2) && (currentstep < MICROSTEPS*3)) {
ocra = microstepcurve[MICROSTEPS*3 - currentstep];
ocrb = microstepcurve[currentstep - MICROSTEPS*2];
} else if ( (currentstep >= MICROSTEPS*3) && (currentstep < MICROSTEPS*4)) {
ocra = microstepcurve[currentstep - MICROSTEPS*3];
ocrb = microstepcurve[MICROSTEPS*4 - currentstep];
}
}
currentstep += MICROSTEPS*4;
currentstep %= MICROSTEPS*4;
#ifdef MOTORDEBUG
Serial.print("current step: "); Serial.println(currentstep, DEC);
Serial.print(" pwmA = "); Serial.print(ocra, DEC);
Serial.print(" pwmB = "); Serial.println(ocrb, DEC);
#endif
if (steppernum == 1) {
setPWM1(ocra);
setPWM2(ocrb);
} else if (steppernum == 2) {
setPWM3(ocra);
setPWM4(ocrb);
}
// release all
latch_state &= ~a & ~b & ~c & ~d; // all motor pins to 0
//Serial.println(step, DEC);
if (style == MICROSTEP) {
if ((currentstep >= 0) && (currentstep < MICROSTEPS))
latch_state |= a | b;
if ((currentstep >= MICROSTEPS) && (currentstep < MICROSTEPS*2))
latch_state |= b | c;
if ((currentstep >= MICROSTEPS*2) && (currentstep < MICROSTEPS*3))
latch_state |= c | d;
if ((currentstep >= MICROSTEPS*3) && (currentstep < MICROSTEPS*4))
latch_state |= d | a;
} else {
switch (currentstep/(MICROSTEPS/2)) {
case 0:
latch_state |= a; // energize coil 1 only
break;
case 1:
latch_state |= a | b; // energize coil 1+2
break;
case 2:
latch_state |= b; // energize coil 2 only
break;
case 3:
latch_state |= b | c; // energize coil 2+3
break;
case 4:
latch_state |= c; // energize coil 3 only
break;
case 5:
latch_state |= c | d; // energize coil 3+4
break;
case 6:
latch_state |= d; // energize coil 4 only
break;
case 7:
latch_state |= d | a; // energize coil 1+4
break;
}
}
MC.latch_tx();
return currentstep;
}

復制代碼

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
1、安裝庫：IDE—工具—管理庫—搜索“Servo”—安裝
2、實驗之八：測試M1M2電機
*/
#include <AFMotor.h>
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
void setup() {
Serial.begin(9600);
Serial.println("測試M1M2電機!");
// turn on motor
motor1.setSpeed(200);
motor2.setSpeed(200);
motor1.run(RELEASE);
motor2.run(RELEASE);
}
void loop() {
uint8_t i;
Serial.println("正轉");
motor1.run(FORWARD);
motor2.run(FORWARD);
for (i = 0; i < 255; i++) {
motor1.setSpeed(i);
motor2.setSpeed(i);
delay(10);
}
for (i = 255; i != 0; i--) {
motor1.setSpeed(i);
motor2.setSpeed(i);
delay(10);
}
Serial.println("反轉");
motor1.run(BACKWARD);
motor2.run(BACKWARD);
for (i = 0; i < 255; i++) {
motor1.setSpeed(i);
motor2.setSpeed(i);
delay(10);
}
for (i = 255; i != 0; i--) {
motor1.setSpeed(i);
motor2.setSpeed(i);
delay(10);
}
Serial.println("斷電一秒");
motor1.run(RELEASE);
motor2.run(RELEASE);
delay(1000);
}

復制代碼

/*
【Arduino】168種傳感器模塊系列實驗（資料+代碼+圖形+仿真）
實驗一百七十：L293D四路電機驅動板 motor control shield 馬達板
Adafruit Motor Shield模塊 Arduino AFMotor 電機擴展板
1、安裝庫：百度搜索“AFMotor庫”— 下載 — 拷貝到Arduino-libraries 文件夾中
2、實驗之九：測試M1M2M3M4電機前進與后退
*/
#include <AFMotor.h>
// 創(chuàng)建對象
AF_DCMotor motor1(1);
AF_DCMotor motor2(2);
AF_DCMotor motor3(3);
AF_DCMotor motor4(4);
// 主程序開始
void setup() {
}
void loop() {
motor1.setSpeed(200);
motor1.run(FORWARD);
motor2.setSpeed(200);
motor2.run(FORWARD);
motor3.setSpeed(200);
motor3.run(FORWARD);
motor4.setSpeed(200);
motor4.run(FORWARD);
delay(2000);
motor1.setSpeed(0);
motor1.run(RELEASE);
motor2.setSpeed(0);
motor2.run(RELEASE);
motor3.setSpeed(0);
motor3.run(RELEASE);
motor4.setSpeed(0);
motor4.run(RELEASE);
delay(1000);
motor1.setSpeed(200);
motor1.run(BACKWARD);
motor2.setSpeed(200);
motor2.run(BACKWARD);
motor3.setSpeed(200);
motor3.run(BACKWARD);
motor4.setSpeed(200);
motor4.run(BACKWARD);
delay(2000);
motor1.setSpeed(0);
motor1.run(RELEASE);
motor2.setSpeed(0);
motor2.run(RELEASE);
motor3.setSpeed(0);
motor3.run(RELEASE);
motor4.setSpeed(0);
motor4.run(RELEASE);
delay(1000);
}

復制代碼

久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费