/**********************************************************************************************************
建立头文件"transport.h"
**********************************************************************************************************/
#ifndef __TRANSPORT_H
#define __TRANSPORT_H

#include "stm8_macro.h"

/*********************************************************
 接收数据帧:
 1.结构  : 2字节帧头 + 1字节长度信息 + 数据 + 1字节校验码
 
 2.移植  : 1).IC层，数据的接收中断与发送函数。
           2).CRC_Calculation(u8* ),校验码计算
           
 3.OUTPUT: 1).调用DataFrame_Receive()将接收到的原始数据经过处理、CRC校验，
              将得到的有效数据帧存放于RcvFrameCache.Cache[]中，数据
              不包含帧头。
           2).接收数据超时:调用DataFrame_Receive()接收一帧数据的过程中，
              超过(TIME_OUT)次扫描未接收到数据则输出超时Cmd_TimeOut。
           3).调用getDataFrame(u8* buffer)从RcvFrameCache.Cache[]中获取数据帧
*********************************************************/

//////////////////////// 参数配置 ////////////////////////

// 长度信息计算方法:
// 0: 长度 = 长度信息本身字节数 + 数据 + 校验码
// 1: 长度 = 长度信息本身字节数 + 数据
// 2: 长度 = 数据 + 校验码
// 3: 长度 = 数据
#define LENGTH_METHOD              (0L)

#define FRAME_HEAD1                (0XFFul)//帧头1
#define FRAME_HEAD2                (0xF0ul)//帧头2

#define FRAME_LENGTH_MIN           (5ul)   //一帧数据的最小长度
#define FRAME_LENGTH_MAX           (20ul)  //一帧数据的最大长度

#define ROW_DATA_SIZE              (100ul) // 接收到的原始数据缓存大小
#define FRAME_CACHE_SIZE           (200ul) // 接收到的帧数据缓存大小

#define TIMEOUT_MECHANISMS_ENABLE  1       //超时处理机制  0:失能  1:使能

#if TIMEOUT_MECHANISMS_ENABLE != 0
	#define TIME_OUT               (500ul) //接收一帧数据超时的时间阈值，
								           //单位:调用Command_Receive()函数的周期
#endif

//////////////////////////////////////////////////////////

typedef enum {
  Cmd_NoCmd = 0, //未收到完整数据包
  Cmd_OK,        //接收成功
  Cmd_TimeOut,   //接收超时
  Cmd_LEN_Wrong, //接收到的数据包错误(长度不在范围内)
  Cmd_CRC_Wrong  //CRC校验错误
} _frameRes_;


void Uart_Init(u32 baudrate);
void UartSendData(u8 *ptr, u8 len);
u8   UartSendStr(u8 *str);

u8 CRC_Calculation(u8* pbuf);
_frameRes_ DataFrame_Receive(void);
_frameRes_ getDataFrame(u8 *buffer);
u8 framePakage(u8 *buffer, const u8 cmdDataLen, ...);

#endif /*__TRANSPORT_H*/


/**********************************************************************************************************
建立源文件"transport.c"
***********************************************************************************************************/

#include "transport.h"
#include "stdarg.h"
#include "stm8s.h"



//从接收到的数据帧中获取 总长度 = 长度 + 数据 + 校验码
//len : 长度信息
#if   LENGTH_METHOD == 0
	#define GET_TOTAL_LENGTH(len)  (len)
#elif LENGTH_METHOD == 1
	#define GET_TOTAL_LENGTH(len)  (len+1)
#elif LENGTH_METHOD == 2
	#define GET_TOTAL_LENGTH(len)  (len+1)
#elif LENGTH_METHOD == 3
	#define GET_TOTAL_LENGTH(len)  (len+2)
#else
	#error "wrong define LENGTH_METHOD !"
#endif


typedef enum{
  FINDING_HEAD1 = 0,
  FINDING_HEAD2,
  NEED_LENGTH,
  GETTING_DATA,
  GETTING_CHECKSUM
} RcvStatus_TypeDef;

volatile struct{
  u8 Reg[ROW_DATA_SIZE];     //串口接收到的原始数据缓存
  u8 countTail;              //串口接收计数
} RcvRawData;                //接收到的原始数据

struct {
  u8  Cache[FRAME_CACHE_SIZE]; //接收有效指令缓存器,不包含帧头
  u8  countTail;               //
} RcvFrameCache;               //接收到的帧数据

//#define DEBUG
#ifdef DEBUG
struct {
  u16 correctNum;
  u8  errNum;
  u8  errbuf[256];
} FrameNum;
#endif

static void RowDataInput(u8 byte);

////////////////////////////////////////////////////////////

//----------------------------------------------------------------

/******** IC层 ********/

/*
 @Function : UART初始化
             8bit数据位，1位停止位，无校验位，允许接收和发送
 @Input    : 波特率
 @Output   : None
 **/
 
void Uart_Init(u32 baudrate)
{
	UART2_Cmd(DISABLE);

	UART2_DeInit();  //恢复默认值
	
    UART2_Init(baudrate, 
               UART2_WORDLENGTH_8D,            // 8bit数据位
               UART2_STOPBITS_1,               // 1bit停止位
               UART2_PARITY_NO,                // 无校验位
               UART2_SYNCMODE_CLOCK_DISABLE,   // 禁用同步模式
               UART2_MODE_TXRX_ENABLE);        // 发送、接收使能

	UART2_ITConfig(UART2_IT_RXNE_OR, ENABLE);  // 开接收中断 
	
	UART2_Cmd(ENABLE);                         // 使能UART2
}

/*
 @Function : 发送数据
 @Input	    : ptr   数据首地址
             len   要发送的长度
 @Output   : None
 **/
void UartSendData(u8 *ptr, u8 len)
{
    while(len--)
    {
		while(UART2_GetFlagStatus(UART2_FLAG_TXE) == RESET);
		UART2_SendData8(*ptr++);
    }
}

/*
 @Function : 发送数据
 @Input	    : ptr   数据首地址
 @Output   : 发送的字节长度
 **/
u8 UartSendStr(u8 *str)
{
	u8 i;

	for(i=0; *str != 0x00; i++)
	{
		while(UART2_GetFlagStatus(UART2_FLAG_TXE) == RESET);
		UART2_SendData8(*str++);
	}
	return i;
}

/*
 @Function : UART2中断服务函数
 @Input	    : None
 @Output   : None
 **/
@far @interrupt void UART2_IRQHandler(void)
{
	u8 byte;
	
	if(UART2_GetFlagStatus(UART2_FLAG_RXNE) != RESET)
	{
		UART2_ClearFlag(UART2_FLAG_RXNE);
		
		byte = UART2_ReceiveData8();
		
		RowDataInput(byte);
	}
}

//----------------------------------------------------------------

/******** 传输层 ********/

/*
 @Function : CRC计算
 @Input	    : ptr  数据帧首地址,不包含帧头(首地址内容为长度)
 @Output   : CRC校验码
 **/
u8 CRC_Calculation(u8* pbuf)
{
	u8 len, check_code;
	
	len = pbuf[0];
	check_code = (u8)(len ^ pbuf[1] ^ pbuf[len-3] ^ pbuf[len-2]);
	
	return check_code;
}

/*
 @Function : 数据帧CRC校验
 @Input	    : ptr  数据帧首地址
 @Output   : 0  校验失败
             1  校验成功
 **/
static u8 CRC_Check(u8 *pbuf)
{
	u8 len, check_code;
	
	len = pbuf[0];
	check_code = CRC_Calculation(pbuf);

	if(check_code == pbuf[len-1])
	{
		return 1;
	}
	return 0;
}

/*
 @Function : 数据复制
 @Input	    : ptrdes
             ptrsrc
             len    复制的字节长度
 @Output   : 目的地址
 **/
static void* mymemcpy(void* pdes, void* psrc, unsigned int len)
{
	char* ptrdes = (char*)pdes; 
	char* ptrsrc = (char*)psrc;

	if(pdes == 0 || psrc == 0)
		return pdes;
	if(ptrdes>ptrsrc?(ptrdes-ptrsrc<len):(ptrsrc-ptrdes<len))//有重叠
	{
		return pdes;
	}
    while(len--)
    {
        *ptrdes++ = *ptrsrc++;
    }
	return pdes;
}

/*
 @Function : 封装成帧
 @Attention: STVD 环境下: va_list 在调用va_arg()后地址至少+2，
             故输入的可变形参必须为 2字节变量
 @Input	    : buffer     封装后的数据存入地址
             cmdDataLen 数据长度(不包含:包头，长度，校验码)
             ...        数据(必须为16位变量) (不包含:包头，长度，校验码)
 @Output   : 1 输入数据有误
			  0 成功
 **/
u8 framePakage(u8 *buffer, const u8 cmdDataLen, ...)
{
	unsigned char i;
	unsigned char frame[FRAME_LENGTH_MAX];
	va_list ap;
	
	va_start(ap, cmdDataLen);

	if(cmdDataLen < FRAME_LENGTH_MIN - 1)
	{
		return 1;//输入数据错误
	}
	frame[0] = FRAME_HEAD1;
	frame[1] = FRAME_HEAD2;

	//长度
#if   LENGTH_METHOD == 0
	frame[2] = (unsigned char)(cmdDataLen + 2);
#elif LENGTH_METHOD == 1 || LENGTH_METHOD == 2
	frame[2] = (unsigned char)(cmdDataLen + 1);
#elif LENGTH_METHOD == 3
	frame[2] = (unsigned char)cmdDataLen;
#endif
	//数据
	for(i=0; i<cmdDataLen; i++)
	{
		frame[i+3] = (unsigned char)va_arg(ap, unsigned int);
		i = i;
	}
	va_end(ap);
	
	frame[i+3] = CRC_Calculation(frame+2);
	mymemcpy(buffer, frame, FRAME_LENGTH_MAX);
	return 0;
}

/*
 @Function : 输入接收到的原始数据
 @Input    : byte   接收到的1字节原始数据
 @Output   : None
 **/
static void RowDataInput(u8 byte)
{
	if(++RcvRawData.countTail >= ROW_DATA_SIZE)
	{
		RcvRawData.countTail = 0;
	}
	RcvRawData.Reg[RcvRawData.countTail] = byte;
}

/*
 @Function : 接收数据帧(用于扫描接收数据)
             接收到的数据存储于RcvFrameCache.Cache中
 @Input    : None
 @Output   : 接收状态
 **/
_frameRes_ DataFrame_Receive(void)
{
	static u8 buffer[FRAME_LENGTH_MAX];
	static RcvStatus_TypeDef RcvStatus;
    static u8 rec_countHead;
    static u8 cmd_offset;
	static u8 total_len;
#ifdef TIMEOUT_MECHANISMS_ENABLE
    static u16 timeout;
#endif
    u8 byte;
	_frameRes_ res = Cmd_NoCmd;

    if(rec_countHead != RcvRawData.countTail)//有接收到数据
    {
		if(++rec_countHead >= ROW_DATA_SIZE)
		{
			rec_countHead = 0;
		}
		
        switch(RcvStatus)
        {
            case FINDING_HEAD1 :
				byte = RcvRawData.Reg[rec_countHead];
                if(byte == (u8)(FRAME_HEAD1))
                {
                    RcvStatus = FINDING_HEAD2;
					#ifdef TIMEOUT_MECHANISMS_ENABLE
					timeout = 0x8000;
					#endif
                }
                break;
            case FINDING_HEAD2 :
				byte = RcvRawData.Reg[rec_countHead];
                if(byte == (u8)(FRAME_HEAD2))
                {
                    RcvStatus = NEED_LENGTH;
                }
                else
                {
                    RcvStatus = FINDING_HEAD1;
                }
                break;
            case NEED_LENGTH :
				byte = RcvRawData.Reg[rec_countHead];
                if(byte<FRAME_LENGTH_MIN || byte>FRAME_LENGTH_MAX)
                {
                    RcvStatus = FINDING_HEAD1;
                    res = Cmd_CRC_Wrong;
                    break;
                }
                cmd_offset = 0;
				buffer[cmd_offset++] = byte;
                RcvStatus = GETTING_DATA;
                break;
            case GETTING_DATA :
				byte = RcvRawData.Reg[rec_countHead];
				buffer[cmd_offset++] = byte;
				total_len = GET_TOTAL_LENGTH(buffer[0]);
				if(cmd_offset == total_len - 1)
				{
					RcvStatus = GETTING_CHECKSUM;
				}
                break;
			case GETTING_CHECKSUM :
				byte = RcvRawData.Reg[rec_countHead];
				buffer[cmd_offset] = byte;
				RcvStatus = FINDING_HEAD1;
				timeout = 0;
				if(CRC_Check(buffer))//CRC校验
				{
					if(RcvFrameCache.countTail + total_len - 1 >= FRAME_CACHE_SIZE)
					{
						mymemcpy(&RcvFrameCache.Cache[RcvFrameCache.countTail], 
								  buffer, 
								  (int)(FRAME_CACHE_SIZE - RcvFrameCache.countTail));
						mymemcpy(&RcvFrameCache.Cache[0], 
								  buffer + (FRAME_CACHE_SIZE - RcvFrameCache.countTail), 
								  (int)(RcvFrameCache.countTail + total_len - FRAME_CACHE_SIZE));
						RcvFrameCache.countTail = (u8)(RcvFrameCache.countTail + total_len - FRAME_CACHE_SIZE);
					}
					else
					{
						mymemcpy(&RcvFrameCache.Cache[RcvFrameCache.countTail], 
								  buffer, 
								  total_len);
						RcvFrameCache.countTail += total_len;
					}
					res = Cmd_OK;
				}
				else
				{
					res = Cmd_CRC_Wrong;
				}
				break;
        }
    }
	#if TIMEOUT_MECHANISMS_ENABLE != 0
    else//没有接收到数据
    {
		//超时计时
		if(timeout & 0x8000)
		{
			if((++timeout & ~0x8000) >= TIME_OUT)
			{
				timeout = 0;
				RcvStatus = FINDING_HEAD1;
				res = Cmd_TimeOut;
			}
		}
    }
	#endif
	#ifdef DEBUG
	if(res == Cmd_OK)
		FrameNum.correctNum++;
	else if(res != Cmd_NoCmd)
	{
		static u8 Framecount = 0;
		FrameNum.errNum++;
		FrameNum.errbuf[Framecount++] = res;
	}
	#endif
    return res;
}

/*
 @Function : 获取数据帧(获取缓存中未处理的数据帧)
             接收到的数据存储于RcvFrameCache.Cache中,
 @Input    : buffer
 @Output   : 接收状态
 **/
_frameRes_ getDataFrame(u8 *buffer)
{
	#ifdef DEBUG
	u8 i;
	u8 framebuf[FRAME_LENGTH_MAX];
	#endif
	vu8 total_len;
	static u8  countHead;
	_frameRes_ fr = Cmd_NoCmd;;
    if(countHead != RcvFrameCache.countTail)
    {
		total_len = RcvFrameCache.Cache[countHead];
		total_len = GET_TOTAL_LENGTH(total_len);
		if(countHead + total_len - 1 >= FRAME_CACHE_SIZE)
		{
			mymemcpy(buffer, 
					 &RcvFrameCache.Cache[countHead], 
					 (int)(FRAME_CACHE_SIZE - countHead));
			mymemcpy(buffer + (FRAME_CACHE_SIZE - countHead), 
					 &RcvFrameCache.Cache[0], 
					 (int)(countHead + total_len - FRAME_CACHE_SIZE));
			countHead = (u8)(countHead + total_len - FRAME_CACHE_SIZE);
		}
		else
		{
			mymemcpy(buffer, 
					 &RcvFrameCache.Cache[countHead], 
					 total_len);
			countHead += total_len;
		}
		fr = Cmd_OK;
		
	#ifdef DEBUG
		for(i=0; i<FRAME_LENGTH_MAX; i++)
		{
			framebuf[i] = 0x00;
		}
		mymemcpy(framebuf, 
			     buffer, 
			     FRAME_LENGTH_MAX);
	#endif
    }
	return fr;
}