X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/ece9e3d5991dd481fc36baf799a1a85d14b88251..4a8ac5e474741f14492597880e751b3f806cb965:/Demos/Device/Keyboard/Keyboard.c?ds=sidebyside

diff --git a/Demos/Device/Keyboard/Keyboard.c b/Demos/Device/Keyboard/Keyboard.c
index 265e950e0..6abd193f4 100644
--- a/Demos/Device/Keyboard/Keyboard.c
+++ b/Demos/Device/Keyboard/Keyboard.c
@@ -37,22 +37,11 @@
  
 #include "Keyboard.h"
 
-/* Project Tags, for reading out using the ButtLoad project */
-BUTTLOADTAG(ProjName,    "LUFA Keyboard App");
-BUTTLOADTAG(BuildTime,   __TIME__);
-BUTTLOADTAG(BuildDate,   __DATE__);
-BUTTLOADTAG(LUFAVersion, "LUFA V" LUFA_VERSION_STRING);
-
 /* Scheduler Task List */
 TASK_LIST
 {
-	#if !defined(INTERRUPT_CONTROL_ENDPOINT)
-	{ Task: USB_USBTask          , TaskStatus: TASK_STOP },
-	#endif
-	
-	#if !defined(INTERRUPT_DATA_ENDPOINT)
-	{ Task: USB_Keyboard_Report  , TaskStatus: TASK_STOP },
-	#endif
+	{ .Task = USB_USBTask          , .TaskStatus = TASK_STOP },	
+	{ .Task = USB_Keyboard_Report  , .TaskStatus = TASK_STOP },
 };
 
 /* Global Variables */
@@ -62,12 +51,12 @@ TASK_LIST
 bool UsingReportProtocol = true;
 
 /** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
- *  for either the entire idle duration, or until the report status changes (e.g. the user moves the mouse).
+ *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
  */
-uint8_t IdleCount = 0;
+uint16_t IdleCount = 500;
 
 /** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
- *  milliseconds. This is seperate to the IdleCount timer and is incremented and compared as the host may request 
+ *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request 
  *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
  */
 uint16_t IdleMSRemaining = 0;
@@ -111,12 +100,10 @@ int main(void)
 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
  *  starts the library USB task to begin the enumeration and USB management process.
  */
-EVENT_HANDLER(USB_Connect)
+void EVENT_USB_Connect(void)
 {
-	#if !defined(INTERRUPT_CONTROL_ENDPOINT)
 	/* Start USB management task */
 	Scheduler_SetTaskMode(USB_USBTask, TASK_RUN);
-	#endif
 
 	/* Indicate USB enumerating */
 	UpdateStatus(Status_USBEnumerating);
@@ -125,34 +112,14 @@ EVENT_HANDLER(USB_Connect)
 	UsingReportProtocol = true;
 }
 
-/** Event handler for the USB_Reset event. This fires when the USB interface is reset by the USB host, before the
- *  enumeration process begins, and enables the control endpoint interrupt so that control requests can be handled
- *  asynchronously when they arrive rather than when the control endpoint is polled manually.
- */
-EVENT_HANDLER(USB_Reset)
-{
-	#if defined(INTERRUPT_CONTROL_ENDPOINT)
-	/* Select the control endpoint */
-	Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
-
-	/* Enable the endpoint SETUP interrupt ISR for the control endpoint */
-	USB_INT_Enable(ENDPOINT_INT_SETUP);
-	#endif
-}
-
 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
  *  the status LEDs.
  */
-EVENT_HANDLER(USB_Disconnect)
+void EVENT_USB_Disconnect(void)
 {
 	/* Stop running keyboard reporting and USB management tasks */
-	#if !defined(INTERRUPT_DATA_ENDPOINT)
 	Scheduler_SetTaskMode(USB_Keyboard_Report, TASK_STOP);
-	#endif
-
-	#if !defined(INTERRUPT_CONTROL_ENDPOINT)
 	Scheduler_SetTaskMode(USB_USBTask, TASK_STOP);
-	#endif
 	
 	/* Indicate USB not ready */
 	UpdateStatus(Status_USBNotReady);
@@ -161,165 +128,134 @@ EVENT_HANDLER(USB_Disconnect)
 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
  *  of the USB device after enumeration, and configures the keyboard device endpoints.
  */
-EVENT_HANDLER(USB_ConfigurationChanged)
+void EVENT_USB_ConfigurationChanged(void)
 {
 	/* Setup Keyboard Keycode Report Endpoint */
 	Endpoint_ConfigureEndpoint(KEYBOARD_EPNUM, EP_TYPE_INTERRUPT,
 		                       ENDPOINT_DIR_IN, KEYBOARD_EPSIZE,
 	                           ENDPOINT_BANK_SINGLE);
 
-	#if defined(INTERRUPT_DATA_ENDPOINT)
-	/* Enable the endpoint IN interrupt ISR for the report endpoint */
-	USB_INT_Enable(ENDPOINT_INT_IN);
-	#endif
-
 	/* Setup Keyboard LED Report Endpoint */
 	Endpoint_ConfigureEndpoint(KEYBOARD_LEDS_EPNUM, EP_TYPE_INTERRUPT,
 		                       ENDPOINT_DIR_OUT, KEYBOARD_EPSIZE,
 	                           ENDPOINT_BANK_SINGLE);
 
-	#if defined(INTERRUPT_DATA_ENDPOINT)
-	/* Enable the endpoint OUT interrupt ISR for the LED report endpoint */
-	USB_INT_Enable(ENDPOINT_INT_OUT);
-	#endif
-
 	/* Indicate USB connected and ready */
 	UpdateStatus(Status_USBReady);
 
-	#if !defined(INTERRUPT_DATA_ENDPOINT)
 	/* Start running keyboard reporting task */
 	Scheduler_SetTaskMode(USB_Keyboard_Report, TASK_RUN);
-	#endif
 }
 
 /** Event handler for the USB_UnhandledControlPacket event. This is used to catch standard and class specific
  *  control requests that are not handled internally by the USB library (including the HID commands, which are
  *  all issued via the control endpoint), so that they can be handled appropriately for the application.
  */
-EVENT_HANDLER(USB_UnhandledControlPacket)
+void EVENT_USB_UnhandledControlPacket(void)
 {
 	/* Handle HID Class specific requests */
-	switch (bRequest)
+	switch (USB_ControlRequest.bRequest)
 	{
 		case REQ_GetReport:
-			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 			{
 				USB_KeyboardReport_Data_t KeyboardReportData;
 
+				Endpoint_ClearSETUP();
+	
 				/* Create the next keyboard report for transmission to the host */
 				CreateKeyboardReport(&KeyboardReportData);
 
-				/* Ignore report type and ID number value */
-				Endpoint_Discard_Word();
-				
-				/* Ignore unused Interface number value */
-				Endpoint_Discard_Word();
-
-				/* Read in the number of bytes in the report to send to the host */
-				uint16_t wLength = Endpoint_Read_Word_LE();
-				
-				/* If trying to send more bytes than exist to the host, clamp the value at the report size */
-				if (wLength > sizeof(KeyboardReportData))
-				  wLength = sizeof(KeyboardReportData);
-
-				Endpoint_ClearSetupReceived();
-	
 				/* Write the report data to the control endpoint */
-				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, wLength);
+				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
 				
 				/* Finalize the stream transfer to send the last packet or clear the host abort */
-				Endpoint_ClearSetupOUT();
+				Endpoint_ClearOUT();
 			}
 		
 			break;
 		case REQ_SetReport:
-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 			{
-				Endpoint_ClearSetupReceived();
+				Endpoint_ClearSETUP();
 				
 				/* Wait until the LED report has been sent by the host */
-				while (!(Endpoint_IsSetupOUTReceived()));
+				while (!(Endpoint_IsOUTReceived()));
 
 				/* Read in the LED report from the host */
 				uint8_t LEDStatus = Endpoint_Read_Byte();
 
-				/* Process the incomming LED report */
+				/* Process the incoming LED report */
 				ProcessLEDReport(LEDStatus);
 			
 				/* Clear the endpoint data */
-				Endpoint_ClearSetupOUT();
+				Endpoint_ClearOUT();
 
 				/* Acknowledge status stage */
-				while (!(Endpoint_IsSetupINReady()));
-				Endpoint_ClearSetupIN();
+				while (!(Endpoint_IsINReady()));
+				Endpoint_ClearIN();
 			}
 			
 			break;
 		case REQ_GetProtocol:
-			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 			{
-				Endpoint_ClearSetupReceived();
+				Endpoint_ClearSETUP();
 				
 				/* Write the current protocol flag to the host */
 				Endpoint_Write_Byte(UsingReportProtocol);
 				
 				/* Send the flag to the host */
-				Endpoint_ClearSetupIN();
+				Endpoint_ClearIN();
 
 				/* Acknowledge status stage */
-				while (!(Endpoint_IsSetupOUTReceived()));
-				Endpoint_ClearSetupOUT();
+				while (!(Endpoint_IsOUTReceived()));
+				Endpoint_ClearOUT();
 			}
 			
 			break;
 		case REQ_SetProtocol:
-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 			{
-				/* Read in the wValue parameter containing the new protocol mode */
-				uint16_t wValue = Endpoint_Read_Word_LE();
-								
-				Endpoint_ClearSetupReceived();
+				Endpoint_ClearSETUP();
 
 				/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
-				UsingReportProtocol = (wValue != 0x0000);
+				UsingReportProtocol = (USB_ControlRequest.wValue != 0);
 
 				/* Acknowledge status stage */
-				while (!(Endpoint_IsSetupINReady()));
-				Endpoint_ClearSetupIN();
+				while (!(Endpoint_IsINReady()));
+				Endpoint_ClearIN();
 			}
 			
 			break;
 		case REQ_SetIdle:
-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
 			{
-				/* Read in the wValue parameter containing the idle period */
-				uint16_t wValue = Endpoint_Read_Word_LE();
-				
-				Endpoint_ClearSetupReceived();
+				Endpoint_ClearSETUP();
 				
 				/* Get idle period in MSB */
-				IdleCount = (wValue >> 8);
+				IdleCount = (USB_ControlRequest.wValue >> 8);
 				
 				/* Acknowledge status stage */
-				while (!(Endpoint_IsSetupINReady()));
-				Endpoint_ClearSetupIN();
+				while (!(Endpoint_IsINReady()));
+				Endpoint_ClearIN();
 			}
 			
 			break;
 		case REQ_GetIdle:
-			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
+			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 			{		
-				Endpoint_ClearSetupReceived();
+				Endpoint_ClearSETUP();
 				
 				/* Write the current idle duration to the host */
 				Endpoint_Write_Byte(IdleCount);
 				
 				/* Send the flag to the host */
-				Endpoint_ClearSetupIN();
+				Endpoint_ClearIN();
 
 				/* Acknowledge status stage */
-				while (!(Endpoint_IsSetupOUTReceived()));
-				Endpoint_ClearSetupOUT();
+				while (!(Endpoint_IsOUTReceived()));
+				Endpoint_ClearOUT();
 			}
 
 			break;
@@ -383,7 +319,7 @@ void ProcessLEDReport(uint8_t LEDReport)
 }
 
 /** Sends the next HID report to the host, via the keyboard data endpoint. */
-static inline void SendNextReport(void)
+void SendNextReport(void)
 {
 	static USB_KeyboardReport_Data_t PrevKeyboardReportData;
 	USB_KeyboardReport_Data_t        KeyboardReportData;
@@ -392,57 +328,58 @@ static inline void SendNextReport(void)
 	/* Create the next keyboard report for transmission to the host */
 	CreateKeyboardReport(&KeyboardReportData);
 	
-	/* Check if the idle period is set */
-	if (IdleCount)
-	{
-		/* Check if idle period has elapsed */
-		if (!(IdleMSRemaining))
-		{
-			/* Reset the idle time remaining counter, must multiply by 4 to get the duration in milliseconds */
-			IdleMSRemaining = (IdleCount << 2);
-		}
-		else
-		{
-			/* Idle period not elapsed, indicate that a report must not be sent unless the report has changed */
-			SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
-		}
-	}
+	/* Check to see if the report data has changed - if so a report MUST be sent */
+	SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
 	
 	/* Save the current report data for later comparison to check for changes */
 	PrevKeyboardReportData = KeyboardReportData;
-
+	
+	/* Check if the idle period is set and has elapsed */
+	if ((IdleCount != HID_IDLE_CHANGESONLY) && (!(IdleMSRemaining)))
+	{
+		/* Reset the idle time remaining counter, must multiply by 4 to get the duration in milliseconds */
+		IdleMSRemaining = (IdleCount << 2);
+		
+		/* Idle period is set and has elapsed, must send a report to the host */
+		SendReport = true;
+	}
+	
 	/* Select the Keyboard Report Endpoint */
 	Endpoint_SelectEndpoint(KEYBOARD_EPNUM);
 
-	/* Check if Keyboard Endpoint Ready for Read/Write, and if we should send a report */
-	if (Endpoint_ReadWriteAllowed() && SendReport)
+	/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
+	if (Endpoint_IsReadWriteAllowed() && SendReport)
 	{
 		/* Write Keyboard Report Data */
 		Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
-
+		
 		/* Finalize the stream transfer to send the last packet */
-		Endpoint_ClearCurrentBank();
+		Endpoint_ClearIN();
 	}
 }
 
 /** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
-static inline void ReceiveNextReport(void)
+void ReceiveNextReport(void)
 {
 	/* Select the Keyboard LED Report Endpoint */
 	Endpoint_SelectEndpoint(KEYBOARD_LEDS_EPNUM);
 
-	/* Check if Keyboard LED Endpoint Ready for Read/Write */
-	if (!(Endpoint_ReadWriteAllowed()))
-	  return;
-
-	/* Read in the LED report from the host */
-	uint8_t LEDReport = Endpoint_Read_Byte();
+	/* Check if Keyboard LED Endpoint contains a packet */
+	if (Endpoint_IsOUTReceived())
+	{
+		/* Check to see if the packet contains data */
+		if (Endpoint_IsReadWriteAllowed())
+		{
+			/* Read in the LED report from the host */
+			uint8_t LEDReport = Endpoint_Read_Byte();
 
-	/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
-	Endpoint_ClearCurrentBank();
+			/* Process the read LED report from the host */
+			ProcessLEDReport(LEDReport);
+		}
 
-	/* Process the read LED report from the host */
-	ProcessLEDReport(LEDReport);
+		/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
+		Endpoint_ClearOUT();
+	}
 }
 
 /** Function to manage status updates to the user. This is done via LEDs on the given board, if available, but may be changed to
@@ -472,7 +409,6 @@ void UpdateStatus(uint8_t CurrentStatus)
 	LEDs_SetAllLEDs(LEDMask);
 }
 
-#if !defined(INTERRUPT_DATA_ENDPOINT)
 /** Function to manage HID report generation and transmission to the host, when in report mode. */
 TASK(USB_Keyboard_Report)
 {
@@ -486,62 +422,3 @@ TASK(USB_Keyboard_Report)
 		ReceiveNextReport();
 	}
 }
-#endif
-
-/** ISR for the general Pipe/Endpoint interrupt vector. This ISR fires when an endpoint's status changes (such as
- *  a packet has been received) on an endpoint with its corresponding ISR enabling bits set. This is used to send
- *  HID packets to the host each time the HID interrupt endpoints polling period elapses, as managed by the USB
- *  controller. It is also used to respond to standard and class specific requests send to the device on the control
- *  endpoint, by handing them off to the LUFA library when they are received.
- */
-ISR(ENDPOINT_PIPE_vect, ISR_BLOCK)
-{
-	#if defined(INTERRUPT_CONTROL_ENDPOINT)
-	/* Check if the control endpoint has received a request */
-	if (Endpoint_HasEndpointInterrupted(ENDPOINT_CONTROLEP))
-	{
-		/* Clear the endpoint interrupt */
-		Endpoint_ClearEndpointInterrupt(ENDPOINT_CONTROLEP);
-
-		/* Process the control request */
-		USB_USBTask();
-
-		/* Handshake the endpoint setup interrupt - must be after the call to USB_USBTask() */
-		USB_INT_Clear(ENDPOINT_INT_SETUP);
-	}
-	#endif
-
-	#if defined(INTERRUPT_DATA_ENDPOINT)
-	/* Check if keyboard endpoint has interrupted */
-	if (Endpoint_HasEndpointInterrupted(KEYBOARD_EPNUM))
-	{
-		/* Select the Keyboard Report Endpoint */
-		Endpoint_SelectEndpoint(KEYBOARD_EPNUM);
-
-		/* Clear the endpoint IN interrupt flag */
-		USB_INT_Clear(ENDPOINT_INT_IN);
-
-		/* Clear the Keyboard Report endpoint interrupt */
-		Endpoint_ClearEndpointInterrupt(KEYBOARD_EPNUM);
-
-		/* Send the next keypress report to the host */
-		SendNextReport();
-	}
-
-	/* Check if Keyboard LED status Endpoint has interrupted */
-	if (Endpoint_HasEndpointInterrupted(KEYBOARD_LEDS_EPNUM))
-	{
-		/* Select the Keyboard LED Report Endpoint */
-		Endpoint_SelectEndpoint(KEYBOARD_LEDS_EPNUM);
-
-		/* Clear the endpoint OUT interrupt flag */
-		USB_INT_Clear(ENDPOINT_INT_OUT);
-
-		/* Clear the Keyboard LED Report endpoint interrupt */
-		Endpoint_ClearEndpointInterrupt(KEYBOARD_LEDS_EPNUM);
-
-		/* Process the LED report sent from the host */
-		ReceiveNextReport();
-	}
-	#endif
-}