#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"
#include "r_cg_adc.h"
#include "r_cg_serial.h"

uint8_t g_rx_buf[3];

extern uint16_t g_AdVal[3];


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

    //LED初始化
    FanLED_Ctrl(0);
    HeatLED_Ctrl(0);
    //AnmoLED_Ctrl(0);

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

    //UART初始化
    R_UART0_Start();
    R_UART0_Receive(g_rx_buf,1);
}
uint8_t uart_sendend;
void Variable_Init(void)
{
    uart_sendend = 1;
}
static uint8_t heat_txstate=0,fan_txstate=0,motor_txstate=0,heat_state=0,fan_state=0,motor_state=0;
uint8_t g_tx_buf[7] = {0};

void UART_Tx_Pro(uint8_t keyid)
{
    uint8_t uart_buf[7] = {0x5a,0xa5,0x04,0x00,0x00,0x00,0x00};
    uint8_t i;

    switch (keyid)
    {
    case KEY_JR:
        uart_buf[3] = (0x03 + heat_txstate)<<4;
        break;
    case KEY_FAN:
        uart_buf[3] = 0x03 + fan_txstate;
        break;
    case KEY_AM:
        if (motor_txstate == 0)
        {
            uart_buf[4] = 0x0d;
        }
        else
        {
            uart_buf[4] = 0x09 + motor_txstate;
        }
        break;
    default:
        return;
    }
    //checksum
    uart_buf[6] = uart_buf[3] + uart_buf[5] + uart_buf[4];

    for ( i = 0; i < 7; i++)
    {
        g_tx_buf[i] = uart_buf[i];
    }
    if (uart_sendend == 1)
    {
        uart_sendend = 0;
        R_UART0_Send(g_tx_buf,7);
    }
}

uint8_t datacount=0;
uint8_t RxTimeoutCount=0;
static uint8_t Rxdata[10];
uint8_t RxFlag=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 MsgPro(uint8_t len)
{
    uint8_t i;
    //不用大屏协议
    uint8_t crc,crcRx;
    if (len <= 3)
    {
        return;
    }
    crc = 0;
    for(i=0;i<3;i++)
    {
        crc += Rxdata[i];
    }
    crcRx = Rxdata[3];
    
    if (crc == crcRx)
    {
        switch (Rxdata[0])
        {
        case 0x10:
            heat_state = 0;
            //fan_state = 0;
            break;
        case 0x20:
            heat_state = 3;
            fan_state = 0;
            break;
        case 0x70:
            heat_state = 2;
            fan_state = 0;
            break;
        case 0x80:
            heat_state = 1;
            fan_state = 0;
            break;
        case 0x01:
            fan_state = 0;
            //heat_state = 0;
            break;
        case 0x02:
            fan_state = 3;
            heat_state = 0;
            break;
        case 0x07:
            fan_state = 2;
            heat_state = 0;
            break;
        case 0x08:
            fan_state = 1;
            heat_state = 0;
            break;
        case 0x11:
            fan_state = 0;
            heat_state = 0;
        default:
            break;
        }
        switch (Rxdata[1])
        {
        case 0x1a:
            motor_state = 1;
            break;
        case 0x1b:
            motor_state = 2;
            break;
        case 0x1c:
            motor_state = 3;
            break;
        case 0x1d:
            motor_state = 0;
            break;
        default:
            break;
        }
    }
    
    RxFlag = 0;
    RxTimeoutCount = 0;
    datacount = 0;
}
void keyLogic(uint8_t keyno)
{
    
    switch (keyno)
    {
    case KEY_JR:
        heat_txstate = heat_state + 1;
        if (heat_txstate > 3)
        {
            heat_txstate = 0;
        }
        heat_state = heat_txstate;
        fan_state = 0;

        break;
    case KEY_FAN:
        fan_txstate = fan_state + 1;
        if (fan_txstate > 3)
        {
            fan_txstate = 0;
        }
        fan_state = fan_txstate;
        heat_state = 0;
        
        break;
    case KEY_AM:
        motor_txstate = motor_state + 1;
        if (motor_txstate > 3)
        {
            motor_txstate = 0;
        }
        motor_state = motor_txstate;
        
        break;
    default:
        break;
    }
    
    UART_Tx_Pro(keyno);
}

#define KEY_DELAY_TIME 6
void keyScan(void)//5ms
{
    static uint16_t keydelay[KEY_NUM]={0};
    static uint8_t keyflag[KEY_NUM]={0};
    static uint8_t keep_count[KEY_NUM]={0};
    uint8_t keyval,i;
    for (i = 0; i < KEY_NUM; i++)
    {
        keyval = GetKeyState(i);
        if (keyval == 1 && keyflag[i] == 0)
        {
            keydelay[i]++;
            if (keydelay[i] > KEY_DELAY_TIME)//30ms
            {   
                keyflag[i] = 1;
                keydelay[i] = KEY_DELAY_TIME;
                keyLogic(i);
                keep_count[i] = 0;
            }
            
        }
        else if (keyval == 0)
        {
            keyflag[i] = 0;
            keydelay[i] = 0;
        }
        
    }
    //持续发送
    
}

void LED_Ctrl(void)
{
    FanLED_Ctrl(fan_state);
    HeatLED_Ctrl(heat_state);
    AnmoLED_Ctrl(motor_state);
}

void AppTask(void)
{
    static uint8_t ledno = 1,last = 0;
    if (TimeBase5msFlag == 1)
    {
        TimeBase5msFlag = 0;
        keyScan();
        if (RxFlag)
        {
            RxTimeoutCount++;
            if (RxTimeoutCount > 6)
            {
                RxFlag = 0;
            }
            
        }
        else
        {
            RxTimeoutCount = 0;
        }
        
    }
    

    if (TimeBase10msFlag == 1)
    {
        TimeBase10msFlag = 0;
        LED_Ctrl();
    }
    
    if (TimeBase100msFlag == 1)
    {
        TimeBase100msFlag = 0;
        
        R_WDT_Restart();

    }
    
    if (TimeBase1000msFlag == 1)
    {
        TimeBase1000msFlag = 0;
        //UART_Tx_Pro(1);

    }
    
}

#define		POLYNOMINAL		0xA001
#define		PRESET_VALUE	0xFFFF

unsigned int crc16_make(unsigned char *Buffer, unsigned char size)
{
	unsigned int 	Cur_CRC_Value;
	unsigned char  	i,j;
		
	Cur_CRC_Value = PRESET_VALUE;
	
	for(i = 0x00; i < size; i++)
	{
		Cur_CRC_Value ^= *Buffer++;
		
		for(j = 0x00; j < 8; j++)
		{
			if(Cur_CRC_Value & 0x0001) 
			{
				Cur_CRC_Value = (Cur_CRC_Value >> 1) ^ POLYNOMINAL;
			}
			else
			{
				Cur_CRC_Value = (Cur_CRC_Value >> 1);
			}
		}
	}
	
	return Cur_CRC_Value;

}