圏9研究所 工作室

圏9研究所の開発情報資料など

STM32F411 BlackPill USB Speaker ISO（５） コード1/2

BlackPill STM32

１．コード
１）main
（１）<main.h>

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "usbd_sp.h”
（２）<main.c>
/* USER CODE BEGIN WHILE */
  usbd_sp_iso();

  while (1)
  {
２）USBD AUDIO
（１）<usbd_conf.c>
USBD_StatusTypeDef USBD_LL_Init(USBD_HandleTypeDef *pdev)
{
················
hpcd_USB_OTG_FS.Init.Sof_enable = ENABLE;
（２）<usbd_audio.h>
#define USB_AUDIO_CONFIG_DESC_SIZ             (0x6DU+0x09U)
················
#define AUDIO_OUT_PACKET                      (uint16_t)(((USBD_AUDIO_FREQ * 2U * 2U) / 1000U) + 4U)
（３）<usbd_audio.c>
#define AUDIO_PACKET_SZE(frq) \
	(uint8_t)(((frq * 2U * 2U) / 1000U + 4U) & 0xFFU), (uint8_t)((((frq * 2U * 2U) / 1000U) >> 8) & 0xFFU)

················
// Endpoint 1 - Standard Descriptor - See UAC Spec 1.0 p.61 4.6.1.1 Standard AS Isochronous Audio Data Endpoint Descriptor
  // Isochronous Async endpoint for audio packets
  AUDIO_STANDARD_ENDPOINT_DESC_SIZE,         /* bLength */
  USB_DESC_TYPE_ENDPOINT,                    /* bDescriptorType */
  AUDIO_OUT_EP,                              /* bEndpointAddress 1 out endpoint*/
  USBD_EP_TYPE_ISOC_ASYNC,                   /* bmAttributes */
  AUDIO_PACKET_SZE(USBD_AUDIO_FREQ), 		/* wMaxPacketSize in Bytes (Freq(Samples)*2(Stereo)*2(HalfWord)) */
  AUDIO_FS_BINTERVAL,                                      /* bInterval */
  0x00,                                      /* bRefresh */
  AUDIO_IN_EP,                               /* bSynchAddress */
  // 09 byte

················
// Endpoint 2 - Standard Descriptor - See UAC Spec 1.0 p.63 4.6.2.1 Standard AS Isochronous Synch Endpoint Descriptor
  // 3byte 10.14 sampling frequency feedback to host
  AUDIO_STANDARD_ENDPOINT_DESC_SIZE, /* bLength */
  USB_DESC_TYPE_ENDPOINT,            /* bDescriptorType */
  AUDIO_IN_EP,                       /* bEndpointAddress */
  0x11,                              /* bmAttributes */
  0x03, 0x00,                        /* wMaxPacketSize in Bytes */
  0x01,                              /* bInterval 1ms */
  SOF_RATE,                          /* bRefresh 4ms = 2^2 */
  0x00,                              /* bSynchAddress */
  // 09 byte

ISO_ControlTypeDef iso_cont = {.fs = AUDIO_ISO_FS_INIT, .tx_flag = 1U};

extern DMA_HandleTypeDef hdma_tim2_ch1;
USBD_AUDIO_Init()
static uint8_t USBD_AUDIO_Init(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
{
················
	/* Open EP IN */
	USBD_LL_OpenEP(pdev, AUDIO_IN_EP, USBD_EP_TYPE_ISOC, AUDIO_IN_PACKET);
	pdev->ep_in[AUDIO_IN_EP & 0xFU].is_used = 1U;

	/* Flush feedback endpoint */
	USBD_LL_FlushEP(pdev, AUDIO_IN_EP);

···············
	//Set tx_flag 1 to block feedback transmission in SOF handler since device is not ready.
	iso_cont.tx_flag = 1U;
USBD_AUDIO_DeInit()
uint8_t USBD_AUDIO_DeInit(USBD_HandleTypeDef *pdev, uint8_t cfgidx)
{
················
	iso_cont.tx_flag = 0U;	 // Clear feedback transmission flag
USBD_AUDIO_DataIn()
static uint8_t USBD_AUDIO_DataIn(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
	/* epnum is the lowest 4 bits of bEndpointAddress. See UAC 1.0 spec, p.61 */
	if (epnum == (AUDIO_IN_EP & 0xf))	{
		 iso_cont.tx_flag = 0U;
	}
  /* Only OUT data are processed */
	return (uint8_t)USBD_OK;
}
USBD_AUDIO_SOF()
static uint8_t USBD_AUDIO_SOF(USBD_HandleTypeDef *pdev)
{
		typedef union {
			uint32_t	rate;
			uint8_t	fbbuf[4];
		} R2FBB;
		R2FBB	fb_data;

	/* Transmit feedback only when the last one is transmitted */
	if (iso_cont.tx_flag == 0U)
	{
	/* Get FNSOF. Use volatile for fnsof_new since its address is mapped to a hardware register. */
		USB_OTG_GlobalTypeDef *USBx = USB_OTG_FS;
		uint32_t USBx_BASE = (uint32_t)USBx;
		uint32_t volatile fnsof_new = (USBx_DEVICE->DSTS & USB_OTG_DSTS_FNSOF) >> 8;

		if ((iso_cont.fnsof & 0x1) == (fnsof_new & 0x1))
		{
			fb_data.rate=(((iso_cont.fs / 1000) << 14) | ((iso_cont.fs % 1000) << 4));
			USBD_LL_Transmit(pdev, AUDIO_IN_EP, (uint8_t *)fb_data.fbbuf, 3U);
			/* Block transmission until it's finished. */
			 iso_cont.tx_flag = 1U;
		}
	}
	return (uint8_t)USBD_OK;
}
USBD_AUDIO_IsoINIncomplete()
static uint8_t USBD_AUDIO_IsoINIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
	USB_OTG_GlobalTypeDef* USBx = USB_OTG_FS;
	uint32_t USBx_BASE = (uint32_t)USBx;
	iso_cont.fnsof = (USBx_DEVICE->DSTS & USB_OTG_DSTS_FNSOF) >> 8;

	if (iso_cont.tx_flag == 1U) {
		 iso_cont.tx_flag = 0U;
		USBD_LL_FlushEP(pdev, AUDIO_IN_EP);
	}

	return (uint8_t)USBD_OK;
}
USBD_AUDIO_IsoOutIncomplete()
static uint8_t USBD_AUDIO_IsoOutIncomplete(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
	// Fix suggested by Andrew to restart audio (fix Windows problem ?)
		USBD_AUDIO_HandleTypeDef *haudio;
		haudio = (USBD_AUDIO_HandleTypeDef*)pdev->pClassData;

		USBD_LL_FlushEP(pdev, AUDIO_OUT_EP);

		/* Prepare Out endpoint to receive next audio packet */
		(void)USBD_LL_PrepareReceive(pdev, AUDIO_OUT_EP, &haudio->buffer[haudio->wr_ptr], AUDIO_OUT_PACKET);

		return (uint8_t)USBD_OK;
}
USBD_AUDIO_DataOut()
static uint8_t USBD_AUDIO_DataOut(USBD_HandleTypeDef *pdev, uint8_t epnum)
{
················
	if (epnum == AUDIOOutEpAdd)
	{
		if(haudio->rd_enable == RD_IDLE)	{
			// Restart USBD Outdata
			iso_cont.ofs_packet = 0;
			iso_cont.usbintn = 0;
			haudio->offset = AUDIO_OFFSET_UNKNOWN;
			haudio->rd_enable = RD_START;
			haudio->rd_ptr = 0U;
			haudio->wr_ptr = 0U;
			iso_cont.tx_flag = 0;
			usbd_audio_wrinq(WR_PTR_1st);
		}
		/* Get received data packet length */
		PacketSize = (uint16_t)USBD_LL_GetRxDataSize(pdev, epnum);

		/* Packet received Callback */
		((USBD_AUDIO_ItfTypeDef *)pdev->pUserData[pdev->classId])->PeriodicTC(&haudio->buffer[haudio->wr_ptr],
																																					PacketSize, AUDIO_OUT_TC);

/* Increment the Buffer pointer or roll it back when all buffers are full */
		haudio->wr_ptr += PacketSize;

		iso_cont.ofs_packet += PacketSize;
		if(iso_cont.ofs_packet >= DAC_BUF_SIZE4)	{
			iso_cont.ofs_packet = iso_cont.ofs_packet - DAC_BUF_SIZE4;
			//HAL_GPIO_TogglePin(LED_GPIO_Port, LED_Pin);
		}
		iso_cont.usbintn ++;

		if((iso_cont.usbintn % 4) == 0)	{
			uint16_t ofs_dac = DAC_BUF_SIZE - (uint16_t)(__HAL_DMA_GET_COUNTER(&hdma_tim2_ch1) % DAC_BUF_SIZE);
			int32_t ofs_diff = (int32_t)iso_cont.ofs_packet - (int32_t)ofs_dac * 4;
			if (ofs_diff < (-DAC_BUF_SIZE4/2)) ofs_diff = ofs_diff + DAC_BUF_SIZE4;
			else if(ofs_diff > (DAC_BUF_SIZE4/2))	 ofs_diff = ofs_diff - DAC_BUF_SIZE4;
			iso_cont.fs = AUDIO_ISO_FS_INIT - (int32_t)(ofs_diff * AUDIO_ISO_FS_INIT) / DAC_BUF_SIZE4;
			if(iso_cont.fs > (AUDIO_ISO_FS_INIT+AUDIO_ISO_FS_DMAX))	 iso_cont.fs = AUDIO_ISO_FS_INIT+AUDIO_ISO_FS_DMAX;
			if(iso_cont.fs < (AUDIO_ISO_FS_INIT-AUDIO_ISO_FS_DMAX))	 iso_cont.fs = AUDIO_ISO_FS_INIT-AUDIO_ISO_FS_DMAX;
			//fs=48013;		// 1998:48111 1999:48060 2000:48013 2001:47987 2002:47936
		}
		if(iso_cont.usbintn >= AUDIO_OUT_PACKET_NUM)	{
			 iso_cont.usbintn = 0;
			/* All buffers are full: roll back */
			if(haudio->rd_enable == RD_START)	haudio->rd_enable = RD_PLAY;
			if(haudio->rd_enable == RD_PLAY)
			{
				haudio->rd_ptr = haudio->wr_ptr;
				haudio->offset = AUDIO_OFFSET_FULL;
			}
			haudio->wr_ptr = 0;
		}
		/* Prepare Out endpoint to receive next audio packet */
		(void)USBD_LL_PrepareReceive(pdev, AUDIOOutEpAdd,
					&haudio->buffer[haudio->wr_ptr],
					AUDIO_OUT_PACKET);
		return (uint8_t)USBD_OK;
続く