💃 👨🏻‍🚀 🛑 STM32 और USB-HID - यह आसान है 👧 👃🏼 ➿

यह 2014 है, और एक पीसी के साथ माइक्रोकंट्रोलर्स को जोड़ने के लिए, सबसे लोकप्रिय साधन एक नियमित सीरियल पोर्ट है। इसके साथ काम करना शुरू करना आसान है, प्रधानता को समझना आसान है - बाइट्स की एक धारा।
हालांकि, सभी आधुनिक मानकों ने पीसी से COM पोर्ट को बाहर रखा है और आपको एमके पर अपनी परियोजना तक पहुंचने के लिए यूएसबी-यूएआर एडेप्टर का उपयोग करना होगा। वह हमेशा हाथ में नहीं होता है। ड्राइवरों के साथ समस्याओं के कारण ऐसा एडेप्टर हमेशा महत्वपूर्ण रूप से काम नहीं करता है। इसके अन्य नुकसान भी हैं।
लेकिन हर बार जब यूएसबी या सीरियल पोर्ट का उपयोग करने की बात आती है, तो UART की तार्किक सादगी के कई प्रशंसक हैं। और उनके पास अच्छा कारण है। हालाँकि, यह एक विकल्प है अच्छा है?

मुझे लंबे समय से यह बताने के लिए कहा गया है कि STM32F103 के उदाहरण का उपयोग करके एक पीसी और एमके के बीच पैकेट डेटा एक्सचेंज को कैसे व्यवस्थित किया जाए। मैं एक काम कर रहे मसौदे को दे दूंगा और आपको बताऊंगा कि इसे अपनी आवश्यकताओं के लिए कैसे अनुकूलित किया जाए। और आप खुद तय करें कि आपको इसकी जरूरत है या नहीं।

हमारे पास एक आधुनिक कम लागत वाला माइक्रोकंट्रोलर STM32F103C8 है जिसमें बिल्ट-इन USB हार्डवेयर सपोर्ट है, इसके बारे में मैंने पहले भी बताया था।

मैंने कहा कि सीरियल पोर्ट में अन्य कमियां हैं:
- अक्सर COM पोर्ट पीसी या लैपटॉप पर उपलब्ध नहीं होता है
-इस डिवाइस को अलग से संचालित करना होगा
- पीसी में COM पोर्ट होने पर भी, सिग्नल स्तरों को समन्वित करना आवश्यक है: पीसी RS232 इंटरफ़ेस का उपयोग करता है जिसमें विभेदक सिग्नल स्तर + 15V और -15V होते हैं, और माइक्रोकंट्रोलर TTL स्तरों (+ 5V, + 3.3V, एकध्रुवीय) का उपयोग करते हैं।
- अक्सर दर्जनों वर्चुअल COM पोर्ट सिस्टम में बनते हैं और आपके डिवाइस से मेल खाने वाले पोर्ट को खोजना आसान नहीं हो सकता है।
बदले में, USB कई वर्षों से हमारे साथ है और इसके फायदे हैं:
HOST डिवाइस से बिजली की आपूर्ति करने की क्षमता
- सुविधाजनक पैकेज विनिमय कार्यान्वयन
-एक साथ कई कार्यक्रमों के साथ डिवाइस से जुड़ने की क्षमता
कनेक्ट डिवाइस की विशिष्ट पहचान करने की क्षमता
कई आधुनिक एमके में -हार्डवेयर का समर्थन, जो एडेप्टर की आवश्यकता को समाप्त करता है
USB कार्यक्षमता बेहद समृद्ध है, लेकिन यह एक समस्या को जन्म देता है - समझ एक सीरियल इंटरफ़ेस के साथ उतना आसान नहीं है। उपकरणों का एक अलग वर्ग है - USB-HID, जिन्हें ड्राइवरों की स्थापना की आवश्यकता नहीं है, विशेष रूप से मनुष्यों और विभिन्न इनपुट-आउटपुट डिवाइसों के साथ बातचीत के लिए डिज़ाइन किए गए हैं। एमके के साथ डेटा एक्सचेंज के आयोजन के लिए आदर्श। व्यक्तिगत रूप से, मुझे बैच साझा करना पसंद है। यह एक सुविधाजनक अमूर्तता है। इसके अलावा, बैच संदेशों को अलग करना बाइट्स की एक सरल धारा के साथ काम करने की तुलना में कुछ आसान और अधिक सुविधाजनक है।

छिपाई प्रोफ़ाइल चयन

USB-HID उपकरणों का एक काफी व्यापक वर्ग है, इसलिए सबसे पहले हमें यह चुनना होगा कि हम कौन सा डिवाइस बनाएंगे।
हम कीबोर्ड, माउस, जॉयस्टिक और अन्य इनपुट डिवाइस का अनुकरण बना सकते हैं, और हम अपना डिवाइस बना सकते हैं ताकि मानक के कठोर ढांचे पर निर्भर न हों और पीसी के साथ डेटा का स्वतंत्र रूप से आदान-प्रदान कर सकें।
मैं आपको बताऊंगा कि कस्टम HID डिवाइस कैसे बनाते हैं। इससे अधिकतम स्वतंत्रता मिलती है। लेख को बाहर नहीं खींचने के लिए, मैं यथासंभव संक्षेप में बताने की कोशिश करूंगा - नेटवर्क पर और मेरे बिना मानक के बहुत सारे विवरण हैं, लेकिन व्यक्तिगत रूप से उन्होंने मेरी थोड़ी मदद की जब एक विशिष्ट समस्या को हल करना आवश्यक था।

परियोजना की संरचना

मैं STM32 के तहत विकास के लिए EmBlocks का उपयोग करता हूं । आप किसी भी सुविधाजनक वातावरण का उपयोग कर सकते हैं, परियोजना को अनुकूलित करना बहुत मुश्किल नहीं है।
निम्नलिखित परियोजना की मूल संरचना में जोड़े गए हैं:

STM32F10x, STM32L1xx और STM32F3xx USB-FS-Device ड्राइवर लाइब्रेरी संस्करण 4.0.0 के साथ USB-FS फ़ोल्डर ।
इंक और Src फ़ोल्डर में, फ़ाइलें:
platform_config.h - यहाँ एक विशिष्ट बोर्ड और MK परिवार की परिभाषाएँ हैं
stm32_it.h, stm32_it.c - बाधा हैंडलर यहाँ परिभाषित किए गए हैं
usb_conf.h, usb_endp.c - यहाँ एंडपॉइंट (समापन बिंदु), आकार और उनके बफ़र्स, हैंडलर फ़ंक्शन के पते परिभाषित किए गए हैं
usb_desc.h, usb_desc.c - डिवाइस के बारे में जानकारी यहां एकत्र की गई है - यह कैसे निर्धारित किया जाएगा जब एक पीसी से जुड़ा हो और डेटा पैकेट का आकार और प्रारूप निर्धारित किया जाए।
hw_config.c - एक पीसी पर डेटा भेजने के साथ सभी काम यहां एकत्र किए जाते हैं
hw_config.h, usb_istr.h, usb_prop.h, usb_pler.h
usb_istr.c, usb_prop.c, usb_pwr.c - USB-FS लाइब्रेरी को काम करने के लिए आवश्यक है, लेकिन आपको उनमें चढ़ना नहीं है

हम USB का उपयोग करके किसी भी प्रोजेक्ट में इन सभी फ़ाइलों को जोड़ते हैं।

USB आरंभीकरण

यूएसबी मॉड्यूल के सही संचालन के लिए, एमके की आवृत्ति महत्वपूर्ण है। सभी आवृत्तियाँ आपको USB घड़ी को सही ढंग से सेट करने की अनुमति नहीं देती हैं। हमारे मामले में, 8 मेगाहर्ट्ज पर एक क्रिस्टल थरथरानवाला का उपयोग किया जाता है और एमके 72 मेगाहर्ट्ज की आवृत्ति पर संचालित होता है, और 48 मेगाहर्ट्ज पर एक यूएसबी मॉड्यूल।
Main.c में, कोड की कुछ पंक्तियाँ शामिल करें

main.c

/* Includes ------------------------------------------------------------------*/ #include "hw_config.h" #include "usb_lib.h" #include "usb_pwr.h" /* Private variables ---------------------------------------------------------*/ __IO uint8_t PrevXferComplete = 1; int main(void) { Set_System(); USB_Interrupts_Config(); Set_USBClock(); USB_Init(); while (1) { if (bDeviceState == CONFIGURED) { if (PrevXferComplete) { RHIDCheckState(); } } } }

Set_System () फ़ंक्शन में, पावर के लिए D + लाइन पुल -अप का पिन प्रोग्रामेटिक रूप से पीसी से डिवाइस को कनेक्ट / डिस्कनेक्ट करने के लिए कॉन्फ़िगर किया गया है (यह हमारे बोर्ड में उपयोग नहीं किया गया है), रुकावट कॉन्फ़िगर किया गया है, और डेमो प्रोजेक्ट के लिए एलईडी और बटन एलईडी हैं।
USB_Interrupts_Config () में, MK के परिवार (F10x, F37x, L1x समर्थित हैं) के आधार पर इंटरप्ट को कॉन्फ़िगर किया गया है।
USB_Init () फ़ंक्शन USB मॉड्यूल शुरू करता है। यदि आपको डिबगिंग के लिए USB कार्य को अस्थायी रूप से अक्षम करने की आवश्यकता है, तो बस इस लाइन पर टिप्पणी करें।
फिर एक अंतहीन लूप में यह जांच की जाती है कि क्या पीसी से कनेक्ट होने पर यूएसबी मॉड्यूल को कॉन्फ़िगर करना संभव था। यदि सब कुछ सही ढंग से काम करता है और डिवाइस सफलतापूर्वक जुड़ा हुआ है, तो पीसी चालू है और पावर सेविंग मोड में नहीं है, तो स्थिति कंफर्टेबल होगी।
अगला, यह जांचा जाता है कि क्या पीसी में पिछला डेटा ट्रांसफर पूरा हो गया था और यदि ऐसा है, तो RHIDCheckState () फ़ंक्शन में भेजने के लिए एक नया पैकेट तैयार किया गया है

पैकेट का आकार और प्रसारण आवृत्ति

USB-HID डिवाइस स्वयं स्थानांतरण आरंभ नहीं कर सकता, क्योंकि बस मेजबान डिवाइस द्वारा समन्वित है - पीसी। इसलिए, हमारे डिवाइस के यूएसबी डिस्क्रिप्टर को तैयार करते समय, हम लिखते हैं कि हमें अपने डिवाइस से कितनी बार पूछताछ करने की आवश्यकता है। विनिर्देश के अनुसार, अधिकतम मतदान आवृत्ति 1 kHz है और एक समय में प्रेषित पैकेट का अधिकतम आकार 64 बाइट्स है। यदि यह पर्याप्त नहीं है, तो आपको ऑपरेशन के अन्य तरीकों का उपयोग करना होगा - जैसे कि USB बल्क, लेकिन वहां आप बिना ड्राइवरों के नहीं कर सकते।
पीसी के साथ सहभागिता स्थापित करने के लिए 3 हैंडल जिम्मेदार हैं:

डिवाइस डिस्क्रिप्टर

 /* USB Standard Device Descriptor */ const uint8_t RHID_DeviceDescriptor[RHID_SIZ_DEVICE_DESC] = { RHID_SIZ_DEVICE_DESC, //       USB_DEVICE_DESCRIPTOR_TYPE, // bDescriptorType - ,    .    - Device descriptor 0x00, 0x02, // bcdUSB -    USB  . 2.0 // ,    ,   USB.   ,       0x00, //bDeviceClass 0x00, //bDeviceSubClass 0x00, //bDeviceProtocol 0x40, //bMaxPacketSize -     Endpoint 0 ( ) //    VID  PID,    ,     . 0x83, 0x04, //idVendor (0x0483) 0x11, 0x57, //idProduct (0x5711) DEVICE_VER_L, DEVICE_VER_H, // bcdDevice rel. DEVICE_VER_H.DEVICE_VER_L    //    ,  ,    . //        //         VID/PID  . 1, //Index of string descriptor describing manufacturer 2, //Index of string descriptor describing product 3, //Index of string descriptor describing the device serial number 0x01 // bNumConfigurations -   .   . } ; /* CustomHID_DeviceDescriptor */

टिप्पणियों में सब कुछ बहुत पारदर्शी है। DEVICE_VER_L पर ध्यान दें, DEVICE_VER_H - ये usb_desc.h से स्थिरांक हैं, जिन्हें आप अपने डिवाइस के संस्करण की पहचान करने के लिए बदल सकते हैं।

विन्यास डिस्क्रिप्टर (डिवाइस क्षमताओं का वर्णन करता है)

 /* USB Configuration Descriptor */ /* All Descriptors (Configuration, Interface, Endpoint, Class, Vendor */ const uint8_t RHID_ConfigDescriptor[RHID_SIZ_CONFIG_DESC] = { 0x09, // bLength:    USB_CONFIGURATION_DESCRIPTOR_TYPE, // bDescriptorType:   -  RHID_SIZ_CONFIG_DESC, 0x00, // wTotalLength:          0x01, // bNumInterfaces:      0x01, // bConfigurationValue:    0x00, // iConfiguration:  ,     0xE0, // bmAttributes:  ,       USB 0x32, // MaxPower 100 mA:    100  /**************   ****************/ 0x09, // bLength:    USB_INTERFACE_DESCRIPTOR_TYPE, // bDescriptorType:   -  0x00, // bInterfaceNumber:    - 0 0x00, // bAlternateSetting:   ,     0x02, // bNumEndpoints -  . 0x03, // bInterfaceClass:   - HID //       ,    ,          //      HID- 0x00, // bInterfaceSubClass :  . 0x00, // nInterfaceProtocol :   0, // iInterface:  ,   //      ,    -  HID  /******************** HID  ********************/ 0x09, // bLength:  HID- HID_DESCRIPTOR_TYPE, // bDescriptorType:   - HID 0x01, 0x01, // bcdHID:   HID 1.1 0x00, // bCountryCode:   ( ) 0x01, // bNumDescriptors:    report  HID_REPORT_DESCRIPTOR_TYPE, // bDescriptorType:   - report RHID_SIZ_REPORT_DESC, 0x00, // wItemLength:  report- /********************    (endpoints) ********************/ 0x07, // bLength:   USB_ENDPOINT_DESCRIPTOR_TYPE, //   - endpoints 0x81, // bEndpointAddress:      1(IN) 0x03, // bmAttributes:    - Interrupt endpoint wMaxPacketSize, 0x00, // wMaxPacketSize: Bytes max 0x20, // bInterval: Polling Interval (32 ms) 0x07, /* bLength: Endpoint Descriptor size */ USB_ENDPOINT_DESCRIPTOR_TYPE, /* bDescriptorType: */ /* Endpoint descriptor type */ 0x01, /* bEndpointAddress: */ /* Endpoint Address (OUT) */ 0x03, /* bmAttributes: Interrupt endpoint */ wMaxPacketSize, /* wMaxPacketSize: Bytes max */ 0x00, 0x20, /* bInterval: Polling Interval (32 ms) */ } ; /* RHID_ConfigDescriptor */

यहां wMaxPacketSize स्थिर पर ध्यान देने योग्य है - यह अधिकतम पैकेट आकार निर्धारित करता है जिसे हम पीसी के साथ विनिमय करेंगे। प्रोजेक्ट को कॉन्फ़िगर किया गया है ताकि जब यह बदलता है, तो बफ़र्स का आकार भी बदलता है। लेकिन यह मत भूलो कि आपको मानक द्वारा 0x40 से अधिक निर्दिष्ट नहीं करना चाहिए। इस निरंतर के साथ सावधान रहें - यदि प्रेषित पैकेट आकार में अलग है, तो समस्याएं होंगी!
टिप्पणी bInterval के साथ अगला स्थिरांक मिलीसेकंड में डिवाइस की मतदान अवधि है। हमारे डिवाइस के लिए 32ms निर्धारित हैं।

रिपोर्ट संभाल (प्रोटोकॉल का वर्णन करता है)

 const uint8_t RHID_ReportDescriptor[RHID_SIZ_REPORT_DESC] = { 0x06, 0x00, 0xff, // USAGE_PAGE (Generic Desktop) 0x09, 0x01, // USAGE (Vendor Usage 1) 0xa1, 0x01, // COLLECTION (Application) 0x85, 0x01, // REPORT_ID (1) 0x09, 0x01, // USAGE (Vendor Usage 1) 0x15, 0x00, // LOGICAL_MINIMUM (0) 0x25, 0x01, // LOGICAL_MAXIMUM (1) 0x75, 0x08, // REPORT_SIZE (8) 0x95, 0x01, // REPORT_COUNT (1) 0xb1, 0x82, // FEATURE (Data,Var,Abs,Vol) 0x85, 0x01, // REPORT_ID (1) 0x09, 0x01, // USAGE (Vendor Usage 1) 0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol) 0x85, 0x02, // REPORT_ID (2) 0x09, 0x02, // USAGE (Vendor Usage 2) 0x15, 0x00, // LOGICAL_MINIMUM (0) 0x25, 0x01, // LOGICAL_MAXIMUM (1) 0x75, 0x08, // REPORT_SIZE (8) 0x95, 0x01, // REPORT_COUNT (1) 0xb1, 0x82, // FEATURE (Data,Var,Abs,Vol) 0x85, 0x02, // REPORT_ID (2) 0x09, 0x02, // USAGE (Vendor Usage 2) 0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol) 0x85, 0x03, // REPORT_ID (3) 0x09, 0x03, // USAGE (Vendor Usage 3) 0x15, 0x00, // LOGICAL_MINIMUM (0) 0x26, 0xff, 0x00, // LOGICAL_MAXIMUM (255) 0x75, 0x08, // REPORT_SIZE (8) 0x95, RPT3_COUNT, // REPORT_COUNT (N) 0xb1, 0x82, // FEATURE (Data,Var,Abs,Vol) 0x85, 0x03, // REPORT_ID (3) 0x09, 0x03, // USAGE (Vendor Usage 3) 0x91, 0x82, // OUTPUT (Data,Var,Abs,Vol) 0x85, 0x04, // REPORT_ID (4) 0x09, 0x04, // USAGE (Vendor Usage 4) 0x75, 0x08, // REPORT_SIZE (8) 0x95, RPT4_COUNT, // REPORT_COUNT (N) 0x81, 0x82, // INPUT (Data,Var,Abs,Vol) 0xc0 // END_COLLECTION }

यह सबसे महत्वपूर्ण वर्णनकर्ता है - यह संचार प्रोटोकॉल और डिवाइस की कार्यक्षमता का वर्णन करता है। इसका गठन कोई आसान काम नहीं है। यदि आप डिस्क्रिप्टर बनाते समय कोई गलती करते हैं, तो डिवाइस काम करना बंद कर देगा। वर्णनकर्ता प्रारूप बहुत कठिन है। यहां तक कि एक विशेष छिपाई Descriptor उपकरण उपयोगिता भी है। और परियोजना के मूल में इस उपयोगिता में संपादन के लिए ऊपर वर्णित वर्णनकर्ता के साथ फाइल "RHID.hid" है। लेकिन अगर आप यह नहीं समझते हैं कि आप क्या कर रहे हैं, तो यह बेहतर है कि आप न जाएं।
सादगी के लिए, मैंने दो स्थिरांक बनाए:
RPT3_COUNT - OUTPUT बफर आकार एमके में एक पैकेट प्रेषित करने के लिए (उदाहरण के लिए - 1 बाइट)
RPT4_COUNT - पैकेट को पीसी में स्थानांतरित करने के लिए बाइट्स में INPUT बफर का आकार (उदाहरण के लिए - 4 बाइट्स)
इनमें से किसी भी बफ़र का आकार wMaxPacketSize से अधिक नहीं होना चाहिए। कम संभव है।
वैसे, आप कस्टम छिपाई को किसी अन्य छिपाई डिवाइस में बदल सकते हैं, उदाहरण के लिए, केवल एक कुंजीपटल या जॉयस्टिक, रिपोर्टडाइपस्क्रिप्ट को फिर से लिखना और कॉन्फ़िगरेशन डिस्क्रिप्टर में डिवाइस के वर्ग और उपवर्ग को बदलना।

रिपोर्ट क्या है?

होस्ट (पीसी) और डिवाइस (एमके) पूर्वनिर्धारित संरचना के डेटा पैकेट का आदान-प्रदान करते हैं - रिपोर्ट। बहुत सारे पैकेज हो सकते हैं, उन्हें सभी अवसरों के लिए प्रदान किया जा सकता है - उदाहरण के लिए, डिवाइस में कुछ घटनाओं के बारे में डेटा के साथ एक पैकेज, डेटा के साथ एक पैकेज जिसे पीसी द्वारा अनुरोध किया गया था, एमके के लिए एक कमांड के साथ एक पैकेज। कुछ भी आप चाहते हैं। लेकिन सभी पैकेजों की संरचना को RHID_ReportDescriptor की संरचना में वर्णित किया जाना चाहिए।
पीसी और एमके आईडी द्वारा रिपोर्ट के बीच अंतर करते हैं, जो पैकेट में पहला बाइट है।
हमारे उदाहरण में, 4 प्रकार की रिपोर्टें हैं:

REPORT_ID = 1 और 2 - MK1 को LED1 / LED2 को चालू / बंद करने की आज्ञा। इसमें वांछित एलईडी राज्य के साथ 1-बिट क्षेत्र है और SET_REPORT विधि और SET_FEATURE विधि (बाद में अधिक) दोनों को भेजने का समर्थन करता है।
REPORT_ID = 3 - एक बाइट को MK में स्थानांतरित करता है। सिर्फ एमके डेटा को कैसे प्रसारित करना है यह दिखाने के लिए। हम स्लाइडर की स्थिति को पास करेंगे।
REPORT_ID = 4 पीसी डेटा स्थानांतरित करने के लिए एक रिपोर्ट है। यह एल ई डी, बटन (यदि कोई है) की वर्तमान स्थिति के बारे में जानकारी देता है और रिपोर्ट में प्रेषित डेटा को आईडी = 3 बाइट्स के साथ देता है ताकि यह पता चले कि डेटा प्राप्त हो गया है।

यदि आपने पूरी तरह से यह नहीं पता लगाया है कि रिपोर्ट डिस्क्रिप्टर कैसे बनाया जाए, तो बस स्थिरांक RPT3_COUNT और RPT4_COUNT को बदलें, आउटगोइंग और इनकमिंग का इच्छित आकार (पीसी के दृष्टिकोण से) पैकेट सेट करें। बाकी रिपोर्टों को केवल छुआ नहीं जा सकता है, वे चोट नहीं पहुंचाएंगे। याद रखें कि पहली बाइट एक रिपोर्ट आईडी होनी चाहिए।

विनिमय चक्र

इसलिए, हमने पीआईडी, वीआईडी, संस्करण संख्या सेट करके अपने डिवाइस को कॉन्फ़िगर किया, इनकमिंग और आउटगोइंग पैकेट के आकार को कॉन्फ़िगर किया और काम करने के लिए तैयार हैं।
प्रत्येक 32ms, जैसा कि हमने कॉन्फ़िगरेशन डिस्क्रिप्टर में अनुरोध किया था, मेजबान हमें पोल करेगा और RHIDCheckState फ़ंक्शन में हम जांच करेगा - अगर हमारे पास भेजने के लिए कुछ है, तो हम मेजबान के लिए एक डेटा पैकेट बनाते हैं।

RHIDCheckState - डेटा भेजने का कार्य

 /******************************************************************************* * Function Name : RHIDCheckState. * Description : Decodes the RHID state. * Input : None. * Output : None. * Return value : The state value. *******************************************************************************/ uint16_t btn1_prev, btn2_prev; uint8_t Buffer[RPT4_COUNT+1]; uint8_t RHIDCheckState(void) { uint16_t btn1=0, btn2=0; btn1 = GPIO_ReadInputDataBit(BTN1_PORT, BTN1_PIN); btn2 = GPIO_ReadInputDataBit(BTN2_PORT, BTN2_PIN); Buffer[0] = 4; Buffer[1] = btn1; Buffer[2] = btn2; Buffer[3] = (GPIO_ReadInputDataBit(LED_PORT, LED1_PIN) | GPIO_ReadInputDataBit(LED_PORT, LED2_PIN)<<1); /* Reset the control token to inform upper layer that a transfer is ongoing */ PrevXferComplete = 0; /* Copy buffer date info in ENDP1 Tx Packet Memory Area*/ USB_SIL_Write(EP1_IN, Buffer, RPT4_COUNT+1); /* Enable endpoint for transmission */ SetEPTxValid(ENDP1); return (btn1 | btn2<<1); }

Uint8_t बफर [RPT4_COUNT + 1] सरणी को आवक के पेलोड के आकार के रूप में परिभाषित किया गया है (हमेशा मेजबान के दृष्टिकोण से माना जाता है) पैकेट + बाइट आईडी। यह महत्वपूर्ण है - अगर बफर का आकार अलग है - समस्याएं होंगी। इसलिए, बफ़र का आकार बदलने के लिए, usb_desc.h में निरंतर मान को संपादित करें।
फ़ंक्शन में, हम एक पैकेज में डेटा एकत्र करते हैं, झंडा PrevXferComplete = 0 सेट करते हैं, यह दर्शाता है कि डेटा भेजा जा रहा है और होस्ट को डेटा भेजने के लिए USB_SIL_Write और SetEPTxValid लाइब्रेरी फ़ंक्शन को कॉल करें।
बस इतना ही, होस्ट को डेटा ट्रांसफर खत्म हो गया है।

डेटा प्राप्त करना थोड़ा अधिक जटिल है - डिवाइस को डेटा भेजने के दो तरीके हैं - उनमें से एक रिपोर्ट विवरणक में वर्णित SET_FEAUTRE फ़ंक्शन के माध्यम से संबंधित मापदंडों के साथ डिवाइस की सुविधाओं का उपयोग करना है। यह कुछ अमूर्त है, कार्यों के एक समूह के साथ डिवाइस के सुंदर नियंत्रण के लिए, ताकि आप सार्थक कार्यों को बुला सकें, और न केवल बाइट्स की एक धारा भेजें।
दूसरा तरीका डिवाइस के साथ फ़ाइल के रूप में काम करना है - बस पैकेज को फ़ाइल के रूप में लिखें। इस विधि को SET_REPORT कहा जाता है। वास्तव में, यह थोड़ा धीमा काम करता है।
हमारा उपकरण दोनों विधियों का समर्थन करता है, जैसा कि हमने रिपोर्ट डिस्क्रिप्टर में होस्ट को बताया था।

प्रसंस्करण SET_FEATURE

SET_FEAUTRE विधि द्वारा भेजा गया डेटा usb_prop.c में संसाधित किया गया है

फ़ंक्शन HID_Status_In

 /******************************************************************************* * Function Name : HID_Status_In. * Description : HID status IN routine. * Input : None. * Output : None. * Return : None. *******************************************************************************/ void HID_Status_In(void) { BitAction Led_State; if (Report_Buf[1] == 0) { Led_State = Bit_RESET; } else { Led_State = Bit_SET; } switch (Report_Buf[0]) { case 1: /* Led 1 */ if (Led_State != Bit_RESET) { GPIO_SetBits(LED_PORT,LED1_PIN); } else { GPIO_ResetBits(LED_PORT,LED1_PIN); } break; case 2: /* Led 2 */ if (Led_State != Bit_RESET) { GPIO_SetBits(LED_PORT,LED2_PIN); } else { GPIO_ResetBits(LED_PORT,LED2_PIN); } break; case 3: /* Led 1&2 */ Buffer[4]=Report_Buf[1]; break; } }

यहां हम रिपोर्ट में पहले बाइट की जांच करते हैं और उसके अनुसार हम पैकेट के बाकी हिस्सों की प्रक्रिया करते हैं - हम एल ई डी को नियंत्रित करते हैं या मेजबान द्वारा हमें भेजे गए बाइट को लेते हैं और इसे पैकेट में डालते हैं और बाद में RHIDKheckState फ़ंक्शन पर वापस भेजते हैं।
Report_Buf के तहत, wMaxPacketSize बाइट्स आरक्षित हैं ताकि कोई भी पैकेट जो होस्ट हमें भेजता है वह फिट हो सके।

SET_REPORT विधि द्वारा भेजा गया डेटा usb_endp.c में संसाधित किया गया है

फ़ंक्शन EP1_OUT_Callback

 /******************************************************************************* * Function Name : EP1_OUT_Callback. * Description : EP1 OUT Callback Routine. * Input : None. * Output : None. * Return : None. *******************************************************************************/ void EP1_OUT_Callback(void) { BitAction Led_State; /* Read received data (2 bytes) */ USB_SIL_Read(EP1_OUT, Receive_Buffer); if (Receive_Buffer[1] == 0) { Led_State = Bit_RESET; } else { Led_State = Bit_SET; } switch (Receive_Buffer[0]) { case 1: /* Led 1 */ if (Led_State != Bit_RESET) { GPIO_SetBits(LED_PORT,LED1_PIN); } else { GPIO_ResetBits(LED_PORT,LED1_PIN); } break; case 2: /* Led 2 */ if (Led_State != Bit_RESET) { GPIO_SetBits(LED_PORT,LED2_PIN); } else { GPIO_ResetBits(LED_PORT,LED2_PIN); } break; case 3: /* Led 1&2 */ Buffer[4]=Receive_Buffer[1]; break; } SetEPRxStatus(ENDP1, EP_RX_VALID); }

यहां यह लगभग समान है, केवल आपको USB_SIL_Read (EP1_OUT, Receive_Buffer) पर कॉल करके डेटा स्वयं लेने की आवश्यकता है और अंत में सूचित करें कि हमने SetEPRxStatus (EN1: EP_RX_VALID) को कॉल करना समाप्त कर दिया है;

हमने सीखा कि किस तरह से डिवाइस को कॉन्फ़िगर करना, संचार करना और सही आकार के पैकेट में डेटा प्राप्त करना है, जिस आवृत्ति की हमें आवश्यकता है।
हम प्रोजेक्ट को इकट्ठा करते हैं और इसे डिवाइस में फ्लैश करते हैं।
यह कुछ इस तरह काम करेगा:

यह परियोजना एसटी माइक्रोइलेक्ट्रॉनिक से यूएसबी छिपाई प्रदर्शनकारी उपयोगिता के साथ बातचीत का समर्थन करती है।
डिवाइस क्षमता पृष्ठ रिपोर्ट डिस्क्रिप्टर में वर्णित क्षमताओं को प्रदर्शित करता है।
इनपुट / आउटपुट ट्रांसफर आपको डिवाइस को मैन्युअल रूप से डेटा भेजने और उससे आने वाले पैकेट को देखने की अनुमति देता है।
ग्राफिक दृश्य आपको एल ई डी को नियंत्रित करने की अनुमति देता है, चेकबॉक्स एलईडी 1, एलईडी 2, संबंधित रिपोर्ट आईडी सेट करने के साथ-साथ एक स्लाइडर के साथ स्थानांतरण बाइट्स (रिपोर्टआईडी = 3)

मैंने एक छोटा डेमो सॉफ्टवेयर भी लिखा है जो स्वचालित रूप से कंप्यूटर से कनेक्शन का पता लगाता है और इसके VID और PID द्वारा हमारे डिवाइस को डिस्कनेक्ट करता है, ऑटो कनेक्ट चेकबॉक्स के बगल में संकेतक द्वारा स्थिति - जुड़ा / डिस्कनेक्ट किया गया

रेडियो बटन का उपयोग करके भेजें आपको डिवाइस को डेटा भेजने की विधि चुनने की अनुमति देता है।
रिपोर्ट: डिवाइस बाइट से प्राप्त पैकेट, रिपोर्टआईडी के साथ शुरू होता है।
नीचे दिए गए एल ई डी पर क्लिक करने पर - हम डिवाइस के एल ई डी को नियंत्रित करते हैं। उनकी स्थिति डिवाइस की वर्तमान स्थिति को प्रदर्शित करती है। यह डिवाइस से रिपोर्ट से पढ़ा जाता है।
स्लाइडर को आगे बढ़ाते हुए, हम आईडी = 3 के साथ रिपोर्ट भेजते हैं और स्लाइडर की स्थिति के अनुसार मूल्य। उपकरण रिपोर्ट के 4 बाइट्स में इस मान को लौटाएगा।
कॉम्बोबॉक्स में, सिस्टम में पाए जाने वाले HID डिवाइस प्रदर्शित होते हैं और यदि हमारा डिवाइस पाया जाता है, तो इसका नाम प्रदर्शित होता है।

आप GitHub पर अपनी जरूरत की सभी चीजें डाउनलोड कर सकते हैं। की संरचना में:
डीटी - छिपाई वर्णक उपकरण
tstHID-STM32F103 - एमब्लॉक के लिए परियोजना
यूएसबी छिपाई प्रदर्शनकारी - एसटी माइक्रोइलेक्ट्रॉनिक से उपयोगिता
HIDSTM32.exe - डेल्फी पर मेरे डेमो सॉफ्टवेयर में एक समान कार्यक्षमता है, लेकिन कॉन्फ़िगरेशन की आवश्यकता नहीं है

यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में लिखें। मैं जवाब देने की कोशिश करूंगा। मैंने छोटी चीज़ों के एक समूह में सार को डूबने की कोशिश नहीं की, ताकि एक सामान्य समझ विकसित हो। बाकी को पहले से ही परियोजना का अध्ययन करके समझा जा सकता है। लेकिन अगर आपको जल्दी से अपनी डिवाइस बनाने की आवश्यकता है, और जंगल में चढ़ने का समय नहीं है - आपको जो कुछ भी चाहिए, मैंने वर्णन किया है।

PS डिफ़ॉल्ट रूप से, जब कोई होस्ट पावर सेविंग मोड में जाता है, तो डिवाइस उसके साथ सो जाता है, और यदि आप डिवाइस को स्लीपिंग पीसी से कनेक्ट करते हैं, तो यह भी सो जाएगा। इसलिए, अगर हम बिजली की आपूर्ति को डिवाइस में प्लग करते हैं या इसे बैटरी से बिजली देते हैं, तो यह काम नहीं करेगा, यह मानते हुए कि यह एक नींद पीसी से जुड़ा है (कॉन्फ़िगरेशन पैकेज पीएसयू से निश्चित रूप से नहीं आएगा)। मैंने लाइब्रेरी को बदल दिया ताकि डिवाइस केवल पीएसयू को जोड़ने पर भी काम करे। इसलिए, डिवाइस एक पीसी से जुड़ा हुआ है और स्वायत्तता से काम करेगा। (यह पता लगाने में मुझे लंबा समय लगा।)

STM32 और USB-HID - यह आसान है