branches/linux-serial/SlipSerial.cpp

#ifdef _WINDOWS
#include "StdAfx.h"
#endif

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