ระบบขับเคลื่อน

การแนะนำ

The drivetrain class controls how a robot drives and turns. A drivetrain is made of motors and wheels that work together to move the robot.

ระบบขับเคลื่อน drivetrain ไม่ใช้ เซ็นเซอร์ไจโร สำหรับการเลี้ยวตามทิศทางหรือการหมุน สามารถขับเคลื่อนไปข้างหน้าหรือถอยหลัง และเลี้ยวซ้ายหรือขวาได้ แต่ไม่สามารถเลี้ยวไปยังทิศทางหรือการหมุนที่เฉพาะเจาะจงได้ สำหรับการเลี้ยวตามทิศทางและการหมุน ให้ใช้คลาส smartdrive

หน้านี้ใช้ myDrivetrain เป็นตัวอย่างชื่อระบบขับเคลื่อน โปรดแทนที่ด้วยชื่อที่คุณกำหนดเองตามต้องการ

คลาสที่สืบทอดมา

คลาส drivetrain ทำหน้าที่เป็นคลาสพื้นฐานสำหรับคลาสที่สืบทอดต่อไปนี้:

• smartdrive - สร้างระบบขับเคลื่อนที่รองรับเซ็นเซอร์ไจโร

ตัวสร้างคลาส

1 - สร้างระบบขับเคลื่อนโดยใช้กลุ่มมอเตอร์ motor_group วัตถุสำหรับด้านซ้ายและด้านขวา

drivetrain(
    motor_group      &l,
    motor_group      &r,
    double           wheelTravel = 320,
    double           trackWidth = 320,
    double           wheelBase = 130,
    distanceUnits    unit = mm,
    double           externalGearRatio = 1.0 );

2 - สร้างระบบขับเคลื่อนโดยใช้มอเตอร์ motor ที่มีอยู่สำหรับด้านซ้ายและด้านขวา

drivetrain(
    motor            &l,
    motor            &r,
    double           wheelTravel = 320,
    double           trackWidth = 320,
    double           wheelBase = 130,
    distanceUnits    unit = mm,
    double           externalGearRatio = 1.0 );

ตัวทำลายคลาส

ทำลายอ็อบเจ็กต์ drivetrain และปล่อยทรัพยากรที่เกี่ยวข้อง

virtual ~drivetrain();

พารามิเตอร์

พารามิเตอร์	พิมพ์	คำอธิบาย
&l / &r	motor_group / motor	มอเตอร์ซ้ายและขวา หรือกลุ่มมอเตอร์ พารามิเตอร์ทั้งสองต้องใช้ประเภทเดียวกัน: อย่างใดอย่างหนึ่งคือ วัตถุ motor_group สองตัวที่ หรือวัตถุ motor สองตัวที่เป็น
wheelTravel	double	เส้นรอบวงของล้อระบบขับเคลื่อน ค่าเริ่มต้นคือ 320
trackWidth	double	ระยะห่างระหว่างล้อซ้ายและล้อขวา ค่าเริ่มต้นคือ 320
wheelBase	double	ระยะห่างระหว่างล้อหน้าและล้อหลัง ค่าเริ่มต้นคือ 130
unit	distanceUnits	หน่วยสำหรับ wheelTravel, trackWidthและ wheelBaseคือ mm (ค่าเริ่มต้น) หรือ inches
externalGearRatio	double	อัตราทดเกียร์ที่ใช้ปรับระยะทางการขับเคลื่อนหากมีการใช้เกียร์ ค่าเริ่มต้นคือ 1.0

ตัวอย่าง

// Create the left and right motor objects.
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the drivetrain object.
drivetrain myDrivetrain = drivetrain(
    leftMotor,  // left motor
    rightMotor, // right motor
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

ฟังก์ชันสมาชิก

คลาส drivetrain ประกอบด้วยฟังก์ชันสมาชิกต่อไปนี้:

การกระทำ - ขยับและหมุนหุ่นยนต์

• drive - เคลื่อนหุ่นยนต์ไปข้างหน้าหรือถอยหลังตลอดไป

• driveFor - เคลื่อนหุ่นยนต์ไปข้างหน้าหรือถอยหลังตามระยะทางที่กำหนด

• turn - หมุนหุ่นยนต์ไปทางซ้ายหรือขวาตลอดไป

• turnFor - หมุนหุ่นยนต์ไปทางซ้ายหรือขวาตามจำนวนองศาหรือรอบที่กำหนด

• stop - หยุดการเคลื่อนที่ของหุ่นยนต์

การตั้งค่า - ปรับการตั้งค่าระบบขับเคลื่อน

• setDriveVelocity - บอกหุ่นยนต์ว่าจะขับเร็วแค่ไหน

• setTurnVelocity - บอกหุ่นยนต์ว่าจะเลี้ยวเร็วแค่ไหน

• setStopping - บอกวิธีที่หุ่นยนต์จะหยุดเคลื่อนที่: โดยการเบรก การปล่อยให้ไหลไปเอง หรือการหยุดนิ่ง

• setTimeout - ตั้งค่าระยะเวลาที่หุ่นยนต์จะพยายามทำการเคลื่อนไหวให้เสร็จสิ้น

ค่าต่างๆ - ตรวจสอบสถานะการเคลื่อนไหว

• isDone - ส่งคืนค่าบูลีนว่าหุ่นยนต์เคลื่อนที่เสร็จแล้วหรือไม่

• isMoving - ส่งคืนว่าหุ่นยนต์กำลังเคลื่อนที่หรือไม่ ในรูปแบบค่าบูลีน

• velocity - ส่งคืนความเร็วในการขับเคลื่อนของหุ่นยนต์

• current - ส่งคืนกระแสไฟฟ้าที่ระบบขับเคลื่อนใช้

• power - ส่งคืนอัตราการใช้พลังงานของระบบขับเคลื่อน

• torque - ส่งคืนค่าแรงบิดที่ระบบขับเคลื่อนใช้

• efficiency - ส่งคืนประสิทธิภาพการใช้พลังงานของระบบขับเคลื่อน

• temperature - ส่งคืนอุณหภูมิของระบบขับเคลื่อน

• voltage - ส่งคืนแรงดันไฟฟ้าของระบบขับเคลื่อน

ก่อนเรียกใช้ฟังก์ชันสมาชิก drivetrain ใดๆ จะต้องสร้างอ็อบเจ็กต์ drivetrain ก่อน

/* This constructor is required when using VS Code.
Drivetrain configuration is generated automatically
in VEXcode using the Device Menu. Replace the values
as needed. */

// Create the left and right motor objects.
motor leftMotor = motor(PORT1, false);
motor rightMotor = motor(PORT9, true);

// Create the drivetrain object.
drivetrain myDrivetrain = drivetrain(
    leftMotor,  // left motor
    rightMotor, // right motor
    259.34,     // wheelTravel
    320,        // trackWidth
    40,         // wheelBase
    mm,         // unit
    1.0 );      // externalGearRatio

การกระทำ

ขับ

คำสั่ง drive จะทำให้หุ่นยนต์เคลื่อนที่ไปข้างหน้าหรือถอยหลังอย่างไม่มีที่สิ้นสุด หุ่นยนต์จะเคลื่อนที่ต่อไปจนกว่าจะได้รับคำสั่งอื่น เช่น การเลี้ยวหรือการหยุด

Available Functions

1 - ขับเคลื่อนโดยใช้ความเร็วในการขับเคลื่อนปัจจุบัน

void drive(
    directionType dir );

2 - ขับเคลื่อนด้วยความเร็วที่กำหนด

void drive(
    directionType dir,
    double        velocity,
    velocityUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
dir	directionType	ทิศทางการเคลื่อนที่ของหุ่นยนต์: forward หรือ reverse
velocity	double	ความเร็วในการขับเคลื่อนสามารถกำหนดได้ตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาทีเมื่อใช้ rpm rpmหรือตั้งแต่ 0 ถึง 720 องศาต่อวินาทีเมื่อใช้ dps dpsหากไม่ได้ระบุความเร็ว หุ่นยนต์จะขับเคลื่อนด้วยความเร็วในการขับเคลื่อนปัจจุบัน
units	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• drive คือคำสั่งที่ไม่รอ โปรเจกต์จะรันโค้ดบรรทัดถัดไปทันที

• หุ่นยนต์จะเคลื่อนที่ต่อไปจนกว่าจะมีการเรียก stop หรือฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนอื่นทำงาน

• isDone และ isMoving ไม่ได้ใช้กับ drive เพราะ drive ไม่มีระยะเป้าหมาย

Examples

// Drive forward and back.
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.drive(reverse, 25, rpm);
wait(2, seconds);
myDrivetrain.stop();

ไดรฟ์ฟอร์

คำสั่ง driveFor จะเคลื่อนหุ่นยนต์ไปข้างหน้าหรือถอยหลังเป็นระยะทางที่กำหนด โครงการจะรอจนกว่าหุ่นยนต์จะหยุดเคลื่อนที่ก่อนที่โค้ดบรรทัดถัดไปจะทำงาน

Available Functions

1 - ขับเคลื่อนไปในทิศทางที่กำหนดเป็นระยะทางโดยใช้ความเร็วในการขับเคลื่อนปัจจุบัน

bool driveFor(
    directionType dir,
    double        distance,
    distanceUnits units,
    bool          waitForCompletion = true );

2 - ขับเคลื่อนไปในทิศทางตามค่าระยะทางโดยใช้ความเร็วในการขับเคลื่อนปัจจุบัน

bool driveFor(
    double        distance,
    distanceUnits units,
    bool          waitForCompletion = true );

3 - ขับเคลื่อนไปในทิศทางตามค่าระยะทางด้วยความเร็วที่กำหนด

bool driveFor(
    double        distance,
    distanceUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

4 - ขับเคลื่อนไปในทิศทางที่กำหนด เป็นระยะทางที่กำหนด ด้วยความเร็วที่กำหนด

bool driveFor(
    directionType dir,
    double        distance,
    distanceUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
dir	directionType	ทิศทางการเคลื่อนที่ของหุ่นยนต์: forward หรือ reverse
distance	double	ระยะทางที่หุ่นยนต์ขับเคลื่อนไปได้
units	distanceUnits	หน่วยวัดระยะทาง: mm (มิลลิเมตร), inchesหรือ cm (เซนติเมตร)
velocity	double	ความเร็วในการขับเคลื่อนสามารถกำหนดได้ตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาทีเมื่อใช้ rpm rpmหรือตั้งแต่ 0 ถึง 720 องศาต่อวินาทีเมื่อใช้ dps dpsหากไม่ได้ระบุความเร็ว หุ่นยนต์จะขับเคลื่อนด้วยความเร็วในการขับเคลื่อนปัจจุบัน
units_v	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)
waitForCompletion	bool	true (ค่าเริ่มต้น) จะทำให้โปรเจ็กต์รอจนกว่าหุ่นยนต์จะเคลื่อนที่เสร็จก่อนที่โค้ดบรรทัดถัดไปจะทำงาน false จะทำให้โค้ดบรรทัดถัดไปทำงานทันที

Return Values

ส่งคืนค่าบูลีนว่าหุ่นยนต์ไปถึงระยะทางเป้าหมายหรือไม่

• true - หุ่นยนต์ไปถึงระยะทางเป้าหมายแล้ว

• false - หุ่นยนต์ไม่ได้ทำการเคลื่อนไหวจนเสร็จสิ้น หรือฟังก์ชันส่งค่ากลับก่อนที่การเคลื่อนไหวจะเสร็จสมบูรณ์ เนื่องจาก waitForCompletion ถูกตั้งค่าเป็น false

Notes

• การเรียกใช้ฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนอื่นในขณะที่ driveFor กำลังทำงานอยู่ จะขัดจังหวะการเคลื่อนที่ปัจจุบัน

• driveFor ใช้ระยะทางเป้าหมาย ดังนั้น isDone และ isMoving สามารถใช้ร่วมกับมันได้

Examples

// Drive 200 mm, then back 200 mm.
myDrivetrain.driveFor(forward, 200, mm);
myDrivetrain.driveFor(reverse, 200, mm);

เปลี่ยน

turn จะหมุนหุ่นยนต์ไปทางซ้ายหรือขวาเรื่อยๆ จนกว่าจะได้รับคำสั่งอื่น เช่น ขับเคลื่อนหรือหยุด

Available Functions

1 - หมุนโดยใช้ความเร็วในการหมุนปัจจุบัน

void turn(
    turnType dir );

2 - หมุนด้วยความเร็วที่กำหนด

void turn(
    turnType     dir,
    double       velocity,
    velocityUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
dir	turnType	ทิศทางที่หุ่นยนต์หมุน: left หรือ right
velocity	double	ความเร็วในการหมุนสามารถกำหนดได้ตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาที เมื่อใช้ rpm rpmหรือตั้งแต่ 0 ถึง 720 องศาต่อวินาที เมื่อใช้ dps dpsหากไม่ได้ระบุความเร็ว หุ่นยนต์จะหมุนด้วยความเร็วในการหมุนปัจจุบัน
units	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• turn คือไม่รอ การทำงานของโปรเจ็กต์จะเริ่มบรรทัดโค้ดถัดไปทันที

• หุ่นยนต์จะหมุนต่อไปจนกว่าจะมีการเรียก stop หรือฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนอื่นทำงาน

• isDone และ isMoving ไม่ได้ใช้กับ turn เพราะ turn ไม่มีมุมเป้าหมาย

Examples

// Turn right, then left, then stop.
myDrivetrain.turn(right);
wait(2, seconds);
myDrivetrain.turn(left);
wait(2, seconds);
myDrivetrain.stop();

เทิร์นฟอร์

turnFor หมุนหุ่นยนต์ไปทางซ้ายหรือขวาเป็นจำนวนองศา รอบ หรือหน่วยดิบที่กำหนด การหมุนจะสัมพันธ์กับตำแหน่งปัจจุบันของหุ่นยนต์ โครงการจะรอจนกว่าหุ่นยนต์จะหมุนเสร็จก่อนที่โค้ดบรรทัดถัดไปจะทำงาน

Available Functions

1 - หมุนตามมุมที่กำหนดโดยใช้ความเร็วในการหมุนปัจจุบัน

bool turnFor(
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

2 - เลี้ยวไปในทิศทางที่กำหนดด้วยมุมที่กำหนด โดยใช้ความเร็วในการเลี้ยวปัจจุบัน

bool turnFor(
    turnType      dir,
    double        angle,
    rotationUnits units,
    bool          waitForCompletion = true );

3 - หมุนตามมุมที่กำหนดด้วยความเร็วที่กำหนด

bool turnFor(
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

4 - เลี้ยวไปในทิศทางที่กำหนดด้วยมุมและความเร็วที่กำหนด

bool turnFor(
    turnType      dir,
    double        angle,
    rotationUnits units,
    double        velocity,
    velocityUnits units_v,
    bool          waitForCompletion = true );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
dir	turnType	ทิศทางที่หุ่นยนต์หมุน: left หรือ right
angle	double	ระยะการหมุนของหุ่นยนต์
units	rotationUnits	หน่วยการหมุน: deg (องศา), rev (รอบ) หรือ raw (หน่วยดิบ) หนึ่งรอบเท่ากับ 360 องศา
velocity	double	ความเร็วในการหมุนสามารถกำหนดได้ตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาที เมื่อใช้ rpm rpmหรือตั้งแต่ 0 ถึง 720 องศาต่อวินาที เมื่อใช้ dps dpsหากไม่ได้ระบุความเร็ว หุ่นยนต์จะหมุนด้วยความเร็วในการหมุนปัจจุบัน
units_v	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)
waitForCompletion	bool	true (ค่าเริ่มต้น) จะทำให้โปรเจ็กต์รอจนกว่าหุ่นยนต์จะหมุนเสร็จก่อนที่โค้ดบรรทัดถัดไปจะทำงาน false จะทำให้โค้ดบรรทัดถัดไปทำงานทันที

Return Values

ส่งคืนค่าบูลีนว่าหุ่นยนต์ทำมุมได้ตามเป้าหมายหรือไม่

• true - หุ่นยนต์ทำมุมได้ตามเป้าหมายแล้ว

• false - หุ่นยนต์ไม่ได้ทำการเลี้ยวเสร็จสิ้น หรือฟังก์ชันส่งค่ากลับก่อนที่การเลี้ยวจะเสร็จสมบูรณ์ เนื่องจาก waitForCompletion ถูกตั้งค่าเป็น false

Notes

• การเรียกใช้ฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนอื่นในขณะที่ฟังก์ชัน turnFor กำลังทำงานอยู่ จะขัดจังหวะการเคลื่อนที่ปัจจุบัน

• turnFor ใช้มุมเป้าหมาย ดังนั้น isDone และ isMoving สามารถใช้ร่วมกับมันได้

Examples

// Turn right, then left.
myDrivetrain.turnFor(right, 90, degrees);
wait(1, seconds);
myDrivetrain.turnFor(left, 90, degrees);

หยุด

คำสั่ง stop จะหยุดการเคลื่อนที่ของหุ่นยนต์ หากมีการกำหนดโหมดการหยุดไว้ โหมดนั้นจะควบคุมวิธีการหยุดของหุ่นยนต์สำหรับการเรียกใช้ฟังก์ชันนี้

Available Functions

1 - หยุดระบบขับเคลื่อนโดยใช้โหมดการหยุดปัจจุบัน

void stop();

2 - หยุดระบบขับเคลื่อนโดยใช้โหมดการหยุดที่กำหนดไว้

void stop(
    brakeType mode );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
mode	brakeType	วิธีที่หุ่นยนต์จะหยุด: brake - หยุดทันที coast - ชะลอความเร็วจนหยุด hold - หยุดทันทีและคงตำแหน่งล้อไว้

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Examples

// Drive forward, then coast to a stop.
myDrivetrain.setDriveVelocity(100, percent);
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.stop(coast);

ตัวกลายพันธุ์

ตั้งค่าความเร็วในการขับขี่

คำสั่ง setDriveVelocity จะบอกหุ่นยนต์ว่าควรขับเร็วแค่ไหน โดยเปอร์เซ็นต์ที่สูงขึ้นจะทำให้หุ่นยนต์ขับเร็วขึ้น และเปอร์เซ็นต์ที่ต่ำลงจะทำให้หุ่นยนต์ขับช้าลง

ทุกโครงการเริ่มต้นด้วยการที่หุ่นยนต์ขับเคลื่อนด้วยความเร็ว 50% เป็นค่าเริ่มต้น

หมายเหตุ: ความเร็วที่สูงขึ้นจะทำให้หุ่นยนต์ขับเคลื่อนได้เร็วขึ้น แต่ความแม่นยำอาจลดลง ความเร็วที่ต่ำลงจะทำให้หุ่นยนต์ขับเคลื่อนได้ช้าลง แต่ความแม่นยำอาจเพิ่มขึ้น

Available Functions

void setDriveVelocity(
  double velocity,
  velocityUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
velocity	double	ความเร็วในการขับเคลื่อนตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาทีเมื่อใช้ rpm, หรือตั้งแต่ 0 ถึง 720 องศาต่อวินาทีเมื่อใช้ dps
units	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• ความเร็วในการขับเคลื่อนจะถูกนำไปใช้โดยฟังก์ชันการเคลื่อนที่ของระบบส่งกำลังในภายหลัง เว้นแต่จะมีการระบุความเร็วที่เฉพาะเจาะจงไว้ในคำสั่งเรียกใช้ฟังก์ชัน

Examples

// Drive forward, then coast to a stop.
myDrivetrain.setDriveVelocity(100, percent);
myDrivetrain.drive(forward);
wait(2, seconds);
myDrivetrain.stop(coast);

ตั้งค่าความเร็วในการเลี้ยว

setTurnVelocity บอกหุ่นยนต์ว่าควรเลี้ยวเร็วแค่ไหน เปอร์เซ็นต์ที่สูงขึ้นจะทำให้หุ่นยนต์เลี้ยวเร็วขึ้น และเปอร์เซ็นต์ที่ต่ำลงจะทำให้หุ่นยนต์เลี้ยวช้าลง

ทุกโครงการเริ่มต้นด้วยการที่หุ่นยนต์หมุนด้วยความเร็ว 50% เป็นค่าเริ่มต้น

หมายเหตุ: ความเร็วที่สูงขึ้นจะทำให้หุ่นยนต์เลี้ยวได้เร็วขึ้น แต่ความแม่นยำอาจลดลง ความเร็วที่ต่ำลงจะทำให้หุ่นยนต์เลี้ยวได้ช้าลง แต่ความแม่นยำอาจเพิ่มขึ้น

Available Functions

void setTurnVelocity(
  double velocity,
  velocityUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
velocity	double	ความเร็วในการหมุนตั้งแต่ 0% ถึง 100% เมื่อใช้ velocityUnits::pct, ตั้งแต่ 0 ถึง 120 รอบต่อนาทีเมื่อใช้ rpm, หรือตั้งแต่ 0 ถึง 720 องศาต่อวินาทีเมื่อใช้ dps
units	velocityUnits	หน่วยความเร็ว: velocityUnits::pct (เปอร์เซ็นต์), rpm (รอบต่อนาที), หรือ dps (องศาต่อวินาที)

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• ความเร็วในการเลี้ยวจะถูกนำไปใช้โดยฟังก์ชันการเลี้ยวของระบบขับเคลื่อนในภายหลัง เว้นแต่จะมีการระบุความเร็วที่เฉพาะเจาะจงไว้ในคำสั่งเรียกใช้ฟังก์ชัน

Examples

// Try default, slow, then fast.
myDrivetrain.turnFor(right, 360, degrees);
wait(1, seconds);
myDrivetrain.setTurnVelocity(20, percent);
myDrivetrain.turnFor(right, 360, degrees);
wait(1, seconds);
myDrivetrain.setTurnVelocity(100, percent);
myDrivetrain.turnFor(right, 360, degrees);

ตั้งค่าการหยุด

setStopping กำหนดวิธีการหยุดหุ่นยนต์: โดยการเบรก การปล่อยให้ไหลไปเอง หรือการหยุดนิ่ง

Available Functions

void setStopping(
  brakeType mode );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
mode	brakeType	วิธีที่หุ่นยนต์จะหยุด: brake - หยุดทันที coast - ชะลอความเร็วจนหยุด hold - หยุดทันทีและคงตำแหน่งล้อไว้

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• โหมดการหยุดจะถูกใช้โดยการเรียก stop ในภายหลัง เว้นแต่จะมีการระบุโหมดการหยุดเฉพาะในการเรียกฟังก์ชัน

• หากไม่ได้ใช้ฟังก์ชันนี้ หุ่นยนต์จะใช้เบรก brake เมื่อหยุด

ตั้งค่าหมดเวลา

setTimeout กำหนดระยะเวลาที่หุ่นยนต์จะพยายามทำการเคลื่อนไหวให้เสร็จสิ้น หากหุ่นยนต์ไม่สามารถทำการเคลื่อนไหวให้เสร็จสิ้นภายในเวลาที่กำหนด มันจะหยุดพยายามและไปยังบรรทัดโค้ดถัดไป ซึ่งจะช่วยป้องกันไม่ให้หุ่นยนต์ติดอยู่กับการเคลื่อนไหวใดๆ

Available Functions

void setTimeout(
  int32_t time,
  timeUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
time	int32_t	ระยะเวลาที่หุ่นยนต์สามารถพยายามทำท่าทางให้เสร็จสมบูรณ์ ค่านี้ควรเป็นจำนวนเต็มบวก
units	timeUnits	หน่วยของเวลา: sec (วินาที) หรือ msec (มิลลิวินาที)

Return Values

ฟังก์ชันนี้ไม่ส่งค่ากลับ

Notes

• การหมดเวลาจะใช้ได้เฉพาะกับฟังก์ชันระบบขับเคลื่อนที่เคลื่อนที่ไปยังเป้าหมาย เช่น driveFor และ turnFor

Examples

// Turn right after driving forward.
myDrivetrain.setTimeout(1, seconds);
myDrivetrain.driveFor(forward, 25, inches);
myDrivetrain.turnFor(right, 90, degrees);

ผู้รับ

เสร็จแล้ว

isDone จะส่งคืนค่าบูลีนว่าหุ่นยนต์เคลื่อนที่เสร็จแล้วหรือไม่ ค่านี้สามารถใช้ควบคุมจังหวะเวลาของพฤติกรรมอื่นๆ โดยอิงจากการเคลื่อนที่ของหุ่นยนต์ได้

Available Functions

bool isDone( void );

Parameters

ฟังก์ชันนี้ไม่รับพารามิเตอร์ใดๆ

Return Values

• true - หุ่นยนต์เคลื่อนที่เสร็จแล้ว

• false - หุ่นยนต์ยังคงเคลื่อนที่อยู่

Notes

• isDone ทำงานร่วมกับฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนตามเป้าหมาย เช่น driveFor และ turnFor

• isDone ไม่ได้ใช้ร่วมกับ drive หรือ turn เนื่องจากฟังก์ชันเหล่านั้นไม่ได้เคลื่อนที่ไปยังเป้าหมาย

กำลังย้าย

isMoving จะส่งคืนค่าบูลีนว่าหุ่นยนต์กำลังเคลื่อนที่หรือไม่ ค่านี้สามารถใช้ควบคุมจังหวะเวลาของพฤติกรรมอื่นๆ โดยอิงจากการเคลื่อนที่ของหุ่นยนต์ได้

Available Functions

virtual bool isMoving( void );

Parameters

ฟังก์ชันนี้ไม่รับพารามิเตอร์ใดๆ

Return Values

• true - หุ่นยนต์กำลังเคลื่อนที่

• false - หุ่นยนต์ไม่เคลื่อนที่

Notes

• isMoving ทำงานร่วมกับฟังก์ชันการเคลื่อนที่ของระบบขับเคลื่อนตามเป้าหมาย เช่น driveFor และ turnFor

• isMoving ไม่ได้ใช้ร่วมกับ drive หรือ turn เนื่องจากฟังก์ชันเหล่านั้นไม่ได้เคลื่อนที่ไปยังเป้าหมาย

ความเร็ว

ค่า velocity จะแสดงความเร็วในการขับเคลื่อนของหุ่นยนต์

สามารถแสดงค่าความเร็วเป็นเปอร์เซ็นต์ ในหน่วย rpmหรือ dpsค่าบวกหมายความว่าหุ่นยนต์กำลังเคลื่อนที่ไปข้างหน้า ค่าลบหมายความว่าหุ่นยนต์กำลังเคลื่อนที่ถอยหลัง

Available Functions

double velocity(
  velocityUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	velocityUnits	หน่วยที่จะส่งคืนความเร็วเป็น: percent, pct, rpmหรือ dps

Return Values

ส่งคืนค่าความเร็วของระบบขับเคลื่อนเป็นค่า double ในหน่วยที่เลือก

Examples

// Show velocity before and during motion.
Brain.Screen.print("Resting: %f", myDrivetrain.velocity(percent));
myDrivetrain.drive(forward, 100, velocityUnits::pct);
wait(1, seconds);
Brain.Screen.newLine();
Brain.Screen.print("Moving: %f", myDrivetrain.velocity(percent));
myDrivetrain.stop();

ปัจจุบัน

current returns how much electrical current the drivetrain is using. Current is the amount of electricity flowing through the drivetrain. It can be returned in amps (amperes) or as a percentage, depending on the unit.

ค่ากระแสไฟฟ้าที่สูงขึ้นหมายความว่าระบบขับเคลื่อนใช้กระแสไฟฟ้ามากขึ้น ซึ่งอาจเกิดขึ้นเมื่อหุ่นยนต์กำลังดันกับวัตถุหรือพยายามเคลื่อนที่เมื่อติดอยู่

สามารถใช้ตรวจสอบได้ว่าระบบขับเคลื่อนทำงานหนักเกินไปหรือไม่ขณะเคลื่อนที่ หากกระแสไฟฟ้าสูงต่อเนื่อง ระบบขับเคลื่อนอาจร้อนขึ้นหรือใช้พลังงานอย่างไม่มีประสิทธิภาพ

Available Functions

1 - ส่งคืนกระแสไฟฟ้าของระบบขับเคลื่อนในหน่วยแอมป์

double current(
    currentUnits units = currentUnits::amp );

2 - ส่งคืนกระแสไฟฟ้าของระบบขับเคลื่อนเป็นเปอร์เซ็นต์

double current(
    percentUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	currentUnits	หน่วยที่จะส่งกระแสไฟกลับ: amp
units	percentUnits	หน่วยที่จะส่งคืนกระแสไฟฟ้า: percent หรือ pct

Return Values

ส่งคืนค่ากระแสไฟฟ้าของระบบขับเคลื่อนเป็นค่า double ในหน่วยที่เลือก

พลัง

ค่า power แสดงปริมาณพลังงานที่ระบบขับเคลื่อนใช้ โดยวัดเป็นวัตต์ ค่า Power แสดงให้เห็นว่าระบบขับเคลื่อนใช้พลังงานเร็วแค่ไหน

ค่ากำลังไฟฟ้าที่สูงขึ้นหมายความว่าระบบขับเคลื่อนใช้พลังงานเร็วขึ้น ซึ่งอาจเกิดขึ้นเมื่อหุ่นยนต์กำลังดันกับวัตถุหรือพยายามเคลื่อนที่เมื่อติดอยู่

สามารถใช้สิ่งนี้เพื่อเปรียบเทียบการเคลื่อนไหวหรือตรวจสอบว่าระบบขับเคลื่อนทำงานหนักเกินไปหรือไม่ หากกำลังไฟสูงอยู่ตลอดเวลา ระบบขับเคลื่อนอาจร้อนขึ้นหรือใช้พลังงานอย่างไม่มีประสิทธิภาพมากขึ้น

Available Functions

double power(
  powerUnits units = powerUnits::watt );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	powerUnits	หน่วยพลังงาน: watt

Return Values

ส่งคืนกำลังของระบบขับเคลื่อนเป็นหน่วยวัตต์ ( double)

แรงบิด

แรงบิดแสดงให้เห็นว่าระบบส่งกำลังสามารถผลักหรือดึงได้แรงแค่ไหนในขณะที่ล้อหมุน

ค่า torque torque จะแสดงค่าแรงบิดที่ระบบส่งกำลังใช้งาน โดยวัดเป็นนิวตันเมตร (Nm) หรือนิ้วปอนด์ (InLb)

ค่าแรงบิดที่สูงขึ้นหมายความว่าระบบขับเคลื่อนกำลังผลักหรือดึงแรงขึ้น ซึ่งอาจเกิดขึ้นเมื่อหุ่นยนต์กำลังผลักกับวัตถุหรือพยายามเคลื่อนที่เมื่อติดอยู่

สามารถใช้ตรวจสอบได้ว่าระบบขับเคลื่อนทำงานหนักเกินไปหรือไม่ หรือเพื่อเปรียบเทียบว่าการเคลื่อนไหวแต่ละแบบต้องการแรงผลักมากแค่ไหน

Available Functions

double torque(
  torqueUnits units = torqueUnits::nm );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	torqueUnits	หน่วยที่ใช้ในการแสดงค่าแรงบิด: Nm (นิวตันเมตร, ค่าเริ่มต้น) หรือ InLb (นิ้วปอนด์)

Return Values

ส่งคืนค่าแรงบิดของระบบขับเคลื่อนเป็น double ในหน่วยที่เลือก

ประสิทธิภาพ

ค่าประสิทธิภาพ efficiency เป็นเปอร์เซ็นต์ตั้งแต่ 0% ถึง 100%

ประสิทธิภาพแสดงให้เห็นว่าพลังงานของระบบขับเคลื่อนถูกนำไปใช้ในการเคลื่อนที่มากน้อยเพียงใด ค่าประสิทธิภาพที่สูงขึ้นหมายความว่าพลังงานของระบบขับเคลื่อนถูกนำไปใช้ในการเคลื่อนที่มากขึ้น ค่าประสิทธิภาพที่ต่ำลงอาจเกิดขึ้นได้เมื่อระบบขับเคลื่อนทำงานหนักแต่เคลื่อนที่ได้ไม่มาก เช่น เมื่อหุ่นยนต์ติดอยู่หรือชนกับวัตถุ

สามารถใช้เพื่อเปรียบเทียบการเคลื่อนไหว หรือตรวจสอบว่าระบบขับเคลื่อนสูญเสียพลังงานไปโดยเปล่าประโยชน์ แทนที่จะนำไปใช้ในการเคลื่อนไหวหรือไม่

Available Functions

double efficiency(
  percentUnits units = percentUnits::pct );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	percentUnits	หน่วยที่จะส่งคืนประสิทธิภาพ: percent หรือ pct

Return Values

ส่งคืนค่าประสิทธิภาพระบบขับเคลื่อนเป็น double ในหน่วยที่เลือก

อุณหภูมิ

temperature จะแสดงอุณหภูมิเฉลี่ยของระบบขับเคลื่อนเป็นเปอร์เซ็นต์ ตั้งแต่ 0% ถึง 100%

อุณหภูมิแสดงให้เห็นถึงความร้อนของมอเตอร์ในระบบขับเคลื่อน อุณหภูมิที่สูงขึ้นหมายความว่ามอเตอร์กำลังร้อนขึ้นขณะทำงาน มอเตอร์ควรมีอุณหภูมิต่ำกว่า 55 องศาเซลเซียสเพื่อให้ทำงานได้อย่างเต็มประสิทธิภาพ

หากมอเตอร์ร้อนเกินไป มอเตอร์จะลดกระแสไฟฟ้าสูงสุดลงเพื่อป้องกันตัวเอง เมื่ออุณหภูมิถึง 70 องศาเซลเซียส มอเตอร์จะหยุดทำงานจนกว่าจะเย็นลง

สามารถใช้ตรวจสอบได้ว่าชุดขับเคลื่อนร้อนเกินไปหรือไม่ระหว่างการเคลื่อนไหวซ้ำๆ การใช้งานเป็นเวลานาน หรือเมื่อมีการดันกับวัตถุ

Available Functions

double temperature(
  percentUnits units );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	percentUnits	หน่วยที่จะส่งคืนอุณหภูมิ: percent หรือ pct

Return Values

ส่งคืนค่าอุณหภูมิเฉลี่ยของระบบขับเคลื่อนเป็นค่า double ในหน่วยที่เลือก

Notes

• ค่าที่ส่งคืน 50% หมายความว่าอุณหภูมิเฉลี่ยของมอเตอร์อยู่ที่ประมาณ 45°C (113°F)

• ช่วงอุณหภูมิการทำงานปกติของระบบขับเคลื่อนอยู่ที่ประมาณ 20°C (68°F) ถึง 70°C (158°F)

แรงดันไฟฟ้า

voltage ส่งคืนแรงดันไฟฟ้าของระบบขับเคลื่อน

แรงดันไฟฟ้าคือแรงดันไฟฟ้าที่จ่ายให้กับมอเตอร์ของระบบขับเคลื่อน สามารถนำค่านี้มาใช้ร่วมกับค่ากระแสไฟฟ้าและกำลังไฟฟ้าเพื่อทำความเข้าใจว่าระบบขับเคลื่อนใช้พลังงานไฟฟ้าอย่างไร

Available Functions

double voltage(
  voltageUnits units = voltageUnits::volt );

Parameters

พารามิเตอร์	พิมพ์	คำอธิบาย
units	voltageUnits	หน่วยที่ใช้ในการส่งค่าแรงดันไฟฟ้ากลับ: volt (ค่าเริ่มต้น) หรือ voltageUnits::mV. voltageUnits::mV หมายถึงมิลลิโวลต์

Return Values

ส่งคืนค่าแรงดันไฟฟ้าของระบบขับเคลื่อนเป็นค่า double ในหน่วยที่เลือก