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

int twi_slave_init(volatile avr32_twi_t *twi, const twi_options_t *opt, const twi_slave_fct_t *slave_fct){  bool global_interrupt_enabled = Is_global_interrupt_enabled();  // Set pointer to TWIM instance for IT  twi_inst = twi;  // Disable TWI interrupts  if (global_interrupt_enabled) Disable_global_interrupt();  twi->idr = ~0UL;  twi->sr;  // Reset TWI  twi->cr = AVR32_TWI_CR_SWRST_MASK;  if (global_interrupt_enabled) Enable_global_interrupt();  // Dummy read in SR  twi->sr;  // Disable all interrupts  Disable_global_interrupt();  // Register TWI handler on level 2  INTC_register_interrupt( &twi_slave_interrupt_handler, AVR32_TWI_IRQ, AVR32_INTC_INT1);  // Enable all interrupts  Enable_global_interrupt();  // Set slave address  twi->smr = (opt->chip << AVR32_TWI_SMR_SADR_OFFSET);  // Disable master transfer  twi->cr = AVR32_TWI_CR_MSDIS_MASK;  // Enable slave  twi->cr = AVR32_TWI_CR_SVEN_MASK;  // get a pointer to applicative routines  twi_slave_fct = *slave_fct;  // Slave Access Interrupt Enable  twi_it_mask = AVR32_TWI_IER_SVACC_MASK;  twi->ier = twi_it_mask;  // Everything went ok  return TWI_SUCCESS;}

void boardsupport_init(void) {	central_data_t *central_data;	irq_initialize_vectors();	cpu_irq_enable();	Disable_global_interrupt();			sysclk_init();	//delay_init(sysclk_get_cpu_hz());			INTC_init_interrupts();	central_data=central_data_get_pointer_to_struct();		#ifdef TELEMETRY_USE_UART		uart_int_set_usart_conf(TELEMETRY_UART_INDEX, asv_debug_uart_conf());		//uart configuration		uart_int_init(TELEMETRY_UART_INDEX);		uart_int_register_write_stream(uart_int_get_uart_handle(TELEMETRY_UART_INDEX), &(central_data->wired_out_stream));		// Registering streams		buffer_make_buffered_stream_lossy(&(wired_in_buffer), &(central_data->wired_in_stream));		uart_int_register_read_stream(uart_int_get_uart_handle(TELEMETRY_UART_INDEX), &(central_data->wired_in_stream));		central_data->debug_in_stream=&central_data->wired_in_stream;		central_data->debug_out_stream=&central_data->wired_out_stream;	#endif			central_data_init();	Enable_global_interrupt();}

void DFU_UsbStop (void){  Disable_global_interrupt();  Usb_disable();  (void)Is_usb_enabled();  Enable_global_interrupt();}

void avr32EthEnableIrq(NetInterface *interface){   //Enable Ethernet MAC interrupts   Enable_global_interrupt();   //Enable Ethernet PHY interrupts   interface->phyDriver->enableIrq(interface);}

void encoder_init_all ()	{	uint8_t isr_counter = 0;		Disable_global_interrupt();	/* Initialization loop, this loop inits all required IO and interrupts	 * for EIC module and pins used to read encoders.  */		while(isr_counter < ENCODER_COUNT)		{		/* Init io for interrupt line and state poll line. */		gpio_enable_gpio_pin(encoder_handle[isr_counter].a_pin);		gpio_enable_gpio_pin(encoder_handle[isr_counter].b_pin);				/* Set pullup for both gpio channels. */		gpio_enable_pin_pull_up(encoder_handle[isr_counter].a_pin);		gpio_enable_pin_pull_up(encoder_handle[isr_counter].b_pin);					/* Init interrupt from encoder A line */		gpio_enable_pin_interrupt(encoder_handle[isr_counter].a_pin, GPIO_FALLING_EDGE);		gpio_disable_pin_interrupt(encoder_handle[isr_counter].b_pin);				INTC_register_interrupt(&encoders_and_buttons_isr, 			AVR32_GPIO_IRQ_0 + (encoder_handle[isr_counter].a_pin/8),			AVR32_INTC_INT0);					isr_counter++;		}	Enable_global_interrupt();	}

int tc_configure_interrupts(volatile avr32_tc_t *tc, unsigned int channel, const tc_interrupt_t *bitfield){  bool global_interrupt_enabled = Is_global_interrupt_enabled();  // Check for valid input.  if (channel >= TC_NUMBER_OF_CHANNELS)    return TC_INVALID_ARGUMENT;  // Enable the appropriate interrupts.  tc->channel[channel].ier = bitfield->etrgs << AVR32_TC_ETRGS_OFFSET |                             bitfield->ldrbs << AVR32_TC_LDRBS_OFFSET |                             bitfield->ldras << AVR32_TC_LDRAS_OFFSET |                             bitfield->cpcs << AVR32_TC_CPCS_OFFSET |                             bitfield->cpbs << AVR32_TC_CPBS_OFFSET |                             bitfield->cpas << AVR32_TC_CPAS_OFFSET |                             bitfield->lovrs << AVR32_TC_LOVRS_OFFSET |                             bitfield->covfs << AVR32_TC_COVFS_OFFSET;  // Disable the appropriate interrupts.  if (global_interrupt_enabled) Disable_global_interrupt();  tc->channel[channel].idr = (~bitfield->etrgs & 1) << AVR32_TC_ETRGS_OFFSET |                             (~bitfield->ldrbs & 1) << AVR32_TC_LDRBS_OFFSET |                             (~bitfield->ldras & 1) << AVR32_TC_LDRAS_OFFSET |                             (~bitfield->cpcs & 1) << AVR32_TC_CPCS_OFFSET |                             (~bitfield->cpbs & 1) << AVR32_TC_CPBS_OFFSET |                             (~bitfield->cpas & 1) << AVR32_TC_CPAS_OFFSET |                             (~bitfield->lovrs & 1) << AVR32_TC_LOVRS_OFFSET |                             (~bitfield->covfs & 1) << AVR32_TC_COVFS_OFFSET;  tc->channel[channel].sr;  if (global_interrupt_enabled) Enable_global_interrupt();  return 0;}

void Actividad2(void){						pm_switch_to_osc0(&AVR32_PM, FOSC0, OSC0_STARTUP); //osc0 a 12Mhz		center=0;		//Interrupciones				Disable_global_interrupt();		INTC_init_interrupts();		INTC_register_interrupt(&tecla_lrc_isr, 71, 0);		INTC_register_interrupt(&tecla_lrc_isr, 70,0);		gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_LEFT,GPIO_RISING_EDGE);		gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_RIGHT,GPIO_RISING_EDGE);		gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_ENTER,GPIO_RISING_EDGE);		gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_UP,GPIO_RISING_EDGE);		gpio_enable_pin_interrupt(QT1081_TOUCH_SENSOR_DOWN,GPIO_RISING_EDGE);		Enable_global_interrupt();										while (1){}	}

/** /brief Register an external interrupt handler for the touch event. * */void at42qt1060_register_eic_int(void (*touch_detect_callback)(void)){  eic_options_t eic_options[1];  at42qt1060.touch_detect_callback = touch_detect_callback;  gpio_enable_module_pin(AT42QT1060_DETECT_PIN, AT42QT1060_EIC_EXTINT_FUNCTION);  Disable_global_interrupt();  INTC_register_interrupt(&at42qt1060_detect_eic_int_handler, AT42QT1060_EIC_EXTINT_IRQ,    AT42QT1060_EIC_EXTINT_LEVEL);  eic_options[0].eic_mode = EIC_MODE_EDGE_TRIGGERED;  eic_options[0].eic_level = EIC_EDGE_FALLING_EDGE;  eic_options[0].eic_async = EIC_SYNCH_MODE;  eic_options[0].eic_line = AT42QT1060_EIC_LINE;  eic_init(&AVR32_EIC, &eic_options[0], 1);  eic_enable_lines(&AVR32_EIC, (1 << eic_options[0].eic_line));  eic_enable_interrupt_lines(&AVR32_EIC, (1 << eic_options[0].eic_line));  Enable_global_interrupt();  return;}

void sio_putstr(char *cptr){  uint8_t byteSend = 0;  Disable_global_interrupt();  if( checkIfFifoEmpty  & (!checkIfDataToSend) )    { // nothing in queue data can be transmited directly      // to uart FIFO      resetFifo;      while( (*cptr!='/0') & (byteSend < UART_TX_FIFO_SIZE) )        {          UART_SendByte(SERIAL_USART, (*cptr++) );          byteSend++;        }    }  //FIFO full save data in buffer  while(*cptr)    {      uartDataToSend.txbuf[uartDataToSend.lastPtr++] = (*cptr++);      byteSend = 0xff;    }  if(byteSend == 0xff)    {      uartDataToSend.txbuf[uartDataToSend.lastPtr] = '/0';    }  Enable_global_interrupt();  return;}

/*! *  /brief Init the push button 3 sensor. * *  /return true upon success, false if error. */bool b_pushb3_init ( void ){portCHAR token[6];   // Get the xCFGMutex.   if( pdTRUE == x_supervisor_SemaphoreTake( xCFGMutex, 20 ) )   {       // get the field       if (config_file_get_value(SENSOR_PB3_CONFIG_FILE, "alarm" , token) >= 0)       {         // update value         if (!strcmp(token, "on"))         {           bAlarm3 = pdTRUE;         }       }     // Release the xCFGMutex.     x_supervisor_SemaphoreGive( xCFGMutex );   }   /* configure push button to produce IT on input change */   gpio_enable_pin_interrupt(PB3_POSITION , GPIO_PIN_CHANGE);   /* Disable all interrupts */   Disable_global_interrupt();   /* register push button 3 handler on level 3 */   INTC_register_interrupt( (__int_handler)&vpushb_ISR, AVR32_GPIO_IRQ_0 + (PB3_POSITION/8), AVR32_INTC_INT3);   /* Enable all interrupts */   Enable_global_interrupt();   return (true);}

/** /brief Prepare the rtouch detect function. * * A touch can be detected by setting the Y lines  (or X lines) as inputs and * enabling the internal pull-ups for these pins. The other lines, X in this * case are connected to GND. By a touch the Y lines will be pulled low and an * interrupt can be triggered on a low level detect. * * This function does the registering of the interrupt handler for the touch * detect. Currently we use a GPIO interrupt, but here it is only possible to * trigger on edges but actually we should trigger on a low level. Anyway this * should work too. * Here we use the YL line as source input for the edge detection but it is * also possible to use YH. */static void inline rtouch_prepare_detect(void){	Disable_global_interrupt();	INTC_register_interrupt(&rtouch_detect_int_handler,			AVR32_GPIO_IRQ_0 + rtouch_gpio_ymap[0].pin / 8, 0);	Enable_global_interrupt();}

void BUFFERED_SIO_SendHandler (void){    // Something to send ?    if (BUFFERED_SIO_TxBuffer_StartPointer == BUFFERED_SIO_TxBuffer_EndPointer)    {        return;    }    BUFFERED_SIO_TxBuffer_StartPointer++;    // Rollover ?    if (BUFFERED_SIO_TX_BUFFER_SIZE <= BUFFERED_SIO_TxBuffer_StartPointer)    {        BUFFERED_SIO_TxBuffer_StartPointer = 0;    }    // Send char    usart_putchar (BUFFERED_SIO_USART, BUFFERED_SIO_TxBuffer[BUFFERED_SIO_TxBuffer_StartPointer]);    // Enable USART Tx interrupt for transmitting all chars    Disable_global_interrupt ();    BUFFERED_SIO_USART->IER.txempty = 1;    Enable_global_interrupt ();}

void mdma_configure_interrupts(volatile avr32_mdma_t *mdma, const mdma_interrupt_t *bitfield){  bool global_interrupt_enabled = Is_global_interrupt_enabled();  // Enable the appropriate interrupts.  mdma->ier            = bitfield->ch0c << AVR32_MDMA_IER_CH0C_OFFSET |                         bitfield->ch1c << AVR32_MDMA_IER_CH1C_OFFSET |                         bitfield->ch2c << AVR32_MDMA_IER_CH2C_OFFSET |                         bitfield->ch3c << AVR32_MDMA_IER_CH3C_OFFSET |                         bitfield->berr0 << AVR32_MDMA_IER_BERR0_OFFSET |                         bitfield->berr1 << AVR32_MDMA_IER_BERR1_OFFSET |                         bitfield->berr2 << AVR32_MDMA_IER_BERR2_OFFSET |                         bitfield->berr3 << AVR32_MDMA_IER_BERR3_OFFSET ;  // Disable the appropriate interrupts.  if (global_interrupt_enabled) Disable_global_interrupt();  mdma->idr            = (~bitfield->ch0c & 1)  << AVR32_MDMA_IDR_CH0C_OFFSET |                         (~bitfield->ch1c & 1)  << AVR32_MDMA_IDR_CH1C_OFFSET |                         (~bitfield->ch2c & 1)  << AVR32_MDMA_IDR_CH2C_OFFSET |                         (~bitfield->ch3c & 1)  << AVR32_MDMA_IDR_CH3C_OFFSET |                         (~bitfield->berr0 & 1) << AVR32_MDMA_IDR_BERR0_OFFSET |                         (~bitfield->berr1 & 1) << AVR32_MDMA_IDR_BERR1_OFFSET |                         (~bitfield->berr2 & 1) << AVR32_MDMA_IDR_BERR2_OFFSET |                         (~bitfield->berr3 & 1) << AVR32_MDMA_IDR_BERR3_OFFSET ;  if (global_interrupt_enabled) Enable_global_interrupt();}

u8 BUFFERED_SIO_WriteString (u16 Len, u8 * String_pu8){u16 Value;    // Save end pointer    Value = BUFFERED_SIO_TxBuffer_EndPointer;    Disable_global_interrupt ();    // For each byte    while (0 < Len)    {        Value++;        // End of buffer ?        if (BUFFERED_SIO_TX_BUFFER_SIZE <= Value)        {            // Set pointer to start of buffer            Value = 0;        }        // Buffer full ?        if (Value == BUFFERED_SIO_TxBuffer_StartPointer)        {            // Abort sending            Enable_global_interrupt ();            return (FALSE);        }        // Write byte into buffer        BUFFERED_SIO_TxBuffer_EndPointer = Value;#ifdef STICK_20_SEND_DEBUGINFOS_VIA_HID        BUFFERED_SIO_HID_TxBuffer_EndPointer = Value;#endif        BUFFERED_SIO_TxBuffer[Value] = *String_pu8;        // Todo ISR Lock start        // Pointers to next byte        String_pu8++;        Len--;        // Todo ISR Lock end    }    Enable_global_interrupt ();    return (TRUE);}

void isrInternalClok(void){		RTC->MODE0.CTRL.reg &=  0b1111111111111101;//stop timer			Disable_global_interrupt();			//printf("+");			static bool state;			state=stateLed;						timeManage.halfmillis+=VALUE_TIMER;					if(timeManage.halfmillis<(RTC_FREQ/2)){//all 500ms				stateLed=LOW;			}			else{				stateLed=HIGH;			}			if(state!=stateLed){				led = stateLed;				//	if(synchroLed!=NULL){				//		xSemaphoreGiveFromISR( synchroLed,NULL);				//	}			}						timeManage.second+=timeManage.halfmillis/RTC_FREQ;			timeManage.halfmillis=timeManage.halfmillis%RTC_FREQ;			if((valueCor!=0)){				if (timeCorr==0){					timeCorr=timeCorrection;					Clock off;					off.second=(unsigned int )abs(valueCor)/RTC_FREQ;					off.halfmillis=(unsigned int)abs(valueCor)%RTC_FREQ;					if(valueCor<0){						off.sign=false;					}					else{						off.sign=true;					}					//change the time					timeManage=sumClock(timeManage,off);					//change the correction offset					sumOffset=sumClock(sumOffset,off);//ok				}				else{					timeCorr--;				}					sumOffset.second+=sumOffset.halfmillis/RTC_FREQ;				sumOffset.halfmillis=sumOffset.halfmillis%RTC_FREQ;				timeManage.second+=timeManage.halfmillis/RTC_FREQ;				timeManage.halfmillis=timeManage.halfmillis%RTC_FREQ;						}							Enable_global_interrupt();	RTC->MODE0.CTRL.reg |= RTC_MODE0_CTRL_ENABLE; //enable timer}

/*! /brief Initializes MCU interrupts. */static void init_interrupts(void){  // Initialize interrupt handling.  INTC_init_interrupts();  // Enable interrupts globally.  Enable_global_interrupt();}

void eic_clear_interrupt_lines(volatile avr32_eic_t *eic, unsigned int mask_lines){  Bool global_interrupt_enabled = Is_global_interrupt_enabled();  if (global_interrupt_enabled) Disable_global_interrupt();  eic->icr = mask_lines;  eic->isr;  if (global_interrupt_enabled) Enable_global_interrupt();}

void twi_disable_interrupt(volatile avr32_twi_t *twi){  bool global_interrupt_enabled = Is_global_interrupt_enabled();  if (global_interrupt_enabled) Disable_global_interrupt();  twi->idr = ~0UL;  twi->sr;  if (global_interrupt_enabled) Enable_global_interrupt();}

void controller_shutdown(void){  // Disable all interrupts  Disable_global_interrupt();  // Disable the RTC  rtc_disable(&AVR32_RTC);  // Enable global interrupts  Enable_global_interrupt();}

void platform_int_init(){  unsigned i;    for( i = 0; i < NUM_UART; i ++ )    if( usart_irqs[ i ] != -1 )      INTC_register_interrupt( phandlers[ i ], usart_irqs[ i ], AVR32_INTC_INT0 );     Enable_global_interrupt();   }

void pm_bod_disable_irq(volatile avr32_pm_t *pm){  Bool global_interrupt_enabled = Is_global_interrupt_enabled();  if (global_interrupt_enabled) Disable_global_interrupt();  pm->idr = AVR32_PM_IDR_BODDET_MASK;  pm->isr;  if (global_interrupt_enabled) Enable_global_interrupt();}

/*! /brief Main function. Execution starts here. * * /retval 42 Fatal error. */int main(void){  // Configure system clocks.  if (pcl_configure_clocks(&pcl_freq_param) != PASS)    return 42;  // Initialize USB clock (on PLL1)  pcl_configure_usb_clock();  // Initialize usart comm  init_dbg_rs232(pcl_freq_param.pba_f);#if BOARD == EVK1105  Disable_global_interrupt();  /* Register interrupt handler to the interrupt controller   * up, down buttons on PB22, PB23 -> GPIO_IRQ_6   */  INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_6, 0);  /* all gpios between PB23 - PB31) */  INTC_register_interrupt(&touch_button_isr, AVR32_GPIO_IRQ_7, 0);  Enable_global_interrupt();#endif  // Initialize USB task  usb_task_init();#if USB_DEVICE_FEATURE == true  // Initialize device mouse USB task  device_mouse_hid_task_init();#endif#if USB_HOST_FEATURE == true  //host_keyboard_hid_task_init();  // Initialize host mouse USB task  host_mouse_hid_task_init();#endif#ifdef FREERTOS_USED  // Start OS scheduler  vTaskStartScheduler();  portDBG_TRACE("FreeRTOS returned.");  return 42;#else  // No OS here. Need to call each task in round-robin mode.  while (true)  {    usb_task();  #if USB_DEVICE_FEATURE == true    device_mouse_hid_task();  #endif  #if USB_HOST_FEATURE == true    //host_keyboard_hid_task();    host_mouse_hid_task();  #endif  }#endif  // FREERTOS_USED}

void eic_clear_interrupt_line(volatile avr32_eic_t *eic, unsigned int line_number){  Bool global_interrupt_enabled = Is_global_interrupt_enabled();  // Clear line line_number  if (global_interrupt_enabled) Disable_global_interrupt();  eic->icr = 1 << line_number;  eic->isr;  if (global_interrupt_enabled) Enable_global_interrupt();}

/** * Name         : interrupts_init * * Synopsis     : void interrupts_init (void) * * Description  : Initialize and enable global interrupts *  */void interrupts_init (void){	// Enable low level and medium level interrupts 	PMIC.CTRL = PMIC_LVL_LOW | PMIC_LVL_MEDIUM;		// Set priority of low level interrupts to Round Robin scheduling	PMIC.CTRL |= PMIC_RREN_bm;		// Enable global interrupts	Enable_global_interrupt();}

/** * /brief  Through this function, the SNA is configured for the PCRC service. * * /param  puc_sna   Pointer to the SNA * */void pcrc_configure_sna(uint8_t *puc_sna){	Disable_global_interrupt();	memcpy(puc_SNA, puc_sna, SNA_SIZE);	uc_SNA_crc_8  = _eval_crc_8(puc_SNA, SNA_SIZE, 0);	ul_SNA_crc_32 = _eval_crc_32(puc_SNA, SNA_SIZE, 0);	Enable_global_interrupt();}

u16 BUFFERED_SIO_Init (void){    // IO mappingstatic const gpio_map_t USART_GPIO_MAP = {    {BUFFERED_SIO_USART_RX_PIN, BUFFERED_SIO_USART_RX_FUNCTION},    {BUFFERED_SIO_USART_TX_PIN, BUFFERED_SIO_USART_TX_FUNCTION}};    // USART options.static const usart_options_t USART_OPTIONS = {    .baudrate = 57600 * 2,    .charlength = 8,    .paritytype = USART_NO_PARITY,    .stopbits = USART_1_STOPBIT,    .channelmode = USART_NORMAL_CHMODE};    // Reset vars    BUFFERED_SIO_TxBuffer_StartPointer = 0;    BUFFERED_SIO_TxBuffer_EndPointer = 0;    BUFFERED_SIO_TxActiv_Sendbytes = 0;    BUFFERED_SIO_RxBuffer_StartPointer = 0;    BUFFERED_SIO_RxBuffer_EndPointer = 0;#ifdef STICK_20_SEND_DEBUGINFOS_VIA_HID    BUFFERED_SIO_HID_TxBuffer_StartPointer = 0;    BUFFERED_SIO_HID_TxBuffer_EndPointer = 0;    BUFFERED_SIO_HID_TxActiv_Sendbytes = 0;#endif    // Assign GPIO to USART.    gpio_enable_module (USART_GPIO_MAP, sizeof (USART_GPIO_MAP) / sizeof (USART_GPIO_MAP[0]));    // Initialize USART in RS232 mode.    usart_init_rs232 (BUFFERED_SIO_USART, &USART_OPTIONS, FPBA_HZ);    // Disable all interrupts.    Disable_global_interrupt ();    // Set ISR    INTC_register_interrupt (&BUFFERED_SIO_Usart_ISR, BUFFERED_SIO_USART_IRQ, AVR32_INTC_INT0);    // Enable USART Rx interrupt.    BUFFERED_SIO_USART->IER.rxrdy = 1;    // Enable USART Tx interrupt.    // BUFFERED_SIO_USART->IER.txempty = 1;    // Enable all interrupts.    Enable_global_interrupt ();    return (TRUE);}

int twi_master_init(volatile avr32_twim_t *twi, const twi_options_t *opt) {    bool global_interrupt_enabled = Is_global_interrupt_enabled();    int status = TWI_SUCCESS;    // Disable TWI interrupts    if (global_interrupt_enabled) Disable_global_interrupt();    twi->idr = ~0UL;    // Reset TWI    twi->cr = AVR32_TWIM_CR_SWRST_MASK;    if (global_interrupt_enabled) Enable_global_interrupt();    // Clear SR    twi->scr = ~0UL;    // Disable all interrupts    Disable_global_interrupt();    // Register TWI handler on level 2    BSP_INTC_IntReg( &twi_master_interrupt_handler, AVR32_TWIM0_IRQ, AVR32_INTC_INT1);    // Enable all interrupts    Enable_global_interrupt();    twi->cr = AVR32_TWIM_CR_MEN_MASK;    if (opt->smbus) {        twi->cr = AVR32_TWIM_CR_SMEN_MASK;        twi->smbtr = (unsigned long) -1;    }    // Select the speed    if (twi_set_speed(twi, opt->speed, opt->pba_hz) == TWI_INVALID_CLOCK_DIV)        return TWI_INVALID_CLOCK_DIV;    // Probe the component    //status = twi_probe(twi, opt->chip);    return status;}

void ISO7816_Usart_ISR_Test (void){    static int n = 0;    static int c;    // static int x;    // Test for tx int    // Tx int enabled ?    if (1 == EXAMPLE_INT_USART->IMR.txempty)    {        // Yes        // Data send ?        if (1 == EXAMPLE_INT_USART->CSR.txempty)        {            // Data send            EXAMPLE_INT_USART->IDR.txempty = 1;            usart_reset_tx (EXAMPLE_INT_USART);            /*               // Disable tx empty interrupt Disable_global_interrupt(); EXAMPLE_INT_USART->IDR.txempty = 1; Enable_global_interrupt(); while (1 ==               EXAMPLE_INT_USART->IMR.txempty) ; */            /*               // clearing interrupt request x = EXAMPLE_INT_USART->cr; EXAMPLE_INT_USART->cr = x; x = EXAMPLE_INT_USART->cr; */        }    }    else    {        n++;    }    // Test for rx int    if (1 == EXAMPLE_INT_USART->CSR.rxrdy)    {        // Data is ready        usart_read_char (EXAMPLE_INT_USART, &c);        // EXAMPLE_INT_USART->IER.txempty = 1;        // Send data        // usart_write_char(EXAMPLE_INT_USART, c);        // Enable tx int        Disable_global_interrupt ();        EXAMPLE_INT_USART->IER.txempty = 1;        Enable_global_interrupt ();        while (0 == EXAMPLE_INT_USART->IMR.txempty);    }    /*       usart_read_char(EXAMPLE_INT_USART, &c); usart_write_char(EXAMPLE_INT_USART, c); */    n++;}

void _init(void){	sysclk_init();		// Disable all interrupts.	Disable_global_interrupt();	// Initialize interrupt vectors.	INTC_init_interrupts();		// Enable all interrupts.	Enable_global_interrupt();}

void BUFFERED_SIO_TxIntHandler (void){    if (FALSE == BUFFERED_SIO_TxEmpty ())    {        BUFFERED_SIO_SendHandler ();    }    else    {        // Disable USART Tx interrupt.        Disable_global_interrupt ();        BUFFERED_SIO_USART->IDR.txempty = 1;        Enable_global_interrupt ();    }}