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

蓝桥杯-单片机组基础21——第15届省赛代码_十五届蓝桥杯单片机省赛答案

作者：繁依Fanyi0 | 2024-04-22 12:58:35

赞

踩

十五届蓝桥杯单片机省赛答案

目录

0.比赛题目回忆

1. 底层头文件

2.底层文件

3.主函数文件

做下来感觉，主观题第15届比14届稍微简单一些，但是出其不意考了DAC

本届客观题有点难，做选择感觉把握性不大，多选比较多

万幸比赛前一天做出了第14届的题，今年的题和去年的题比较接近（可参考本专栏上一篇文章）

如果有幸进入国赛，将继续更新国赛之路专栏

0.比赛题目回忆

（请以官方的文档为准，可能回忆有误）：

配置为IO模式，矩阵键盘操作S4589，短接P34和SIGNAL，

除了ds1302的时间显示界面，其余界面数值高位为0时，直接熄灭

采集555定时计数器频率，与频率参数相加后成为最终频率值，并将其中500~pf之间的频率映射到1~5V的DAC输出。（pf为超限频率）

当频率超出pf时，led2间隔0.2s闪烁。当频率为负数时，led2常亮

共有6个数码管显示界面，分别为：

  1. F频率采集界面，F__频率数值。该状态下led1间隔0.2s闪烁。当采集到的频率为负时，显示LL
  2. P1超限频率pf设置界面，默认参数2000，按下S9减少1000，按下S8增加1000，范围为1000~9000
  3. P2频率参数设置界面，默认参数0，按下S9减少100，按下S8增加100，范围为-900~900。其中负数时要有符号显示，为0时只显示最后一位0和提示符P2，其他位熄灭
  4. 时间显示界面，显示格式：时时-分分-秒秒
  5. HF频率回显，显示采集到的最大频率数值
  6. HA时间回显，显示采集到最大频率时的时间，格式为：HA时时分分秒秒

按键切换逻辑为：

按下S4，切换逻辑为：1 - 23 - 4 - 56 -1

按下S5，切换逻辑为：2 - 3 或 5 - 6

比赛结束后复现代码如下：

1. 底层头文件

iic.h

  1. #ifndef __IIC_H__
  2. #define __IIC_H__
  3.  
  4. void I2CStart(void);
  5. void I2CStop(void);
  6. void I2CSendByte(unsigned char byt);
  7. unsigned char I2CWaitAck(void);
  8.  
  9. #endif

ds1302.h

  1. #ifndef __DS1302_H__
  2. #define __DS1302_H__
  3.  
  4. void Write_Ds1302(unsigned  char temp) ;
  5. void Write_Ds1302_Byte( unsigned char address,unsigned char dat )    ;
  6. unsigned char Read_Ds1302_Byte ( unsigned char address );
  7.  
  8. #endif

basecode.h

  1. #ifndef __BASECODE_H__
  2. #define __BASECODE_H__
  3.  
  4. void select_HC573 ( unsigned char channal );
  5. void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG );
  6. void state_SMG_all ( unsigned char value_SMG_all );
  7. void state_led ( unsigned char value_led );
  8. void init_sys ();
  9.  
  10. #endif

2.底层文件

iic.c

  1. /*	#   I2C代码片段说明
  2. 	1. 	本文件夹中提供的驱动代码供参赛选手完成程序设计参考。
  3. 	2. 	参赛选手可以自行编写相关代码或以该代码为基础，根据所选单片机类型、运行速度和试题
  4. 		中对单片机时钟频率的要求，进行代码调试和修改。
  5. */
  6.  
  7. #include <reg52.h>
  8. #include <intrins.h>
  9.  
  10. sbit sda = P2^1;
  11. sbit scl = P2^0;
  12.  
  13.  
  14.  
  15. #define DELAY_TIME	5
  16.  
  17. //
  18. static void I2C_Delay(unsigned char n)
  19. {
  20.     do
  21.     {
  22.         _nop_();_nop_();_nop_();_nop_();_nop_();
  23.         _nop_();_nop_();_nop_();_nop_();_nop_();
  24.         _nop_();_nop_();_nop_();_nop_();_nop_();		
  25.     }
  26.     while(n--);      	
  27. }
  28.  
  29. //
  30. void I2CStart(void)
  31. {
  32.     sda = 1;
  33.     scl = 1;
  34. 	I2C_Delay(DELAY_TIME);
  35.     sda = 0;
  36. 	I2C_Delay(DELAY_TIME);
  37.     scl = 0;    
  38. }
  39.  
  40. //
  41. void I2CStop(void)
  42. {
  43.     sda = 0;
  44.     scl = 1;
  45. 	I2C_Delay(DELAY_TIME);
  46.     sda = 1;
  47. 	I2C_Delay(DELAY_TIME);
  48. }
  49.  
  50. //
  51. void I2CSendByte(unsigned char byt)
  52. {
  53.     unsigned char i;
  54. 	
  55.     for(i=0; i<8; i++){
  56.         scl = 0;
  57. 		I2C_Delay(DELAY_TIME);
  58.         if(byt & 0x80){
  59.             sda = 1;
  60.         }
  61.         else{
  62.             sda = 0;
  63.         }
  64. 		I2C_Delay(DELAY_TIME);
  65.         scl = 1;
  66.         byt <<= 1;
  67. 		I2C_Delay(DELAY_TIME);
  68.     }
  69. 	
  70.     scl = 0;  
  71. }
  72.  
  73. /*
  74. unsigned char I2CReceiveByte(void)
  75. {
  76. 	unsigned char da;
  77. 	unsigned char i;
  78. 	for(i=0;i<8;i++){   
  79. 		scl = 1;
  80. 		I2C_Delay(DELAY_TIME);
  81. 		da <<= 1;
  82. 		if(sda) 
  83. 			da |= 0x01;
  84. 		scl = 0;
  85. 		I2C_Delay(DELAY_TIME);
  86. 	}
  87. 	return da;    
  88. }
  90. */
  91. unsigned char I2CWaitAck(void)
  92. {
  93. 	unsigned char ackbit;
  94. 	
  95.     scl = 1;
  96. 	I2C_Delay(DELAY_TIME);
  97.     ackbit = sda; 
  98.     scl = 0;
  99. 	I2C_Delay(DELAY_TIME);
  100. 	
  101. 	return ackbit;
  102. }
  103.  
  104. /*/
  105. void I2CSendAck(unsigned char ackbit)
  106. {
  107.     scl = 0;
  108.     sda = ackbit; 
  109. 	I2C_Delay(DELAY_TIME);
  110.     scl = 1;
  111. 	I2C_Delay(DELAY_TIME);
  112.     scl = 0; 
  113. 	sda = 1;
  114. 	I2C_Delay(DELAY_TIME);
  115. }
  116. */

ds1302.c

  1. /*	# 	DS1302代码片段说明
  2. 	1. 	本文件夹中提供的驱动代码供参赛选手完成程序设计参考。
  3. 	2. 	参赛选手可以自行编写相关代码或以该代码为基础，根据所选单片机类型、运行速度和试题
  4. 		中对单片机时钟频率的要求，进行代码调试和修改。
  5. */								
  6.  
  7. //
  8. #include <reg52.h>
  9. #include <intrins.h>
  10.  
  11. sbit SCK = P1^7;
  12. sbit SDA = P2^3;
  13. sbit RST = P1^3;
  14.  
  15.  
  16. void Write_Ds1302(unsigned  char temp) 
  17. {
  18. 	unsigned char i;
  19. 	for (i=0;i<8;i++)     	
  20. 	{ 
  21. 		SCK = 0;
  22. 		SDA = temp&0x01;
  23. 		temp>>=1; 
  24. 		SCK=1;
  25. 	}
  26. }   
  27.  
  28. //
  29. void Write_Ds1302_Byte( unsigned char address,unsigned char dat )     
  30. {
  31.  	RST=0;	_nop_();
  32.  	SCK=0;	_nop_();
  33.  	RST=1; 	_nop_();  
  34.  	Write_Ds1302(address);	
  35.  	Write_Ds1302(dat);		
  36.  	RST=0; 
  37. }
  38.  
  39. //
  40. unsigned char Read_Ds1302_Byte ( unsigned char address )
  41. {
  42.  	unsigned char i,temp=0x00;
  43.  	RST=0;	_nop_();
  44.  	SCK=0;	_nop_();
  45.  	RST=1;	_nop_();
  46.  	Write_Ds1302(address);
  47.  	for (i=0;i<8;i++) 	
  48.  	{		
  49. 		SCK=0;
  50. 		temp>>=1;	
  51.  		if(SDA)
  52.  		temp|=0x80;	
  53.  		SCK=1;
  54. 	} 
  55.  	RST=0;	_nop_();
  56.  	SCK=0;	_nop_();
  57. 	SCK=1;	_nop_();
  58. 	SDA=0;	_nop_();
  59. 	SDA=1;	_nop_();
  60. 	return (temp);			
  61. }

basecode.c

  1. #include <reg52.h>
  2. #include <intrins.h>
  3.  
  4. void select_HC573 ( unsigned char channal )
  5. {
  6. 	switch ( channal )
  7. 	{
  8. 		case 4:
  9. 			P2 = ( P2 & 0x1f ) | 0x80;
  10. 		break;
  11. 		case 5:
  12. 			P2 = ( P2 & 0x1f ) | 0xa0;
  13. 		break;
  14. 		case 6:
  15. 			P2 = ( P2 & 0x1f ) | 0xc0;
  16. 		break;
  17. 		case 7:
  18. 			P2 = ( P2 & 0x1f ) | 0xe0;
  19. 		break;
  20. 		case 0:
  21. 			P2 = ( P2 & 0x1f ) | 0x00;
  22. 		break;
  23. 	}
  24. }
  25.  
  26. void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG )
  27. {
  28. 	select_HC573 ( 0 );
  29. 	P0 = 0x01 << pos_SMG;	
  30. 	select_HC573( 6 );
  31. 	select_HC573 ( 0 );
  32. 	P0 = value_SMG;
  33. 	select_HC573( 7 );
  34. 	select_HC573 ( 0 );
  35. }
  36.  
  37. void state_SMG_all ( unsigned char value_SMG_all )
  38. {
  39. 	select_HC573 ( 0 );
  40. 	P0 = 0xff;	
  41. 	select_HC573( 6 );
  42. 	select_HC573 ( 0 );
  43. 	P0 = value_SMG_all;
  44. 	select_HC573( 7 );
  45. 	select_HC573 ( 0 );
  46. }	
  47.  
  48.  
  49. void state_led ( unsigned char value_led )
  50. {
  51. 	select_HC573 ( 0 );
  52. 	P0 = 0xff;
  53. 	select_HC573 ( 4 );
  54. 	P0 = value_led;
  55. 	select_HC573 ( 4 );	
  56. 	select_HC573 ( 0 );
  57. }
  58.  
  59. void init_sys ()
  60. {
  61. 	select_HC573 ( 0 );
  62. 	P0 = 0xff;	
  63. 	select_HC573 ( 4 );
  64. 	select_HC573 ( 0 );
  65. 	P0 = 0x00;
  66. 	select_HC573 ( 5 );
  67. 	select_HC573 ( 0 );
  68.  
  69. }

3.主函数文件

  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #include "iic.h"
  4. #include "ds1302.h"
  5. #include "basecode.h"
  6.  
  7. sfr AUXR = 0x8e;
  8. sbit C1 = P4^4;
  9. sbit C2 = P4^2;
  10. sbit H1 = P3^3;
  11. sbit H2 = P3^2;
  12.  
  13. unsigned char code duanma[20] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
  14.                                  0x88,0x83,0xc6,0xc0,0x86,0x8e,0xbf,0xc7,0x89,0x8c};
  15. unsigned char code Write_address [7] = { 0x80 , 0x82 , 0x84 , 0x86 , 0x88 , 0x8a , 0x8c};
  16. unsigned char code Read_address [7] = { 0x81 , 0x83 , 0x85 , 0x87 , 0x89 , 0x8b , 0x8d };
  17.  
  18. //2022year 3month 31day 5 23 59 50
  19. unsigned char date_ds1302 [7] = { 0x05 , 0x03 , 0x13 , 0x13 , 0x02 , 0x06 , 0x24 };
  20.  
  21. unsigned int max_fre = 0;
  22. int set_fre = 0;
  23. int pf = 2000;
  24. unsigned int value_dac = 0;
  25. unsigned char max_fre_time_hour = 0x00;
  26. unsigned char max_fre_time_min = 0x00;
  27. unsigned char max_fre_time_second = 0x00;
  28. unsigned char SMG_flag = 1;
  29. unsigned char value_led = 0xff;
  30. bit flash_dac = 0;
  31.  
  32.  
  33. void flash_SMG ();
  34. void flash_date ();
  35. void valuerunning ();	
  36. void keyrunning ();
  37.  
  38. void dacrunning ( unsigned char value_dac )
  39. {
  40. 	if ( flash_dac == 1 )
  41. 	{
  42. 		I2CStart();
  43. 		I2CSendByte( 0x90 );
  44. 		I2CWaitAck();
  45. 		I2CSendByte( 0x43 );
  46. 		I2CWaitAck();
  47. 		I2CSendByte( value_dac );
  48. 		I2CWaitAck();
  49. 		I2CStop();
  50. 	}
  51. }
  52.  
  53. void init_ds1302 ()
  54. {
  55. 	unsigned char i;
  56. 	Write_Ds1302_Byte ( 0x8e , 0x00 );
  57. 	for ( i=0 ; i<7 ; i++ )
  58. 	{
  59. 		Write_Ds1302_Byte ( Write_address[i] , date_ds1302[i] );
  60. 	}
  61. 	Write_Ds1302_Byte ( 0x8e , 0x80 );
  62.  
  63. }
  64.  
  65. bit flash_ds1302 = 0;
  66. void flash_date()
  67. {
  68. 	if ( flash_ds1302 == 1 )
  69. 	{
  70. 		unsigned char i;
  71. 		for ( i=0 ; i<7 ; i++ )
  72. 		{
  73. 			date_ds1302[i] = Read_Ds1302_Byte ( Read_address[i] );
  74. 		}
  75. 		
  76. 		flash_ds1302 = 0;
  77. 	}
  78. }
  79.  
  80.  
  81. //==============================================================================
  82. void init_timer01 ()		
  83. {
  84. 	AUXR &= 0xBF;		//定时器时钟12T模式
  85. 	TMOD = 0x06;		//设置定时器模式
  86. 	TL1 = 0xCE;		//设置定时初值
  87. 	TH1 = 0xFF;		//设置定时初值
  88. 	TF1 = 0;		//清除TF1标志
  89. 	TR1 = 1;		//定时器1开始计时
  90. 	
  91. 	TL0 = 0xFF;		//设置定时初值
  92. 	TH0 = 0xFF;		//设置定时初值
  93. 	TF0 = 0;		//清除TF0标志
  94. 	TR0 = 1;		//定时器0开始计时
  95. 	
  96. 	EA = 1;
  97. 	ET0 = 1;
  98. 	ET1 = 1;
  99. }
  100.  
  101. unsigned int count_timer0 = 0;
  102. void timer0_service () interrupt 1
  103. {	
  104. 	count_timer0 ++;	
  105. }
  106. //=============================================================================
  107.  
  108. bit flag_200ms = 0;
  109. int count_fre = 0;
  110. unsigned char count_50us = 0;
  111. unsigned char count_5ms = 0;
  112. unsigned char flash_count = 0;
  113. unsigned char date_hour;
  114. unsigned char date_min;
  115. unsigned char date_second;
  116. void timer1_service () interrupt 3
  117. {
  118. 	
  119. 	if ( ++count_50us == 200 )
  120. 	{
  121. 		count_50us = 0;
  122. 		
  123. 	}
  124. 	
  125. 	if ( count_50us % 40 == 0 ) 
  126. 	{
  127. 		if ( SMG_flag == 1 )//窗口1
  128. 		{
  129. 			if ( ++flash_count > 6 )
  130. 			{
  131. 				flash_count = 0;
  132. 			}
  133. 		}
  134. 		else if ( SMG_flag == 2 )//窗口2
  135. 		{
  136. 			if ( ++flash_count > 6 )
  137. 			{
  138. 				flash_count = 0;
  139. 			}
  140. 		}
  141. 		else if ( SMG_flag == 3 )//窗口3
  142. 		{
  143. 			if ( ++flash_count == 9 )
  144. 			{
  145. 				flash_count = 0;
  146. 			}
  147. 		}
  148. 		else if ( SMG_flag == 4 )//窗口4
  149. 		{
  150. 			if ( ++flash_count > 7 )
  151. 			{
  152. 				flash_count = 0;
  153. 			}
  154. 		}
  155. 		else if ( SMG_flag == 5 )//窗口5
  156. 		{
  157. 			if ( ++flash_count == 9 )
  158. 			{
  159. 				flash_count = 0;
  160. 			}
  161. 		}
  162. 		else if ( SMG_flag == 6 )//窗口6
  163. 		{
  164. 			if ( ++flash_count > 7 )
  165. 			{
  166. 				flash_count = 0;
  167. 			}
  168. 		}
  169. 		else if ( SMG_flag == 7 )//测试窗口7
  170. 		{
  171. 			if ( ++flash_count > 7 )
  172. 			{
  173. 				flash_count = 0;
  174. 			}
  175. 		}
  176. 		
  177. 		flash_SMG ();	
  178. 	}
  179. 	
  180. 	if ( count_50us % 100 == 0 )
  181. 	{
  182. 		count_5ms++;
  183. 		flash_dac = 1;	
  184. 		if ( count_5ms == 200 )
  185. 		{
  186. 			count_5ms = 0;
  187. 			count_fre = count_timer0 + set_fre;
  188. 			count_timer0 = 0;
  189. 			
  190. 			date_hour = date_ds1302[2]; 
  191. 			date_min = date_ds1302[1];
  192. 			date_second = date_ds1302[0];						
  193. 		}
  194. 		if ( count_5ms % 40 == 0 )
  195. 		{
  196. 			flag_200ms = ~flag_200ms;
  197. 		}		
  198. 		
  199.  
  200. 	}
  201. 	
  202. 	if ( count_50us % 40 == 0 )
  203. 	{
  204. 		
  205. 		state_led ( value_led );
  206. 		flash_ds1302 = 1;
  207. 		
  208. 	}
  209. 	
  210. }
  211.  
  212.  
  213. void valuerunning ()
  214. {
  215. 	unsigned int tmp_value_dac = 0;
  216. 	float pf_sub = pf - 500;
  217. 	
  218. 	
  219. 	if ( count_fre > max_fre && count_fre > 0 )
  220. 	{
  221. 		max_fre = count_fre;
  222. 		max_fre_time_hour = date_ds1302[2];
  223. 		max_fre_time_min = date_ds1302[1];
  224. 		max_fre_time_second = date_ds1302[0];
  225. 	}
  226. 	
  227. 	
  228. 	if ( count_fre < 0  )
  229. 	{
  230. 		tmp_value_dac = 0;
  231. 		value_led &= 0xfd;
  232. 	}
  233. 	else
  234. 	{
  235. 		value_led |= 0x02;
  236. 		if ( count_fre < 500 )
  237. 		{
  238. 			tmp_value_dac = 52;
  239. 		}
  240. 		else if ( count_fre < pf )
  241. 		{
  242. 			pf_sub = 204.0/pf_sub;
  243. 			tmp_value_dac = count_fre*pf_sub;
  244. 			
  245. 			if ( tmp_value_dac >= 255 )//5V
  246. 			{
  247. 				tmp_value_dac = 255;
  248. 			}
  249. 			else if ( tmp_value_dac < 50 && tmp_value_dac != 0 )//1V
  250. 			{
  251. 				tmp_value_dac = 52;
  252. 			}			
  253. 			
  254. 		}
  255. 		else
  256. 		{		
  257. 			tmp_value_dac = 255;
  258. 		}
  259. 	}
  260. 	value_dac = tmp_value_dac;
  261. 	
  262. 	if ( flag_200ms == 0 && SMG_flag == 1 )
  263. 	{
  264. 		value_led &= 0xfe;
  265. 	}
  266. 	else
  267. 	{
  268. 		value_led |= 0x01;		
  269. 	}
  270. 	
  271. 	if ( count_fre > pf )
  272. 	{
  273. 		if ( flag_200ms == 0 )
  274. 		{
  275. 			value_led &= 0xfd;
  276. 		}
  277. 		else
  278. 		{
  279. 			value_led |= 0x02;
  280. 		}
  281. 	}
  282. }
  283. 		
  284. 	
  285. void Delay4ms()		//@12.000MHz
  286. {
  287. 	unsigned char i, j;
  288.  
  289. 	i = 47;
  290. 	j = 174;
  291. 	do
  292. 	{
  293. 		while (--j);
  294. 	} while (--i);
  295. }
  296.  
  297. void keyrunning ()
  298. {
  299. 	C1 = 0;
  300. 	C2 = H1 = H2 = 1;
  301. 	if ( H1 == 0 )
  302. 	{
  303. 		Delay4ms();
  304. 		if ( H1 == 0 )//S4
  305. 		{
  306. 			switch ( SMG_flag )
  307. 			{
  308. 				case 1:
  309. 					SMG_flag = 2;
  310. 				break;
  311. 				case 2:case 3:
  312. 					SMG_flag = 4;
  313. 				break;
  314. 				case 4:
  315. 					SMG_flag = 5;
  316. 				break;
  317. 				case 5:case 6:
  318. 					SMG_flag = 1;
  319. 				break;
  320. 			}
  321. 			while ( H1 == 0 );
  322. 		}
  323. 	}
  324. 	else if ( H2 == 0 )
  325. 	{
  326. 		Delay4ms();
  327. 		if ( H2 == 0 )//S5
  328. 		{
  329. 			switch ( SMG_flag )
  330. 			{
  331. 				case 2:
  332. 					SMG_flag = 3;
  333. 				break;
  334. 				case 3:
  335. 					SMG_flag = 2;
  336. 				break;
  337. 				case 5:
  338. 					SMG_flag = 6;
  339. 				break;
  340. 				case 6:
  341. 					SMG_flag = 5;
  342. 				break;
  343. 			}			
  344. 			while ( H2 == 0 );	
  345. 		}
  346. 	}
  347.  
  348. 	C2 = 0;
  349. 	C1 = H1 = H2 = 1;
  350. 	if ( H1 == 0 )
  351. 	{
  352. 		Delay4ms();
  353. 		if ( H1 == 0 )//S8
  354. 		{
  355. 			if ( SMG_flag == 2 )
  356. 			{
  357. 				pf += 1000;
  358. 				if ( pf == 10000 )
  359. 				{
  360. 					pf = 9000;
  361. 				}
  362. 			}
  363. 			else if ( SMG_flag == 3 )
  364. 			{
  365. 				set_fre += 100;
  366. 				if ( set_fre == 1000 )
  367. 				{
  368. 					set_fre = 900;
  369. 				}
  370. 			}								
  371. 			while ( H1 == 0 );
  372. 		}
  373. 	}
  374. 	else if ( H2 == 0 )
  375. 	{
  376. 		Delay4ms();
  377. 		if ( H2 == 0 )//S9
  378. 		{
  379. 			if ( SMG_flag == 2 )
  380. 			{
  381. 				pf -= 1000;
  382. 				if ( pf == 0 )
  383. 				{
  384. 					pf = 1000;
  385. 				}
  386. 			}
  387. 			else if ( SMG_flag == 3 )
  388. 			{
  389. 				set_fre -= 100;
  390. 				if ( set_fre == -1000 )
  391. 				{
  392. 					set_fre = -900;
  393. 				}
  394. 			}								
  395. 			while ( H2 == 0 );	
  396. 		}
  397. 	}
  398. }	
  399. 	
  400.  
  401. 		
  402. 	
  403. void flash_SMG ()
  404. {
  405. 	state_SMG_all ( 0xff );
  406. 	
  407. 	if ( SMG_flag == 1 )
  408. 	{
  409. 		switch ( flash_count )
  410. 		{
  411. 			case 0 :	
  412. 				state_SMG ( 0 , duanma[15] );
  413. 			break;
  414. 			case 1 :
  415. 				if ( count_fre > 9999 )
  416. 				{
  417. 					state_SMG ( 3 , duanma[count_fre/10000] );
  418. 				}
  419. 				else
  420. 				{
  421. 					state_SMG ( 3 , 0xff );
  422. 				}
  423. 			break;
  424. 			case 2 :
  425. 				if ( count_fre > 999 )
  426. 				{				
  427. 					state_SMG ( 4 , duanma[count_fre/1000%10] );
  428. 				}
  429. 				else
  430. 				{
  431. 					state_SMG ( 4 , 0xff );
  432. 				}
  433. 			break;
  434. 			case 3 :
  435. 				if ( count_fre > 99 )
  436. 				{				
  437. 					state_SMG ( 5 , duanma[count_fre/100%10] );
  438. 				}
  439. 				else
  440. 				{
  441. 					state_SMG ( 5 , 0xff );
  442. 				}
  443. 			break;
  444. 			case 4 :
  445. 				if ( count_fre > 0 )
  446. 				{
  447. 					if ( count_fre > 9 )
  448. 					{
  449. 						state_SMG ( 6 , duanma[count_fre/10%10] );
  450. 					}
  451. 					else
  452. 					{
  453. 						state_SMG ( 6 , 0xff );
  454. 					}
  455. 				}
  456. 				else
  457. 				{
  458. 					state_SMG ( 6 , duanma[17] );
  459. 				}
  460. 			break;
  461. 			case 5 :
  462. 				if ( count_fre > 0 )
  463. 				{
  464. 					state_SMG ( 7 , duanma[count_fre%10] );
  465. 				}
  466. 				else
  467. 				{
  468. 					state_SMG ( 7 , duanma[17] );
  469. 				}
  470. 			break;
  471. 			case 6 :	
  472. 				state_SMG_all ( 0xff );
  473. 			break;
  474. 		}
  475. 	}
  476. 	else if ( SMG_flag == 2 )
  477. 	{
  478. 		switch ( flash_count )
  479. 		{
  480. 			case 0 :	
  481. 				state_SMG ( 0 , duanma[19] );
  482. 			break;
  483. 			case 1 :
  484. 				state_SMG ( 1 , duanma[1] );
  485. 			break;
  486. 			case 2 :			
  487. 				state_SMG ( 4 , duanma[pf/1000] );
  488. 			break;
  489. 			case 3 :			
  490. 				state_SMG ( 5 , duanma[0] );
  491. 			break;
  492. 			case 4 :
  493. 				state_SMG ( 6 , duanma[0] );
  494. 			break;
  495. 			case 5 :			
  496. 				state_SMG ( 7 , duanma[0] );
  497. 			break;
  498. 			case 6 :	
  499. 				state_SMG_all ( 0xff );
  500. 			break;
  501. 		}
  502. 	}		
  503. 	else if ( SMG_flag == 3 )
  504. 	{
  505. 		switch ( flash_count )
  506. 		{
  507. 			case 0 :	
  508. 				state_SMG ( 0 , duanma[19] );
  509. 			break;
  510. 			case 1 :
  511. 				state_SMG ( 1 , duanma[2] );
  512. 			break;
  513. 			case 2 :
  514. 				if ( set_fre < 0 )
  515. 				{				
  516. 					state_SMG ( 4 , duanma[16] );
  517. 				}
  518. 				else
  519. 				{
  520. 					state_SMG ( 4 , 0xff );
  521. 				}
  522. 			break;
  523. 			case 3 :
  524. 				if ( set_fre != 0 )
  525. 				{
  526. 					if ( set_fre < 0 )
  527. 					{						
  528. 						state_SMG ( 5 , duanma[set_fre*-1/100] );
  529. 					}
  530. 					else
  531. 					{
  532. 						state_SMG ( 5 , duanma[set_fre/100] );
  533. 					}
  534. 				}
  535. 				else
  536. 				{
  537. 					state_SMG ( 5 , 0xff );
  538. 				}
  539. 			break;
  540. 			case 4 :
  541. 				if ( set_fre != 0 )
  542. 				{				
  543. 					state_SMG ( 6 , duanma[0] );
  544. 				}
  545. 				else
  546. 				{
  547. 					state_SMG ( 6 , 0xff );
  548. 				}
  549. 			break;
  550. 			case 5 :			
  551. 				state_SMG ( 7 , duanma[0] );
  552. 			break;
  553. 			case 6 :	
  554. 				state_SMG_all ( 0xff );
  555. 			break;
  556. 		}
  557. 	}
  558. 	else if ( SMG_flag == 4 )
  559. 	{
  560. 		switch ( flash_count )
  561. 		{
  562. 			case 0 :	
  563. 				state_SMG ( 0 , duanma[date_hour/16] );
  564. 			break;
  565. 			case 1 :	
  566. 				state_SMG ( 1 , duanma[date_hour%16] );
  567. 			break;
  568. 			case 2 :	
  569. 				state_SMG ( 2 , duanma[16] );
  570. 			break;
  571. 			case 3 :	
  572. 				state_SMG ( 3 , duanma[date_min/16] );
  573. 			break;
  574. 			case 4 :	
  575. 				state_SMG ( 4 , duanma[date_min%16] );
  576. 			break;
  577. 			case 5 :	
  578. 				state_SMG ( 5 , duanma[16] );
  579. 			break;
  580. 			case 6 :	
  581. 				state_SMG ( 6 , duanma[date_second/16] );
  582. 			break;
  583. 			case 7 :	
  584. 				state_SMG ( 7 , duanma[date_second%16] );
  585. 			break;
  586. 			case 8 :	
  587. 				state_SMG_all ( 0xff );
  588. 			break;
  589. 		}
  590. 	}
  591. 	else if ( SMG_flag == 5 )
  592. 	{
  593. 		switch ( flash_count )
  594. 		{
  595. 			case 0 :	
  596. 				state_SMG ( 0 , duanma[18] );
  597. 			break;
  598. 			case 1 :
  599. 				state_SMG ( 1 , duanma[15] );
  600. 			break;
  601. 			case 2 :
  602. 				if ( max_fre > 9999 )
  603. 				{				
  604. 					state_SMG ( 3 , duanma[max_fre/10000%10] );
  605. 				}
  606. 				else
  607. 				{
  608. 					state_SMG ( 3 , 0xff );
  609. 				}
  610. 			break;
  611. 			case 3 :
  612. 				if ( max_fre > 999 )
  613. 				{				
  614. 					state_SMG ( 4 , duanma[max_fre/1000%10] );
  615. 				}
  616. 				else
  617. 				{
  618. 					state_SMG ( 4 , 0xff );
  619. 				}
  620. 			break;
  621. 			case 4 :
  622. 				if ( max_fre > 99 )
  623. 				{				
  624. 					state_SMG ( 5 , duanma[max_fre/100%10] );
  625. 				}
  626. 				else
  627. 				{
  628. 					state_SMG ( 5 , 0xff );
  629. 				}
  630. 			break;
  631. 			case 5 :
  632. 				if ( max_fre > 9 )
  633. 				{				
  634. 					state_SMG ( 6 , duanma[max_fre/10%10] );
  635. 				}
  636. 				else
  637. 				{
  638. 					state_SMG ( 6 , 0xff );
  639. 				}
  640. 			break;
  641. 			case 6 :			
  642. 				state_SMG ( 7 , duanma[max_fre%10] );
  643. 			break;
  644. 			case 7 :	
  645. 				state_SMG_all ( 0xff );
  646. 			break;
  647. 		}
  648. 	}
  649. 	else if ( SMG_flag == 6 )
  650. 	{
  651. 		switch ( flash_count )
  652. 		{
  653. 			case 0 :	
  654. 				state_SMG ( 0 , duanma[18] );
  655. 			break;
  656. 			case 1 :
  657. 				state_SMG ( 1 , duanma[10] );
  658. 			break;
  659. 			case 2 :
  660. 				state_SMG ( 2 , duanma[max_fre_time_hour/16] );
  661. 			break;
  662. 			case 3 :
  663. 				state_SMG ( 3 , duanma[max_fre_time_hour%16] );
  664. 			break;
  665. 			case 4 :
  666. 				state_SMG ( 4 , duanma[max_fre_time_min/16] );
  667. 			break;
  668. 			case 5 :
  669. 				state_SMG ( 5 , duanma[max_fre_time_min%16] );
  670. 			break;
  671. 			case 6 :
  672. 				state_SMG ( 6 , duanma[max_fre_time_second/16] );
  673. 			break;
  674. 			case 7 :
  675. 				state_SMG ( 7 , duanma[max_fre_time_second%16] );
  676. 			break;			
  677. 			case 8 :	
  678. 				state_SMG_all ( 0xff );
  679. 			break;
  680. 		}
  681. 	}
  682. 	else if ( SMG_flag == 7 )
  683. 	{
  684. 		switch ( flash_count )
  685. 		{
  686. 			case 0 :	
  687. 				state_SMG ( 0 , duanma[count_fre/1000%10] );
  688. 			break;
  689. 			case 1 :
  690. 				state_SMG ( 1 , duanma[count_fre/100%10] );
  691. 			break;
  692. 			case 2 :			
  693. 				state_SMG ( 2 , duanma[count_fre/10%10] );
  694. 			break;
  695. 			case 3 :				
  696. 				state_SMG ( 3 , duanma[count_fre%10] );
  697. 			break;
  698. 			case 4 :				
  699. 				state_SMG ( 5 , duanma[value_dac*100/51/100] );
  700. 			break;
  701. 			case 5 :			
  702. 				state_SMG ( 6 , duanma[value_dac*100/551/10%10] );
  703. 			break;
  704. 			case 6 :			
  705. 				state_SMG ( 7 , duanma[value_dac*100/51%10] );
  706. 			break;
  707. 			case 7 :	
  708. 				state_SMG_all ( 0xff );
  709. 			break;
  710. 		}
  711. 	}
  712. }
  713.  
  714. void main ()
  715. {
  716. 	init_sys();
  717. 	init_timer01 ();
  718. 	init_ds1302 ();
  719. 	while ( 1 )
  720. 	{	
  721. 		flash_date ();
  722. 		valuerunning ();
  723. 		dacrunning ( value_dac );
  724. 		keyrunning ();
  725. 	}
  726. }

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

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

  

闽ICP备14008679号