Demos/Device/LowLevel/AudioInput/AudioInput.c

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