jeon/HECO2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6934f09b2a2928de960b2ceaf5d9d604bead09b2
HECO2/Source/FND_display/edit.si4project/Backup/My_system(4443).c
T
jeon 096111e983 feat: 06-17 신규 작업본 반영 (개발사양서/기능검토/승인원/Source 등 추가) 
.claude/ 제외(.gitignore 추가). 기존 초기커밋(5a96a69) 위에 신규·수정·이동분 커밋.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-18 07:54:58 +09:00

750 lines
17 KiB
C
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink