M28/APP/user/appTask.c

#include "appTask.h"
#include "iodefine.h"
#include "r_cg_adc.h"
#include "PINdef.h"
#include "hwCtrl.h"
#include "MotorCtrl.h"
#include "r_cg_serial.h"
#include "r_cg_timer.h"



unsigned char Timer_1ms_flag;
unsigned char Timer_5ms_flag;
unsigned char Timer_10ms_flag;
unsigned char Timer_20ms_flag;
unsigned char Timer_50ms_flag;
unsigned char Timer_1000ms_flag;

uint32_t gIGNVoltage,gBattVoltage;

uint8_t g_rx_buf[3];
uint8_t g_tx_buf[8];

uint8_t datacount=0;
uint8_t RxTimeoutCount=0;
static uint8_t Rxdata[10];
uint8_t RxFlag=0;

const uint8_t fan_duty_arr[4] = {0,100,80,70};
const uint8_t heat_duty_arr[4] = {0,80,65,50};
static uint8_t heat_state=0,fan_state=0,am_state=0;
static uint8_t key_js_press_flag;
static uint16_t TimeOutCounter[3] = {0};

void Batt_State_Ctrl(void);
void PowerDetect(void);
void IGN_State_Ctrl(void);
void MsgPro(uint8_t len);
void UnlockMotorCtrl(void);
void TimeOutCtrl(void);
void IGN_Detect(void);//10ms
void Apply_task(void)
{
    static uint8_t temp;
    if (Timer_1ms_flag == 1)
    {
        Timer_1ms_flag = 0;
        KeyScan();
    }
    if (Timer_5ms_flag == 1)
    {
        Timer_5ms_flag = 0;
        KeyPro();
        amCtrl_Task();
    }

    if (Timer_10ms_flag == 1)
    {
        Timer_10ms_flag = 0;
        UnlockMotorCtrl();
        IGN_Detect();

    }
    if (Timer_20ms_flag == 1)
    {
        Timer_20ms_flag = 0;


    }
    if (Timer_50ms_flag == 1)
    {
        Timer_50ms_flag = 0;
        PowerDetect();
        
    }
    if (Timer_1000ms_flag == 1)
    {
        Timer_1000ms_flag = 0;
        //R_UART0_Send(g_tx_buf,1);
        //TimeOutCtrl();//20240721:取消模块定时，改为面板定时
    }
    
}

#define IGN_OFF 1
#define IGN_ON 0
void IGN_Detect(void)//10ms
{
    static uint8_t IGN_STATE = 0;
    static uint8_t IGN_ON_Counter = 0, IGN_OFF_Counter = 0;
    switch (IGN_STATE)
    {
    case 0:
        if (I_IGN == IGN_OFF)
        {
            IGN_OFF_Counter++;
            IGN_ON_Counter = 0;
            if (IGN_OFF_Counter > 10)
            {
                IGN_STATE = 1;
                IGN_OFF_Counter = 0;
            }
        }
        else
        {
            IGN_ON_Counter++;
            IGN_OFF_Counter = 0;
            if (IGN_ON_Counter > 10)
            {
                IGN_STATE = 2;
                IGN_ON_Counter = 0;
            }
        }
        break;
    case 1:
        if (I_IGN == IGN_ON)
        {
            IGN_ON_Counter++;
            IGN_OFF_Counter = 0;
            if (IGN_ON_Counter > 30)
            {
                IGN_STATE = 2;
                IGN_ON_Counter = 0;
            }
        }
        else
        {
            IGN_ON_Counter = 0;
        }
        break;
    case 2:
        if (I_IGN == IGN_OFF)
        {
            IGN_OFF_Counter++;
            IGN_ON_Counter = 0;
            if (IGN_OFF_Counter > 30)
            {
                IGN_STATE = 1;
                IGN_OFF_Counter = 0;
                amCtrl_SetState(0);
                am_state = 0;
                fan_state = 0;
                heat_state = 0;
                setFanDuty(fan_duty_arr[0]);
                setHeatDuty(heat_duty_arr[0]);
            }
        }
        else
        {
            IGN_OFF_Counter = 0;
        }
        break;
    default:
        break;
    }
    
}

void TimeOutCtrl(void)//1s
{
    if (fan_state != 0)
    {
        TimeOutCounter[0]++;
        if (TimeOutCounter[0] > 1500)//25min
        {
            fan_state = 0;
            setFanDuty(fan_duty_arr[fan_state]);
        }
    }
    else
    {
        TimeOutCounter[0] = 0;
    }

    if (heat_state != 0)
    {
        TimeOutCounter[1]++;
        if (TimeOutCounter[1] > 1500)//25min
        {
            heat_state = 0;
            setHeatDuty(heat_duty_arr[heat_state]);
        }
        
    }
    else
    {
        TimeOutCounter[1] = 0;
    }


}

void UnlockMotorCtrl(void)//10ms
{
    static uint16_t unlockPressCounter = 0,unlockMotorActCounter = 0;
    static uint8_t unlockMotorState = 0;
    //按键处理
    if (getKeyPressFlag(KEYID_JS) == 1)
    {
        if (unlockMotorState == 0)key_js_press_flag = 1;
    }
    if (getKeyReleaseFlag(KEYID_JS) == 1)
    {
        if (unlockMotorState == 3)
        {
            unlockMotorActCounter = 0;
            unlockMotorState = 4;
            setUnlockMotor(MOTOR_XH);
        }
        
        key_js_press_flag = 0;
    }
    
    
    if (key_js_press_flag == 1)
    {
        if (unlockPressCounter < 800)//8s
        {
            unlockPressCounter++;
            if (unlockPressCounter >= 300)
            {
                //setUnlockMotor(MOTOR_XH);
                unlockMotorState = 5;
                key_js_press_flag = 0;
                setUnlockMotor(MOTOR_XH);
                unlockMotorActCounter = 0;
            }
            
        }
        else
        {
            //unlockPressCounter = 0;
        }
    }
    else
    {
        if (unlockPressCounter > 3 && unlockPressCounter < 100)//30-1000ms
        {
            unlockMotorState = 1;
        }
        unlockPressCounter = 0;
    }
    
    switch (unlockMotorState)
    {
    case 0:
        //no act
        setUnlockMotor(MOTOR_NOACT);
        break;
    case 1:
        unlockMotorActCounter = 0;
        unlockMotorState = 2;
        setUnlockMotor(MOTOR_XQ);
        break;
    case 2:
        unlockMotorActCounter++;
        if (unlockMotorActCounter > 200)//3S -> 2S
        {
            unlockMotorActCounter = 0;
            unlockMotorState = 3;
            setUnlockMotor(MOTOR_NOACT);
        }
        break;
    case 3:
        unlockMotorActCounter++;
        if (unlockMotorActCounter > 800)
        {
            unlockMotorActCounter = 0;
            unlockMotorState = 4;
            setUnlockMotor(MOTOR_XH);
        }
        break;
    case 4:
        unlockMotorActCounter++;
        if (unlockMotorActCounter > 200)//3S -> 2S
        {
            unlockMotorActCounter = 0;
            unlockMotorState = 0;
            setUnlockMotor(MOTOR_NOACT);
        }
        break;
    case 5:
        unlockMotorActCounter++;
        if (unlockMotorActCounter > 300)//3S -> 2S
        {
            unlockMotorActCounter = 0;
            unlockMotorState = 0;
            setUnlockMotor(MOTOR_NOACT);
        }
        break;
    default:
        unlockMotorState = 0;
        break;
    }
}




void PowerDetect(void)//50ms
{
    uint16_t adval;
    adval = getAdval(AD_ST1_IGN);
    gIGNVoltage = adval;
    gIGNVoltage = gIGNVoltage*5*61*1000/(1024*11) + 700;
    
    adval = getAdval(AD_ST2_BAT);
    gBattVoltage = adval;
    gBattVoltage = gBattVoltage*5*61*1000/(1024*11) + 700;

    Batt_State_Ctrl();
    IGN_State_Ctrl();
}
BATT_STATUS_Type battState = BattStatus_Init;
uint16_t battCtrlCounter[3] = {0,0,0};
void Batt_State_Ctrl(void)//50ms
{
    switch (battState)
    {
    case BattStatus_Init:
        if (gBattVoltage >= 8500 && gBattVoltage <= 16500)
        {
            battCtrlCounter[0]++;
            battCtrlCounter[1] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[0] > 3)
            {
                battCtrlCounter[0] = 0;
                battState = BattStatus_Normal;
            }
        }
        else if (gBattVoltage > 16500)
        {
            battCtrlCounter[1]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[1] > 3)
            {
                battCtrlCounter[1] = 0;
                battState = BattStatus_OV;
            }
        }
        else if (gBattVoltage < 8500)
        {
            battCtrlCounter[2]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[1] = 0;
            if (battCtrlCounter[2] > 3)
            {
                battCtrlCounter[2] = 0;
                battState = BattStatus_UV;
            }
        }
        break;
    case BattStatus_Normal:
        if (gBattVoltage < 8500)
        {
            battCtrlCounter[2]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[1] = 0;
            if (battCtrlCounter[2] > 30)
            {
                battCtrlCounter[2] = 0;
                battState = BattStatus_UV;
            }
        }
        else if (gBattVoltage > 16500)
        {
            battCtrlCounter[1]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[1] > 30)
            {
                battCtrlCounter[1] = 0;
                battState = BattStatus_OV;
            }
        }
        break;

    case BattStatus_OV:
        if (gBattVoltage <= 16500 && gBattVoltage >= 8500)
        {
            battCtrlCounter[1]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[1] > 30)
            {
                battCtrlCounter[1] = 0;
                battState = BattStatus_Normal;
            }
        }
        else if (gBattVoltage < 8500)
        {
            battCtrlCounter[2]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[1] = 0;
            if (battCtrlCounter[2] > 30)
            {
                battCtrlCounter[2] = 0;
                battState = BattStatus_UV;
            }
        }
        break;
        
    case BattStatus_UV:
        if (gBattVoltage >= 8500 && gBattVoltage <= 16500)
        {
            battCtrlCounter[1]++;
            battCtrlCounter[0] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[1] > 30)
            {
                battCtrlCounter[1] = 0;
                battState = BattStatus_Normal;
            }
        }
        else if (gBattVoltage > 16500)
        {
            battCtrlCounter[0]++;
            battCtrlCounter[1] = 0;
            battCtrlCounter[2] = 0;
            if (battCtrlCounter[0] > 30)
            {
                battCtrlCounter[0] = 0;
                battState = BattStatus_OV;
            }
        }
        
    default:
        battState = BattStatus_Init;
        battCtrlCounter[0] = 0;
        battCtrlCounter[1] = 0;
        battCtrlCounter[2] = 0;
        break;
    }
}
uint16_t ignCtrlCounter;
uint8_t gIGN_State=0;
void IGN_State_Ctrl(void)//50ms
{
    if (gIGN_State == 0)
    {
        if (gIGNVoltage > 8500)
        {
            ignCtrlCounter++;
            if (ignCtrlCounter > 10)
            {
                gIGN_State = 1;
                ignCtrlCounter = 0;
            }
        }
        else
        {
            ignCtrlCounter = 0;
        }
    }
    else if (gIGN_State == 1)
    {
        if (gIGNVoltage < 8000)
        {
            ignCtrlCounter++;
            if (ignCtrlCounter > 10)
            {
                gIGN_State = 0;
                ignCtrlCounter = 0;
            }
        }
        else
        {
            ignCtrlCounter = 0;
        }
    }
}

void HardWare_Init(void)
{
    //时基初始化
    R_TAU0_Channel0_Start();

    //AD 初始化
    R_ADC_Start();
    R_ADC_Set_OperationOn();
    R_TAU0_Channel1_Start();

    //UART初始化
    R_UART0_Start();
    R_UART0_Receive(g_rx_buf,1);

    setFanDuty(0);
    setHeatDuty(0);

    //通风加热
    R_TAU0_Channel4_Start();
    R_TAU0_Channel6_Start();

}

void value_init(void)
{
    key_js_press_flag = 0;
    amCtrl_Init();
    //MotorValueInit();
}

void KeyPro(void)
{
    if (getKeyPressFlag(KEYID_AM) == KEY_PRESSED)
    {
        am_state = !am_state;
        amCtrl_SetState(am_state);
    }


}



void Timer_Pro(void)
{
	static unsigned int Timer_1ms_tick_count; 
	Timer_1ms_tick_count++;
    Timer_1ms_flag=1;
	if(Timer_1ms_tick_count%5==0)
	{
		Timer_5ms_flag=1;
	}
	if(Timer_1ms_tick_count%10==0)
	{
		Timer_10ms_flag=1;
	}
	if(Timer_1ms_tick_count%20==0)
	{
		Timer_20ms_flag=1;
	}
    if(Timer_1ms_tick_count%50==0)
	{
		Timer_50ms_flag=1;
	}
	if(Timer_1ms_tick_count%1000==0)
	{
		Timer_1000ms_flag = 1;
	}
	if(Timer_1ms_tick_count>=5000)
	{
		Timer_1ms_tick_count=0;
	}
}



void UART_Rx_Pro(uint8_t data)
{
    static uint8_t last_data=0,datalen=0;
    if (last_data == 0x5A && data == 0xA5)
    {
        RxFlag = 1;
        datacount = 0;
        datalen=0;
        //g_tx_buf[0] = 1;
        //R_UART0_Send(g_tx_buf,1);
    }
    else
    {
        if (RxFlag == 1)
        {
            datalen = data;
            RxFlag = 2;
            g_tx_buf[0] = 2;
            //R_UART0_Send(g_tx_buf,1);
        }
        else if (RxFlag == 2)
        {
            Rxdata[datacount++] = data;
            if (datacount >= datalen)
            {
                MsgPro(datalen);
            }
            
        }    
    }
    last_data = data;
    RxTimeoutCount = 0;
    
}



void SendTFJRmsg(uint8_t tf,uint8_t jr)
{
    uint8_t i,txbuf[7] = {0x5a,0xa5,0x04,0x01,0x00,0x00,0x01};
    if (tf != 0)
    {
        switch (tf)
        {
        case 1:
            txbuf[3] = txbuf[6] = 0x08;
            break;
        case 2:
            txbuf[3] = txbuf[6] = 0x07;
            break;
        case 3:
            txbuf[3] = txbuf[6] = 0x02;
            break;
        default:
            break;
        }
    }
    else if (jr != 0)
    {
        switch (jr)
        {
        case 1:
            txbuf[3] = txbuf[6] = 0x80;
            break;
        case 2:
            txbuf[3] = txbuf[6] = 0x70;
            break;
        case 3:
            txbuf[3] = txbuf[6] = 0x20;
            break;
        default:
            break;
        }
    }
    else
    {
        txbuf[3] = txbuf[6] = 0x11;
    }
    for (i = 0; i < 7; i++)
    {
        g_tx_buf[i] = txbuf[i];
    }
    R_UART0_Send(g_tx_buf,7);
}

void MsgPro(uint8_t len)
{
    uint8_t i;
    //不用大屏协议
    uint8_t crc,crcRx;
    if (len <= 3)
    {
        return;
    }
    //R_UART0_Send(Rxdata,4);
    //ClearSleepCounter();
    crc = 0;
    for(i=0;i<3;i++)
    {
        crc += Rxdata[i];
    }
    crcRx = Rxdata[3];
    
    if (crc == crcRx)
    {
        
        if (Rxdata[0] != 0)
        {
            
            switch (Rxdata[0])
            {
            case 0x03:
                fan_state = 0;
                heat_state = 0;
                break;
            case 0x06:
                fan_state = 3;
                heat_state = 0;
                
                break;
            case 0x05:
                fan_state = 2;
                heat_state = 0;
                break;
            case 0x04:
                fan_state = 1;
                heat_state = 0;
                break;
            case 0x30:
                fan_state = 0;
                heat_state = 0;
                break;
            case 0x60:
                fan_state = 0;
                heat_state = 3;
                break;
            case 0x50:
                fan_state = 0;
                heat_state = 2;
                break;
            case 0x40:
                fan_state = 0;
                heat_state = 1;
                break;
            default:
                break;
            }

            

            if (gIGN_State == 1 && battState == BattStatus_Normal)
            {
                //SendTFJRmsg(fan_state,heat_state);
                setFanDuty(fan_duty_arr[fan_state]);
                setHeatDuty(heat_duty_arr[heat_state]);
                
            }
           
            
        }
        if (Rxdata[1] != 0)
        {
            switch (Rxdata[1])
            {
            case 0x0A:
                am_state = 1;
                break;
            case 0x0B:
                am_state = 2;
                break;
                
            case 0x0C:
                am_state = 3;
                break;
                
            case 0x0D:
                am_state = 0;  
                break;
            
            default:
                break;
            }
            amCtrl_SetState(am_state);
        }
        
    }

    RxFlag = 0;
    RxTimeoutCount = 0;
    datacount = 0;
}