一、原理图



二、源代码
LD3320.c

1. #include "ld3320.h"
   
2. #include "delay.h"
   
3. #include "usart.h"        
   
4. #include "string.h"
   
5. u8 ld3320Data;
   
6. extern u8 nAsrStatus;
   
7. 
   
8. unsigned long nMp3StartPos=0;
   
9. unsigned long nMp3Size=0;
   
10. unsigned long nMp3Pos=0;
    
11. u8 bMp3Play=0;                                                        //        用来记录播放MP3的状态
    
12. u8 nLD_Mode = LD_MODE_IDLE;                //        用来记录当前是在进行ASR识别还是在播放MP3
    
13. u8 ucRegVal;
    
14. u8 ucHighInt;
    
15. u8 ucLowInt;
    
16. u8 ucStatus;
    
17. u8 ucSPVol=15; // MAX=15 MIN=0                //        Speaker喇叭输出的音量
    
18. 
    
19. 
    
20. 
    
21. void ld3320_init()
    
22. {
    
23.         GPIO_InitTypeDef  GPIO_InitStructure;
    
24.          EXTI_InitTypeDef EXTI_InitStructure;
    
25.          NVIC_InitTypeDef NVIC_InitStructure;
    
26. 
    
27.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE);         //使能PB,PE端口时钟
    
28.         
    
29.         GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);
    
30.         
    
31.         
    
32.         GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_15;                                 
    
33.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  
    
34.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 
    
35.         GPIO_Init(GPIOA, &GPIO_InitStructure);                                       
    
36.         GPIO_SetBits(GPIOA,GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_15);
    
37.         
    
38.         GPIO_InitStructure.GPIO_Pin =GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15 ;                                 
    
39.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  
    
40.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 
    
41.         GPIO_Init(GPIOB, &GPIO_InitStructure);                                       
    
42.         GPIO_SetBits(GPIOB,GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_14|GPIO_Pin_15);
    
43.                
    
44.         
    
45.         LD3320_MD=0;  //选择并口
    
46.         LD3320_RST=1;        
    
47.         LD3320_A0=0;
    
48.         
    
49.         
    
50.         GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11;                                 
    
51.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                  
    
52.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 
    
53.         GPIO_Init(GPIOB, &GPIO_InitStructure);               
    
54. 
    
55.           RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);        //使能复用功能时钟
    
56. 
    
57.     // 中断线以及中断初始化配置   下降沿触发
    
58.           GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource11);
    
59. 
    
60.           EXTI_InitStructure.EXTI_Line=EXTI_Line11;        
    
61.           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;        
    
62.           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    
63.           EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    
64.           EXTI_Init(&EXTI_InitStructure);                 //根据EXTI_InitStruct中指定的参数初始化外设EXTI寄存器
    
65.         
    
66.         NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;                        //使能外部中断通道
    
67.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;        //抢占优先级0
    
68.           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;                                        //子优先级0
    
69.           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                                                                //使能外部中断通道
    
70.           NVIC_Init(&NVIC_InitStructure);            //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器        
    
71. 
    
72. }
    
73. 
    
74. //外部中断服务程序
    
75. void EXTI15_10_IRQHandler(void)
    
76. {
    
77.         if(EXTI_GetITStatus(EXTI_Line11)!= RESET )
    
78.         {
    
79.                 ld3320_process_init();               
    
80.                 EXTI_ClearFlag(EXTI_Line11);
    
81.                 EXTI_ClearITPendingBit(EXTI_Line11);//清除LINE上的中断标志位  
    
82.         }         
    
83. }
    
84. 
    
85. 
    
86. void ld3320_write_reg( unsigned char address, unsigned char dataout )
    
87. {
    
88.         
    
89.         ld3320Data=address;
    
90.         LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
    
91.         LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
    
92.         delay_us(1);
    
93.         LD3320_A0  =1;
    
94.         LD3320_CS = 0;
    
95.         LD3320_WR = 0;
    
96. 
    
97.         LD3320_WR = 1;
    
98.         LD3320_CS = 1;
    
99.         
    
100. 
     
101.         
     
102.         ld3320Data=dataout;
     
103.         LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
     
104.         LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
     
105.         delay_us(1);
     
106.         LD3320_A0 = 0;
     
107.         LD3320_CS = 0;
     
108.         LD3320_WR = 0;
     
109. 
     
110.         LD3320_WR = 1;
     
111.         LD3320_CS = 1;
     
112. }
     
113. 
     
114. unsigned char ld3320_read_reg( unsigned char address )
     
115. {
     
116.         unsigned char datain;
     
117. 
     
118.         ld3320Data=address;
     
119.         LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
     
120.         LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
     
121.         
     
122.         LD3320_A0 = 1;
     
123.         delay_us(1);
     
124.         LD3320_CS = 0;
     
125.         delay_us(1);
     
126.         LD3320_WR = 0;
     
127.         delay_us(1);
     
128. 
     
129.         LD3320_WR = 1;
     
130.         delay_us(1);
     
131.         LD3320_CS = 1;
     
132.         delay_us(1);
     
133. 
     
134.         LD3320_A0 = 0;
     
135.         delay_us(1);
     
136.         LD3320_CS = 0;
     
137.         delay_us(1);
     
138.         LD3320_RD = 0;
     
139.         LD3320_DATA_IN();
     
140.         delay_us(1);
     
141.         
     
142.         bita0=LD3320_D0_R;bita1=LD3320_D1_R;bita2=LD3320_D2_R;bita3=LD3320_D3_R;
     
143.         bita4=LD3320_D4_R;bita5=LD3320_D5_R; bita6=LD3320_D6_R;bita7=LD3320_D7_R;
     
144.         datain= ld3320Data;
     
145.         
     
146.         LD3320_DATA_OUT();
     
147.         LD3320_RD = 1;
     
148.         delay_us(1);
     
149.         LD3320_CS = 1;
     
150. 
     
151.         return datain;
     
152. }
     
153. 
     
154. 
     
155. void ld3320_reset()
     
156. {
     
157.         LD3320_RST=1;
     
158.         delay_ms(1);
     
159.         LD3320_RST=0;
     
160.         delay_ms(1);
     
161.         LD3320_RST=1;
     
162. 
     
163.         delay_ms(1);
     
164.         LD3320_CS=0;
     
165.         delay_ms(1);
     
166.         LD3320_CS=1;
     
167.         delay_ms(1);
     
168. }
     
169. u8 ld3320_check()
     
170. {
     
171.         u8 a[3];
     
172.         memset(a,0x00,sizeof(a));
     
173.         ld3320_reset();
     
174.         delay_ms(1);
     
175.         ld3320_read_reg(0x06);  
     
176.         delay_ms(1);
     
177.         ld3320_write_reg(0x35, 0x33);  
     
178.         delay_ms(1);
     
179.         ld3320_write_reg(0x1b, 0x55);   
     
180.         delay_ms(1);
     
181.         ld3320_write_reg(0xb3, 0xaa);        
     
182.         
     
183.         a[0]=ld3320_read_reg(0x35);
     
184.         delay_ms(5);
     
185.                
     
186.         a[1]=ld3320_read_reg(0x1b);
     
187.         delay_ms(5);
     
188.         a[2]=ld3320_read_reg(0xb3);
     
189. 
     
190.         if(a[0]!=0x33||a[1]!=0x55||a[2]!=0xaa)
     
191.                 return 1;
     
192.         return 0;
     
193.         
     
194. }
     
195. 
     
196. 
     
197. 
     
198. void ld3320_init_common()
     
199. {
     
200.         bMp3Play = 0;
     
201. 
     
202.         ld3320_read_reg(0x06);  
     
203.         ld3320_write_reg(0x17, 0x35);
     
204.         delay_ms(10);
     
205.         ld3320_read_reg(0x06);  
     
206. 
     
207.         ld3320_write_reg(0x89, 0x03);  
     
208.         delay_ms(5);
     
209.         ld3320_write_reg(0xCF, 0x43);   
     
210.         delay_ms(5);
     
211.         ld3320_write_reg(0xCB, 0x02);
     
212.         
     
213.         /*PLL setting*/
     
214.         ld3320_write_reg(0x11, LD_PLL_11);      
     
215.         if (nLD_Mode == LD_MODE_MP3)
     
216.         {
     
217.                 ld3320_write_reg(0x1E, 0x00);
     
218.                 ld3320_write_reg(0x19, LD_PLL_MP3_19);   
     
219.                 ld3320_write_reg(0x1B, LD_PLL_MP3_1B);   
     
220.                 ld3320_write_reg(0x1D, LD_PLL_MP3_1D);
     
221.         }
     
222.         else
     
223.         {
     
224.                 ld3320_write_reg(0x1E,0x00);
     
225.                 ld3320_write_reg(0x19, LD_PLL_ASR_19);
     
226.                 ld3320_write_reg(0x1B, LD_PLL_ASR_1B);               
     
227.             ld3320_write_reg(0x1D, LD_PLL_ASR_1D);
     
228.         }
     
229.         delay_ms(10);
     
230.         
     
231.         ld3320_write_reg(0xCD, 0x04);
     
232.         ld3320_write_reg(0x17, 0x4c);
     
233.         delay_ms(5);
     
234.         ld3320_write_reg(0xB9, 0x00);
     
235.         ld3320_write_reg(0xCF, 0x4F);
     
236.         ld3320_write_reg(0x6F, 0xFF);
     
237. }
     
238. 
     
239. void ld3320_init_mp3()
     
240. {
     
241.         nLD_Mode = LD_MODE_MP3;
     
242.         ld3320_init_common();
     
243. 
     
244.         ld3320_write_reg(0xBD,0x02);
     
245.         ld3320_write_reg(0x17, 0x48);
     
246.         delay_ms(10);
     
247. 
     
248.         ld3320_write_reg(0x85, 0x52);
     
249.         ld3320_write_reg(0x8F, 0x00);  
     
250.         ld3320_write_reg(0x81, 0x00);
     
251.         ld3320_write_reg(0x83, 0x00);
     
252.         ld3320_write_reg(0x8E, 0xff);
     
253.         ld3320_write_reg(0x8D, 0xff);
     
254.     delay_ms(1);
     
255.         ld3320_write_reg(0x87, 0xff);
     
256.         ld3320_write_reg(0x89, 0xff);
     
257.         delay_ms(1);
     
258.         ld3320_write_reg(0x22, 0x00);   
     
259.         ld3320_write_reg(0x23, 0x00);
     
260.         ld3320_write_reg(0x20, 0xef);   
     
261.         ld3320_write_reg(0x21, 0x07);
     
262.         ld3320_write_reg(0x24, 0x77);         
     
263.     ld3320_write_reg(0x25, 0x03);
     
264.     ld3320_write_reg(0x26, 0xbb);   
     
265.     ld3320_write_reg(0x27, 0x01);
     
266. }
     
267. 
     
268. 
     
269. 
     
270. void ld3320_init_asr()
     
271. {
     
272.         nLD_Mode=LD_MODE_ASR_RUN;
     
273.         ld3320_init_common();
     
274. 
     
275.         ld3320_write_reg(0xBD, 0x00);
     
276.         ld3320_write_reg(0x17, 0x48);
     
277.         delay_ms(10);
     
278. 
     
279.         ld3320_write_reg(0x3C, 0x80);   
     
280.         ld3320_write_reg(0x3E, 0x07);
     
281.         ld3320_write_reg(0x38, 0xff);   
     
282.         ld3320_write_reg(0x3A, 0x07);
     
283.         
     
284.         ld3320_write_reg(0x40, 0);         
     
285.         ld3320_write_reg(0x42, 8);
     
286.         ld3320_write_reg(0x44, 0);   
     
287.         ld3320_write_reg(0x46, 8);
     
288.         delay_ms(10);
     
289. }
     
290. 
     
291. void ld3320_reload_mp3data()
     
292. {
     
293.         unsigned long nCurMp3Pos;
     
294.         u8 val;
     
295.         u8 k;
     
296. 
     
297.         nCurMp3Pos = nMp3StartPos + nMp3Pos;
     
298. 
     
299.         ucStatus = ld3320_read_reg(0x06);
     
300.         while ( !(ucStatus&MASK_FIFO_STATUS_AFULL) && (nMp3Pos<nMp3Size) )
     
301.         {
     
302.                 val=0;
     
303.                 for(k=0;k<8;k++)
     
304.                 {
     
305.                 }
     
306.                 ld3320_write_reg(0x01,val);
     
307. 
     
308.                 nMp3Pos++;
     
309. 
     
310.                 ucStatus = ld3320_read_reg(0x06);
     
311.         }
     
312. }
     
313. 
     
314. 
     
315. void ld3320_reload_mp3data_2()
     
316. {
     
317.         unsigned long nCurMp3Pos;
     
318.         u8 val;
     
319.         u8 k;
     
320. 
     
321.         nCurMp3Pos = nMp3StartPos + nMp3Pos;
     
322. 
     
323. 
     
324.         //读取音乐文件写入
     
325.         
     
326.         
     
327. 
     
328.         ucStatus = ld3320_read_reg(0x06);
     
329.         while ( !(ucStatus&MASK_FIFO_STATUS_AFULL) && (nMp3Pos<nMp3Size) )
     
330.         {
     
331.                 val=0;
     
332. 
     
333. 
     
334.                 nMp3Pos++;
     
335. 
     
336.                 ucStatus = ld3320_read_reg(0x06);
     
337.         }
     
338. }
     
339. 
     
340. 
     
341. 
     
342. 
     
343. void ld3320_process_init()
     
344. {
     
345.         u8 nAsrResCount=0;
     
346.         
     
347.         ucRegVal = ld3320_read_reg(0x2B);
     
348.         if(nLD_Mode == LD_MODE_ASR_RUN)
     
349.         {
     
350.                 // 语音识别产生的中断
     
351.                 // （有声音输入，不论识别成功或失败都有中断）
     
352.                 ld3320_write_reg(0x29,0) ;
     
353.                 ld3320_write_reg(0x02,0) ;
     
354.                 if((ucRegVal & 0x10) &&
     
355.                         ld3320_read_reg(0xb2)==0x21 &&
     
356.                         ld3320_read_reg(0xbf)==0x35)
     
357.                 {
     
358.                         nAsrResCount = ld3320_read_reg(0xba);
     
359.                         if(nAsrResCount>0 && nAsrResCount<=4)
     
360.                         {
     
361.                                 nAsrStatus=LD_ASR_FOUNDOK;
     
362.                         }
     
363.                         else
     
364.                     {
     
365.                                 nAsrStatus=LD_ASR_FOUNDZERO;
     
366.                         }        
     
367.                 }
     
368.                 else
     
369.                 {
     
370.                         nAsrStatus=LD_ASR_FOUNDZERO;
     
371.                 }
     
372.                         
     
373.                 ld3320_write_reg(0x2b, 0);
     
374.             ld3320_write_reg(0x1C,0);
     
375.                 return;
     
376.         }
     
377.         
     
378.         // 声音播放产生的中断，有三种：
     
379.         // A. 声音数据已全部播放完。
     
380.         // B. 声音数据已发送完毕。
     
381.         // C. 声音数据暂时将要用完，需要放入新的数据。        
     
382.         ucHighInt = ld3320_read_reg(0x29);
     
383.         ucLowInt=ld3320_read_reg(0x02);
     
384.         ld3320_write_reg(0x29,0) ;
     
385.         ld3320_write_reg(0x02,0) ;
     
386.     if(ld3320_read_reg(0xBA)&CAUSE_MP3_SONG_END)
     
387.     {
     
388.         // A. 声音数据已全部播放完。
     
389. 
     
390.                 ld3320_write_reg(0x2B,  0);
     
391.               ld3320_write_reg(0xBA, 0);        
     
392.                 ld3320_write_reg(0xBC,0x0);        
     
393.                 bMp3Play=0;                                        // 声音数据全部播放完后，修改bMp3Play的变量
     
394.                 ld3320_write_reg(0x08,1);
     
395.                 delay_ms(5);
     
396.               ld3320_write_reg(0x08,0);
     
397.                 ld3320_write_reg(0x33, 0);
     
398. 
     
399.                 return ;
     
400.      }
     
401. 
     
402.          if(nMp3Pos>=nMp3Size)
     
403.         {
     
404.         // B. 声音数据已发送完毕。
     
405. 
     
406.                 ld3320_write_reg(0xBC, 0x01);
     
407.                 ld3320_write_reg(0x29, 0x10);
     
408. //                bMp3Play=0;                                //        此时，只是主控MCU把所有MP3数据发送到LD3320芯片内，但是还没有把送入的数据全部播放完毕
     
409.                 return;        
     
410.         }
     
411. 
     
412.         // C. 声音数据暂时将要用完，需要放入新的数据。        
     
413. 
     
414.         ld3320_reload_mp3data_2();
     
415.                
     
416.         ld3320_write_reg(0x29,ucHighInt);
     
417.         ld3320_write_reg(0x02,ucLowInt) ;
     
418. }
     
419. void ld3320_play()
     
420. {
     
421.         nMp3Pos=0;
     
422.         bMp3Play=1;
     
423. 
     
424.         if (nMp3Pos >=  nMp3Size)
     
425.                 return ;
     
426. 
     
427.         ld3320_reload_mp3data();
     
428. 
     
429.     ld3320_write_reg(0xBA, 0x00);
     
430.         ld3320_write_reg(0x17, 0x48);
     
431.         ld3320_write_reg(0x33, 0x01);
     
432.         ld3320_write_reg(0x29, 0x04);
     
433.         
     
434.         ld3320_write_reg(0x02, 0x01);
     
435.         ld3320_write_reg(0x85, 0x5A);
     
436. }
     
437. 
     
438. void ld3320_adjust_volume(u8 val)
     
439. {
     
440.         ucSPVol = val;
     
441.         val = ((15-val)&0x0f) << 2;
     
442.         ld3320_write_reg(0x8E, val | 0xc3);
     
443.         ld3320_write_reg(0x87, 0x78);
     
444. }
     
445. // Return 1: success.
     
446. u8 ld3320_check_asrbusyflag_b2()
     
447. {
     
448.         u8 j;
     
449.         u8 flag = 0;
     
450.         for (j=0; j<10; j++)
     
451.         {
     
452.                 if (ld3320_read_reg(0xb2) == 0x21)
     
453.                 {
     
454.                         flag = 1;
     
455.                         break;
     
456.                 }
     
457.                 delay_ms(10);               
     
458.         }
     
459.         return flag;
     
460. }
     
461. 
     
462. void LD_AsrStart()
     
463. {
     
464.         ld3320_init_asr();
     
465. }
     
466. 
     
467. // Return 1: success.
     
468. u8 ld3320_asrun()
     
469. {
     
470.         ld3320_write_reg(0x35, MIC_VOL);
     
471.         ld3320_write_reg(0x1C, 0x09);
     
472.         ld3320_write_reg(0xBD, 0x20);
     
473.         ld3320_write_reg(0x08, 0x01);
     
474.         delay_ms( 1 );
     
475.         ld3320_write_reg(0x08, 0x00);
     
476.         delay_ms( 1 );
     
477. 
     
478.         if(ld3320_check_asrbusyflag_b2() == 0)
     
479.         {
     
480.                 return 0;
     
481.         }
     
482. 
     
483.         ld3320_write_reg(0xB2, 0xff);        
     
484.         ld3320_write_reg(0x37, 0x06);
     
485.         delay_ms( 10 );
     
486.         ld3320_write_reg(0x1C, 0x0b);
     
487.         ld3320_write_reg(0x29, 0x10);
     
488.         
     
489.         ld3320_write_reg(0xBD, 0x00);
     
490.         return 1;
     
491. }
     
492. 
     
493. // Return 1: success.
     
494. //        添加识别关键词语，开发者可以学习"语音识别芯片LD3320高阶秘籍.pdf"中关于垃圾词语吸收错误的用法
     
495. u8 ld3320_asr_addFixed()
     
496. {
     
497.         u8 k, flag;
     
498.         u8 nAsrAddLength;
     
499.         const char sRecog[24][30] = {"xiao hui hui",
     
500.                                                                 "ni you xi fu mei",
     
501.                                                                 "jiang ge gu shi",
     
502.                                                                 "ni shi bu shi dan teng",
     
503.                                                                 "ni ban ben hao duo shao",
     
504.                                                                 "jin tian duo shao hao",
     
505.                                                                 "jin tian ji hao le",
     
506.                                                                 "xian zai ji dian le",
     
507.                                                                 "jin nian ji sui le",
     
508.                                                                 "ni sheng wa le mei",
     
509.                                                                 "da kai ji dian qi yi",
     
510.                                                                 "da kai ji dian qi er",
     
511.                                                                 "guan bi ji dian qi yi",
     
512.                                                                 "guan bi ji dian qi er",
     
513.                                                                 "da kai suo you ji dian qi",
     
514.                                                                 "guan bi suo you ji dian qi",
     
515.                                                                 "tiao gao yin liang",
     
516.                                                                 "zeng jia tin liang",
     
517.                                                                 "tiao xiao yin liang",
     
518.                                                                 "jiang di yin lliang",
     
519.                                                                 "tiao gao yu su",
     
520.                                                                 "zeng jia yu su",
     
521.                                                                 "tiao xiao yu su",
     
522.                                                                 "jiang di yu su",
     
523.                                                                 };
     
524.         const Order pCode[24] = {
     
525.                                                         name,
     
526.                                                         wife,
     
527.                                                         speakStore,
     
528.                                                         eggPain,
     
529.                                                         visionNum,
     
530.                                                         todayDate,
     
531.                                                         whyToday,
     
532.                                                         whatTime,
     
533.                                                         howOld,
     
534.                                                         haveChild,
     
535.                                                         openRelayOne,
     
536.                                                         openRelayTwo,
     
537.                                                         closeRelayOne,
     
538.                                                         closeRelayTwo,
     
539.                                                         openRelay,
     
540.                                                         closeRelay,
     
541.                                                         upVolume,
     
542.                                                         upVolume,
     
543.                                                         downVolume,
     
544.                                                         downVolume,
     
545.                                                         upSpeed,
     
546.                                                         upSpeed,
     
547.                                                         downSpeed,
     
548.                                                         downSpeed,
     
549.                                                         };
     
550.                
     
551.         flag = 1;
     
552.         for (k=0; k<24; k++)
     
553.         {
     
554.                         
     
555.                 if(ld3320_check_asrbusyflag_b2() == 0)
     
556.                 {
     
557.                         flag = 0;
     
558.                         break;
     
559.                 }
     
560.                
     
561.                 ld3320_write_reg(0xc1, pCode[k] );
     
562.                 ld3320_write_reg(0xc3, 0 );
     
563.                 ld3320_write_reg(0x08, 0x04);
     
564.                 delay_ms(1);
     
565.                 ld3320_write_reg(0x08, 0x00);
     
566.                 delay_ms(1);
     
567. 
     
568.                 for (nAsrAddLength=0; nAsrAddLength<30; nAsrAddLength++)
     
569.                 {
     
570.                         if (sRecog[k][nAsrAddLength] == 0)
     
571.                                 break;
     
572.                         ld3320_write_reg(0x5, sRecog[k][nAsrAddLength]);
     
573.                 }
     
574.                 ld3320_write_reg(0xb9, nAsrAddLength);
     
575.                 ld3320_write_reg(0xb2, 0xff);
     
576.                 ld3320_write_reg(0x37, 0x04);
     
577.         }
     
578.     return flag;
     
579. }
     
580. 
     
581. 
     
582. u8 ld3320_get_result()
     
583. {
     
584.         return ld3320_read_reg(0xc5 );
     
585. }
     
586. 
     
587. /************************************************************************************/
     
588. //        RunASR()函数实现了一次完整的ASR语音识别流程
     
589. //        LD_AsrStart() 函数实现了ASR初始化
     
590. //        LD_AsrAddFixed() 函数实现了添加关键词语到LD3320芯片中
     
591. //        LD_AsrRun()        函数启动了一次ASR语音识别流程
     
592. //
     
593. //        任何一次ASR识别流程，都需要按照这个顺序，从初始化开始进行
     
594. /************************************************************************************/
     
595. 
     
596. u8 ld3320_run_asr()
     
597. {
     
598.         u8 i=0;
     
599.         u8 asrflag=0;
     
600.         for (i=0; i<5; i++)                        //        防止由于硬件原因导致LD3320芯片工作不正常，所以一共尝试5次启动ASR识别流程
     
601.         {
     
602.                 LD_AsrStart();
     
603.                 delay_ms(10);
     
604.                 if (ld3320_asr_addFixed()==0)
     
605.                 {
     
606.                         ld3320_reset();                        //        LD3320芯片内部出现不正常，立即重启LD3320芯片
     
607.                         delay_ms(100);                        //        并从初始化开始重新ASR识别流程
     
608.                         continue;
     
609.                 }
     
610.                 delay_ms(300);
     
611.                 if (ld3320_asrun() == 0)
     
612.                 {
     
613.                         ld3320_reset();                        //        LD3320芯片内部出现不正常，立即重启LD3320芯片
     
614.                         delay_ms(100);                        //        并从初始化开始重新ASR识别流程
     
615.                         continue;
     
616.                 }
     
617. 
     
618.                 asrflag=1;
     
619.                 break;                                        //        ASR流程启动成功，退出当前for循环。开始等待LD3320送出的中断信号
     
620.         }
     
621. 
     
622.         return asrflag;
     
623. }
     
624. 
     

复制代码

LD3320.h

1. #ifndef __LD3320_H
   
2. #define __LD3320_H
   
3. #include "sys.h"
   
4. 
   
5. typedef struct
   
6. {
   
7.     unsigned char  b0:1;
   
8.     unsigned char  b1:1;
   
9.     unsigned char  b2:1;
   
10.     unsigned char  b3:1;
    
11.     unsigned char  b4:1;
    
12.     unsigned char  b5:1;
    
13.     unsigned char  b6:1;
    
14.     unsigned char  b7:1;
    
15. } BIT8;
    
16. 
    
17. extern u8 ld3320Data;
    
18. #define     bita0               (((BIT8*) & ld3320Data) -> b0)
    
19. #define     bita1               (((BIT8*) & ld3320Data) -> b1)
    
20. #define     bita2               (((BIT8*) & ld3320Data) -> b2)
    
21. #define     bita3               (((BIT8*) & ld3320Data) -> b3)
    
22. #define     bita4               (((BIT8*) & ld3320Data) -> b4)
    
23. #define     bita5               (((BIT8*) & ld3320Data) -> b5)
    
24. #define     bita6               (((BIT8*) & ld3320Data) -> b6)
    
25. #define     bita7               (((BIT8*) & ld3320Data) -> b7)
    
26. 
    
27. 
    
28. 
    
29. 
    
30. #define LD3320_A0   PBout(15)
    
31. #define LD3320_RD   PBout(14)
    
32. #define LD3320_WR   PAout(12)
    
33. #define LD3320_CS   PAout(11)
    
34. #define LD3320_RST  PBout(10)
    
35. #define LD3320_MD   PBout(13)
    
36.                
    
37. #define LD3320_D0 PBout(5)
    
38. #define LD3320_D1 PBout(4)
    
39. #define LD3320_D2 PBout(3)
    
40. #define LD3320_D3 PAout(15)
    
41. #define LD3320_D4 PBout(9)
    
42. #define LD3320_D5 PBout(8)
    
43. #define LD3320_D6 PBout(7)
    
44. #define LD3320_D7 PBout(6)
    
45. 
    
46. #define LD3320_D0_R PBin(5)
    
47. #define LD3320_D1_R PBin(4)
    
48. #define LD3320_D2_R PBin(3)
    
49. #define LD3320_D3_R PAin(15)
    
50. #define LD3320_D4_R PBin(9)
    
51. #define LD3320_D5_R PBin(8)
    
52. #define LD3320_D6_R PBin(7)
    
53. #define LD3320_D7_R PBin(6)
    
54. 
    
55. 
    
56. #define LD3320_DATA_IN()  {GPIOA->CRH&=0X0FFFFFFF;GPIOA->CRH|=(u32)8<<28;GPIOB->CRL&=0X00000FFF;GPIOB->CRL|=0X88888000;GPIOB->CRH&=0XFFFFFF00;GPIOB->CRH|=0X00000088;}
    
57. #define LD3320_DATA_OUT() {GPIOA->CRH&=0X0FFFFFFF;GPIOA->CRH|=(u32)3<<28;GPIOB->CRL&=0X00000FFF;GPIOB->CRL|=0X33333000;GPIOB->CRH&=0XFFFFFF00;GPIOB->CRH|=0X00000033;}
    
58. 
    
59. 
    
60. #define LD3320_DATA_WRITE(x) {ld3320Data = x;LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;}
    
61. #define LD3320_DATA_READ(x)  {bita0=LD3320_D0_R;bita1=LD3320_D1_R;bita2=LD3320_D2_R;bita3=LD3320_D3_R;bita4=LD3320_D4_R;bita5=LD3320_D5_R; bita6=LD3320_D6_R;bita7=LD3320_D7_R;x= ld3320Data;}
    
62. 
    
63.         
    
64.         
    
65. //        以下三个状态定义用来记录程序是在运行ASR识别还是在运行MP3播放
    
66. #define LD_MODE_IDLE                0x00
    
67. #define LD_MODE_ASR_RUN                0x08
    
68. #define LD_MODE_MP3                         0x40
    
69. 
    
70. 
    
71. //        以下五个状态定义用来记录程序是在运行ASR识别过程中的哪个状态
    
72. #define LD_ASR_NONE                                0x00        //        表示没有在作ASR识别
    
73. #define LD_ASR_RUNING                        0x01        //        表示LD3320正在作ASR识别中
    
74. #define LD_ASR_FOUNDOK                        0x10        //        表示一次识别流程结束后，有一个识别结果
    
75. #define LD_ASR_FOUNDZERO                 0x11        //        表示一次识别流程结束后，没有识别结果
    
76. #define LD_ASR_ERROR                         0x31        //        表示一次识别流程中LD3320芯片内部出现不正确的状态
    
77. 
    
78. 
    
79. #define CLK_IN                       8        /* user need modify this value according to clock in */
    
80. #define LD_PLL_11                        (u8)((CLK_IN/2.0)-1)
    
81. #define LD_PLL_MP3_19                0x0f
    
82. #define LD_PLL_MP3_1B                0x18
    
83. #define LD_PLL_MP3_1D           (u8)(((90.0*((LD_PLL_11)+1))/(CLK_IN))-1)
    
84. 
    
85. #define LD_PLL_ASR_19                 (u8)(CLK_IN*32.0/(LD_PLL_11+1) - 0.51)
    
86. #define LD_PLL_ASR_1B                 0x48
    
87. #define LD_PLL_ASR_1D                 0x1f
    
88. 
    
89. // LD chip fixed values.
    
90. #define        RESUM_OF_MUSIC               0x01
    
91. #define        CAUSE_MP3_SONG_END           0x20
    
92. 
    
93. #define        MASK_INT_SYNC                                0x10
    
94. #define        MASK_INT_FIFO                                0x04
    
95. #define               MASK_AFIFO_INT                                0x01
    
96. #define        MASK_FIFO_STATUS_AFULL                0x08        
    
97.         
    
98.         
    
99.         
    
100. typedef enum
     
101. {
     
102.         name=1,  //小灰灰
     
103.         wife=2,  //你有媳妇没
     
104.         speakStore=3,//讲个故事
     
105.         eggPain=4,  //你最近是不是蛋疼
     
106.         visionNum=5, //你版本号是多少
     
107.         todayDate=6,//今天多少号
     
108.         whyToday=6, //今天几号了
     
109.         whatTime=7,  //现在几点了
     
110.         howOld=8,    //今年几岁了
     
111.         haveChild=9, //你生娃了没
     
112.         openRelayOne=10, //打开继电器一
     
113.         openRelayTwo=11,  //打开继电器二
     
114.         closeRelayOne=12, //关闭继电器一
     
115.         closeRelayTwo=13, //关闭继电器二
     
116.         openRelay=14,     //打开所有继电器
     
117.         closeRelay=15,    //关闭所有继电器
     
118.         upVolume=17,   //调高音量
     
119.         downVolume=18, //降低音量
     
120.         upSpeed=19,                //提高语速
     
121.         downSpeed=20,      //降低语速
     
122. }Order;
     
123.         
     
124.         
     
125.         
     
126.         
     
127.         
     
128. extern unsigned long nMp3StartPos;
     
129. extern unsigned long nMp3Size;
     
130. extern unsigned long nMp3Pos;
     
131. extern u8 bMp3Play;                                                        //        用来记录播放MP3的状态
     
132. extern u8 nLD_Mode;                //        用来记录当前是在进行ASR识别还是在播放MP3
     
133. extern u8 ucRegVal;
     
134. extern u8 ucHighInt;
     
135. extern u8 ucLowInt;
     
136. extern u8 ucStatus;
     
137. extern u8 ucSPVol; // MAX=15 MIN=0                //        Speaker喇叭输出的音量
     
138. #define MIC_VOL 0x55        
     
139.         
     
140.                
     
141. u8 ld3320_check(void);        
     
142. void ld3320_init(void);        
     
143. void ld3320_process_init(void);        
     
144. void ld3320_reset(void);
     
145. void ld3320_init_common(void);
     
146. void ld3320_init_mp3(void);
     
147. void ld3320_init_asr(void);
     
148. void ld3320_reload_mp3data(void);
     
149. void ld3320_reload_mp3data_2(void);
     
150. void ld3320_play(void);
     
151. void ld3320_adjust_volume(u8 val);
     
152. u8 ld3320_check_asrbusyflag_b2(void);
     
153. void LD_AsrStart(void);
     
154. u8 ld3320_asrun(void);
     
155. u8 ld3320_asr_addFixed(void);
     
156. u8 ld3320_get_result(void);
     
157. u8 ld3320_run_asr(void);
     
158.         
     
159. #endif

复制代码

freq.c

1. #include "freq.h"
   
2. 
   
3. 
   
4. void ld3320_freq_init(void)
   
5. {
   
6. 
   
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   
8. 
   
9.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);         //使能PB,PE端口时钟
   
10. 
    
11. 
    
12.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
    
13.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
14.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
15.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    
16.         GPIO_SetBits(GPIOA,GPIO_Pin_8);
    
17.         
    
18.         RCC_MCOConfig(RCC_MCO_HSE); //RCC_MCO_NoClock --- 无时钟输出
    
19.                                                                 //RCC_MCO_SYSCLK --- 输出系统时钟（SysCLK）
    
20.                                                                 //RCC_MCO_HSI --- 输出内部高速8MHz的RC振荡器的时钟（HSI）
    
21.                                                                 //RCC_MCO_HSE --- 输出高速外部时钟信号（HSE）
    
22.                                                                 //RCC_MCO_PLLCLK_Div2 --- 输出PLL倍频后的二分频时钟（PLLCLK/2）               
    
23. }
    

复制代码

freq.h

1. #ifndef __FREQ_H
   
2. #define __FREQ_H
   
3. #include "sys.h"
   
4. 
   
5. 
   
6. void ld3320_freq_init(void);        
   
7. 
   
8.                                                      
   
9. #endif

复制代码

main.c

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "ld3320.h"
   
6. #include "freq.h"
   
7. #include "malloc.h"        
   
8. 
   
9. 
   
10. u8 nAsrStatus=0;        
    
11. extern u8 bMp3Play;                                                        //        用来记录播放MP3的状态
    
12. 
    
13. u8 voiceSpeed=5,voiceVolume=10;
    
14. 
    
15. int main(void)
    
16. {        
    
17.         u8  nAsrRes;
    
18.         u16 i;
    
19.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    
20.         uart_init(115200);
    
21.         
    
22.         delay_init();        
    
23.         ld3320_freq_init();
    
24.         led_init();        
    
25.         mem_init();                                //初始化内存池
    
26.         ld3320_init();
    
27.         delay_ms(1000);
    
28.         ld3320_reset();
    
29.         while(ld3320_check())
    
30.         {
    
31.                 printf("LD3320 Error!!\r\n");
    
32.                 turn_r_led();
    
33.                 delay_ms(500);
    
34.         }        
    
35.         nAsrStatus = LD_ASR_NONE;                //        初始状态：没有在作ASR
    
36.                
    
37.         while(1)
    
38.         {        
    
39.                 if (bMp3Play!=0)                        //        如果还在播放MP3中，则等待，直到MP3播放完毕 即bMp3Play==0
    
40.                         continue;                                //        bMp3Play 是定义的一个全局变量用来记录MP3播放的状态，不是LD3320芯片内部的寄存器
    
41.                 switch(nAsrStatus)
    
42.                 {
    
43.                         case LD_ASR_RUNING:        break;
    
44.                         case LD_ASR_ERROR:        break;
    
45.                                 
    
46.                         case LD_ASR_NONE:
    
47.                         {        
    
48.                                 nAsrStatus=LD_ASR_RUNING;
    
49.                                 if (ld3320_run_asr()==0)        
    
50.                                 {
    
51.                                         nAsrStatus = LD_ASR_ERROR;
    
52.                                 }
    
53.                                 
    
54.                         }break;
    
55.                         case LD_ASR_FOUNDOK:
    
56.                         {
    
57.                                 nAsrRes = ld3320_get_result();
    
58.                                 printf("nAsrRes=%d\r\n",nAsrRes);                                
    
59.                                 switch(nAsrRes)
    
60.                                 {
    
61.                                         case name:
    
62.                                         {           
    
63.                                                 printf("小灰灰\r\n");        
    
64.                                         }break;
    
65.                                         case wife:   
    
66.                                         {
    
67.                                                 printf("你有媳妇没\r\n");
    
68.                                         }break;
    
69.                                         case speakStore:
    
70.                                         {                        
    
71.                                                 printf("讲个故事\r\n");
    
72.                                         }break;
    
73.                                         case eggPain:   
    
74.                                         {                                                
    
75.                                                 printf("你最近是不是蛋疼\r\n");
    
76.                                         }break;
    
77.                                         case visionNum:   
    
78.                                         {                                                
    
79.                                                 printf("你版本号是多少\r\n");
    
80.                                         }break;
    
81.                                         case todayDate:
    
82.                                         {                                       
    
83.                                                 printf("今天多少号\r\n");
    
84.                                         }break;
    
85.                                         case whatTime:  
    
86.                                         {                                                
    
87.                                                 printf("现在几点了\r\n");                                       
    
88.                                         }break;
    
89.                                         case howOld:        
    
90.                                         {                                                
    
91.                                                 printf("今年几岁了\r\n");
    
92.                                         }break;
    
93.                                         case haveChild:  
    
94.                                         {                                       
    
95.                                                 printf("你生娃了没\r\n");
    
96.                                         }break;
    
97.                                         case openRelayOne:
    
98.                                         {                                       
    
99.                                                 printf("打开继电器一\r\n");
    
100.                                         }break;
     
101.                                         case openRelayTwo:
     
102.                                         {                                                
     
103.                                                 printf("打开继电器二\r\n");
     
104.                                         }break;
     
105.                                         case closeRelayOne:
     
106.                                         {                                                
     
107.                                                 printf("关闭继电器一\r\n");
     
108.                                         }break;
     
109.                                         case closeRelayTwo:
     
110.                                         {                                                
     
111.                                                 printf("关闭继电器二\r\n");
     
112.                                         }break;
     
113.                                         case openRelay:   
     
114.                                         {                                       
     
115.                                                 printf("打开所有继电器\r\n");
     
116.                                         }break;
     
117.                                         case closeRelay:  
     
118.                                         {                                                
     
119.                                                 printf("关闭所有继电器\r\n");
     
120.                                         }break;        
     
121.                                         case upVolume:   
     
122.                                         {                                                
     
123.                                                 printf("调高音量\r\n");
     
124.                                         }break;        
     
125.                                         case downVolume:
     
126.                                         {   
     
127.                                                 printf("降低音量\r\n");
     
128.                                         }break;        
     
129.                                         case upSpeed:
     
130.                                         {                                       
     
131.                                                 printf("提高语速\r\n");
     
132.                                         }break;        
     
133.                                         case downSpeed:  
     
134.                                         {                                       
     
135.                                                 printf("降低语速\r\n");
     
136.                                                 
     
137.                                         }break;                                       
     
138.                                 }
     
139.                                 nAsrStatus = LD_ASR_NONE;
     
140.                                 
     
141.                         }break;
     
142.                         case LD_ASR_FOUNDZERO:
     
143.                         default:
     
144.                         {
     
145.                                 nAsrStatus = LD_ASR_NONE;
     
146.                                 
     
147.                         }break;
     
148.                 }
     
149.                 delay_us(2);
     
150.                 i++;
     
151.                 if(i>=60000)
     
152.                 {
     
153.                         i=0;
     
154.                         turn_g_led();
     
155.                 }
     
156.         }
     
157. }
     
158. 
     
159. 
     

复制代码