void TickTimer(void)
{
// Interrupt handling
TICKTIMER_INT_HANDLER;
counter++;
if (counter == TickCountOverFlow) counter = 0;
// BRTOS TRACE SUPPORT
#if (OSTRACE == 1)
#if(OS_TICK_SHOW == 1)
#if(OS_TRACE_BY_TASK == 1)
Update_OSTrace(0, ISR_TICK);
#else
Update_OSTrace(configMAX_TASK_INSTALL - 1, ISR_TICK);
#endif
#endif
#endif
// ************************
// Handler code for the tick
// ************************
OS_TICK_HANDLER();
// ************************
// Interrupt Exit
// ************************
OS_INT_EXIT_EXT();
// ************************
}
unsigned long USART1IntHandler(void *pvCBData,
unsigned long ulEvent,
unsigned long ulMsgParam,
void *pvMsgData)
{
char receive_byte;
if ((ulEvent & UART_EVENT_RX) == UART_EVENT_RX)
{
receive_byte = xHWREGB(UART1_BASE + UART_012_D);
if (OSQueuePost(Serial1, receive_byte) == BUFFER_UNDERRUN)
{
// Problema: Estouro de buffer
//OSCleanQueue(Serial0);
}
}
if ((ulEvent & UART_EVENT_TC) == UART_EVENT_TC)
{
if ((xHWREGB(UART1_BASE + UART_012_C2) & UART_EVENT_TC) == UART_EVENT_TC)
{
UARTIntDisable(UART1_BASE, UART_INT_TC);
(void)OSSemPost(SerialTX1);
}
}
// ************************
// Interrupt Exit
// ************************
OS_INT_EXIT_EXT();
// ************************
return 0;
}
unsigned long USART0IntHandler(void *pvCBData,
unsigned long ulEvent,
unsigned long ulMsgParam,
void *pvMsgData)
{
char receive_byte;
if (Contiki_Sem != NULL){
if ((ulEvent & UART_EVENT_RX) == UART_EVENT_RX)
{
receive_byte = xHWREGB(UART0_BASE + UART_012_D);
if (slip_input_byte(receive_byte) == 1) OSSemPost(Contiki_Sem);
buffer_rcvd[buffer_rcvd_i++]=receive_byte;
#if 0
if (OSQueuePost(Serial0, receive_byte) == BUFFER_UNDERRUN)
{
// Problema: Estouro de buffer
OSQueueClean(Serial0);
}
#endif
}
if ((ulEvent & UART_EVENT_TC) == UART_EVENT_TC)
{
if ((xHWREGB(UART0_BASE + UART_012_C2) & UART_EVENT_TC) == UART_EVENT_TC)
{
UARTIntDisable(UART0_BASE, UART_INT_TC);
(void)OSSemPost(SerialTX0);
}
}
// ************************
// Interrupt Exit
// ************************
OS_INT_EXIT_EXT();
// ************************
}else{
if ((ulEvent & UART_EVENT_RX) == UART_EVENT_RX)
{
receive_byte = xHWREGB(UART0_BASE + UART_012_D);
}
if ((ulEvent & UART_EVENT_TC) == UART_EVENT_TC)
{
if ((xHWREGB(UART0_BASE + UART_012_C2) & UART_EVENT_TC) == UART_EVENT_TC)
{
UARTIntDisable(UART0_BASE, UART_INT_TC);
}
}
}
}
//*****************************************************************************
//
// The UART interrupt handler.
//
//*****************************************************************************
void UARTIntHandler(void)
{
uint32_t ui32Status;
char data;
//
// Get the interrrupt status.
//
ui32Status = ROM_UARTIntStatus(UART0_BASE, true);
UARTIntClear(UART0_BASE, ui32Status);
if ((ui32Status&UART_INT_RX) == UART_INT_RX)
{
//
// Loop while there are characters in the receive FIFO.
//
while(ROM_UARTCharsAvail(UART0_BASE))
{
//
// Read the next character from the UART and write it back to the UART.
//
data = (char)ROM_UARTCharGetNonBlocking(UART0_BASE);
OSQueuePost(qUART, data);
}
}
if ((ui32Status&UART_INT_TX) == UART_INT_TX)
{
ROM_UARTIntDisable(UART0_BASE, UART_INT_TX);
// Call the keyboard analysis task
OSSemPost(sUART);
}
// ************************
// Interrupt Exit
// ************************
OS_INT_EXIT_EXT();
// ************************
}
interrupt void Radio_Interrupt(void)
#endif
{
#if PROCESSOR == COLDFIRE_V1
// ************************
// Entrada de interrupção
// ************************
OS_INT_ENTER();
// ************************
#endif
// Tratamento da interrupção
(void)RFFLAG; // Lê o registrador
RFIF; // Limpa a flag de interrupção do registrador
// Desabilita interrupção de hardware ligada ao pino INT
RFIINT_DISABLE;
#if (NESTING_INT == 1)
OS_ENABLE_NESTING();
#endif
OSSemPost(RF_Event);
// ************************
// Saída de interrupção
// ************************
#if PROCESSOR == COLDFIRE_V1
OS_INT_EXIT();
// ************************
#endif
#if PROCESSOR == ARM_Cortex_M0
OS_INT_EXIT_EXT();
// ************************
#endif
}
void OS_TICK_HANDLER(void)
{
OS_SR_SAVE_VAR
uint8_t iPrio = 0;
ContextType *Task = Head;
////////////////////////////////////////////////////
// Put task with delay overflow in the ready list //
////////////////////////////////////////////////////
while(Task != NULL)
{
if (Task->TimeToWait == OSTickCounter)
{
iPrio = Task->Priority;
#if (NESTING_INT == 1)
OSEnterCritical();
#endif
// Put the task into the ready list
OSReadyList = OSReadyList | (PriorityMask[iPrio]);
#if (VERBOSE == 1)
Task->State = READY;
#endif
Task->TimeToWait = EXIT_BY_TIMEOUT;
#if (NESTING_INT == 1)
OSExitCritical();
#endif
// Remove from delay list
RemoveFromDelayList();
#if ((PROCESSOR == ARM_Cortex_M0) || (PROCESSOR == ARM_Cortex_M3) || (PROCESSOR == ARM_Cortex_M4) || (PROCESSOR == ARM_Cortex_M4F))
OS_INT_EXIT_EXT();
#endif
}
Task = Task->Next;
}
//////////////////////////////////////////
// System Load //
//////////////////////////////////////////
#if (COMPUTES_CPU_LOAD == 1)
if (DutyCnt >= 1000)
{
DutyCnt = 0;
LastOSDuty = OSDuty;
OSDuty = 0;
}else
{
if (!OSDutyTmp) OSDuty++;
OSDutyTmp = 0;
DutyCnt++;
}
#endif
//////////////////////////////////////////
#if (TIMER_HOOK_EN == 1)
BRTOS_TimerHook();
#endif
}
