#include "system/common/sys_common.h"
#include "app.h"
#include "system_definitions.h"
#include "global.h"
#include "GPS.h"

// *****************************************************************************
// *****************************************************************************
// Section: System Interrupt Vector Functions
// *****************************************************************************
// *****************************************************************************

extern SemaphoreHandle_t xGPS_Data_ISR;//xSysTMR_ISR;

unsigned char chrt = 0,ConsoleBuffer[50];
unsigned int cindex=0, testcountTimer2=0,testcountTimer4=0;
void __ISR(_UART3_TX_VECTOR, ipl0AUTO) _IntHandlerDrvUsartTransmitInstance0(void)                   // UART-3 Debug port
{
    IFS4bits.U3TXIF=0;
//    DRV_USART_TasksTransmit(sysObj.drvUsart0);
}
void __ISR(_UART3_RX_VECTOR, ipl7AUTO) _IntHandlerDrvUsartReceiveInstance0(void) // Console Uart
{
    ConsoleBuffer[cindex++]=U3RXREG;
     IFS4bits.U3RXIF=0;  
}

void __ISR(_UART3_FAULT_VECTOR, ipl7AUTO) _IntHandlerDrvUsartErrorInstance0(void)
{
     unsigned char ch;
    if((U3STAbits.OERR) || (U3STAbits.PERR)|| (U3STAbits.FERR)){
                ch = U3RXREG;
                U3STAbits.OERR = 0;U3STAbits.PERR = 0; U3STAbits.FERR = 0;   
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_3_ERROR);  //s
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_3_RECEIVE); //s
                  IFS4bits.U3EIF=0;
                  IFS4bits.U3RXIF=0;
                
              }
    
}
 
 

 
void __ISR(_UART1_TX_VECTOR, ipl0AUTO) _IntHandlerDrvUsartTransmitInstance1(void)                   // UART-1 GPRS TX
{
    IFS3bits.U1TXIF=0;

}

void __ISR(_UART1_RX_VECTOR, ipl7AUTO) _IntHandlerDrvUsartReceiveInstance1(void)                    // UART-1 GPRS port RX
{   
    
    GPRS_Buf = U1RXREG;   
    
    comport[1].RX_Buffer[comport[1].Rxinbuf_counter] = GPRS_Buf;            
    comport[1].Rxinbuf_counter = comport[1].Rxinbuf_counter + 1;
    IFS3bits.U1RXIF=0;
    
    if (comport[1].Rxinbuf_counter >= 511) {
        comport[1].Rxinbuf_counter = 0;
    }         										
    comport[1].RXTickCounter = SYS_TMR_TickCountGet();  
    //comport[1].RXTickCounter = sSysTmrObject.sysTickCount;  // Replacement to avoid Non-Rtos API
    
}

void __ISR(_UART1_FAULT_VECTOR, ipl7AUTO) _IntHandlerDrvUsartErrorInstance1(void)
{
     unsigned char ch;
    if((U1STAbits.OERR) || (U1STAbits.PERR)|| (U1STAbits.FERR)){
                ch = U1RXREG;
                U1STAbits.OERR = 0;U1STAbits.PERR = 0; U1STAbits.FERR = 0;   
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_1_ERROR);  //s
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_1_RECEIVE); //s
                  IFS3bits.U1EIF=0;
                  IFS3bits.U1RXIF=0;
                
              }
}

 

void __ISR(_UART2_TX_VECTOR, ipl0AUTO) _IntHandlerDrvUsartTransmitInstance2(void)
{
  IFS4bits.U2TXIF = 0;
//    DRV_USART_TasksTransmit(sysObj.drvUsart2);
}
void __ISR(_UART2_RX_VECTOR, ipl7AUTO) _IntHandlerDrvUsartReceiveInstance2(void)
{
    char IntercommRx = 0;
    IntercommRx = U2RXREG;
    U3TXREG = IntercommRx;
    IFS4bits.U2RXIF = 0; 

}
void __ISR(_UART2_FAULT_VECTOR, ipl7AUTO) _IntHandlerDrvUsartErrorInstance2(void)
{
     unsigned char ch;
    if((U2STAbits.OERR) || (U2STAbits.PERR)|| (U2STAbits.FERR)){
                ch = U2RXREG;
                U2STAbits.OERR = 0;U2STAbits.PERR = 0; U2STAbits.FERR = 0;   
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_2_ERROR); //s
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_2_RECEIVE); //s
                  IFS4bits.U2EIF=0;
                  IFS4bits.U2RXIF=0;
                
              }
}

 

 
void __ISR(_UART4_TX_VECTOR, ipl0AUTO) _IntHandlerDrvUsartTransmitInstance3(void)
{

    IFS5bits.U4TXIF=0;

}
void __ISR(_UART4_RX_VECTOR, ipl7AUTO) _IntHandlerDrvUsartReceiveInstance3(void)   // GPS Uart
{
  
    char GPS_Data = U4RXREG;
    
    LATGbits.LATG0 = 1;                     //GPS Health LED
    gps_fifobuff[gps_incounter++] = GPS_Data;
    IFS5bits.U4RXIF=0;
    
    if(gps_incounter >= GPS_Data_BufSize){
        gps_incounter = 0;
    }	
    BaseType_t xHigherPriorityTaskWoken;
    xHigherPriorityTaskWoken = pdFALSE;
    
    if(xSemaphoreGiveFromISR(xGPS_Data_ISR,&xHigherPriorityTaskWoken) == pdTRUE){
         portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
    }  
}
void __ISR(_UART4_FAULT_VECTOR, ipl7AUTO) _IntHandlerDrvUsartErrorInstance3(void)
{
     unsigned char ch;
    if((U4STAbits.OERR) || (U4STAbits.PERR)|| (U4STAbits.FERR)){
                ch = U4RXREG;
                U4STAbits.OERR = 0;U4STAbits.PERR = 0; U4STAbits.FERR = 0;   
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_4_ERROR);  //s
//                SYS_INT_SourceStatusClear(INT_SOURCE_USART_4_RECEIVE); //s
                  IFS5bits.U4EIF=0;
                  IFS5bits.U4RXIF=0;
                
              }
}
 

 

void __ISR(_UART5_TX_VECTOR, ipl0AUTO) _IntHandlerDrvUsartTransmitInstance4(void)
{

     IFS5bits.U5TXIF=0;

}
void __ISR(_UART5_RX_VECTOR, ipl6AUTO) _IntHandlerDrvUsartReceiveInstance4(void)
{
    char MVB_Dat = U5RXREG;
    U3TXREG = MVB_Dat;
    IFS5bits.U5RXIF=0;
//    PLIB_INT_SourceFlagClear(INT_ID_0, INT_SOURCE_USART_5_RECEIVE); //s

}
void __ISR(_UART5_FAULT_VECTOR, ipl6AUTO) _IntHandlerDrvUsartErrorInstance4(void)
{
    
    unsigned char ch;
    if((U5STAbits.OERR) || (U5STAbits.PERR)|| (U5STAbits.FERR)){
                ch = U5RXREG;
                U5STAbits.OERR = 0;U5STAbits.PERR = 0; U5STAbits.FERR = 0;   
               // SYS_INT_SourceStatusClear(INT_SOURCE_USART_5_ERROR);  //s
               // SYS_INT_SourceStatusClear(INT_SOURCE_USART_5_RECEIVE);//s
                IFS5bits.U5EIF=0;
                IFS5bits.U5RXIF=0;
              }
    
}
 
 // Uart Interrupt flags

//U1(RXIF,TXIF,EIF) -ifs3
//U2,U3             - ifs4
//U4,U5,U6          -ifs 5
 
 
//void IntHandlerDrvTmrInstance0(void) 
void __ISR(_TIMER_2_VECTOR, ipl1AUTO) IntHandlerDrvTmrInstance0(void)
{
    testcountTimer2++;
	DRV_TMR_Tasks(sysObj.drvTmr0); //s  enabled by default  and commented now on 13-03-20
	
//    IFS0bits.T2IF = 0;
//    BaseType_t xHigherPriorityTaskWoken;
//    xHigherPriorityTaskWoken = pdFALSE;

       	   // Here i have written DRV_TMR_Tasks as Separate Task with xSysTMR_ISR handle so as to not to call an API in ISR 
		   
//    if(xSemaphoreGiveFromISR(xSysTMR_ISR,&xHigherPriorityTaskWoken) == pdTRUE){
//          // IFS0bits.T2IF = 0;
//         portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
//    }          
   
    
}


//void IntHandlerDrvTmrInstance1(void)
void __ISR(_TIMER_4_VECTOR, ipl1AUTO) IntHandlerDrvTmrInstance1(void)
{
    testcountTimer4++;
//   PLIB_INT_SourceFlagClear(INT_ID_0, INT_SOURCE_TIMER_4);
   IFS0bits.T4IF = 0;

}



//void __ISR(_TIMER_3_VECTOR, ipl1AUTO) IntHandlerDrvTmrInstance2(void) 
void IntHandlerDrvTmrInstance2(void)			// ipl3 (30.03.11-changing the )
{
    
	// clear the interrupt flag
   //PLIB_INT_SourceFlagClear( INT_ID_0,INT_SOURCE_TIMER_3); //s _actually present now commented
    IFS0bits.T3IF = 0;
         Lcc_Rx_Tick_cnt++;
         Lcc_Tx_Tick_cnt++;

        
     PR3= 40000;	
}

void __ISR(_SPI1_RX_VECTOR, ipl3AUTO) _IntHandlerSPIRxInstance0(void)
{
    DRV_SPI_Tasks(sysObj.spiObjectIdx0);
}
void __ISR(_SPI1_TX_VECTOR, ipl3AUTO) _IntHandlerSPITxInstance0(void)
{
    DRV_SPI_Tasks(sysObj.spiObjectIdx0);
}
void __ISR(_SPI1_FAULT_VECTOR, ipl3AUTO) _IntHandlerSPIFaultInstance0(void)
{
    DRV_SPI_Tasks(sysObj.spiObjectIdx0);
}
void __ISR(_ETHERNET_VECTOR, ipl5AUTO) _IntHandler_ETHMAC(void)
{
    DRV_ETHMAC_Tasks_ISR((SYS_MODULE_OBJ)0);
}

/* This function is used by ETHMAC driver */
bool SYS_INT_SourceRestore(INT_SOURCE src, int level)
{
    if(level)
    {
        SYS_INT_SourceEnable(src);
    }

    return level;
}

/*********************DMA ISR for Upgrade Process**************************/
void __ISR(_DMA1_VECTOR, ipl7AUTO) _DMA1Interrupt(void)
{
 
    if(DCH1INTbits.CHBCIF)
    {
        DCH1INTbits.CHBCIF = 0;        
    }
    if(DCH1INTbits.CHERIF)                      //ERROR
    {
        DCH1INTbits.CHERIF = 0;   
    }
    if(DCH1INTbits.CHDDIF)                      //Destination done 
    {
        DCH1INTbits.CHDDIF = 0;   
    }
    IFS4bits.DMA1IF = 0;
    Data_Rec=1;
}

void __ISR(_DMA0_VECTOR, ipl6AUTO) _DMA0Interrupt(void)
{
 
    if(DCH0INTbits.CHBCIF)
    {
        DCH0INTbits.CHBCIF = 0;  
        DMA_TX_comp=1;
    }
    if(DCH0INTbits.CHERIF)                      //ERROR
    {
        DCH0INTbits.CHERIF = 0;   
    }
    if(DCH0INTbits.CHDDIF)                      //Destination done 
    {
        DCH0INTbits.CHDDIF = 0;   
    }
    IFS4bits.DMA0IF = 0;

}