Demos/Device/LowLevel/AudioInput/AudioInput.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 /** \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 | MIC_IN_ADC_MUX_MASK);
  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_EPNUM, EP_TYPE_ISOCHRONOUS, ENDPOINT_DIR_IN,
 122                                                     AUDIO_STREAM_EPSIZE, ENDPOINT_BANK_DOUBLE);
 123
 124         /* Indicate endpoint configuration success or failure */
 125         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 126 }
 127
 128 /** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
 129  *  the device from the USB host before passing along unhandled control requests to the library for processing
 130  *  internally.
 131  */
 132 void EVENT_USB_Device_ControlRequest(void)
 133 {
 134         /* Process General and Audio specific control requests */
 135         switch (USB_ControlRequest.bRequest)
 136         {
 137                 case REQ_SetInterface:
 138                         /* Set Interface is not handled by the library, as its function is application-specific */
 139                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_STANDARD | REQREC_INTERFACE))
 140                         {
 141                                 Endpoint_ClearSETUP();
 142                                 Endpoint_ClearStatusStage();
 143
 144                                 /* Check if the host is enabling the audio interface (setting AlternateSetting to 1) */
 145                                 StreamingAudioInterfaceSelected = ((USB_ControlRequest.wValue) != 0);
 146                         }
 147
 148                         break;
 149                 case AUDIO_REQ_GetStatus:
 150                         /* Get Status request can be directed at either the interface or endpoint, neither is currently used
 151                          * according to the latest USB Audio 1.0 standard, but must be ACKed with no data when requested */
 152                         if ((USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE)) ||
 153                             (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT)))
 154                         {
 155                                 Endpoint_ClearSETUP();
 156                                 Endpoint_ClearStatusStage();
 157                         }
 158
 159                         break;
 160                 case AUDIO_REQ_SetCurrent:
 161                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT))
 162                         {
 163                                 /* Extract out the relevant request information to get the target Endpoint index and control being set */
 164                                 uint8_t EndpointIndex   = (uint8_t)USB_ControlRequest.wIndex;
 165                                 uint8_t EndpointControl = (USB_ControlRequest.wValue >> 8);
 166
 167                                 /* Only handle SET CURRENT requests to the audio endpoint's sample frequency property */
 168                                 if ((EndpointIndex == AUDIO_STREAM_EPNUM) && (EndpointControl == AUDIO_EPCONTROL_SamplingFreq))
 169                                 {
 170                                         uint8_t SampleRate[3];
 171
 172                                         Endpoint_ClearSETUP();
 173                                         Endpoint_Read_Control_Stream_LE(SampleRate, sizeof(SampleRate));
 174                                         Endpoint_ClearOUT();
 175
 176                                         /* Set the new sampling frequency to the value given by the host */
 177                                         CurrentAudioSampleFrequency = (((uint32_t)SampleRate[2] << 16) | ((uint32_t)SampleRate[1] << 8) | (uint32_t)SampleRate[0]);
 178
 179                                         /* Adjust sample reload timer to the new frequency */
 180                                         OCR0A = ((F_CPU / 8 / CurrentAudioSampleFrequency) - 1);
 181                                 }
 182                         }
 183
 184                         break;
 185                 case AUDIO_REQ_GetCurrent:
 186                         if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_ENDPOINT))
 187                         {
 188                                 /* Extract out the relevant request information to get the target Endpoint index and control being retrieved */
 189                                 uint8_t EndpointIndex   = (uint8_t)USB_ControlRequest.wIndex;
 190                                 uint8_t EndpointControl = (USB_ControlRequest.wValue >> 8);
 191
 192                                 /* Only handle GET CURRENT requests to the audio endpoint's sample frequency property */
 193                                 if ((EndpointIndex == AUDIO_STREAM_EPNUM) && (EndpointControl == AUDIO_EPCONTROL_SamplingFreq))
 194                                 {
 195                                         uint8_t SampleRate[3];
 196
 197                                         /* Convert the sampling rate value into the 24-bit format the host expects for the property */
 198                                         SampleRate[2] = (CurrentAudioSampleFrequency >> 16);
 199                                         SampleRate[1] = (CurrentAudioSampleFrequency >> 8);
 200                                         SampleRate[0] = (CurrentAudioSampleFrequency &  0xFF);
 201
 202                                         Endpoint_ClearSETUP();
 203                                         Endpoint_Write_Control_Stream_LE(SampleRate, sizeof(SampleRate));
 204                                         Endpoint_ClearOUT();
 205                                 }
 206                         }
 207
 208                         break;
 209         }
 210 }
 211
 212 /** ISR to handle the reloading of the data endpoint with the next sample. */
 213 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 214 {
 215         uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
 216
 217         /* Select the audio stream endpoint */
 218         Endpoint_SelectEndpoint(AUDIO_STREAM_EPNUM);
 219
 220         /* Check if the current endpoint can be written to and that the audio interface is enabled */
 221         if (Endpoint_IsINReady() && StreamingAudioInterfaceSelected)
 222         {
 223                 int16_t AudioSample;
 224
 225                 #if defined(USE_TEST_TONE)
 226                         static uint8_t SquareWaveSampleCount;
 227                         static int16_t CurrentWaveValue;
 228
 229                         /* In test tone mode, generate a square wave at 1/256 of the sample rate */
 230                         if (SquareWaveSampleCount++ == 0xFF)
 231                           CurrentWaveValue ^= 0x8000;
 232
 233                         /* Only generate audio if the board button is being pressed */
 234                         AudioSample = (Buttons_GetStatus() & BUTTONS_BUTTON1) ? CurrentWaveValue : 0;
 235                 #else
 236                         /* Audio sample is ADC value scaled to fit the entire range */
 237                         AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
 238
 239                         #if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
 240                         /* Microphone is biased to half rail voltage, subtract the bias from the sample value */
 241                         AudioSample -= (SAMPLE_MAX_RANGE / 2);
 242                         #endif
 243                 #endif
 244
 245                 /* Write the sample to the buffer */
 246                 Endpoint_Write_16_LE(AudioSample);
 247
 248                 /* Check to see if the bank is now full */
 249                 if (!(Endpoint_IsReadWriteAllowed()))
 250                 {
 251                         /* Send the full packet to the host */
 252                         Endpoint_ClearIN();
 253                 }
 254         }
 255
 256         Endpoint_SelectEndpoint(PrevEndpoint);
 257 }
 258