51能直接驱动喇叭吗？就是直接接到单片机IO口。
能不能驱动15欧的喇叭？ 有没有什么应用的资料的？ 谢了 
悬赏分：10 - 解决时间：2009-12-10 23:24 
问题补充：具体要怎么驱动呢？？
提问者： xngh126 - 三级
;------------------------------------------------------------------
做而论道的回答：
可以使用一个PNP型的晶体管，如8550，构成一个驱动器，电路如下所示。

注意：不发音的时候，应该保持引脚的输出为高电平；
如果难以保证，则应该在电阻支路中，再串联一个10uF的电容器，起到隔直的作用。 
回答者： 做而论道 - 十一级    2009-12-6 18:04 
;------------------------------------------------------------------
其它答案：
-
你得使用一个驱动器件，单片机的IO口驱动能力不大。
回答者： -------- 二级    2009-12-6 23:04 
-
最好安装一个驱动，这样也可以直接驱动喇叭只是声音很小。毕竟单片机发出的电流电压是有限制的，一个I/0的功率不够大。加个驱动就好多了。 
回答者： ypfengye - 三级    2009-12-6 13:41
http://zhidao.baidu.com/question/128268495.html
 
 

在网上论坛看到一个贴子收集的，供大家参考

方案一：三极管驱动
 


方案二：ULN2003驱动

 


方案三：光耦+三极管驱动
 


方案四：光耦+ULN2003驱动


 

 



 

光耦内阻比较大，不能直接驱动负载，后面要加一级驱动管

我理解的所谓数据驱动程序的方法，简单而言：将数据与程序分析，将代码逻辑的组织转换成数字规律的统计。即将数据作为一个要处理的脚本（当做数据库），然后程序作为解释器，将脚本的内容用代码逻辑解释出来，实现编程功能。

这就要求我们将代码逻辑分解出其内在数据关系，这样我们就可以写出与数据无关的函数，这样的函数通用性很大，利于复用，耦合性也比较低，利于修改，且修改后不易出错。

这样的方法也有坏处，就是可读性变差，解决的办法就是多写点关于逻辑的注释。

下面举个例子：（来自书籍--单片机编程魔法师之高级裸编程思想，挺好的一本书，可以看看，可以去下载下载链接处，待有缘人！ ）

（1）要实现如下波形：



（2）我们 一般的实现方法：将上面分成16段（依据是波形存在不一样的时候作为分界点），每段单独分析。代码如下（使用51单片机实现）。

#include <reg51.h>

sbit P10=P1^0;
sbit P11=P1^1;
sbit P12=P1^2;
sbit P13=P1^3;

void delay(unsigned char d, unsigned int t)
{
	unsigned int i;

	P1 = P1 & 0xF0 | d;
	for(i=0; i<t; i++);
}

main(void)
{
	while(1)
	{
		delay(0x00, 749);		// 阶段1
		delay(0x01, 251);		// 阶段2

		delay(0x00, 749);		// 阶段3
		delay(0x03, 251);		// 阶段4

		delay(0x00, 749);		// 阶段5
		delay(0x01, 251);		// 阶段6

		delay(0x00, 749);		// 阶段7
		delay(0x07, 251);		// 阶段8

		delay(0x00, 749);		// 阶段9
		delay(0x01, 251);		// 阶段10

		delay(0x00, 749);		// 論僇11
		delay(0x03, 251);		// 論僇12

		delay(0x00, 749);		// 阶段13
		delay(0x01, 251);		// 阶段14

		delay(0x00, 749);		// 阶段15
		delay(0x0F, 251);		// 阶段16
	}
}


（3）而采用数据驱动程序的方法：将每个阶段分离出数据，然后用一个函数统一处理。本例中使用数组来存储代表各个阶段的逻辑的数据，接着用一段代码就可解决，来代码如下：

#include <reg51.h>

sbit P10=P1^0;
sbit P11=P1^1;
sbit P12=P1^2;
sbit P13=P1^3;

#define STAGES		16
unsigned char code P1_1234[] = {0, 1, 0, 3, 0, 1, 0, 7, 0, 1, 0, 3, 0, 1, 0, 15};
unsigned int code Dts[] = {749, 251, 749, 251, 749, 251, 749, 251, 749, 251, 749, 251, 749, 251, 749, 251};

void delay(unsigned char d, unsigned int t)
{
	unsigned int i;

	P1 = P1 & 0xF0 | d;
	for(i=0; i<t; i++);
}

main(void)
{
	int i;

	while(1)
	{
		for(i=0; i<STAGES; i++)
			delay(P1_1234[i], Dts[i]);
	}
}


（4）好处：似乎没有看出了，牺牲了易读性，有得必有失，我们会的得到什么？

再举几个例子：实现以下波形。对于这个波形，如果我们不采用数据驱动程序的方法，那么相当于重写（重新分阶段，不难但是繁琐），而使用这种高阶的方法后，解释器代码一个字母都不用改变。



数据驱动程序的代码如下：

#include <reg51.h>

sbit P10=P1^0;
sbit P11=P1^1;
sbit P12=P1^2;
sbit P13=P1^3;

#define STAGES		8
unsigned char code P1_1234[] = {0, 1, 3, 7, 15, 7, 3, 1};

void delay(unsigned char d, unsigned int t)
{
	unsigned int i;

	P1 = P1 & 0xF0 | d;
	for(i=0; i<t; i++);
}

main(void)
{
	int i;

	while(1)
	{
		for(i=0; i<STAGES; i++)
			delay(P1_1234[i], 500);
	}
}

（5）总结：

虽然数据驱动代码这种高阶的方法不是万能，但是对于相似的编程要求，则给我们提供了一种可复用的方法，避免一些简单却繁琐的工作任务。

还有， 用这种方法记得写注释，不然不仅别人看不懂， 就连几天后的你再次回顾时，都不知道是怎么写出来的。

一、使用proteus绘制简单的电路图，用于后续仿真

 



二、编写程序

/********************************************************************************************************************
----	@Project:	LED-74HC595
----	@File:	main.c
----	@Edit:	ZHQ
----	@Version:	V1.0
----	@CreationTime:	20200524
----	@ModifiedTime:	20200524
----	@Description:	两片联级的74HC595驱动的16个LED灯交叉闪烁。比如，先是第1,3,5,7,9,11,13,15八个灯亮，其它的灯都灭。然后再反过来，原来亮的就灭，原来灭的就亮。交替闪烁。
----	单片机：AT89C52
********************************************************************************************************************/
#include "reg52.h"
/*——————宏定义——————*/
#define FOSC 11059200L
#define T1MS (65536-FOSC/12/1000)   /*1ms timer calculation method in 12Tmode*/

#define const_time_level  400   


/*——————变量函数定义及声明——————*/
/*定义74HC595*/
sbit Hc595_Sh = P2^3;
sbit Hc595_St = P2^4;
sbit Hc595_Ds = P2^5;

unsigned char ucLED1 = 0;   /*代表16个灯的亮灭状态，0代表灭，1代表亮*/
unsigned char ucLED2 = 0;
unsigned char ucLED3 = 0;
unsigned char ucLED4 = 0;
unsigned char ucLED5 = 0;
unsigned char ucLED6 = 0;
unsigned char ucLED7 = 0;
unsigned char ucLED8 = 0;
unsigned char ucLED9 = 0;
unsigned char ucLED10 = 0;
unsigned char ucLED11 = 0;
unsigned char ucLED12 = 0;
unsigned char ucLED13 = 0;
unsigned char ucLED14 = 0;
unsigned char ucLED15 = 0;
unsigned char ucLED16 = 0;


unsigned char ucLed_update = 0;  /*刷新变量。每次更改LED灯的状态都要更新一次。*/

unsigned char ucLedStep = 0; /*步骤变量*/
unsigned int  uiTimeCnt = 0; /*统计定时中断次数的延时计数器*/

unsigned char ucLedStatus16_09 = 0;   /*代表底层74HC595输出状态的中间变量*/
unsigned char ucLedStatus08_01 = 0;   /*代表底层74HC595输出状态的中间变量*/

/**
* @brief  定时器0初始化函数
* @param  无
* @retval 初始化T0
**/
void Init_T0(void)
{
	TMOD = 0x01;                    /*set timer0 as mode1 (16-bit)*/
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
}
/**
* @brief  外围初始化函数
* @param  无
* @retval 初始化外围
**/
void Init_Peripheral(void)
{
	ET0 = 1;/*允许定时中断*/
	TR0 = 1;/*启动定时中断*/
	EA = 1;/*开总中断*/

}

/**
* @brief  初始化函数
* @param  无
* @retval 初始化单片机
**/
void	Init(void)
{
	Init_T0();
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Long(unsigned int uiDelayLong)
{
   unsigned int i;
   unsigned int j;
   for(i=0;i<uiDelayLong;i++)
   {
      for(j=0;j<500;j++)  /*内嵌循环的空指令数量*/
          {
             ; /*一个分号相当于执行一条空语句*/
          }
   }
}
/**
* @brief  延时函数
* @param  无
* @retval 无
**/
void Delay_Short(unsigned int uiDelayShort)
{
   unsigned int i;
   for(i=0;i<uiDelayShort;i++)
   {
		 ; /*一个分号相当于执行一条空语句*/
   }
}

/**
* @brief  595驱动函数
* @param  无
* @retval * 两个联级74HC595的工作过程：
* 每个74HC595内部都有一个8位的寄存器，两个联级起来就有两个寄存器。ST引脚就相当于一个刷新
* 信号引脚，当ST引脚产生一个上升沿信号时，就会把寄存器的数值输出到74HC595的输出引脚并且锁存起来，
* DS是数据引脚，SH是把新数据送入寄存器的时钟信号。也就是说，SH引脚负责把数据送入到寄存器里，ST引脚
* 负责把寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来。
**/
void HC595_Drive(unsigned char ucLedStatusTemp16_09, unsigned char ucLedStatusTemp08_01)
{
	unsigned char i;
	unsigned char ucTempData;
	Hc595_Sh = 0;
	Hc595_St = 0;	
	
	ucTempData = ucLedStatusTemp16_09;	/*先送高8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Hc595_Ds = 1;
		}
		else
		{
			Hc595_Ds = 0;
		}
		Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		Delay_Short(15); 
		Hc595_Sh = 1;
		Delay_Short(15); 	
			
		ucTempData = ucTempData <<1;
	}
	ucTempData = ucLedStatusTemp08_01;	/*再先送低8位*/
	for(i = 0; i < 8; i ++)
	{
		if(ucTempData >= 0x80)
		{
			Hc595_Ds = 1;
		}
		else
		{
			Hc595_Ds = 0;
		}
		Hc595_Sh = 0;	/*SH引脚的上升沿把数据送入寄存器*/
		Delay_Short(15); 
		Hc595_Sh = 1;
		Delay_Short(15); 	
			
		ucTempData = ucTempData <<1;
	}
	
	Hc595_St = 0;	/*ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来*/
	Delay_Short(15);
	Hc595_St = 1;
	Delay_Short(15);
	
	Hc595_Sh = 0;	/*拉低，抗干扰就增强*/
	Hc595_St = 0;
	Hc595_Ds = 0;
}
/**
* @brief  LED更新函数
* @param  无
* @retval 
* 把74HC595驱动程序翻译成类似单片机IO口直接驱动方式的过程。
* 每次更新LED输出，记得都要把ucLed_update置1表示更新。
**/
void LED_Update()
{
	if(ucLed_update == 1)
	{
		ucLed_update = 0;	/*及时清零，让它产生只更新一次的效果，避免一直更新。*/
		if(ucLED1 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x01;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfe;
		}
		if(ucLED2 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x02;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfd;
		}
		if(ucLED3 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x04;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xfb;
		}
		if(ucLED4 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x08;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xf7;
		}		
		if(ucLED5 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x10;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xef;
		}
		if(ucLED6 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x20;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xdf;
		}
		if(ucLED7 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x40;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0xbf;
		}
		if(ucLED8 == 1)
		{
			ucLedStatus08_01 = ucLedStatus08_01 | 0x80;
		}
		else
		{
			ucLedStatus08_01 = ucLedStatus08_01 & 0x7f;
		}
		if(ucLED9 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x01;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfe;
		}
		if(ucLED10 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x02;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfd;
		}
		if(ucLED11 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x04;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xfb;
		}
		if(ucLED12 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x08;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xf7;
		}		
		if(ucLED13 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x10;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xef;
		}
		if(ucLED14 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x20;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xdf;
		}
		if(ucLED15 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x40;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0xbf;
		}
		if(ucLED16 == 1)
		{
			ucLedStatus16_09 = ucLedStatus16_09 | 0x80;
		}
		else
		{
			ucLedStatus16_09 = ucLedStatus16_09 & 0x7f;
		}
		HC595_Drive(ucLedStatus16_09, ucLedStatus08_01);
	}
}
/**
* @brief  LED闪烁函数
* @param  无
* @retval 无
**/
void LED_Flicker(void)
{
	switch(ucLedStep)
	{
		case 0:
			if(uiTimeCnt >= const_time_level)
			{
				uiTimeCnt = 0;	/*时间计数器清零*/
				
				ucLED1 = 1;	/*每个变量都代表一个LED灯的状态*/
				ucLED2 = 0;
				ucLED3 = 1;
				ucLED4 = 0;
				ucLED5 = 1;
				ucLED6 = 0;
				ucLED7 = 1;
				ucLED8 = 0;
				ucLED9 = 1;
				ucLED10 = 0;
				ucLED11 = 1;
				ucLED12 = 0;
				ucLED13 = 1;
				ucLED14 = 0;
				ucLED15 = 1;
				ucLED16 = 0;
				
				ucLed_update = 1;  /*更新显示*/
				ucLedStep = 1;
			}
		break;
		case 1:
			if(uiTimeCnt >= const_time_level)
			{
				uiTimeCnt = 0;	/*时间计数器清零*/
				
				ucLED1 = 0;	/*每个变量都代表一个LED灯的状态*/
				ucLED2 = 1;
				ucLED3 = 0;
				ucLED4 = 1;
				ucLED5 = 0;
				ucLED6 = 1;
				ucLED7 = 0;
				ucLED8 = 1;
				ucLED9 = 0;
				ucLED10 = 1;
				ucLED11 = 0;
				ucLED12 = 1;
				ucLED13 = 0;
				ucLED14 = 1;
				ucLED15 = 0;
				ucLED16 = 1;
				
				ucLed_update = 1;  /*更新显示*/
				ucLedStep = 0;
			}			
		break;
	}
}
/**
* @brief  定时器0中断函数
* @param  无
* @retval 无
**/
void ISR_T0(void)	interrupt 1
{
	TF0 = 0;  /*清除中断标志*/
  TR0 = 0; /*关中断*/
	
	if(uiTimeCnt < 0xffff)	/*设定这个条件，防止uiTimeCnt超范围。*/
	{
		uiTimeCnt ++;		
	}
	
	TL0 = T1MS;                     /*initial timer0 low byte*/
	TH0 = T1MS >> 8;                /*initial timer0 high byte*/
  TR0 = 1; /*开中断*/	
}

/*——————主函数——————*/
/**
* @brief  主函数
* @param  无
* @retval 实现LED灯闪烁
**/
void main()
{
	/*单片机初始化*/
	Init();
	/*延时，延时时间一般是0.3秒到2秒之间，等待外围芯片和模块上电稳定*/
	Delay_Long(100);
	/*单片机外围初始化*/	
	Init_Peripheral();
	while(1)
	{
		/*按键服务函数*/
		LED_Flicker();
		/*LED更新函数*/
		LED_Update(); 
	}
}



三、仿真实现