#region Coad's Code : C#

Visual Studio 2005 (Whidbey) Beta2 is Here!

coad — Tue, 19 Apr 2005 01:16:00 GMT

Whidbey Beta2 is Released! We all (you & MS) have been waiting long for this build! Wow, it is a substantial improvement over Beta1 and the client bits even have a Go Live License. I'm excited! How about you?

If you have a MSDN Subscription, you can Get the Beta for the cost of S/H or download Visual Studio 2005 - Team System (aka VSTS). There is a Go-Live License which permits "production deployments of customer applications".

For the free (for now) Express SKUs: C#, VB, VC++, J#, Web Dev, SQL Srv

SerialPort (RS-232 Serial COM Port) in C# .NET

coad — Thu, 24 Mar 2005 02:28:00 GMT

This article is about communicating through the PC's Serial COM RS-232 port using Microsoft .NET 2.0 or later by using the System.IO.Ports.SerialPort class. If you're looking for USB info, see here.

Way in the Past...

Back in my early (pre C# MVP) days, I had written an article on DevHood titled Serial COM Simply in C#. It became quite popular and is (at the time of writing this follow up post) the top Google search for "serial c#". Now every week I get several e-mails with people asking questions and it is high time for some serious updating.

The article was (originally) written soon after .NET was introduced to the world, and other .NET serial port controls had not yet been written. So at the time, this was an easy solution. Just use the MSComm.ocx control from VS6 which most Devs had at the time. Now however, there are many easier and preferred methods than dealing with the complexities of interoping with an old legacy (non-.NET) ActiveX OCX control.

A Bright Future is Here!

Today, the primary solution is to use the new SerialPort control that is part of .NET 2.0 and is freely available in C# Express on MSDN. It is considerably easier to use and is a true .NET component.

Example Application & Sample Code: SerialPort Terminal

For loyal fans of the tutorial, I've written a sample code application, SerialPortTerminal.zip, which you can try out to see how the new SerialPort control is used. Requires Visual Studio 2005 & .NET 2.0 or later to compile & run. If you just want to run the executable, try the latest clickonce deployed version I’ve posted. It is just a simple little application with very basic support for text or binary (hex) modes to send and receive data. A nice feature or two is auto-detection of installed COM ports that update at runtime if you plugin or remove those USB-to-Serial adapters, also you can change the DTR and RTS levels and monitor the CTS, DSR, and CD lines.

Continued Support

Due to the high volume of e-mail I've been receiving on serial port communication in general, I've wrote this post and added an FAQ section to the bottom of the post. Check this first if you have questions. If you post a question as a comment that hasn't been answered in the post, I'll add it to the FAQ section.

For those of you who I've directed to this blog post, please understand that I'm just another guy working away at a full time job (helping manage the release of Team System) who has worked with serial RS-232 ports in the past (moving on to USB now). I like to help people, hence I wrote the original article, this sample code, and the FAQ, but do not have the resources to answer additional serial port communication questions. Please check out the SerialCom FAQ for other .NET COM Port solutions and technical support options.

Get Connected Up

You can obtain USB to Serial adapters and have just about as many ports on your PC as you like. I carry around two adapters with a null modem (what is it?, search Froogle) between them so I can create a loopback to send & receive through to separate ports on most any computer. I'd recommend doing the same for when writing code for the serial port.

If you'd like to quickly and easily create your own external devices to communicate with the PC, I recommend starting with the Parallax BASIC Stamp modules. Parallax has lots of easy accessories (such as LCDs, RF, Sounds, AD & DA, etc) for their modules. After that you could migrate to an Atmel Microcontroller (recommended) or Microchip PIC.

Let's Have the Code

Here is an example of how easy it is to use the new SerialPort control.

Very simply, here is how you can send a bit of data out the port.

// This is a new namespace in .NET 2.0
// that contains the SerialPort class
using System.IO.Ports;

private static void SendSampleData()
{
  // Instantiate the communications
  // port with some basic settings
  SerialPort port = new SerialPort(
    "COM1", 9600, Parity.None, 8, StopBits.One);
  
  // Open the port for communications
  port.Open();
  
  // Write a string
  port.Write("Hello World");
  
  // Write a set of bytes
  port.Write(new byte[] {0x0A, 0xE2, 0xFF}, 0, 3);
  
  // Close the port
  port.Close();
}

Now let's take a look at what it takes to read data in from the communications port. This demonstrates reading text; for an example of reading binary data, see my SerialPortTerminal.zip sample app.

Create a new "Console Application" and replace all the default class code with this code
Add a reference to "System.Windows.Forms" to the project
Run w/ F5, to exit the app, press Ctrl-Break.
Get Connected Up with two USB to Serial adapters and a null modem
Use another app, the code above, or the SerialPortTerminal.zip example to send data and watch it come in with this code

#region Namespace Inclusions
using System;
using System.IO.Ports;
using System.Windows.Forms;
#endregion

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

    [STAThread]
    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 
        SerialDataReceivedEventHandler(port_DataReceived);

      // Begin communications
      port.Open();
      
      // Enter an application loop to keep this thread alive
      Application.Run();
    }

    private void port_DataReceived(object sender,
      SerialDataReceivedEventArgs e)
    {
      // Show all the incoming data in the port's buffer
      Console.WriteLine(port.ReadExisting());
    }
  }
}

One of the (several) new methods that is supported, and one I'm very glad is finally here, is the ability to obtain a list of the COM ports installed on the computer (ex: COM1, COM2, COM4). This is definately helpful when you want to present the list of ports avalible for the user to select from (as in the SerialPortTerminal.zip Win App example).

foreach (string s in SerialPort.GetPortNames())
  System.Diagnostics.Trace.WriteLine(s);

Here are two helpful little methods for sending files through the serial port. Of course, these are the bare essentials and as always, you should check to make sure the port is open first (port.IsOpen) and use try/catch around trying to open a file, but you get the gist with this code. The binary sending routine is limited to about 2GB (the size of an int), but this should be okay for most uses.

using System.IO;

private static void SendTextFile(
  SerialPort port, string FileName)
{ port.Write(File.OpenText(FileName).ReadToEnd()); }

private static void SendBinaryFile(
  SerialPort port, string FileName)
{
  using (FileStream fs = File.OpenRead(FileName))
    port.Write((new BinaryReader(fs)).ReadBytes(
      (int)fs.Length), 0, (int)fs.Length);
}

RS-232 Project Photos

Each of these involve RS-232 serial port communications.

Just what's needed to get started with microcontrollers,
a Basic Stamp, mini LCD display, power, and RS-232 port.

Two USB to Serial adapters with a null modem
to loopback and test your serial software.

The brains to a mini automated radio station that let me
control my PC & home using my HAM radio from around town.

Port Wiring Notes

DB9 Male (Pin Side)                   DB9 Female (Pin Side)
DB9 Female (Solder Side)              DB9 Male (Solder Side)
    -------------                          -------------
    \ 1 2 3 4 5 /                          \ 5 4 3 2 1 /
     \ 6 7 8 9 /                            \ 9 8 7 6 /
      ---------                              ---------

DB9 Female to DB9 Female Null-Modem Wiring
 2 |  3 |  7 |  8 | 6&1|  5 |  4
---- ---- ---- ---- ---- ---- ---- 
 3 |  2 |  8 |  7 |  4 |  5 | 6&1

9-pin   25-pin  Assignment                 From PC
------  ------  -------------------------  ------------
Shield  1       Case Ground                Gnd
1       8       DCD (Data Carrier Detect)  Input
2       3       RX  (Receive Data)         Input
3       2       TX  (Transmit Data)        Output
4       20      DTR (Data Terminal Ready)  Output
5       7       GND (Signal Ground)        Gnd
6       6       DSR (Data Set Ready)       Input
7       4       RTS (Request To Send)      Output
8       5       CTS (Clear To Send)        Input
9       22      RI  (Ring Indicator)       Input

- RTS & DTR are binary outputs that can be manually set and held
- DCD, DSR, CTS, and RI are binary inputs that can be read
- RX & TX can not be set manually and are controlled by the UART
- maximum voltages are between -15 volts and +15 volts
- binary outputs are between +5 to +15 volts and -5 to -15 volts
- binary inputs are between +3 to +15 volts and -3 to -15 volts
- input voltages between -3 to +3 are undefined while output voltages
  between -5 and +5 are undefined
- positive voltages indicate ON or SPACE, negative voltages indicate
  OFF or MARK

Other Resources

Here are some additional sites, libraries, tutorials, etc. These are links that I just found around the net and am providing for convenience (they are not endorsed).

Where CF = Compact Framework

The Final Say (aka Conclusion)

The new SerialPort class in .NET 2.0 rocks! It is much easier to use than getting the old MSComm.ocx control going in a .NET app, contains new functionality, is a 'native' .NET control, has docs built into the MSDN Library, and is easy to use.

Frequently Asked Questions (FAQ)

I'm adding this section (as of 8/10/06) to address the common questions I get on this post and through e-mail. Chances are, if you ask a good question in the comments here, I'll post it here for others to see easily. Some of the most popular topics are usb, device, cable, lines, power, packets, bridge, help.

Q: When updating a control (like a text box) while in the DataRecieved event, I get an error.
A: The SerialPort class raises events on a separate thread than the main form was create on. Windows Forms controls must be modified only on their original thread. Thankfully there is an easy way to do this. Each Windows control has a "Invoke" method which will run code on the control's original thread. So to put the recently received data into a text box (txtLog), this would do it: txtLog.Invoke(new EventHandler(delegate { txtLog.Text += comport.ReadExisting(); }); You can see this more in action in the "Log" event of "Terminal.cs" my sample code project, SerialPortTerminal.zip.
Q: I can't find the System.IO.Ports namespace.
A: Using Visual Studio 2003? The new namespace, and SerialPort class, is part of .NET 2.0 and Visual Studio 2005. It is not included in .NET 1.x (and Visual Studio 2003). Even if you have .NET 2.0 or Visual Studio 2005 installed, you can not access the class from within Visual Studio 2003.
Q: I only have .NET 1.1, what can I do?
A: Upgrade to .NET 2.0. Seriously, it's free. In fact, you can get the great C# and VB Visual Studio Interactive Development Environment (IDE) editors for FREE now with C# Express and VB Express. The .NET 2.0 Software Development Kit (SDK) for command-line development is also free. If you really must stay in .NET 1.1, you can use the technique I talk about in Serial COM Simply in C# or a 3rd party library.
Q: I'm sending data to my device, but it is not responding.
A: First make sure the device will respond using a standard app like Hyperterminal. Check the settings (baud rate, data bits, stop bits, etc) and make sure they match with your code. Try sending binary data via binary arrays. Many devices expect a carriage return at the end of a command, so be sure to send 0x0D or \n. String data can be easily converted to a binary array using:
byte[] data = System.Text.ASCIIEncoding.Default.GetBytes("Hello World\n");
com.Write(data, 0, data.Length);
Many devices require several carriage returns first to sync baud rates, so send several, like: com.Output("".PadLeft(9, '\n')); It you're communicating with a modem, make sure Echo Back is turned on. Send "ATE1\n". Other than this, just keep trying and playing around with it. It can be hard because you don't see the response from the device as easily as you would with a terminal app.
Q: When I put received data to a text box or rich text box, I get a strange symbols.
A: The default font of text boxes is designed only to show standard characters. Try using "CharMap" (a free tool in WinXP, click "Start", "Run", type "CharMap", enter). "Terminal" is a font designed to show classic ASCII characters and is what most terminal apps (like my sample code and Hyperterminal) use. There are also many ASCII codes that won't display correctly. This is why I choose to show the hex data instead of an ASCII string a lot of the time. System.Convert.ToString(mybyte, 16) will convert a byte to a string hex code, for example: byte b = 13; string s = Convert.ToStrong(b, 16).PadLeft(2, '0'), then s will contain "0D". See the "ByteArrayToHexString" and "HexStringToByteArray" methods in my sample app, SerialPortTerminal.zip.
Q: What about USB communications? How can I do USB?
This blog post isn't about USB. Believe me, I wish the .NET framework supported USB natively, and I'm doing what I can here at Microsoft to see USB get into the framework in the future. For now, you can use a USB to Serial adapter. I use a lot of these. They plug into the USB port, then appear just as a SerialPort to the PC.

For native USB devices, microcontroller vendors such as Microchip, Atmel, and TI make chips that do this for projects as well as have chips that support USB natively (I'm using the PIC18F2455). There is a lot of info and USB C# libraries readily available online with a quick search, try USB C#, which turns up resources like this great article or this USB HID C# open source project.

For simple USB-to-Serial bridges that allow your device to communicate via RS-232 but connect via USB to the PC, check out the section below on USB-to-Serial Bridge Chipsets
Q: Can I use the sample code here in my own projects (commercial or not)?
Yes! All sample code on my blog is free public domain material. I'm not a legal guy so I don't know the exact words to use, but I'll try... I'm not responsible for any problems! Use at your own rick etc. However, have at it, if it helps you out, fantastic, that's what it's here for.
Q: When using SerialPort.Open() (or SerialPort.PortOpen = true) I get the exception "UnauthorizedAccessException" or the error "An unhandled exception of type 'System.Runtime.InteropServices.COMException' occurred in axinterop.mscommlib.dll"
It may be one of a few factors:
- It may require Administrative privileges to use the port.
- The port may already be open by another program, only one app can use a port at a time.
- The port may not exist on the computer (this happens a lot). Verify the port you're trying to open is listed in the Device Manager (FAQ #9).
- The name being provided is not exactly correct.
  Use the full name of the port when opening, like "COM1" (not "1")
Q: How do I know what COM ports are on my PC?
Use the Device Manager ("Start", "Run", "devmgmt.msc") and look for the "Ports" node (see below). If you don't see a Ports node, it's because there are no Serial or Parallel ports installed in the PC. You can also use System.IO.Ports.SerialPort.GetPortNames() to return the list of available ports. Many laptops these day's don't have a serial port. You can get more serial ports very easily today with USB to Serial adapters.
Q: How do I communicate with my specific device? Modem, Mobile Phone, LED/LCD Display, Scanner, GPS, GSM/GPRS, CDMA, test equipment, etc
This post is specific to device independent serial port communications. RS-232 is a hardware standard and there are hundreds (if not thousands) of software protocols that are created for communicating over RS-232. An analogy would be that physical telephone hardware is used around the globe (like the RS-232 hardware standard), but there are hundreds of languages people can speak through the phone to each other to communicate (the software protocol). You will need to find information about the protocol used for your specific device elsewhere. I'd recommend looking on the manufacture's website, writing/calling the manufacture, or searching online for your specific device. Sometimes you can find fans or hackers of a device that congregate on a forum. Some protocols can be found through wikipedia, like the GPS NMEA 0183 serial protocol that GPS units use to send their data via a serial connection. Honestly the RS-232 communications is the easy part, I personally find the more interesting challenge is writing software for the particular protocol in use. Best of luck in finding specifications on the protocol you’re device uses!

Q: What control lines can I manually manipulate?
Control lines on an RS-232 serial port were introduced to provide flow control of serial data. Even though a modem or PC may be rated for a particular baud rate, it doesn’t always mean that the device can process the data that fast. For example, bits may flow in through a modem at 2400 bps (bits per second) but in the early days a PC couldn’t process the data fast enough, so it would toggle control lines to tell the modem that it was read for more data or to ‘pause’ send it data. Now since PCs are quite fast these lines are mostly ignored. They can be used as a simple way to toggle an LED or send or receive high or low states. RTS/CTS control flow is one such technique which is supported natively by the control via the Handshake property.

Lines marked ‘Output’ in the table can be set by the serial port to a high or low state (True or False) and the ‘Input’ lines can be read as high or low. You can use the PinChanged event to be notified when one of the input pins changes. The Handshake property can be set to use RTS/CTS (uses hardware control lines) or XON/XOFF (uses software) or both.

Control Line	Name	DB9 Pin	SerialPort Property	I/O
DTR	Data Terminal Ready	4	DtrEnable	Output
RTS	Request to Send	7	RtsEnable	Output
CTS	Clear to Send	8	CtsHolding	Input
DSR	Data Set Ready	6	DsrHolding	Input
CD (or DCD)	Data Carrier Detect	1	CDHolding	Input

For detecting a Ring Indication, see the next question.

Q: How do you detect the Ring Indicator line?
There isn’t a property off of the SerialPort class to test the current state of the Ring Indicator (DB9 pin 9), but there is an event that gets triggered, PinChanged. You can attach an event listener to PinChanged and when the event is called, SerialPinChangedEventArgs is passed with a EventType property of type SerialPinChange which will indicate if a ring indication was detected. Here is an example:

comport.PinChanged += new SerialPinChangedEventHandler(comport_PinChanged);

void comport_PinChanged(object sender, SerialPinChangedEventArgs e)

{

if (e.EventType == SerialPinChange.Ring) RingDetected();

}
Q: What pins can I use for powering devices, a high signal, or for boolean input & output?
The TX & RX pins carry the standard serial signal, but the other pins can be used as high/low input/output pins. The output pins (4 DTR or 8 CTS), supply 5 to 15 volts (15v is proper RS-232 standard) when high and 0 to -15 volts when low. They only supply flea current so they're not meant to be used for powering any devices (like USB is designed for). However, they can be used as a reference voltage or for switching to one of the input pins for a high or low signal. The input pins (1 DCD, 6 DSR, 8 CTS, and 9 RI) can be used to detect a high or low signal. Proper RS-232 signal levels are -15v for a low and +15v for a high (compared to ground, pin 5). A MAX232 or similar chip takes a TTL 0-5v input and produces the -15v to +15v levels. However, most PC RS-232 COM ports will accept a 0v for low and 5v for high, but it is not guaranteed and alters from PC to PC. If you want a simple "toggle high", just hold pin 4 DTR high, and switch it to pin 1 DCD. The .NET SerialPort class has easy to use properties for switching the output pins high or low and for detecting the current level of the input pins. I have been able to use pin 4 DTR for a very low current (20ma max) PIC processors, but not reliably. I prefer to always supply external power and use pin 4 as a signal to turn on or off my device. I'll attach pin 4 to a transistor that switches my power source to my PIC to turn it on or off.
Q: What about ‘packets’? Does RS-232 support any commands or data segregation? OR Data comes in at seemingly random times?
Serial data flow through RS-232 has nothing to do with ‘packets’. It’s just a stream of bytes in and out. There is no guarantee that data arrives together.

Packet Protocols
Any notion of data compartmentalization (packets) would have to be coded by you for your unique use. Much of my time working with serial has been spent on defining useful packet like protocols, that usually include some type of header, command structure, and CRC check. For example, the first two bytes are the packet length, the next two bytes is the command, next two bytes are parameters, and the last byte is a CRC. Then my apps would buffer incoming data and look in the buffer for valid packets. Of course it differs depending on the device you’re working with and your specific needs. USB does have specific communications protocol defined, one of them being command based, like the little packet just mentioned. But with USB, you’re able to get the whole command and parameter together at once, with serial you have to create the protocol yourself, buffer, and parse the data. My previous serial post has more info under the header “Protocol Development”.

Buffering Incoming Data
Since bytes may come in at any time, buffering incoming data is critical. For example, you may send a command out to your device, and the response back to the PC could trigger a single DataReceived event with all the 30 bytes of response data in the receive buffer. Or more likely, it could be any number of separate triggers of the DataReceived (up to the number of bytes received), like 4 triggers, first with 2 bytes, then 15 bytes, then 1 byte, then 12 bytes. Don’t look for a complete response in a single DataReceived call, instead:
1. buffer the incoming data
2. then scan your buffer to find complete data
3. remove the used data from the buffer

To buffer incoming data, use a coding pattern like this:
(download the code SerialComBuffering.zip)

using System;

using System.IO.Ports;

using System.Collections.Generic;

namespace SerialComBuffering

{

class Program

{

    SerialPort com = new SerialPort(SerialPort.GetPortNames()[0],

      9600, Parity.None, 8, StopBits.One);

    List<byte> bBuffer = new List<byte>();

    string sBuffer = String.Empty;

    static void Main(string[] args)

    { new Program(); }

    Program()

    {

      com.DataReceived +=

        new SerialDataReceivedEventHandler(com_DataReceived);

      com.Open();

      Console.WriteLine("Waiting for incoming data...");

      Console.ReadKey();

    }

    void com_DataReceived(object sender,

      SerialDataReceivedEventArgs e)

    {

      // Use either the binary OR the string technique (but not both)

      // Buffer and process binary data

      while (com.BytesToRead > 0)

        bBuffer.Add((byte)com.ReadByte());

      ProcessBuffer(bBuffer);

      // Buffer string data

      sBuffer += com.ReadExisting();

      ProcessBuffer(sBuffer);

    }

    private void ProcessBuffer(string sBuffer)

    {

      // Look in the string for useful information

      // then remove the useful data from the buffer

    }

    private void ProcessBuffer(List<byte> bBuffer)

    {

      // Look in the byte array for useful information

      // then remove the useful data from the buffer

    }

}

}
Q: How do you detect when a device is connected or disconnected?
Simply put, the device usually starts or stops sending data. There are no built in events when a device connects or disconnects. But there are a few tricks you can do, if you’re creating the serial device yourself, then you have more options. I’ve had my devices (and PC apps) send a constant “are you there” set of bytes, like 00 00 11 11 00 00 hex (I’d use a ‘are you there’ custom ‘packet’ as in Q13 above) till a device on the other end responds. You could also use hardware, that’s what some of the other signals lines are for (CDC, DSR, RTS, CTS, RI), you can tie one of these high and then catch an event when the line goes high so you know there’s a device there, when it goes low the device is gone.
Q: How do I transfer files?
If you’re interested in sending entire files between computers or to a device, you have two primary choices. First choice is to write your own protocol for breaking a file into manageable packets, detecting errors, sending/receiving, etc. Second choice is to use a protocol already created, like XModem, YModem, ZModem, etc. These protocols were created long ago specifically to send files over a serial connection with features like error correction, being able to resume transfers, compression, etc. I’m only aware of commercial implementations for .NET right now, like Sax Software’s CommStudio or Scientific Component’s PortController.NET. If anyone find an open source implementation, please let me know!
Q: Where can I get USB-to-Serial cables?
USB-to-Serial adapter cables allow you to get a standard RS-232 DB9 cable by plugging in the adapter to your USB port. You can use several of these to get multiple DB9 ports. Many laptops, even desktops, don’t have serial ports these days which makes these particularly handy.

Every so often I source a good cable for a decent price, typically around $10. Here is the deal I’m currently using. http://www.iofast.com/product_info.php/products_id/4681

Be forewarned, not all cables are created equally! There are two issues to contend with…
1. There are a number of companies that create USB chipsets that emulates an RS-232 port. Some are much more compatible with PCs and Macs than others. For example, the Prolific and FTDI chipset are used in the most compatible adapters (unlike Ark Micro, or others). Those companies produce WHQL (Windows Hardware Quality Labs) certified drivers and the drivers are built into most Windows and Mac systems already. So when shopping for a cable, be sure to check the chipset manufacture. Here are some handy links to drivers in case you need them.
  1. Prolific Chipset Drivers
  2. FTDI Chipset Drivers
2. Standard RS-232 signals range from 3 to 15 volts (plus or minus), 0 is not a valid signal. The USB-to-Serial interface chips used in these cables produce 0 to 5 volts, standard TTL level logic. While this works for some PCs, and certainly most microcontrollers, it is not 100% compatible. The ‘correct’ USB-to-Serial cables incorporate an additional line level driver, like the MAX232, that take the 0 to 5 volts and convert it to an appropriate +/- 12 volts for RS-232. The problem is that many low-quality cables exist out there without this line level driver chip.
Q: How can I best interface with my microcontroller? USB-to-Serial Bridge Chipsets
If you are building your own devices, usually with some type of microcontroller, and want to interface with the PC, you can certainly use RS-232 either plugged straight into your PC or via a USB-to-Serial adapter cable, but another option is to use an USB-to-Serial bridge chipset directly in your project (what is inside of the USB-to-Serial adapter cables). This allows your device to use RS-232 internally, but connect to a computer via USB and you as a project designer never need worry about the USB interface or drivers (your device and PC software just see serial RS-232). You could use a native USB microcontroller (without an RS-232 bridge), such as the PIC18F2450, but that requires writing your own USB drivers and a much deeper understanding of the USB infrastructure (both in hardware and software). This article is focused on serial RS-232, so I’m covering the USB-to-Serial bridges here.

These modern ICs don’t require external crystals, can power your device from USB Power, provide clock sources for your micro if you like, and come with Windows Certified (WHQL) drivers that are actually included in Windows Vista and beyond (also built in Mac drivers). Here are a few…
1. FTDI FT232RL
  The FTDI chips are most popular in electronics projects and used by companies like Parallax and the Arduino Duemilanove. They also have the best support in terms of evaluation modules, well written datasheet, and product availability.
  Links: product info, datasheet, evaluation modules, buy from Mouser, drivers
2. Prolific PL-2303HX
  These are the chips used in the most popular USB-to-Serial cables. They are slightly less costly than the FTDI chips in bulk, but are not quite as well supported in the US market.
  Links: product info, datasheet, buy from Saelig, drivers
3. TI TUSB3410
  Another option from Texas Instruments. I haven’t used this chip. Product Info
p.s. For trying it out and prototyping, I personally recommend this particular FTDI evaluation board, the UM232R since it plugs into typical solderless protoytpe breadboards and has most of the pins easily accessible. Last priced it was $20 from Mouser.
Q: How can I get more support? What are my support options?

Read this FAQ section! :)
You can try leaving a comment below. Perhaps someone knows the answer
Read the official MS documentation, MSDN on SerialPort
See if the article Wikipedia on RS-232
Try doing a search and look for other content. " SerialPort C#", "Serial Com C#", "serial port .net"
Post a question in the .NET Base Class Library in MSDN Forums

Reverse Enum Lookup

coad — Tue, 22 Jun 2004 06:46:00 GMT

Sometimes you may have the string name of an enumeration identifier, and want its enum type. For example, you write a enum identifier as a string to a file and want to read it back and obtain the original enumeration type. This takes place when you serialize a class to an XML file and deserialize it back using XmlSerializer.

private enum Direction {North, South, East, West};

private Direction ParseDirection(string name)
{ return (Direction) Enum.Parse(typeof(Direction), name, true); }

Obtaining Indented XML as a String

coad — Tue, 22 Jun 2004 05:55:00 GMT

Using XmlDocument.Save(string file) produces a file with nicely indented elements. XmlDocument.OuterXml returns a string without any formatting. If you want a nicely formatted string (to display to the user, write to console, etc), without directly writing to a file, you must use the XmlTextWriter.

The using statements in the method makes sure the resorces are disposed of sooner than later. Here is the code to return a string of formatted XML from an XmlDocument. Download Example Code (requires Visual Studio 2005)

using System.IO;
using System.Xml;

public static string FormatXML(XmlDocument doc)
{ 
  // Create a stream buffer that can be read as a string
  using (StringWriter sw = new StringWriter())

    // Create a specialized writer for XML code
    using (XmlTextWriter xtw = new XmlTextWriter(sw))
    {
      // Set the writer to use indented (hierarchical) elements
      xtw.Formatting = System.Xml.Formatting.Indented;

      // Write the XML document to the stream
      doc.WriteTo(xtw);

      // Return the stream as a string
      return sw.ToString();
    }
}

Creating Quick Tests in C#

coad — Fri, 18 Jun 2004 09:51:00 GMT

Update on 5/2/07: This post has nothing to do with Unit Testing (it was written before I was aware of unit testing) but has to do with write little bits of code to try new stuff out. It is also only for VS03. For the current version (VS05), see this post: CoadNet VS Project Templates, Quick Code + Console App for C# in VS05

CoadTools Quick Test C# Project Template (setup .msi) for Visual Studio .NET 2003

Introduction
Very often I need to test a tidbit of code, do some research on a class, etc. In fact, I was creating several times as many quick code test projects as any other project need. I used to start a Console application, change it to a Windows Application, but still needed to add namespaces, etc. So I created a custom "New Project" template for Visual Studio .NET 2003. To use, just install, load VS.NET, choose "New Project"/"Visaul C# Projects"/"Quick Test", and you're good to go.

The Goal
The main goal was to minimize the time to test code. Just start VS.NET, choose the "Quick Test" project, and type code. I wanted to send output to the Trace (VS.NET Ouput Window) and have the most common namespaces already included. You can easily modify the template after it is installed to suite your own needs.

Compare and Contrast
A popular tool is Snippet Compiler, which is a stand-alone mini-IDE for testing code. This is a great tool, especially if you do not own VS.NET 2003. When testing, I find that I want the full VS.NET environment, which I'm most familiar with and productive in, and to perform quick MSDN help lookup and take advantage of the full debugging interface. Just a simple custom "New Project" template like this provides all these objectives in a simple manor.

Saving Code
When creating a new quick test project, I usually just store the project in "C:\Temp\Test". This way I keep my tests for future reference and they are out of the way.

Leave Feedback
This is completely free. All I ask is that you leave a feedback comment. :)

VS.NET 2003 "New Project" Dialog w/ Quick Test Project

Code Template in VS.NET, Fully Customizable

Screen captures have been brought to you by SnagIt. This is my first use of SnagIt, a powerful screen capture utility, and it is fantastic! Extremely easy to use (a big plus for me) and it includes additional editing tools.

Property Event Pattern

coad — Fri, 18 Jun 2004 04:59:00 GMT

Introduction
Since the advent of .NET, one of my most frequent and useful patterns is using an event to notify change in state. Applying this pattern has reduced overall code, improved reliability, and made maintenance and expansion easier.

Why? The Context
Without events, spaghetti code occurs real quickly when one method changes state that other code is dependant on without notifying that the change is made. This is one of the most frequent causes of coding errors (bugs) in mid-to-large applications that I have seen. Events go a long way in solve this issue.

This should be obvious with public properties that can be changed externally, but must be acted upon by the owner. Such as the Text property on a label, when changed, the label must be redrawn.

Common Example
This is used extensively on Windows Forms components. Almost every property has an associated change event. TextChanged for the Text property, EnableChanged for the Enabled property and so on.

Internally Critical
This pattern becomes more subtle but critical with internal members. In larger applications, for clarity, I wrap most all class variables in properties with change events. If the class is designed to be inherited, this becomes all the more important as you can not rely on derived classes to notify your code when they change state.

The Solution

Subscribe to Events
Code that depends on a class' state can subscribe to the appropriate change event to receive notification of when that state changes to take appropriate action.
Event Triggers
The "Event Triggers" allow easy triggering of the event and allow derived classes the option of first notification (before the event occurs).
Internal Access Through Properties
Even internal members should access the variable through the property to ensure that notification occurs. In other words, members should not access the class variable directly, only through the property.

#region Public Events
public event EventHandler DevicePortChanged;
#endregion

#region Property Variables
private int m_DevicePort;
#endregion

#region Public Properties
public int DevicePort
{
  get {return m_DevicePort;}
  set
  {
    int saved = m_DevicePort;
    m_DevicePort = value;
    if (saved != value) OnDevicePortChanged(EventArgs.Empty);
  }
}
#endregion

#region Event Triggers
protected virtual void OnDevicePortChanged(EventArgs e)
{ if (DevicePortChanged != null) DevicePortChanged(this, e); }
#endregion

References

Associating a File Extension and Context Menus with an Application in the Registry

coad — Fri, 11 Jun 2004 21:31:00 GMT

You can easily assign a file extension to open with your application in the registry.

Verbal Description
The extension is added as a key under "HKEY_CLASSES_ROOT" with the (default) value set to the file's type (a string arbitrarily assigned by yourself). Then you add a key with the file's type also to "HKEY_CLASSES_ROOT" with its (default) value set to the file's type description (that is shown in Exporer). Under the same key, add they keys "shell/open/command" with the (default) value being the program to execute. Use "%1" with the quotes to pass the file's name to your app. You can also assign an icon by adding a "DefaultIcon" key under the file's type key. Then additional context menu items can be added by putting keys the [filetype]/shell/[MenuItem]/Command

Example Registry Entries

HKEY_CLASSES_ROOT\.npost = NovaBlog.Post
HKEY_CLASSES_ROOT\NovaBlog.Post = NovaBlog Article Posting
HKEY_CLASSES_ROOT\NovaBlog.Post\DefaultIcon = C:\Program Files\NovaBlog\NovaBlox.exe,0
HKEY_CLASSES_ROOT\NovaBlog.Post\shell\Open = &Open
HKEY_CLASSES_ROOT\NovaBlog.Post\shell\Open\Command = C:\Program Files\NovaBlog\NovaBlox.exe "%1"
HKEY_CLASSES_ROOT\NovaBlog.Post\shell\PostNow = &Post the Article Now
HKEY_CLASSES_ROOT\NovaBlog.Post\shell\PostNow\Command = C:\Program Files\NovaBlog\NovaBlox.exe /postnow "%1"

C# Code
Thankfully there is a Microsoft.Win32 namespace with classes for working with the registry. This is all there is to it!

// Created by Noah Coad, 6/11/04

using Microsoft.Win32;
using System.Windows.Forms;

public static void CreateRegEntries()
{
  RegistryKey rkey = Registry.ClassesRoot;
  rkey.CreateSubKey(".npost").SetValue("", "NovaBlog.Post");
  rkey = rkey.CreateSubKey("NovaBlog.Post");
  rkey.SetValue("", "NovaBlog Article Post");
  rkey.CreateSubKey("DefaultIcon").SetValue("", Application.ExecutablePath + ",0");
  rkey = rkey.CreateSubKey("shell");
  
  RegistryKey keycmd = rkey.CreateSubKey("Open");
  keycmd.SetValue("", "&amp;Open");
  keycmd.CreateSubKey("Command").SetValue("",
    "\"" + Application.ExecutablePath + "\" \"%1\"");
  
  keycmd = rkey.CreateSubKey("PostNow");
  keycmd.SetValue("", "&amp;Post Article Now");
  keycmd.CreateSubKey("Command").SetValue("",
    "\"" + Application.ExecutablePath + "\" /postnow \"%1\"");
}

Programming Practices Policy v3.0 Released

coad — Wed, 19 May 2004 02:33:00 GMT

Now available is a new version of the synopsis of C# coding practices that are being used by the majority of MVPs, professional C# coders, and my associates. These practices are being used by the development community and this is an abbreviation that I have assembled for colleagues.

Programming Practice Policy.pdf v3.0

C# Team FAQ Blog

coad — Mon, 19 Apr 2004 01:37:00 GMT

The C# team at Microsoft has started a Frequently Asked Questions (FAQ) blog where they answer some interesting topics. Definitely a good read for C# developers. I've found it interesting to see the reasoning behind some of the descriptions made in the C# language.

http://blogs.msdn.com/csharpfaq/

Two New CoadTools, AdvancedFileProperties & OrderedStringDictionary

coad — Sun, 18 Apr 2004 03:37:00 GMT

My protege, Radoslav (Radi) Ivanov (age 16), has published his first code utilitity! It is an “Advanced File Properties“ reader that retrieves the NTFS extended properties of a file. It provides a DataTable wrapped method for an included COM DLL.

I created an “Ordered String Dictionary“ that implements an ArrayList to create a string key/value pair dictionary that keeps the ordering of its elements. The System.Collections.Specialized StringDictionary uses a HashTable that looses the order of its pairs and NameValueCollection does not support insertion at a specific location. This class is in the “SpecializedCollections“ CoadTool.

Free CoadTools
http://www.coad.net/products/

Assimilate XML RSS Feed from URL in C#

coad — Thu, 15 Apr 2004 02:46:00 GMT

This piece of code pulls an RSS feed and displays the title of the articles. It is here to demonstrate just how easy it is to pull XML off the web and utilize the data.

I use Trace.WriteLine instead of Console.WriteLine so the report is fed to the Visual Studio output window and can be run as either a Console or Windows app, but at least a new Console window is not opened.

using System.Xml;

using System.Net;

using System.Text;

using System.Diagnostics;

// -------------------------------

// RSS XML Feed URL

string url = "http://msmvps.com/coad/rss.aspx";

// Create an interface to the web

WebClient c = new WebClient();

// Download the XML into a string

string xml = ASCIIEncoding.Default.GetString(c.DownloadData(url));

// Document to contain the feed

XmlDocument doc = new XmlDocument();

// Parse the xml

doc.LoadXml(xml);

// Display each article title

foreach (XmlNode node in doc.SelectNodes("/rss/channel/item/title"))

Trace.WriteLine(node.InnerText);

Edit File with Shell Registry Settings

coad — Wed, 14 Apr 2004 14:37:00 GMT

This snippet of code looks up the registered editor for the file type passed. If it doesn’t find one, it uses notepad (it was of course designed originally for text files).

Notice: See the cascading if statement both assigning and checking for null.

private void EditFile(string FilePath)

{

// Attempt to locate the system's editor for this file type

RegistryKey rkey = Registry.ClassesRoot.OpenSubKey(Path.GetExtension(FilePath));

if ((rkey != null) &&

((rkey = Registry.ClassesRoot.OpenSubKey(rkey.GetValue("") + @"\shell\edit\command")) != null) &&

(rkey.GetValue("").ToString() != String.Empty))

{

ProcessStartInfo psi = new ProcessStartInfo();

// Don't use the system's shell

psi.UseShellExecute = false;

// Replace the file parameter with this file

psi.FileName = rkey.GetValue("").ToString().Replace("%1", FilePath);

// Begin execution

Process.Start(psi);

}

// The system editor could not be located, using Notepad

else Process.Start("notepad", FilePath);

}

Simple C# XSL Transformation

coad — Wed, 14 Apr 2004 04:06:00 GMT

“XSLTransform.cs”

And here is a simple C# translator that takes an XML file sends it through an XSL file transform and saves the output. It is intended to be used as a console application. This can be easily used to apply the CSV transform XSL to Vocabulary.xml.

// Created by Noah Coad, coad.net/noah, noah@coad.net, 4/10/04

using System;

using System.IO;

using System.Xml;

using System.Xml.Xsl;

using System.Diagnostics;

namespace XSLTransform

{

class Transform

{

private Transform(string[] args)

{

// Make sure at least three command

// line arguments are specified

if (args.Length < 3) {ShowSyntax(); return;}

XslTransform xsl = new XslTransform();

// Attempt to load the XSL

try {xsl.Load(args[1]);}

catch (XmlException e) {Console.WriteLine("Could not load XSL transform: " + args[1] + "\n\n" + e.Message); return;}

catch (XsltException e) {Console.WriteLine("Could not process the XSL: " + args[1] + "\n\n" + e.Message + "\nOn line " + e.LineNumber + " @ " + e.LinePosition); return;}

// Attempt to transform the XML

try {xsl.Transform(args[0], args[2]);}

catch (XmlException e) {Console.WriteLine("Could not perform transform on: " + "\n\n" + e.Message); return;}

}

[STAThread]

static void Main(string[] args)

{ new Transform(args); }

private void ShowSyntax()

{ Console.Write("XSLTransform Xml-URL Xsl-URL Output.txt"); }

}