branches/linux-serial/SlipSerial.cpp

#include "StdAfx.h"
#include ".\slipserial.h"

#include <iomanip>

enum SlipState{
        SlipNormal,
        SlipEscaped,
        SlipError,
        SlipStopped
};

#define SLIP_END 192
#define SLIP_ESC 219
#define SLIP_ESCAPED_END 220
#define SLIP_ESCAPED_ESC 221


CSlipSerial::CSlipSerial(char* port, int bitrate)
: CSerial(port,bitrate)
{
}

CSlipSerial::CSlipSerial()
: CSerial()
{
}

CSlipSerial::~CSlipSerial(void)
{
}


std::vector<unsigned char> CSlipSerial::readFrame()
{
        std::vector<unsigned char> buf;

        int state = SlipNormal;

        while ( /*bytesReady() >0 &&*/ state != SlipStopped)
        {
                unsigned char data = readByte();
                switch (state)
                {
                        case SlipNormal:
                                if (data == SLIP_END)
                                        state = SlipStopped;
                                else if (data == SLIP_ESC)
                                        state = SlipEscaped;
                                else
                                        buf.push_back(data);
                                break;
                        case SlipEscaped:
                                if (data == SLIP_ESCAPED_END)
                                        buf.push_back(SLIP_END);
                                else if (data == SLIP_ESCAPED_ESC)
                                        buf.push_back(SLIP_ESC);
                                else
                                        state = SlipError;
                                break;
                        default: //empty default case
                                break;
                }
        }

        if (state != SlipStopped || state == SlipError)  //in case we ran out of data before we recieved af SLIP_END character or there was an error
        {
                buf.clear();
        }

        return buf;
}

void CSlipSerial::writeFrame(std::vector<unsigned char> data)
{
        for (int i=0; i<data.size(); i++)
        {
                writeSlipByte( data[i] );
        }
        //send the frame termination byte
        writeByte(SLIP_END);

}

void CSlipSerial::writeFrame(unsigned char buf[], int len)
{
        for (int i=0; i<len; i++)
        {
                writeSlipByte( buf[i] );
        }
        writeByte(SLIP_END);
}

void CSlipSerial::writeSlipByte(unsigned char out)
{
        if (out == SLIP_ESC)
        {
                writeByte(SLIP_ESC);
                writeByte(SLIP_ESCAPED_ESC);
        }
        else if (out == SLIP_END)
        {
                writeByte(SLIP_ESC);
                writeByte(SLIP_ESCAPED_END);
        }
        else
                writeByte( out );
}
1	torben	38	#include "StdAfx.h"
2			#include ".\slipserial.h"
3
4			#include <iomanip>
5
6			enum SlipState{
7			SlipNormal,
8			SlipEscaped,
9			SlipError,
10			SlipStopped
11			};
12
13			#define SLIP_END 192
14			#define SLIP_ESC 219
15			#define SLIP_ESCAPED_END 220
16			#define SLIP_ESCAPED_ESC 221
17
18
19			CSlipSerial::CSlipSerial(char* port, int bitrate)
20			: CSerial(port,bitrate)
21			{
22			}
23
24			CSlipSerial::CSlipSerial()
25			: CSerial()
26			{
27			}
28
29			CSlipSerial::~CSlipSerial(void)
30			{
31			}
32
33
34			std::vector<unsigned char> CSlipSerial::readFrame()
35			{
36			std::vector<unsigned char> buf;
37
38			int state = SlipNormal;
39
40			while ( /bytesReady() >0 &&/ state != SlipStopped)
41			{
42			unsigned char data = readByte();
43			switch (state)
44			{
45			case SlipNormal:
46			if (data == SLIP_END)
47			state = SlipStopped;
48			else if (data == SLIP_ESC)
49			state = SlipEscaped;
50			else
51			buf.push_back(data);
52			break;
53			case SlipEscaped:
54			if (data == SLIP_ESCAPED_END)
55			buf.push_back(SLIP_END);
56			else if (data == SLIP_ESCAPED_ESC)
57			buf.push_back(SLIP_ESC);
58			else
59			state = SlipError;
60			break;
61			default: //empty default case
62			break;
63			}
64			}
65
66			if (state != SlipStopped \|\| state == SlipError) //in case we ran out of data before we recieved af SLIP_END character or there was an error
67			{
68			buf.clear();
69			}
70
71			return buf;
72			}
73
74			void CSlipSerial::writeFrame(std::vector<unsigned char> data)
75			{
76			for (int i=0; i<data.size(); i++)
77			{
78			writeSlipByte( data[i] );
79			}
80			//send the frame termination byte
81			writeByte(SLIP_END);
82
83			}
84
85			void CSlipSerial::writeFrame(unsigned char buf[], int len)
86			{
87			for (int i=0; i<len; i++)
88			{
89			writeSlipByte( buf[i] );
90			}
91			writeByte(SLIP_END);
92			}
93
94			void CSlipSerial::writeSlipByte(unsigned char out)
95			{
96			if (out == SLIP_ESC)
97			{
98			writeByte(SLIP_ESC);
99			writeByte(SLIP_ESCAPED_ESC);
100			}
101			else if (out == SLIP_END)
102			{
103			writeByte(SLIP_ESC);
104			writeByte(SLIP_ESCAPED_END);
105			}
106			else
107			writeByte( out );
108			}