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()
{
// Åbner Serial porten.
        mComport = CreateFile( mPortstr, 
                                                                        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			// Åbner Serial porten.
62			mComport = CreateFile( mPortstr,
63			GENERIC_READ\|GENERIC_WRITE,
64			0,
65			0,
66			OPEN_EXISTING,
67			FILE_ATTRIBUTE_NORMAL,
68			0);
69
70			// Error check.
71			if (mComport == INVALID_HANDLE_VALUE)
72			{
73			throw std::exception(writeLastError().c_str());
74			}
75
76			DCB dcb;
77			dcb.DCBlength = sizeof(DCB);
78			mDcbRestore.DCBlength = sizeof(DCB);
79
80			// Error check.
81			if (!GetCommState(mComport,&dcb) \|\| !GetCommState(mComport,&mDcbRestore))
82			{
83			std::string error = writeLastError();
84			CloseHandle(mComport);
85			throw std::exception(error.c_str());
86			}
87
88			// Definerer Serial Conf.
89			dcb.BaudRate = mBitrate;
90			dcb.ByteSize = 8;
91			dcb.Parity = NOPARITY;
92			dcb.StopBits = ONESTOPBIT;
93			dcb.fDtrControl = DTR_CONTROL_DISABLE;
94			dcb.fRtsControl = RTS_CONTROL_TOGGLE;
95			dcb.fParity = false;
96			dcb.fDsrSensitivity = false;
97
98			// Error check.
99			if (!SetCommState(mComport,&dcb))
100			{
101			std::string error = writeLastError();
102			CloseHandle(mComport);
103			throw std::exception(error.c_str());
104			}
105
106			mIsopen = true;
107			}
108
109			void CSerial::close()
110			{
111			if (mIsopen)
112			{
113			while (getComstat().cbOutQue >0)
114	kevin	113	{
115	kevin	70	Sleep(5);
116	kevin	113	}
117	kevin	70	SetCommState(mComport,&mDcbRestore);
118			CloseHandle(mComport);
119			mIsopen = false;
120			}
121			}
122
123
124			unsigned char CSerial::readByte()
125			{
126			unsigned char out;
127			unsigned long size;
128
129			if (!mIsopen)
130	kevin	113	{
131	kevin	70	throw std::exception("Port not opened");
132	kevin	113	}
133	kevin	70
134			ReadFile(mComport,&out,1,&size,0);
135			// Error check.
136			if (size != 1)
137			{
138			std::string error = writeLastError();
139			CloseHandle(mComport);
140			throw std::exception(error.c_str());
141			}
142	kevin	113
143	kevin	70
144			//printByte("Read", out);
145			return out;
146			}
147
148
149			void CSerial::writeByte(unsigned char out)
150			{
151			unsigned long size;
152
153			//printByte("Write", out);
154			if (!mIsopen)
155			throw std::exception("Port not opened");
156
157			while (getComstat().cbOutQue >0)
158			Sleep(2);
159
160			WriteFile(mComport,&out,1,&size, NULL);
161			if (size ==0)
162			{
163			std::string error = writeLastError();
164			CloseHandle(mComport);
165			throw std::exception(error.c_str());
166			}
167			}
168
169			COMSTAT CSerial::getComstat() const
170			{
171			if (!mIsopen)
172			throw std::exception("Port not opened");
173
174			COMSTAT stat;
175			DWORD x;
176			ClearCommError(mComport,&x,&stat);
177			return stat;
178			}
179
180			int CSerial::bytesReady() const
181			{
182			return getComstat().cbInQue;
183			}
184
185			int CSerial::outQueueSize() const
186			{
187			return getComstat().cbOutQue;
188			}
189
190
191			void CSerial::printByte(char* description, unsigned char byte)
192			{
193			std::cout << description << " : " << (int) byte << "/" << std::setw(2) << std::setfill('0') << std::hex << (int) byte << std::endl;
194			std::cout << std::dec;
195			}