Programming and Interfacing the Serial/UART/RS-232 port of a Computer/PC in Windows and Linux Part-1

From now on in this article i will be using the Serial/COM/UART words interchangeably so dear readers please cope with it. RS-232  is also the same just that it defines the same communication protocol with different voltage levels. Read more about it at RS-232 wiki.

After many futile attempts of trying to write a program in C/C++ to access the serial port of a computer especially in windows, I finally succeeded in writing a simple program in C to access the serial port of windows to send and receive data.

Now in this era of modern computers where high-speed lan, wifi and optical fibre like communications method exist some of you might think what is the use of serial port, also most of computers nowadays don't have a serial/com port any more.

But ask any electronic engineer or an embedded system designer or any networking engineer dealing with programming of modems, network switches etc or to my fellow hobbyists and electronic enthusiasts out there, a serial port is as important and crucial tool of their day to day requirement as you can say is a hammer is to a blacksmith.

I agree that serial ports have disappeared from modern PCs but to fill the void and especially suited for the needs of people like us are Usb to Serial converters available in the market from many vendors to list a few FTDI232RL/230x/231x  and Prolific PL2303 or Silicon labs CP2102 etc.There are many more also.

Now using them for sending and receiving data from a device having a UART is very easily accomplished in windows or linux or osx, by using the appropriate drivers for the device and using a console application like hyper-terminal or Termite in windows or Putty which is cross-platform. So that we can communicate with our device may be for programming or debugging or just for using as input/output console for example with microcontroller platforms like Arduino, AVR, ARM, PIC, 8051 etc.

But sometimes need arises to write a custom application so that you can make it a total standalone app fine tuning it according to your requirement. 

Like for example suppose i want a windows app to have a few buttons such that when i press a button a particular character is sent to the serial port; now i can send a character using any serial console apps described above, but suppose i need it for use by people of non-technical background to operate this. Then it would be a bad idea to think of training the end user for operating the product using a terminal app which would obviously be difficult for non-technical people instead we can just ask the end user to press a button.

But for that we will have to build a custom app which can interface with serial port. Many people have built this kind of stuff but there are rarely good articles on the web which can explain people with very less experience in windows coding where to begin from.

For people like me with not so much experience with windows programming it is a difficult feat to achieve especially the receiving data part(sending data is comparatively easier).

After doing a lot of search on the web and reading a few books i was able to send data using a program built in Visual C++/CLR dotnet. But still i was not able to receive data. I wrote this program for an embedded systems project i did "Bluetooth based home automation". In this project, by sending certain characters to the device using serial port i could turn on or off household electrical appliances connected to it.

But recently i figured it out how to write a simple ( totally basic command line) program to send and receive data from serial port. well this was a good start then building upon it, I decided to build a console like Windows app in C/C++( not .net) and i can say i somewhat succeeded as i was able to send and receive data using it. I built the GUI part using wxWidgets(had to mess around a lot first to get the wxWidgets to work at beginning) and used the same C code used in the console app to deal with the UART interfacing part. Well it has a few bugs but i consider it not bad for beginners like me.

Below you can find the complete code for the command line program. The program below uses WINAPI. You can compile it using any free version of Visual Studio or using mingW. You can use Codeblocks also it comes with a pre-configured version of mingW.

Most of the code is self explanatory but i will explain the important ones.

	#include <windows.h>
	#include <stdio.h>
	int main()
	{
	//windows type variables
	HANDLE hCom; //Handle variable
	DWORD rwlen; // read/write length
	char send[32];
	char receive[32]= {0};//well i didn't test much as what is the maximum size of
	//windows serial receive buffer but i tested it upto 94 characters and worked well
	//but i am not sure that is this buffer size a feature of the prolific pl2303 driver
	//or a generic windows feature. However it would be safe to assume that it can
	//buffer 32 characters.
	int port,n;
	char port_name[20];
	printf("Please input serial port number ");
	scanf("%d",&port);
	/* Open COM device */
	sprintf( port_name, "\\\\.\\COM%d", port );
	hCom = CreateFile( port_name, GENERIC_READ|GENERIC_WRITE,
	0, 0, OPEN_EXISTING, 0, 0 );
	//this is the CreateFile() which creates an instance of the SerialPort
	//accessible for read or write operations
	//the code in it is self-explanatory
	if( hCom==INVALID_HANDLE_VALUE )
	{
	printf( "\terror: COM%d is not available.\n", port );
	return -2;
	}
	/* optional but important part */
	//The DCB struct contains the parametes to confiure a serial port
	//if not used to configure then driver defaults will be used
	//if you change any port properties for example baud rate from
	//device manager it will not take effect immediately sometimes
	//you need to either restart the device or plug out and plug in the
	//device again for new parameters to take effect .
	//SO the below dcb method is more appropriate
	DCB dcbSerialParams = {0};
	dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
	if (!GetCommState(hCom, &dcbSerialParams))
	{
	printf("Unable to get the state of serial port");
	//error getting state
	}
	dcbSerialParams.BaudRate=CBR_9600;
	dcbSerialParams.ByteSize=8;
	dcbSerialParams.StopBits=ONESTOPBIT;
	dcbSerialParams.Parity=NOPARITY;
	if(!SetCommState(hCom, &dcbSerialParams))
	{
	printf("Unable to set serial port settings\n");
	//error setting serial port state
	}
	/* DCB optional part ends here */
	/* COMTIMEOUTS Optional Part but very usefull especially against ReadHAngs */
	COMMTIMEOUTS timeouts={0};
	timeouts.ReadIntervalTimeout=50;
	timeouts.ReadTotalTimeoutConstant=50;
	timeouts.ReadTotalTimeoutMultiplier=10;
	timeouts.WriteTotalTimeoutConstant=50;
	timeouts.WriteTotalTimeoutMultiplier=10;
	if(!SetCommTimeouts(hCom, &timeouts))
	{
	printf("Error setting Serial Port timeouts property\n");
	//error occureed. Inform user
	}
	printf("COM%d opened successfully\n",port);
	printf("enter a string to send via serial port\n");
	//gets(send); because of some reason gets() is not working
	//that is why i am using scanf()
	scanf("%s",send);
	n = strlen(send); //number of bytes to transmit
	//Sleep(2000);//wait 2 secs, it is totally not necessary
	WriteFile( hCom, send, n, &rwlen, 0 ); //send data through serial port
	printf("%d bytes of Data transmitted successfully\n",rwlen);
	/*Description of function WriteFile */
	//hCom : is the handle to SerialPOrt instance
	//send : buffer containing data to be sent
	//n : number of bytes to send
	//rwlen: number of bytes actually sent
	//0 or NULL: i don't know what it is for but its necessary, may be it used in
	//file access because these same functions are also used for fileaccess in windows
	//WriteFile function returns a NULL value in case of error can be used
	//to show pr manage errors.
	//Sleep(3000 ); //just to check the how well the receive buffer works
	//but a small delay is required so that we allow time for the receive buffer to be populated
	/* Sleep(1000);
	ReadFile( hCom, receive, sizeof(receive), &rwlen, 0 ); // read data from the serial port buffer of the OS
	printf("%d of out of %d bytes read from port and data is %s\n",rwlen,sizeof(receive),receive);
	*/
	int i;
	for(i=0;i<10;i++)
	{
	//from this test i found out that data is only removed from the Serial FIFO buffer
	//of either the OS or serial Device driver(i am not sure, who is in control) when that byte is read
	//until that new data keeps adding up to the buffer until the buffer overflows
	//and i think the buffer overflow point was somewhere near 200 bytes(I tried to read 512bytes atonce)
	//in my setup->pl2303 usb to serial in windows 7
	//Timeouts are absolutely necessary otherwise the program will hang if not able
	//to read specified number of bytes
	strset(receive,0);//clears the string buffer "receive"
	Sleep(1000);
	ReadFile( hCom, receive, sizeof(receive), &rwlen, 0 ); // read data from the serial port buffer of the OS
	printf("%d of out of %d bytes read from port and data is %s\n",rwlen,sizeof(receive),receive);
	}
	/*Description of function ReadFile */
	//hCom : is the handle to SerialPOrt instance
	//receive : buffer into which data it to be read
	//n : number of bytes to read from receive buffer
	//rwlen: number of bytes actually read. It Plays an important role in here as it tells
	//us the actual number of bytes read from the buffer not that is specified to read.
	//small error in my experiment. I found now that when i give number of characters to be read
	//more than that of to be received then it hangs waiting for more characters to arrive into
	//buffer to be read. So if you now the number of characters to be received
	//specify exactly or less but not more, other wise the program will hang
	//oneway to escape from this problem is by using timeout parameter.
	//So the serialport file will have a FIFO buffer which can then be used to
	//read data from. Once you read some characters those characters are removed
	//from the buffer and whatever are remaining to be read will be present in
	//the buffer. Once all characters are read then buffer will be empty.
	/*
	Solution for this allready found using timeouts
	//if there would be some mechanism to find how many bytes are present in the buffer
	//then it would be great or one way is to keep reading one character each time(loop) until you get a timeout.
	*/
	//but if you are continuosly reading data like in a monitor or terminal app
	//then no problem you can safely specify number of bytes to be read
	//before display and loop it continuously so for example you have specified
	//8bytes to read then ReadFile will exit only after it has read 8bytes or on timeout
	//if timeout is specified.
	//Finally i think using the timeouts worked out as now it doesn't hang even on specifying
	//more values to read.
	//0 or NULL: i don't know what it is for but its necessary, may be it used in
	//file access because these same functions are also used for fileaccess in windows
	//ReadFile function returns a NULL value in case of error can be used
	//to show or manage errors.
	//moral of the whole story is that we can't receive data and send data from console
	//at the same time obviously because in a console application you can't do both at a time,
	//but even if you go for window based application then it would require multithreaded programming,
	//or overlapped access or service creation etc. which are much advanced concepts for
	//the average experimenters
	//so for example i am building a programmer i will give an instruction and i know
	//exactly how many bytes i want to read or i can wait for a timeout
	//or i can wait for a null character,
	/*Text below is only applicable if the FIFO buffer has overflown
	//but keep in mind that the serial
	//buffer will be overwritten and data will be lost if you don't read
	//the data before any new data arrives. */
	//Scenario-1
	//if you are into making a terminal like stuff then you should learn either the
	//above mentioned advanced concepts or use simple timesharing, by which
	//we calculate the minimum receive time between characters according to baudrate
	//for example for 9600 baudrate deducting the 2% overhead, minimum receive time
	//between consecutive characters will be something close to but less than 1ms
	//so we have 1ms of time to read the device.(or better use timeouts)
	//So judging from the size of fifo buffer we and time it will take before
	//the buffer is filled and our baudrate we can read it in specific intervals
	//and do our processing in rest of the time.
	//Scenario-2
	//if you are the designer of both the embedded device and the PC side software
	//then you can code some kind of token based mechanism on receipt of which the
	//embedded device will understand that it is now safe to transmit, as the PC side
	//app is waiting for response.
	CloseHandle( hCom );//close the handle
	return 0;
	}

view raw serialport.c hosted with ❤ by GitHub

Here is the link  https://github.com/neutronstriker/SerialPortWin to whole project you can download it and modify it if you like.

I think after going through the whole code thoroughly by now you must have understood the basics of sending and receiving data from the serial port in C using WINAPI.

So lets now proceed to make a more user-friendly app i.e. a GUI(Graphical user interface) program, which should be easy to use even by the non-programmers.

So using the same functions used above to send and receive data i made a GUI program GUI_SerialConsole_wx. I made the GUI part using wxWidgets and CodeBlocks IDE. 

Well Codeblocks i a great IDE and when combined with wxWidgets makes building the GUI part as easy as possible.

Here is a screen shot of my app 

Now if you want the program only and want to skip the hassle of searching for the dependencies then here it is Release.7z. It contains all necessary files related to the program.

However i have to warn you that this is test-only initial release and it has lot of bugs especially related to the receiving part. Because the program needs to actively keep polling the serial port buffer for any new characters received, So that it can be shown in the app window. 

But it requires multi-threaded programming or Inter process communication, with which i am not much familiar. 

So what i did was i used wx_timer to initiate a 1-Second timer and whenever the timer event was triggered i would display the characters in the lower Receive Data Box. Well this works but isn't a very clean solution to our problem.

So i welcome you to modify the code and solve the issue if you like.

For basic programming of serial port in linux please read the next part of this blog..