精华内容
下载资源
问答
  • 蜂鸣器播放音乐
    2022-04-28 14:38:27

    文章目录

    要求

    控制蜂鸣器播放音乐

    资源

    工程文件压缩包
    链接:https://pan.baidu.com/s/1hA-aa0JRP33IlOYFNzKf7A
    提取码:0ida

    main函数

    #include <REGX52.H>
    #include "Key.h"
    #include "Delay.h"
    #include "Nixie.h"
    #include "MATRIXLED.H"
    #include "Buzzer.h"
    
    
    void main(){
    	//8x8点阵模块
    	unsigned char code context[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0x08,0x10,0x10,0x10,0x0F,0x00,
    0x00,0x5E,0x91,0xB1,0xA2,0x7F,0x01,0x00,0x81,0xFF,0x49,0x84,0x84,0x44,0x38,0x00,
    0x81,0xFF,0x49,0x84,0x84,0x44,0x38,0x00,0x80,0xC1,0xB1,0x0F,0x0C,0xB0,0xC0,0x80,
    0x00,0x00,0x00,0x00,0x00,0x00,0x80,0xFF,0x12,0x21,0x21,0x12,0x0C,0x00,0x00,0xD1,
    0xDF,0x01,0x00,0x40,0x41,0x61,0x3F,0x41,0x41,0x60,0x00,0x00,0x20,0x20,0xFE,0x21,
    0x21,0x02,0x00,0xFF,0x08,0x10,0x10,0x10,0x0F,0x00,0x1E,0x21,0x21,0x21,0x92,0xFF,
    0x01,0x00,0x5E,0x91,0xB1,0xA2,0x7F,0x01,0x00,0x80,0xC1,0xB1,0x0F,0x0C,0xB0,0xC0,
    0x80,0x00,0x00,0x00,0xFD,0x00,0x00,0xFD,0x00,0x00,0xFD,0x00,0x00,0x00,0x00,0x00};
    	unsigned char len0=128;
    	unsigned char i;
    	unsigned char counter=0;
    	unsigned char base=1;
    	//蜂鸣器模块
    	unsigned char code Tune[]={5,5,6,5,1,7,0,5,5,6,5,2,1,0,5,5,5,3,1,7,6,0,4,4,3,1,2,1,0};
    	unsigned char code Tune_Interval[]={1,1,1,1,1,3,2,1,1,1,1,1,3,2,1,1,1,1,1,1,2,2,1,1,1,1,1,3,2};
    	unsigned int len=29;
    	unsigned int KEY;
    	while(1){
    		KEY=get_key();
    		if(KEY==1){
    			KEY=0;
    			//蜂鸣器模块
    			for(i=0;i<len;i++){
    				Buzzer_Bass_Play(Tune_Interval[i]*80,Tune[i]);
    				KEY=get_key();
    				if(KEY==4){
    					break;
    				}
    			}
    			while(1){
    				//8x8点阵模块
    				for(i=0;i<8;i++){
    					MatrixLED_ShowColumn(i,context[base+i]);
    				}
    				counter++;
    				if(counter>14){				//每一帧动画显示次数
    					counter=0;
    					base++;					//显示下一帧动画
    					if(base>len0-8){		//一共显示多少帧动画
    						base=0;
    					}
    				}
    				if(base==0){
    					KEY=0;
    					break;
    				}
    			}
    			while(1){
    				MatrixLED_ShowColumn(0,0x70);
    				MatrixLED_ShowColumn(1,0x88);
    				MatrixLED_ShowColumn(2,0x84);
    				MatrixLED_ShowColumn(3,0x62);
    				MatrixLED_ShowColumn(4,0x62);
    				MatrixLED_ShowColumn(5,0x84);
    				MatrixLED_ShowColumn(6,0x88);
    				MatrixLED_ShowColumn(7,0x70);
    				KEY=get_key();
    				if(KEY==4){
    					break;
    				}
    			}
    		}
    	}
    }
    
    更多相关内容
  • 可以发出音乐的单片机编程代码,其中包含源代码。
  • 但自从在网上看到各种用蜂鸣器播放音乐的实例,我就对蜂鸣器产生了浓厚的兴趣。 我了解到,蜂鸣器可以根据频率改变发出声音的音调,具体音符对应频率如下: 编号 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18...
  • 蜂鸣器播放音乐

    2018-04-17 19:34:07
    STC89C52控制蜂鸣器播放音乐,自己已经反复实验了,确保能正常使用,希望对初学者有帮助
  • 播放一段有200个音节的乐曲,文件齐全。使用quartusⅡ13.1进行编程,modelsim进行仿真
  • 51单片机程序蜂鸣器播放音乐-C语言版.zip
  • 适合于arduino初学者以及arduino的相关课程设计,下载安装arduino程序可直接使用,需要自己动手根据代码接线也可按自己思路改代码接线。
  • 基于STM32F103无源蜂鸣器播放音乐内含四首音乐,适用于所有单片机移植,我用的是F103ZET6
  • 资源是51单片机使用蜂鸣器播放音乐的实验例程,通过PWM信号来控制蜂鸣器,改变PWM的频率,可以改变蜂鸣器的发声音调,从而可以播放音乐
  • 11-2 蜂鸣器播放音乐

    2022-06-16 20:00:39
    11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣器播放音乐11-2 蜂鸣...
  • 51单片机+蜂鸣器 播放音乐 4按键换歌
  • C语言控制51单片机蜂鸣器播放音乐,另附单片机演奏音乐时音调和节拍的确定方法。压缩包内有两个使用51单片机播放音乐的实验程序源代码,供初学者参考。
  • FPGA设计控制蜂鸣器播放音乐实验的Verilog逻辑源码Quartus工程文件+文档说明,根据简谱不同简谱名频率让蜂鸣器发出不一样的响声,FPGA型号Cyclone4E系列中的EP4CE6F17C8,Quartus版本17.1。 module music_top ( ...
  • 使用51单片机的蜂鸣器输出三首音乐:送别、爬音阶、八月桂花。当然了,可以随意更换乐曲,把谱输入数组就行...其中蜂鸣器接p1.5,独立按键1接p3.2(外部中断0)实现暂停播放,独立按键2和3接p0.1和p0.0,实现音乐的选择
  • stm32蜂鸣器播放音频(纯音乐) 原理:定时器PWM输出到蜂鸣器,通过改变定时器重装值,改变频率,从而改变音频,我采用stm32F407zet6,蜂鸣器接在PA8,如果你的不是在TIM_Beep_Control_Init()改io 使用实例: int ...
  • 摘要:VC/C++源码,多媒体技术,51单片机,蜂鸣器 C语言控制51单片机蜂鸣器播放音乐,另附单片机演奏音乐时音调和节拍的确定方法。压缩包内有两个使用51单片机播放音乐的实验程序源代码,供初学者参考。
  • 课程设计作业,用有源蜂鸣器在树莓派上播放音乐,并且10s后暂停音乐。
  • 51单片机用蜂鸣器播放音乐,简单的程序。
  • 单片机控制蜂鸣器播放音乐,用keil软件对编写的c代码进行编译
  • 使用AT89C51单片机,无源蜂鸣器,以及LED灯...AT89C51单片机提供定时器用于产生特定的具有一定有规律的频率的方波,从而驱动蜂鸣器,使得蜂鸣器发出声响,频率与音乐的音调相对应。同时带有proteus仿真,以备代码调试。
  • 适合于arduino初学者以及arduino的相关课程设计,下载安装arduino程序可直接使用,需要自己动手根据代码接线也可按自己思路改代码接线。
  • 野火stm32指南者实现蜂鸣器播放音乐--红尘情歌,开箱即用,按键key1即可播放音乐,reset键可重置。
  • 51单片机实验-蜂鸣器播放音乐

    千次阅读 2021-10-03 19:33:39
    51单片机实验-蜂鸣器播放音乐 题目:编程实现利用单片机使蜂鸣器播放“茉莉花”的乐曲。 学校单片机时写的,利用单片机控制蜂鸣器播放乐曲,开发板上的蜂鸣器可以用三极管驱动,需要根据乐谱来设置当前节拍的发声...

    51单片机实验-蜂鸣器播放音乐

    题目:编程实现利用单片机使蜂鸣器播放“茉莉花”的乐曲。
    学习单片机时写的,利用单片机控制蜂鸣器播放乐曲,开发板上的蜂鸣器可以用三极管驱动,需要根据乐谱来设置当前节拍的发声时间。中断函数来控制蜂鸣器的发声。

    #include<reg51.h> 
    sbit Buzz = P1^6; //声明绑定蜂鸣器,接线时只需将此IO口与蜂鸣器(扬声器)信号输入端相连即可
    unsigned int code NoteFrequ[]={   
    	523,587,659,698,784,880,988,    //中音对应的1-7  
    	1047,1175,1319,1397,1568,1760,1976,	//高音对应的1-7
    	262,294,330,349,392,440,494};  //低音对应的1-7
    
    unsigned int code NoteReload[]={ //中音1-7和高音1-7对应的定时器重载值
    	65536 - (11059200/12) /(523*2),//中音1-7  
    	65536 - (11059200/12) /(587*2),  
    	65536 - (11059200/12) /(659*2),
    	65536 - (11059200/12) /(698*2),
    	65536 - (11059200/12) /(784*2),  
    	65536 - (11059200/12) /(880*2),
    	65536 - (11059200/12) /(988*2),
    	65536 - (11059200/12) /(1047*2),//高音1-7  
    	65536 - (11059200/12) /(1175*2),  
    	65536 - (11059200/12) /(1319*2),  
    	65536 - (11059200/12) /(1397*2),
    	65536 - (11059200/12) /(1568*2),
    	65536 - (11059200/12) /(1760*2),
    	65536 - (11059200/12) /(1976*2),
    	65536 - (11059200/12) /(262*2), //低音1-7
    	65536 - (11059200/12) /(294*2),
    	65536 - (11059200/12) /(330*2),
    	65536 - (11059200/12) /(349*2),
    	65536 - (11059200/12) /(392*2),
    	65536 - (11059200/12) /(440*2),
    	65536 - (11059200/12) /(494*2)};
    
    bit enable = 1; //发声使能表标识
    bit tmrflay = 0; //定时器中中断完成标识
    
    unsigned char T0RH = 0xff; //T0重载值高字节
    unsigned char T0RL = 0x00; //T0重载值低字节
    void PlayTwoTiger(); void main()
    {   
    	unsigned int i;
        EA = 1;
    	TMOD =0x01;  //模式1	
    	TH0 = T0RH;
    	TL0 = T0RL;  
    	ET0 = 1;  //使能T0中断
        TR0 = 1;  //启动
        while(1)
    	{  
    		PlayTwoTiger();
    		for(i=0;i<40000;i++); 
        }
    }
    /**音乐函数**/
    void PlayTwoTiger()
    {
    	unsigned char beat;    //节拍索引
    	unsigned char note;    //节拍对应音符
    	unsigned int time=0;   //节拍计时
    	unsigned int beattime=0;  //总时间计时
    	unsigned int soundtime=0; //没拍发声计时
    	unsigned char code PlayTwoTigerNote[]={ //音符表
    		3,3,5,6,8,8,6,5,5,6,5,
    		3,3,5,6,8,8,6,5,5,6,5,
    		5,5,5,3,5,6,6,5,
    		3,2,3,5,3,2,1,1,2,1,
    		3,2,1,3,2,3,5,6,8,5,
    		2,3,5,2,3,1,20,19,
    		20,1,2,3,
    		1,2,1,20,19
    		};  
    	unsigned char code PlayTwoBeat[]={  //节拍表,4表示一拍,1表示1/4拍,8表示两拍
    		4,2,2,2,2,2,2,4,2,2,8,
    		4,2,2,2,2,2,2,4,2,2,8,
    		4,4,4,2,2,4,4,8,
    		4,2,2,4,2,2,4,2,2,8,
    		2,2,2,2,6,2,4,2,2,8,
    		4,2,2,2,2,2,2,8,
    		4,4,6,2,
    		2,2,2,2,16
    		};   
    	for(beat=0; beat<sizeof(PlayTwoTigerNote);) //节拍索引循环变量
    	{		   
    		while(!tmrflay);   //每次定时器中断完成 节拍处理 
    		tmrflay = 0;       
    		if(time == 0)      //节拍播放完成重启
    		{
    			note = PlayTwoTigerNote[beat]-1;
    			T0RH = NoteReload[note]>>8;
    			T0RL = NoteReload[note];     //计算总时间,右移2位等于除4,移位代替除法加快速度
    			beattime = (PlayTwoBeat[beat]*NoteFrequ[note])>>2;   //计算发声时间,为总时间的0.75s
    			soundtime =beattime - (beattime>>2);  
    			enable = 1;  //开始发声  
    			time++;   
    		}
    		else    //节拍播放未结束,则继续处理
    		{
    			if(time >= beattime) //当前时间清零  
    			{
    				time = 0;     //准备重新启动
    				beat++;   
    			}
    			else      //累加时间
    			{
    				time++;   
    				if(time == soundtime)    //发声时间到达;关闭蜂鸣器
    				{
    					enable =0;      //用以区分连续两个节拍  
    				}
    			}  
    		}
    	}
    }
    
    void InterRupt() interrupt 1   //中断服务
    {
    	TH0 =T0RH;
    	TL0 =T0RL;
    	tmrflay = 1;
    	if(enable)
    	{  
    		Buzz=~Buzz;
    	}
    	else
    	{   
    		Buzz=1;
    	}
    }
    
    

    若有问题,评论留言~

    展开全文
  • 单片机控制蜂鸣器播放音乐电路+源代码+Proteus仿真
  • 51单片机控制蜂鸣器播放音乐电路+源代码+Proteus仿真
  • stm32蜂鸣器播放音乐

    热门讨论 2012-11-14 16:32:21
    用stm32f103c8t6封装,调制pwm波驱动蜂鸣器播放音乐
  • Arduino红外遥控无源蜂鸣器播放音乐

    千次阅读 2021-07-03 16:39:29
    Arduino红外遥控无源蜂鸣器播放音乐 蜂鸣器,按驱动形式来分一般分为两类,一种是有源蜂鸣器,另外一种是无源蜂鸣器。有源蜂鸣器上电就会响,可玩性不高,但无源蜂鸣器是一个很有意思的东西,可以通过改变输入的频率...

    Arduino红外遥控无源蜂鸣器播放音乐/模拟电子琴

    原文链接:https://www.yourcee.com/newsinfo/2927905.html

    简介

    请添加图片描述

    点击图片购买

    蜂鸣器,按驱动形式来分一般分为两类,一种是有源蜂鸣器,另外一种是无源蜂鸣器。有源蜂鸣器上电就会响,可玩性不高,但无源蜂鸣器是一个很有意思的东西,可以通过改变输入的频率可以使它发出不同音调的声音,利用Arduino Uno和无源蜂鸣器实现播放音乐。

    关于频谱

    下图是C调中音符所对应的频率,用里面的频率我们就可以让无源蜂鸣器发出 Do、Re、Mi、Fa、Sol、La、Si。以此类推利用蜂鸣器播放音乐就简单了很多。
    在这里插入图片描述
    除了Do、Re、Mi…外,用无源蜂鸣器播放音乐还需要注意节拍,如果节拍处理不好的话,听起来就不是那首歌了,由于每一首歌的速度都不同,所以在节拍处理上每一首歌都不一样,最好就找4/4拍的儿歌来练练手,比如《小蜜蜂》。

    实验材料

    1. Arduino Uno板
    2. 无源蜂鸣器
    3. 红外遥控一套
    4. 杜邦线

    接线

    Uno红外接收蜂鸣器
    5vVCCVCC
    GNDGNDGND
    D9I/O
    D10I/O
    在这里插入图片描述

    实验代码

    无源蜂鸣器播放
    《小蜜蜂》和
    《有酒今朝醉》----->>>>我爱您,你爱我,啦啦啦啦甜蜜蜜
    -------------------------->>>>童年就八岁,多欢趣,见到狗仔起势追。

    #include <IRremote.h>
    
    /********C调*********/
    #define L1 262
    #define L2 294
    #define L3 330
    #define L4 349   //低
    #define L5 392
    #define L6 440
    #define L7 494
    
    #define M1 523
    #define M2 587
    #define M3 659
    #define M4 698    //中
    #define M5 784
    #define M6 880
    #define M7 988
    
    #define H1 1046
    #define H2 1109
    #define H3 1318
    #define H4 1397   //高
    #define H5 1568
    #define H6 1760
    #define H7 1976
    
    #define none 0    //空
    /**********************/
    const int RECV = 10; //定义红外遥控接收器的数据接口
    IRrecv irrecv(RECV);
    decode_results results; //创建红外遥控对象
    
    
    const int Buzzer = 11; //定义蜂鸣器接口
    int arrLength;        //定义一个变量用于计算数组的长度
    
    
    /*******有酒今朝醉*******/
    void music1()
    {
      //频谱
      int music1[] = {
        L5, M1, M2,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M1, M2, none, M2, M1,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M2, M1, none,
        M4, M4, M5, M6, M6,
        M5, M5, M3, M1, M2, none, M1, M2,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M2, M1, M1
      };
      //节拍
      float music1_delay[] = {
        0.5, 0.25, 0.25,
        0.5, 0.5, 0.75, 0.25, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 1, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.75, 0.25, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 1, 1,
        1, 0.5, 0.5, 1, 1,
        0.5, 0.5, 0.5, 0.5, 1, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.25, 0.25, 1
      };
    
      for (int i = 0; i < (sizeof(music1) / sizeof(music1[0])); i++)
      {
        tone(Buzzer, music1[i]);   //驱动蜂鸣器
        delay(music1_delay[i] * 500); //节拍实现
        noTone(Buzzer);   //停止蜂鸣器
      }
    
    }
    
    
    /*******小蜜蜂*******/
    void little_Bee()
    {
      //频谱
      int little_Bee[] = {
        M5, M3, M3, none,
        M4, M2, M2, none,
        M1, M2, M3, M4,
        M5, M5, M5, none,
        M5, M3, M3, M3,
        M4, M2, M2, M2,
        M1, M3, M5, M5,
        M3, M3, M1, none,
        M2, M2, M2, M2,
        M2, M3, M4, none,
        M3, M3, M3, M3,
        M3, M4, M5, none,
        M5, M3, M3, M3,
        M4, M2, M2, M2,
        M1, M3, M5, M5,
        M3, M3, M1, none
      };
      /*由于是四四拍,所以节拍简单*/
      int Bee_delay[] = {
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1
      };
    
    
      for (int i = 0; i < (sizeof(little_Bee) / sizeof(little_Bee[0])); i++)
      {
        tone(Buzzer, little_Bee[i]);    //驱动蜂鸣器
        delay(500);   //节拍实现
        noTone(Buzzer); //关闭蜂鸣器
      }
    
    }
    
    
    
    void setup() {
      // put your setup code here, to run once:
      Serial.begin(9600);     //初始化
      irrecv.enableIRIn();    //初始化
    
    }
    
    void loop() {
      // put your main code here, to run repeatedly:
    
      /******用于查看遥控器按键的编码,在串口输出*******
        String a = ''; //定义一个空的字符串,用于接收红外遥控器返回的值
        if (irrecv.decode(&results))
        {
        a=results.value;
        Serial.println(a);
        }
      */
      if (irrecv.decode(&results))  //判断红外接收器是否收到遥控器发来的命令
      {
       
        long int a = 0;
        a=results.value;
        Serial.println(a);
    
    
        switch(a)
        {
          case 16753245 : little_Bee();break;
          case 16736925 : music1(); break;
          default: irrecv.resume(); break;
          } 
      }
    }
    

    其中IRremote.h红外的库需要注意一下,如何接收和处理遥控器发过来的值。

    这个程序是首先通过把遥控器发过来的值在串口打印出来,利用Switch…case语句把红外遥控接收到的值和实际键值做比对。

     case 16753245 : little_Bee();break;
    

    这一句就是把Switch语句中传进来的形参和红外接收器接收到的值与按键1的值做对比

     case 16736925 : music1(); break;
    

    这一句就是把Switch语句中传进来的形参和红外接收器接收到的值与按键1的值做对比
    从而达到按下按键1,播放《小蜜蜂》,按下按键2,播放《有酒今朝醉》

    模拟电子琴

    在上面程序的基础上加上一个简单的电子琴功能,分别用7个按钮控制音节,然后把C调分为3个部分,低、中、高(非音乐专用,勿喷!)。
    上面做红外遥控播放《小蜜蜂》时,用到了遥控器的1、2两颗按键,现在根据上面的代码继续拓展。

    接线

    按钮采用共阴的接法
    在这里插入图片描述

    代码

    #include <IRremote.h>
    
    /********C调*********/
    #define L1 262
    #define L2 294
    #define L3 330
    #define L4 349   //低
    #define L5 392
    #define L6 440
    #define L7 494
    
    #define M1 523
    #define M2 587
    #define M3 659
    #define M4 698    //中
    #define M5 784
    #define M6 880
    #define M7 988
    
    #define H1 1046
    #define H2 1109
    #define H3 1318
    #define H4 1397   //高
    #define H5 1568
    #define H6 1760
    #define H7 1976
    
    #define none 0    //空
    /**********************/
    const int RECV = 10; //定义红外遥控接收器的数据接口
    IRrecv irrecv(RECV);
    decode_results results; //创建红外遥控对象
    
    
    const int Buzzer = 11; //定义蜂鸣器接口
    int arrLength;        //定义一个变量用于计算数组的长度
    
    /*****定义模拟电子琴按键******/
    const int KEY_1 = 2;
    const int KEY_2 = 3;
    const int KEY_3 = 4;
    const int KEY_4 = 5;
    const int KEY_5 = 6;
    const int KEY_6 = 7;
    const int KEY_7 = 8;
    const int KEY_8 = 9;  //用于跳出电子琴循环
    
    /*******有酒今朝醉*******/
    void music1()
    {
      //频谱
      int music1[] = {
        L5, M1, M2,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M1, M2, none, M2, M1,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M2, M1, none,
        M4, M4, M5, M6, M6,
        M5, M5, M3, M1, M2, none, M1, M2,
        M3, M5, M5, M6, M5, M3, M2, M1, M1, M2,
        M3, M3, M2, M2, M1, M1
      };
      //节拍
      float music1_delay[] = {
        0.5, 0.25, 0.25,
        0.5, 0.5, 0.75, 0.25, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 1, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.75, 0.25, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 1, 1,
        1, 0.5, 0.5, 1, 1,
        0.5, 0.5, 0.5, 0.5, 1, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.5, 0.5, 0.25, 0.25, 0.5, 0.25, 0.25,
        0.5, 0.5, 0.5, 0.25, 0.25, 1
      };
    
      for (int i = 0; i < (sizeof(music1) / sizeof(music1[0])); i++)
      {
        tone(Buzzer, music1[i]);   //驱动蜂鸣器
        delay(music1_delay[i] * 500); //节拍实现
        noTone(Buzzer);   //停止蜂鸣器
      }
    
    
    }
    
    
    /*******小蜜蜂*******/
    void little_Bee()
    {
      //频谱
      int little_Bee[] = {
        M5, M3, M3, none,
        M4, M2, M2, none,
        M1, M2, M3, M4,
        M5, M5, M5, none,
        M5, M3, M3, M3,
        M4, M2, M2, M2,
        M1, M3, M5, M5,
        M3, M3, M1, none,
        M2, M2, M2, M2,
        M2, M3, M4, none,
        M3, M3, M3, M3,
        M3, M4, M5, none,
        M5, M3, M3, M3,
        M4, M2, M2, M2,
        M1, M3, M5, M5,
        M3, M3, M1, none
      };
      /*由于是四四拍,所以节拍简单*/
      int Bee_delay[] = {
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1,
        1, 1, 1, 1
      };
    
    
      for (int i = 0; i < (sizeof(little_Bee) / sizeof(little_Bee[0])); i++)
      {
        tone(Buzzer, little_Bee[i]);    //驱动蜂鸣器
        delay(500);   //节拍实现
        noTone(Buzzer); //关闭蜂鸣器
      }
    
    }
    
    
    
    void setup() {
      // put your setup code here, to run once:
      pinMode(KEY_1, INPUT_PULLUP);    //定义IO口模式
      pinMode(KEY_2, INPUT_PULLUP);
      pinMode(KEY_3, INPUT_PULLUP);
      pinMode(KEY_4, INPUT_PULLUP);
      pinMode(KEY_5, INPUT_PULLUP);
      pinMode(KEY_6, INPUT_PULLUP);
      pinMode(KEY_7, INPUT_PULLUP);
      pinMode(KEY_8, INPUT);
    
      Serial.begin(9600);     //初始化
      irrecv.enableIRIn();    //初始化
    
    }
    
    void loop() {
      // put your main code here, to run repeatedly:
    
      /******用于查看遥控器按键的编码,在串口输出*******
        String a = ''; //定义一个空的字符串,用于接收红外遥控器返回的值
        if (irrecv.decode(&results))
        {
        a=results.value;
        Serial.println(a);
        }
      */
      if (irrecv.decode(&results))  //判断红外接收器是否收到遥控器发来的命令
      {
        long int a = 0;
        a = results.value;
        Serial.println(a);
    
        switch (a)
        {
          case 16753245 : little_Bee(); break;
          case 16736925 : music1(); break;
          case 16769565 : piano_L(); break;
          case 16720605 : piano_M(); break;
          case 16712445 : piano_H(); break;
          default: irrecv.resume(); break;
        }
      }
    }
    
    
    
    
    
    
    
    /*******C调低电子琴***********/
    void piano_L()
    {
      while (1) //死循环
      {
        if (digitalRead(KEY_1) == LOW) //判断按键是否被按下
        {
          tone(Buzzer, L1);     //按下了,播放L1这个音节
          delay(100);
          noTone(Buzzer);     //停止播放
        }
        else if (digitalRead(KEY_2) == LOW)
        {
          tone(Buzzer, L2);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_3) == LOW)
        {
          tone(Buzzer, L3);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_4) == LOW)
        {
          tone(Buzzer, L4);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_5) == LOW)
        {
          tone(Buzzer, L5);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_6) == LOW)
        {
          tone(Buzzer, L6);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_7) == LOW)
        {
          tone(Buzzer, L7);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_8) == HIGH)  //如果按下的时KEY_8
        {
          break;
        }           //跳出循环
      }
    
    }
    
    /*******C调中电子琴***********/
    void piano_M()
    {
      while (1)
      {
        if (digitalRead(KEY_1) == LOW)
        {
          tone(Buzzer, M1);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_2) == LOW)
        {
          tone(Buzzer, M2);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_3) == LOW)
        {
          tone(Buzzer, M3);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_4) == LOW)
        {
          tone(Buzzer, M4);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_5) == LOW)
        {
          tone(Buzzer, M5);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_6) == LOW)
        {
          tone(Buzzer, M6);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_7) == LOW)
        {
          tone(Buzzer, M7);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_8) == HIGH)
        {
          break;
        }
      }
    
    }
    
    /*******C调高电子琴***********/
    void piano_H()
    {
      while (1)
      {
        if (digitalRead(KEY_1) == LOW)
        {
          tone(Buzzer, H1);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_2) == LOW)
        {
          tone(Buzzer, H2);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_3) == LOW)
        {
          tone(Buzzer, H3);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_4) == LOW)
        {
          tone(Buzzer, H4);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_5) == LOW)
        {
          tone(Buzzer, H5);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_6) == LOW)
        {
          tone(Buzzer, H6);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_7) == LOW)
        {
          tone(Buzzer, H7);
          delay(100);
          noTone(Buzzer);
        }
        else if (digitalRead(KEY_8) == HIGH)
        {
          break;
        }
      }
    
    }
    

    通过按下红外遥控的3、4、5号按钮,实现三个C调不同音调的选择切换。
    上电后,通过红外遥控器选择低、中、高声调的电子琴,按下按键即可实现蜂鸣器发出“Do、Re、Mi、Fa、Sol、La、Si”,可以试着弹奏自己喜欢的音乐。

    总结

    无源蜂鸣器,可以通过给它输入不同的频率,发出不同的声音,本次实验就是利用它的这个工作特性实现了简单的歌曲播放,和简易的电子琴,欢迎留言交流,大家相互学习进步。

    展开全文
  • 蜂鸣器播放音乐 fpga实现

    千次阅读 2021-09-28 11:23:19
    这里介绍无源蜂鸣器播放音乐的方法。 思路: 利用计数器产生pwm波形 根据乐谱设置震荡周期 给蜂鸣器赋值 注:一个音符响一个周期不在人耳的感知范围内,一般一个音符需要重复200以上个周期可以清楚的听到 注:音符...

    目录

    原理

    蜂鸣器分为有源蜂鸣器和无源蜂鸣器,即以有无震荡源分类,
    有震荡源直接通直流电就可发生,无震荡源则需要通震荡波才能发声。
    这里介绍无源蜂鸣器播放音乐的方法。
    思路:
    利用计数器产生pwm波形
    根据乐谱设置震荡周期
    给蜂鸣器赋值

    注:一个音符响一个周期不在人耳的感知范围内,一般一个音符需要重复200以上个周期可以清楚的听到
    在这里插入图片描述
    注:音符周期计算:时钟频率 / 音符频率 = 音符周期数
    或者 音符周期 / 时钟周期

    实现

    这里实现的《两只老虎》

    三个计数器
    cnt0 计数音符周期
    cnt1 计数一个音符响的次数
    cnt2 计数总的音符个数

    两个参数
    一个音符周期预设值
    一个音符周期占空比

    代码

    module pwm_beep2(
        input clk,
        input rst_n,
        output reg beep
    );
    
    parameter M1 = 17'd95600;
    parameter M2 = 17'd85150;
    parameter M3 = 17'd75850;
    parameter M4 = 17'd71600;
    parameter M5 = 17'd63750;
    parameter M6 = 17'd56800;
    parameter M7 = 17'd50600;
    
    reg [16:0] cnt0;//音符周期计数器
    wire add_cnt0;
    wire end_cnt0;
    
    reg [8:0] cnt1;//音符重复次数计数器
    wire add_cnt1;
    wire end_cnt1;
    
    reg [4:0] cnt2;//音符总次数
    wire add_cnt2;
    wire end_cnt2;
    
    reg 	[16:0] preset_note;//预设音符周期数
    wire 	[16:0] preset_duty;//占空比
    //音符周期计数
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt0 <= 17'b0;
        end
        else if(add_cnt0)begin
            if(end_cnt0)begin
                cnt0 <= 17'b0;
            end
            else begin
                cnt0 <= cnt0 +1'b1;
            end
        end
    end
    assign add_cnt0 = 1'b1;
    assign end_cnt0 = add_cnt0 && (cnt0 == preset_note - 1);
    
    //音符重复次数
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt1 <= 9'b0;
        end
        else if(add_cnt1)begin
            if(end_cnt1)begin
                cnt1 <= 9'b0;
            end
            else begin
                cnt1 <= cnt1 +1'b1;
            end
        end
    end
    assign add_cnt1 = end_cnt0;
    assign end_cnt1 = add_cnt1 && (cnt1 == 299);
    
    //音符总次数
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt2 <= 5'b0;
        end
        else if(add_cnt2)begin
            if(end_cnt2)begin
                cnt2 <= 5'b0;
            end
            else begin
                cnt2 <= cnt2 +1'b1;
            end
        end
    end
    assign add_cnt2 = end_cnt1;
    assign end_cnt2 = add_cnt2 && (cnt2 == 31);
    
    //给音符周期赋值 对照乐谱的音符位置赋值
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            preset_note <= 17'b0;
        end
        else begin
            case(cnt2)
                6'd0    :   preset_note <= M1;
                6'd1    :   preset_note <= M2;
                6'd2    :   preset_note <= M3;
                6'd3    :   preset_note <= M1;
                6'd4    :   preset_note <= M1;
                6'd5    :   preset_note <= M2;
                6'd6    :   preset_note <= M3;
                6'd7    :   preset_note <= M1;
                6'd8    :   preset_note <= M3;
                6'd9    :   preset_note <= M4;
                6'd10   :   preset_note <= M5;
                6'd11   :   preset_note <= M3;
                6'd12   :   preset_note <= M4;
                6'd13   :   preset_note <= M5;
                6'd14   :   preset_note <= M5;
                6'd15   :   preset_note <= M6;
                6'd16   :   preset_note <= M5;
                6'd17   :   preset_note <= M4;
                6'd18   :   preset_note <= M3;
                6'd19   :   preset_note <= M1;
                6'd20   :   preset_note <= M5;
                6'd21   :   preset_note <= M6;
                6'd22   :   preset_note <= M5;
                6'd23   :   preset_note <= M4;
                6'd24   :   preset_note <= M3;
                6'd25   :   preset_note <= M1;
                6'd26   :   preset_note <= M2;
                6'd27   :   preset_note <= M5;
                6'd28   :   preset_note <= M1;
                6'd29   :   preset_note <= M2;
                6'd30   :   preset_note <= M5;
                6'd31   :   preset_note <= M1;
                default :   preset_note <= M1;
            endcase
        end
    end
    
    //给蜂鸣器赋值,并设定占空比
    always@(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            beep <= 1'b1;
        end
        else if(cnt0 <= preset_duty)begin
            beep <= 1'b0;//蜂鸣器低电平有效
        end
        else begin
            beep <= 1'b1;
        end
    end
    assign preset_duty = preset_note >> 1;//50%占空比
    endmodule
    

    总结:不会之前感觉好难,学会之后感觉挺简单,就三个计数器,在合适的时候将周期值赋给参数就行。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,092
精华内容 836
关键字:

蜂鸣器播放音乐