trunk/H7%20Server/Serial.cpp

#include "StdAfx.h"

#include "Serial.h"

#include <exception>
#include <string>
#include <sstream>
#include <iomanip>

std::string writeLastError()
{
        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();
}


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

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

        open();
}

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

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

        mPortstr = port;
        mBitrate = bitrate;

        open();
}

void CSerial::open()
{
        mComport = CreateFile( mPortstr, GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);

        if (mComport == INVALID_HANDLE_VALUE)
        {
                throw std::exception(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;
}

void CSerial::close()
{
        if (mIsopen)
        {
                while (getComstat().cbOutQue >0)
                        Sleep(5);
                SetCommState(mComport,&mDcbRestore);
                CloseHandle(mComport);
                mIsopen = false;
        }
}


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

        if (!mIsopen)
                throw std::exception("Port not opened");

        ReadFile(mComport,&out,1,&size,0);
        if (size != 1)
        {
                std::string error = writeLastError();
                CloseHandle(mComport);
                throw std::exception(error.c_str());
        }


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


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

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

        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());
        }
}

COMSTAT CSerial::getComstat() const
{
        if (!mIsopen)
                throw std::exception("Port not opened");

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

int CSerial::bytesReady() const
{
        return getComstat().cbInQue;
}

int CSerial::outQueueSize() const
{
        return getComstat().cbOutQue;
}


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