C++ ROM_IntMasterEnable函数代码示例

void Timer0IntHandler(void){
	// Used to countdown from entered time

	// Clear the timer interrupt.
	ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

	// Check if time has been reached
	if(g_countdownTime == 0){
		ROM_IntMasterDisable();
		UARTprintf("Time's Up!\n\n");
		ROM_IntMasterEnable();
		ROM_TimerEnable(TIMER1_BASE, TIMER_A);
		ROM_TimerIntDisable(TIMER0_BASE, TIMER_A);
		return;
	}

	// Turn on LED
	ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, LED_RED);
	ROM_TimerEnable(TIMER2_BASE, TIMER_A);

	// Update the interrupt status on the display.
	ROM_IntMasterDisable();
	UARTprintf("    %i\n",g_countdownTime);
	ROM_IntMasterEnable();

	// Decrement counter
	g_countdownTime--;
	
	// Turn off LED
	//ROM_GPIOPinWrite(GPIO_PORTF_BASE, LED_RED, 0);
}

//*****************************************************************************
//
// The interrupt handler for the first timer interrupt.
//
//*****************************************************************************
void
Timer0IntHandler(void)
{
    char cOne, cTwo;

    //
    // Clear the timer interrupt.
    //
    ROM_TimerIntClear(TIMER0_BASE, TIMER_TIMA_TIMEOUT);

    //
    // Toggle the flag for the first timer.
    //
    HWREGBITW(&g_ui32Flags, 0) ^= 1;

    //
    // Use the flags to Toggle the LED for this timer
    //
    GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, g_ui32Flags << 1);

    //
    // Update the interrupt status on the display.
    //
    ROM_IntMasterDisable();
    cOne = HWREGBITW(&g_ui32Flags, 0) ? '1' : '0';
    cTwo = HWREGBITW(&g_ui32Flags, 1) ? '1' : '0';
    UARTprintf("\rT1: %c  T2: %c", cOne, cTwo);
    ROM_IntMasterEnable();
}

//*****************************************************************************
//
// This example application demonstrates the use of the timers to generate
// periodic interrupts.
//
//*****************************************************************************
int
main(void)
{
    //
    // Set the clocking to run directly from the crystal.
    //
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                       SYSCTL_XTAL_16MHZ);

    //
    // Initialize the UART and write status.
    //
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    GPIOPinConfigure(GPIO_PA0_U0RX);
    GPIOPinConfigure(GPIO_PA1_U0TX);
    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
    UARTStdioInit(0);
    UARTprintf("\033[2JTimers example\n");
    UARTprintf("T1: 0  T2: 0");

    //
    // Enable the peripherals used by this example.
    //
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER1);

    //
    // Enable processor interrupts.
    //
    ROM_IntMasterEnable();

    //
    // Configure the two 32-bit periodic timers.
    //
    ROM_TimerConfigure(TIMER0_BASE, TIMER_CFG_PERIODIC);
    ROM_TimerConfigure(TIMER1_BASE, TIMER_CFG_PERIODIC);
    ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, ROM_SysCtlClockGet());
    ROM_TimerLoadSet(TIMER1_BASE, TIMER_A, ROM_SysCtlClockGet() / 2);

    //
    // Setup the interrupts for the timer timeouts.
    //
    ROM_IntEnable(INT_TIMER0A);
    ROM_IntEnable(INT_TIMER1A);
    ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);

    //
    // Enable the timers.
    //
    ROM_TimerEnable(TIMER0_BASE, TIMER_A);
    ROM_TimerEnable(TIMER1_BASE, TIMER_A);

    //
    // Loop forever while the timers run.
    //
    while(1)
    {
    }
}

//*****************************************************************************
//
// This function is called to start an acquisition running.  It determines
// which channels are to be logged, enables the ADC sequencers, and computes
// the first RTC match value.  This will start the acquisition running.
//
//*****************************************************************************
void AcquireStart()
{
    unsigned long ulIdx;

    ulIdx = ulSelectedMask;
    g_ulNumItems = 0;
    while(ulIdx)
    {
        if(ulIdx & 1)
        {
            g_ulNumItems++;
        }
        ulIdx >>= 1;
    }



    //USBStickOpenLogFile(0);

    ROM_ADCSequenceEnable(ADC0_BASE,SEQUENCER);
    //ROM_ADCSequenceDataGet(ADC0_BASE,SEQUENCER,&g_ulADCData[0]);
    ROM_ADCIntClear(ADC0_BASE,SEQUENCER);

    ROM_ADCIntEnable(ADC0_BASE,SEQUENCER);
    ROM_IntEnable(INT_ADC0SS2);

    ROM_TimerEnable(TIMER0_BASE, TIMER_A);

    //ROM_IntEnable(INT_TIMER1A);
    //ROM_TimerIntEnable(TIMER1_BASE, TIMER_TIMA_TIMEOUT);
    //ROM_TimerEnable(TIMER1_BASE, TIMER_A);
    ROM_IntMasterEnable();
}

void board_init(void) {
	uint32_t clockfreq;
	ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
                       SYSCTL_XTAL_16MHZ);

	board_configure_led();
	console_init();
	board_spi_init();
	board_systick_init();
	board_watchdog_init();	
	timer_example_timer_init();	
	
	clockfreq = ROM_SysCtlClockGet();
	delayloopspermicrosecond = (ROM_SysCtlClockGet() / (uint32_t) 1e6) / 3;
	delayloopspermillisecond = (ROM_SysCtlClockGet() / (uint32_t) 1e3) / 3;

	console_printtext("\n\n\n***** TM4C   scheduler *****\n");
	console_printtext("**  System clock: %d MHz  **\n", ROM_SysCtlClockGet() / (uint32_t) 1e6);
	console_printtext("* Type 'help' for commands *\n");
	if (clockfreq < 3e6)
		console_printtext("WARNING: System clock is below 3 MHz, board timing might be inaccurate!\n");
	else 
		console_printtext("\n");
	
	ROM_IntMasterEnable();
}

void setup() {
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);

    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);

    ROM_FPULazyStackingEnable();
    ROM_FPUEnable();

    uart_setup();

    sd_init();
    dac_setup();
    keycontrol_setup();
    initConfig();
    tick_setup();    
    soundoutcontrol_setup();
    setupADC();
    setupUSBStore();
    initSampleBlocks();
    
    
    ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT);
    ROM_IntMasterEnable();

    DEBUG_PRINT("Setup complete\n", NULL);
}

//*****************************************************************************
//
// Given a destination buffer and a tStat pointer, this function will produce a
// formatted "request string" that can be used in the Exosite_Write function.
//
//*****************************************************************************
void
StatRequestFormat(tStat *psStat, char *pcRequestBuffer)
{
    if((psStat->eValueType) == STRING)
    {
        //
        // Disable interrupts to avoid changes to the string during the copy
        // operation.
        //
        ROM_IntMasterDisable();

        usprintf(pcRequestBuffer, "%s=%s",
                 psStat->pcCloudAlias,
                 StatStringVal(*psStat));

        ROM_IntMasterEnable();
    }
    else if((psStat->eValueType) == INT)
    {
        usprintf(pcRequestBuffer, "%s=%d",
                 psStat->pcCloudAlias,
                 StatIntVal(*psStat));
    }
    else if((psStat->eValueType) == HEX)
    {
        usprintf(pcRequestBuffer, "%s=0x%x",
                 psStat->pcCloudAlias,
                 StatIntVal(*psStat));
    }
}

// * enc_2_int_init ***********************************************************
// * setup interrupt from qei                                                 *
// * Assumes system clock already configured                                  *
// ****************************************************************************
void enc_2_int_init(void)
{
  ROM_IntMasterEnable();                                  // enable NVIC interrupts
  ROM_QEIIntEnable(ENC_2_BASE, ENC_2_INT_FLAGS);          // enable interrupt signal(s)
  ROM_IntEnable(ENC_2_INTVECT);                           // enable NVIC vector for our module
                                                          // interrupt now active, remember to clear on interrupt
}

//Initialize as a slave
void TwoWire::begin(uint8_t address)
{

    if(i2cModule == NOT_ACTIVE) {
        i2cModule = BOOST_PACK_WIRE;
    }

    ROM_SysCtlPeripheralEnable(g_uli2cPeriph[i2cModule]);
    ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][0]);
    ROM_GPIOPinConfigure(g_uli2cConfig[i2cModule][1]);
    ROM_GPIOPinTypeI2C(g_uli2cBase[i2cModule], g_uli2cSDAPins[i2cModule]);
    ROM_GPIOPinTypeI2CSCL(g_uli2cBase[i2cModule], g_uli2cSCLPins[i2cModule]);
    slaveAddress = address;

    //Enable slave interrupts
    ROM_IntEnable(g_uli2cInt[i2cModule]);
    I2CSlaveIntEnableEx(SLAVE_BASE, I2C_SLAVE_INT_DATA | I2C_SLAVE_INT_STOP);
    HWREG(SLAVE_BASE + I2C_O_SICR) =
        I2C_SICR_DATAIC | I2C_SICR_STARTIC | I2C_SICR_STOPIC;

    //Setup as a slave device
    ROM_I2CMasterDisable(MASTER_BASE);
    I2CSlaveEnable(SLAVE_BASE);
    I2CSlaveInit(SLAVE_BASE, address);

    ROM_IntMasterEnable();

}

void timerInit()
{

#if F_CPU >= 80000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 50000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 40000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 25000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_8|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 16200000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1|SYSCTL_USE_OSC|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);	//NOT PLL
#elif F_CPU >= 16100000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_1|SYSCTL_USE_OSC|SYSCTL_OSC_INT|
                SYSCTL_OSC_MAIN);	//NOT PLL, INT OSC
#elif F_CPU >= 16000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_12_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 10000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_20|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#elif F_CPU >= 8000000
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_25|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#else
    ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
                SYSCTL_OSC_MAIN);
#endif

    //
    //  SysTick is used for delay() and delayMicroseconds()
    //
//	ROM_SysTickPeriodSet(0x00FFFFFF);
    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
    ROM_SysTickEnable();

    //
    //Initialize Timer5 to be used as time-tracker since beginning of time
    //
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER5); //not tied to launchpad pin
    ROM_TimerConfigure(TIMER5_BASE, TIMER_CFG_PERIODIC_UP);

    ROM_TimerLoadSet(TIMER5_BASE, TIMER_A, ROM_SysCtlClockGet()/1000);

    ROM_IntEnable(INT_TIMER5A);
    ROM_TimerIntEnable(TIMER5_BASE, TIMER_TIMA_TIMEOUT);

    ROM_TimerEnable(TIMER5_BASE, TIMER_A);

    ROM_IntMasterEnable();

}

// Start the timers and interrupt frequency
void servoStart(void) {
    ROM_SysCtlPeripheralEnable(SERVO_TIMER_PERIPH);
    ROM_IntMasterEnable();
    ROM_TimerConfigure(SERVO_TIMER, TIMER_CFG_PERIODIC);
    ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, (ROM_SysCtlClockGet() / 1000000) * SERVO_TIMER_RESOLUTION);
    ROM_IntEnable(SERVO_TIMER_INTERRUPT);
    ROM_TimerIntEnable(SERVO_TIMER, SERVO_TIMER_TRIGGER);
    ROM_TimerEnable(SERVO_TIMER, SERVO_TIMER_A);
}

// * svm_int_init *************************************************************
// * setup counter reload interrupt from pwm generator for svm                *
// * Assumes system clock already configured                                  *
// ****************************************************************************
void svm_int_init(void)
{
  ROM_IntMasterEnable();                                    // enable NVIC interrupts
  ROM_PWMIntEnable(SVM_PWM_BASE, SVM_PWM_INT_GEN);          // enable interrupt assertion from our specific generator in module
  ROM_PWMGenIntTrigEnable(SVM_PWM_BASE, SVM_PWM_GEN, PWM_INT_CNT_LOAD);
                                                            // enable counter load interrupt from our generator
  ROM_IntEnable(SVM_PWM_GEN_INTVECT);                       // enable NVIC vector for our generator
                                                            // load interrupt for our generator is now active
}

//*****************************************************************************
//
// PoC2Repeater
//
//*****************************************************************************
int
main(void)
{
    // Set the clocking to run directly from the crystal at 120MHz.
    g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                             SYSCTL_OSC_MAIN |
                                             SYSCTL_USE_PLL |
                                             SYSCTL_CFG_VCO_480), 120000000);

    // Enable the peripherals
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART7);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);


    // Enable the GPIO pins for the LEDs (PN0 and PN1).
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0);
    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4);


	// ButtonsInit
    ROM_GPIODirModeSet(GPIO_PORTJ_BASE, ALL_BUTTONS, GPIO_DIR_MODE_IN);
    MAP_GPIOPadConfigSet(GPIO_PORTJ_BASE, ALL_BUTTONS,
                         GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);	

    // Enable processor interrupts.
    ROM_IntMasterEnable();

    // Set GPIO PC4 and PC5 as UART pins.
    GPIOPinConfigure(GPIO_PC4_U7RX);
    GPIOPinConfigure(GPIO_PC5_U7TX);
    ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);

    // Configure the UART for 115,200, 8-N-1 operation.
    ROM_UARTConfigSetExpClk(UART7_BASE, g_ui32SysClock, 115200,
                            (UART_CONFIG_WLEN_8 |
                             UART_CONFIG_STOP_ONE |
                             UART_CONFIG_PAR_NONE));

    // Enable the UART interrupt.
    ROM_IntEnable(INT_UART7);
    ROM_UARTIntEnable(UART7_BASE, UART_INT_RX | UART_INT_RT);
    
    // Reset message info
    for(uint8_t i = 0; i < MSG; i++)
    	message[i] = 0;

    // Loop forever echoing data through the UART.
    while(1)
    {
    }
}

//*****************************************************************************
//
// Delay for 5 us.
//
//*****************************************************************************
void delayFiveMicroseconds(uint32_t g_ui32SysClock) {
	//
	// Delay for 5 us. The value of the number provided to SysCtlDelay
	// is the number of loops (3 assembly instructions each) to iterate through.
	// Interrupts are disabled temporarily to ensure the pulse length is 5us.
	//
	ROM_IntMasterDisable();

	ROM_SysCtlDelay(g_ui32SysClock / 3 / 200000);

	ROM_IntMasterEnable();
}

ServoClass::ServoClass()
{
	ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|
	                SYSCTL_OSC_MAIN);

	// Initialize variables of the class

	g_ulPeriod = 0;

	for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
	{
		g_ulServoPins[il_iter] = INVALID_SERVO_PIN;
		g_ulServoPulse[il_iter] = DEFAULT_SERVO_PULSE_WIDTH;
	}

	g_iServoNo = 0;
	g_ulPulseWidth = 0;
	g_ulTicksPerMicrosecond = 0;

	setRefresh();

	//	for(int il_iter = 0; il_iter < SERVOS_PER_TIMER; il_iter++)
	//	{
	//		if (g_ulServoPins[il_iter] != INVALID_SERVO_PIN)
	//		{
	//			pinMode(g_ulServoPins[il_iter], OUTPUT);
	//			digitalWrite(g_ulServoPins[il_iter], LOW);
	//		}
	//	}

	// Enable TIMER
	ROM_SysCtlPeripheralEnable(SERVO_TIMER_PERIPH);

	// Enable processor interrupts.
	ROM_IntMasterEnable();

	// Configure the TIMER
	ROM_TimerConfigure(SERVO_TIMER, SERVO_TIME_CFG);

	// Calculate the number of timer counts/microsecond
	g_ulTicksPerMicrosecond = ROM_SysCtlClockGet() / 1000000;
	g_ulPeriod = g_ulTicksPerMicrosecond * REFRESH_INTERVAL;   // 20ms = Standard Servo refresh delay

	// Initially load the timer with 20ms interval time
	ROM_TimerLoadSet(SERVO_TIMER, SERVO_TIMER_A, g_ulPeriod);

	// Setup the interrupt for the TIMER1A timeout.
	ROM_IntEnable(SERVO_TIMER_INTERRUPT);
	ROM_TimerIntEnable(SERVO_TIMER, SERVO_TIMER_TRIGGER);

	// Enable the timer.
	ROM_TimerEnable(SERVO_TIMER, SERVO_TIMER_A);
}