Demos/Device/Incomplete/TestAndMeasurement/TestAndMeasurement.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
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #include "TestAndMeasurement.h"
  32
  33 /** Contains the (usually static) capabilities of the TMC device. This table is requested by the
  34  *  host upon enumeration to give it information on what features of the Test and Measurement USB
  35  *  Class the device supports.
  36  */
  37 TMC_Capabilities_t Capabilities =
  38         {
  39                 .Status     = TMC_STATUS_SUCCESS,
  40                 .TMCVersion = VERSION_BCD(1.00),
  41
  42                 .Interface  =
  43                         {
  44                                 .ListenOnly             = false,
  45                                 .TalkOnly               = false,
  46                                 .PulseIndicateSupported = false,
  47                         },
  48
  49                 .Device     =
  50                         {
  51                                 .SupportsAbortINOnMatch = false,
  52                         },
  53         };
  54
  55 /** Current TMC control request that is being processed */
  56 static uint8_t RequestInProgress = 0;
  57
  58 /** Stream callback abort flag for bulk IN data */
  59 static bool IsTMCBulkINReset = false;
  60
  61 /** Stream callback abort flag for bulk OUT data */
  62 static bool IsTMCBulkOUTReset = false;
  63
  64 /** Last used tag value for data transfers */
  65 static uint8_t CurrentTransferTag = 0;
  66
  67 /** Length of last data transfer, for reporting to the host in case an in-progress transfer is aborted */
  68 static uint16_t LastTransferLength = 0;
  69
  70 /** Buffer to hold the next message to sent to the TMC host */
  71 static uint8_t NextResponseBuffer[64];
  72
  73 /** Indicates the length of the next response to send */
  74 static uint8_t NextReponseLen;
  75
  76 /** Main program entry point. This routine contains the overall program flow, including initial
  77  *  setup of all components and the main program loop.
  78  */
  79 int main(void)
  80 {
  81         SetupHardware();
  82
  83         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  84         sei();
  85
  86         for (;;)
  87         {
  88                 TMC_Task();
  89                 USB_USBTask();
  90         }
  91 }
  92
  93 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  94 void SetupHardware(void)
  95 {
  96         /* Disable watchdog if enabled by bootloader/fuses */
  97         MCUSR &= ~(1 << WDRF);
  98         wdt_disable();
  99
 100         /* Disable clock division */
 101         clock_prescale_set(clock_div_1);
 102
 103         /* Hardware Initialization */
 104         LEDs_Init();
 105         USB_Init();
 106 }
 107
 108 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
 109  *  starts the library USB task to begin the enumeration and USB management process.
 110  */
 111 void EVENT_USB_Device_Connect(void)
 112 {
 113         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 114 }
 115
 116 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
 117  *  the status LEDs and stops the USB management and CDC management tasks.
 118  */
 119 void EVENT_USB_Device_Disconnect(void)
 120 {
 121         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 122 }
 123
 124 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
 125  *  of the USB device after enumeration - the device endpoints are configured and the CDC management task started.
 126  */
 127 void EVENT_USB_Device_ConfigurationChanged(void)
 128 {
 129         bool ConfigSuccess = true;
 130
 131         /* Setup TMC In, Out and Notification Endpoints */
 132         ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_NOTIFICATION_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
 133                                                     TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
 134         ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_IN_EPNUM,  EP_TYPE_BULK, ENDPOINT_DIR_IN,
 135                                                     TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
 136         ConfigSuccess &= Endpoint_ConfigureEndpoint(TMC_OUT_EPNUM, EP_TYPE_BULK, ENDPOINT_DIR_OUT,
 137                                                     TMC_IO_EPSIZE, ENDPOINT_BANK_SINGLE);
 138
 139         /* Indicate endpoint configuration success or failure */
 140         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 141 }
 142
 143 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 144  *  the device from the USB host before passing along unhandled control requests to the library for processing
 145  *  internally.
 146  */
 147 void EVENT_USB_Device_ControlRequest(void)
 148 {
 149         uint8_t TMCRequestStatus = TMC_STATUS_SUCCESS;
 150
 151         /* Process TMC specific control requests */
 152         switch (USB_ControlRequest.bRequest)
 153         {
 154                 case Req_InitiateAbortBulkOut:
 155                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
 156                         {
 157                                 /* Check that no split transaction is already in progress and the data transfer tag is valid */
 158                                 if (RequestInProgress != 0)
 159                                 {
 160                                         TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;
 161                                 }
 162                                 else if (USB_ControlRequest.wValue != CurrentTransferTag)
 163                                 {
 164                                         TMCRequestStatus = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
 165                                 }
 166                                 else
 167                                 {
 168                                         /* Indicate that all in-progress/pending data OUT requests should be aborted */
 169                                         IsTMCBulkOUTReset = true;
 170
 171                                         /* Save the split request for later checking when a new request is received */
 172                                         RequestInProgress = Req_InitiateAbortBulkOut;
 173                                 }
 174
 175                                 Endpoint_ClearSETUP();
 176
 177                                 /* Write the request response byte */
 178                                 Endpoint_Write_8(TMCRequestStatus);
 179
 180                                 Endpoint_ClearIN();
 181                                 Endpoint_ClearStatusStage();
 182                         }
 183
 184                         break;
 185                 case Req_CheckAbortBulkOutStatus:
 186                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
 187                         {
 188                                 /* Check that an ABORT BULK OUT transaction has been requested and that the request has completed */
 189                                 if (RequestInProgress != Req_InitiateAbortBulkOut)
 190                                   TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;
 191                                 else if (IsTMCBulkOUTReset)
 192                                   TMCRequestStatus = TMC_STATUS_PENDING;
 193                                 else
 194                                   RequestInProgress = 0;
 195
 196                                 Endpoint_ClearSETUP();
 197
 198                                 /* Write the request response bytes */
 199                                 Endpoint_Write_8(TMCRequestStatus);
 200                                 Endpoint_Write_16_LE(0);
 201                                 Endpoint_Write_32_LE(LastTransferLength);
 202
 203                                 Endpoint_ClearIN();
 204                                 Endpoint_ClearStatusStage();
 205                         }
 206
 207                         break;
 208                 case Req_InitiateAbortBulkIn:
 209                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
 210                         {
 211                                 /* Check that no split transaction is already in progress and the data transfer tag is valid */
 212                                 if (RequestInProgress != 0)
 213                                 {
 214                                         TMCRequestStatus = TMC_STATUS_SPLIT_IN_PROGRESS;
 215                                 }
 216                                 else if (USB_ControlRequest.wValue != CurrentTransferTag)
 217                                 {
 218                                         TMCRequestStatus = TMC_STATUS_TRANSFER_NOT_IN_PROGRESS;
 219                                 }
 220                                 else
 221                                 {
 222                                         /* Indicate that all in-progress/pending data IN requests should be aborted */
 223                                         IsTMCBulkINReset = true;
 224
 225                                         /* Save the split request for later checking when a new request is received */
 226                                         RequestInProgress = Req_InitiateAbortBulkIn;
 227                                 }
 228
 229                                 Endpoint_ClearSETUP();
 230
 231                                 /* Write the request response bytes */
 232                                 Endpoint_Write_8(TMCRequestStatus);
 233                                 Endpoint_Write_8(CurrentTransferTag);
 234
 235                                 Endpoint_ClearIN();
 236                                 Endpoint_ClearStatusStage();
 237                         }
 238
 239                         break;
 240                 case Req_CheckAbortBulkInStatus:
 241                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
 242                         {
 243                                 /* Check that an ABORT BULK IN transaction has been requested and that the request has completed */
 244                                 if (RequestInProgress != Req_InitiateAbortBulkIn)
 245                                   TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;
 246                                 else if (IsTMCBulkINReset)
 247                                   TMCRequestStatus = TMC_STATUS_PENDING;
 248                                 else
 249                                   RequestInProgress = 0;
 250
 251                                 Endpoint_ClearSETUP();
 252
 253                                 /* Write the request response bytes */
 254                                 Endpoint_Write_8(TMCRequestStatus);
 255                                 Endpoint_Write_16_LE(0);
 256                                 Endpoint_Write_32_LE(LastTransferLength);
 257
 258                                 Endpoint_ClearIN();
 259                                 Endpoint_ClearStatusStage();
 260                         }
 261
 262                         break;
 263                 case Req_InitiateClear:
 264                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 265                         {
 266                                 /* Check that no split transaction is already in progress */
 267                                 if (RequestInProgress != 0)
 268                                 {
 269                                         Endpoint_Write_8(TMC_STATUS_SPLIT_IN_PROGRESS);
 270                                 }
 271                                 else
 272                                 {
 273                                         /* Indicate that all in-progress/pending data IN and OUT requests should be aborted */
 274                                         IsTMCBulkINReset  = true;
 275                                         IsTMCBulkOUTReset = true;
 276
 277                                         /* Save the split request for later checking when a new request is received */
 278                                         RequestInProgress = Req_InitiateClear;
 279                                 }
 280
 281                                 Endpoint_ClearSETUP();
 282
 283                                 /* Write the request response byte */
 284                                 Endpoint_Write_8(TMCRequestStatus);
 285
 286                                 Endpoint_ClearIN();
 287                                 Endpoint_ClearStatusStage();
 288                         }
 289
 290                         break;
 291                 case Req_CheckClearStatus:
 292                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 293                         {
 294                                 /* Check that a CLEAR transaction has been requested and that the request has completed */
 295                                 if (RequestInProgress != Req_InitiateClear)
 296                                   TMCRequestStatus = TMC_STATUS_SPLIT_NOT_IN_PROGRESS;
 297                                 else if (IsTMCBulkINReset || IsTMCBulkOUTReset)
 298                                   TMCRequestStatus = TMC_STATUS_PENDING;
 299                                 else
 300                                   RequestInProgress = 0;
 301
 302                                 Endpoint_ClearSETUP();
 303
 304                                 /* Write the request response bytes */
 305                                 Endpoint_Write_8(TMCRequestStatus);
 306                                 Endpoint_Write_8(0);
 307
 308                                 Endpoint_ClearIN();
 309                                 Endpoint_ClearStatusStage();
 310                         }
 311
 312                         break;
 313                 case Req_GetCapabilities:
 314                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
 315                         {
 316                                 Endpoint_ClearSETUP();
 317
 318                                 /* Write the device capabilities to the control endpoint */
 319                                 Endpoint_Write_Control_Stream_LE(&Capabilities, sizeof(TMC_Capabilities_t));
 320                                 Endpoint_ClearOUT();
 321                         }
 322
 323                         break;
 324         }
 325 }
 326
 327 void ProcessSentMessage(uint8_t* const Data, const uint8_t Length)
 328 {
 329         if (strncmp((char*)Data, "*IDN?", 5) == 0)
 330           strcpy((char*)NextResponseBuffer, "LUFA TMC DEMO");
 331
 332         NextReponseLen = strlen((char*)NextResponseBuffer);
 333 }
 334
 335 uint8_t GetNextMessage(uint8_t* const Data)
 336 {
 337           strcpy((char*)NextResponseBuffer, "LUFA TMC DEMO");
 338
 339         NextReponseLen = strlen((char*)NextResponseBuffer);
 340 // ---
 341         uint8_t DataLen = MIN(NextReponseLen, 64);
 342
 343         strlcpy((char*)Data, (char*)NextResponseBuffer, DataLen);
 344
 345         return DataLen;
 346 }
 347
 348 /** Function to manage TMC data transmission and reception to and from the host. */
 349 void TMC_Task(void)
 350 {
 351         /* Device must be connected and configured for the task to run */
 352         if (USB_DeviceState != DEVICE_STATE_Configured)
 353           return;
 354
 355         TMC_MessageHeader_t MessageHeader;
 356         uint8_t             MessagePayload[128];
 357
 358         /* Try to read in a TMC message from the interface, process if one is available */
 359         if (ReadTMCHeader(&MessageHeader))
 360         {
 361                 /* Indicate busy */
 362                 LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
 363
 364                 switch (MessageHeader.MessageID)
 365                 {
 366                         case TMC_MESSAGEID_DEV_DEP_MSG_OUT:
 367                                 LastTransferLength = 0;
 368                                 while (Endpoint_Read_Stream_LE(MessagePayload, MIN(MessageHeader.TransferSize, sizeof(MessagePayload)), &LastTransferLength) ==
 369                                        ENDPOINT_RWSTREAM_IncompleteTransfer)
 370                                 {
 371                                         if (IsTMCBulkOUTReset)
 372                                           break;
 373                                 }
 374
 375                                 Endpoint_ClearOUT();
 376
 377                                 ProcessSentMessage(MessagePayload, LastTransferLength);
 378                                 break;
 379                         case TMC_MESSAGEID_DEV_DEP_MSG_IN:
 380                                 Endpoint_ClearOUT();
 381
 382                                 MessageHeader.TransferSize = GetNextMessage(MessagePayload);
 383                                 MessageHeader.MessageIDSpecific.DeviceOUT.LastMessageTransaction = true;
 384                                 WriteTMCHeader(&MessageHeader);
 385
 386                                 LastTransferLength = 0;
 387                                 while (Endpoint_Write_Stream_LE(MessagePayload, MessageHeader.TransferSize, &LastTransferLength) ==
 388                                        ENDPOINT_RWSTREAM_IncompleteTransfer)
 389                                 {
 390                                         if (IsTMCBulkINReset)
 391                                           break;
 392                                 }
 393
 394                                 Endpoint_ClearIN();
 395                                 break;
 396                         default:
 397                                 Endpoint_StallTransaction();
 398                                 break;
 399                 }
 400
 401                 LEDs_SetAllLEDs(LEDMASK_USB_READY);
 402         }
 403
 404         /* All pending data has been processed - reset the data abort flags */
 405         IsTMCBulkINReset  = false;
 406         IsTMCBulkOUTReset = false;
 407 }
 408
 409 /** Attempts to read in the TMC message header from the TMC interface.
 410  *
 411  *  \param[out] MessageHeader  Pointer to a location where the read header (if any) should be stored
 412  *
 413  *  \return Boolean true if a header was read, false otherwise
 414  */
 415 bool ReadTMCHeader(TMC_MessageHeader_t* const MessageHeader)
 416 {
 417         uint16_t BytesTransferred;
 418         uint8_t  ErrorCode;
 419
 420         /* Select the Data Out endpoint */
 421         Endpoint_SelectEndpoint(TMC_OUT_EPNUM);
 422
 423         /* Abort if no command has been sent from the host */
 424         if (!(Endpoint_IsOUTReceived()))
 425           return false;
 426
 427         /* Read in the header of the command from the host */
 428         BytesTransferred = 0;
 429         while ((ErrorCode = Endpoint_Read_Stream_LE(MessageHeader, sizeof(TMC_MessageHeader_t), &BytesTransferred)) ==
 430                ENDPOINT_RWSTREAM_IncompleteTransfer)
 431         {
 432                 if (IsTMCBulkOUTReset)
 433                   break;
 434         }
 435
 436         /* Store the new command tag value for later use */
 437         CurrentTransferTag = MessageHeader->Tag;
 438
 439         /* Indicate if the command has been aborted or not */
 440         return (!(IsTMCBulkOUTReset) && (ErrorCode == ENDPOINT_RWSTREAM_NoError));
 441 }
 442
 443 bool WriteTMCHeader(TMC_MessageHeader_t* const MessageHeader)
 444 {
 445         uint16_t BytesTransferred;
 446         uint8_t  ErrorCode;
 447
 448         /* Set the message tag of the command header */
 449         MessageHeader->Tag        =  CurrentTransferTag;
 450         MessageHeader->InverseTag = ~CurrentTransferTag;
 451
 452         /* Select the Data In endpoint */
 453         Endpoint_SelectEndpoint(TMC_IN_EPNUM);
 454
 455         /* Send the command header to the host */
 456         BytesTransferred = 0;
 457         while ((ErrorCode = Endpoint_Write_Stream_LE(MessageHeader, sizeof(TMC_MessageHeader_t), &BytesTransferred)) ==
 458                ENDPOINT_RWSTREAM_IncompleteTransfer)
 459         {
 460                 if (IsTMCBulkINReset)
 461                   break;
 462         }
 463
 464         /* Indicate if the command has been aborted or not */
 465         return (!(IsTMCBulkINReset) && (ErrorCode == ENDPOINT_RWSTREAM_NoError));
 466 }