रूबी बांधना सी लाइब्रेरी के लिए

दूसरे दिन, यह libftdi लाइब्रेरी के लिए बाइंडिंग का निर्माण करने के लिए आवश्यक था, जो आधुनिक कंप्यूटरों को अप्रचलित करने के लिए USB कंप्यूटरों को RS-232 या TTL स्तरों के माध्यम से सीरियल डेटा ट्रांसफ़र करने के लिए चिप्स प्रदान करता है।

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

एफएफआई के कई फायदे हैं जो इसके पक्ष में खेले हैं:

• एमआरआई रूबी 1.9, एमआरआई रूबी 1.8, जेआरयूबी, रुबिनियस के लिए सीमित समर्थन के व्याख्याकारों के लिए समर्थन;
• विंडोज प्लेटफॉर्म के लिए समर्थन (दूसरों के बीच);
• बाइंडर्स को संकलित करने की आवश्यकता नहीं है;
• सुविधाजनक बाध्यकारी विवरण भाषा।

रूबी के लिए बाध्यकारी भंडार ।

शुरुआत

हम एक बाध्यकारी मॉड्यूल बनाते हैं जो libftdi लाइब्रेरी को लोड करता है:

require 'ffi' # Represents libftdi ruby bindings. # End-user API represented by {Ftdi::Context} class. module Ftdi extend FFI::Library ffi_lib "libftdi" end 

मानव रहित संसाधन प्रबंधन

Libftdi का मुख्य सार इसका संदर्भ है, जिसे आपको इसके साथ काम करना शुरू करने पर प्रकाश डालने की आवश्यकता है, और फिर उसी के अनुसार इसे जारी करें। FFI::ManagedStruct वर्ग अप्रबंधित संसाधनों के स्वत: संग्रह के लिए जिम्मेदार है:

  attach_function :ftdi_new, [ ], :pointer attach_function :ftdi_free, [ :pointer ], :void # Represents libftdi context and end-user API. # @example Open USB device # ctx = Ftdi::Context.new # begin # ctx.usb_open(0x0403, 0x6001) # begin # ctx.baudrate = 250000 # ensure # ctx.usb_close # end # rescue Ftdi::Error => e # $stderr.puts e.to_s # end class Context < FFI::ManagedStruct # layout skipped... # Initializes new libftdi context. # @raise [CannotInitializeContextError] libftdi cannot be initialized. def initialize ptr = Ftdi.ftdi_new raise CannotInitializeContextError.new if ptr.nil? super(ptr) end # Deinitialize and free an ftdi context. # @return [NilClass] nil def self.release(p) Ftdi.ftdi_free(p) nil end end 

FFI :: ManagedStruct निर्माणकर्ता निर्दिष्ट लेआउट (मूल दृश्य से FFI दृश्य के लिए संरचना रूपांतरण का नक्शा) द्वारा मार्श किए जाने वाले संरचना के लिए एक सूचक को स्वीकार करता है। हमारे कंस्ट्रक्टर में, हमें ftdi_new (मूल रूप से मॉलोक का उपयोग करके) कॉल के माध्यम से एक पॉइंटर मिलता है और इसे सुपरक्लास को पास करते हैं।

कचरा इकट्ठा करते समय, रिलीज़ क्लास विधि को मूल संरचना के लिए एक पैरामीटर-पॉइंटर के साथ बुलाया जाएगा, जिसमें हम इसे मुक्त करेंगे।

हम एपीआई बनाते हैं

चूंकि सभी लाइब्रेरी कॉल्स संदर्भ के साथ काम करते हैं, हम सभी एपीआई संदर्भ विधियों को बनाएंगे और एक ctx विधि बनाएंगे जो इन कॉल्स को सरल बनाने के लिए libftdi संदर्भ के लिए एक पॉइंटर लौटाता है।

अधिकांश libftdi फ़ंक्शन एक हस्ताक्षरित पूर्णांक लौटाते हैं, जो परिणाम शून्य से कम होने पर त्रुटि का संकेत देता है। इसलिए, समस्याओं के मामले में फ़ंक्शन कॉल के परिणाम को छोड़ने और अपवाद को छोड़ने के लिए एक सहायक लिखना सुविधाजनक है:

  private def ctx self.to_ptr end def check_result(status_code) if status_code < 0 raise StatusCodeError.new(status_code, error_string) end nil end 

यहाँ error_string , वह विधि है जो libftdi संदर्भ से त्रुटि संदेश प्राप्त करती है।

अब, उदाहरण के लिए, हम ftdi_set_interface फ़ंक्शन ftdi_set_interface लिए पोर्ट विकल्प और बाइंडिंग की ftdi_set_interface करते ftdi_set_interface । जिससे हम नाचते हैं:

 enum ftdi_interface { INTERFACE_ANY = 0, INTERFACE_A = 1, INTERFACE_B = 2, INTERFACE_C = 3, INTERFACE_D = 4 }; int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface); 

और हमें क्या मिलता है:

  # Port interface for chips with multiple interfaces. # @see Ftdi::Context#interface= Interface = enum(:interface_any, :interface_a, :interface_b, :interface_c, :interface_d) attach_function :ftdi_set_interface, [ :pointer, Interface ], :int class Context # ... # Open selected channels on a chip, otherwise use first channel. # @param [Interface] new_interface Interface to use for FT2232C/2232H/4232H chips. # @raise [StatusCodeError] libftdi reports error. # @return [Interface] New interface. def interface=(new_interface) check_result(Ftdi.ftdi_set_interface(ctx, new_interface)) new_interface end ... end 

बाइट सरणियों के साथ काम करें

ASCIIZ स्ट्रिंग्स के साथ काम करते समय तुच्छ (प्रकार :string ) है, बाइट्स के एक सरणी को स्थानांतरित करने के लिए उनका उपयोग करने का प्रयास विफलता के लिए बर्बाद होता है, क्योंकि एफएफआई मार्शलर पहले शून्य बाइट पर ठोकर खाते हैं।

बाइट्स की एक सरणी को स्थानांतरित करने के लिए हम टाइप का उपयोग करेंगे :pointer , जिसे हम एफएफआई के माध्यम से बनाएंगे: मेमोरीपॉइंटर (मेमोरी में संबंधित बफर को आवंटित करना और भरना)।

  attach_function :ftdi_write_data, [ :pointer, :pointer, :int ], :int class Context # ... # Writes data. # @param [String, Array] bytes String or array of integers that will be interpreted as bytes using pack('c*'). # @return [Fixnum] Number of written bytes. # @raise [StatusCodeError] libftdi reports error. def write_data(bytes) bytes = bytes.pack('c*') if bytes.respond_to?(:pack) size = bytes.respond_to?(:bytesize) ? bytes.bytesize : bytes.size mem_buf = FFI::MemoryPointer.new(:char, size) mem_buf.put_bytes(0, bytes) bytes_written = Ftdi.ftdi_write_data(ctx, mem_buf, size) check_result(bytes_written) bytes_written end end 

जैसा कि आप देख सकते हैं, बिल्डिंग बाइंडर्स एक तुच्छ कार्य बन गया है।

उन लोगों के लिए जो अपने निर्माण को स्वचालित करना चाहते हैं, मैं SWIG की दिशा में देखने की सलाह देता हूं।