__interrupt void TA0_ISR(void)
{
  __bic_SR_register_on_exit(CPUOFF);        // Exit LPM0
}
Beispiel #2
0
__interrupt VOID iUsbInterruptHandler(VOID)
{
    BYTE bWakeUp = FALSE;
    //Check if the setup interrupt is pending.
    //We need to check it before other interrupts,
    //to work around that the Setup Int has lower priority then Input Endpoint 0
    if (USBIFG & SETUPIFG)
    {
        bWakeUp = SetupPacketInterruptHandler();  
        USBIFG &= ~SETUPIFG;    // clear the interrupt bit
    }   
    switch (__even_in_range(USBVECINT & 0x3f, USBVECINT_OUTPUT_ENDPOINT7))
    {
    case USBVECINT_NONE:
      break;
    case USBVECINT_PWR_DROP:
      __no_operation();
      break;
    case USBVECINT_PLL_LOCK:
      break;
    case USBVECINT_PLL_SIGNAL:
      break;
    case USBVECINT_PLL_RANGE:
      if (wUsbEventMask & kUSB_clockFaultEvent)
      {
          bWakeUp = USB_handleClockEvent();
      }
      break;
    case USBVECINT_PWR_VBUSOn:
      PWRVBUSonHandler();
      if (wUsbEventMask & kUSB_VbusOnEvent)
      {
          bWakeUp = USB_handleVbusOnEvent();
      }
      break;
    case USBVECINT_PWR_VBUSOff:
      PWRVBUSoffHandler();
      if (wUsbEventMask & kUSB_VbusOffEvent)
      {
          bWakeUp = USB_handleVbusOffEvent();
      }
      break;
    case USBVECINT_USB_TIMESTAMP:
      break;
    case USBVECINT_INPUT_ENDPOINT0:
      IEP0InterruptHandler();
      break;
    case USBVECINT_OUTPUT_ENDPOINT0:
      OEP0InterruptHandler();
      break;
    case USBVECINT_RSTR:
      USB_reset();
      if (wUsbEventMask & kUSB_UsbResetEvent)
      {
          bWakeUp = USB_handleResetEvent();
      }
      break;
    case USBVECINT_SUSR:
      USB_suspend();
      if (wUsbEventMask & kUSB_UsbSuspendEvent)
      {
          bWakeUp = USB_handleSuspendEvent();
      }
      break;
    case USBVECINT_RESR:
      USB_resume();
      if (wUsbEventMask & kUSB_UsbResumeEvent)
      {
          bWakeUp = USB_handleResumeEvent();
      }
      //-- after resume we will wake up! Independ what event handler says.
      bWakeUp = TRUE;
      break;
    case USBVECINT_SETUP_PACKET_RECEIVED:
      // NAK both IEP and OEP enpoints
      tEndPoint0DescriptorBlock.bIEPBCNT = EPBCNT_NAK;
      tEndPoint0DescriptorBlock.bOEPBCNT = EPBCNT_NAK;
      SetupPacketInterruptHandler();
      break;
    case USBVECINT_STPOW_PACKET_RECEIVED:
      break;
    case USBVECINT_INPUT_ENDPOINT1:
      break;
    case USBVECINT_INPUT_ENDPOINT2:
      //send saved bytes from buffer...
      bWakeUp = CdcToHostFromBuffer(CDC0_INTFNUM);
            break;
    case USBVECINT_INPUT_ENDPOINT3:
      break;
    case USBVECINT_INPUT_ENDPOINT4:
      break;
    case USBVECINT_INPUT_ENDPOINT5:
      break;
    case USBVECINT_INPUT_ENDPOINT6:
      break;
    case USBVECINT_INPUT_ENDPOINT7:
      break;
    case USBVECINT_OUTPUT_ENDPOINT1:
      break;
    case USBVECINT_OUTPUT_ENDPOINT2:
      //call callback function if no receive operation is underway
      if (!CdcIsReceiveInProgress(CDC0_INTFNUM) && USBCDC_bytesInUSBBuffer(CDC0_INTFNUM))
      {
          if (wUsbEventMask & kUSB_dataReceivedEvent)
          {
              bWakeUp = USBCDC_handleDataReceived(CDC0_INTFNUM);
          }
      }
      else
      {
          //complete receive opereation - copy data to user buffer
          bWakeUp = CdcToBufferFromHost(CDC0_INTFNUM);
      }

      break;
    case USBVECINT_OUTPUT_ENDPOINT3:
      break;
    case USBVECINT_OUTPUT_ENDPOINT4:
      break;
    case USBVECINT_OUTPUT_ENDPOINT5:
      break;
    case USBVECINT_OUTPUT_ENDPOINT6:
      break;
    case USBVECINT_OUTPUT_ENDPOINT7:
      break;
    default:
      break;
    }
    if (bWakeUp)
    {
    	 __bic_SR_register_on_exit(LPM3_bits);   // Exit LPM0-3
    	 __no_operation();                       // Required for debugger
    }
}
Beispiel #3
0
interrupt(USCI_A1_VECTOR) USCI_A1_ISR (void)
{
  halUsbReceiveBuffer[bufferSize++] = UCA3RXBUF;
   __bic_SR_register_on_exit(LPM3_bits);   
}
Beispiel #4
0
__interrupt void PORT2_ISR(void)
#endif
{
	u8 int_flag, int_enable;
	u8 buzzer = 0;
	u8 simpliciti_button_event = 0;
	static u8 simpliciti_button_repeat = 0;

	// Clear button flags
	button.all_flags = 0;

	// Remember interrupt enable bits
	int_enable = BUTTONS_IE;

	// Store valid button interrupt flag
	int_flag = BUTTONS_IFG & int_enable;

	// ---------------------------------------------------
	// While SimpliciTI stack is active, buttons behave differently:
	//  - Store button events in SimpliciTI packet data
	//  - Exit SimpliciTI when button DOWN was pressed 
  	if (is_rf())
  	{
  		// Erase previous button press after a number of resends (increase number if link quality is low)
  		// This will create a series of packets containing the same button press
  		// Necessary because we have no acknowledge
  		// Filtering (edge detection) will be done by receiver software
  		if (simpliciti_button_repeat++ > 6) 
  		{
  			simpliciti_data[0] &= ~0xF0;
  			simpliciti_button_repeat = 0;
  		}
  		
  		if ((int_flag & BUTTON_STAR_PIN) == BUTTON_STAR_PIN)			
  		{
  			simpliciti_data[0] |= SIMPLICITI_BUTTON_STAR;
  			simpliciti_button_event = 1;
  		}
  		else if ((int_flag & BUTTON_NUM_PIN) == BUTTON_NUM_PIN)	
  		{
  			simpliciti_data[0] |= SIMPLICITI_BUTTON_NUM;
  			simpliciti_button_event = 1;
  		}
		else if ((int_flag & BUTTON_UP_PIN) == BUTTON_UP_PIN)	
		{
			simpliciti_data[0] |= SIMPLICITI_BUTTON_UP;
			simpliciti_button_event = 1;
		}
		else if ((int_flag & BUTTON_DOWN_PIN) == BUTTON_DOWN_PIN)	
		{
			simpliciti_flag |= SIMPLICITI_TRIGGER_STOP;
		}
		
		// Trigger packet sending inside SimpliciTI stack
		if (simpliciti_button_event) simpliciti_flag |= SIMPLICITI_TRIGGER_SEND_DATA;
  	}
  	else // Normal operation
  	{
		// Debounce buttons
		if ((int_flag & ALL_BUTTONS) != 0)
		{ 
			// Disable PORT2 IRQ
			__disable_interrupt();
			BUTTONS_IE = 0x00; 
			__enable_interrupt();
	
			// Debounce delay 1
			Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_IN));
	
			// Reset inactivity detection
			sTime.last_activity = sTime.system_time;
		}

		// ---------------------------------------------------
		// STAR button IRQ
		if (IRQ_TRIGGERED(int_flag, BUTTON_STAR_PIN))
		{
			// Filter bouncing noise 
			if (BUTTON_STAR_IS_PRESSED)
			{
				button.flag.star = 1;
				
				// Generate button click
				buzzer = 1;
			}
		}
		// ---------------------------------------------------
		// NUM button IRQ
		else if (IRQ_TRIGGERED(int_flag, BUTTON_NUM_PIN))
		{
			// Filter bouncing noise 
			if (BUTTON_NUM_IS_PRESSED)
			{
				button.flag.num = 1;
	
				// Generate button click
				buzzer = 1;
				
				if( !sys.flag.lock_buttons)
				{
					#ifdef CONFIG_STOP_WATCH
					// Faster reaction for stopwatch split button press
					if (is_stopwatch_run())
					{
						split_stopwatch();
						button.flag.num = 0;
						
					}
					#endif
				}
			}
		}
		// ---------------------------------------------------
		// UP button IRQ
		else if (IRQ_TRIGGERED(int_flag, BUTTON_UP_PIN))
		{
			// Filter bouncing noise 
			if (BUTTON_UP_IS_PRESSED)
			{
				button.flag.up = 1;
		
				// Generate button click
				buzzer = 1;
			}
		}
		// ---------------------------------------------------
		// DOWN button IRQ
		else if (IRQ_TRIGGERED(int_flag, BUTTON_DOWN_PIN))
		{
			// Filter bouncing noise 
			if (BUTTON_DOWN_IS_PRESSED)
			{
				button.flag.down = 1;
	
				// Generate button click
				buzzer = 1;
				
				if( !sys.flag.lock_buttons)
				{
					#ifdef CONFIG_STOP_WATCH
					// Faster reaction for stopwatch stop button press
					if (is_stopwatch_run())
					{
						stop_stopwatch();
						button.flag.down = 0;
					}
					// Faster reaction for stopwatch start button press
					else if (is_stopwatch_stop())
					{
						start_stopwatch();
						button.flag.down = 0;
					}
					#endif
				}
			}
		}
		// ---------------------------------------------------
		// B/L button IRQ
		else if (IRQ_TRIGGERED(int_flag, BUTTON_BACKLIGHT_PIN))
		{
			// Filter bouncing noise 
			if (BUTTON_BACKLIGHT_IS_PRESSED)
			{
				sButton.backlight_status = 1;
				sButton.backlight_timeout = 0;
				P2OUT |= BUTTON_BACKLIGHT_PIN;
				P2DIR |= BUTTON_BACKLIGHT_PIN;
				button.flag.backlight = 1;
			}
		}	
	}
	
	// Trying to lock/unlock buttons?
	if ((button.flag.num && button.flag.down) || (button.flag.star && button.flag.up))
	{
		// No buzzer output
		buzzer = 0;
		button.all_flags = 0;
	}

	// Generate button click when button was activated
	if (buzzer)
	{
		// Any button event stops active alarm
		#ifdef CONFIG_ALARM
		if (sAlarm.state == ALARM_ON) 
		{
			stop_alarm();
			button.all_flags = 0;
		}
		else 
		#endif
		
		#ifdef CONFIG_CYCLE_ALARM
		if (sCycleAlarm.state == CYCLE_ALARM_RINGING) 
		{
			stop_cycle_alarm();
			button.all_flags = 0;
		}
		else 
		#endif
		
		#ifdef CONFIG_EGGTIMER
		if (sEggtimer.state == EGGTIMER_ALARM) {
			stop_eggtimer_alarm();
			button.all_flags = 0;
		}
		else
		#endif
		
		if (!sys.flag.up_down_repeat_enabled && !sys.flag.no_beep)
		{
			start_buzzer(1, CONV_MS_TO_TICKS(20), CONV_MS_TO_TICKS(150));
		}
		
		// Debounce delay 2
		Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_OUT));
	}
	
	#ifdef FEATURE_PROVIDE_ACCEL
	// ---------------------------------------------------
	// Acceleration sensor IRQ
	if (IRQ_TRIGGERED(int_flag, AS_INT_PIN))
	{
		// Get data from sensor
		request.flag.acceleration_measurement = 1;
  	}
	#endif
	
  	// ---------------------------------------------------
	// Pressure sensor IRQ
	if (IRQ_TRIGGERED(int_flag, PS_INT_PIN)) 
	{
		// Get data from sensor
		request.flag.altitude_measurement = 1;
  	}
  	
  	// ---------------------------------------------------
  	// Safe long button event detection
  	if(button.flag.star || button.flag.num) 
	{
		// Additional debounce delay to enable safe high detection
		Timer0_A4_Delay(CONV_MS_TO_TICKS(BUTTONS_DEBOUNCE_TIME_LEFT));
	
		// Check if this button event is short enough
		if (BUTTON_STAR_IS_PRESSED) button.flag.star = 0;
		if (BUTTON_NUM_IS_PRESSED) button.flag.num = 0;	
	}
	
	// Reenable PORT2 IRQ
	__disable_interrupt();
	BUTTONS_IFG = 0x00; 	
	BUTTONS_IE  = int_enable; 	
	__enable_interrupt();

	// Exit from LPM3/LPM4 on RETI
	__bic_SR_register_on_exit(LPM4_bits); 
}
__interrupt void Timer_A0(void)
{
	TA0CTL |= MC_0;			//Use UP mode timer
	__bic_SR_register_on_exit(LPM0_bits|GIE); //When we exit the interrupt routine we return to Low Power Mode

}
Beispiel #6
0
__interrupt void PRT1_ISR(void)
{
  P1IFG = 0;
  __bic_SR_register_on_exit(LPM4_bits);     // wakeup from LPM
}
__interrupt void Timer_A(void)
{
	__bic_SR_register_on_exit(LPM3_bits);
}
__interrupt void USCIAB0RX_ISR(void)
{
  UCB0STAT &= ~(UCSTPIFG + UCSTTIFG);       // Clear interrupt flags
  if (RXByteCtr)                            // Check RX byte counter
    __bic_SR_register_on_exit(CPUOFF);      // Exit LPM0 if data was
}                                           // received
void ADC10_ISR(void)
{                                                       //
    __bic_SR_register_on_exit(LPM0_bits);               // Wakeup main code
}
Beispiel #10
0
__interrupt void timer1_isr(void)
#endif
{
	g_event |= EV_TIMER1;
	__bic_SR_register_on_exit(LPM0_bits);
} 
Beispiel #11
0
__interrupt void port2_isr(void)
#endif
{
	g_event |= EV_PORT2;
	__bic_SR_register_on_exit(LPM0_bits);
} 
__interrupt void TIMER0_D0_ISR (void)
{
  REdge1 = TD0CL0;
  REdge2 = TD0CCR0;
  __bic_SR_register_on_exit(LPM0_bits);      // Exit LPM0 
}
Beispiel #13
0
__interrupt void ADC12ISR(void){
	adcResult = ADC12MEM0;					// Read Converted Value, IFG is Cleared
	__bic_SR_register_on_exit(LPM0_bits); 	// Clear LPM0
}
Beispiel #14
0
__interrupt void DMA_ISR(void)
{
	DMA0CTL &= ~ DMAIFG;
	__bic_SR_register_on_exit(LPM0_bits);    // Exit LPM0 on reti
}
__interrupt void ADC10_ISR (void)
{
  __bic_SR_register_on_exit(CPUOFF);        // Clear CPUOFF bit from 0(SR)
}
__interrupt void watchdog_timer (void)
{
  __bic_SR_register_on_exit(LPM3_bits);     // Clear LPM3 bits from 0(SR)
}
__interrupt void USCIAB0TX_ISR(void)
{
    RXData = UCB0RXBUF;                       // Get RX data
    __bic_SR_register_on_exit(CPUOFF);        // Exit LPM0
}
__interrupt void USCIAB0TX_ISR(void)
{
  UCB0TXBUF = TXData;                       // TX data
  __bic_SR_register_on_exit(CPUOFF);        // Exit LPM0
}