Demos/Device/LowLevel/AudioInput/AudioInput.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2012.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2012  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 /** \file
  32  *
  33  *  Main source file for the Audio Input demo. This file contains the main tasks of the demo and
  34  *  is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "AudioInput.h"
  38
  39 /** Flag to indicate if the streaming audio alternative interface has been selected by the host. */
  40 static bool StreamingAudioInterfaceSelected = false;
  41
  42 /** Current audio sampling frequency of the streaming audio endpoint. */
  43 static uint32_t CurrentAudioSampleFrequency = 48000;
  44
  45
  46 /** Main program entry point. This routine contains the overall program flow, including initial
  47  *  setup of all components and the main program loop.
  48  */
  49 int main(void)
  50 {
  51         SetupHardware();
  52
  53         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  54         sei();
  55
  56         for (;;)
  57         {
  58                 USB_USBTask();
  59         }
  60 }
  61
  62 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  63 void SetupHardware(void)
  64 {
  65         /* Disable watchdog if enabled by bootloader/fuses */
  66         MCUSR &= ~(1 << WDRF);
  67         wdt_disable();
  68
  69         /* Disable clock division */
  70         clock_prescale_set(clock_div_1);
  71
  72         /* Hardware Initialization */
  73         LEDs_Init();
  74         Buttons_Init();
  75         ADC_Init(ADC_FREE_RUNNING | ADC_PRESCALE_32);
  76         ADC_SetupChannel(MIC_IN_ADC_CHANNEL);
  77         USB_Init();
  78
  79         /* Start the ADC conversion in free running mode */
  80         ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ADC_GET_CHANNEL_MASK(MIC_IN_ADC_CHANNEL));
  81 }
  82
  83 /** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs, and
  84  *  configures the sample update and PWM timers.
  85  */
  86 void EVENT_USB_Device_Connect(void)
  87 {
  88         /* Indicate USB enumerating */
  89         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
  90
  91         /* Sample reload timer initialization */
  92         TIMSK0  = (1 << OCIE0A);
  93         OCR0A   = ((F_CPU / 8 / CurrentAudioSampleFrequency) - 1);
  94         TCCR0A  = (1 << WGM01);  // CTC mode
  95         TCCR0B  = (1 << CS01);   // Fcpu/8 speed
  96 }
  97
  98 /** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
  99  *  the status LEDs, disables the sample update and PWM output timers and stops the USB and Audio management tasks.
 100  */
 101 void EVENT_USB_Device_Disconnect(void)
 102 {
 103         /* Stop the sample reload timer */
 104         TCCR0B = 0;
 105
 106         /* Indicate streaming audio interface not selected */
 107         StreamingAudioInterfaceSelected = false;
 108
 109         /* Indicate USB not ready */
 110         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 111 }
 112
 113 /** Event handler for the USB_ConfigurationChanged event. This is fired when the host set the current configuration
 114  *  of the USB device after enumeration - the device endpoints are configured.
 115  */
 116 void EVENT_USB_Device_ConfigurationChanged(void)
 117 {
 118         bool ConfigSuccess = true;
 119
 120         /* Setup Audio Stream Endpoint */
 121         ConfigSuccess &= Endpoint_ConfigureEndpoint(AUDIO_STREAM_EPADDR, EP_TYPE_ISOCHRONOUS, AUDIO_STREAM_EPSIZE, 2);
 122
 123         /* Indicate endpoint configuration success or failure */
 124         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 125 }
 126
 127 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 128  *  the device from the USB host before passing along unhandled control requests to the library for processing
 129  *  internally.
 130  */
 131 void EVENT_USB_Device_ControlRequest(void)
 132 {
 133         /* Process General and Audio specific control requests */
 134         switch (USB_ControlRequest.bRequest)
 135         {
 136                 case REQ_SetInterface:
 137                         /* Set Interface is not handled by the library, as its function is application-specific */
 138                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE))
 139                         {
 140                                 Endpoint_ClearSETUP();
 141                                 Endpoint_ClearStatusStage();
 142
 143                                 /* Check if the host is enabling the audio interface (setting AlternateSetting to 1) */
 144                                 StreamingAudioInterfaceSelected = ((USB_ControlRequest.wValue) != 0);
 145                         }
 146
 147                         break;
 148                 case AUDIO_REQ_GetStatus:
 149                         /* Get Status request can be directed at either the interface or endpoint, neither is currently used
 150                          * according to the latest USB Audio 1.0 standard, but must be ACKed with no data when requested */
 151                         if ((USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) ||
 152                             (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT)))
 153                         {
 154                                 Endpoint_ClearSETUP();
 155                                 Endpoint_ClearStatusStage();
 156                         }
 157
 158                         break;
 159                 case AUDIO_REQ_SetCurrent:
 160                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT))
 161                         {
 162                                 /* Extract out the relevant request information to get the target Endpoint address and control being set */
 163                                 uint8_t EndpointAddress = (uint8_t)USB_ControlRequest.wIndex;
 164                                 uint8_t EndpointControl = (USB_ControlRequest.wValue >> 8);
 165
 166                                 /* Only handle SET CURRENT requests to the audio endpoint's sample frequency property */
 167                                 if ((EndpointAddress == AUDIO_STREAM_EPADDR) && (EndpointControl == AUDIO_EPCONTROL_SamplingFreq))
 168                                 {
 169                                         uint8_t SampleRate[3];
 170
 171                                         Endpoint_ClearSETUP();
 172                                         Endpoint_Read_Control_Stream_LE(SampleRate, sizeof(SampleRate));
 173                                         Endpoint_ClearIN();
 174
 175                                         /* Set the new sampling frequency to the value given by the host */
 176                                         CurrentAudioSampleFrequency = (((uint32_t)SampleRate[2] << 16) | ((uint32_t)SampleRate[1] << 8) | (uint32_t)SampleRate[0]);
 177
 178                                         /* Adjust sample reload timer to the new frequency */
 179                                         OCR0A = ((F_CPU / 8 / CurrentAudioSampleFrequency) - 1);
 180                                 }
 181                         }
 182
 183                         break;
 184                 case AUDIO_REQ_GetCurrent:
 185                         if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_ENDPOINT))
 186                         {
 187                                 /* Extract out the relevant request information to get the target Endpoint address and control being retrieved */
 188                                 uint8_t EndpointAddress = (uint8_t)USB_ControlRequest.wIndex;
 189                                 uint8_t EndpointControl = (USB_ControlRequest.wValue >> 8);
 190
 191                                 /* Only handle GET CURRENT requests to the audio endpoint's sample frequency property */
 192                                 if ((EndpointAddress == AUDIO_STREAM_EPADDR) && (EndpointControl == AUDIO_EPCONTROL_SamplingFreq))
 193                                 {
 194                                         uint8_t SampleRate[3];
 195
 196                                         /* Convert the sampling rate value into the 24-bit format the host expects for the property */
 197                                         SampleRate[2] = (CurrentAudioSampleFrequency >> 16);
 198                                         SampleRate[1] = (CurrentAudioSampleFrequency >> 8);
 199                                         SampleRate[0] = (CurrentAudioSampleFrequency &  0xFF);
 200
 201                                         Endpoint_ClearSETUP();
 202                                         Endpoint_Write_Control_Stream_LE(SampleRate, sizeof(SampleRate));
 203                                         Endpoint_ClearOUT();
 204                                 }
 205                         }
 206
 207                         break;
 208         }
 209 }
 210
 211 /** ISR to handle the reloading of the data endpoint with the next sample. */
 212 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 213 {
 214         uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
 215
 216         /* Select the audio stream endpoint */
 217         Endpoint_SelectEndpoint(AUDIO_STREAM_EPADDR);
 218
 219         /* Check if the current endpoint can be written to and that the audio interface is enabled */
 220         if (Endpoint_IsINReady() && StreamingAudioInterfaceSelected)
 221         {
 222                 int16_t AudioSample;
 223
 224                 #if defined(USE_TEST_TONE)
 225                         static uint8_t SquareWaveSampleCount;
 226                         static int16_t CurrentWaveValue;
 227
 228                         /* In test tone mode, generate a square wave at 1/256 of the sample rate */
 229                         if (SquareWaveSampleCount++ == 0xFF)
 230                           CurrentWaveValue ^= 0x8000;
 231
 232                         /* Only generate audio if the board button is being pressed */
 233                         AudioSample = (Buttons_GetStatus() & BUTTONS_BUTTON1) ? CurrentWaveValue : 0;
 234                 #else
 235                         /* Audio sample is ADC value scaled to fit the entire range */
 236                         AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
 237
 238                         #if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
 239                         /* Microphone is biased to half rail voltage, subtract the bias from the sample value */
 240                         AudioSample -= (SAMPLE_MAX_RANGE / 2);
 241                         #endif
 242                 #endif
 243
 244                 /* Write the sample to the buffer */
 245                 Endpoint_Write_16_LE(AudioSample);
 246
 247                 /* Check to see if the bank is now full */
 248                 if (!(Endpoint_IsReadWriteAllowed()))
 249                 {
 250                         /* Send the full packet to the host */
 251                         Endpoint_ClearIN();
 252                 }
 253         }
 254
 255         Endpoint_SelectEndpoint(PrevEndpoint);
 256 }
 257