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

void main(void)	{	SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);	GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);	GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);	GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0); /* led */    GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);    GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);	GPIOIntTypeSet(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, GPIO_RISING_EDGE);	GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_RISING_EDGE);	GPIOPinIntEnable(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);	GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_1);	IntMasterEnable();    IntEnable(INT_GPIOE);    IntEnable(INT_GPIOF);    GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);    GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);    while(1)    	{    	}	}

void Keypad(void*data){  while (1)  {          // RIT128x96x4StringDraw(" KKEYPAD   ", 20, 80, 15);            keypad *myKey = (keypad*) data;       if (UpFlag){       *myKey->driveMotorSpeedInc=TRUE; UpFlag=FALSE;       }       if(globalCounter%500==0)       {                    GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_2);           IntEnable(INT_GPIOE);       }       if(DownFlag){       *myKey->driveMotorSpeedDec=TRUE;DownFlag=FALSE;       }       if(globalCounter%500==0)       {                    GPIOPinIntClear(GPIO_PORTD_BASE, GPIO_PIN_5);        IntEnable(INT_GPIOD);        }    vTaskDelay(500);  }}

//ISR INITvoid ctl_buttons_isr_init(CTL_ISR_FN_t fn){int en; int32u proba;en=ctl_global_interrupts_set(0);buttons_isr=fn;SysCtlPeripheralEnable(PUSHBUTTON_PERIPH);//UNLOCKOLNI KELL A PF0 REGISZTERT MERT NMI-RE VAN ALLITVAHWREG(PUSHBUTTON_PORT + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;HWREG(PUSHBUTTON_PORT + GPIO_O_CR) |= 0x01;HWREG(PUSHBUTTON_PORT + GPIO_O_LOCK) = 0;GPIODirModeSet(PUSHBUTTON_PORT, LEFT_SWITCH | RIGHT_SWITCH , GPIO_DIR_MODE_IN);GPIOPadConfigSet(PUSHBUTTON_PORT,LEFT_SWITCH | RIGHT_SWITCH , GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);GPIOPinIntDisable(PUSHBUTTON_PORT, LEFT_SWITCH | RIGHT_SWITCH);if((GPIOPinIntStatus(PUSHBUTTON_PORT, 1)) == LEFT_SWITCH ){ GPIOPinIntClear(PUSHBUTTON_PORT, LEFT_SWITCH );}if((GPIOPinIntStatus(PUSHBUTTON_PORT, 1)) == RIGHT_SWITCH ){ GPIOPinIntClear(PUSHBUTTON_PORT, RIGHT_SWITCH );}ctl_set_priority(PUSHBUTTON_IRQ_PRIORITY, 1);ctl_unmask_isr(PUSHBUTTON_IRQ_PRIORITY);ctl_global_interrupts_set(en);GPIOIntTypeSet(PUSHBUTTON_PORT, LEFT_SWITCH | RIGHT_SWITCH , GPIO_BOTH_EDGES); //GPIO_BOTH_EDGESGPIOPinIntEnable(PUSHBUTTON_PORT, LEFT_SWITCH | RIGHT_SWITCH );}

void IntWheelSensor(){	CPU_INT32U         ulStatusR_A;	CPU_INT32U         ulStatusL_A;	static CPU_INT08U CountL = 0;	static CPU_INT08U CountR = 0;	static CPU_INT08U data = 0;	ulStatusR_A = GPIOPinIntStatus(RIGHT_IR_SENSOR_A_PORT, DEF_TRUE);	ulStatusL_A = GPIOPinIntStatus(LEFT_IR_SENSOR_A_PORT, DEF_TRUE);        if (ulStatusR_A & RIGHT_IR_SENSOR_A_PIN)        {          GPIOPinIntClear(RIGHT_IR_SENSOR_A_PORT, RIGHT_IR_SENSOR_A_PIN);           /* Clear interrupt.*/          CountR = CountR + 1;        }        if (ulStatusL_A & LEFT_IR_SENSOR_A_PIN)        {          GPIOPinIntClear(LEFT_IR_SENSOR_A_PORT, LEFT_IR_SENSOR_A_PIN);          CountL = CountL + 1;        }	if((CountL >= Left_tgt) && (CountR >= Right_tgt))        {          data = 0x11;          Left_tgt = 0;          Right_tgt = 0;          CountL = 0;          CountR = 0;          BSP_MotorStop(LEFT_SIDE);          BSP_MotorStop(RIGHT_SIDE);        }        else if(CountL >= Left_tgt)        {          data = 0x10;          Left_tgt = 0;          CountL = 0;          BSP_MotorStop(LEFT_SIDE);        }        else if(CountR >= Right_tgt)        {          data = 0x01;          Right_tgt = 0;          CountR = 0;          BSP_MotorStop(RIGHT_SIDE);        }        return;}

// Interrupt handlervoid PinChangeIntHandler (void) {	unsigned long ul_A_Val;	unsigned long ul_B_Val;	int current_state;	// Clear the interrupt (documentation recommends doing this early)	GPIOPinIntClear (GPIO_PORTF_BASE, GPIO_PIN_7);	GPIOPinIntClear (GPIO_PORTF_BASE, GPIO_PIN_5);	ul_A_Val = GPIOPinRead (GPIO_PORTF_BASE, GPIO_PIN_7); // Read the pin	ul_B_Val = GPIOPinRead (GPIO_PORTF_BASE, GPIO_PIN_5);	if (!ul_A_Val){ //Check what state the pins at and assign that state to "current state"		if(!ul_B_Val){			current_state = 1;		}		else{			current_state = 2;		}	}	else{		if(ul_B_Val){			current_state = 3;		}		else{			current_state = 4;		}	}	// Check if the previous state is different from the current state.	// Determine what direction the encoder is spinning	if (current_state != prev_state){		if (abs(prev_state-current_state) == 1){			if(current_state>prev_state){				encoder_1 --;			}			else{				encoder_1 ++;			}		}		else{			if(current_state<prev_state){				encoder_1 --;			}			else{				encoder_1 ++;			}		}	}	prev_state = current_state; // Assign current state for next time the interrupt runs}

/* The handler for the GPIOPortB Pin4, Pin5 & Pin6 state change interrupt. */void portBIntHandler(void) {    //clear the interrupt    GPIOPinIntClear (GPIO_PORTB_BASE, (GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6));    int button;    //Read the state of the pins    //Select icon clicked to start/stop heli    if (!GPIOPinRead( GPIO_PORTB_BASE, GPIO_PIN_4 )) {    	xSemaphoreGiveFromISR( xBinarySelectSemaphore, pdFALSE );	}    //Up icon clicked    if (!GPIOPinRead( GPIO_PORTB_BASE, GPIO_PIN_5 )) {    	button = UP;    	xQueueSendFromISR( xButtonQueue, &button, NULL );	}    //Down icon clicked    if (!GPIOPinRead( GPIO_PORTB_BASE, GPIO_PIN_6 )) {    	button = DOWN;    	xQueueSendFromISR( xButtonQueue, &button, NULL );	}    //Reset icon clicked    if (!GPIOPinRead( GPIO_PORTB_BASE, GPIO_PIN_1 )) {		SysCtlReset();	}}

/** * Configures the used button as input source * Registers gpio_c interrupt.. */void button_init(){	GPIOPinTypeGPIOInput(BSP_BUTTON_BASE, BSP_USER_BUTTON);	GPIOIntTypeSet(BSP_BUTTON_BASE,BSP_USER_BUTTON,GPIO_FALLING_EDGE);	GPIOPortIntRegister(BSP_BUTTON_BASE,GPIO_C_Isr_Handler);	GPIOPinIntClear(BSP_BUTTON_BASE, BSP_USER_BUTTON);	GPIOPinIntEnable(BSP_BUTTON_BASE, BSP_USER_BUTTON);}

// *************** GPIO_SetInterruptTask *************** 					void GPIO_SetInterruptTask( GPIO_PORT_T port, GPIO_PIN_T pins,                            unsigned long int_type, unsigned long priority, 							void (*task)( void ) ){	unsigned long port_base = GPIO_PortBase[port];	// Set the interrupt task for the specified port and pins	if     ( pins & 0x01 ) GPIO_PinISR[port][0] = task;	else if( pins & 0x02 ) GPIO_PinISR[port][1] = task; 	else if( pins & 0x04 ) GPIO_PinISR[port][2] = task;	else if( pins & 0x08 ) GPIO_PinISR[port][3] = task;	else if( pins & 0x10 ) GPIO_PinISR[port][4] = task;	else if( pins & 0x20 ) GPIO_PinISR[port][5] = task;	else if( pins & 0x40 ) GPIO_PinISR[port][6] = task;	else if( pins & 0x80 ) GPIO_PinISR[port][7] = task;	// Set the event type and priority, and clear the interrupt	IntPrioritySet( GPIO_IntAssignment[port], priority );	 	GPIOIntTypeSet( port_base, pins, int_type );	GPIOPinIntClear( port_base, pins);	// Enable interrupts	IntEnable( GPIO_IntAssignment[port] ); 	GPIOPinIntEnable( port_base, pins );}

void vs_requesthandler(void){  unsigned int len, tail;  GPIOPinIntClear(GPIO_PORTA_BASE, GPIO_PIN_1);  len = vs_buflen();  if(len != 0)  {    if(len > 16)    {      len = 16;    }    vs_ssi_writewait(); //ssi transmit fifo full?    VS_DCS_DISABLE();    tail = vs_buftail;    VS_DCS_ENABLE();    for(; len!=0; len--)    {      vs_ssi_write(vs_buf.b8[tail]);      if(++tail == VS_BUFSIZE)      {        tail = 0;      }    }    vs_buftail = tail;  }  else  {    vs_pause();  }  return;}

void vs_pause(void){  GPIOPinIntDisable(GPIO_PORTA_BASE, GPIO_PIN_1); //disable dreq irq  GPIOPinIntClear(GPIO_PORTA_BASE, GPIO_PIN_1);  return;}

void GPIO_PortG_ISR( void ){ 	unsigned char int_status = 0;	GPIO_PIN_T    pin        = 0;	// Figure out which pin caused the interrupt	int_status = GPIOPinIntStatus( GPIO_PORTG_BASE, true );	if( int_status & 0x01 )      pin = 0;				  	else if( int_status & 0x02 ) pin = 1;	 	  	else if( int_status & 0x04 ) pin = 2;	  	else if( int_status & 0x08 ) pin = 3;	  	else if( int_status & 0x10 ) pin = 4;	 	else if( int_status & 0x20 ) pin = 5;	else if( int_status & 0x40 ) pin = 6;	else if( int_status & 0x80 ) pin = 7;	// Acknowledge and diable interrupts for this pin.   // GPIOPinIntDisable( GPIO_PORTG_BASE, int_status );     GPIOPinIntClear( GPIO_PORTG_BASE, int_status );  	// Call the task function for this pin's interrupt	GPIO_PinISR[GPIO_PORT_G][pin]();	// Enable interrupts for the pin. XXX Does this provide enough	// debouncing for GPIO interrupts? If not, we can set a flag in	// main that enables interrupts after a set amount of time.     //GPIOPinIntEnable( GPIO_PORTG_BASE, int_status ); 					  }

voidGPIOFIntHandler(void){    // Clear the GPIO interrupt.    GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);    y = 0;    // Counter for how long the snooze button was pressed    while (GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_1)==0){    	y++;       }    // If the snooze button was held long enough, add 5 minutes to the alarm    if (y>500000){    	int z;    	for (z=0; z<5; z++){    		IncrementTimeA();        }    }    // Clear the screen    RIT128x96x4Clear();    // Turn off the LED    GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);    // Turn off the alarm    PWMOutputState(PWM0_BASE, PWM_OUT_0_BIT | PWM_OUT_1_BIT, false);    PWMGenDisable(PWM0_BASE, PWM_GEN_0);    // Disable the interrupt so that snooze and turn off alarm cannot be used    GPIOPinIntDisable(GPIO_PORTF_BASE, GPIO_PIN_1);}

void PortBIntHandler (void)	// Interrupt handler called upon IR receive{	// Reset delay counter	waitTime=0;			// Turn on Status light upon first IR receive	GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_0,0x01);			// skip repeating IR pulse sequences	if(!checkProtocol())									return;			// 2 second delay between button presses		if(waitTime2 < 20000)								{		flag = 1;	}	else	{		flag = 0;	}				// parse IR pulse sequence data	getData();		// concatenate corresponding character to display buffer	decodeLetter(decode(string));		// clear interrupt	GPIOPinIntClear(GPIO_PORTB_BASE, GPIO_PIN_1);		// reset delay between button presses	waitTime2=0;}

void GPIO_PortF_IntHandler(void) {	GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_4);	GPIOPinIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4);	Encoder_Count++;	GPIOPinIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4);}

void GpioIn::enableInterrupts(void){    // Clear the interrupt    GPIOPinIntClear(gpio_.port, gpio_.pin);    // Enable the interrupt    GPIOPinIntEnable(gpio_.port, gpio_.pin);}

void SW_IntHandler(void){    GPIOPinIntClear(GPIO_PORTC_BASE, GPIO_PIN_5);    printf("Switch PUSH/r/n");    QEIPositionSet(QEI0_BASE, 0);}

void RF22_PinIntHandler(void){	if(GPIOPinIntStatus(RFM_22_PORT_INT, false) & RFM_22_PIN_INT)	{		RF22_isr0();	}	GPIOPinIntClear(RFM_22_PORT_INT, RFM_22_PIN_INT);}

void EncoderInterruptHandler(void){	int temp = 0;	unsigned char pin, pinA, pinB;	unsigned port;	signed dir;	volatile encoder_count_t *p_encCount;		if((GPIOPinIntStatus(port=GPIO_PORTC_BASE, false) & (pin=GPIO_PIN_5)))	{		// encoder 0 fired!		pinA = GPIO_PIN_5;		pinB = GPIO_PIN_4;		dir = dir0;		p_encCount = &enc0;	}	else if(GPIOPinIntStatus(port=GPIO_PORTB_BASE, false) & (pin=GPIO_PIN_4))	{		// encoder 0 fired!		pinA = GPIO_PIN_5;		pinB = GPIO_PIN_4;		dir = -dir0;		p_encCount = &enc0;	}	else if(GPIOPinIntStatus(port=GPIO_PORTC_BASE, false) & (pin=GPIO_PIN_6))	{		// encoder 1 fired!		pinA = GPIO_PIN_6;		pinB = GPIO_PIN_6;		dir = dir1;		p_encCount = &enc1;	} 	else if (GPIOPinIntStatus(port=GPIO_PORTB_BASE, false) & (pin=GPIO_PIN_6))	{		// encoder 1 fired!		pinA = GPIO_PIN_6;		pinB = GPIO_PIN_6;		dir = -dir1;		p_encCount = &enc1;	} else return;	GPIOPinIntClear(port, pin);		if(GPIOPinRead(GPIO_PORTC_BASE, pinA))	++temp;	// channel A	if(GPIOPinRead(GPIO_PORTB_BASE, pinB))	++temp;	// channel B	switch(temp)	{	case 0:	// both channels == 0	case 2:	// both channels == 1		// channel A == channel B		*p_encCount += dir;	// --> moving forward		break;	case 1:	// one channel == 1 and the other == 0		// channel A != channel B		*p_encCount -= dir;	// --> moving backward		break;	}}

/** 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 GPIO_3A_ISR(void){    if(GPIOPinIntStatus(SOC_GPIO_3_REGS, GPIO_INT_LINE_1, LCD_INT_PIN))    {    	LCD_Interrupt(FALSE);    	LCD_SetInterruptFlag();        GPIOPinIntClear(SOC_GPIO_3_REGS, GPIO_INT_LINE_1, LCD_INT_PIN);    }}

void vGPIO_ISR( void ){    portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;    /* Clear the interrupt. */    GPIOPinIntClear(GPIO_PORTC_BASE, mainPUSH_BUTTON);    /* Wake the button handler task. */    xSemaphoreGiveFromISR( xButtonSemaphore, &xHigherPriorityTaskWoken );    portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );}

void PortBIntHandler (void) // Interrupt handler called upon IR receive{		char str[10];	    // Reset delay counter    waitTime=0;             // skip repeating IR pulse sequences    if(!checkProtocol())		{				GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_0,0x00);			GPIOPinIntClear(GPIO_PORTB_BASE, GPIO_PIN_1);				//displayAccel();        return;		}    // 2 second delay between button presses        if(waitTime2 < 20000)                               {        flag = 1;    }    else    {        flag = 0;    }                // parse IR pulse sequence data    getData();    		    // concatenate corresponding character to display buffer    decodeLetter(decode(string));		RIT128x96x4StringDraw(display2, 0, 80, 15);        GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_0,0x01);      // reset delay between button presses    waitTime2=0;		GPIOPinIntClear(GPIO_PORTB_BASE, GPIO_PIN_1);		//displayAccel();}

void DataReadyIntHandler(void){	uint8_t p = ROM_GPIOPinIntStatus(ADS_DRY_PORT, true) & 0xFF;	MAP_IntDisable(INT_GPIOC);	MAP_GPIOPinIntDisable(ADS_DRY_PORT, ADS_DRY_PIN);	GPIOPinIntClear(ADS_DRY_PORT, p);	HWREGBITW(&g_ulFlags, FLAG_ADS_INT) = 1;}

void flipPancake(void) {	GPIOPinIntDisable(GPIO_PORTA_BASE, GPIO_PIN_2);	WaitUS(2000);	GPIOPinIntClear(GPIO_PORTA_BASE, GPIO_PIN_2);	if(!GPIOPinRead(GPIO_PORTA_BASE,GPIO_PIN_2))	{		UARTprintf("Triggered./n");		SetServoPosition(PANCAKE_POSITION,100*pancake);		pancake = !pancake;	}	GPIOPinIntEnable(GPIO_PORTA_BASE, GPIO_PIN_2);}

/***************************************************************************** *  INTERRUPT SERVICE ROUTINES *****************************************************************************/void ISR_Bumper(void){    // TODO: Doesn't differentiate between L or R bumper    // TODO: We should probably add debouncing    /* Clears Interrupt */    GPIOPinIntClear(GPIO_PORTE_BASE, (1 << 0) | (1 << 1));    bBumperPressed = true;    return;}

void SonarGPIOIntHandler(void) {	GPIOPinIntClear(GPIO_PORTD_BASE, GPIO_PIN_3);	if (GPIOPinRead(GPIO_PORTD_BASE, GPIO_PIN_3)) {		status = TIMING;		TIME(MAX_SONAR_TIME);	} else {		Sonar_Value = TimerValueGet(TIMER2_BASE, TIMER_A);		status = DELAY;		(*callback)(Sonar_Value);		TIME(MS(10));	}}

//This will be used to handle button presses calling for a bluetooth resetvoid onBoardInteruptHandle(void){	//double I2C1_BIT_DELAY=(SysCtlClockGet() / (100 * 3));	//100us	GPIOPinIntClear(GPIO_PORTF_BASE,GPIO_PIN_0|GPIO_PIN_4);	ResetBluetooth();	//This is an attempt at an I2C hard reset of all devices.	//Float SDA high, and toggle SCL through nine complete cycles at 100kHz (or slower). Then issue a STOP sequence	/*GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_7,0x80);	//SDA High	SysCtlDelay(I2C1_BIT_DELAY);	int i = 0;	for(i=0; i<9; i++){		GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6,0x40); 	//SCL High		SysCtlDelay(I2C1_BIT_DELAY);		GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6,0x00);	//SCL Low		SysCtlDelay(I2C1_BIT_DELAY);	}	GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6,0x00);	//SCL Low	SysCtlDelay(I2C1_BIT_DELAY);	GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_7,0x00);	//SDA Low	SysCtlDelay(I2C1_BIT_DELAY);	GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_6,0x40);	//SCL High	SysCtlDelay(I2C1_BIT_DELAY);	GPIOPinWrite(GPIO_PORTA_BASE,GPIO_PIN_7,0x80);	//SDA High	SysCtlDelay(I2C1_BIT_DELAY);*/	//Serious credit to the man who made the Arduino version of this. he gave me addresses and equations. Sadly Arduino obfuscates what really is happening	//Link posted on blog page	//gyro address = 0x68 not 0x69	/*GPIOPinConfigure(GPIO_PA7_I2C1SDA);	GPIOPinTypeI2C(GPIO_PORTA_BASE, GPIO_PIN_7);	//Set GPA7 as SDA	GPIOPinConfigure(GPIO_PA6_I2C1SCL);	GPIOPinTypeI2CSCL(GPIO_PORTA_BASE, GPIO_PIN_6);	//Set GPA6 as SCL	I2CMasterInitExpClk(I2C1_MASTER_BASE,SysCtlClockGet(),false);	//I think it operates at 100kbps	I2CMasterEnable(I2C1_MASTER_BASE);	//Initalize the accelerometer			Address = 0x53	GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3,0x02);	UARTSend(0xAB);	I2CTransmit(0x53,0x2D,0x00);	I2CTransmit(0x53,0x2D,0x10);	I2CTransmit(0x53,0x2D,0x08);	//Initalize the gyroscope				Address = 0x68	I2CTransmit(0x68,0x3E,0x00);	I2CTransmit(0x68,0x15,0x07);	I2CTransmit(0x68,0x16,0x1E);	I2CTransmit(0x68,0x17,0x00);	UARTSend(0xAC);*/	//SysCtlReset();		//This fixes the I2C but it's way to slow to be}

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

// ARM codevoid pinout_interrupt( void ) {  GPIOPinIntClear( PINOUT_PORT, PINOUT_MASK ); ///clear interrupt flag  if ( !GPIOPinRead( PINOUT_PORT, 1 << PIN_RESET ) ) {    mc_reset();  } else if ( !GPIOPinRead( PINOUT_PORT, 1 << PIN_FEED_HOLD ) ) {    sys.execute |= EXEC_FEED_HOLD;  } else if ( !GPIOPinRead( PINOUT_PORT, 1 << PIN_CYCLE_START ) ) {    sys.execute |= EXEC_CYCLE_START;  }}

void Pin_Int(void)	{		GPIOPinIntClear(GPIO_PORTE_BASE, GPIO_PIN_0);		if(g_ulcount==5)		{		g_ulcount=0;		GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5, 0);		SysCtlDelay(SysCtlClockGet() / 12);		GPIOPinWrite(GPIO_PORTC_BASE, GPIO_PIN_5, GPIO_PIN_5);		SysCtlDelay(SysCtlClockGet() / 12);		}		g_ulcount++;	}