Improving the Performance of Serial Ports Using C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace LocalTimeReader
{
    class LocalTimeReaderPort: ConnectedSerialPort
    {
        public enum PortStatus
        {
            NotConnected,
            ConnectionEstablished,
            ConnectionIdle,
            CheckConnected
        }

        private bool newMessage;
        private Message receivedMessage;
        private PortStatus status;
        private MainForm parent;
        private System.Threading.Timer acknowledgeTimer = null;

        public LocalTimeReaderPort(MainForm prt)
        {
            parent = prt;
            newMessage = true;
            status = PortStatus.NotConnected;
            acknowledgeTimer = new System.Threading.Timer(new TimerCallback(acknowledgeTimer_Elapsed), null, 1000, 1000);
        }

        public override bool OpenPort(string port)
        {
            bool open = base.OpenPort(port);

            if (!this.CtsHolding)
            {
                this.Close();
                return false;
            }

            return open;
        }

        protected override void ConnectedSerialPort_PinChanged(object sender, System.IO.Ports.SerialPinChangedEventArgs e)
        {
            base.ConnectedSerialPort_PinChanged(sender, e);

            if (!this.IsOpen)
                return;

            if (this.CtsHolding)
                return;

            MessageBox.Show("Communication with all devices has been lost.\n  Check cables and restart all devices.",
                "Communication Closed", MessageBoxButtons.OK, MessageBoxIcon.Information);

            try
            {
                this.DiscardOutBuffer();
                this.ClosePort();
            }
            catch
            {
            }
        }

        private void acknowledgeTimer_Elapsed(object sender)
        {
            if (status == PortStatus.ConnectionEstablished)
                status = PortStatus.ConnectionIdle;
            else if (status == PortStatus.ConnectionIdle || status == PortStatus.NotConnected)
            {
                if (status == PortStatus.ConnectionIdle)
                    status = PortStatus.CheckConnected;
                SendAcknowledge();
            }
            else if (status == PortStatus.CheckConnected)
            {
                acknowledgeTimer.Change(Timeout.Infinite, Timeout.Infinite);
                MessageBox.Show("Communication lost - Timeout on acknowledge request",
                    "Communication Closed", MessageBoxButtons.OK, MessageBoxIcon.Information);
                try
                {
                    this.DiscardOutBuffer();
                    this.ClosePort();
                }
                catch
                {
                }
            }
        }

        private void ReceivedMessage(Message receivedMessage)
        {
            if (receivedMessage.Code == 0x03)
                status = PortStatus.ConnectionEstablished;

            if (receivedMessage.Code == 0x01)
                parent.ReceivedAcknowledgeRequest();

            if (status == PortStatus.NotConnected)
                return;
 
            if (receivedMessage.Code == 0x05)
                parent.ReceivedTime(receivedMessage.Index, receivedMessage.LocalTime, receivedMessage.RemoteTime);
        }

        protected override void ProcessDataReceived(object sender, EventArgs e)
        {
            int totalBytes = this.BytesToRead;
            if (totalBytes == 0)
                return;

            int byteCount = 0;
            while (byteCount < totalBytes)
            {
                if (newMessage)
                {
                    if (status != PortStatus.NotConnected)
                        status = PortStatus.ConnectionEstablished;

                    receivedMessage = new Message((byte)this.ReadByte());

                    if (receivedMessage.Status == Message.MessageStatus.InProgress)
                        newMessage = false;
                    else
                        ReceivedMessage(receivedMessage);
                }
                else
                {
                    receivedMessage.Add((byte)this.ReadByte());
                    if (receivedMessage.Status != Message.MessageStatus.InProgress)
                    {
                        newMessage = true;
                        ReceivedMessage(receivedMessage);
                    }

                }
                byteCount++;
            }

        }

        public void SendAcknowledge()
        {
            byte[] dataBytes = new byte[1];
            dataBytes[0] = 0x02;
            SendMessage(dataBytes);
        }

        public void SendTimeRequest(byte index, long time)
        {
            byte[] dataBytes = new byte[10];
            dataBytes[0] = 0x04;
            dataBytes[1] = index;
            (BitConverter.GetBytes(time)).CopyTo(dataBytes, 2);

            SendMessage(dataBytes);
        }
        
        private void SendMessage(byte[] data)
        {
            try
            {
                this.Write(data, 0, data.Length);
            }
            catch
            {
                MessageBox.Show("Failed To Send Message", "Timeout", MessageBoxButtons.OK,
                    MessageBoxIcon.Warning);
            }
        }

        public void ClosePort()
        {
             if (this.IsOpen)
                this.DiscardOutBuffer();
            if (this.IsOpen)
                this.Close();
            parent.PortClosing();
        }
    }
}