自学教程：C++ GPIOIntClear函数代码示例

void ButtonHandler(){	uint32_t mask=GPIOIntStatus(GPIO_PORTF_BASE,false);	uint8_t value=0;	if(mask & GPIO_PIN_4){		//Boton izquierdo		value= GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4);		if(value==0){			//boton pulsado			// Activa el Timer4A (empezara a funcionar)			TimerEnable(TIMER4_BASE, TIMER_A);			pulsacionLarga=true;		}else{			TimerDisable(TIMER4_BASE,TIMER_A);			if(pulsacionLarga){				xEventGroupSetBits(xEventGroup, PilotoAutomaticoBit);				if((xTaskCreate(PilAuto, (signed portCHAR *)"Piloto Auto", LED1TASKSTACKSIZE,NULL,tskIDLE_PRIORITY + 1, &PilautTaskHandle) != pdTRUE))				{					while(1);				}			}		}	}	if(mask & GPIO_PIN_0){		//boton derecho		xEventGroupClearBits( xEventGroup, PilotoAutomaticoBit );	}	GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4);}

//*****************************************************************************////! This is the Pulse Per Second (PPS) interrupt handler.//! The updateCounter is incremented on each Pulse per second call, if equal to//! the update rate, the GPS data is parsed and logged.////*****************************************************************************void PortKIntHandler(void) {    uint32_t intStatus = 0;    //    // Get the current interrupt status for Port K    //    intStatus = GPIOIntStatus(GPIO_PORTK_BASE,true);    //    // Clear the set interrupts for Port K    //    GPIOIntClear(GPIO_PORTK_BASE,intStatus);    //    // Execute code for PK2 interrupt    //    if((intStatus & GPIO_INT_PIN_2) == GPIO_INT_PIN_2){        if (updateRate == updateCounter++) {            GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0x02);            gpsData();            GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0x00);            updateCounter = 0;            //            // Disable PPS interrupt after one read if in low power mode            //            if (lowPowerOn == 1) {                IntDisable(INT_GPIOK);                logComplete = 1;            }        }    }} // End function PortKIntHandler

void confGPIO(){	//Inicializa el puerto F (LEDs) --> No hace falta si usamos la libreria RGB	 //   ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);	 // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);	//ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0);	//LEDS APAGADOS	ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);	GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);	SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE);	//Inicializa los LEDs usando libreria RGB	RGBInit(1);	SysCtlPeripheralSleepEnable(GREEN_TIMER_PERIPH);	SysCtlPeripheralSleepEnable(BLUE_TIMER_PERIPH);	RGBEnable();	//Inicializamos los botones y su interrupción	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);	ButtonsInit();	GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4);	GPIOIntRegister(GPIO_PORTF_BASE,ButtonHandler);	GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_INT_PIN_0|GPIO_INT_PIN_4, GPIO_BOTH_EDGES);	GPIOIntEnable(GPIO_PORTF_BASE, GPIO_INT_PIN_0|GPIO_INT_PIN_4);	SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF);}

void mode2unset(){	GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);		//Clear any existing interrupts	GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4);		//Enable the GPIO Interrupts on Port F	IntDisable(INT_TIMER1A);	TimerIntDisable(TIMER1_BASE,TIMER_TIMA_TIMEOUT);}

/** * @brief	interrupt handler, updates timer, when fired * * */void PIOINT1_IRQHandler(void){    GPIOIntClear( TRIG_IN_PORT_1, TRIG_IN_PIN_1);    /* detect change time */    timeLast1 = timeEdge1;    timeEdge1 = millis();}

//definition of isr for PORT Fvoid GPIO_PORTF_isr(void){	uint32_t actual_GPIO_PORTF_status=((GPIO_PIN_0 | GPIO_PIN_4) & ~GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0 | GPIO_PIN_4));	switch (actual_GPIO_PORTF_status)	{	case GPIO_PIN_4:																			//if SW1 is pressed		ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_PIN_1);								//turn on RED LED		UARTprintf("RED LED on/n/r");	break;	case GPIO_PIN_0:																			//if SW2 is pressed		ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);								//turn on BLUE LED		UARTprintf("BLUE LED on/n/r");	break;	case (GPIO_PIN_0|GPIO_PIN_4):																//either SW1 and SW2 are pressed		ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1, GPIO_PIN_2 | GPIO_PIN_1);	//turn on RED & BLUE LEDs		UARTprintf("RED & BLUE LEDs on/n/r");	break;	default:																					//neither SW1 nor SW2 are pressed		ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2 | GPIO_PIN_1 , 0);							//turn off RED & BLUE LEDs		UARTprintf("RED & BLUE LEDs off/n/r");	break;	}	GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_0 | GPIO_INT_PIN_4);}

//*****************************************************************************//// Called by the NVIC as a result of GPIO port E interrupt event. For this// application GPIO port E pin 5 is the interrupt line for the ISL29023//// Notifies the application that light is outside of threshold limits.// Task will poll the semaphore and adjust the ranges accordingly.////*****************************************************************************voidIntHandlerGPIOPortE(void){    unsigned long ulStatus;    portBASE_TYPE xHigherPriorityTaskWoken;    ulStatus = GPIOIntStatus(GPIO_PORTE_BASE, true);    //    // Clear all the pin interrupts that are set    //    GPIOIntClear(GPIO_PORTE_BASE, ulStatus);    if(ulStatus & GPIO_PIN_5)    {        //        // ISL29023 has indicated that the light level has crossed outside of        // the intensity threshold levels set in INT_LT and INT_HT registers.        //        xSemaphoreGiveFromISR(g_xISL29023AdjustRangeSemaphore,                              &xHigherPriorityTaskWoken);        //        // If the give of this semaphore causes a task to be ready then        // make sure it has opportunity to run immediately upon return from        // this ISR.        //        if(xHigherPriorityTaskWoken == pdTRUE)        {            portYIELD_FROM_ISR(true);        }    }}

void decodeMatrixInput() {	SysCtlDelay(1000000); // debounce wait	uint32_t input = GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);	if ((input & 0xF0) != 0xF0) // try to decode if something is pushed.		{			int i, row = -1, col = -1;			for (i = 1; i < 5; i++) // get row			{				if (!(input & (8 << i)))					row = i - 1;			}			for(i = 0; i < 4; i++) // get col			{				GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5, 4 << i);				if (GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7) & (16 << row))				{					col = i;					break;				}			}			if (col != -1 && row != -1)				activePattern = row * 4 + col; // get the char of the button.		}	GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5, 0);	GPIOIntClear(GPIO_PORTC_BASE, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);	SysCtlDelay(1000000); // wait to allow button to be lifted}

/** * @brief	interrupt handler, updates timer, when fired * * */void PIOINT2_IRQHandler(void){    GPIOIntClear( TRIG_IN_PORT_2, TRIG_IN_PIN_2);    /* detect change time */    timeLast2 = timeEdge2;    timeEdge2 = millis();}

//*****************************************************************************//// Called by the NVIC as a result of GPIO port M interrupt event. For this// application GPIO port M pin 3 is the interrupt line for the MPU9150//// For BoosterPack 2 Interface use Port M pin 7.////*****************************************************************************voidGPIOPortMIntHandler(void){    unsigned long ulStatus;    //    // Get the status flags to see which pin(s) caused the interrupt.    //    ulStatus = GPIOIntStatus(GPIO_PORTM_BASE, true);    //    // Clear all the pin interrupts that are set    //    GPIOIntClear(GPIO_PORTM_BASE, ulStatus);    //    // Check if this is an interrupt on the MPU9150 interrupt line.    //    // For BoosterPack 2 use Pin 7 instead.    //    if(ulStatus & GPIO_PIN_3) {        //        // Turn on the LED to show that transaction is starting.        //        LEDWrite(CLP_D3 | CLP_D4, CLP_D3);        //        // MPU9150 Data is ready for retrieval and processing.        //        MPU9150DataRead(&g_sMPU9150Inst, MPU9150AppCallback, &g_sMPU9150Inst);    }}

/***************************************************** * 	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);}

void mode2set(){	GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);		//Clear any existing interrupts	GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4);		//Enable the GPIO Interrupts on Port F	TimerLoadSet(TIMER1_BASE, TIMER_A,SysCtlClockGet()/3);	//Set the Max Value of the timer	IntEnable(INT_TIMER1A);	TimerIntEnable(TIMER1_BASE,TIMER_TIMA_TIMEOUT);	//Enable Timer1 Interrupt}

/** Port E interrupt service routine@note Must be configured in startup_ccs.c or else will not be called.*/void IntGPIOe(void){    buttonIsr(0);   // Button 0 was pressed#ifdef TIVA    GPIOIntClear(GPIO_PORTE_BASE, GPIO_PIN_4);					//Clear interrupts#else    GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_4);					//Clear interrupts#endif}

void Interrupt_PB3Init(void){		GPIOIntRegister(GPIO_PORTB_BASE,Interrupt_PB3Handler);		ROM_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_3);		ROM_GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);		GPIOIntDisable(GPIO_PORTB_BASE,GPIO_INT_PIN_3);	  GPIOIntClear(GPIO_PORTB_BASE,GPIO_INT_PIN_3);		GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_INT_PIN_3,GPIO_LOW_LEVEL);}

void onButtonUp(void) {    if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) {        // PF4 was interrupt cause        printf("Button Up/n");        GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown); // Register our handler function for port F        GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_FALLING_EDGE);         // Configure PF4 for falling edge trigger        GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);  // Clear interrupt flag    }}

// Interrupt handler for the GPIO motion detector signalvoid GPIOMotionDetectorIsr(void) {	GPIOIntClear(GPIO_PORTA_BASE, GPIO_INT_PIN_2 | GPIO_INT_PIN_5);#ifdef RUN_AS_MASTER	motionDetectorTrigged = 1;#else	IRIntHandler();#endif}

//Called when detect SRDY goes low first  void  POLL(){	//MRDY Goes LOW (assuming SRDY is LOW)		MRDY_write(0);	//Send POLL command to CC2530	//TODO: Check if the the Type data is also Zero   		uint8_t *nullByte = (uint8_t *)malloc(1);		nullByte = "";			SPI_transfer(nullByte,1);		//free(nullByte);	//Start To Recieve Data when SRDY goes HIGH		uint8_t *RX_data  = malloc(254);		uint16_t count = 0;		while (!SRDY_read()){			SPI_receive(RX_data+count,1);			count++;		}	//call a management function		//Give the data return from function to cc2530			//Here We call the registerd function to provide dataToReturn			commandPasre(RX_data);		//MRDY Goes HIGH			MRDY_write(1);		free(RX_data);		//Clear Interrupt		//GPIO_PORTA_ICR_R = 0xFFFFFFFF;		GPIOIntClear(GPIO_PORTA_BASE,0x00000080);/*		SPI_receive(RX_data,1);		length = *RX_data;		free(RX_data);		RX_data= malloc(sizeof(length+3));		RX_data[0] = length;		SPI_receive(RX_data+1,length+2);*/}

void interrupt_handler(void){  GPIOIntClear(GPIO_PORTB_BASE, GPIO_INT_PIN_2);  if(GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_2) == 0x0) {    isr_flag = 1;  }}

void interrupt_handler(void){	GPIOIntClear(GPIO_PORTF_BASE, GPIO_INT_PIN_2 | GPIO_INT_PIN_3);		if(GPIOPinRead(port_F, GPIO_PIN_2) == 0x0) { 		display_flag = 1;	} }

void brakeHandler(){	GPIOIntClear(GPIO_PORTB_BASE, GPIO_INT_PIN_0);	if(GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_0) == 0x0)	{		enableSys = 0;	}}

/* *  ======== WiFiCC3100_open ======== */WiFi_Handle WiFiCC3100_open(WiFi_Handle handle, unsigned int spiIndex,	WiFi_evntCallback evntCallback, WiFi_Params *params){    unsigned int              key;    WiFiCC3100_Object        *object = handle->object;    WiFiCC3100_HWAttrs const *hwAttrs = handle->hwAttrs;    union {#if !defined(MSP430WARE)        Hwi_Params            hwiParams;#endif        Semaphore_Params      semParams;    } paramsUnion;    key = Hwi_disable();    if (object->isOpen) {        Hwi_restore(key);        Log_warning0("WiFi Hwi already in use.");        return (NULL);    }    object->isOpen = true;    Hwi_restore(key);    /* Construct semaphores to block read/write transactions. */    Semaphore_Params_init(&(paramsUnion.semParams));    paramsUnion.semParams.mode = Semaphore_Mode_BINARY;    paramsUnion.semParams.instance->name = "WiFi.writeSemaphore";    Semaphore_construct(&(object->writeSemaphore), 0, &(paramsUnion.semParams));    paramsUnion.semParams.instance->name = "WiFi.readSemaphore";    Semaphore_construct(&(object->readSemaphore), 0, &(paramsUnion.semParams));#if !defined(MSP430WARE)    Hwi_Params_init(&(paramsUnion.hwiParams));    paramsUnion.hwiParams.arg = (UArg) handle;    paramsUnion.hwiParams.enableInt = false;    /* Hwi_construct cannot fail, use NULL instead of an Error Block */    Hwi_construct(&(object->wifiHwi), hwAttrs->irqIntNum,	    WiFiCC3100_hostIntHandler, &(paramsUnion.hwiParams), NULL);#endif#if defined(MSP430WARE) || defined(MSP432WARE)    MAP_GPIO_clearInterruptFlag(hwAttrs->irqPort, hwAttrs->irqPin);    MAP_GPIO_enableInterrupt(hwAttrs->irqPort, hwAttrs->irqPin);#else    GPIOIntClear(hwAttrs->irqPort, hwAttrs->irqPin);    GPIOIntEnable(hwAttrs->irqPort, hwAttrs->irqPin);#endif    /* Store SPI interface parameters */    object->spiIndex = spiIndex;    object->bitRate = params->bitRate;    return (handle);}

void onButtonDown(void) {    if (GPIOIntStatus(GPIO_PORTF_BASE, false) & GPIO_PIN_4) {      	/*The GPIOIntStatus returns the value of the GPIORIS register and in this case,     AND's it with the Pin 4 mask. So if the condition for the interrupt has occurred for the Pin then the if statement is true.*/        // PF4 was interrupt cause        printf("Button Down/n");        GPIOIntRegister(GPIO_PORTF_BASE, onButtonUp);   // Register our handler function for port F        GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4, GPIO_RISING_EDGE);          // Configure PF4 for rising edge trigger        GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);  // Clear interrupt flag    }}

void PIOINT0_IRQHandler(void){  uint32_t regVal;  regVal = GPIOIntStatus( PORT0, 7 );  if ( regVal )  {	SingleResponseIsr();	GPIOIntClear( PORT0, 7 );  }		  return;}

void interrupt_setup(void){    // Interrupt setuü    GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4);        // Disable interrupt for PF4 (in case it was enabled)    GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);      // Clear pending interrupts for PF4    GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown);     // Register our handler function for port F    GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4,        GPIO_FALLING_EDGE);             // Configure PF4 for falling edge trigger    GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4);     // Enable interrupt for PF4}

/** Port F interrupt service routine@note Must be configured in startup_ccs.c or else will not be called.*/void IntGPIOf(void){    uint32_t buttonState = GPIOPinRead(GPIO_PORTF_BASE, ALL_BUTTONS);    if ((~buttonState) & LEFT_BUTTON)        buttonIsr(1);    else if ((~buttonState) & RIGHT_BUTTON)        buttonIsr(2);#ifdef TIVA    GPIOIntClear(GPIO_PORTF_BASE, ALL_BUTTONS);                   //Clear interrupts#else    GPIOPinIntClear(GPIO_PORTF_BASE, ALL_BUTTONS);                   //Clear interrupts#endif}

/******************************************************************************* Function name:		PIOINT2_IRQHandler**** Descriptions:		Use one GPIO pin(port2 pin1) as interrupt source**** parameters:			None** Returned value:		None** *****************************************************************************/void PIOINT2_IRQHandler(void){  uint32_t regVal;  gpio2_counter++;  regVal = GPIOIntStatus( PORT2, 1 );  if ( regVal )  {	p2_1_counter++;	GPIOIntClear( PORT2, 1 );  }		  return;}

/******************************************************************************* Function name:		PIOINT1_IRQHandler**** Descriptions:		Use one GPIO pin(port1 pin1) as interrupt source**** parameters:			None** Returned value:		None** *****************************************************************************/void PIOINT1_IRQHandler(void){  uint32_t regVal;  gpio1_counter++;  regVal = GPIOIntStatus( PORT1, 4 );  if ( regVal )  {	p1_1_counter++;	GPIOIntClear( PORT1, 4 );  }		  return;}

//Button interrupt handlervoid interrupt_handler(void){    //Clear the interrupt ports  GPIOIntClear(GPIO_PORTC_BASE, GPIO_INT_PIN_5 | GPIO_INT_PIN_6);    if(GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_5) == 0x20){    frequency -= 10000;}  if(GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_6) == 0x40){    frequency += 10000;}        //Set new timer frequency    TimerLoadSet(TIMER0_BASE, TIMER_A, frequency);}

/************ FUNCTION DEFINITIONS ****************/void modeselect(void){	if(GPIOIntStatus(GPIO_PORTF_BASE,false) & GPIO_INT_PIN_0)	{		GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_0);		for(i=0;i<2000;i++);		if (GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_0)==0)		{			mode++;			if (mode==6)				mode = 1;			switch(mode)	//According to mode, initialize peripherals and disable other peripherals			{			case 1:	mode2unset(); mode3unset();	mode4unset();	mode5unset();	mode1set();	break;			case 2: mode1unset(); mode3unset();	mode4unset();	mode5unset();	mode2set();	break;			case 3: mode2unset(); mode1unset();	mode4unset();	mode5unset();	mode3set();	break;			case 4: mode2unset(); mode1unset();	mode3unset();	mode5unset();	mode4set();	break;			case 5: mode2unset(); mode1unset();	mode4unset();	mode3unset();	mode5set();	break;			}		}	}	if((GPIOIntStatus(GPIO_PORTF_BASE,false)&GPIO_INT_PIN_4)&& (mode==2||mode==5))	{		GPIOIntClear(GPIO_PORTF_BASE,GPIO_PIN_4);		if(!GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_4))		{			mode2();			TimerLoadSet(TIMER1_BASE, TIMER_A,SysCtlClockGet()/3);	//Set the Max Value of the timer			TimerEnable(TIMER1_BASE,TIMER_A);	//Start the timer		}		else		{			TimerDisable(TIMER1_BASE,TIMER_A);			fast_flag=0;		}	}}

/* * This is the interrupt handler for the button that changes the LEDs brightness */void PortFIntHandler(){  uint32_t status=0;  status = GPIOIntStatus(GPIO_PORTF_BASE,true);  GPIOIntClear(GPIO_PORTF_BASE,status);  if( GPIOPinRead(GPIO_PORTF_BASE,GPIO_PIN_1) == 0)	  Maxbrilho = 255;  else	  Maxbrilho = 50;  MudaPadrao = 1;}