void SysTimerHandler(void)
{
/// Clear interrupt flag
MAP_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
/// Call disk process
disk_timerproc();
}
//****************************************************************************
//
//! The delay function uses timer to implement the delay time in milliseconds
//!
//! \param time in millisecond
//
//! \return void
//****************************************************************************
static void delay(int time_ms)
{
// Initialize Timer 0B as one-shot down counter.
MAP_PRCMPeripheralClkEnable(PRCM_TIMERA0, PRCM_RUN_MODE_CLK);
MAP_PRCMPeripheralReset(PRCM_TIMERA0);
MAP_TimerConfigure(TIMERA0_BASE, TIMER_CFG_SPLIT_PAIR | TIMER_CFG_B_ONE_SHOT);
MAP_TimerPrescaleSet(TIMERA0_BASE, TIMER_B, PRESCALE);
//Load the value in milisecond
MAP_TimerLoadSet(TIMERA0_BASE, TIMER_B, MILLISECONDS_TO_TICKS(time_ms));
// Enable the timer
MAP_TimerEnable(TIMERA0_BASE, TIMER_B);
//Stall during debug
MAP_TimerControlStall(TIMERA0_BASE, TIMER_B, 1);
// Enable interrupt upon Time-out
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
// Clear Interrupt Flag
MAP_TimerIntClear(TIMERA0_BASE, MAP_TimerIntStatus(TIMERA0_BASE, true));
//Wait until timer time-out
while (MAP_TimerIntStatus(TIMERA0_BASE, true) != TIMER_TIMB_TIMEOUT){}
//Disable the timer
MAP_TimerDisable(TIMERA0_BASE, TIMER_B);
//Disable Interrupt
MAP_TimerIntDisable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
MAP_TimerIntUnregister(TIMERA0_BASE, TIMER_B);
}
//*****************************************************************************
//
//! Periodic Timer Interrupt Handler
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
void
TimerPeriodicIntHandler(void)
{
unsigned long ulInts;
//
// Clear all pending interrupts from the timer we are
// currently using.
//
ulInts = MAP_TimerIntStatus(TIMERA0_BASE, true);
MAP_TimerIntClear(TIMERA0_BASE, ulInts);
//
// Increment our interrupt counter.
//
g_usTimerInts++;
if(!(g_usTimerInts & 0x1))
{
//
// Off Led
//
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
}
else
{
//
// On Led
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
}
}
//*****************************************************************************
//
//! clears the timer interrupt
//!
//! \param ulBase is the base address for the timer.
//!
//! This function
//! 1. clears the interrupt with given base.
//!
//! \return none
//
//*****************************************************************************
void Timer_IF_InterruptClear(unsigned long ulBase)
{
unsigned long ulInts;
ulInts = MAP_TimerIntStatus(ulBase, true);
//
// Clear the timer interrupt.
//
MAP_TimerIntClear(ulBase, ulInts);
}
void ToneIntHandler(void)
{
MAP_TimerIntClear(TIMERA0_BASE, TIMER_B);
if(--g_duration <= 0) {
MAP_TimerIntDisable(TIMERA0_BASE, TIMER_TIMB_TIMEOUT);
MAP_TimerDisable(TIMERA0_BASE, TIMER_B);
noTone(current_pin);
}
}
static void TimerEmitCtrlHandler(void)
{
// Clear interrupt
unsigned long ulInts;
ulInts = MAP_TimerIntStatus(s_ulTimerEmitCtrl,true);
MAP_TimerIntClear(s_ulTimerEmitCtrl,ulInts);
s_ucLine++;
s_nSampleIndex++;
// 调节定时器
EmitStop();
if (s_nSampleIndex < 129) {
EmitStart(FIX_E0DELAY);
}
// 启动采样与命令发送
bool bEnPower = g_bRunning;
s_bRxDone = false;
//TRACE("0x%x\r\n",s_ucLine);
// 缓冲区 乒乓操作
unsigned char* pTmp;
pTmp = s_pucRxRcv; s_pucRxRcv = s_pucRxSnd; s_pucRxSnd = pTmp;
// 开始采样
if ( ((s_ucFrame & 0x01) == 0x00)
&& (s_ucLine>127)
)
{
DMATransceive((s_ucFrame & 0x01),g_ucZoom,g_ucGain,127,s_pucTx,s_pucRxRcv);
}
else {
DMATransceive((s_ucFrame & 0x01),g_ucZoom,g_ucGain,s_ucLine,s_pucTx,s_pucRxRcv);
}
// 发送数据到无线连接
if (s_nSampleIndex >= 3) {
ISR_LineSend(s_ucFrame,s_nSampleIndex-3,s_pucRxSnd,512);
}
/*
// 开始采样第下一条线
s_ucLine++;
Command(true,g_ucZoom,g_ucGain,s_ucLine);
// 开始采样下一条线，并将读取的线送入队列
if (s_nSampleIndex < 128)
EmitStart(85000);
else
EmitStop();
ReadSPI((unsigned char*)s_ucRxBuff,(unsigned char*)s_ucTxBuff,512);
ISR_LineSend(s_ucFrame,s_nSampleIndex,(unsigned char*)s_ucRxBuff,512);
s_nSampleIndex++;
*/
}
//*****************************************************************************
//
//! Timer interrupt handler
//
//*****************************************************************************
static void TimerIntHandler()
{
//
// Clear the interrupt
//
MAP_TimerIntClear(TIMERA2_BASE,TIMER_CAPA_EVENT);
//
// Get the samples and compute the frequency
//
g_ulSamples[0] = g_ulSamples[1];
g_ulSamples[1] = MAP_TimerValueGet(TIMERA2_BASE,TIMER_A);
g_ulFreq = (TIMER_FREQ/(g_ulSamples[0] - g_ulSamples[1]));
}
// 虚拟霍尔中断
void HallSyncHandler(void)
{
// Clear interrupt
unsigned long ulInts;
ulInts = MAP_TimerIntStatus(TIMERA2_BASE,true);
MAP_TimerIntClear(TIMERA2_BASE,ulInts);
// 送出控制命令
if (ulInts & 0x01) {
++g_nVirHallCnt;
bool bCap = false;
if (g_nVirHallCnt >= 10) {
bCap = ISR_BufferCapacity();
}
//s_ucFrame++; // 不论能不能缓冲均累计帧号，以此来区分丢帧
if (bCap) {
TRACE("VH\r\n");
g_nVirHallCnt = 0; // 复位计数器
s_nSampleIndex = 0;
s_ucFrame++;
s_ucLine=0;
s_pucTx = s_ucTxBuff;
s_pucRxRcv = s_ucRxBuff_0;
s_pucRxSnd = s_ucRxBuff_1;
// 启动定时器
TRACE("->\r\n");
EmitStart(FIX_E0DELAY);
// 启动DMA采样，同时发送命令
s_bRxDone = false;
DMATransceive( (s_ucFrame & 0x01) ,g_ucZoom,g_ucGain,s_ucLine,s_pucTx,s_pucRxRcv);
/*
EmitStart(85000);
Command(true,g_ucZoom,g_ucGain,s_ucLine); // 开始采样第一条线
*/
}
else {
// 注：前一次发射和采样还没有完成，无法开始新的一次采样
if (g_nVirHallCnt == 10)
EmitStop();
}
}
}
//*****************************************************************************
//
//! \TimerA0IntHandler
//!
//! Handles interrupts for Timer A0,
//!
//! \param None.
//!
//! \return None.
//
//*****************************************************************************
static void
TimerA0IntHandler(void)
{
unsigned long ulStatus;
unsigned long ulCountOnEntry;
//
// Clear all interrupts for Timer unit 0.
//
ulStatus = MAP_TimerIntStatus(TIMERA0_BASE, true);
MAP_TimerIntClear(TIMERA0_BASE, ulStatus);
//
// Take a snapshot of the other interrupt's counter.
//
ulCountOnEntry = g_ulA1IntCount;
MAP_TimerEnable(TIMERA1_BASE, TIMER_A);
//
// We wait 2mS to give the A1 interrupt a chance to fire.
//
UTUtilsDelay(SLOW_TIMER_DELAY_uS);
//
// Determine whether the Timer A1 interrupt handler was processed during our
// delay and set the global flag accordingly.
//
if(ulCountOnEntry == g_ulA1IntCount)
{
g_bA1CountChanged = false;
}
else
{
g_bA1CountChanged = true;
}
//
// Increment our interrupt counter.
//
g_ulA0IntCount++;
//
// Alert to the user
//
UART_PRINT("Completed TimerA0 Interrupt Handler \n\r");
}
/* EFFECTS: Timer Interrupt handler, which toggles the RED led */
void TimerPeriodicIntHandler(void)
{
unsigned long ulInts;
// Clear all pending interrupts from the timer we are currently using.
ulInts = MAP_TimerIntStatus(TIMERA0_BASE, true);
MAP_TimerIntClear(TIMERA0_BASE, ulInts);
// Increment our interrupt counter.
if(g_usTimerInts)
{
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
g_usTimerInts = 0;
}
else
{
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
g_usTimerInts = 1;
}
}
//*****************************************************************************
//
//! \TimerA2IntHandler
//!
//! Handles interrupts for Timer A2.
//! This interrupt handler clears the source of the interrupt and
//! increments a counter and returns.
//!
//! \param None.
//!
//! \return None.
//
//*****************************************************************************
static void
TimerA2IntHandler(void)
{
unsigned long ulStatus;
//
// Clear all interrupts for Timer.
//
ulStatus = MAP_TimerIntStatus(TIMERA2_BASE, true);
MAP_TimerIntClear(TIMERA2_BASE, ulStatus);
//
// Increment our global interrupt counter.
//
g_ulA2IntCount++;
//
// Alert to the User
//
UART_PRINT("Completed TimerA2 Interrupt Handler \n\r");
}
static i32 hwt32_stop(struct hw_timer32* hwt)
{
u32 status = 0;
MAP_TimerDisable(hwt->base_addr, TIMER_A);
MAP_TimerIntDisable(hwt->base_addr, hwt->irq_mask);
status = MAP_TimerIntStatus(hwt->base_addr, true);
MAP_TimerIntClear(hwt->base_addr, status);
TimerValueSet(hwt->base_addr,TIMER_A,0x0);
hwt32_set_op_mode(hwt, HW_TIMER_NOT_USED);
hwt->irq_mask = 0;
hwt->n_rollovers = 0;
hwt->sw_early_ro = false;
hwt->mtone_expy.hi_32 = 0;
hwt->mtone_expy.lo_32 = 0;
return 0;
}
void cc_hwt32_isr(cc_hndl hndl)
{
u32 status;
struct hw_timer32 *hwt = (struct hw_timer32*) hndl;
if(NULL == hwt)
return;
status = MAP_TimerIntStatus(hwt->base_addr, true);
if((false == hwt32_is_running(hwt)) ||
(status & ~hwt->irq_mask))
goto hwt32_isr_exit;
hwt32_handle_timeout(hwt, status);
hwt32_isr_exit:
MAP_TimerIntClear(hwt->base_addr, status);
return;
}
//*****************************************************************************
//
//! \PerformIntTest
//!
//! Performs the repeated steps in running each test scenario.
//!
//! \param ucPriorityA0 is the interrupt priority to be used for Timer A0
//! \param ucPriorityA1 is the interrupt priority to be used for Timer A1
//! \param ucPriorityA2 is the interrupt priority to be used for Timer A2
//!
//! This function performs all the steps which are common to each test scenario
//! inside function InterruptTest.
//!
//! \return None.
//
//*****************************************************************************
tBoolean
PerformIntTest(unsigned long ulPriBits, unsigned char ucPriorityA0,
unsigned char ucPriorityA1,unsigned char ucPriorityA2)
{
tBoolean bRetcode;
unsigned long ulStatus;
//
// Set the appropriate interrupt priorities.
//
MAP_IntPriorityGroupingSet(ulPriBits);
MAP_IntPrioritySet(INT_TIMERA0A, ucPriorityA0);
MAP_IntPrioritySet(INT_TIMERA1A, ucPriorityA1);
MAP_IntPrioritySet(INT_TIMERA2A, ucPriorityA2);
//
// Clear any pending timer interrupts
//
ulStatus = MAP_TimerIntStatus(TIMERA0_BASE, false);
MAP_TimerIntClear(TIMERA0_BASE, ulStatus);
ulStatus = MAP_TimerIntStatus(TIMERA1_BASE, false);
MAP_TimerIntClear(TIMERA1_BASE, ulStatus);
ulStatus = MAP_TimerIntStatus(TIMERA2_BASE, false);
MAP_TimerIntClear(TIMERA2_BASE, ulStatus);
//
// Clear all the counters and flags used by the interrupt handlers.
//
g_ulA0IntCount = 0;
g_ulA1IntCount = 0;
g_ulA2IntCount=0;
g_bA1CountChanged = false;
//
// Enable three timer interrupts
//
MAP_TimerIntEnable(TIMERA0_BASE, TIMER_TIMA_TIMEOUT);
MAP_TimerIntEnable(TIMERA1_BASE, TIMER_TIMA_TIMEOUT);
MAP_TimerIntEnable(TIMERA2_BASE, TIMER_TIMA_TIMEOUT);
//
// Enable Timer A0
//
MAP_TimerEnable(TIMERA0_BASE, TIMER_A);
//
// Wait for Timer 0/A to fire.
//
bRetcode = UTUtilsWaitForCount(&g_ulA0IntCount, 1,
((SLOW_TIMER_DELAY_uS*3)/1000));
//
// Stop All timers and disable their interrupts
//
MAP_TimerDisable(TIMERA2_BASE, TIMER_A);
MAP_TimerDisable(TIMERA1_BASE, TIMER_A);
MAP_TimerDisable(TIMERA0_BASE, TIMER_A);
MAP_TimerIntDisable(TIMERA2_BASE, TIMER_TIMA_TIMEOUT);
MAP_TimerIntDisable(TIMERA1_BASE, TIMER_TIMA_TIMEOUT);
MAP_TimerIntDisable(TIMERA0_BASE, TIMER_TIMA_TIMEOUT);
return(bRetcode);
}
// Timer interrupt service routine
void OneMsTaskTimer_int(void)
{
// Clear the timer interrupt.
MAP_TimerIntClear(g_ulBase, MAP_TimerIntStatus(g_ulBase, true));
OneMsTaskTimer::_ticHandler();
}
//*****************************************************************************
//
//! Application callback handler for GPT Timer A0 interrupt
//!
//! \param none
//!
//! This function
//! 1. Clears the WDT interrupt
//!
//! \return None.
//
//*****************************************************************************
void AppGPTCallBackHandler()
{
MAP_TimerIntClear(TIMERA0_BASE,TIMER_TIMB_TIMEOUT|TIMER_TIMA_TIMEOUT);
DBG_PRINT("GPT TimerA0 Interrupt occured\n\r");
}
/*----------------------------------------------------------------------------*/
void hw_timer1a_int_handler()
{
MAP_TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
tn_event_iset(g_timer1a_evt, g_timer1a_evt_pattern);
tn_int_exit();
}
