#include "uart.h"
#include "xc_hal.h"
#include "check.h"


#define RAD_HEAD1		0xFA
#define RAD_HEAD2		0x3C
#define RAD_REAR1		0x3D
#define RAD_REAR2		0xFB

#define TEST_HEAD1		0x2B
#define TEST_HEAD2		0x2B
#define TEST_REAR1		0xE4
#define TEST_REAR2		0xC7

//数据协议类型
#define TYPE_RAD		1
#define TYPE_TEST		2

uint8_t port_txbuff[40] = {0}; 
uint8_t port_rxdata[32] = {0};

volatile uint8_t rxcnt = 0;
volatile uint8_t rxstat = 0;
volatile uint8_t rxtype = 0;
volatile uint8_t rxflag = 0;
volatile uint8_t rxwait = 0;
volatile uint8_t radar_wait = 0;

void uart_tick(void)
{
	if(rxwait > 0 && --rxwait == 0)
	{
		rxstat = 0;
	}
	if(radar_wait > 0)
	{
		radar_wait--;
	}
}

//端口接收中断
void uart_rxbyte(uint8_t byte)
{
	switch(rxstat)
	{
	case 0: //接收帧头1
		if(byte == RAD_HEAD1)
		{
			rxtype = TYPE_RAD;
			rxstat = 1;
		}
		else if(byte == TEST_HEAD1)
		{
			rxtype = TYPE_TEST;
			rxstat = 11;
		}
		break;
	case 1: //接收帧头2
		rxstat = (byte==RAD_HEAD2) ? 2 : 0;
		break;
	case 2:
		port_rxdata[0] = byte;
		rxstat = 3;
		break;
	case 3: 
		rxstat = (byte==0) ? 4 : 0;
		break;
	case 4:
		rxcnt = 0;
		port_rxdata[1] = byte;
		rxstat = (byte!=0)?5:6;
		break;
	case 5:
		port_rxdata[2+rxcnt] = byte;
		if(++rxcnt >= port_rxdata[1] || rxcnt >= 30)
		{
			rxstat = 6;
		}
		break;
	case 6:
		rxstat = 7;
		break;
	case 7:
		rxstat = (byte==RAD_REAR1) ? 8 : 0;
		break;
	case 8:
		if(byte == RAD_REAR2)
		{
			rxflag = 1;
		}
		rxstat = 0;
		break;
	case 11:
		rxstat = (byte==TEST_HEAD2) ? 12 : 0;
		break;
	case 12:
		port_rxdata[0] = byte;
		rxstat = 13;
		break;
	case 13:
		rxcnt = 0;
		port_rxdata[1] = byte;
		rxstat = (byte!=0)?14:15;
		break;
	case 14:
		port_rxdata[2+rxcnt] = byte;
		if(++rxcnt >= port_rxdata[1])
		{
			rxstat = 15;
		}
		break;
	case 15:
		rxstat = (byte==TEST_REAR1) ? 16 : 0;
		break;
	case 16:
		if(byte == TEST_REAR2)
		{
			rxflag = 1;
		}
		rxstat = 0;
		break;
	}
	rxwait = 10;
}

void uart_send(uint8_t *pdata, uint8_t type)
{
	uint8_t txcnt = 0;
	
	rxflag = 0;
	if(type == TYPE_RAD)
	{
		port_txbuff[txcnt++] = RAD_HEAD1;
		port_txbuff[txcnt++] = RAD_HEAD2;
		port_txbuff[txcnt++] = pdata[0];
		port_txbuff[txcnt++] = 0x00;
		port_txbuff[txcnt++] = pdata[1];
		for(uint8_t i = 0; i < pdata[1]; i++)
		{
			port_txbuff[txcnt++] = pdata[2+i];
		}
		port_txbuff[txcnt++] = CRC8_SAE(port_txbuff+2, pdata[1]+3);
		port_txbuff[txcnt++] = RAD_REAR1;
		port_txbuff[txcnt++] = RAD_REAR2;
	}
	else if(type == TYPE_TEST)
	{
		port_txbuff[txcnt++] = TEST_HEAD1;
		port_txbuff[txcnt++] = TEST_HEAD2;
		port_txbuff[txcnt++] = pdata[0];
		port_txbuff[txcnt++] = pdata[1];
		for(uint8_t i = 0; i < pdata[1]; i++)
		{
			port_txbuff[txcnt++] = pdata[2+i];
		}
		port_txbuff[txcnt++] = TEST_REAR1;
		port_txbuff[txcnt++] = TEST_REAR2;
	}
	hal_uart_send(port_txbuff, txcnt);
}

uint8_t radcmd_map[] = {0x11, 0x12, 0xB3, 0x14, 0x15, 0x16, 0x17};
uint8_t tstcmd_map[] = {0x01, 0x02, 0x03};

static uint8_t check_radcmd(uint8_t cmd)
{
	for(uint8_t i = 0; i < sizeof(radcmd_map); i++)
	{
		if(cmd == radcmd_map[i])
		{
			return 1;
		}
	}
	return 0;
}

static uint8_t check_tstcmd(uint8_t cmd)
{
	for(uint8_t i = 0; i < sizeof(tstcmd_map); i++)
	{
		if(cmd == tstcmd_map[i])
		{
			return 1;
		}
	}
	return 0;
}

void uart_recv(void (*func)(uint8_t *, uint8_t))
{
	if(rxflag != 0) 
	{
		rxflag = 0;
		if(rxtype == TYPE_RAD && check_radcmd(port_rxdata[0]))
		{
			(*func)(port_rxdata, rxtype);
			if(port_rxdata[0] != 0x12)
			{
				uart_send(port_rxdata, TYPE_RAD);
			}
		}
		if(rxtype == TYPE_TEST && check_tstcmd(port_rxdata[0]))
		{
			(*func)(port_rxdata, rxtype);
			uart_send(port_rxdata, TYPE_TEST);
		}
	}
}

uint8_t uart_trx(uint8_t *txdata, uint8_t *rxdata)
{
	uart_send(txdata, TYPE_RAD);

	rxflag = 0;
	rxtype = 0;
	radar_wait = 200;
	while(radar_wait != 0)
	{
		if((rxflag != 0) && (rxtype == TYPE_RAD))
		{
			rxflag = 0;
			for(int i = 0; i < port_rxdata[1]+2; i++)
			{
				rxdata[i] = port_rxdata[i];
			}
			return 1;
		}
	}
	//rxflag = 0;
	return 0;
}