#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include "Nano100Series.h"
#include "adc.h"
#include "gpio.h"
#include "pwm.h"
#include "timer.h"
#include "uart.h"
#include "sys.h"
#include "clk.h"
#include "EEPROM_Emulate.h"


#include "My_define.h"



extern uint8_t Melody_Mode;

extern volatile uint8_t Power_On;
extern volatile uint8_t Tx_Run_Mode;
extern volatile uint8_t Tx_Fan_Speed;
extern volatile uint8_t Tx_Reservation_Hour;


extern uint16_t Main_Err_Code; 
extern uint8_t Vsp_Mode; 


void delay_us(uint32_t us)
{
	CLK_SysTickDelay(us);
}


void delay_ms(uint32_t ms)
{
	while(ms--)
	{
		delay_us(1000);
	}
}


void UART0_Init()//co2
{
    /*---------------------------------------------------------------------------------------------------------*/
    /* Init UART                                                                                               */
    /*---------------------------------------------------------------------------------------------------------*/
	SYS_ResetModule(UART0_RST);
    UART_Open(UART0, 115200);

	
    UART_EnableInt(UART0, UART_IER_RDA_IE_Msk);
    NVIC_EnableIRQ(UART0_IRQn);
}


void UART1_Init()
{
    /*---------------------------------------------------------------------------------------------------------*/
    /* Init UART                                                                                               */
    /*---------------------------------------------------------------------------------------------------------*/
	SYS_ResetModule(UART1_RST);
    UART_Open(UART1, 115200);
	
    UART_EnableInt(UART1, UART_IER_RDA_IE_Msk);
    NVIC_EnableIRQ(UART1_IRQn);
}

void SC0_Init() // to main
{
	SCUART_Open(SC0, 1200);
	// Enable smartcard receive interrupt
	SCUART_ENABLE_INT(SC0, SC_IER_RDA_IE_Msk);
	NVIC_EnableIRQ(SC0_IRQn);
}


void SC1_Init() // to dust
{
	SCUART_Open(SC1, 9600);
	// Enable smartcard receive interrupt
	SCUART_ENABLE_INT(SC1, SC_IER_RDA_IE_Msk);
	NVIC_EnableIRQ(SC1_IRQn);
}




void PowerDownFunction(void)
{
;
}



#define IR_EVENT_POWER	0x01
#define IR_EVENT_MODE	0x02
#define IR_EVENT_WIND_UP	0x04
#define IR_EVENT_WIND_DN	0x05
#define IR_EVENT_TIME_1	0x06
#define IR_EVENT_TIME_2	0x07
#define IR_EVENT_TIME_3	0x08
#define IR_EVENT_FILTER_RESET	0x09

#define IR_START        13500
#define IR_HIGH         2260
#define IR_LOW          1180
#define IR_STOP         600
#define IR_REPEAT       11200

uint16_t long_timer1 = 0;
uint16_t remocon_buff[4];
uint8_t remocon_pos = 0;
uint8_t remocon_bit_count = 0;

uint8_t  IR_Event_Code = 0;
volatile uint8_t  IR_Event_Flag = 0;
void IR_Receive(void)
{
        uint16_t tmp = 0;
        
	long_timer1 = TIMER2->DR/12;
	TIMER2->CTL |= TIMER_CTL_SW_RST_Msk;
	TIMER_Start(TIMER2);
        
        if((long_timer1 > IR_START-300)&&(long_timer1 < IR_START+300))
        {
            remocon_buff[0] = 0;
            remocon_buff[1] = 0;
            remocon_bit_count = 0;
            remocon_pos = 0;
        }
        else if((long_timer1 > IR_REPEAT-300)&&(long_timer1 < IR_REPEAT+300))
        {
            remocon_buff[0] = 0;
            remocon_buff[1] = 0;
            remocon_bit_count = 0;
            remocon_pos = 0;
        }
        else if((long_timer1 > IR_HIGH-200)&&(long_timer1 < IR_HIGH+200))
        {
          remocon_buff[remocon_pos] |= 0x8000;
          if(remocon_bit_count++ >= 15){remocon_bit_count = 0;remocon_pos=1;}
          else {remocon_buff[remocon_pos] >>= 1;}
        }
        else if((long_timer1 > IR_LOW-200)&&(long_timer1 < IR_LOW+200))
        {
          remocon_buff[remocon_pos] &= ~0x8000;
          if(remocon_bit_count++ >= 15){remocon_bit_count = 0;remocon_pos=1;}
          else {remocon_buff[remocon_pos] >>= 1;}
        }
        
	if((remocon_pos == 1)&&(remocon_bit_count == 15))
	{
		if(remocon_buff[0] == 0xA55A)
		{
			tmp = remocon_buff[1];
/*			switch(tmp)
			{
				case 0x6E11: // Power
					IR_Event_Code = IR_EVENT_POWER;
					break;
				case 0x6D12: // mode
					IR_Event_Code = IR_EVENT_MODE;
					break;
				case 0x6C13: // up
					IR_Event_Code = IR_EVENT_WIND_UP;
					break;
				case 0x6817: // dn
					IR_Event_Code = IR_EVENT_WIND_DN;
					break;
				case 0x6718: // 1hour
					IR_Event_Code = IR_EVENT_TIME_1 ;
					break;
				case 0x6619: // 2hour
					IR_Event_Code = IR_EVENT_TIME_2 ;
					break;
				case 0x215E: // 3hour
					IR_Event_Code = IR_EVENT_TIME_3 ;
					break;
				case 0x354A: // filter reset
					IR_Event_Code = IR_EVENT_FILTER_RESET;
					break;
				default:
					IR_Event_Code = 0;
					break;
			}
			if(IR_Event_Code)
			{
				IR_Event_Flag = 1;
			}
			*/
		}
		remocon_buff[0] = 0;
		remocon_buff[1] = 0;
		remocon_bit_count = 0;
		remocon_pos = 0;
        }

}



volatile uint8_t Touch_Event = 0;

void GPABC_IRQHandler(void)
{
    uint32_t reg;

	if(GPIO_GET_INT_FLAG(PB, BIT12))
	{
		GPIO_CLR_INT_FLAG(PB, BIT12);
		CLK->WK_INTSTS = 1; /* clear interrupt status */
		if(PB12 == 0)Touch_Event = 1;
		else Touch_Event = 2;
	}    
	else if(GPIO_GET_INT_FLAG(PB, BIT14))
	{
		GPIO_CLR_INT_FLAG(PB, BIT14);
		CLK->WK_INTSTS = 1; /* clear interrupt status */
		IR_Receive();
	}
	else
	{
		reg = PA->ISRC; PA->ISRC = reg;
		reg = PB->ISRC; PB->ISRC = reg;
		reg = PC->ISRC; PC->ISRC = reg;
	}
}

volatile uint8_t Run_Timer = 0;
volatile uint16_t mSec_Timer = 0;
volatile uint16_t Touch_Event_Timer = 0;
volatile uint16_t Blink_Timer = 0;
volatile uint8_t Rx_rs485_TimeOut = 0;
volatile uint8_t Rx_modbus_TimeOut = 0;
volatile uint8_t Rx_wifi_TimeOut = 0;
volatile uint16_t FastBlink_Timer = 0;

void TMR0_IRQHandler(void)
{
	Touch_Event_Timer++;
	
	if(Run_Timer)Run_Timer--;
	if(mSec_Timer)mSec_Timer--;
	if(Blink_Timer)Blink_Timer--;
	if(FastBlink_Timer)FastBlink_Timer--;
	if(Rx_rs485_TimeOut)Rx_rs485_TimeOut--;
	if(Rx_modbus_TimeOut)Rx_modbus_TimeOut--;
	if(Rx_wifi_TimeOut)Rx_wifi_TimeOut--;
	
    // clear timer interrupt flag
    TIMER_ClearIntFlag(TIMER0);
}

// TIMER_ClearWakeupFlag(TIMER0);
void Timer0_Init(void)
{
    TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1000); // 1ms -> HZ

    // Enable timer interrupt
    TIMER_EnableInt(TIMER0);
    NVIC_EnableIRQ(TMR0_IRQn);

	
    // Start Timer 0
    TIMER_Start(TIMER0);
}


void TMR1_IRQHandler(void)
{
	Melody_process();


	// clear timer interrupt flag
	TIMER_ClearIntFlag(TIMER1);
}

void Timer1_Init(void)
{
    TIMER_Open(TIMER1, TIMER_PERIODIC_MODE, 100); // 10ms -> HZ

    // Enable timer interrupt
    TIMER_EnableInt(TIMER1);
    NVIC_EnableIRQ(TMR1_IRQn);

	
    // Start Timer 0
    TIMER_Start(TIMER1);
}
void Timer2_Init(void) ///////////////////////////////////////////////////////////////////
{
    TIMER_Open(TIMER2, TIMER_PERIODIC_MODE, 1); // 1000ms -> HZ

    // Enable timer interrupt
    TIMER_EnableInt(TIMER2);
//    NVIC_EnableIRQ(TMR2_IRQn);

	
    // Start Timer 0
    TIMER_Start(TIMER2);
}/////////////////////////////////////////////////////////////////////////////////////


void PWM_Init(void)
{
    // PWM0 frequency is 300Hz, duty 50% 
//    PWM_ConfigOutputChannel(PWM0, 3, 960, 50); // LCD Backlight
    PWM_ConfigOutputChannel(PWM1, 0, 100, 0); // buzzer

    // Enable output of all PWM channels 
//     PWM_EnableOutput(PWM0, 1<<3); // ch3
     PWM_EnableOutput(PWM1, 0x01);

    // Start
//    PWM_Start(PWM0, 1<<3); // pwm0_ch3
    PWM_Start(PWM1, 0x01);

}



volatile uint32_t ADC3_Value = 0;;
void ADC_IRQHandler(void)
{
    uint32_t u32Flag;

    // Get ADC conversion finish interrupt flag
    u32Flag = ADC_GET_INT_FLAG(ADC, ADC_ADF_INT);

    if(u32Flag & ADC_ADF_INT)
    {
        ADC3_Value = ADC_GET_CONVERSION_DATA(ADC, 3);
    }
    ADC_CLR_INT_FLAG(ADC, u32Flag);

}

void ADC_Init(void)
{

	// Enable channel 1
    ADC_Open(ADC, ADC_INPUT_MODE_SINGLE_END, ADC_OPERATION_MODE_SINGLE, ADC_CH_1_MASK);

    // Set reference voltage to AVDD
    ADC_SET_REF_VOLTAGE(ADC, ADC_REFSEL_POWER);


    // Power on ADC
    ADC_POWER_ON(ADC);

    // Enable ADC ADC_IF interrupt
    ADC_EnableInt(ADC, ADC_ADF_INT);
    NVIC_EnableIRQ(ADC_IRQn);

 
    ADC_START_CONV(ADC);

}


void GPIO_Init(void)
{

	GPIO_SetMode(PA, BIT2|BIT3|BIT4, GPIO_PMD_OUTPUT); // A_2002
	PA2 = 0;
	PA3 = 0;
	PA4 = 0;
	GPIO_SetMode(PA, BIT13|BIT14|BIT15, GPIO_PMD_OUTPUT); // B_2002
	PA13 = 0;
	PA14 = 0;
	PA15 = 0;
	GPIO_SetMode(PC, BIT9|BIT10|BIT11, GPIO_PMD_OUTPUT); // C_2002
	PC9 = 0;
	PC10 = 0;
	PC11 = 0;
	GPIO_SetMode(PD, BIT7|BIT14|BIT15, GPIO_PMD_OUTPUT); // D_2002
	PD7 = 0;
	PD14 = 0;
	PD15 = 0;


	GPIO_SetMode(PB, BIT6, GPIO_PMD_OUTPUT); // 485 DIR
	PB6 = 0;


	GPIO_SetMode(PA, BIT10, GPIO_PMD_OPEN_DRAIN); // touch
	GPIO_SetMode(PA, BIT11, GPIO_PMD_OPEN_DRAIN); 


	GPIO_SetMode(PB, BIT12, GPIO_PMD_INPUT); // touch int
	GPIO_ENABLE_PULL_UP(PB, BIT12);
	GPIO_EnableInt(PB, 12, GPIO_INT_BOTH_EDGE);


	GPIO_SetMode(PB, BIT14, GPIO_PMD_INPUT); // ir int
	GPIO_ENABLE_PULL_UP(PB, BIT14);
	GPIO_EnableInt(PB, 14, GPIO_INT_FALLING);

	NVIC_EnableIRQ(GPABC_IRQn);

	/* Enable interrupt de-bounce function and select de-bounce sampling cycle time */
	GPIO_SET_DEBOUNCE_TIME(GPIO_DBCLKSRC_HCLK, GPIO_DBCLKSEL_1);
	GPIO_ENABLE_DEBOUNCE(PB, BIT12|BIT14);

}

void SYS_Init(void)
{
  /* Unlock protected registers */
    SYS_UnlockReg();

    /* Enable clock source */
    CLK_EnableXtalRC(CLK_PWRCTL_LIRC_EN_Msk|CLK_PWRCTL_HIRC_EN_Msk);

    /* Waiting for clock source ready */
    CLK_WaitClockReady(CLK_CLKSTATUS_LIRC_STB_Msk|CLK_CLKSTATUS_HIRC_STB_Msk);

    /* If the defines do not exist in your project, please refer to the related clk.h in the Header folder appended to the tool package. */
    /* Set HCLK clock */
    CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_HIRC, CLK_HCLK_CLK_DIVIDER(1));

    /* Enable IP clock */
    CLK_EnableModuleClock(GPIO_MODULE);
    CLK_EnableModuleClock(WDT_MODULE);
//    CLK_EnableModuleClock(I2C0_MODULE);
//    CLK_EnableModuleClock(I2C1_MODULE);
//    CLK_EnableModuleClock(PWM0_CH23_MODULE);
    CLK_EnableModuleClock(PWM1_CH01_MODULE);
    CLK_EnableModuleClock(ISP_MODULE);
    CLK_EnableModuleClock(SC0_MODULE);
//    CLK_EnableModuleClock(SC1_MODULE);
    CLK_EnableModuleClock(SRAM_MODULE);
    CLK_EnableModuleClock(TICK_MODULE);
    CLK_EnableModuleClock(TMR0_MODULE);
    CLK_EnableModuleClock(TMR1_MODULE);
    CLK_EnableModuleClock(TMR2_MODULE);
//    CLK_EnableModuleClock(UART0_MODULE);
    CLK_EnableModuleClock(UART1_MODULE);
    CLK_EnableModuleClock(WDT_MODULE);

    /* Set IP clock */

//    CLK_SetModuleClock(PWM0_CH23_MODULE, CLK_CLKSEL1_PWM0_CH23_S_HIRC, MODULE_NoMsk);
    CLK_SetModuleClock(PWM1_CH01_MODULE, CLK_CLKSEL2_PWM1_CH01_S_HIRC, MODULE_NoMsk);
    CLK_SetModuleClock(SC0_MODULE, CLK_CLKSEL2_SC_S_HIRC, CLK_SC0_CLK_DIVIDER(6));
//    CLK_SetModuleClock(SC1_MODULE, CLK_CLKSEL2_SC_S_HIRC, CLK_SC1_CLK_DIVIDER(1));
    CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0_S_HIRC, MODULE_NoMsk);
    CLK_SetModuleClock(TMR1_MODULE, CLK_CLKSEL1_TMR1_S_HIRC, MODULE_NoMsk);
    CLK_SetModuleClock(TMR2_MODULE, CLK_CLKSEL2_TMR2_S_HIRC, MODULE_NoMsk);
 //   CLK_SetModuleClock(UART0_MODULE, CLK_CLKSEL1_UART_S_HIRC, CLK_UART_CLK_DIVIDER(1));
    CLK_SetModuleClock(UART1_MODULE, CLK_CLKSEL1_UART_S_HIRC, CLK_UART_CLK_DIVIDER(1));
    CLK_SetModuleClock(WDT_MODULE, 0, 0);

    /* Update System Core Clock */
    /* User can use SystemCoreClockUpdate() to calculate SystemCoreClock. */
    SystemCoreClockUpdate();



    //If the defines do not exist in your project, please refer to the corresponding sys.h in the Header folder appended to the tool package.
    SYS->PA_H_MFP =  SYS_PA_H_MFP_PA9_MFP_SC0_DAT | SYS_PA_H_MFP_PA8_MFP_SC0_CLK;
    SYS->PB_H_MFP = SYS_PB_H_MFP_PB11_MFP_PWM1_CH0;
    SYS->PB_L_MFP = SYS_PB_L_MFP_PB5_MFP_UART1_TX | SYS_PB_L_MFP_PB4_MFP_UART1_RX ;
    SYS->PC_H_MFP = 0x00000000;
    SYS->PC_L_MFP =  0x00000000;
    SYS->PD_H_MFP = 0x00000000;
    SYS->PD_L_MFP = 0x00000000;
    SYS->PE_L_MFP = 0x00000000;
    SYS->PF_L_MFP = SYS_PF_L_MFP_PF1_MFP_ICE_CLK | SYS_PF_L_MFP_PF0_MFP_ICE_DAT;


  
    /* Lock protected registers */
    SYS_LockReg();

    return;

}


extern uint8_t Main_Modbus_ID;

void Processor_Init(void)
{
								  // 0        1		2		3		4	5		6		7	8		9 , ' ' ,   E   ,  A

	uint8_t eep_check[20];
	uint8_t i;

	Power_On = 0;
	Tx_Run_Mode = 0;
	Tx_Fan_Speed = 0;
	Tx_Reservation_Hour = 0;


	Led_OnOff(100,1);//all on
	Disp_Segdata(0, 8, 8, 8, 8);
	Disp_Segdata(1, 8, 8, 8, 8);
	Disp_Segdata(2, 8, 8, 8, 8);
	for(i=0; i<10; i++)Display_process();

	touch_i2c_init() ;


	Melody_Mode = MELODY_TOUCH;
	delay_ms(2000);


	Led_OnOff(100, 0); // all off
	Disp_Segdata(0, 14, 14, 5, 2); // s2
	Disp_Segdata(1, 1, 0, 0, 0); // 1000
	Disp_Segdata(2, 16, 13, ROOMCON_VERSION>>4, ROOMCON_VERSION&0x0F); // R-01
	for(i=0; i<10; i++)Display_process();

	delay_ms(2000);

	power_off_process();

////////////////////////////////////////////////////////////

	for(i=0; i<10; i++)
	{
		Read_Data(i, &eep_check[i]);
	}

	if((eep_check[EEP_ADDR_START] == 0x55)&&(eep_check[EEP_ADDR_START+1] == 0xAA))
	{
	//	Main_Modbus_ID = eep_check[EEP_ADDR_MODBUS_ID];
	}
	else
	{
		Main_Modbus_ID = 1;
		
		Write_Data(EEP_ADDR_START, 0x55);
		Write_Data(EEP_ADDR_START+1, 0xAA);
		
	//	Write_Data(EEP_ADDR_MODBUS_ID, Main_Modbus_ID);

	}

}



extern uint16_t Pm_1_0_value, Pm_2_5_value, Pm_10_value;
extern uint16_t CO2_Value;
uint8_t CO2_quality = 0;
uint8_t PM2_5_quality = 0;
uint8_t PM10_quality = 0;
uint8_t temp_fan_speed = 0;
uint8_t temp_pm_quality = 0;

#define CO2_HISTERISE	0 
#define DUST_HISTERISE	0 

void Air_Quality_process(void)
{

	if(Power_On == 1)
	{
		if(CO2_Value <= 500-CO2_HISTERISE) CO2_quality = 0;
		else if((CO2_Value > 500+CO2_HISTERISE)&&(CO2_Value <= 1000-CO2_HISTERISE)) CO2_quality = 0x01;
		else if((CO2_Value > 1000+CO2_HISTERISE)&&(CO2_Value <= 1500-CO2_HISTERISE)) CO2_quality = 0x02;
		else if(CO2_Value > 1500+CO2_HISTERISE)CO2_quality = 0x04;

	//2020.5.26 PM2.5 기준변경
		if(Pm_2_5_value <= 15-DUST_HISTERISE) PM2_5_quality = 0;
		else if((Pm_2_5_value > 15+DUST_HISTERISE)&&(Pm_2_5_value <= 35-DUST_HISTERISE)) PM2_5_quality = 0x01;
		else if((Pm_2_5_value > 35+DUST_HISTERISE)&&(Pm_2_5_value <= 75-DUST_HISTERISE)) PM2_5_quality = 0x02;
		else if(Pm_2_5_value > 75+DUST_HISTERISE)PM2_5_quality = 0x04;

		if(Pm_10_value <= 30-DUST_HISTERISE) PM10_quality = 0;
		else if((Pm_10_value > 30+DUST_HISTERISE)&&(Pm_10_value <= 80-DUST_HISTERISE)) PM10_quality = 0x01;
		else if((Pm_10_value > 80+DUST_HISTERISE)&&(Pm_10_value <= 150-DUST_HISTERISE)) PM10_quality = 0x02;
		else if(Pm_10_value > 150+DUST_HISTERISE)PM10_quality = 0x04;


		temp_pm_quality =  PM2_5_quality | PM10_quality;

		
		if(Tx_Run_Mode == MODE_AUTO)
		{
			if(CO2_quality == 0)
			{
				if(temp_pm_quality < 1)temp_fan_speed = 0;
				else if(temp_pm_quality < 2)temp_fan_speed = 2;
				else if(temp_pm_quality < 4)temp_fan_speed = 3;
				else temp_fan_speed = 4;
			}
			else
			{
				if(CO2_quality == 0x01)
				{
					if(temp_pm_quality < 2)temp_fan_speed = 2;
					else if(temp_pm_quality < 4)temp_fan_speed = 3;
					else temp_fan_speed = 4;
				}
				else if(CO2_quality == 0x02)
				{
					if(temp_pm_quality < 4)temp_fan_speed = 3;
					else temp_fan_speed = 4;
				}				
				else if(CO2_quality == 0x04)
				{
					 temp_fan_speed = 4;
				}	
			}

			Tx_Fan_Speed = temp_fan_speed;

		}

	}
}

extern uint8_t Blinking_Count, Blink_Toggle;

extern volatile uint8_t Filter_Reset_Flag;
extern volatile uint8_t Tx_Mode_Event , Tx_Fan_Event , Tx_Reserve_Event ;
volatile uint16_t Fan_Setting_Timer = 0;

void IR_Remocon_process(void)
{
	switch(IR_Event_Code)
	{
		case IR_EVENT_POWER:
			if(Power_On == 0)power_on_process();
			else power_off_process();
			break;
		case IR_EVENT_WIND_UP:
			if(Power_On == 1)
			{
				if((Tx_Run_Mode == MODE_AUTO)||(Tx_Run_Mode == MODE_BYPASS))
				{
					Melody_Mode = MELODY_NG;
				}
				else
				{
					if(Tx_Fan_Speed<5)Tx_Fan_Speed++;
				
					Tx_Fan_Event = TX_EVENT;
				
					Melody_Mode = MELODY_TOUCH;
				}
			}
			break;
		case IR_EVENT_WIND_DN:
			if(Power_On == 1)
			{
				if((Tx_Run_Mode == MODE_AUTO)||(Tx_Run_Mode == MODE_BYPASS))
				{
					Melody_Mode = MELODY_NG;
				}
				else
				{
					if(Tx_Fan_Speed > 1)Tx_Fan_Speed--;
				
					Tx_Fan_Event = TX_EVENT;
				
					Melody_Mode = MELODY_TOUCH;
				}
			}
			break;
		case IR_EVENT_TIME_1:
			if(Power_On == 1)
			{
				if(Tx_Reservation_Hour == 1)Tx_Reservation_Hour = 0;
				else Tx_Reservation_Hour = 1;
				
				if(Blinking_Count == 0)
				{
					Blink_Timer = 0;
					Blink_Toggle = 0;
				}
				Blinking_Count = 3;
				Melody_Mode = MELODY_TOUCH;
			
				Tx_Reserve_Event = TX_EVENT;
			}
			break;
		case IR_EVENT_TIME_2:
			if(Power_On == 1)
			{
				if(Tx_Reservation_Hour == 4)Tx_Reservation_Hour = 0;
				else Tx_Reservation_Hour = 4;
				
				if(Blinking_Count == 0)
				{
					Blink_Timer = 0;
					Blink_Toggle = 0;
				}
				Blinking_Count = 3;
				Melody_Mode = MELODY_TOUCH;
			
				Tx_Reserve_Event = TX_EVENT;
			}

			break;
		case IR_EVENT_TIME_3:
			if(Power_On == 1)
			{
				if(Tx_Reservation_Hour == 8)Tx_Reservation_Hour = 0;
				else Tx_Reservation_Hour = 8;
				
				if(Blinking_Count == 0)
				{
					Blink_Timer = 0;
					Blink_Toggle = 0;
				}
				Blinking_Count = 3;
				Melody_Mode = MELODY_TOUCH;
			
				Tx_Reserve_Event = TX_EVENT;
			}

			break;
		case IR_EVENT_MODE:
			if(Power_On == 1)
			{
				if(Tx_Run_Mode == MODE_VENT)Tx_Run_Mode = MODE_AUTO;
				else if(Tx_Run_Mode == MODE_AUTO)Tx_Run_Mode = MODE_VENT;

				
				Tx_Reservation_Hour = 0;
				Tx_Fan_Speed = 3;
				
				Tx_Mode_Event = TX_EVENT;
				Tx_Fan_Event = TX_EVENT;
				Tx_Reserve_Event = TX_EVENT;
				
				Melody_Mode = MELODY_TOUCH;
			}
			break;
		case IR_EVENT_FILTER_RESET:
			Filter_Reset_Flag = 1;
			Melody_Mode = MELODY_TOUCH;
			break;
		default:
			break;
	}
	if(IR_Event_Code)IR_Event_Code = 0;
}