ซ่อนคำอธิบายโปรโตคอล ความรู้เบื้องต้นเกี่ยวกับโลกของอุปกรณ์ USB โดยใช้ตัวอย่างไมโครคอนโทรลเลอร์จาก Silicon Laboratories โดยสังเขป: HID คืออะไรและมาพร้อมกับอะไร?

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

โปรเจ็กต์นี้พิจารณาการใช้ไมโครคอนโทรลเลอร์ PIC และคอมไพเลอร์ที่รองรับ USB เพื่อแปลงจอยสติ๊กพอร์ตเกมเก่าเพื่อให้สามารถใช้งานผ่าน USB ได้ ข้อดีประการหนึ่งของคอมไพเลอร์ mikroC คือการสร้างไลบรารี USB HID ที่ทำให้การสร้างอุปกรณ์ USB HID เป็นเรื่องง่าย เมื่อเขียนโค้ด USB โดยใช้คอมไพเลอร์ mikroC อุปกรณ์ USB ที่ผลิตขึ้นจะเป็นอุปกรณ์ HID ที่แท้จริงซึ่งสามารถใช้เพื่อส่งและรับข้อมูลจากไมโครคอนโทรลเลอร์ PIC อย่างไรก็ตาม คุณสามารถแก้ไขตัวอธิบาย USB ที่สร้างโดย mikroC เพื่อให้สามารถรับอุปกรณ์ USB HID เฉพาะได้ เช่น แป้นพิมพ์ เมาส์ จอยสติ๊ก หรือแท็บเล็ตอินพุตกราฟิก

คอมไพเลอร์

โปรเจ็กต์นี้ใช้คอมไพเลอร์ mikroC v8 วิธีการที่ใช้จะคล้ายกับคอมไพเลอร์อื่นๆ ส่วนใหญ่ที่สร้างโค้ด HID

จอยสติ๊ก

โปรเจ็กต์นี้ใช้จอยสติ๊ก IBM 76H1571 รุ่นเก่า รูปภาพที่แสดงด้านล่าง:

76H1571 เป็นจอยสติ๊กแบบ 4 ปุ่มพร้อมล้อปีกผีเสื้อและสวิตช์มุมมองหมวก POV สิ่งที่น่าสนใจที่สุดคือคุณไม่สามารถใช้วงล้อและสวิตช์พร้อมกันได้ - คุณสามารถใช้องค์ประกอบใดองค์ประกอบหนึ่งก็ได้ สวิตช์เลื่อนสองตัวที่ด้านหน้าของจอยสติ๊กใช้เพื่อเปิดและปิดวงล้อและสวิตช์ POV ดังนั้นคุณสามารถเลือกองค์ประกอบใดก็ได้ที่คุณต้องการใช้ในช่วงเวลาใดก็ตาม

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

โดยสรุปฉันต้องการชี้ให้เห็นว่าจอยสติ๊กที่แปลงแล้วมีลักษณะดังต่อไปนี้:

จอยสติ๊ก 2 แกน
คันเร่งล้อ
สวิตช์ POV 4 ทิศทาง
6 ปุ่ม

ตัวอธิบายรายงาน HID

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

การสร้างที่จับ

เว็บไซต์ USB IF โฮสต์โปรแกรมที่มีประโยชน์ซึ่งทำให้การสร้างตัวอธิบายรายงาน HID ง่ายขึ้นมาก เรียกว่า HID Descriptor Tool และสามารถดาวน์โหลดได้ฟรีจากหน้า HID Tools หลังจากดาวน์โหลด ให้แตกไฟล์เก็บถาวรและเรียกใช้ไฟล์ Dt.exe.

การใช้โปรแกรมนี้ คุณสามารถสร้างตัวอธิบายรายงานของคุณเองสำหรับจอยสติ๊ก (หรืออุปกรณ์ HID อื่นๆ) กำหนดจำนวนแกนและปุ่ม และระบุคุณลักษณะอื่นๆ (แป้นหางเสือ ล้อ ฯลฯ) โปรแกรมยังมาพร้อมกับเทมเพลตคำอธิบายที่คุณสามารถใช้หรือแก้ไขได้ทันทีเพื่อให้เหมาะกับความต้องการของคุณ ตั้งอยู่ในโฟลเดอร์เดียวกันกับไฟล์ปฏิบัติการและมีนามสกุล .ซ่อน. เรียกว่าแม่แบบด้ามจับจอยสติ๊ก joystk.hidนั่นคือสิ่งที่ฉันใช้ เมื่อโหลดแล้ว จะปรากฏหน้าจอดังนี้:

ส่วนสำคัญจะถูกเน้นด้วยกรอบสีแดง พวกเขาระบุพารามิเตอร์ต่อไปนี้:

1 ล้อ อธิบายด้วยค่า 8 บิตตั้งแต่ -127 ถึง 127
แกน X และ Y
สวิตช์มุมมอง POV 1 ตัว มี 4 ตำแหน่ง (0-3) และแสดงมุม 0-270 อธิบายด้วยค่า 4 บิต
4 ปุ่ม แต่ละปุ่มอธิบายด้วย 1 บิต

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

การปรับเปลี่ยนคำอธิบาย

การเพิ่มหมายเลขอ้างอิงให้กับโค้ดของคุณ

หลังจากสร้างหมายเลขอ้างอิงรายงานแล้ว คุณต้องส่งออกเป็นรหัส C โดยคลิก ไฟล์ -> บันทึกเป็นในเมนูโปรแกรม HID Descriptor Tool ในกล่องโต้ตอบที่ปรากฏขึ้น ให้เปลี่ยนประเภทไฟล์เป็น ไฟล์ส่วนหัว (*.h).

สิ่งนี้จะสร้างไฟล์ส่วนหัว C ที่คุณสามารถเพิ่มลงในโปรเจ็กต์ของคุณได้ในภายหลัง

การบูรณาการไมโครซี

หากต้องการเพิ่มไฟล์ส่วนหัวให้กับ descriptor ที่สร้างโดย mikroC คุณจะต้องดำเนินการบางขั้นตอน หากคุณดูที่ mikroC descriptor คุณจะสังเกตเห็นว่าแต่ละไบต์ตามด้วยอักขระ ‘,0’ (โดยไม่สนใจเครื่องหมายคำพูด นี่คือ เครื่องหมายจุลภาค-ศูนย์). คุณจะต้องแก้ไขตัวอธิบายรายงานที่สร้างขึ้น รวมถึงข้อมูลส่วนขยาย คุณควรจะได้ที่จับที่มีลักษณะดังนี้:

0x05, 0, 0x01, 0, // USAGE_PAGE (เดสก์ท็อปทั่วไป) 0x15, 0, 0x00, 0, // LOGICAL_MINIMUM (0) 0x09, 0, 0x04, 0, // การใช้งาน (จอยสติ๊ก) 0xa1, 0, 0x01, 0 , // COLLECTION (แอปพลิเคชัน) 0x05, 0, 0x02, 0, // USAGE_PAGE (การควบคุมการจำลอง) 0x09, 0, 0xbb, 0, // USAGE (คันเร่ง) 0x15, 0, 0x81, 0, // LOGICAL_MINIMUM (-127 ) 0x25, 0, 0x7f, 0, // LOGICAL_MAXIMUM (127) 0x75, 0, 0x08, 0, // REPORT_SIZE (8) 0x95, 0, 0x01, 0, // REPORT_COUNT (1) 0x81, 0, 0x02, 0 , // อินพุต (ข้อมูล, Var, Abs) 0x05, 0, 0x01, 0, // USAGE_PAGE (เดสก์ท็อปทั่วไป) 0x09, 0, 0x01, 0, // การใช้งาน (ตัวชี้) 0xa1, 0, 0x00, 0, // คอลเลกชัน (ทางกายภาพ) 0x09, 0, 0x30, 0, //////////////////////////////////////// / // // การใช้งาน (X) 0x09, 0, 0x31, 0, // การใช้งาน (Y) 0x95, 0, 0x02, 0, // REPORT_COUNT (2) 0x81, 0, 0x02, 0, // อินพุต (ข้อมูล, Var, Abs) 0xc0, 0, // END_COLLECTION 0x09, 0, //////////////////////////////////// // ///////// 0x39, 0, // การใช้งาน (สวิตช์หมวก) 0x15, 0, 0x00, 0, // LOGICAL_MINIMUM (0) 0x25, 0, 0x03, 0, // LOGICAL_MAXIMUM (3) 0x35, 0, 0x00, 0, // PHYSICAL_MINIMUM (0) 0x46, 0, 0x0e, 0, 0x01, 0, // PHYSICAL_MAXIMUM (270) 0x65, 0, 0x14, 0, // หน่วย (Eng Rot: Angular Pos) 0x75, 0, 0x04, 0, // REPORT_SIZE (4) 0x95, 0, 0x01, 0, // REPORT_COUNT (1) 0x81, 0, 0x02, 0, // อินพุต (ข้อมูล, Var, Abs) 0x05, 0, // ///////////////////////////////// 0x09, 0, // USAGE_PAGE (ปุ่ม) 0x19, 0 , 0x01, 0 , // USAGE_MINIMUM (ปุ่ม 1) 0x29, 0, 0x04, 0, // USAGE_MAXIMUM (ปุ่ม 4) 0x15, 0, 0x00, 0, // LOGICAL_MINIMUM (0) 0x25, 0, 0x01, 0, / / LOGICAL_MAXIMUM (1 ) 0x75, 0, 0x01, 0, // REPORT_SIZE (1) 0x95, 0, 0x04, 0, // REPORT_COUNT (4) 0x55, 0, 0x00, 0, // UNIT_EXPONENT (0) 0x65, 0 , 0x00, 0 , // หน่วย (ไม่มี) 0x81, 0, 0x02, 0, // อินพุต (ข้อมูล, Var, Abs) 0xc0, 0 // END_COLLECTION

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

ข้อมูลการจัดการจริงจะถูกเก็บไว้ในอาร์เรย์ทั้งหมด DescTables. รายการ 50 รายการล่างสุดในอาร์เรย์คือตัวจัดการรายงาน (บรรทัด 109-160) ลบบรรทัดเหล่านี้ และวางลงในคำอธิบายใหม่ที่ตำแหน่งนี้ ตอนนี้คุณต้องทำการแก้ไขไฟล์ USBdsc.c ต่อไปนี้:

เปลี่ยนบรรทัด 23 ให้ตรงกัน ขนาดว่างตัวอธิบายรายงาน (เช่น ขนาดของตัวอธิบายที่สร้างโดยเครื่องมือ HID โดยไม่มีรายการ 0' เพิ่มเติมที่ต้องเพิ่มสำหรับ mikroC - 77 ไบต์ ในกรณีของตัวอธิบายเริ่มต้นสำหรับจอยสติ๊ก):
- ถ่านที่ไม่ได้ลงนาม const HID_ReportDesc_len = 77;
ลบขอบเขตอาร์เรย์สำหรับ DescTablesที่บรรทัด 36:
ถ่านที่ไม่ได้ลงนาม const DescTables = (

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

การถ่ายโอนข้อมูลไปยังพีซี

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

ค่า Wheel, X และ Y เป็นค่า 8 บิต อย่างไรก็ตาม ค่าตัวเลือกมุมมอง POV และปุ่มเป็นแบบ 4 บิต ดังนั้นจึงรวมเป็นหนึ่งไบต์ รูปแบบข้อมูลได้รับด้านล่าง:

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

ฮาร์ดแวร์

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

การตั้งค่าสวิตช์

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

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

ดังนั้น เพื่อกำหนดทิศทางของสวิตช์มุมมอง POV สายไฟจะต่อเข้ากับวงจรแบ่งแรงดันไฟฟ้าดังแสดงด้านล่าง:

เมื่อเชื่อมต่อสายไฟเข้ากับแหล่งพลังงาน 5 V เราจะได้แรงดันไฟฟ้าดังต่อไปนี้:

แผนภาพไฟฟ้า

หลังจากพิจารณาการเชื่อมต่อสายไฟของจอยสติ๊กแล้ว เราได้ออกแบบวงจรที่จะเชื่อมต่อกับปุ่มและโพเทนชิโอมิเตอร์ทั้งหมด และส่งข้อมูลไปยังพีซี เพื่อจุดประสงค์นี้จึงใช้ไมโครคอนโทรลเลอร์ PIC18F2550 ที่ทำงานที่ความถี่ 20 MHz สวิตช์เชื่อมต่อกับพอร์ต PORTB โพเทนชิโอมิเตอร์และสวิตช์มุมมอง POV เชื่อมต่อกับ ADC ของพอร์ต PORTA แผนภาพแสดงด้านล่าง:

เขียงหั่นขนมแสดงอยู่ด้านล่าง (มีสายจัมเปอร์สามเส้น คลิกเพื่อดูภาพขนาดใหญ่):

หลังจากสร้างบอร์ดและการทดสอบแล้ว ให้วางบอร์ดไว้ที่ฐานของจอยสติ๊กและเปลี่ยนสายพอร์ตเกมเป็นสาย USB ภาพถ่ายของจอยสติ๊กที่แปลงแล้วแสดงอยู่ด้านล่าง:

อุปกรณ์พร้อมใช้งาน! ประกอบจอยสติ๊กและเชื่อมต่อกับพอร์ต USB ฟรี ในเวลาเดียวกัน Windows OS จะต้องตรวจพบอย่างถูกต้อง คุณสามารถปรับเทียบและเริ่มใช้กับเกมที่รองรับจอยสติ๊กได้

บทสรุป

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

รายชื่อธาตุกัมมันตภาพรังสี

การกำหนด	พิมพ์	นิกาย	ปริมาณ	บันทึก	ร้านค้า	สมุดบันทึกของฉัน
ยู1	MK PIC 8 บิต	PIC18F2550	1

Mbed OS เป็นระบบปฏิบัติการโอเพ่นซอร์สสำหรับแพลตฟอร์มที่ใช้ไมโครคอนโทรลเลอร์ Arm ที่ออกแบบมาโดยเฉพาะสำหรับอุปกรณ์ Internet of Things (IoT) ได้แก่ อุปกรณ์ที่ใช้พลังงานต่ำและมีข้อจำกัดซึ่งจำเป็นต้องเชื่อมต่ออินเทอร์เน็ต Mbed OS มอบเลเยอร์นามธรรมสำหรับไมโครคอนโทรลเลอร์ที่ทำงานอยู่ เพื่อให้นักพัฒนาสามารถมุ่งเน้นไปที่การเขียนแอปพลิเคชัน C/C++ ที่เรียกใช้ฟังก์ชันการทำงานที่มีอยู่ในฮาร์ดแวร์หลากหลายประเภท แอปพลิเคชัน Mbed OS สามารถนำมาใช้ซ้ำได้บนแพลตฟอร์มที่เข้ากันได้กับ Mbed

บนหน้านี้

เริ่มต้นใช้งาน

หากคุณต้องการดำน้ำโดยตรง:

ซอร์สโค้ดมีอยู่ใน GitHub และในหน้าเผยแพร่ของเรา

ซอร์สโค้ดและใบอนุญาต

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

แผนภาพสถาปัตยกรรม

นี่คือสถาปัตยกรรมพื้นฐานของบอร์ด Mbed:

รากฐานระบบปฏิบัติการ Mbed

Mbed OS ใช้ Hardware Abstraction Layer (HAL) เพื่อรองรับชิ้นส่วนทั่วไปของไมโครคอนโทรลเลอร์ เช่น ตัวจับเวลา รากฐานนี้อำนวยความสะดวกในการเขียนแอปพลิเคชันกับชุดทั่วไปของ Application Programming Interfaces (API) อุปกรณ์ของคุณจะมีไลบรารีและไดรเวอร์ที่จำเป็นสำหรับอุปกรณ์ต่อพ่วง MCU มาตรฐาน เช่น I2C, อนุกรม และ SPI โดยอัตโนมัติ

HAL ยังทำหน้าที่เป็นจุดเริ่มต้นในการเพิ่มการรองรับเป้าหมายหรือคุณลักษณะใหม่ให้กับเป้าหมายที่มีอยู่ เราทำงานอย่างใกล้ชิดกับพันธมิตรซิลิคอนของเราเพื่อถ่ายทอดคุณลักษณะใหม่เหล่านี้ไปยังบอร์ดพัฒนาที่เปิดใช้งาน Mbed

Mbed OS มีแกน RTOS ดังนั้นจึงรองรับการดำเนินการซอฟต์แวร์แบบเรียลไทม์แบบกำหนดเงื่อนไขแบบมัลติเธรด RTOS primitives พร้อมใช้งานอยู่เสมอ ช่วยให้ไดรเวอร์และแอปพลิเคชันพึ่งพาเธรด เซมาฟอร์ mutexes และฟีเจอร์ RTOS อื่นๆ

โครงสร้างของ Mbed OS ช่วยให้สามารถจับคู่แอปพลิเคชันและระบบจัดเก็บข้อมูลได้ กล่าวอีกนัยหนึ่ง เมื่อตัวเลือกการจัดเก็บข้อมูลระดับบล็อกแตกต่างกันไปและขึ้นอยู่กับแอปพลิเคชัน คุณสามารถเลือกระบบไฟล์ที่เหมาะกับอุปกรณ์ IoT ของคุณมากที่สุด ระบบไฟล์ FAT ซึ่งสนับสนุนโดยการ์ด SD ช่วยให้สามารถใช้งานร่วมกับระบบปฏิบัติการอื่น เช่น Windows, Mac OS หรือ Linux เมื่อความน่าเชื่อถือสูงและการกู้คืนจากไฟฟ้าขัดข้องเป็นสิ่งสำคัญ ควรใช้ระบบไฟล์แบบฝังของเรา ซึ่งได้รับการสนับสนุนด้วยชิปแฟลช (Q)SPI NOR

สุดท้ายนี้ Mbed OS จะใช้เลเยอร์การกำหนดเป้าหมายใหม่และการรวมกระบวนการบูตของห่วงโซ่เครื่องมือที่รองรับแต่ละอันสำหรับคุณ ดังนั้นการพัฒนาแอปพลิเคชันจึงให้ความรู้สึกคล้ายกับการพัฒนา C หรือ C++ สำหรับระบบปฏิบัติการอื่น ๆ

การเชื่อมต่อ

Arm ทำงานร่วมกับพันธมิตรเพื่อเปิดใช้งาน Bluetooth Low Energy, NFC, RFID, LoRa, 6LoWPAN-ND, Thread, Wi-SUN, อีเธอร์เน็ต, Wi-Fi, เซลลูลาร์ และ IoT บนมือถือ (LPWA) ในอุปกรณ์และสถาปัตยกรรมระบบที่ใช้ Mbed OS Mbed OS นำเสนอแกนหลักที่เสถียรของเทคโนโลยีการเชื่อมต่อที่มีอยู่ ในขณะเดียวกัน ก็เพิ่มฟีเจอร์ที่ทันสมัยในการเผยแพร่ฟีเจอร์รายไตรมาส เพื่อให้คุณทราบถึงแนวโน้มของอุตสาหกรรม เพื่อให้คุณสามารถเปลี่ยนไปใช้โซลูชันที่เป็นนวัตกรรมใหม่ที่สร้างมูลค่าทางธุรกิจ

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

Mbed OS รองรับแพลตฟอร์ม Pelion IoT ของเราอย่างเต็มที่ ดังนั้นคุณจึงสามารถจัดการอุปกรณ์ที่ใช้งานและข้อมูลของอุปกรณ์เหล่านั้นได้ Mbed OS และ Pelion ร่วมกันประกอบด้วยระบบนิเวศที่สอดคล้องกันซึ่งตอบสนองความต้องการของโครงการที่พร้อมสำหรับการผลิตส่วนใหญ่

ความปลอดภัย

แพลตฟอร์ม Pelion IoT มีการรักษาความปลอดภัยในตัวในทุกระดับ โดยเน้นทั้งการป้องกันการละเมิดและการบรรเทาผลกระทบที่ตามมา นอกเหนือจากบริการคลาวด์ที่แข็งแกร่ง สแต็กการสื่อสารที่แข็งแกร่ง และการอัพเดตเฟิร์มแวร์ที่ปลอดภัยแล้ว Mbed ยังมีบล็อคการสร้างความปลอดภัยเฉพาะสองแบบ: Arm Mbed TLS และ Secure Partition Manager (SPM) ที่ตรงตามแนวทางปฏิบัติที่ดีที่สุดในอุตสาหกรรมโดยเป็นส่วนหนึ่งของสถาปัตยกรรมความปลอดภัยของแพลตฟอร์มของ Arm ช่องทางการสื่อสารที่ปลอดภัยของ Mbed TLS ระหว่างอุปกรณ์และเกตเวย์หรือเซิร์ฟเวอร์ และการใช้ตัวจัดการพาร์ติชันที่ปลอดภัยและโดเมนความปลอดภัยแบบแยกสำหรับบริการระบบที่เชื่อถือได้จะช่วยลดพื้นผิวของการโจมตี เมื่อรวมกันแล้ว นี่เป็นโมเดลการรักษาความปลอดภัยแบบชิปสู่คลาวด์ที่ไม่เหมือนใคร โดยอาศัยความสามารถระดับต่ำที่พันธมิตรระบบนิเวศของ Arm Silicon มอบให้เพื่อรักษาความปลอดภัยข้อมูลและตัวตนของอุปกรณ์ที่เชื่อมต่อกับคลาวด์

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

อัพเดตเฟิร์มแวร์ระยะไกล

Mbed OS นำเสนอการผสานรวมกับบริการอัปเดตการจัดการอุปกรณ์ Pelion ได้อย่างราบรื่น คุณจึงสามารถอัปเดตแอปพลิเคชันของอุปกรณ์หรือเวอร์ชันของ Mbed OS ได้ เครื่องมือพัฒนา Arm Mbed CLI สามารถสร้างเพย์โหลดการอัปเดต สร้างรายการ และส่งไปยังอุปกรณ์การพัฒนาของคุณได้ ด้วยสองคำสั่ง หากคุณต้องการอัปเดตกลุ่มอุปกรณ์ คุณสามารถสร้างและอัปโหลดรายการและเพย์โหลดของคุณไปยังพอร์ทัลการจัดการอุปกรณ์และเรียกใช้แคมเปญมาตรฐานจากที่นั่น Online Compiler ยังนำเสนอการผสานรวมอย่างรวดเร็วสำหรับขั้นตอนการพัฒนาอีกด้วย

ฮาร์ดแวร์

Arm พันธมิตร และชุมชนนักพัฒนา Arm Mbed ทำงานร่วมกันเพื่อพัฒนาโครงการ Mbed OS ระบบนิเวศที่เจริญรุ่งเรืองนี้หมายความว่า Mbed OS มีไดรเวอร์สำหรับฮาร์ดแวร์ที่แตกต่างกันจำนวนมาก ดังนั้นคุณจึงสามารถมุ่งความสนใจไปที่โค้ดแอปพลิเคชันที่สะอาดและพกพาได้

โดยทั่วไปแล้ว ฮาร์ดแวร์ที่คุณเห็นบนเว็บไซต์ของเรามีสามประเภท:

โมดูล: ประกอบด้วยไมโครคอนโทรลเลอร์ การเชื่อมต่อ IoT เป็นศูนย์กลาง และหน่วยความจำออนบอร์ดที่จำเป็น เหมาะอย่างยิ่งสำหรับการออกแบบผลิตภัณฑ์ IoT ตั้งแต่การสร้างต้นแบบไปจนถึงการผลิตจำนวนมาก โมดูลที่เปิดใช้งาน Mbed รองรับ Mbed OS อย่างสมบูรณ์พร้อมไดรเวอร์การเชื่อมต่อที่มีอยู่ทั้งหมด
บอร์ด: บอร์ดพัฒนาเป็นวิธีที่ไม่แพงในการเริ่มพัฒนาด้วย Mbed OS และส่วนประกอบอื่นๆ
ส่วนประกอบ: ฐานข้อมูลคอมโพเนนต์โฮสต์ไลบรารีที่นำมาใช้ซ้ำได้สำหรับฮาร์ดแวร์ มิดเดิลแวร์ และบริการ IoT ต่างๆ ที่คุณสามารถใช้กับไมโครคอนโทรลเลอร์ Arm ได้ ส่วนประกอบเหล่านี้สามารถใช้เป็นส่วนประกอบสำหรับการพัฒนาต้นแบบและผลิตภัณฑ์ได้อย่างรวดเร็ว

เครื่องมือ

ชุดผลิตภัณฑ์ Mbed มีเครื่องมือที่จำเป็นสำหรับการทำงานกับ Mbed OS ไม่ว่าคุณจะมีทักษะระดับใดก็ตาม หากคุณเป็นนักพัฒนาที่มีประสบการณ์และมีการตั้งค่าเดสก์ท็อป คุณอาจต้องการทำงานแบบออฟไลน์กับ Arm Mbed CLI ซึ่งเป็นเครื่องมือบรรทัดคำสั่งที่ใช้ Python ของเรา คุณสามารถใช้ Mbed CLI กับหนึ่งในสาม toolchains ที่รองรับ: Arm Compiler 6, GCC และ IAR คุณยังสามารถส่งออกโปรเจ็กต์สำหรับ IDE อื่นๆ ได้ เช่น Keil MDK Mbed OS มีโค้ดบูรณาการสำหรับ toolchain ที่รองรับแต่ละอันเพื่อทำให้เธรดปลอดภัย

ควบคุม

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

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

โครงสร้างของตัวอธิบายมีดังนี้:

ตัวอธิบายอุปกรณ์และการกำหนดค่าคือหนึ่งรายการต่ออุปกรณ์ อาจมีตัวอธิบายอินเทอร์เฟซหลายตัว (เช่น MFP อาจมีอินเทอร์เฟซของเครื่องพิมพ์ อินเทอร์เฟซของสแกนเนอร์ ฯลฯ)

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

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

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

หากสามารถใช้อุปกรณ์ใน BIOS ได้แสดงว่าอุปกรณ์นั้นถูกกำหนดให้สามารถบู๊ตได้โดยใช้พารามิเตอร์

bInterfaceSubClass

0 - ไม่มีคลาสย่อย (อุปกรณ์ปกติ)

1 - อุปกรณ์บู๊ต;

2-255 - สงวนไว้

พารามิเตอร์ bInterfaceProtocol จะเหมาะสมก็ต่อเมื่อมีการประกาศว่าอุปกรณ์สามารถบูตได้

1 - คีย์บอร์ด;

3-255 - สงวนไว้

จำเป็นต้องตรวจสอบว่าอุปกรณ์อยู่ในคลาส HID ไม่ใช่โดยพารามิเตอร์ bDeviceClass และ bDeviceSubClass แต่โดยพารามิเตอร์ bInterfaceClass และ bInterfaceSubClass

ตัวอธิบายรายงานประกอบด้วยองค์ประกอบข้อมูล (รายการ)

องค์ประกอบอาจรวมถึงองค์ประกอบข้อมูลเพิ่มเติม ขนาดของบล็อกข้อมูลถูกกำหนดโดยประเภทพื้นฐาน (สั้นและยาว) กล่าวโดยย่อ โวลุ่มอาจเป็น 0, 1, 2 หรือ 4 ไบต์ องค์ประกอบแบบยาวมีค่า bSize = 2

ไดรเวอร์ HID แยกวิเคราะห์รายงานทั้งหมดจากโฮสต์ตามลำดับเชิงเส้น ค้นหาองค์ประกอบตามตัวอธิบายรายงาน และจัดเก็บไว้ในตารางองค์ประกอบ

ประเพณี

สิ่งเหล่านี้คือส่วนของตัวอธิบายรายงานที่กำหนดสิ่งที่ควรทำกับข้อมูล (เช่น อินพุต x, y, z)

การวางแนว HID

ตามค่าเริ่มต้น ทิศทางการเคลื่อนที่จะมาจากซ้ายไปขวา (X) จากบนลงล่าง (Y) และจากระยะใกล้มาก (Z)

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

ตัวอธิบาย HID

กำหนดความยาวและประเภทของตัวอธิบายทาสสำหรับอุปกรณ์ ประกอบด้วยส่วนต่าง ๆ ดังต่อไปนี้:

เป็นอีกครั้งที่รายงานเป็นแพ็กเก็ตข้อมูลจากมุมมอง HID ตัวอธิบายรายงานเป็นตัวอธิบายโครงสร้างของแพ็คเกจที่กำหนด โฮสต์จะประมวลผลรายงานจากอุปกรณ์และวิเคราะห์เนื้อหาของแต่ละแพ็คเกจตามนั้น ตัวอธิบายรายงานแบ่งออกเป็นบล็อคตามเงื่อนไข ส่วนแรกของบล็อกประกอบด้วยสามฟิลด์: ประเภทองค์ประกอบ แท็กองค์ประกอบ และขนาดองค์ประกอบ ฟิลด์เหล่านี้จะร่วมกันกำหนดว่าข้อมูลใดที่บล็อกมีอยู่

องค์ประกอบสามประเภทต่อไปนี้: Maain, Global, Local ตัวอย่างเช่น แท็กต่อไปนี้สอดคล้องกับประเภทหลัก:

อินพุต - หมายถึงข้อมูลอุปกรณ์ เช่น ตำแหน่งเคอร์เซอร์ สถานะของปุ่ม ฯลฯ

เอาท์พุต - กำหนดข้อมูลที่จะส่งจากโฮสต์ไปยังอุปกรณ์

คุณลักษณะ - อธิบายการกำหนดค่าอุปกรณ์ที่สามารถส่งไปยังอุปกรณ์ได้

คอลเลกชัน - การจัดกลุ่มความหมายขององค์ประกอบอินพุต เอาต์พุต และคุณลักษณะ

End Collection - ระบุจุดสิ้นสุดของการรวบรวมองค์ประกอบ

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

ประเภทท้องถิ่นและสากลจะกำหนดค่าข้อมูลขั้นต่ำและสูงสุด และอื่นๆ

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

ตัวอย่าง:

จำนวนรายงาน (2)

Report Size(3) ระบุขนาดขององค์ประกอบเป็นบิต (ในกรณีนี้ 3)

จำนวนรายงาน (2) กำหนดจำนวนขององค์ประกอบดังกล่าว

หากเราสามารถบรรจุและส่งข้อมูลประมาณสามปุ่มที่กดพร้อมกันได้ รายงานจะเป็นดังนี้:

ขนาดรายงาน (8)

รายงานเหรียญ(3)

หากรายงานระบุสถานะของปุ่มทั้ง 8 ปุ่ม จะมีลักษณะดังนี้:

ขนาดรายงาน (1)

รายงานเหรียญ (8)

ตัวอธิบายรายงานอาจมีองค์ประกอบหลักหลายประการ จำเป็นต้องมีองค์ประกอบคำอธิบายข้อมูลการควบคุมแต่ละองค์ประกอบต่อไปนี้ (องค์ประกอบอื่นๆ เป็นทางเลือก):

อินพุต (เอาต์พุตหรือคุณสมบัติ)
การใช้งาน
หน้าการใช้งาน
ขั้นต่ำเชิงตรรกะ
ค่าสูงสุดเชิงตรรกะ
ขนาดรายงาน
รายงานจำนวน

ตัวอย่างที่ใช้เมาส์ 3 ปุ่ม:

หน้าการใช้งาน (เดสก์ท็อปทั่วไป), ; หน้าการใช้งานทั่วไป

การใช้งาน (เมาส์)

คอลเลกชัน (แอปพลิเคชัน) ; เมาส์ชนิดเปิด

การใช้งาน (ตัวชี้)

คอลเลกชัน (ทางกายภาพ) ; เปิดคอลเลกชันดัชนี

หน้าการใช้งาน (ปุ่ม)

การใช้งานขั้นต่ำ (1)

การใช้งานสูงสุด (3),

ตรรกะขั้นต่ำ (0),

ค่าสูงสุดทางตรรกะ (1), ;ฟิลด์ส่งคืนข้อมูลจาก 0 ถึง 1

จำนวนรายงาน (3)

Report Size (1), ; สร้าง 3 ฟิลด์หนึ่งบิต (ปุ่ม 1, 2 และ 3)

อินพุต (ข้อมูล, ตัวแปร, สัมบูรณ์), ; สร้างฟิลด์สำหรับรายงานอินพุต

จำนวนรายงาน (1)

ขนาดรายงาน (5), ; สร้างฟิลด์คงที่ 5 บิต

อินพุต (คงที่) ; เพิ่มฟิลด์ลงในรายงานขาเข้า

หน้าการใช้งาน (เดสก์ท็อปทั่วไป)

การใช้งาน(X)

การใช้งาน(ใช่)

ตรรกะขั้นต่ำ (-127)

ค่าสูงสุดทางตรรกะ (127), ;field ส่งกลับค่าจาก -127 ถึง 127

ขนาดรายงาน (8)

จำนวนรายงาน (2), ; สร้าง 2 ฟิลด์ 8 บิต (X และ Y)

อินพุต (ข้อมูล ตัวแปร สัมพัทธ์) ;เพิ่มฟิลด์ลงในรายงานขาเข้า

สิ้นสุดคอลเลกชัน ;ปิดคอลเลกชันตัวชี้

สิ้นสุดการรวบรวม ปิดการรวบรวมเมาส์

คอลเลกชันเปิดชุดข้อมูล:

ฟิสิคัล 0x00
แอปพลิเคชัน 0x01
ตรรกะ 0x02
รายงาน 0x03
ชื่ออาร์เรย์ 0x04
สวิตช์การใช้งาน 0x05
การใช้งาน 0x06
สงวนไว้ 0x07 - 0x7F - สำหรับการใช้งานในอนาคต
สงวนไว้ 0x80 - 0xFF - สำหรับผู้ขาย

องค์ประกอบทั้งหมดมีคำนำหน้า 1 ไบต์ที่ระบุประเภทพื้นฐานขององค์ประกอบ HID กำหนดรูปแบบองค์ประกอบหลัก 2 รูปแบบ:

ความยาวทั้งหมดสั้น 1-5 ไบต์ ใช้สำหรับองค์ประกอบที่เกิดขึ้นบ่อยที่สุด

ยาว 3-258 ไบต์ ใช้สำหรับองค์ประกอบที่ต้องการข้อมูลจำนวนมาก

รูปแบบสั้นและยาวประกอบด้วยขนาด ประเภท และแท็กขององค์ประกอบในไบต์แรก

รูปแบบสั้น

รูปแบบยาว

ค่าต่ำสุดเชิงตรรกะและค่าสูงสุดเชิงตรรกะ

LMin & LMax ผูกค่าที่ส่งคืนโดยอุปกรณ์ และค่าต่ำสุดทางกายภาพและค่าสูงสุดทางกายภาพให้ความหมายกับขอบเขตเหล่านี้ ทำให้ค่าสามารถปรับขนาดได้ ตัวอย่างเช่น เทอร์โมมิเตอร์มีองศาตรรกะตั้งแต่ 0 ถึง 999 แต่มีองศาทางกายภาพอยู่ที่ 32 ถึง 212 องศา

ลองดูตัวอย่างเมาส์ที่มีความไว 400dpi:

ดังนั้นสูตรคำนวณอัตราส่วนจึงควรเป็น

(127-(-127)) / ((3175-(-3175)) * 10^-4) = 400 dpi

แบบสอบถามมาตรฐาน

คลาส HID ใช้คำขอ Get_Descriptor มาตรฐาน คำขอ Get_Descriptor(Configuration) ส่งคืนตัวอธิบายการกำหนดค่า ตัวอธิบายอินเทอร์เฟซทั้งหมด ตัวอธิบายจุดสิ้นสุด และตัวอธิบาย HID ทั้งหมดสำหรับแต่ละอินเทอร์เฟซ ไม่ควรส่งคืนหมายเลขอ้างอิง String ให้รายงานหมายเลขอ้างอิง

ดังนั้นลำดับควรเป็นดังนี้:

1.Get_Descriptor

โครงสร้าง:

ตารางที่กำหนดประเภทตัวอธิบาย (ไบต์สูงของ wValue ในคำขอ Get_Descriptor):

2. Set_Descriptor

โครงสร้าง:

3. ข้อความค้นหาเฉพาะคลาส

โครงสร้าง:

ค่า bRequest ที่มีจำหน่าย:

4. รับ_รายงาน

mValue กำหนดประเภทรายงานในไบต์สูงและรหัสรายงานในไบต์ต่ำ รหัสรายงานถูกตั้งค่าเป็น 0 หากไม่ได้ใช้ ประเภทรายงานถูกกำหนดดังนี้:

5.Set_Report

ความหมายของเขตข้อมูลจะคล้ายกับคำขอ Get_Report

6.Get_Idle

อ่านเปอร์เซ็นต์การไม่ได้ใช้งานของระบบปัจจุบันสำหรับรายงานอินพุตแต่ละรายการ

7.Set_ไม่ได้ใช้งาน

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

8. Get_โปรโตคอล

แบบสอบถามจะอ่านว่าโปรโตคอลใดที่ใช้งานอยู่ในปัจจุบัน

รองรับโดยอุปกรณ์บูตคลาส

9.Set_โปรโตคอล

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

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

โดยสังเขป: HID คืออะไรและมาพร้อมกับอะไร?

ตามชื่อที่แนะนำ คลาสของอินเทอร์เฟซที่เป็นปัญหาได้รับการออกแบบเพื่อใช้อุปกรณ์โต้ตอบกับผู้ใช้ แต่เนื่องจากความเรียบง่ายและสะดวกสบาย จึงมักจะทำงานร่วมกับอุปกรณ์ต่อพ่วงประเภทอื่นผ่านอินเทอร์เฟซนี้ จากฝั่งอุปกรณ์ การใช้งาน HID นั้นง่ายมาก: คุณไม่จำเป็นต้องกังวลกับโปรโตคอลการแลกเปลี่ยนข้อมูลระดับต่ำ อธิบายรายงาน และประมวลผลคำขอได้อย่างง่ายดาย และในด้านโฮสต์ อุปกรณ์ HID สามารถทำงานได้ในพื้นที่ผู้ใช้ผ่านไดรเวอร์ระบบปฏิบัติการมาตรฐาน แน่นอนว่า CDC ACM ยังอนุญาตให้คุณแลกเปลี่ยนข้อมูลกับอุปกรณ์ในลักษณะเดียวกัน แต่คลาสนี้ใช้งานบนอุปกรณ์ได้ยากกว่า สะดวกสำหรับการจัดระเบียบการโต้ตอบแบบเธรดอย่างต่อเนื่อง และไม่เหมาะกับการทำงานในการตอบกลับคำขอ โหมด.

อ่านเพิ่มเติม: ขางอกมาจากไหนและทำงานอย่างไร

HID เป็นสิ่งสากล: การแลกเปลี่ยนข้อมูลดำเนินการโดยการส่งและรับรายงานที่เรียกว่า (รายงาน HID) ซึ่งแต่ละรายงานเราต้องอธิบายด้วยวิธีพิเศษเพื่อให้ไดรเวอร์ระบบปฏิบัติการที่รับผิดชอบในการทำงานกับ HID สามารถเข้าใจระบบภายในได้อย่างถูกต้อง โครงสร้างข้อมูลของเรา หากเราใช้อุปกรณ์อินพุตมาตรฐาน เช่น แป้นพิมพ์ เมาส์ หรือจอยสติ๊ก จากนั้นโดยการวิเคราะห์เนื้อหาของตัวอธิบายรายงานของอุปกรณ์ของเรา ผู้ขับขี่จะเข้าใจวิธีการรับข้อมูลที่สนใจ ไม่ว่าจะเป็นการกดปุ่มหรือข้อมูล เกี่ยวกับการเคลื่อนไหวของตัวชี้ แม้ว่าเราจะใช้ HID เพื่อวัตถุประสงค์บางอย่างของเราเองและแลกเปลี่ยนรายงานจากโปรแกรมของเราเอง เรายังคงจำเป็นต้องอธิบายรายงานอย่างถูกต้องตามข้อกำหนด

ตัวอธิบายรายงาน

ดังนั้น การสร้างตัวอธิบายรายงานเดียวกันนี้จึงเป็นส่วนที่ยากที่สุดในการนำอุปกรณ์ต่อพ่วง HID ไปใช้ ไม่ว่านักพัฒนาจะทำอะไร ทุกอย่างก็จะผิดพลาดไปหมด บ้างก็ใช้โปรแกรมพิเศษ (เช่น ทางการ เครื่องมืออธิบาย HID) ซึ่งช่วยให้คุณสร้างคำอธิบายในส่วนต่อประสานกราฟิกและส่งออกชุดไบต์สำเร็จรูป คนอื่นๆ ใช้ตัวแปลงที่แปลงคำอธิบายข้อความเป็นโค้ดและในทางกลับกัน (เช่น hidrd) ทุกอย่างจะเรียบร้อยดี แต่การสนับสนุนโค้ดดังกล่าวที่สร้างโดยเครื่องมือของบุคคลที่สามเพิ่มเติมจะมีความซับซ้อนอย่างมาก: การแก้ไขแต่ละครั้งจำเป็นต้องใช้โปรแกรมที่เกี่ยวข้องอีกครั้ง ยังมีอีกหลายคนที่นำคำอธิบายสำเร็จรูปจากตัวอย่างอย่างโง่เขลา ปรับขนาดและจำนวนข้อมูลเพื่อให้เหมาะกับงานของพวกเขา และแลกเปลี่ยนแพ็คเก็ตในรูปแบบของตนเองที่ไม่สอดคล้องกับเนื้อหาที่แท้จริงของคำอธิบาย แต่แนวทางนี้ยังเต็มไปด้วยช่วงเวลาที่เลวร้ายมากมายซึ่งไม่ชัดเจนเสมอไป เช่น โดยทั่วไป การเบี่ยงเบนอื่นใดที่อยู่ห่างจากตัวอักษรของข้อกำหนด

เราจะใช้เส้นทางตรง: เราจะสร้างคำอธิบายในลักษณะที่ชัดเจนและอ่านง่าย โดยใช้มาโครจากตัวประมวลผลล่วงหน้า C ในแบบที่เราคุ้นเคยและสะดวกสำหรับผู้เชี่ยวชาญ CSE วิธีการนี้ไม่ได้แทนที่ความจำเป็นในการทำความคุ้นเคยกับข้อกำหนดเฉพาะ เอชไอดี 1.11เพื่อให้เข้าใจหลักการพื้นฐานของการสร้างตัวอธิบายการรายงาน แต่ช่วยให้คุณไม่ต้องรู้รายละเอียดของรูปแบบไบนารี่ กล่าวอีกนัยหนึ่ง เราจะอธิบายคำอธิบายโดยประมาณตามที่อธิบายไว้ในตัวอย่างของข้อกำหนดคุณลักษณะที่กล่าวถึงข้างต้น

หลักการพื้นฐาน

ผู้ที่ขี้เกียจเกินไปที่จะศึกษาข้อมูลจำเพาะในตอนนี้และเจาะลึกเนื้อหาสำคัญ โปรดอ่านข้อความฟรีของฉันด้านล่าง

คำอธิบายรายงานประกอบด้วยองค์ประกอบที่เรียกว่าองค์ประกอบหรือจุด ซึ่งแต่ละองค์ประกอบประกอบด้วยส่วนหัวและบล็อกข้อมูล (ไม่บังคับ) โดยทั่วไป องค์ประกอบต่างๆ อาจมีทั้งแบบสั้นและแบบยาว แต่ในที่นี้เราจะอธิบายเฉพาะองค์ประกอบแบบสั้นเท่านั้น เพราะเราจะทำงานกับองค์ประกอบเหล่านั้นเท่านั้น ส่วนหัวขององค์ประกอบประกอบด้วยฟิลด์ขนาดข้อมูล (2 บิต) ฟิลด์ประเภท (2 บิต) และฟิลด์แท็ก (4 บิต) รวมเป็น 8 บิต ฟิลด์ขนาดระบุความยาวของข้อมูลเป็นไบต์: 0, 1, 2 หรือ 4 ไบต์ ฟิลด์ประเภทระบุประเภท: หลัก ส่วนกลาง ท้องถิ่น ฟิลด์แท็กระบุองค์ประกอบนั้นเอง มีองค์ประกอบที่แตกต่างกันมากมาย และเราจะไม่อธิบายทั้งหมดที่นี่ เราจะเน้นเฉพาะองค์ประกอบหลักบางส่วนเท่านั้นในระหว่างทาง

ตัวอย่างคำอธิบาย

สมมติว่าเรากำลังพัฒนาอุปกรณ์มาตรฐานเช่นเมาส์ นี่คือตัวอย่างของตัวอธิบายรายงานจากข้อกำหนด:

หน้าการใช้งาน (เดสก์ท็อปทั่วไป), การใช้งาน (เมาส์), คอลเลกชัน (แอปพลิเคชัน), การใช้งาน (ตัวชี้), คอลเลกชัน (ทางกายภาพ), หน้าการใช้งาน (ปุ่ม), การใช้งานขั้นต่ำ (01), การใช้งานสูงสุด (03), ตรรกะขั้นต่ำ (0) , ตรรกะสูงสุด (1), จำนวนรายงาน (3), ขนาดรายงาน (1), อินพุต (ข้อมูล, ตัวแปร, สัมบูรณ์), จำนวนรายงาน (1), ขนาดรายงาน (5), อินพุต (คงที่), หน้าการใช้งาน (เดสก์ท็อปทั่วไป ), การใช้งาน (X), การใช้งาน (Y), โลจิคัลขั้นต่ำ (-127), โลจิคัลสูงสุด (127), ขนาดรายงาน (8), จำนวนรายงาน (2), อินพุต (ข้อมูล, ตัวแปร, สัมพัทธ์), คอลเลกชันสิ้นสุด, สิ้นสุด ของสะสม

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

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

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

ข้อมูลต่อไปนี้จะอธิบายฟิลด์พิกัดเคอร์เซอร์ในลักษณะเดียวกัน เนื่องจากเมาส์มักจะสร้างพิกัดสัมพันธ์ซึ่งต่างจาก digitizer ดังนั้น Relative จึงถูกระบุในองค์ประกอบ Input แทนที่จะเป็น Absolute และเนื่องจากพิกัดสัมพัทธ์เหล่านี้สามารถเป็นได้ทั้งบวกและลบ ค่าขีดจำกัดที่สอดคล้องกันจึงถูกระบุไว้ในค่าต่ำสุดเชิงตรรกะและค่าสูงสุดเชิงตรรกะตั้งแต่ -127 ถึง 127 โดยจะมีการจัดสรรสูงสุด 8 บิตสำหรับแต่ละค่า (ขนาดรายงาน) และผลรวมของ 2 ค่า (จำนวนรายงาน) คำแนะนำสำหรับไดรเวอร์เกี่ยวกับลำดับของฟิลด์ที่มีค่าพิกัดจะได้รับที่นี่โดยใช้องค์ประกอบการใช้งาน

คำอธิบายของคำอธิบายใน C

ดังนั้นงานของเราคือการนำเสนอคำอธิบายเดียวกันโดยใช้ภาษา C ซึ่งตัวประมวลผลล่วงหน้าของ C จะช่วยเรา นี่คือตัวอย่างเดียวกันที่จะมีลักษณะเช่นนี้:

#รวม /* คำจำกัดความมาโครสำหรับ HID Report Descriptor DSL ของเรา */ #include "hid_def.h" static const uint8_t hid_report_descriptor = ( HID_USAGE_PAGE (GENERIC_DESKTOP), HID_USAGE (MOUSE), HID_COLLECTION (APPLICATION), HID_USAGE (POINTER), HID_COLLECTION (PHYSICAL), HID_USAGE_PAGE (ปุ่ม), HID_USAGE_MINIMUM (1, 1), HID_USAGE_MAXIMUM (1, 3), HID_LOGICAL_MINIMUM (1, 0), HID_LOGICAL_MAXIMUM (1, 1), HID_REPORT_COUNT (3), HID_REPORT_SIZE (1), HID_INPUT (ข้อมูล, ตัวแปร, สัมบูรณ์ ) , HID_REPORT_COUNT (1), HID_REPORT_SIZE (5), HID_INPUT (คงที่), HID_USAGE_PAGE (GENERIC_DESKTOP), HID_USAGE (X), HID_USAGE (Y), HID_LOGICAL_MINIMUM (1, -127), HID_LOGICAL_MAXIMUM (1, 127), HID_REPORT_SIZE (8 ) , HID_REPORT_COUNT (2), HID_INPUT (ข้อมูล, ตัวแปร, ที่เกี่ยวข้อง), HID_END_COLLECTION (ทางกายภาพ), HID_END_COLLECTION (แอปพลิเคชัน), );

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

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

ร่วมงานปาร์ตี้

ฉันจะไม่ซ่อนมัน คำจำกัดความแบบมาโครสำหรับภาษาเฉพาะโดเมนของเราอยู่ในไฟล์ hid_def.hมีเวทย์มนตร์ตัวประมวลผลล่วงหน้าจำนวนมากซึ่งกำหนดไว้ในไฟล์ส่วนหัวอื่น มาโคร.h.

ฉันได้ส่งโปรเจ็กต์นี้ไปยังที่เก็บ github:katyo/hid_def แล้ว ดังนั้นตอนนี้ก็ถึงเวลาที่จะเริ่มเขียนตัวอธิบายรายงาน HID ด้วยวิธีของมนุษย์

อุปกรณ์จาก Silicon Laboratories ไม่ได้รับความนิยมอย่างกว้างขวางในแวดวงสมัครเล่น แต่ยังห่างไกลจากเรือธงเช่น Atmel อย่างไรก็ตาม พวกเขายังมีไมโครคอนโทรลเลอร์ของสายหลักในแพ็คเกจ TQFP ที่สามารถเข้าถึงได้โดยปุถุชนทั่วไป และชุดเริ่มต้น USB ToolStick (ซึ่งได้รับการกล่าวถึงเมื่อเร็ว ๆ นี้บนฮับ) ฉันเองเริ่มคุ้นเคยกับเทคโนโลยีไมโครโปรเซสเซอร์โดยทำงานร่วมกับ "silabs" และค่อนข้างประสบความสำเร็จ
ในบทความนี้ ฉันจะบอกคุณว่าคุณสามารถจัดระเบียบการสื่อสารระหว่างคอมพิวเตอร์และ MK โดยใช้อินเทอร์เฟซ USB ได้อย่างไร และ Silabs พยายามทำให้นักพัฒนาง่ายขึ้นอย่างไร
จากการทดสอบ เราจะใช้บอร์ด C8051F320DK พร้อมด้วยไมโครคอนโทรลเลอร์ซีรีส์ F32x ตามลำดับ ซึ่งรองรับฮาร์ดแวร์ USB และสภาพแวดล้อมการพัฒนา uVision4 ของ Keil

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

สถาปัตยกรรม USB ช่วยให้สามารถถ่ายโอนข้อมูลพื้นฐานได้สี่ประเภท:

ข้อความควบคุม ( ควบคุมการถ่ายโอน) – ใช้เพื่อกำหนดค่าอุปกรณ์ระหว่างการเชื่อมต่อและควบคุมอุปกรณ์ระหว่างการทำงาน โปรโตคอลให้การส่งมอบข้อมูลที่รับประกัน
การถ่ายโอนอาร์เรย์ข้อมูล ( การถ่ายโอนข้อมูลจำนวนมาก) คือการโอนโดยไม่มีข้อผูกมัดใดๆ เกี่ยวกับความล่าช้าในการจัดส่งและความเร็วในการส่งข้อมูล การถ่ายโอนแบบอาร์เรย์สามารถใช้แบนด์วิธบัสทั้งหมดซึ่งเป็นอิสระจากการถ่ายโอนประเภทอื่น เกียร์เหล่านี้มีลำดับความสำคัญต่ำที่สุดและอาจถูกระงับเมื่อมีการบรรทุกน้ำหนักมาก รับประกันการจัดส่ง - ในกรณีที่มีข้อผิดพลาดแบบสุ่ม จะดำเนินการทำซ้ำ การถ่ายโอนอาร์เรย์มีความเหมาะสมสำหรับการแลกเปลี่ยนข้อมูลกับเครื่องพิมพ์ เครื่องสแกน อุปกรณ์จัดเก็บข้อมูล ฯลฯ
ขัดจังหวะ ( ขัดจังหวะการถ่ายโอน) – การส่งสัญญาณระยะสั้นที่เกิดขึ้นเองตามธรรมชาติและต้องให้บริการไม่ช้ากว่าที่อุปกรณ์กำหนด
กำหนดเวลาการบริการตั้งไว้ในช่วง 10-255 ms สำหรับ
ต่ำ 1-255 ms สำหรับความเร็วเต็มที่ ที่ความเร็วสูงคุณสามารถสั่งได้ 125 µs ในกรณีที่เกิดข้อผิดพลาดในการแลกเปลี่ยนแบบสุ่ม จะดำเนินการซ้ำ ตัวอย่างเช่น มีการใช้การขัดจังหวะเมื่อป้อนอักขระจากแป้นพิมพ์ หรือเพื่อส่งข้อความเกี่ยวกับการเคลื่อนไหวของเมาส์
การส่งสัญญาณแบบไอโซโครนัส ( การถ่ายโอนแบบไม่ต่อเนื่อง) – การส่งสัญญาณต่อเนื่องแบบเรียลไทม์ โดยครอบครองส่วนที่ตกลงไว้ล่วงหน้าของความจุของรถบัสพร้อมรับประกันเวลาการส่งมอบล่าช้า ช่วยให้คุณสามารถจัดระเบียบช่องสัญญาณที่มีแบนด์วิดท์ 1.023 MB/s (หรือสองช่อง 0.5 MB/s) ด้วยความเร็วสูงสุด โดยกินแบนด์วิธสูงสุด 70% ของแบนด์วิธที่มีอยู่ (ส่วนที่เหลือสามารถเต็มไปด้วยช่องที่มีความจุน้อยกว่า) ที่ความเร็วสูง อุปกรณ์ปลายทางสามารถรับลิงก์ได้สูงสุด 24 MB/s (192 Mbps) หากตรวจพบข้อผิดพลาด จะไม่ลองข้อมูลที่ไม่ต่อเนื่องกันอีกครั้ง - แพ็กเก็ตที่ไม่ถูกต้องจะถูกละเว้น การถ่ายโอนแบบ Isochronous จำเป็นสำหรับอุปกรณ์สตรีมมิ่ง: กล้องวิดีโอ อุปกรณ์เสียงดิจิทัล (ลำโพง USB ไมโครโฟน) อุปกรณ์เล่นและบันทึกเสียงและวิดีโอ (ซีดีและดีวีดี)

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

การสร้างอุปกรณ์จอยสติ๊กที่รองรับ USB HID

ประเภทอุปกรณ์ USB ที่ใช้กันทั่วไปและง่ายที่สุดคือ HID (Human Interface Devices) ประเภทของการส่งผ่านที่ใช้ซึ่งเป็นมาตรฐานสำหรับอุปกรณ์ดังกล่าวคือการขัดจังหวะ ตัวแทนทั่วไปของคลาสนี้ ได้แก่ แป้นพิมพ์ USB, เมาส์, จอยสติ๊ก, แผงการตั้งค่าจอภาพ, เครื่องอ่านบาร์โค้ด, เครื่องอ่านการ์ด ฯลฯ
ข้อดีของอุปกรณ์ HID คือ:

ความง่ายในการใช้งาน
รหัสขนาดกะทัดรัด
รองรับ Windows (ไม่ต้องใช้ไดรเวอร์เพิ่มเติม)

เรามาประยุกต์ใช้วิธีที่ง่ายที่สุดกันดีกว่า หุ่นยนต์ควบคุมจอยสติ๊ก. ตัวอย่างเช่นเราจะต้องมีที่จับแก๊สที่มีปุ่มสองปุ่ม (หรือมากกว่า) สำหรับกลไกการต่อสู้ (!) ซึ่งเรากำลังประกอบในโรงรถ บอร์ดสาธิต C8051F320DK มีตัวต้านทานแบบปรับได้ 1 ตัวและปุ่ม 2 ปุ่ม ซึ่งเพียงพอสำหรับค่าขั้นต่ำ

Silabovtsy เป็นตัวอย่างเฟิร์มแวร์ของไมโครคอนโทรลเลอร์ ซึ่งจำลองเมาส์ USB ที่มีอินเทอร์เฟซ HID ตัวอย่างนี้เพียงพอที่จะปรับใช้อินเทอร์เฟซการโต้ตอบของมนุษย์ส่วนใหญ่ได้อย่างรวดเร็วและไม่ลำบาก ด้วยเหตุนี้ในตัวอย่างที่นำมาเป็นพื้นฐานจึงจำเป็นต้องทำใหม่:

การกำหนดค่าตัวอธิบายอุปกรณ์ HID
ขั้นตอนการถ่ายโอนข้อมูล
ตัวจัดการชื่ออุปกรณ์ HID

เริ่มจากตัวอธิบายอุปกรณ์กันก่อน

เราต้องการคำอธิบายในรูปแบบต่อไปนี้:
รหัส const hid_report_descriptor HIDREPORTDESC =
{
0x05, 0x01, // USAGE_PAGE (เดสก์ท็อปทั่วไป)

0x09, 0x04, // การใช้งาน (จอยสติ๊ก)
0xa1, 0x01, // COLLECTION (แอปพลิเคชัน)
0x05, 0x02, // USAGE_PAGE (การควบคุมการจำลอง)
0x09, 0xbb, // การใช้งาน (คันเร่ง)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0xff, 0x00, // LOGICAL_MAXIMUM (255)
0x75, 0x08, // REPORT_SIZE (8)
0x95, 0x01, // รายงาน_COUNT (1)

0x05, 0x09, // USAGE_PAGE (ปุ่ม)
0x19, 0x01, // USAGE_MINIMUM (ปุ่ม 1)
0x29, 0x02, // USAGE_MAXIMUM (ปุ่ม 2)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x75, 0x01, // รายงาน_SIZE (1)
0x95, 0x08, // REPORT_COUNT (8)
0x55, 0x00, // UNIT_EXPONENT (0)
0x65, 0x00, // หน่วย (ไม่มี)
0x81, 0x02, // อินพุต (ข้อมูล, Var, Abs)
0xc0 // END_COLLECTION
}
ทีนี้เรามาดูกันดีกว่าว่ามีอะไรบ้าง ส่วนที่สำคัญที่สุดในการอธิบายอุปกรณ์ในอนาคตคือประเภทข้อมูล จะต้องอธิบายส่วน การควบคุมการจำลอง(การจำลององค์ประกอบควบคุม) ซึ่งเพิ่งมี คันเร่ง(คันเร่ง) สำหรับสิ่งนี้เราระบุ:

ช่วงของค่าที่จะใช้งาน คันเร่ง– LOGICAL_MINIMUM(0) และ LOGICAL_MAXIMUM(255)
กำหนดขนาดของช่วงนี้ (หนึ่งไบต์) – REPORT_SIZE (8) และ
จำนวนการควบคุมประเภทนี้ – REPORT_COUNT (1)

มันเป็นเรื่องที่คล้ายกันกับปุ่ม (USAGE_PAGE ( ปุ่ม)):

ช่วงของค่า - LOGICAL_MINIMUM(0) และ LOGICAL_MAXIMUM(1);
ขนาดช่วง (หนึ่งบิต) - REPORT_SIZE(1);
มีปุ่มมากกว่าหนึ่งปุ่ม ดังนั้นที่นี่จึงจำเป็นต้องใช้ฟิลด์ความยาวไบต์ ซึ่งหมายถึง REPORT_COUNT (8)

ทั้งหมดนี้จำเป็นสำหรับระบบปฏิบัติการ ตอนนี้จะรู้วิธีจัดการ 2 ไบต์ที่จะได้รับจากคอนโทรลเลอร์ โดยใช้ descriptor เป็นคีย์ถอดรหัส
ใช่ และใน .h มีบรรทัดเหล่านี้อยู่ก่อนการประกาศ hid_report_descriptor:
#กำหนด HID_REPORT_DESCRIPTOR_SIZE 0x002C
#define HID_REPORT_DESCRIPTOR_SIZE_LE 0x2C00 //ENDIAN เล็กน้อย

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

เพื่อให้งานสร้าง descriptor ง่ายขึ้น คุณสามารถใช้โปรแกรมที่ www.usb.org (HID Descriptor Tool) โปรแกรมมาพร้อมกับตัวอย่างการกำหนดค่าของอุปกรณ์ HID บางตัว ซึ่งคุณสามารถปรับเปลี่ยนให้เหมาะกับงานของคุณหรือสร้างอุปกรณ์ HID ของคุณเองได้
นี่เป็นการสรุปคำอธิบายของจอยสติ๊กและคุณต้องเตรียมข้อมูลสำหรับการถ่ายโอนไปยังพีซี

ขั้นตอนการถ่ายโอนข้อมูล

เราพบโค้ดต่อไปนี้ในตัวอย่าง:
เป็นโมฆะ IN_Report (เป็นโมฆะ)(

IN_PACKET = เวกเตอร์;
IN_PACKET = ปุ่ม;

// ชี้ IN_BUFFER ตัวชี้ไปที่แพ็กเก็ตข้อมูลและตั้งค่า
// ความยาว IN_BUFFER เพื่อส่งขนาดรายงานที่ถูกต้อง
IN_BUFFER.Ptr = IN_PACKET;
IN_BUFFER.ความยาว = 2;
}

ขั้นตอนนี้เกี่ยวข้องกับการรวบรวมแพ็กเก็ตที่ส่ง ซึ่งจะถูกส่งผ่านตัวชี้ที่ซับซ้อน (อันที่จริง มันเป็นเพียงโครงสร้างของตัวชี้และความยาวของมัน) และส่งโดยอุปกรณ์ของเรา สิ่งสำคัญคือต้องเขียนแพ็คเกจอย่างระมัดระวังตามที่ความคิดเห็นบอกเราจากนั้นพวกเขาจะทำทุกอย่างโดยที่เราไม่ต้องมีส่วนร่วม
ตอนนี้ฉันจะบอกคุณว่าเราได้รับตัวแปร VECTOR และ BUTTONS อย่างไรและที่ไหน (ทั้งสองอย่างนี้เป็นประเภทถ่านที่ไม่ได้ลงชื่อซึ่งมีขนาดไบต์)
ตัวแปรโกลบอล VECTOR ได้รับการกำหนดค่าจาก ADC เมื่อเกิดการขัดจังหวะ:
โมฆะ ADC_Conver_ISR (โมฆะ) ขัดจังหวะ 10
{
AD0INT = 0;

// ข้อบ่งชี้การทำงานของ ADC
ถ้า(เวกเตอร์ != ADC0H)
ไฟ LED = 1;
อื่น
ไฟ LED = 0;

เวกเตอร์ = ADC0H;
}

BUTTONS ตัวแปรส่วนกลางจะเปลี่ยนค่าตามการกดปุ่มในทำนองเดียวกัน ปุ่มต่างๆ ถูกโพลโดยการขัดจังหวะตัวจับเวลา ตั้งเวลาตามความชอบส่วนตัวของคุณ
โมฆะ Timer2_ISR (เป็นโมฆะ) ขัดจังหวะ 5
{
P2 &= ~Led_2;

ถ้า ((P2 & Sw1)==0) // ตรวจสอบว่ากดปุ่ม #1 หรือไม่
{
//กด
ปุ่ม = ปุ่ม | (1<<0);
LED2 = 1;
}
อื่น
{
//ไม่ได้กด.
ปุ่ม = ปุ่ม & 0xFE;
}

ถ้า ((P2 & Sw2)==0) // ตรวจสอบว่ากดปุ่ม #2 หรือไม่
{
//กด
ปุ่ม = ปุ่ม | (1<<1);
LED2 = 1;
}
อื่น
{
//ไม่ได้กด.
ปุ่ม = ปุ่ม & 0xFD;
}
TF2H = 0; // ล้างการตั้งค่าสถานะขัดจังหวะ Timer2
}

ตัวอธิบายชื่ออุปกรณ์ HID

สุดท้ายนี้ เราสามารถปรับข้อมูลสตริงเพื่อให้อุปกรณ์มีชื่อที่เราต้องการได้ (ในตัวอย่างของฉัน “JOYSTICK-HABR”)
กำลังมองหาคำอธิบายสตริง String2Descเขียนใหม่
#กำหนดขนาด STR2LEN ของ ("JOYSTICK-HABR") * 2

รหัส const ถ่านที่ไม่ได้ลงนาม String2Desc =
{
STR2LEN, 0x03,
"เจ", 0,
"โอ", 0,
"ใช่", 0,
"ส", 0,
"ท", 0,
"ฉัน", 0,
"ค", 0,
"เค", 0,
"-", 0,
"ฮ", 0,
"ก", 0,
"ข", 0,
"ร", 0,
};

การระบุอุปกรณ์ HID

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

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

ความเร็วในการส่งข้อมูลต่ำถือเป็นข้อจำกัดหลักของตัวเลือกการออกแบบอุปกรณ์ HID อัตราการถ่ายโอนข้อมูลสูงสุดที่เป็นไปได้กับองค์กรแลกเปลี่ยนดังกล่าวคือ 64 Kbit/วินาที ตัวเลขนี้เมื่อเปรียบเทียบกับความเร็วบัส USB เต็มรูปแบบที่ 12 Mbit/s ดูเหมือนเป็นข้อเสียของเทคโนโลยี HID ในการเลือกการใช้งาน USB ที่เฉพาะเจาะจง อย่างไรก็ตาม สำหรับงานสื่อสารจำนวนมาก ความเร็วที่ระบุก็เพียงพอแล้ว และสถาปัตยกรรม HID ซึ่งเป็นเครื่องมือพิเศษก็เข้ามาแทนที่วิธีจัดระเบียบการแลกเปลี่ยนข้อมูลอย่างเหมาะสม

โดยทั่วไปแล้ว อุปกรณ์ HID นั้นง่ายต่อการนำไปใช้กับ MCU ที่รองรับ USB เกือบทุกตัว ตามกฎแล้วตัวอย่างการทำงานหนึ่งตัวอย่างจากนักพัฒนาก็เพียงพอแล้ว โดยการปรับเปลี่ยนคุณจะได้รับฟังก์ชันที่จำเป็น

การสร้างอุปกรณ์ USB ที่สมบูรณ์โดยใช้ชุดเครื่องมือ Silabs USBXpress

แต่ถึงเวลาที่คุณต้องใช้โปรโตคอลของคุณเองเพื่อทำงานกับอุปกรณ์บน MK ในเวลาเดียวกัน ฉันต้องการถ่ายโอนข้อมูลจำนวนมากด้วยความเร็วสูง และทำทั้งหมดนี้โดยใช้แล็ปท็อปของฉันซึ่งมี USB จำนวนมาก ไม่ใช่ COM เดียว และแม้แต่อุปกรณ์ของคุณก็ไม่ควรใหญ่กว่ากล่องไม้ขีด และติดตั้งบนบอร์ด USB-UART บนชิป FT232RL เป็นไปไม่ได้
ตอนนั้นเองที่คนจาก Silabs ตัดสินใจทำให้ชีวิตง่ายขึ้นสำหรับทุกคนและแสดง "หนทางสู่อนาคต" โดยไม่ทำลายฟันในการเขียนฟืนและเฟิร์มแวร์ของตัวเอง
ชุดพัฒนา USBXpressเป็นโซลูชั่นที่สมบูรณ์แบบสำหรับ MCU และโฮสต์ (PC) ซึ่งให้การทำงานที่เรียบง่ายด้วยโปรโตคอล USB โดยใช้ API ระดับสูงสำหรับทั้งสองฝ่าย ไม่จำเป็นต้องมีความรู้พิเศษเกี่ยวกับโปรโตคอล USB หรือการเขียนไดรเวอร์ นี่คือสิ่งที่ชาวสิลาโบวิตเขียนไว้ในคำแนะนำของพวกเขา

พูดถึง Programmer's Guid: เข้าใจง่ายและเข้าใจง่ายด้วยเนื้อหาเพียง 30 หน้า โดยส่วนตัวแล้วไม่ชอบตัวอย่างเลย มักจะมีมุมที่คดเคี้ยวมาก และไม่ควรดูโปรแกรม PC เลย เพราะอ่านไม่ออกอย่างมาก .
USBXpress DK ใช้งานได้กับไมโครคอนโทรลเลอร์ของกลุ่มผลิตภัณฑ์ C8051F32x, C8051F34x และ CP210x (ตัวควบคุมบริดจ์ USB เป็น UART) ไลบรารี USBXpress ประกอบด้วยไลบรารีระดับต่ำ ไดรเวอร์ USB สำหรับพีซี และ DLL สำหรับการพัฒนาแอปพลิเคชันระดับสูง และแน่นอนว่ามีชุดเอกสารและตัวอย่างด้วย
ไลบรารีใช้การถ่ายโอนข้อมูลในโหมด BULK เท่านั้น เมื่อใช้ฟังก์ชันทั้งหมดของไลบรารี การใช้งานจะใช้หน่วยความจำแฟลชของไมโครคอนโทรลเลอร์เพียง 3 KB

เฟิร์มแวร์

ลองดูตัวอย่างที่เรียบง่ายและเข้าใจได้ไม่มากก็น้อย ซึ่งมีฟังก์ชันการทำงานคล้ายกับตัวอย่าง HID ก่อนหน้านี้ เราจะไม่เข้าสู่แอปพลิเคชัน PC ทุกอย่างจะชัดเจนหลังจากที่เราเฟิร์มแวร์สำหรับ MK เสร็จแล้ว
ดังนั้นสาระสำคัญของตัวอย่าง TestPanel: เราอ่านค่าจากไมโครคอนโทรลเลอร์ ADC (โพเทนชิออมิเตอร์) และเครื่องวัดอุณหภูมิในตัว ( อุณหภูมิ) เช่นเดียวกับจากการกดปุ่ม ( สวิตช์1สถานะและ สวิตช์2สถานะ) และตัวเราเองก็สามารถกระพริบไฟ LED ได้ ( นำ1และ นำ2).
ตอนนี้ขั้นตอนบังคับและประเด็นละเอียดอ่อนที่เราจะพิจารณา:

การเขียนคำอธิบาย USB
การเริ่มต้นอุปกรณ์และ USB บนบอร์ด
การประมวลผลข้อมูลขาเข้าและสร้างแพ็คเกจขาออก
การจัดการขัดจังหวะ

แต่ก่อนอื่น เมื่อสร้างโปรเจ็กต์ อย่าลืมใส่ไฟล์ส่วนหัวด้วย USB_API.hและห้องสมุดนั่นเอง USBX_F320_1.lib.

การเขียนคำอธิบาย USB

ต่างจาก HID ที่มีโครงสร้างอย่างเป็นทางการอย่างชาญฉลาด ที่นี่ทุกอย่างก็เรียบง่าย
รหัส const UINT USB_VID = 0x10C4;
รหัส const UINT USB_PID = 0xEA61;
รหัส const ไบต์ USB_MfrStr = (0x1A,0x03,"S",0,"i",0,"l",0,"a,0,"b,0,"s,0);
รหัส const BYTE USB_ProductStr = (0x10,0x03,"U",0,"S",0,"B",0,"X",0,"_",0,"A",0,"P", 0);
รหัส const ไบต์ USB_SerialStr = (0x0A,0x03,"H",0,"A",0,"B",0,"R",0);
รหัส const ไบต์ USB_MaxPower = 15;
รหัส const ไบต์ USB_PwAttributes = 0x80;
รหัส const UINT USB_bcdDevice = 0x0100;

ฉันคิดว่าทุกอย่างชัดเจนกับ VID, PID และชื่อ อีกทั้งคุณยังสามารถตั้งค่ากระแสสูงสุดด้วยพารามิเตอร์ MaxPower (max.current = _MaxPower*2), PwAttributes - พารามิเตอร์ที่รับผิดชอบในการปลุกระยะไกลของโฮสต์ และ bcdDevice - หมายเลขรุ่นของอุปกรณ์

ความแตกต่างของการเริ่มต้นอุปกรณ์และ USB บนบอร์ด

ตอนนี้เรามาเริ่มด้วยฟังก์ชันหลักซึ่ง MK จะรับและส่งข้อมูลอย่างไม่รู้จักเหน็ดเหนื่อย
เป็นโมฆะหลัก (เป็นโมฆะ)
{
PCA0MD &= ~0x40; // ปิดการใช้งานตัวจับเวลา Watchdog
USB_Clock_Start(); // เริ่มต้นนาฬิกา USB *ก่อน* เรียก USB_Init
USB_Init(USB_VID,USB_PID,USB_MfrStr,USB_ProductStr,USB_SerialStr,USB_MaxPower,USB_PwAttributes,USB_bcdDevice);

เริ่มต้น();
USB_Int_Enable();
...

ตามความคิดเห็นที่ต้องการ ก่อนอื่นจำเป็นต้องเริ่มต้นตัวสร้างสัญญาณนาฬิกาสำหรับ USB ก่อนที่จะเริ่มต้นเอง จากนั้นจึงดำเนินการเริ่มต้นที่เหลือสำหรับ MK - Initialize(); - ซึ่งกำหนดค่าพอร์ต ตัวจับเวลา และ ADC จากนั้นเราจะเปิดใช้งานการขัดจังหวะ USB

ประมวลผลข้อมูลขาเข้าและสร้างแพ็กเก็ตขาออก

เรามาถึงสิ่งที่สำคัญที่สุด
//... ความต่อเนื่องของหลัก
ในขณะที่ (1)
{
ถ้า (Out_Packet == 1) Led1 = 1;
อย่างอื่น Led1 = 0;
ถ้า (Out_Packet == 1) Led2 = 1;
อย่างอื่น Led2 = 0;

In_Packet = สวิตช์1สถานะ;
In_Packet = สวิตช์2สถานะ;
In_Packet = โพเทนชิออมิเตอร์;
In_Packet = อุณหภูมิ;
}
//จบ main
}

Out_Packet – แพ็กเก็ตที่ได้รับจากโฮสต์
In_Packet - แพ็กเก็ตที่ส่งไปยังโฮสต์
ประเด็นนี้ชัดเจน MK อัปเดตแพ็คเกจที่ส่งอย่างต่อเนื่องและอ่านสถานะของแพ็คเกจที่ได้รับ

การจัดการขัดจังหวะ

ต่อไปนี้เป็นคำไม่กี่คำเกี่ยวกับตำแหน่งที่เราได้รับค่าในแพ็กเก็ตที่ส่ง เช่นเดียวกับในตัวอย่างของ HID สถานะของปุ่มจะได้จากการขัดจังหวะจากตัวจับเวลา และค่าของ ADC และเทอร์โมมิเตอร์จะได้จากการขัดจังหวะจาก ADC
นี่คือจุดละเอียดอ่อนจุดหนึ่ง - เมื่อเริ่มต้น ADC เรากำหนดค่าเพื่อให้การแปลงค่าเกิดขึ้นเมื่อตัวจับเวลาล้น (แบบเดียวกับที่เราใช้สำหรับปุ่ม) และการขัดจังหวะจาก ADC เกิดขึ้นเมื่อการแปลงเสร็จสิ้น . และที่นี่นอกเหนือจากการรับค่าตัวแปลงเมื่อสิ้นสุดกระบวนการแล้ว เรายังเรียกฟังก์ชัน API อีกด้วย
Block_Write(In_Packet, 8)
ซึ่งส่งข้อมูลที่รวบรวมไปยังคอมพิวเตอร์
การรับคำสั่งจากคอมพิวเตอร์เกิดขึ้นในขั้นตอนการประมวลผลขัดจังหวะ USB:
โมฆะ USB_API_TEST_ISR (เป็นโมฆะ) ขัดจังหวะ 16
{
ไบต์ INTVAL = Get_Interrupt_Source();

ถ้า (INTVAL & RX_COMPLETE)
{
Block_Read(Out_Packet, 8);
}

ถ้า (INTVAL & DEV_SUSPEND)
{
ระงับ_อุปกรณ์();
}

ถ้า (INTVAL & DEV_CONFIGURED)
{
เริ่มต้น();
}
}

ประเด็นนี้อธิบายไว้โดยละเอียดใน Programmer's Guid ประเด็นก็คือมีการเรียกฟังก์ชัน API Get_Interrupt_Source() โดยส่งคืนโค้ดด้วยเหตุผลของการขัดจังหวะ API ถัดไป โค้ดจะถูกวิเคราะห์และดำเนินการที่จำเป็น

โปรแกรมบนพีซี

ฉันจะไม่แยกชิ้นส่วนโปรแกรมคอมพิวเตอร์ ทีม Silab ได้จัดเตรียมตัวอย่างใน Visual Basic และ C แต่ไม่ได้ดูซอร์สโค้ดด้วยซ้ำ การเชื่อมต่อไลบรารีในสภาพแวดล้อมการพัฒนาที่คุณใช้และการอ่านสองสามหน้าเกี่ยวกับฟังก์ชันต่างๆ ไม่ควรทำให้เกิดความซับซ้อนใดๆ
ผมจะใช้โปรแกรมตัวอย่างที่คอมไพล์ไว้แล้ว

ดังนั้นเราจึงรวบรวมโปรเจ็กต์สำหรับ MK, แฟลช, ติดตั้งไดรเวอร์สากลสำหรับ USBXpress และเชื่อมต่อบอร์ดดีบั๊ก ระบบจะตรวจจับอุปกรณ์ใหม่และติดตั้งไดรเวอร์ให้
หลังการติดตั้ง มาดูกันว่าเกิดอะไรขึ้นใน Windows Device Manager:

ตอนนี้เรามารันโปรแกรมกันดีกว่า:

เราเห็นว่าเธอพบอุปกรณ์ถูกต้อง

เพียงเท่านี้คุณก็สามารถกดปุ่มต่างๆ กะพริบไดโอด อุ่น MK ด้วยมือของคุณ และดูว่าอุณหภูมิเพิ่มขึ้นอย่างไร

บทสรุป

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

แหล่งที่มาที่ใช้และมีประโยชน์:

Guk M. อินเทอร์เฟซฮาร์ดแวร์พีซี สารานุกรม. - เซนต์ปีเตอร์สเบิร์ก: ปีเตอร์, 2545 - 528 หน้า
คูริลิน เอ.ไอ. ไมโครคอนโทรลเลอร์ Silicon Labs พร้อมอินเทอร์เฟซ USB นิตยสาร "ส่วนประกอบอิเล็กทรอนิกส์" ฉบับที่ 5, 2550