TestAndMeasurement.c 13.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*
             LUFA Library
     Copyright (C) Dean Camera, 2010.
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

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

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

#include "TestAndMeasurement.h"

33
34
35
36
37
38
/** Contains the (usually static) capabilities of the TMC device. This table is requested by the
 *  host upon enumeration to give it information on what features of the Test and Measurement USB
 *  Class the device supports.
 */
TMC_Capabilities_t Capabilities =
	{
39
		.Status     = TMC_STATUS_SUCCESS,
40
41
42
43
44
45
		.TMCVersion = VERSION_BCD(1.00),
		
		.Interface  =
			{
				.ListenOnly             = false,
				.TalkOnly               = false,
46
				.PulseIndicateSupported = false,
47
48
49
50
51
52
53
54
			},

		.Device     =
			{
				.SupportsAbortINOnMatch = false,
			},
	};

55
/** Current TMC control request that is being processed */
56
uint8_t RequestInProgress = 0;
57
58

/** Stream callback abort flag for bulk IN data */
59
bool IsTMCBulkINReset = false;
60
61

/** Stream callback abort flag for bulk OUT data */
62
bool IsTMCBulkOUTReset = false;
63

64
65
/** Last used tag value for data transfers */
uint8_t CurrentTransferTag = 0;
66

67

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/** 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);
	sei();
	
	for (;;)
	{
		TMC_Task();
		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();

	/* Disable clock division */
	clock_prescale_set(clock_div_1);
	
	/* Hardware Initialization */
	LEDs_Init();
	USB_Init();
}

100
101
102
/** 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.
 */
103
104
105
106
107
void EVENT_USB_Device_Connect(void)
{
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
}

108
109
110
/** 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 and CDC management tasks.
 */
111
112
113
114
115
void EVENT_USB_Device_Disconnect(void)
{
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
}

116
117
118
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
 *  of the USB device after enumeration - the device endpoints are configured and the CDC management task started.
 */
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
void EVENT_USB_Device_ConfigurationChanged(void)
{
	LEDs_SetAllLEDs(LEDMASK_USB_READY);

	/* Setup TMC In and Out Endpoints */
	if (!(Endpoint_ConfigureEndpoint(TMC_IN_EPNUM, EP_TYPE_BULK,
		                             ENDPOINT_DIR_IN, TMC_IO_EPSIZE,
	                                 ENDPOINT_BANK_SINGLE)))
	{
		LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
	}

	if (!(Endpoint_ConfigureEndpoint(TMC_OUT_EPNUM, EP_TYPE_BULK,
		                             ENDPOINT_DIR_OUT, TMC_IO_EPSIZE,
	                                 ENDPOINT_BANK_SINGLE)))
	{
		LEDs_SetAllLEDs(LEDMASK_USB_ERROR);
	}
}

139
140
141
142
/** Event handler for the USB_UnhandledControlRequest event. This is used to catch standard and class specific
 *  control requests that are not handled internally by the USB library (including the CDC control commands,
 *  which are all issued via the control endpoint), so that they can be handled appropriately for the application.
 */
143
144
void EVENT_USB_Device_UnhandledControlRequest(void)
{
145
	uint8_t TMCRequestStatus = TMC_STATUS_SUCCESS;
146

147
	/* Process TMC specific control requests */
148
149
150
151
152
	switch (USB_ControlRequest.bRequest)
	{
		case Req_InitiateAbortBulkOut:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
			{
153
154
				Endpoint_ClearSETUP();
				
155
				/* Check that no split transaction is already in progress and the data transfer tag is valid */
156
				if (RequestInProgress != 0)
157
				{
158
					TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;
159
				}
160
				else if (USB_ControlRequest.wValue != CurrentTransferTag)
161
				{
162
					TMCRequestStatus = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
163
164
165
166
167
168
169
				}
				else
				{
					/* Indicate that all in-progress/pending data OUT requests should be aborted */
					IsTMCBulkOUTReset = true;
					
					/* Save the split request for later checking when a new request is received */
170
					RequestInProgress = Req_InitiateAbortBulkOut;
171
172
				}
				
173
174
175
				/* Write the request response byte */
				Endpoint_Write_Byte(TMCRequestStatus);

176
177
				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();
178
179
180
181
182
183
			}
			
			break;
		case Req_CheckAbortBulkOutStatus:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
			{
184
185
				Endpoint_ClearSETUP();
				
186
				/* Check that an ABORT BULK OUT transaction has been requested and that the request has completed */
187
				if (RequestInProgress != Req_InitiateAbortBulkOut)
188
				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;				
189
				else if (IsTMCBulkOUTReset)
190
				  TMCRequestStatus = TMC_STATUS_PENDING;
191
				else
192
				  RequestInProgress = 0;			
193
				
194
195
196
197
				/* Write the request response bytes */
				Endpoint_Write_Byte(TMCRequestStatus);
				Endpoint_Write_Word_LE(0);
				Endpoint_Write_DWord_LE(0); // TODO - Last transfer length
198
199
200

				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();				
201
202
203
204
205
206
			}
			
			break;
		case Req_InitiateAbortBulkIn:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
			{
207
208
				Endpoint_ClearSETUP();
				
209
				/* Check that no split transaction is already in progress and the data transfer tag is valid */
210
				if (RequestInProgress != 0)
211
				{
212
					TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;				
213
				}
214
				else if (USB_ControlRequest.wValue != CurrentTransferTag)
215
				{
216
					TMCRequestStatus = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
217
218
219
220
				}
				else
				{
					/* Indicate that all in-progress/pending data IN requests should be aborted */
221
					IsTMCBulkINReset = true;
222
223
					
					/* Save the split request for later checking when a new request is received */
224
					RequestInProgress = Req_InitiateAbortBulkIn;
225
226
				}
				
227
228
				/* Write the request response bytes */
				Endpoint_Write_Byte(TMCRequestStatus);
229
				Endpoint_Write_Byte(CurrentTransferTag);
230

231
232
				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();
233
234
235
236
237
238
			}
			
			break;
		case Req_CheckAbortBulkInStatus:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
			{
239
240
				Endpoint_ClearSETUP();
				
241
				/* Check that an ABORT BULK IN transaction has been requested and that the request has completed */
242
				if (RequestInProgress != Req_InitiateAbortBulkIn)
243
				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;
244
				else if (IsTMCBulkINReset)
245
				  TMCRequestStatus = TMC_STATUS_PENDING;
246
				else
247
				  RequestInProgress = 0;
248
				
249
250
251
252
				/* Write the request response bytes */
				Endpoint_Write_Byte(TMCRequestStatus);
				Endpoint_Write_Word_LE(0);
				Endpoint_Write_DWord_LE(0); // TODO - Last transfer length
253
254

				Endpoint_ClearIN();
255
				Endpoint_ClearStatusStage();
256
257
258
259
260
261
			}
			
			break;
		case Req_InitiateClear:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
			{
262
263
				Endpoint_ClearSETUP();
				
264
				/* Check that no split transaction is already in progress */
265
				if (RequestInProgress != 0)
266
				{
267
					Endpoint_Write_Byte(TMC_STATUS_SPLIT_IN_PROGRESS);				
268
269
270
271
272
273
274
275
				}
				else
				{
					/* Indicate that all in-progress/pending data IN and OUT requests should be aborted */
					IsTMCBulkINReset  = true;
					IsTMCBulkOUTReset = true;
					
					/* Save the split request for later checking when a new request is received */
276
					RequestInProgress = Req_InitiateClear;
277
278
				}
				
279
280
281
				/* Write the request response byte */
				Endpoint_Write_Byte(TMCRequestStatus);

282
283
				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();
284
285
286
287
288
289
			}
			
			break;
		case Req_CheckClearStatus:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
			{
290
291
				Endpoint_ClearSETUP();
				
292
				/* Check that a CLEAR transaction has been requested and that the request has completed */
293
				if (RequestInProgress != Req_InitiateClear)
294
				  TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;				
295
				else if (IsTMCBulkINReset || IsTMCBulkOUTReset)
296
				  TMCRequestStatus = TMC_STATUS_PENDING;
297
				else
298
				  RequestInProgress = 0;
299
				
300
301
302
				/* Write the request response bytes */
				Endpoint_Write_Byte(TMCRequestStatus);
				Endpoint_Write_Byte(0);
303
304
305
				
				Endpoint_ClearIN();
				Endpoint_ClearStatusStage();				
306
307
308
309
310
311
			}
			
			break;
		case Req_GetCapabilities:
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
			{
312
313
314
315
316
317
318
319
				/* Acknowledge the SETUP packet, ready for data transfer */
				Endpoint_ClearSETUP();
					
				/* Write the device capabilities to the control endpoint */
				Endpoint_Write_Control_Stream_LE(&Capabilities, sizeof(TMC_Capabilities_t));
				
				/* Finalize the stream transfer to send the last packet or clear the host abort */
				Endpoint_ClearOUT();
320
321
322
323
324
			}
			
			break;
	}
}
325
326

/** Function to manage TMC data transmission and reception to and from the host. */
327
328
329
330
331
void TMC_Task(void)
{
	/* Device must be connected and configured for the task to run */
	if (USB_DeviceState != DEVICE_STATE_Configured)
	  return;
332
	
333
334
335
336
	TMC_MessageHeader_t MessageHeader;
	
	/* Check if a TMC packet has been received */
	if (ReadTMCHeader(&MessageHeader))
337
	{
338
339
		/* Indicate busy */
		LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
340
		
341
342
343
		switch (MessageHeader.MessageID)
		{
			case TMC_MESSAGEID_DEV_DEP_MSG_OUT:
344
345
				Endpoint_Discard_Stream(MessageHeader.TransferSize, StreamCallback_AbortOUTOnRequest);
				Endpoint_ClearOUT();
346
347
				break;
			case TMC_MESSAGEID_DEV_DEP_MSG_IN:
348
				Endpoint_ClearOUT();
349

350
351
				MessageHeader.TransferSize = 3;
				WriteTMCHeader(&MessageHeader);
352

353
354
				Endpoint_Write_Stream_LE("TMC", 3, StreamCallback_AbortINOnRequest);
				Endpoint_ClearIN();
355
356
357
				break;
			default:
				Endpoint_StallTransaction();
358
359
				break;
		}
360
361

		LEDs_SetAllLEDs(LEDMASK_USB_READY);
362
	}
363
364
365
366
	
	/* All pending data has been processed - reset the data abort flags */
	IsTMCBulkINReset  = false;
	IsTMCBulkOUTReset = false;
367
}
368

369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
bool ReadTMCHeader(TMC_MessageHeader_t* const MessageHeader)
{
	/* Select the Data Out endpoint */
	Endpoint_SelectEndpoint(TMC_OUT_EPNUM);
	
	/* Abort if no command has been sent from the host */
	if (!(Endpoint_IsOUTReceived()))
	  return false;
	
	/* Read in the header of the command from the host */
	Endpoint_Read_Stream_LE(MessageHeader, sizeof(TMC_MessageHeader_t), StreamCallback_AbortOUTOnRequest);

	/* Store the new command tag value for later use */
	CurrentTransferTag = MessageHeader->Tag;
	
	/* Indicate if the command has been aborted or not */
	return !IsTMCBulkOUTReset;
}

bool WriteTMCHeader(TMC_MessageHeader_t* const MessageHeader)
{
	/* Compute the next transfer tag value, must be between 1 and 254 */
	if (++CurrentTransferTag == 0xFF)
	  CurrentTransferTag = 1;

	/* Set the message tag of the command header */
	MessageHeader->Tag        =  CurrentTransferTag;
	MessageHeader->InverseTag = ~CurrentTransferTag;

	/* Select the Data In endpoint */
	Endpoint_SelectEndpoint(TMC_IN_EPNUM);

	/* Send the command header to the host */
	Endpoint_Write_Stream_LE(MessageHeader, sizeof(TMC_MessageHeader_t), StreamCallback_AbortINOnRequest);

	/* Indicate if the command has been aborted or not */
	return !IsTMCBulkINReset;
}

408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
/** Stream callback function for the Endpoint stream write functions. This callback will abort the current stream transfer
 *  if a TMC Abort Bulk IN request has been issued to the control endpoint.
 */
uint8_t StreamCallback_AbortINOnRequest(void)
{	
	/* Abort if a TMC Bulk Data IN abort was received */
	if (IsTMCBulkINReset)
	  return STREAMCALLBACK_Abort;
	
	/* Continue with the current stream operation */
	return STREAMCALLBACK_Continue;
}

/** Stream callback function for the Endpoint stream read functions. This callback will abort the current stream transfer
 *  if a TMC Abort Bulk OUT request has been issued to the control endpoint.
 */
uint8_t StreamCallback_AbortOUTOnRequest(void)
{	
	/* Abort if a TMC Bulk Data IN abort was received */
	if (IsTMCBulkOUTReset)
	  return STREAMCALLBACK_Abort;
	
	/* Continue with the current stream operation */
	return STREAMCALLBACK_Continue;
}