trunk/FlisServer/Serial.cpp

#include "StdAfx.h"
#include <iostream>

#include "Serial.h"

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

std::string writeLastError()
{
        LPVOID lpMsgBuf;
        UINT error = GetLastError();
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL,
                        error,
                        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(CString port, int bitrate)
{
        if (mIsopen)
                throw std::exception("Port already opened");

        mPortstr = port;
        mBitrate = bitrate;

        open();
}

void CSerial::open()
{
        CString comport = "\\\\.\\";
        comport += mPortstr;
// �bner Serial porten.
        mComport = CreateFile( comport, 
                                                                        GENERIC_READ|GENERIC_WRITE,
                                                                        0,
                                                                        0,
                                                                        OPEN_EXISTING,
                                                                        FILE_ATTRIBUTE_NORMAL,
                                                                        0);

// Error check.
        if (mComport == INVALID_HANDLE_VALUE)
        {
                throw std::exception(writeLastError().c_str());
        }

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

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

// Definerer Serial Conf.
        dcb.BaudRate = mBitrate;
        dcb.ByteSize = 8;
        dcb.Parity = NOPARITY;
        dcb.StopBits = ONESTOPBIT;
        dcb.fDtrControl = DTR_CONTROL_DISABLE;
        dcb.fRtsControl = RTS_CONTROL_TOGGLE;
        dcb.fParity = false;
        dcb.fDsrSensitivity = false;

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