devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

2024新年快乐_用c语言制作新年贺卡

作者：笔触狂放9 | 2024-02-27 01:59:20

赞

踩

用c语言制作新年贺卡

前言

2023年马上就要过去，希望2024年会越来越好，根据自己学的内容来实现一些我的idea。

单片机

思路

最开始的构思是这样的，“2024”用数码管来输出然后中文的“新年快乐”用点阵来实现，但是点阵是动态的截图不好看，就想干脆用LCD1602输出英文的新年快乐算了，这样就只需要一个AT89C51就行了，还剩下五根引脚，想起来过年我印象中听过最多的歌是“好运来”就想增加一个蜂鸣器来播放好运来歌曲，大致的构思出的原理图如下，实验所需器件在代码后面。

3b046931d58a4e96bb4c4270e571139d.png

 2024

首先是对2024的输出，这个就是输出他的BCD码。这个网络标号最开始就是C0在上面，输出的时候发现不对，然后就反过来标记，算是蒙对的。

  1. #include<reg51.h>
  2.  
  3. void main(void){
  4. 	while(1){
  5. 		//2024 0010 0000 0010 0100
  6. 		P1=0x20;
  7. 		P3=0x24;
  8. 	}
  9. }

7fc401bec8ca423bb6a96788a6772d5c.png

Happy New Year 

用LCD 1602输出我们没必要重新书写代码，只需要修改之后的代码即可。顺便对输出“2024”部分封装成函数。字符型液晶显示器LCD 1602的显示控制（Keil+Proteus）_1602液晶显示电路在keli中名称-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_64066303/article/details/134224776

  1. #include<reg51.h>
  2. #include<intrins.h>	//包含_nop_()空函数指令的头文件
  3. #define uchar unsigned char 
  4. #define uint unsigned int
  5. #define out P0
  6. sbit RS=P2^0;//位变量
  7. sbit RW=P2^1;//位变量
  8. sbit E=P2^2;//位变量
  9. //函数声明部分
  10. void lcd_initial(void);//LCD初始化函数
  11. void check_busy(void);//检查忙标志位函数
  12. void write_command(uchar com);//写命令函数
  13. void write_data(uchar dat);//写数据函数
  14. void string(uchar ad,uchar *s);//显示字符串
  15. void delay(uint);//延时
  16. void print_LED();//输出“2024”的数码管
  17.  
  18. void main(void){
  19. 	lcd_initial();//对LCD初始化
  20. 	while(1){
  21. 		print_LED();
  22. 		string(0x81,"Happy New Year");//显示第一行的字符
  23. 		string(0xC1,"peace happiness");//显示第二行的字符
  24. 		delay(100);//延时
  25. 		write_command(0x01);//清屏
  26. 		delay(100);//延时
  27. 	}
  28. }
  29.  
  30. //延时
  31. void delay(uint j){
  32. 	uchar i=250;
  33. 	for(;j>0;j--){
  34. 		while(--i);
  35. 		i=249;
  36. 		while(--i);
  37. 		i=250;
  38. 	}
  39. }
  40.  
  41. //检查忙标志
  42. void check_busy(void){
  43. 	uchar dt;
  44. 	do{
  45. 		dt=0xff;//dt为变量单元，初值为0xff
  46. 		//RS=0,E=1时才可以读忙标志位
  47. 		E=0;
  48. 		RS=0;
  49. 		RW=1;
  50. 		E=1;
  51. 		dt=out;//out为P0口，P0口的状态送入dt中
  52. 	}while(dt&0x80);//如果忙标志位BF=1，继续循环检测，等待BF=0
  53. 	E=0;//BF=0,LCD 1602不忙，结束检测
  54. }
  55.  
  56. //写命令
  57. void write_command(uchar com){
  58. 	check_busy();
  59. 	//按规定RS和E同时为0时，才可以写命令
  60. 	E=0;
  61. 	RS=0;
  62. 	RW=0;
  63. 	out=com;//将命令com写入P0口
  64. 	E=1;//写命令时，E应为正脉冲，即正跳变，所以前面先置E=0
  65. 	_nop_();//空操作1个机器周期，等待硬件反应
  66. 	E=0;//E由高电平变为低电平，LCD 1602开始执行命令
  67. 	delay(1);//延时，等待硬件反应
  68. }
  69.  
  70. //写数据
  71. void write_data(uchar dat){
  72. 	check_busy();//检测忙标志位BF=1则等待，若BF=0，则可对LCD 1602写入命令
  73. 	E=0;//按规定写数据时，E应为正脉冲，所以先置E=0
  74. 	//按规定RS=1和RW=0时，才可以写入数据
  75. 	RS=1;
  76. 	RW=0;
  77. 	out=dat;//将数据”dat“从P0口输出，即写入LCD 1602
  78. 	E=1;//E产生正跳变
  79. 	_nop_();//空操作1个机器周期，等待硬件反应
  80. 	E=0;//E由高电平变为低电平，写数据操作结束
  81. 	delay(1);
  82. }
  83.  
  84. //液晶显示器初始化函数
  85. void lcd_initial(void){
  86. 	write_command(0x38);//8位两行显示，5*7点阵字符
  87. 	_nop_();//空操作1个机器周期，等待硬件反应
  88. 	write_command(0x0C);//开整体显示，光标关，无闪烁
  89. 	_nop_();//空操作1个机器周期，等待硬件反应
  90. 	//write_command(0x05);//光标右移
  91. 	_nop_();//空操作1个机器周期，等待硬件反应
  92. 	write_command(0x01);//清屏
  93. 	delay(1);
  94. }
  95. //输出显示字符串
  96. void string(uchar ad,uchar *s){
  97. 	write_command(ad);
  98. 	while(*s>0){
  99. 		write_data(*s++);//输出字符串，且指针增1
  100. 		delay(100);
  101. 	}
  102. }
  103.  
  104. void print_LED(){//输出“2024”的数码管
  105. 	//2024 0010 0000 0010 0100
  106. 	P1=0x20;
  107. 	P3=0x24;
  108. }

116ae46585cf41c8ad177c7fd68b2196.png

 好运来

先找到“好运来”的音乐简谱，然后带入之前的代码中。

e49385ca9d264f47ae832dc45c3ea91d.png

2ebf477100524be49a0140e910cdae88.png

单片机实验（三）-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_64066303/article/details/134624276

  1. #include<reg51.h>
  2. #include<intrins.h>	//包含_nop_()空函数指令的头文件
  3. #define uchar unsigned char 
  4. #define uint unsigned int
  5. #define out P0
  6.  
  7. #define L1  1
  8. #define L1_ 2
  9. #define L2  3
  10. #define L2_ 4
  11. #define L3  5
  12. #define L4  6
  13. #define L4_ 7
  14. #define L5  8
  15. #define L5_ 9
  16. #define L6  10
  17. #define L6_ 11
  18. #define L7  12
  19. #define M1  13
  20. #define M1_ 14
  21. #define M2  15
  22. #define M2_ 16
  23. #define M3  17
  24. #define M4  18
  25. #define M4_ 19
  26. #define M5  20
  27. #define M5_ 21
  28. #define M6  22
  29. #define M6_ 23
  30. #define M7  24
  31. #define H1  25
  32. #define H1_ 26
  33. #define H2  27
  34. #define H2_ 28
  35. #define H3  29
  36. #define H4  30
  37. #define H4_ 31
  38. #define H5  32
  39. #define H5_ 33
  40. #define H6  34
  41. #define H6_ 35
  42. #define H7  36
  43.  
  44. #define ClockSpeed 12000000 //时钟频率，Hz
  45. #define SongSpeed 240       //ms，八分音符
  46. sbit beepIO = P2^7;         //定义蜂鸣器IO口
  47.  
  48. uchar freq_select;
  49.  
  50. //音阶频率表
  51. unsigned int code freq_table[]={0,61714 ,61928 ,62131 ,62322 ,62502 ,62673 ,62833 ,62985 ,63128 ,63263 ,63391 ,63511, //低音
  52. 																	63628 ,63731 ,63835 ,63928 ,64021 ,64103 ,64185 ,64260 ,64331 ,64400 ,64463 ,64524, //中音
  53. 																	64580 ,64633 ,64684 ,64732 ,64777 ,64820 ,64860 ,64898 ,64934 ,64968 ,65000 ,65030 //高音
  54. 	                        };				
  55.  
  56. 		
  57. //好运来
  58. uchar code song[]={
  59. 	//叠个千纸鹤 再系个红腰带
  60. 	M6,3, M6,1, H1,1, H1,1, M6,3, M6,1, M5,1, M3,1, M5,1, H1,1, M6,2, 0,2,
  61. 	//愿善良的人们 天天好运来.你
  62. 	M6,1, H1,1, H1,1, H1,1, H1,2, M5,2, M6,1, M5,1, M2,1, M5,1, M3,3, M2,1,
  63. 	//勤劳生活美，你健康春常在
  64. 	M3,1, M2,1, M1,1, M3,1, M2,3, M3,1, M6,1, M5,1, M3,1, M6,1, M6,1, M5,3, 
  65. 	//你一生的忙碌为了笑逐颜开。
  66. 	M6,1, H1,1, H1,3, M6,1, H2,1, H2,1, H2,1, H1,1, M6,2, M5,1, H1,1, M6,4, M6,3, 
  67. 	//好运来，祝你好运来，好运
  68. 	M6,2, H3,3, H2,1, H2,2, H1,1, M6,1, M5,2, H1,2, M6,4, M6,2, H2,2, 
  69. 	//带来了喜和爱。好运
  70. 	H1,2, M6,1, M5,1, M2,2, M5,1, M6,1, M5,1, M3,3, M3,2, M6,3, M5,1, 
  71. 	//来，我们好运来，迎着好运来
  72. 	M6,2, M6,1, M5,1, M6,2, H2,3, H1,1, H2,4, H1,3, H1,1, H1,1, H2,1,
  73. 	//兴旺发达通四海。
  74. 	H3,1, H3,1, H2,1, H1,1, M5,2, H1,3, M6,1, M6,2, 
  75. 	40
  76. };
  77. sbit RS=P2^0;//位变量
  78. sbit RW=P2^1;//位变量
  79. sbit E=P2^2;//位变量
  80. //函数声明部分
  81. void lcd_initial(void);//LCD初始化函数
  82. void check_busy(void);//检查忙标志位函数
  83. void write_command(uchar com);//写命令函数
  84. void write_data(uchar dat);//写数据函数
  85. void string(uchar ad,uchar *s);//显示字符串
  86. void delay(uint);//延时
  87. void print_2024();//输出“2024”的数码管
  88. void print_HappyNewYear();//输出“新年快乐”的LCD 1602
  89. void timer0_initial();//初始化定时器0的状态
  90. void delay_ms(unsigned int x); //音乐延时函数
  91.  
  92. void main(void){
  93. 	uchar select;
  94. 	timer0_initial();//对定时器T0进行初始化
  95. 	lcd_initial();//对LCD初始化
  96. 	print_2024();
  97. 	print_HappyNewYear();
  98. 	while(song[select]!= 40)        //判断歌曲是否结束
  99. 	{
  100. 		freq_select=song[select];		
  101. 		if(freq_select)         //判断是否是休止符0
  102. 		{
  103. 			select++;
  104. 			delay_ms(song[select]*SongSpeed);
  105. 			TR0 = 0;   //关闭蜂鸣器一段时间再打开，模拟按键抬手动作。
  106. 			delay_ms(10);
  107. 			TR0 = 1;
  108. 			select++;
  109. 		}else{			
  110. 			TR0 = 0;
  111. 			select++;
  112. 			delay_ms(song[select]*SongSpeed);
  113. 			TR0 = 1;
  114. 			select++;
  115. 		}
  116. 	}
  117. }
  118.  
  119. //延时
  120. void delay(uint j){
  121. 	uchar i=250;
  122. 	for(;j>0;j--){
  123. 		while(--i);
  124. 		i=249;
  125. 		while(--i);
  126. 		i=250;
  127. 	}
  128. }
  129.  
  130. //检查忙标志
  131. void check_busy(void){
  132. 	uchar dt;
  133. 	do{
  134. 		dt=0xff;//dt为变量单元，初值为0xff
  135. 		//RS=0,E=1时才可以读忙标志位
  136. 		E=0;
  137. 		RS=0;
  138. 		RW=1;
  139. 		E=1;
  140. 		dt=out;//out为P0口，P0口的状态送入dt中
  141. 	}while(dt&0x80);//如果忙标志位BF=1，继续循环检测，等待BF=0
  142. 	E=0;//BF=0,LCD 1602不忙，结束检测
  143. }
  144.  
  145. //写命令
  146. void write_command(uchar com){
  147. 	check_busy();
  148. 	//按规定RS和E同时为0时，才可以写命令
  149. 	E=0;
  150. 	RS=0;
  151. 	RW=0;
  152. 	out=com;//将命令com写入P0口
  153. 	E=1;//写命令时，E应为正脉冲，即正跳变，所以前面先置E=0
  154. 	_nop_();//空操作1个机器周期，等待硬件反应
  155. 	E=0;//E由高电平变为低电平，LCD 1602开始执行命令
  156. 	delay(1);//延时，等待硬件反应
  157. }
  158.  
  159. //写数据
  160. void write_data(uchar dat){
  161. 	check_busy();//检测忙标志位BF=1则等待，若BF=0，则可对LCD 1602写入命令
  162. 	E=0;//按规定写数据时，E应为正脉冲，所以先置E=0
  163. 	//按规定RS=1和RW=0时，才可以写入数据
  164. 	RS=1;
  165. 	RW=0;
  166. 	out=dat;//将数据”dat“从P0口输出，即写入LCD 1602
  167. 	E=1;//E产生正跳变
  168. 	_nop_();//空操作1个机器周期，等待硬件反应
  169. 	E=0;//E由高电平变为低电平，写数据操作结束
  170. 	delay(1);
  171. }
  172.  
  173. //液晶显示器初始化函数
  174. void lcd_initial(void){
  175. 	write_command(0x38);//8位两行显示，5*7点阵字符
  176. 	_nop_();//空操作1个机器周期，等待硬件反应
  177. 	write_command(0x0C);//开整体显示，光标关，无闪烁
  178. 	_nop_();//空操作1个机器周期，等待硬件反应
  179. 	//write_command(0x05);//光标右移
  180. 	_nop_();//空操作1个机器周期，等待硬件反应
  181. 	write_command(0x01);//清屏
  182. 	delay(1);
  183. }
  184. //输出显示字符串
  185. void string(uchar ad,uchar *s){
  186. 	write_command(ad);
  187. 	while(*s>0){
  188. 		write_data(*s++);//输出字符串，且指针增1
  189. 		delay(100);
  190. 	}
  191. }
  192.  
  193. void print_2024(){//输出“2024”的数码管
  194. 	//2024 0010 0000 0010 0100
  195. 	P1=0x20;
  196. 	P3=0x24;
  197. }
  198.  
  199. void print_HappyNewYear(){//输出“新年快乐”的LCD 1602
  200. 	string(0x81,"Happy New Year");//显示第一行的字符
  201. 	string(0xC1,"peace happiness");//显示第二行的字符
  202. 	delay(50);//延时
  203. 	//write_command(0x01);//清屏
  204. }
  205.  
  206. void timer0_initial()//初始化定时器0的状态
  207. {
  208. 	beepIO = 0;
  209. 	TH0   = 0xFD;	
  210. 	TL0   = 0x09;
  211. 	TMOD  = 0x01;  //选择定时器0,工作方式1
  212. 	ET0   = 1;     //允许定时器0中断
  213. 	EA    = 1;     //CPU开放中断
  214. 	TF0   = 0;     //溢出标志位清0
  215. 	TR0   = 1;     //开启定时器0
  216. }
  217.  
  218. void BeepTimer0() interrupt 1	//中断函数
  219. {
  220. 	beepIO = !beepIO;   //蜂鸣器IO口高低电平转换
  221. 	TH0 = freq_table[freq_select]/256 ;
  222. 	TL0 = freq_table[freq_select]%256 ;
  223. }
  224.  
  225. void delay_ms(unsigned int x) //音乐延时函数
  226. {
  227. 	uchar t;
  228. 	while(x--) for(t=0;t<120;t++);
  229. }

110b3041fea14a8cad7c689c5c52a302.png

本来觉得影响不大的，但是忽略了音乐的播放是需要延迟来表示每一个音的节拍，所以就把lcd清屏取消了，让他就一直显示这个，目前的话就是一轮之后会重新从主函数开始，而且LCD输出的时候他会发出其他的声音。

所以又继续完善了一下

 代码

  1. #include<reg51.h>
  2. #include<intrins.h>	//包含_nop_()空函数指令的头文件
  3. #define uchar unsigned char 
  4. #define uint unsigned int
  5. #define out P0
  6.  
  7. #define L1  1
  8. #define L1_ 2
  9. #define L2  3
  10. #define L2_ 4
  11. #define L3  5
  12. #define L4  6
  13. #define L4_ 7
  14. #define L5  8
  15. #define L5_ 9
  16. #define L6  10
  17. #define L6_ 11
  18. #define L7  12
  19. #define M1  13
  20. #define M1_ 14
  21. #define M2  15
  22. #define M2_ 16
  23. #define M3  17
  24. #define M4  18
  25. #define M4_ 19
  26. #define M5  20
  27. #define M5_ 21
  28. #define M6  22
  29. #define M6_ 23
  30. #define M7  24
  31. #define H1  25
  32. #define H1_ 26
  33. #define H2  27
  34. #define H2_ 28
  35. #define H3  29
  36. #define H4  30
  37. #define H4_ 31
  38. #define H5  32
  39. #define H5_ 33
  40. #define H6  34
  41. #define H6_ 35
  42. #define H7  36
  43.  
  44. #define ClockSpeed 12000000 //时钟频率，Hz
  45. #define SongSpeed 240       //ms，八分音符
  46. sbit beepIO = P2^7;         //定义蜂鸣器IO口
  47.  
  48. uchar freq_select;
  49.  
  50. //音阶频率表
  51. unsigned int code freq_table[]={0,61714 ,61928 ,62131 ,62322 ,62502 ,62673 ,62833 ,62985 ,63128 ,63263 ,63391 ,63511, //低音
  52. 																	63628 ,63731 ,63835 ,63928 ,64021 ,64103 ,64185 ,64260 ,64331 ,64400 ,64463 ,64524, //中音
  53. 																	64580 ,64633 ,64684 ,64732 ,64777 ,64820 ,64860 ,64898 ,64934 ,64968 ,65000 ,65030 //高音
  54. 	                        };				
  55.  
  56. 		
  57. //好运来
  58. uchar code song[]={
  59. 	//叠个千纸鹤 再系个红腰带
  60. 	M6,3, M6,1, H1,1, H1,1, M6,3, M6,1, M5,1, M3,1, M5,1, H1,1, M6,2, 0,2,
  61. 	//愿善良的人们 天天好运来.你
  62. 	M6,1, H1,1, H1,1, H1,1, H1,2, M5,2, M6,1, M5,1, M2,1, M5,1, M3,3, M2,1,
  63. 	//勤劳生活美，你健康春常在
  64. 	M3,1, M2,1, M1,1, M3,1, M2,3, M3,1, M6,1, M5,1, M3,1, M6,1, M6,1, M5,3, 
  65. 	//你一生的忙碌为了笑逐颜开。
  66. 	M6,1, H1,1, H1,3, M6,1, H2,1, H2,1, H2,1, H1,1, M6,2, M5,1, H1,1, M6,4, M6,3, 
  67. 	//好运来，祝你好运来，好运
  68. 	M6,2, H3,3, H2,1, H2,2, H1,1, M6,1, M5,2, H1,2, M6,4, M6,2, H2,2, 
  69. 	//带来了喜和爱。好运
  70. 	H1,2, M6,1, M5,1, M2,2, M5,1, M6,1, M5,1, M3,3, M3,2, M6,3, M5,1, 
  71. 	//来，我们好运来，迎着好运来
  72. 	M6,2, M6,1, M5,1, M6,2, H2,3, H1,1, H2,4, H1,3, H1,1, H1,1, H2,1,
  73. 	//兴旺发达通四海。
  74. 	H3,1, H3,1, H2,1, H1,1, M5,2, H1,3, M6,1, M6,2, 
  75. 	40
  76. };
  77. sbit RS=P2^0;//位变量
  78. sbit RW=P2^1;//位变量
  79. sbit E=P2^2;//位变量
  80. //函数声明部分
  81. void lcd_initial(void);//LCD初始化函数
  82. void check_busy(void);//检查忙标志位函数
  83. void write_command(uchar com);//写命令函数
  84. void write_data(uchar dat);//写数据函数
  85. void string(uchar ad,uchar *s);//显示字符串
  86. void delay(uint);//延时
  87. void timer0_initial();//初始化定时器0的状态
  88. void delay_ms(unsigned int x); //音乐延时函数
  89. void print_2024();//输出“2024”的数码管
  90. void print_HappyNewYear();//输出“新年快乐”的LCD 1602
  91.  
  92. void main(void){
  93. 	
  94. 	print_2024();//输出“2024”的数码管
  95. 	print_HappyNewYear();//输出“新年快乐”的LCD 1602
  96. 	//其他的都静态输出即可
  97. 	while(1){
  98. 		uchar select=0;//每次重新初始化
  99. 		timer0_initial();//对定时器T0进行初始化
  100. 		while(song[select]!= 40)        //判断歌曲是否结束
  101. 		{
  102. 			freq_select=song[select];		
  103. 			if(freq_select)         //判断是否是休止符0
  104. 			{
  105. 				select++;
  106. 				delay_ms(song[select]*SongSpeed);
  107. 				TR0 = 0;   //关闭蜂鸣器一段时间再打开，模拟按键抬手动作。
  108. 				delay_ms(10);
  109. 				TR0 = 1;
  110. 				select++;
  111. 			}else{			
  112. 				TR0 = 0;
  113. 				select++;
  114. 				delay_ms(song[select]*SongSpeed);
  115. 				TR0 = 1;
  116. 				select++;
  117. 			}
  118. 		}
  119. 	}
  120. }
  121.  
  122. //延时
  123. void delay(uint j){
  124. 	uchar i=250;
  125. 	for(;j>0;j--){
  126. 		while(--i);
  127. 		i=249;
  128. 		while(--i);
  129. 		i=250;
  130. 	}
  131. }
  132.  
  133. //检查忙标志
  134. void check_busy(void){
  135. 	uchar dt;
  136. 	do{
  137. 		dt=0xff;//dt为变量单元，初值为0xff
  138. 		//RS=0,E=1时才可以读忙标志位
  139. 		E=0;
  140. 		RS=0;
  141. 		RW=1;
  142. 		E=1;
  143. 		dt=out;//out为P0口，P0口的状态送入dt中
  144. 	}while(dt&0x80);//如果忙标志位BF=1，继续循环检测，等待BF=0
  145. 	E=0;//BF=0,LCD 1602不忙，结束检测
  146. }
  147.  
  148. //写命令
  149. void write_command(uchar com){
  150. 	check_busy();
  151. 	//按规定RS和E同时为0时，才可以写命令
  152. 	E=0;
  153. 	RS=0;
  154. 	RW=0;
  155. 	out=com;//将命令com写入P0口
  156. 	E=1;//写命令时，E应为正脉冲，即正跳变，所以前面先置E=0
  157. 	_nop_();//空操作1个机器周期，等待硬件反应
  158. 	E=0;//E由高电平变为低电平，LCD 1602开始执行命令
  159. 	delay(1);//延时，等待硬件反应
  160. }
  161.  
  162. //写数据
  163. void write_data(uchar dat){
  164. 	check_busy();//检测忙标志位BF=1则等待，若BF=0，则可对LCD 1602写入命令
  165. 	E=0;//按规定写数据时，E应为正脉冲，所以先置E=0
  166. 	//按规定RS=1和RW=0时，才可以写入数据
  167. 	RS=1;
  168. 	RW=0;
  169. 	out=dat;//将数据”dat“从P0口输出，即写入LCD 1602
  170. 	E=1;//E产生正跳变
  171. 	_nop_();//空操作1个机器周期，等待硬件反应
  172. 	E=0;//E由高电平变为低电平，写数据操作结束
  173. 	delay(1);
  174. }
  175.  
  176. //液晶显示器初始化函数
  177. void lcd_initial(void){
  178. 	write_command(0x38);//8位两行显示，5*7点阵字符
  179. 	_nop_();//空操作1个机器周期，等待硬件反应
  180. 	write_command(0x0C);//开整体显示，光标关，无闪烁
  181. 	_nop_();//空操作1个机器周期，等待硬件反应
  182. 	//write_command(0x05);//光标右移
  183. 	_nop_();//空操作1个机器周期，等待硬件反应
  184. 	write_command(0x01);//清屏
  185. 	delay(1);
  186. }
  187. //输出显示字符串
  188. void string(uchar ad,uchar *s){
  189. 	write_command(ad);
  190. 	while(*s>0){
  191. 		write_data(*s++);//输出字符串，且指针增1
  192. 		delay(100);
  193. 	}
  194. }
  195.  
  196. void timer0_initial()//初始化定时器0的状态
  197. {
  198. 	beepIO = 0;
  199. 	TH0   = 0xFD;	
  200. 	TL0   = 0x09;
  201. 	TMOD  = 0x01;  //选择定时器0,工作方式1
  202. 	ET0   = 1;     //允许定时器0中断
  203. 	EA    = 1;     //CPU开放中断
  204. 	TF0   = 0;     //溢出标志位清0
  205. 	TR0   = 1;     //开启定时器0
  206. }
  207.  
  208. void BeepTimer0() interrupt 1	//中断函数
  209. {
  210. 	beepIO = !beepIO;   //蜂鸣器IO口高低电平转换
  211. 	TH0 = freq_table[freq_select]/256 ;
  212. 	TL0 = freq_table[freq_select]%256 ;
  213. }
  214.  
  215. void delay_ms(unsigned int x) //音乐延时函数
  216. {
  217. 	uchar t;
  218. 	while(x--) for(t=0;t<120;t++);
  219. }
  220.  
  221. void print_2024(){//输出“2024”的数码管
  222. 	//2024 0010 0000 0010 0100
  223. 	P1=0x20;
  224. 	P3=0x24;
  225. }
  226.  
  227. void print_HappyNewYear(){//输出“新年快乐”的LCD 1602
  228. 	lcd_initial();//对LCD初始化
  229. 	string(0x81,"Happy New Year");//显示第一行的字符
  230. 	string(0xC1,"peace happiness");//显示第二行的字符
  231. 	delay(50);//延时
  232. 	//write_command(0x01);//清屏
  233. }
  234.  
  235.  
  236.

51bd47c705cb4dce857f9a386eb720f5.png

器件名称Proteus关键字
红色共阴极数码管7SEG-BCD
蓝色共阴极数码管7SEG-BCD-BLUE
绿色共阴极数码管7SEG-BCD-GRN
51单片机AT89C51
复位按钮BUTTON
电容CAP
电解电容CAP-ELEC
晶体振荡器CRYSTAL
字符型LCD 1602显示器LM016L
滑动变阻器POT-HG
电阻RES
排阻RESPACK-8
蜂鸣器SPEAKER

好运来

C/C++ 

在B站上面看到了一个视频，打算就是实现这个烟花效果，当然光靠命令行是实现不了的。

【C语言开发】教你用代码写一个浪漫烟花特效！七夕最美的浪漫烟花代码，快写给她看一看吧！_哔哩哔哩_bilibiliicon-default.png?t=N7T8https://www.bilibili.com/video/BV16N4y1d7K6/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=7c3bfbf39d037fe80c97234396acc524

文字输出

首先需要用到EasyX库，我用的编译器是Dev-C++。

EasyX Graphics Library for C++icon-default.png?t=N7T8https://easyx.cn/15天学会EasyX 第1天：EasyX的下载与配置安装_easyx下载-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/LCR2025/article/details/131019284

 

 

 

 

链接“-leasyx -lgdi32 -lole32”

  1. #include<stdio.h>
  2. #include<easyx.h>//图形界面库
  3.  
  4. int main(){
  5. 	initgraph(1200,800);//创建窗口 宽1200 高度800
  6. 	settextcolor(YELLOW);//设置字体的颜色
  7. 	settextstyle(25,0,"楷体");//设置字体的风格 字号  
  8.  
  9. 	outtextxy(300,300,"2024新年之际，祝福你健康、快乐、平安、幸福");
  10. 	outtextxy(300,350,"愿你每天都笑容满面");
  11. 	outtextxy(300,400,"所求皆如愿，所行皆坦途，多喜乐，长安宁");
  12. 	outtextxy(300,450,"平安喜乐，万事胜意");
  13. 	outtextxy(300,500,"期末考试顺利");
  14. 	outtextxy(600,550,"——封奚泽优"); 
  15. 	getchar();//按回车键继续 
  16. 	
  17. 	while(1);
  18. 	return 0;
  19. }

 

 播放音乐

dev c++播放音乐MP3（win环境）亲测有效_怎么在devc++里面用#pragma comment (lib,“winmm.lib”)-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_47170063/article/details/110310633解决用mciSendString()函数不能播放音乐的问题_mcisendstring播放不出音乐-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/m0_46436640/article/details/106591562

链接“-lwinmm”

直接放弃这个环节了，我的一直播放不了，目前不知道是什么情况，看到有的说是不能用网易云下载的音乐要用QQ音乐下载的，也有用TEXT又不用TEXT的我这里都播放不了，直接进入下一个部分了。

有知道的大佬可以帮我分析分析

烟花

  1. //烟花弹
  2. struct yhd{
  3. 	//属性
  4. 	int x,y;//当前坐标 
  5. 	int hx,hy;//最高点的坐标 
  6. 	unsigned long t1,t2,dt;//时间来控制速度 
  7. 	IMAGE img;//保存烟花弹的图片 
  8. 	bool isshoot;//烟花是否属于正在上升的状态 
  9. }yhd;

加载图片

 这个也一直输出不了，重新安装了一下编译器，出现了一个错误，一个是中文注释不现实，一个是输出中文乱码。

解决Dev-C++中文注释无法显示，单击才能显示的问题_devc中文注释无法显示-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_46251611/article/details/123352345

DEVC++运行中文乱码的解决方法 - 哔哩哔哩 (bilibili.com)icon-default.png?t=N7T8https://www.bilibili.com/read/cv26335420/

打算换一个编译器尝试一下，暂时先这样。

  1. #include<stdio.h>
  2. #include<easyx.h>//图形界面库
  3. #include<stdlib.h>
  4. #include<time.h>
  5. #define _CRT_SECURE_NO_WARNINGS  
  6. #include<windows.h>
  7. #pragma comment(lib,"winmm.lib")//媒体库文件 
  8. #include <mmsystem.h>//媒体头文件 
  9.  
  10. //烟花弹
  11. struct yhd{
  12. 	//属性
  13. 	int x,y;//当前坐标 
  14. 	int hx,hy;//最高点的坐标 
  15. 	unsigned long t1,t2,dt;//时间来控制速度 
  16. 	IMAGE img;//保存烟花弹的图片 
  17. 	bool isshoot;//烟花是否属于正在上升的状态 
  18. }yhd;
  19.  
  20.  
  21. int main(){
  22. 	srand((unsigned)time(NULL));//选取种子文件 
  23. 	initgraph(1200,800);//创建窗口 宽1200 高度800
  24. 	//打开音乐文件 
  25. 	mciSendString(TEXT("open music.mp3 alias song"),NULL,0,NULL);//mci 媒体控制接口 
  26. 	mciSendString(TEXT("play song repeat"),NULL,0,NULL);//mci 媒体控制接口 
  27. 	
  28. 	settextcolor(YELLOW);//设置字体的颜色
  29. 	settextstyle(25,0,"楷体");//设置字体的风格 字号  
  30. 	 
  31. 	outtextxy(300,300,"2024新年之际，祝福你健康、快乐、平安、幸福");
  32. 	outtextxy(300,350,"愿你每天都笑容满面");
  33. 	outtextxy(300,400,"所求皆如愿，所行皆坦途，多喜乐，长安宁");
  34. 	outtextxy(300,450,"平安喜乐，万事胜意");
  35. 	outtextxy(300,500,"期末考试顺利");
  36. 	outtextxy(600,550,"——封奚泽优"); 
  37. 	//getchar();//按回车键继续 
  38.  
  39. 	//初始化烟花弹（烟花弹需要上升，y坐标变化，x不变） 
  40. 	yhd.x=rand()%(1200-20);
  41. 	yhd.y=750;//最开始烟花弹的位置 
  42. 	yhd.hx=yhd.x;
  43. 	yhd.hy=rand()%400;//爆炸高度 
  44. 	yhd.t1=GetTickCount();//获取当前系统的时间
  45. 	yhd.dt=10;//dt 10ms 
  46. 	yhd.isshoot=true;//最开始是上升状态
  47. 	loadimage(&yhd.img,"yhd.png",20,50);//加载图片
  48. 	putimage(yhd.x,yhd.y,&yhd.img,SRCINVERT);
  49. 	 
  50. 	while(1);
  51. 	return 0;
  52. }

大侠请重新来过

输出文字

 下载了Visual Studio 2022，先粘贴之前的代码，发现没有easyx图形库

我们重新安装一下
Visual Studio 2022手动安装EasyX_easyx下手动载-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/zeandon/article/details/130771808 

 然后就链接成功了，接着就是显示

解决VS字符集的问题，对初学者特重要_vs的项目属性里配置属性常规里面 没有字符集这个选项-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/shi_xiaobin/article/details/122389721

 播放音乐

只是播放音乐看到后面。

VS中如何导入并且播放音乐_vs2022装bgm-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/weixin_43701019/article/details/100027495 

 然后终于有声音了，结果是因为换了一首歌，都是mp3格式的，但是有的就是不行，很奇怪，避免在网易云上面下载

我这里用的是相对路径

  1. #include<stdio.h>
  2. #include<easyx.h>//图形界面库
  3. #include<stdlib.h>
  4. #include<time.h>
  5. #define _CRT_SECURE_NO_WARNINGS  
  6. #include<windows.h>
  7. #pragma comment(lib,"winmm.lib")//媒体库文件 
  8. #include <mmsystem.h>//媒体头文件 
  9.  
  10. //烟花弹
  11. struct yhd {
  12. 	//属性
  13. 	int x, y;//当前坐标 
  14. 	int hx, hy;//最高点的坐标 
  15. 	unsigned long t1, t2, dt;//时间来控制速度 
  16. 	IMAGE img;//保存烟花弹的图片 
  17. 	bool isshoot;//烟花是否属于正在上升的状态 
  18. }yhd;
  19.  
  20.  
  21. int main() {
  22. 	srand((unsigned)time(NULL));//选取种子文件 
  23. 	initgraph(1200, 800);//创建窗口 宽1200 高度800
  24. 	//打开音乐文件 
  25. 	mciSendString(L"open music.mp3 alias bgm", 0, 0, 0);//mci 媒体控制接口 
  26. 	mciSendString(L"play bgm repeat", 0, 0, 0);//mci 媒体控制接口 
  27.  
  28. 	settextcolor(YELLOW);//设置字体的颜色
  29. 	settextstyle(25, 0, _T("楷体"));//设置字体的风格 字号  
  30. 	
  31.  
  32. 	outtextxy(300, 300, _T("2024新年之际，祝福你健康、快乐、平安、幸福"));
  33. 	outtextxy(300, 350, _T("愿你每天都笑容满面"));
  34. 	outtextxy(300, 400, _T("所求皆如愿，所行皆坦途，多喜乐，长安宁"));
  35. 	outtextxy(300, 450, _T("平安喜乐，万事胜意"));
  36. 	outtextxy(300, 500, _T("期末考试顺利"));
  37. 	outtextxy(600, 550, _T("——封奚泽优"));
  38.  
  39.  
  40. 	while (1);//防止直接退出程序
  41. 	return 0;
  42. }

音乐

 果然就是音乐本身的问题，带回原来的Dev-C++还是可以运行。

烟花

加载图片

  1.  
  2.  
  3. //烟花弹
  4. struct yhd {
  5. 	//属性
  6. 	int x, y;//当前坐标 
  7. 	int hx, hy;//最高点的坐标 
  8. 	unsigned long t1, t2, dt;//时间来控制速度 
  9. 	IMAGE img;//保存烟花弹的图片 
  10. 	bool isshoot;//烟花是否属于正在上升的状态 
  11. }yhd;
  12.  
  13.  
  14.  
  15. //初始化烟花弹（烟花弹需要上升，y坐标变化，x不变） 
  16. yhd.x = rand() % (1200 - 20);
  17. yhd.y = 750;//最开始烟花弹的位置 
  18. yhd.hx = yhd.x;
  19. yhd.hy = rand() % 400;//爆炸高度 
  20. yhd.t1 = GetTickCount();//获取当前系统的时间
  21. yhd.dt = 10;//dt 10ms 
  22. yhd.isshoot = true;//最开始是上升状态
  23. loadimage(&yhd.img, _T("yhd.jpg"), 20, 50);//加载图片
  24. putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  25.

烟花上升

  1. //获取当前时间
  2. yhd.t2 = GetTickCount();//t2
  3. //速度 处于发射状态
  4. if (yhd.t2 - yhd.t1 > yhd.dt && yhd.isshoot == true) {
  5. 	//会覆盖之前的
  6. 	putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  7. 	if (yhd.y > yhd.hy) {//有一个上界
  8. 		yhd.y -= 5;//上升
  9. 	}
  10. 	putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  11. 	if(yhd.y<=yhd.hy){
  12. 		//已经到达最高点
  13. 		//1.擦除烟花弹
  14. 		putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  15. 		//停止上升
  16. 		yhd.isshoot = false;
  17. 	}
  18. 	if (yhd.isshoot == false) {
  19. 		//初始化烟花弹（烟花弹需要上升，y坐标变化，x不变） 
  20. 		yhd.x = rand() % (1200 - 20);
  21. 		yhd.y = 750;//最开始烟花弹的位置 
  22. 		yhd.hx = yhd.x;
  23. 		yhd.hy = rand() % 400;//爆炸高度 
  24. 		yhd.t1 = GetTickCount();//获取当前系统的时间
  25. 		yhd.dt = 10;//dt 10ms 
  26. 		yhd.isshoot = true;//最开始是上升状态
  27. 		loadimage(&yhd.img, _T("yhd.jpg"), 20, 50);//加载图片
  28. 		putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  29. 	}
  30. 	yhd.t1 = yhd.t2;
  31. }

中间还发现命令行界面总是需要单独关闭，弄的太烦了，然后就用了下面的方法来关闭。

#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )

 烟花

视频中的代码不完整，简直了。

定义烟花类

  1. //烟花
  2. struct yh{
  3. 	int r;//当前半径
  4. 	int maxr;//最大半径
  5. 	int x, y;//中心点的坐标(窗口)
  6. 	int cx, cy;//中心点的坐标(图片)
  7. 	int xy[240][240];//图片的宽高，保存图片中的每一个像素点
  8. 	bool isboom;//是否开始爆炸(图片的显示)
  9. 	bool isdraw;//是否开始显示(用户看到的)
  10. 	unsigned long t1, t2, dt;//爆炸的速度
  11. } yh;

 初始化烟花

  1. yh.r=0;//当前半径
  2. yh.maxr = 120;//最大半径
  3. yh.cx = 120;
  4. yh.cy = 120;//中心点的坐标(图片)
  5. yh.xy[240][240];//图片的宽高，保存图片中的每一个像素点
  6. yh.isboom=false;//是否开始爆炸(图片的显示)
  7. yh.isdraw=false;//是否开始显示(用户看到的)
  8. yh.t1 = GetTickCount();
  9. yh.dt = 5;//爆炸的速度5ms
  10. IMAGE yhimg;
  11. loadimage(&yhimg, _T("yh.jpg"), 240, 240);//加载图片
  12.  
  13. SetWorkingImage(&yhimg);//指定待获取的图片(默认是从窗口获取)
  14. //获取图片的像素点放到数组当中
  15. for (int a = 0; a < 240; a++) {
  16. 	for (int b = 0; b < 240; b++) {
  17. 		yh.xy[a][b]=getpixel(a, b);
  18. 	}
  19. }
  20. SetWorkingImage();//将烟花图片释放

 烟花的绽放

  1. //dt的数组
  2. int drt[] = { 5,5,5,15,15,15,25,25,25,55,60,65 };//烟花绽放的速度越来越慢ms
  3. yh.t2 = GetTickCount();
  4. //烟花已经爆炸
  5. if (yh.t2 - yh.t1 > yh.dt && yh.isboom == true) {
  6. 	if (yh.r < yh.maxr) {
  7. 		yh.r++;//半径不断变大，但是不能超过最大的范围
  8. 		yh.dt = drt[yh.r / 10];//dt不断变大
  9. 		yh.isdraw = true;//开始绘制
  10. 	}
  11. 	//爆炸结束(重置)
  12. 	if (yh.r >= yh.maxr - 1) {
  13. 		//停止绘制，停止爆炸
  14. 		yh.isdraw = false;
  15. 		yh.isboom = false;
  16. 		yh.t1 = GetTickCount();
  17. 		yh.dt = 5;
  18. 		yh.r = 0;
  19. 	}
  20. 	yh.t1 = yh.t2;
  21. }
  22. if (yh.isdraw == true) {
  23. 	//628次 2π
  24. 	for (double a = 0; a <= 6.28; a += 0.01) {
  25. 		//圆的轨迹方程
  26. 		int x1 = yh.cx + yh.r * cos(a);
  27. 		int y1 = yh.cy - yh.r * sin(a);
  28. 		//x1,y1 628个来自图片的像素点坐标
  29. 		yh.xy[x1][y1];
  30. 	}
  31. }

他是到这里结束了，然后无法实现烟花图片的输出，因为他并没有相关的代码，需要输出像素点。我最开始写的是putpixel(x1,y1,yh.xy[x1][y1]);发现每次输出的位置都是那一个地方，想着要和最高点的高度有关，改成了putpixel(hy.x,yh.y,yh.xy[x1][y1]);发现结果都不输出了，我想了很久发现如果坐标固定不变，那不就是一个点在一直输出，人眼无法发现这个变化，所以想应该在图片画圆的时候同步对窗口中以最高点为圆心画圆，所以最终变成了putpixel(x2,y2,yh.xy[x1][y1]);

【C/C++开发教程】图形图像处理入门，像素如何组成及图形图像识别和运算_哔哩哔哩_bilibiliicon-default.png?t=N7T8https://www.bilibili.com/video/BV1na411t7Di/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=7c3bfbf39d037fe80c97234396acc524

  1. 	//开始绘制图像
  2. 	if (yh.isdraw == true) {
  3. 		//628次 2π
  4. 		for (double a = 0; a <= 6.28; a += 0.01) {
  5. 			//圆的轨迹方程(图片)
  6. 			int x1 = yh.cx + yh.r * cos(a);
  7. 			int y1 = yh.cy - yh.r * sin(a);
  8. 			//圆的轨迹方程(窗口)
  9. 			int x2 = yh.x + yh.r * cos(a);
  10. 			int y2 = yh.y - yh.r * sin(a);
  11. 			//x1,y1 628个来自图片的像素点坐标
  12. 			putpixel(x2,y2,yh.xy[x1][y1]);
  13. 		}
  14. 	}
  15. }

 这样就实现了单个烟花的绽放

多个烟花绽放

首先判断变成了这个，需要等爆炸完之后发下一个，其次是位置不能在if (yhd.t2 - yhd.t1 > yhd.dt && yhd.isshoot == true) 里面，此时的已经不再上升了，放里面就实现不了发送多个。

  1. if (yhd.isshoot == false && yh.isboom == false) {
  2. 	//初始化烟花弹
  3. 	initYHD();
  4. }

绽放的烟花消失 

接着就是这最后一个问题了，如何让绽放的烟花自己消失。

最开始我的想法是输出一个黑色的像素点然后去覆盖他，但是考虑到有文字出现所以需要的不是覆盖而是恢复之前的，所以我的想法是用一个结构体来保存之前窗口将会被覆盖的像素，在之后的几轮中一边绽放新的一边恢复之前的，想法很好，但是现实很骨感，如果两个烟花绽放重合，你现在保存的像素之后还是有烟花绽放的影子，所以之后就像用黑色覆盖就覆盖吧，把字体重新输出不就行了。结果和现实还是有点差距。如果是重合的话，黑色还是会把之前的给覆盖了，这个目前还没解决，有大佬会的话，希望能够提供一下思路。

  1. //用于保存之前被覆盖的像素
  2. struct tmp{
  3. 	int x, y;//中心点的坐标(窗口)
  4. 	int ishuifu;//是否恢复
  5. }tmp;
  6.  
  7. //当已经发送第二个的时候恢复第一个的
  8. if (tmp.ishuifu) {
  9. 	//圆的轨迹方程(窗口)
  10. 	int x3 = tmp.x + yh.r * cos(a);
  11. 	int y3 = tmp.y - yh.r * sin(a);
  12. 	//重新弄成黑色
  13. 	putpixel(x3, y3,0x000000);
  14. }

代码

和老师讲的还是有点差距的，我的有点小丑。

  1. #include<stdio.h>
  2. #include<easyx.h>//图形界面库
  3. #include<stdlib.h>
  4. #include<graphics.h>
  5. #include<conio.h>
  6. #include<time.h>
  7. #define _CRT_SECURE_NO_WARNINGS  
  8. #include<windows.h>
  9. #pragma comment(lib,"winmm.lib")//媒体库文件 
  10. #include <mmsystem.h>//媒体头文件 
  11. #pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
  12. #include<math.h>
  13.  
  14. //烟花弹
  15. struct yhd {
  16. 	//属性
  17. 	int x, y;//当前坐标 
  18. 	int hx, hy;//最高点的坐标 
  19. 	unsigned long t1, t2, dt;//时间来控制速度 
  20. 	IMAGE img;//保存烟花弹的图片 
  21. 	bool isshoot;//烟花是否属于正在上升的状态 
  22. }yhd;
  23.  
  24. //烟花
  25. struct yh{
  26. 	int r;//当前半径
  27. 	int maxr;//最大半径
  28. 	int x, y;//中心点的坐标(窗口)
  29. 	int cx, cy;//中心点的坐标(图片)
  30. 	int xy[240][240];//图片的宽高，保存图片中的每一个像素点
  31. 	bool isboom;//是否开始爆炸(图片的显示)
  32. 	bool isdraw;//是否开始显示(用户看到的)
  33. 	unsigned long t1, t2, dt;//爆炸的速度
  34. } yh;
  35.  
  36. //用于保存之前被覆盖的像素
  37. struct tmp{
  38. 	int x, y;//中心点的坐标(窗口)
  39. 	int ishuifu;//是否恢复
  40. }tmp;
  41.  
  42. void initYHD();//初始化烟花弹
  43. void initYH();//初始化烟花
  44. void printText();//输出文字
  45.  
  46. //主函数
  47. int main() {
  48. 	srand((unsigned)time(NULL));//选取种子文件 
  49. 	initgraph(1200, 800);//创建窗口 宽1200 高度800
  50. 	//打开音乐文件 
  51. 	mciSendString(L"open music.mp3 alias bgm", 0, 0, 0);//mci 媒体控制接口 
  52. 	mciSendString(L"play bgm repeat", 0, 0, 0);//mci 媒体控制接口 
  53.  
  54. 	//getchar();//按回车键继续 
  55.  
  56. 	//初始化烟花弹（烟花弹需要上升，y坐标变化，x不变） 
  57. 	initYHD();
  58. 	//初始化烟花
  59. 	initYH();
  60.  
  61. 	//不恢复
  62. 	tmp.ishuifu = false;
  63.  
  64. 	while (1) {
  65. 		//打印文字
  66. 		printText();
  67. 		//获取当前时间
  68. 		yhd.t2 = GetTickCount();//t2
  69. 		//速度 处于发射状态
  70. 		if (yhd.t2 - yhd.t1 > yhd.dt && yhd.isshoot == true) {
  71. 			//会覆盖之前的
  72. 			putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  73. 			if (yhd.y > yhd.hy) {//有一个上界
  74. 				yhd.y -= 5;//上升
  75. 			}
  76. 			//覆盖之前的
  77. 			putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  78.  
  79. 			if(yhd.y<=yhd.hy){
  80. 				//已经到达最高点
  81. 				//1.擦除烟花弹
  82. 				putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  83. 				//停止上升
  84. 				yhd.isshoot = false;
  85. 				//开始爆炸
  86. 				yh.isboom = true;
  87. 				//上升最高点的坐标就是爆炸的中心
  88. 				yh.x = yhd.x;
  89. 				yh.y = yhd.y;
  90. 			}
  91. 			yhd.t1 = yhd.t2;
  92. 		}
  93.  
  94. 		//2.重新初始化烟花弹烟花爆炸完毕(这个要移出来,如果放在前面那个if里面就不能实现了，新的一轮要isshoot==true才能进去，这判断又是不能为true)
  95. 		if (yhd.isshoot == false && yh.isboom == false) {
  96. 			//保存原点坐标
  97. 			tmp.x = yh.x;
  98. 			tmp.y = yh.y;
  99. 			//恢复
  100. 			tmp.ishuifu = true;
  101.  
  102. 			//初始化烟花弹
  103. 			initYHD();
  104. 		}
  105.  
  106. 		//dt的数组
  107. 		int drt[] = { 5,5,5,15,15,15,25,25,25,55,60,65 };//烟花绽放的速度越来越慢ms
  108. 		yh.t2 = GetTickCount();
  109. 		//烟花已经爆炸
  110. 		if (yh.t2 - yh.t1 > yh.dt && yh.isboom == true) {
  111. 			if (yh.r < yh.maxr) {
  112. 				yh.r++;//半径不断变大，但是不能超过最大的范围
  113. 				yh.dt = drt[yh.r / 10];//dt不断变大
  114. 				yh.isdraw = true;//开始绘制
  115. 			}
  116. 			//爆炸结束(重置)
  117. 			if (yh.r >= yh.maxr - 1) {
  118. 				//停止绘制，停止爆炸
  119. 				yh.isdraw = false;
  120. 				yh.isboom = false;
  121. 				yh.t1 = GetTickCount();
  122. 				yh.dt = 5;
  123. 				yh.r = 0;
  124. 			}
  125. 			yh.t1 = yh.t2;
  126. 		}
  127. 		//开始绘制图像
  128. 		if (yh.isdraw == true) {
  129. 			//628次 2π
  130. 			int i = 0, j = 0;
  131. 			for (double a = 0; a <= 6.28; a += 0.01) {
  132. 				//当已经发送第二个的时候恢复第一个的
  133. 				if (tmp.ishuifu) {
  134. 					//圆的轨迹方程(窗口)
  135. 					int x3 = tmp.x + yh.r * cos(a);
  136. 					int y3 = tmp.y - yh.r * sin(a);
  137. 					//重新弄成黑色
  138. 					putpixel(x3, y3,0x000000);
  139. 				}
  140.  
  141. 				//圆的轨迹方程(图片)
  142. 				int x1 = yh.cx + yh.r * cos(a);
  143. 				int y1 = yh.cy - yh.r * sin(a);
  144. 				//圆的轨迹方程(窗口)
  145. 				int x2 = yh.x + yh.r * cos(a);
  146. 				int y2 = yh.y - yh.r * sin(a);
  147. 				//x1,y1 628个来自图片的像素点坐标
  148. 				putpixel(x2,y2,yh.xy[x1][y1]);
  149. 			}
  150. 		}
  151. 	}
  152.  
  153. 	while (1);//防止直接退出程序
  154. 	return 0;
  155. }
  156.  
  157. //初始化烟花弹
  158. void initYHD() {
  159. 	//初始化烟花弹（烟花弹需要上升，y坐标变化，x不变） 
  160. 	yhd.x = rand() % (1200 - 20);
  161. 	yhd.y = 750;//最开始烟花弹的位置 
  162. 	yhd.hx = yhd.x;
  163. 	yhd.hy = rand() % 400;//爆炸高度 
  164. 	yhd.t1 = GetTickCount();//获取当前系统的时间
  165. 	yhd.dt = 5;//dt 10ms 
  166. 	yhd.isshoot = true;//最开始是上升状态
  167. 	loadimage(&yhd.img, _T("yhd.jpg"), 20, 50);//加载图片
  168. 	putimage(yhd.x, yhd.y, &yhd.img, SRCINVERT);
  169. }
  170.  
  171. //初始化烟花
  172. void initYH() {
  173. 	yh.r=0;//当前半径
  174. 	yh.maxr = 120;//最大半径
  175. 	yh.cx = 120;
  176. 	yh.cy = 120;//中心点的坐标(图片)
  177. 	yh.xy[240][240];//图片的宽高，保存图片中的每一个像素点
  178. 	yh.isboom=false;//是否开始爆炸(图片的显示)
  179. 	yh.isdraw=false;//是否开始显示(用户看到的)
  180. 	yh.t1 = GetTickCount();
  181. 	yh.dt = 5;//爆炸的速度5ms
  182. 	IMAGE yhimg;
  183. 	loadimage(&yhimg, _T("yh.jpg"), 240, 240);//加载图片
  184.  
  185. 	SetWorkingImage(&yhimg);//指定待获取的图片(默认是从窗口获取)
  186. 	//获取图片的像素点放到数组当中
  187. 	for (int a = 0; a < 240; a++) {
  188. 		for (int b = 0; b < 240; b++) {
  189. 			yh.xy[a][b]=getpixel(a, b);
  190. 		}
  191. 	}
  192. 	SetWorkingImage();//将烟花图片释放
  193. }
  194.  
  195. void printText() {//输出文字
  196. 	settextcolor(YELLOW);//设置字体的颜色
  197. 	settextstyle(25, 0, _T("楷体"));//设置字体的风格 字号  
  198.  
  199.  
  200. 	outtextxy(300, 300, _T("2024新年之际，祝福你健康、快乐、平安、幸福"));
  201. 	outtextxy(300, 350, _T("愿你每天都笑容满面"));
  202. 	outtextxy(300, 400, _T("所求皆如愿，所行皆坦途，多喜乐，长安宁"));
  203. 	outtextxy(300, 450, _T("平安喜乐，万事胜意"));
  204. 	outtextxy(300, 500, _T("期末考试顺利"));
  205. 	outtextxy(600, 550, _T("——封奚泽优"));
  206. }

 总结

本来构思的是看自己学的都可以如何祝大家新年快乐，目前只用到了单片机的知识，C语言部分一直实现不了，之后会持续更新，争取早日输出。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/149148
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号