.NET Framework
क्रमिक बंदरगाह

मूल परिचालन

var serialPort = new SerialPort("COM1", 9600, Parity.Even, 8, StopBits.One);
serialPort.Open();
serialPort.WriteLine("Test data");
string response = serialPort.ReadLine();
Console.WriteLine(response);
serialPort.Close();

उपलब्ध पोर्ट नाम सूचीबद्ध करें

string[] portNames = SerialPort.GetPortNames();

अतुल्यकालिक पढ़ा

void SetupAsyncRead(SerialPort serialPort)
{
    serialPort.DataReceived += (sender, e) => {
        byte[] buffer = new byte[4096];
        switch (e.EventType)
        {
            case SerialData.Chars:
                var port = (SerialPort)sender;
                int bytesToRead = port.BytesToRead;
                if (bytesToRead > buffer.Length)
                    Array.Resize(ref buffer, bytesToRead);
                int bytesRead = port.Read(buffer, 0, bytesToRead);
                // Process the read buffer here
                // ...
                break;
            case SerialData.Eof:
                // Terminate the service here
                // ...
                break;
        }
    };

सिंक्रोनस टेक्स्ट इको सर्विस

using System.IO.Ports;

namespace TextEchoService
{
    class Program
    {
        static void Main(string[] args)
        {
            var serialPort = new SerialPort("COM1", 9600, Parity.Even, 8, StopBits.One);
            serialPort.Open();
            string message = "";
            while (message != "quit")
            {
                message = serialPort.ReadLine();
                serialPort.WriteLine(message);
            }
            serialPort.Close();
        }
    }
}

अतुल्यकालिक संदेश रिसीवर

using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Text;
using System.Threading;

namespace AsyncReceiver
{
    class Program
    {
        const byte STX = 0x02;
        const byte ETX = 0x03;
        const byte ACK = 0x06;
        const byte NAK = 0x15;
        static ManualResetEvent terminateService = new ManualResetEvent(false);
        static readonly object eventLock = new object();
        static List<byte> unprocessedBuffer = null;

        static void Main(string[] args)
        {
            try
            {
                var serialPort = new SerialPort("COM11", 9600, Parity.Even, 8, StopBits.One);
                serialPort.DataReceived += DataReceivedHandler;
                serialPort.ErrorReceived += ErrorReceivedHandler;
                serialPort.Open();
                terminateService.WaitOne();
                serialPort.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine("Exception occurred: {0}", e.Message);
            }
            Console.ReadKey();
        }

        static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            lock (eventLock)
            {
                byte[] buffer = new byte[4096];
                switch (e.EventType)
                {
                    case SerialData.Chars:
                        var port = (SerialPort)sender;
                        int bytesToRead = port.BytesToRead;
                        if (bytesToRead > buffer.Length)
                            Array.Resize(ref buffer, bytesToRead);
                        int bytesRead = port.Read(buffer, 0, bytesToRead);
                        ProcessBuffer(buffer, bytesRead);
                        break;
                    case SerialData.Eof:
                        terminateService.Set();
                        break;
                }
            }
        }
        static void ErrorReceivedHandler(object sender, SerialErrorReceivedEventArgs e)
        {
            lock (eventLock)
                if (e.EventType == SerialError.TXFull)
                {
                    Console.WriteLine("Error: TXFull. Can't handle this!");
                    terminateService.Set();
                }
                else
                {
                    Console.WriteLine("Error: {0}. Resetting everything", e.EventType);
                    var port = (SerialPort)sender;
                    port.DiscardInBuffer();
                    port.DiscardOutBuffer();
                    unprocessedBuffer = null;
                    port.Write(new byte[] { NAK }, 0, 1);
                }
        }

        static void ProcessBuffer(byte[] buffer, int length)
        {
            List<byte> message = unprocessedBuffer;
            for (int i = 0; i < length; i++)
                if (buffer[i] == ETX)
                {
                    if (message != null)
                    {
                        Console.WriteLine("MessageReceived: {0}", 
                            Encoding.ASCII.GetString(message.ToArray()));
                        message = null;
                    }
                }
                else if (buffer[i] == STX)
                    message = null;
                else if (message != null)
                    message.Add(buffer[i]);
            unprocessedBuffer = message;
        }
    }
}

यह कार्यक्रम STX और ETX बाइट्स में संलग्न संदेशों की प्रतीक्षा करता है और उनके बीच आने वाले पाठ को आउटपुट करता है। बाकी सब त्याग है। बफर ओवरफ्लो लिखने पर यह रुक जाता है। अन्य त्रुटियों पर यह इनपुट और आउटपुट बफ़र्स को रीसेट करता है और आगे के संदेशों की प्रतीक्षा करता है।

कोड दिखाता है:

• एसिंक्रोनस सीरियल पोर्ट रीडिंग (देखें SerialPort.DataReceived उपयोग)।
• सीरियल पोर्ट त्रुटि प्रसंस्करण (देखें SerialPort.ErrorReceived उपयोग)।
• गैर-पाठ संदेश-आधारित प्रोटोकॉल कार्यान्वयन।
• आंशिक संदेश पढ़ना।
  • SerialPort.DataReceived घटना संपूर्ण संदेश ( ETX ) की तुलना में पहले हो सकती है। संपूर्ण संदेश इनपुट बफ़र में भी उपलब्ध नहीं हो सकता है (SerialPort.Read (..., ..., port.BytesToRead) केवल संदेश का एक भाग पढ़ता है)। इस मामले में हम प्राप्त भाग ( unprocessedBuffer ) को unprocessedBuffer और आगे के डेटा की प्रतीक्षा करते हैं।
• एक बार में आने वाले कई संदेशों से निपटना।
  • SerialPort.DataReceived घटना दूसरे छोर से कई संदेश भेजे जाने के बाद ही हो सकती है।