//*****************************************************************************
//
// The SysTick Timer interrupt handler.
//
//*****************************************************************************
void SysTickTimerHandler(void)
{
    
    IntMasterDisable();
    SYSTICKINT_FLAG = true;
    IntMasterEnable();   
}

//*****************************************************************************
//
// The interrupt handler for the first timer interrupt.
//
//*****************************************************************************
void
Timer1IntHandler(void)
{

    //
    // Clear the timer interrupt.
    //
    TimerIntClear(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
	DEBUG_TP5(0); 

    //
    // Update the interrupt status.
    //
    IntMasterDisable();
	
	if(GetDMCmode() != BIT_MODE )
	{

		/*------------------------------------------------------------*/
		/* EncoderTick(QEI0_BASE); time is 3~ microsecond			  */
		/* EncoderTick(QEI0_BASE); time is 3~ microsecond			  */
		/*------------------------------------------------------------*/		
		EncoderTick(QEI0_BASE); // PITCH Encoder	  
		EncoderTick(QEI1_BASE); // ROLL Encoder
	}
    IntMasterEnable();
	
	DEBUG_TP5(1); 
}

//*****************************************************************************
//
// Gets the current number of UART messages waiting to be processed.
//
// This function returns the number of unprocessed messages that are currently
// in the UART ring buffer.
//
// \return Current number of UART messages in the buffer.
//
//*****************************************************************************
uint_fast16_t
RemoTIUARTGetRxMsgCount(void)
{
    bool bIntState;
    uint_fast16_t ui16Temp;

    //
    // Turn off interrupts and save Interrupt enable state.
    //
    bIntState = IntMasterDisable();

    //
    // Copy message count to local variable.
    //
    ui16Temp = g_ui16RxMsgCount;

    //
    // Restore interrupt enable state.
    //
    if(!bIntState)
    {
        IntMasterEnable();
    }

    //
    // Return a snapshot of the message count.
    //
    return(ui16Temp);
}

// *******************************************************
// Returns the raw RTC time which is the same number
// of systick interrupts.
unsigned long long mRTCGetRaw(void)
{
	IntMasterDisable();
	unsigned long long ticks = g_ullRTCTicks;
	IntMasterEnable();
	return ticks;
}

//*****************************************************************************
//
// Register a callback for UART transmission complete..
//
// \param pfnCallback is a pointer to a tRemoTICallback function.
//
// Register the \e pfnCallback that will be called when a UART transmisssion is
// complete.  The Transmit buffer has just been emptied of its last byte. Only
// one callback is active at a time.  Calling this function more than once
// will override earlier callbacks.  Pass \b NULL to unregister.
//
// \return None.
//
//*****************************************************************************
void
RemoTIUARTRegisterTxCompleteCallback(tRemoTICallback *pfnCallback)
{
    bool bIntState;
    //
    // Turn off interrupts and save previous interrupt enable state.
    //
    bIntState = IntMasterDisable();

    //
    // Register the callback.
    //
    g_pfnTxCallback = pfnCallback;

    //
    // Restore interrupt master enable state.
    //
    if(!bIntState)
    {
        IntMasterEnable();
    }

    //
    // Finished.
    //
}

/*****************************************************
 * 	Function: init_BtnHandler
 *	Description: Initializes button interrupt
 *			Initializes timer for button counter
 *	Input: NONE
 *	Output: NONE
 *****************************************************/
void init_BtnHandler(void)
{
	// Unlock un-maskable pin
	HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = GPIO_LOCK_KEY;

	// Set up our interrupt for button presses
	IntMasterDisable();																				// Disable all interrupts
	GPIOIntDisable(BTN_OVERRIDE_REG, BTN_OVERRIDE);
	GPIOPinTypeGPIOInput(BTN_OVERRIDE_REG, BTN_OVERRIDE);
	GPIOPadConfigSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU);		// Set Pull-up
	GPIOIntTypeSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_BOTH_EDGES); 								// Set edge to trigger on
	GPIOIntClear(BTN_OVERRIDE_REG, BTN_OVERRIDE); 													// Clear the interrupt bit
	GPIOIntEnable(BTN_OVERRIDE_REG, BTN_OVERRIDE); 													// Enable the interrupt
	IntEnable(INT_GPIOE);

	// Lock un-maskable pin
	HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = 0;

	// Setup timer interrupt for button pressing
	// This timer will run up and when it is released we will check how long it was running
	SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
	TimerConfigure(BTN_OVERRIDE_TIM_BASE, TIMER_CFG_PERIODIC);					// Setup interrupt as 32 bit timer counting up
	TimerLoadSet(BTN_OVERRIDE_TIM_BASE, BTN_OVERRIDE_TIM, clockTime/1000);		// Load Timer
	IntEnable(INT_TIMER0A);
	TimerIntEnable(BTN_OVERRIDE_TIM_BASE, TIMER_TIMA_TIMEOUT);

	// Turn the input pin to the button high
	GPIOPinTypeGPIOOutput(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL);
	GPIOPinWrite(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL, BTN_OVERRIDE_CONTROL);
}

//*****************************************************************************
//
//! This is the code that gets called when the processor receives an unexpected
//! interrupt.  This simply enters an infinite loop, preserving the system
//! state for examination by a debugger.
//!
//! \return None.
//
//*****************************************************************************
void
IntDefaultHandler(void)
{
    //
    // Disable all interrupts.
    //
    IntMasterDisable();

    //
    // Turn off all the PWM outputs.
    //
    PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT | PWM_OUT_2_BIT |
                              PWM_OUT_3_BIT | PWM_OUT_4_BIT | PWM_OUT_5_BIT,
                              false);

    //
    // Turn on STATUS and MODE LEDs.  They will remain on.
    //
    BlinkStart(STATUS_LED, 1, 1, 1);
    BlinkStart(MODE_LED, 1, 1, 1);
    BlinkHandler();

    //
    // Go into an infinite loop.
    //
    while(1)
    {
    }
}

void ADC0IntHandler()
{

    unsigned long adc0Value;   // Holds the ADC result
    char adc0String[5];        // Holds the string-converted ADC result

    // 清ADC0中断标志.
    // ADCIntClear (unsigned long ulBase, unsigned long ulSequenceNum) 
    ADCIntClear(ADC0_BASE, 0);
    
    //从SSO读出转换结果 (FIFO0),本例中只有一个采样.如果要使用多个转换源,需要使用数组做为参数传递给API函数,保存FIFO转换结果.
    // long ADCSequenceDataGet (unsigned long ulBase,unsigned long ulSequenceNum,unsigned long *pulBuffer) 
    ADCSequenceDataGet(ADC0_BASE, 0, &adc0Value);
    adc0Value= ((59960 - (adc0Value * 100)) / 356);
    
    
    // 在OLED上显示当前温度
    usprintf(adc0String, "%d", adc0Value);    
    IntMasterDisable();
    RIT128x96x4StringDraw("Current temp :         ", 6, 48, 15);
    RIT128x96x4StringDraw(adc0String, 94, 48, 15);
    IntMasterEnable();  

    // ADC模块空闲,可以进行下一次转换
    adc_busy=0;    
 
}

//*****************************************************************************
//
// Main routine for the mouse.
//
//*****************************************************************************
void
USBMouseMain(void)
{
    //
    // Disable interrupts while changing the variables below.
    //
    IntMasterDisable();

    switch(sMouseState.eState)
    {
        case MOUSE_PENDING:
        {
            //
            // Send the report since there is one pending.
            //
            USBDHIDMouseStateChange((void *)&g_sMouseDevice,
                                    (uint8_t)sMouseState.i32X,
                                    (uint8_t)sMouseState.i32Y,
                                    sMouseState.ui8Buttons);
            //
            // Clear out the report data so that pending data does not
            // continually accumulate.
            //
            sMouseState.i32X = 0;
            sMouseState.i32Y = 0;

            if(sMouseState.ui8Buttons)
            {
                //
                // Need to always send out that all buttons are released.
                //
                sMouseState.ui8Buttons = 0;
                sMouseState.eState = MOUSE_SENDING_PEND;
            }
            else
            {
                //
                // Switch to sending state and wait for the transmit to be
                // complete.
                //
                sMouseState.eState = MOUSE_SENDING;
            }

            break;
        }
        case MOUSE_DISCONNECT:
        case MOUSE_SENDING:
        case MOUSE_SENDING_PEND:
        case MOUSE_IDLE:
        default:
        {
            break;
        }
    }

    //
    // Enable interrupts now that the main loop is complete.
    //
    IntMasterEnable();
}

//*****************************************************************************
//
// Change the value of a variable atomically.
//
// \param pui32Val points to the index whose value is to be modified.
// \param ui32Delta is the number of bytes to increment the index by.
// \param ui32Size is the size of the buffer the index refers to.
//
// This function is used to increment a read or write buffer index that may be
// written in various different contexts.  It ensures that the
// read/modify/write sequence is not interrupted and, hence, guards against
// corruption of the variable.  The new value is adjusted for buffer wrap.
//
// \return None.
//
//*****************************************************************************
static void
UpdateIndexAtomic(volatile uint32_t *pui32Val, uint32_t ui32Delta,
                  uint32_t ui32Size)
{
    bool bIntsOff;

    //
    // Turn interrupts off temporarily.
    //
    bIntsOff = IntMasterDisable();

    //
    // Update the variable value.
    //
    *pui32Val += ui32Delta;

    //
    // Correct for wrap.  We use a loop here since we don't want to use a
    // modulus operation with interrupts off but we don't want to fail in
    // case ui32Delta is greater than ui32Size (which is extremely unlikely
    // but...)
    //
    while(*pui32Val >= ui32Size)
    {
        *pui32Val -= ui32Size;
    }

    //
    // Restore the interrupt state
    //
    if(!bIntsOff)
    {
        IntMasterEnable();
    }
}

/************************************************************************************//**
** \brief     Disables the generation IRQ interrupts and stores information on
**            whether or not the interrupts were already disabled before explicitly
**            disabling them with this function. Normally used as a pair together
**            with IrqInterruptRestore during a critical section.
** \return    none.
**
****************************************************************************************/
void IrqInterruptDisable(void)
{
  if (interruptNesting == 0)
  {
    IntMasterDisable();
  }
  interruptNesting++;
} /*** end of IrqInterruptDisable ***/

//Print at x,y with given brightness
void oled_d_print_xyb(char *str, unsigned long x, unsigned long y, unsigned long b)
{
	IntMasterDisable();

	RIT128x96x4StringDraw(str, x, y, b);

	IntMasterEnable();
}

//Print at 0,0 with full brightness
void oled_d_print_origin(char *str)
{
	IntMasterDisable();

	RIT128x96x4StringDraw(str, 0, 0, MAX_BRIGHTNESS);

	IntMasterEnable();
}

//Clear the screen
void oled_d_clear(void)
{
	IntMasterDisable();

	RIT128x96x4Clear();

	IntMasterEnable();
}

/**************************************************************************//**
* @brief    Connect interrupt service routine to 32 kHz timer interrupt.
*
* @param    pFnHandle   Void function pointer to interrupt service routine
*
* @return   None
******************************************************************************/
void halTimer32kIntConnect(void (*pFnHandle)(void))
{
    tBoolean intDisabled = IntMasterDisable();
    SleepModeIntRegister(&halTimer32kIsr);  // Register function and
    IntDisable(INT_SMTIM);                  // disable SMTIM interrupts
    pFptr = pFnHandle;                      // Set custom ISR
    if(!intDisabled) IntMasterEnable();
}

//Print at x,y with full brightness
void oled_d_print_xy(char *str, unsigned long x, unsigned long y)
{
	IntMasterDisable();

	RIT128x96x4StringDraw(str, x, y, MAX_BRIGHTNESS);

	IntMasterEnable();
}

//##### INTERNAL BEGIN #####
//*****************************************************************************
//
// Send a wakup packet to the remote network processors UART interface.
//
// This function will send a NULL character to the UART interface repeatedly
// in order to awaken the RNP and cause it to start listening for UART packets.
//
// \return None.
//
//*****************************************************************************
void
RemoTIUARTWake(void)
{
#if 0
    bool bIntState;
    uint32_t ui32Ticks;

    //
    // Disable Master interrupts.  Record previous interrupt state to properly
    // restore it later.
    //
    bIntState = IntMasterDisable();

    //
    // Tick counter for tracking how many times we send the NULL character set.
    //
    ui32Ticks = 0;

    //
    // If the TX interrupt is enabled.  If it is assume UART is already
    // awake.  If it is not then wake up the UART on the RNP with a null char.
    //
    if((HWREG(g_ui32UARTBase + UART_O_IM) & 0x20) != UART_IM_TXIM);
    {
        do
        {
            //
            // Send consecutive NULL characters.
            //
            UARTCharPut(g_ui32UARTBase, 0);
            UARTCharPut(g_ui32UARTBase, 0);
            UARTCharPut(g_ui32UARTBase, 0);
            UARTCharPut(g_ui32UARTBase, 0);

            //
            // Delay 10 milliseconds to allow time for RNP to process and wake.
            //
            SysCtlDelay(SysCtlClockGet() / (100 * 3));
            ui32Ticks++;

        //
        // Send the NULL character set until we get a character back or we have
        // tried 10 times to get a response.
        //
        } while((ui32Ticks < 10) & (UARTCharsAvail(g_ui32UARTBase) == 0));
    }

    //
    // Restore the master interrupt enable to it previous state.
    //
    if(!bIntState)
    {
        IntMasterEnable();
    }
#endif // 0
}

static void flashEraseCallback(void)
{
    // Disable global interrupts
    IntMasterDisable();

    // Erase Flash CCA page
    FlashMainPageErase(CC2538_FLASH_CCA_ADDRESS);

    // Reset the board
    SysCtrlReset();
}

void HardwareInit()
{
  IntMasterDisable();
  //
  // Datasheet says use PLL if reading from ADC
  //
  SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ);
//  SysCtlClockSet(SYSCTL_SYSDIV_10 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_6MHZ);
  ConsoleInit(115200);
  A3906Init();
  SysTickInit(1000);
  RMBD01Init();
  IntMasterEnable();
}

static void clock_init(void)
{
    /**
     * Disable global interrupts
     */
    bool bIntDisabled = IntMasterDisable();

    /**
     * Configure the 32 kHz pins, PD6 and PD7, for crystal operation
     * By default they are configured as GPIOs
     */
    GPIODirModeSet(GPIO_D_BASE, 0x40, GPIO_DIR_MODE_IN);
    GPIODirModeSet(GPIO_D_BASE, 0x80, GPIO_DIR_MODE_IN);
    IOCPadConfigSet(GPIO_D_BASE, 0x40, IOC_OVERRIDE_ANA);
    IOCPadConfigSet(GPIO_D_BASE, 0x80, IOC_OVERRIDE_ANA);

    /**
     * Set the real-time clock to use the 32khz internal crystal
     * Set the system clock to use the external 32 MHz crystal
     * Set the system clock to 32 MHz
     */
    SysCtrlClockSet(true, false, SYS_CTRL_SYSDIV_32MHZ);

    /**
     * Set the IO clock to operate at 16 MHz
     * This way peripherals can run while the system clock is gated
     */
    SysCtrlIOClockSet(SYS_CTRL_SYSDIV_16MHZ);

    /**
     * Wait until the selected clock configuration is stable
     */
    while (!((HWREG(SYS_CTRL_CLOCK_STA)) & (SYS_CTRL_CLOCK_STA_XOSC_STB)));

    /**
     * Define what peripherals run in each mode
     */
    SysCtrlDeepSleepSetting();
    SysCtrlSleepSetting();
    SysCtrlRunSetting();
    SysCtrlWakeupSetting();

    /**
     * Re-enable interrupt if initially enabled.
     */
    if(!bIntDisabled)
    {
        IntMasterEnable();
    }
}