PyUSB 1.0 के साथ प्रोग्रामिंग

अनुवादक से :
यह PyUSB 1.0 मैनुअल के साथ प्रोग्रामिंग का अनुवाद है
यह गाइड PyUSB डेवलपर्स द्वारा लिखा गया था, लेकिन जल्दी से कमिट्स के माध्यम से चल रहा है, मेरा मानना ​​है कि वालक गाइड के मुख्य लेखक हैं।

मुझे अपना परिचय दो

PyUSB 1.0 एक पायथन लाइब्रेरी है जो USB की आसान पहुँच प्रदान करता है। PyUSB विभिन्न कार्य प्रदान करता है:

• पायथन में 100% लिखा:
  0.x संस्करणों के विपरीत जो सी में लिखे गए थे, संस्करण 1.0 पायथन में लिखा गया है। यह पायथन प्रोग्रामर को बिना किसी सी अनुभव के बेहतर प्यूस बी काम करने की अनुमति देता है।
• प्लेटफ़ॉर्म तटस्थता:
  संस्करण 1.0 में फ्रंट-एंड बैकएंड योजना शामिल है। यह एपीआई को सिस्टम-विशिष्ट कार्यान्वयन विवरण से अलग करता है। IBackend इंटरफ़ेस इन दो परतों को जोड़ता है। PyUSB libusb 0.1, libusb 1.0 और OpenUSB के लिए बिल्ट-इन बैकएंड्स के साथ आता है। आप चाहें तो अपना बैकेंड खुद लिख सकते हैं।
• पोर्टेबिलिटी:
  PyUSB को Python> = 2.4, ctypes के साथ किसी भी प्लेटफ़ॉर्म पर चलना चाहिए, और कम से कम समर्थित बैक-इन बैकेंड में से एक होना चाहिए।
• सादगी:
  USB डिवाइस के साथ इंटरेक्शन इतना आसान कभी नहीं रहा! USB एक जटिल प्रोटोकॉल है, और PyUSB में सबसे आम कॉन्फ़िगरेशन के लिए अच्छे प्रीसेट हैं।
• Isochronous गियर समर्थन:
  यदि अंतर्निहित बैकेंड उनका समर्थन करता है, तो PyUSB समकालिक स्थानांतरण का समर्थन करता है।

यद्यपि PyUSB USB प्रोग्रामिंग को कम दर्दनाक बनाता है, यह ट्यूटोरियल मानता है कि आपको USB प्रोटोकॉल का न्यूनतम ज्ञान है। यदि आप USB के बारे में कुछ नहीं जानते हैं, तो मैं Jan Axelson की उत्कृष्ट USB पूर्ण पुस्तक की अनुशंसा करता हूं।

बहुत बात करते हैं, चलो कोड लिखते हैं!

कौन है कौन

आरंभ करने के लिए, आइए PyUSB मॉड्यूल का विवरण दें। सभी PyUSB मॉड्यूल निम्न मॉड्यूल के साथ USB के अंतर्गत हैं:

मॉड्यूल	विवरण
कोर	मुख्य USB मॉड्यूल।
util	सहायक कार्य।
नियंत्रण	मानक प्रबंधन अनुरोध।
विरासत	संस्करण 0.x संगतता परत।
बैकएंड	एक बैकपैक जिसमें अंतर्निहित बैकएंड होते हैं।

उदाहरण के लिए, एक कोर मॉड्यूल आयात करने के लिए, निम्नलिखित दर्ज करें:

>>> import usb.core >>> dev = usb.core.find() 

खैर, शुरू करते हैं

निम्नलिखित एक सरल प्रोग्राम है जो स्ट्रिंग (परीक्षण) को पहले प्राप्त डेटा स्रोत (अंतिम बिंदु) पर भेजता है:

  import usb.core import usb.util #    dev = usb.core.find(idVendor=0xfffe, idProduct=0x0001) #   ? if dev is None: raise ValueError('Device not found') #   .  ,   #    dev.set_configuration() #    cfg = dev.get_active_configuration() intf = cfg[(0,0)] ep = usb.util.find_descriptor( intf, #     custom_match = \ lambda e: \ usb.util.endpoint_direction(e.bEndpointAddress) == \ usb.util.ENDPOINT_OUT) assert ep is not None #   ep.write('test') 

पहली दो पंक्तियाँ PyUSB पैकेज मॉड्यूल आयात करती हैं। usb.core मुख्य मॉड्यूल है, और usb.util में सहायक कार्य होते हैं। निम्न आदेश हमारे डिवाइस को खोजता है और यदि यह मिलता है तो वस्तु का एक उदाहरण देता है। यदि नहीं, तो कोई नहीं लौटाता। अगला, हम कॉन्फ़िगरेशन सेट करते हैं जो हम उपयोग करेंगे। नोट: तर्कों की अनुपस्थिति का अर्थ है कि वांछित कॉन्फ़िगरेशन डिफ़ॉल्ट रूप से सेट किया गया था। जैसा कि आप देखेंगे, कई PyUSB विशेषताओं में अधिकांश सामान्य उपकरणों के लिए डिफ़ॉल्ट सेटिंग्स हैं। इस स्थिति में, पाया गया पहला कॉन्फ़िगरेशन सेट है।

फिर, हम उस समापन बिंदु की तलाश करते हैं जिस पर हम रुचि रखते हैं। हम इसे पहले इंटरफेस के अंदर देख रहे हैं जो हमारे पास है। इस बिंदु को खोजने के बाद, हम इसे डेटा भेजते हैं।

अगर हम पहले से ही समापन बिंदु का पता जानते हैं, तो हम बस डिवाइस ऑब्जेक्ट के लेखन फ़ंक्शन को कॉल कर सकते हैं:

 dev.write(1, 'test') 

यहां हम एड्रेस 1 पर ब्रेकप्वाइंट पर स्ट्रिंग 'टेस्ट' लिखते हैं। इन सभी कार्यों पर निम्नलिखित अनुभागों में बेहतर चर्चा की जाएगी।

क्या गलत है?

PyUSB में प्रत्येक फ़ंक्शन त्रुटि के मामले में एक अपवाद फेंकता है। मानक पायथन अपवादों के अलावा, PyUSB USB से संबंधित त्रुटियों के लिए usb.core.USBError को परिभाषित करता है।

आप PyUSB लॉग फ़ंक्शंस का भी उपयोग कर सकते हैं। यह लॉगिंग मॉड्यूल का उपयोग करता है। इसका उपयोग करने के लिए, निम्न लॉगिंग स्तरों में से एक के साथ PYUSB_DEBUG पर्यावरण चर को परिभाषित करें: महत्वपूर्ण , त्रुटि , चेतावनी , जानकारी या डीबग ।

डिफ़ॉल्ट रूप से, संदेश sys.stderr पर भेजे जाते हैं । यदि आप चाहते हैं, तो आप पर्यावरण चर PYUSB_LOG_FILENAME को परिभाषित करके किसी फ़ाइल में लॉग संदेश पुनर्निर्देशित कर सकते हैं। यदि फ़ाइल के लिए इसका मान सही पथ है, तो संदेश वहां लिखे जाएंगे, अन्यथा उन्हें sys.stderr पर भेजा जाएगा।

तुम कहाँ हो

कोर मॉड्यूल में खोज () फ़ंक्शन का उपयोग सिस्टम से जुड़े उपकरणों को खोजने और करने के लिए किया जाता है। उदाहरण के लिए, मान लें कि हमारे डिवाइस में 0xfffe के मान के साथ विक्रेता ID और 0x0001 का उत्पाद ID है। यदि हमें इस उपकरण को खोजने की आवश्यकता है तो हम यह करेंगे:

 import usb.core dev = usb.core.find(idVendor=0xfffe, idProduct=0x0001) if dev is None: raise ValueError('Our device is not connected') 

यह सब है, फ़ंक्शन usb.core.Device ऑब्जेक्ट को लौटाएगा जो हमारे डिवाइस का प्रतिनिधित्व करता है। यदि डिवाइस नहीं मिला है, तो यह कोई नहीं लौटेगा। वास्तव में, आप डिवाइस डिस्क्रिप्टर वर्ग के किसी भी क्षेत्र का उपयोग कर सकते हैं जो आप चाहते हैं। उदाहरण के लिए, क्या होगा यदि हम यह पता लगाना चाहते हैं कि क्या कोई यूएसबी प्रिंटर सिस्टम से जुड़ा है? यह बहुत आसान है:

 #      ,   if usb.core.find(bDeviceClass=7) is None: raise ValueError('No printer found') 

7 USB विनिर्देश के अनुसार प्रिंटर वर्ग के लिए कोड है। ओह, रुको, क्या होगा अगर मैं सभी उपलब्ध प्रिंटर को नंबर देना चाहता हूं? कोई समस्या नहीं:

 #     ... printers = usb.core.find(find_all=True, bDeviceClass=7) # Python 2, Python 3,     import sys sys.stdout.write('There are ' + len(printers) + ' in the system\n.') 

क्या हुआ? खैर, थोड़ा स्पष्टीकरण के लिए समय ... खोज में एक पैरामीटर होता है जिसे find_all कहा जाता है और फाल्स को डिफॉल्ट करता है। जब यह झूठ है [१] , पहले मापदंड से मेल खाने वाले पहले डिवाइस को खोजेंगे (हम जल्द ही इस बारे में बात करेंगे)। यदि आप पैरामीटर के लिए एक सही मान पास करते हैं, तो मानदंड के मिलान के बजाय सभी उपकरणों की सूची लौटाएगा। वह सब है! सरल, सही?

क्या हम कर रहे हैं? नहीं! मैंने अभी तक सब कुछ नहीं बताया है: कई डिवाइस वास्तव में डिवाइस डिस्क्रिप्टर के बजाय इंटरफ़ेस डिस्क्रिप्टर में अपनी कक्षा की जानकारी रखते हैं। इसलिए, सिस्टम से जुड़े सभी प्रिंटरों को सही मायने में खोजने के लिए, हमें सभी कॉन्फ़िगरेशनों के साथ-साथ सभी इंटरफेस से गुजरने की आवश्यकता होगी, और जांचें कि क्या इंटरफेस में से एक bInterfaceClass पर सेट है। 7. यदि आप मेरी तरह एक प्रोग्रामर हैं, तो आप आश्चर्यचकित हो सकते हैं: क्या कोई आसान तरीका है जिसके साथ इसे लागू किया जा सकता है। उत्तर: हां, वह है। आरंभ करने के लिए, आइए सभी जुड़े प्रिंटर खोजने के लिए तैयार कोड को देखें:

 import usb.core import usb.util import sys class find_class(object): def __init__(self, class_): self._class = class_ def __call__(self, device): #  ,   if device.bDeviceClass == self._class: return True # ,   ,   # ,     for cfg in device: # find_descriptor:  ? intf = usb.util.find_descriptor( cfg, bInterfaceClass=self._class ) if intf is not None: return True return False printers = usb.core.find(find_all=1, custom_match=find_class(7)) 

Custom_match पैरामीटर डिवाइस ऑब्जेक्ट को प्राप्त करने वाली किसी भी ऑब्जेक्ट को स्वीकार करता है। यह एक उपयुक्त डिवाइस के लिए सही लौटना चाहिए और अनुचित के लिए गलत होना चाहिए। आप चाहें तो डिवाइस फ़ील्ड के साथ custom_match भी जोड़ सकते हैं:

 #   ,    : printers = usb.core.find(find_all=1, custom_match=find_class(7), idVendor=0xfffe) 

यहां हम आपूर्तिकर्ता 0xfffe के प्रिंटर में रुचि रखते हैं।

अपना वर्णन कीजिए

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

 >>> dev.bLength >>> dev.bNumConfigurations >>> dev.bDeviceClass >>> # ... 

डिवाइस में उपलब्ध कॉन्फ़िगरेशन तक पहुंचने के लिए, आप डिवाइस को पुन: व्यवस्थित कर सकते हैं:

 for cfg in dev: sys.stdout.write(str(cfg.bConfigurationValue) + '\n') 

उसी तरह, आप इंटरफ़ेस को एक्सेस करने के लिए कॉन्फ़िगरेशन को पुनरावृत्त कर सकते हैं, साथ ही साथ अपने नियंत्रण बिंदुओं तक पहुंचने के लिए इंटरफेस को पुन: व्यवस्थित कर सकते हैं। प्रत्येक प्रकार की वस्तु में विशेषताओं के अनुसार संबंधित विवरणक के क्षेत्र होते हैं। एक उदाहरण देखें:

 for cfg in dev: sys.stdout.write(str(cfg.bConfigurationValue) + '\n') for intf in cfg: sys.stdout.write('\t' + \ str(intf.bInterfaceNumber) + \ ',' + \ str(intf.bAlternateSetting) + \ '\n') for ep in intf: sys.stdout.write('\t\t' + \ str(ep.bEndpointAddress) + \ '\n') 

आप विवरणकर्ताओं तक यादृच्छिक पहुँच के लिए अनुक्रमित का उपयोग कर सकते हैं, जैसा कि यहाँ है:

 >>> #      >>> cfg = dev[1] >>> #      >>> intf = cfg[(0,0)] >>> #    >>> ep = intf[2] 

जैसा कि आप देख सकते हैं कि सूचकांक 0. से गिने गए हैं, लेकिन प्रतीक्षा करें! इंटरफ़ेस तक पहुंच पाने के तरीके में कुछ अजीब है ... हाँ, आप सही हैं, कॉन्फ़िगरेशन के लिए इंडेक्स दो मानों की एक श्रृंखला लेता है, जिनमें से पहला इंटरफ़ेस इंडेक्स है, और दूसरा एक वैकल्पिक सेटिंग है। सामान्य तौर पर, पहला इंटरफ़ेस एक्सेस करने के लिए, लेकिन दूसरी सेटिंग के साथ, हम cfg [(0,1)] लिखेंगे।

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

• find_descriptor अपना पहला पैरामीटर स्रोत डिस्क्रिप्टर के रूप में प्राप्त करता है जिसे आप खोजेंगे ।
• इसमें कोई बैकेंड पैरामीटर नहीं है [२] ।

उदाहरण के लिए, यदि हमारे पास cfg कॉन्फ़िगरेशन डिस्क्रिप्टर है, और हम इंटरफ़ेस 1 के लिए सभी वैकल्पिक सेटिंग्स ढूंढना चाहते हैं, तो हम यह करेंगे:

 import usb.util alt = usb.util.find_descriptor(cfg, find_all=True, bInterfaceNumber=1) 

ध्यान दें कि find_descriptor usb.util मॉड्यूल में है। यह पहले बताए गए custom_match पैरामीटर को भी स्वीकार करता है।

हम कई समान उपकरणों के साथ सौदा करते हैं

कभी-कभी आपके पास कंप्यूटर से जुड़े दो समान उपकरण हो सकते हैं। आप उनके बीच अंतर कैसे कर सकते हैं? डिवाइस ऑब्जेक्ट दो अतिरिक्त विशेषताओं के साथ आते हैं जो USB विनिर्देश का हिस्सा नहीं हैं, लेकिन बहुत उपयोगी हैं: बस और पता विशेषताएँ। सबसे पहले, यह कहने योग्य है कि ये विशेषताएं बैकएंड से आती हैं, और बैकएंड उनका समर्थन नहीं कर सकता है - इस मामले में वे किसी भी पर सेट नहीं हैं । हालाँकि, ये विशेषताएँ डिवाइस बस की संख्या और पते का प्रतिनिधित्व करती हैं और, जैसा कि आपने अनुमान लगाया होगा, एक ही idVendor और idProduct विशेषता मानों के साथ दो उपकरणों के बीच अंतर करने के लिए उपयोग किया जा सकता है।

मुझे कैसे काम करना चाहिए?

कनेक्ट करने के बाद, USB उपकरणों को कुछ मानक प्रश्नों का उपयोग करके कॉन्फ़िगर किया जाना चाहिए। जब मैंने USB विनिर्देश का अध्ययन करना शुरू किया, तो मुझे वर्णनकर्ता, कॉन्फ़िगरेशन, इंटरफेस, वैकल्पिक सेटिंग्स, स्थानांतरण प्रकार और उन सभी से हतोत्साहित किया गया ... और सबसे बुरी बात, आप बस उन्हें अनदेखा नहीं कर सकते: डिवाइस कॉन्फ़िगरेशन सेट किए बिना काम नहीं करता है, भले ही यह एक हो! PyUSB आपके जीवन को यथासंभव सरल बनाने की कोशिश कर रहा है। उदाहरण के लिए, अपनी डिवाइस ऑब्जेक्ट प्राप्त करने के बाद, सबसे पहले, इसके साथ बातचीत करने से पहले, आपको एक set_configuration अनुरोध भेजना होगा। इस क्वेरी के लिए कॉन्फ़िगरेशन पैरामीटर जो आपकी रुचि है bConfigurationValue है । अधिकांश उपकरणों में एक से अधिक कॉन्फ़िगरेशन नहीं हैं, और उपयोग करने के लिए कॉन्फ़िगरेशन मान को ट्रैक करना कष्टप्रद है (हालांकि अधिकांश कोड मैंने केवल हार्डकोड किए गए देखा था)। इसलिए, PyUSB में, आप बिना किसी तर्क के एक set_configuration अनुरोध भेज सकते हैं। इस स्थिति में, वह पाया गया पहला कॉन्फ़िगरेशन स्थापित करेगा (यदि आपके डिवाइस में केवल एक है, तो आपको कॉन्फ़िगरेशन मान के बारे में चिंता करने की आवश्यकता नहीं है)। उदाहरण के लिए, मान लें कि आपके पास एक कॉन्फ़िगरेशन डिस्क्रिप्टर वाला एक उपकरण है, और इसका bConfigurationValue फ़ील्ड 5 है [३] , बाद के प्रश्न समान होंगे:

 >>> dev.set_configuration(5) #  >>> dev.set_configuration() #  ,   5 -  #  >>> cfg = util.find_descriptor(dev, bConfigurationValue=5) >>> cfg.set() #  >>> cfg = util.find_descriptor(dev, bConfigurationValue=5) >>> dev.set_configuration(cfg) 

वाह! आप कॉन्फ़िगरेशन ऑब्जेक्ट को set_configuration के पैरामीटर के रूप में उपयोग कर सकते हैं! हां, उसके पास वर्तमान कॉन्फ़िगरेशन में स्वयं को कॉन्फ़िगर करने के लिए एक सेट विधि भी है।

एक और विकल्प जिसकी आपको आवश्यकता है या कॉन्फ़िगर करने की आवश्यकता नहीं है, वह है इंटरफेस बदलने का विकल्प। प्रत्येक डिवाइस में एक समय में केवल एक सक्रिय कॉन्फ़िगरेशन हो सकता है, और प्रत्येक कॉन्फ़िगरेशन में एक से अधिक इंटरफ़ेस हो सकते हैं, और आप एक ही समय में सभी इंटरफ़ेस का उपयोग कर सकते हैं। यदि आप इंटरफ़ेस को तार्किक उपकरण के रूप में समझते हैं तो आप इस अवधारणा को बेहतर ढंग से समझते हैं। उदाहरण के लिए, आइए एक मल्टीफ़ंक्शन प्रिंटर की कल्पना करें, जो एक ही समय में एक प्रिंटर और एक स्कैनर दोनों है। जटिल करने के लिए नहीं (या कम से कम इसे यथासंभव सरल बनाएं), मान लेते हैं कि उसके पास केवल एक कॉन्फ़िगरेशन है। क्योंकि हमारे पास एक प्रिंटर और स्कैनर है, कॉन्फ़िगरेशन में 2 इंटरफ़ेस हैं: एक प्रिंटर के लिए और एक स्कैनर के लिए। एक से अधिक इंटरफेस वाले डिवाइस को कंपोजिट डिवाइस कहा जाता है। जब आप अपने मल्टीफ़ंक्शन प्रिंटर को अपने कंप्यूटर से कनेक्ट करते हैं, तो ऑपरेटिंग सिस्टम दो अलग-अलग ड्राइवरों को लोड करेगा: प्रत्येक "तार्किक" परिधीय डिवाइस जो आपके पास है [४] ।

वैकल्पिक इंटरफ़ेस सेटिंग्स के बारे में क्या? अच्छी बात है आपने पूछा। एक इंटरफ़ेस में एक या अधिक वैकल्पिक सेटिंग्स हैं। माना जाता है कि केवल एक वैकल्पिक सेटिंग वाले इंटरफ़ेस में कोई वैकल्पिक सेटिंग नहीं होती है [५] उपकरणों के लिए एक विन्यास के रूप में इंटरफेस के लिए वैकल्पिक सेटिंग्स, अर्थात्, प्रत्येक इंटरफ़ेस के लिए आपके पास केवल एक सक्रिय वैकल्पिक सेटिंग हो सकती है। उदाहरण के लिए, USB विनिर्देश बताता है कि डिवाइस में प्राथमिक वैकल्पिक कॉन्फ़िगरेशन में एक समकालिक चेकपॉइंट नहीं हो सकता है [६] , ताकि स्ट्रीमिंग डिवाइस में कम से कम दो वैकल्पिक सेटिंग्स हों, एक दूसरी सेटिंग में एक समकालिक चेकपॉइंट होना चाहिए। लेकिन, कॉन्फ़िगरेशन के विपरीत, केवल एक वैकल्पिक कॉन्फ़िगरेशन के साथ इंटरफेस को कॉन्फ़िगर करने की आवश्यकता नहीं है []] । आप set_interface_altsetting फ़ंक्शन का उपयोग करके एक वैकल्पिक इंटरफ़ेस सेटिंग का चयन करते हैं:

 >>> dev.set_interface_altsetting(interface = 0, alternate_setting = 0) 

चेतावनी

USB विनिर्देशन कहता है कि यदि किसी अतिरिक्त वैकल्पिक सेटिंग में इंटरफ़ेस के लिए SET_INTERFACE अनुरोध प्राप्त होता है, तो डिवाइस को एक त्रुटि वापस करने की अनुमति है। इसलिए यदि आप सुनिश्चित नहीं हैं कि इंटरफ़ेस में एक से अधिक वैकल्पिक सेटिंग हैं या यह SET_INTERFACE अनुरोध को स्वीकार करता है, तो सबसे सुरक्षित तरीका यह है कि कोशिश करने वाले ब्लॉक के अंदर set_interface_altsetting को कॉल करें:

 try: dev.set_interface_altsetting(...) except USBError: pass 

आप इंटरफ़ेस ऑब्जेक्ट को फ़ंक्शन पैरामीटर के रूप में भी उपयोग कर सकते हैं, इंटरफ़ेस और वैकल्पिक_सेटिंग पैरामीटर स्वचालित रूप से bInterfaceNumber और bAlternateSetting फ़ील्ड से विरासत में मिले हैं । एक उदाहरण:

 >>> intf = find_descriptor(...) >>> dev.set_interface_altsetting(intf) >>> intf.set_altsetting() # !        

चेतावनी

इंटरफ़ेस ऑब्जेक्ट सक्रिय कॉन्फ़िगरेशन डिस्क्रिप्टर से संबंधित होना चाहिए।

मुझसे बात करो मधु

और अब हमारे लिए यह समझने का समय है कि यूएसबी उपकरणों के साथ बातचीत कैसे करें। USB में चार प्रकार की डेटा स्ट्रीम हैं: बल्क ट्रांसफर, इंटरप्ट ट्रांसफर, आइसोक्रोनस ट्रांसफर और कंट्रोल ट्रांसफर। मैं प्रत्येक सूत्र के उद्देश्य और उनके बीच के अंतर को समझाने की योजना नहीं बनाता। इसलिए, मुझे लगता है कि आपके पास USB डेटा धाराओं का कम से कम बुनियादी ज्ञान है।

नियंत्रण डेटा स्ट्रीम एकमात्र स्ट्रीम है जिसकी संरचना विनिर्देश में वर्णित है, बाकी बस यूएसबी बिंदु से कच्चे डेटा को भेजते हैं और प्राप्त करते हैं। इसलिए, आपके पास नियंत्रण प्रवाह के साथ काम करने के लिए विभिन्न कार्य हैं, और बाकी प्रवाह उसी कार्यों द्वारा संसाधित किए जाते हैं।

आप ctrl_transfer विधि का उपयोग करके नियंत्रण डेटा स्ट्रीम तक पहुंच सकते हैं। इसका उपयोग आउटगोइंग (OUT) और इनकमिंग (IN) स्ट्रीम के लिए किया जाता है। प्रवाह की दिशा bmRequestType पैरामीटर द्वारा निर्धारित की जाती है।

पैरामीटर ctrl_transfer नियंत्रण अनुरोध की संरचना के साथ लगभग मेल खाते हैं। निम्नलिखित एक उदाहरण है कि कैसे नियंत्रण डेटा स्ट्रीम को व्यवस्थित किया जाए। []] :

 >>> msg = 'test' >>> assert dev.ctrl_transfer(0x40, CTRL_LOOPBACK_WRITE, 0, 0, msg) == len(msg) >>> ret = dev.ctrl_transfer(0xC0, CTRL_LOOPBACK_READ, 0, 0, len(msg)) >>> sret = ''.join([chr(x) for x in ret]) >>> assert sret == msg 

यह उदाहरण मानता है कि हमारे डिवाइस में दो उपयोगकर्ता नियंत्रण अनुरोध शामिल हैं जो लूपबैक पाइप की तरह काम करते हैं। आप CTRL_LOOPBACK_WRITE संदेश के साथ क्या लिखते हैं, आप CTRL_LOOPBACK_READ संदेश के साथ पढ़ सकते हैं।

पहले चार पैरामीटर - bmRequestType , bmRequest , wValue और wIndex - कंट्रोल स्ट्रीम की मानक संरचना के क्षेत्र हैं। पांचवां पैरामीटर या तो आउटगोइंग डेटा स्ट्रीम के लिए ट्रांसफर किया जा रहा डेटा है या इनकमिंग स्ट्रीम में पढ़े जा रहे डेटा की संख्या। प्रेषित डेटा किसी भी प्रकार का अनुक्रम हो सकता है, जिसे सरणी के लिए __in____ विधि के इनपुट के लिए एक पैरामीटर के रूप में खिलाया जा सकता है। यदि कोई डेटा स्थानांतरित नहीं किया जा रहा है, तो पैरामीटर को किसी भी (या आने वाली डेटा स्ट्रीम के मामले में 0) पर सेट किया जाना चाहिए। ऑपरेशन टाइमआउट का संकेत देने वाला एक और वैकल्पिक पैरामीटर है। यदि आप इसे पास नहीं करते हैं, तो डिफ़ॉल्ट टाइमआउट का उपयोग किया जाएगा (बाद में इस पर अधिक)। आउटगोइंग डेटा स्ट्रीम में, वापसी मूल्य वास्तव में डिवाइस को भेजे गए बाइट्स की संख्या है। इनकमिंग स्ट्रीम में, रिटर्न वैल्यू एक सरणी है जिसमें डेटा पढ़ा जाता है।

अन्य धाराओं के लिए, आप डेटा लिखने और पढ़ने के लिए क्रमशः लिखने और पढ़ने के तरीकों का उपयोग कर सकते हैं। आपको स्ट्रीम के प्रकार के बारे में चिंता करने की आवश्यकता नहीं है - यह स्वचालित रूप से चेकपॉइंट के पते से पता लगाया जाता है। यहाँ हमारा लूपबैक उदाहरण है, बशर्ते कि हमारे पास ब्रेकपॉइंट 1 पर एक लूपबैक पाइप हो:

 >>> msg = 'test' >>> assert len(dev.write(1, msg, 100)) == len(msg) >>> ret = dev.read(0x81, len(msg), 100) >>> sret = ''.join([chr(x) for x in ret]) >>> assert sret == msg 

पहले और तीसरे पैरामीटर दोनों विधियों के लिए समान हैं - यह क्रमशः चेकपॉइंट पता और टाइमआउट है। दूसरा पैरामीटर प्रेषित डेटा (लिखना) या पढ़ने (पढ़ने) के लिए बाइट्स की संख्या है। लौटाया गया डेटा या तो पढ़ने की विधि के लिए एक सरणी ऑब्जेक्ट का एक उदाहरण होगा, या लिखने की विधि के लिए लिखे गए बाइट्स की संख्या।

बीटा 2 संस्करणों के साथ, बाइट्स की संख्या के बजाय, आप रीड या ctrl_transfer एक ऐरे ऑब्जेक्ट के लिए पास कर सकते हैं, जिसमें डेटा पढ़ा जाएगा। इस स्थिति में, पढ़ने के लिए बाइट्स की संख्या array.itemsize के मान के सरणी समय की लंबाई होगी।

Ctrl_transfer में , टाइमआउट पैरामीटर वैकल्पिक है। जब टाइमआउट छोड़ा जाता है, तो Device.default_timeout प्रॉपर्टी को ऑपरेशनल टाइमआउट के रूप में उपयोग किया जाता है।

खुद पर नियंत्रण रखें

डेटा स्ट्रीम फ़ंक्शन के अलावा, usb.control मॉड्यूल मानक USB नियंत्रण अनुरोधों को शामिल करने वाले फ़ंक्शन प्रदान करता है, और usb.util मॉड्यूल में एक सुविधाजनक get_string फ़ंक्शन होता है जो विशेष रूप से लाइन डिस्क्रिप्टर प्रदर्शित करता है।

अतिरिक्त विषय

हर महान अमूर्तता के पीछे एक महान अहसास है

पहले, केवल लिबास था। उसके बाद libusb 1.0 आया और हमारे पास 0.1 और 1.0 libusb था। उसके बाद, हमने ओपनयूएसबी बनाया और अब हम यूएसबी लाइब्रेरी के टॉवर ऑफ बेबल में रहते हैं [९] । PyUSB इसे कैसे संभालता है? खैर, PyUSB एक लोकतांत्रिक पुस्तकालय है, आप चाहें तो कौन सा पुस्तकालय चुन सकते हैं। वास्तव में, आप अपनी स्वयं की USB लाइब्रेरी को स्क्रैच से लिख सकते हैं और इसका उपयोग करने के लिए PyUSB को बता सकते हैं।

खोज फ़ंक्शन का एक और पैरामीटर है, जिसके बारे में मैंने आपको नहीं बताया। यह बैकएंड पैरामीटर है। यदि आप इसे स्थानांतरित नहीं करते हैं, तो अंतर्निहित बैकएंड में से एक का उपयोग किया जाएगा। बैकएंड usb.backend.IBackend से विरासत में मिली एक वस्तु है, जो ऑपरेटिंग सिस्टम-विशिष्ट USB जंक को शुरू करने के लिए जिम्मेदार है। जैसा कि आपने अनुमान लगाया होगा, बिल्ट-इन लिबास 0.1, लिबसब 1.0 और ओपनयूएसबी बैकएंड हैं।

आप अपने स्वयं के बैकएंड को लिख सकते हैं और इसका उपयोग कर सकते हैं। बस IBackend से विरासत में मिलता है और आवश्यक तरीकों को सक्षम करता है। यह कैसे किया जाता है, यह समझने के लिए आपको usb.backend प्रलेखन को देखने की आवश्यकता हो सकती है।

स्वार्थी मत बनो

पायथन के पास वह है जिसे हम स्वचालित मेमोरी प्रबंधन कहते हैं । इसका मतलब है कि वर्चुअल मशीन यह तय करेगी कि मेमोरी से वस्तुओं को कब उतारना है। हुड के तहत, PyUSB उन सभी निम्न-स्तरीय संसाधनों का प्रबंधन करता है, जिनके साथ आपको काम करने की आवश्यकता होती है (इंटरफ़ेस को स्वीकृत करना, डिवाइस को समायोजित करना, आदि) और अधिकांश उपयोगकर्ताओं को इस बारे में चिंता करने की आवश्यकता नहीं है। लेकिन, पायथन द्वारा वस्तुओं के स्वचालित विनाश की अपरिभाषित प्रकृति के कारण, उपयोगकर्ता यह अनुमान नहीं लगा सकते हैं कि आवंटित संसाधन कब जारी किए जाएंगे। कुछ अनुप्रयोगों को आवंटित करने और नि: शुल्क संसाधनों को निर्धारित करने की आवश्यकता है। ऐसे अनुप्रयोगों के लिए, usb.util मॉड्यूल संसाधन प्रबंधन के साथ बातचीत करने के लिए कार्य प्रदान करता है।

यदि आप मैन्युअल रूप से इंटरफेस का अनुरोध करना और जारी करना चाहते हैं, तो आप क्लेम_इंटरफेस और रिलीज़_इनफ़र्ट फ़ंक्शंस का उपयोग कर सकते हैं। claim_interface , . , . release_interface , . , . , libusb .

( ), dispose_resources . ( ) , find .

, — , API USB. -, ctypes find_library() . Linux Unix- , find_library ( /sbin/ldconfig , gcc objdump ) .

/ , . , PyUSB find_library() .

:

 >>> import usb.core >>> import usb.backend.libusb1 >>> >>> backend = usb.backend.libusb1.get_backend(find_library=lambda x: "/usr/lib/libusb-1.0.so") >>> dev = usb.core.find(..., backend=backend) 

, find_library — get_backend(), , .

API PyUSB (0.--), , , API. , , . PyUSB 1.0 usb.legacy . API API. « , import usb import usb.legacy as usb ?», . — , , . , import usb usb.legacy . — .

,

, e-mail , . PyUSB .

[1] True False ( ), Python. (true) (false), Python, . ( . — .. ) :

[2] .

[3] USB - . .

[4] , .

[5] , .

[6] , , .

[7] , .

[8] PyUSB 0. ( ).

[9] , . , .