File content as of revision 16:cf433716f8d6:

#include "MEF.h"
#include "CRC16.h"

void MEF::ReceiveBit(bool bit)
{
    switch (state)
    {
        case PREAMBLE : 
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter == 8 )
                    {
                        state = START;
                        m_Counter = 0;    
                    }

                }break;
        case START :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter == 8 && startChecker())
                    {
                        state = TYPE;
                        m_Counter = 0;
                    }
                    else
                    {
                        //BOOMBOOM
                        _decodeError();
                    }

                    
                }break;
        case TYPE :
                {
                    m_Counter ++;
                    if(m_Counter == 8)
                    {
                        state = LENGTH;
                        m_Counter = 0;
                    }
                    
                }break;
        case LENGTH :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter == 8)
                    {
                        state = DATA;
                        m_DataSize = calculateSize();
                        m_Counter = 0;
                    }
                    
                }break;
        case DATA :
                {
                    m_BSPayload[m_Counter] = bit;
                    if ((m_Counter % 8) == 0 && m_Counter != 0)
                    {
                        m_CPayload[m_Counter / 8] = (m_BSPayload[m_Counter] << 0) | (m_BSPayload[m_Counter - 1] << 1) | (m_BSPayload[m_Counter - 2] << 2) | (m_BSPayload[m_Counter - 3] << 3) | (m_BSPayload[m_Counter - 4] << 4) | (m_BSPayload[m_Counter - 5] << 5) | (m_BSPayload[m_Counter - 6] << 6) | (m_BSPayload[m_Counter - 7] << 7);
                    }
                    m_Counter++;
                    if(m_Counter == m_DataSize*8)
                    {
                        
                        state = CRC16STATE;
                        CRC16 crc16;
                        m_CRC = crc16.calculateCRC16(m_CPayload, m_DataSize);
                        m_Counter = 0;                            
                    }
                }break;
        case CRC16STATE :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter == 16)
                    {
                        if(!compareCRC())
                        {
                            //BOOMBOOM
                            _decodeError();    
                        }
                        else
                        {
                           state = END;     
                        }
                        m_Counter = 0;
                    }
                    
                }break;
        case END :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter == 8 && startChecker())
                    {
                        state = PREAMBLE;
                        m_Counter = 0;
                        //CALLBACK
                        _decodeCallback(m_BSPayload);
                    }
                    else
                    {
                        //BOOMBOOM
                        _decodeError();
                    }
                }break;           
    }
    _updateState(state);
}

bool MEF::preambleChecker()
{
    bool temp = false;
    bool resultTest1 = true, resultTest2 = true;
    for(int i = 0; i < 8; i++)
    {
        if(m_InputBuffer[i] != temp)
        {
            resultTest1 = false;
        }
        if(m_InputBuffer[i] == temp)
        {
            resultTest2 = false;
        }
        temp = !temp;
    }
    return resultTest1 || resultTest2;    
}

bool MEF::startChecker()
{
    if(m_InputBuffer[0] == 0 && m_InputBuffer[1] == 1 && m_InputBuffer[2] == 1 && m_InputBuffer[3] == 1 && m_InputBuffer[4] == 1 && m_InputBuffer[5] == 1 && m_InputBuffer[6] == 1 && m_InputBuffer[7] == 0)
    {
        return true;
    }
    return false;
}

int MEF::calculateSize()
{
    return (m_InputBuffer[0] << 7) | (m_InputBuffer[1] << 6) | (m_InputBuffer[2] << 5) | (m_InputBuffer[3] << 4) | (m_InputBuffer[4] << 3) | (m_InputBuffer[5] << 2) | (m_InputBuffer[6] << 1) | (m_InputBuffer[7] << 0);
}

bool MEF::compareCRC()
{
    unsigned short incommingCRC = (m_InputBuffer[0] << 0) | 
    (m_InputBuffer[1] << 1) | 
    (m_InputBuffer[2] << 2) | 
    (m_InputBuffer[3] << 3) | 
    (m_InputBuffer[4] << 4) | 
    (m_InputBuffer[5] << 5) | 
    (m_InputBuffer[6] << 6) | 
    (m_InputBuffer[7] << 7) | 
    (m_InputBuffer[8] << 8) |
    (m_InputBuffer[9] << 9) |
    (m_InputBuffer[10] << 10) |
    (m_InputBuffer[11] << 11) |
    (m_InputBuffer[12] << 12) |
    (m_InputBuffer[13] << 13) |
    (m_InputBuffer[14] << 14) |
    (m_InputBuffer[15] << 15);
    
    return m_CRC == incommingCRC;
}

void MEF::error()
{
    
}