Revision 6bfd3967

View differences:

Descriptors.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
 *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special
35
 *  computer-readable structures which the host requests upon device enumeration, to determine
36
 *  the device's capabilities and functions.
37
 */
38

  
39
#include "Descriptors.h"
40

  
41
/** HID class report descriptor. This is a special descriptor constructed with values from the
42
 *  USBIF HID class specification to describe the reports and capabilities of the HID device. This
43
 *  descriptor is parsed by the host and its contents used to determine what data (and in what encoding)
44
 *  the device will send, and what it may be sent back from the host. Refer to the HID specification for
45
 *  more details on HID report descriptors.
46
 */
47
const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
48
{
49
	HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
50
	HID_RI_USAGE(8, 0x06), /* Keyboard */
51
	HID_RI_COLLECTION(8, 0x01), /* Application */
52
	    HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
53
	    HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
54
	    HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
55
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
56
	    HID_RI_LOGICAL_MAXIMUM(8, 0x01),
57
	    HID_RI_REPORT_SIZE(8, 0x01),
58
	    HID_RI_REPORT_COUNT(8, 0x08),
59
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
60
	    HID_RI_REPORT_COUNT(8, 0x01),
61
	    HID_RI_REPORT_SIZE(8, 0x08),
62
	    HID_RI_INPUT(8, HID_IOF_CONSTANT),
63
	    HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
64
	    HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
65
	    HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
66
	    HID_RI_REPORT_COUNT(8, 0x05),
67
	    HID_RI_REPORT_SIZE(8, 0x01),
68
	    HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
69
	    HID_RI_REPORT_COUNT(8, 0x01),
70
	    HID_RI_REPORT_SIZE(8, 0x03),
71
	    HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
72
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
73
	    HID_RI_LOGICAL_MAXIMUM(8, 0x65),
74
	    HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
75
	    HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
76
	    HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */
77
	    HID_RI_REPORT_COUNT(8, 0x06),
78
	    HID_RI_REPORT_SIZE(8, 0x08),
79
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
80
	HID_RI_END_COLLECTION(0),
81
};
82

  
83
/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
84
 *  device characteristics, including the supported USB version, control endpoint size and the
85
 *  number of device configurations. The descriptor is read out by the USB host when the enumeration
86
 *  process begins.
87
 */
88
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
89
{
90
	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
91

  
92
	.USBSpecification       = VERSION_BCD(01.10),
93
	.Class                  = USB_CSCP_NoDeviceClass,
94
	.SubClass               = USB_CSCP_NoDeviceSubclass,
95
	.Protocol               = USB_CSCP_NoDeviceProtocol,
96

  
97
	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
98

  
99
	.VendorID               = 0x03EB,
100
	.ProductID              = 0x2042,
101
	.ReleaseNumber          = VERSION_BCD(00.01),
102

  
103
	.ManufacturerStrIndex   = 0x01,
104
	.ProductStrIndex        = 0x02,
105
	.SerialNumStrIndex      = NO_DESCRIPTOR,
106

  
107
	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
108
};
109

  
110
/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
111
 *  of the device in one of its supported configurations, including information about any device interfaces
112
 *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
113
 *  a configuration so that the host may correctly communicate with the USB device.
114
 */
115
const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
116
{
117
	.Config =
118
		{
119
			.Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
120

  
121
			.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
122
			.TotalInterfaces        = 1,
123

  
124
			.ConfigurationNumber    = 1,
125
			.ConfigurationStrIndex  = NO_DESCRIPTOR,
126

  
127
			.ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
128

  
129
			.MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
130
		},
131

  
132
	.HID_Interface =
133
		{
134
			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
135

  
136
			.InterfaceNumber        = 0x00,
137
			.AlternateSetting       = 0x00,
138

  
139
			.TotalEndpoints         = 2,
140

  
141
			.Class                  = HID_CSCP_HIDClass,
142
			.SubClass               = HID_CSCP_BootSubclass,
143
			.Protocol               = HID_CSCP_KeyboardBootProtocol,
144

  
145
			.InterfaceStrIndex      = NO_DESCRIPTOR
146
		},
147

  
148
	.HID_KeyboardHID =
149
		{
150
			.Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
151

  
152
			.HIDSpec                = VERSION_BCD(01.11),
153
			.CountryCode            = 0x00,
154
			.TotalReportDescriptors = 1,
155
			.HIDReportType          = HID_DTYPE_Report,
156
			.HIDReportLength        = sizeof(KeyboardReport)
157
		},
158

  
159
	.HID_ReportINEndpoint =
160
		{
161
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
162

  
163
			.EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
164
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
165
			.EndpointSize           = KEYBOARD_EPSIZE,
166
			.PollingIntervalMS      = 0x01
167
		},
168

  
169
	.HID_ReportOUTEndpoint =
170
		{
171
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
172

  
173
			.EndpointAddress        = (ENDPOINT_DIR_OUT | KEYBOARD_OUT_EPNUM),
174
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
175
			.EndpointSize           = KEYBOARD_EPSIZE,
176
			.PollingIntervalMS      = 0x01
177
		}
178
};
179

  
180
/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
181
 *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
182
 *  via the language ID table available at USB.org what languages the device supports for its string descriptors.
183
 */
184
const USB_Descriptor_String_t PROGMEM LanguageString =
185
{
186
	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
187

  
188
	.UnicodeString          = {LANGUAGE_ID_ENG}
189
};
190

  
191
/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
192
 *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
193
 *  Descriptor.
194
 */
195
const USB_Descriptor_String_t PROGMEM ManufacturerString =
196
{
197
	.Header                 = {.Size = USB_STRING_LEN(8), .Type = DTYPE_String},
198

  
199
	.UnicodeString          = L"imp tech"
200
};
201

  
202
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
203
 *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
204
 *  Descriptor.
205
 */
206
const USB_Descriptor_String_t PROGMEM ProductString =
207
{
208
	.Header                 = {.Size = USB_STRING_LEN(10), .Type = DTYPE_String},
209

  
210
	.UnicodeString          = L"tasta v0.2"
211
};
212

  
213
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
214
 *  documentation) by the application code so that the address and size of a requested descriptor can be given
215
 *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
216
 *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
217
 *  USB host.
218
 */
219
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
220
                                    const uint8_t wIndex,
221
                                    const void** const DescriptorAddress)
222
{
223
	const uint8_t  DescriptorType   = (wValue >> 8);
224
	const uint8_t  DescriptorNumber = (wValue & 0xFF);
225

  
226
	const void* Address = NULL;
227
	uint16_t    Size    = NO_DESCRIPTOR;
228

  
229
	switch (DescriptorType)
230
	{
231
		case DTYPE_Device:
232
			Address = &DeviceDescriptor;
233
			Size    = sizeof(USB_Descriptor_Device_t);
234
			break;
235
		case DTYPE_Configuration:
236
			Address = &ConfigurationDescriptor;
237
			Size    = sizeof(USB_Descriptor_Configuration_t);
238
			break;
239
		case DTYPE_String:
240
			switch (DescriptorNumber)
241
			{
242
				case 0x00:
243
					Address = &LanguageString;
244
					Size    = pgm_read_byte(&LanguageString.Header.Size);
245
					break;
246
				case 0x01:
247
					Address = &ManufacturerString;
248
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
249
					break;
250
				case 0x02:
251
					Address = &ProductString;
252
					Size    = pgm_read_byte(&ProductString.Header.Size);
253
					break;
254
			}
255

  
256
			break;
257
		case HID_DTYPE_HID:
258
			Address = &ConfigurationDescriptor.HID_KeyboardHID;
259
			Size    = sizeof(USB_HID_Descriptor_HID_t);
260
			break;
261
		case HID_DTYPE_Report:
262
			Address = &KeyboardReport;
263
			Size    = sizeof(KeyboardReport);
264
			break;
265
	}
266

  
267
	*DescriptorAddress = Address;
268
	return Size;
269
}
270

  
Descriptors.h
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
 *  Header file for Descriptors.c.
35
 */
36

  
37
#ifndef _DESCRIPTORS_H_
38
#define _DESCRIPTORS_H_
39

  
40
	/* Includes: */
41
		#include <LUFA/Drivers/USB/USB.h>
42

  
43
		#include <avr/pgmspace.h>
44

  
45
	/* Type Defines: */
46
		/** Type define for the device configuration descriptor structure. This must be defined in the
47
		 *  application code, as the configuration descriptor contains several sub-descriptors which
48
		 *  vary between devices, and which describe the device's usage to the host.
49
		 */
50
		typedef struct
51
		{
52
			USB_Descriptor_Configuration_Header_t Config;
53

  
54
			// Keyboard HID Interface
55
			USB_Descriptor_Interface_t            HID_Interface;
56
			USB_HID_Descriptor_HID_t              HID_KeyboardHID;
57
	        USB_Descriptor_Endpoint_t             HID_ReportINEndpoint;
58
	        USB_Descriptor_Endpoint_t             HID_ReportOUTEndpoint;
59
		} USB_Descriptor_Configuration_t;
60

  
61
	/* Macros: */
62
		/** Endpoint number of the Keyboard HID reporting IN endpoint. */
63
		#define KEYBOARD_IN_EPNUM         1
64

  
65
		/** Endpoint number of the Keyboard HID reporting OUT endpoint. */
66
		#define KEYBOARD_OUT_EPNUM        2
67

  
68
		/** Size in bytes of the Keyboard HID reporting IN and OUT endpoints. */
69
		#define KEYBOARD_EPSIZE           8
70

  
71
	/* Function Prototypes: */
72
		uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
73
		                                    const uint8_t wIndex,
74
		                                    const void** const DescriptorAddress)
75
		                                    ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
76

  
77
#endif
78

  
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

  
Keyboard.h
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
 *  Header file for Keyboard.c.
35
 */
36

  
37
#ifndef _KEYBOARD_H_
38
#define _KEYBOARD_H_
39

  
40
	/* Includes: */
41
		#include <avr/io.h>
42
		#include <avr/wdt.h>
43
		#include <avr/power.h>
44
		#include <avr/interrupt.h>
45
		#include <stdbool.h>
46
		#include <string.h>
47

  
48
		#include "Descriptors.h"
49

  
50
		#include <LUFA/Version.h>
51
		#include <LUFA/Drivers/USB/USB.h>
52
		#include <LUFA/Drivers/Board/LEDs.h>
53

  
54
	/* Macros: */
55
		/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
56
		#define LEDMASK_USB_NOTREADY        LEDS_LED1
57

  
58
		/** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */
59
		#define LEDMASK_USB_ENUMERATING     (LEDS_LED2 | LEDS_LED3)
60

  
61
		/** LED mask for the library LED driver, to indicate that the USB interface is ready. */
62
		#define LEDMASK_USB_READY           (LEDS_LED2 | LEDS_LED4)
63

  
64
		/** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */
65
		#define LEDMASK_USB_ERROR           (LEDS_LED1 | LEDS_LED3)
66

  
67
	/* Function Prototypes: */
68
		void SetupHardware(void);
69
		void HID_Task(void);
70

  
71
		void EVENT_USB_Device_Connect(void);
72
		void EVENT_USB_Device_Disconnect(void);
73
		void EVENT_USB_Device_ConfigurationChanged(void);
74
		void EVENT_USB_Device_ControlRequest(void);
75
		void EVENT_USB_Device_StartOfFrame(void);
76

  
77
		void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData);
78
		void ProcessLEDReport(const uint8_t LEDReport);
79
		void SendNextReport(void);
80
		void ReceiveNextReport(void);
81

  
82
#endif
83

  
makefile
1
# Hey Emacs, this is a -*- makefile -*-
2
#----------------------------------------------------------------------------
3
# WinAVR Makefile Template written by Eric B. Weddington, J?rg Wunsch, et al.
4
#  >> Modified for use with the LUFA project. <<
5
#
6
# Released to the Public Domain
7
#
8
# Additional material for this makefile was written by:
9
# Peter Fleury
10
# Tim Henigan
11
# Colin O'Flynn
12
# Reiner Patommel
13
# Markus Pfaff
14
# Sander Pool
15
# Frederik Rouleau
16
# Carlos Lamas
17
# Dean Camera
18
# Opendous Inc.
19
# Denver Gingerich
20
#
21
#----------------------------------------------------------------------------
22
# On command line:
23
#
24
# make all = Make software.
25
#
26
# make clean = Clean out built project files.
27
#
28
# make coff = Convert ELF to AVR COFF.
29
#
30
# make extcoff = Convert ELF to AVR Extended COFF.
31
#
32
# make program = Download the hex file to the device, using avrdude.
33
#                Please customize the avrdude settings below first!
34
#
35
# make dfu = Download the hex file to the device, using dfu-programmer (must
36
#            have dfu-programmer installed).
37
#
38
# make flip = Download the hex file to the device, using Atmel FLIP (must
39
#             have Atmel FLIP installed).
40
#
41
# make dfu-ee = Download the eeprom file to the device, using dfu-programmer
42
#               (must have dfu-programmer installed).
43
#
44
# make flip-ee = Download the eeprom file to the device, using Atmel FLIP
45
#                (must have Atmel FLIP installed).
46
#
47
# make doxygen = Generate DoxyGen documentation for the project (must have
48
#                DoxyGen installed)
49
#
50
# make debug = Start either simulavr or avarice as specified for debugging,
51
#              with avr-gdb or avr-insight as the front end for debugging.
52
#
53
# make filename.s = Just compile filename.c into the assembler code only.
54
#
55
# make filename.i = Create a preprocessed source file for use in submitting
56
#                   bug reports to the GCC project.
57
#
58
# To rebuild project do "make clean" then "make all".
59
#----------------------------------------------------------------------------
60

  
61

  
62
# MCU name
63
MCU = atmega32u2
64

  
65

  
66
# Target architecture (see library "Board Types" documentation).
67
ARCH = AVR8
68

  
69

  
70
# Target board (see library "Board Types" documentation, NONE for projects not requiring
71
# LUFA board drivers). If USER is selected, put custom board drivers in a directory called
72
# "Board" inside the application directory.
73
BOARD = USBKEY
74

  
75

  
76
# Processor frequency.
77
#     This will define a symbol, F_CPU, in all source code files equal to the
78
#     processor frequency in Hz. You can then use this symbol in your source code to
79
#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
80
#     automatically to create a 32-bit value in your source code.
81
#
82
#     This will be an integer division of F_USB below, as it is sourced by
83
#     F_USB after it has run through any CPU prescalers. Note that this value
84
#     does not *change* the processor frequency - it should merely be updated to
85
#     reflect the processor speed set externally so that the code can use accurate
86
#     software delays.
87
F_CPU = 16000000
88

  
89

  
90
# Input clock frequency.
91
#     This will define a symbol, F_USB, in all source code files equal to the
92
#     input clock frequency (before any prescaling is performed) in Hz. This value may
93
#     differ from F_CPU if prescaling is used on the latter, and is required as the
94
#     raw input clock is fed directly to the PLL sections of the AVR for high speed
95
#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
96
#     at the end, this will be done automatically to create a 32-bit value in your
97
#     source code.
98
#
99
#     If no clock division is performed on the input clock inside the AVR (via the
100
#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
101
F_USB = $(F_CPU)
102

  
103

  
104
# Output format. (can be srec, ihex, binary)
105
FORMAT = ihex
106

  
107

  
108
# Target file name (without extension).
109
TARGET = Keyboard
110

  
111

  
112
# Object files directory
113
#     To put object files in current directory, use a dot (.), do NOT make
114
#     this an empty or blank macro!
115
OBJDIR = .
116

  
117

  
118
# Path to the LUFA library
119
LUFA_PATH = ../../../..
120

  
121

  
122
# LUFA library compile-time options and predefined tokens
123
LUFA_OPTS  = -D USB_DEVICE_ONLY
124
LUFA_OPTS += -D FIXED_CONTROL_ENDPOINT_SIZE=8
125
LUFA_OPTS += -D FIXED_NUM_CONFIGURATIONS=1
126
LUFA_OPTS += -D USE_FLASH_DESCRIPTORS
127
LUFA_OPTS += -D USE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)"
128

  
129

  
130
# Create the LUFA source path variables by including the LUFA root makefile
131
include $(LUFA_PATH)/LUFA/makefile
132

  
133

  
134
# List C source files here. (C dependencies are automatically generated.)
135
SRC = $(TARGET).c                                                 \
136
	  Descriptors.c                                               \
137
	  $(LUFA_SRC_USB)
138

  
139

  
140
# List C++ source files here. (C dependencies are automatically generated.)
141
CPPSRC =
142

  
143

  
144
# List Assembler source files here.
145
#     Make them always end in a capital .S.  Files ending in a lowercase .s
146
#     will not be considered source files but generated files (assembler
147
#     output from the compiler), and will be deleted upon "make clean"!
148
#     Even though the DOS/Win* filesystem matches both .s and .S the same,
149
#     it will preserve the spelling of the filenames, and gcc itself does
150
#     care about how the name is spelled on its command-line.
151
ASRC =
152

  
153

  
154
# Optimization level, can be [0, 1, 2, 3, s].
155
#     0 = turn off optimization. s = optimize for size.
156
#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
157
OPT = s
158

  
159

  
160
# Debugging format.
161
#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
162
#     AVR Studio 4.10 requires dwarf-2.
163
#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
164
DEBUG = dwarf-2
165

  
166

  
167
# List any extra directories to look for include files here.
168
#     Each directory must be seperated by a space.
169
#     Use forward slashes for directory separators.
170
#     For a directory that has spaces, enclose it in quotes.
171
EXTRAINCDIRS = $(LUFA_PATH)/
172

  
173

  
174
# Compiler flag to set the C Standard level.
175
#     c89   = "ANSI" C
176
#     gnu89 = c89 plus GCC extensions
177
#     c99   = ISO C99 standard (not yet fully implemented)
178
#     gnu99 = c99 plus GCC extensions
179
CSTANDARD = -std=c99
180

  
181

  
182
# Place -D or -U options here for C sources
183
CDEFS  = -DF_CPU=$(F_CPU)UL
184
CDEFS += -DF_USB=$(F_USB)UL
185
CDEFS += -DBOARD=BOARD_$(BOARD) -DARCH=ARCH_$(ARCH)
186
CDEFS += $(LUFA_OPTS)
187

  
188

  
189
# Place -D or -U options here for ASM sources
190
ADEFS  = -DF_CPU=$(F_CPU)
191
ADEFS += -DF_USB=$(F_USB)UL
192
ADEFS += -DBOARD=BOARD_$(BOARD)
193
ADEFS += $(LUFA_OPTS)
194

  
195
# Place -D or -U options here for C++ sources
196
CPPDEFS  = -DF_CPU=$(F_CPU)UL
197
CPPDEFS += -DF_USB=$(F_USB)UL
198
CPPDEFS += -DBOARD=BOARD_$(BOARD)
199
CPPDEFS += $(LUFA_OPTS)
200
#CPPDEFS += -D__STDC_LIMIT_MACROS
201
#CPPDEFS += -D__STDC_CONSTANT_MACROS
202

  
203

  
204

  
205
#---------------- Compiler Options C ----------------
206
#  -g*:          generate debugging information
207
#  -O*:          optimization level
208
#  -f...:        tuning, see GCC manual and avr-libc documentation
209
#  -Wall...:     warning level
210
#  -Wa,...:      tell GCC to pass this to the assembler.
211
#    -adhlns...: create assembler listing
212
CFLAGS = -g$(DEBUG)
213
CFLAGS += $(CDEFS)
214
CFLAGS += -O$(OPT)
215
CFLAGS += -funsigned-char
216
CFLAGS += -funsigned-bitfields
217
CFLAGS += -ffunction-sections
218
CFLAGS += -fno-inline-small-functions
219
CFLAGS += -fpack-struct
220
CFLAGS += -fshort-enums
221
CFLAGS += -fno-strict-aliasing
222
CFLAGS += -Wall
223
CFLAGS += -Wstrict-prototypes
224
#CFLAGS += -mshort-calls
225
#CFLAGS += -fno-unit-at-a-time
226
#CFLAGS += -Wundef
227
#CFLAGS += -Wunreachable-code
228
#CFLAGS += -Wsign-compare
229
CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
230
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
231
CFLAGS += $(CSTANDARD)
232

  
233

  
234
#---------------- Compiler Options C++ ----------------
235
#  -g*:          generate debugging information
236
#  -O*:          optimization level
237
#  -f...:        tuning, see GCC manual and avr-libc documentation
238
#  -Wall...:     warning level
239
#  -Wa,...:      tell GCC to pass this to the assembler.
240
#    -adhlns...: create assembler listing
241
CPPFLAGS = -g$(DEBUG)
242
CPPFLAGS += $(CPPDEFS)
243
CPPFLAGS += -O$(OPT)
244
CPPFLAGS += -funsigned-char
245
CPPFLAGS += -funsigned-bitfields
246
CPPFLAGS += -fpack-struct
247
CPPFLAGS += -fshort-enums
248
CPPFLAGS += -fno-exceptions
249
CPPFLAGS += -Wall
250
CPPFLAGS += -Wundef
251
#CPPFLAGS += -mshort-calls
252
#CPPFLAGS += -fno-unit-at-a-time
253
#CPPFLAGS += -Wstrict-prototypes
254
#CPPFLAGS += -Wunreachable-code
255
#CPPFLAGS += -Wsign-compare
256
CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)
257
CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
258
#CPPFLAGS += $(CSTANDARD)
259

  
260

  
261
#---------------- Assembler Options ----------------
262
#  -Wa,...:   tell GCC to pass this to the assembler.
263
#  -adhlns:   create listing
264
#  -gstabs:   have the assembler create line number information; note that
265
#             for use in COFF files, additional information about filenames
266
#             and function names needs to be present in the assembler source
267
#             files -- see avr-libc docs [FIXME: not yet described there]
268
#  -listing-cont-lines: Sets the maximum number of continuation lines of hex
269
#       dump that will be displayed for a given single line of source input.
270
ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100
271

  
272

  
273
#---------------- Library Options ----------------
274
# Minimalistic printf version
275
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
276

  
277
# Floating point printf version (requires MATH_LIB = -lm below)
278
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
279

  
280
# If this is left blank, then it will use the Standard printf version.
281
PRINTF_LIB =
282
#PRINTF_LIB = $(PRINTF_LIB_MIN)
283
#PRINTF_LIB = $(PRINTF_LIB_FLOAT)
284

  
285

  
286
# Minimalistic scanf version
287
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
288

  
289
# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
290
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
291

  
292
# If this is left blank, then it will use the Standard scanf version.
293
SCANF_LIB =
294
#SCANF_LIB = $(SCANF_LIB_MIN)
295
#SCANF_LIB = $(SCANF_LIB_FLOAT)
296

  
297

  
298
MATH_LIB = -lm
299

  
300

  
301
# List any extra directories to look for libraries here.
302
#     Each directory must be seperated by a space.
303
#     Use forward slashes for directory separators.
304
#     For a directory that has spaces, enclose it in quotes.
305
EXTRALIBDIRS =
306

  
307

  
308

  
309
#---------------- External Memory Options ----------------
310

  
311
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
312
# used for variables (.data/.bss) and heap (malloc()).
313
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
314

  
315
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
316
# only used for heap (malloc()).
317
#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
318

  
319
EXTMEMOPTS =
320

  
321

  
322

  
323
#---------------- Linker Options ----------------
324
#  -Wl,...:     tell GCC to pass this to linker.
325
#    -Map:      create map file
326
#    --cref:    add cross reference to  map file
327
LDFLAGS  = -Wl,-Map=$(TARGET).map,--cref
328
LDFLAGS += -Wl,--relax
329
LDFLAGS += -Wl,--gc-sections
330
LDFLAGS += $(EXTMEMOPTS)
331
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
332
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
333
#LDFLAGS += -T linker_script.x
334

  
335

  
336

  
337
#---------------- Programming Options (avrdude) ----------------
338

  
339
# Programming hardware
340
# Type: avrdude -c ?
341
# to get a full listing.
342
#
343
AVRDUDE_PROGRAMMER = jtagmkII
344

  
345
# com1 = serial port. Use lpt1 to connect to parallel port.
346
AVRDUDE_PORT = usb
347

  
348
AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
349
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
350

  
351

  
352
# Uncomment the following if you want avrdude's erase cycle counter.
353
# Note that this counter needs to be initialized first using -Yn,
354
# see avrdude manual.
355
#AVRDUDE_ERASE_COUNTER = -y
356

  
357
# Uncomment the following if you do /not/ wish a verification to be
358
# performed after programming the device.
359
#AVRDUDE_NO_VERIFY = -V
360

  
361
# Increase verbosity level.  Please use this when submitting bug
362
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
363
# to submit bug reports.
364
#AVRDUDE_VERBOSE = -v -v
365

  
366
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
367
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
368
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
369
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
370

  
371

  
372

  
373
#---------------- Debugging Options ----------------
374

  
375
# For simulavr only - target MCU frequency.
376
DEBUG_MFREQ = $(F_CPU)
377

  
378
# Set the DEBUG_UI to either gdb or insight.
379
# DEBUG_UI = gdb
380
DEBUG_UI = insight
381

  
382
# Set the debugging back-end to either avarice, simulavr.
383
DEBUG_BACKEND = avarice
384
#DEBUG_BACKEND = simulavr
385

  
386
# GDB Init Filename.
387
GDBINIT_FILE = __avr_gdbinit
388

  
389
# When using avarice settings for the JTAG
390
JTAG_DEV = /dev/com1
391

  
392
# Debugging port used to communicate between GDB / avarice / simulavr.
393
DEBUG_PORT = 4242
394

  
395
# Debugging host used to communicate between GDB / avarice / simulavr, normally
396
#     just set to localhost unless doing some sort of crazy debugging when
397
#     avarice is running on a different computer.
398
DEBUG_HOST = localhost
399

  
400

  
401

  
402
#============================================================================
403

  
404

  
405
# Define programs and commands.
406
SHELL = sh
407
CC = avr-gcc
408
OBJCOPY = avr-objcopy
409
OBJDUMP = avr-objdump
410
SIZE = avr-size
411
AR = avr-ar rcs
412
NM = avr-nm
413
AVRDUDE = avrdude
414
REMOVE = rm -f
415
REMOVEDIR = rm -rf
416
COPY = cp
417
WINSHELL = cmd
418

  
419

  
420
# Define Messages
421
# English
422
MSG_ERRORS_NONE = Errors: none
423
MSG_BEGIN = -------- begin --------
424
MSG_END = --------  end  --------
425
MSG_SIZE_BEFORE = Size before:
426
MSG_SIZE_AFTER = Size after:
427
MSG_COFF = Converting to AVR COFF:
428
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
429
MSG_FLASH = Creating load file for Flash:
430
MSG_EEPROM = Creating load file for EEPROM:
431
MSG_EXTENDED_LISTING = Creating Extended Listing:
432
MSG_SYMBOL_TABLE = Creating Symbol Table:
433
MSG_LINKING = Linking:
434
MSG_COMPILING = Compiling C:
435
MSG_COMPILING_CPP = Compiling C++:
436
MSG_ASSEMBLING = Assembling:
437
MSG_CLEANING = Cleaning project:
438
MSG_CREATING_LIBRARY = Creating library:
439

  
440

  
441

  
442

  
443
# Define all object files.
444
OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)
445

  
446
# Define all listing files.
447
LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)
448

  
449

  
450
# Compiler flags to generate dependency files.
451
GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
452

  
453

  
454
# Combine all necessary flags and optional flags.
455
# Add target processor to flags.
456
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
457
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
458
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
459

  
460

  
461

  
462

  
463

  
464
# Default target.
465
all: begin gccversion sizebefore build sizeafter end
466

  
467
# Change the build target to build a HEX file or a library.
468
build: elf hex eep lss sym
469
#build: lib
470

  
471

  
472
elf: $(TARGET).elf
473
hex: $(TARGET).hex
474
eep: $(TARGET).eep
475
lss: $(TARGET).lss
476
sym: $(TARGET).sym
477
LIBNAME=lib$(TARGET).a
478
lib: $(LIBNAME)
479

  
480

  
481

  
482
# Eye candy.
483
# AVR Studio 3.x does not check make's exit code but relies on
484
# the following magic strings to be generated by the compile job.
485
begin:
486
	@echo
487
	@echo $(MSG_BEGIN)
488

  
489
end:
490
	@echo $(MSG_END)
491
	@echo
492

  
493

  
494
# Display size of file.
495
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
496
ELFSIZE = $(SIZE) $(MCU_FLAG) $(FORMAT_FLAG) $(TARGET).elf
497
MCU_FLAG = $(shell $(SIZE) --help | grep -- --mcu > /dev/null && echo --mcu=$(MCU) )
498
FORMAT_FLAG = $(shell $(SIZE) --help | grep -- --format=.*avr > /dev/null && echo --format=avr )
499

  
500

  
501
sizebefore:
502
	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
503
	2>/dev/null; echo; fi
504

  
505
sizeafter:
506
	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
507
	2>/dev/null; echo; fi
508

  
509

  
510

  
511
# Display compiler version information.
512
gccversion :
513
	@$(CC) --version
514

  
515

  
516
# Program the device.
517
program: $(TARGET).hex $(TARGET).eep
518
	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
519

  
520
flip: $(TARGET).hex
521
	batchisp -hardware usb -device $(MCU) -operation erase f
522
	batchisp -hardware usb -device $(MCU) -operation loadbuffer $(TARGET).hex program
523
	batchisp -hardware usb -device $(MCU) -operation start reset 0
524

  
525
dfu: $(TARGET).hex
526
	/home/mj/temp/dfu-programmer-0.5.4/src/dfu-programmer $(MCU) erase
527
	/home/mj/temp/dfu-programmer-0.5.4/src/dfu-programmer $(MCU) flash $(TARGET).hex
528
	/home/mj/temp/dfu-programmer-0.5.4/src/dfu-programmer $(MCU) reset
529

  
530
flip-ee: $(TARGET).hex $(TARGET).eep
531
	$(COPY) $(TARGET).eep $(TARGET)eep.hex
532
	batchisp -hardware usb -device $(MCU) -operation memory EEPROM erase
533
	batchisp -hardware usb -device $(MCU) -operation memory EEPROM loadbuffer $(TARGET)eep.hex program
534
	batchisp -hardware usb -device $(MCU) -operation start reset 0
535
	$(REMOVE) $(TARGET)eep.hex
536

  
537
dfu-ee: $(TARGET).hex $(TARGET).eep
538
	dfu-programmer $(MCU) eeprom-flash $(TARGET).eep
539
	dfu-programmer $(MCU) reset
540

  
541

  
542
# Generate avr-gdb config/init file which does the following:
543
#     define the reset signal, load the target file, connect to target, and set
544
#     a breakpoint at main().
545
gdb-config:
546
	@$(REMOVE) $(GDBINIT_FILE)
547
	@echo define reset >> $(GDBINIT_FILE)
548
	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
549
	@echo end >> $(GDBINIT_FILE)
550
	@echo file $(TARGET).elf >> $(GDBINIT_FILE)
551
	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
552
ifeq ($(DEBUG_BACKEND),simulavr)
553
	@echo load  >> $(GDBINIT_FILE)
554
endif
555
	@echo break main >> $(GDBINIT_FILE)
556

  
557
debug: gdb-config $(TARGET).elf
558
ifeq ($(DEBUG_BACKEND), avarice)
559
	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
560
	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
561
	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
562
	@$(WINSHELL) /c pause
563

  
564
else
565
	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
566
	$(DEBUG_MFREQ) --port $(DEBUG_PORT)
567
endif
568
	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
569

  
570

  
571

  
572

  
573
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
574
COFFCONVERT = $(OBJCOPY) --debugging
575
COFFCONVERT += --change-section-address .data-0x800000
576
COFFCONVERT += --change-section-address .bss-0x800000
577
COFFCONVERT += --change-section-address .noinit-0x800000
578
COFFCONVERT += --change-section-address .eeprom-0x810000
579

  
580

  
581

  
582
coff: $(TARGET).elf
583
	@echo
584
	@echo $(MSG_COFF) $(TARGET).cof
585
	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
586

  
587

  
588
extcoff: $(TARGET).elf
589
	@echo
590
	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
591
	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
592

  
593

  
594

  
595
# Create final output files (.hex, .eep) from ELF output file.
596
%.hex: %.elf
597
	@echo
598
	@echo $(MSG_FLASH) $@
599
	$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock $< $@
600

  
601
%.eep: %.elf
602
	@echo
603
	@echo $(MSG_EEPROM) $@
604
	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
605
	--change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0
606

  
607
# Create extended listing file from ELF output file.
608
%.lss: %.elf
609
	@echo
610
	@echo $(MSG_EXTENDED_LISTING) $@
611
	$(OBJDUMP) -h -S -z $< > $@
612

  
613
# Create a symbol table from ELF output file.
614
%.sym: %.elf
615
	@echo
616
	@echo $(MSG_SYMBOL_TABLE) $@
617
	$(NM) -n $< > $@
618

  
619

  
620

  
621
# Create library from object files.
622
.SECONDARY : $(TARGET).a
623
.PRECIOUS : $(OBJ)
624
%.a: $(OBJ)
625
	@echo
626
	@echo $(MSG_CREATING_LIBRARY) $@
627
	$(AR) $@ $(OBJ)
628

  
629

  
630
# Link: create ELF output file from object files.
631
.SECONDARY : $(TARGET).elf
632
.PRECIOUS : $(OBJ)
633
%.elf: $(OBJ)
634
	@echo
635
	@echo $(MSG_LINKING) $@
636
	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
637

  
638

  
639
# Compile: create object files from C source files.
640
$(OBJDIR)/%.o : %.c
641
	@echo
642
	@echo $(MSG_COMPILING) $<
643
	$(CC) -c $(ALL_CFLAGS) $< -o $@
644

  
645

  
646
# Compile: create object files from C++ source files.
647
$(OBJDIR)/%.o : %.cpp
648
	@echo
649
	@echo $(MSG_COMPILING_CPP) $<
650
	$(CC) -c $(ALL_CPPFLAGS) $< -o $@
651

  
652

  
653
# Compile: create assembler files from C source files.
654
%.s : %.c
655
	$(CC) -S $(ALL_CFLAGS) $< -o $@
656

  
657

  
658
# Compile: create assembler files from C++ source files.
659
%.s : %.cpp
660
	$(CC) -S $(ALL_CPPFLAGS) $< -o $@
661

  
662

  
663
# Assemble: create object files from assembler source files.
664
$(OBJDIR)/%.o : %.S
665
	@echo
666
	@echo $(MSG_ASSEMBLING) $<
667
	$(CC) -c $(ALL_ASFLAGS) $< -o $@
668

  
669

  
670
# Create preprocessed source for use in sending a bug report.
671
%.i : %.c
672
	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@
673

  
674

  
675
# Target: clean project.
676
clean: begin clean_list end
677

  
678
clean_list :
679
	@echo
680
	@echo $(MSG_CLEANING)
681
	$(REMOVE) $(TARGET).hex
682
	$(REMOVE) $(TARGET).eep
683
	$(REMOVE) $(TARGET).cof
684
	$(REMOVE) $(TARGET).elf
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff