|
6:26 AM
1 Comments »
0 Comments »
We were then introduced to .Net 1.1, VB programmers loved the fact that Visual Basic had finally evolved to an OO language. It was soon discovered that, with all it's OO abilities, the ability to communicate via a serial port wasn't available, so once again VB developers were forced to rely on the MSComm Control from previous versions of Visual Basic, still not that big of a deal, but some were upset that an intrinsic way of serial port communication wasn't offered with the .net Framework. Worse yet, C# developers had to rely on a Visual Basic control and Namespace if they wanted to communicate via serial port.
Then along comes .Net 2.0, and this time Microsoft added the System.IO.Ports Namespace, and within that was the SerialPort Class. DotNet developers finally had an intrinsic way of serial port communication, without having to deal with the complexities of interoping with an old legacy ActiveX OCX control. One of the most useful methods in the SerialPort class is the GetPortNames Method. This allows you to retrieve a list of available ports (COM1,COM2,etc.) available for the computer the application is running on.
Now that we have that out of the way, lets move on to programming our application. As with all application I create, I keep functionality separated from presentation, I do this by creating Manager classes that manage the functionality for a given process. What we will be looking at is the code in my CommunicationManagerclass. As with anything you write in .Net you need to add the references to the Namespace's you'll be using:
In this application I wanted to give the user the option of what format they wanted to send the message in, either string or binary, so we have an enumeration for that, and an enumerations for the type of message i.e; Incoming, Outgoing, Error, etc. The main purpose of this enumeration is for changing the color of the text displayed to the user according to message type. Here are the enumerations:
Next we have our variable list, 6 of them are for populating our class Properties, the other 2 are access throughout the class so they needed to be made global:
NOTE:I always separate my code into sections using the #region ... #endregion to make it easier when scanning my code. It is a design choice so it's not necessary if you don't want to do it.
Now we need to create our class properties. All the properties in this class are public read/write properties. We have properties for the following items of the Serial Port:
To be able to instantiate any class object we create we need Constructors. Constructors are the entry point to your class, and is the first code executed when instantiating a class object. We have 2 constructors for our manager class, one that sets our properties to a specified value, and one that sets our properties to an empty value, thus initializing the variables preventing a NullReferenceException from occurring. We also add an EventHandler in the constructor, the event will be executed whenever there's data waiting in the buffer:
The first think you need to know about serial port communication is writing data to the port. The first thing we do in our WriteData method is to check what transmission mode the user has selected, since binary data needs to be converted into binary, then back to string for displaying to the user. Next we need to make sure the port is open, for this we use the IsOpen Property of the SerialPort Class. If the port isn't open we open it by calling the Open Method of the SerialPort Class. For writing to the port we use the Write Method:
You will notice in this method we call three methods:
Here we convert the provided string to a byte array, then the WriteData method sends it out the port. For displaying we need to convert it back into string format, so we use the ByteToHex method we created:
The last method that WriteData depends on is the DisplayData method. Here we use the Invoke Method of our RichTextBox, the control used to display the data, to create a new EventHandler which creates a new Delegate for setting the properties we wish for our message, then appending it to the value already displayed:
NOTE: You will notice that we hyave added the STAThread Attribute to our method. This is used when a single thread apartment is required by a control, like the RichTextBox.
The next method we will look at it used when we need to open the port initially. Here we set the BaudRate, Parity, StopBits, DataBits and PortName Properties of the SerialPort Class:
Next lets take a look at our event handler. This event will be executed whenever there's data waiting in the buffer. This method looks identical to our WriteDatamethod, because it has to do the same exact work:
We have 3 small methods left, and these are actually optional, for the lack of a better word. These methods are used to populate my ComboBox's on my UI with the port names available on the computer, Parity values and Stop Bit values. The Parity and Stop Bits are available in enumerations included with the .Net Framework 2.0:
That is how you do Serial Port Communication in C#. Microsoft finally gave us intrinsic tools to perform this task, no more relying on legacy objects. I am providing this class and a sample application to show how to implement what we just learned. What I am providing is under the GNU General Public License meaning you can modify and distribute how you see fit, but the license header must stay in tact. I hope you found this tutorial useful and informative, thank you for reading.
Then along comes .Net 2.0, and this time Microsoft added the System.IO.Ports Namespace, and within that was the SerialPort Class. DotNet developers finally had an intrinsic way of serial port communication, without having to deal with the complexities of interoping with an old legacy ActiveX OCX control. One of the most useful methods in the SerialPort class is the GetPortNames Method. This allows you to retrieve a list of available ports (COM1,COM2,etc.) available for the computer the application is running on.
Now that we have that out of the way, lets move on to programming our application. As with all application I create, I keep functionality separated from presentation, I do this by creating Manager classes that manage the functionality for a given process. What we will be looking at is the code in my CommunicationManagerclass. As with anything you write in .Net you need to add the references to the Namespace's you'll be using:
using System; using System.Text; using System.Drawing; using System.IO.Ports;
In this application I wanted to give the user the option of what format they wanted to send the message in, either string or binary, so we have an enumeration for that, and an enumerations for the type of message i.e; Incoming, Outgoing, Error, etc. The main purpose of this enumeration is for changing the color of the text displayed to the user according to message type. Here are the enumerations:
#region Manager Enums ////// enumeration to hold our transmission types /// public enum TransmissionType { Text, Hex } /// /// enumeration to hold our message types /// public enum MessageType { Incoming, Outgoing, Normal, Warning, Error }; #endregion
Next we have our variable list, 6 of them are for populating our class Properties, the other 2 are access throughout the class so they needed to be made global:
#region Manager Variables //property variables private string _baudRate = string.Empty; private string _parity = string.Empty; private string _stopBits = string.Empty; private string _dataBits = string.Empty; private string _portName = string.Empty; private TransmissionType _transType; private RichTextBox _displayWindow; //global manager variables private Color[] MessageColor = { Color.Blue, Color.Green, Color.Black, Color.Orange, Color.Red }; private SerialPort comPort = new SerialPort(); #endregion
NOTE:I always separate my code into sections using the #region ... #endregion to make it easier when scanning my code. It is a design choice so it's not necessary if you don't want to do it.
Now we need to create our class properties. All the properties in this class are public read/write properties. We have properties for the following items of the Serial Port:
- Baud Rate: A measure of the speed of serial communication, roughly equivalent to bits per second.
- Parity: The even or odd quality of the number of 1's or 0's in a binary code, often used to determine the integrity of data especially after transmission.
- Stop Bits: A bit that signals the end of a transmission unit
- Data Bits: The number of bits used to represent one character of data.
- Port Name: The port with which we're communicating through, i.e; COM1, COM2, etc.
#region Manager Properties ////// Property to hold the BaudRate /// of our manager class /// public string BaudRate { get { return _baudRate; } set { _baudRate = value; } } /// /// property to hold the Parity /// of our manager class /// public string Parity { get { return _parity; } set { _parity = value; } } /// /// property to hold the StopBits /// of our manager class /// public string StopBits { get { return _stopBits; } set { _stopBits = value; } } /// /// property to hold the DataBits /// of our manager class /// public string DataBits { get { return _dataBits; } set { _dataBits = value; } } /// /// property to hold the PortName /// of our manager class /// public string PortName { get { return _portName; } set { _portName = value; } } /// /// property to hold our TransmissionType /// of our manager class /// public TransmissionType CurrentTransmissionType { get{ return _transType;} set{ _transType = value;} } /// /// property to hold our display window /// value /// public RichTextBox DisplayWindow { get { return _displayWindow; } set { _displayWindow = value; } } #endregion
To be able to instantiate any class object we create we need Constructors. Constructors are the entry point to your class, and is the first code executed when instantiating a class object. We have 2 constructors for our manager class, one that sets our properties to a specified value, and one that sets our properties to an empty value, thus initializing the variables preventing a NullReferenceException from occurring. We also add an EventHandler in the constructor, the event will be executed whenever there's data waiting in the buffer:
#region Manager Constructors ////// Constructor to set the properties of our Manager Class /// /// Desired BaudRate /// Desired Parity /// Desired StopBits /// Desired DataBits /// Desired PortName public CommunicationManager(string baud, string par, string sBits, string dBits, string name, RichTextBox rtb) { _baudRate = baud; _parity = par; _stopBits = sBits; _dataBits = dBits; _portName = name; _displayWindow = rtb; //now add an event handler comPort.DataReceived += new SerialDataReceivedEventHandler(comPort_DataReceived); } /// /// Comstructor to set the properties of our /// serial port communicator to nothing /// public CommunicationManager() { _baudRate = string.Empty; _parity = string.Empty; _stopBits = string.Empty; _dataBits = string.Empty; _portName = "COM1"; _displayWindow = null; //add event handler comPort.DataReceived+=new SerialDataReceivedEventHandler(comPort_DataReceived); } #endregion
The first think you need to know about serial port communication is writing data to the port. The first thing we do in our WriteData method is to check what transmission mode the user has selected, since binary data needs to be converted into binary, then back to string for displaying to the user. Next we need to make sure the port is open, for this we use the IsOpen Property of the SerialPort Class. If the port isn't open we open it by calling the Open Method of the SerialPort Class. For writing to the port we use the Write Method:
#region WriteData public void WriteData(string msg) { switch (CurrentTransmissionType) { case TransmissionType.Text: //first make sure the port is open //if its not open then open it if (!(comPort.IsOpen == true)) comPort.Open(); //send the message to the port comPort.Write(msg); //display the message DisplayData(MessageType.Outgoing, msg + "\n"); break; case TransmissionType.Hex: try { //convert the message to byte array byte[] newMsg = HexToByte(msg); //send the message to the port comPort.Write(newMsg,0,newMsg.Length); //convert back to hex and display DisplayData(MessageType.Outgoing, ByteToHex(newMsg) + "\n"); } catch (FormatException ex) { //display error message DisplayData(MessageType.Error, ex.Message); } finally { _displaywindow.SelectAll(); } break; default: //first make sure the port is open //if its not open then open it if (!(comPort.IsOpen == true)) comPort.Open(); //send the message to the port comPort.Write(msg); //display the message DisplayData(MessageType.Outgoing, msg + "\n"); break; break; } } #endregion
You will notice in this method we call three methods:
- HexToByte
- ByteToHex
- DisplayData
#region HexToByte ////// method to convert hex string into a byte array /// /// string to convert /// a byte array private byte[] HexToByte(string msg) { //remove any spaces from the string msg = msg.Replace(" ", ""); //create a byte array the length of the //string divided by 2 byte[] comBuffer = new byte[msg.Length / 2]; //loop through the length of the provided string for (int i = 0; i < msg.Length; i += 2) //convert each set of 2 characters to a byte //and add to the array comBuffer[i / 2] = (byte)Convert.ToByte(msg.Substring(i, 2), 16); //return the array return comBuffer; } #endregion
Here we convert the provided string to a byte array, then the WriteData method sends it out the port. For displaying we need to convert it back into string format, so we use the ByteToHex method we created:
#region ByteToHex ////// method to convert a byte array into a hex string /// /// byte array to convert /// a hex string private string ByteToHex(byte[] comByte) { //create a new StringBuilder object StringBuilder builder = new StringBuilder(comByte.Length * 3); //loop through each byte in the array foreach (byte data in comByte) //convert the byte to a string and add to the stringbuilder builder.Append(Convert.ToString(data, 16).PadLeft(2, '0').PadRight(3, ' ')); //return the converted value return builder.ToString().ToUpper(); } #endregion
The last method that WriteData depends on is the DisplayData method. Here we use the Invoke Method of our RichTextBox, the control used to display the data, to create a new EventHandler which creates a new Delegate for setting the properties we wish for our message, then appending it to the value already displayed:
#region DisplayData ////// method to display the data to & from the port /// on the screen /// /// MessageType of the message /// Message to display [STAThread] private void DisplayData(MessageType type, string msg) { _displaywindow.Invoke(new EventHandler(delegate { _displaywindow.SelectedText = string.Empty; _displaywindow.SelectionFont = new Font(_displaywindow.SelectionFont, FontStyle.Bold); _displaywindow.SelectionColor = MessageColor[(int)type]; _displaywindow.AppendText(msg); _displaywindow.ScrollToCaret(); })); } #endregion
NOTE: You will notice that we hyave added the STAThread Attribute to our method. This is used when a single thread apartment is required by a control, like the RichTextBox.
The next method we will look at it used when we need to open the port initially. Here we set the BaudRate, Parity, StopBits, DataBits and PortName Properties of the SerialPort Class:
#region OpenPort public bool OpenPort() { try { //first check if the port is already open //if its open then close it if (comPort.IsOpen == true) comPort.Close(); //set the properties of our SerialPort Object comPort.BaudRate = int.Parse(_baudRate); //BaudRate comPort.DataBits = int.Parse(_dataBits); //DataBits comPort.StopBits = (StopBits)Enum.Parse(typeof(StopBits),_stopBits); //StopBits comPort.Parity = (Parity)Enum.Parse(typeof(Parity),_parity); //Parity comPort.PortName = _portName; //PortName //now open the port comPort.Open(); //display message DisplayData(MessageType.Normal, "Port opened at " + DateTime.Now + "\n"); //return true return true; } catch (Exception ex) { DisplayData(MessageType.Error, ex.Message); return false; } } #endregion
Next lets take a look at our event handler. This event will be executed whenever there's data waiting in the buffer. This method looks identical to our WriteDatamethod, because it has to do the same exact work:
#region comPort_DataReceived ////// method that will be called when theres data waiting in the buffer /// /// /// void comPort_DataReceived(object sender, SerialDataReceivedEventArgs e) { //determine the mode the user selected (binary/string) switch (CurrentTransmissionType) { //user chose string case TransmissionType.Text: //read data waiting in the buffer string msg = comPort.ReadExisting(); //display the data to the user DisplayData(MessageType.Incoming, msg + "\n"); break; //user chose binary case TransmissionType.Hex: //retrieve number of bytes in the buffer int bytes = comPort.BytesToRead; //create a byte array to hold the awaiting data byte[] comBuffer = new byte[bytes]; //read the data and store it comPort.Read(comBuffer, 0, bytes); //display the data to the user DisplayData(MessageType.Incoming, ByteToHex(comBuffer) + "\n"); break; default: //read data waiting in the buffer string str = comPort.ReadExisting(); //display the data to the user DisplayData(MessageType.Incoming, str + "\n"); break; } } #endregion
We have 3 small methods left, and these are actually optional, for the lack of a better word. These methods are used to populate my ComboBox's on my UI with the port names available on the computer, Parity values and Stop Bit values. The Parity and Stop Bits are available in enumerations included with the .Net Framework 2.0:
#region SetParityValues public void SetParityValues(object obj) { foreach (string str in Enum.GetNames(typeof(Parity))) { ((ComboBox)obj).Items.Add(str); } } #endregion #region SetStopBitValues public void SetStopBitValues(object obj) { foreach (string str in Enum.GetNames(typeof(StopBits))) { ((ComboBox)obj).Items.Add(str); } } #endregion #region SetPortNameValues public void SetPortNameValues(object obj) { foreach (string str in SerialPort.GetPortNames()) { ((ComboBox)obj).Items.Add(str); } } #endregion
That is how you do Serial Port Communication in C#. Microsoft finally gave us intrinsic tools to perform this task, no more relying on legacy objects. I am providing this class and a sample application to show how to implement what we just learned. What I am providing is under the GNU General Public License meaning you can modify and distribute how you see fit, but the license header must stay in tact. I hope you found this tutorial useful and informative, thank you for reading.
3:59 AM
