File content as of revision 24:e307f6aad106:

#include "APP.h"
#include "Manchester.h"
#include "Frame.h"
#include "MEF.h"

Serial pc(USBTX, USBRX);
DigitalOut out(p8);
DigitalIn in(p30);

bool clockTick = false;
bitset<FRAMESIZE> message;
bitset<MAX_DATA> decodedMessage;
int debugMessage;
bool debugMessageReady = false;
bool dataReady;
bool frameDropped; 
int counter = 0;
unsigned int period = 0;
unsigned int currentClocks = 0;
bool periodCalculated = false;
MEF mef;
STATES mefSTATE;
int payloadSize = 0;
bool swag = false;
bool asdf = false;
int messageLength = 4;
bool buffer[16];
int bufferCounter = 0;
bool firstBit = true;
STATES tempState = NOSTATE;
Mail<Message, 16> mailBox;
Mutex mute;
bool sendMessageReady;

int benchmark(void (*function) (void))
{
    int count = LPC_TIM2->TC;
    function();
    return LPC_TIM2->TC - count;
}

extern "C" void TIMER1_IRQHandler()
{
    if ((LPC_TIM1->IR & 0x01) == 0x01) // if MR0 interrupt, proceed
    {

        if(sendMessageReady)
        {
            clockTick = !clockTick;
            out = encode(message[counter], clockTick);
    
            if (clockTick)
            {
                counter++;
            }
    
            if (counter >= 56+messageLength*8)
            {
                counter = 0;
                sendMessageReady = false;
            }
        }
        LPC_TIM1->IR |= 1 << 0;        // Clear MR0 interrupt flag
    }
}

extern "C" void TIMER2_IRQHandler()
{
    unsigned int clocks = LPC_TIM2->CR0;
    bool inputValue = in.read();

    // Discard first bit
    if (!periodCalculated && !firstBit)
    {
        period = clocks / 2;
        periodCalculated = true;
    }
    
    if (firstBit)
    {
        swag = true;
        asdf = !inputValue;
        mef.ReceiveBit(!inputValue);
        firstBit = false;
    }

    if (periodCalculated)
    {
        if (clocks >= period*1.5 || (currentClocks + clocks) >= period*1.5)
        {
            currentClocks = 0;
            swag = true;
            asdf = !inputValue;
            mef.ReceiveBit(!inputValue);
        }
        else
        {
            currentClocks += clocks;
        }
    }

    LPC_TIM2->TC = 0;

    LPC_TIM2->IR |= 0xFFFFFFFF;     // clear Timer interrupt register
}

void initTimers()
{
    //Timer 1 (match)
    LPC_SC->PCLKSEL0 |= (1 << 4);           // pclk = cclk timer1
    LPC_SC->PCONP |= (1 << 2);              // timer1 power on
    LPC_TIM1->MR0 = CLOCKS_TO_SECOND / 100;  // 100 ms
    LPC_TIM1->MCR = 3;                      // interrupt and reset control
                                            // Interrupt & reset timer on match
    LPC_TIM1->EMR = (3 << 4);
    NVIC_EnableIRQ(TIMER1_IRQn);            // enable timer interrupt
    LPC_TIM1->TCR = 1;                      // enable Timer

    //Timer 2 (cap)
    LPC_SC->PCLKSEL1 |= (1 << 12);          // pclk = cclk timer2
    LPC_SC->PCONP |= (1 << 22);             // timer2 power on
    LPC_TIM2->TC = 0;                       // clear timer counter
    LPC_TIM2->PC = 0;                       // clear prescale counter
    LPC_TIM2->PR = 0;                       // clear prescale register
    LPC_TIM2->TCR |= (1 << 1);              // reset timer
    LPC_TIM2->TCR &= ~(1 << 1);             // release reset
    LPC_TIM2->IR = 0xFFFFFFFF;              // clear interrupt register
    LPC_TIM2->CCR |= 0x0000007;             // enable rising-edge and falling-edge capture on 2.0
    NVIC_EnableIRQ(TIMER2_IRQn);            // enable timer interrupt
    LPC_TIM2->TCR = 1;                      // start Timer
}



int main()
{
    //message = buildFrame(convertToBits("BLUB", messageLength), messageLength);    

    LPC_PINCON->PINSEL0 |= (3 << 8);   // P0.4 = CAP2.0
    initTimers();
    Thread term(terminal);

    while (true)
    {
        if (dataReady)
        {
            for (int i = 0; i < payloadSize * 8; i++)
            {
                
                if((i + 1) % 8 == 0)
                {
                    char tempChar = (decodedMessage[i] << 0) | (decodedMessage[i - 1] << 1) | (decodedMessage[i - 2] << 2) | (decodedMessage[i - 3] << 3) | (decodedMessage[i - 4] << 4) | (decodedMessage[i - 5] << 5) | (decodedMessage[i - 6] << 6) | (decodedMessage[i - 7] << 7);
                    pc.printf("%c", tempChar);        
                }
            }
            dataReady = false;
        }
        
        osEvent evt = mailBox.get();
        if (evt.status == osEventMail) 
        {
            mute.lock();
            // écriture de l'événement en sortie (port série)
            Message *mail = (Message*)evt.value.p;
            messageLength = mail->size;
            pc.printf("Envoie de %i bytes, %c \r\n", messageLength, mail->buffer[0]);
            message = buildFrame(convertToBits(mail->buffer, messageLength), messageLength);
            mailBox.free(mail);
            sendMessageReady = true;
            mute.unlock();
        }    
        
        
        #if DEBUG
        debugPrint();
        #endif
    }
}

void _decodeCallback(bitset<MAX_DATA> decMessage, int size)
{
    decodedMessage = decMessage;
    payloadSize = size;
    dataReady = true;
}

void _decodeError()
{
    frameDropped = true;
    periodCalculated = false;
    period = 0;
}

void _updateState(STATES state)
{
    mefSTATE = state;
}

void _mefDebug(int blu)
{
    debugMessage = blu;
    debugMessageReady = true;
}

void debugPrint()
{
    if (tempState != mefSTATE)
    {
        pc.printf("\r\nNew state: %i \r\n", mefSTATE);
        tempState = mefSTATE;
    }
    if(frameDropped)
    {
        pc.printf("Frame dropped\r\n");
        frameDropped = false;    
    }
    if(debugMessageReady)
    {
        pc.printf("%i\r\n", debugMessage);
        debugMessageReady = false;
    }
    
    if (swag)
    {
        pc.printf("%i ", asdf);
        swag = false;
    }
}

void terminal(void const *args)
{
    char messageBuffer[80];
    int bufferCounter = 0;
    char temp;
    while(true)
    {
        if(pc.readable())
        {
            temp = pc.getc();
            if(temp == 0x0D)
            {      
                pc.printf("Debug send %c , %i\r\n", messageBuffer[0], bufferCounter);          
                mute.lock();
                
                Message * mes = mailBox.alloc();                
                memcpy(mes->buffer, messageBuffer, bufferCounter);
                mes->size = bufferCounter;                
                mailBox.put(mes);
                
                mute.unlock();
                
                bufferCounter = 0;
            }
            else
            {
                pc.printf("%c", temp);
                messageBuffer[bufferCounter] = temp;
                bufferCounter++;
            }
        }
    }    
}