audio_class.c

最新版IAR FOR ARM（EWARM）5.11中的代码例子

/*************************************************************************
 * Function Name: AudioOutHadler
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio In EP handler
 *
 *************************************************************************/
void * AudioOutHadler (void *Arg)
{
Int32U PacketLength;
Int32U Save = __get_interrupt_state();
  __disable_interrupt();
  MicEna = TRUE;
  // Set pointer to free buffer
  if(++MicCurrBuffer & 1)
  {
    PacketLength = (Int32U)pMicData - (Int32U)AudioMicData1;
    pMicData = AudioMicData2;
  }
  else
  {
    PacketLength = (Int32U)pMicData - (Int32U)AudioMicData2;
    pMicData = AudioMicData1;
  }

  __set_interrupt_state(Save);
  // Send microphone output buffer
  USB_EpWrite((USB_Endpoint_t)MicEp,
              (pInt8U)((MicCurrBuffer & 1)?AudioMicData1:AudioMicData2),
              &PacketLength);
  return(NULL);
}

/*************************************************************************
 * Function Name: Tim2Handler
 * Parameters: none
 *
 * Return: none
 *
 * Description: Timer 2 interrupt handler
 *		
 *************************************************************************/
__ramfunc __arm
void Tim2Handler (void)
{
union _Val MicTemp;
Int32U  IntrState;

  IntrState =__get_CPSR();
  __set_CPSR(IntrState | 0x80);
  IntrState &= 0x80;

  if (SempEna)
  {
    if(Delta > 1)
    {
      // Get next input sample
      Val.Data = AudioSpkData[SempCount++];
      Delta   -= 2;
      // Correct pointer to sample buffer
      if(SempCount >= sizeof(AudioSpkData)/sizeof(Int16U))
      {
        SempCount = 0;
      }
      if(!AudioFeat1Mute && AudioSpkVolMul)
      {
        // Apply volume
        Val.Data   *= AudioSpkVolMul;
        // Add offset
        Val.DataHi += 0x200;
        // Check for overflow and correct value
        if(Val.DataHi < 50)
        {
          Val.DataHi = 50;
        }
        else if(Val.DataHi > 975)
        {
          Val.DataHi = 975;
        }
      }
      else
      {
        // set middle of range
        Val.DataHi = 0x200;
      }
    }
    else
    {
      // Disable output stream after emptying the buffer
      SempEna = FALSE;
      SempPerCurrHold = SempPeriod;
    }
  }
  else
  {
    SempPerCurrHold = SempPeriod;
  }
  // Clear TIM3 flag OC2
  TIM3->SR &= ~TIM_FLAG_OC2;
  while(!(TIM3->SR & TIM_FLAG_OC2));
  TIM3->OC1R =  Val.DataHi;
  if(MicEna)
  {
    if(!AudioFeat2Mute && AudioMicVolMul)
    {
      // Get ADC sample and remove offset
      MicTemp.Data  = (ADC->DR7 & 0x3FF) - 0x200;
      // Start conversion
      ADC->CR |= 1;
      // Add volume
      MicTemp.Data *= AudioMicVolMul;
      // check for overflow and correct the result
      if(MicTemp.DataHi < -511)
      {
        MicTemp.Data = -511 * 65536;
      }
      else if(MicTemp.DataHi > 511)
      {
        MicTemp.Data = 511 * 65536;
      }
      // Scale to 16bit
      MicTemp.Data <<= 6;
    }
    else
    {
      // set middle of range
      MicTemp.DataHi = 0;
    }
    // write to output buffer
    *pMicData++ = MicTemp.DataHi;
  }
  TIM2->OC1R += SempPerCurrHold; // reload output compare
  TIM2->SR &= ~TIM_FLAG_OC1;     // clear interrupt flag
  IntrState = __get_CPSR() & ~0x80;
  __set_CPSR(IntrState);
}

/*************************************************************************
 * Function Name: AudioFeatureGetReg
 * Parameters:  Int32U CS, Int32U Id
 *
 * Return: Boolean
 *
 * Description:
 *
 *************************************************************************/
static Boolean AudioFeatureGetReg (Int32U CS, Int32U Id)
{
  switch (CS)
  {
  case REQUEST_GET_CUR:
    // Load current value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (AudioFeat1Vol>>8)& 0xFF;
      AudioBuf[0] =  AudioFeat1Vol    & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (AudioFeat2Vol>>8)& 0xFF;
      AudioBuf[0] =  AudioFeat2Vol    & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_MIN:
    // Load minimum value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1MinVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1MinVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2MinVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2MinVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_MAX:
    // Load maximum value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1MaxVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1MaxVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2MaxVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2MaxVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  case REQUEST_GET_RES:
    // Load resolution value of Volume in the transmit buffer
    if (Id == FeatUnit1Id)
    {
      AudioBuf[1] = (Feat1ResVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat1ResVol      & 0xFF;
    }
    else if (Id == FeatUnit2Id)
    {
      AudioBuf[1] = (Feat2ResVol>>8)  & 0xFF;
      AudioBuf[0] =  Feat2ResVol      & 0xFF;
    }
    else
    {
      return(FALSE);
    }
    break;
  default:
    return(FALSE);
  }
  return(TRUE);
}

/*************************************************************************
 * Function Name: UsbClassAudioRequest
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio Requests
 *
 *************************************************************************/
void * UsbClassAudioRequest (void * pArg)
{
UsbEpCtrl_t * pAdioReqCtrl = (UsbEpCtrl_t *) pArg;
UsbSetupPacket_t * pAudioReqPacket = (UsbSetupPacket_t *)pAdioReqCtrl->pData;
  // Validate Request
  switch (pAudioReqPacket->mRequestType.Recipient)
  {
  case UsbRecipientInterface:
    // Feature Unit requests only Imlement for interface 0
    if ((pAudioReqPacket->wIndex.Word == (FeatUnit1Id << 8)) ||
        (pAudioReqPacket->wIndex.Word == (FeatUnit2Id << 8)))
    {
      // Request type
      switch (pAudioReqPacket->wValue.Hi)
      {
      case FU_MUTE_CONTROL:
        if ((pAudioReqPacket->bRequest == REQUEST_SET_CUR) &&
            (pAudioReqPacket->wLength.Word == 1))
        {
          // Set mute flag
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioCS       = pAudioReqPacket->wValue.Hi;
          AudioCN       = pAudioReqPacket->wValue.Lo;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter= 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbPass);
        }
        else if ((pAudioReqPacket->bRequest == REQUEST_GET_CUR) &&
                 (pAudioReqPacket->wLength.Word == 1))
        {
          // Read mute flag
          if(pAudioReqPacket->wIndex.Hi == FeatUnit1Id)
          {
            AudioBuf[0]  = AudioFeat1Mute;
          }
          else
          {
            AudioBuf[0]  = AudioFeat2Mute;
          }
          pAdioReqCtrl->Counter= 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void*)UsbPass);
        }
        break;
      case FU_VOLUME_CONTROL:
        if(pAudioReqPacket->bRequest & 0x80)
        {
          // Read different volume values
          if((pAudioReqPacket->wLength.Word == 2) &&
              AudioFeatureGetReg(pAudioReqPacket->bRequest,pAudioReqPacket->wIndex.Hi))
          {
            pAdioReqCtrl->Counter = 2;
            pAdioReqCtrl->pData = AudioBuf;
            return((void*)UsbPass);
          }
        }
        else if((pAudioReqPacket->bRequest == REQUEST_SET_CUR) &&
                (pAudioReqPacket->wLength.Word  == 2))
        {
          // Set volume value
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioCS       = pAudioReqPacket->wValue.Hi;
          AudioCN       = pAudioReqPacket->wValue.Lo;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter = 2;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbPass);
        }
        break;
      }
    }
    // Selector Unit requests only Imlement for interface 0
    else if (pAudioReqPacket->wIndex.Word == (SelUnit1ID << 8))
    {
      if(pAudioReqPacket->wValue.Word == 0)
      {
        // Read different selector unit values
        if(pAudioReqPacket->bRequest & 0x80)
        {
          if(pAudioReqPacket->wLength.Word == 1)
          {
            AudioBuf[0] = 1;
            pAdioReqCtrl->Counter = 1;
            pAdioReqCtrl->pData = AudioBuf;
            return((void*)UsbPass);
          }
        }
        else
        {
          // Set channel
          AudioRequest  = pAudioReqPacket->bRequest;
          AudioId       = pAudioReqPacket->wIndex.Hi;
          AudioDataSize = pAudioReqPacket->wLength.Word;
          pAdioReqCtrl->Counter = 1;
          pAdioReqCtrl->pData = AudioBuf;
          return((void *)UsbPass);
        }
      }
    }
    return((void *)UsbFault);
  case UsbRecipientEndpoint:
    return((void *)UsbFault);
  }
  return((void *)UsbFault);
}

/*************************************************************************
 * Function Name: UsbClassAudioData
 * Parameters:  void * pArg
 *
 * Return: void *
 *
 * Description: USB Class Audio Data receive
 *
 *************************************************************************/
void * UsbClassAudioData (void * pArg)
{
  if((AudioId == FeatUnit1Id) ||
     (AudioId == FeatUnit2Id))
  {
    switch (AudioCS)
    {
    case FU_MUTE_CONTROL:
      // Set mute flag
      if (AudioId == FeatUnit1Id)
      {
        AudioFeat1Mute = AudioBuf[0];
      }
      else if (AudioId == FeatUnit2Id)
      {
        AudioFeat2Mute = AudioBuf[0];
      }
      else
      {
        return((void*)UsbFault);
      }
      break;
    case FU_VOLUME_CONTROL:
      // Set volume value
      if (AudioId == FeatUnit1Id)
      {
        AudioFeat1Vol = AudioBuf[0] + ((Int16U)AudioBuf[1]<<8);
        if((Int16U)AudioFeat1Vol == MinVol)
        {
          AudioSpkVolMul = 0;
        }
        else
        {
          if (AudioFeat1Vol < (Int16S)Feat1MinVol)
          {
            AudioFeat1Vol = Feat1MinVol;
          }
          else if(AudioFeat1Vol > (Int16S)Feat1MaxVol)
          {
            AudioFeat1Vol = Feat1MaxVol;
          }
          // -48dB - +6dB multiply
          AudioSpkVolMul = (VolumeMul[((AudioFeat1Vol>>8)+0x30) & 0x3F]) >> 6;
        }
      }
      else if (AudioId == FeatUnit2Id)
      {
        AudioFeat2Vol = AudioBuf[0] + ((Int16U)AudioBuf[1]<<8);
        if((Int16U)AudioFeat2Vol == MinVol)
        {
          AudioMicVolMul = 0;
        }
        else
        {
          if (AudioFeat2Vol < (Int16S)Feat2MinVol)
          {
            AudioFeat2Vol = Feat2MinVol;
          }
          else if(AudioFeat2Vol > (Int16S)Feat2MaxVol)
          {
            AudioFeat2Vol = Feat2MaxVol;
          }
          // -48dB - +6dB multiply
          AudioMicVolMul = VolumeMul[((AudioFeat2Vol>>8)+0x30) & 0x3F];
        }
      }
      else
      {
        return((void*)UsbFault);
      }
      break;
    default:
      return((void*)UsbFault);
    }
  }
  else if (AudioId == SelUnit1ID)
  {
    // empty
  }
  else
  {
    return((void*)UsbFault);
  }
  return((void*)UsbPass);
}