#include "hwCtrl.h"
#include "r_cg_port.h"
#include "iodefine.h"
#include "PINdef.h"
#include "r_cg_adc.h"




static uint8_t keystate[KEY_NUM] = {0};
static uint8_t keyPressFlag[KEY_NUM] = {0};
static uint8_t keyReleaseFlag[KEY_NUM] = {0};
static uint16_t keydelay[KEY_NUM] = {0};
extern uint16_t g_adval[AD_ST_NUM];

#define KEY_DELAY_TIMES 20 //20Ms
void ClearKeyState(void)
{
    uint8_t i;
    for (i = 0; i < KEY_NUM; i++)
    {
        keystate[i] = 0;
    }
}
void setKeyPressFlag(uint8_t id)
{
    if (id < KEY_NUM)
    {
        keyPressFlag[id] = KEY_PRESSED;
    }
}
void setKeyReleaseFlag(uint8_t id)
{
    
    if (id < KEY_NUM)
    {
        keyReleaseFlag[id] = KEY_PRESSED;
    }
}
uint8_t getKeyPressFlag(uint8_t id)
{
    uint8_t retVal = KEY_NOPRESSED;
    if (id < KEY_NUM)
    {
        retVal = keyPressFlag[id];
        keyPressFlag[id] = KEY_NOPRESSED;
    }
    return retVal;
}
uint8_t getKeyReleaseFlag(uint8_t id)
{
    uint8_t retVal = KEY_NOPRESSED;
    if (id < KEY_NUM)
    {
        retVal = keyReleaseFlag[id];
        keyReleaseFlag[id] = KEY_NOPRESSED;
    }
    return retVal;
}


extern unsigned char keybyte1,keybyte2;
void KeyScan(void)
{
    uint8_t i,key,key_nopress;
    key_nopress = 0;
    for (i = 0; i < KEY_NUM; i++)
    {
        key = GetSigState(i);
        if (key == KEY_PRESSED && keystate[i] == KEY_NOPRESSED)
        {
            keydelay[i]++;
            if (keydelay[i] >= KEY_DELAY_TIMES)
            {
                keystate[i] = KEY_PRESSED;
                setKeyPressFlag(i);
            }
        }
        else if(key == KEY_NOPRESSED)
        {
            if (keydelay[i] > 0)
            {
                keydelay[i]--;
            }
            else
            {
                if (keystate[i] == KEY_PRESSED)
                {
                    setKeyReleaseFlag(i);
                }
                keystate[i] = KEY_NOPRESSED;
                key_nopress++;
            }  
        }
    }
    
}


uint8_t GetSigState(uint8_t sigid)
{

    switch (sigid)
    {
    case KEYID_AM:
        return I_Key_AM==0?1:0;
    case KEYID_JS:
        return I_Key_JS==0?1:0;
    default:
        return 0;
    }
}

uint8_t GetKeyState(uint8_t keyno)
{
    if (keyno <= KEY_NUM)
    {
        return keystate[keyno];
    }
    return KEY_NOPRESSED;
}



uint16_t getAdval(uint8_t ch)
{
    if (ch < AD_ST_NUM)
    {
        return g_adval[ch];
    }
    
    return 0;
}

void setValveState(uint8_t valve_id,uint8_t state)
{
    switch (valve_id)
    {
    case VALVE1:
        O_T1 = state;
        break;
        
    case VALVE2:
        O_T2 = state;
        break;
        
    case VALVE3:
        O_T3 = state;
        break;
        
    case VALVE4:
        O_T4 = state;
        break;

    default:
        break;
    }
}

void setPumpState(uint8_t state)
{
    O_PUMP = state;
}


void ad_handle(void)
{
    switch (ADS)
    {
    case AD_SCAN_STEP1_CH:
        R_ADC_Get_Result(g_adval);
        ADS = AD_SCAN_STEP2_CH;
        break;
    case AD_SCAN_STEP2_CH:
        R_ADC_Get_Result(g_adval+1);
        ADS = AD_SCAN_STEP1_CH;
        break;
    default:
        ADS = AD_SCAN_STEP1_CH;
        break;
    }
}

void setFanDuty(uint8_t duty)
{
    uint32_t reg;
    if (duty > 100)
    {
        duty = 100;
    }
    if (duty < 0)
    {
        duty = 0;
    }

    reg = TDR06;
	reg = (reg + 1U) * duty / 100U;
	TDR07 = (unsigned short)reg;
}

void setHeatDuty(uint8_t duty)
{
    uint32_t reg;
    if (duty > 100)
    {
        duty = 100;
    }
    if (duty < 0)
    {
        duty = 0;
    }
    reg = TDR04;
    reg = (reg + 1U) * duty / 100U;
    TDR05 = (unsigned short)reg;
}

void setUnlockMotor(MOTORACT_type state)
{
    switch (state)
    {
    case 0:
        O_RLY1 = 0;
        O_RLY2 = 0;
        break;
    
    case 1:
        O_RLY1 = 1;
        O_RLY2 = 0;
        break;
        
    case 2:
        O_RLY1 = 0;
        O_RLY2 = 1;
        break;

    default:
        break;
    }
}