Revision 6ebafa20 Keyboard.c

View differences:

Keyboard.c
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
35
 *  is responsible for the initial application hardware configuration.
36
 */
37

  
38
#include "Keyboard.h"
39

  
40
/** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
41
 *  protocol reporting mode.
42
 */
43
static bool UsingReportProtocol = true;
44

  
45
/** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
46
 *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
47
 */
48
static uint16_t IdleCount = 500;
49

  
50
/** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
51
 *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
52
 *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
53
 */
54
static uint16_t IdleMSRemaining = 0;
55

  
56

  
57
/** Main program entry point. This routine configures the hardware required by the application, then
58
 *  enters a loop to run the application tasks in sequence.
59
 */
60
int main(void)
61
{
62
	SetupHardware();
63

  
64
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
65
	sei();
66

  
67
	for (;;)
68
	{
69
		HID_Task();
70
		USB_USBTask();
71
	}
72
}
73

  
74
/** Configures the board hardware and chip peripherals for the demo's functionality. */
75
void SetupHardware(void)
76
{
77
	/* Disable watchdog if enabled by bootloader/fuses */
78
	MCUSR &= ~(1 << WDRF);
79
	wdt_disable();
80

  
81
	/* Disable clock division */
82
	clock_prescale_set(clock_div_1);
83

  
84
	/* Hardware Initialization */
85
	LEDs_Init();
86
	USB_Init();
87
}
88

  
89
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
90
 *  starts the library USB task to begin the enumeration and USB management process.
91
 */
92
void EVENT_USB_Device_Connect(void)
93
{
94
	/* Indicate USB enumerating */
95
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
96

  
97
	/* Default to report protocol on connect */
98
	UsingReportProtocol = true;
99
}
100

  
101
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
102
 *  the status LEDs.
103
 */
104
void EVENT_USB_Device_Disconnect(void)
105
{
106
	/* Indicate USB not ready */
107
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
108
}
109

  
110
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
111
 *  of the USB device after enumeration, and configures the keyboard device endpoints.
112
 */
113
void EVENT_USB_Device_ConfigurationChanged(void)
114
{
115
	bool ConfigSuccess = true;
116

  
117
	/* Setup HID Report Endpoints */
118
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
119
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
120
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
121
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
122

  
123
	/* Turn on Start-of-Frame events for tracking HID report period expiry */
124
	USB_Device_EnableSOFEvents();
125

  
126
	/* Indicate endpoint configuration success or failure */
127
	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
128
}
129

  
130
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
131
 *  the device from the USB host before passing along unhandled control requests to the library for processing
132
 *  internally.
133
 */
134
void EVENT_USB_Device_ControlRequest(void)
135
{
136
	/* Handle HID Class specific requests */
137
	switch (USB_ControlRequest.bRequest)
138
	{
139
		case HID_REQ_GetReport:
140
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
141
			{
142
				USB_KeyboardReport_Data_t KeyboardReportData;
143

  
144
				/* Create the next keyboard report for transmission to the host */
145
				CreateKeyboardReport(&KeyboardReportData);
146

  
147
				Endpoint_ClearSETUP();
148

  
149
				/* Write the report data to the control endpoint */
150
				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
151
				Endpoint_ClearOUT();
152
			}
153

  
154
			break;
155
		case HID_REQ_SetReport:
156
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
157
			{
158
				Endpoint_ClearSETUP();
159

  
160
				/* Wait until the LED report has been sent by the host */
161
				while (!(Endpoint_IsOUTReceived()))
162
				{
163
					if (USB_DeviceState == DEVICE_STATE_Unattached)
164
					  return;
165
				}
166

  
167
				/* Read in the LED report from the host */
168
				uint8_t LEDStatus = Endpoint_Read_8();
169

  
170
				Endpoint_ClearOUT();
171
				Endpoint_ClearStatusStage();
172

  
173
				/* Process the incoming LED report */
174
				ProcessLEDReport(LEDStatus);
175
			}
176

  
177
			break;
178
		case HID_REQ_GetProtocol:
179
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
180
			{
181
				Endpoint_ClearSETUP();
182

  
183
				/* Write the current protocol flag to the host */
184
				Endpoint_Write_8(UsingReportProtocol);
185

  
186
				Endpoint_ClearIN();
187
				Endpoint_ClearStatusStage();
188
			}
189

  
190
			break;
191
		case HID_REQ_SetProtocol:
192
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
193
			{
194
				Endpoint_ClearSETUP();
195
				Endpoint_ClearStatusStage();
196

  
197
				/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
198
				UsingReportProtocol = (USB_ControlRequest.wValue != 0);
199
			}
200

  
201
			break;
202
		case HID_REQ_SetIdle:
203
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
204
			{
205
				Endpoint_ClearSETUP();
206
				Endpoint_ClearStatusStage();
207

  
208
				/* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
209
				IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
210
			}
211

  
212
			break;
213
		case HID_REQ_GetIdle:
214
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
215
			{
216
				Endpoint_ClearSETUP();
217

  
218
				/* Write the current idle duration to the host, must be divided by 4 before sent to host */
219
				Endpoint_Write_8(IdleCount >> 2);
220

  
221
				Endpoint_ClearIN();
222
				Endpoint_ClearStatusStage();
223
			}
224

  
225
			break;
226
	}
227
}
228

  
229
/** Event handler for the USB device Start Of Frame event. */
230
void EVENT_USB_Device_StartOfFrame(void)
231
{
232
	/* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
233
	if (IdleMSRemaining)
234
	  IdleMSRemaining--;
235
}
236

  
237
/** Fills the given HID report data structure with the next HID report to send to the host.
238
 *
239
 *  \param[out] ReportData  Pointer to a HID report data structure to be filled
240
 */
241
void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
242
{
243
	uint8_t UsedKeyCodes      = 0;
244

  
245
	/* Clear the report contents */
246
	memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
247

  
248
	/* Make sent key uppercase by indicating that the left shift key is pressed */
249
	ReportData->Modifier = HID_KEYBOARD_MODIFER_LEFTSHIFT;
250
}
251

  
252
/** Processes a received LED report, and updates the board LEDs states to match.
253
 *
254
 *  \param[in] LEDReport  LED status report from the host
255
 */
256
void ProcessLEDReport(const uint8_t LEDReport)
257
{
258
	uint8_t LEDMask = LEDS_LED2;
259

  
260
	if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
261
	  LEDMask |= LEDS_LED1;
262

  
263
	if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
264
	  LEDMask |= LEDS_LED3;
265

  
266
	if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
267
	  LEDMask |= LEDS_LED4;
268

  
269
	/* Set the status LEDs to the current Keyboard LED status */
270
	LEDs_SetAllLEDs(LEDMask);
271
}
272

  
273
/** Sends the next HID report to the host, via the keyboard data endpoint. */
274
void SendNextReport(void)
275
{
276
	static USB_KeyboardReport_Data_t PrevKeyboardReportData;
277
	USB_KeyboardReport_Data_t        KeyboardReportData;
278
	bool                             SendReport = true;
279

  
280
	/* Create the next keyboard report for transmission to the host */
281
	CreateKeyboardReport(&KeyboardReportData);
282

  
283
	/* Check to see if the report data has changed - if so a report MUST be sent */
284
	SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
285

  
286
	/* Check if the idle period is set and has elapsed */
287
	if (IdleCount && (!(IdleMSRemaining)))
288
	{
289
		/* Reset the idle time remaining counter */
290
		IdleMSRemaining = IdleCount;
291

  
292
		/* Idle period is set and has elapsed, must send a report to the host */
293
		SendReport = true;
294
	}
295

  
296
	/* Select the Keyboard Report Endpoint */
297
	Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
298

  
299
	/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
300
	if (Endpoint_IsReadWriteAllowed() && SendReport)
301
	{
302
		/* Save the current report data for later comparison to check for changes */
303
		PrevKeyboardReportData = KeyboardReportData;
304

  
305
		/* Write Keyboard Report Data */
306
		Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
307

  
308
		/* Finalize the stream transfer to send the last packet */
309
		Endpoint_ClearIN();
310
	}
311
}
312

  
313
/** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
314
void ReceiveNextReport(void)
315
{
316
	/* Select the Keyboard LED Report Endpoint */
317
	Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
318

  
319
	/* Check if Keyboard LED Endpoint contains a packet */
320
	if (Endpoint_IsOUTReceived())
321
	{
322
		/* Check to see if the packet contains data */
323
		if (Endpoint_IsReadWriteAllowed())
324
		{
325
			/* Read in the LED report from the host */
326
			uint8_t LEDReport = Endpoint_Read_8();
327

  
328
			/* Process the read LED report from the host */
329
			ProcessLEDReport(LEDReport);
330
		}
331

  
332
		/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
333
		Endpoint_ClearOUT();
334
	}
335
}
336

  
337
/** Function to manage HID report generation and transmission to the host, when in report mode. */
338
void HID_Task(void)
339
{
340
	/* Device must be connected and configured for the task to run */
341
	if (USB_DeviceState != DEVICE_STATE_Configured)
342
	  return;
343

  
344
	/* Send the next keypress report to the host */
345
	SendNextReport();
346

  
347
	/* Process the LED report sent from the host */
348
	ReceiveNextReport();
349
}
350

  
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
35
 *  is responsible for the initial application hardware configuration.
36
 */
37

  
38
#include "Keyboard.h"
39

  
40
/** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
41
 *  protocol reporting mode.
42
 */
43
static bool UsingReportProtocol = true;
44

  
45
/** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
46
 *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
47
 */
48
static uint16_t IdleCount = 500;
49

  
50
/** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
51
 *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
52
 *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
53
 */
54
static uint16_t IdleMSRemaining = 0;
55

  
56
static uint16_t foo = 0;
57
/** Main program entry point. This routine configures the hardware required by the application, then
58
 *  enters a loop to run the application tasks in sequence.
59
 */
60
int main(void)
61
{
62
	SetupHardware();
63

  
64
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
65
	sei();
66

  
67
	for (;;)
68
	{
69
		HID_Task();
70
		USB_USBTask();
71
	}
72
}
73

  
74
/** Configures the board hardware and chip peripherals for the demo's functionality. */
75
void SetupHardware(void)
76
{
77
	/* Disable watchdog if enabled by bootloader/fuses */
78
	MCUSR &= ~(1 << WDRF);
79
	wdt_disable();
80

  
81
	/* Disable clock division */
82
	clock_prescale_set(clock_div_1);
83

  
84
	/* Hardware Initialization */
85
	LEDs_Init();
86
	USB_Init();
87
}
88

  
89
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
90
 *  starts the library USB task to begin the enumeration and USB management process.
91
 */
92
void EVENT_USB_Device_Connect(void)
93
{
94
	/* Indicate USB enumerating */
95
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
96

  
97
	/* Default to report protocol on connect */
98
	UsingReportProtocol = true;
99
}
100

  
101
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
102
 *  the status LEDs.
103
 */
104
void EVENT_USB_Device_Disconnect(void)
105
{
106
	/* Indicate USB not ready */
107
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
108
}
109

  
110
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
111
 *  of the USB device after enumeration, and configures the keyboard device endpoints.
112
 */
113
void EVENT_USB_Device_ConfigurationChanged(void)
114
{
115
	bool ConfigSuccess = true;
116

  
117
	/* Setup HID Report Endpoints */
118
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
119
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
120
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
121
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
122

  
123
	/* Turn on Start-of-Frame events for tracking HID report period expiry */
124
	USB_Device_EnableSOFEvents();
125

  
126
	/* Indicate endpoint configuration success or failure */
127
	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
128
}
129

  
130
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
131
 *  the device from the USB host before passing along unhandled control requests to the library for processing
132
 *  internally.
133
 */
134
void EVENT_USB_Device_ControlRequest(void)
135
{
136
	/* Handle HID Class specific requests */
137
	switch (USB_ControlRequest.bRequest)
138
	{
139
		case HID_REQ_GetReport:
140
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
141
			{
142
				USB_KeyboardReport_Data_t KeyboardReportData;
143

  
144
				/* Create the next keyboard report for transmission to the host */
145
				CreateKeyboardReport(&KeyboardReportData);
146

  
147
				Endpoint_ClearSETUP();
148

  
149
				/* Write the report data to the control endpoint */
150
				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
151
				Endpoint_ClearOUT();
152
			}
153

  
154
			break;
155
		case HID_REQ_SetReport:
156
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
157
			{
158
				Endpoint_ClearSETUP();
159

  
160
				/* Wait until the LED report has been sent by the host */
161
				while (!(Endpoint_IsOUTReceived()))
162
				{
163
					if (USB_DeviceState == DEVICE_STATE_Unattached)
164
					  return;
165
				}
166

  
167
				/* Read in the LED report from the host */
168
				uint8_t LEDStatus = Endpoint_Read_8();
169

  
170
				Endpoint_ClearOUT();
171
				Endpoint_ClearStatusStage();
172

  
173
				/* Process the incoming LED report */
174
				ProcessLEDReport(LEDStatus);
175
			}
176

  
177
			break;
178
		case HID_REQ_GetProtocol:
179
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
180
			{
181
				Endpoint_ClearSETUP();
182

  
183
				/* Write the current protocol flag to the host */
184
				Endpoint_Write_8(UsingReportProtocol);
185

  
186
				Endpoint_ClearIN();
187
				Endpoint_ClearStatusStage();
188
			}
189

  
190
			break;
191
		case HID_REQ_SetProtocol:
192
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
193
			{
194
				Endpoint_ClearSETUP();
195
				Endpoint_ClearStatusStage();
196

  
197
				/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
198
				UsingReportProtocol = (USB_ControlRequest.wValue != 0);
199
			}
200

  
201
			break;
202
		case HID_REQ_SetIdle:
203
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
204
			{
205
				Endpoint_ClearSETUP();
206
				Endpoint_ClearStatusStage();
207

  
208
				/* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
209
				IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
210
			}
211

  
212
			break;
213
		case HID_REQ_GetIdle:
214
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
215
			{
216
				Endpoint_ClearSETUP();
217

  
218
				/* Write the current idle duration to the host, must be divided by 4 before sent to host */
219
				Endpoint_Write_8(IdleCount >> 2);
220

  
221
				Endpoint_ClearIN();
222
				Endpoint_ClearStatusStage();
223
			}
224

  
225
			break;
226
	}
227
}
228

  
229
/** Event handler for the USB device Start Of Frame event. */
230
void EVENT_USB_Device_StartOfFrame(void)
231
{
232
	/* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
233
	if (IdleMSRemaining)
234
	  IdleMSRemaining--;
235
}
236

  
237
/** Fills the given HID report data structure with the next HID report to send to the host.
238
 *
239
 *  \param[out] ReportData  Pointer to a HID report data structure to be filled
240
 */
241
void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
242
{
243
	uint8_t UsedKeyCodes      = 0;
244

  
245
	/* Clear the report contents */
246
	memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
247
	/* Make sent key uppercase by indicating that the left shift key is pressed */
248
	//ReportData->Modifier = HID_KEYBOARD_MODIFER_LEFTSHIFT;
249
	if(foo%5000){
250
		UsedKeyCodes = 2;
251
		ReportData->KeyCode[0] = HID_KEYBOARD_SC_L; 
252
		ReportData->KeyCode[1] = HID_KEYBOARD_SC_A;
253
	}
254
	foo++;
255
}
256

  
257
/** Processes a received LED report, and updates the board LEDs states to match.
258
 *
259
 *  \param[in] LEDReport  LED status report from the host
260
 */
261
void ProcessLEDReport(const uint8_t LEDReport)
262
{
263
	uint8_t LEDMask = LEDS_LED2;
264

  
265
	if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
266
	  LEDMask |= LEDS_LED1;
267

  
268
	if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
269
	  LEDMask |= LEDS_LED3;
270

  
271
	if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
272
	  LEDMask |= LEDS_LED4;
273

  
274
	/* Set the status LEDs to the current Keyboard LED status */
275
	LEDs_SetAllLEDs(LEDMask);
276
}
277

  
278
/** Sends the next HID report to the host, via the keyboard data endpoint. */
279
void SendNextReport(void)
280
{
281
	static USB_KeyboardReport_Data_t PrevKeyboardReportData;
282
	USB_KeyboardReport_Data_t        KeyboardReportData;
283
	bool                             SendReport = true;
284

  
285
	/* Create the next keyboard report for transmission to the host */
286
	CreateKeyboardReport(&KeyboardReportData);
287

  
288
	/* Check to see if the report data has changed - if so a report MUST be sent */
289
	SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
290

  
291
	/* Check if the idle period is set and has elapsed */
292
	if (IdleCount && (!(IdleMSRemaining)))
293
	{
294
		/* Reset the idle time remaining counter */
295
		IdleMSRemaining = IdleCount;
296

  
297
		/* Idle period is set and has elapsed, must send a report to the host */
298
		SendReport = true;
299
	}
300

  
301
	/* Select the Keyboard Report Endpoint */
302
	Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
303

  
304
	/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
305
	if (Endpoint_IsReadWriteAllowed() && SendReport)
306
	{
307
		/* Save the current report data for later comparison to check for changes */
308
		PrevKeyboardReportData = KeyboardReportData;
309

  
310
		/* Write Keyboard Report Data */
311
		Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
312

  
313
		/* Finalize the stream transfer to send the last packet */
314
		Endpoint_ClearIN();
315
	}
316
}
317

  
318
/** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
319
void ReceiveNextReport(void)
320
{
321
	/* Select the Keyboard LED Report Endpoint */
322
	Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
323

  
324
	/* Check if Keyboard LED Endpoint contains a packet */
325
	if (Endpoint_IsOUTReceived())
326
	{
327
		/* Check to see if the packet contains data */
328
		if (Endpoint_IsReadWriteAllowed())
329
		{
330
			/* Read in the LED report from the host */
331
			uint8_t LEDReport = Endpoint_Read_8();
332

  
333
			/* Process the read LED report from the host */
334
			ProcessLEDReport(LEDReport);
335
		}
336

  
337
		/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
338
		Endpoint_ClearOUT();
339
	}
340
}
341

  
342
/** Function to manage HID report generation and transmission to the host, when in report mode. */
343
void HID_Task(void)
344
{
345
	/* Device must be connected and configured for the task to run */
346
	if (USB_DeviceState != DEVICE_STATE_Configured)
347
	  return;
348

  
349
	/* Send the next keypress report to the host */
350
	SendNextReport();
351

  
352
	/* Process the LED report sent from the host */
353
	ReceiveNextReport();
354
}
355

  

Also available in: Unified diff