STM32F103 WAV录音SD存储 WAV语音软解播放

最新推荐文章于 2026-08-15 15:01:02 发布
原创 最新推荐文章于 2026-08-15 15:01:02 发布 · 2k 阅读 · 25 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
STM32

当前文章被收录于：

STM32
1 篇文章 1 人学习
订阅专栏 查看详情
本文详细介绍了使用STM32F103微控制器通过FATFS文件系统实现WAV录音并存储到SD卡，以及如何播放SD卡上的WAV文件。主要涉及了SPI接口与SD卡的交互，包括初始化、读写操作，以及文件系统的设置。同时，还展示了ADC录音和TIM播放的基本流程。

STM32F103 WAV录音SD存储 WAV语音软解播放

整体思路

  1. 使用FATFS文件系统存储读取SD卡文件；
  2. 使用TIM 播放 WAV文件；
  3. 使用ADC+DMA 录音并保存文件；

FATFS文件系统设置

CUBE MAX设置

SD读写代码

#include "SDdriver.h"
#include "stdio.h"
uint8_t DFF=0xFF;
//uint8_t test;
uint8_t SD_TYPE=0x00;

uint8_t writesd,readsd;

uint8_t res=0;
UINT Bw;	

uint16_t TotalSpace;

MSD_CARDINFO SD0_CardInfo;

uint32_t mic_addr_start = 0x00000001;

//////////////////////////////////////////////////////////////
//片选
//////////////////////////////////////////////////////////////
void SD_CS(uint8_t p){
	if(p==0){	
		HAL_GPIO_WritePin(SD_CS_GPIO_Port,SD_CS_Pin,GPIO_PIN_SET);
		}else{
		HAL_GPIO_WritePin(SD_CS_GPIO_Port,SD_CS_Pin,GPIO_PIN_RESET);
		}
}
///////////////////////////////////////////////////////////////
//发送命令，发完释放
//////////////////////////////////////////////////////////////
int SD_sendcmd(uint8_t cmd,uint32_t arg,uint8_t crc){
	uint8_t r1;
  uint8_t retry;

  SD_CS(0);
	HAL_Delay(20);
  SD_CS(1);
	do{
		retry=spi_readwrite(DFF);
	}while(retry!=0xFF);

  spi_readwrite(cmd | 0x40);
  spi_readwrite(arg >> 24);
  spi_readwrite(arg >> 16);
  spi_readwrite(arg >> 8);
  spi_readwrite(arg);
  spi_readwrite(crc);
  if(cmd==CMD12)spi_readwrite(DFF);
  do
	{
		r1=spi_readwrite(0xFF);
	}while(r1&0X80);
	
	return r1;
}


/////////////////////////////////////////////////////////////
//SD卡初始化
////////////////////////////////////////////////////////////
uint8_t SD_init(void)
{
	uint8_t r1;	
	uint8_t buff[6] = {0};
	uint16_t retry; 
	uint8_t i;
	
//	MX_SPI3_Init();
	SPI_setspeed(SPI_BAUDRATEPRESCALER_256);
	SD_CS(0);
	for(retry=0;retry<10;retry++){
			spi_readwrite(DFF);
	}
	
	//SD卡进入IDLE状态
	do{
		r1 = SD_sendcmd(CMD0 ,0, 0x95);	
	}while(r1!=0x01);
	
	//查看SD卡的类型
	SD_TYPE=0;
	r1 = SD_sendcmd(CMD8, 0x1AA, 0x87);
	if(r1==0x01){
		for(i=0;i<4;i++)buff[i]=spi_readwrite(DFF);	//Get trailing return value of R7 resp
		if(buff[2]==0X01&&buff[3]==0XAA)//卡是否支持2.7~3.6V
		{
			retry=0XFFFE;
			do
			{
				SD_sendcmd(CMD55,0,0X01);	//发送CMD55
				r1=SD_sendcmd(CMD41,0x40000000,0X01);//发送CMD41
			}while(r1&&retry--);
			if(retry&&SD_sendcmd(CMD58,0,0X01)==0)//鉴别SD2.0卡版本开始
			{
				for(i=0;i<4;i++)buff[i]=spi_readwrite(0XFF);//得到OCR值
				if(buff[0]&0x40){
					SD_TYPE=V2HC;
				}else {
					SD_TYPE=V2;
				}						
			}
		}else{
			SD_sendcmd(CMD55,0,0X01);			//发送CMD55
			r1=SD_sendcmd(CMD41,0,0X01);	//发送CMD41
			if(r1<=1)
			{		
				SD_TYPE=V1;
				retry=0XFFFE;
				do //等待退出IDLE模式
				{
					SD_sendcmd(CMD55,0,0X01);	//发送CMD55
					r1=SD_sendcmd(CMD41,0,0X01);//发送CMD41
				}while(r1&&retry--);
			}else//MMC卡不支持CMD55+CMD41识别
			{
				SD_TYPE=MMC;//MMC V3
				retry=0XFFFE;
				do //等待退出IDLE模式
				{											    
					r1=SD_sendcmd(CMD1,0,0X01);//发送CMD1
				}while(r1&&retry--);  
			}
			if(retry==0||SD_sendcmd(CMD16,512,0X01)!=0)SD_TYPE=ERR;//错误的卡
		}
	}
	SD_CS(0);
	SPI_setspeed(SPI_BAUDRATEPRESCALER_4);
	if(SD_TYPE)return 0;
	else return 1;
}


//读取指定长度数据
uint8_t SD_ReceiveData(uint8_t *data, uint16_t len)
{

  uint8_t r1;
   SD_CS(1);
   do
   { 
      r1 = spi_readwrite(0xFF);	
//      HAL_Delay(100);
		}while(r1 != 0xFE);	
	 
  while(len--)
  {
   *data = spi_readwrite(0xFF);
   data++;
  }
//	spi_readwrite_DMA(data,len);//DMA读取
//	HAL_SPI_TransmitReceive(&hspi1,data,data,len,1000);	
  spi_readwrite(0xFF);
  spi_readwrite(0xFF); 										  		
  return 0;
}
//向sd卡写入一个数据包的内容 512字节
uint8_t SD_SendBlock(uint8_t*buf,uint8_t cmd)
{	
	uint16_t t;	
uint8_t r1;	
	do{
		r1=spi_readwrite(0xFF);
	}while(r1!=0xFF);
	
	spi_readwrite(cmd);
	if(cmd!=0XFD)//不是结束指令
	{
		for(t=0;t<512;t++)spi_readwrite(buf[t]);//提高速度,减少函数传参时间
	    spi_readwrite(0xFF);//忽略crc
	    spi_readwrite(0xFF);
		t=spi_readwrite(0xFF);//接收响应
		if((t&0x1F)!=0x05)return 2;//响应错误									  					    
	}						 									  					    
    return 0;//写入成功
}

//获取CID信息
uint8_t SD_GETCID (uint8_t *cid_data)
{
		uint8_t r1;
	  r1=SD_sendcmd(CMD10,0,0x01); //读取CID寄存器
		if(r1==0x00){
			r1=SD_ReceiveData(cid_data,16);
		}
		SD_CS(0);
		if(r1)return 1;
		else return 0;
}
//获取CSD信息
uint8_t SD_GETCSD(uint8_t *csd_data){
		uint8_t r1;	 
    r1=SD_sendcmd(CMD9,0,0x01);//发CMD9命令，读CSD寄存器
    if(r1==0)
	{
    	r1=SD_ReceiveData(csd_data, 16);//接收16个字节的数据 
    }
	SD_CS(0);//取消片选
	if(r1)return 1;
	else return 0;
}
//获取SD卡的总扇区数
uint32_t SD_GetSectorCount(void)
{
    uint8_t csd[16];
    uint32_t Capacity;  
    uint8_t n;
		uint16_t csize;  					    
	//取CSD信息，如果期间出错，返回0
    if(SD_GETCSD(csd)!=0) return 0;	    
    //如果为SDHC卡，按照下面方式计算
    if((csd[0]&0xC0)==0x40)	 //V2.00的卡
    {	
		csize = csd[9] + ((uint16_t)csd[8] << 8) + 1;
		Capacity = (uint32_t)csize << 10;//得到扇区数	 		   
    }else//V1.XX的卡
    {	
		n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
		csize = (csd[8] >> 6) + ((uint16_t)csd[7] << 2) + ((uint16_t)(csd[6] & 3) << 10) + 1;
		Capacity= (uint32_t)csize << (n - 9);//得到扇区数   
    }
    return Capacity;
}
int MSD0_GetCardInfo(PMSD_CARDINFO SD0_CardInfo)
{
  uint8_t r1;
  uint8_t CSD_Tab[16];
  uint8_t CID_Tab[16];

  /* Send CMD9, Read CSD */
  r1 = SD_sendcmd(CMD9, 0, 0xFF);
  if(r1 != 0x00)
  {
    return r1;
  }

  if(SD_ReceiveData(CSD_Tab, 16))
  {
	return 1;
  }

  /* Send CMD10, Read CID */
  r1 = SD_sendcmd(CMD10, 0, 0xFF);
  if(r1 != 0x00)
  {
    return r1;
  }

  if(SD_ReceiveData(CID_Tab, 16))
  {
	return 2;
  }  

  /* Byte 0 */
  SD0_CardInfo->CSD.CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
  SD0_CardInfo->CSD.SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
  SD0_CardInfo->CSD.Reserved1 = CSD_Tab[0] & 0x03;
  /* Byte 1 */
  SD0_CardInfo->CSD.TAAC = CSD_Tab[1] ;
  /* Byte 2 */
  SD0_CardInfo->CSD.NSAC = CSD_Tab[2];
  /* Byte 3 */
  SD0_CardInfo->CSD.MaxBusClkFrec = CSD_Tab[3];
  /* Byte 4 */
  SD0_CardInfo->CSD.CardComdClasses = CSD_Tab[4] << 4;
  /* Byte 5 */
  SD0_CardInfo->CSD.CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
  SD0_CardInfo->CSD.RdBlockLen = CSD_Tab[5] & 0x0F;
  /* Byte 6 */
  SD0_CardInfo->CSD.PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
  SD0_CardInfo->CSD.WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
  SD0_CardInfo->CSD.RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
  SD0_CardInfo->CSD.DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
  SD0_CardInfo->CSD.Reserved2 = 0; /* Reserved */
  SD0_CardInfo->CSD.DeviceSize = (CSD_Tab[6] & 0x03) << 10;
  /* Byte 7 */
  SD0_CardInfo->CSD.DeviceSize |= (CSD_Tab[7]) << 2;
  /* Byte 8 */
  SD0_CardInfo->CSD.DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6;
  SD0_CardInfo->CSD.MaxRdCurrentVDDMin = (CSD_Tab[8] & 0x38) >> 3;
  SD0_CardInfo->CSD.MaxRdCurrentVDDMax = (CSD_Tab[8] & 0x07);
  /* Byte 9 */
  SD0_CardInfo->CSD.MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5;
  SD0_CardInfo->CSD.MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2;
  SD0_CardInfo->CSD.DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1;
  /* Byte 10 */
  SD0_CardInfo->CSD.DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7;
  SD0_CardInfo->CSD.EraseGrSize = (CSD_Tab[10] & 0x7C) >> 2;
  SD0_CardInfo->CSD.EraseGrMul = (CSD_Tab[10] & 0x03) << 3;
  /* Byte 11 */
  SD0_CardInfo->CSD.EraseGrMul |= (CSD_Tab[11] & 0xE0) >> 5;
  SD0_CardInfo->CSD.WrProtectGrSize = (CSD_Tab[11] & 0x1F);
  /* Byte 12 */
  SD0_CardInfo->CSD.WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7;
  SD0_CardInfo->CSD.ManDeflECC = (CSD_Tab[12] & 0x60) >> 5;
  SD0_CardInfo->CSD.WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2;
  SD0_CardInfo->CSD.MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2;
  /* Byte 13 */
  SD0_CardInfo->CSD.MaxWrBlockLen |= (CSD_Tab[13] & 0xc0) >> 6;
  SD0_CardInfo->CSD.WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5;
  SD0_CardInfo->CSD.Reserved3 = 0;
  SD0_CardInfo->CSD.ContentProtectAppli = (CSD_Tab[13] & 0x01);
  /* Byte 14 */
  SD0_CardInfo->CSD.FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7;
  SD0_CardInfo->CSD.CopyFlag = (CSD_Tab[14] & 0x40) >> 6;
  SD0_CardInfo->CSD.PermWrProtect = (CSD_Tab[14] & 0x20) >> 5;
  SD0_CardInfo->CSD.TempWrProtect = (CSD_Tab[14] & 0x10) >> 4;
  SD0_CardInfo->CSD.FileFormat = (CSD_Tab[14] & 0x0C) >> 2;
  SD0_CardInfo->CSD.ECC = (CSD_Tab[14] & 0x03);
  /* Byte 15 */
  SD0_CardInfo->CSD.CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1;
  SD0_CardInfo->CSD.Reserved4 = 1;

  if(SD0_CardInfo->CardType == V2HC)
  {
	 /* Byte 7 */
	 SD0_CardInfo->CSD.DeviceSize = (uint16_t)(CSD_Tab[8]) *256;
	 /* Byte 8 */
	 SD0_CardInfo->CSD.DeviceSize += CSD_Tab[9] ;
  }

  SD0_CardInfo->Capacity = SD0_CardInfo->CSD.DeviceSize * MSD_BLOCKSIZE * 1024;
  SD0_CardInfo->BlockSize = MSD_BLOCKSIZE;

  /* Byte 0 */
  SD0_CardInfo->CID.ManufacturerID = CID_Tab[0];
  /* Byte 1 */
  SD0_CardInfo->CID.OEM_AppliID = CID_Tab[1] << 8;
  /* Byte 2 */
  SD0_CardInfo->CID.OEM_AppliID |= CID_Tab[2];
  /* Byte 3 */
  SD0_CardInfo->CID.ProdName1 = CID_Tab[3] << 24;
  /* Byte 4 */
  SD0_CardInfo->CID.ProdName1 |= CID_Tab[4] << 16;
  /* Byte 5 */
  SD0_CardInfo->CID.ProdName1 |= CID_Tab[5] << 8;
  /* Byte 6 */
  SD0_CardInfo->CID.ProdName1 |= CID_Tab[6];
  /* Byte 7 */
  SD0_CardInfo->CID.ProdName2 = CID_Tab[7];
  /* Byte 8 */
  SD0_CardInfo->CID.ProdRev = CID_Tab[8];
  /* Byte 9 */
  SD0_CardInfo->CID.ProdSN = CID_Tab[9] << 24;
  /* Byte 10 */
  SD0_CardInfo->CID.ProdSN |= CID_Tab[10] << 16;
  /* Byte 11 */
  SD0_CardInfo->CID.ProdSN |= CID_Tab[11] << 8;
  /* Byte 12 */
  SD0_CardInfo->CID.ProdSN |= CID_Tab[12];
  /* Byte 13 */
  SD0_CardInfo->CID.Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
  /* Byte 14 */
  SD0_CardInfo->CID.ManufactDate = (CID_Tab[13] & 0x0F) << 8;
  /* Byte 15 */
  SD0_CardInfo->CID.ManufactDate |= CID_Tab[14];
  /* Byte 16 */
  SD0_CardInfo->CID.CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
  SD0_CardInfo->CID.Reserved2 = 1;

  return 0;  
}


//写SD卡
//buf:数据缓存区
//sector:起始扇区
//cnt:扇区数
//返回值:0,ok;其他,失败.
uint8_t SD_WriteDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
{
	uint8_t r1;
//	uint8_t Rxdata;	
	if(SD_TYPE!=V2HC)sector *= 512;//转换为字节地址
	if(cnt==1)
	{
		r1=SD_sendcmd(CMD24,sector,0X01);//读命令
		if(r1==0)//指令发送成功
		{
			r1=SD_SendBlock(buf,0xFE);//写512个字节	   
		}
	}else
	{
		if(SD_TYPE!=MMC)
		{
			SD_sendcmd(CMD55,0,0X01);	
			SD_sendcmd(CMD23,cnt,0X01);//发送指令	
		}
 		r1=SD_sendcmd(CMD25,sector,0X01);//连续读命令
		if(r1==0)
		{
			do
			{
				r1=SD_SendBlock(buf,0xFC);//接收512个字节	 
				buf+=512;  
			}while(--cnt && r1==0);
//			HAL_SPI_TransmitReceive_DMA(&hspi1,&Rxdata,buf,cnt*512);
			r1=SD_SendBlock(0,0xFD);//接收512个字节 
		}
	}   
	SD_CS(0);//取消片选
	return r1;//
}	
//读SD卡
//buf:数据缓存区
//sector:扇区
//cnt:扇区数
//返回值:0,ok;其他,失败.
uint8_t SD_ReadDisk(uint8_t*buf,uint32_t sector,uint8_t cnt)
{
	uint8_t r1;
//	uint8_t Txdata;	
	if(SD_TYPE!=V2HC)sector <<= 9;//转换为字节地址
	if(cnt==1)
	{
		r1=SD_sendcmd(CMD17,sector,0X01);//读命令
		if(r1==0)//指令发送成功
		{
			r1=SD_ReceiveData(buf,512);//接收512个字节	   
		}
	}else
	{
		r1=SD_sendcmd(CMD18,sector,0X01);//连续读命令
		do
		{
			r1=SD_ReceiveData(buf,512);//接收512个字节	 
			buf+=512;  
		}while(--cnt && r1==0); 	
		
//		HAL_SPI_TransmitReceive_DMA(&hspi1,buf,&Txdata,cnt*512);
		SD_sendcmd(CMD12,0,0X01);	//发送停止命令
	}   
	SD_CS(0);//取消片选
	return r1;//
}




uint8_t spi_readwrite(uint8_t Txdata){
	uint8_t Rxdata;	
	HAL_SPI_TransmitReceive(&hspi1,&Txdata,&Rxdata,1,1000);
	return Rxdata;
}

uint8_t spi_readwrite_DMA(uint8_t *Rxdata,uint16_t SPI_BUFFER_SIZE){//DMA读取
	uint8_t Txdata;	
	HAL_SPI_TransmitReceive(&hspi1,&Txdata,Rxdata,SPI_BUFFER_SIZE,1000);
//	HAL_SPI_TransmitReceive_DMA(&hspi1,&Txdata,Rxdata,SPI_BUFFER_SIZE);//HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData,uint16_t Size)
//	HAL_SPI_TransmitReceive(&hspi1,&Txdata,&Rxdata,1,100);
	return Txdata;
}
//SPI1波特率设置
void SPI_setspeed(uint8_t speed){
	hspi1.Init.BaudRatePrescaler = speed;
}

///////////////////////////END//////////////////////////////////////
void SD_init_(void)
	
{
	res = SD_init();		//SD卡初始化
	readsd=0;
	writesd=0;
	
	if(res == 1)
	{
		printf("SD卡初始化失败! \r\n");		
	}
	else
	{
		printf("SD卡初始化成功！ \r\n");		
	}
}


void SD_mount(void)
{
	res=f_mount(&fs,"0:",1);		//挂载
	
//	if(test_sd == 0)		//用于测试格式化
	if(res == FR_NO_FILESYSTEM)		//没有文件系统，格式化
	{
//		test_sd =1;				//用于测试格式化
		printf("没有文件系统! \r\n");		
		res = f_mkfs("", 0, 0);		//格式化sd卡
		if(res == FR_OK)
		{
			printf("格式化成功! \r\n");		
			res = f_mount(NULL,"0:",1); 		//格式化后先取消挂载
			res = f_mount(&fs,"0:",1);			//重新挂载	
			if(res == FR_OK)
			{
				printf("SD卡已经成功挂载，可以进进行文件写入测试!\r\n");
			}	
		}
		else
		{
			printf("格式化失败! \r\n");		
		}
	}
	else if(res == FR_OK)
	{
		printf("挂载成功! \r\n");		
	}
	else
	{
		printf("挂载失败! \r\n");
	}	

}

改写user_discio.c

#include <string.h>
#include "ff_gen_drv.h"
#include "SDdriver.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/
/* Disk status */
static volatile DSTATUS Stat = STA_NOINIT;

/* USER CODE END DECL */

/* Private function prototypes -----------------------------------------------*/
DSTATUS USER_initialize (BYTE pdrv);
DSTATUS USER_status (BYTE pdrv);
DRESULT USER_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count);
#if _USE_WRITE == 1
  DRESULT USER_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count);
#endif /* _USE_WRITE == 1 */
#if _USE_IOCTL == 1
  DRESULT USER_ioctl (BYTE pdrv, BYTE cmd, void *buff);
#endif /* _USE_IOCTL == 1 */

Diskio_drvTypeDef  USER_Driver =
{
  USER_initialize,
  USER_status,
  USER_read,
#if  _USE_WRITE
  USER_write,
#endif  /* _USE_WRITE == 1 */
#if  _USE_IOCTL == 1
  USER_ioctl,
#endif /* _USE_IOCTL == 1 */
};

/* Private functions ---------------------------------------------------------*/

/**
  * @brief  Initializes a Drive
  * @param  pdrv: Physical drive number (0..)
  * @retval DSTATUS: Operation status
  */
DSTATUS USER_initialize (
	BYTE pdrv           /* Physical drive nmuber to identify the drive */
)
{
  /* USER CODE BEGIN INIT */
   uint8_t res;
	 res = SD_init();//SD_Initialize() 
		 	if(res)//STM32 SPI的bug,在sd卡操作失败的时候如果不执行下面的语句,可能导致SPI读写异常
			{
				SPI_setspeed(SPI_BAUDRATEPRESCALER_256);
				spi_readwrite(0xff);//提供额外的8个时钟
				SPI_setspeed(SPI_BAUDRATEPRESCALER_2);
			}
	if(res)return  STA_NOINIT;
	else return RES_OK; //初始化成功
  /* USER CODE END INIT */
}

/**
  * @brief  Gets Disk Status
  * @param  pdrv: Physical drive number (0..)
  * @retval DSTATUS: Operation status
  */
DSTATUS USER_status (
	BYTE pdrv       /* Physical drive number to identify the drive */
)
{
  /* USER CODE BEGIN STATUS */
  switch (pdrv)
	{
		case 0 :
			return RES_OK;
		case 1 :
			return RES_OK;
		case 2 :
			return RES_OK;
		default:
			return STA_NOINIT;
	}
  /* USER CODE END STATUS */
}

/**
  * @brief  Reads Sector(s)
  * @param  pdrv: Physical drive number (0..)
  * @param  *buff: Data buffer to store read data
  * @param  sector: Sector address (LBA)
  * @param  count: Number of sectors to read (1..128)
  * @retval DRESULT: Operation result
  */
DRESULT USER_read (
	BYTE pdrv,      /* Physical drive nmuber to identify the drive */
	BYTE *buff,     /* Data buffer to store read data */
	DWORD sector,   /* Sector address in LBA */
	UINT count      /* Number of sectors to read */
)
{
  /* USER CODE BEGIN READ */
  uint8_t res;
	if( !count )
	{    
		return RES_PARERR;  /* count不能等于0，否则返回参数错误 */
	}
	switch (pdrv)
	{
		case 0:			 
		    res=SD_ReadDisk(buff,sector,count);	 //需要改写以提升速度
				if(res == 0){
					return RES_OK;
				}else{
					return RES_ERROR;
				}                                               
		default:
			return RES_ERROR;
	}
  /* USER CODE END READ */
}

/**
  * @brief  Writes Sector(s)
  * @param  pdrv: Physical drive number (0..)
  * @param  *buff: Data to be written
  * @param  sector: Sector address (LBA)
  * @param  count: Number of sectors to write (1..128)
  * @retval DRESULT: Operation result
  */
#if _USE_WRITE == 1
DRESULT USER_write (
	BYTE pdrv,          /* Physical drive nmuber to identify the drive */
	const BYTE *buff,   /* Data to be written */
	DWORD sector,       /* Sector address in LBA */
	UINT count          /* Number of sectors to write */
)
{
  /* USER CODE BEGIN WRITE */
  /* USER CODE HERE */
  uint8_t  res;
	if( !count )
	{    
		return RES_PARERR;  /* count不能等于0，否则返回参数错误 */
	}
	switch (pdrv)
	{
		case 0:
			
		    res=SD_WriteDisk((uint8_t *)buff,sector,count);//需要改写以提升速度
				if(res == 0){
					return RES_OK;
				}else{
					return RES_ERROR;
				}                                                
		default:return RES_ERROR;
	}
  /* USER CODE END WRITE */
}
#endif /* _USE_WRITE == 1 */

/**
  * @brief  I/O control operation
  * @param  pdrv: Physical drive number (0..)
  * @param  cmd: Control code
  * @param  *buff: Buffer to send/receive control data
  * @retval DRESULT: Operation result
  */
#if _USE_IOCTL == 1
DRESULT USER_ioctl (
	BYTE pdrv,      /* Physical drive nmuber (0..) */
	BYTE cmd,       /* Control code */
	void *buff      /* Buffer to send/receive control data */
)
{
  /* USER CODE BEGIN IOCTL */
    DRESULT res;
	 switch(cmd)
	    {
		    case CTRL_SYNC:
						SD_CS(1);
						do{
							HAL_Delay(20);
						}while(spi_readwrite(0xFF)!=0xFF);
						res=RES_OK;
						SD_CS(0);
		        break;	 
		    case GET_SECTOR_SIZE:
		        *(WORD*)buff = 512;
		        res = RES_OK;
		        break;	 
		    case GET_BLOCK_SIZE:
		        *(WORD*)buff = 8;
		        res = RES_OK;
		        break;	 
		    case GET_SECTOR_COUNT:
		        *(DWORD*)buff = SD_GetSectorCount();
		        res = RES_OK;
		        break;
		    default:
		        res = RES_PARERR;
		        break;
	    }
		return res;
  /* USER CODE END IOCTL */
}
#endif /* _USE_IOCTL == 1 */

录音代码

#include "mic.h"
#include "sys.h"
#include "main.h"
#include "ebyte_e32x.h"
#include "stdio.h"
#include "SDdriver.h"


uint8_t wave_buffer_a[wave_buffer_size];
uint8_t wave_buffer_b[wave_buffer_size];
unsigned int wavIndex=0;
long cnn_cont=0;
unsigned int x=0;
extern int8_t encode_out[20];
unsigned int page_index;
uint32_t start_addr;

unsigned char wave_head[44]={
	0x52,0x49,0x46,0x46,0x6C,0x56,0x00,0x00,0x57,0x41,0x56,0x45,0x66,0x6D,0x74,0x20,
	0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x40,0x1F,0x00,0x00,0x40,0x1F,0x00,0x00,
	0x01,0x00,0x08,0x00,0x64,0x61,0x74,0x61,0x48,0x56,0x00,0x00};
unsigned char length[4]={0x6C,0x56,0x00,0x00};

void adc_half(void)
{
		for(x=0;x<DMA_size/2-1;x++)
			{
				wave_buffer_a[wavIndex]=adc_val[x]*255/4096;
				wavIndex+=1;
			}
}
void adc_all(void)
{
    for(x=DMA_size/2-1;x<DMA_size-1;x++)
			{
				wave_buffer_a[wavIndex]=adc_val[x]*255/4096;
				wavIndex+=1;
				
			}
			wavIndex=0;
			buff_flag=1;
			cnn_cont++;

}


void record_pdm(void)
{
		if(record_flag==1)
		{
			if(buff_flag==3){ 	
        cnn_cont=0;				
				HAL_TIM_Base_Start(&htim3);

				HAL_ADC_Start_DMA(&hadc1, (uint32_t *)(&adc_val), DMA_size);
				HAL_ADCEx_Calibration_Start(&hadc1);
				wavIndex=0;
				buff_flag=0;
				f_open(&file,"record.wav",FA_OPEN_ALWAYS |FA_WRITE);
				f_write(&file,wave_head,sizeof(wave_head),&Bw);

			}
			if(buff_flag==1){ 
				buff_flag=0;
				Audio_write();
			}

	 }
	if(record_flag==3)
		{	
			record_flag =0;
			HAL_TIM_Base_Stop_IT(&htim3);	
			HAL_ADC_Stop_DMA(&hadc1);
  		printf("record to end\r\n");
			f_lseek(&file, 4);
			length[0]=(cnn_cont*512+44) &0xff;
			length[1]=(cnn_cont*512+44)>>8 &0xff;
			length[2]=(cnn_cont*512+44)>>16 &0xff;
			length[3]=(cnn_cont*512+44)>>24 &0xff;
			f_write(&file,length,4,&Bw);
			f_close(&file);	

		}
			
}
void Audio_write(void)
{

	f_write(&file,wave_buffer_a,512,&Bw);

}

语音播放代码

#include "speak.h"
#include "sys.h"
#include "stdio.h"
#include "SDdriver.h"

void audio_PCM(void)
{	
	if(play_flag==3){
			cont=0;
			TIM4->CCR1=0;
			HAL_TIM_PWM_Stop(&htim4,TIM_CHANNEL_1);	
			HAL_TIM_Base_Stop_IT(&htim1); 
		  f_close(&file);
			printf("play to end \r\n");
		  play_flag =0;
	}
	
	if(play_flag ==1){
		if(buff_flag==3){
			f_lseek(&file, 4);
			f_read (&file, &length,4, &Bw);
			cnn_cont=length[0]|length[1]<<8|length[2]<<16|length[3]<<24;
			cnn_cont=cnn_cont/512;
			write_flag=0;
			Audio_read();
			write_flag=1;
			Audio_read();
			buff_flag=0;
			cont=0;
			HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_1);
			__HAL_TIM_CLEAR_IT(&htim1, TIM_IT_UPDATE);
			HAL_TIM_Base_Start_IT(&htim1); 	
		}
		if(buff_flag==1){ 
			Audio_read();	
			buff_flag=0;
		}	
	}
}
void  Audio_play(TCHAR* path){/* Pointer to the file name */
	f_open(&file,path,FA_READ);
	buff_flag=3;
	play_flag=1;
}

void Audio_read(void){
	if(cnn_cont>1){
		cnn_cont--;
			if(write_flag==1){
				f_read (&file, &wave_buffer_b,512, &Bw);
				
			}
			else
			{
				f_read (&file, &wave_buffer_a,512, &Bw);
				}
		
	}else{
		play_flag=3;
	}
}
标签
#stm32 #单片机 #语音识别
基于STM32F103芯片的音频数据的Flash读取与DAC播放
qq_46470208的博客
12-31 2907
基于STM32F103芯片的音频数据的Flash读取与DAC播放 文章目录基于STM32F103芯片的音频数据的Flash读取与DAC播放1 Flash 概述1.1 单片机内存映射1.2 Flash 构成1.3 Flash 写入流程2 读取Flash内存的实例2.1 STM32CubeMX 配置2.2 keil 配置3 DAC 概述4 DAC 播放实例4.1 实验准备与测试4.1.1 用Audition输出一个周期2khz的正弦波4.1.24.2 数字音频还原总结参考 1 Flash 概述 1.1 单片机内
STM32单片机语音提示盲人拐杖整点报时夜间警示超声波测距
LS840233684的博客
10-12 2020
STM32单片机语音提示盲人拐杖整点报时夜间警示超声波测距 关键词：语音提示盲人拐杖 整点报时 超声波测距拐杖
语音_播报_STM32F103_语音播报_stm32f103语音_STM32语音播报_351711COm_
09-29
可以实现STM32F103的语音播报功能，里面是详细的实验报告
基于STM32F103的录音笔项目：从ADC采样到WAV文件存储的嵌入式音频系统实践
weixin_28278377的博客
08-06 173
在嵌入式系统开发中，模数转换（ADC）和文件系统是两项基础且关键的技术。ADC负责将模拟信号（如声音）转换为数字信号，其采样率和精度直接影响数据质量；而FATFS等文件系统则管理存储设备上的数据组织，实现文件的创建、读写与删除。这两项技术的结合，为设备实现本地化数据采集与存储提供了核心支撑，具有很高的工程价值。其典型应用场景包括环境监测、语音记录、数据日志等离线设备。本文以STM32F103C8T6微控制器为核心，详细解析如何利用其内置ADC和DMA进行音频采样，并通过FATFS中间件将PCM数据以WAV格
STM32F103连接语音合成模块实现文字转语音播报-工程源码.zip
11-13
这是一份keil工程源码(适用于STM32F103C8T6、RCT6、ZET6、VET6等)。 可以直接使用keil5打开编译。 工程里用到了 OLED显示屏(0.96寸 SPI接口)，语音合成播报模块，主控芯片是STM32F103RCT6。 并且带了一份文档，讲解了如何使用语音模块，如何接线，以及购买的地址链接。 实现功能： 按下按键，可以进行语音播报，并且在OLED显示屏上显示语音播报模块的状态（播放中和播放完毕的状态）。 在OLED显示屏上显示4行中文，每行8个字，通过按键选择行。 按下按键确认就播报这一段中文。 效果可看B站视频： https://space.bilibili.com/68130189
基于STM32F103单片机的红外感应语音播报自动迎客门
a_huan258147的博客
04-28 9372
系统功能设计 （末尾附文件） 本系统由STM32F103C8T6单片机核心板、语音播报、ULN2003步进电机控制、红外避障传感器、按键及电源组成。 1、红外探头检测到有人时，自动门打开（步进电机向打开方向旋转一周），人员进入，语音播报欢迎。 2、在开门的状态下，检测不到人遮挡，自动门关闭。 3、在关门过程中，再次检测到人遮挡，会停止关门进行开门操作。防止夹到人。 4、另外按键操作相当于门里的开关，按下开关门打开，门里人出来，语音播报欢迎再次光临。 NY3P065BP8语音芯片电路设计 此系列语音芯片是技针
基于STM32的录音机设计(STM32F103+VS1053B)
热门推荐
06-10 1万+
本项目设计并实现了一款基于STM32微控制器的便携式录音机。该录音机采用STM32F103C8T6作为主控芯片，结合VS1053B音频编解码模块、SD卡存储、OLED显示屏以及按键模块，提供了手动录音、自动录音和录音回放等多种功能。
STM32F103_WM8978_录音及播放参考例程：为音频处理带来新选择
gitblog_06709的博客
04-14 894
STM32F103_WM8978_录音及播放参考例程：为音频处理带来新选择 【下载地址】STM32F103_WM8978_录音及播放参考例程 本开源项目为STM32F103与WM8978音频处理模块的录音及播放参考例程，助您轻松实现音频数据的录制与播放。通过该例程，您可以将录音数据直接存储至SD卡，并支持从SD卡播放音频...
STM32 音频ADC转wav格式
m0_37777700的博客
10-24 1325
STM32 音频ADC DAC测试方法_stm32 adc 音频-CSDN博客
AI智能棋盘合成WTV020-SD语音内容
weixin_42462474的博客
11-08 627
本文介绍如何利用WTV020-SD语音芯片在AI智能棋盘中实现低成本、高可靠性的语音反馈，通过预录真人语音和SPI控制，达成毫秒级响应，适用于教育、视障辅助等场景。
STM32内部FLASH存储音频并通过DAC播放的完整实现方案
快马扬鞭须努力！
08-13 411
在嵌入式系统开发中，音频播放功能常需外接存储芯片，增加了系统复杂性与成本。其核心原理在于将数字音频信号通过数模转换器（DAC）还原为模拟波形。DAC作为关键外设，负责将离散的数字量转换为连续的模拟电压。结合直接存储器访问（DMA）技术，可实现音频数据从存储介质到DAC的高效、无需CPU干预的自动搬运，极大解放了处理器资源，提升了系统实时性。这一技术组合在智能家居、工业报警、语音提示等对成本与体积敏感的应用场景中价值显著。本文以STM32微控制器为例，深入探讨如何利用其内部FLASH存储PCM音频数据，并通过
正点原子-战舰V3开发板硬件资源全解析与实战应用指南
weixin_30566063的博客
03-22 112
本文全面解析正点原子战舰V3开发板的硬件资源与实战应用，重点介绍其基于STM32F103ZET6芯片的架构设计、丰富外设接口及存储系统配置技巧。通过详细的代码示例和应用场景分析，帮助开发者高效利用该开发板进行音频处理、通信接口开发及低功耗管理等高级应用。
振南技术干货集：znFAT 硬刚日本的 FATFS 历险记（8）
小超嵌入式笔记
11-28 1097
网上能搜到的关于数码相框的方案,大多是基于液晶屏显示的,我手里没有现成的液晶屏,VGA 倒是有两个。大家选择液晶屏而不选 VGA 的原因,我后来才知道:因为 VGA 显示需要的显存比较大,一般至少 2 MB,这么大的显存是需要银子的。DEO 用的是 EP3C16F484C6 的 FPGA(属Altera Cyclonell系列),片上只有 56 个 M9KRAM,56 这个数字很鸡,于 32 和64之间,所以我就建立了一个32 KB 的双口 RAM。（承诺必须兑现，5 年之后的谢师会，我擎书谢师。
优信电子所有博客汇总(导航搜索)
优信电子的博客
08-15 1万+
本文用于汇总我们发布过的所有有关传感器、单片机、模块以及调试学习心得的文章，优信粉们可以使用 ctrl+F 搜索相关的内容以便快速寻找文章，CSDN为目前我们与用户共同分享学习进步的一个平台，更多的学习内容我们技术人员会逐步更新发布，评论区也可以提交大家需求以便我们有针对性的更新文章！...
杰理AD16N：高集成度音频SoC在智能玩具与教育硬件中的开发实践
weixin_33829657的博客
07-13 396
本文深入探讨了杰理AD16N高集成度音频SoC在智能玩具与教育硬件中的开发实践。作为一款专为音频处理设计的32位SoC，AD16N集成了MP3解码器、ADC/DAC转换器和功率放大器，支持三路并行解码和超低功耗运行。文章通过实际案例展示了其在儿童故事机、英语学习机等教育硬件中的应用优势，包括成本节省40%、低功耗设计及音质优化技巧，为开发者提供了从环境搭建到高级应用的全方位指南。
【信息科学与工程学】计算机科学与自动化——第一百五十五篇 缓存系统设计06
最新发布
weixin_49199313的博客
08-15 332
字段详细内容编号​B1类型​PaaS + MaaS（基于微服务 + 事件溯源 + CQRS + 国产化组件：鲲鹏CPU + 昇腾GPU + TiDB + Ceph国产版 + Kafka国产版 + 东方通中间件 + 华为云CDN + WebSocket + QUIC）问题​微服务 + 事件溯源 + 鲲鹏920 + 昇腾910 + TiDB + Ceph（XSKY）+ 国产Kafka + WebSocket + QUIC 电-热-力耦合：如何支持单个超大客户（10亿注册用户，5亿日活），每秒1亿条消息 + 10
STM32F103ZET6串口调试与语音播报
weixin_45760766的博客
08-30 6189
串行数据传输时，数据是一位一位地在通信线上传输的，先由具有几位总线的计算机内的发送设备，将几位并行数据经并--串转换硬件转换成串行方式，再逐位经传输线到达接收站的设备中，并在接收端将数据从串行方式重新转换成并行方式，以供接收方使用。另一种方法是使用8条数据线分别传送8位，一次传送一个字节，叫并行通信。所谓同步通信，是指数据传送是以数据块（一组字符）为单位，字符与字符之间、字符内部的位与位之间都同步，因为一次传输的数据块中包含的数据较多，所以接收时钟与发送进钟严格同步，通常要有同步时钟。...
基于STM32F103ZET6单片机无线抢答器语音播报蓝牙APP设计21-913
Danpianjihuizong的博客
04-07 440
21-913、STM32F103ZET6无线抢答器设计-LCD1602-KEY-1位数码管-蓝牙-LED-ISD产品功能描述：本设计由STM32F102ZET6单片机核心板电路+按键电路+ISD1820语音模块电路+LCD1602液晶显示电路+蓝牙模块电路+LED指示灯电路组成。1、当主持人按下抢答按键后，8名选手做好准备，当液晶显示9秒倒计时，当计时从9变为0时，红灯变绿灯，选手开始按下按键抢答，当抢答成功时，语音播报：抢答成功。同时液晶显示对应的选手标号以及抢答成功的选手的抢答时间（抢答时间从数码管从9
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值