File content as of revision 22:b855dbf3a8c1:

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

void MEF::init()
{
    m_InputBuffer.reset();
    m_BSPayload.reset();
    memset(m_CPayload, 0, 80);
    m_Counter = 0;
    m_DataSize = 0;
    m_CRC = 0;
}

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

                }break;
        case START :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter >= 8)
                    {
                        if(startChecker())
                        {
                            state = TYPE;
                            m_Counter = 0;
                        }
                        else
                        {
                            //Bluboom
                            _decodeError();
                            state = PREAMBLE;
                            init();                            
                        }
                    }                    
                }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 + 1) % 8) == 0 && m_Counter != 0)
                    {
                        m_CPayload[(m_Counter + 1)/ 8 - 1] = (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;
                        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();
                            state = PREAMBLE;
                            init();    
                        }
                        else
                        {
                           state = END;                               
                        }
                        m_Counter = 0;
                    }
                    
                }break;
        case END :
                {
                    m_InputBuffer[m_Counter] = bit;
                    m_Counter++;
                    if(m_Counter >= 8)
                    {
                        if(startChecker())
                        {
                            state = PREAMBLE;
                            m_Counter = 0;
                            //CALLBACK
                            _decodeCallback(m_BSPayload, m_DataSize);   
                        }
                        else
                        {
                            //BOOMBOOM
                            _decodeError();
                            state = PREAMBLE;
                            init();
                        }
                    }

                }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] << 15) | 
    (m_InputBuffer[1] << 14) | 
    (m_InputBuffer[2] << 13) | 
    (m_InputBuffer[3] << 12) | 
    (m_InputBuffer[4] << 11) | 
    (m_InputBuffer[5] << 10) | 
    (m_InputBuffer[6] << 9) | 
    (m_InputBuffer[7] << 8) | 
    (m_InputBuffer[8] << 7) |
    (m_InputBuffer[9] << 6) |
    (m_InputBuffer[10] << 5) |
    (m_InputBuffer[11] << 4) |
    (m_InputBuffer[12] << 3) |
    (m_InputBuffer[13] << 2) |
    (m_InputBuffer[14] << 1) |
    (m_InputBuffer[15] << 0);

    return m_CRC == incommingCRC;
}

void MEF::error()
{
    
}