एंड्रॉइड - आने वाली (हाई-स्पीड) यूएसबी डेटा खोना

Question

एंड्रॉइड का उपयोग करते समय, मैं आने वाली यूएसबी डेटा स्ट्रीम पर डेटा खो रहा हूं जो विंडोज़ में उसी डिवाइस/स्ट्रीम को पढ़ने के दौरान खो नहीं जाता है। (मुझे पता है कि एंड्रॉइड एक वास्तविक समय ओएस नहीं है, लेकिन न तो विंडोज है, और विंडोज को डेटा के साथ 'रख-रखाव' करने में कोई समस्या नहीं है।)

मेरे पास डेटा 3.5 एमबी/सेकेंड में डेटा का उपयोग कर रहा है एफटीडीआई 2232 एच चिप जो 4 के बफर में बनाया गया है। Libusb में bulk_transfer कॉल एक समय में 16K के लिए पूछ सकते हैं, इसलिए एंड्रॉइड को हर 4 एमएमएस या उससे अधिक यूएसबी बफर की सामग्री काटने की जरूरत है।

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

फिर भी, एंड्रॉइड यूएसबी डेटा में 'चारों ओर नहीं जा रहा' है, कभी-कभी पढ़ने के बीच 12ms तक प्रतीक्षा करता है, जिससे डेटा का गुच्छा खो जाता है।

क्या किसी के पास कोई विचार है? डीएमए? कर्नेल को कुछ प्रकार के 'वास्तविक समय' अनुरोध?

Answer 1

मुझे इससे पहले इस तरह की समस्या का सामना करना पड़ा है। जावा का उपयोग करके भूल जाओ, पृष्ठभूमि में यह अनगिनत चीजें कर रहा है जो रीयलटाइम एक्सेस को रोकता है, उदा। कचरा संग्रह, धागा प्रसंस्करण। इवेंट-संचालित प्रोग्रामिंग का उपयोग करना भी भूलें, यहां तक ​​कि उच्च प्राथमिकता धागे में भी, ईवेंट संसाधित होने में काफी समय लग सकता है और आप डेटा खो सकते हैं।

जिस तरह से मैंने इसे ठीक किया था, वह "असभ्य" कोड लिखना था! खेतों में प्रयुक्त सी या विधानसभा, और इस तरह एक मतदान समारोह (सी-तरह छद्म कोड में) ने लिखा:

#define PAUSE 2 /* Check twice as often as the packet rate */ 
#define TIMEOUT (500/PAUSE) /* Abort if half a second of no data */ 

/* Provide handle, data buffer and size of buffer 
    Returns TRUE if full buffer read, FALSE if not, data unread in size 
*/ 
BOOL real_time_read(HANDLE handle, BYTE *data, size_t *size) 
{ 
    BOOL result = FALSE; 
    int timeout = TIMEOUT; 

    set_thread_priority(REALTIME); 

    while (is_handle_valid(handle)) 
    { 
     if (is_data_pending(handle)) 
     { 
      size_t count = get_data(handle, data, size); 
      data += count; 
      *size -= count; 
      if (!*size) 
      { 
       result = TRUE; 
       break; 
      } 
     } 
     else if (!--timeout) 
      break; 

     /* Give a tiny time slice to other processes */ 
     usleep(PAUSE); 
    } 

    return result; 
} 

आपने कहा आप सी कोशिश की, तो यह वास्तविक कार्यों में बदलने के लिए आसान होना चाहिए। सुविधा कार्यों का उपयोग करने के प्रलोभन से बचें, आप जितना संभव हो सके धातु के करीब चाहते हैं। जैसे यदि एक ओ/एस फ़ंक्शन Read() बदले में read() पर कॉल करता है जो बदले में _read() पर कॉल करता है, तो आप _read() का उपयोग करना चाहते हैं। यह चालू होने पर डिवाइस काफी धीमा होगा, लेकिन यह रीयल-टाइम पहुंच का व्यापार है।