branches/linux-serial/Serial.cpp

#ifdef _WINDOWS
#include "StdAfx.h"
#else //linux
#include <errno.h>
#endif

#include "Serial.h"

#include <stdexcept>
#include <string>
#include <sstream>
#include <iomanip>

std::string writeLastError()
{
#ifdef _WINDOWS
        LPVOID lpMsgBuf;
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL,
                        GetLastError(),
                        MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
                        (LPSTR) &lpMsgBuf,
                        0,
                        NULL);

        std::ostringstream out;
        out << "Error" << lpMsgBuf;
        return out.str();
#else //linux
        char message[256];
        strerror_r(errno, message, 255);
        return std::string(message);
#endif
}


CSerial::CSerial()
{
        mIsopen = false;
}

CSerial::CSerial(char* port, int bitrate)
{
        mPortstr = port;
        mBitrate = bitrate;
        mIsopen = false;

#ifdef _WINDOWS
        openWindows();
#else
        openLinux();
#endif
}

CSerial::~CSerial(void)
{
        close();
}

void CSerial::open(char* port, int bitrate)
{
        if (mIsopen)
                throw std::runtime_error("Port already opened");

        mPortstr = port;
        mBitrate = bitrate;
        
#ifdef _WINDOWS
        openWindows();
#else
        openLinux();
#endif
}

#ifdef _WINDOWS
void CSerial::openWindows()
{
        mComport = CreateFile( mPortstr, GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);

        if (mComport == INVALID_HANDLE_VALUE)
        {
                throw std::runtime_error(writeLastError().c_str());
        }

        DCB dcb;
        dcb.DCBlength = sizeof(DCB);
        mDcbRestore.DCBlength = sizeof(DCB);

        if (!GetCommState(mComport,&dcb) || !GetCommState(mComport,&mDcbRestore))
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }

        dcb.BaudRate = mBitrate;
        dcb.ByteSize = 8;
        dcb.Parity = NOPARITY;
        dcb.StopBits = ONESTOPBIT;
        dcb.fDtrControl = DTR_CONTROL_DISABLE;
        dcb.fRtsControl = RTS_CONTROL_DISABLE;
        dcb.fParity = false;
        dcb.fDsrSensitivity = false;

        if (!SetCommState(mComport,&dcb))
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }

        mIsopen = true;
}
#endif


#ifndef _WINDOWS
void CSerial::openLinux()
{
}
#endif

void CSerial::close()
{
        if (mIsopen)
        {
#ifdef _WINDOWS
                while (getComstat().cbOutQue >0)
                        Sleep(5);
                SetCommState(mComport,&mDcbRestore);
                CloseHandle(mComport);
#else // linux close()
#endif
                mIsopen = false;
        }
}


unsigned char CSerial::readByte()
{
        unsigned char out;
        unsigned long size;

        if (!mIsopen)
                throw std::runtime_error("Port not opened");
#ifdef _WINDOWS
        ReadFile(mComport,&out,1,&size,0);
        if (size != 1)
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }
#else //linux readByte()
#endif

        //printByte("Read", out);
        return out;
}


void CSerial::writeByte(unsigned char out)
{
        unsigned long size;

        //printByte("Write", out);
        if (!mIsopen)
                throw std::runtime_error("Port not opened");

#ifdef _WINDOWS
        while (getComstat().cbOutQue >0)
                Sleep(2);

        WriteFile(mComport,&out,1,&size, NULL);
        if (size ==0)
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }
#else //linux writeByte()
#endif
}
#ifdef _WINDOWS
COMSTAT CSerial::getComstat() const
{
        if (!mIsopen)
                throw std::exception("Port not opened");

        COMSTAT stat;
        DWORD x;
        ClearCommError(mComport,&x,&stat);
        return stat;
}
#endif

int CSerial::bytesReady() const
{
#ifdef _WINDOWS
        return getComstat().cbInQue;
#else
        return 0;
#endif
}

int CSerial::outQueueSize() const
{
#ifdef _WINDOWS
        return getComstat().cbOutQue;
#else
        return 0;
#endif
}

/* Debug function
void CSerial::printByte(char* description, unsigned char byte)
{
        std::cout << description << " : " <<  (int) byte << "/" << std::setw(2) << std::setfill('0') << std::hex << (int) byte << std::endl;
        std::cout << std::dec;
}
*/

/*
void CSerial::writeBytes(UCVector out)
{
        unsigned long bytesWritten;
        unsigned int size = out.size();
        unsigned char *buf = new unsigned char[size];

        for (int i=0; i<size; i++)
                buf[i] = out[i];

        WriteFile(mComport,buf,size,&bytesWritten,NULL);
        if (bytesWritten != size)
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }
        delete[] buf;
}
*/


/*
UCVector CSerial::readBytes(int maxcount)
{
        UCVector buf;


        return buf;
}
*/
1	torben	44	#ifdef _WINDOWS
2	torben	38	#include "StdAfx.h"
3	torben	44	#else //linux
4			#include <errno.h>
5			#endif
6	torben	38
7			#include "Serial.h"
8
9	torben	44	#include <stdexcept>
10	torben	38	#include <string>
11			#include <sstream>
12			#include <iomanip>
13
14			std::string writeLastError()
15			{
16	torben	44	#ifdef _WINDOWS
17	torben	38	LPVOID lpMsgBuf;
18			FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER\|FORMAT_MESSAGE_FROM_SYSTEM\|FORMAT_MESSAGE_IGNORE_INSERTS,
19			NULL,
20			GetLastError(),
21			MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
22			(LPSTR) &lpMsgBuf,
23			0,
24			NULL);
25
26			std::ostringstream out;
27			out << "Error" << lpMsgBuf;
28			return out.str();
29	torben	44	#else //linux
30			char message[256];
31			strerror_r(errno, message, 255);
32			return std::string(message);
33			#endif
34	torben	38	}
35
36
37			CSerial::CSerial()
38			{
39			mIsopen = false;
40			}
41
42			CSerial::CSerial(char* port, int bitrate)
43			{
44			mPortstr = port;
45			mBitrate = bitrate;
46			mIsopen = false;
47
48	torben	44	#ifdef _WINDOWS
49			openWindows();
50			#else
51			openLinux();
52			#endif
53	torben	38	}
54
55			CSerial::~CSerial(void)
56			{
57			close();
58			}
59
60			void CSerial::open(char* port, int bitrate)
61			{
62			if (mIsopen)
63	torben	44	throw std::runtime_error("Port already opened");
64	torben	38
65			mPortstr = port;
66			mBitrate = bitrate;
67	torben	44
68			#ifdef _WINDOWS
69			openWindows();
70			#else
71			openLinux();
72			#endif
73	torben	38	}
74
75	torben	44	#ifdef _WINDOWS
76			void CSerial::openWindows()
77	torben	38	{
78			mComport = CreateFile( mPortstr, GENERIC_READ\|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
79
80			if (mComport == INVALID_HANDLE_VALUE)
81			{
82	torben	44	throw std::runtime_error(writeLastError().c_str());
83	torben	38	}
84
85			DCB dcb;
86			dcb.DCBlength = sizeof(DCB);
87			mDcbRestore.DCBlength = sizeof(DCB);
88
89			if (!GetCommState(mComport,&dcb) \|\| !GetCommState(mComport,&mDcbRestore))
90			{
91			std::string error = writeLastError();
92			CloseHandle(mComport);
93			throw std::exception(error.c_str());
94			}
95
96			dcb.BaudRate = mBitrate;
97			dcb.ByteSize = 8;
98			dcb.Parity = NOPARITY;
99			dcb.StopBits = ONESTOPBIT;
100			dcb.fDtrControl = DTR_CONTROL_DISABLE;
101			dcb.fRtsControl = RTS_CONTROL_DISABLE;
102			dcb.fParity = false;
103			dcb.fDsrSensitivity = false;
104
105			if (!SetCommState(mComport,&dcb))
106			{
107			std::string error = writeLastError();
108			CloseHandle(mComport);
109			throw std::exception(error.c_str());
110			}
111
112			mIsopen = true;
113			}
114	torben	44	#endif
115	torben	38
116	torben	44
117			#ifndef _WINDOWS
118			void CSerial::openLinux()
119			{
120			}
121			#endif
122
123	torben	38	void CSerial::close()
124			{
125			if (mIsopen)
126			{
127	torben	44	#ifdef _WINDOWS
128	torben	38	while (getComstat().cbOutQue >0)
129			Sleep(5);
130			SetCommState(mComport,&mDcbRestore);
131			CloseHandle(mComport);
132	torben	44	#else // linux close()
133			#endif
134	torben	38	mIsopen = false;
135			}
136			}
137
138
139			unsigned char CSerial::readByte()
140			{
141			unsigned char out;
142			unsigned long size;
143
144			if (!mIsopen)
145	torben	44	throw std::runtime_error("Port not opened");
146			#ifdef _WINDOWS
147	torben	38	ReadFile(mComport,&out,1,&size,0);
148			if (size != 1)
149			{
150			std::string error = writeLastError();
151			CloseHandle(mComport);
152			throw std::exception(error.c_str());
153			}
154	torben	44	#else //linux readByte()
155			#endif
156	torben	38
157	torben	44	//printByte("Read", out);
158	torben	38	return out;
159			}
160
161
162			void CSerial::writeByte(unsigned char out)
163			{
164			unsigned long size;
165
166	torben	44	//printByte("Write", out);
167	torben	38	if (!mIsopen)
168	torben	44	throw std::runtime_error("Port not opened");
169	torben	38
170	torben	44	#ifdef _WINDOWS
171	torben	38	while (getComstat().cbOutQue >0)
172			Sleep(2);
173
174			WriteFile(mComport,&out,1,&size, NULL);
175			if (size ==0)
176			{
177			std::string error = writeLastError();
178			CloseHandle(mComport);
179			throw std::exception(error.c_str());
180			}
181	torben	44	#else //linux writeByte()
182			#endif
183	torben	38	}
184	torben	44	#ifdef _WINDOWS
185	torben	38	COMSTAT CSerial::getComstat() const
186			{
187			if (!mIsopen)
188			throw std::exception("Port not opened");
189
190			COMSTAT stat;
191			DWORD x;
192			ClearCommError(mComport,&x,&stat);
193			return stat;
194			}
195	torben	44	#endif
196	torben	38
197			int CSerial::bytesReady() const
198			{
199	torben	44	#ifdef _WINDOWS
200	torben	38	return getComstat().cbInQue;
201	torben	44	#else
202			return 0;
203			#endif
204	torben	38	}
205
206			int CSerial::outQueueSize() const
207			{
208	torben	44	#ifdef _WINDOWS
209	torben	38	return getComstat().cbOutQue;
210	torben	44	#else
211			return 0;
212			#endif
213	torben	38	}
214
215	torben	44	/* Debug function
216	torben	38	void CSerial::printByte(char* description, unsigned char byte)
217			{
218			std::cout << description << " : " << (int) byte << "/" << std::setw(2) << std::setfill('0') << std::hex << (int) byte << std::endl;
219			std::cout << std::dec;
220			}
221	torben	44	*/
222	torben	38
223			/*
224			void CSerial::writeBytes(UCVector out)
225			{
226			unsigned long bytesWritten;
227			unsigned int size = out.size();
228			unsigned char *buf = new unsigned char[size];
229
230			for (int i=0; i<size; i++)
231			buf[i] = out[i];
232
233			WriteFile(mComport,buf,size,&bytesWritten,NULL);
234			if (bytesWritten != size)
235			{
236			std::string error = writeLastError();
237			CloseHandle(mComport);
238			throw std::exception(error.c_str());
239			}
240			delete[] buf;
241			}
242			*/
243
244
245			/*
246			UCVector CSerial::readBytes(int maxcount)
247			{
248			UCVector buf;
249
250
251
252			return buf;
253			}
254			*/