सीरियल पोर्ट पर एकाधिक कमांड भेजना और दूसरा भेजने से पहले उत्तर की प्रतीक्षा करना

थ्रेड.स्लीप के साथ खेलना बंद करें: यह संभवतः आपकी मदद नहीं करेगा।
जिस तरह से मैं यह करूँगा वह आदेशों की एक कतार स्थापित करना है, और प्रतिक्रिया प्राप्त करने के लिए डेटारिसीव्ड ईवेंट का उपयोग करना है। जब प्रतिक्रिया पूरी हो जाए, तो कतार से अगला आदेश निकालें, और उसे भेजें, और डेटारिसीव्ड ईवेंट को प्रतिक्रिया आने पर उसकी प्रक्रिया करने दें।
जब कतार खाली होती है, तो आदेशों का सेट पूरा हो जाता है।

सामान्य तौर पर एप्लिकेशन को ब्लॉक करने से बचने के लिए सभी एसिंक्रोनस IO ऑपरेशंस को अपने थ्रेड में निष्पादित किया जाना चाहिए। अन्यथा आपके पास GUI में अंतराल होगा या सबसे खराब स्थिति में GUI पूरी तरह से अवरुद्ध हो जाएगा।

आपके मामले में आपको उत्तर प्राप्त करने और कतारबद्ध आदेशों को प्रसारित करने के लिए कम से कम एक थ्रेड की आवश्यकता होगी।

पूर्ण प्रतिक्रिया प्राप्त होने तक प्राप्तकर्ता थ्रेड को डेटा बफर करना चाहिए। यह कैसे करना है यह डेटा पर निर्भर करता है (उदाहरण के लिए टेक्स्ट डेटा के साथ लाइन फ़ीड या प्रोटोकॉल हेडर में घोषित बाइट्स की संख्या प्राप्त करने के बाद)।

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

ट्रांसमिट थ्रेड केवल एक ब्लॉकिंग कॉल का उपयोग करके भेज सकता है क्योंकि इसे वैसे भी इंतजार करना पड़ता है। भेजने के बाद प्रतिक्रिया प्राप्त सिग्नल का इंतजार करना होगा।

आप भेजने और प्राप्त करने को एक या दो थ्रेड में रख सकते हैं।

प्राप्त करने के लिए छद्म कोड (पाठ डेटा मानकर):

// Check for kill (terminate thread) event (wait with no timeout)
while (!KillEvent)
{
    do 
    {
        // Blocking call until a character is available
        // Should have a timeout and corresponding handling (break here)
        rxChar = ReceiveChar();
        Buffer += rxChar;
    }
    while (rxChar != '\n');
    // Signal other threads that a response has been received
    // Pass a copy of Buffer to the main thread for display
}

ट्रांसमिट थ्रेड में, कमांड भेजने के बाद ऊपर कॉल करें या अपने स्वयं के थ्रेड में प्राप्त होने पर ईवेंट की प्रतीक्षा करें।

थ्रेड और ईवेंट का उपयोग करके आप कॉल करने से बचते हैं sleep जिससे आम तौर पर बचा जाना चाहिए और यह सुनिश्चित करना चाहिए कि कोई भी सिस्टम समय बर्बाद न हो।

मेरा SerialDevice यहाँ कक्षा:
जीपीआईबी/वीज़ा/सीरियल इंटरफेस के लिए मल्टीथ्रेडेड संचार[^]

उपरोक्त समाधान 2 में वर्णित प्रक्रिया को बिल्कुल लागू करता है: एसिंक्रोनस कमांड के साथ I/O एक अलग थ्रेड में किया जाता है जो लिखने/पढ़ने के लिए सरल ब्लॉकिंग कॉल का उपयोग करता है।

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

बीच में मैंने DataReceived हैंडलर का उपयोग किए बिना एक समाधान निकाला।
बस सीरियल पोर्ट पर कमांड लिखें और फिर लिखने के बाद सीरियल पोर्ट से उत्तर पढ़ें।
और यह मैं जो खोज रहा हूं उसके अनुसार काम कर रहा है।

लेकिन निश्चित नहीं हूं कि ऐसा करने का यह सही तरीका है या नहीं।
उदाहरण:
लिखना();
पढ़ना();