蓝桥杯单片机-国赛2——按键专项测试：单击、双击、双按键、数码管闪烁移位

最新推荐文章于 2024-06-13 19:47:49 发布

archie474

最新推荐文章于 2024-06-13 19:47:49 发布

阅读量736

点赞数 9

分类专栏：蓝桥杯-单片机组编程进阶技巧与国赛器件文章标签：蓝桥杯单片机嵌入式硬件 51单片机 c语言

本文链接：https://blog.csdn.net/qq_43323677/article/details/139015218

版权

蓝桥杯-单片机组编程进阶技巧与国赛器件专栏收录该内容

7 篇文章 1 订阅

订阅专栏

本文基于小蜜蜂代码风格，并结合往期文章程序修改

参考代码中注释较少，有疑问可评论或私信，会及时解答

其他参考文章请查看本人博客其他专栏

1. 编程心得

定时计数器尽量选用1T
ds1302的bcd码，最大值选用0x99。在进位判定时，转为十进制，再比较时间大小决定是否补偿60
双按键消抖尽量长，为了消除按键的前后次序，20ms比较可以
要检测按键是否按下，可以使用标志位指示按下的操作。
注意定义的局部变量，要放在语句最开始，前面不能放任何语句
刷新外设时，注意利用ds1302的时间进行定时时，会出现不在中断内，导致更新时间不及时
数码管8位只亮1位，可能是因为中断函数内太复杂，可以想办法减轻中断函数负担
可以使用多层if嵌套替代多个逻辑判断，减少bug的产生
活用标志位变量

2. 题目讲解

2.1 时间界面，开机默认界面，显示正常时间

2.2 闹钟界面，可自定义3个闹钟

【按键要求】：

红色区域为本任务涉及的部分。

在界面1下，s8-s17单击时，切换到界面2 。同时长按不松手s18+s19时，蜂鸣器滴一声，并间隔1s逐个显示用户设置的闹钟。双击s19展示闹钟铃声1，并设置为闹钟铃声。双击s19展示闹钟铃声2，并设置为闹钟铃声。

在界面2下，s8-s11为0-3， s12-s15为4-7，s16-s17为8-9，S18单击为闹钟界面切换，S19单击为确定设置键，S18+S19同时按下无反应。

2.3【具体要求】：

1.设置功能

正常时间显示界面1情况下，按下s11-s17任意按键，进入闹钟设置界面2，默认秒的十位闪烁。再次按下s11-s17任意按键，可以实现闹钟时间设置，从分的个位，向左移动到分十位，直到时十位，依次循环，再次按下，时十位切换至秒个位。按下数字键，直接修改对应的闹钟时间（需注意分时间整体不能大于等于60，只能0-59，时不能大于等于24，只能0-23）。按下s19，确定闹钟设置，立即回到界面1，（没有按下确定设置键s19，设置不成功），在界面2下，5秒无按键按下，自动退出闹钟设置界面2，进入时间显示界面1，闹钟无效。同时，在界面2下，按下s18可切换到下一个闹钟设置，共3个闹钟可设置。

2.交互功能

在时间显示界面1下，长按下不松手S18+S19双按键，蜂鸣器发出滴的一声，并可以间隔1s逐个查看设定的3个闹钟数值。双击s19时，可以播放闹钟铃声1，并将闹钟的实际铃声设定为铃声1 。双击s18时，可以播放闹钟铃声2，并将闹钟的实际铃声设定为铃声2 。双击操作必须在1s以内完成，如果超出1s则判定双击失败。

【额外考点】：定义s7为长按按键，按住超过2s则所有闹钟清零，但不松手界面2依旧保持。

3.显示要求

数码管无闪烁、跳动、鬼影、抖动、脉动等现象

在界面2下设置闹钟时，要求对应位间隔0.5s闪烁，即亮灭周期为1s ，按下任意数字键后，闪烁位循环向左移动，并立即将对应数字显示在数码管上。在界面2下，如果没有按下任何按键，则5s后自动返回界面1。在界面1下，按下任意数字键立即切换到界面2，此时固定为设置闹钟A1。并确保在界面1时间显示到xx：xx：55~00：00：00之间任意时刻按下数字键后，在界面2能正常维持5s的滞空时间（注意秒进位带来的返回界面1的bug）。

4.蜂鸣器设置

闹钟时间到，蜂鸣器播放对应的铃声。铃声1为2s一个周期，前1s内均匀滴滴滴……，后1s内静音，以此重复，持续6秒，具体效果自定义。铃声2为2s一个周期，前1s为滴——滴——滴滴——……，后1s静音，因此循环，持续6秒，具体效果自定义。

如果时间到了整点，蜂鸣器持续响1秒。

（注意，对于未设置的闹钟，默认为00：00，此时当时间刚好到整点时，只有整点的1s报时，而闹钟不会启动）

界面1下，双击s18或s19可以播放对应铃声，播放总时长为2s

在界面1下，同时按下S18+S19进行闹钟查看时，蜂鸣器滴一声，时长自定义。

3.代码资源情况

只用定时计数器0产生50us的中断，未用定时计数器1
矩阵按键s4-s6未使用，ds1302每500ms刷新一次
设置初始时间为：23：58：55，初始闹钟1为：23：59，闹钟2和闹钟3为00：00处于无效状态
初始为闹钟铃声1

4.完整参考代码

头文件如不会操作，可查看本人博客省赛专栏

4.1 底层代码源文件

#include <ds1302.h>
#include <onewire.h>
#include <reg52.h>
#include <intrins.h>

//锁存器通道选择函数
void select_HC573 ( unsigned char channal )
{
	switch ( channal )
	{
		case 4:
			P2 = ( P2 & 0x1f ) | 0x80;
		break;
		case 5:
			P2 = ( P2 & 0x1f ) | 0xa0;
		break;
		case 6:
			P2 = ( P2 & 0x1f ) | 0xc0;
		break;
		case 7:
			P2 = ( P2 & 0x1f ) | 0xe0;
		break;
		case 0:
			P2 = ( P2 & 0x1f ) | 0x00;
		break;
	}
}

//单位数码管显示函数
void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG )
{
	select_HC573 ( 0 );
	P0 = 0x01 << pos_SMG;	
	select_HC573( 6 );
	select_HC573 ( 0 );
	P0 = value_SMG;
	select_HC573( 7 );
	select_HC573 ( 0 );
}

//全位数码管静态显示
void state_SMG_all ( unsigned char value_SMG_all )
{
	select_HC573 ( 0 );
	P0 = 0xff;	
	select_HC573( 6 );
	select_HC573 ( 0 );
	P0 = value_SMG_all;
	select_HC573( 7 );
	select_HC573 ( 0 );
}	


//led灯光控制函数
void state_led ( unsigned char value_led )
{
	select_HC573 ( 0 );
	P0 = 0xff;
	select_HC573 ( 4 );
	P0 = value_led;
	select_HC573 ( 4 );	
	select_HC573 ( 0 );
}

//初始化系统，关闭继电器和蜂鸣器
void init_sys ()
{
	select_HC573 ( 0 );
	P0 = 0xff;	
	select_HC573 ( 4 );
	select_HC573 ( 0 );
	P0 = 0x00;
	select_HC573 ( 5 );
	select_HC573 ( 0 );

}

4.2 底层代码头文件

#ifndef __BASECODE_H__
#define __BASECODE_H__


unsigned char code duanma[20] = {0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,
                                 0x88,0x83,0xc6,0xc0,0x86,0x8e,0xbf,0xc7,0x89,0x8c};
unsigned char code Write_address [7] = { 0x80 , 0x82 , 0x84 , 0x86 , 0x88 , 0x8a , 0x8c};
unsigned char code Read_address [7] = { 0x81 , 0x83 , 0x85 , 0x87 , 0x89 , 0x8b , 0x8d };
 
//2024year 5month 14day 2 23 58 55
unsigned char date_ds1302 [7] = { 0x55 , 0x58 , 0x23 , 0x14 , 0x05 , 0x02 , 0x24 };

void state_buzz ( unsigned char value_buzz );
void select_HC573 ( unsigned char channal );
void state_SMG ( unsigned char pos_SMG , unsigned char value_SMG );
void state_SMG_all ( unsigned char value_SMG_all );
void state_led ( unsigned char value_led );
void init_sys ();
void state_buzz ( unsigned char value_buzz );


#endif

4.3 主函数文件

#include <reg52.h>
#include <intrins.h>
#include <ds1302.h>
#include "basecode.h"

sfr AUXR = 0x8e;
sfr P4 = 0xc0;

sbit C1 = P4^4;
sbit C2 = P4^2;
sbit C3 = P3^5;
sbit C4 = P3^4;
sbit R1 = P3^0;
sbit R2 = P3^1;
sbit R3 = P3^2;
sbit R4 = P3^3;

unsigned char SMG_flag = 1;
unsigned char clock_flag = 1;
unsigned char set_bit = 4;
unsigned char old_second = 0x99;
unsigned char flash_count = 0x00;
unsigned char ds1302_hour = 0x00;
unsigned char ds1302_min = 0x00;
unsigned char ds1302_second = 0x00;
bit count_1s = 0;

void flash_SMG();
void Delay20ms();
void Delay100ms ();

void state_buzz ( unsigned char value_buzz )
{
	if ( value_buzz == 0 )
	{
		P2 = ( P2 & 0x1f ) | 0xa0;
		P0 = 0x00;
	}
	else
	{
		P2 = ( P2 & 0x1f ) | 0xa0;
		P0 = 0x40;
	}
}

void ring1 ()
{
	if ( count_1s == 1 )
	{
		state_buzz ( 1 );
		Delay20ms();
		state_buzz ( 0 );
		Delay20ms();
		state_buzz ( 1 );
		Delay20ms();
		state_buzz ( 0 );
		Delay20ms();
		state_buzz ( 1 );
		Delay20ms();
		state_buzz ( 0 );
		Delay20ms();
	}
}

void ring2 ()
{
	if ( count_1s == 1 )
	{
		state_buzz ( 0 );
		Delay100ms();
		state_buzz ( 1 );
		Delay100ms();
		state_buzz ( 0 );
		Delay100ms();
		state_buzz ( 1 );
	}
}

void ringdi ()
{
		state_buzz ( 1 );
		Delay20ms();
		Delay20ms();
		state_buzz ( 0 );
}	
	

void init_ds1302 ()
{
	unsigned char i;
	Write_Ds1302_Byte ( 0x8e , 0x00 );
	for ( i=0 ; i<3 ; i++ )
	{
		Write_Ds1302_Byte ( Write_address[i] , date_ds1302[i] );
	}
	Write_Ds1302_Byte ( 0x8e , 0x80 );
 
}
 
void flash_date()
{
		unsigned char i;
		ds1302_hour = date_ds1302[2];
		ds1302_min = date_ds1302[1];
		ds1302_second = date_ds1302[0];
		
		
		for ( i=0 ; i<3 ; i++ )
		{
			date_ds1302[i] = Read_Ds1302_Byte ( Read_address[i] );
		}
}


void init_timer0()		//50微秒@12.000MHz
{
	AUXR |= 0x80;		//定时器时钟1T模式
	TMOD &= 0xF0;		//设置定时器模式
	TL0 = 0xA8;		//设置定时初始值
	TH0 = 0xFD;		//设置定时初始值
	TF0 = 0;		//清除TF0标志
	TR0 = 1;		//定时器0开始计时
	
	EA = 1;
	ET0 = 1;
}



unsigned char clock[3][4] = { { 2 , 3 , 5 , 9 } , { 0 , 0 , 0 , 0 } , { 0 , 0 , 0 , 0 } };//分别对应三个闹钟的时分位
unsigned char set_clock_value[4] = { 0 , 0 , 0 , 0 };  //用于数码管显示，同时存储暂时数据
unsigned char old_clean_second = 0;
unsigned char count_50us = 0;
unsigned char count_10ms = 0;
unsigned char count_05s = 0;
bit count_500ms = 0;
bit count_500ms_flag = 0;
bit clean_clock = 0;
bit key7_flag = 0;
void timer0_service () interrupt 1
{
	if ( ++count_50us == 200 )
	{
		count_50us = 0;
		
		if ( ++count_10ms % 50 == 0 ) 
		{
			if ( count_500ms_flag == 0 )
			{
				count_500ms = ~count_500ms;	
			}
			else
			{
				count_500ms = 1;	
			}
			
			if ( ++count_05s % 2 == 0 )
			{
				count_1s = ~count_1s;
				
				if ( count_05s == 200 ) 
				{
					count_05s = 0;
				}
			}
			
			count_10ms = 0;			
			
		}
		flash_date();
			
	}		
		
	
	
	if ( count_50us % 40 == 0 )
	{
		if ( ++flash_count == 8 )
		{
			flash_count = 0;
		}
		
		flash_SMG();
	}
	
	
	//长按s7超过2s所有闹钟清零
	if ( clean_clock == 1 && key7_flag == 1 )
	{

		unsigned char i,j;		
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_clean_second / 16 * 10) + (old_clean_second % 16);

		if ( current_second < previous_second )
		{
			current_second += 60;
		}
		
		if ( current_second - previous_second >= 2 ) 		
		{
			for( i=0 ; i<4 ; i++ )
			{
				for ( j=0 ; j<4 ; j++ )
				{
					clock[i][j] = 0;
				}
			}
			
			for ( i=0 ; i<4 ; i++ )
			{
				set_clock_value[i] = 0;
			}
			key7_flag = 0;			
		}
		
	}	
}

bit flag_buzz = 0;
bit key_flag = 0;   //按键被按下标志，1表示被按下，0表示未被按下
bit play_ring = 0;
unsigned char key19_twice = 0;
unsigned char key18_twice = 0;
unsigned char old_twice_second = 0;

void value_running ()
{
	if ( ds1302_hour == 0x00 && ds1302_min == 0x00 && ds1302_second < 0x01 )
	{
//		select_HC573(5);P0 = 0x40;select_HC573(0);
		state_buzz ( 1 );
	}
	else 
	{
//		select_HC573(5);P0 = 0x00;select_HC573(0);
		state_buzz ( 0 );
	}
	
	if ( key_flag == 1 )
	{
		SMG_flag = 2;	
	}
	else if (key_flag == 0 && SMG_flag == 2) 
	{
		// 将BCD编码的秒转换为十进制
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_second / 16 * 10) + (old_second % 16);

		// 检查是否已经过了5秒，考虑到秒数从59回到0的情况
		if (current_second < previous_second) 
		{ // 说明发生了进位
			current_second += 60;
		}

		if ((current_second - previous_second) >= 5) 
		{
			SMG_flag = 1;
			clock_flag = 1;
			set_bit = 4;
		}
	}

	//1s内未成功双击，只是单击
	if ( key19_twice == 1 )
	{
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_twice_second / 16 * 10) + (old_twice_second % 16);
		
		if ( (current_second - previous_second) > 2 )
		{	
			key19_twice = 0;
		}		
	}
	else if ( key18_twice == 1 )
	{		
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_twice_second / 16 * 10) + (old_twice_second % 16);
		
		if ( current_second - previous_second > 2 )
		{	
			key18_twice = 0;
		}
	}
	
	//1s内成功双击
	if ( key19_twice == 2 )
	{		
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_twice_second / 16 * 10) + (old_twice_second % 16);
		play_ring = 0;
		if (current_second < previous_second) 
		{ 
			current_second += 60;
		}
		
		if ( (current_second - previous_second) <= 2 )
		{	
			ring1 ();
		}
		else
		{
			key19_twice = 0;
			state_buzz ( 0 );
		}		
	}
	else if ( key18_twice == 2 )
	{				
		unsigned char current_second = (ds1302_second / 16 * 10) + (ds1302_second % 16);
		unsigned char previous_second = (old_twice_second / 16 * 10) + (old_twice_second % 16);
		play_ring = 1;
		if (current_second < previous_second) 
		{ 
			current_second += 60;
		}
		
		if ( current_second - previous_second <= 2 )
		{	
			ring2 ();
		}
		else
		{
			key18_twice = 0;
			state_buzz ( 0 );
		}
	}
	
	//闹钟正常铃声
	if ( clock[0][0]*16+clock[0][1] == ds1302_hour && clock[0][2]*16+clock[0][3] == ds1302_min ) 
	{
		if ( clock[0][0]+clock[0][1]+clock[0][2]+clock[0][3] != 0 )
		{
			if ( ds1302_second  <= 0x06 )
			{
				if ( play_ring == 0 )
				{
					ring1();
				}
				else
				{
					ring2();
				}
			}
		}
	}
	else if ( clock[1][0]*16+clock[1][1] == ds1302_hour && clock[1][2]*16+clock[1][3] == ds1302_min )
	{
		if ( clock[1][0]+clock[1][1]+clock[1][2]+clock[1][3] != 0 )
		{
			if ( ds1302_second  <= 0x06 )
			{
				if ( play_ring == 0 )
				{
					ring1();
				}
				else
				{
					ring2();
				}
			}
		}		
		
	}
	else if ( clock[2][0]*16+clock[2][1] == ds1302_hour && clock[2][2]*16+clock[2][3] == ds1302_min )
	{
		if ( clock[2][0]+clock[2][1]+clock[2][2]+clock[2][3] != 0 )
		{
			if ( ds1302_second  <= 0x06 )
			{
				if ( play_ring == 0 )
				{
					ring1();
				}
				else
				{
					ring2();
				}
			}
		}
	}	

}

unsigned char set_clock_hour = 0x00;
unsigned char set_clock_min = 0x00;
unsigned char set_clock_second = 0x00;
void flash_SMG()
{
	state_SMG_all ( 0xff );
	
	if ( SMG_flag == 1 )
	{
		switch ( flash_count )
		{
			case 0:
				state_SMG ( 0 , duanma[ds1302_hour/16] );
			break;
			case 1:
				state_SMG ( 1 , duanma[ds1302_hour%16] );
			break;
			case 2:
				state_SMG ( 2 , duanma[16] );
			break;
			case 3:
				state_SMG ( 3 , duanma[ds1302_min/16] );
			break;
			case 4:
				state_SMG ( 4 , duanma[ds1302_min%16] );
			break;
			case 5:
				state_SMG ( 5 , duanma[16] );
			break;
			case 6:
				state_SMG ( 6 , duanma[ds1302_second/16] );
			break;
			case 7:
				state_SMG ( 7 , duanma[ds1302_second%16] );
			break;
		}
	}
	else if ( SMG_flag == 2 )
	{
		switch ( flash_count )
		{
			case 0:
				state_SMG ( 0 , duanma[10] );
			break;
			case 1:
				state_SMG ( 1 , duanma[clock_flag] );
			break;
			case 2:
				state_SMG ( 2 , 0x7f );
			break;
			case 3:
				if ( set_bit == 1 && count_500ms == 0 )
				{
					state_SMG ( 3 , 0xff );
				}
				else
				{
					state_SMG ( 3 , duanma[set_clock_value[0]] );
				}
			break;
			case 4:
				if ( set_bit == 2 && count_500ms == 0 )
				{
					state_SMG ( 4 , 0xff );
				}
				else
				{
					state_SMG ( 4 , duanma[set_clock_value[1]] );
				}
			break;
			case 5:
				state_SMG ( 5 , duanma[16] );
			break;
			case 6:
				if ( set_bit == 3 && count_500ms == 0 )
				{
					state_SMG ( 6 , 0xff );
				}
				else
				{
					state_SMG ( 6 , duanma[set_clock_value[2]] );
				}
			break;
			case 7:
				if ( set_bit == 4 && count_500ms == 0 )
				{
					state_SMG ( 7 , 0xff );
				}
				else
				{
					state_SMG ( 7 , duanma[set_clock_value[3]] );
				}
			break;
		}
	}
}

void Delay1ms()		//@12.000MHz
{
	unsigned char i, j;

	i = 12;
	j = 169;
	do
	{
		while (--j);
	} while (--i);
}

void Delay20ms()		//@12.000MHz
{
	unsigned char i, j;

	i = 234;
	j = 115;
	do
	{
		while (--j);
	} while (--i);
}

void Delay100ms()		//@11.0592MHz
{
	unsigned char i, j, k;

	_nop_();
	_nop_();
	i = 5;
	j = 52;
	k = 195;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}


void Delay1s()		//@12.000MHz
{
	unsigned char i, j, k;

	_nop_();
	_nop_();
	i = 46;
	j = 153;
	k = 245;
	do
	{
		do
		{
			while (--k);
		} while (--j);
	} while (--i);
}


void key_running ()
{			
	C2 = 0;
	C1 = C3 = C4 = R1 = R2 = R3 = R4 = 1;
	if ( R1 == 0 )				//S11 
	{
		Delay1ms();
		if ( R1 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 )
				{
					set_clock_value[set_bit-1] = 3;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			

			while ( R1 == 0 );
			key_flag = 0;
		}
	}
	else if ( R2 == 0 )			//S10 
	{
		Delay1ms();
		if ( R2 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				set_clock_value[set_bit-1] = 2;
				if ( --set_bit == 0 )
				{
					set_bit = 4;
				}
			}			
			
			while ( R2 == 0 );
			key_flag = 0;
		}
	}
	else if ( R3 == 0 )			//S9 
	{
		Delay1ms();
		if ( R3 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				set_clock_value[set_bit-1] = 1;
				if ( --set_bit == 0 )
				{
					set_bit = 4;
				}
			}			
			
			while ( R3 == 0 );
			key_flag = 0;
		}
	}
	else if ( R4 == 0 )			//S8 
	{
		Delay1ms();
		if ( R4 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				set_clock_value[set_bit-1] = 0;
				if ( --set_bit == 0 )
				{
					set_bit = 4;
				}
			}			
		
			while ( R4 == 0 );
			key_flag = 0;
		}
	}
	
	C3 = 0;
	C1 = C2 = C4 = R1 = R2 = R3 = R4 = 1;
	if ( R1 == 0 )				//S15 
	{
		Delay1ms();
		if ( R1 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 && set_bit != 3 )
				{
						
					set_clock_value[set_bit-1] = 7;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R1 == 0 );
			key_flag = 0;
		}
	}
	else if ( R2 == 0 )			//S14
	{
		Delay1ms();
		if ( R2 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 && set_bit != 3 )
				{
					set_clock_value[set_bit-1] = 6;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R2 == 0 );
			key_flag = 0;
		}
	}
	else if ( R3 == 0 )			//S13
	{
		Delay1ms();
		if ( R3 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 )
				{
					set_clock_value[set_bit-1] = 5;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R3 == 0 );
			key_flag = 0;
		}
	}
	else if ( R4 == 0 )			//S12
	{
		Delay1ms();
		if ( R4 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 )
				{
					set_clock_value[set_bit-1] = 4;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R4 == 0 );
			key_flag = 0;
		}
	}

	C4 = 0;
	C1 = C2 = C3 = R1 = R2 = R3 = R4 = 1;
	if ( R1 == 0 || R2 == 0 )				
	{
		Delay20ms();
		if ( R1 == 0 && R2 == 0 ) //S19+S18 
		{
			key19_twice = key18_twice = 0;			
			if ( SMG_flag == 1 )
			{
				ringdi ();
				while ( R1 == 0 && R2 == 0 )
				{
					SMG_flag = 2;
					count_500ms_flag = 1;  //用于屏蔽数码管的闪烁
					set_clock_value[0] = clock[clock_flag-1][0];
					set_clock_value[1] = clock[clock_flag-1][1];
					set_clock_value[2] = clock[clock_flag-1][2];
					set_clock_value[3] = clock[clock_flag-1][3];
					
					if ( R1 == 0 && R2 == 0 )
					{
						Delay1s();
					}
					
					if ( ++clock_flag == 4 )
					{
						clock_flag = 1;
					}								
				}
				SMG_flag = 1;
				count_500ms_flag = 0;
				
			}
		}
		else if ( R1 == 0 ) 		//S19
		{
			if ( SMG_flag == 2 ) 
			{
				key19_twice = key18_twice = 0;
				clock[clock_flag-1][0] = set_clock_value[0];
				clock[clock_flag-1][1] = set_clock_value[1];
				clock[clock_flag-1][2] = set_clock_value[2];
				clock[clock_flag-1][3] = set_clock_value[3];
				SMG_flag = 1;	
				clock_flag = 1;
				set_bit = 4;
			}
			else if ( SMG_flag == 1 )
			{
				key18_twice = 0;
				if ( ++key19_twice == 2 );
//				{
					old_twice_second = ds1302_second;
//				}
			}

			while ( R1 == 0 );
		}
		else if ( R2 == 0 ) 		 //S18
		{
			if ( SMG_flag == 2 )
			{
				key_flag = 1;
				key19_twice = key18_twice = 0;
				old_second = ds1302_second;
				set_bit = 4;
				if ( ++clock_flag == 4 )
				{
					clock_flag = 1;
				}
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 1 )
			{
				key19_twice = 0;
				if ( ++key18_twice == 2 );
//				{
					old_twice_second = ds1302_second;
//				}
			}
			while ( R2 == 0 );
			key_flag = 0;
		}
	}
	else if ( R3 == 0 )				//S17
	{
		Delay1ms();
		if ( R3 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 && set_bit != 3 )
				{
					set_clock_value[set_bit-1] = 9;
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R3 == 0 );
			key_flag = 0;
		}
	}
	else if ( R4 == 0 )				//S16
	{
		Delay1ms();
		if ( R4 == 0 )
		{
			
			key_flag = 1;
			key19_twice = key18_twice = 0;
			old_second = ds1302_second;
			if ( SMG_flag == 1 )
			{
				SMG_flag = 2;
				set_clock_value[0] = clock[clock_flag-1][0];
				set_clock_value[1] = clock[clock_flag-1][1];
				set_clock_value[2] = clock[clock_flag-1][2];
				set_clock_value[3] = clock[clock_flag-1][3];				
			}
			else if ( SMG_flag == 2 )
			{
				if ( set_bit != 1 && set_bit != 3 )
				{
					set_clock_value[set_bit-1] = 8;
			
					if ( --set_bit == 0 )
					{
						set_bit = 4;
					}
				}
			}			
					
			while ( R4 == 0 );
			key_flag = 0;
		}
	}

	
	//长按s7闹钟清零按键
	C1 = 0;
	C2 = C3 = C4 = R1 = R2 = R3 = R4 = 1;
	if ( R1 == 0 )
	{
		Delay1ms();
		
		if ( R1 == 0 && SMG_flag == 2 )
		{	
			key_flag = 1;
			old_second = ds1302_second;
			key7_flag = 1;
			old_clean_second = ds1302_second;
			while ( R1 == 0 )
			{
				if ( key7_flag == 1 )
				{				
					clean_clock = 1;
				}
			}
			clean_clock = 0;
			key_flag = 0;
		}
	}					
}



void main ()
{
	init_sys ();
	init_ds1302 ();
	init_timer0 ();
	state_led ( 0xff );
	while ( 1 )
	{		
		
		key_running();
		value_running ();		
	}
}

archie474

关注

9
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
蓝桥杯单片机-国赛2——按键专项测试：单击、双击、双按键、数码管闪烁移位

红色区域为本任务涉及的部分。在界面1下，s8-s17单击时，切换到界面2。同时长按不松手s18+s19时，蜂鸣器滴一声，并间隔1s逐个显示用户设置的闹钟。双击s19展示闹钟铃声1，并设置为闹钟铃声。双击s19展示闹钟铃声2，并设置为闹钟铃声。在界面2下，s8-s11为0-3， s12-s15为4-7，s16-s17为8-9，S18单击为闹钟界面切换，S19单击为确定设置键，S18+S19同时按下无反应。
复制链接

扫一扫