led指示灯电路图大全（八款led指示灯电路设计原理图详解）
 
   
led指示灯电路图（一）
 
  
 
 
 
 
 
  
图1所示电路中只有两个元件，R选用1/6--1/8W碳膜电阻或金属膜电阻，阻值在1--300K之间。
 
  
Ne为氖泡，也选取用普通日光灯启辉器中的氖泡，若想用体积小且在60V左右即能启辉的氖灯泡，其型号为NNH-616型，电阻R选用270K的1/6W金属膜电阻。led指示灯电路：
 
  
 
  
led指示灯电路图（二）
 
  
采用变压器将高压变为低压，并进行整流滤波，以便输出稳定的低压直流电。开关恒流源又分隔离式电源和非隔离式电源，隔离是指输出高低电压隔离，安全性非常高，所以对外壳绝缘性要求不高。非隔离安全性稍差，但成本也相对低，传统节能灯就是采用非隔离电源，采用绝缘塑料外壳防护。开关电源的安全性相对较高（一般是输出低压），性能稳定，缺点是电路复杂、价格较高。开关电源技术成熟，性能稳定，是目前LED照明的主流电源。
 
  
 
  
图1：开关恒流隔离式日光灯管电源
 
  
 
  
图2：开关恒流隔离电源原理图
 
  
 
  
图3：开关恒流源电源
 
  
led指示灯电路图（三）
 
  
市场上出现一种廉价的LED手电筒，这种手电前端为5～8个高亮度发光管，使用1～2节电池。由于使用超高亮度发光管的原因，发光效率很高，工作电流比较小，实测使用一节五号电池5头电筒，电流只有100mA左右。非常省电。如果使用大容量充电电池，可以连续使用十几个小时，笔者就买了一个。从前端拆开后，根据实物绘制了电路图，如图所示。
 
  
 
  
工作原理：
 
  
接通电源后，VT1因R1接负极，而c1两端电压不能突变。VT1（b）极电位低于e极，VT1导通，VT2（b）极有电流流入，VT2也导通，电流从电源正极经L、VT2（c）极到e极，流回电源负极，电源对L充电，L储存能量，L上的自感电动势为左正右负。经c1的反馈作用，VT1基极电位比发射极电位更低，VT1进入深度饱和状态，同时VT2也进入深度饱和状态，即Ib》Ic/β（β为放大倍数）。
 
  
随着电源对c1的充电，C1两端电压逐渐升高，即VTI（b）极电位逐渐上升，Ib1逐渐减小，当Ib1《=Ic1/β时，VT1退出饱和区，VT2也退出饱和区，对L的充电电流减小。此时．L上的自感电动势变为左负右正，经c1反馈作用。VT1基极电位进一步上升，VT1迅速截止，VT2也截止，L上储存的能量释放，发光管上的电源电压加到L上产生了自感电动势，达到升压的目的。此电压足以使LED发光。
 
  
led指示灯电路图（四）
 
  
该电路是一款适用于城市街道、公园和厂区亮化工程等景观照明的LED变色灯光控制电路。电路结构简单、寿命长、光色艳丽、柔和、美观。
 
  
工作原理如下：电路通电，交流220V经整流后，一路经电阻R1降压C1滤波成+5V电压给集成块U1（12C508A）供电;另一路直接提供给发光二极管（红、绿、蓝）的正极。当12C508A得电后，轮流从⑤脚、⑥脚、⑦脚输出0～0.76V脉冲信号，触发相应的可控硅导通，从而使所连接的发光二极管串发光。U1的④脚所接电阻R4和电容C3为时间常数控制（改变相应的电阻和电容容量规格，就可以改变各串发光二极管点亮的时长）;R2和R3是用于通电时，启动12C508A工作。该灯正常一个循环周期为2分钟左右。
 
  
整个灯串由12条宽15mm长465mm的灯板，共有528个LED组成，红、绿、蓝LED间隔排列。其中红色LED为80个一串。间隔20个串1个1.2kΩ/1W的限流电阻（电流为13.7mA）。绿和蓝各为48个LED.各间隔12个串1个1KΩ/1W电阻（电流均为15mA）。混合交叉排列44个为一组板。
 
  
常见故障：通电后不亮。其故障一般为R2、R3、R1断路或者12C508A损坏。如果出现有一组色长亮，就是该组控制的可控硅（MCR100-6）击穿。还有一种最常见的现象，就是发光二极管串接电路中有一只老化或烧断，则该组就无电流通过而不亮。这时就需要用一组3.0V的电源，串一只20Ω。电阻后。分别对该组二极管从头到尾逐一进行查找。将不亮的LED换掉就好了。
 
  
维修时，一定要断开电源后，进行焊接或查找故障。注意安全。按实物绘制的电路图如附图所示。
 
  
 
  
led指示灯电路图（五）
 
  
led驱动电源电路图如下
 
  
 
  
输入整流部分：分析高压输入整流电路的具体参数，然后选取具体保险整流二极管的规格，因为我们的功率比较低，可以选取线绕电阻作为保险，用1N4007做整流管如果功率较大要选用其他耐流更高的整流二极管。
 
  
整流滤波部分：若EMI要求较严，可增加以下π型电路，若要求没那么严格，可以只用一个滤波电容，电容跟电感的具体容量跟感量，根据总功率选取。
 
  
驱动电路部分：经过R3的电流转化为电压，反馈给IC控制输出电流，在初级绕组加DRC吸收电路，因为我们是内置mos管，驱动电路已集成在IC电路内，所以驱动mos电路不做讲解。
 
  
IC供电与外围电路部分：通过辅助绕组整流滤波单独给IC供电，通过R5与R6阻值的比例来控制输出空载电压。
 
  
输出整流滤波电路部分：通过超快恢复二极管整流和高频低阻电解滤波后，输出给负载，并在超快恢复二极管上加RC电路滤波，通过超快恢复二极管反向波形调试来选取电阻电容，以最大抑制二极管的反向尖峰，在输出端加假负载，一般设计假负载会损耗3毫安电流。
 
  
led指示灯电路图（六）
 
  
本装置的电路如图所示。主要由单电源低功耗运算放大器集成电路IC1、二只低功率晶体管、麦克风和高亮度发光二极管所组成。当麦克风MIC接收到一定强度外界声响（包括各种噪声），产生相应强度的输出电压，加到比较器IC1c，当此电压超过比较器门限值，其输出为高电位，使V1导通，它输出电压加到比较器 IC1b，同样地，此电压器高于IC1b的门限值，IC1b输出高电位去激励IC1a和V2组成的功率放大器，从而驱动LED发光。预设的延时长短。则由 C2和R6，以及R7、R8组成的充放电电路的时间常数决定。
 
  
 
  
在这种照明装置上，也可以加上一只按钮开关使LED点亮，并在预定的时间继续发光。电路供电也很方便，用4节镍氢（MiMH）供电。整个装置间歇性地工作，电池可使用2个月，整个电路处在待机状态，消耗电流400μA，在LED点亮时消耗电流24mA。
 
  
从电路结构看，麦克风MIC通过导线连接输入端与地线之间。并通过R1接到电源正极，信号交流成分通过电容C1耦合到运放IC同相引脚。麦克风灵敏度的调节在很大程度上取决于R1值大小。建议R1值取15kΩ，对于所用麦克风品牌型号不同，R1值也应作相应改变，以便达到所期望的灵敏度。在最大灵敏度调节时，在房门打开，空气气流对麦克风振动膜的压力作用下，就应该使LED受到触发而点亮。IC1采用TLC274，其引脚图见图。
 
  
 
  
led指示灯电路图（七）
 
  
买一只1W白光LED，用手机电池一试，真亮，可以制作一个小台灯。
 
  
用酒杯状的乳白色塑料瓶盖做灯罩。从LED散热板（自带的）后面引出正、负两根线，穿过灯罩，经过弯管引入灯座。灯的形状就出来了。为了充电方便，使用了太阳能板，但电压太低，只能充一节电池，为此，增加了升压板。为了在阴雨天使用，增加了交流充电，并可在交流供电情况下点亮LED灯，此LED的端电压为3+2V、额定电流350mA，经实验，电压达到4.8V仍可正常工作，关键是限流在350mA左右。
 
  
 
  
升压板是从6V应急灯旧板上裁剪下来的振荡电路，未作任何修改（见图中点画线框内），然后经桥式整流提供充电电流。笔者认为，灭蚊拍、电子点火器、验币器等振荡电路，小作修改，也能变通作为升压板使用。电池用三节五号1800m A.h镍氢电池，夏天不用阳光直接照射太阳板，在鞍明亮处即可充电。交流充电提供4. 3V充电电压，约350mA充电电流。假如使用三节五号镍镉电池，限流电阻Ri应改为8~iori，以减小充电电流，避免损坏电池。
 
  
led指示灯电路图（八）
 
  
高亮度白色发光二极管（LED）是现在热门照明光源，因为这种发光器件比其他所有光源都更节能。这里介绍一款自制的LED调光台灯，它既不用专用IC，也不用单片机，仅用一片普通数字电路和少量分立元件就可以DIY一个用按键调光的台灯。
 
  
电路：
 
  
台灯的亮度分为弱、中、强三档，加上“关”共有4种工作状态。
 
  
假设手电一开始处在“关”的状态，那么每次短促地按一下按键，台灯便会按“弱、中、强，关”的顺序轮换，下面是它的电路图（图1）。
 
  
 
  
电路用1块闲置的手机锂电池供电，整个台灯安装在一个小巧的塑料机壳里。由于CMOS电路静态耗电极少（5μA以下），所以除转换工作状态的按键外没有再设电源开关。电路中的关键元件LED采用大功率白色发光二极管。
 
 
 
转载于:https://www.cnblogs.com/ydvely521/p/10048820.html

ULN2003的基本介绍
 
ULN2003的概述
 
ULN2003是高耐压、大电流复合晶体管阵列，由七个硅NPN 复合晶体管组成。一般采用DIP—16 或SOP—16 塑料封装。
 
ULN2003的主要特点：
 
ULN2003 的每一对达林顿都串联一个2.7K 的基极电阻，在5V 的工作电压下它能与TTL 和CMOS 电路直接相连，可以直接处理原先需要标准逻辑缓冲器来处理的数据。
ULN2003 工作电压高，工作电流大，灌电流可达500mA，并且能够在关态时承受50V 的电压，输出还可以在高负载电流并行运行。
ULN2003的作用
 
ULN2003是大电流驱动阵列，多用于单片机、智能仪表、PLC、数字量输出卡等控制电路中，可直接驱动继电器等负载。输入5VTTL电平，输出可达500mA/50V。
 
简单地说，ULN2003其实就是用来放大电流的，增加驱动能力。比如说单片机输出引脚一般输出就几mA，是无法驱动电机、继电器或者电磁阀的，像要让直流电机转需要500mA，而用ULN2003放大后，可以通过单片机的输出引脚直接控制这些设备。
 
 
 
ULN2003的引脚图和功能
 
ULN2003的引脚图
 
 
ULN2003的引脚功能
 
引脚1：CPU脉冲输入端，端口对应一个信号输出端；
引脚2：CPU脉冲输入端；
引脚3：CPU脉冲输入端；
引脚4：CPU脉冲输入端；
引脚5：CPU脉冲输入端；
引脚6：CPU脉冲输入端；
引脚7：CPU脉冲输入端；
引脚8：接地；
引脚9：该脚是内部7个续流二极管负极的公共端，各二极管的正极分别接各达林顿管的集电极。用于感性负载时，该脚接负载电源正极，实现续流作用。如果该脚接地，实际上就是达林顿管的集电极对地接通；
引脚10：脉冲信号输出端，对应7脚信号输入端；
引脚11：脉冲信号输出端，对应6脚信号输入端；
引脚12：脉冲信号输出端，对应5脚信号输入端；
引脚13：脉冲信号输出端，对应4脚信号输入端；
引脚14：脉冲信号输出端，对应3脚信号输入端；
引脚15：脉冲信号输出端，对应2脚信号输入端；
引脚16：脉冲信号输出端，对应1脚信号输入端。
 
 
ULN2003工作原理驱动应用电路
 
ULN2003是高耐压、大电流复合晶体管阵列，由七个硅NPN 复合晶体管组成，每一对达林顿都串联一个2.7K 的基极电阻，在5V 的工作电压下它能与TTL 和CMOS 电路直接相连，可以直接处理原先需要标准逻辑缓冲器来处理的数据。
 
LN2003也是一个7路反向器电路，即当输入端为高电平时，ULN2003输出端为低电平；当输入端为低电平时，ULN2003输出端为高电平。
 
ULN2003是一个非门电路，包含7个单元，单独每个单元驱动电流最大可达500mA，9脚可以悬空。比如1脚输入，16脚输出，你的负载接在VCC与16脚之间，不用9脚。
 
根据上面的原理，ULN2003的驱动应用电路的基本示例图，各个引脚的功能都标注在上面：
 
 
这里需要注意的是：尽管按照官方文献要求，控制电压输入需要在5V，其实只需要超过2.5V的电平信号基本都能够算作是高电平。也就是说，3.3V的单片机的IO口的高电平输出就能够直接来进行ULN2003的控制输入了。
 
再介绍一个实际例程的ULN2003的驱动应用电路：
 
 
整体看下来：引脚1-7是输入信号；引脚10-16是输出信号，引脚8接地，引脚9接VCC。
 
引脚1输入RL信号，相对应的输出引脚16控制的是一个继电器。当引脚1输入高电平，继电器开启；
引脚2-5输入D、C、B、A信号，相对应的输出引脚15、14、13、12作为四相来控制四相五线步进电机；
引脚6输入SPK信号，相对应的输出引脚11控制的是一个喇叭。当引脚6输入高电平，喇叭开启；
引脚7输入M0T信号，相对应的输出引脚10控制的是一个直流电机。当引脚6输入高电平，直流电机启动。
这个时候大概就能理解ULN2003的本质了：
 
由于单片机的引脚输出电流太低了，无法驱动大部分的设备。而ULN2003只相当于是一个开关，设备（负载）的供电是在外围电路上，而它能够通过微弱的单片机输出电流来控制外围电路的开闭。这某种程度上也可以说是，放大电流，增加驱动能力。
 
 
 
STM32驱动步进电机
 
硬件连接
 
单片机：STM32F103ZET6
步进电机：28BYJ-48
驱动电路：ULN2003芯片的驱动板【TELESKY】5V 步进电机马达+ ULN2003驱动板5V测试模块板 (1套)
引脚连接：IN1：PC3、IN2：PC2、IN3：PC0、IN4：PC13、OUT1：步进电机4、OUT2：步进电机3、OUT3：步进电机2、OUT4：步进电机1、步进电机5：VCC电源正极（5V）、GND：共地、COM：VCC电源正极（5V）。
5V直流电源：STM32F103ZET6开发板上的5V电压引脚（下图中的VCC）。
之前提到：STM32的IO口高电平3.3V能够作为ULN2003的控制输入信号，这里再强调一次。
 
具体的硬件连接的图如下所示：
 
 
STM32控制程序
 
步进电机是一种将电脉冲转化为角位移的执行设备。通俗一点讲：当步进驱动器接收到一个脉冲信号，它就驱动步进电机按设定的方向转动一个固定的角度（即步进角）。我们可以通过控制脉冲个数来控制角位移量，从而达到准确定位的目的；同时我们可以通过控制脉冲频率来控制电机转动的速度和加速度，从而达到调速的目的。
 
28BYJ48型步进电机是四相八拍电机，电压为DC5V～DC12V。当对步进电机按一定顺序施加一系列连续不断的控制脉冲时，它可以连续不断地转动。每一个脉冲信号使得步进电机的某一相或两相绕组的通电状态改变一次，也就对应转子转过一定的角度。当通电状态的改变完成一个循环时，转子转过一个齿距。四相步进电机可以在不同的通电方式下运行，常见的通电方式有单（单相绕组通电）四拍（A-B-C-D-A……），双（双相绕组通电）四拍（AB-BC-CD-DA-AB……），四相八拍（A-AB-B-BC-C-CD-D-DA-A……）。
 
所以说，要想启动步进电机只需要依次给各个相输入高电平信号就可以了。注意，当给某一相输入信号的时候，其他相要重新置0。也就是说，同一时刻只能保持有一个相。
 
#include "stm32f10x.h"
#include "delay.h"

//引脚连接
//IN1：PC3、IN2：PC2、IN3：PC0、IN4：PC13、

//步进电机初始化函数
void Motor_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);//开启时钟
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_0|GPIO_Pin_2|GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure);
	
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);//默认低电平
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	GPIO_ResetBits(GPIOC,GPIO_Pin_2);
	GPIO_ResetBits(GPIOC,GPIO_Pin_3);
	
}

//步进电机正转函数
void Motorcw(void)
{
	GPIO_SetBits(GPIOC,GPIO_Pin_13);//依次高电平输出
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	GPIO_ResetBits(GPIOC,GPIO_Pin_2);
	GPIO_ResetBits(GPIOC,GPIO_Pin_3);
	delay_ms(10);
	
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);
	GPIO_SetBits(GPIOC,GPIO_Pin_0);
	GPIO_ResetBits(GPIOC,GPIO_Pin_2);
	GPIO_ResetBits(GPIOC,GPIO_Pin_3);
	delay_ms(10);
	
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	GPIO_SetBits(GPIOC,GPIO_Pin_2);
	GPIO_ResetBits(GPIOC,GPIO_Pin_3);
	delay_ms(10);
	
	GPIO_ResetBits(GPIOC,GPIO_Pin_13);
	GPIO_ResetBits(GPIOC,GPIO_Pin_0);
	GPIO_ResetBits(GPIOC,GPIO_Pin_2);
	GPIO_SetBits(GPIOC,GPIO_Pin_3);
	delay_ms(10);
	
}
 
int main(void)
{
	delay_init();//delay初始化函数
	Motor_Init();
 while(1)
 {
	Motorcw();
 }
}
 
 
 

一、原理图
 
 二、源代码
 LD3320.c
 
#include "ld3320.h"
#include "delay.h"
#include "usart.h"	
#include "string.h"
u8 ld3320Data;
extern u8 nAsrStatus;

unsigned long nMp3StartPos=0;
unsigned long nMp3Size=0;
unsigned long nMp3Pos=0;
u8 bMp3Play=0;							//	用来记录播放MP3的状态
u8 nLD_Mode = LD_MODE_IDLE;		//	用来记录当前是在进行ASR识别还是在播放MP3
u8 ucRegVal;
u8 ucHighInt;
u8 ucLowInt;
u8 ucStatus;
u8 ucSPVol=15; // MAX=15 MIN=0		//	Speaker喇叭输出的音量



void ld3320_init()
{
	GPIO_InitTypeDef  GPIO_InitStructure;
 	EXTI_InitTypeDef EXTI_InitStructure;
 	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE);	 //使能PB,PE端口时钟
	
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable,ENABLE);
	
	
	GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_15;				 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 
	GPIO_Init(GPIOA, &GPIO_InitStructure);					
	GPIO_SetBits(GPIOA,GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_15);
	
	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 ;				 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; 		 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 
	GPIO_Init(GPIOB, &GPIO_InitStructure);					
	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);
		
	
	LD3320_MD=0;  //选择并口
	LD3320_RST=1;	
	LD3320_A0=0;
	
	
	GPIO_InitStructure.GPIO_Pin =GPIO_Pin_11;				 
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 		 
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;		 
	GPIO_Init(GPIOB, &GPIO_InitStructure);		

  	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);	//使能复用功能时钟

    // 中断线以及中断初始化配置   下降沿触发
  	GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource11);

  	EXTI_InitStructure.EXTI_Line=EXTI_Line11;	
  	EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;	
  	EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  	EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  	EXTI_Init(&EXTI_InitStructure);	 	//根据EXTI_InitStruct中指定的参数初始化外设EXTI寄存器
	
	NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;			//使能外部中断通道
  	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;	//抢占优先级0
  	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;					//子优先级0 
  	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;								//使能外部中断通道
  	NVIC_Init(&NVIC_InitStructure);  	  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器	

}

//外部中断服务程序
void EXTI15_10_IRQHandler(void)
{
	if(EXTI_GetITStatus(EXTI_Line11)!= RESET ) 
	{
		ld3320_process_init();		
		EXTI_ClearFlag(EXTI_Line11);
		EXTI_ClearITPendingBit(EXTI_Line11);//清除LINE上的中断标志位  
	} 	
}


void ld3320_write_reg( unsigned char address, unsigned char dataout )
{
	
	ld3320Data=address;
	LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
	LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
	delay_us(1);
	LD3320_A0  =1;
	LD3320_CS = 0;
	LD3320_WR = 0;

	LD3320_WR = 1;
	LD3320_CS = 1;
	

	
	ld3320Data=dataout;
	LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
	LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
	delay_us(1);
	LD3320_A0 = 0;
	LD3320_CS = 0;
	LD3320_WR = 0;

	LD3320_WR = 1;
	LD3320_CS = 1;
}

unsigned char ld3320_read_reg( unsigned char address )
{
	unsigned char datain;

	ld3320Data=address;
	LD3320_D0=bita0;LD3320_D1=bita1;LD3320_D2=bita2;LD3320_D3=bita3;
	LD3320_D4=bita4;LD3320_D5=bita5;LD3320_D6=bita6;LD3320_D7=bita7;
	
	LD3320_A0 = 1;
	delay_us(1);
	LD3320_CS = 0;
	delay_us(1);
	LD3320_WR = 0;
	delay_us(1);

	LD3320_WR = 1;
	delay_us(1);
	LD3320_CS = 1;
	delay_us(1);

	LD3320_A0 = 0;
	delay_us(1);
	LD3320_CS = 0;
	delay_us(1);
	LD3320_RD = 0;
	LD3320_DATA_IN();
	delay_us(1);
	
	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;
	datain= ld3320Data;
	
	LD3320_DATA_OUT();
	LD3320_RD = 1;
	delay_us(1);
	LD3320_CS = 1;

	return datain;
}


void ld3320_reset()
{
	LD3320_RST=1;
	delay_ms(1);
	LD3320_RST=0;
	delay_ms(1);
	LD3320_RST=1;

	delay_ms(1);
	LD3320_CS=0;
	delay_ms(1);
	LD3320_CS=1;
	delay_ms(1);
}
u8 ld3320_check()
{
	u8 a[3];
	memset(a,0x00,sizeof(a));
	ld3320_reset();
	delay_ms(1);
	ld3320_read_reg(0x06);  
	delay_ms(1);
	ld3320_write_reg(0x35, 0x33);  
	delay_ms(1);
	ld3320_write_reg(0x1b, 0x55);   
	delay_ms(1);
	ld3320_write_reg(0xb3, 0xaa);	
	
	a[0]=ld3320_read_reg(0x35);
	delay_ms(5);
		
	a[1]=ld3320_read_reg(0x1b);
	delay_ms(5);
	a[2]=ld3320_read_reg(0xb3);

	if(a[0]!=0x33||a[1]!=0x55||a[2]!=0xaa)
		return 1;
	return 0;
	
}



void ld3320_init_common()
{
	bMp3Play = 0;

	ld3320_read_reg(0x06);  
	ld3320_write_reg(0x17, 0x35); 
	delay_ms(10);
	ld3320_read_reg(0x06);  

	ld3320_write_reg(0x89, 0x03);  
	delay_ms(5);
	ld3320_write_reg(0xCF, 0x43);   
	delay_ms(5);
	ld3320_write_reg(0xCB, 0x02);
	
	/*PLL setting*/
	ld3320_write_reg(0x11, LD_PLL_11);       
	if (nLD_Mode == LD_MODE_MP3)
	{
		ld3320_write_reg(0x1E, 0x00); 
		ld3320_write_reg(0x19, LD_PLL_MP3_19);   
		ld3320_write_reg(0x1B, LD_PLL_MP3_1B);   
		ld3320_write_reg(0x1D, LD_PLL_MP3_1D);
	}
	else
	{
		ld3320_write_reg(0x1E,0x00);
		ld3320_write_reg(0x19, LD_PLL_ASR_19); 
		ld3320_write_reg(0x1B, LD_PLL_ASR_1B);		
	    ld3320_write_reg(0x1D, LD_PLL_ASR_1D);
	}
	delay_ms(10);
	
	ld3320_write_reg(0xCD, 0x04);
	ld3320_write_reg(0x17, 0x4c); 
	delay_ms(5);
	ld3320_write_reg(0xB9, 0x00);
	ld3320_write_reg(0xCF, 0x4F); 
	ld3320_write_reg(0x6F, 0xFF); 
}

void ld3320_init_mp3()
{
	nLD_Mode = LD_MODE_MP3;
	ld3320_init_common();

	ld3320_write_reg(0xBD,0x02);
	ld3320_write_reg(0x17, 0x48);
	delay_ms(10);

	ld3320_write_reg(0x85, 0x52); 
	ld3320_write_reg(0x8F, 0x00);  
	ld3320_write_reg(0x81, 0x00);
	ld3320_write_reg(0x83, 0x00);
	ld3320_write_reg(0x8E, 0xff);
	ld3320_write_reg(0x8D, 0xff);
    delay_ms(1);
	ld3320_write_reg(0x87, 0xff);
	ld3320_write_reg(0x89, 0xff);
	delay_ms(1);
	ld3320_write_reg(0x22, 0x00);    
	ld3320_write_reg(0x23, 0x00);
	ld3320_write_reg(0x20, 0xef);    
	ld3320_write_reg(0x21, 0x07);
	ld3320_write_reg(0x24, 0x77);          
    ld3320_write_reg(0x25, 0x03);
    ld3320_write_reg(0x26, 0xbb);    
    ld3320_write_reg(0x27, 0x01); 
}



void ld3320_init_asr()
{
	nLD_Mode=LD_MODE_ASR_RUN;
	ld3320_init_common();

	ld3320_write_reg(0xBD, 0x00);
	ld3320_write_reg(0x17, 0x48);
	delay_ms(10);

	ld3320_write_reg(0x3C, 0x80);    
	ld3320_write_reg(0x3E, 0x07);
	ld3320_write_reg(0x38, 0xff);    
	ld3320_write_reg(0x3A, 0x07);
	
	ld3320_write_reg(0x40, 0);          
	ld3320_write_reg(0x42, 8);
	ld3320_write_reg(0x44, 0);    
	ld3320_write_reg(0x46, 8); 
	delay_ms(10);
}

void ld3320_reload_mp3data()
{
	unsigned long nCurMp3Pos;
	u8 val;
	u8 k;

	nCurMp3Pos = nMp3StartPos + nMp3Pos;

	ucStatus = ld3320_read_reg(0x06);
	while ( !(ucStatus&MASK_FIFO_STATUS_AFULL) && (nMp3Pos<nMp3Size) )
	{
		val=0;
		for(k=0;k<8;k++)
		{
		}
		ld3320_write_reg(0x01,val);

		nMp3Pos++;

		ucStatus = ld3320_read_reg(0x06);
	}
}


void ld3320_reload_mp3data_2()
{
	unsigned long nCurMp3Pos;
	u8 val;
	u8 k;

	nCurMp3Pos = nMp3StartPos + nMp3Pos;


	//读取音乐文件写入
	
	

	ucStatus = ld3320_read_reg(0x06);
	while ( !(ucStatus&MASK_FIFO_STATUS_AFULL) && (nMp3Pos<nMp3Size) )
	{
		val=0;


		nMp3Pos++;

		ucStatus = ld3320_read_reg(0x06);
	}
}




void ld3320_process_init()
{
	u8 nAsrResCount=0;
	
	ucRegVal = ld3320_read_reg(0x2B);
	if(nLD_Mode == LD_MODE_ASR_RUN)
	{
		// 语音识别产生的中断
		// （有声音输入，不论识别成功或失败都有中断）
		ld3320_write_reg(0x29,0) ;
		ld3320_write_reg(0x02,0) ;
		if((ucRegVal & 0x10) &&
			ld3320_read_reg(0xb2)==0x21 && 
			ld3320_read_reg(0xbf)==0x35)
		{
			nAsrResCount = ld3320_read_reg(0xba);
			if(nAsrResCount>0 && nAsrResCount<=4) 
			{
				nAsrStatus=LD_ASR_FOUNDOK;
			}
			else
		    {
				nAsrStatus=LD_ASR_FOUNDZERO;
			}	
		}
		else
		{
			nAsrStatus=LD_ASR_FOUNDZERO;
		}
			
		ld3320_write_reg(0x2b, 0);
    	ld3320_write_reg(0x1C,0);
		return;
	}
	
	// 声音播放产生的中断，有三种：
	// A. 声音数据已全部播放完。
	// B. 声音数据已发送完毕。
	// C. 声音数据暂时将要用完，需要放入新的数据。	
	ucHighInt = ld3320_read_reg(0x29); 
	ucLowInt=ld3320_read_reg(0x02); 
	ld3320_write_reg(0x29,0) ;
	ld3320_write_reg(0x02,0) ;
    if(ld3320_read_reg(0xBA)&CAUSE_MP3_SONG_END)
    {
	// A. 声音数据已全部播放完。

		ld3320_write_reg(0x2B,  0);
      	ld3320_write_reg(0xBA, 0);	
		ld3320_write_reg(0xBC,0x0);	
		bMp3Play=0;					// 声音数据全部播放完后，修改bMp3Play的变量
		ld3320_write_reg(0x08,1);
		delay_ms(5);
      	ld3320_write_reg(0x08,0);
		ld3320_write_reg(0x33, 0);

		return ;
     }

	 if(nMp3Pos>=nMp3Size)
	{
	// B. 声音数据已发送完毕。

		ld3320_write_reg(0xBC, 0x01);
		ld3320_write_reg(0x29, 0x10);
//		bMp3Play=0;				//	此时，只是主控MCU把所有MP3数据发送到LD3320芯片内，但是还没有把送入的数据全部播放完毕
		return;	
	}

	// C. 声音数据暂时将要用完，需要放入新的数据。	

	ld3320_reload_mp3data_2();
		
	ld3320_write_reg(0x29,ucHighInt); 
	ld3320_write_reg(0x02,ucLowInt) ;
}
void ld3320_play()
{
	nMp3Pos=0;
	bMp3Play=1;

	if (nMp3Pos >=  nMp3Size)
		return ; 

	ld3320_reload_mp3data();

    ld3320_write_reg(0xBA, 0x00);
	ld3320_write_reg(0x17, 0x48);
	ld3320_write_reg(0x33, 0x01);
	ld3320_write_reg(0x29, 0x04);
	
	ld3320_write_reg(0x02, 0x01); 
	ld3320_write_reg(0x85, 0x5A);
}

void ld3320_adjust_volume(u8 val)
{
	ucSPVol = val;
	val = ((15-val)&0x0f) << 2;
	ld3320_write_reg(0x8E, val | 0xc3); 
	ld3320_write_reg(0x87, 0x78); 
}
// Return 1: success.
u8 ld3320_check_asrbusyflag_b2()
{
	u8 j;
	u8 flag = 0;
	for (j=0; j<10; j++)
	{
		if (ld3320_read_reg(0xb2) == 0x21)
		{
			flag = 1;
			break;
		}
		delay_ms(10);		
	}
	return flag;
}

void LD_AsrStart()
{
	ld3320_init_asr();
}

// Return 1: success.
u8 ld3320_asrun()
{
	ld3320_write_reg(0x35, MIC_VOL);
	ld3320_write_reg(0x1C, 0x09);
	ld3320_write_reg(0xBD, 0x20);
	ld3320_write_reg(0x08, 0x01);
	delay_ms( 1 );
	ld3320_write_reg(0x08, 0x00);
	delay_ms( 1 );

	if(ld3320_check_asrbusyflag_b2() == 0)
	{
		return 0;
	}

	ld3320_write_reg(0xB2, 0xff);	
	ld3320_write_reg(0x37, 0x06);
	delay_ms( 10 );
	ld3320_write_reg(0x1C, 0x0b);
	ld3320_write_reg(0x29, 0x10);
	
	ld3320_write_reg(0xBD, 0x00);
	return 1;
}

// Return 1: success.
//	添加识别关键词语，开发者可以学习"语音识别芯片LD3320高阶秘籍.pdf"中关于垃圾词语吸收错误的用法
u8 ld3320_asr_addFixed()
{
	u8 k, flag;
	u8 nAsrAddLength;
	const char sRecog[24][30] = {"xiao hui hui",
								"ni you xi fu mei",
								"jiang ge gu shi",
								"ni shi bu shi dan teng",
								"ni ban ben hao duo shao",
								"jin tian duo shao hao",
								"jin tian ji hao le",
								"xian zai ji dian le",
								"jin nian ji sui le",
								"ni sheng wa le mei",
								"da kai ji dian qi yi",
								"da kai ji dian qi er",
								"guan bi ji dian qi yi",
								"guan bi ji dian qi er",
								"da kai suo you ji dian qi",
								"guan bi suo you ji dian qi",
								"tiao gao yin liang",
								"zeng jia tin liang",
								"tiao xiao yin liang",
								"jiang di yin lliang",
								"tiao gao yu su",
								"zeng jia yu su",
								"tiao xiao yu su",
								"jiang di yu su",
								};
	const Order pCode[24] = {
							name,
							wife,
							speakStore,
							eggPain,
							visionNum,
							todayDate,
							whyToday,
							whatTime,
							howOld,
							haveChild,
							openRelayOne,
							openRelayTwo,
							closeRelayOne,
							closeRelayTwo,
							openRelay,
							closeRelay,
							upVolume,
							upVolume,
							downVolume,
							downVolume,
							upSpeed,
							upSpeed,
							downSpeed,
							downSpeed,
							};
		
	flag = 1;
	for (k=0; k<24; k++)
	{
			
		if(ld3320_check_asrbusyflag_b2() == 0)
		{
			flag = 0;
			break;
		}
		
		ld3320_write_reg(0xc1, pCode[k] );
		ld3320_write_reg(0xc3, 0 );
		ld3320_write_reg(0x08, 0x04);
		delay_ms(1);
		ld3320_write_reg(0x08, 0x00);
		delay_ms(1);

		for (nAsrAddLength=0; nAsrAddLength<30; nAsrAddLength++)
		{
			if (sRecog[k][nAsrAddLength] == 0)
				break;
			ld3320_write_reg(0x5, sRecog[k][nAsrAddLength]);
		}
		ld3320_write_reg(0xb9, nAsrAddLength);
		ld3320_write_reg(0xb2, 0xff);
		ld3320_write_reg(0x37, 0x04);
	}
    return flag;
}


u8 ld3320_get_result()
{
	return ld3320_read_reg(0xc5 );
}

/************************************************************************************/
//	RunASR()函数实现了一次完整的ASR语音识别流程
//	LD_AsrStart() 函数实现了ASR初始化
//	LD_AsrAddFixed() 函数实现了添加关键词语到LD3320芯片中
//	LD_AsrRun()	函数启动了一次ASR语音识别流程
//
//	任何一次ASR识别流程，都需要按照这个顺序，从初始化开始进行
/************************************************************************************/

u8 ld3320_run_asr()
{
	u8 i=0;
	u8 asrflag=0;
	for (i=0; i<5; i++)			//	防止由于硬件原因导致LD3320芯片工作不正常，所以一共尝试5次启动ASR识别流程
	{
		LD_AsrStart();
		delay_ms(10);
		if (ld3320_asr_addFixed()==0)
		{
			ld3320_reset();			//	LD3320芯片内部出现不正常，立即重启LD3320芯片
			delay_ms(100);			//	并从初始化开始重新ASR识别流程
			continue;
		}
		delay_ms(300);
		if (ld3320_asrun() == 0)
		{
			ld3320_reset();			//	LD3320芯片内部出现不正常，立即重启LD3320芯片
			delay_ms(100);			//	并从初始化开始重新ASR识别流程
			continue;
		}

		asrflag=1;
		break;					//	ASR流程启动成功，退出当前for循环。开始等待LD3320送出的中断信号
	}

	return asrflag;
}

 
LD3320.h
 
#ifndef __LD3320_H 
#define __LD3320_H 
#include "sys.h"

typedef struct
{
    unsigned char  b0:1; 
    unsigned char  b1:1; 
    unsigned char  b2:1; 
    unsigned char  b3:1; 
    unsigned char  b4:1;
    unsigned char  b5:1;
    unsigned char  b6:1;
    unsigned char  b7:1;
} BIT8;

extern u8 ld3320Data;
#define     bita0               (((BIT8*) & ld3320Data) -> b0)
#define     bita1               (((BIT8*) & ld3320Data) -> b1)
#define     bita2               (((BIT8*) & ld3320Data) -> b2)
#define     bita3               (((BIT8*) & ld3320Data) -> b3)
#define     bita4               (((BIT8*) & ld3320Data) -> b4)
#define     bita5               (((BIT8*) & ld3320Data) -> b5)
#define     bita6               (((BIT8*) & ld3320Data) -> b6)
#define     bita7               (((BIT8*) & ld3320Data) -> b7)




#define LD3320_A0   PBout(15)
#define LD3320_RD   PBout(14)
#define LD3320_WR   PAout(12)
#define LD3320_CS   PAout(11)
#define LD3320_RST  PBout(10)
#define LD3320_MD   PBout(13)
		
#define LD3320_D0 PBout(5)
#define LD3320_D1 PBout(4)
#define LD3320_D2 PBout(3)
#define LD3320_D3 PAout(15)
#define LD3320_D4 PBout(9)
#define LD3320_D5 PBout(8)
#define LD3320_D6 PBout(7)
#define LD3320_D7 PBout(6)

#define LD3320_D0_R PBin(5)
#define LD3320_D1_R PBin(4)
#define LD3320_D2_R PBin(3)
#define LD3320_D3_R PAin(15)
#define LD3320_D4_R PBin(9)
#define LD3320_D5_R PBin(8)
#define LD3320_D6_R PBin(7)
#define LD3320_D7_R PBin(6)


#define LD3320_DATA_IN()  {GPIOA->CRH&=0X0FFFFFFF;GPIOA->CRH|=(u32)8<<28;GPIOB->CRL&=0X00000FFF;GPIOB->CRL|=0X88888000;GPIOB->CRH&=0XFFFFFF00;GPIOB->CRH|=0X00000088;}
#define LD3320_DATA_OUT() {GPIOA->CRH&=0X0FFFFFFF;GPIOA->CRH|=(u32)3<<28;GPIOB->CRL&=0X00000FFF;GPIOB->CRL|=0X33333000;GPIOB->CRH&=0XFFFFFF00;GPIOB->CRH|=0X00000033;}


#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;}
#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;}

	
	
//	以下三个状态定义用来记录程序是在运行ASR识别还是在运行MP3播放
#define LD_MODE_IDLE		0x00
#define LD_MODE_ASR_RUN		0x08
#define LD_MODE_MP3		 	0x40


//	以下五个状态定义用来记录程序是在运行ASR识别过程中的哪个状态
#define LD_ASR_NONE				0x00	//	表示没有在作ASR识别
#define LD_ASR_RUNING			0x01	//	表示LD3320正在作ASR识别中
#define LD_ASR_FOUNDOK			0x10	//	表示一次识别流程结束后，有一个识别结果
#define LD_ASR_FOUNDZERO 		0x11	//	表示一次识别流程结束后，没有识别结果
#define LD_ASR_ERROR	 		0x31	//	表示一次识别流程中LD3320芯片内部出现不正确的状态


#define CLK_IN   		    8	/* user need modify this value according to clock in */
#define LD_PLL_11			(u8)((CLK_IN/2.0)-1)
#define LD_PLL_MP3_19		0x0f
#define LD_PLL_MP3_1B		0x18
#define LD_PLL_MP3_1D   	(u8)(((90.0*((LD_PLL_11)+1))/(CLK_IN))-1)

#define LD_PLL_ASR_19 		(u8)(CLK_IN*32.0/(LD_PLL_11+1) - 0.51)
#define LD_PLL_ASR_1B 		0x48
#define LD_PLL_ASR_1D 		0x1f

// LD chip fixed values.
#define        RESUM_OF_MUSIC               0x01
#define        CAUSE_MP3_SONG_END           0x20

#define        MASK_INT_SYNC				0x10
#define        MASK_INT_FIFO				0x04
#define    	   MASK_AFIFO_INT				0x01
#define        MASK_FIFO_STATUS_AFULL		0x08	
	
	
	
typedef enum
{
	name=1,  //小灰灰 
	wife=2,  //你有媳妇没
	speakStore=3,//讲个故事
	eggPain=4,  //你最近是不是蛋疼
	visionNum=5, //你版本号是多少
	todayDate=6,//今天多少号
	whyToday=6, //今天几号了
	whatTime=7,  //现在几点了
	howOld=8,    //今年几岁了
	haveChild=9, //你生娃了没
	openRelayOne=10, //打开继电器一
	openRelayTwo=11,  //打开继电器二
	closeRelayOne=12, //关闭继电器一
	closeRelayTwo=13, //关闭继电器二
	openRelay=14,     //打开所有继电器
	closeRelay=15,    //关闭所有继电器
	upVolume=17,   //调高音量
	downVolume=18, //降低音量
	upSpeed=19,		//提高语速
	downSpeed=20,      //降低语速
}Order;
	
	
	
	
	
extern unsigned long nMp3StartPos;
extern unsigned long nMp3Size;
extern unsigned long nMp3Pos;
extern u8 bMp3Play;							//	用来记录播放MP3的状态
extern u8 nLD_Mode;		//	用来记录当前是在进行ASR识别还是在播放MP3
extern u8 ucRegVal;
extern u8 ucHighInt;
extern u8 ucLowInt;
extern u8 ucStatus;
extern u8 ucSPVol; // MAX=15 MIN=0		//	Speaker喇叭输出的音量
#define MIC_VOL 0x55	
	
		
u8 ld3320_check(void);	
void ld3320_init(void);	
void ld3320_process_init(void);	
void ld3320_reset(void);
void ld3320_init_common(void);
void ld3320_init_mp3(void);
void ld3320_init_asr(void);
void ld3320_reload_mp3data(void);
void ld3320_reload_mp3data_2(void);
void ld3320_play(void);
void ld3320_adjust_volume(u8 val);
u8 ld3320_check_asrbusyflag_b2(void);
void LD_AsrStart(void);
u8 ld3320_asrun(void);
u8 ld3320_asr_addFixed(void);
u8 ld3320_get_result(void);
u8 ld3320_run_asr(void);
	
#endif

 
freq.c
 
#include "freq.h"


void ld3320_freq_init(void)
{
 
	GPIO_InitTypeDef  GPIO_InitStructure;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);	 //使能PB,PE端口时钟


	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);	
	GPIO_SetBits(GPIOA,GPIO_Pin_8);
	
	RCC_MCOConfig(RCC_MCO_HSE); //RCC_MCO_NoClock --- 无时钟输出 
								//RCC_MCO_SYSCLK --- 输出系统时钟（SysCLK） 
								//RCC_MCO_HSI --- 输出内部高速8MHz的RC振荡器的时钟（HSI） 
								//RCC_MCO_HSE --- 输出高速外部时钟信号（HSE） 
								//RCC_MCO_PLLCLK_Div2 --- 输出PLL倍频后的二分频时钟（PLLCLK/2）		
}
 

 
freq.h
 
#ifndef __FREQ_H
#define __FREQ_H 
#include "sys.h"


void ld3320_freq_init(void);	

		 				    
#endif

 
main.c
 
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "ld3320.h"
#include "freq.h"
#include "malloc.h"	

 
u8 nAsrStatus=0;	
extern u8 bMp3Play;							//	用来记录播放MP3的状态

u8 voiceSpeed=5,voiceVolume=10;

int main(void)
{	
	u8  nAsrRes;
	u16 i;
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
	uart_init(115200);
	
	delay_init();	
	ld3320_freq_init();
	led_init();	
	mem_init();				//初始化内存池
	ld3320_init();
	delay_ms(1000);
	ld3320_reset();
	while(ld3320_check())
	{
		printf("LD3320 Error!!\r\n");
		turn_r_led();
		delay_ms(500);
	}	
	nAsrStatus = LD_ASR_NONE;		//	初始状态：没有在作ASR
		
	while(1)
	{	
		if (bMp3Play!=0)			//	如果还在播放MP3中，则等待，直到MP3播放完毕 即bMp3Play==0
			continue;				//	bMp3Play 是定义的一个全局变量用来记录MP3播放的状态，不是LD3320芯片内部的寄存器
		switch(nAsrStatus)
		{
			case LD_ASR_RUNING:	break;
			case LD_ASR_ERROR:	break;
				
			case LD_ASR_NONE:
			{	
				nAsrStatus=LD_ASR_RUNING;
				if (ld3320_run_asr()==0)	
				{
					nAsrStatus = LD_ASR_ERROR;
				}
				
			}break;
			case LD_ASR_FOUNDOK:
			{
				nAsrRes = ld3320_get_result();
				printf("nAsrRes=%d\r\n",nAsrRes);				
				switch(nAsrRes)
				{
					case name:
					{           
						printf("小灰灰\r\n");	
					}break;
					case wife:    
					{
						printf("你有媳妇没\r\n");
					}break;
					case speakStore: 
					{			
						printf("讲个故事\r\n");
					}break;
					case eggPain:    
					{						
						printf("你最近是不是蛋疼\r\n");
					}break;
					case visionNum:   
					{						
						printf("你版本号是多少\r\n");
					}break;
					case todayDate: 
					{					
						printf("今天多少号\r\n");
					}break;
					case whatTime:  
					{						
						printf("现在几点了\r\n");					
					}break;
					case howOld:        
					{						
						printf("今年几岁了\r\n");
					}break;
					case haveChild:  
					{					
						printf("你生娃了没\r\n");
					}break;
					case openRelayOne: 
					{					
						printf("打开继电器一\r\n");
					}break;
					case openRelayTwo:
					{						
						printf("打开继电器二\r\n");
					}break;
					case closeRelayOne: 
					{						
						printf("关闭继电器一\r\n");
					}break;
					case closeRelayTwo: 
					{						
						printf("关闭继电器二\r\n");
					}break;
					case openRelay:    
					{					
						printf("打开所有继电器\r\n");
					}break;
					case closeRelay:  
					{						
						printf("关闭所有继电器\r\n");
					}break;	
					case upVolume:   
					{						
						printf("调高音量\r\n");
					}break;	
					case downVolume: 
					{    
						printf("降低音量\r\n");
					}break;	
					case upSpeed:
					{					
						printf("提高语速\r\n");
					}break;	
					case downSpeed:  
					{					
						printf("降低语速\r\n");
						
					}break;					
				}
				nAsrStatus = LD_ASR_NONE;
				
			}break;
			case LD_ASR_FOUNDZERO:
			default:
			{
				nAsrStatus = LD_ASR_NONE;
				
			}break;
		}
		delay_us(2);
		i++;
		if(i>=60000)
		{
			i=0;
			turn_g_led();
		}
	}
}

 
完整资料下载：https://download.csdn.net/download/qq_15181569/11263439