Example #1
0
//ISR INIT
void 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 ALLITVA
HWREG(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_EDGES
GPIOPinIntEnable(PUSHBUTTON_PORT, LEFT_SWITCH | RIGHT_SWITCH );
}
Example #2
0
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;
	}
}
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;
}
Example #4
0
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 ); 					  
}
Example #5
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 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);
    }
}
Example #7
0
/*----------------------------------------------------------------------------*/
void hw_portA_int_handler()
{
    unsigned char mask = GPIOPinIntStatus(GPIO_PORTA_BASE, NULL);
    if (mask & GPIO_PIN_7)
    {
        MAP_GPIOPinIntClear(GPIO_PORTA_BASE, GPIO_PIN_7 );
        DS1390_int_handler();
    }
    tn_int_exit();
}
Example #8
0
bool Extint::triggered()
{
    //is this external line generate the interrupt ?
    if ( (GPIOPinIntStatus(this->GpioPortBase, false) & this->GpioPin) == this->GpioPin)
    {
        return true;
    }
    else
    {
        return false;
    }
}
Example #9
0
void
IntGPIOHandler(void)
{
volatile int i;

// Handle select button interrupt
// Then clear the interrupt flag
	if (GPIOPinIntStatus(GPIO_PORTF_BASE, GPIO_PIN_1)) {
		GPIOPinIntClear(GPIO_PORTF_BASE, GPIO_PIN_1);
	}

// Make sure flags has time to clear before leaving ISR
	for(i=0;i<3;i++);
}
Example #10
0
/*----------------------------------------------------------------------------*/
void hw_portC_int_handler()
{
    unsigned char mask = GPIOPinIntStatus(GPIO_PORTC_BASE, NULL);

    if (mask & GPIO_PIN_4)
    {
    MAP_GPIOPinIntClear(GPIO_PORTC_BASE, GPIO_PIN_4 );
    }
    if (mask & GPIO_PIN_5)
    {
    MAP_GPIOPinIntClear(GPIO_PORTC_BASE, GPIO_PIN_5 );
    }
    tn_int_exit();
}
Example #11
0
void quad_encoder() {
	IntDisable(INT_GPIOC);
	long temp;
	
	temp = GPIOPinIntStatus( GPIO_PORTC_BASE, true);

	
	Display *disp = global_current_display(0);
	
	if( (disp->menu_type >> 4) < 2 ) {
		if(temp & 0x20) {
			push_encoder_button();
			delaymycode(10);
		}
		
		else if(temp & 0x80) {
			push_back_button();
			delaymycode(10);
		
		}
		
		else if( (temp & 0x10) || (temp & 0x40) ) {
			unsigned char curA = GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_4);
			unsigned char curB = GPIOPinRead(GPIO_PORTC_BASE, GPIO_PIN_6);
			Encoder_State* encoder = global_get_encoder();
			//(curA == 0)&&(curA != encoder->encoderA_last)&&(curB == encoder->encoderB_last)
			if( (curB) ) {
				
				turn_encoder_left();
				delaymycode(1);
				encoder->encoderA_last = curA;
				encoder->encoderB_last = curB;
				
			}
			//(curB == 0)&&(curB != encoder->encoderB_last)&&(curA == encoder->encoderA_last)
			else if( (~(encoder->encoderA_last ^ curB)) ) {
				turn_encoder_right();
				delaymycode(1);	
				encoder->encoderA_last = curA;
				encoder->encoderB_last = curB;
			}
		}	
	}
	
	else if ( (disp->menu_type >> 4) >= 2 ) {
Example #12
0
void  GPIO_Port_B_ISR (void)
{
    ulong ulStatus;
#if OS_CRITICAL_METHOD ==3
    OS_CPU_SR  cpu_sr;
#endif
    
    OS_ENTER_CRITICAL();
    OSIntNesting++;
    OS_EXIT_CRITICAL();
    
    ulStatus = GPIOPinIntStatus(GPIO_PORTB_BASE, true);        //    读取中断状态 
    GPIOPinIntClear(GPIO_PORTB_BASE, ulStatus);                //    清除中断状态,重要 
    
    if(ulStatus & GPIO_PIN_5)
    {
         OSSemPost(RNSemIsr);
    }
     OSIntExit();
}
Example #13
0
void TouchScreenIntHandler(void)
{
	GPIOPinIntClear(ADS7843_PORT_INT, ADS7843_PIN_INT);

	if(GPIOPinIntStatus(ADS7843_PORT_INT, false) & ADS7843_PIN_INT)
	{
		touchIntPinInterruptEnable(false);
		ADS7843touchPenIntHandler();
		if(ADS7843dataAvailable())
		{
		    // Enable Timer
		    touchScreenTimerEnable(true);
		    TOUCH_DEBUG("PEN_DOWN\r\n");
		}
		else
		{
			touchIntPinInterruptEnable(true);
		}

	}
}
Example #14
0
//ISR HANDLER
CTL_ISR_FN_t buttons_isr_handler(void)
{
int32u int_status;
int_status = GPIOPinIntStatus( PUSHBUTTON_PORT, 1 );
GPIOPinIntClear( PUSHBUTTON_PORT, int_status );
if(int_status & LEFT_SWITCH)
{
 if(GPIOPinRead(PUSHBUTTON_PORT, LEFT_SWITCH) == LEFT_SWITCH)
  ctl_events_set_clear(&button_events,0,L_BTN_PUSHED);
 else
  ctl_events_set_clear(&button_events,L_BTN_PUSHED,0);
}
if(int_status & RIGHT_SWITCH)
{
 if(GPIOPinRead(PUSHBUTTON_PORT, RIGHT_SWITCH) == RIGHT_SWITCH)
  ctl_events_set_clear(&button_events,0, R_BTN_PUSHED);
 else
  ctl_events_set_clear(&button_events,R_BTN_PUSHED,0);
}

}
// *******************************************************
// Interrupt handler for the port. This monitors GPIO pins
// and modifies the button_t type.
void buttonISR(void)
{
	//


	button_t* button;

	// Read the pin's digital state
	//long rawPinData = GPIOPinRead(button->ulPort, button->ucPin);
	//long rawPinData = GPIOPinRead(PORT_BASE_B,
	//		UP_B | DOWN_B | LEFT_B | RIGHT_B | SELECT_B);

	long rawPinData =  GPIOPinIntStatus(PORT_BASE_B,
			UP_B | DOWN_B | LEFT_B | RIGHT_B | SELECT_B);

	//long rawPinData =  GPIOPinIntStatus(PORT_BASE_B, 1);

	//transfer the current pin read to a more meaningful variable
	long pin = 0;// = 1 << (buttonPin + 3);

	//int pinState;

	long currentPin;  // loop through all the pins
	for (currentPin = UP; currentPin <= SELECT; currentPin++)
	{
		button = &buttonPointer[currentPin];

		switch(currentPin)
		{
		    case UP:
		        pin = UP_B;
		        break;
		    case DOWN:
		    	pin = DOWN_B;
		    	break;
		    case LEFT:
		    	pin = LEFT_B;
		    	break;
		    case RIGHT:
		    	pin = RIGHT_B;
		    	break;
		    case SELECT:
		    	pin = SELECT_B;
		    	break;
		    default:
		    	pin = 0;
		    	break;
		}

		// Don't do anything until pushed button has
		// been serviced by checkBut().
		if ((button->iState == BUT_PUSHED) || (button->iState == BUT_INACTIVE))
		{
			// Do nothing
		}
			// check for a button press.
		else if (rawPinData & pin)
		{
			button->iState = BUT_PUSHED;
		}
	}

	GPIOPinIntClear(PORT_BASE_B, LEFT_B | RIGHT_B | SELECT_B | UP_B | DOWN_B);
}