devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32传感器外设集--语音识别模块（LD3320）_ld3320官方

作者：2023面试高手 | 2024-04-06 22:33:11

赞

踩

ld3320官方

目录

前言

本节主要贴上以前写的语音识别外设LD3320，希望对大家有用，本人已经测试过有用

如何使用，将下面这段函数添加到功能函数中

LD3320.h

LD3320.c

参考

前言

LD3320是一款由icroute公司生产的语音识别芯片。它具有高性能的语音识别能力，可以广泛应用于各种智能控制、语音交互等场景。以下是关于LD3320语音识别模块的详细介绍：

1. 基本原理：LD3320语音识别模块通过识别预先内置的指令来实现对语音的控制。它的工作模式主要有三种：普通模式、按键模式和口令模式。在口令模式下，设备需要一级唤醒词（口令）来启动ASR进程，从而避免误动作。

2. 应用场景：LD3320语音识别模块可以广泛应用于家居智能控制、智能小车DIY设计、毕业设计创新功能、个人DIY设计以及语音控制嵌入式产品设计等领域。

3. 性能特点：LD3320具有较高的识别准确率和稳定性，能够在各种环境下实现精确的语音识别。此外，它还具有较低的功耗和较小的体积，便于集成到各种设备中。

4. 技术参数：LD3320语音识别模块具备50条预设指令的识别能力。在接收到语音指令后，模块会根据指令执行相应的操作。其工作电压范围为3.3V-5V，适合多种电源供应方案。

5. 接口方式：LD3320模块采用标准的TTL电平接口，易于与微控制器、单片机等设备连接。同时，它还具备完善的开发文档和示例代码，便于开发者进行二次开发。

6. 市场前景：随着智能家居、智能硬件等领域的快速发展，对语音识别技术的需求日益增长。LD3320作为一种具有较高性能和实用性的语音识别模块，具有广阔的市场前景。

本节主要贴上以前写的语音识别外设LD3320，希望对大家有用，本人已经测试过有用

如何使用，将下面这段函数添加到功能函数中

  1. switch(nAsrStatus)
  2. 		{
  3. 			case LD_ASR_RUNING:
  4. 				
  5. 			case LD_ASR_ERROR:		
  6. 					break;
  7. 			case LD_ASR_NONE:
  8. 					nAsrStatus=LD_ASR_RUNING;
  9. 					if (RunASR()==0)//启动一次ASR识别流程：ASR初始化，ASR添加关键词语，启动ASR运算
  10. 					{		
  11. 						nAsrStatus = LD_ASR_ERROR;
  12. 					}
  13. 					break;
  14. 			case LD_ASR_FOUNDOK:
  15. 					 nAsrRes = LD_GetResult( );//一次ASR识别流程结束，去取ASR识别结果										 
  16. 					 printf("\r\n识别码:%d", nAsrRes);			 		
  17. 								
  18. 					 switch(nAsrRes)		   			//对结果执行相关操作,客户修改
  19. 						{
  20. 							case CODE_LSD:					//命令“流水灯”
  21. 							{
  22. 									printf(" 流水灯 指令识别成功\r\n"); 
  23. 							    //SYN6288_Speech(DEBUG_USARTx,"现在展示流水灯");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  24. 									Delay_ms(200);
  25. 															 break;
  26. 							}
  27. 							case CODE_SS:	 					//命令“闪烁”
  28. 							{
  29. 								printf(" 名字 指令识别成功\r\n"); 
  30. 								// SYN6288_Speech(DEBUG_USARTx,"现在展示闪烁");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  31. 									Delay_ms(200);
  32. 															 break;
  33. 							}
  34. 							case LDE_1:					
  35. 							{
  36. 								printf(" 红灯打开\r\n"); 
  37. 								 //SYN6288_Speech(DEBUG_USARTx,"按键触发");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  38. 									Delay_ms(200);
  39. 															break;
  40. 							}
  41. 							
  42. 							case LDE_2:						
  43. 							{
  44. 								printf(" 绿灯打开\r\n");
  45. 								 //SYN6288_Speech(DEBUG_USARTx,"全灭 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  46. 									Delay_ms(200);
  47. 															break;
  48. 							}
  49. 							case LDE_3:						
  50. 							{
  51. 								printf(" 蓝灯打开\r\n");
  52. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  53. 									Delay_ms(200);
  54. 															break;
  55. 							}	
  56. 							case LDE_1_1:					
  57. 							{
  58. 								printf(" 红灯关闭\r\n"); 
  59. 								 //SYN6288_Speech(DEBUG_USARTx,"按键触发");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  60. 									Delay_ms(200);
  61. 															break;
  62. 							}
  63. 							
  64. 							case LDE_2_1:						
  65. 							{
  66. 								printf(" 绿灯关闭\r\n");
  67. 								 //SYN6288_Speech(DEBUG_USARTx,"全灭 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  68. 									Delay_ms(200);
  69. 															break;
  70. 							}
  71. 							case LDE_3_1:						
  72. 							{
  73. 								printf(" 蓝灯关闭\r\n");
  74. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  75. 									Delay_ms(200);
  76. 								break;
  77. 							}
  78. 								
  79. 							case LDE_All_OFF:						//命令“状态”
  80. 							{
  81. 								printf(" 全灯关闭打开\r\n");
  82. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  83. 									Delay_ms(200);
  84. 								break;
  85. 							}	
  86. 							case chen:						
  87. 							{
  88. 								
  89. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  90. 									Delay_ms(200);
  91. 								break;
  92. 							}
  93. 							case chen_1:						
  94. 							{
  95. 								
  96. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  97. 									Delay_ms(200);
  98. 								break;
  99. 							}
  100. 							case voice_J_0:						
  101. 							{
  102. 			
  103. 								printf(" 音量提高\r\n");
  104. 								 //SYN6288_Speech(DEBUG_USARTx,"全灭 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  105. 									Delay_ms(200);
  106. 															break;
  107. 							}
  108. 							case voice_J_1:						
  109. 							{
  110. 								printf(" 音量降低\r\n");
  111. 						
  112. 								// SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  113. 									Delay_ms(200);
  114. 								break;
  115. 							}								
  116. 							default:break;
  117. 						}	
  118. 					nAsrStatus = LD_ASR_NONE;
  119. 					break;
  120. 			case LD_ASR_FOUNDZERO:
  121. 			default:
  122. 					nAsrStatus = LD_ASR_NONE;
  123. 					break;
  124. 			}//switch

LD3320.h

  1. #ifndef _LD3320_H__
  2. #define _LD3320_H__
  3. #include "stm32f10x_exti.h"
  4. #include "stm32f10x_spi.h"
  5.  
  6. ///以下三个状态定义用来记录程序是在运行ASR识别还是在运行MP3播放
  7. #define LD_MODE_IDLE			0x00
  8. #define LD_MODE_ASR_RUN		0x08
  9. #define LD_MODE_MP3		 		0x40
  10. ///以下五个状态定义用来记录程序是在运行ASR识别过程中的哪个状态
  11. #define LD_ASR_NONE					0x00	//表示没有在作ASR识别
  12. #define LD_ASR_RUNING				0x01	//表示LD3320正在作ASR识别中
  13. #define LD_ASR_FOUNDOK			0x10	//表示一次识别流程结束后，有一个识别结果
  14. #define LD_ASR_FOUNDZERO 		0x11	//表示一次识别流程结束后，没有识别结果
  15. #define LD_ASR_ERROR	 			0x31	//	表示一次识别流程中LD3320芯片内部出现不正确的状态
  16.  
  17. #define CLK_IN   					24/* user need modify this value according to clock in */
  18. #define LD_PLL_11					(uint8_t)((CLK_IN/2.0)-1)
  19. #define LD_PLL_MP3_19			0x0f
  20. #define LD_PLL_MP3_1B			0x18
  21. #define LD_PLL_MP3_1D   	(uint8_t)(((90.0*((LD_PLL_11)+1))/(CLK_IN))-1)
  22.  
  23. #define LD_PLL_ASR_19 		(uint8_t)(CLK_IN*32.0/(LD_PLL_11+1) - 0.51)
  24. #define LD_PLL_ASR_1B 		0x48
  25. #define LD_PLL_ASR_1D 		0x1f
  26.  
  27. #define MIC_VOL 0x43
  28. ///识别码（客户修改处）
  29. #define CODE_LSD	1	 //唤醒
  30. #define CODE_SS	  2	 //名字
  31. #define LDE_1	  3	 //打开红
  32. #define LDE_2	  4	 //打开绿
  33. #define LDE_3		5  //打开蓝
  34. #define LDE_All_OFF		6  //状态
  35. #define voice_J_0  7	//提高音量
  36.  
  37. #define LDE_1_1	  51	 //打开红
  38. #define LDE_2_1	  52	 //打开绿
  39. #define LDE_3_1		53  //打开蓝
  40. #define voice_J_1  57	//降低音量
  41.  
  42.  
  43.  
  44.  
  45. #define chen		90  //娱乐
  46. #define chen_1		91  //娱乐
  47.  
  48.  
  49. ///LD3320引脚相关定义
  50. #define LD3320RST_PIN					GPIO_Pin_15		
  51. #define LD3320RST_GPIO_PORT		GPIOB
  52. #define LD3320RST_GPIO_CLK		RCC_APB2Periph_GPIOB
  53. #define LD_RST_H() 						GPIO_SetBits(GPIOB, GPIO_Pin_15)
  54. #define LD_RST_L() 						GPIO_ResetBits(GPIOB, GPIO_Pin_15)
  55.  
  56. ///LD3320引脚相关定义
  57. #define LD3320CS_PIN					GPIO_Pin_4		
  58. #define LD3320CS_GPIO_PORT		GPIOA
  59. #define LD3320CS_GPIO_CLK			RCC_APB2Periph_GPIOA
  60. #define LD_CS_H()							GPIO_SetBits(GPIOA, GPIO_Pin_4)
  61. #define LD_CS_L()							GPIO_ResetBits(GPIOA, GPIO_Pin_4)
  62.  
  63. #define LD3320IRQ_GPIO_CLK		RCC_APB2Periph_GPIOB
  64. #define LD3320IRQ_PIN					GPIO_Pin_12
  65. #define LD3320IRQ_GPIO_PORT		GPIOB
  66. #define LD3320IRQEXIT_PORTSOURCE		GPIO_PortSourceGPIOB
  67. #define LD3320IRQPINSOURCE		GPIO_PinSource12
  68. #define LD3320IRQEXITLINE			EXTI_Line12
  69. #define LD3320IRQN						EXTI15_10_IRQn
  70.  
  71. #define LD3320WR_PIN					GPIO_Pin_13
  72. #define LD3320WR_GPIO_PORT		GPIOB
  73. #define LD3320WR_GPIO_CLK			RCC_APB2Periph_GPIOB
  74. #define LD_SPIS_H()  					GPIO_SetBits(GPIOB, GPIO_Pin_13)
  75. #define LD_SPIS_L()  					GPIO_ResetBits(GPIOB, GPIO_Pin_13)
  76.  
  77. #define	LD3320SPI							SPI1
  78. #define LD3320SPI_CLK					RCC_APB2Periph_SPI1						
  79.  
  80. #define LD3320SPIMISO_PIN					GPIO_Pin_6
  81. #define LD3320SPIMISO_GPIO_PORT		GPIOA
  82. #define LD3320SPIMISO_GPIO_CLK		RCC_APB2Periph_GPIOA
  83.  
  84. #define LD3320SPIMOSI_PIN					GPIO_Pin_7
  85. #define LD3320SPIMOSI_GPIO_PORT		GPIOA
  86. #define LD3320SPIMOSI_GPIO_CLK		RCC_APB2Periph_GPIOA
  87.  
  88. #define LD3320SPISCK_PIN					GPIO_Pin_5
  89. #define LD3320SPISCK_GPIO_PORT		GPIOA
  90. #define LD3320SPISCK_GPIO_CLK			RCC_APB2Periph_GPIOA
  91.  
  92. ///相关初始化
  93. void LD3320_main(void);
  94. void LD3320_init(void);
  95. static void LD3320_GPIO_Cfg(void);
  96. static void LD3320_EXTI_Cfg(void);
  97. static void LD3320_SPI_cfg(void);
  98. ///中间层
  99. static void LD3320_delay(unsigned long uldata);
  100. uint8_t RunASR(void);
  101. void LD_reset(void);
  102. void LD_AsrStart(void);
  103. uint8_t LD_Check_ASRBusyFlag_b2(void);
  104. ///寄存器操作
  105. uint8_t spi_send_byte(uint8_t byte);
  106. void LD_WriteReg(uint8_t data1,uint8_t data2);
  107. uint8_t LD_ReadReg(uint8_t reg_add);
  108. uint8_t LD_AsrAddFixed(void);
  109. uint8_t LD_GetResult(void);
  110. uint8_t LD_AsrRun(void);
  111. void ProcessInt(void);
  112. void LD_Init_Common(void);
  113. void LD_Init_ASR(void);
  114.  
  115. #endif

LD3320.c

  1. #include "LD3320.h"
  2. #include "string.h"
  3. #include "bsp_SysTick.h"
  4. #include <string.h>
  5. #include "bsp_usart1.h"
  6. #include "SYN6288.h"
  7. #include "bsp_led.h"
  8.  
  9. /************************************************************************************
  10. //	nAsrStatus 用来在main主程序中表示程序运行的状态，不是LD3320芯片内部的状态寄存器
  11. //	LD_ASR_NONE:			表示没有在作ASR识别
  12. //	LD_ASR_RUNING：		表示LD3320正在作ASR识别中
  13. //	LD_ASR_FOUNDOK:		表示一次识别流程结束后，有一个识别结果
  14. //	LD_ASR_FOUNDZERO:	表示一次识别流程结束后，没有识别结果
  15. //	LD_ASR_ERROR:			表示一次识别流程中LD3320芯片内部出现不正确的状态
  16. 首先：
  17. LD3320
  18. SPI总线
  19.  
  20. RST—PB15，
  21. CS--PA4，
  22. IRQ—PB12，
  23. WR—PB13，
  24. MISO—PA6，
  25. MOSI—PA7，
  26. SCK—PA5
  27. *********************************************************************************/
  28. extern uint8_t nAsrStatus;	
  29. uint8_t nLD_Mode = LD_MODE_IDLE;//用来记录当前是在进行ASR识别还是在播放MP3
  30. uint8_t ucRegVal;
  31.  
  32.  
  33. static void LD3320_GPIO_Cfg(void)
  34. {	
  35. 		GPIO_InitTypeDef GPIO_InitStructure;
  36. 		RCC_APB2PeriphClockCmd(LD3320RST_GPIO_CLK | LD3320CS_GPIO_CLK,ENABLE);
  37. 		//LD_CS	/RSET
  38. 		GPIO_InitStructure.GPIO_Pin =LD3320CS_PIN;
  39. 		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  40. 		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  41. 		GPIO_Init(LD3320CS_GPIO_PORT,&GPIO_InitStructure);
  42. 		GPIO_InitStructure.GPIO_Pin =LD3320RST_PIN;
  43. 		GPIO_Init(LD3320RST_GPIO_PORT,&GPIO_InitStructure);
  44. }
  45. static void LD3320_EXTI_Cfg(void)
  46. {
  47.   EXTI_InitTypeDef EXTI_InitStructure;
  48. 	NVIC_InitTypeDef NVIC_InitStructure;
  49.   GPIO_InitTypeDef GPIO_InitStructure;
  50. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);	
  51.  
  52. 	RCC_APB2PeriphClockCmd(LD3320IRQ_GPIO_CLK, ENABLE);
  53.   GPIO_InitStructure.GPIO_Pin =LD3320IRQ_PIN;
  54.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  55.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  56.   GPIO_Init(LD3320IRQ_GPIO_PORT, &GPIO_InitStructure);
  57. 	//外部中断线配置
  58.   GPIO_EXTILineConfig(LD3320IRQEXIT_PORTSOURCE, LD3320IRQPINSOURCE);
  59.   EXTI_InitStructure.EXTI_Line = LD3320IRQEXITLINE;
  60.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  61.   EXTI_InitStructure.EXTI_Trigger =EXTI_Trigger_Falling;
  62.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  63.   EXTI_Init(&EXTI_InitStructure);
  64. 	//中断嵌套配置
  65.   NVIC_InitStructure.NVIC_IRQChannel = LD3320IRQN;
  66.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  67.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  68.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  69.   NVIC_Init(&NVIC_InitStructure);
  70. }
  71. static void LD3320_SPI_cfg(void)
  72. {
  73. 	SPI_InitTypeDef  SPI_InitStructure;
  74. 	GPIO_InitTypeDef GPIO_InitStructure;
  75.   //spi端口配置
  76. 	RCC_APB2PeriphClockCmd(LD3320SPI_CLK,ENABLE);		
  77.   RCC_APB2PeriphClockCmd(LD3320WR_GPIO_CLK | LD3320SPIMISO_GPIO_CLK | LD3320SPIMOSI_GPIO_CLK | LD3320SPISCK_GPIO_CLK,ENABLE);
  78. 	
  79. 	GPIO_InitStructure.GPIO_Pin = LD3320SPIMISO_PIN;
  80. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  81. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  82. 	GPIO_Init(LD3320SPIMISO_GPIO_PORT,&GPIO_InitStructure);
  83. 	
  84. 	GPIO_InitStructure.GPIO_Pin = LD3320SPIMOSI_PIN;
  85. 	GPIO_Init(LD3320SPIMOSI_GPIO_PORT,&GPIO_InitStructure);
  86.  
  87. 	GPIO_InitStructure.GPIO_Pin = LD3320SPISCK_PIN;
  88. 	GPIO_Init(LD3320SPISCK_GPIO_PORT,&GPIO_InitStructure);
  89. 	
  90. 	GPIO_InitStructure.GPIO_Pin = LD3320WR_PIN;				
  91. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  92. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  93. 	GPIO_Init(LD3320WR_GPIO_PORT, &GPIO_InitStructure);
  94. 	
  95. 	LD_CS_H();
  96. 	
  97. 	SPI_Cmd(LD3320SPI, DISABLE);
  98.  
  99. 	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;   	//全双工
  100. 	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;						   						//主模式
  101. 	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;					   					//8位
  102. 	SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;						   							//时钟极性 空闲状态时，SCK保持低电平
  103. 	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;						   						//时钟相位 数据采样从第一个时钟边沿开始
  104. 	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;							   							//软件产生NSS
  105. 	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;   //波特率控制 SYSCLK/128
  106. 	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;				   					//数据高位在前
  107. 	SPI_InitStructure.SPI_CRCPolynomial = 7;							   							//CRC多项式寄存器初始值为7
  108. 	SPI_Init(LD3320SPI, &SPI_InitStructure);
  109.  
  110. 	SPI_Cmd(LD3320SPI, ENABLE);
  111. }
  112.  
  113. ///中间层
  114. void EXTI15_10_IRQHandler(void)
  115. {
  116. 	if(EXTI_GetITStatus(LD3320IRQEXITLINE)!= RESET ) 
  117. 	{
  118. 		ProcessInt(); 
  119. 	
  120. 		EXTI_ClearFlag(LD3320IRQEXITLINE);
  121. 		EXTI_ClearITPendingBit(LD3320IRQEXITLINE);//清除LINE上的中断标志位  
  122. 	} 
  123. }
  124. static void LD3320_delay(unsigned long uldata)
  125. {
  126. 	unsigned int i  =  0;
  127. 	unsigned int j  =  0;
  128. 	unsigned int k  =  0;
  129. 	for (i=0;i<5;i++)
  130. 	{
  131. 		for (j=0;j<uldata;j++)
  132. 		{
  133. 			k = 200;
  134. 			while(k--);
  135. 		}
  136. 	}
  137. }
  138. uint8_t RunASR(void)
  139. {
  140. 	uint8_t i=0;
  141. 	uint8_t asrflag=0;
  142. 	for (i=0; i<5; i++)		//防止由于硬件原因导致LD3320芯片工作不正常，所以一共尝试5次启动ASR识别流程
  143. 	{
  144. 		LD_AsrStart();			//初始化ASR
  145. 		LD3320_delay(100);
  146. 		if (LD_AsrAddFixed()==0)	//添加关键词语到LD3320芯片中
  147. 		{
  148. 			LD_reset();				//LD3320芯片内部出现不正常，立即重启LD3320芯片
  149. 			LD3320_delay(50);	//并从初始化开始重新ASR识别流程
  150. 			continue;
  151. 		}
  152. 		LD3320_delay(10);
  153. 		if (LD_AsrRun() == 0)
  154. 		{
  155. 			LD_reset();			 //LD3320芯片内部出现不正常，立即重启LD3320芯片
  156. 			LD3320_delay(50);//并从初始化开始重新ASR识别流程
  157. 			continue;
  158. 		}
  159. 		asrflag=1;
  160. 		break;						//ASR流程启动成功，退出当前for循环。开始等待LD3320送出的中断信号
  161. 	}	
  162. 	return asrflag;
  163. }
  164.  
  165. void LD_reset(void)
  166. {
  167. 	uint8_t i;
  168. 	LD_RST_H();
  169. 	LD3320_delay(100);
  170. 	LD_RST_L();
  171. 	LD3320_delay(100);
  172. 	LD_RST_H();
  173. 	LD3320_delay(100);
  174. 	LD_CS_L();
  175. 	LD3320_delay(100);
  176. 	LD_CS_H();		
  177. 	LD3320_delay(100);
  178. 	
  179. 	i=LD_ReadReg(0x6);
  180. 	LD_WriteReg(0x35, 0x33);
  181. 	LD_WriteReg(0x1b, 0x55);
  182. 	LD_WriteReg(0xb3, 0xaa);
  183. 	i=LD_ReadReg(0x35);
  184. 	i=LD_ReadReg(0x1b);
  185. 	i=LD_ReadReg(0xb3);
  186. 	i=i;
  187. 	LD_RST_H();
  188. 	LD3320_delay(100);
  189. 	LD_RST_L();
  190. 	LD3320_delay(100);
  191. 	LD_RST_H();
  192. 	LD3320_delay(100);
  193. 	LD_CS_L();
  194. 	LD3320_delay(100);
  195. 	LD_CS_H();		
  196. 	i=LD_ReadReg(0x6);
  197. 	LD3320_delay(100);
  198. 	i=LD_ReadReg(0x35);
  199. 	i=LD_ReadReg(0x1b);
  200. 	i=LD_ReadReg(0xb3);
  201. 	i=i;
  202. }
  203. void LD_AsrStart(void)
  204. {
  205. 	LD_Init_ASR();
  206. }
  207.  
  208. uint8_t LD_Check_ASRBusyFlag_b2(void)
  209. {
  210. 	uint8_t j;
  211. 	uint8_t flag = 0;
  212. 	for (j=0; j<10; j++)
  213. 	{
  214. 		if (LD_ReadReg(0xb2) == 0x21)
  215. 		{
  216. 			flag = 1;
  217. 			break;
  218. 		}
  219. 		LD3320_delay(10);		
  220. 	}
  221. 	return flag;
  222. }
  223.  
  224.  
  225. ///寄存器操作
  226. uint8_t spi_send_byte(uint8_t byte)
  227. {
  228. 	while (SPI_I2S_GetFlagStatus(LD3320SPI, SPI_I2S_FLAG_TXE) == RESET);
  229. 	SPI_I2S_SendData(LD3320SPI,byte);
  230. 	while (SPI_I2S_GetFlagStatus(LD3320SPI,SPI_I2S_FLAG_RXNE) == RESET);
  231. 	return SPI_I2S_ReceiveData(LD3320SPI);
  232. }
  233.  
  234. void LD_WriteReg(uint8_t data1,uint8_t data2)
  235. {
  236. 	LD_CS_L();
  237. 	LD_SPIS_L();
  238. 	spi_send_byte(0x04);
  239. 	spi_send_byte(data1);
  240. 	spi_send_byte(data2);
  241. 	LD_CS_H();
  242. }
  243.  
  244. uint8_t LD_ReadReg(uint8_t reg_add)
  245. {
  246. 	uint8_t i;
  247. 	LD_CS_L();
  248. 	LD_SPIS_L();
  249. 	spi_send_byte(0x05);
  250. 	spi_send_byte(reg_add);
  251. 	i=spi_send_byte(0x00);
  252. 	LD_CS_H();
  253. 	return(i);
  254. }
  255.  
  256. uint8_t LD_GetResult(void)
  257. {
  258. 	return LD_ReadReg(0xc5);
  259. }
  260.  
  261. uint8_t LD_AsrRun(void)
  262. {
  263. 	LD_WriteReg(0x35, MIC_VOL);
  264. 	LD_WriteReg(0x1C, 0x09);
  265. 	LD_WriteReg(0xBD, 0x20);
  266. 	LD_WriteReg(0x08, 0x01);
  267. 	LD3320_delay( 5 );
  268. 	LD_WriteReg(0x08, 0x00);
  269. 	LD3320_delay( 5);
  270.  
  271. 	if(LD_Check_ASRBusyFlag_b2() == 0)
  272. 	{
  273. 		return 0;
  274. 	}
  275.  
  276. 	LD_WriteReg(0xB2, 0xff);	
  277. 	LD_WriteReg(0x37, 0x06);
  278. 	LD_WriteReg(0x37, 0x06);
  279. 	LD3320_delay(5);
  280. 	LD_WriteReg(0x1C, 0x0b);
  281. 	LD_WriteReg(0x29, 0x10);
  282. 	LD_WriteReg(0xBD, 0x00);   
  283. 	return 1;
  284. }
  285. void ProcessInt(void)
  286. {
  287. 	uint8_t nAsrResCount=0;
  288.  
  289. 	ucRegVal = LD_ReadReg(0x2B);
  290.  
  291. // 语音识别产生的中断
  292. //（有声音输入，不论识别成功或失败都有中断）
  293. 	LD_WriteReg(0x29,0) ;
  294. 	LD_WriteReg(0x02,0) ;
  295.  
  296. 	if((ucRegVal & 0x10) && LD_ReadReg(0xb2)==0x21 && LD_ReadReg(0xbf)==0x35)		
  297. 	{	 
  298. 			nAsrResCount = LD_ReadReg(0xba);
  299.  
  300. 			if(nAsrResCount>0 && nAsrResCount<=4) 
  301. 			{
  302. 				nAsrStatus=LD_ASR_FOUNDOK; 				
  303. 			}
  304. 			else
  305. 			{
  306. 				nAsrStatus=LD_ASR_FOUNDZERO;
  307. 			}	
  308. 	}
  309. 	else
  310. 	{
  311. 		nAsrStatus=LD_ASR_FOUNDZERO;//执行没有识别
  312. 	}
  313.  
  314. 	LD_WriteReg(0x2b,0);
  315. 	LD_WriteReg(0x1C,0);//写0:ADC不可用
  316. 	LD_WriteReg(0x29,0);
  317. 	LD_WriteReg(0x02,0);
  318. 	LD_WriteReg(0x2B,0);
  319. 	LD_WriteReg(0xBA,0);	
  320. 	LD_WriteReg(0xBC,0);	
  321. 	LD_WriteReg(0x08,1);//清除FIFO_DATA
  322. 	LD_WriteReg(0x08,0);//清除FIFO_DATA后 再次写0
  323. }
  324.  
  325. void LD_Init_Common(void)
  326. {
  327. 	LD_ReadReg(0x06);  
  328. 	LD_WriteReg(0x17, 0x35); 
  329. 	LD3320_delay(5);
  330. 	LD_ReadReg(0x06);  
  331.  
  332. 	LD_WriteReg(0x89, 0x03);  
  333. 	LD3320_delay(5);
  334. 	LD_WriteReg(0xCF, 0x43);   
  335. 	LD3320_delay(5);
  336. 	LD_WriteReg(0xCB, 0x02);
  337. 	
  338. 	/*PLL setting*/
  339. 	LD_WriteReg(0x11, LD_PLL_11);       
  340. 	if (nLD_Mode == LD_MODE_MP3)
  341. 	{
  342. 		LD_WriteReg(0x1E, 0x00); 
  343. 		LD_WriteReg(0x19, LD_PLL_MP3_19);   
  344. 		LD_WriteReg(0x1B, LD_PLL_MP3_1B);   
  345. 		LD_WriteReg(0x1D, LD_PLL_MP3_1D);
  346. 	}
  347. 	else
  348. 	{
  349. 		LD_WriteReg(0x1E,0x00);
  350. 		LD_WriteReg(0x19, LD_PLL_ASR_19); 
  351. 		LD_WriteReg(0x1B, LD_PLL_ASR_1B);		
  352. 	  LD_WriteReg(0x1D, LD_PLL_ASR_1D);
  353. 	}
  354. 	LD3320_delay(5);
  355. 	
  356. 	LD_WriteReg(0xCD, 0x04);
  357. 	LD_WriteReg(0x17, 0x4c); 
  358. 	LD3320_delay(1);
  359. 	LD_WriteReg(0xB9, 0x00);
  360. 	LD_WriteReg(0xCF, 0x4F); 
  361. 	LD_WriteReg(0x6F, 0xFF); 
  362. }
  363.  
  364. void LD_Init_ASR(void)
  365. {
  366. 	nLD_Mode=LD_MODE_ASR_RUN;
  367. 	LD_Init_Common();
  368.  
  369. 	LD_WriteReg(0xBD, 0x00);
  370. 	LD_WriteReg(0x17, 0x48);	
  371. 	LD3320_delay(5);
  372. 	LD_WriteReg(0x3C, 0x80);    
  373. 	LD_WriteReg(0x3E, 0x07);
  374. 	LD_WriteReg(0x38, 0xff);    
  375. 	LD_WriteReg(0x3A, 0x07);
  376. 	LD_WriteReg(0x40, 0);          
  377. 	LD_WriteReg(0x42, 8);
  378. 	LD_WriteReg(0x44, 0);    
  379. 	LD_WriteReg(0x46, 8); 
  380. 	LD3320_delay( 1 );
  381. }
  382.  
  383. ///相关初始化
  384. void LD3320_init(void)
  385. {
  386. 	LD3320_GPIO_Cfg();	
  387. 	LD3320_EXTI_Cfg();
  388. 	LD3320_SPI_cfg();
  389. 	LD_reset();
  390. }
  391. static uint8_t LD_AsrAddFixed(void)
  392. {
  393. 	uint8_t k, flag;
  394. 	uint8_t nAsrAddLength;
  395. 	#define DATE_A 20    //数组二维数值
  396. 	#define DATE_B 50		//数组一维数值
  397. 	//添加关键词，用户修改
  398. 	uint8_t  sRecog[DATE_A][DATE_B] = {
  399. 	 			"xiao die xiao die",\
  400. 				"ni jiao shen me",\
  401. 				"ni shi shei",\
  402. 				"da kai hong deng",\
  403. 				"da kai lv deng",\
  404. 				"da kai lan deng",\
  405. 				"guan bi hong deng",\
  406. 				"guan bi lv deng",\
  407. 				"guan bi lan deng",\
  408. 				"chen meng die shi shei",\
  409. 				"chen xiang xin shi shei",\
  410. 				"yin liang ti gao",\
  411. 				"yin liang jiang da",\
  412. 				"guan bi suo you deng" \
  413. 		
  414. 		
  415. 																	};	
  416. 	uint8_t  pCode[DATE_A] = {
  417. 	 															CODE_LSD,	\
  418. 																CODE_SS,	\
  419. 																CODE_SS,	\
  420. 																LDE_1,   \
  421. 																LDE_2,	\
  422. 																LDE_3,		\
  423. 																LDE_1_1,   \
  424. 																LDE_2_1,	\
  425. 																LDE_3_1,		\
  426. 																chen,		\
  427. 																chen_1,		\
  428. 																voice_J_0,		\
  429. 																voice_J_1,		\
  430. 																LDE_All_OFF		\
  431. 															};	//添加识别码，用户修改
  432. 	flag = 1;
  433. 	for (k=0; k<DATE_A; k++)
  434. 	{			
  435. 		if(LD_Check_ASRBusyFlag_b2() == 0)
  436. 		{
  437. 			flag = 0;
  438. 			break;
  439. 		}
  440.  
  441. 		LD_WriteReg(0xc1, pCode[k] );
  442. 		LD_WriteReg(0xc3, 0);
  443. 		LD_WriteReg(0x08, 0x04);
  444. 		LD3320_delay(1);
  445. 		LD_WriteReg(0x08, 0x00);
  446. 		LD3320_delay(1);
  447.  
  448. 		for (nAsrAddLength=0; nAsrAddLength<DATE_B; nAsrAddLength++)
  449. 		{
  450. 			if (sRecog[k][nAsrAddLength] == 0)
  451. 				break;
  452. 			LD_WriteReg(0x5, sRecog[k][nAsrAddLength]);
  453. 		}
  454. 		LD_WriteReg(0xb9, nAsrAddLength);
  455. 		LD_WriteReg(0xb2, 0xff);
  456. 		LD_WriteReg(0x37, 0x04);
  457. 	}	 
  458. 	return flag;
  459. }
  460.  
  461.  
  462. 用户修改
  463. //void LD3320_main(void)
  464. //{
  465. //	uint8_t nAsrRes=0;
  466. //	  
  467. // 	printf("1、流水灯\r\n"); 
  468. //	printf("2、闪烁\r\n"); 				
  469. //	printf("3、按键触发\r\n"); 		
  470. //	printf("4、全灭\r\n"); 			
  471. //	printf("5、状态\r\n"); 		
  472. //	nAsrStatus = LD_ASR_NONE;//初始状态：没有在作ASR
  473.  
  474. //	while(1)
  475. //	{
  476. //		switch(nAsrStatus)
  477. //		{
  478. //			case LD_ASR_RUNING:
  479. //				
  480. //			case LD_ASR_ERROR:		
  481. //					break;
  482. //			case LD_ASR_NONE:
  483. //					nAsrStatus=LD_ASR_RUNING;
  484. //					if (RunASR()==0)//启动一次ASR识别流程：ASR初始化，ASR添加关键词语，启动ASR运算
  485. //					{		
  486. //						nAsrStatus = LD_ASR_ERROR;
  487. //					}
  488. //					break;
  489. //			case LD_ASR_FOUNDOK:
  490. //					 nAsrRes = LD_GetResult( );//一次ASR识别流程结束，去取ASR识别结果										 
  491. //					 printf("\r\n识别码:%d", nAsrRes);			 		
  492. //								
  493. //					 switch(nAsrRes)		   			//对结果执行相关操作,客户修改
  494. //						{
  495. //							case CODE_LSD:					//命令“流水灯”
  496. //							{
  497. //									printf(" 流水灯 指令识别成功\r\n"); 
  498. //							    SYN6288_Speech(DEBUG_USARTx,"现在展示流水灯");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  499. //									Delay_ms(500);
  500. //															 break;
  501. //							}
  502. //							case CODE_SS:	 					//命令“闪烁”
  503. //							{
  504. //								printf(" 闪烁 指令识别成功\r\n"); 
  505. //								 SYN6288_Speech(DEBUG_USARTx,"现在展示闪烁");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  506. //									Delay_ms(500);
  507. //															 break;
  508. //							}
  509. //							case CODE_AJCF:					//命令“按键触发”
  510. //							{
  511. //								printf(" 按键触发 指令识别成功\r\n"); 
  512. //								 SYN6288_Speech(DEBUG_USARTx,"按键触发");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  513. //									Delay_ms(500);
  514. //															break;
  515. //							}
  516. //							
  517. //							case CODE_QM:						//命令“全灭”
  518. //							{
  519. //								printf(" 全灭 指令识别成功\r\n");
  520. //								 SYN6288_Speech(DEBUG_USARTx,"全灭 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  521. //									Delay_ms(500);
  522. //															break;
  523. //							}
  524. //							case CODE_ZT:						//命令“状态”
  525. //							{
  526. //								printf(" 状态 指令识别成功\r\n");
  527. //								 SYN6288_Speech(DEBUG_USARTx,"状态 指令识别成功");  /*播放声音,播放声音时候LED会灭掉，就是BY接口用来检测是否繁忙的*/
  528. //									Delay_ms(500);
  529. //							}							
  530. //							default:break;
  531. //						}	
  532. //					nAsrStatus = LD_ASR_NONE;
  533. //					break;
  534. //			case LD_ASR_FOUNDZERO:
  535. //			default:
  536. //					nAsrStatus = LD_ASR_NONE;
  537. //					break;
  538. //			}//switch
  539. //		//开发板测试
  540. //		Board_text(nAsrRes );
  541. //	}// while
  542. //}

参考

STM32F103C8T6＋LD3320语音识别模块智能灯控icon-default.png?t=N7T8https://blog.csdn.net/weixin_53129688/article/details/127982201?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522170212843516800222862352%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=170212843516800222862352&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~top_click~default-2-127982201-null-null.nonecase&utm_term=ld3320&spm=1018.2226.3001.4450

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/374771
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号