#include "r_cg_macrodriver.h"
#include "appTask.h"
#include "event.h"
#include "r_cg_port.h"
#include "r_cg_timer.h"
#include "r_cg_wdt.h"
#include "hwCtrl.h"

void KeyPressPro(uint8_t keyno);
void KeyReleasePro(uint8_t keyno);

static uint8_t autoflag = 0;
static uint8_t updown = 0,stopflag = 0;

static uint16_t keydelay[5]={0,0,0,0,0};
static uint8_t keyflag[5]={0,0,0,0,0};
static uint8_t shoudong = 0;

#define UPDOWN_UP   1
#define UPDOWN_DOWN 2
#define UPDOWN_NO   0


#define KEY_DELAY_TIME 6
#define KEY_DELAY_TIME_50ms 10
#define KEY_DELAY_TIME_8000ms 1600

uint8_t shortflag;

void HardWare_Init(void)
{
    //time base init
    R_TAU0_Channel0_Start();

    //output init 
    RLY1_Ctrl(OFF);
    RLY2_Ctrl(OFF);
    MOS_Ctrl(OFF);

    //adc init
    R_ADC_Start();
    R_ADC_Set_OperationOn();
    R_TAU0_Channel1_Start();//for adc scan
}

void Variable_Init(void)
{
    autoflag = 0;
    updown = 0;
    shortflag = 1;
}

void KeyPressPro(uint8_t keyno)
{
    if(autoflag != UPDOWN_NO)
    {
        autoflag = 0;
        shoudong = keyno+1;
        return;
    }

    if (keyno == KEY_UP || keyno == KEY_L_UP)
    {
        updown = UPDOWN_UP;
    }
    else if (keyno == KEY_DOWN || keyno == KEY_L_DOWN)
    {
        updown = UPDOWN_DOWN;
    }
    
    
}
void KeyReleasePro(uint8_t keyno)
{
    if (keyno+1 == shoudong)
    {
        shoudong = 0;
        return;
    }
    
    switch (keyno)
    {
    case KEY_UP:
        //NO
        break;
    case KEY_DOWN:
        if (keydelay[KEY_AUTO]>=KEY_DELAY_TIME_50ms &&  keydelay[KEY_AUTO] < KEY_DELAY_TIME_8000ms && shortflag == 0)
        {
            autoflag = UPDOWN_DOWN;
        }
        break;
    default:
        break;
    }
}


void keyScan(void)//5ms
{
    
    uint8_t i;
    for (i = 0; i < 4; i++)
    {
        if (GetKeyState(i) == KEY_PRESSED)
        {
            keydelay[i]++;
            if (keydelay[i] > KEY_DELAY_TIME)
            {
                keydelay[i] = KEY_DELAY_TIME;
                if (keyflag[i] == 0)
                {
                    keyflag[i] = 1;
                    KeyPressPro(i);
                }
                
            }
        }
        else
        {
            if (keydelay[i] > 0)
            {
                keydelay[i]--;
                if (keydelay[i] == 0 && keyflag[i] == 1)//减到0且按下过
                {
                    keyflag[i] = 0;
                    KeyReleasePro(i);
                }
            }
        }
    }
    if (keyflag[KEY_UP] == 0 && keyflag[KEY_DOWN] == 0 && keyflag[KEY_L_UP] == 0 && keyflag[KEY_L_DOWN] == 0)
    {
        updown = 0;
        stopflag = 0;
        shoudong = 0;
        shortflag = 0;
    }
    
    if (GetKeyState(KEY_AUTO) == KEY_PRESSED)
    {
        keydelay[KEY_AUTO]++;
        if (keydelay[KEY_AUTO] >= 2000)
        {
            keydelay[KEY_AUTO] = 2000;
        }
    }
    else
    {
        if (keyflag[KEY_UP]==0 && keyflag[KEY_DOWN]==0)
        {
            keydelay[KEY_AUTO] = 0;
        } 
    }

}

#define MOTOR_NONE  0
#define MOTOR_UP    1
#define MOTOR_DOWN  2
#define MOTOR_BREAK 3
void Motor_Ctrl(uint8_t state)
{
    switch (state)
    {
    case MOTOR_UP:
        RLY2_Ctrl(ON);
        RLY1_Ctrl(OFF);
        MOS_Ctrl(ON);
        break;
    case MOTOR_DOWN:
        RLY2_Ctrl(OFF);
        RLY1_Ctrl(ON);
        MOS_Ctrl(ON);
        break;
    case MOTOR_BREAK:
        RLY1_Ctrl(ON);
        RLY2_Ctrl(ON);
        MOS_Ctrl(ON);
        break;
    default:
        RLY1_Ctrl(OFF);
        RLY2_Ctrl(OFF);
        MOS_Ctrl(OFF);
        break;
    }
}

#define OC_9A       21
#define OC_13A      30
#define OC_6A       12
extern uint16_t g_adcval;
void Output_Ctrl(void)//10mS
{
    static uint16_t autotime=0;
    static uint8_t oc_delay = 0;
    
    if (g_adcval > OC_9A)
    {
        oc_delay++;
        if (oc_delay > 20)//200 ms
        {
            Motor_Ctrl(MOTOR_NONE);
            shortflag = 1;
        }
    }
    else
    {
        oc_delay = 0;
    }
    
    if (shortflag == 1)
    {
        autoflag = 0;
        Motor_Ctrl(MOTOR_NONE);
        return;
    }

    if (stopflag == 1)
    {
        Motor_Ctrl(MOTOR_NONE);
        return;
    }
    
    

    if (updown == UPDOWN_UP)
    {
        Motor_Ctrl(MOTOR_UP);
        autotime++;
    }
    else if (updown == UPDOWN_DOWN)
    {
        Motor_Ctrl(MOTOR_DOWN);
        autotime++;
    }
    else
    {
        if (autoflag == UPDOWN_DOWN)
        {
            Motor_Ctrl(MOTOR_DOWN);
            autotime++;
        }
        else
        {
            Motor_Ctrl(MOTOR_NONE);
            autotime = 0;
        }
    }

    if (autotime > 800)//8s
    {
        Motor_Ctrl(MOTOR_NONE);
        autotime = 0;
        autoflag = 0;
        stopflag = 1;
    }
    
}


void AppTask(void)
{
    static uint8_t ledno = 1,last = 0;
    if (TimeBase5msFlag == 1)
    {
        TimeBase5msFlag = 0;
        keyScan();
    }
    

    if (TimeBase10msFlag == 1)
    {
        TimeBase10msFlag = 0;
        Output_Ctrl();
    }
    
    if (TimeBase100msFlag == 1)
    {
        TimeBase100msFlag = 0;
        
        R_WDT_Restart();
    }
    
    if (TimeBase1000msFlag == 1)
    {
        TimeBase1000msFlag = 0;
	/*
        LED_Ctrl1LED(ledno,LED_ON);
        LED_Ctrl1LED(last,LED_OFF);
        last = ledno;
        ledno++;
        if (ledno > 9)
        {
            ledno = 1;
        }
        */
    }
    
}