COSMOS SLIP support functions

Collaboration diagram for COSMOS SLIP support functions:

Functions
int32_t	slip_check_crc (uint8_t *sbuf, uint16_t ssize)
	Check SLIP packet CRC. More...
int32_t	slip_check_crc (slip_t &sbuf)
int32_t	slip_unpack (uint8_t *sbuf, uint16_t ssize, uint8_t *rbuf, uint16_t rsize)
	Unpack SLIP packet. More...
int32_t	slip_unpack (slip_t &sbuf, slip_t &rbuf)
int32_t	slip_decode (uint8_t *sbuf, uint16_t ssize, uint8_t *rbuf, uint16_t rsize)
	Decode SLIP packet. More...
int32_t	slip_decode (slip_t &sbuf, slip_t &rbuf)
int32_t	slip_encode (uint8_t *rbuf, uint16_t rsize, uint8_t *sbuf, uint16_t ssize)
	Encode data in to SLIP packet. More...
int32_t	slip_encode (slip_t &rbuf, slip_t &sbuf)
int32_t	slip_pack (uint8_t *rbuf, uint16_t rsize, uint8_t *sbuf, uint16_t ssize)
	Pack data in to SLIP packet. More...
int32_t	slip_pack (slip_t &rbuf, slip_t &sbuf)
uint16_t	slip_calc_crc (uint8_t *buf, uint16_t size)
	Calculate CRC-16-CCITT. More...
uint16_t	slip_calc_crc (slip_t &buf)
uint16_t	slip_get_crc (uint8_t *buf, uint16_t index)
	Get CRC from SLIP buffer. More...
uint16_t	slip_get_crc (slip_t &buf)
uint16_t	slip_set_crc (uint8_t *buf, uint16_t index)
	Set CRC for SLIP buffer. More...
uint16_t	slip_set_crc (slip_t &buf)

Detailed Description

Function Documentation

int32_t slip_check_crc	(	uint8_t *	sbuf,
		uint16_t	ssize
	)

Check SLIP packet CRC.

Get the CRC from the end of a SLIP packet and check it against the calculated CRC.

Parameters

sbuf	Pointer to buffer containing SLIP encoded data plus CRC.
ssize	Total size of buffer, including CRC.

Returns

0 if CRC checks out, otherwise SLIP_ERROR_CRC.

    {
    uint16_t crc, crc2;

    crc = slip_get_crc(sbuf,ssize-2);
    crc2 = slip_calc_crc(sbuf,ssize-2);
    if (crc != crc2)
        return (SLIP_ERROR_CRC);
    return 0;
    }

int32_t slip_check_crc

(

slip_t &

sbuf

)

    {
    uint16_t crc, crc2;

    crc = slip_get_crc(sbuf);
    crc2 = slip_calc_crc(sbuf);
    if (crc != crc2)
        return (SLIP_ERROR_CRC);
    return 0;
    }

int32_t slip_unpack	(	uint8_t *	sbuf,
		uint16_t	ssize,
		uint8_t *	rbuf,
		uint16_t	rsize
	)

Unpack SLIP packet.

Convert SLIP data in one buffer to raw ASCII data in second buffer and return length.

Parameters

sbuf	character buffer to read SLIP data from
ssize	size of SLIP buffer
rbuf	character buffer to store raw data
rsize	size of raw buffer, including terminal 0

Returns

bytes in raw buffer

{
    if (slip_check_crc(sbuf, ssize))
    {
        return (SLIP_ERROR_CRC);
    }

    return (slip_decode(sbuf, ssize-2, rbuf, rsize));
}

int32_t slip_unpack	(	slip_t &	sbuf,
		slip_t &	rbuf
	)

{
    if (slip_check_crc(sbuf))
    {
        return (SLIP_ERROR_CRC);
    }

    return (slip_decode(sbuf, rbuf));
}

int32_t slip_decode	(	uint8_t *	sbuf,
		uint16_t	ssize,
		uint8_t *	rbuf,
		uint16_t	rsize
	)

Decode SLIP packet.

Convert SLIP data in one buffer to raw ASCII data in second buffer and return length.

Parameters

sbuf	character buffer to read SLIP data from
ssize	size of SLIP buffer
rbuf	character buffer to store raw data
rsize	size of raw buffer, including terminal 0

Returns

bytes in raw buffer

{
    uint16_t i, j, ch;

    i = j = 0;
    do
    {
        if (j > ssize-3)
            return (SLIP_ERROR_PACKING);
        ch = sbuf[j++];
        if (i < rsize)
        {
            switch (ch)
            {
            case SLIP_FESC:
                if (j > ssize-3)
                    return (SLIP_ERROR_PACKING);
                ch = sbuf[j++];
                switch (ch)
                {
                case SLIP_TFEND:
                    rbuf[i] = SLIP_FEND;
                    break;
                case SLIP_TFESC:
                    rbuf[i] = SLIP_FESC;
                    break;
                }
                ++i;
                break;
            case SLIP_FEND:
                break;
            default:
                rbuf[i] = ch;
                ++i;
                break;
            }
        }
        else
            return (SLIP_ERROR_BUFFER);
    } while (ch != SLIP_FEND);

    return (i);
}

int32_t slip_decode	(	slip_t &	sbuf,
		slip_t &	rbuf
	)

{
    size_t j, ch;
    rbuf.clear();

    j = 0;
    do
    {
        if (j > sbuf.size()-3)
        {
            return (SLIP_ERROR_PACKING);
        }
        ch = sbuf[j++];
    } while (ch != SLIP_FEND);

    do
    {
        if (j > sbuf.size()-3)
        {
            return (SLIP_ERROR_PACKING);
        }
        ch = sbuf[j++];
        switch (ch)
        {
        case SLIP_FESC:
            if (j > sbuf.size()-3)
                return (SLIP_ERROR_PACKING);
            ch = sbuf[j++];
            switch (ch)
            {
            case SLIP_TFEND:
                rbuf.push_back(SLIP_FEND);
                break;
            case SLIP_TFESC:
                rbuf.push_back(SLIP_FESC);
                break;
            }
            break;
        case SLIP_FEND:
            break;
        default:
            rbuf.push_back(ch);
            break;
        }
    } while (ch != SLIP_FEND);

    return (rbuf.size());
}

int32_t slip_encode	(	uint8_t *	rbuf,
		uint16_t	rsize,
		uint8_t *	sbuf,
		uint16_t	ssize
	)

Encode data in to SLIP packet.

Convert raw ASCII in one buffer to SLIP encoded data in second buffer.

Parameters

rbuf	Buffer with raw data
rsize	Number of bytes in raw buffer
sbuf	Buffer to place SLIP data in
ssize	Maximum size of SLIP buffer

Returns

bytes actually written

{
    uint16_t i, j;

    i = j = 0;
    if (ssize < 3)
        return (SLIP_ERROR_BUFFER);
    sbuf[i++] = SLIP_FEND;

    for (j=0; j<rsize; ++j)
    {
        switch (rbuf[j])
        {
        case SLIP_FEND:
            if (i > ssize-4)
                return (SLIP_ERROR_BUFFER);
            sbuf[i++] = SLIP_FESC;
            sbuf[i++] = SLIP_TFEND;
            break;
        case SLIP_FESC:
            if (i > ssize-4)
                return (SLIP_ERROR_BUFFER);
            sbuf[i++] = SLIP_FESC;
            sbuf[i++] = SLIP_TFESC;
            break;
        default:
            if (i > ssize-3)
                return (SLIP_ERROR_BUFFER);
            sbuf[i++] = rbuf[j];
            break;
        }
    }
    if (ssize < i+1)
        return (SLIP_ERROR_BUFFER);
    sbuf[i++] = SLIP_FEND;
    return (i);
}

int32_t slip_encode	(	slip_t &	rbuf,
		slip_t &	sbuf
	)

{
    sbuf.clear();
    sbuf.push_back(SLIP_FEND);

    for (size_t j=0; j<rbuf.size(); ++j)
    {
        switch (rbuf[j])
        {
        case SLIP_FEND:
            sbuf.push_back(SLIP_FESC);
            sbuf.push_back(SLIP_TFEND);
            break;
        case SLIP_FESC:
            sbuf.push_back(SLIP_FESC);
            sbuf.push_back(SLIP_TFESC);
            break;
        default:
            sbuf.push_back(rbuf[j]);
            break;
        }
    }
    sbuf.push_back(SLIP_FEND);
    sbuf.push_back(0);
    sbuf.push_back(0);
    return (sbuf.size());
}

int32_t slip_pack	(	uint8_t *	rbuf,
		uint16_t	rsize,
		uint8_t *	sbuf,
		uint16_t	ssize
	)

Pack data in to SLIP packet.

Convert raw ASCII in one buffer to SLIP encoded data in second buffer, appending a 16 bit CCITT CRC.

Parameters

rbuf	Buffer with raw data
rsize	Number of bytes in raw buffer
sbuf	Buffer to place SLIP data in
ssize	Maximum size of SLIP buffer

Returns

bytes actually written

{
    int32_t i;

    i = slip_encode(rbuf, rsize, sbuf, ssize);
    if (i < 0) return (SLIP_ERROR_BUFFER);
    if (ssize < i+3) return (SLIP_ERROR_BUFFER);
    slip_set_crc(sbuf,i);
    i+=2;
    return (i);
}

int32_t slip_pack	(	slip_t &	rbuf,
		slip_t &	sbuf
	)

{
    int32_t iretn;

    iretn = slip_encode(rbuf, sbuf);
    if (iretn < 0)
    {
        return iretn;
    }

    slip_set_crc(sbuf);
    return sbuf.size();
}

uint16_t slip_calc_crc	(	uint8_t *	buf,
		uint16_t	size
	)

Calculate CRC-16-CCITT.

Calculate 16-bit CCITT CRC for the indicated buffer and number of bytes. The initial shift register value is 0xffff, and the calculation starts with the LSB, so the Polynomial is 0x8408.

Parameters

buf	bytes to calculate on
size	number of bytes

Returns

calculated CRC

{
    uint16_t crc = 0xffff;
    uint8_t ch;
    int i, j;

    for (i=0; i<size; ++i)
    {
        ch = buf[i];
        for (j=0; j<8; j++)
        {
            crc = (crc >> 1)^(((ch^crc)&0x01)?0x8408:0);
            ch >>= 1;
        }
    }
    return (crc);
}

uint16_t slip_calc_crc

(

slip_t &

buf

)

{
    uint16_t crc = 0xffff;
    uint8_t ch;

    for (size_t i=0; i<buf.size()-2; ++i)
    {
        ch = buf[i];
        for (size_t j=0; j<8; ++j)
        {
            crc = (crc >> 1)^(((ch^crc)&0x01)?0x8408:0);
            ch >>= 1;
        }
    }
    return (crc);
}

uint16_t slip_get_crc	(	uint8_t *	buf,
		uint16_t	index
	)

Get CRC from SLIP buffer.

Extract the CRC from the specified point in a SLIP buffer and return it as an unsigned integer.

Parameters

buf	SLIP buffer
index	Location in buffer of start of CRC

Returns

CRC

{
    uint16_t crc;

    memcpy(&crc, &buf[index], 2);

    return (crc);
}

uint16_t slip_get_crc

(

slip_t &

buf

)

{
    uint16_t crc;

    memcpy(&crc, &buf[buf.size()-2], 2);

    return (crc);
}

uint16_t slip_set_crc	(	uint8_t *	buf,
		uint16_t	index
	)

Set CRC for SLIP buffer.

Calculate the CRC for the specified length SLIP buffer and append it to the buffer.

Parameters

buf	SLIP buffer
index	Location in buffer of start of CRC

Returns

Calculated CRC

{
    uint16_t crc;

    crc = slip_calc_crc(buf, index);
    memcpy(&buf[index], &crc, 2);

    return (crc);
}

uint16_t slip_set_crc

(

slip_t &

buf

)

{
    uint16_t crc;

    crc = slip_calc_crc(buf);
    memcpy(&buf[buf.size()-2], &crc, 2);

    return (crc);
}