File content as of revision 1:ccecc816c5e8:

#include "mbed.h"
#include "main.h"
#include "RIT.h"

#define TIMEOUT_MESSAGE "MBED detected a timeout - eStop!\n\n\n\n"
#define USB_BUFFER_SIZE 1024
 
Serial serial(USBTX, USBRX);
Timer usbTimer;
RIT usbRIT(100);
Flags flags;

char txBuffer[USB_BUFFER_SIZE] = {0};
char rxBuffer[USB_BUFFER_SIZE] = {0};

int main(void) {
 
    flags.rxNewData = 0;
    flags.txSentData = 0;
    flags.usbTimeout = 0;
    
    serial.baud(115200);
    
    //NVIC_SetPriority(TIMER3_IRQn, 1);//priority 1
    //NVIC_SetPriority(USB_IRQn, 2);//priority 2
    
    NVIC_SetPriority( NonMaskableInt_IRQn, 100 ); 
    NVIC_SetPriority(MemoryManagement_IRQn, 100);
    
    NVIC_SetPriority(BusFault_IRQn, 100);
    NVIC_SetPriority(UsageFault_IRQn, 100);
    NVIC_SetPriority(SVCall_IRQn, 100);
    NVIC_SetPriority(DebugMonitor_IRQn, 100);
    NVIC_SetPriority(PendSV_IRQn, 100);
    NVIC_SetPriority(SysTick_IRQn, 50);
    NVIC_SetPriority(WDT_IRQn, 100);
    NVIC_SetPriority(TIMER0_IRQn, 85);
    NVIC_SetPriority(TIMER1_IRQn, 85);
    NVIC_SetPriority(TIMER2_IRQn, 85);
    NVIC_SetPriority(TIMER3_IRQn, 85);
    NVIC_SetPriority(UART0_IRQn, 100);
    NVIC_SetPriority(UART1_IRQn, 100);
    NVIC_SetPriority(UART2_IRQn, 100);
    NVIC_SetPriority(UART3_IRQn, 100);
    
    NVIC_SetPriority(PWM1_IRQn, 100);
    NVIC_SetPriority(I2C0_IRQn, 100);
    NVIC_SetPriority(I2C1_IRQn, 100);
    NVIC_SetPriority(I2C2_IRQn, 100);
    NVIC_SetPriority(SPI_IRQn, 100);
    NVIC_SetPriority(SSP0_IRQn, 100);
    NVIC_SetPriority(SSP1_IRQn, 100);
    NVIC_SetPriority(PLL0_IRQn, 100);
    NVIC_SetPriority(RTC_IRQn, 100);
    NVIC_SetPriority(EINT0_IRQn, 100);
    NVIC_SetPriority(EINT1_IRQn, 100);
    
    NVIC_SetPriority(EINT2_IRQn, 100);
    NVIC_SetPriority(EINT3_IRQn, 100);
    NVIC_SetPriority(ADC_IRQn, 100);
    NVIC_SetPriority(BOD_IRQn, 100);
    NVIC_SetPriority(USB_IRQn, 100);
    NVIC_SetPriority(CAN_IRQn, 100);
    NVIC_SetPriority(DMA_IRQn, 100);
    
    NVIC_SetPriority(I2S_IRQn, 100);
    NVIC_SetPriority(ENET_IRQn, 100);
    NVIC_SetPriority(RIT_IRQn, 1);
    NVIC_SetPriority(MCPWM_IRQn, 100);
    NVIC_SetPriority(QEI_IRQn, 100);
    NVIC_SetPriority(PLL1_IRQn, 100);
    
    serial.attach(&serialRx_ISR, Serial::RxIrq);
    usbRIT.append(&usbTimer_ISR);
    usbRIT.disable();
    
    char responseData[USB_BUFFER_SIZE] = {0};
    char requestData[USB_BUFFER_SIZE] = {0};
    
    //LPC_TIMER3->;
    
    //setup ISRs
    
    while(1) {
        if (flags.usbTimeout) {
            usbTimeout();
        }
        if (flags.rxNewData) {
            memcpy(requestData, rxBuffer, USB_BUFFER_SIZE); //requestData = rxBuffer;
            memset(rxBuffer, 0, USB_BUFFER_SIZE); //reset rx buffer
                
            //deconstruct and validate request
            
            //construct response:
            memcpy(responseData, requestData, USB_BUFFER_SIZE); //just echo request back for now
                
            memcpy(txBuffer, responseData, USB_BUFFER_SIZE); //txBuffer = responseData;
            
            serialTx();
            
            flags.rxNewData = 0;
        }
    }
}

void serialTx (void) {
__disable_irq();
    char buffPntr;
    bool terminated = 0;
    for(buffPntr=0; buffPntr<4; buffPntr++) {
        serial.putc(txBuffer[buffPntr]);
    }
    while ((!terminated)&&(buffPntr != USB_BUFFER_SIZE-1)) {
        if ((txBuffer[buffPntr-3] == 0x0A)&&(txBuffer[buffPntr-2] == 0x0A)&&(txBuffer[buffPntr-1] == 0x0A)&&(txBuffer[buffPntr] == 0x0A)) {
            terminated = 1;
        }
        else {
            serial.putc(txBuffer[buffPntr]);
        }
        buffPntr++;
    }
    //send data from tx buffer
    memset(txBuffer, 0, USB_BUFFER_SIZE); //reset tx buffer
    flags.txSentData = 1;
__enable_irq();
}

void usbTimeout(void) {
    memcpy(txBuffer, TIMEOUT_MESSAGE, USB_BUFFER_SIZE); //send eStop over usb serial
    serialTx();
    shutdown();
__disable_irq();
    while(1) {;} //remain here until hardware reset 
}

void shutdown(void) {
    //turn off each peripheral safely
}


/**************** ISRs ****************/

void serialRx_ISR(void) {
    char buffPntr = 0;
    bool terminated = 0;
    
    usbRIT.disable();
    usbTimer.stop();
    usbTimer.reset();
    usbTimer.start();
    usbRIT.enable();
    while ((buffPntr != USB_BUFFER_SIZE-1)&&(!flags.usbTimeout)) {
        if (buffPntr >= 3) {
            if ((rxBuffer[buffPntr-3] == 0x0A)&&(rxBuffer[buffPntr-2] == 0x0A)&&(rxBuffer[buffPntr-1] == 0x0A)&&(rxBuffer[buffPntr] == 0x0A)) {
                terminated = 1;
            }
        }
        if (!terminated) {
            while((!serial.readable())&&(!flags.usbTimeout)) {;}
            if (serial.readable()) {
                rxBuffer[buffPntr] = serial.getc();//whenDataReady, insert into rx buffer
            }
        }
        else {
            rxBuffer[buffPntr] = 0;
        }
        buffPntr++;
    }
    if (!terminated) {
        flags.usbTimeout = 1; //no valid termination seen
    }
    else {
        flags.rxNewData = 1;
    }
    flags.rxNewData = 1;
}

void usbTimer_ISR(void) {
    usbRIT.disable();
    usbTimer.stop();
    if ((flags.rxNewData) && (flags.txSentData)) {
        usbTimer.reset();
        usbTimer.start();
        usbRIT.enable();
        flags.rxNewData = 0;
        flags.txSentData = 0;
    }
    else {
        flags.usbTimeout = 1;
    }
}