0
0

开源小项目 - 基于无源蜂鸣器实现的音乐播放器

目录

  1.     该项目使用无源蜂鸣器实现静态音乐播放器，即需要用户手动添加歌曲节点，读者可自行扩展成动态节点，实现动态音乐播放器列表，主要实现功能如下：

  1. 支持歌曲的暂停与播放

  2. 支持上一首、下一首歌曲切换

  3. 支持自定义音乐播放模式：顺序播放、随机播放、单曲循环

  4. 支持自定义设定音乐音量大小（0-100）

    1.  主要运用知识点：

  5. 定时器配置与使用

  6. PWM配置与使用

  7. C语言结构体、结构体嵌套、枚举使用

  8. C语言指针、一维数组、二维数组、指针数组使用

  9. C语言链表使用

    1.  源码中支持的库函数清单如下：
  1. void                    beep_init(void);                                /* 无源蜂鸣器初始化 */
  2. void                    beep_handler(void);                             /* 蜂鸣器音乐播放处理函数 定时执行 */
  3. void                    music_init(void);                               /* 播放器初始化 */
  4. void                    music_pause_playback(void);                     /* 暂停播放 */
  5. void                    music_resume_playback(void);                    /* 恢复播放 */
  6. void                    music_set_volume(unsigned char volume);         /* 设置音量大小 */
  7. unsigned char           music_get_volume(void);                         /* 获取音量大小 */
  8. void                    music_set_mode(ENUM_MUSIC_MODE_TYPEDEF mode);   /* 设置播放模式 */
  9. ENUM_MUSIC_MODE_TYPEDEF music_get_mode(void);                           /* 获取播放模式 */
  10. void                    music_switch_previous(void);                    /* 播放上一首 */
  11. void                    music_switch_next(void);                        /* 播放下一首 */

蜂鸣器（音乐播放器）驱动源码下载：无源蜂鸣器实现音乐播放器功能

一、音乐简谱相关知识

  1.     简谱是一种用简单符号表示音乐音高和节奏的音乐记谱方法。关于简谱中的相关知识点统计如下：

** 1. 音符**：简谱中用不同形状的符号表示不同音高的音符。常见的音符有：C、D、E、F、G、A、B。它们分别代表了音阶中的不同音名。

** 2. 节拍**：节拍是音乐中的基本时间单位，用来划分音乐的节奏。在简谱中，节拍可以用不同的符号和线条表示，如四分音符、八分音符等。

** 3. 拍号**：简谱中的拍号用来表示每小节中的拍数，常见的拍号有2/4、3/4、4/4等。这些拍号告诉演奏者每小节有多少拍和每拍的时值。

** 4. 调号**：调号在简谱中用来表示音乐作品所采用的调性。调号可以影响乐谱中所有音符的音高，使其适应特定的音阶。

** 5. 连线**：在简谱中，如果需要表示音符的音长超过一个小节，可以使用连线将两个相同音符连接起来，延长音符的时值。

** 6. 休止符**：除了音符之外，简谱还包括用来表示休止的符号。休止符用来表示音乐中的停顿或静默。

1、音符

  1.     在简谱中，用以表示音的高低及相互关系的基本符号，为七个阿拉伯数字：即１、２、３、４、５、６、７，唱作do、re、mi、fa、sol、la、si，称为唱名。


图1 音符说明

注意：一个音符由这个音的音高和对应的时值组成。

  1.     在简谱中，如果音符时值的长短用短横线“-”表示，就称为单纯音符。单纯音符除四分音符外，有以下两种形式：

**1. **在基本音符右侧加记一条短横线

  1.     表示增长原音符时值的一倍。这类加记在音符右侧、使音符时值增长的短横线，称为增时线。**增时线越多，音符的时值越长。**

**2. **在基本音符下方加记一条短横线

** 表示缩短原音符时值的一半。这类加记在音符下方、使音符时值缩短的短横线，称为减时线。减时线越多，音符的时值越短。**


图2 单纯音符说明 

  1.     在简谱中，加记在单纯音符的右侧的，使音符时值增长的小圆点"·"，称为附点。加记附点的音符称为附点音符，附点本身并无一定的长短，其长短由前面的单纯音符来决定。**附点音符会增长原音符时值的一半**，常用于四分音符和小于四分音符的各种音符之后。


图3 附点音符说明

2、音调

  1.     在一些其他乐谱中，可能会存在一些更高或更低的音，如：
  3.     1.在基本音符上方加记一个"·"，表示该音升高一个八度，称为高音；
  5.     2.加记两个":"，则表示该音升高两个八度，称为倍高音。
  7.     3.在基本音符下方加记一个"·"，表示该音降低一个八度，称为低音；

​​​​​​​​​​​​​​ 4.加记两个":"，则表示该音降低两个八度，称为倍低音。


图4 音调说明

3、识读简谱

  1.     接下来我将以儿歌《两只老虎》的简谱来为大家简单讲解。


图5 《两只老虎》简谱 

  1.     由上图的简谱可知，该乐谱演奏使用的是C调，且每个音符使用节拍为一拍（4/4）。例如，第一个音符（1）代表使用C调音阶中的第一个音（do），且四分音符的时值为4。因此如果我们想用无源蜂鸣器演奏出上图中的这样的一首儿歌，我们需要：

1. 找到简谱中C调的音符对应的蜂鸣器频率（确定音调对应的频率）


图6 C调对应的蜂鸣器频率

2. 确定蜂鸣器演奏一拍所需的时间（即确定一个音调对应的节拍数）

  1.     源代码中我给定1/4拍为200ms，那么一拍需要的时间为800ms（用户也可根据歌曲的节奏自行设计）。

3.创建结构体确定一个音符所需的两个属性（音调频率、节拍数）

  1. /* 音符 */
  2. typedef struct {
  3.     unsigned short frequency; /* 音调 -- 表现形式为蜂鸣器频率 */
  4.     unsigned char duration;   /* 节拍 -- 表现形式为重复次数 */
  5. } STRUCT_MUSIC_NOTE_TYPEDEF;

4.将《两只老虎》简谱的每个音符使用结构体数组编写好代码

  1.     下面代码中的{523, 4}代表do的频率是523Hz，由于定义的基准节拍为1/4拍，歌曲中一个音符是4/4拍，因此这里填写4。
  1. /* 两只老虎 歌单 C调 4/4 */
  2. STRUCT_MUSIC_NOTE_TYPEDEF twoTigers_notes[32] = {
  3.     /* 两只老虎 */
  4.     {523, 4}, {587, 4}, {659, 4}, {523, 4},
  5.     /* 两只老虎 */
  6.     {523, 4}, {587, 4}, {659, 4}, {523, 4},
  7.     /* 跑得快 */
  8.     {659, 4}, {698, 4}, {784, 8},
  9.     /* 跑得快 */
  10.     {659, 4}, {698, 4}, {784, 8},
  11.     /* 一只没有眼睛 */
  12.     {784, 3}, {880, 1}, {784, 3}, {698, 1}, {659, 4}, {523, 4},
  13.     /* 一只没有耳朵 */
  14.     {784, 3}, {880, 1}, {784, 3}, {698, 1}, {659, 4}, {523, 4},
  15.     /* 真奇怪 */
  16.     {523, 4}, {784, 4}, {523, 8},
  17.     /* 真奇怪 */
  18.     {523, 4}, {784, 4}, {523, 8},
  19. };

5.创建静态歌单列表

  1.     这里我以另外两首歌《生日快乐》和《私奔》（看完房客的后遗症，哈哈哈）为例，创建结构体数组如下：
  1. /* 生日快乐 歌单 F调 3/4 -->目前使用的是C调 */
  2. STRUCT_MUSIC_NOTE_TYPEDEF birthday_notes[25] = {
  3.     /* 祝你生日快乐 */
  4.     {392, 3}, {392, 3}, {440, 6}, {392, 6}, {523, 6}, {494, 12},
  5.     /* 祝你生日快乐 */
  6.     {392, 3}, {392, 3}, {440, 6}, {392, 6}, {587, 6}, {523, 12},
  7.     /* 祝你生日快乐 */
  8.     {392, 3}, {392, 3}, {784, 6}, {659, 6}, {523, 6}, {494, 6}, {466, 6},
  9.     /* 祝你生日快乐 */
  10.     {698, 4}, {698, 1}, {659, 3}, {523, 3}, {587, 6}, {523, 12},
  11. };
  13. /* 私奔 歌单 A调 4/4 -->目前使用的是C调 */
  14. STRUCT_MUSIC_NOTE_TYPEDEF elope_notes[41] = {
  15.     /* 把青春献给 */
  16.     {392, 1}, {784, 2}, {784, 2}, {784, 2}, {784, 2}, {784, 4}, {659, 2}, {587, 2},
  17.     /* 身后那座 */
  18.     {587, 2}, {659, 2}, {659, 2}, {784, 2}, {784, 2}, {784, 2}, {880, 4},
  19.     /* 辉煌的都市 */
  20.     {523, 4}, {523, 4}, {440, 2}, {523, 4}, {440, 2},
  21.     /* 为了这个 */
  22.     {440, 2}, {523, 2}, {523, 2}, {523, 2}, {523, 2}, {440, 2}, {392, 2},
  23.     /* 美梦我们 */
  24.     {392, 2}, {523, 2}, {523, 2}, {523, 2}, {523, 2}, {784, 6},
  25.     /* 付出着代价 */
  26.     {659, 2}, {587, 2}, {523, 2}, {523, 2}, {523, 2}, {659, 2}, {523, 2}, {587, 2},
  27. };
  1.     然后将三首歌的结构体数组存放到结构体指针数组中，方便我们后续使用链表进行索引
  1. STRUCT_MUSIC_NOTE_TYPEDEF *notes[SONG_MAX] = {
  2.     birthday_notes, /* 生日快乐 */
  3.     twoTigers_notes,/* 两只老虎 */
  4.     elope_notes     /* 私奔 */
  5. };
  1.     这里面还引用了枚举值SONG_MAX，该枚举用于定义我们的歌曲列表中有哪些歌曲，枚举代码说明如下：
  1. /* 歌曲曲目定义 */
  2. typedef enum {
  3.     SONG_BIRTHDAY,  /* 歌曲 生日快乐 */
  4.     SONG_TWO_TIGER, /* 歌曲 两只老虎 */
  5.     SONG_ELOPE,     /* 歌曲 私奔 */
  6.     SONG_MAX,
  7. } ENUM_MUSIC_SONG_TYPEDEF;
  1.     为什么需要创建这样的一个枚举类型呢？是为了方便我们后续找到我们的歌曲列表中有多少首歌，当我们新增一首歌之后，只需要将歌曲的枚举声明添加到SONG_ELOPE之后，SONG_MAX之前，这样当我们每次调用SONG_MAX就能获取到歌曲里有多少首歌啦！

二、音乐播放器实现过程

1、 无源蜂鸣器初始化配置

无源蜂鸣器配置主要分为两个部分：GPIO引脚配置与复用的定时器通道配置，代码如下：

  1. /* 无源蜂鸣器使用引脚 */
  2. #define     BEEP_RCC_CLK        RCC_APB2Periph_GPIOB
  3. #define     BEEP_GPIO_PORT      GPIOB
  4. #define     BEEP_GPIO_PIN       GPIO_Pin_1
  6. /**
  7.  * @功能描述 GPIO基础功能初始化
  8.  * @入口参数 无
  9.  * @输出参数 无
  10.  */
  11. static void beep_gpio_config(void)
  12. {
  13.     RCC_APB2PeriphClockCmd(BEEP_RCC_CLK | RCC_APB2Periph_AFIO, ENABLE);   /* 使能端口时钟并开启复用时钟 */
  14.     
  15.     GPIO_InitTypeDef  GPIO_InitStructure;
  16.     GPIO_InitStructure.GPIO_Pin     = BEEP_GPIO_PIN;
  17.     GPIO_InitStructure.GPIO_Speed   = GPIO_Speed_50MHz;
  18.     GPIO_InitStructure.GPIO_Mode    = GPIO_Mode_AF_PP;
  19.     GPIO_Init(BEEP_GPIO_PORT, &GPIO_InitStructure);
  20. }
  22. /**
  23.  * @功能描述 定时器复用功能PWM初始化
  24.  * @入口参数 无
  25.  * @输出参数 无
  26.  */
  27. static void beep_pwm_config(void) 
  28. {
  29.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3,ENABLE); /* 开启时钟 */
  30.     
  31.     TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStruct;     /* 定时器初始化 */
  32.     TIM_TimeBaseInitStruct.TIM_ClockDivision = TIM_CKD_DIV1;        /* 分频因子 */
  33.     TIM_TimeBaseInitStruct.TIM_CounterMode   = TIM_CounterMode_Up;  /* 向上计数模式 */
  34.     TIM_TimeBaseInitStruct.TIM_Period        = 7200 - 1;            /* 自动重装载值 */
  35.     TIM_TimeBaseInitStruct.TIM_Prescaler     = 5 - 1;               /* 预分频值 */
  36.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStruct);                /* 完成定时器初始化 */
  37.     
  38.     TIM_OCInitTypeDef TIM_OCInitStruct; /* 定时器通道初始化 */
  39.     TIM_OCInitStruct.TIM_OCMode      = TIM_OCMode_PWM1;             /* 初始化输出比较 */
  40.     TIM_OCInitStruct.TIM_OCPolarity  = TIM_OCPolarity_High;
  41.     TIM_OCInitStruct.TIM_OutputState = TIM_OutputState_Enable;
  42.     TIM_OCInitStruct.TIM_Pulse       = 0;
  43.     TIM_OC4Init(TIM3, &TIM_OCInitStruct);                           /* 定时器通道x初始化 */
  44.     
  45.     TIM_OC4PreloadConfig(TIM3, TIM_OCPreload_Enable);               /* OCx预装载寄存器使能 */
  46.     TIM_ARRPreloadConfig(TIM3, ENABLE);
  47.     
  48.     TIM_Cmd(TIM3, ENABLE);
  49. }
  51. /**
  52.  * @功能描述 无源蜂鸣器初始化
  53.  * @入口参数 无
  54.  * @输出参数 无
  55.  */
  56. void beep_init(void)
  57. {
  58.     beep_gpio_config();
  59.     beep_pwm_config();
  60. }

2、 蜂鸣器频率、占空比、使能配置

  1.     频率配置主要用于设置蜂鸣器的输出音调，即可以演奏出歌曲中的任意音调；占空比配置主要用于设置蜂鸣器的输出音量，即通过占空比控制蜂鸣器喇叭输出的高低；使能配置主要用于设置蜂鸣器是否输出，即蜂鸣器是否需要播放当前的音乐（切换播放与暂停功能的由来）。该部分代码如下：
  1. /**
  2.  * @功能描述 设置蜂鸣器输出音量
  3.  * @入口参数 sound - 音量 0-100
  4.  * @输出参数 无
  5.  */
  6. static void beep_set_sound(unsigned char sound)
  7. {
  8.     TIM_SetCompare4(TIM3, sound*7200/100);
  9. }
  11. /**
  12.  * @功能描述 设置蜂鸣器输出频率
  13.  * @入口参数 freq 频率
  14.  * @输出参数 无
  15.  */
  16. static void beep_set_freq(unsigned short freq)
  17. {
  18.     TIM_PrescalerConfig(TIM3, 72000000/7200/freq, TIM_PSCReloadMode_Immediate);
  19. }
  21. /**
  22.  * @功能描述 设置蜂鸣器是否输出
  23.  * @入口参数 enable true-使能 false-失能
  24.  * @输出参数 无
  25.  */
  26. static void beep_enable(bool enable)
  27. {
  28.     if(enable == true) {
  29.         TIM_Cmd(TIM3, ENABLE);
  30.     }
  31.     else {
  32.         TIM_Cmd(TIM3, DISABLE);
  33.     }
  34. }
  36. /**
  37.  * @功能描述 设置蜂鸣器播放音乐的音量 音调 使能
  38.  * @入口参数 sound - 音量 0-100
  39.  * @入口参数 freq  - 音调(蜂鸣器频率)
  40.  * @入口参数 enable - 开/关蜂鸣器
  41.  * @输出参数 无
  42.  */
  43. void beep_settings(unsigned char sound, unsigned short freq, bool enable)
  44. {
  45.     beep_set_sound(sound);
  46.     beep_set_freq(freq);
  47.     beep_enable(enable);
  48. }

3、 音乐播放器列表清单初始化

  1.     接着我们就需要定义我们的静态歌曲列表中有哪些歌曲了，代码如下：
  1. STRUCT_BEEP_MUSIC_TYPEDEF myMusic[SONG_MAX] = {
  2.     {true, 10, 0, 0, 0, 0, 25, "Happy Birthday", 0, 0, 0},
  3.     {true, 50, 0, 0, 0, 0, 32, "Two Tigers",     0, 0, 0},
  4.     {true, 80, 0, 0, 0, 0, 41, "Elope",          0, 0, 0},
  5. };
  1.     这里使用了一个新的结构体STRUCT_BEEP_MUSIC_TYPEDEF，其具体定义如下：
  1. /* 音谱 */
  2. typedef struct BEEP_MUSIC{
  3.     bool isPause;                       /* 暂停/恢复音乐播放标志位 true-暂停 false-恢复 */
  4.     unsigned char volume;               /* 歌曲播放的音量大小 0-100 */
  5.     unsigned char repeats;              /* 当前节拍 需要重复的次数 */
  6.     unsigned char repeat_cnt;           /* 当前节拍 重复次数计数值 */
  7.     unsigned short curr_tone;           /* 当前的音调 */
  8.     unsigned short tone_cnt;            /* 当前音调所处的计数值 */
  9.     
  10.     unsigned short total_tone;          /* 总音调的个数 */
  11.     const char* song_title;             /* 歌曲名称 */
  12.     STRUCT_MUSIC_NOTE_TYPEDEF *notes;   /* 歌曲音符表 */
  13.     
  14.     struct BEEP_MUSIC *pre_music;       /* 指向上一首歌曲 */
  15.     struct BEEP_MUSIC *next_music;      /* 指向下一首歌曲 */
  16. } STRUCT_BEEP_MUSIC_TYPEDEF;
  1.     这个结构体用于描述音乐播放相关的信息，包括音量、播放状态、音调等，同时也包含了链表结构，因此也就可以串联多首歌曲了。

4、 音乐播放器初始化

  1. static STRUCT_BEEP_MUSIC_TYPEDEF *cur_music;    /* 当前播放歌曲指针 */
  2. static ENUM_MUSIC_MODE_TYPEDEF music_mode;      /* 歌单播放模式 */
  4. /**
  5.  * @功能描述 音乐播放器初始化函数
  6.  * @入口参数 无
  7.  * @输出参数 无
  8.  */
  9. void music_init(void)
  10. {
  11.     unsigned char i;
  12.     
  13.     /* 加载所有歌曲的歌单数据 */
  14.     for(i=0; i<SONG_MAX; i++) {
  15.         /* 为notes成员分配内存 */
  16.         myMusic[i].notes = (STRUCT_MUSIC_NOTE_TYPEDEF *)malloc(myMusic[i].total_tone * sizeof(STRUCT_MUSIC_NOTE_TYPEDEF));
  17.         /* 使用memcpy函数复制歌曲音符数据 */
  18.         memcpy(myMusic[i].notes, notes[i], myMusic[i].total_tone * sizeof(STRUCT_MUSIC_NOTE_TYPEDEF));
  19.     }
  21.     /* 使用循环链表连接所有的歌曲 */
  22.     for(i=0; i<SONG_MAX; i++) {
  23.         (i == 0)          ? (myMusic[0].pre_music = &myMusic[SONG_MAX-1])  : (myMusic[i].pre_music = &myMusic[i-1]);
  24.         (i == SONG_MAX-1) ? (myMusic[SONG_MAX-1].next_music = &myMusic[0]) : (myMusic[i].next_music = &myMusic[i+1]);
  25.     }
  26.     
  27.     cur_music = &myMusic[0];    /* 初始化歌曲指针指向第一首歌 */
  28.     music_mode = MODE_RANDOM;    /* 初始化播放模式为顺序播放模式 */
  29. }

5、 设计音乐播放器处理函数

  1. /**
  2.  * @功能描述 蜂鸣器音乐播放器入口处理函数
  3.  * @入口参数 无
  4.  * @输出参数 无
  5.  */
  6. void beep_music_handler(void)
  7. {
  8.     /* 判断歌曲不存在 或 按下暂停键 就退出播放 */
  9.     if(cur_music == NULL || cur_music->isPause == true) {
  10.         beep_enable(false);
  11.         return;
  12.     }
  13.     
  14.     if(cur_music->curr_tone >= cur_music->total_tone) {
  15.         music_switch_next();
  16.     }
  17.     
  18.     if(cur_music->repeat_cnt >= cur_music->repeats) {
  19.         cur_music->repeat_cnt = 0;
  20.         cur_music->curr_tone ++;
  21.         cur_music->repeats = cur_music->notes[cur_music->curr_tone].duration;
  22.     }
  23.     
  24.     beep_settings(cur_music->volume, cur_music->notes[cur_music->curr_tone].frequency, 1);
  25.     
  26.     cur_music->repeat_cnt ++;
  27. }
  1.     这段代码是一个处理蜂鸣器音乐播放的函数
  1. beep_music_handler

，主要功能如下：

  1. 首先判断当前的歌曲是否存在（即cur_music是否为NULL）或者当前歌曲是否处于暂停状态（isPause为true），如果是，则停止蜂鸣器的播放并退出函数。

  2. 如果当前音符的索引curr_tone大于等于总音符数total_tone，则切换到下一首歌曲（调用music_switch_next函数）。

  3. 如果当前歌曲的重复次数repeat_cnt大于等于设定的重复次数repeats，则重置重复计数器，并将当前音符索引指向下一个音符，同时更新重复次数为下一个音符的持续时间。

  4. 根据当前音符的音量和频率设置蜂鸣器的音调和音量，播放该音符。

  5. 增加当前歌曲的重复计数器值。

    1.  这个函数实现了音乐播放器的核心逻辑，包括切换音符、切换歌曲、设置音调和音量等操作，以实现音乐的连续播放。

6、 其他业务代码（暂停、播放、上一曲、下一曲、音量调节）

  1.     针对这部分的业务代码就比较简单了，只要能够理解STRUCT_BEEP_MUSIC_TYPEDEF结构体就知道这部分内容是在干嘛了，代码如下：
  1. /**
  2.  * @功能描述 音乐播放器 暂停播放音乐
  3.  * @入口参数 无
  4.  * @输出参数 无
  5.  */
  6. void music_pause_playback(void)
  7. {
  8.     cur_music->isPause = true;
  9. }
  11. /**
  12.  * @功能描述 音乐播放器 恢复播放音乐
  13.  * @入口参数 无
  14.  * @输出参数 无
  15.  */
  16. void music_resume_playback(void)
  17. {
  18.     cur_music->isPause = false;
  19. }
  21. /**
  22.  * @功能描述 音乐播放器 设置音量大小
  23.  * @入口参数 volume - 音量 0-100
  24.  * @输出参数 无
  25.  */
  26. void music_set_volume(unsigned char volume)
  27. {
  28.     cur_music->volume = volume;
  29. }
  31. /**
  32.  * @功能描述 音乐播放器 获取音量大小
  33.  * @入口参数 无
  34.  * @输出参数 volume - 音量 0-100
  35.  */
  36. unsigned char music_get_volume(void)
  37. {
  38.     return (cur_music->volume);
  39. }
  41. /**
  42.  * @功能描述 音乐播放器 设置歌曲播放模式
  43.  * @入口参数 mode - 模式 顺序 单曲 随机
  44.  * @输出参数 无
  45.  */
  46. void music_set_mode(ENUM_MUSIC_MODE_TYPEDEF mode)
  47. {
  48.     music_mode = mode;
  49. }
  51. /**
  52.  * @功能描述 音乐播放器 获取歌曲播放模式
  53.  * @入口参数 无
  54.  * @输出参数 mode - 模式 顺序 单曲 随机
  55.  */
  56. ENUM_MUSIC_MODE_TYPEDEF music_get_mode(void)
  57. {
  58.     return (music_mode);
  59. }
  61. /**
  62.  * @功能描述 音乐播放器 切换上一首
  63.  * @入口参数 无
  64.  * @输出参数 无
  65.  */
  66. void music_switch_previous(void)
  67. {
  68.     if(cur_music->pre_music != NULL) {
  69.         /* 先清除正在播放的歌曲进度 */
  70.         cur_music->isPause = true;
  71.         cur_music->repeats = 0;
  72.         cur_music->repeat_cnt = 0;
  73.         cur_music->curr_tone = 0;
  74.         cur_music->tone_cnt = 0;
  75.         
  76.         cur_music = cur_music->pre_music;
  77.         cur_music->isPause = false;
  78.     }
  79. }
  81. /**
  82.  * @功能描述 生成指定范围内的随机整数
  83.  * @入口参数 min-max 指定范围
  84.  * @输出参数 无
  85.  */
  86. static int myRandom(int min, int max)
  87. {
  88.     return min + rand() % (max - min + 1);
  89. }
  91. /**
  92.  * @功能描述 音乐播放器 切换下一首
  93.  * @入口参数 无
  94.  * @输出参数 无
  95.  */
  96. void music_switch_next(void)
  97. {
  98.     if(cur_music->next_music != NULL) {
  99.         /* 清除正在播放的歌曲进度 */
  100.         cur_music->repeats = 0;
  101.         cur_music->repeat_cnt = 0;
  102.         cur_music->curr_tone = 0;
  103.         cur_music->tone_cnt = 0;
  104.         
  105.         switch(music_mode) {
  106.             case MODE_ORDER: {
  107.                 cur_music->isPause = true;
  108.                 cur_music = cur_music->next_music;
  109.                 cur_music->isPause = false;
  110.             }break;
  111.             
  112.             case MODE_SONGLE: {
  113.                 
  114.             }break;
  115.             
  116.             case MODE_RANDOM: {
  117.                 cur_music->isPause = true;
  118.                 cur_music = &myMusic[myRandom(0, SONG_MAX-1)];
  119.                 cur_music->isPause = false;
  120.             }break;
  121.             
  122.             default: break;
  123.         }
  124.     }
  125. }

三、使用方法

1、初始化无源蜂鸣器

  1.     找到一个无源蜂鸣器，并选择使用STM32的引脚（注意需要带定时器复用功能的，如本例中的PB1），然后在main函数中调用函数beep_init()进行蜂鸣器的初始化。

2、创建歌曲简谱

  1.     找希望播放的歌曲，创建对应的结构体数组，创建步骤见 **1.3节 识读乐谱。**

** *这里注意需要有四个地方需要修改：①beep.h中的歌曲枚举需要新增自己的歌曲枚举定义；②创建歌曲对应的结构体数组；③notes指针数组中需要添加对应的结构体数组；④myMusic结构体数组中需要添加对应的歌曲初始化内容。

3、初始化音乐播放器

  1.     然后需要在main函数中调用music_init()函数去初始化我们的静态音乐播放列表。
  1.     注意：music_init()函数中初始化歌曲默认指向的第1首歌，并且播放模式为顺序播放模式。

4、 创建定时器运行音乐播放器处理函数

  1.     这里我们需要创建一个任务定时器用于定时运行函数beep_music_handler()，定时时间为我们之前给定的200ms。当然如果不想创建定时器的话呢，也可以使用延时函数进行处理。
  1.     注意：使用延时函数处理的话可能会存在任务的运行会受到延时函数的阻塞，影响系统的运行流畅度，因此推荐使用定时器。

5、 调用源码中的接口函数实现音乐播放器的功能

  1.     我们可以创建按键扫描与键值获取函数，用于使用按键控制音乐的播放与暂停、上一曲与下一曲、播放模式的切换等功能。

6、 测试代码

  1. int main(void)
  2. {
  3.     delay_init();
  4.     usart1_init(115200);
  5.     basic_tim_init();
  6.     
  7.     /* 外设初始化 */
  8.     led_init();
  9.     key_init();
  10.     lcd_init();
  11.     power_init();
  12.     beep_init();
  13.     
  14.     music_init();
  15.     
  16.     lcd_clearGram();
  17.     lcd_refreshGram();
  18.     
  19.     timer_createTask(T_TASK1, key_scan_10ms, 10);       /* 按键扫描任务 10ms */
  20.     timer_createTask(T_TASK2, beep_music_handler, 200); /* 音乐播放器处理任务 200ms */
  21.     
  22.     while(1) {
  23.         switch(key_getValue()) {
  24.             case KEY_OK_S: {
  25.                 music_pause_playback();
  26.             }break;
  27.             
  28.             case KEY_DOWN_S: {
  29.                 music_resume_playback();
  30.             }break;
  31.             
  32.             case KEY_LEFT_S: {
  33.                 music_switch_previous();
  34.             }break;
  35.             
  36.             case KEY_RIGHT_S: {
  37.                 music_switch_next();
  38.             }break;
  39.         }
  40.     }
  41. }

END

标签： 单片机 嵌入式硬件 stm32
本文转载自: https://blog.csdn.net/JJ_KING123/article/details/136437758
版权归原作者 JJ & NN 所有， 如有侵权，请联系我们删除。
登录后发布评论

“开源小项目 - 基于无源蜂鸣器实现的音乐播放器”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？