5.3 按键/遥控读取部份代码

#include "Config.h"


extern volatile _Bool Synch; 
extern volatile  u8 RF_data; 
extern volatile XTIMER Timer[e_Timer_Max];
const u8 rfcodes[] = { 
	0XCC, 0X03, 0X0C, 0X0F, 0X30, 0X33, 
	0X3C, 0X3F, 0XC0, 0XC3, 0XCF, 0XF0
}; 

void Key_Init(void) 
{ 
	set_io_isinput(PORT_KEY_SET, BIT_KEY_SET); 
	set_io_isinput(PORT_KEY_INC, BIT_KEY_INC); 
	set_io_isinput(PORT_KEY_DEC, BIT_KEY_DEC); 
	
	set_io_pushpull(PORT_KEY_SET, BIT_KEY_SET); 
	set_io_pushpull(PORT_KEY_INC, BIT_KEY_INC); 
	set_io_pushpull(PORT_KEY_DEC, BIT_KEY_DEC); 
} 

uCHAR GetKeyVal(void)
{
	char temp, i;
	static key_bak, key_temp=KEY_SEL_NOSEL; 	
	
	temp = 0; 
	if(!get_bit(PORT_KEY_SET, BIT_KEY_SET)) { 
		temp |= BIT(0); 
	} 
	if(!get_bit(PORT_KEY_INC, BIT_KEY_INC)) { 
		temp |= BIT(1); 
	} 
	if(!get_bit(PORT_KEY_DEC, BIT_KEY_DEC)) { 
		temp |= BIT(2); 
	} 
	
	if(temp == KEY_SEL_NOSEL) { 
		//unpressed 
		key_temp = KEY_SEL_NOSEL; 
		return KEY_SEL_NOSEL; 
	} 
	//the last key event not free
	if(key_temp==temp) return KEY_SEL_NOSEL;	//key noise filter
	if(!IS_TIMERSTART(e_Timer_KeyFilter)) { 
		key_bak = temp; 
		START_TIMER(e_Timer_KeyFilter, 10); 
	} else if(key_bak!=temp) { 
		//key changed in filter 
		STOP_TIMER(e_Timer_KeyFilter); 
		return KEY_SEL_NOSEL; 
	} 

	if(!IS_TIMEROVER(e_Timer_KeyFilter)) return KEY_SEL_NOSEL; 
	STOP_TIMER(e_Timer_KeyFilter); 
	key_temp = temp; 

	if(temp==0x01) { 
		return KEY_SEL_SET;
	} else if(temp==0x02) { 
		return KEY_SEL_INC;
	} else if(temp==0x04) { 
		return KEY_SEL_DEC;
	} else { 
		//KEY_SEL_MOV,KEY_SEL_POW 
		if(temp==0x03) { 
			return KEY_SEL_MOV;
		} else if(temp==0x05) { 
			return KEY_SEL_POW;
		}
	} 
	return KEY_SEL_NOSEL;
}

uCHAR IR_KeyB(void)
{
	uCHAR Keytemp;
	static uCHAR RF_Temp = 0xFF;
	
	if(!Synch) { 
		Keytemp = GetKeyVal(); 
	} else { 
		Synch = FALSE; 
		if(IS_TIMERSTART(e_Timer_Remote)) { 
			if(!IS_TIMEROVER(e_Timer_Remote)) { 
				return KEY_SEL_NOSEL; 
			} 
			STOP_TIMER(e_Timer_Remote); 
		} 
		//遥控解码间隙超时
		START_TIMER(e_Timer_Remote, 300); 
		
		for(Keytemp=0; Keytemp<12; Keytemp++) { 
			if(rfcodes[Keytemp]==RF_data) { 
				Synch = TRUE; 
				break; 
			} 
		} 
		if(Synch) { 
			switch(Keytemp) { 
			case 10: 
				Keytemp = KEY_SEL_SET; 
				break; 
			case 11:
				Keytemp = KEY_SEL_DEC; 
				break; 
			} 
		} 
		Synch = FALSE; 
	} 
	
	return Keytemp;
}

#include "Config.h"

#if OPT_COUNTER
volatile Counter_t on_Ct = {0}; 
#endif 
volatile Alam_t on_Alam = {0, 0, 0, 0}; 
volatile uCHAR dis_buffer[11];
volatile WatchSet_t WatchSet; 

extern DATE date;
extern TIME time;
extern volatile WatchCfg_t WatchCofing; 
extern volatile XTIMER Timer[e_Timer_Max];

//-----------------------------------

#define isLeampyear(year) ((year%4==0&&year%100!=0)||(year%400==0))  
	
//-----------------------------------

//led show codes
//0~9, ' ', -, A, C, H
const uCHAR LED[] = {
	0XDE,0X06,0XEC,0XAE,0X36, //0~4
	0XBA,0XFA,0X0E,0XFE,0XBE, //5~9
	0x00, //String - ' '
	0X20, //String - '-'
	0X7E, //String - 'A'
	0XD8, //String - 'C'
	0X76, //String - 'H'
	0XD6, //String - 'U'
	0X5E, //String - 'N'
	0XF0, //String - 't'
	0XD0, //String - 'L'
	0X01  //String - '.'
}; 

const uCHAR SEGMENT[] = { 
	0x08,0x04,0x02,0x80,0x40,0x10,0x20,0x01
}; 

//-----------------------------------
//FUNCTION: DISPLAY THE DATA
//-----------------------------------
static void Watch_Update_Display(void)
{
	uCHAR i; 
	uCHAR v; 
	
	for(i=0; i<11; i++) { 
		v = *(dis_buffer+i); 
		if(v>=LEDWORD_USEDEF) { 
			MC74HC595_Shift(v-LEDWORD_USEDEF); 
		} else { 
			MC74HC595_Shift(LED[v]); 
		} 
	} 
	MC74HC595_Update(); 
}

void write_DisBuffer(u8 ID, u8 v) 
{ 
	*(dis_buffer+ID) = v; 
} 

u8 read_DisBuffer(u8 ID) 
{ 
	return *(dis_buffer+ID); 
} 

//----------------------------------
//FUNCTION: display the year
//----------------------------------
void Watch_Display_Date(DATE date)
{
	write_DisBuffer(LEDITEM_MAIN_1, math_div(date.year, 10));	//year ten
	write_DisBuffer(LEDITEM_MAIN_2, math_mod(date.year, 10));			//year signed
	write_DisBuffer(LEDITEM_MAIN_3, LEDWORD_LINE);						//"-"
	write_DisBuffer(LEDITEM_MAIN_4, math_div(date.month, 10));	//month ten
	write_DisBuffer(LEDITEM_MAIN_5, math_mod(date.month, 10));		//month signed
	write_DisBuffer(LEDITEM_MAIN_6, LEDWORD_LINE);						//"-"
	write_DisBuffer(LEDITEM_MAIN_7, math_div(date.day, 10));	//date ten
	write_DisBuffer(LEDITEM_MAIN_8, math_mod(date.day, 10));			//date signed
	write_DisBuffer(LEDITEM_WEEK, math_mod(date.week, 10));		//week
	if(WatchSet.in.item.show) { 
		write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDA); 
		write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_WORDT); 
	} 
	
	Watch_Update_Display(); 
}


//----------------------------------
//Function: display the date
//----------------------------------
void Watch_Display_Time(TIME time)
{
	uCHAR temp;
	static u8 scrow = TRUE; 
	
	write_DisBuffer(LEDITEM_MAIN_1, math_div(time.hour, 10));	//Hour ten
	write_DisBuffer(LEDITEM_MAIN_2, math_mod(time.hour, 10));		//Hour signed
	write_DisBuffer(LEDITEM_MAIN_3, LEDWORD_LINE);			//"-"
	write_DisBuffer(LEDITEM_MAIN_4, math_div(time.min, 10));	//minute ten
	write_DisBuffer(LEDITEM_MAIN_5, math_mod(time.min, 10));		//minute signed
	write_DisBuffer(LEDITEM_MAIN_6, LEDWORD_LINE);			//"-"
	write_DisBuffer(LEDITEM_MAIN_7, math_div(time.sec, 10));	//second ten
	write_DisBuffer(LEDITEM_MAIN_8, math_mod(time.sec, 10));		//second signed
	if(!WatchSet.in.items) { 
#if OPT_COUNTER
		if(on_Ct.use) { 
			if(!on_Ct.full) { 
				on_Ct.segLeds |= SEGMENT[on_Ct.sCount++]; 
				if(on_Ct.sCount>=6) { 
					on_Ct.sCount = 0; 
				} 
				on_Ct.segLeds &= ~SEGMENT[on_Ct.sCount]; 
				
				write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDC); 
				write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_DIG0); 
				write_DisBuffer(LEDITEM_WEEK, LEDWORD_USEDEF+on_Ct.segLeds);
			} else { 
				if(scrow) { 
					write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_BLANK); 
					write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_BLANK); 
					write_DisBuffer(LEDITEM_WEEK, LEDWORD_BLANK);
				} else { 
					write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDC); 
					write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_DIG0); 
					write_DisBuffer(LEDITEM_WEEK, LEDWORD_LINE);
				} 
				scrow = !scrow; 
			} 
		} else 
#endif 
		if(on_Alam.inw) { 
			if(scrow) { 
				write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDA); 
				write_DisBuffer(LEDITEM_TEMP_L, on_Alam.id); 
				write_DisBuffer(LEDITEM_WEEK, LEDWORD_LINE);
			} else { 
				write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_BLANK); 
				write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_BLANK); 
				write_DisBuffer(LEDITEM_WEEK, LEDWORD_BLANK);
			} 
			scrow = !scrow; 
		} else { 
			temp = Temperature_Read(); 
			if(temp>=100) { 
				write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_LINE); 
				write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_LINE); 
			} else { 
				write_DisBuffer(LEDITEM_TEMP_H, math_div(temp, 10)); 
				write_DisBuffer(LEDITEM_TEMP_L, math_mod(temp, 10)); 
			} 
			write_DisBuffer(LEDITEM_WEEK, math_mod(date.week, 10));		//week 
		} 
	} 
	Watch_Update_Display(); 
}

void Watch_Display_Temp(s8 temp) 
{ 
	if(temp>=0) { 
		write_DisBuffer(LEDITEM_TEMP_H, math_div(temp, 10));
		write_DisBuffer(LEDITEM_TEMP_L, math_mod(temp, 10)); 
	} else { 
		write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_LINE);
		write_DisBuffer(LEDITEM_TEMP_L, (0-temp));
	} 
	Watch_Update_Display(); 
} 


//----------------------------------
//Function: Adjust the time
//----------------------------------
void setv(uCHAR ID, s8 v, const char min, const char max) 
{ 
	s8 ss = -1; 

	if(v>=10) { 
		ss = v-10; 
		if((ss>=min)&&(ss<=max))write_DisBuffer(ID, ss); 
	} else { 
		ss = (char)(read_DisBuffer(ID)+v); 
		if(ss > max) {  
			write_DisBuffer(ID, min); 
		} else if(ss < min) { 
			write_DisBuffer(ID, max); 
		} else { 
			write_DisBuffer(ID, (uCHAR)ss); 
		} 
	} 
	if(v!=0)WatchSet.in.item.modify = TRUE; 
} 

void setCV(uCHAR ID, s8 v, const char min, const char max) 
{ 
	setv(ID, v, min, max); 
	//更新闪烁缓存数值
	WatchSet.temp = read_DisBuffer(ID); 
} 

static TIME Watch_Adjust_Time(char AdjItem, s8 val)
{	
	TIME new_time; 
	
	switch(AdjItem){
	case 0: 
		setCV(LEDITEM_MAIN_1, val, 0, 2); 
		if(read_DisBuffer(LEDITEM_MAIN_1)==2){
			setv(LEDITEM_MAIN_2, val, 0, 3); 
		}
		break;
	case 1:
		if(read_DisBuffer(LEDITEM_MAIN_1)==2){
			setCV(LEDITEM_MAIN_2, val, 0, 3); 
		} else { 
			setCV(LEDITEM_MAIN_2, val, 0, 9); 
		}
		break;
	case 2:
		setCV(LEDITEM_MAIN_4, val, 0, 5); 
		break;
	case 3:
		setCV(LEDITEM_MAIN_5, val, 0, 9); 
		break;
	case 4:
		setCV(LEDITEM_MAIN_7, val, 0, 5); 
		break;
	case 5:
		setCV(LEDITEM_MAIN_8, val, 0, 9); 
		break;
	default: 
		break;
	} 
	 
	new_time.hour = math_mux(read_DisBuffer(LEDITEM_MAIN_1),10) + read_DisBuffer(LEDITEM_MAIN_2);
	new_time.min  = math_mux(read_DisBuffer(LEDITEM_MAIN_4),10) + read_DisBuffer(LEDITEM_MAIN_5);
	new_time.sec  = math_mux(read_DisBuffer(LEDITEM_MAIN_7),10) + read_DisBuffer(LEDITEM_MAIN_8);
	Watch_Update_Display(); 
	
	return new_time; 
}



//---------------------------------
//Function: Adjust date
//---------------------------------
void Adjust_Date_Value(u8 ID)
{
	u8 month, x; 
	u16 year = 2000; 
	uCHAR lagermonth[] = {1,3,5,7,8,10,12};

	year += read_DisBuffer(LEDITEM_MAIN_1)*10 + read_DisBuffer(LEDITEM_MAIN_2); 
	month = read_DisBuffer(LEDITEM_MAIN_4)*10 + read_DisBuffer(LEDITEM_MAIN_5); 
	if(month==2) { 
		if(read_DisBuffer(LEDITEM_MAIN_7)==2) { 
			if(isLeampyear(year)) { 
				setv(LEDITEM_MAIN_8, 0, 0,  8); 
			} else { 
				setv(LEDITEM_MAIN_8, 0, 0,  9); 
			} 
		} 
	} else if(read_DisBuffer(LEDITEM_MAIN_7)==3) { 
		for(x=0; x<sizeof(lagermonth); x++) { 
			if(month==lagermonth[x]) { 
				setv(LEDITEM_MAIN_8, 0, 0,  1); 
				break; 
			} 
		} 
		if(x>=sizeof(lagermonth)) { 
			write_DisBuffer(LEDITEM_MAIN_8, 0); 
		} 
	} 
	//更新闪烁缓存数值
	if(ID==LEDITEM_MAIN_8) { 
		WatchSet.temp = read_DisBuffer(LEDITEM_MAIN_8); 
	} 
}

static DATE Watch_Adjust_Date(char AdjItem, s8 val)
{
	u8 month; 
	DATE new_date;  
	

	switch(AdjItem){
	case 0:
		//Year-H
		setCV(LEDITEM_MAIN_1, val, 0, 9); 
		break;
	case 1:
		//Year-L
		setCV(LEDITEM_MAIN_2, val, 0, 9); 
		break; 
	case 2: 
		//Month-H
		setCV(LEDITEM_MAIN_4, val, 0, 1); 
		if(read_DisBuffer(LEDITEM_MAIN_4)) { 
			setv(LEDITEM_MAIN_5, val, 0, 2); 
		} else { 
			setv(LEDITEM_MAIN_5, val, 1, 9); 
		}
		Adjust_Date_Value(LEDITEM_MAIN_4); 
		break;
	case 3:
		//Month-L
		if(read_DisBuffer(LEDITEM_MAIN_4)) { 
			setCV(LEDITEM_MAIN_5, val, 0, 2); 
		} else { 
			setCV(LEDITEM_MAIN_5, val, 1, 9); 
		} 
		Adjust_Date_Value(LEDITEM_MAIN_5); 
		break;
	case 4: 
		//DAY-H 
		month = read_DisBuffer(LEDITEM_MAIN_4)*10 + read_DisBuffer(LEDITEM_MAIN_5); 
		if(month==2) { 
			setCV(LEDITEM_MAIN_7, val, 0, 2); 
		} else { 
			setCV(LEDITEM_MAIN_7, val, 0, 3); 
		} 
		Adjust_Date_Value(LEDITEM_MAIN_7); 
		break;
	case 5:
		if(read_DisBuffer(LEDITEM_MAIN_7)==3) { 
			setCV(LEDITEM_MAIN_8, val, 0, 1); 
		} else { 
			setCV(LEDITEM_MAIN_8, val, 0, 9); 
		} 
		Adjust_Date_Value(LEDITEM_MAIN_8); 
		break;
	case 6:
		setCV(LEDITEM_WEEK, val, 0, 6); 
		break;
	default: 
		break;
	} 

	
	new_date.year   = math_mux(read_DisBuffer(LEDITEM_MAIN_1),10) + read_DisBuffer(LEDITEM_MAIN_2);
	new_date.month  = math_mux(read_DisBuffer(LEDITEM_MAIN_4),10) + read_DisBuffer(LEDITEM_MAIN_5);
	new_date.day   = math_mux(read_DisBuffer(LEDITEM_MAIN_7),10) + read_DisBuffer(LEDITEM_MAIN_8);
	new_date.week   = read_DisBuffer(LEDITEM_WEEK);
	Watch_Update_Display(); 
	return new_date; 
}



//---------------------------------
//Check alam time 
//---------------------------------
void Watch_Start_Alam(void)
{
	u8 i; 
	u16 nowtime; 
	Alert_t alam; 
	static u8 beepn = 0; 

	nowtime = (time.hour<<8)+time.min; 
	if((nowtime>=0x0700)&&(nowtime<0x1200)) { //7:00~18:00
		MC74HC595_Light_Set(80); 
	} else { 
		MC74HC595_Light_Set(30); 
	} 
	if(WatchSet.in.item.set) return; 

	if(on_Alam.enb) { 
		if(on_Alam.inw) { 
			if(on_Alam.time==nowtime) { 
				if(IS_TIMERSTART(e_Timer_Beep)) { 
					if(!IS_TIMEROVER(e_Timer_Beep)) return; 
				}
				if(++beepn<3) { 
					Beeper(TRUE, 150, 150); 
				} else { 
					beepn = 0; 
					Beeper(TRUE, 150, 250); 
				} 
			} else { 
				on_Alam.inw = FALSE; 
				if(on_Alam.cnt==0) on_Alam.enb = FALSE; 
			} 
		} else { 
			if((nowtime-on_Alam.time)>=3) { 
				on_Alam.inw = TRUE; 
				on_Alam.cnt--; 
				on_Alam.time = nowtime; 
			} 
		} 
	}

	
	if(time.sec) return; 
	for(i=0; i<10; i++) { 
		alam = WatchCofing.alart[i]; 
		if(!alam.on) continue; 
		if((alam.begin>alam.end)&&(date.week>alam.end)&&(date.week<alam.begin)) continue; 
		if((alam.begin<alam.end)&&((date.week<alam.begin)||(date.week>alam.end))) continue; 
		if((alam.begin==alam.end)&&(date.week!=alam.begin))continue; 
		if(nowtime==alam.time) { 
			on_Alam.inw = TRUE; 
			on_Alam.enb = TRUE; 
			on_Alam.cnt = 2; 
			on_Alam.id = i; 
			on_Alam.time = nowtime; 
			beepn = 0; 
			return; 
		} 
	} 
} 


void Watch_Show_SetItem(MENUMOD_ITEM mi, char sub)
{ 
	switch(mi) { 
	case MENUMOD_ITEM_TIME: 
		write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDC); 
		write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_WORDH); 
		write_DisBuffer(LEDITEM_WEEK, LEDWORD_BLANK); 
		Watch_Display_Time(time); 
		Watch_Adjust_Time(sub, 0); 
		break; 
	case MENUMOD_ITEM_DATE: 
		write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDC); 
		write_DisBuffer(LEDITEM_TEMP_L, LEDWORD_WORDU); 
		Watch_Display_Date(date);
		Watch_Adjust_Date(sub, 0); 
		break; 
#if OPT_COUNTER
	case MENUMOD_ITEM_COUNT: 
		write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDC); 
		write_DisBuffer(LEDITEM_TEMP_L, 0); 
		write_DisBuffer(LEDITEM_WEEK, LEDWORD_LINE); 
		Watch_Display_Time(on_Ct.set); 
		Watch_Adjust_Time(sub, 0); 
		break; 
#endif 
	case MENUMOD_ITEM_ALAM0:
	case MENUMOD_ITEM_ALAM1:
	case MENUMOD_ITEM_ALAM2:
	case MENUMOD_ITEM_ALAM3:
	case MENUMOD_ITEM_ALAM4:
	case MENUMOD_ITEM_ALAM5:
	case MENUMOD_ITEM_ALAM6:
	case MENUMOD_ITEM_ALAM7:
	case MENUMOD_ITEM_ALAM8:
	case MENUMOD_ITEM_ALAM9:
		Watch_Show_Alam(mi-MENUMOD_ITEM_ALAM0); 
		Watch_Adjust_Time(sub, 0); 
		break; 
	} 
}


//++++++++++++++++++++++++++++++++++ 
//+                         Grounp: time                           +
//++++++++++++++++++++++++++++++++++ 

//---------------------------------
//Function:Watch_Set_ time
//---------------------------------
void Watch_Set_Time(char item, char val)
{
	Watch_Display_Time(time);
	time = Watch_Adjust_Time(item, val);
}

//---------------------------------
//---------------------------------
void Watch_Save_Time(void)
{
	Writetime(time);
}


//+++++++++++++++++++++++++++++++++Grounp: Count down++++++++++++++++++++++++++
#if OPT_COUNTER 
//---------------------------------
//Function: Watch_Set_ count down
//---------------------------------
void Watch_Set_Count(char item, char val)
{ 
	Watch_Display_Time(on_Ct.set); 
	on_Ct.set = Watch_Adjust_Time(item, val);
}

//---------------------------------
//---------------------------------
void Watch_Start_Count(void)
{
	u32 setV; 

	if(!on_Ct.use) return; 

	setV = TimeToSeconds(on_Ct.set); 
	if(on_Ct.pause) { 
		Watch_Display_Time(SecondsToTime(setV-on_Ct.run)); 
		return; 
	} 
	
	if(!on_Ct.full) { 
		if(math_Time(time, on_Ct.base)==0) goto COUNT_DISPLAY; 
		
		on_Ct.run += math_Time(time, on_Ct.base); 
		on_Ct.base = time; 
		if(on_Ct.run>=setV) { 
			on_Ct.run = setV; 
			on_Ct.full = TRUE; 
			STOP_TIMER(e_Timer_Count); 
			START_TIMER(e_Timer_Alam, 30000); 
		} 
	} else { 
		if(IS_TIMEROVER(e_Timer_Alam)) { 
			on_Ct.use = FALSE; 
			on_Ct.full = FALSE; 
			STOP_TIMER(e_Timer_Alam); 
			STOP_TIMER(e_Timer_Count); 
			return; 
		} else { 
			Beeper(TRUE, 300, 500); 
			if(IS_TIMERSTOP(e_Timer_Count)) { 
				START_TIMER(e_Timer_Count, 400); 
			} 
		} 
	} 
COUNT_DISPLAY: 
	if(IS_TIMEROVER(e_Timer_Count)) {
		RESET_TIMER(e_Timer_Count); 
		Watch_Display_Time(SecondsToTime(setV-on_Ct.run)); 
	} 
}


void Watch_Save_Count(void) 
{ 
	time = Readtime(); 
	
	on_Ct.run = 0; 
	on_Ct.sCount = 0; 
	on_Ct.segLeds= 0; 
	on_Ct.full = FALSE; 
	on_Ct.pause = FALSE; 
	on_Ct.use = TRUE; 
	on_Ct.base = time; 
	START_TIMER(e_Timer_Count, 150); 
}
#endif 


//++++++++++++++++++++++++++++++++++Grounp: Alam++++++++++++++++++++++++++++++++
//---------------------------------
//Function: show the alam time
//---------------------------------
void Watch_Show_Alam(char alamID)
{
	u8 s; 
	Alert_t alam; 
	
	alam = WatchCofing.alart[alamID]; 
	
	write_DisBuffer(LEDITEM_TEMP_H, LEDWORD_WORDA); 
	write_DisBuffer(LEDITEM_TEMP_L, alamID); 

	s = (u8)(alam.time>>8); 
	write_DisBuffer(LEDITEM_MAIN_1, math_div(s, 10));	        //Hour ten
	write_DisBuffer(LEDITEM_MAIN_2, math_mod(s, 10));	        //Hour signed
	write_DisBuffer(LEDITEM_MAIN_3, LEDWORD_LINE);   //"-"
	s = (u8)(alam.time); 
	write_DisBuffer(LEDITEM_MAIN_4, math_div(s, 10));	         //minute ten
	write_DisBuffer(LEDITEM_MAIN_5, math_mod(s, 10));		     //minute signed
	write_DisBuffer(LEDITEM_MAIN_6, LEDWORD_BLANK);  //"."
	write_DisBuffer(LEDITEM_MAIN_7, alam.begin); 
	write_DisBuffer(LEDITEM_MAIN_8, alam.end); 
	if(alam.on) { 
		write_DisBuffer(LEDITEM_WEEK, LEDWORD_LINE); 
	} else { 
		write_DisBuffer(LEDITEM_WEEK, LEDWORD_BLANK); 
	} 
	
	Watch_Update_Display(); 
}

//---------------------------------
//Funtion: Watch_Set_ Alam time
//---------------------------------
void Watch_Set_Alam(char alamID, char item, char val)
{ 
	u8 v; 
	Alert_t* alam; 
	TIME alamTime; 
	
	Watch_Show_Alam(alamID);
	switch(item) { 
	case 0: 
		setCV(LEDITEM_MAIN_1, val, 0, 2); 
		if(read_DisBuffer(LEDITEM_MAIN_1)==2){
			setv(LEDITEM_MAIN_2, val, 0, 3); 
		}
		break;
	case 1:
		if(read_DisBuffer(LEDITEM_MAIN_1)==2){
			setCV(LEDITEM_MAIN_2, val, 0, 3); 
		} else { 
			setCV(LEDITEM_MAIN_2, val, 0, 9); 
		}
		break;
	case 2:
		setCV(LEDITEM_MAIN_4, val, 0, 5); 
		break;
	case 3:
		setCV(LEDITEM_MAIN_5, val, 0, 9); 
		break;
	case 4: 
		setCV(LEDITEM_MAIN_7, val, 0, 6); 
		break; 
	case 5: 
		setCV(LEDITEM_MAIN_8, val, 0, 6); 
		break; 
	} 	
	WatchCofing.dirty = TRUE; 
	
	alam = WatchCofing.alart+alamID; 
	alam->on = TRUE; 
	alam->time  = (read_DisBuffer(LEDITEM_MAIN_1)*10+read_DisBuffer(LEDITEM_MAIN_2))<<8; 
	alam->time += (read_DisBuffer(LEDITEM_MAIN_4)*10+read_DisBuffer(LEDITEM_MAIN_5)); 
	alam->begin = read_DisBuffer(LEDITEM_MAIN_7); 
	alam->end   = read_DisBuffer(LEDITEM_MAIN_8); 
	write_DisBuffer(LEDITEM_WEEK, LEDWORD_LINE); 
	
	Watch_Update_Display(); 
}

//---------------------------------
//---------------------------------
void Watch_Save_Alam(void)
{ 
}
//++++++++++++++++++++++++++++++++Grounp: Date+++++++++++++++++++++++++++++++++

//---------------------------------
//Function: set the date
//---------------------------------
void Watch_Set_Date(char item, char val)
{
	Watch_Display_Date(date);
	date = Watch_Adjust_Date(item, val);
}

//---------------------------------
//---------------------------------
void Watch_Save_Date(void)
{
	Writedaliy(date);
}


//---------------------------------
//---------------------------------
void Watch_Flash_SetItem(void)
{
	uCHAR i, item;
 	static char scrow = TRUE;

	if(WatchSet.in.item.adj) { 
		switch(WatchSet.sub) { 
		case 0: 
			item = LEDITEM_MAIN_1; 
			break; 
		case 1: 
			item = LEDITEM_MAIN_2; 
			break; 
		case 2: 
			item = LEDITEM_MAIN_4; 
			break; 
		case 3: 
			item = LEDITEM_MAIN_5; 
			break; 
		case 4: 
			item = LEDITEM_MAIN_7; 
			break; 
		case 5: 
			item = LEDITEM_MAIN_8; 
			break; 
		default: 
			item = LEDITEM_WEEK; 
			break; 
		} 
		
		if(scrow) { 
			WatchSet.temp = *(dis_buffer+item); 
			*(dis_buffer+item) = LEDWORD_BLANK;
		} else { 
			*(dis_buffer+item) = WatchSet.temp;
		} 
	} 
	scrow = !scrow;
	Watch_Update_Display(); 
}


//---------------------------------
//---------------------------------

void Watch_Init(void) 
{ 
	uCHAR i; 
	
	MC74HC595_Init(); 
	for(i=0; i<11; i++) { 
		dis_buffer[i] = LEDWORD_LINE; 
	} 
	
	Watch_Update_Display(); 
	Ds1302_Init();
} 

5.5 电子表核心数据结构

typedef struct {
	uCHAR hour;
	uCHAR min;
	uCHAR sec;
}TIME;

typedef struct {
	uCHAR year;
	uCHAR month;
	uCHAR day;
	uCHAR week;
}DATE;

typedef struct { 
	u8 on:1;    //响闹开关 
	u8 begin:6; //响闹周期开始
	u8 end;     //响闹周期结束
	u16 time;   //响闹时间
}Alert_t;  

typedef struct { 
	u8 dirty; 
	u8 leddute; 
	u16 rfaddr; 
	//====================
	//Alert Set
	//====================
	Alert_t alart[10]; 
}WatchCfg_t; 

typedef struct { 
	u8 enb:1; //闹钟已经打开 
	u8 inw:1; //闹钟正在运行
	u8 id:6;  //闹钟编号 
	u8 cnt;   //重复提醒次数
	u16 time; //最后一次响闹时间
}Alam_t; 

#if OPT_COUNTER
typedef struct { 
	u8 use:1; 
	u8 full:1; 
	u8 pause:1; 
	u8 sCount:5; 
	u8 segLeds; 
	TIME run; 
	TIME set; 
	TIME base; 
}Counter_t;  
#endif 

typedef struct { 
	union { 
		struct { 
			u8 set:1;    //in set statu 
			u8 adj:1;    //in adjust statu 
			u8 show:1;   //in show alam item or date 
			u8 modify:1; //item is modify 
		}item; 
		u8 items; 
	}in; 
	u8 item; //main set item 
	u8 sub;  //sub set item 
	u8 temp; //backup digtal value 
}WatchSet_t; 

5.6  主任务程序

Main.c

/* MAIN.C file
 * 
 * Copyright (c) 2002-2005 STMicroelectronics
 */

#include "Config.h"

DATE date;
TIME time;
extern volatile _Bool Synch; 
extern volatile Alam_t on_Alam; 
#if OPT_COUNTER
extern volatile Counter_t on_Ct; 
#endif 
extern volatile WatchSet_t WatchSet; 
extern volatile WatchCfg_t WatchCofing; 
extern volatile XTIMER Timer[e_Timer_Max];


void memclr(void* src, u8 len)
{
	while(len--){ *((u8*)src+len) = 0x00; }
}

void RESTART(void) 
{ 
	WWDG_CR |= BIT(7); 
	WWDG_CR &= ~BIT(6); 
}

#if OPT_WATCHDOGDEMON 
void Watchdog_Init(void)
{ 
	WWDG_CR &= ~BIT(7); //Stop Window watchdog 
	WWDG_CR = 0x7F; 
	
	IWDG_KR = 0xCC; //启动IWDG
	IWDG_KR = 0x55; //解除 PR 及 RLR 的写保护
	IWDG_RLR = 0xff; //看门狗计数器重装载数值 	  
	IWDG_PR = 0x06; //分频系数为256，最长超时时间为：1.02S
	IWDG_KR = 0xAA; //刷新IDDG，避免产生看门狗复位，同时恢复 PR 及 RLR 的写保护状态
}
#else 
void Watchdog_Init(void) {_asm("nop"); }
#endif 

/*********************************************
函数功能：系统内部时钟配置
*********************************************/
void Init_SystemClock(void)
{
	//时钟配置为内部RC，16M
	CLK_CKDIVR &= ~(BIT(4)|BIT(3));
}

void Ready(void) 
{
	START_TIMER(e_Timer_RunTick, 500);  //in 800mS
}

//_Bool on = FALSE;
void doTaskScheduler(void) 
{ 
	static s8 taskID = -1, c=0;  
	
	Decode_Task(); 
	switch(taskID) { 
	case 0: 
		Beeper_Task(); 
		break; 
	case 1: 
		KeyProcess();//Countflag 
		break; 
	case 2: 
		if(c)Watch_Start_Alam();
		break; 
	case 3: 
		Temperature_Task();  
		break; 
	case 4: 
		ExitMenu(FALSE); 
		break; 
	case 5: 
#if OPT_COUNTER
		if(!WatchSet.in.items && on_Ct.use) { 
			Watch_Start_Count();  
		}
		break; 
#endif 
	default: 
		taskID = -1; 
		if(!IS_TIMEROVER(e_Timer_RunTick)) break; 
		RESET_TIMER(e_Timer_RunTick); 
		if(WatchSet.in.items) { 
			if(WatchSet.in.item.adj) { 
				Watch_Flash_SetItem(); 
			} 
		} else { 
			c = 1; 
			date = Readdaliy();
			time = Readtime();
#if OPT_COUNTER
			if(!on_Ct.use) 
#endif 
			{ 
				Watch_Display_Time(time); 
			} 
		} 
		break; 
	} 
	++taskID; 
}

void InitDeviceConfig(void) 
{
	memclr((void*)0, 1024); 
	Load_WatchCofing(); 
	Watch_Init(); 
	//TimerInit();
	Key_Init(); 
	Beeper_Init(); 
	Decode_Init(); 
	Temperature_Init(); 

	SystemTimer_Init();  //初始化系统定时器，软定时器时钟源
	Watchdog_Init();
	_asm("rim");    //开总中断
}

int main(void)
{ 	
	Init_SystemClock();
	//Init Device Hardware 
	InitDeviceConfig();
	
	Ready();
	for(;;) {
		RESETWDT();
		doTaskScheduler(); 
	}
}

单帖长度限制，部份代码，后面跟贴附上