设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 一个STC单片机驱动MAX7219的音乐节拍器程序
返回列表 发新帖
查看: 194|回复: 3
打印 上一主题 下一主题
收起左侧

一个STC单片机驱动MAX7219的音乐节拍器程序

[复制链接]
跳转到指定楼层
楼主
ID:39720 发表于 2026-5-3 08:10 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
main.c
  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #include "keyscan.h"

  5. // 定时器0初始化
  6. void Timer0_Init()
  7. {
  8.     TMOD |= 0x01;      // 定时器0，工作模式1
  9.     TH0 = 0xFC;        // 1ms定时
  10.     TL0 = 0x18;
  11.     ET0 = 1;           // 允许定时器0中断
  12.     TR0 = 1;           // 启动定时器0
  13.     EA = 1;            // 开启总中断
  14. }

  16. // 主函数
  17. void main()
  18. {
  19.     // 初始化
  20.     P0 = 0xFF;
  21.     P1 = 0xFF;
  22.     P2 = 0x00;  // LED初始全灭
  23.     P3 = 0xFF;

  25.     MAX7219_Init();
  26.     Clear_Display();
  27.     Display_Speed();
  28.     Display_BeatType();

  30.     Timer0_Init();

  32.     while(1)
  33.     {
  34.         Key_Scan();
  35.     }
  36. }

  38. // 定时器0中断服务程序
  39. void Timer0_ISR() interrupt 1
  40. {
  41.     TH0 = 0xFC;        // 重新装载初值
  42.     TL0 = 0x18;

  44.     timer_count++;

  46.     if(is_playing)
  47.     {
  48.         if(timer_count >= interval)
  49.         {
  50.             timer_count = 0;

  52.             // 产生节拍
  53.             Update_LEDs();
  54.             Output_Sound();

  56.             // 更新拍数
  57.             beat_count++;
  58.             if(beat_count >= beats_per_bar[beat_type])
  59.             {
  60.                 beat_count = 0;
  61.             }
  62.         }
  63.     }
  64. }



  68. keyscan.c
  69. #include "keyscan.h"
  70. unsigned int interval = 0;
  71. unsigned char is_playing = 0;
  72. unsigned char beat_count = 0;
  73. unsigned int timer_count = 0;
  74. // 按键扫描
  75. void Key_Scan()
  76. {
  77.     static unsigned char key_up_flag = 1;
  78.     static unsigned char key_down_flag = 1;
  79.     static unsigned char key_type_flag = 1;
  80.     static unsigned char key_start_flag = 1;

  82.     // 速度+按键
  83.     if(KEY_UP == 0)
  84.     {
  85.         if(key_up_flag)
  86.         {
  87.             key_up_flag = 0;
  88.             if(beat_speed < 240)
  89.             {
  90.                 beat_speed += 1;
  91.                 Display_Speed();
  92.                 if(is_playing)
  93.                 {
  94.                     // 重新计算间隔
  95.                     interval = 60000 / beat_speed;  // ms
  96.                 }
  97.             }
  98.         }
  99.     }
  100.     else
  101.     {
  102.         key_up_flag = 1;
  103.     }

  105.     // 速度-按键
  106.     if(KEY_DOWN == 0)
  107.     {
  108.         if(key_down_flag)
  109.         {
  110.             key_down_flag = 0;
  111.             if(beat_speed > 40)
  112.             {
  113.                 beat_speed -= 1;
  114.                 Display_Speed();
  115.                 if(is_playing)
  116.                 {
  117.                     interval = 60000 / beat_speed;  // ms
  118.                 }
  119.             }
  120.         }
  121.     }
  122.     else
  123.     {
  124.         key_down_flag = 1;
  125.     }

  127.     // 拍型选择按键
  128.     if(KEY_TYPE == 0)
  129.     {
  130.         if(key_type_flag)
  131.         {
  132.             key_type_flag = 0;
  133.             beat_type = (beat_type + 1) % 4;
  134.             beat_count = 0;
  135.             Display_BeatType();
  136.             Update_LEDs();
  137.         }
  138.     }
  139.     else
  140.     {
  141.         key_type_flag = 1;
  142.     }

  144.     // 开始/停止按键
  145.     if(KEY_START == 0)
  146.     {
  147.         if(key_start_flag)
  148.         {
  149.             key_start_flag = 0;
  150.             is_playing = !is_playing;
  151.             if(is_playing)
  152.             {
  153.                 beat_count = 0;
  154.                 interval = 60000 / beat_speed;  // 计算每个节拍的时间间隔(ms)
  155.                 timer_count = 0;
  156.                 // 显示运行状态
  157.                 MAX7219_WriteCmd(5, 0x80);  // 在第五位显示点
  158.             }
  159.             else
  160.             {               
  161.                 MAX7219_WriteCmd(5, 0x00);      // 显示停止状态               
  162.                 LED1 = LED2 = LED3 = LED4 = LED5 = LED6 = 0;  // 关闭所有LED
  163.             }
  164.         }
  165.     }
  166.     else
  167.     {
  168.         key_start_flag = 1;
  169.     }
  170. }

  172. void delay_ms(unsigned int ms)
  173. {
  174.     unsigned int i, j;
  175.     for(i = 0; i < ms; i++)
  176.         for(j = 0; j < 114; j++);
  177. }
  178. // 更新指示灯
  179. void Update_LEDs()
  180. {
  181.     LED1 = LED2 = LED3 = LED4 = LED5 = LED6 = 0;  // 先关闭所有LED

  183.     switch(beat_type)
  184.     {
  185.         case 0:  // 2/4拍
  186.             if(beat_count == 0) LED1 = 1;  // 强拍
  187.             if(beat_count == 1) LED2 = 1;  // 弱拍
  188.             break;

  190.         case 1:  // 3/4拍
  191.             if(beat_count == 0) LED1 = 1;  // 强拍
  192.             if(beat_count == 1) LED2 = 1;  // 弱拍
  193.             if(beat_count == 2) LED3 = 1;  // 弱拍
  194.             break;

  196.         case 2:  // 4/4拍
  197.             if(beat_count == 0) LED1 = 1;  // 强拍
  198.             if(beat_count == 1) LED2 = 1;  // 弱拍
  199.             if(beat_count == 2) LED3 = 1;  // 次强拍
  200.             if(beat_count == 3) LED4 = 1;  // 弱拍
  201.             break;

  203.         case 3:  // 6/8拍
  204.             if(beat_count == 0) LED1 = 1;  // 强拍
  205.             if(beat_count == 1) LED2 = 1;  // 弱拍
  206.             if(beat_count == 2) LED3 = 1;  // 弱拍
  207.             if(beat_count == 3) LED4 = 1;  // 次强拍
  208.             if(beat_count == 4) LED5 = 1;  // 弱拍
  209.             if(beat_count == 5) LED6 = 1;  // 弱拍
  210.             break;
  211.     }
  212. }

  214. // 输出音源信号
  215. void Output_Sound()
  216. {
  217.     // 根据拍型输出不同的音源
  218.     switch(beat_type)
  219.     {
  220.         case 0:  // 2/4拍
  221.             if(beat_count == 0)
  222.             {
  223.                 SOUND1 = 1;  // 强拍
  224.                 delay_ms(20);
  225.                 SOUND1 = 0;
  226.             }
  227.             else
  228.             {
  229.                 SOUND2 = 1;  // 弱拍
  230.                 delay_ms(10);
  231.                 SOUND2 = 0;
  232.             }
  233.             break;

  235.         case 1:  // 3/4拍
  236.             if(beat_count == 0)
  237.             {
  238.                 SOUND1 = 1;  // 强拍
  239.                 delay_ms(20);
  240.                 SOUND1 = 0;
  241.             }
  242.             else
  243.             {
  244.                 SOUND3 = 1;  // 弱拍
  245.                 delay_ms(10);
  246.                 SOUND3 = 0;
  247.             }
  248.             break;

  250.         case 2:  // 4/4拍
  251.             if(beat_count == 0)
  252.             {
  253.                 SOUND1 = 1;  // 强拍
  254.                 delay_ms(20);
  255.                 SOUND1 = 0;
  256.             } else if(beat_count == 2)
  257.             {
  258.                 SOUND2 = 1;  // 次强拍
  259.                 delay_ms(15);
  260.                 SOUND2 = 0;
  261.             }
  262.             else
  263.             {
  264.                 SOUND3 = 1;  // 弱拍
  265.                 delay_ms(10);
  266.                 SOUND3 = 0;
  267.             }
  268.             break;

  270.         case 3:  // 6/8拍
  271.             if(beat_count == 0)
  272.             {
  273.                 SOUND1 = 1;  // 强拍
  274.                 delay_ms(20);
  275.                 SOUND1 = 0;
  276.             }
  277.             else if(beat_count == 3)
  278.             {
  279.                 SOUND2 = 1;  // 次强拍
  280.                 delay_ms(15);
  281.                 SOUND2 = 0;
  282.             }
  283.             else
  284.             {
  285.                 SOUND4 = 1;  // 弱拍
  286.                 delay_ms(10);
  287.                 SOUND4 = 0;
  288.             }
  289.             break;
  290.     }
  291. }


  294. diplay.c
  295. #include "display.h"

  297. unsigned int beat_speed = 120;      // 节拍速度（BPM），默认120
  298. unsigned char beat_type = 0;        // 拍型索引 0:2/4, 1:3/4, 2:4/4, 3:6/8
  299. // 数字字体（0-9）

  301. unsigned char code font_table[] =
  302. {
  303.     0x7E, 0x30, 0x6D, 0x79, 0x33,
  304.     0x5B, 0x5F, 0x70, 0x7F, 0x7B
  305. };

  307. // 拍型对应的每小节拍数
  308. unsigned char code beats_per_bar[] = {2, 3, 4, 6};

  310. // MAX7219初始化命令
  311. unsigned char code init_cmds[][2] =
  312. {
  313.     {0x0C, 0x01},  // 关闭关机模式
  314.     {0x0B, 0x07},  // 扫描所有8位
  315.     {0x0A, 0x08},  // 亮度
  316.     {0x09, 0x00},  // 解码模式：无
  317.     {0x0F, 0x00}   // 显示测试：关闭
  318. };



  322. // MAX7219写一个字节
  323. void MAX7219_WriteByte(unsigned char data_byte)
  324. {
  325.     unsigned char i;
  326.     for(i = 0; i < 8; i++)
  327.     {
  328.         MAX7219_CLK = 0;
  329.         MAX7219_DIN = (data_byte & 0x80) ? 1 : 0;
  330.         data_byte <<= 1;
  331.         MAX7219_CLK = 1;
  332.     }
  333. }

  335. // MAX7219写命令
  336. void MAX7219_WriteCmd(unsigned char address, unsigned char data_byte)
  337. {
  338.     MAX7219_CS = 0;
  339.     MAX7219_WriteByte(address);
  340.     MAX7219_WriteByte(data_byte);
  341.     MAX7219_CS = 1;
  342. }

  344. // MAX7219初始化
  345. void MAX7219_Init()
  346. {
  347.     unsigned char i;
  348.     for(i = 0; i < 5; i++)
  349.     {
  350.         MAX7219_WriteCmd(init_cmds[i][0], init_cmds[i][1]);
  351.     }
  352. }

  354. // 在数码管上显示数字
  355. void Display_Number(unsigned char digit, unsigned char number)
  356. {
  357.     if(digit >= 1 && digit <= 8)
  358.     {
  359.         MAX7219_WriteCmd(digit, number);
  360.     }
  361. }

  363. // 显示当前速度
  364. void Display_Speed()
  365. {
  366.     unsigned char bai, shi, ge;

  368.     bai = beat_speed / 100;
  369.     shi = (beat_speed % 100) / 10;
  370.     ge = beat_speed % 10;

  372.     // 显示在4-6位数码管上
  373.     Display_Number(3, font_table[bai]);
  374.     Display_Number(2, font_table[shi]);
  375.     Display_Number(1, font_table[ge]);
  376. }

  378. // 显示拍型
  379. void Display_BeatType()
  380. {
  381.     switch(beat_type)
  382.     {
  383.         case 0: Display_Number(8, 0x6D);         //2
  384.                 Display_Number(7, 0x01);
  385.                 Display_Number(6, 0x33); break;  // 4
  386.         case 1: Display_Number(8, 0x79);         // 3
  387.                 Display_Number(7, 0x01);
  388.                 Display_Number(6, 0x33); break;  // 4
  389.         case 2: Display_Number(8, 0x33);         // 4
  390.                 Display_Number(7, 0x01);
  391.                 Display_Number(6, 0x33); break;  // 4
  392.         case 3: Display_Number(8, 0x5F);         // 6
  393.                 Display_Number(7, 0x01);
  394.                 Display_Number(6, 0x7F); break;  // 8
  395.     }
  396. }

  398. // 清除所有显示
  399. void Clear_Display()
  400. {
  401.     unsigned char i;
  402.     for(i = 1; i <= 8; i++)
  403.     {
  404.         MAX7219_WriteCmd(i, 0x00);
  405.     }
  406. }

复制代码


本主题由 51hei糖糖 执行 审核通过

评分

参与人数 1黑币 +10 收起 理由
wpppmlah + 10 赞一个！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:39720 发表于 2026-5-3 08:14 | 只看该作者
我的压缩文件怎么发呀？
回复

使用道具 举报

板凳
ID:1064915 发表于 2026-5-4 08:10 | 只看该作者
MAX7219 是美国MAXIM 公司推出的多位LED 显示驱动器，采用3 线串行接口传送数据，可直接与单片机接口连接，用户能方便修改其内部参数，以实现多位LED 显示。它内含硬件动态扫描电路、BCD译码器、段驱动器和位驱动器。
回复

使用道具 举报

地板
ID:477512 发表于 2026-5-5 08:01 | 只看该作者
压缩文件在哪里？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表