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

蓝桥杯-单片机基础20——第14届省赛真题代码详解_第十四届蓝桥杯单片机程序题简述

作者：Monodyee | 2024-06-12 03:27:18

赞

踩

第十四届蓝桥杯单片机程序题简述

网上传言说14届最难，实际做下来感觉确实是这样的

本试题，需要将矩阵键盘短接，J3的555定时器输出口与P34短接

1.比赛题目

2.编程的大致思路

  • 首先，完成基础代码与数码管的不同窗口，定义大部分要用到的变量，并测试每个窗口是否显示正常
  • 然后，添加外设模块，并逐个测试模块在不同窗口下的显示效果
  • 接着，进行按键的定义和数值处理函数的优化，将逻辑功能整体实现清晰
  • 最后，对杂七杂八的led等部分进行设置，测试各个功能是否正常

3.编程心得

  1. 555定时器，除了要短接引脚，还要用RB3调节频率的数值
  2. 光敏电阻数字跳动太大：加1ms延时，加中断刷新，加最后一步等待应答，加临时变量判断数据正确再写入
  3. ds18b20，注意你采用的是不是三位数进行记录
  4. ds1302,最好用中断，每隔1s提取一遍时间到变量中，再用数码管显示
  5. 对于刷新频率为1s为单位的变量，可以直接读取ds1302的秒位，判断是否达到1s的整数倍
  6. 程序必须要有一个50us的中断处理，有了50us其他的刷新很好确定
  7. 对于led的操作。当led的变化有规律时——建立数组存放led的状态。当led没有规律时——一定要学会位运算，直接对变量value_led进行位操作，然后利用中断传入led处理函数
  8. 对于io编程模式，要注意对锁存器常关闭。同时采用先赋值P0端口，再打开锁存器方式，这样有效防止数据冲突。
  9. 所有的外设，除了555以外，都可以设置一个刷新的标志变量，可以提升系统运行效率

4.代码参考

4.1 头文件

onewire.h        ds1302.h        iic.h

和上一篇博客一样，和15届官方发的没有区别。为了节省篇幅这里不放出，可以参考上一篇文章，基本没有变动

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_relay ( unsigned char value_relay );
  8. void state_led ( unsigned char value_led );
  9. void init_sys ();
  10. void init_ds1302 ();
  11. void init_temperature ();
  12.  
  13. #endif

4.2 底层文件

onewire.c        ds1302.c        iic.c        和常规一样，也和上一篇博客一样

basecode.c

  1.  
  2. #include <ds1302.h>
  3. #include <onewire.h>
  4. #include <reg52.h>
  5. #include <intrins.h>
  6.  
  7.  
  8. //锁存器通道选择函数
  9. void select_HC573 ( unsigned char channal )
  10. {
  11. 	switch ( channal )
  12. 	{
  13. 		case 4:
  14. 			P2 = ( P2 & 0x1f ) | 0x80;
  15. 		break;
  16. 		case 5:
  17. 			P2 = ( P2 & 0x1f ) | 0xa0;
  18. 		break;
  19. 		case 6:
  20. 			P2 = ( P2 & 0x1f ) | 0xc0;
  21. 		break;
  22. 		case 7:
  23. 			P2 = ( P2 & 0x1f ) | 0xe0;
  24. 		break;
  25. 		case 0:
  26. 			P2 = ( P2 & 0x1f ) | 0x00;
  27. 		break;
  28. 	}
  29. }
  30.  
  31. //单位数码管显示函数
  32. void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG )
  33. {
  34. 	select_HC573 ( 0 );
  35. 	P0 = 0x01 << pos_SMG;	
  36. 	select_HC573( 6 );
  37. 	select_HC573 ( 0 );
  38. 	P0 = value_SMG;
  39. 	select_HC573( 7 );
  40. 	select_HC573 ( 0 );
  41. }
  42.  
  43. //全位数码管静态显示
  44. void state_SMG_all ( unsigned char value_SMG_all )
  45. {
  46. 	select_HC573 ( 0 );
  47. 	P0 = 0xff;	
  48. 	select_HC573( 6 );
  49. 	select_HC573 ( 0 );
  50. 	P0 = value_SMG_all;
  51. 	select_HC573( 7 );
  52. 	select_HC573 ( 0 );
  53. }	
  54.  
  55.  
  56. //led灯光控制函数
  57. void state_led ( unsigned char value_led )
  58. {
  59. 	select_HC573 ( 0 );
  60. 	P0 = 0xff;
  61. 	select_HC573 ( 4 );
  62. 	P0 = value_led;
  63. 	select_HC573 ( 4 );	
  64. 	select_HC573 ( 0 );
  65. }
  66.  
  67. //初始化系统，关闭继电器和蜂鸣器
  68. void init_sys ()
  69. {
  70. 	select_HC573 ( 0 );
  71. 	P0 = 0xff;	
  72. 	select_HC573 ( 4 );
  73. 	select_HC573 ( 0 );
  74. 	P0 = 0x00;
  75. 	select_HC573 ( 5 );
  76. 	select_HC573 ( 0 );
  77.  
  78. }
  79.  
  80.  
  81.  
  82. void init_temperature ()
  83. {
  84. 	unsigned char LSB,MSB;
  85. 	init_ds18b20();
  86. 	Write_DS18B20(0xcc);	
  87. 	Write_DS18B20(0x44);
  88. 	
  89. 	do{
  90. 		init_ds18b20();
  91. 		Write_DS18B20(0xcc);	
  92. 		Write_DS18B20(0xbe);
  93. 		
  94. 		LSB = Read_DS18B20();
  95. 		MSB = Read_DS18B20();
  96. 		
  97. 		MSB = ( MSB << 4 ) | ( LSB >> 4 );
  98. 	}while ( MSB == 85 );
  99. }

4.3主函数文件

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

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

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

  

闽ICP备14008679号