C:/Documents and Settings/student/My Documents/robo_magellan/visual_studio_(system_controller)/RS232Port/RS232Port/RS232MainForm.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.IO.Ports;
using System.Threading; 

namespace RS232Port {
    public partial class RS232MainForm : Form {
        //this form creates a toolset to use with the windows serial port.
        //it provides a public serial port for external configuration
        //and bool to hex to dec formatting utilities for sending data

        string[] _portNames;
        string _serialData;
                byte[] _serialBytes;

                public byte[] SerialBytes {
                        get { return _serialBytes; }
                        set { _serialBytes = value; }
                }
        private bool[] _ctsDsrStates = new bool[2]; //could also add discrete cts dsr(s)
        //declare a serial port delegate to handle its events
        public delegate void receiveDataEventHandler();
        public delegate void pinChangedEventHandler();
                public delegate void updateStatusEventHandler();
                public delegate void updateErrorEventHandler(Exception error);
                public event updateErrorEventHandler updateErrorEvent;
        //create a public serial port receive data event and a 
        //cts dsr pin changed event for external calsses to register 
        //methods with, when events are triggered they will call the external methods
        //(method group conversion)
        public event receiveDataEventHandler receiveDataEvent;
        public event pinChangedEventHandler ctsChangedEvent;
        public event pinChangedEventHandler dsrChangedEvent;
                public event updateStatusEventHandler setSilentModeEvent;
        //create threads to handle recieving data and pin state changes
        Thread receiveDataThread;
        Thread ctsStateChangedThread;
        Thread dsrStateChangedThread;

        public enum debugTerminalMode {
            silent,
            quiet,
            verbose,
        };

                bool _silent = true;
                public bool Silent {
                        get { return _silent; }
                        set {
                                _silent = value;
                                if (_silent) {
                                        receiveDataEvent -= onReceiveData;
                                        ctsChangedEvent -= onCtsChanged;
                                        dsrChangedEvent -= onDsrChanged;
                                } else {
                                        receiveDataEvent += onReceiveData;
                                        ctsChangedEvent += onCtsChanged;
                                        dsrChangedEvent += onDsrChanged;
                                }
                                if (setSilentModeEvent != null)
                                        setSilentModeEvent.Invoke();
                        }
                }

        private debugTerminalMode _debugMode;

        public debugTerminalMode DebugMode {
            set {
                _debugMode = value;
            }
            get {
                return _debugMode;
            }
        }

                string _status;
        public string Status {
            get {return _status;}
        }

        public SerialPort Port {
            get {
                return _port;
            }
        }

        public string[] PortNames {
            get {
                return _portNames;
            }
        }

        public string SerialData {
            get {
                return _serialData;
            }
        }

        bool _ctsState = false;
        public bool CtsState {
            get {return _ctsState;}
        }

        bool _dsrState = false;
        public bool DsrState {
            get {return _dsrState;}
        }

        int _recieveDelayMs = 0;
        public int RecieveDelayMs {
            get { return _recieveDelayMs; }
            set { _recieveDelayMs = value; }
        }

        public RS232MainForm() {
            InitializeComponent();
            comPortSelectionComboBox.Items.AddRange(SerialPort.GetPortNames());
            _portNames = new string[comPortSelectionComboBox.Items.Count];
            _portNames = SerialPort.GetPortNames();
            updateStatusMessage("Open a serial port from the drop down menu.");
            _debugMode = debugTerminalMode.silent;
                        //_serialBytes = new byte[2457600];
        }

        private void comPortSelectionComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            _port.PortName = comPortSelectionComboBox.SelectedItem.ToString();
            openPortButton.Enabled = true;
            openPortButton.Text = "Open Port";
            updateButtons();
        }

        public void setPortName(string name) {
            //add error handling
            _port.PortName = name;
        }

        private void openPortButton_Click(object sender, EventArgs e) {
            if (!_port.IsOpen) {
                openPortButton.BackColor = Color.Lime;
                openPortButton.Text = "Close Port";
                                updateStatusMessage(initializeComPort());
            } else {
                openPortButton.BackColor = SystemColors.Control;
                openPortButton.Text = "Open Port";
                updateStatusMessage(closePort());
            }
            updateButtons();
        }

                public string initializeComPort() {
                        string returnMessage = "";
                        try {
                                openPort();
                                returnMessage = "opened " + _port.PortName;
                        } catch (System.UnauthorizedAccessException e) {
                                if (updateErrorEvent != null)
                                        updateErrorEvent.Invoke(e);
                                returnMessage = "opening " + _port.PortName
                                        + " failed, unauthorized access!";
                        } catch (System.InvalidOperationException e) {
                                if (updateErrorEvent != null)
                                        updateErrorEvent.Invoke(e);
                                returnMessage = _port.PortName
                                        + " is allready open, invalid operation!";
                        } catch (System.IO.IOException e) {
                                if (updateErrorEvent != null)
                                        updateErrorEvent.Invoke(e);
                                returnMessage = _port.PortName
                                        + " does not exist!";
                        }
                        return returnMessage;
                }

        private void openPort() {
            if (!_port.IsOpen) {
                _port.Open();
                updatePortSettings();
                toggleControlls();
            }
        }

        public string closePort() {
                        string returnMessage = "";
            if (_port.IsOpen) {
                                _port.DiscardOutBuffer();
                                _port.DiscardInBuffer();
                _port.Close();
                                toggleControlls();
                                returnMessage = "closed " + _port.PortName;
                        } else returnMessage = _port.PortName + " is allready closed";
                        return returnMessage;
        }

                private void toggleControlls() {
                        comPortSelectionComboBox.Enabled = !_port.IsOpen;
                        bitsPerSecondComboBox.Enabled = !_port.IsOpen;
                        dataBitsComboBox.Enabled = !_port.IsOpen;
                        parityComboBox.Enabled = !_port.IsOpen;
                        stopBitsComboBox.Enabled = !_port.IsOpen;
                        flowControlComboBox.Enabled = !_port.IsOpen;
                }

        private void updateButtons() {
            if (_port.IsOpen) {
                if (_port.CtsHolding)
                    ctsHoldingButton.BackColor = Color.Lime;
                else
                    ctsHoldingButton.BackColor = SystemColors.Control;
                if (_port.DsrHolding)
                    dsrHoldingButton.BackColor = Color.Lime;
                else
                    dsrHoldingButton.BackColor = SystemColors.Control;
            } else {
                ctsHoldingButton.BackColor = SystemColors.Control;
                dsrHoldingButton.BackColor = SystemColors.Control;
            }
            dtrEnableButton.Enabled = _port.IsOpen;
            if (_port.Handshake != Handshake.RequestToSendXOnXOff
                && _port.Handshake != Handshake.RequestToSend)
                rtsEnableButton.Enabled = _port.IsOpen;
        }

        private void dtrEnableButton_Click(object sender, EventArgs e) {
            //toggle dtr, not implemented as method because the serial port is public
            _port.DtrEnable = !_port.DtrEnable;
            updateStatusMessage("DTR Enabled: " + _port.DtrEnable.ToString());
            if (_port.DtrEnable)
                dtrEnableButton.BackColor = Color.Lime;
            else
                dtrEnableButton.BackColor = SystemColors.Control;
        }

        private void rtsEnableButton_Click(object sender, EventArgs e) {
            //toggle rts, not implemented as method because the serial port is public
            _port.RtsEnable = !_port.RtsEnable;
            updateStatusMessage("RTS Enabled: " + _port.RtsEnable.ToString());
            if (_port.RtsEnable)
                rtsEnableButton.BackColor = Color.Lime;
            else
                rtsEnableButton.BackColor = SystemColors.Control;
        }

        private void _port_PinChanged(object sender, SerialPinChangedEventArgs e) {
                        //Thread.CurrentThread.Priority = ThreadPriority.Highest;
            if (_ctsState != _port.CtsHolding) {
                                _ctsState = _port.CtsHolding;
                //execute methods that are registered with handler
                                if (_silent && ctsChangedEvent != null)
                                        ctsChangedEvent.Invoke();
                                else if (ctsChangedEvent != null) {
                                        ctsStateChangedThread = new Thread(new ThreadStart(onCtsChanged));
                                        //ctsStateChangedThread.Priority = ThreadPriority.Highest;
                                        ctsStateChangedThread.Start();
                                }
            }
            if (_dsrState != _port.DsrHolding) {
                                _dsrState = _port.DsrHolding;
                                if (_silent && dsrChangedEvent != null)
                                        dsrChangedEvent.Invoke();
                                else if(dsrChangedEvent != null) {
                                        dsrStateChangedThread = new Thread(new ThreadStart(onDsrChanged));
                                        //dsrStateChangedThread.Priority = ThreadPriority.Highest;
                                        dsrStateChangedThread.Start();
                                }
            }
                        
                        
        }

        //execute when pin states change
                private void onCtsChanged() {
                        if (debugTextBox.InvokeRequired)
                                this.Invoke(ctsChangedEvent);
                        else {  
                                if (DebugMode == debugTerminalMode.verbose)
                                        updateDebugTextBox("CTS changed to: " + _port.CtsHolding.ToString());
                        }
                }

        //execute when pin states change
        private void onDsrChanged() {
                        if (debugTextBox.InvokeRequired)
                this.Invoke(dsrChangedEvent);
            else {
                if (DebugMode == debugTerminalMode.verbose)
                    updateDebugTextBox("DSR changed to: " + _port.DsrHolding.ToString());
            }
        }

                private void _port_DataReceived(object sender, SerialDataReceivedEventArgs e) {
                        //nead to delay here to allow data to accumulate in buffer
                        if (_recieveDelayMs > 0)
                                Thread.Sleep(_recieveDelayMs);
                        if (_port.IsOpen) {
                                try {
                                        _serialBytes = new byte[_port.BytesToRead];
                                        _port.Read(_serialBytes, 0, _port.BytesToRead);
                                        _serialData = System.Text.ASCIIEncoding.ASCII.GetString(_serialBytes);
                                } catch(Exception ex) { //handle it here

                                        _port.DiscardInBuffer();
                                }
                                //start new thread and execute methods registered with handler
                                if (_silent && receiveDataEvent != null)
                                        receiveDataEvent.Invoke();
                                else if (receiveDataEvent != null) {
                                        receiveDataThread = new Thread(new ThreadStart(onReceiveData));
                                        receiveDataThread.Start();
                                }
                        }
                }

        //executed when recieve data event fires
        private void onReceiveData() {
                        if (debugTextBox.InvokeRequired) {
                                        this.Invoke(receiveDataEvent);
                        } else {
                                if (DebugMode != debugTerminalMode.silent) {
                                        rxToolStripStatusLabel.BackColor = Color.Lime;
                                        resetRXImageTimer.Enabled = true;
                                        updateDebugTextBox(_serialData);
                                        if (DebugMode == debugTerminalMode.verbose)
                                                updateDebugTextBox("Received: " + _serialData);
                                }
                        }
        }

        private void silentRadioButton_CheckedChanged(object sender, EventArgs e) {
            foreach (Control c in debugTerminalModeGroupBox.Controls) {
                if (c is RadioButton) {
                    if (((RadioButton)c).Checked) {
                        switch (((RadioButton)c).Text) {
                            case "Silent":
                                _debugMode = debugTerminalMode.silent;
                                                                silentCheckBox.Checked = true;
                                break;
                            case "Quiet":
                                _debugMode = debugTerminalMode.quiet;
                                                                silentCheckBox.Checked = false;
                                break;
                            case "Verbose":
                                _debugMode = debugTerminalMode.verbose;
                                                                silentCheckBox.Checked = false;
                                break;
                            default:
                                break;
                        }
                    }
                }
            }
            updateStatusMessage("Terminal mode set to: " + _debugMode.ToString());
        }

        private void updateDebugTextBox(string message) {
                        if(debugTextBox.Text.Length > 500000)
                                debugTextBox.Clear();
            debugTextBox.AppendText(message);
        }

        public void clearDebugTextBox() {
            debugTextBox.Clear();
            updateStatusMessage("Cleared debug text box");
        }

        public void updateStatusMessage(string update) {
            _status = update;
            toolStripStatusLabel.Text = update;
            if (_debugMode == debugTerminalMode.verbose)
                updateDebugTextBox(update);
        }

        public void updatePortSettings() {
                        for (int i = 0; i < comPortSelectionComboBox.Items.Count; i++) {
                                if (comPortSelectionComboBox.Items[i].ToString() == _port.PortName)
                                        comPortSelectionComboBox.SelectedIndex = i;
                        }
            for (int i = 0; i < bitsPerSecondComboBox.Items.Count; i++) {
                if (bitsPerSecondComboBox.Items[i].ToString() == _port.BaudRate.ToString())
                    bitsPerSecondComboBox.SelectedIndex = i;
            }
            for (int i = 0; i < dataBitsComboBox.Items.Count; i++) {
                if (dataBitsComboBox.Items[i].ToString() == _port.DataBits.ToString())
                    dataBitsComboBox.SelectedIndex = i;
            }
            for (int i = 0; i < parityComboBox.Items.Count; i++) {
                if (parityComboBox.Items[i].ToString() == _port.Parity.ToString())
                    parityComboBox.SelectedIndex = i;
            }
            for (int i = 0; i < stopBitsComboBox.Items.Count; i++) {
                if (stopBitsComboBox.Items[i].ToString() == _port.StopBits.ToString())
                    stopBitsComboBox.SelectedIndex = i;
            }
            for (int i = 0; i < flowControlComboBox.Items.Count; i++) {
                if (flowControlComboBox.Items[i].ToString() == _port.Handshake.ToString())
                    flowControlComboBox.SelectedIndex = i;
            }
        }

        private void bitsPerSecondComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            _port.BaudRate = int.Parse(bitsPerSecondComboBox.SelectedItem.ToString());
        }

        private void dataBitsComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            _port.DataBits = int.Parse(dataBitsComboBox.SelectedItem.ToString());
        }

        private void parityComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            switch (parityComboBox.SelectedItem.ToString()) {
                case "Even":
                    _port.Parity = Parity.Even;
                    break;
                case "Mark":
                    _port.Parity = Parity.Mark;
                    break;
                case "None":
                    _port.Parity = Parity.None;
                    break;
                case "Odd":
                    _port.Parity = Parity.Odd;
                    break;
                case "Space":
                    _port.Parity = Parity.Space;
                    break;
                default:
                    break;
            }
        }

        private void stopBitsComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            switch (stopBitsComboBox.SelectedItem.ToString()) {
                case "One":
                    _port.StopBits = StopBits.One;
                    break;
                case "OnePointFive":
                    _port.StopBits = StopBits.OnePointFive;
                    break;
                case "Two":
                    _port.StopBits = StopBits.Two;
                    break;
                default:
                    break;
            }
        }

        private void flowControlComboBox_SelectedIndexChanged(object sender, EventArgs e) {
            switch (flowControlComboBox.SelectedItem.ToString()) {
                case "None":
                    _port.Handshake = Handshake.None;
                    break;
                case "RequestToSend":
                    _port.Handshake = Handshake.RequestToSend;
                    break;
                case "RequestToSendXOnXOff":
                    _port.Handshake = Handshake.RequestToSendXOnXOff;
                    break;
                case "XOnXOff":
                    _port.Handshake = Handshake.XOnXOff;
                    break;
                default:
                    break;
            }
        }

        private void sendDataButton_Click(object sender, EventArgs e) {
            transmit(clipboardTextBox.Text);
        }

        public void transmit(string data) {
            if (_port.IsOpen) {
                                if (_debugMode != debugTerminalMode.silent) {
                                        txToolStripStatusLabel.BackColor = Color.Lime;
                                        if (_debugMode == debugTerminalMode.verbose)
                                                updateDebugTextBox("Sent: " + data);
                                        resetTXImageTimer.Enabled = true;
                                }
                                _port.Write(data); 
            }
        }

        private void resetTXImageTimer_Tick(object sender, EventArgs e) {
            txToolStripStatusLabel.BackColor = Color.Red;
            resetTXImageTimer.Enabled = false;
        }

        private void resetRXImageTimer_Tick(object sender, EventArgs e) {
            rxToolStripStatusLabel.BackColor = Color.Red;
            resetRXImageTimer.Enabled = false;
        }

        private void clearDebugTerminalButton_Click(object sender, EventArgs e) {
            debugTextBox.Clear();
        }

                private void clipboardTextBox_KeyUp(object sender, KeyEventArgs e) {
                        if(e.KeyCode == Keys.Enter)
                                transmit(clipboardTextBox.Text);
                }

                private void exitToolStripMenuItem_Click(object sender, EventArgs e) {
                        exitGracefully();
                }

                public void exitGracefully() {
                        if (_port.IsOpen) {
                                _port.DiscardOutBuffer();
                                _port.DiscardInBuffer();
                                _port.Close();
                        }
                        Thread.Sleep(500);
                        this.Dispose();
                }

                private void RS232MainForm_FormClosing(object sender, FormClosingEventArgs e) {
                        exitGracefully();
                }

                private void hideToolStripMenuItem_Click(object sender, EventArgs e) {
                        this.Hide();
                }

                private void silentCheckBox_CheckedChanged(object sender, EventArgs e) {
                        Silent = silentCheckBox.Checked;
                        silentRadioButton.Checked = true;
                }

                private void sendByteButton_Click(object sender, EventArgs e) {
                        short sendInt = 0;
                        short.TryParse(sendByteTextBox.Text, out sendInt);
                        byte sendByte = (byte)sendInt;
                        sendSerialCommand(commandComboBox.SelectedItem.ToString()[0], (byte)sendInt);
                }

                byte[] _byteArray = {0, 58, 0, 59}; //58 is a colon, 59 is a semicolon
                Encoding _enc = Encoding.ASCII; 
                public void sendSerialCommand(char headder, byte command) {
                        _byteArray[0] = (byte)headder;
                        _byteArray[2] = command;        
                        if (_port.IsOpen) {
                                if (_debugMode != debugTerminalMode.silent) {
                                        txToolStripStatusLabel.BackColor = Color.Lime;
                                        if (_debugMode == debugTerminalMode.verbose)
                                                updateDebugTextBox("Sent: " + new string(_enc.GetChars(_byteArray)));
                                        resetTXImageTimer.Enabled = true;
                                }
                                _port.Write(_byteArray, 0, 4);
                        }
                }

    }
}

---