นี่คือ GitBook hub เป็นพื้นที่สำหรับรวบรวมเอกสารและคู่มือการใช้งานสำหรับผลิตภัณฑ์ของเรา เรามุ่งเน้นที่พัฒนาและปรับปรุง model และ code ของพวกเราเพื่อนำสัตว์เลี้ยงหุ่นยนต์ไบโอนิคมาสู่โลกโปรดอ่านหมายเหตุเวอร์ชันอย่างละเอียดเพื่อกำหนดค่าหุ่นยนต์ของคุณ

หากคุณต้องการความช่วยเหลือ โปรดส่งข้อความถึง support@petoi.com หรือโพสต์บนฟอรัมของเราที่ petoi.camp.

ผลิตภัณฑ์

😼

🐶

** ดาวน์โหลดเวอร์ชันล่าสุดของ Petoi Desktop APP. **

Petoi Desktop App เป็นเครื่องมือที่ทำให้ง่ายขึ้นสำหรับเพื่อกำหนดค่าเฟิร์มแวร์ ปรับเทียบหุ่นยนต์ และออกแบบการเคลื่อนไหวที่กำหนดเองสำหรับหุ่นยนต์ โมดูลฟังก์ชันที่สำคัญคือ Firmware Uploader, Joint Calibrator และ Skill Composer.

ซอร์สโค้ดเขียนด้วย Tkinker ใน Python3 และเป็นโอเพ่นซอร์ส https://github.com/PetoiCamp/OpenCat/tree/main/pyUI.

UI.py เป็นเป็นโปรแกรมทั่วไปที่เชื่อมต่อกับส่วนอื่นทั้งหมด:

• UI.py

-> FirmwareUploader.py

-> Calibrator.py

-> SkillComposer.py

translate.py มีการองรับหลายภาษาใน UI สามารถเปลี่ยน UI เป็นภาษาที่ต้องการใช้งานได้

ก่อนเรียกใช้แอป คุณต้องใช้อะแดปเตอร์ USB ที่ให้มาหรือดองเกิลบลูทูธเพื่อเชื่อมต่อกับหุ่นยนต์ Petoi

เอ็กซีคิวเทเบิ้ลไฟล์โปรแกรม

คุณสามารถดาวน์โหลด pre-compiled executables ของแอพเดสก์ท็อปเพื่อหลีกเลี่ยงอินเทอร์เฟซการเขียนโปรแกรม

หลังจากดาวน์โหลดเวอร์ชัน Mac แล้ว คุณต้องลากลงในโฟลเดอร์แอปพลิเคชัน

หากคุณเห็นข้อความขึ้นว่าไม่สามารถเปิด "Petoi Desktop App" ได้เนื่องจากไม่สามารถตรวจสอบผู้พัฒนาได้ คุณสามารถคลิกขวาที่ไอคอน กดปุ่ม Shift และคลิ๊ก Open.

เรียกใช้งานแอพจากเทอร์มินัล

ในกรณีของปัญหาเอ็กซีคิวเทเบิ้ลไฟล์โปรแกรม หรือถ้าคุณต้องการแก้ไขซอร์สและทดสอบ คุณสามารถรันโค้ดจากเทอร์มินัลได้เช่นกัน

เทอร์มินัล เป็นอินเทอร์เฟซในตัวบนเครื่อง Mac หรือ Linux สภาพแวดล้อมที่เทียบเท่าบนเครื่อง Windows เรียกว่า Command-Line Tool (CMD) ขอแนะนำให้คุณติดตั้ง Anaconda เพื่อจัดการสภาพแวดล้อม Python ของคุณ นอกจากนี้ยังสามารถให้ Powershell เป็นเทอร์มินัลสำหรับเครื่อง Windows รุ่นเก่า

ขึ้นอยู่กับการกำหนดค่า Python ที่มีอยู่ของคุณ คุณอาจต้องอัปเกรดเป็น Python3 และติดตั้งไลบรารีต่อไปนี้:

• pyserial

• pillow

คุณสามารถติดตั้งได้โดยพิมพ์ pip3 install pyserial pillow ใน เทอร์มินัล หรือใช้ตัวจัดการแพ็คเกจใน Anaconda

ในการรันโค้ด:

1. ใน Terminal ใช้คำสั่ง cd เพื่อนำทางไปยังโฟลเดอร์ OpenCat/pyUI/ คุณสามารถใช้แป้น Tab เพื่อเติมชื่อพาธโดยอัตโนมัติ

2. หลังจากเข้าสู่โฟลเดอร์ pyUI/ ให้ป้อน ls และตรวจสอบให้แน่ใจว่าคุณเห็น UI.py และซอร์สโค้ด python อื่น ๆ ในรายการ

3. รัน python3 UI.py.

Setup Process

ซอฟต์แวร์ OpenCat ทำงานได้ทั้งบน Nybble และ Bittle ซึ่งควบคุมโดย NyBoard ที่ใช้ ATmega328P สามารถดูเอกสารรายละเอียดเพิ่มเติมได้ที่ NyBoard V1_0 หรือ NyBoard V1_1.

เลื่อน สวิตซ์I2C (SW2) เป็น Arduino.

สวิตช์ I2C เปลี่ยนอุปกรณ์หลัก I2C (gyro/accelerometer, servo driver, external EEPROM) ตามค่าเริ่มต้น “Arduino” NyBoard ใช้ ATmega328P แบบออนบอร์ดเป็นชิปหลัก บน “RPi” NyBoard ใช้ชิปภายนอกที่เชื่อมต่อผ่านพอร์ต I2C (SDA, SCL) เป็นชิปหลัก

Quick Start Tutorial Video

ขั้นตอนการตั้งค่าสำหรับ Nybble เกือบจะเหมือนกัน ยกเว้นว่าคุณต้องเปลี่ยนการกำหนดโมเดลเป็น #define NYBBLE. อย่าลืมอ่านขั้นตอนโดยละเอียดต่อไปนี้

Downloads and installations of Arduino IDE

ถ้าเป็นบอร์ด NyBoard V1_* เวอร์ชั่นใดก็ตามสามารถเลือกเป็น Arduino Uno ได้เลย

เชื่อมต่อตัวอัปโหลด (บางครั้งเรียกว่า programmer )

สำหรับขั้นตอนเฉพาะ โปรดดูส่วนเชื่อมต่อ NyBoard ใน USB uploader module Connect NyBoard section

เชื่อมต่อตัวอัปโหลด Bluetooth (optional)

สำหรับขั้นตอนเฉพาะ โปรดดูที่ส่วนเชื่อมต่อ NyBoard ใน Dual-Mode Bluetooth Module Connect NyBoard section

ดาวน์โหลด OpenCat แพ็คเกจ

• ดาวน์โหลด ​OpenCat repo เวอร์ชั่นล่าสุดจาก GitHub: https://github.com/PetoiCamp/OpenCat. จะดีกว่าถ้าคุณใช้คุณสมบัติการควบคุมเวอร์ชันของ GitHub มิฉะนั้น ตรวจสอบให้แน่ใจว่าคุณดาวน์โหลดทั้งโฟลเดอร์ OpenCat ทุกครั้ง codeทั้งหมดต้องเป็นเวอร์ชันเดียวกันจึงจะทำงานร่วมกันได้

• หากคุณดาวน์โหลดไฟล์ Zip ของ code คุณจะได้รับ OpenCat-main โฟลเดอร์หลังจาก unzip คุณต้องเปลี่ยนชื่อเป็น OpenCat ก่อนเปิด OpenCat.ino เพื่อให้ชื่อทั้งสองตรงกัน

• มี code ที่ชื่อว่า testX.ino หลายไฟล์ในโฟลเดอร์ ModuleTests คุณสามารถอัปโหลดเพื่อทดสอบบางโมดูลแยกกันได้ เปิด testX.ino ใดๆ ที่มีคำนำหน้าว่า “test” (แนะนำให้ใช้ testBuzzer.ino เป็น sketch ทดสอบแรกของคุณ)

• เปิด serial monitor และตั้งค่า baud rate บน NyBoard V1_* ให้เลือกบอร์ดเป็น Arduino Uno และตั้งค่า baud rate เป็น 115200 ทั้งใน code และ serial monitor

• Compile code ไม่ควรมีข้อความแสดงข้อผิดพลาด เมืออัปโหลด sketch ไปยังบอร์ดของคุณและคุณจะเห็น LED Tx และ Rx กะพริบถี่ๆ เมื่อหยุดกะพริบ ข้อความควรปรากฏบน serial monitor

Upload

ในการกำหนดค่าบอร์ด โปรดทำตามขั้นตอนเหล่านี้

1. กำหนดค่าประเภทหุ่นยนต์และรุ่นของบอร์ด

เปิดไฟล์ OpenCat.ino และเลือกเวอร์ชันของหุ่นยนต์และบอร์ดของคุณ ตัวอย่างเช่น

#define BITTLE    //Petoi 9 DOF robot dog: 1x on head + 8x on leg
//#define NYBBLE  //Petoi 11 DOF robot cat: 2x on head + 1x on tail + 8x on leg

//#define NyBoard_V0_1
//#define NyBoard_V0_2
#define NyBoard_V1_0
//#define NyBoard_V1_1

2.ตั้งค่า configuration mode

คอมเมนท์ในส่วน #define MAIN_SKETCH เพื่อให้โค้ดเปลี่ยนโหมดการกำหนดค่าบอร์ด อัปโหลดและปฏิบัติตาม serial prompts เพื่อดำเนินการต่อดังตัวอย่างด้านล่าง

// #define MAIN_SKETCH

3. เสียบตัวอัพโหลด USB เข้ากับคอมพิวเตอร์ของคุณ

ติดตั้ง the driver หากไม่พบพอร์ต USB ภายใต้ Arduino -> Tools -> Port

4. เสียบตัวอัปโหลด USB เข้ากับ NyBoard

สำหรับขั้นตอนเฉพาะโปรดดูส่วนเชื่อมต่อ Connect NyBoard section ใน USB uploader module

5. อัปโหลด configuration mode sketch

กดปุ่มอัปโหลด

6. เปิด serial monitor

คุณสามารถหาปุ่มนี้ได้ภายใต้เครื่องมือ Tools หรือที่มุมบนขวาของ IDE

ตั้งค่า serial monitor เป็น No line ending และ baud rate 115200

7.รีเซ็ตออฟเซ็ตของข้อต่อ

The serial prompts:

Reset joint offsets? (Y/n):

ป้อน 'Y' และกด Enter หากคุณต้องการรีเซ็ตออฟเซ็ตของข้อต่อทั้งหมดเป็น 0

โปรแกรมจะทำการรีเซ็ต จากนั้นอัปเดต constants และ instinctive skills ในหน่วยความจำ

8. IMU (Inertial Measurement Unit) calibration

The serial prompts:

Calibrate the IMU? (Y/n): 

ป้อน 'Y' และกด Enter หากคุณไม่เคยปรับเทียบ IMU หรือต้องการทำการปรับเทียบใหม่

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

เมื่อ serial monitor แสดง "Ready!" คุณสามารถปิด serial monitor เพื่อทำขั้นตอนถัดไป

9. Calibrate the servo controller chip PCA9685

มีขั้นตอนเพิ่มเติมในการ Calibrate servo driver หลังจากการ calibrate IMU

Optional: Connect PWM 3 -> Grove pin A3 to calibrate PCA9685

คุณสามารถ calibrate servo controller (PCA9685 chip) เพื่อให้สัญญาณมุมแม่นยำยิ่งขึ้น ใช้สายจัมเปอร์แบบสั้นเพื่อเชื่อมต่อ PWM pin3 (pin สัญญาณของ pin เซอร์โวตัวใดตัวหนึ่ง) และ Grove pin A3

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

10. อัปโหลด sketch ของฟังก์ชันหลัก

ยกเลิก comment #define MAIN_SKETCHเพื่อให้ใช้งานได้ code จะกลายเป็นโปรแกรมปกติสำหรับการทำงานหลัก จากนั้นอัปโหลด code

#define MAIN_SKETCH

เปิด serial monitor เมื่อ serial monitor แสดง " Ready! " หุ่นยนต์ก็พร้อมที่จะรับคำสั่งถัดไปของคุณ

11. The module macro in the code

Code เริ่มต้นทำงานในโหมดมาตรฐาน หากคุณมีโมดูลที่ขยายได้บางโมดูล คุณอาจยกเลิกการแสดงความคิดเห็น macro definition ของโมดูลนั้นๆ จะปิดใช้งานรหัส Gyro เพื่อประหยัดพื้นที่ในการเขียนโปรแกรมและเปิดใช้งานการสาธิตของโมดูล

ใน official modules ถูกกำหนดไว้ในไฟล์ส่วนหัวแยกต่างหากใน OpenCat/src/ คุณสามารถค้นหาได้ใน OpenCat/src/io.h -> readSignal() ลักษณะการทำงานของ OTHER_MODULES กำหนดไว้ใน OpenCat/OpenCat.ino -> otherModule() คุณสามารถศึกษาโค้ดตัวอย่างเพื่อเขียนฟังก์ชันของคุณเองได้

12. Modify the "joint - pin" mapping

ในบางกรณี คุณอาจต้องการปรับเปลี่ยนการ mapping ของ "pin ข้อต่อ" ของหุ่นยนต์ คุณสามารถแก้ไขได้ใน OpenCat/src/OpenCat.h ตรวจสอบให้แน่ใจว่าคุณกำลังแก้ไขบล็อกโค้ดที่สอดคล้องกับเวอร์ชันของบอร์ดที่จุดเริ่มต้นของ OpenCat.ino หลังจากแก้ไข อย่าลืมบันทึกการเปลี่ยนแปลงและทำขั้นตอนการอัปโหลดซ้ำตั้งแต่ขั้นตอนที่ 2

1. อ่านคู่มือเริ่มใช้งานฉบับย่อ

พารามิเตอร์เฉพาะของแต่ละโมดูลการทำงานของ BiBoard โปรดดู ของคู่มือเริ่มต้นใช้งานฉบับย่อของ BiBoard

2. Set up BiBoard

2.1 เตรียม environment ในการพัฒนา ESP32

สำหรับรายละเอียด โปรดดู ของคู่มือเริ่มใช้งานของ BiBoard

2.2 แก้ไขไฟล์ code ในแพ็คเกจ

• sdkconfig.h

ต่อท้ายบรรทัดโค้ดที่ส่วนท้ายของไฟล์:

2.3 เพิ่ม hardware partition

2.4 ดาวน์โหลด OpenCatEsp32 แพ็คเกจ

• Iหากคุณดาวน์โหลดไฟล์ Zip ของ code คุณจะได้รับโฟลเดอร์หลักของ OpenCatEsp32 หลังจากคลาย zip คุณต้องเปลี่ยนชื่อเป็น OpenCatEsp32 ก่อนเปิด OpenCatEsp32.ino เพื่อให้ชื่อทั้งสองตรงกัน .

• มี code ที่ชื่อว่า testX.ino หลายไฟล์ในโฟลเดอร์ ModuleTests คุณสามารถอัปโหลดเพื่อทดสอบบางโมดูลแยกกันได้ เปิด testX.ino ใดๆ ที่มีคำนำหน้าว่า “test” (แนะนำให้ใช้ testBuzzer.ino เป็น sketch ทดสอบแรกของคุณ)

2.5 Compile and upload the sketch

แก้ไข definition ประเภทอุปกรณ์ใน BiBoard.ino ตามประเภทอุปกรณ์

แก้ไข definition รุ่นของบอร์ดใน BiBoard.ino ตามรุ่นของบอร์ด

หลังจากการแก้ไขเสร็จสิ้น คุณสามารถคลิกปุ่มอัปโหลดเพื่ออัปโหลด BiBoard.ino และการเปลี่ยนแปลงในโปรแกรมจะถูกบันทึกโดยอัตโนมัติ

2.6 Initialization

เมื่อเปิด BiBoard ที่เพิ่งตั้งค่าใหม่ จะต้องเชื่อมต่อ serial port เข้ากับคอมพิวเตอร์ และเริ่มต้นข้อต่อและ gyroscope accelerometer (IMU) ในหน้าต่าง serial port monitor

คุณจะเห็นคำถามหลายข้อ:

พิมพ์ 'Y' ซึ่งหมายถึงการรีเซ็ตเซอร์โวทั้งหมดเป็นศูนย์

พิมพ์ 'Y' กับคำถาม ซึ่งหมายถึงการ calibrate MPU6050 เช่น gyro/accelerometer sensor

รายละเอียดของข้อมูลการแสดงผลของ serial port มีดังนี้：

หลังจากการ calibrate IMU เสร็จสิ้น ทุกครั้งที่เปิดเครื่อง หุ่นยนต์จะเข้าสู่โปรแกรมการเปิดเครื่องตามปกติ

2.7 Power on

• กดปุ่มบนแบตเตอรี่ค้างไว้และวางหุ่นยนต์โดยให้ด้านหนึ่งขึ้น มันจะเข้าสู่สถานะ calibration state automatically ภาพด้านล่างแสดงขาบนและขาล่างที่ติดตั้งหลังจากหุ่นยนต์เข้าสู่สถานะการ calibate

• หากคุณเปิดหุ่นยนต์และหุ่นยนต์ตั้งตรง (โดยหงายหลังขึ้น) หุ่นยนต์จะเริ่มจากท่า " rest " (พับขาและปลดล็อกเซอร์โว)

2.8 โหมดมาตรฐานและโหมดพิเศษ

Code จะเริ่มต้นทำงานในโหมดมาตรฐาน หากคุณมีโมดูลที่สามารถขยายได้บางโมดูล คุณอาจยกเลิกข้อคิดเห็น definition ของโมดูลเฉพาะ จะปิดใช้งานรหัส Gyro เพื่อประหยัดพื้นที่ในการเขียนโปรแกรมและเปิดใช้งานการสาธิตของโมดูล

ใน official modules ถูกกำหนดไว้ในไฟล์ส่วนหัวแยกต่างหากใน OpenCat/src/ คุณสามารถค้นหาได้ใน OpenCat/src/io.h -> readSignal() ลักษณะการทำงานของ OTHER_MODULES กำหนดไว้ใน OpenCat/OpenCat.ino -> otherModule() คุณสามารถศึกษาโค้ดตัวอย่างเพื่อเขียนฟังก์ชันของคุณเองได้

3. Configuration with App

BiBoard มีบลูทูธในตัว และคุณสามารถเชื่อมต่อกับแอพ Android ได้:

คุณสามารถตรวจสอบประวัติการอัปเดตและคุณลักษณะเพิ่มเติมได้ใน ChangeLog.md (BiBoard\ChangeLog.md)

1. การเตรียมการ

รีโมทคุยข้อมูลผ่าน Infrared ทำให้ไม่ต้องจับคู่ โปรดตรวจสอบว่าได้ถอดแผ่นฉนวนพลาสติกออกแล้วเพื่อให้ถ่านสามารถจ่ายไฟเข้าไปสู่ตัวรีโมท และหากทดสอบเบื้องต้นโดยการชี้ตัวส่งสัญญาณของรีโมท (Infrared Transmitter) ไปที่ตัวรับสัญญาณ(Infrared Receiver)ที่ด้านหลังหุ่นยนต์เมื่อใช้งาน หากหุ่นยนต์ไม่ตอบสนอง คุณสามารถใช้กล้องของโทรศัพท์เพื่อตรวจสอบเครื่องส่งสัญญาณได้ หากไม่กะพริบเมื่อคลิกปุ่ม คุณต้องเปลี่ยนแบตเตอรี่ หากไฟกะพริบ แสดงว่าโปรแกรมบนหุ่นยนต์ไม่ได้กำหนดค่าอย่างถูกต้อง

2. คีย์แมพ

ตำแหน่งของปุ่มนั้นสำคัญมาก แม้ว่าสัญลัษณ์ต่างๆจะช่วยให้จดจำ function ต่างๆได้ แต่จจะเป็นการดีกว่าถ้าที่จะกำหนดสัญลักษณ์ที่เกี่ยวข้องกับตำแหน่งเพื่อให้สามารถอ้างอิงถึงคีย์ต่างๆได้ เช่น K00 สำหรับแถวที่ 1 และคอลัมน์ที่ 1 และ K32 สำหรับแถวที่ 4 และคอลัมน์ที่ 3

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

เรายังสร้างแผงควบคุมระยะไกลแบบกำหนดเองสำหรับแบทช์ในอนาคตอีกด้วย ผู้ใช้ก่อนหน้านี้สามารถดาวน์โหลดไฟล์การออกแบบและพิมพ์บนกระดาษ A4

3. ตรวจสอบฟีเจอร์การเคลื่อนไหว

• Rest จะเป็นการสั่งหุ่นยนต์หมอบลงและปิดการทำงานของเซอร์โวเป็นคำสั่งคลิ๊กที่ปลอดภัยหากหุ่นยนต์ทำอะไรแปลกๆ

• Balance คือท่ายืนที่สมดุล คุณสามารถปรับหุ่นยนต์จากด้านข้างและหุ่นยนต์จะพยายามบาลานซ์ คุณสามารถทดสอบความสามารถในการทรงตัวบนกระดานได้ การทรงตัวจะเปิดใช้งานในท่าทางและการเดินส่วนใหญ่.

• การกด F/L/R จะทำให้หุ่นยนต์เคลื่อนที่ไปข้างหน้า/ซ้าย/ขวา

• B จะทำให้หุ่นยนต์เคลื่อนที่ถอยหลัง

• Calibrate ทำให้หุ่นยนต์อยู่ในท่าการคาลิเบรตและปิดการทำงานของไจโร

• Stepping หุ่นยนต์ย่ำอยู่กับที่จุดเดิม

• Crawl/walk/trot คือท่าที่สลับและใช้ร่วมกับปุ่มในการบังคับทิศทางของหุ่นยนต์ได้ได้

• ปุ่มถัดจาก trot คือท่าทางหรือทักษะอื่นๆ ที่ตั้งไว้ล่วงหน้า

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

• พื้นผิวที่แตกต่างกันมีแรงเสียดทานต่างกันและจะส่งผลต่อประสิทธิภาพการเดิน การเดินบนพื้นลาดเหมาะสำหรับหุ่นยนต์ขาสั้นทำให้การนี้มันสามารถคลานได้ด้วยคำสั่ง (command kcr) สำหรับภูมิประเทศที่เดินลำบาก

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

• เมื่อหุ่นยนต์กำลังเดิน คุณสามารถปล่อยให้หุ่นยนต์ปีนขึ้น/ลงทางลาดชันเล็กน้อย (<10 องศา)

** ดาวน์โหลดเวอร์ชันล่าสุดของ . **

หลังจาก หรือ เชื่อมต่ออย่างถูกต้อง, เปิด (สำหรับ Windows: UI.exe / สำหรับ Mac: Petoi Desktop App) เลือกรุ่นและภาษา จากนั้นคลิกปุ่ม "Joint Calibrator" เพื่อเปิดอินเทอร์เฟซของ calibrator

อินเทอร์เฟซการคาลิเบรทข้อต่อ

Nybble

Bittle

1. คลิกปุ่ม "คาลิเบรท" และเซอร์โวทั้งหมดจะย้ายไปยังตำแหน่งสอบเทียบทันที

1. ใช้เครื่องมือรูปตัว L ที่ให้มาเพื่อเป็นข้อมูลอ้างอิงระหว่างการคาลิเบรท ตามหมายเลขดัชนีของข้อต่อที่แสดงที่ด้านบนของอินเทอร์เฟซ (เมื่อปรับเทียบเซอร์โว ให้ปรับขาท่อนบนก่อน แล้วจึงปรับขาท่อนล่าง) ลากแถบเลื่อนที่เกี่ยวข้อง (ด้านล่างหมายเลขดัชนี) หรือคลิกส่วนที่ว่างของแถบเลื่อนเพื่อปรับข้อต่อให้เป็นมุมฉาก

คุณสามารถสลับระหว่าง "พัก", "ยืนขึ้น" และ "เดิน" เพื่อทดสอบผลการคาลิเบรท

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

** ดาวน์โหลดเวอร์ชันล่าสุดของ . **

Petoi Desktop App ทำงานได้ทั้งบน Nybble และ Bittle ซึ่งควบคุมโดย NyBoard ที่ใช้ ATmega328P หรือ BiBoard ที่ใช้ ESP32 สามารถดูเอกสารรายละเอียดเพิ่มเติมได้ที่ หรือ .

กดสวิตช์ I2C (SW2) ไปที่ฝั่ง "Arduino"

สวิตช์ I2C เปลี่ยนเป็นมาสเตอร์ I2C (ไจโร/มาตรความเร่ง, ไดรเวอร์เซอร์โว, EEPROM ภายนอก) ตามค่าเริ่มต้น “Arduino” NyBoard ใช้ ATmega328P แบบออนบอร์ดเป็นชิปหลัก ใน “RPi” NyBoard ใช้ชิปภายนอกที่เชื่อมต่อผ่านพอร์ต I2C (SDA, SCL) เป็นชิปหลัก เลือก "Arduino" เสมอ แต่ถ้ารู้วิธีเชื่อมต่ออุปกรณ์ I2C จากชิปภายนอกสามารถเปลี่ยนโหมดได้

อัปโหลดเฟิร์มแวร์สำหรับ NyBoard ด้วยแอป Petoi Desktop

สำหรับ NyBoard การอัปโหลดเฟิร์มแวร์ส่วนใหญ่จะเรียกแอปพลิเคชัน avrdude เพื่ออัปโหลดไฟล์เฟิร์มแวร์สำหรับเมนบอร์ด

การลง avrdude ใน Linux OS

เชื่อมต่อตัวอัปโหลด USB

ตรวจสอบการเชื่อมต่อของ serial ports:

หลังจากเชื่อมต่อตัวอัปโหลด USB อย่างถูกต้องแล้ว ให้เปิด PetoiDesktopApp (สำหรับ Windows: UI.exe / สำหรับ Mac: Petoi Desktop App) แล้วเลือกรุ่นและภาษา

Menu bar in Petoi Desktop APP

คลิกปุ่ม "Firmware Uploader" เพื่อเปิดอินเทอร์เฟซ Firmware Uploader:

เลือกตัวเลือกที่ถูกต้องเพื่ออัปโหลดเฟิร์มแวร์ล่าสุดสำหรับ NyBoard

ขั้นตอนการอัพโหลด

หลังจากคลิกปุ่ม "อัปโหลด" กระบวนการอัปโหลดจะเริ่มขึ้นทันที แถบสถานะด้านล่างจะแสดงความคืบหน้าปัจจุบันตามเวลาจริง รวมถึงผลลัพธ์ในการรัน

หลังจากอัปโหลดเฟิร์มแวร์ Parameters สำเร็จแล้ว บอร์ดจะเริ่มรันโปรแกรมการกำหนดค่าด้วยตัวเอง หน้าต่างข้อความบางหน้าต่างจะปรากฏขึ้นตามลำดับเพื่อให้คุณยืนยันหรือยกเลิก:

• Reset joint offsets? (Y/N)

เลือก "是(Y)" โปรแกรมจะรีเซ็ตพารามิเตอร์การสอบเทียบเซอร์โวทั้งหมดเป็นศูนย์ และแถบสถานะจะอัปเดตกระบวนการที่เกี่ยวข้องและผลลัพธ์ตามเวลาจริง

เลือก "否(N)" โปรแกรมจะข้ามขั้นตอนนี้ไป

• Calibrate IMU? (Y/N)

เลือก "是(Y)" โปรแกรมจะปรับเทียบไจโรสโคป (IMU) และแถบสถานะจะอัปเดตกระบวนการที่เกี่ยวข้องและผลลัพธ์ตามเวลาจริง

เลือก "否(N)" โปรแกรมจะข้ามขั้นตอนนี้ไป

เมื่อทำตามขั้นตอนทั้งหมดเสร็จสิ้น หน้าต่างข้อความจะปรากฏขึ้นว่า "Parameter initialization complete!" คุณต้องกดยืนยันเพื่อขั้นตอนถัดไป

หลังจากการอัปโหลดเสร็จสิ้น แถบสถานะจะอัปเดตผลลัพธ์ที่เกี่ยวข้อง เช่น การอัปโหลดเฟิร์มแวร์สำเร็จหรือล้มเหลว หากการอัปโหลดสำเร็จ จะมีหน้าต่างข้อความ "การอัปโหลดเฟิร์มแวร์เสร็จสมบูรณ์!" จะปรากฏขึ้นพร้อมกัน

หากคุณมีประสบการณ์ในการเขียนโปรแกรม Arduino IDE โปรดดูที่ Upload Sketch For NyBoard

บทเกริ่นนำ ของอินเทอร์เฟซ

** ดาวน์โหลดเวอร์ชันล่าสุดของ . **

อินเทอร์เฟซของสกิลคอมโพสเซอร์

Nybble

Bittle

ตัวเลือกในเมนู

• โมเดล

  • Nybble

  • Bittle

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

• ภาษา
• ประโยชน์

  เราจะเพิ่มแกดเจ็ตขนาดเล็กลงในแท็บยูทิลิตี้ต่อไป ขณะนี้เรามีตัวเลือกสีตาสำหรับเซ็นเซอร์อัลตราโซนิกของแมว Nybble พร้อมไฟ LED ในตัว

การเชื่อมต่อและการหมุนหมายเลขสถานะ

พอร์ท / เชื่อมต่อ

เซอร์โว

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

ไจโร

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

แรนด้อม

ท่าที่ตั้งค่าไว้

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

สามารถสลับไปมาระหว่างท่าทางต่างๆ และสังเกตว่าแถบเลื่อนในในหน้าต่างปรับข้อต่ออัปเดตอย่างไรเพื่อแสดงเห็นการเปลี่ยนแปลงในมุมองศาของข้อต่อ

Joint Controller

แถบเลื่อนมุมสามารถแสดงมุมข้อต่อปัจจุบันของหุ่นยนต์ สามารถหมุนข้อต่อของหุ่นยนต์กลับด้านได้หากคุณเปลี่ยนค่า คุณสามารถลากแถบเลื่อนเพื่อปรับมุมกว้าง หรือคลิกด้านบนหรือด้านล่างแถบเลื่อนเพื่อปรับแบบละเอียด (ทีละ 1 องศา) ข้อต่อบางอันจะมีระยะการเข้าถึงที่เล็กกว่าตัวเลื่อน พยายามใช้มุมระหว่าง -125 ถึง 125 องศา การส่งมุมที่ใหญ่ขึ้นจะเพิ่มเวลาตอบสนองกับหุ่นยนต์

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

คุณสามารถควบคุมหลายข้อต่อได้โดยคลิกปุ่มหมุนหมายเลข "+" หรือ "-" บนแถบเลื่อนแต่ละตัว แถบเลื่อนทั้งหมดที่มีการกด "+" จะเปลี่ยนโดย increaments เดียวกัน แถบเลื่อนที่กดปุ่ม "-" จะเปลี่ยนตามค่าลบ ปุ่มสามารถเปิดปิดได้ คลิกปุ่ม "Unbind All" เพื่อปลดข้อต่อทั้งหมดพร้อมกัน

คุณยังสามารถควบคุมข้อต่อทั้งตัวของหุ่นยนต์ได้ด้วยแถบเลื่อนที่แผงตรงกลาง คุณสามารถปรับแถบเลื่อนกลางเหล่านี้เพื่อปรับการวางแนวและการแปลโดยรวมของหุ่นยนต์ ท่า "สมดุล" ที่เป็นกลางสามารถสร้างผลลัพธ์ที่ดีกว่าท่าเอียงอื่น ๆ

Skill Editor

ฟังก์ชันก่อนหน้านี้สามารถแก้ไขท่าทางเดียวได้ Skill Editor เป็นตัวกำหนดตารางเวลาแอนิเมชั่นสต็อปโมชั่น คุณสามารถเพิ่ม ลบ และแทรกเฟรมของท่าทางต่างๆ และทำให้หุ่นยนต์เคลื่อนไหวได้อย่างต่อเนื่องและราบรื่น

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

การทำงานขั้นพื้นฐาน

การเปิดใช้งานเฟรม

สามารถคลิก "=" (ปุ่มที่ 2 ของแต่ละเฟรม) เพื่อเปิดใช้งานเฟรมที่เกี่ยวข้องและย้ายหุ่นยนต์ไปยังท่าทางของเฟรม เฟรมจะเก็บการแก้ไขใหม่ทั้งหมดของคุณในท่าทางปัจจุบันของหุ่นยนต์ สัญลักษณ์ "=" จะเป็นตัวหนา และปุ่มจะใหญ่ขึ้น หากเฟรมปัจจุบันถูกแก้ไข สัญลักษณ์ "=" จะกลายเป็นเครื่องหมายตกใจสีแดง "!" คุณสามารถคลิกปุ่มนี้เพื่อบันทึกการแก้ไขของคุณ มิฉะนั้น การแก้ไขปัจจุบันจะถูกยกเลิกหากคุณคลิกปุ่ม "="ของเฟรมอื่นๆ

การเพิ่มเฟรม

คุณสามารถคลิกปุ่ม "v" (ปุ่มที่ 9 ของแต่ละเฟรม) เพื่อเพิ่มเฟรมหลังจากเฟรมปัจจุบันและเปิดใช้งาน กรอบใหม่จะเหมือนกับของเฟรมที่เปิดใช้งานก่อนหน้า

แทรกเฟรม

ไม่จำเป็นต้องเพิ่มเฟรมใหม่หลังจากเฟรมสุดท้ายเสมอไป คุณสามารถคลิกปุ่ม "v" (ปุ่มที่ 9 ของแต่ละเฟรม) oเฟรมระหว่างกลางใด ๆ เพื่อแทรกเฟรมใหม่ด้านล่างโดยการกดปุ่ม "v" . เฟรมใหม่มีข้อมูลที่เหมือนกันกับเฟรมที่เปิดใช้งานก่อนหน้า

สะท้อนเฟรม

สามารถคลิกปุ่ม ">|<" เพื่อให้เฟรมนี้เหมือนกับเฟรมท่าทางของเฟรมที่เปิดใช้งานไปแล้ว

ลบเฟรม

สามารถคลิกที่ปุ่ม "<" (ปุ่มที่ 8 ของแต่ละเฟรม) เพื่อลบเฟรมปัจจุบันโดยกดปุ่มค้างไว้เฟรมต่อไปนี้ทั้งหมดจะเลื่อนขึ้น ถ้า เฟรมที่เปิดใช้งานถูกลบ เฟรมก่อนหน้าจะเปิดใช้งาน เฟรมที่เปิด เป็นเฟรมแรกและถูกลบ เฟรมถัดไปจะถูกเปิดใช้งาน

เพิ่มคำอธิบายสำหรับแต่ละเฟรม

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

การผูกติดข้อต่อและแก้ไขแบบส่งผ่าน

หากมุมของข้อต่อเหมือนกันในเฟรมปัจจุบันและเฟรมถัดไป การแก้ไขและบันทึกมุมจะอัปเดตมุมในเฟรมต่อไปนี้ด้วยจนกว่ามุมจะแตกต่างกัน ตัวอย่างเช่น หากมุมร่วมของ 8 เป็น 4,4,4,4,6,7 ในทุกเฟรม การเปลี่ยนมุมในเฟรมที่สองเป็น 8 จะอัปเดตลำดับเป็น 4,8,8,8,6,7

เล่นสกิลตามลำดับ

นอกเหนือจากการคลิกด้วยตนเองที่ปุ่ม "=" (ปุ่มที่ 2 ของแต่ละเฟรม)หากต้องการดูท่าเดียว คุณสามารถคลิก "Play" ปุ่มเริ่มแสดงท่าตามลำดับเริ่มจากเฟรมที่เปิดใช้งานทั้งหมด ในระหว่างการเล่นสามารถกดปุ่ม "Stop" เพื่อหยุดการเล่นสกิลกลางคันได้

ส่งออกสกิล

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

เนื้อหาของไฟล์ข้อความที่ส่งออก (.txt) สามารถคัดลอกและวางลงในไฟล์ Instinct**.h เพื่อใช้เป็นอาร์เรย์ทักษะได้

นำเข้าสกิล

หลังจากที่คลิกปุ่ม "Import"คุณจะเห็นหน้าต่างเด้งขึ้นมามันอนุญาตให้คุณก๊อปปี้และวางสกิลดาต้าอารเ์เรย์ใน text editor หรือ นำเข้าสกิลที่มีอยู่แล้วจากการสร้างโดยคนอื่นได้คุณสามารถดูตัวอย่างได้ที่OpenCat/src/InstinctBittle.h or InstinctNybble.h. รูปแบบสกิลที่สมบูรณ์ควรประกอบด้วยคู่"{ }" และมีตัวเลขระหว่างกลาง. เฉพาะรายการแรกเท่านั้นที่จะถูกนำเข้าหากมีอาร์เรย์สกิลหลายรายการ ควรตรวจสอบก่อนนำเข้า

รีเซ็ตตัวแก้ไขสกิล

คุณสามารถใช้ปุ่ม "Restart" เพื่อล้างแผงตัวแก้ไขสกิลและเริ่มต้นใหม่

การดำเนินการขั้นสูง

ตั้งค่า Action Frame Loops

กำหนดความเร็วในการเคลื่อนที่

1，2，4，8，12，16，32，48，max

ตั้งค่าการหน่วงเวลา

มีให้เลือก 17 แบบ: 0，50，100，200，300，400，500，600，700，800，900，1000，2000，3000，4000，5000，6000.

แน่นอน คุณยังสามารถป้อนค่าจำนวนเต็มในช่วง 0~6000 ในช่องตัวเลือก "Delay" หน่วยเป็นมิลลิวินาที (ms)

ตั้งค่าทริกเกอร์และมุม

ตัวเลือก "ทริกเกอร์" (ปุ่มที่ 4 ของเฟรม) ในเฟรมใช้เพื่อกำหนดทิศทางการหมุนของร่างกายเมื่อหุ่นยนต์สั่งงานเฟรมถัดไป มีตัวเลือกการตั้งค่า 5 แบบต่อไปนี้:

• None หมายความว่าไม่มีทริกเกอร์และตั้งค่าเงื่อนไขมุมแล้ว

• Pitch หมายถึงตัวหุ่นยนต์หมุนทำให้จมูกลง

• -Pitch หมายถึงตัวหุ่นยนต์หมุนทำให้จมูกสูงขึ้น

• Roll หมายความว่าตัวหุ่นยนต์จะกลิ้งไปทางด้านซ้าย (ทวนเข็มนาฬิกาเมื่อมองจากหาง)

• -Roll หมายถึง ตัวหุ่นยนต์จะกลิ้งไปทางด้านขวา (ตามเข็มนาฬิกาเมื่อมองจากหาง)

ตัวเลือก "มุม" (ปุ่มที่ 5 ของเฟรม) ถูกกำหนดโดยอ้างอิงถึงมุมของระบบพิกัดเชิงขั้ว ดังที่แสดงในรูปด้านบน เมื่อร่างกายอยู่ในแนวนอน มุมของแกนพิกัดเชิงขั้วคือ 0 องศา หากแกนพิกัดเชิงขั้วหมุนทวนเข็มนาฬิกา มุมจะเป็นบวกและค่อยๆ เพิ่มขึ้น ช่วงการตั้งค่ามุมคือค่าจำนวนเต็มระหว่าง-125~125.

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

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

ส่งออกท่าทางที่เรียนรู้(มิเรอร์)

ตัวเลือกพฤติกรรมและการเดิน

เมื่อนำเข้าอาร์เรย์ทักษะที่สร้างไว้ล่วงหน้า แอปเดสก์ท็อปจะเลือกตัวเลือก "พฤติกรรม/การเดิน" โดยอัตโนมัติตามรูปแบบข้อมูล เฟรมจะถูกโหลดลงในโปรแกรมแก้ไขเฟรม และหุ่นยนต์จะย้ายไปยังตำแหน่งของเฟรมแรกโดยอัตโนมัติ

การควบคุมหุ่นยนต์หลายตัวพร้อมกัน

• USB

ก่อนอื่นให้เชื่อมต่อตัวอัปโหลด USB เข้ากับแผงวงจรหลักของหุ่นยนต์ จากนั้นใช้สายเคเบิลข้อมูลเพื่อเชื่อมต่อกับอินเทอร์เฟซ USB ของคอมพิวเตอร์

• Bluetooth

ขั้นแรกให้เสียบโมดูล Bluetooth เข้ากับบอร์ดหลักของหุ่นยนต์ (ไม่จำเป็นต้องใช้บอร์ดที่ใช้ ESP32) จับคู่บอร์ดกับอินเทอร์เฟซการตั้งค่า Bluetooth ของคอมพิวเตอร์ แอปเดสก์ท็อปจะตรวจจับว่ามีการเชื่อมต่อพอร์ตอนุกรมใหม่หรือไม่ เมื่อเชื่อมต่อพอร์ตอนุกรมหลายพอร์ตสำเร็จ ปุ่มตัวเลือกพอร์ตอนุกรมในพื้นที่ "State Dials" จะเปลี่ยนเป็น "All" คลิกรายการแบบเลื่อนลงเพื่อดูพอร์ตอนุกรมทั้งหมดที่เชื่อมต่อสำเร็จ หุ่นยนต์ทั้งหมดจะถูกซิงโครไนซ์แบบเรียลไทม์ด้วยวิธีนี้ คุณยังสามารถเลือกพอร์ตอนุกรมใดก็ได้เพื่อควบคุมหุ่นยนต์ที่เกี่ยวข้อง

หากคุณถอดปลั๊กซีเรียลพอร์ต USB บนคอมพิวเตอร์ (หรือเลือกที่จะตัดการเชื่อมต่อโมดูล Bluetooth ในอินเทอร์เฟซการตั้งค่า Bluetooth) พอร์ตอนุกรมที่เกี่ยวข้องจะถูกลบออกจากรายการแบบหล่นลงตามเวลาจริง

หากคุณถอดปลั๊กซีเรียลพอร์ต USB ทั้งหมด (ตัดการเชื่อมต่อโมดูลบลูทูธทั้งหมด) ปุ่มตัวเลือกพอร์ตอนุกรมจะแสดงเป็น "ไม่มี" และปุ่มด้านซ้ายจะแสดงขึ้น "Listening". แอปเดสก์ท็อปยังคงตรวจพบโดยอัตโนมัติว่ามีการเชื่อมต่อพอร์ตหรือไม่ เมื่อหุ่นยนต์เชื่อมต่อกับคอมพิวเตอร์อีกครั้งผ่านพอร์ต ปุ่มทางด้านซ้ายของเมนูแบบเลื่อนลงจะแสดงขึ้น "Connected". ชื่อพอร์ตที่สอดคล้องกันจะแสดงอยู่ในปุ่มตัวเลือกพอร์ตอนุกรม

หากคุณต้องการให้แอปเดสก์ท็อปหยุดตรวจหาการเชื่อมต่อแบบซีเรียล คุณสามารถคลิกปุ่ม"Connected" / ปุ่ม "Listening" ข้อความในปุ่มจะเปลี่ยนเป็น "Connect"และการเชื่อมต่อแบบพอร์ตทั้งหมดจะถูกตัดการเชื่อมต่อ คลิกปุ่ม "Connect" อีกครั้งเพื่อรีสตาร์ทฟังก์ชันการตรวจจับแบบเรียลไทม์

หลังจากอัพโหลดแล้ว MicroPython firmware บน ESP8266 เราสามารถใช้มันในการรันสคริปต์ MicroPython ได้

1. Run the script directly

เราสามารถดำเนินการรันสคริปต์ MicroPython ได้โดยตรงในตัวแปร interpreter ของ MicroPython

# Simple script：
print("Hello MicroPython")

2. Use the .py file to run the script

คุณสามารถเขียนสคริปต์ Python ง่าย ๆ เพื่อสั่งให้ไฟ LED สีแดงกระพริบได้ดังนี้:

from machine import Pin
import time

# GPIO LED IO2
def blink():
    
    led = machine.Pin(2, machine.Pin.OUT)     # Pin 2 ,Output mode
    
    while(True):			# loop
        led.on()			# light on LED
        time.sleep(1)		# delay 1s
        led.off()			# light off LED
        time.sleep(1)		# delay 1s

if __name__ == "__main__":
    blink()

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

3. Upload the .py file to the ESP8266

เราสามารถคลิกที่ View -> File เพื่อเปิดแถบเครื่องมือไฟล์ และไฟล์จะปรากฏทางด้านซ้ายของ Thonny โดยส่วนบนคือไดเรกทอรีของเครื่องมือจำลองและส่วนล่างคือไฟล์ที่เก็บอยู่ในอุปกรณ์ MicroPython โดยค่าเริ่มต้นจะมีไฟล์ boot.py เพียงไฟล์เดียว โปรดอย่าลบไฟล์นี้ เพราะเป็นไฟล์เริ่มต้นของอุปกรณ์ MicroPython

เราบันทึกสคริปต์เป็นชื่อ blink.py และบันทึกไว้บนเครื่องคอมพิวเตอร์ จากนั้นคลิกขวาที่ไฟล์และเลือก Upload to / :

เลือก MicroPython device ในหน้าต่าง:

มีไฟล์blink.py อยู่บนอุปกรณ์แล้ว ดังนั้นไฟล์ได้ถูกบันทึกบนอุปกรณ์แล้ว

4. Write a script to let robot perform actions sequentially

ESP8266 สามารถส่งคำสั่งไปยัง NyBoard ผ่านพอร์ตซีเรียลได้ โดยเราเพียงแค่เขียนสคริปต์ส่งพอร์ตซีเรียลง่าย ๆ เพื่อส่งคำสั่งพอร์ตซีเรียลไปยัง NyBoard แล้วหุ่นยนต์ก็สามารถดำเนินการทำตามคำสั่งตามลำดับได้

from machine import UART
import time

uart = UART(0, baudrate=115200,timeout=5)

# walk
def walk(time_ms):
    print("walk")
    uart.write("kwkF")      # walk cmd
    time.sleep_ms(time_ms)  # keep time
    uart.write("d")         # stop
    time.sleep_ms(1500)
    
# backward
def back(time_ms):
    print("back")
    uart.write("kbk")
    time.sleep_ms(time_ms)
    uart.write("d")
    time.sleep_ms(1500)

# stop
def stop():
    uart.write("d")
    
def initConnection():
    connected = False
    while True:
        uart.write("d")
        for t in range(30):
            uos.dupterm(None, 1)        # disable REPL on UART(0), detach the REPL from UART0
            time.sleep_ms(5)            #delay is a must
            result = uart.read(1)
            uos.dupterm(uart, 1)        # enable REPL on UART(0), reattach REPL

            if result != None:
#                 uart.write(result)    # for debug
                if result == b"d":

                    connected = True
                    break
            time.sleep_ms(10)

        if connected:
            break

    uart.write("b22 4 24 4 26 4")
 

def actSeq():
    initConnection()
    time.sleep_ms(2000)
    walk(3000)
    back(3000)
    uart.write("m0 90")
    time.sleep_ms(3000)
    uart.write("i8 -20 9 -60")
    time.sleep_ms(2000)
    uart.write("b26 4 24 4 20 4")
    time.sleep_ms(1000)
    uart.write("d")
    uos.dupterm(None, 1)        # disable REPL on UART(0), detach the REPL from UART0

    
if __name__ == "__main__":
    actSeq()
    

เมื่อฟังก์ชั่น actSeq() ถูกเรียกใช้งาน มันจะส่งออกชุดคำสั่งผ่านพอร์ตซีเรียลไปยัง NyBoard ผ่านบอร์ด WiFi และใช้ serial monitor เพื่อดูผลลัพธ์ ดังนี้ (สำหรับความสะดวกในการอ่าน โปรดใช้การตั้งค่า automatic frame break ของตัวดีบักเกอร์พอร์ตซีเรียล เพื่อให้มีการขึ้นบรรทัดใหม่อัตโนมัติ)

5. Power on and run automatically

หลังจากที่เราได้ debug การทำงานของ sequence action เรียบร้อยแล้ว โดยการเชื่อมต่อ ESP8266 กับ NyBoard แล้วโปรแกรมดังกล่าวจะไม่สามารถรันได้เนื่องจากฟังก์ชั่น actSeq() ไม่ได้ทำงาน ดังนั้นเราต้องการให้โปรแกรมรันโดยอัตโนมัติหลังจากมีการเปิดเครื่อง ซึ่งมีวิธีการได้แก่ 2 วิธีดังนี้:

• กรุณาเปลี่ยนชื่อไฟล์เป็น "main.py" และบันทึกลงบนอุปกรณ์ (แนะนำ)

• แก้ไข Boot.py

1. การแนะนำฟังก์ชัน

ESP-NOW เป็นโปรโตคอลการสื่อสารไร้สายอีกอย่างหนึ่งที่ถูกพัฒนาโดย Espressif ซึ่งทำให้อุปกรณ์หลายตัวสามารถสื่อสารกันได้โดยไม่ต้องใช้ Wi-Fi หรือใช้ Wi-Fi ได้ตามต้องการ โปรโตคอลนี้คล้ายกับการเชื่อมต่อไร้สาย 2.4GHz แบบพลังงานต่ำที่พบได้บ่อยในเม้าส์ไร้สาย โดยอุปกรณ์จะถูกเชื่อมต่อกันก่อนที่จะสื่อสารกันได้ หลังจากการเชื่อมต่อแล้ว การเชื่อมต่อระหว่างอุปกรณ์จะเป็นต่อเนื่องแบบ peer-to-peer และไม่ต้องมีการสร้าง handshake protocol โดยเป็นเทคโนโลยีการสื่อสารที่เร็วและมีการส่งข้อมูลแบบสั้นๆ โดยไม่ต้องมีการเชื่อมต่อ ซึ่งช่วยให้คอนโทรลเลอร์พลังงานต่ำสามารถควบคุมอุปกรณ์อัจฉริยะได้โดยตรงโดยไม่ต้องเชื่อมต่อกับเราเตอร์ นี่เหมาะสำหรับสถานการณ์เช่นไฟอัจฉริยะ การควบคุมระยะไกล และการส่งข้อมูลเซ็นเซอร์กลับมา

หลังจากใช้การสื่อสาร ESP-NOW ถ้ามีอุปกรณ์บางตัวสูญเสียพลังงานโดยไม่ได้ปิดเสียงเชื่อมต่อกับอุปกรณ์ที่เหลือไว้ ให้เริ่มต้นอุปกรณ์นั้นใหม่ ก็จะเชื่อมต่อกับโหนดที่เหลืออยู่โดยอัตโนมัติเพื่อดำเนินการสื่อสารต่อไป

โหมดการสื่อสารที่รองรับโดย ESP-NOW มีดังนี้:

• one-to-one communication

• one-to-many communication

• many-to-one communication

• many-to-many communication

ESP-NOW รองรับคุณสมบัติดังนี้:

• การเข้ารหัสแพคเก็ตแบบยูนิแคสต์หรือการสื่อสารแบบยูนิแคสต์โดยไม่มีการเข้ารหัสแพคเก็ต

• การใช้งานผสมระหว่างอุปกรณ์ที่มีการเข้ารหัสจับคู่และอุปกรณ์ที่ไม่มีการเข้ารหัสจับคู่

• สามารถบรรทุกข้อมูล payload ได้สูงสุดถึง 250 ไบต์

• รองรับการตั้งค่าฟังก์ชันการส่งแบบ callback เพื่อแจ้งให้ชั้นแอปพลิเคชันทราบเมื่อการส่งแฟรมไม่สำเร็จหรือสำเร็จ

ต่อไปนี้เป็นข้อ จำกัด ของ ESP-NOW:

• ไม่รองรับการส่ง Broadcast packet ชั่วคราว;

• มีข้อจำกัดในการใช้กับอุปกรณ์ที่เป็นคู่ระหว่างการเข้ารหัส

  • ในโหมด Station รองรับคู่ระหว่างการเข้ารหัสได้สูงสุด 10 อุปกรณ์;

  • ในโหมด SoftAP หรือ SoftAP + Station mixed mode รองรับคู่ระหว่างการเข้ารหัสได้สูงสุด 6 อุปกรณ์;

  • จำนวนอุปกรณ์ที่เป็นคู่ระหว่างการเข้ารหัสไม่เกิน 20 อุปกรณ์ทั้งหมด;

• ขนาดของข้อมูล payload สามารถรับได้สูงสุด 250 ไบต์.

การควบคุมกลุ่ม Petoi สามารถใช้ฟังก์ชันการสื่อสาร ESP-NOW ของ ESP8266 ได้

2. Setup for ESP-NOW

2.1 Hardware setup

ในกรณีนี้ เตรียมอุปกรณ์ 2 ตัวของ Bittle (ที่มี ESP8266 ติดตั้งอยู่) และคอมพิวเตอร์ที่เชื่อมต่อกับ ESP8266 1 ตัว

ข้อมูลต่อไปนี้เกี่ยวกับการอัปโหลดโปรแกรมและการเรียกรูปแบบ MAC ของโมดูลในรูปภาพ

2.2 Software setup

เปิดโปรแกรม Thonny และใช้ USB uploader เพื่อเชื่อมต่อโมดูล ESP8266 แล้วป้อนคำสั่งต่อไปนี้ใน shell interface:

หากมีการแจ้งเตือนข้อผิดพลาดเช่น "ไม่พบโมดูล espnow" แปลว่ามีปัญหาในการอัพโหลดเฟิร์มแวร์ ในขณะที่หากไม่มีการแจ้งเตือน แปลว่าการอัพโหลดเฟิร์มแวร์เสร็จสมบูรณ์

3. Code introduction

โค้ดควบคุมกลุ่มถูกแบ่งเป็น 3 ส่วน:

• Query the MAC address of the module

• Transmitter program

• receiver program

3.1 Query the MAC address of the module

หมายเลข MAC คือหมายเลขที่ใช้ในการยืนยันตำแหน่งของอุปกรณ์เครือข่าย และรับผิดชอบในชั้นที่สอง (data link layer) ของโมเดลเครือข่าย OSI หมายเลข MAC ยังเรียกว่าที่อยู่ฟิสิกส์ (physical address) และที่อยู่ฮาร์ดแวร์ (hardware address) มันถูกเขียนลงบนหน่วยความจำที่ไม่สูญเสีย (เช่น EEPROM) ของการ์ดเครือข่ายเมื่อผู้ผลิตอุปกรณ์เครือข่ายผลิตอุปกรณ์นั้นๆ ขึ้นมา

ที่อยู่ MAC เป็นที่อยู่ที่ใช้สำหรับยืนยันตำแหน่งของอุปกรณ์เครือข่าย และรับผิดชอบด้านชั้นที่สอง (data link layer) ของโมเดลเครือข่าย OSI ที่อยู่ MAC ยังเรียกว่าที่อยู่ฟิสิกส์และที่อยู่ฮาร์ดแวร์ จะถูกเขียนลงในหน่วยความจำที่ไม่สูญเสีย (เช่น EEPROM) ของการ์ดเครือข่ายเมื่อมันถูกผลิตโดยผู้ผลิตอุปกรณ์เครือข่าย

ความยาวของที่อยู่ MAC คือ 48 บิต (6 ไบต์) ซึ่งมักแสดงเป็น 12 ตัวเลขฐานสิบหก 3 ไบต์แรกแทนหมายเลขอุปกรณ์ซีเรียลของผู้ผลิตฮาร์ดแวร์เครือข่ายที่ได้รับมอบหมายโดย IEEE (สถาบันวิทยาการและอิเล็กทรอนิกส์) และ 3 ไบต์สุดท้ายแทนหมายเลขอุปกรณ์เครือข่ายบางอย่าง (เช่นการ์ดเครือข่าย) ที่ผลิตโดยผู้ผลิต

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

วิธีที่ง่ายที่สุดในการใช้ ESPNOW คือการส่งข้อมูลด้วย MAC address โดยเราจะใช้โปรแกรมเล็ก ๆ เพื่อสอบถาม MAC address ของโมดูล

หลังจากการรันโปรแกรมใน Thonny เสร็จสิ้น โปรแกรมจะแสดง MAC address บน terminal ออกมา ในขณะนี้ คุณสามารถใช้สติ๊กเกอร์สำหรับเขียน MAC address ของโมดูลแล้ววางไว้บนโมดูลได้เลย

3.2 Transmitter program

โปรแกรมส่งประกอบด้วยส่วนต่อไปนี้:

• Enable the WiFi function of the module

• Configure the ESP-NOW protocol and enable it

• Add a node (peer) that needs to communicate

• Send a message

โค้ดที่เป็นตัวอย่างเฉพาะ:

3.3 Receiver program

โปรแกรมตัวรับประกอบด้วยส่วนต่อไปนี้:

• Enable the WiFi function of the module

• Configure the ESP-NOW protocol and enable it

• Add a node (peer) that needs to communicate

• Receive and decode the message, and send commands to NyBoard through the serial port

โค้ดที่เป็นตัวอย่างเฉพาะ:

โค้ดนี้ถูกแพ็กเก็ตไว้ในฟังก์ชันที่ชื่อว่า espnow_rx() เพื่อความสะดวกในการเริ่มโปรแกรมโดยอัตโนมัติหลังจากเปิดเครื่องขึ้นมา

มีวิธีสองวิธีในการเรียกใช้โปรแกรมโดยอัตโนมัติหลังจากเปิดเครื่อง:

• Rename the code file to main.py;

• Modify the boot.py ;

สำหรับผู้เริ่มต้นเราแนะนำอันแรก

3.4 Communication-Command Converter

การเขียนการแปลงคำสั่งผ่านทางซีเรียลที่ส่งมาจะทำให้โปรแกรมซับซ้อนและยากต่อการบำรุงรักษา ดังนั้นเราสามารถสร้างฟังก์ชันใหม่เพื่อทำการแปลงคำสั่งและส่งออกคำสั่งได้ โดยจะทำการเก็บคำสั่งที่รับเข้ามาเป็นตัวเลขเดียวกันกับคำสั่งที่ส่งออกไปยังฝั่งอีกข้าง ที่เขียนเป็นฟังก์ชันใหม่ ตั้งชื่อว่า“instruction_handle()” เพื่อแปลงข้อความที่ได้รับเป็นตัวเลขและส่งออกข้อความตามรูปแบบของคำสั่งที่ต้องการ

เชื่อมต่อ USB Adapter

เชื่อมต่อ USB Adapter เข้ากับเมนบอร์ดและเลือก serial port ที่ถูกต้อง โปรดดูส่วน Connect NyBoard section เชื่อมต่อ NyBoard ในโมดูล USB Uploader สำหรับขั้นตอนเฉพาะ

เปิด serial monitor และตั้งค่า baud rate บน NyBoard V1_* ให้ตั้งค่า " No line ending " และ baud rate เป็น 115200 ใน serial monitor

เชื่อมต่อ Bluetooth uploader (optional)

สำหรับขั้นตอนเฉพาะ โปรดดูที่ Connect NyBoard section ใน Dual-Mode Bluetooth Module

จากนั้นคุณสามารถเลือก Tools->Port บน Arduino IDE และใช้งานในลักษณะเดียวกับ USB Adapter

ด้วย USB adapter / Bluetooth module ที่เชื่อมต่อ NyBoard และ Arduino IDE คุณจะมีอินเทอร์เฟซที่ดีที่สุด - Serial Monitor เพื่อสื่อสารกับ NyBoard และเปลี่ยนทุก byte บนนั้น (ผ่านการส่ง serial commands ตาม serial protocol).

การเตรียมการ

1. Install python (version≥ 3.6, such as Anaconda3-5.2.0-Windows-x86_64.exe)

2. Install pyserial library (version 3.5)

เชื่อมต่อซีเรียลพอร์

โดยปกติแล้วการใช้ USB adapter ในการเชื่อมต่อกับหุ่นยนต์จะต้องเห็นพอร์ทแค่อันเดียวหากไม่ได้เชื่อมต่อกับสิ่งอื่น

แต่เมื่อเชื่อมต่อผ่านทาง Bluetooth จะเห็นพอร์ตที่เชื่อมต่อ 2 พอร์ตดังรูป

เปิด Terminal (เช่น Anaconda Prompt) ใส่พาธที่สคริปต์ตั้งอยู่ (***\serialMaster) คุณสามารถใช้คำสั่งต่อไปนี้ในการเรียกใช้สคริปต์ สคริปต์จะตรวจสอบหมายเลขพอร์ตซีเรียลโดยอัตโนมัติตั้งแต่ต้นและเสร็จสิ้นการเชื่อมต่อ

Run the script

Method 1: Run the ardSerial.py

***\serialMaster>python3 ardSerial.py kbalance

Parameters: kbalance เป็น serial command บ่งบอกถึงสกิลของหุ่นยนต์

แน่นอน คุณยังสามารถเรียกใช้สคริปต์นี้โดยไม่ต้องใส่พารามิเตอร์ใด ๆ:

***\serialMaster>python3 ardSerial.py

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

__main__ - INFO - port[0] is COM11
__main__ - INFO - port[1] is COM5
__main__ - INFO - port[2] is COM10
Waiting for the robot to booting up
Waiting for the robot to booting up
['b', '\n* Start *\nBittle\nReady!\np\n']
Adding COM5
['b', '\n* Start *\nBittle\nReady!\np\n']
Adding COM11
__main__ - INFO - Connect to usb serial port:
__main__ - INFO - COM5
__main__ - INFO - COM11

เมื่อสคริปต์เริ่มทำงานอย่างเป็นทางการ ข้อมูลเตือนต่อไปนี้จะถูกพิมพ์ออกมา:

คุณสามารถพิมพ์ 'quit' หรือ 'q' เพื่อออก

ต่อไปนี้คุณสามารถป้อนคำสั่งซีเรียลใน Terminal เพื่อควบคุมหุ่นยนต์ให้ดำเนินการต่าง ๆ ที่น่าสนใจ 😃 เช่น

Kbalance        # Command to control the robot to stand normally
m 0 -30 0 30    # Command to control the robot head to swing left and right

Method 2: Run the custom scheduler, example.py

***\serialMaster>python3 example.py

รายการ testSchedule ใน example.py ใช้เพื่อทดสอบคำสั่งพอร์ตซีเรียลต่าง ๆ ให้เรียกใช้โค้ดสคริปต์ต่อไปนี้เพื่อดูผลของการดำเนินการของคำสั่งพอร์ตซีเรียลในรายการ:

for task in testSchedule:
    wrapper(task)

คุณยังสามารถอ้างอิงเนื้อหาของรายการ stepUpSchedule (ใน ***\serialMaster\demos\stepup.py) เขียนรายการพฤติกรรมตามความต้องการจริงของคุณ และเปิดเผยความคิดสร้างสรรค์ของคุณ 🤩

หมายเหตุ: เมื่อเรียกใช้สคริปต์ที่อยู่ในพาธ \serialMaster\demos คุณต้องใช้คำสั่ง "cd demos" เพื่อเข้าสู่พาธที่สคริปต์ตั้งอยู่ (\serialMaster\demos) ก่อน แล้วจึงใช้คำสั่ง python3 เพื่อเรียกใช้สคริปต์ (เช่น "python3 stepup.py")

['kbalance', 2]

• 'kbalance' หมายถึงคำสั่งในการควบคุม Bittle ให้ยืนอยู่ในท่าปกติ

• 2 หมายถึงเวลาที่หน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที

['d', 2]

• d หมายถึงคำสั่งในการวางหุ่นยนต์ลงและปิดเซอร์โว

• 2 หมายถึงเวลาที่หน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที

['c', 2]

• c หมายถึงคำสั่งในการเข้าสู่โหมดการคาลิเบรท (calibration mode)

• 2 หมายถึงเวลาที่หน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที หลังจากที่คำสั่งเคลื่อนไหวเหล่านี้เสร็จสิ้น คำสั่งถัดไปจะถูกดำเนินการหลังจากหน่วงเวลา 2 วินาที

['c', [0, -9], 2]

• c หมายถึงคำสั่งในการเข้าสู่โหมดการคาลิเบรท (calibration mode)

• 0 หมายถึงหมายเลขดัชนีของเซอร์โวข้อต่อ (joint servo)

• -9 หมายถึงมุมการหมุน, หน่วยเป็นองศา

• 2 หมายถึงเวลาที่หน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที

โดยใช้รูปแบบนี้คุณสามารถเข้าสู่โหมดการปรับแต่งเพื่อปรับแต่งมุมของเซอร์โวข้อต่อบางตัวได้ หมายเหตุ: หากคุณต้องการให้ค่าการแก้ไขในคำสั่งนี้มีผลให้เกิดผล คุณต้องป้อนคำสั่ง "s" หลังจากดำเนินการคำสั่งนี้

ตัวอย่างนี้หมายถึง เซอร์โวข้อต่อที่มีหมายเลขซีเรียลเป็น 0 หมุน -9 องศา หลังจากที่คำสั่งการเคลื่อนไหวเหล่านี้เสร็จสิ้น คำสั่งถัดไปจะถูกดำเนินการหลังจากหน่วงเวลา 2 วินาที

['m', [0, -20], 1.5]

• m หมายถึงคำสั่งในการควบคุมการหมุนของเซอร์โวข้อต่อ

• 0 หมายถึงหมายเลขดัชนีของเซอร์โวข้อต่อ (joint servo)

• -20 หมายถึงมุมการหมุน (มุมอ้างอิงจากจุดเริ่มต้น ไม่ใช่มุมเพิ่มเติม), หน่วยเป็นองศา

• 1.5 หมายถึงเวลาที่หน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที สามารถเป็นตัวเลขทศนิยมได้

['m', [0, 45, 0, -45, 0, 45, 0, -45], 2]

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

ตัวอย่างนี้หมายถึง หมุนเซอร์โวข้อต่อที่มีหมายเลขดัชนีเป็น 0 ไปยังตำแหน่งมุม 45 องศาก่อน จากนั้นหมุนไปยังตำแหน่งมุม -45 องศา และเช่นนี้ต่อไป หลังจากที่คำสั่งการเคลื่อนไหวเหล่านี้เสร็จสิ้น คำสั่งถัดไปจะถูกดำเนินการหลังจากหน่วงเวลา 2 วินาที

['i', [ 8, -15, 9, -20], 2]

โดยใช้รูปแบบนี้คุณสามารถส่งคำสั่งหมุนของเซอร์โวข้อต่อหลายตัวพร้อมกัน และคำสั่งการหมุนเหล่านี้จะถูกดำเนินการพร้อมกัน มุมของข้อต่อถูกจัดเก็บเป็นตัวอักษร ASCII ดังนั้นสามารถป้อนโดยตรงโดยมนุษย์ได้

ตัวอย่างนี้หมายถึง หมุนเซอร์โวข้อต่อที่มีหมายเลขดัชนีเป็น 8 และ 9 ไปยังตำแหน่งมุม -15 และ -20 องศา พร้อมกัน หลังจากที่คำสั่งการเคลื่อนไหวเหล่านี้เสร็จสิ้น คำสั่งถัดไปจะถูกดำเนินการหลังจากหน่วงเวลา 2 วินาที

['M', [8, 50, 9, 50, 10, 50, 11, 50, 0, 0], 3]

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

• 8, 9, 10, 11, 0 หมายถึงหมายเลขดัชนีของเซอร์โวข้อต่อ (joint servos)

• 50, 50, 50, 50, 0 หมายถึงมุมการหมุนของข้อต่อ (มุมอ้างอิงจากจุดเริ่มต้น ไม่ใช่มุมเพิ่มเติม) หน่วยเป็นองศา

• 3 หมายถึงเวลาหน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที

['I', [20, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 36, 36, 36, 36], 5]

• I หมายถึงคำสั่งในการหมุนของเซอร์โวข้อต่อทั้งหมดพร้อมกัน (ในปัจจุบันคำสั่งรองรับจำนวน 16 ข้อต่อ) มุมของข้อต่อถูกเข้ารหัสเป็นเลขฐานสองเพื่อเพิ่มประสิทธิภาพในการส่งข้อมูล

• 20, 0, 0, 0, 0, 0, 0, 0, 45, 45, 45, 45, 36, 36, 36, 36 หมายถึงมุมการหมุนของข้อต่อแต่ละตัวที่สอดคล้องกับหมายเลขดัชนี 0-15 (มุมอ้างอิงจากจุดเริ่มต้น ไม่ใช่มุมเพิ่มเติม) หน่วยเป็นองศา

• 5 หมายถึงเวลาหน่วงหลังจากเสร็จสิ้นคำสั่ง หน่วยเป็นวินาที

['b', [10,2], 2]

• b หมายถึงคำสั่งในการควบคุมบัซเซอร์ให้ส่งเสียงเป่าวิทยุ (beep)

• 10 หมายถึงเสียงดนตรี (music tone) ที่ใช้ในการสั่งให้บัซเซอร์ส่งเสียง

• 2 หมายถึงความยาวของการเล่นเสียง (duration) ต่อเป็นเวลา 1/duration วินาที

• 2 หมายถึงเวลาหน่วงหลังจากสิ้นสุดการเล่นเสียง หน่วยเป็นวินาที

['b',[0, 1, 14, 8, 14, 8, 21, 8, 21, 8, 23, 8, 23, 8, 21, 4, 19, 8, 19, 8, 18, 8, 18, 8, 16, 8, 16, 8, 14, 4],3]

• b หมายถึงคำสั่งในการควบคุมบัซเซอร์ให้ส่งเสียงเป่าวิทยุ (beep)

• 0, 14, 14, 21... หมายถึงเสียงดนตรี (music tone) ที่ใช้ในการสั่งให้บัซเซอร์ส่งเสียง ตามลำดับเสียง

• 1, 8, 8, 8 หมายถึงความยาวของการเล่นเสียง (duration) ต่อเป็นเวลา 1/duration วินาที โดยเรียงตามเสียงดนตรีที่กำหนด ในที่นี้คือ 0, 14, 14, 21...

• 3 หมายถึงเวลาหน่วงหลังจากเสียงดนตรีเล่นเสร็จ หน่วยเป็นวินาที

ใช่ ด้วยคำสั่ง tone คุณสามารถสร้างเสียงดนตรีง่าย ๆ หรือเล่นทั้งหมดในครั้งเดียวกันได้ โดยใช้รูปแบบดังตัวอย่างที่กล่าวมาก่อนหน้านี้

ความหมายของตัวอย่างนี้คือ: เล่นทั้งหมดของสัมผัสด้วยเสียงดนตรีแบบง่าย ๆ และหน่วงเวลา 3 วินาทีหลังจากที่สัมผัสด้วยเสียงดนตรีเสร็จสิ้น

ck = [

-3, 0, 5, 1,

0, 1, 2,

45, 0, 0, 0, 0, 0, 0, 0, 45, 35, 38, 50, -30, -10, 0, -20, 6, 1, 0, 0,

-45, 0, 0, 0, 0, 0, 0, 0, 35, 45, 50, 38, -10, -30, -20, 0, 6, 1, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 30, 30, 30, 30, 30, 30, 30, 30, 5, 0, 0, 0,

]

['K', ck, 1]

• 'K' หมายถึงข้อมูลทักษะ (skill data) ที่ส่งให้กับ Bittle ในเวลาเดียวกัน (realtime) โดยต้องใช้ฟอร์แมตของสตริงและรหัสของทักษะที่ต้องการส่งขึ้นไปใน Bittle

• อาเรย์ของทักษะจะถูกส่งไปยังหุ่นยนต์และทำงานโดยการประมวลผลที่ตัวหุ่นยนต์ (execute locally on the robot) โดยไม่ต้องส่งข้อมูลกลับมายังคอมพิวเตอร์หรืออุปกรณ์อื่น ๆ อาทิเช่น Raspberry Pi หรือเซิร์ฟเวอร์

• คุณสามารถแทรกทักษะลงในไลบรารีของทักษะ (skill library) หรือ InstinctX.h โดยใช้รูปแบบนี้

สำหรับคำอธิบายของคำสั่งอื่น ๆ บนพอร์ตซีเรียลโปรต์ โปรดอ้างอิงตามเอกสาร Serial Commands. นี้

Pleaseขอให้นี่เป็นแรงบันดาลใจสำหรับการช่วย Nybble และ Bittle ในการค้นหาแรงบันดาลใจของพวกเขา และขอให้คุณมีความสุขกับการเล่น! 😍

การสอนที่ผ่านมาช่วยให้หุ่นยนต์สามารถดำเนินการแบบเป็นลำดับได้โดยการแก้ไขโค้ด Python แบบออฟไลน์ แต่วิธีนี้ไม่สะดวกเพราะเมื่อต้องการแก้ไขโค้ด เราจะต้องถอด WiFi module ออกและแก้ไขในโหมดออฟไลน์ และเราไม่สามารถหยุดโปรแกรมและแก้ไขพารามิเตอร์ได้โดยยืดหยุ่น สาเหตุเพราะ ESP8266 มีพอร์ตซีเรียลเพียงตัวเดียว และเราต้องใช้มันในการสื่อสารกับ NyBoard โดยดีอีกฝั่ง MicroPython ใช้ฟังก์ชั่น WiFi ที่ ESP มีให้เพื่อให้สามารถทำการดีบั๊กโค้ด Python แบบไร้สายได้ผ่าน WebREPL

The official document

ด้วยเอกลักษณ์ของ ESP8266 และเอกสารอย่างเป็นทางการ ทางเราได้เขียนคู่มือต่อไปนี้:

1. Enable webREPL

หลังจากเชื่อมต่ออุปกรณ์แล้ว ให้เข้าสู่อินเตอร์เฟสของ MicroPython แล้วพิมพ์คำสั่งimport webrepl_setup webrepl_setup และทำตามขั้นตอนตามคำแนะนำ:

1. การเปิดใช้งาน WebREPL เมื่อเปิดเครื่อง: E

2. ตั้งค่ารหัสผ่านสำหรับ WebREPL โดยใช้คำสั่ง "Set password for it" และกรอกรหัสผ่านที่ต้องการ (เช่น 1234)

3. การตั้งค่าเรียบร้อยแล้ว ให้ปิด shell โดยการพิมพ์ exit() แล้วกด Enter เพื่อออกจากโหมด shell และกลับไปยังหน้าจอคำสั่ง Thonny

4. รีบูทโดยการพิมพ์y reboot the ESP8266: y

2. The script to setup webREPL

เราใช้สคริปต์ตัวอย่างด้านล่างนี้ เพื่อแทนที่ SSID และรหัสผ่านด้วยข้อมูลเครือข่ายของคุณในบริเวณใกล้เคียง:

import network
import time
import webrepl

def do_connect():
    
    # WiFi SSID and Password
    wifi_ssid = "YOUR SSID"             # YOUR WiFi SSID
    wifi_password = "YOUR PASSWORD"     # YOUR WiFi PASSWORD

    # Wireless config : Station mode
    station = network.WLAN(network.STA_IF)
    station.active(True)

    # Continually try to connect to WiFi access point
    while not station.isconnected():
    
        # Try to connect to WiFi access point
        print("Connecting...")
        station.connect(wifi_ssid, wifi_password)
        time.sleep(10)

    # Display connection details
    print("Connected!")
    print("My IP Address:", station.ifconfig()[0])
    

if __name__ == "__main__":
    do_connect()
    webrepl.start()

หลังจากเรียกใช้งานสคริปต์ มันจะพยายามเชื่อมต่อกับเครือข่าย WiFi อยู่เสมอ และเมื่อเชื่อมต่อสำเร็จแล้ว มันจะเริ่มต้น WebREPL service ของอุปกรณ์โดยอัตโนมัติ

Connected!
My IP Address: 192.168.xxx.xxx
WebREPL daemon started on ws://192.168.xxx.xxx:8266
Started webrepl in normal mode

IP address นี้จะถูกกำหนดโดย DHCP ของเร้าเตอร์ ดังนั้นอาจจะเปลี่ยนไปตามเครือข่ายและการกำหนดค่าของเร้าเตอร์ กรุณาจำ IP address นี้เพื่อนำไปใช้ในการตั้งค่า WebREPL ต่อไป

3. Configure the WebREPL service

ขณะนี้เรากำลังดีบักสคริปต์ Python ผ่าน WebREPL และพอร์ตซีเรียลก่อนหน้านั้นถูกใช้สื่อสารกับ NyBoard ดังนั้นในตัวเลือก ให้เปลี่ยนพอร์ต USB-COMx ก่อนหน้านี้เป็น WebREPL

จากนั้นให้กรอกที่อยู่ IP, พอร์ต และรหัสผ่านของ WebREPL แล้วคลิก OK.

When WebREPL Connected is displayed, the connection is successful.

คุณสามารถทดสอบตัวอย่างอย่างง่ายได้ที่ blink.py.

WebREPL เป็นการบันทึกพอร์ตซีเรียลและรองรับการ Debug ไร้สาย ข้อเสียคือความเร็วช้า (เนื่องจากการล่าช้าของเครือข่าย) และเวลารอการรีเซ็ตซอฟต์แวร์ยาว ๆ

4. Separate the serial port from the debugger

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

เราหวังว่าเมื่อดีบั๊กโปรแกรม ซีเรียลพอร์ตจะแสดงเฉพาะคำสั่งที่เราต้องการ ไม่ใช่ข้อมูล Debug ที่ไม่จำเป็น เปิดไฟล์ boot.py บนอุปกรณ์ แก้ไขหมายเลขบรรทัด uos.dupterm(None, 1) และบันทึก ให้ยกเลิกการผูกพอร์ตซีเรียลและ REPL debug รีสตาร์ทโมดูล และจะไม่มีข้อมูลดีบั๊กถูกแสดงบนซีเรียลพอร์ต ดังตัวอย่าง:

เพื่อเพิ่มความสมบูรณ์ เราสามารถแสดงข้อมูล debug ผ่าน print() statement ซึ่งจะถูกแสดงใน Shell ผ่าน WiFi

ด้วยการใช้ ESP8266 และ webREPL คุณสามารถแก้ไขลำดับการทำงานของหุ่นยนต์ด้วย MicroPython ได้อย่างสะดวกด้วยครับ

เราได้กำหนดชุดของซีเรียลโปรโตคอลสำหรับหุ่นยนต์:

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

สามารถทดลองคำสั่งของซีเรียลได้ที่ the serial monitor:

• “ksit”

• “m0 30”

• “m0 -30”

• “kbalance”

• “kwkF”

• “ktrL”

• “d”

คุณสามารถอ้างอิงถึงคำนิยามแมโครใน OpenCat.h เพื่อใช้ชุดโทเคนที่มีการอัปเดตล่าสุด

บางคำสั่งที่มีให้ใช้สำหรับทักษะหุ่นยนต์เพิ่มเติม:

ชุดความสามารถที่สมบูรณ์และใช้งานอยู่ถูกกำหนดไว้ใน InstinctBittle.h หรือ InstinctNybble.h: ตัวอย่างเช่น :

const char* skillNameWithType[]={"bdFI","bkI","bkLI","crFI","crLI","hlwI","mhFI","mhLI","pcFI","phFI","phLI","trFI","trLI","vtFI","vtLI","wkFI","wkLI","balanceI","buttUpI","calibI","droppedI","liftedI","restI","sitI","strI","zeroN","bfI","ckI","climbCeilI","fdI","ffI","hiI","jyI","pdI","peeI","puI","pu1I","rcI","rlLI","rtI","stpI","tsI",};

ชื่อทักษะทั้งหมดในรายการสามารถเรียกใช้งานโดยการเพิ่ม 'k' ไปด้านหน้าและลบคำต่อท้าย ตัวอย่างเช่น มี "sitI" อยู่ในรายการ คุณสามารถส่ง "ksit" เพื่อเรียกท่านั่ง หากทักษะมีอักขระ "F" หรือ "L" เป็นอักขระที่สองจากท้าย นั่นเป็นการเดิน หมายความว่าเดินไปข้างหน้าหรือไปทางซ้าย เดินไปทางขวาเป็นการสะท้อนของการเดินไปทางซ้าย ดังนั้นคุณสามารถส่ง "kwkF", "kwkL", "kwkR" เพื่อให้หุ่นยนต์เดิน ในทำนองเดียวกัน ยังมีการเดินแบบอื่น ๆ เช่น รถโรงเรียน ("tr"), คลาน ("cr"), และการเดินขาละขา ("vt")

Part 1: Hardware Setup

1.1 hardware list

• USB Uploader (CH340C)

• WiFi ESP8266

1.2 Connection

นำโมดูล ESP8266 แทนที่ลงในอินเทอร์เฟซการกำหนดค่าโมดูลของ USB uploader แล้วค้นหาพอร์ต COM ที่เกี่ยวข้องใน Windows device manager

Part 2: Software Setup

2.1 Download Thonny

ดาวน์โหลดเวอร์ชันล่าสุดของ Thonny ซึ่งเป็นตัวแก้ไข Python แบบติดตั้งพร้อมใช้งาน MicroPython ได้เลย

Download address: https://thonny.org/

2.2 Download the MicroPython firmware

ซอฟต์แวร์ ESP8266 ที่คอมไพล์แล้วถูกจัดหาไว้ในเว็บไซต์อย่างเป็นทางการของ MicroPython เนื่องจากโมดูล WiFi ของเราเป็นขนาด 4MB ดังนั้นโปรดเลือกซอฟต์แวร์ล่าสุดที่มีชื่อว่า ESP8266 พร้อมกับ 2MiB+ flash และดาวน์โหลดไฟล์ bin นั้น

Firmware download address: https://micropython.org/download/esp8266/

2.3 Upload the MicroPython firmware to the ESP8266 module

มีวิธีการอัพโหลดซอฟต์แวร์ MicroPython ไปยังโมดูล ESP8266 2 วิธีด้วยกัน:

• การใช้เครื่องมือดาวน์โหลด ESPtool ช่วยให้คุณสามารถควบคุมพาร์ติชันและการใช้งาน Flash ได้อย่างแม่นยำมากกว่า

• การใช้เครื่องมือที่ซ่อนอยู่ใน Thonny

เพื่อความสะดวก เราจะใช้เครื่องมือที่ซ่อนอยู่ใน Thonny ขั้นตอนการใช้งานคือดังนี้:

1. เปิดโปรแกรม Thonny หน้าต่างหลักจะเป็นดังรูปด้านล่าง โดย Thonny จะใช้ Python interpreter ในไดเร็กทอรีการติดตั้งโดยปริยาย
2. เลือก Tools -> Options เพื่อเข้าสู่หน้าต่างตัวเลือก ในแท็บ General สามารถเลือกภาษาที่ต้องการได้ (ต้องรีสตาร์ทโปรแกรม)
3. เปิด Thonny และเลือกหัวข้อ Tools -> Options เพื่อเข้าสู่หน้าต่างตัวเลือก ในแท็บ General ให้เลือกภาษาที่เราต้องการ (จะต้องทำการรีสตาร์ท) และในแท็บ Interpreter เราจะเปลี่ยน Interpreter เริ่มต้นจาก Python3 มาเป็น MicroPython (ESP8266) และเลือกพอร์ตที่ถูกต้อง
4. ในขณะนี้โมดูล ESP8266 ยังไม่ได้อัปโหลดฟิร์มแวร์ MicroPython ให้คลิกที่ "Install or update firmware" ที่มุมล่างขวาของรูปภาพด้านบนเพื่ออัปเดตฟิร์มแวร์โดยใช้เครื่องมือที่มีอยู่ในโปรแกรม Thonny

5. เลือกพอร์ต (COMx) ที่ ESP8266 module อยู่และเลือกตำแหน่งที่อยู่ของ firmware MicroPython (.bin file) ที่ดาวน์โหลดมา ตรวจสอบโหมดแฟลช: from image file (keep) (ความเร็วจะช้าลง แต่มันเพียงแค่ต้องไหวทนและไม่ง่ายต่อการทำผิดพลาด) และเลือกตัวเลือก Erase flash before installing กดปุ่ม Install
6. ขั้นตอนนี้จะแสดงความคืบหน้าในมุมมองด้านล่างของอินเทอร์เฟซ โปรแกรมจะเริ่มลบ Flash ก่อนแล้วจึงเขียน Firmware จากนั้นจะแสดงคำว่า "Done" เมื่อการโปรแกรมเสร็จสมบูรณ์
7. การเตรียมซอฟต์แวร์เสร็จสิ้นแล้ว และหน้าจอด้านล่างจะปรากฏขึ้นหลังจากปิดอินเตอร์เฟซการดาวน์โหลด ข้อความสีแดงเป็นเกี่ยวกับการพิมพ์ของ ESP8266 เนื่องจาก ESP8266 จะพิมพ์สตริงของรหัสด้วยอัตราเร็ว baud ที่แตกต่างกับ 115200 เมื่อเริ่มต้น สตริงรหัสนี้ไม่สามารถรู้จักได้โดย MicroPython Shell การปรากฏเครื่องหมาย >>> ของ Python แสดงว่า Firmware ถูกอัปโหลดสำเร็จ

คุณสามารถประสานซ็อกเก็ต 2x5 บน Nyboard เพื่อเสียบ Raspberry Pi PI 3A+ เป็นแบบที่ดีที่สุดสำหรับ มิติของ Nyboard

Nybble

Bittle

• Ascii: ใช้ 2 ไบต์เพื่อเก็บอักขระ Ascii '6' และ '5'

• Binary: ใช้ 1 byte เพื่อจัดเก็บค่า 65 ซึ่งเปรียบเสมือนกับตัวอักษร Ascii 'A'

1. Config Raspberry Pi serial port

In Pi's terminal, type sudo raspi-config

ในตัวเลือก Interface ให้ค้นหา Serial แล้วปิดการเข้าสู่ระบบ shell ผ่านทางซีเรียลและเปิดใช้งานอินเทอร์เฟซซีเรียลเพื่อใช้พอร์ต UART หลัก:

1. Run raspi-config with sudo privilege: sudo raspi-config.

2. Find Interface Options -> Serial Port.

3. At the option Would you like a login shell to be accessible over serial? select 'No'.

4. At the option Would you like the serial port hardware to be enabled? select 'Yes'.

5. Exit raspi-config and reboot for changes to take effect.

ถ้าคุณเชื่อมต่อ Pi เข้ากับช่อง 2x5 ของ NyBoard แล้ว พอร์ตซีเรียลของพวกเขาควรจะเชื่อมต่อโดยอัตโนมัติที่แรงดัน 3.3V อย่างไรก็ตามหากไม่ได้เชื่อมต่อแบบนี้ คุณควรใช้หลอดสายขนาดเล็กเพื่อเชื่อมต่อ Rx และ Tx ของชิป AI ของคุณกับ Tx และ Rx ของ NyBoard โดยให้แรงดันตรงกัน

ถ้าคุณต้องการรันโปรแกรมเป็นคำสั่ง bash คุณต้องทำให้โปรแกรมสามารถรันได้:

chmod +x ardSerial.py

คุณอาจจะต้องเปลี่ยน path ที่ถูกต้องของ Python binary บนบรรทัดแรก:

#!/user/bin/python

3. Use ardSerial.py as the commander of robot

พิมพ์ ./ardSerial.py <args> เทียบเท่ากับการพิมพ์ ใน Arduino's serial monitor โดยตัวอย่างเช่น ./ardSerial.py kcrF หมายความว่า "ทำการเคลื่อนที่ด้วยทักษะคลานไปข้างหน้า".

การทำงานของ ardSerial.py และการแยกวิเคราะห์ใน OpenCat.ino ต้องการการปรับปรุงเพิ่มเติมเพื่อรองรับคำสั่งซีเรียลทั้งหมดในโปรโตคอล

1. บทนำ

BiBoard เป็นบอร์ดควบคุมหุ่นยนต์สุนัขที่ใช้ ESP32 พัฒนาโดย Petoi LLC ไม่เหมือนกับ NyBoard สำหรับผู้ใช้ทั่วไปและผู้ชื่นชอบหุ่นยนต์ BiBoard มุ่งเน้นไปที่นักพัฒนาและผู้เชี่ยวชาญเป็นหลัก โปรเซสเซอร์ประสิทธิภาพสูง หน่วยความจำและพื้นที่เก็บข้อมูลขนาดใหญ่ขึ้น การเชื่อมต่อไร้สาย และฟังก์ชั่นเสียงรวมอยู่ด้วย

2. โมดูลและฟังก์ชัน

การแบ่งฟังก์ชันสำหรับ BiBoard แสดงอยู่ด้านล่าง:

บล็อกไดอะแกรมสำหรับ BiBoard แสดงไว้ด้านล่าง:

3. รายละเอียดโมดูล:

3.1 Power

มี 2 วิธีในการจ่ายไฟให้กับ BiBoard: USB 5V และช่องเสียบแบตเตอรี่ 7.4V

เมื่อใช้พลังงานจาก USB จะไม่มีเอาต์พุตพลังงานสำหรับส่วนขยาย DC-DC 5V และเซอร์โว

เมื่อใช้พลังงานแบตเตอรี่ที่ 7.4V (สูงสุด: 8.4V) จะจ่ายทั้งเซอร์โวและส่วนไฟ 5V คุณสามารถใช้ 5V จ่ายไฟให้กับ Raspberry Pi

3.2 โมดูลบนบอร์ด

3.2.1 ตั้งค่าสภาพแวดล้อมการพัฒนา ESP32

เปิด "Preferences" ใน Arduino เพิ่ม URL ของบอร์ดพัฒนา ESP32:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

บันทึกแล้วออก

เปิด “Boards Manager...” และรอการอัปเดตจากลิงก์สนับสนุนบอร์ดภายนอก ค้นหา “esp32” และดาวน์โหลดแพ็คเกจสนับสนุนล่าสุด

หลังจากแสดง “INSTALLED” แสดงว่าแพ็คเกจสนับสนุนบอร์ด BiBoard เสร็จสิ้น

3.2.2 USB Downloader

ไม่มีวงจร USB ใน ESP32 ดังนั้นเราจึงใช้สะพาน USB CP2102 ตามคำแนะนำอย่างเป็นทางการ ดาวน์โหลดสูงสุดคือ 921600 โดยสะพานเชื่อมต่อกับ serial1 ของ ESP32

เราใช้พอร์ต USB Type-C ตัวต้านทาน 2 ตัว CC1 และ CC2 ถูกเพิ่มเป็นตัวระบุ

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

ทรานซิสเตอร์จะรับสัญญาณโมเด็มอนุกรมมาตรฐาน DTR และ RTS และทริกเกอร์ลำดับเวลาเฉพาะที่บังคับให้ ESP32 เข้าสู่โหมดดาวน์โหลด จากนั้นรีบูต รายละเอียดของวงจรดาวน์โหลดอัตโนมัติแสดงไว้ด้านล่าง

3.2.3 IMU

เราใช้ Invensense MPU6050 ซึ่งเป็น IMU ที่ใช้กันอย่างแพร่หลาย ที่อยู่ I2C ของมันคือ 0x68 และการขัดจังหวะของ DMP เชื่อมต่อกับ IO26 ของ ESP32

ด้วยความช่วยเหลือของไลบรารี MPU6050 DMP ของ Jrowberg คุณสามารถรับสถานะการเคลื่อนไหวของ Bittle ได้อย่างง่ายดาย ไลบรารี MPU6050 ของ Jrowberg ต้องถูกแก้ไขเพื่อปรับให้เข้ากับ ESP32 ชนิดข้อมูลของ “int8” และ “PGMSpace” ควรได้รับการกำหนดไว้ล่วงหน้าแทน 8-bit AVR macros เราขอเสนอไลบรารีที่แก้ไขแล้วของ MPU6050 คุณสามารถเปลี่ยนไลบรารีเดิมเพื่อให้ทั้งบอร์ด AVR และบอร์ด ESP ทำงานได้ตามปกติ

3.2.4 EEPROM

บน BiBoard มี EEPROM 64Kbit คุณสามารถใช้ EEPROM อ่านและเขียนโปรแกรมที่ใช้กับ Arduino UNO ได้โดยตรง คุณสามารถใช้เพื่อเก็บข้อมูลการตั้งค่าเริ่มต้น นอกจากนี้ยังมีตัวอย่างโปรแกรมชื่อ “EEPROM” ในแพ็คเกจสนับสนุน ESP32 นี่ไม่ใช่โปรแกรมสาธิตของ I2C EEPROM นี่คือการสาธิต EEPROM จำลองโดยหน่วยความจำแฟลช QSPI ของ ESP32

3.2.5 DAC and audio applications

เราใช้เอาต์พุต DAC และ class-D แอมพลิฟายเออร์ แทน PWM buzzer เพื่อทำให้ Bittle สดใสยิ่งขึ้น คุณสามารถใช้ 3 วิธีในการขับโมดูลเสียง:

1. ใช้ฟังก์ชัน "Tone()" ของ Arduino

2. ใช้ฟังก์ชัน “dacWrite()” ของ ESP32 เหมือน “analogWrite()” ของ Arduino โดยคุณภาพข้อมูลที่โดย DAC นั้นดีกว่า PWM

3. ใช้ไลบรารีถอดรหัส MP3 ของ ESP ที่พัฒนาโดย XTronical คุณสามารถเล่นไฟล์ MP3 ได้ คุณควรกำหนดค่าระบบไฟล์เช่น SPIFFS หรือ FAT ในแฟลชก่อนที่คุณจะใช้ตัวถอดรหัส MP3 นี้

3.2.6 IR modules

เซ็นเซอร์ IR บน Nyboard และ BiBoard เหมือนกัน คุณจึงสามารถใช้ sketch จาก Nyboard ได้โดยตรง แฟลชของ BiBoard มีขนาดใหญ่พอ ดังนั้นคุณจึงไม่ต้องปิดใช้งาน macros ใน IRremote.h

4. Servo sockets

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

5. Extension sockets

มีช่องเสียบส่วนขยาย 3 ช่องบน BiBoard ที่มีเครื่องหมาย P15, P16 และ P17

5.1 Analog input sockets（P15）

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

5.2 Bus extension sockets（P16）

ช่องนี้ใช้สำหรับส่วนขยายบัสของ ESP32

5.3 Raspberry Pi interface (P17)

คุณสามารถใช้อินเทอร์เฟซนี้เพื่อเชื่อมต่อกับ Raspberry Pi ได้ แต่คุณไม่สามารถต่อเชื่อม Raspberry Pi เหนือ BiBoard ได้โดยตรง คุณต้องใช้สายไฟหรืออะแดปเตอร์แทน

มี ให้นักพัฒนาเชื่อมต่อกับ environment.ได้อย่างสะดวกสบาย แนะนำให้ใช้ ROS ร่วมกับ .

Using ROS on Raspberry Pi

ในปัจจุบัน แนะนำให้ติดตั้ง ROS โดยใช้ Docker

• install docker on Raspberry Pi ()

• prepare workspace

• run the container

• source files and build inside the container

Using ROS for remote control

ROS ถูกออกแบบมาเพื่อให้เหมาะสมกับการคำนวณแบบกระจาย ต่อไปนี้เป็นตัวอย่างง่ายๆ เกี่ยวกับวิธีการเรียกใช้โหนดบนเครื่องคอมพิวเตอร์ต่างกัน

• on host machine (usually more powerful than Raspberry Pi)

• run service node on Raspberry Pi

• send command from host

Examples

• using serial library

• using ROS service

Update：

NyBoard V1_1 เป็นเวอร์ชันที่อัปเกรดมาจาก V1 โดยมุ่งเน้นไปที่ปัญหาขาดแคลนของ ATMEGA328P-MU ในเครือข่ายการจัดหาวัสดุอุปกรณ์ของเรา

1. แทนที่ ATMEGA328P-MU (QFN32=) ด้วย ATMEGA328P-AU (TQFP32)

2. นำ 7 ดวง WS2812 LED ออกเพื่อเพิ่มพื้นที่บนบอร์ด

3. เพิ่ม LED สีเขียวที่ต่อกับพอร์ต D10 และมีฟังก์ชัน PWM

4. ไม่มีการเปลี่ยนแปลงสำหรับ socket และการกำหนดขาต่อจาก V1_0 โปรแกรมบูตและโค้ด OpenCat ยังคงเข้ากันได้อย่างเต็มที่

Overview

บอร์ด NyBoard V1 เป็นเวอร์ชันที่อัพเกรดขึ้นมาจากการรับความคิดเห็นจากผู้ใช้งานกับ NyBoard V0 โดยยังคงรองรับการใช้งานกับเวอร์ชันก่อนหน้า แต่มีการออกแบบใหม่เพื่อทำให้ใช้งานง่ายขึ้น

• NyBoard V1 ยังใช้ Atmel ATMega328P เป็นชิปหลัก แต่เปลี่ยนความถี่ให้เป็น 16MHz โดยไม่ต้องเร่งความถี่ไปยัง 20MHz ตอนนี้บอร์ดเป็นเวอร์ชันที่เข้ากันได้อย่างเต็มที่กับ Arduino Uno จึงทำให้ผู้ใช้ใหม่ที่ไม่เคยใช้ Arduino มาก่อนสะดวกในการใช้งาน

• NyBoard V1 ยังสามารถขับได้ถึง 16 ช่อง PWM ด้วย PCA9685 โดยเรียงลำดับขาแตกต่างจากเดิม แต่ไม่จำเป็นต้องอ่านหมายเลขดัชนีบนบอร์ดเพราะการเชื่อมต่อขานี้ถูกจัดการในซอฟต์แวร์อย่างถูกต้อง

• เซ็นเซอร์การเคลื่อนไหว 6 แกนของ MPU6050 ออกแบบมาบน PCB แทนที่จะเป็นโมดูลแยกต่างหากที่ติดตั้งเหนือบอร์ด มันสนับสนุน DMP (Digital Motion Processor) ซึ่งสามารถคำนวณข้อมูลการเคลื่อนไหวได้โดยตรงและยังมีข้อมูลแบบดิบสำหรับผสมผสานและแยกสัญญาณเองได้

• NyBoard V1 ยังคงใช้ EEPROM 8KB onboard I2C เพื่อบันทึกค่าคงที่สำหรับทักษะต่าง ๆ

• ระบบไฟฟ้าได้รับการออกแบบใหม่เพื่อให้ได้กำลังไฟที่เสถียรมากขึ้น โครงสร้างของอุปกรณ์

• ตั้งแต่วันที่ 1 มกราคม 2021 เราเริ่มรวมดองเกิลบลูทูธอย่างเป็นทางการเพื่อการอัปโหลดและสื่อสารไร้สาย ค่าเริ่มต้นสำหรับอัตราการสื่อสารทั้งหมดจะถูกตั้งค่าไว้ที่ 115200

• ปุ่มรีเซ็ตอยู่ใกล้เข้าถึงมากขึ้นที่ด้านหลังของบอร์ด

• เราได้เพิ่ม 4 ช่องต่อ Grove เพื่อเป็นการเชื่อมต่อแบบ plug-and-play กับโมดูลขยายของ Seeed Studio โดยยังคงให้แผงวงจรมาตรฐานที่มีรูเข็มขัดขนาด 2.54 มม. เช่นเดิม

• สายสัญญาณสำหรับแบตเตอรี่ที่ใช้ต่อกับแผงวงจรเป็นสายแบบ anti-reverse ซึ่งจะช่วยป้องกันการเสียหายจากการต่อผิดขั้ว

Logic diagram of the controller

The configuration of NyBoard V1_0 is shown as below:

Introduction to the onboard components

Main controller

NyBoard V1_0 ใช้ Atmel ATMega328P-AU เป็นชิปหลัก เหมือนกับ MCU ของ Arduino Nano (UNO Compatible)

ATMega328P ทำงานที่ความถี่ 16MHz และมีแหล่งจ่ายไฟ 5V มี SRAM 2KB, Flash 32KB และ on-chip EEPROM 1KB ด้วย bootloader เดียวกับ Arduino Uno คุณสามารถอัพโหลดสคริปต์ผ่านพอร์ตซีเรียลได้เลย

LED（NEW!)

ได้ทำการเปลี่ยน WS2812 ที่เป็น LED RGB แบบต่อเซียงกันเป็น LED เดียวสีเขียวเท่านั้น สามารถใช้คำสั่งควบคุม GPIO ของ Arduino ได้อย่างง่ายดาย

I2C switch

ชิปหลักทำงานที่แรงดัน 5V ในขณะที่อุปกรณ์เสริมอื่น ๆ ทำงานในระดับตรรกะ 3.3V เราใช้ PCA9306 เพื่อแปลงบัส I2C ของ ATMega328P ให้เป็น 3.3V นอกจากนี้เรายังเพิ่มสวิทช์บนบัส I2C ซึ่งจะช่วยเปลี่ยน I2C master ของอุปกรณ์เสริมบนบอร์ดได้ โดยสามารถหมุนสวิทช์ไปที่ "Arduino" หรือ "Raspberry Pi" เพื่อเปลี่ยน I2C master ของอุปกรณ์บนบอร์ดได้

6-Axis IMU MPU6050

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

บน NyBoard V1_0 ที่อยู่ I2C ของ MPU6050 คือ 0x68 และหมุนเวียน ของ MPU6050 ถูกเชื่อมต่อกับพอร์ต PD2 ของ ATMega328P (หรือพอร์ต D2 ของ Arduino Uno) โดยใช้ Interrupt pin

มีหลายไลบรารีสำหรับ MPU6050 ที่มีอยู่แล้วและเราใช้ I2CDev/6050DMP ใน NyBoard V1_0 อย่างไรก็ตาม คุณยังสามารถใช้เวอร์ชันอื่น ๆ ได้ด้วย

PCA9685 and the PWM servo ports

PCA9685 แบ่งออกเป็น 16 ช่อง PWM ที่มีความละเอียด 12 บิตด้วยคำสั่งจากพอร์ต I2C โดยมีที่อยู่ตั้งค่าไว้ที่ 0x40 บนบอร์ด มีหมายเลขช่อง PWM ทั้งหมด 16 ช่องพิมพ์บน PCB อยู่แล้ว แต่คุณไม่จำเป็นต้องอ่านหมายเลขนี้เนื่องจากการแมปพินได้ถูกตั้งค่าเป็นอัตโนมัติผ่านซอฟต์แวร์ แบบจับตามกลุ่มของขาเชื่อมต่อเหมือนเดิมกับรุ่นก่อนหน้า ในการต่อเซอร์โวต้องตรวจสอบทิศทางของขาเซอร์โว ซึ่งมักมี 3 ขา คือ PWM, ไฟ (2S) และ GND (อีกชื่อหนึ่งคือแบตเตอรี่) ขา GND ควรเชื่อมต่อกับสายสีดำของเซอร์โว

บน NyBoard V1_0 พลังงานไฟฟ้าของเซอร์โวต่อกับแบตเตอรี่ไอออน 2S โดยตรง โดยเราออกแบบเซอร์โวของเราให้เข้ากันได้กับแหล่งจ่ายไฟ 8.4V แบบปกติ ซึ่งเซอร์โวปกติทำงานที่แรงดันไฟฟ้า 6V คุณไม่ควรเชื่อมต่อเซอร์โว 9g ปกติเช่น SG90 โดยตรงกับบอร์ด

เราใช้ไลบรารี่ Adafruit PWM Servo Driver Library สำหรับ PCA9685

EEPROM

เราใช้หน่วยความจำในตัวชิป AT24C64 ที่ติดตั้งบนบอร์ดเพื่อเก็บข้อมูลทักษะการเคลื่อนไหว มันมีที่อยู่ I2C เป็น 0x54 ตารางค้นหาของทักษะถูกบันทึกไว้ในหน่วยความจำ EEPROM ในตัวชิป ATMega328P ขนาด 1KB โดยเราใช้ไลบรารี <EEPROM.h> ดังนั้นคุณควรใส่ใจกับความแตกต่างของพวกเขาเมื่อพัฒนาโค้ดใหม่

Passive buzzer

เราใช้ขา PD5 (หรือ D5 ของ Arduino UNO) เพื่อขับเสียงบัสเซอร์ และกระแสไฟจะถูกขยายโดย MOS 2N7002

Infrared receiver

เราใช้ VS1838B เป็นตัวรับสัญญาณอินฟราเรด ที่เชื่อมต่อกับ PD4 (หรือ D4 บน Arduino Uno) โดยใช้ไลบรารี IRremote ของ Arduino และรีโมทที่เข้ารหัสในรูปแบบ NEC คุณสามารถปิดใช้งานโปรโตคอลอื่นๆ ใน IRremote.h เพื่อประหยัดพื้นที่หน่วยความจำแฟลชได้ถึง 10%

Voltage detector

หลอด LED 2 ดวงในโลโก้ของ Petoi แสดงสถานะการเปิดเครื่องของบอร์ด ดวงตาซ้ายสีน้ำเงินแสดงสถานะของชิปต่างๆ ดวงตาขวาสีเหลืองแสดงสถานะของพลังงานสำหรับเซอร์โว การเชื่อมต่อกับแบตเตอรี่ ทั้ง 2 ดวงจะติดขึ้น แต่ถ้า NyBoard ถูกเชื่อมต่อกับ USB downloader ดวงตาสีน้ำเงินเท่านั้นที่จะติดขึ้น

มีช่องรับแบตเตอรี่ป้องกันการกลับด้าน และผลลัพธ์การเชื่อมต่อของแบตเตอรี่ถูกเชื่อมต่อกับ ADC7 (หรือ A7 ของ Arduino Uno) และไม่ได้เกี่ยวข้องกับขาอื่นๆบนบอร์ด ADC7 จะเก็บรวบรวมแรงดันไฟฟ้าที่แบตเตอรี่ผ่านตัวหารแรงดัน และแรงดันที่อ่านได้จะเป็นประมาณ 2 เท่าของค่าที่แสดงออกมา ระดับแรงดันที่ปลอดภัยของแบตเตอรี่อยู่ในช่วงต่ำกว่า 10V

คุณควรชาร์จแบตเตอรี่ทันทีเมื่อแบตเตอรี่ต่ำกว่า 7.4V

Grove sockets

เราใช้ตัวจับสายปลั๊กแบบ Grove เพื่อให้สะดวกในการเสียบและใช้งาน มีปลั๊กแบบนี้ทั้งหมด 3 ชนิด:

Power system

ชิปหลักถูกจ่ายไฟโดย Low-dropout (LDO) linear regulator เพื่อลดเสียงรบกวนและเพิ่มความเสถียรภาพ โดยใช้ LM1117-5V และ XC6206P-3.3V เพื่อจ่ายไฟ 5V และ 3.3V โดยที่ LDO ของแต่ละแรงดันเชื่อมต่อต่อเนื่องกันเพื่อเพิ่มประสิทธิภาพ

มีไดโอดอยู่ระหว่างแบตเตอรี่และ LM1117-5V เพื่อป้องกันการเชื่อมต่อผิดพลาด และมีฟิวส์ที่ฟื้นตัวเอง (6V 500mA) บน USB uploader เพื่อจำกัดกระแสและป้องกันพอร์ต USB

Raspberry Pi ใช้พลังงานมากกว่านี้ ดังนั้นเราเลือก TPS565201 DC-DC เพื่อให้ผลลัพธ์ไฟฟ้าเป็น 5V 3A สูงสุดถึง 5A และมีการป้องกันอุณหภูมิ/กระแส/แรงดันสูง หากชิปส่งออกพลังงานเกิน 4A และอุณหภูมิเกิน 100 องศาเซลเซียส จะตัดการจ่ายไฟไปจนกว่าอุณหภูมิจะกลับสู่ปกติ

เซอร์โวขับเคลื่อนด้วยแบตเตอรี่ Li-ion 2S โดยตรง ต้องระวังไม่ให้เกิดการสัมผัสสั้นกันระหว่างพลังงานหรือขาต่อบน NyBoard

Overview

NyBoard V1 เป็นเวอร์ชันที่ได้รับการอัพเกรดโดยพิจารณาจากความคิดเห็นของผู้ใช้ใน NyBoard V0 โดยเป็นเวอร์ชันที่สามารถใช้งานร่วมกับเวอร์ชันก่อนหน้าได้ แต่มีการออกแบบใหม่เพื่อทำให้ใช้งานได้ง่ายขึ้น.

• บอร์ด NyBoard V1 ยังใช้ Atmel ATMega328P เป็นชิปหลักอยู่เหมือนเดิม แต่มีการเปลี่ยนความถี่จาก 20MHz เป็น 16MHz และเป็นเวอร์ชั่นที่เข้ากันได้กับ Arduino Uno ทำให้ง่ายต่อการใช้งานสำหรับผู้ใช้งานใหม่ของ Arduino

• NyBoard V1 ยังคงใช้ PCA9685 เพื่อให้มีการขับเคลื่อน PWM 16 ช่องเช่นเดิม โดยลำดับของพินถูกเปลี่ยนแปลง แต่คุณไม่ต้องอ่านดัชนีบนบอร์ดเพราะมีการจัดการลำดับของพินด้วยซอฟต์แวร์แล้ว

• เดิมทีบอร์ดใช้โมดูล 6-axis motion sensor MPU6050 ในรูปแบบของโมดูลแยกต่างหากที่ถูกเชื่อมต่อบนบอร์ด แต่บอร์ดรุ่นนี้ได้ทำการออกแบบเป็นส่วนหนึ่งของ PCB เองแล้ว มีการรองรับ DMP (Digital Motion Processor) ซึ่งช่วยในการคำนวณข้อมูลการเคลื่อนไหว และยังสามารถให้ข้อมูลแบบ raw data สำหรับใช้งาน fusion และ filtering algorithms ของเราเองได้อีกด้วย

• NyBoard V1 ยังคงใช้บอร์ดหน่วยความจำภายใน 8KB I2C EEPROM เพื่อบันทึกค่าคงที่สำหรับฝีมือการทำงาน

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

• ตั้งแต่วันที่ 1 มกราคม 2021 เราเริ่มเพิ่มพอร์ต Bluetooth อย่างเป็นทางการเพื่อให้สามารถอัปโหลดและสื่อสารไร้สายได้ ค่าเริ่มต้นของ Baud rate สำหรับพอร์ตสื่อสารทั้งหมดถูกตั้งค่าไว้ที่ 115200

• ปุ่มรีเซ็ตเป็นส่วนสำคัญของบอร์ด และใน NyBoard V1 นั้น ปุ่มรีเซ็ตได้รับการพัฒนาเพื่อทำให้ง่ายต่อการเข้าถึงมากยิ่งขึ้นโดยการวางอยู่ที่ด้านหลังของบอร์ด

• เราเพิ่มพอร์ต Grove 4 ช่องเพื่อให้ใช้งานง่ายกับโมดูลขยาย Seeed Studio โดยไม่ต้องใช้สายเสียบเพิ่มเติม ในขณะเดียวกันยังมีพอร์ตหลักที่ผ่านมาตลอดอยู่เหมือนเดิมที่ขนาด 2.54 มม.

• เราได้เพิ่ม WS2812 RGB LEDs จำนวน 7 ดวงลงบนบอร์ดเป็นรูปแบบออกพอร์ทและตัวบ่งชี้สถานะอีกหนึ่งรูปแบบ

• ช่องต่อแบตเตอรี่ปัจจุบันเป็นแบบ anti-reverse ครับ

Logic diagram of the controller

The configuration of NyBoard V1_0 is shown as below:

Introduction to the onboard components

Main controller

NyBoard V1_0 ใช้ Atmel ATMega328P-MUR เป็นตัวควบคุมหลัก โดยเราได้นำเอาเวอร์ชันขนาดเล็กของมัน QFN32 เพื่อให้เหมาะสมกับการเลือกตำแหน่งและมีความเข้ากันได้กับ TQFP32 ตามปกติเลย

ATMega328P ทำงานที่ความถี่ 16MHz ด้วยแหล่งจ่ายไฟ 5V มีหน่วยความจำ RAM 2KB, Flash 32KB และ on-chip EEPROM 1KB ด้วย bootloader เดียวกับ Arduino Uno คุณสามารถอัพโหลดสคริปต์ผ่านพอร์ตซีเรียลได้เช่นกัน

I2C switch

ชิปหลักทำงานที่แรงดัน 5V ในขณะที่อุปกรณ์รอบตัวทำงานที่ระดับตรรกะของแรงดัน 3.3V โดยเราใช้ PCA9306 เพื่อแปลงบัส I2C ของ ATMega328P เป็นระดับตรรกะ 3.3V และเราได้เพิ่มสวิตช์ I2C บนบัส โดยที่เราสามารถสลับเปลี่ยนตัวควบคุมบัส I2C ของอุปกรณ์บนบอร์ดได้ โดยการเลือก "Arduino" หรือ "Raspberry Pi"

6-Axis IMU MPU6050

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

บน NyBoard V1_0 ที่มีที่อยู่ I2C คือ 0x68 พอร์ตแตกรับ (interrupt pin) เชื่อมต่อกับพอร์ต PD2 ของ ATMega328P (หรือพอร์ต D2 ของ Arduino Uno)

มีหลายไลบรารี่สำหรับใช้กับ MPU6050 และเราใช้ I2CDev/6050DMP ในปัจจุบัน แต่คุณสามารถใช้เวอร์ชันอื่นได้ดังนี้:

PCA9685 and the PWM servo ports

PCA9685 แยกสัญญาณ PWM 16 ช่อง 12 บิตด้วยคำสั่งจากพอร์ต I2C ด้วยที่อยู่ 0x40 บนบอร์ด บนบอร์ดมีหมายเลขดัชนี PWM 16 หมายเลข ที่แสดงอยู่บน PCB แต่คุณไม่จำเป็นต้องอ่านเลขดัชนีเหล่านี้ เนื่องจากการแมพพินจะทำในซอฟต์แวร์แทน แบบต่อสายก็เหมือนเดิม แต่ต้องตรวจสอบทิศทางของพินเซอร์โว หากเป็นเซอร์โวปกติจะมีพินสัญญาณ PWM พลังงาน (2S) และอีกหนึ่งพินเป็น GND และควรเชื่อม GND กับสายสีดำของเซอร์โว

บนบอร์ด NyBoard V1_0 พ่วงพลังงานให้กับโดยตรงกับแบตเตอรี่ Li-ion 2S ของเรา โดยเราออกแบบเซอร์โวของเราให้เข้ากันได้กับแหล่งจ่ายไฟ 8.4V ซึ่งเป็นค่ามาตรฐานของเรา แต่เซอร์โวขนาด 9g ปกติที่เป็น SG90 ที่ทำงานที่แรงดันไฟฟ้า 6V จะไม่ควรถูกเชื่อมต่อโดยตรงกับบอร์ด

เราใช้ไลบรารี Adafruit PWM Servo Driver Library สำหรับ PCA9685

EEPROM

เราบันทึกทักษะการเคลื่อนไหวด้วยหน่วยความจำ I2C EEPROM AT24C64 ขนาด 8KB ซึ่งมีที่อยู่ในสัญญาณ I2C เป็น 0x54 โดยตารางค้นหาของทักษะถูกบันทึกไว้ในหน่วยความจำภายในขนาด 1KB ของ ATMega328P โดยใช้ไลบรารี <EEPROM.h> คุณต้องสังเกตเอาไว้ว่ามีความแตกต่างกันเมื่อพัฒนาโค้ดใหม่ๆ

Passive buzzer

เสียงเตือน (buzzer) ถูกขับเคลื่อนโดย PD5 (หรือ D5 ของ Arduino UNO) และกระแสได้ถูกขยายด้วย MOS ยี่ห้อ 2N7002

Infrared receiver

เราใช้ VS1838B เป็นตัวรับสัญญาณอินฟราเรด ต่อกับขา PD4 (หรือ D4 บน Arduino Uno) โดยใช้ไลบรารี IRremote ของ Arduino โปรโตคอลที่เราใช้เป็นรูปแบบ NEC คุณสามารถปิดใช้งานโปรโตคอลอื่นเพื่อประหยัดพื้นที่ Flash (ประมาณ 10%) ในไฟล์ IRremote.h ได้

Voltage detector

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

มีแหล่งจ่ายไฟชนิด Anti-Reverse สำหรับแบตเตอรี่อยู่บนบอร์ด และแบตเตอรี่มีการเชื่อมต่อไปยัง ADC7 (หรือ A7 ของ Arduino Uno) และไม่ได้เชื่อมต่อกับขาว่างอื่นๆ โดย ADC7 จะรับค่าแรงดันจากแบตเตอรี่ผ่านตัวหารแรงดัน และค่าแรงดันจริงๆ จะมีค่าประมาณ 2 เท่าของค่าที่อ่านได้ ช่วงแรงดันของแบตเตอรี่ที่ถือว่าปลอดภัยคือต่ำกว่า 10V

คุณควรชาร์จแบตเตอรี่ทันทีเมื่อแบตเตอรี่ต่ำกว่า 7.4V

WS2812 RGB LED

เราเพิ่ม WS2812 RGB LEDs 7 ดวง (หรือ NeoPixel) บนบอร์ด NyBoard ด้วย หมายเลขพินคือ D10 พวกเขาถูกจ่ายไฟโดยชิป DC-DC 5V สำหรับ Raspberry Pi และเป็นอิสระจากเครือข่าย 5V ของ ATMega328P ดังนั้นคุณต้องเสียบแบตเตอรี่เพื่อจ่ายไฟให้กับ LED

Grove sockets

เราได้ใช้ช่องเสียบ Grove เพื่อให้การเชื่อมต่อง่ายดาย มีช่องเสียบประเภทต่าง ๆ ดังนี้:

Power system

NyBoard มีการจ่ายไฟหลักโดยใช้ตัวควบคุมไฟเลี้ยงแบบ Low-dropout (LDO) linear regulators เพื่อลดเสียงรบกวนและเพิ่มความเสถียรภาพ โดยใช้ LM1117-5V และ XC6206P-3.3V เพื่อจ่ายไฟเลี้ยงให้กับชิป 5V และ 3.3V โดย LDO 3.3V จะถูกเชื่อมต่อตามลำดับหลังจาก LDO 5V เพื่อเพิ่มประสิทธิภาพในการใช้พลังงาน

มีไดโอดอยู่ระหว่างแบตเตอรี่กับ LM1117-5V เพื่อป้องกันความเสียหายจากการเชื่อมต่อผิดพลาด นอกจากนี้ยังมีฟิวส์ที่สามารถฟื้นตัวเองได้ (6V 500mA) บนตัวอัพโหลด USB เพื่อจำกัดกระแสและป้องกันพอร์ต USB

Raspberry Pi ใช้พลังงานมากกว่าจึงเลือกใช้ TPS565201 DC-DC เพื่อให้ไฟเลี้ยงออกแรงดัน 5V และกระแสไฟ 3A และสามารถให้กระแสสูงสุด 5A พร้อมมีการป้องกันอุณหภูมิ/กระแส/แรงดันสูง ๆ โดยจะตัดไฟเมื่อชิปมีการออกแรงดัน >4A และอุณหภูมิเกิน 100 องศาเซลเซียสจนกว่าอุณหภูมิจะกลับสู่ปกติ โดย WS2812 RGB LEDs ยังถูกจ่ายไฟด้วยแหล่งนี้เช่นกัน

Servo จะได้รับพลังงานจากแบตเตอรี่ Li-ion 2S โดยตรง แต่จำเป็นต้องระวังการสัมผัสไฟหรือพินบน NyBoard ไม่ให้สัมผัสกัน

Last updated: Jan 13, 2021

วัตถุประสงค์ของ DAC นั้นตรงกันข้ามกับของ ADC DAC แปลงสัญญาณดิจิทัลเป็นสัญญาณอะนาล็อกสำหรับเอาต์พุต

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

เมื่อเปรียบเทียบกับ PWM แล้ว DAC จะส่งแรงดันออกโดยตรงโดยไม่ต้องคำนวณรอบการทำงาน ESP32 รวม DAC 8 บิต 2 แชนเนลที่มีค่า 0-255 ช่วงแรงดันไฟฟ้าคือ 0-3.3V ดังนั้นสูตรการคำนวณแรงดันเอาต์พุตของ DAC จึงเป็นดังนี้:

The demo is as follows:

#define DAC1 25 

void setup() {  
}

void loop() {
  
  // 8bit DAC, 255 = 3.3V, 0 = 0.0V 
  for(int i = 0; i < 255; i++){
    dacWrite(DAC1, i);
    delay(10);
  }
}

คำสั่งแนะนำของ ADC บน BiBoard

พิน 34, 35, 36 และ 39 ของโมดูล ESP32 รองรับอินพุตเท่านั้น เรากำหนดค่าให้เป็นพอร์ตอินพุตแบบอะนาล็อกบน BiBoard ซึ่งทำให้สะดวกสำหรับนักพัฒนาในการเชื่อมต่อเซ็นเซอร์เท้า 4 ตัว

การใช้งานตัวแปลงสัญญาณอนาล็อกเป็นดิจิตอล (ADC) บน BiBoard นั้นเหมือนกับ Arduino UNO พื้นฐาน แต่ความแม่นยำนั้นสูงกว่า (12 บิต UNO คือ 10 บิต) และมีการเพิ่มตัวขยายสัญญาณที่ตั้งโปรแกรมได้เพื่อให้ ADC ทำงานในช่วงที่ดีที่สุด

เมื่อป้อนสัญญาณแรงดันไฟฟ้า 1V หากใช้การเข้าถึง 12 บิตตามการกำหนดค่าปกติ แรงดันอ้างอิงจะเท่ากับแรงดันแหล่งจ่ายไฟ (3.3V): เอาต์พุตที่สอดคล้องกันคือ 0~1241 ส่วนใหญ่ของช่วง ADC จะเสียเปล่า ทำให้ได้ข้อมูลที่ไม่ถูกต้อง เมื่อเรากำหนดค่าอัตราขยายที่ตั้งโปรแกรมได้ เราสามารถทำให้สัญญาณอินพุต 1V เติมเต็มช่วง ADC เกือบทั้งหมด และความแม่นยำและความละเอียดจะดีขึ้นอย่างมาก

การสาธิตนี้ใช้ 4 อินพุต กำหนดค่าตามลำดับเป็น: อัตราขยายเดซิเบล 0/2.5/6/11 ควรสังเกตว่าการกำหนดค่าเริ่มต้นของ ESP32 Arduino คืออัตราขยาย 11 เดซิเบล

เราใช้ "analogSetPinAttenuation(PIN_NAME, attenuation)" เพื่อกำหนดค่าอัตราขยายของพินอินพุตเดี่ยว หรือใช้ "analogSetAttenuation(attenuation)" เพื่อกำหนดค่าอัตราขยายของพินอินพุตแบบอะนาล็อกทั้งหมด

// Ain 34 - 0dB Gain - ADC_0db
analogSetPinAttenuation(34, ADC_0db);

// Ain 35 - 2.5dB Gain - ADC_2_5db
analogSetPinAttenuation(35, ADC_2_5db);

// Ain 36 - 6dB Gain - ADC_6db
analogSetPinAttenuation(36, ADC_6db);

// Ain 39 - 11dB Gain - ADC_11db    (default)
analogSetPinAttenuation(39, ADC_11db);

ในการทดสอบจริง เมื่อป้อนแรงดันไฟฟ้ามาตรฐาน 1V ค่า ADC จะเป็น: 3850/2890/2025/1050 ในการผลิตในอนาคต ช่วง ADC สามารถเปลี่ยนแปลงได้โดยการเปลี่ยนอัตราขยายของ ADC โดยไม่ต้องเปลี่ยนแหล่งจ่ายแรงดันอ้างอิง

การใช้งาน EEPROM นั้นเหมือนกับ Arduino UNO มีสองการทำงาน: อ่านและเขียน

Read:

• I2C address of EEPROM

• The internal address of EEPROM (the address for storing data)

• Read data

Write:

• I2C address of EEPROM

• The internal address of EEPROM (the address for storing data)

• Write data

ในการสาธิต BiBoard ที่อยู่ของ EEPROM บนบัส I2C คือ 0x54 และความจุคือ 8192Bytes (64Kbit) เราเขียนค่าทั้งหมด 16 ค่าตามลำดับตั้งแต่ 0 ถึง 15 ใน EEPROM จากแอดเดรสแรก จากนั้นจึงอ่านเพื่อเปรียบเทียบ ในทางทฤษฎี ข้อมูลที่เขียนใน EEPROM และข้อมูลที่อ่านจากที่อยู่ที่เกี่ยวข้องควรเหมือนกัน

ในการทดสอบโรงงานของ NyBoard เราใช้วิธีนี้เช่นกัน แต่จะซับซ้อนกว่า เราจะใช้รายการคงที่เพื่อเติม EEPROM และอ่านเพื่อเปรียบเทียบ

#include <Wire.h>

#define EEPROM_ADDRESS 0x54
#define EEPROM_CAPACITY 8192       // 64Kbit
#define EEPROM_TESTBYTES 16

// write 1 byte EEPROM by address
void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) 
{
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.write(data);
  Wire.endTransmission();
 
  delay(5);
}

// read 1 byte EEPROM by address
byte readEEPROM(int deviceaddress, unsigned int eeaddress ) 
{
  byte rdata = 0xFF;
 
  Wire.beginTransmission(deviceaddress);
  Wire.write((int)(eeaddress >> 8));   // MSB
  Wire.write((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
 
  Wire.requestFrom(deviceaddress,1);
 
  if (Wire.available()) 
    rdata = Wire.read();
  return rdata;
}

void testI2CEEPROM(){

    byte tmpData = 0;

    Serial.println("EEPROM Testing...");
    
    // write EEPROM from 0 to EEPROM_TESTBYTES
    for(int i = 0; i < EEPROM_TESTBYTES; i++){
        writeEEPROM(EEPROM_ADDRESS, i, i % 256);
        delay(1);
    }

    Serial.println();
    
    // read from 0 to EEPROM_TESTBYTES
    for(int i = 0; i < EEPROM_TESTBYTES; i++){
        tmpData =  (int)readEEPROM(EEPROM_ADDRESS, i);
        Serial.print(tmpData);
        Serial.print("\t");
    }
}


void setup(){

    Serial.begin(115200);
    Wire.begin();
    
    testI2CEEPROM();
}

void loop(){
  
}

หมายเหตุ: การดำเนินการ EEPROM โดยเฉพาะการดำเนินการเขียน โดยทั่วไปจะไม่ใส่ลงในลูป () แม้ว่า EEPROM จะทนทานต่อการลบ (100,000 ครั้ง) หากมีการเขียนบล็อคบางบล็อกในลูปบ่อยๆ จะทำให้ EEPROM ทำงานผิดปกติ

มีพอร์ตซีเรียล 2 พอร์ตซึ่งแยกจากกันบนช่องส่วนขยาย 2 ช่อง (P16, P17) บน BiBoard

พอร์ตซีเรียล 1 บน P16 สามารถเชื่อมต่อกับตัวดาวน์โหลด USB และอุปกรณ์ซีเรียลภายนอกได้ โปรดอย่าใช้ตัวดาวน์โหลดและอุปกรณ์ซีเรียลภายนอกพร้อมกัน การแบ่งแรงดันพอร์ตซีเรียลจะนำไปสู่ข้อผิดพลาดในการสื่อสาร

ในการสาธิต Arduino นั้น Serial แทนพอร์ตซีเรียล 0 Serial1 แทนพอร์ตซีเรียล 1 Serial และ Serial1 นั้นส่งถึงกัน

/* In this demo, we use Serial and Serial1 
*  Serial and Serial1 send to each other 
*/

void setup() {
  // initialize both serial ports:
  Serial.begin(115200);
  Serial1.begin(115200);
}

void loop() {
  // read from port 1, send to port 0:
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
  }

  // read from port 0, send to port 1:
  if (Serial.available()) {
    int inByte = Serial.read();
    Serial1.write(inByte);
  }
}

ไม่มีพอร์ต GPIO แยกต่างหากบน BiBoard แต่พอร์ตซีเรียลแบบมัลติเพล็กซ์ 2 (พิน 16, 17) หรือพิน PWM ของอินเทอร์เฟซเซอร์โว PWM ที่ไม่ได้ใช้สามารถใช้เป็นพอร์ต GPIO ได้ พอร์ต GPIO นั้นค่อนข้างใช้งานง่าย หลังจากกำหนดค่าโหมดอินพุตและเอาต์พุตแล้ว การใช้งานจะเหมือนกับ Arduino UNO ทุกประการ คุณสามารถใช้โปรแกรมควบคุม IO ของ Arduino UNO อะไรก็ได้ เพียงแค่เปลี่ยนจำนวนของ IO

/* In this demo, we use TX2, RX2 as general purpose IO
*   TX2 : IO17
*   RX2 : IO16
*/

void setup() {
  // initialize digital pin 16 & 17 as an output.
  pinMode(16, OUTPUT);
  pinMode(17, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
    
  digitalWrite(16, HIGH);            // GPIO 16 & 17 HIGH
  digitalWrite(17, HIGH);
  delay(1000);                       // wait for a second

  digitalWrite(16, LOW);             // GPIO 16 & 17 LOW
  digitalWrite(17, LOW);
  delay(1000);                       // wait for a second
}

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

1. Bluetooth protocol

ในปัจจุบัน โปรโตคอล Bluetooth หลักแบ่งออกเป็นสองประเภท ได้แก่ Bluetooth แบบดั้งเดิม (HS/BR/EDR) ตาม RFCOMM และ Bluetooth พลังงานต่ำ (BLE) ตาม GATT

Bluetooth แบบดั้งเดิมนั้นเร็วกว่าและมีโปรโตคอลแอปพลิเคชันเฉพาะมากมาย เช่น A2DP ที่เน้นเสียง, พอร์ตอนุกรม Bluetooth SPP เป็นต้น อย่างไรก็ตาม การใช้พลังงานสูง และการเข้าถึงอุปกรณ์ Apple ต้องใช้ชิป MFi (Made For iOS) และการรับรอง

Bluetooth Low Energy (BLE) สามารถกำหนดโปรไฟล์ GATT ต่างๆ ได้ด้วยตัวเอง และยังมีโปรไฟล์ที่ใช้กันทั่วไป (เช่น ข้อมูลอุปกรณ์ แบตเตอรี่ ฯลฯ) มีการใช้พลังงานต่ำและใช้กันอย่างแพร่หลาย สามารถใช้กับอุปกรณ์ Apple ข้อเสียคือช้ากว่าบลูทูธแบบเดิม บลูทูธพลังงานต่ำส่วนใหญ่จะใช้กับอุปกรณ์ที่มีปริมาณข้อมูลน้อยแต่ไวต่อการใช้พลังงาน เช่น สร้อยข้อมือ/นาฬิกาอัจฉริยะ/บีคอน

2. Classic Bluetooth serial port (SPP)

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

//This example code is in the Public Domain (or CC0 licensed, at your option.)
//By Evandro Copercini - 2018
//
//This example creates a bridge between Serial and Classical Bluetooth (SPP)
//and also demonstrate that SerialBT have the same functionalities of a normal Serial

#include "BluetoothSerial.h"

#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif

BluetoothSerial SerialBT;

void setup() {
  Serial.begin(115200);
  SerialBT.begin("BTSPP_Test");          //Bluetooth device name
  Serial.println("The device started,");
  Serial.println("Now you can pair it with bluetooth!");
}

void loop() {
  if (Serial.available()) {
    SerialBT.write(Serial.read());
  }
  if (SerialBT.available()) {
    Serial.write(SerialBT.read());
  }
  delay(20);
}