tmk_core/protocol/lufa/LUFA-git/Demos/Device/ClassDriver/AudioInput/AudioInput.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2014.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2014  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 AudioInput demo. This file contains the main tasks of
  34  *  the demo and is responsible for the initial application hardware configuration.
  35  */
  36
  37 #include "AudioInput.h"
  38
  39 /** LUFA Audio Class driver interface configuration and state information. This structure is
  40  *  passed to all Audio Class driver functions, so that multiple instances of the same class
  41  *  within a device can be differentiated from one another.
  42  */
  43 USB_ClassInfo_Audio_Device_t Microphone_Audio_Interface =
  44         {
  45                 .Config =
  46                         {
  47                                 .ControlInterfaceNumber   = INTERFACE_ID_AudioControl,
  48                                 .StreamingInterfaceNumber = INTERFACE_ID_AudioStream,
  49                                 .DataINEndpoint           =
  50                                         {
  51                                                 .Address          = AUDIO_STREAM_EPADDR,
  52                                                 .Size             = AUDIO_STREAM_EPSIZE,
  53                                                 .Banks            = 2,
  54                                         },
  55                         },
  56         };
  57
  58 /** Current audio sampling frequency of the streaming audio endpoint. */
  59 static uint32_t CurrentAudioSampleFrequency = 48000;
  60
  61
  62 /** Main program entry point. This routine contains the overall program flow, including initial
  63  *  setup of all components and the main program loop.
  64  */
  65 int main(void)
  66 {
  67         SetupHardware();
  68
  69         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
  70         GlobalInterruptEnable();
  71
  72         for (;;)
  73         {
  74                 Audio_Device_USBTask(&Microphone_Audio_Interface);
  75                 USB_USBTask();
  76         }
  77 }
  78
  79 /** Configures the board hardware and chip peripherals for the demo's functionality. */
  80 void SetupHardware(void)
  81 {
  82 #if (ARCH == ARCH_AVR8)
  83         /* Disable watchdog if enabled by bootloader/fuses */
  84         MCUSR &= ~(1 << WDRF);
  85         wdt_disable();
  86
  87         /* Disable clock division */
  88         clock_prescale_set(clock_div_1);
  89 #endif
  90
  91         /* Hardware Initialization */
  92         LEDs_Init();
  93         Buttons_Init();
  94         ADC_Init(ADC_FREE_RUNNING | ADC_PRESCALE_32);
  95         ADC_SetupChannel(MIC_IN_ADC_CHANNEL);
  96         USB_Init();
  97
  98         /* Start the ADC conversion in free running mode */
  99         ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ADC_GET_CHANNEL_MASK(MIC_IN_ADC_CHANNEL));
 100 }
 101
 102 /** ISR to handle the reloading of the data endpoint with the next sample. */
 103 ISR(TIMER0_COMPA_vect, ISR_BLOCK)
 104 {
 105         uint8_t PrevEndpoint = Endpoint_GetCurrentEndpoint();
 106
 107         /* Check that the USB bus is ready for the next sample to write */
 108         if (Audio_Device_IsReadyForNextSample(&Microphone_Audio_Interface))
 109         {
 110                 int16_t AudioSample;
 111
 112                 #if defined(USE_TEST_TONE)
 113                         static uint8_t SquareWaveSampleCount;
 114                         static int16_t CurrentWaveValue;
 115
 116                         /* In test tone mode, generate a square wave at 1/256 of the sample rate */
 117                         if (SquareWaveSampleCount++ == 0xFF)
 118                           CurrentWaveValue ^= 0x8000;
 119
 120                         /* Only generate audio if the board button is being pressed */
 121                         AudioSample = (Buttons_GetStatus() & BUTTONS_BUTTON1) ? CurrentWaveValue : 0;
 122                 #else
 123                         /* Audio sample is ADC value scaled to fit the entire range */
 124                         AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
 125
 126                         #if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
 127                         /* Microphone is biased to half rail voltage, subtract the bias from the sample value */
 128                         AudioSample -= (SAMPLE_MAX_RANGE / 2);
 129                         #endif
 130                 #endif
 131
 132                 Audio_Device_WriteSample16(&Microphone_Audio_Interface, AudioSample);
 133         }
 134
 135         Endpoint_SelectEndpoint(PrevEndpoint);
 136 }
 137
 138 /** Event handler for the library USB Connection event. */
 139 void EVENT_USB_Device_Connect(void)
 140 {
 141         LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
 142
 143         /* Sample reload timer initialization */
 144         TIMSK0  = (1 << OCIE0A);
 145         OCR0A   = ((F_CPU / 8 / CurrentAudioSampleFrequency) - 1);
 146         TCCR0A  = (1 << WGM01);  // CTC mode
 147         TCCR0B  = (1 << CS01);   // Fcpu/8 speed
 148 }
 149
 150 /** Event handler for the library USB Disconnection event. */
 151 void EVENT_USB_Device_Disconnect(void)
 152 {
 153         /* Stop the sample reload timer */
 154         TCCR0B = 0;
 155
 156         LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
 157 }
 158
 159 /** Event handler for the library USB Configuration Changed event. */
 160 void EVENT_USB_Device_ConfigurationChanged(void)
 161 {
 162         bool ConfigSuccess = true;
 163
 164         ConfigSuccess &= Audio_Device_ConfigureEndpoints(&Microphone_Audio_Interface);
 165
 166         LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
 167 }
 168
 169 /** Event handler for the library USB Control Request reception event. */
 170 void EVENT_USB_Device_ControlRequest(void)
 171 {
 172         Audio_Device_ProcessControlRequest(&Microphone_Audio_Interface);
 173 }
 174
 175 /** Audio class driver callback for the setting and retrieval of streaming endpoint properties. This callback must be implemented
 176  *  in the user application to handle property manipulations on streaming audio endpoints.
 177  *
 178  *  When the DataLength parameter is NULL, this callback should only indicate whether the specified operation is valid for
 179  *  the given endpoint index, and should return as fast as possible. When non-NULL, this value may be altered for GET operations
 180  *  to indicate the size of the retrieved data.
 181  *
 182  *  \note The length of the retrieved data stored into the Data buffer on GET operations should not exceed the initial value
 183  *        of the \c DataLength parameter.
 184  *
 185  *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.
 186  *  \param[in]     EndpointProperty    Property of the endpoint to get or set, a value from Audio_ClassRequests_t.
 187  *  \param[in]     EndpointAddress     Address of the streaming endpoint whose property is being referenced.
 188  *  \param[in]     EndpointControl     Parameter of the endpoint to get or set, a value from Audio_EndpointControls_t.
 189  *  \param[in,out] DataLength          For SET operations, the length of the parameter data to set. For GET operations, the maximum
 190  *                                     length of the retrieved data. When NULL, the function should return whether the given property
 191  *                                     and parameter is valid for the requested endpoint without reading or modifying the Data buffer.
 192  *  \param[in,out] Data                Pointer to a location where the parameter data is stored for SET operations, or where
 193  *                                     the retrieved data is to be stored for GET operations.
 194  *
 195  *  \return Boolean \c true if the property get/set was successful, \c false otherwise
 196  */
 197 bool CALLBACK_Audio_Device_GetSetEndpointProperty(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo,
 198                                                   const uint8_t EndpointProperty,
 199                                                   const uint8_t EndpointAddress,
 200                                                   const uint8_t EndpointControl,
 201                                                   uint16_t* const DataLength,
 202                                                   uint8_t* Data)
 203 {
 204         /* Check the requested endpoint to see if a supported endpoint is being manipulated */
 205         if (EndpointAddress == Microphone_Audio_Interface.Config.DataINEndpoint.Address)
 206         {
 207                 /* Check the requested control to see if a supported control is being manipulated */
 208                 if (EndpointControl == AUDIO_EPCONTROL_SamplingFreq)
 209                 {
 210                         switch (EndpointProperty)
 211                         {
 212                                 case AUDIO_REQ_SetCurrent:
 213                                         /* Check if we are just testing for a valid property, or actually adjusting it */
 214                                         if (DataLength != NULL)
 215                                         {
 216                                                 /* Set the new sampling frequency to the value given by the host */
 217                                                 CurrentAudioSampleFrequency = (((uint32_t)Data[2] << 16) | ((uint32_t)Data[1] << 8) | (uint32_t)Data[0]);
 218
 219                                                 /* Adjust sample reload timer to the new frequency */
 220                                                 OCR0A = ((F_CPU / 8 / CurrentAudioSampleFrequency) - 1);
 221                                         }
 222
 223                                         return true;
 224                                 case AUDIO_REQ_GetCurrent:
 225                                         /* Check if we are just testing for a valid property, or actually reading it */
 226                                         if (DataLength != NULL)
 227                                         {
 228                                                 *DataLength = 3;
 229
 230                                                 Data[2] = (CurrentAudioSampleFrequency >> 16);
 231                                                 Data[1] = (CurrentAudioSampleFrequency >> 8);
 232                                                 Data[0] = (CurrentAudioSampleFrequency &  0xFF);
 233                                         }
 234
 235                                         return true;
 236                         }
 237                 }
 238         }
 239
 240         return false;
 241 }
 242
 243 /** Audio class driver callback for the setting and retrieval of streaming interface properties. This callback must be implemented
 244  *  in the user application to handle property manipulations on streaming audio interfaces.
 245  *
 246  *  When the DataLength parameter is NULL, this callback should only indicate whether the specified operation is valid for
 247  *  the given entity and should return as fast as possible. When non-NULL, this value may be altered for GET operations
 248  *  to indicate the size of the retrieved data.
 249  *
 250  *  \note The length of the retrieved data stored into the Data buffer on GET operations should not exceed the initial value
 251  *        of the \c DataLength parameter.
 252  *
 253  *  \param[in,out] AudioInterfaceInfo  Pointer to a structure containing an Audio Class configuration and state.
 254  *  \param[in]     Property            Property of the interface to get or set, a value from Audio_ClassRequests_t.
 255  *  \param[in]     EntityAddress       Address of the audio entity whose property is being referenced.
 256  *  \param[in]     Parameter           Parameter of the entity to get or set, specific to each type of entity (see USB Audio specification).
 257  *  \param[in,out] DataLength          For SET operations, the length of the parameter data to set. For GET operations, the maximum
 258  *                                     length of the retrieved data. When NULL, the function should return whether the given property
 259  *                                     and parameter is valid for the requested endpoint without reading or modifying the Data buffer.
 260  *  \param[in,out] Data                Pointer to a location where the parameter data is stored for SET operations, or where
 261  *                                     the retrieved data is to be stored for GET operations.
 262  *
 263  *  \return Boolean \c true if the property GET/SET was successful, \c false otherwise
 264  */
 265 bool CALLBACK_Audio_Device_GetSetInterfaceProperty(USB_ClassInfo_Audio_Device_t* const AudioInterfaceInfo,
 266                                                    const uint8_t Property,
 267                                                    const uint8_t EntityAddress,
 268                                                    const uint16_t Parameter,
 269                                                    uint16_t* const DataLength,
 270                                                    uint8_t* Data)
 271 {
 272         /* No audio interface entities in the device descriptor, thus no properties to get or set. */
 273         return false;
 274 }