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

/** Main program entry point. This routine configures the hardware required by the bootloader, then continuously *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start *  the loaded application code. */int main(void){	/* Setup hardware required for the bootloader */	SetupHardware();	/* Turn on first LED on the board to indicate that the bootloader has started */	LEDs_SetAllLEDs(LEDS_LED1);	/* Enable global interrupts so that the USB stack can function */	GlobalInterruptEnable();	while (RunBootloader)	{		CDC_Task();		USB_USBTask();		/* Time out and start the sketch if one is present */		if (Timeout > TIMEOUT_PERIOD){		RunBootloader = false;}	}	/* Disconnect from the host - USB interface will be reset later along with the AVR */	USB_Detach();	/* Unlock the forced application start mode of the bootloader if it is restarted */	MagicBootKey = MAGIC_BOOT_KEY;	/* Enable the watchdog and force a timeout to reset the AVR */	wdt_enable(WDTO_250MS);	for (;;);}

int main(void){	SetupHardware();	GlobalInterruptEnable();	sei();	for (;;)	{		if (tx_ticks > 0) 		{			tx_ticks--;		}		else if (tx_ticks == 0)		{			LEDs_TurnOnLEDs(LEDS_LED2); // on = off?		}											if (rx_ticks > 0)		{			rx_ticks--;		}		else if (rx_ticks == 0)		{			LEDs_TurnOnLEDs(LEDS_LED1); // on = off? 		}					MIDI_To_Arduino();		MIDI_To_Host();		USB_USBTask();	}}

/** * /brief Main function for the focuser firmware */int	main(int argc, char *argv[]) {	// initialize the 	unsigned short	d = 10;	led_on();	while (d--) {		_delay_ms(100);		led_off();		_delay_ms(100);		led_on();	}	led_off();	// initialize USB, but USB requests will only be handled when	// interrupts are enabled below	USB_Init(USB_DEVICE_OPT_FULLSPEED);	// start the timer, this also enables the watchdog timer	timer_start();	// enable interrupts so that USB processing can begin	GlobalInterruptEnable();	// do nothing		for (;;) {		if (saveneeded) {			motor_save();		}		if (newserial) {			serial_write();		}	}}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	stdout=&mystdout;	stdin=&mystdin;	SetupHardware();	//LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	//Eval Prototype Sharp Reset Pin	//DDRB &= ~RESET_PIN; //Set Input	//PORTB |= RESET_PIN; //Set High	//DDRB |= RESET_PIN; //Set Output	//Drude Sharp LCD Reset PIN	PORTF |= RESETN_PIN; //Set High	DDRF |= RESETN_PIN; //Set Output		//Digitizer Interrupt	//DDRB &= ~(_BV(7)); //PB7 input	//PORTB &= ~(1<<PB7); //PB7 low	PORTB |= (_BV(7)); //Set high (input pullup)		//IP4787CZ32Y HDMI ESD interface chip (HDMI_ACT PIN) Active-High (Test-Point 12)	PORTF |= (_BV(PF1)); //Set high (input pullup)		//Toshiba Interrupt Pin	PORTE |= (_BV(PE6)); //Set high (input pullup)	//Toshiba Standby Pin	PORTF |= (_BV(PF4)); //Set high (input pullup)	//Toshiba Reset Pin - Active Low	PORTC |= (_BV(PC7)); //Set high (input pullup)	//LCD-CABC	//PORTF |= (_BV(PF7)); //Set high (defaults to input pullup)	//DDRF &= ~(_BV(PF7)); //Set output	//PORTF |= (_BV(PF7)); //Set low	//LED-PWM	PORTD |= (_BV(PD6)); //Set high (defaults to input pullup)	//PORTD &= ~(_BV(PD6)); //Set low	//DDRD &= ~(_BV(PD6)); //Set output	RingBuffer_InitBuffer(&FromHost_Buffer, FromHost_Buffer_Data, sizeof(FromHost_Buffer_Data));	init_screen(0x1F); //magic number!		mxt_list_types();	for (;;)	{		HandleSerial();		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		HID_Device_USBTask(&Digitizer_HID_Interface);		USB_USBTask();		HandleDigitizer();	}}

/** Main program entry point. This routine configures the hardware required by the application, then *  enters a loop to run the application tasks in sequence. */int main(void){	SetupHardware();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		USB_USBTask();		uint8_t ReceivedData[VENDOR_IO_EPSIZE];		memset(ReceivedData, 0x00, sizeof(ReceivedData));		Endpoint_SelectEndpoint(VENDOR_OUT_EPADDR);		if (Endpoint_IsOUTReceived())		{			Endpoint_Read_Stream_LE(ReceivedData, VENDOR_IO_EPSIZE, NULL);			Endpoint_ClearOUT();			Endpoint_SelectEndpoint(VENDOR_IN_EPADDR);			Endpoint_Write_Stream_LE(ReceivedData, VENDOR_IO_EPSIZE, NULL);			Endpoint_ClearIN();		}	}}

/** Main program entry point. This routine configures the hardware required by the application, then *  enters a loop to run the application tasks in sequence. */int main(void){	SetupHardware();	puts_P(PSTR(ESC_FG_CYAN "Mouse Host/Device Demo running./r/n" ESC_FG_WHITE));	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		/* Determine which USB mode we are currently in */		if (USB_CurrentMode == USB_MODE_Host)		{			MouseHost_Task();			HID_Host_USBTask(&Mouse_HID_Host_Interface);		}		else		{			HID_Device_USBTask(&Mouse_HID_Device_Interface);		}		USB_USBTask();	}}

/** Main program entry point. This routine configures the hardware required by the bootloader, then continuously *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start *  the loaded application code. */int main(void){	/* Setup hardware required for the bootloader */	SetupHardware();	/* Turn on first LED on the board to indicate that the bootloader has started */	LEDs_SetAllLEDs(LEDS_LED1);	/* Enable global interrupts so that the USB stack can function */	GlobalInterruptEnable();	while (RunBootloader)	{		CDC_Task();		USB_USBTask();	}	/* Wait a short time to end all USB transactions and then disconnect */	_delay_us(1000);	/* Disconnect from the host - USB interface will be reset later along with the AVR */	USB_Detach();	/* Unlock the forced application start mode of the bootloader if it is restarted */	MagicBootKey = MAGIC_BOOT_KEY;	/* Enable the watchdog and force a timeout to reset the AVR */	wdt_enable(WDTO_250MS);	for (;;);}

/** Main program entry point. This routine configures the hardware required by the application, then *  enters a loop to run the application tasks in sequence. */int main(void){	SetupHardware();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	while (RunBootloader || TicksSinceLastCommand++ < 0xFF)	{		MS_Device_USBTask(&Disk_MS_Interface);		USB_USBTask();	}	/* Wait a short time to end all USB transactions and then disconnect */	_delay_us(1000);	/* Disconnect from the host - USB interface will be reset later along with the AVR */	USB_Detach();	/* Unlock the forced application start mode of the bootloader if it is restarted */	MagicBootKey = MAGIC_BOOT_KEY;	/* Enable the watchdog and force a timeout to reset the AVR */	wdt_enable(WDTO_250MS);	for (;;);}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, sizeof(USBtoUSART_Buffer_Data));	RingBuffer_InitBuffer(&USARTtoUSB_Buffer, USARTtoUSB_Buffer_Data, sizeof(USARTtoUSB_Buffer_Data));	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */		if (!(RingBuffer_IsFull(&USBtoUSART_Buffer)))		{			int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);			/* Read bytes from the USB OUT endpoint into the USART transmit buffer */			if (!(ReceivedByte < 0))			  RingBuffer_Insert(&USBtoUSART_Buffer, ReceivedByte);		}		/* Check if the UART receive buffer flush timer has expired or the buffer is nearly full */		uint16_t BufferCount = RingBuffer_GetCount(&USARTtoUSB_Buffer);		if (BufferCount)		{			Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);			/* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data			 * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */			if (Endpoint_IsINReady())			{				/* Never send more than one bank size less one byte to the host at a time, so that we don't block				 * while a Zero Length Packet (ZLP) to terminate the transfer is sent if the host isn't listening */				uint8_t BytesToSend = MIN(BufferCount, (CDC_TXRX_EPSIZE - 1));				/* Read bytes from the USART receive buffer into the USB IN endpoint */				while (BytesToSend--)				{					/* Try to send the next byte of data to the host, abort if there is an error without dequeuing */					if (CDC_Device_SendByte(&VirtualSerial_CDC_Interface,											RingBuffer_Peek(&USARTtoUSB_Buffer)) != ENDPOINT_READYWAIT_NoError)					{						break;					}					/* Dequeue the already sent byte from the buffer now we have confirmed that no transmission error occurred */					RingBuffer_Remove(&USARTtoUSB_Buffer);				}			}		}		/* Load the next byte from the USART transmit buffer into the USART */		if (!(RingBuffer_IsEmpty(&USBtoUSART_Buffer)))		  Serial_SendByte(RingBuffer_Remove(&USBtoUSART_Buffer));		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		USB_USBTask();	}}

/** Configures the board hardware and chip peripherals for the demo's functionality. */void SetupHardware(void){	/* Disable watchdog */  MCUSR = 0;	wdt_disable();	/* Disable clock division */	clock_prescale_set(clock_div_1);  serial_init();  GlobalInterruptEnable();  //LED_CONFIG;	/* Hardware Initialization */	LEDs_Init();	PIN_CONFIG(4);	PIN_CONFIG(5);	PIN_CONFIG(6);	PIN_CONFIG(7);  while(!started);  USB_Init();}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	/* Create a regular character stream for the interface so that it can be used with the stdio.h functions */	CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream);	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	_setBrightness(50);	for (;;)	{		/* Must throw away unused bytes from the host, or it will lock up while waiting for the device */		CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		USB_USBTask();		DS1302_clock_burst_read((uint8_t *) &rtc);		_setDigit( rtc.Seconds % 10 );		_setBrightness( 50 );		_delay_ms(4);    }}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	/* Create a regular blocking character stream for the interface so that it can be used with the stdio.h functions */	CDC_Device_CreateBlockingStream(&VirtualSerial_CDC_Interface, &USBSerialStream);	GlobalInterruptEnable();	for (;;)	{		/* Read in next LED colour command from the host */		uint8_t ColourUpdate = fgetc(&USBSerialStream);		/* Top 3 bits select the LED, bottom 5 control the brightness */		uint8_t Channel = (ColourUpdate & 0b11100000);		uint8_t Duty    = (ColourUpdate & 0b00011111);		if (Channel & (1 << 5))		  SoftPWM_Channel1_Duty = Duty;		if (Channel & (1 << 6))		  SoftPWM_Channel2_Duty = Duty;		if (Channel & (1 << 7))		  SoftPWM_Channel3_Duty = Duty;		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		USB_USBTask();	}}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	TCP_Init();	Webserver_Init();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		if (RNDIS_Device_IsPacketReceived(&Ethernet_RNDIS_Interface))		{			LEDs_SetAllLEDs(LEDMASK_USB_BUSY);			RNDIS_Device_ReadPacket(&Ethernet_RNDIS_Interface, &FrameIN.FrameData, &FrameIN.FrameLength);			Ethernet_ProcessPacket(&FrameIN, &FrameOUT);			if (FrameOUT.FrameLength)			{				RNDIS_Device_SendPacket(&Ethernet_RNDIS_Interface, &FrameOUT.FrameData, FrameOUT.FrameLength);				FrameOUT.FrameLength = 0;			}			LEDs_SetAllLEDs(LEDMASK_USB_READY);		}		TCP_TCPTask(&Ethernet_RNDIS_Interface, &FrameOUT);		RNDIS_Device_USBTask(&Ethernet_RNDIS_Interface);		USB_USBTask();	}}

int main(void){  SetupHardware();  /* Create a regular character stream for the interface so that it can be used with the stdio.h functions */  CDC_Device_CreateStream(&VirtualSerial_CDC_Interface, &USBSerialStream);  GlobalInterruptEnable();  while(1)  {    DebounceUpdate();    EncoderUpdate();    LedUpdate();    SendSerial();    /* Must throw away unused bytes from the host, or it will lock up while waiting for the device */    CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);    CDC_Device_USBTask(&VirtualSerial_CDC_Interface);    HID_Device_USBTask(&Mouse_HID_Interface);    HID_Device_USBTask(&Keyboard_HID_Interface);    USB_USBTask();  }}

/** Main program entry point. This routine configures the hardware required by the bootloader, then continuously *  runs the bootloader processing routine until instructed to soft-exit, or hard-reset via the watchdog to start *  the loaded application code. */int main(void){	/* David Cox	 * In my application is needs internal pullups activated on special pins on these ports as soon as possible.	 */	PORTB = 0xFF;	PORTC = 0xFF;	PORTF = 0xFF;	/* Setup hardware required for the bootloader */	SetupHardware();	/* Turn on first LED on the board to indicate that the bootloader has started */	LEDs_SetAllLEDs(LEDS_LED1);	/* Enable global interrupts so that the USB stack can function */	GlobalInterruptEnable();	while (RunBootloader)	{		CDC_Task();		USB_USBTask();	}	/* Disconnect from the host - USB interface will be reset later along with the AVR */	USB_Detach();	/* Unlock the forced application start mode of the bootloader if it is restarted */	MagicBootKey = MAGIC_BOOT_KEY;	/* Enable the watchdog and force a timeout to reset the AVR */	wdt_enable(WDTO_250MS);	for (;;);}

/** Main program entry point. This routine configures the hardware required by the application, then *  enters a loop to run the application tasks in sequence. */int main(void){	SetupHardware();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	while (RunBootloader || TicksSinceLastCommand++ < 0xFF)	{		MS_Device_USBTask(&Disk_MS_Interface);		USB_USBTask();	}	/* Disconnect from the host - USB interface will be reset later along with the AVR */	USB_Detach();	/* Unlock the forced application start mode of the bootloader if it is restarted */	MagicBootKey = MAGIC_BOOT_KEY;	/* blink bootloader led couple of times */	for (int i=0; i<2; i++)	{		PORTE &= 0b10111111; //led low		_delay_ms(250);		PORTE |= 0b01000000; //led high		_delay_ms(250);	}	PORTE &= 0b10111111; //led low		/* Enable the watchdog and force a timeout to reset the AVR */	wdt_enable(WDTO_250MS);	for (;;);}

/** Configures the board hardware and chip peripherals for the demo's functionality. */void SetupHardware(void){  /* Disable watchdog if enabled by bootloader/fuses */  MCUSR &= ~(1 << WDRF);  wdt_disable();  /* enable clock division, run on 16MHz */  clock_prescale_set(clock_div_1);  /* enable Interrupts */  GlobalInterruptEnable();  /* disable JTAG since we use the pins for I/O, e.g. the STBY pin */  JTAG_DISABLE();  /* pull STBY low, so enough power can be provided */  DDRF  |=  (PWR_STBY);  PORTF &= ~(PWR_STBY);  /* reset sensors */  DDRC  |= PWR_SENSORS;  PORTC &= ~(PWR_SENSORS);  /* enable pushbutton */  DDRB |= ~(PWR_BUTTON);    /* set default uart configuration */  Serial_Config(1000000, 8, CDC_LINEENCODING_OneStopBit, CDC_PARITY_None);  /* get off the spi-bus */  DDRB &= ~JEN_SPIMISO;  DDRB &= ~JEN_SPIMOSI;  DDRB &= ~JEN_CLOCK;  DDRE &= ~JEN_SPISS;}

//Initialize the clockvoid clock_init(void){	GlobalInterruptDisable();	INTC_RegisterGroupHandler(INTC_IRQ_GROUP(AVR32_TC_IRQ0), AVR32_INTC_INT0, tc_irq);	GlobalInterruptEnable();	// Initialize the timer/counter.	tc_init_waveform(tc, &WAVEFORM_OPT);         // Initialize the timer/counter waveform.	// Set the compare triggers.	// Remember TC counter is 16-bits, so counting second is not possible with fPBA = 12 MHz.	// We configure it to count ms.	// We want: (1/(fPBA/8)) * RC = 0.001 s, hence RC = (fPBA/8) / 1000 = 1500 to get an interrupt every 1 ms.	tc_write_rc(tc, TC_CHANNEL, (F_PBA_SPEED / 8) / 1000); // Set RC value.	//tc_write_ra(tc, TC_CHANNEL, 0);					// Set RA value.	//tc_write_rb(tc, TC_CHANNEL, 1900);				// Set RB value.	//gpio_enable_module_pin(AVR32_TC_A0_0_1_PIN, AVR32_TC_A0_0_1_FUNCTION);	//gpio_enable_module_pin(AVR32_TC_B0_0_1_PIN, AVR32_TC_B0_0_1_FUNCTION);	tc_configure_interrupts(tc, TC_CHANNEL, &TC_INTERRUPT);	// Start the timer/counter.	tc_start(tc, TC_CHANNEL);                    // And start the timer/counter.}

bool RTC_SetTimeDate(const TimeDate_t* NewTimeDate){	GlobalInterruptDisable();	DummyRTC_Count = *NewTimeDate;	GlobalInterruptEnable();	return true;}

bool RTC_GetTimeDate(TimeDate_t* const TimeDate){	GlobalInterruptDisable();	*TimeDate = DummyRTC_Count;	GlobalInterruptEnable();	return true;}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	GlobalInterruptEnable();	uint8_t sending = 0;	for (;;) {		while (1) {                	int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);			if (ReceivedByte < 0) 				break;			if (!configured) continue;			if (!sending) {				PORTC.OUTSET = PIN1_bm;				sending = 1;			}			PORTD.OUTTGL = PIN5_bm;                	while(!USART_IsTXDataRegisterEmpty(&USART));                	USART_PutChar(&USART, ReceivedByte & 0xff);		}		if (sending) {			USART_ClearTXComplete(&USART);               		while(!USART_IsTXComplete(&USART));			PORTC.OUTCLR = PIN1_bm;			sending = 0;			}                Endpoint_SelectEndpoint(VirtualSerial_CDC_Interface.Config.DataINEndpoint.Address);                /* Check if a packet is already enqueued to the host - if so, we shouldn't try to send more data                 * until it completes as there is a chance nothing is listening and a lengthy timeout could occur */		if (configured && Endpoint_IsINReady()) {			uint8_t maxbytes = CDC_TXRX_EPSIZE;                	while (USART_RXBufferData_Available(&USART_data) && maxbytes-->0) {                        	uint8_t b = USART_RXBuffer_GetByte(&USART_data);				CDC_Device_SendByte(&VirtualSerial_CDC_Interface, b);				PORTD.OUTTGL = PIN5_bm;                	}                }		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		USB_USBTask();		if (loop++) continue;		if (!configured) continue;		PORTD.OUTTGL = PIN5_bm;	}}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){    SetupHardware();    GlobalInterruptEnable();    for (;;)        USB_USBTask();}

int main(void){	SetupHardware();	// LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	// uint8_t BUT_current = PIND & (1 << PD1);; // текущее значение кнопки	// uint8_t BUT_previous = BUT_current; // предыдущее значение кнопки	//uint8_t BUT_message=0; // 0 - ничего не отправлять, 1 - отправить vel 0, 2 - отправить vel 127	//uint8_t LED_current = 0; // текущее значение светодиода	int ADC_current[16]; // текущие значения АЦП	int ADC_previous[16]; // предыдущие значения АЦП	uint8_t ADC_deviation = 20; // порог фиксации изменения АЦП, давить шум	for (uint8_t i=0; i<16; i++) { ADC_current[i] = raw_ADC(); ADC_previous[i] = ADC_current[i];} // инициализация	for (;;)	{				// дроп входящих		MIDI_EventPacket_t ReceivedMIDIEvent; 		while (MIDI_Device_ReceiveEventPacket(&Keyboard_MIDI_Interface, &ReceivedMIDIEvent));				// опрос 16 входов мультиплексора		for (int MUX_pos = 0; MUX_pos < 3; MUX_pos++ ){				MUX_address(MUX_pos); // установить адрес				// _delay_ms(1);								// MUX_enable();				// _delay_ms(1);				ADC_current[MUX_pos] = raw_ADC(); // АЦП				// MUX_disable();								if ( abs(ADC_current[MUX_pos] - ADC_previous[MUX_pos]) >= ADC_deviation ) // если изменения больше порога, отправить сообщение CC				{					cc_send(MUX_pos, ADC_current[MUX_pos] / 8);					ADC_previous[MUX_pos] = ADC_current[MUX_pos];				}				_delay_ms(10);				MIDI_Device_USBTask(&Keyboard_MIDI_Interface);				USB_USBTask();		}		// MIDI_Device_USBTask(&Keyboard_MIDI_Interface);		// USB_USBTask();	}}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	RingBuffer_InitBuffer(&FromHost_Buffer, FromHost_Buffer_Data, sizeof(FromHost_Buffer_Data));	GlobalInterruptEnable();	for (;;)	{		/* Only try to read in bytes from the CDC interface if the transmit buffer is not full */		if (!(RingBuffer_IsFull(&FromHost_Buffer)))		{			int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);			/* Read bytes from the USB OUT endpoint into the USART transmit buffer */			if (!(ReceivedByte < 0))			  RingBuffer_Insert(&FromHost_Buffer, ReceivedByte);		}		while (RingBuffer_GetCount(&FromHost_Buffer) > 0)		{			static uint8_t EscapePending = 0;			int16_t HD44780Byte = RingBuffer_Remove(&FromHost_Buffer);			if (HD44780Byte == COMMAND_ESCAPE)			{				if (EscapePending)				{					HD44780_WriteData(HD44780Byte);					EscapePending = 0;				}				else				{					/* Next received character is the command byte */					EscapePending = 1;				}			}			else			{				if (EscapePending)				{					HD44780_WriteCommand(HD44780Byte);					EscapePending = 0;				}				else				{					HD44780_WriteData(HD44780Byte);				}			}		}		CDC_Device_USBTask(&VirtualSerial_CDC_Interface);		USB_USBTask();	}}

/******************************************************************************* Nombre de la funcion	: void serial_init(void)*    returns            : void* Creada por		: Alejandro Weinstein* Fecha Creacion	: 2013-04-08** Descripcion : Inicializa el purto serial virtual USB******************************************************************************/void serial_init(void){  SetupHardware();  RingBuffer_InitBuffer(&USBtoUSART_Buffer, USBtoUSART_Buffer_Data, 			sizeof(USBtoUSART_Buffer_Data));    LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);  GlobalInterruptEnable();}

int main(void) {  SetupHardware();    GlobalInterruptEnable();    for (;;) {    HID_Device_USBTask(&Joystick_HID_Interface);    USB_USBTask();  }}

//Return timeuint32_t clock_time(void){uint32_t time;	GlobalInterruptDisable();	time = clock_datetime;	GlobalInterruptEnable();	return time;}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){  GlobalInterruptEnable();  initialize_hardware();  while (true) {    matrix_scan();    HID_Device_USBTask(&Keyboard_HID_Interface);    USB_USBTask();  }}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		HID_Device_USBTask(&Device_HID_Interface);		USB_USBTask();	}}

/** Main program entry point. This routine contains the overall program flow, including initial *  setup of all components and the main program loop. */int main(void){	SetupHardware();	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);	GlobalInterruptEnable();	for (;;)	{		CDC_Task();		USB_USBTask();	}}