Fix demos based on the device mode HID class driver, as well as the driver itself. Changed HID device class driver to require the user to give a buffer and size to hold the previously generated report, for comparison purposes, and altered the prototype of the CALLBACK_HID_Device_CreateHIDReport() function so that reports can be sent to the host even if there are no apparent changes (useful for relative movements in mice, etc.).

Demos/Device/ClassDriver/GenericHID/GenericHID.c

@@ -36,6 +36,9 @@
 
 #include "GenericHID.h"
 
+/** Buffer to hold the previously generated HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevHIDReportBuffer[GENERIC_REPORT_SIZE];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another.
@@ -48,6 +51,9 @@ USB_ClassInfo_HID_Device_t Generic_HID_Interface =
 
 				.ReportINEndpointNumber  = GENERIC_IN_EPNUM,
 				.ReportINEndpointSize    = GENERIC_EPSIZE,
+				
+				.PrevReportINBuffer      = PrevHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevHIDReportBuffer),
 			},
 	};
 
@@ -126,14 +132,17 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes written in the report (or zero if no report is to be sent
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	// Create generic HID report here
 	
-	return 0;
+	*ReportSize = 0;
+	return true;
 }
 
 /** HID class driver callback function for the processing of HID reports from the host.

Demos/Device/ClassDriver/GenericHID/GenericHID.h

@@ -72,8 +72,8 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                             void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
 		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);
 		

Demos/Device/ClassDriver/Joystick/Joystick.c

@@ -36,6 +36,9 @@
 
 #include "Joystick.h"
 
+/** Buffer to hold the previously generated HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevJoystickHIDReportBuffer[sizeof(USB_JoystickReport_Data_t)];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another.
@@ -48,6 +51,9 @@ USB_ClassInfo_HID_Device_t Joystick_HID_Interface =
 
 				.ReportINEndpointNumber  = JOYSTICK_EPNUM,
 				.ReportINEndpointSize    = JOYSTICK_EPSIZE,
+
+				.PrevReportINBuffer      = PrevJoystickHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevJoystickHIDReportBuffer),
 			},
 	};
 
@@ -128,10 +134,12 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes written in the report (or zero if no report is to be sent
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	USB_JoystickReport_Data_t* JoystickReport = (USB_JoystickReport_Data_t*)ReportData;
 	
@@ -154,7 +162,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 	if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 	  JoystickReport->Button |= (1 << 0);
 	  
-	return sizeof(USB_JoystickReport_Data_t);
+	*ReportSize = sizeof(USB_JoystickReport_Data_t);
+	return false;
 }
 
 /** HID class driver callback function for the processing of HID reports from the host.

Demos/Device/ClassDriver/Joystick/Joystick.h

@@ -83,9 +83,9 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateNextHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                                 void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
-		void     CALLBACK_HID_Device_ProcessReceivedHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, const uint8_t ReportID, 
+		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);
 
 #endif

Demos/Device/ClassDriver/Keyboard/Keyboard.c

@@ -37,6 +37,9 @@
 
 #include "Keyboard.h"
 
+/** Buffer to hold the previously generated Keyboard HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevKeyboardHIDReportBuffer[sizeof(USB_KeyboardReport_Data_t)];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another.
@@ -49,6 +52,9 @@ USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
 
 				.ReportINEndpointNumber  = KEYBOARD_EPNUM,
 				.ReportINEndpointSize    = KEYBOARD_EPSIZE,
+
+				.PrevReportINBuffer      = PrevKeyboardHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevKeyboardHIDReportBuffer),
 			},
     };
 
@@ -129,10 +135,12 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes written in the report (or zero if no report is to be sent
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
 	
@@ -155,7 +163,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 	if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 	  KeyboardReport->KeyCode[0] = 0x09; // F
 	
-	return sizeof(USB_KeyboardReport_Data_t);
+	*ReportSize = sizeof(USB_KeyboardReport_Data_t);
+	return false;
 }
 
 /** HID class driver callback function for the processing of HID reports from the host.

Demos/Device/ClassDriver/Keyboard/Keyboard.h

@@ -86,8 +86,8 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                             void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
 		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);
 

Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.c

@@ -37,6 +37,12 @@
 
 #include "KeyboardMouse.h"
 
+/** Buffer to hold the previously generated Keyboard HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevKeyboardHIDReportBuffer[sizeof(USB_KeyboardReport_Data_t)];
+
+/** Buffer to hold the previously generated Mouse HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevMouseHIDReportBuffer[sizeof(USB_MouseReport_Data_t)];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another. This is for the keyboard HID
@@ -50,6 +56,9 @@ USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
 
 				.ReportINEndpointNumber  = KEYBOARD_IN_EPNUM,
 				.ReportINEndpointSize    = HID_EPSIZE,
+
+				.PrevReportINBuffer      = PrevKeyboardHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevKeyboardHIDReportBuffer),
 			},
 	};
 	
@@ -66,6 +75,9 @@ USB_ClassInfo_HID_Device_t Mouse_HID_Interface =
 
 				.ReportINEndpointNumber  = MOUSE_IN_EPNUM,
 				.ReportINEndpointSize    = HID_EPSIZE,
+
+				.PrevReportINBuffer      = PrevMouseHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevMouseHIDReportBuffer),
 			},		
 	};
 
@@ -151,10 +163,12 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes written in the report (or zero if no report is to be sent
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	uint8_t JoyStatus_LCL    = Joystick_GetStatus();
 	uint8_t ButtonStatus_LCL = Buttons_GetStatus();
@@ -180,7 +194,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 		if (JoyStatus_LCL & JOY_PRESS)
 		  KeyboardReport->KeyCode[0] = 0x08; // E
 		
-		return sizeof(USB_KeyboardReport_Data_t);
+		*ReportSize = sizeof(USB_KeyboardReport_Data_t);
+		return false;
 	}
 	else
 	{
@@ -203,7 +218,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 		if (JoyStatus_LCL & JOY_PRESS)
 		  MouseReport->Button  = (1 << 0);
 		
-		return sizeof(USB_MouseReport_Data_t);		
+		*ReportSize = sizeof(USB_MouseReport_Data_t);
+		return true;		
 	}
 }
 

Demos/Device/ClassDriver/KeyboardMouse/KeyboardMouse.h

@@ -90,8 +90,8 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                             void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
 		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);
 		

Demos/Device/ClassDriver/Mouse/Mouse.c

@@ -36,6 +36,9 @@
 
 #include "Mouse.h"
 
+/** Buffer to hold the previously generated Mouse HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevMouseHIDReportBuffer[sizeof(USB_MouseReport_Data_t)];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another.
@@ -48,6 +51,9 @@ USB_ClassInfo_HID_Device_t Mouse_HID_Interface =
 
 				.ReportINEndpointNumber  = MOUSE_EPNUM,
 				.ReportINEndpointSize    = MOUSE_EPSIZE,
+
+				.PrevReportINBuffer      = PrevMouseHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevMouseHIDReportBuffer),
 			},
 	};
 
@@ -128,10 +134,12 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
  *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
  *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes written in the report (or zero if no report is to be sent
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	USB_MouseReport_Data_t* MouseReport = (USB_MouseReport_Data_t*)ReportData;
 		
@@ -154,7 +162,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 	if (ButtonStatus_LCL & BUTTONS_BUTTON1)
 	  MouseReport->Button |= (1 << 1);
 	
-	return sizeof(USB_MouseReport_Data_t);
+	*ReportSize = sizeof(USB_MouseReport_Data_t);
+	return true;
 }
 
 /** HID class driver callback function for the processing of HID reports from the host.

Demos/Device/ClassDriver/Mouse/Mouse.h

@@ -85,8 +85,8 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                             void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
 		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);
 

LUFA/Drivers/USB/Class/Device/HID.c

@@ -51,15 +51,15 @@ void HID_Device_ProcessControlPacket(USB_ClassInfo_HID_Device_t* const HIDInterf
 			{
 				Endpoint_ClearSETUP();	
 
-				uint8_t  ReportINData[HID_MAX_REPORT_SIZE];
 				uint16_t ReportINSize;
 				uint8_t  ReportID = (USB_ControlRequest.wValue & 0xFF);
 
-				memset(ReportINData, 0, sizeof(ReportINData));
+				memset(HIDInterfaceInfo->Config.PrevReportINBuffer, 0, HIDInterfaceInfo->Config.PrevReportINBufferSize);
 				
-				ReportINSize = CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, ReportINData);
+				CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID,
+				                                    HIDInterfaceInfo->Config.PrevReportINBuffer, &ReportINSize);
 
-				Endpoint_Write_Control_Stream_LE(ReportINData, ReportINSize);
+				Endpoint_Write_Control_Stream_LE(HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINSize);
 				Endpoint_ClearOUT();
 			}
 		
@@ -157,20 +157,20 @@ void HID_Device_USBTask(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo)
 	
 	if (Endpoint_IsReadWriteAllowed())
 	{
-		uint8_t  ReportINData[HID_MAX_REPORT_SIZE];
+		uint8_t  ReportINData[HIDInterfaceInfo->Config.PrevReportINBufferSize];
 		uint8_t  ReportID = 0;
 		uint16_t ReportINSize;
 
 		memset(ReportINData, 0, sizeof(ReportINData));
 
-		ReportINSize  = CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, ReportINData);
+		bool ForceSend = CALLBACK_HID_Device_CreateHIDReport(HIDInterfaceInfo, &ReportID, ReportINData, &ReportINSize);
 
-		bool StatesChanged     = (memcmp(ReportINData, HIDInterfaceInfo->State.PreviousReportINData, ReportINSize) != 0);
+		bool StatesChanged     = (memcmp(ReportINData, HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINSize) != 0);
 		bool IdlePeriodElapsed = (HIDInterfaceInfo->State.IdleCount && !(HIDInterfaceInfo->State.IdleMSRemaining));
 		
-		memcpy(HIDInterfaceInfo->State.PreviousReportINData, ReportINData, ReportINSize);
+		memcpy(HIDInterfaceInfo->Config.PrevReportINBuffer, ReportINData, ReportINSize);
 
-		if (ReportINSize && (StatesChanged || IdlePeriodElapsed))
+		if (ReportINSize && (ForceSend || StatesChanged || IdlePeriodElapsed))
 		{
 			HIDInterfaceInfo->State.IdleMSRemaining = HIDInterfaceInfo->State.IdleCount;
 

LUFA/Drivers/USB/Class/Device/HID.h

@@ -56,17 +56,6 @@
 		#endif
 
 	/* Public Interface - May be used in end-application: */
-		/* Macros: */
-			#if !defined(HID_MAX_REPORT_SIZE)
-				/** Maximum size of an IN report which can be generated by the device and sent to the host, in bytes.
-				 *
-				 *  \note If larger reports than the default specified here are to be generated by the device, this
-				 *        value can be overridden by defining this token to the required value in the project makefile
-				 *        and passing it to the compiler via the -D switch.
-				 */
-				#define HID_MAX_REPORT_SIZE     16
-			#endif
-	
 		/* Type Defines: */
 			/** Class state structure. An instance of this structure should be made for each HID interface
 			 *  within the user application, and passed to each of the HID class driver functions as the
@@ -80,6 +69,16 @@
 
 					uint8_t  ReportINEndpointNumber; /**< Endpoint number of the HID interface's IN report endpoint */
 					uint16_t ReportINEndpointSize; /**< Size in bytes of the HID interface's IN report endpoint */					
+					
+					void*    PrevReportINBuffer; /** Pointer to a buffer where the previously created HID input report can be
+					                              *  stored by the driver, for comparison purposes to detect report changes that
+					                              *  must be sent immediately to the host. This should point to a buffer big enough
+					                              *  to hold the largest HID input report sent from the HID interface.
+					                              */
+					uint8_t  PrevReportINBufferSize; /** Size in bytes of the given input report buffer. This is used to create a
+					                                  *  second buffer of the same size within the driver so that subsequent reports
+					                                  *  can be compared.
+					                                  */
 				} Config; /**< Config data for the USB class interface within the device. All elements in this section
 				           *   <b>must</b> be set or the interface will fail to enumerate and operate correctly.
 				           */										 
@@ -89,8 +88,6 @@
 					uint16_t IdleCount; /**< Report idle period, in mS, set by the host */
 					uint16_t IdleMSRemaining; /**< Total number of mS remaining before the idle period elapsed - this should be
 											   *   decremented by the user application if non-zero each millisecond */	
-
-					uint8_t PreviousReportINData[HID_MAX_REPORT_SIZE]; /**< Previously generated report from the HID interface */
 				} State; /**< State data for the USB class interface within the device. All elements in this section
 				          *   are reset to their defaults when the interface is enumerated.
 				          */
@@ -137,10 +134,13 @@
 			 *                 be set to the report ID of the generated HID input report. If multiple reports are not sent via the
 			 *                 given HID interface, this parameter should be ignored.
 			 *  \param[out] ReportData  Pointer to a buffer where the generated HID report should be stored.
+			 *  \param[out] ReportSize  Number of bytes in the generated input report, or zero if no report is to be sent
 			 *
-			 *  \return  Number of bytes in the generated input report, or zero if no report is to be sent
+			 *  \return Boolean true to force the sending of the report even if it is identical to the previous report and still within
+			 *          the idle period (useful for devices which report relative movement), false otherwise
 			 */
-			uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* HIDInterfaceInfo, uint8_t* ReportID, void* ReportData);
+			bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                                     void* ReportData, uint16_t* ReportSize);
 			
 			/** HID class driver callback for the user processing of a received HID input report. This callback may fire in response to
 			 *  either HID class control requests from the host, or by the normal HID endpoint polling procedure. Inside this callback

Projects/Magstripe/Magstripe.c

@@ -45,6 +45,9 @@ BitBuffer_t TrackDataBuffers[TOTAL_TRACKS];
 /** Pointer to the current track buffer being sent to the host. */
 BitBuffer_t* CurrentTrackBuffer = &TrackDataBuffers[TOTAL_TRACKS];
 
+/** Buffer to hold the previously generated Keyboard HID report, for comparison purposes inside the HID class driver. */
+uint8_t PrevKeyboardHIDReportBuffer[sizeof(USB_KeyboardReport_Data_t)];
+
 /** LUFA HID Class driver interface configuration and state information. This structure is
  *  passed to all HID Class driver functions, so that multiple instances of the same class
  *  within a device can be differentiated from one another.
@@ -57,6 +60,9 @@ USB_ClassInfo_HID_Device_t Keyboard_HID_Interface =
 
 				.ReportINEndpointNumber  = KEYBOARD_EPNUM,
 				.ReportINEndpointSize    = KEYBOARD_EPSIZE,
+
+				.PrevReportINBuffer      = PrevKeyboardHIDReportBuffer,
+				.PrevReportINBufferSize  = sizeof(PrevKeyboardHIDReportBuffer),
 			},
 	};
 
@@ -156,15 +162,17 @@ ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 	HID_Device_MillisecondElapsed(&Keyboard_HID_Interface);
 }
 
-/** HID Class driver callback function for the creation of a HID report for the host.
+/** HID class driver callback function for the creation of HID reports to the host.
  *
- *  \param[in] HIDInterfaceInfo  Pointer to the HID interface structure for the HID interface being referenced
+ *  \param[in] HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
  *  \param[in,out] ReportID  Report ID requested by the host if non-zero, otherwise callback should set to the generated report ID
- *  \param[out] ReportData       Pointer to the preallocated report buffer where the created report should be stored
+ *  \param[out] ReportData  Pointer to a buffer where the created report should be stored
+ *  \param[out] ReportSize  Number of bytes written in the report (or zero if no report is to be sent
  *
- *  \return Number of bytes in the created report
+ *  \return Boolean true to force the sending of the report, false to let the library determine if it needs to be sent
  */
-uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, void* ReportData)
+bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+                                         void* ReportData, uint16_t* ReportSize)
 {
 	USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData;
 
@@ -190,7 +198,8 @@ uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const H
 		KeyboardReport->KeyCode = BitBuffer_GetNextBit(CurrentTrackBuffer) ? KEY_1 : KEY_0;
 	}
 	
-	return sizeof(USB_KeyboardReport_Data_t);
+	*ReportSize = sizeof(USB_KeyboardReport_Data_t);
+	return false;
 }
 
 /** HID Class driver callback function for the processing of a received HID report from the host.

Projects/Magstripe/Magstripe.h

@@ -85,8 +85,8 @@
 		void EVENT_USB_ConfigurationChanged(void);
 		void EVENT_USB_UnhandledControlPacket(void);
 
-		uint16_t CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
+		bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID,
-		                                             void* ReportData);
+                                                 void* ReportData, uint16_t* ReportSize);
 		void CALLBACK_HID_Device_ProcessHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, const uint8_t ReportID, 
 		                                          const void* ReportData, const uint16_t ReportSize);