How to Read and Write from the Serial Port

C#Serial Port

C# Problem Overview

I just started learning how to send and receive data from my hardware through the C# GUI.

Can anyone please write a detail how to read data from the serial port?

C# Solutions

Solution 1 - C#

SerialPort (RS-232 Serial COM Port) in C# .NET
This article explains how to use the SerialPort class in .NET to read and write data, determine what serial ports are available on your machine, and how to send files. It even covers the pin assignments on the port itself.

Example Code:

using System;
using System.IO.Ports;
using System.Windows.Forms;

namespace SerialPortExample
  class SerialPortProgram
    // Create the serial port with basic settings
    private SerialPort port = new SerialPort("COM1",
      9600, Parity.None, 8, StopBits.One);

    static void Main(string[] args)
      // Instatiate this class
      new SerialPortProgram();

    private SerialPortProgram()
      Console.WriteLine("Incoming Data:");

      // Attach a method to be called when there
      // is data waiting in the port's buffer
      port.DataReceived += new 

      // Begin communications
      // Enter an application loop to keep this thread alive

    private void port_DataReceived(object sender,
      SerialDataReceivedEventArgs e)
      // Show all the incoming data in the port's buffer

Solution 2 - C#

I spent a lot of time to use SerialPort class and has concluded to use SerialPort.BaseStream class instead. You can see source code: SerialPort-source and SerialPort.BaseStream-source for deep understanding. I created and use code that shown below.

  • The core function public int Recv(byte[] buffer, int maxLen) has name and works like "well known" socket's recv().

  • It means that

  • in one hand it has timeout for no any data and throws TimeoutException.

  • In other hand, when any data has received,

    • it receives data either until maxLen bytes
    • or short timeout (theoretical 6 ms) in UART data flow


public class Uart : SerialPort
        private int _receiveTimeout;

        public int ReceiveTimeout { get => _receiveTimeout; set => _receiveTimeout = value; }

        static private string ComPortName = "";

        /// <summary>
        /// It builds PortName using ComPortNum parameter and opens SerialPort.
        /// </summary>
        /// <param name="ComPortNum"></param>
        public Uart(int ComPortNum) : base()
            base.BaudRate = 115200; // default value           
            _receiveTimeout = 2000;
            ComPortName = "COM" + ComPortNum;

                base.PortName = ComPortName;
            catch (UnauthorizedAccessException ex)
                Console.WriteLine("Error: Port {0} is in use", ComPortName);
            catch (Exception ex)
                Console.WriteLine("Uart exception: " + ex);
        } //Uart()
        /// <summary>
        /// Private property returning positive only Environment.TickCount
        /// </summary>
        private int _tickCount { get => Environment.TickCount & Int32.MaxValue; }

        /// <summary>
        /// It uses SerialPort.BaseStream rather SerialPort functionality .
        ///	It Receives up to maxLen number bytes of data, 
        /// Or throws TimeoutException if no any data arrived during ReceiveTimeout. 
        /// It works likes socket-recv routine (explanation in body).
        /// Returns:
        ///    totalReceived - bytes, 
        ///    TimeoutException,
        ///    -1 in non-ComPortNum Exception  
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="maxLen"></param>
        /// <returns></returns>
        public int Recv(byte[] buffer, int maxLen)
            /// The routine works in "pseudo-blocking" mode. It cycles up to first 
			/// data received using BaseStream.ReadTimeout = TimeOutSpan (2 ms).
            /// If no any message received during ReceiveTimeout property, 
            /// the routine throws TimeoutException 
            /// In other hand, if any data has received, first no-data cycle
			///	causes to exit from routine.

            int TimeOutSpan = 2;
            // counts delay in TimeOutSpan-s after end of data to break receive
            int EndOfDataCnt;
            // pseudo-blocking timeout counter
            int TimeOutCnt = _tickCount + _receiveTimeout; 
            //number of currently received data bytes
            int justReceived = 0;
            //number of total received data bytes
            int totalReceived = 0;

            BaseStream.ReadTimeout = TimeOutSpan;
            //causes (2+1)*TimeOutSpan delay after end of data in UART stream
            EndOfDataCnt = 2;
            while (_tickCount < TimeOutCnt && EndOfDataCnt > 0)
                    justReceived = 0; 
                    justReceived = base.BaseStream.Read(buffer, totalReceived, maxLen - totalReceived);
                    totalReceived += justReceived;

                    if (totalReceived >= maxLen)
                catch (TimeoutException)
                    if (totalReceived > 0) 
                catch (Exception ex)
                    totalReceived = -1;
                    Console.WriteLine("Recv exception: " + ex);

            } //while
            if (totalReceived == 0)
                throw new TimeoutException();
                return totalReceived;
        } // Recv()            
    } // Uart

Solution 3 - C#

Note that usage of a SerialPort.DataReceived event is optional. You can set proper timeout using SerialPort.ReadTimeout and continuously call SerialPort.Read() after you wrote something to a port until you get a full response.

Moreover you can use SerialPort.BaseStream property to extract an underlying Stream instance. The benefit of using a Stream is that you can easily utilize various decorators with it:

var port = new SerialPort();
// LoggingStream inherits Stream, implements IDisposable, needen abstract methods and 
// overrides needen virtual methods. 
Stream portStream = new LoggingStream(port.BaseStream);
portStream.Write(...); // Logs write buffer.
portStream.Read(...); // Logs read buffer.

For more information check:


All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionCHIENSIONView Question on Stackoverflow
Solution 1 - C#Robert HarveyView Answer on Stackoverflow
Solution 2 - C#YakovView Answer on Stackoverflow
Solution 3 - C#Leonid VasilevView Answer on Stackoverflow