X-Git-Url: http://git.linex4red.de/pub/USBasp.git/blobdiff_plain/ece9e3d5991dd481fc36baf799a1a85d14b88251..d37d419ffa419911d0488f50f65a77b1f8ecacce:/Demos/Device/GenericHID/GenericHID.c?ds=inline

diff --git a/Demos/Device/GenericHID/GenericHID.c b/Demos/Device/GenericHID/GenericHID.c
index cacbdc55c..b933e4506 100644
--- a/Demos/Device/GenericHID/GenericHID.c
+++ b/Demos/Device/GenericHID/GenericHID.c
@@ -30,39 +30,50 @@
 
 /** \file
  *
- *  Main source file for the GenericHID demo. This file contains the main tasks of the demo and
- *  is responsible for the initial application hardware configuration.
+ *  Main source file for the GenericHID demo. This file contains the main tasks of
+ *  the demo and is responsible for the initial application hardware configuration.
  */
 
 #include "GenericHID.h"
 
-/* Project Tags, for reading out using the ButtLoad project */
-BUTTLOADTAG(ProjName,    "LUFA GenHID 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_HID_Report       , TaskStatus: TASK_STOP },
-	#endif
-};
+/** 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.
+ */
+USB_ClassInfo_HID_t Generic_HID_Interface =
+	{
+		.InterfaceNumber         = 0,
 
-/** Static buffer to hold the last received report from the host, so that it can be echoed back in the next sent report */
-static uint8_t LastReceived[GENERIC_REPORT_SIZE];
+		.ReportINEndpointNumber  = GENERIC_IN_EPNUM,
+		.ReportINEndpointSize    = GENERIC_EPSIZE,
+		
+		.ReportOUTEndpointNumber = GENERIC_OUT_EPNUM,
+		.ReportOUTEndpointSize   = GENERIC_EPSIZE,
+		
+		.ReportINBufferSize      = GENERIC_REPORT_SIZE,
 
+		.UsingReportProtocol     = true,
+	};
 
-/** Main program entry point. This routine configures the hardware required by the application, then
- *  starts the scheduler to run the USB management task.
+/** 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);
+	
+	for (;;)
+	{
+		USB_HID_USBTask(&Generic_HID_Interface);
+		USB_USBTask();
+	}
+}
+
+/** 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();
@@ -70,314 +81,72 @@ int main(void)
 	/* Disable clock division */
 	clock_prescale_set(clock_div_1);
 
-	/* Indicate USB not ready */
-	UpdateStatus(Status_USBNotReady);
-
-	/* Initialize Scheduler so that it can be used */
-	Scheduler_Init();
-
-	/* Initialize USB Subsystem */
+	/* Hardware Initialization */
+	LEDs_Init();
 	USB_Init();
-	
-	/* Scheduling - routine never returns, so put this last in the main function */
-	Scheduler_Start();
-}
-
-/** 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
+	/* Millisecond timer initialization, with output compare interrupt enabled for the idle timing */
+	OCR0A  = ((F_CPU / 64) / 1000);
+	TCCR0A = (1 << WGM01);
+	TCCR0B = ((1 << CS01) | (1 << CS00));
+	TIMSK0 = (1 << OCIE0A);
 }
 
-/** 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)
+/** Event handler for the library USB Connection event. */
+void EVENT_USB_Connect(void)
 {
-	/* Indicate USB enumerating */
-	UpdateStatus(Status_USBEnumerating);
+	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 }
 
-/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
- *  the status LEDs and stops the USB management task.
- */
-EVENT_HANDLER(USB_Disconnect)
+/** Event handler for the library USB Disconnection event. */
+void EVENT_USB_Disconnect(void)
 {
-	/* Indicate USB not ready */
-	UpdateStatus(Status_USBNotReady);
+	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 }
 
-/** 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 generic HID device endpoints.
- */
-EVENT_HANDLER(USB_ConfigurationChanged)
+/** Event handler for the library USB Configuration Changed event. */
+void EVENT_USB_ConfigurationChanged(void)
 {
-	/* Setup Generic IN Report Endpoint */
-	Endpoint_ConfigureEndpoint(GENERIC_IN_EPNUM, EP_TYPE_INTERRUPT,
-		                       ENDPOINT_DIR_IN, GENERIC_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 Generic OUT Report Endpoint */
-	Endpoint_ConfigureEndpoint(GENERIC_OUT_EPNUM, EP_TYPE_INTERRUPT,
-		                       ENDPOINT_DIR_OUT, GENERIC_EPSIZE,
-	                           ENDPOINT_BANK_SINGLE);
-
-	#if defined(INTERRUPT_DATA_ENDPOINT)
-	/* Enable the endpoint OUT interrupt ISR for the report endpoint */
-	USB_INT_Enable(ENDPOINT_INT_OUT);
-	#endif
+	LEDs_SetAllLEDs(LEDMASK_USB_READY);
 
-	/* Indicate USB connected and ready */
-	UpdateStatus(Status_USBReady);
+	if (!(USB_HID_ConfigureEndpoints(&Generic_HID_Interface)))
+	  LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
 }
 
-/** 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)
+/** Event handler for the library USB Unhandled Control Packet event. */
+void EVENT_USB_UnhandledControlPacket(void)
 {
-	/* Handle HID Class specific requests */
-	switch (bRequest)
-	{
-		case REQ_GetReport:
-			if (bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
-			{
-				Endpoint_ClearSetupReceived();
-	
-				uint8_t GenericData[GENERIC_REPORT_SIZE];
-				
-				CreateGenericHIDReport(GenericData);
-
-				/* Write the report data to the control endpoint */
-				Endpoint_Write_Control_Stream_LE(&GenericData, sizeof(GenericData));
-
-				/* Finalize the stream transfer to send the last packet or clear the host abort */
-				Endpoint_ClearSetupOUT();
-			}
-		
-			break;
-		case REQ_SetReport:
-			if (bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
-			{
-				Endpoint_ClearSetupReceived();
-				
-				/* Wait until the generic report has been sent by the host */
-				while (!(Endpoint_IsSetupOUTReceived()));
-
-				uint8_t GenericData[GENERIC_REPORT_SIZE];
-
-				Endpoint_Read_Control_Stream(&GenericData, sizeof(GenericData));
-
-				ProcessGenericHIDReport(GenericData);
-			
-				/* Clear the endpoint data */
-				Endpoint_ClearSetupOUT();
-
-				/* Wait until the host is ready to receive the request confirmation */
-				while (!(Endpoint_IsSetupINReady()));
-				
-				/* Handshake the request by sending an empty IN packet */
-				Endpoint_ClearSetupIN();
-			}
-			
-			break;
-	}
+	USB_HID_ProcessControlPacket(&Generic_HID_Interface);
 }
 
-/** Function to manage status updates to the user. This is done via LEDs on the given board, if available, but may be changed to
- *  log to a serial port, or anything else that is suitable for status updates.
- *
- *  \param CurrentStatus  Current status of the system, from the GenericHID_StatusCodes_t enum
- */
-void UpdateStatus(uint8_t CurrentStatus)
+/** ISR to keep track of each millisecond interrupt, for determining the HID class idle period remaining when set. */
+ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 {
-	uint8_t LEDMask = LEDS_NO_LEDS;
-	
-	/* Set the LED mask to the appropriate LED mask based on the given status code */
-	switch (CurrentStatus)
-	{
-		case Status_USBNotReady:
-			LEDMask = (LEDS_LED1);
-			break;
-		case Status_USBEnumerating:
-			LEDMask = (LEDS_LED1 | LEDS_LED2);
-			break;
-		case Status_USBReady:
-			LEDMask = (LEDS_LED2 | LEDS_LED4);
-			break;
-	}
-	
-	/* Set the board LEDs to the new LED mask */
-	LEDs_SetAllLEDs(LEDMask);
+	if (Generic_HID_Interface.IdleMSRemaining)
+	  Generic_HID_Interface.IdleMSRemaining--;
 }
 
-/** Function to process the lest received report from the host.
+/** HID class driver callback function for the creation of HID reports to the host.
+ *
+ *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
+ *  \param ReportData  Pointer to a buffer where the created report should be stored
  *
- *  \param DataArray  Pointer to a buffer where the last report data is stored
+ *  \return Number of bytes written in the report (or zero if no report is to be sent
  */
-void ProcessGenericHIDReport(uint8_t* DataArray)
+uint16_t CALLBACK_USB_HID_CreateNextHIDReport(USB_ClassInfo_HID_t* HIDInterfaceInfo, void* ReportData)
 {
-	/*
-		This is where you need to process the reports being sent from the host to the device.
-		DataArray is an array holding the last report from the host. This function is called
-		each time the host has sent a report to the device.
-	*/
+	// Create generic HID report here
 	
-	for (uint8_t i = 0; i < GENERIC_REPORT_SIZE; i++)
-	  LastReceived[i] = DataArray[i];
+	return 0;
 }
 
-/** Function to create the next report to send back to the host at the next reporting interval.
+/** HID class driver callback function for the processing of HID reports from the host.
  *
- *  \param DataArray  Pointer to a buffer where the next report data should be stored
- */
-void CreateGenericHIDReport(uint8_t* DataArray)
-{
-	/*
-		This is where you need to create reports to be sent to the host from the device. This
-		function is called each time the host is ready to accept a new report. DataArray is 
-		an array to hold the report to the host.
-	*/
-
-	for (uint8_t i = 0; i < GENERIC_REPORT_SIZE; i++)
-	  DataArray[i] = LastReceived[i];
-}
-
-#if !defined(INTERRUPT_DATA_ENDPOINT)
-TASK(USB_HID_Report)
-{
-	/* Check if the USB system is connected to a host */
-	if (USB_IsConnected)
-	{
-		Endpoint_SelectEndpoint(GENERIC_OUT_EPNUM);
-		
-		if (Endpoint_ReadWriteAllowed())
-		{
-			/* Create a tempoary buffer to hold the read in report from the host */
-			uint8_t GenericData[GENERIC_REPORT_SIZE];
-			
-			/* Read Generic Report Data */
-			Endpoint_Read_Stream_LE(&GenericData, sizeof(GenericData));
-			
-			/* Process Generic Report Data */
-			ProcessGenericHIDReport(GenericData);
-
-			/* Finalize the stream transfer to send the last packet */
-			Endpoint_ClearCurrentBank();
-		}	
-
-		Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
-		
-		if (Endpoint_ReadWriteAllowed())
-		{
-			/* Create a tempoary buffer to hold the report to send to the host */
-			uint8_t GenericData[GENERIC_REPORT_SIZE];
-			
-			/* Create Generic Report Data */
-			CreateGenericHIDReport(GenericData);
-
-			/* Write Generic Report Data */
-			Endpoint_Write_Stream_LE(&GenericData, sizeof(GenericData));
-
-			/* Finalize the stream transfer to send the last packet */
-			Endpoint_ClearCurrentBank();
-		}
-	}
-}
-#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.
+ *  \param HIDInterfaceInfo  Pointer to the HID class interface configuration structure being referenced
+ *  \param ReportData  Pointer to a buffer where the created report has been stored
+ *  \param ReportSize  Size in bytes of the received HID report
  */
-ISR(ENDPOINT_PIPE_vect, ISR_BLOCK)
+void CALLBACK_USB_HID_ProcessReceivedHIDReport(USB_ClassInfo_HID_t* HIDInterfaceInfo, void* ReportData, uint16_t ReportSize)
 {
-	/* Save previously selected endpoint before selecting a new endpoint */
-	uint8_t PrevSelectedEndpoint = Endpoint_GetCurrentEndpoint();
-
-	#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 Generic IN endpoint has interrupted */
-	if (Endpoint_HasEndpointInterrupted(GENERIC_IN_EPNUM))
-	{
-		/* Select the Generic IN Report Endpoint */
-		Endpoint_SelectEndpoint(GENERIC_IN_EPNUM);
-
-		/* Clear the endpoint IN interrupt flag */
-		USB_INT_Clear(ENDPOINT_INT_IN);
-
-		/* Clear the Generic IN Report endpoint interrupt and select the endpoint */
-		Endpoint_ClearEndpointInterrupt(GENERIC_IN_EPNUM);
-
-		/* Create a temporary buffer to hold the report to send to the host */
-		uint8_t GenericData[GENERIC_REPORT_SIZE];
-		
-		/* Create Generic Report Data */
-		CreateGenericHIDReport(GenericData);
-
-		/* Write Generic Report Data */
-		Endpoint_Write_Stream_LE(&GenericData, sizeof(GenericData));
-
-		/* Finalize the stream transfer to send the last packet */
-		Endpoint_ClearCurrentBank();
-	}
-
-	/* Check if Generic OUT endpoint has interrupted */
-	if (Endpoint_HasEndpointInterrupted(GENERIC_OUT_EPNUM))
-	{
-		/* Select the Generic OUT Report Endpoint */
-		Endpoint_SelectEndpoint(GENERIC_OUT_EPNUM);
-
-		/* Clear the endpoint OUT Interrupt flag */
-		USB_INT_Clear(ENDPOINT_INT_OUT);
-
-		/* Clear the Generic OUT Report endpoint interrupt and select the endpoint */
-		Endpoint_ClearEndpointInterrupt(GENERIC_OUT_EPNUM);
-
-		/* Create a temporary buffer to hold the read in report from the host */
-		uint8_t GenericData[GENERIC_REPORT_SIZE];
-		
-		/* Read Generic Report Data */
-		Endpoint_Read_Stream_LE(&GenericData, sizeof(GenericData));
-		
-		/* Process Generic Report Data */
-		ProcessGenericHIDReport(GenericData);
-
-		/* Finalize the stream transfer to send the last packet */
-		Endpoint_ClearCurrentBank();
-	}
-	#endif
-
-	/* Restore previously selected endpoint */
-	Endpoint_SelectEndpoint(PrevSelectedEndpoint);
+	// Process received generic HID report here
 }